Fix BFD leak in dwarf2_get_dwz_file.
[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           /* Make sure that the symtab is set on the new symbols.
16222              Even though they don't appear in this symtab directly,
16223              other parts of gdb assume that symbols do, and this is
16224              reasonably true.  */
16225           for (int i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (type); ++i)
16226             symbol_set_symtab (TYPE_TEMPLATE_ARGUMENT (type, i),
16227                                symbol_symtab (sym));
16228         }
16229     }
16230 }
16231
16232 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
16233    update TYPE using some information only available in DIE's children.  */
16234
16235 static void
16236 update_enumeration_type_from_children (struct die_info *die,
16237                                        struct type *type,
16238                                        struct dwarf2_cu *cu)
16239 {
16240   struct die_info *child_die;
16241   int unsigned_enum = 1;
16242   int flag_enum = 1;
16243   ULONGEST mask = 0;
16244
16245   auto_obstack obstack;
16246
16247   for (child_die = die->child;
16248        child_die != NULL && child_die->tag;
16249        child_die = sibling_die (child_die))
16250     {
16251       struct attribute *attr;
16252       LONGEST value;
16253       const gdb_byte *bytes;
16254       struct dwarf2_locexpr_baton *baton;
16255       const char *name;
16256
16257       if (child_die->tag != DW_TAG_enumerator)
16258         continue;
16259
16260       attr = dwarf2_attr (child_die, DW_AT_const_value, cu);
16261       if (attr == NULL)
16262         continue;
16263
16264       name = dwarf2_name (child_die, cu);
16265       if (name == NULL)
16266         name = "<anonymous enumerator>";
16267
16268       dwarf2_const_value_attr (attr, type, name, &obstack, cu,
16269                                &value, &bytes, &baton);
16270       if (value < 0)
16271         {
16272           unsigned_enum = 0;
16273           flag_enum = 0;
16274         }
16275       else if ((mask & value) != 0)
16276         flag_enum = 0;
16277       else
16278         mask |= value;
16279
16280       /* If we already know that the enum type is neither unsigned, nor
16281          a flag type, no need to look at the rest of the enumerates.  */
16282       if (!unsigned_enum && !flag_enum)
16283         break;
16284     }
16285
16286   if (unsigned_enum)
16287     TYPE_UNSIGNED (type) = 1;
16288   if (flag_enum)
16289     TYPE_FLAG_ENUM (type) = 1;
16290 }
16291
16292 /* Given a DW_AT_enumeration_type die, set its type.  We do not
16293    complete the type's fields yet, or create any symbols.  */
16294
16295 static struct type *
16296 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
16297 {
16298   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16299   struct type *type;
16300   struct attribute *attr;
16301   const char *name;
16302
16303   /* If the definition of this type lives in .debug_types, read that type.
16304      Don't follow DW_AT_specification though, that will take us back up
16305      the chain and we want to go down.  */
16306   attr = dwarf2_attr_no_follow (die, DW_AT_signature);
16307   if (attr)
16308     {
16309       type = get_DW_AT_signature_type (die, attr, cu);
16310
16311       /* The type's CU may not be the same as CU.
16312          Ensure TYPE is recorded with CU in die_type_hash.  */
16313       return set_die_type (die, type, cu);
16314     }
16315
16316   type = alloc_type (objfile);
16317
16318   TYPE_CODE (type) = TYPE_CODE_ENUM;
16319   name = dwarf2_full_name (NULL, die, cu);
16320   if (name != NULL)
16321     TYPE_NAME (type) = name;
16322
16323   attr = dwarf2_attr (die, DW_AT_type, cu);
16324   if (attr != NULL)
16325     {
16326       struct type *underlying_type = die_type (die, cu);
16327
16328       TYPE_TARGET_TYPE (type) = underlying_type;
16329     }
16330
16331   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16332   if (attr)
16333     {
16334       TYPE_LENGTH (type) = DW_UNSND (attr);
16335     }
16336   else
16337     {
16338       TYPE_LENGTH (type) = 0;
16339     }
16340
16341   maybe_set_alignment (cu, die, type);
16342
16343   /* The enumeration DIE can be incomplete.  In Ada, any type can be
16344      declared as private in the package spec, and then defined only
16345      inside the package body.  Such types are known as Taft Amendment
16346      Types.  When another package uses such a type, an incomplete DIE
16347      may be generated by the compiler.  */
16348   if (die_is_declaration (die, cu))
16349     TYPE_STUB (type) = 1;
16350
16351   /* Finish the creation of this type by using the enum's children.
16352      We must call this even when the underlying type has been provided
16353      so that we can determine if we're looking at a "flag" enum.  */
16354   update_enumeration_type_from_children (die, type, cu);
16355
16356   /* If this type has an underlying type that is not a stub, then we
16357      may use its attributes.  We always use the "unsigned" attribute
16358      in this situation, because ordinarily we guess whether the type
16359      is unsigned -- but the guess can be wrong and the underlying type
16360      can tell us the reality.  However, we defer to a local size
16361      attribute if one exists, because this lets the compiler override
16362      the underlying type if needed.  */
16363   if (TYPE_TARGET_TYPE (type) != NULL && !TYPE_STUB (TYPE_TARGET_TYPE (type)))
16364     {
16365       TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type));
16366       if (TYPE_LENGTH (type) == 0)
16367         TYPE_LENGTH (type) = TYPE_LENGTH (TYPE_TARGET_TYPE (type));
16368       if (TYPE_RAW_ALIGN (type) == 0
16369           && TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type)) != 0)
16370         set_type_align (type, TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type)));
16371     }
16372
16373   TYPE_DECLARED_CLASS (type) = dwarf2_flag_true_p (die, DW_AT_enum_class, cu);
16374
16375   return set_die_type (die, type, cu);
16376 }
16377
16378 /* Given a pointer to a die which begins an enumeration, process all
16379    the dies that define the members of the enumeration, and create the
16380    symbol for the enumeration type.
16381
16382    NOTE: We reverse the order of the element list.  */
16383
16384 static void
16385 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
16386 {
16387   struct type *this_type;
16388
16389   this_type = get_die_type (die, cu);
16390   if (this_type == NULL)
16391     this_type = read_enumeration_type (die, cu);
16392
16393   if (die->child != NULL)
16394     {
16395       struct die_info *child_die;
16396       struct symbol *sym;
16397       struct field *fields = NULL;
16398       int num_fields = 0;
16399       const char *name;
16400
16401       child_die = die->child;
16402       while (child_die && child_die->tag)
16403         {
16404           if (child_die->tag != DW_TAG_enumerator)
16405             {
16406               process_die (child_die, cu);
16407             }
16408           else
16409             {
16410               name = dwarf2_name (child_die, cu);
16411               if (name)
16412                 {
16413                   sym = new_symbol (child_die, this_type, cu);
16414
16415                   if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
16416                     {
16417                       fields = (struct field *)
16418                         xrealloc (fields,
16419                                   (num_fields + DW_FIELD_ALLOC_CHUNK)
16420                                   * sizeof (struct field));
16421                     }
16422
16423                   FIELD_NAME (fields[num_fields]) = SYMBOL_LINKAGE_NAME (sym);
16424                   FIELD_TYPE (fields[num_fields]) = NULL;
16425                   SET_FIELD_ENUMVAL (fields[num_fields], SYMBOL_VALUE (sym));
16426                   FIELD_BITSIZE (fields[num_fields]) = 0;
16427
16428                   num_fields++;
16429                 }
16430             }
16431
16432           child_die = sibling_die (child_die);
16433         }
16434
16435       if (num_fields)
16436         {
16437           TYPE_NFIELDS (this_type) = num_fields;
16438           TYPE_FIELDS (this_type) = (struct field *)
16439             TYPE_ALLOC (this_type, sizeof (struct field) * num_fields);
16440           memcpy (TYPE_FIELDS (this_type), fields,
16441                   sizeof (struct field) * num_fields);
16442           xfree (fields);
16443         }
16444     }
16445
16446   /* If we are reading an enum from a .debug_types unit, and the enum
16447      is a declaration, and the enum is not the signatured type in the
16448      unit, then we do not want to add a symbol for it.  Adding a
16449      symbol would in some cases obscure the true definition of the
16450      enum, giving users an incomplete type when the definition is
16451      actually available.  Note that we do not want to do this for all
16452      enums which are just declarations, because C++0x allows forward
16453      enum declarations.  */
16454   if (cu->per_cu->is_debug_types
16455       && die_is_declaration (die, cu))
16456     {
16457       struct signatured_type *sig_type;
16458
16459       sig_type = (struct signatured_type *) cu->per_cu;
16460       gdb_assert (to_underlying (sig_type->type_offset_in_section) != 0);
16461       if (sig_type->type_offset_in_section != die->sect_off)
16462         return;
16463     }
16464
16465   new_symbol (die, this_type, cu);
16466 }
16467
16468 /* Extract all information from a DW_TAG_array_type DIE and put it in
16469    the DIE's type field.  For now, this only handles one dimensional
16470    arrays.  */
16471
16472 static struct type *
16473 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
16474 {
16475   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16476   struct die_info *child_die;
16477   struct type *type;
16478   struct type *element_type, *range_type, *index_type;
16479   struct attribute *attr;
16480   const char *name;
16481   struct dynamic_prop *byte_stride_prop = NULL;
16482   unsigned int bit_stride = 0;
16483
16484   element_type = die_type (die, cu);
16485
16486   /* The die_type call above may have already set the type for this DIE.  */
16487   type = get_die_type (die, cu);
16488   if (type)
16489     return type;
16490
16491   attr = dwarf2_attr (die, DW_AT_byte_stride, cu);
16492   if (attr != NULL)
16493     {
16494       int stride_ok;
16495
16496       byte_stride_prop
16497         = (struct dynamic_prop *) alloca (sizeof (struct dynamic_prop));
16498       stride_ok = attr_to_dynamic_prop (attr, die, cu, byte_stride_prop);
16499       if (!stride_ok)
16500         {
16501           complaint (_("unable to read array DW_AT_byte_stride "
16502                        " - DIE at %s [in module %s]"),
16503                      sect_offset_str (die->sect_off),
16504                      objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
16505           /* Ignore this attribute.  We will likely not be able to print
16506              arrays of this type correctly, but there is little we can do
16507              to help if we cannot read the attribute's value.  */
16508           byte_stride_prop = NULL;
16509         }
16510     }
16511
16512   attr = dwarf2_attr (die, DW_AT_bit_stride, cu);
16513   if (attr != NULL)
16514     bit_stride = DW_UNSND (attr);
16515
16516   /* Irix 6.2 native cc creates array types without children for
16517      arrays with unspecified length.  */
16518   if (die->child == NULL)
16519     {
16520       index_type = objfile_type (objfile)->builtin_int;
16521       range_type = create_static_range_type (NULL, index_type, 0, -1);
16522       type = create_array_type_with_stride (NULL, element_type, range_type,
16523                                             byte_stride_prop, bit_stride);
16524       return set_die_type (die, type, cu);
16525     }
16526
16527   std::vector<struct type *> range_types;
16528   child_die = die->child;
16529   while (child_die && child_die->tag)
16530     {
16531       if (child_die->tag == DW_TAG_subrange_type)
16532         {
16533           struct type *child_type = read_type_die (child_die, cu);
16534
16535           if (child_type != NULL)
16536             {
16537               /* The range type was succesfully read.  Save it for the
16538                  array type creation.  */
16539               range_types.push_back (child_type);
16540             }
16541         }
16542       child_die = sibling_die (child_die);
16543     }
16544
16545   /* Dwarf2 dimensions are output from left to right, create the
16546      necessary array types in backwards order.  */
16547
16548   type = element_type;
16549
16550   if (read_array_order (die, cu) == DW_ORD_col_major)
16551     {
16552       int i = 0;
16553
16554       while (i < range_types.size ())
16555         type = create_array_type_with_stride (NULL, type, range_types[i++],
16556                                               byte_stride_prop, bit_stride);
16557     }
16558   else
16559     {
16560       size_t ndim = range_types.size ();
16561       while (ndim-- > 0)
16562         type = create_array_type_with_stride (NULL, type, range_types[ndim],
16563                                               byte_stride_prop, bit_stride);
16564     }
16565
16566   /* Understand Dwarf2 support for vector types (like they occur on
16567      the PowerPC w/ AltiVec).  Gcc just adds another attribute to the
16568      array type.  This is not part of the Dwarf2/3 standard yet, but a
16569      custom vendor extension.  The main difference between a regular
16570      array and the vector variant is that vectors are passed by value
16571      to functions.  */
16572   attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
16573   if (attr)
16574     make_vector_type (type);
16575
16576   /* The DIE may have DW_AT_byte_size set.  For example an OpenCL
16577      implementation may choose to implement triple vectors using this
16578      attribute.  */
16579   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16580   if (attr)
16581     {
16582       if (DW_UNSND (attr) >= TYPE_LENGTH (type))
16583         TYPE_LENGTH (type) = DW_UNSND (attr);
16584       else
16585         complaint (_("DW_AT_byte_size for array type smaller "
16586                      "than the total size of elements"));
16587     }
16588
16589   name = dwarf2_name (die, cu);
16590   if (name)
16591     TYPE_NAME (type) = name;
16592
16593   maybe_set_alignment (cu, die, type);
16594
16595   /* Install the type in the die.  */
16596   set_die_type (die, type, cu);
16597
16598   /* set_die_type should be already done.  */
16599   set_descriptive_type (type, die, cu);
16600
16601   return type;
16602 }
16603
16604 static enum dwarf_array_dim_ordering
16605 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
16606 {
16607   struct attribute *attr;
16608
16609   attr = dwarf2_attr (die, DW_AT_ordering, cu);
16610
16611   if (attr)
16612     return (enum dwarf_array_dim_ordering) DW_SND (attr);
16613
16614   /* GNU F77 is a special case, as at 08/2004 array type info is the
16615      opposite order to the dwarf2 specification, but data is still
16616      laid out as per normal fortran.
16617
16618      FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
16619      version checking.  */
16620
16621   if (cu->language == language_fortran
16622       && cu->producer && strstr (cu->producer, "GNU F77"))
16623     {
16624       return DW_ORD_row_major;
16625     }
16626
16627   switch (cu->language_defn->la_array_ordering)
16628     {
16629     case array_column_major:
16630       return DW_ORD_col_major;
16631     case array_row_major:
16632     default:
16633       return DW_ORD_row_major;
16634     };
16635 }
16636
16637 /* Extract all information from a DW_TAG_set_type DIE and put it in
16638    the DIE's type field.  */
16639
16640 static struct type *
16641 read_set_type (struct die_info *die, struct dwarf2_cu *cu)
16642 {
16643   struct type *domain_type, *set_type;
16644   struct attribute *attr;
16645
16646   domain_type = die_type (die, cu);
16647
16648   /* The die_type call above may have already set the type for this DIE.  */
16649   set_type = get_die_type (die, cu);
16650   if (set_type)
16651     return set_type;
16652
16653   set_type = create_set_type (NULL, domain_type);
16654
16655   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16656   if (attr)
16657     TYPE_LENGTH (set_type) = DW_UNSND (attr);
16658
16659   maybe_set_alignment (cu, die, set_type);
16660
16661   return set_die_type (die, set_type, cu);
16662 }
16663
16664 /* A helper for read_common_block that creates a locexpr baton.
16665    SYM is the symbol which we are marking as computed.
16666    COMMON_DIE is the DIE for the common block.
16667    COMMON_LOC is the location expression attribute for the common
16668    block itself.
16669    MEMBER_LOC is the location expression attribute for the particular
16670    member of the common block that we are processing.
16671    CU is the CU from which the above come.  */
16672
16673 static void
16674 mark_common_block_symbol_computed (struct symbol *sym,
16675                                    struct die_info *common_die,
16676                                    struct attribute *common_loc,
16677                                    struct attribute *member_loc,
16678                                    struct dwarf2_cu *cu)
16679 {
16680   struct dwarf2_per_objfile *dwarf2_per_objfile
16681     = cu->per_cu->dwarf2_per_objfile;
16682   struct objfile *objfile = dwarf2_per_objfile->objfile;
16683   struct dwarf2_locexpr_baton *baton;
16684   gdb_byte *ptr;
16685   unsigned int cu_off;
16686   enum bfd_endian byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
16687   LONGEST offset = 0;
16688
16689   gdb_assert (common_loc && member_loc);
16690   gdb_assert (attr_form_is_block (common_loc));
16691   gdb_assert (attr_form_is_block (member_loc)
16692               || attr_form_is_constant (member_loc));
16693
16694   baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
16695   baton->per_cu = cu->per_cu;
16696   gdb_assert (baton->per_cu);
16697
16698   baton->size = 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
16699
16700   if (attr_form_is_constant (member_loc))
16701     {
16702       offset = dwarf2_get_attr_constant_value (member_loc, 0);
16703       baton->size += 1 /* DW_OP_addr */ + cu->header.addr_size;
16704     }
16705   else
16706     baton->size += DW_BLOCK (member_loc)->size;
16707
16708   ptr = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, baton->size);
16709   baton->data = ptr;
16710
16711   *ptr++ = DW_OP_call4;
16712   cu_off = common_die->sect_off - cu->per_cu->sect_off;
16713   store_unsigned_integer (ptr, 4, byte_order, cu_off);
16714   ptr += 4;
16715
16716   if (attr_form_is_constant (member_loc))
16717     {
16718       *ptr++ = DW_OP_addr;
16719       store_unsigned_integer (ptr, cu->header.addr_size, byte_order, offset);
16720       ptr += cu->header.addr_size;
16721     }
16722   else
16723     {
16724       /* We have to copy the data here, because DW_OP_call4 will only
16725          use a DW_AT_location attribute.  */
16726       memcpy (ptr, DW_BLOCK (member_loc)->data, DW_BLOCK (member_loc)->size);
16727       ptr += DW_BLOCK (member_loc)->size;
16728     }
16729
16730   *ptr++ = DW_OP_plus;
16731   gdb_assert (ptr - baton->data == baton->size);
16732
16733   SYMBOL_LOCATION_BATON (sym) = baton;
16734   SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
16735 }
16736
16737 /* Create appropriate locally-scoped variables for all the
16738    DW_TAG_common_block entries.  Also create a struct common_block
16739    listing all such variables for `info common'.  COMMON_BLOCK_DOMAIN
16740    is used to sepate the common blocks name namespace from regular
16741    variable names.  */
16742
16743 static void
16744 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
16745 {
16746   struct attribute *attr;
16747
16748   attr = dwarf2_attr (die, DW_AT_location, cu);
16749   if (attr)
16750     {
16751       /* Support the .debug_loc offsets.  */
16752       if (attr_form_is_block (attr))
16753         {
16754           /* Ok.  */
16755         }
16756       else if (attr_form_is_section_offset (attr))
16757         {
16758           dwarf2_complex_location_expr_complaint ();
16759           attr = NULL;
16760         }
16761       else
16762         {
16763           dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
16764                                                  "common block member");
16765           attr = NULL;
16766         }
16767     }
16768
16769   if (die->child != NULL)
16770     {
16771       struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16772       struct die_info *child_die;
16773       size_t n_entries = 0, size;
16774       struct common_block *common_block;
16775       struct symbol *sym;
16776
16777       for (child_die = die->child;
16778            child_die && child_die->tag;
16779            child_die = sibling_die (child_die))
16780         ++n_entries;
16781
16782       size = (sizeof (struct common_block)
16783               + (n_entries - 1) * sizeof (struct symbol *));
16784       common_block
16785         = (struct common_block *) obstack_alloc (&objfile->objfile_obstack,
16786                                                  size);
16787       memset (common_block->contents, 0, n_entries * sizeof (struct symbol *));
16788       common_block->n_entries = 0;
16789
16790       for (child_die = die->child;
16791            child_die && child_die->tag;
16792            child_die = sibling_die (child_die))
16793         {
16794           /* Create the symbol in the DW_TAG_common_block block in the current
16795              symbol scope.  */
16796           sym = new_symbol (child_die, NULL, cu);
16797           if (sym != NULL)
16798             {
16799               struct attribute *member_loc;
16800
16801               common_block->contents[common_block->n_entries++] = sym;
16802
16803               member_loc = dwarf2_attr (child_die, DW_AT_data_member_location,
16804                                         cu);
16805               if (member_loc)
16806                 {
16807                   /* GDB has handled this for a long time, but it is
16808                      not specified by DWARF.  It seems to have been
16809                      emitted by gfortran at least as recently as:
16810                      http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057.  */
16811                   complaint (_("Variable in common block has "
16812                                "DW_AT_data_member_location "
16813                                "- DIE at %s [in module %s]"),
16814                                sect_offset_str (child_die->sect_off),
16815                              objfile_name (objfile));
16816
16817                   if (attr_form_is_section_offset (member_loc))
16818                     dwarf2_complex_location_expr_complaint ();
16819                   else if (attr_form_is_constant (member_loc)
16820                            || attr_form_is_block (member_loc))
16821                     {
16822                       if (attr)
16823                         mark_common_block_symbol_computed (sym, die, attr,
16824                                                            member_loc, cu);
16825                     }
16826                   else
16827                     dwarf2_complex_location_expr_complaint ();
16828                 }
16829             }
16830         }
16831
16832       sym = new_symbol (die, objfile_type (objfile)->builtin_void, cu);
16833       SYMBOL_VALUE_COMMON_BLOCK (sym) = common_block;
16834     }
16835 }
16836
16837 /* Create a type for a C++ namespace.  */
16838
16839 static struct type *
16840 read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
16841 {
16842   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16843   const char *previous_prefix, *name;
16844   int is_anonymous;
16845   struct type *type;
16846
16847   /* For extensions, reuse the type of the original namespace.  */
16848   if (dwarf2_attr (die, DW_AT_extension, cu) != NULL)
16849     {
16850       struct die_info *ext_die;
16851       struct dwarf2_cu *ext_cu = cu;
16852
16853       ext_die = dwarf2_extension (die, &ext_cu);
16854       type = read_type_die (ext_die, ext_cu);
16855
16856       /* EXT_CU may not be the same as CU.
16857          Ensure TYPE is recorded with CU in die_type_hash.  */
16858       return set_die_type (die, type, cu);
16859     }
16860
16861   name = namespace_name (die, &is_anonymous, cu);
16862
16863   /* Now build the name of the current namespace.  */
16864
16865   previous_prefix = determine_prefix (die, cu);
16866   if (previous_prefix[0] != '\0')
16867     name = typename_concat (&objfile->objfile_obstack,
16868                             previous_prefix, name, 0, cu);
16869
16870   /* Create the type.  */
16871   type = init_type (objfile, TYPE_CODE_NAMESPACE, 0, name);
16872
16873   return set_die_type (die, type, cu);
16874 }
16875
16876 /* Read a namespace scope.  */
16877
16878 static void
16879 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
16880 {
16881   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16882   int is_anonymous;
16883
16884   /* Add a symbol associated to this if we haven't seen the namespace
16885      before.  Also, add a using directive if it's an anonymous
16886      namespace.  */
16887
16888   if (dwarf2_attr (die, DW_AT_extension, cu) == NULL)
16889     {
16890       struct type *type;
16891
16892       type = read_type_die (die, cu);
16893       new_symbol (die, type, cu);
16894
16895       namespace_name (die, &is_anonymous, cu);
16896       if (is_anonymous)
16897         {
16898           const char *previous_prefix = determine_prefix (die, cu);
16899
16900           std::vector<const char *> excludes;
16901           add_using_directive (using_directives (cu),
16902                                previous_prefix, TYPE_NAME (type), NULL,
16903                                NULL, excludes, 0, &objfile->objfile_obstack);
16904         }
16905     }
16906
16907   if (die->child != NULL)
16908     {
16909       struct die_info *child_die = die->child;
16910
16911       while (child_die && child_die->tag)
16912         {
16913           process_die (child_die, cu);
16914           child_die = sibling_die (child_die);
16915         }
16916     }
16917 }
16918
16919 /* Read a Fortran module as type.  This DIE can be only a declaration used for
16920    imported module.  Still we need that type as local Fortran "use ... only"
16921    declaration imports depend on the created type in determine_prefix.  */
16922
16923 static struct type *
16924 read_module_type (struct die_info *die, struct dwarf2_cu *cu)
16925 {
16926   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16927   const char *module_name;
16928   struct type *type;
16929
16930   module_name = dwarf2_name (die, cu);
16931   if (!module_name)
16932     complaint (_("DW_TAG_module has no name, offset %s"),
16933                sect_offset_str (die->sect_off));
16934   type = init_type (objfile, TYPE_CODE_MODULE, 0, module_name);
16935
16936   return set_die_type (die, type, cu);
16937 }
16938
16939 /* Read a Fortran module.  */
16940
16941 static void
16942 read_module (struct die_info *die, struct dwarf2_cu *cu)
16943 {
16944   struct die_info *child_die = die->child;
16945   struct type *type;
16946
16947   type = read_type_die (die, cu);
16948   new_symbol (die, type, cu);
16949
16950   while (child_die && child_die->tag)
16951     {
16952       process_die (child_die, cu);
16953       child_die = sibling_die (child_die);
16954     }
16955 }
16956
16957 /* Return the name of the namespace represented by DIE.  Set
16958    *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
16959    namespace.  */
16960
16961 static const char *
16962 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
16963 {
16964   struct die_info *current_die;
16965   const char *name = NULL;
16966
16967   /* Loop through the extensions until we find a name.  */
16968
16969   for (current_die = die;
16970        current_die != NULL;
16971        current_die = dwarf2_extension (die, &cu))
16972     {
16973       /* We don't use dwarf2_name here so that we can detect the absence
16974          of a name -> anonymous namespace.  */
16975       name = dwarf2_string_attr (die, DW_AT_name, cu);
16976
16977       if (name != NULL)
16978         break;
16979     }
16980
16981   /* Is it an anonymous namespace?  */
16982
16983   *is_anonymous = (name == NULL);
16984   if (*is_anonymous)
16985     name = CP_ANONYMOUS_NAMESPACE_STR;
16986
16987   return name;
16988 }
16989
16990 /* Extract all information from a DW_TAG_pointer_type DIE and add to
16991    the user defined type vector.  */
16992
16993 static struct type *
16994 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
16995 {
16996   struct gdbarch *gdbarch
16997     = get_objfile_arch (cu->per_cu->dwarf2_per_objfile->objfile);
16998   struct comp_unit_head *cu_header = &cu->header;
16999   struct type *type;
17000   struct attribute *attr_byte_size;
17001   struct attribute *attr_address_class;
17002   int byte_size, addr_class;
17003   struct type *target_type;
17004
17005   target_type = die_type (die, cu);
17006
17007   /* The die_type call above may have already set the type for this DIE.  */
17008   type = get_die_type (die, cu);
17009   if (type)
17010     return type;
17011
17012   type = lookup_pointer_type (target_type);
17013
17014   attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
17015   if (attr_byte_size)
17016     byte_size = DW_UNSND (attr_byte_size);
17017   else
17018     byte_size = cu_header->addr_size;
17019
17020   attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
17021   if (attr_address_class)
17022     addr_class = DW_UNSND (attr_address_class);
17023   else
17024     addr_class = DW_ADDR_none;
17025
17026   ULONGEST alignment = get_alignment (cu, die);
17027
17028   /* If the pointer size, alignment, or address class is different
17029      than the default, create a type variant marked as such and set
17030      the length accordingly.  */
17031   if (TYPE_LENGTH (type) != byte_size
17032       || (alignment != 0 && TYPE_RAW_ALIGN (type) != 0
17033           && alignment != TYPE_RAW_ALIGN (type))
17034       || addr_class != DW_ADDR_none)
17035     {
17036       if (gdbarch_address_class_type_flags_p (gdbarch))
17037         {
17038           int type_flags;
17039
17040           type_flags = gdbarch_address_class_type_flags
17041                          (gdbarch, byte_size, addr_class);
17042           gdb_assert ((type_flags & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
17043                       == 0);
17044           type = make_type_with_address_space (type, type_flags);
17045         }
17046       else if (TYPE_LENGTH (type) != byte_size)
17047         {
17048           complaint (_("invalid pointer size %d"), byte_size);
17049         }
17050       else if (TYPE_RAW_ALIGN (type) != alignment)
17051         {
17052           complaint (_("Invalid DW_AT_alignment"
17053                        " - DIE at %s [in module %s]"),
17054                      sect_offset_str (die->sect_off),
17055                      objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17056         }
17057       else
17058         {
17059           /* Should we also complain about unhandled address classes?  */
17060         }
17061     }
17062
17063   TYPE_LENGTH (type) = byte_size;
17064   set_type_align (type, alignment);
17065   return set_die_type (die, type, cu);
17066 }
17067
17068 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
17069    the user defined type vector.  */
17070
17071 static struct type *
17072 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
17073 {
17074   struct type *type;
17075   struct type *to_type;
17076   struct type *domain;
17077
17078   to_type = die_type (die, cu);
17079   domain = die_containing_type (die, cu);
17080
17081   /* The calls above may have already set the type for this DIE.  */
17082   type = get_die_type (die, cu);
17083   if (type)
17084     return type;
17085
17086   if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_METHOD)
17087     type = lookup_methodptr_type (to_type);
17088   else if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_FUNC)
17089     {
17090       struct type *new_type
17091         = alloc_type (cu->per_cu->dwarf2_per_objfile->objfile);
17092
17093       smash_to_method_type (new_type, domain, TYPE_TARGET_TYPE (to_type),
17094                             TYPE_FIELDS (to_type), TYPE_NFIELDS (to_type),
17095                             TYPE_VARARGS (to_type));
17096       type = lookup_methodptr_type (new_type);
17097     }
17098   else
17099     type = lookup_memberptr_type (to_type, domain);
17100
17101   return set_die_type (die, type, cu);
17102 }
17103
17104 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
17105    the user defined type vector.  */
17106
17107 static struct type *
17108 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu,
17109                           enum type_code refcode)
17110 {
17111   struct comp_unit_head *cu_header = &cu->header;
17112   struct type *type, *target_type;
17113   struct attribute *attr;
17114
17115   gdb_assert (refcode == TYPE_CODE_REF || refcode == TYPE_CODE_RVALUE_REF);
17116
17117   target_type = die_type (die, cu);
17118
17119   /* The die_type call above may have already set the type for this DIE.  */
17120   type = get_die_type (die, cu);
17121   if (type)
17122     return type;
17123
17124   type = lookup_reference_type (target_type, refcode);
17125   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17126   if (attr)
17127     {
17128       TYPE_LENGTH (type) = DW_UNSND (attr);
17129     }
17130   else
17131     {
17132       TYPE_LENGTH (type) = cu_header->addr_size;
17133     }
17134   maybe_set_alignment (cu, die, type);
17135   return set_die_type (die, type, cu);
17136 }
17137
17138 /* Add the given cv-qualifiers to the element type of the array.  GCC
17139    outputs DWARF type qualifiers that apply to an array, not the
17140    element type.  But GDB relies on the array element type to carry
17141    the cv-qualifiers.  This mimics section 6.7.3 of the C99
17142    specification.  */
17143
17144 static struct type *
17145 add_array_cv_type (struct die_info *die, struct dwarf2_cu *cu,
17146                    struct type *base_type, int cnst, int voltl)
17147 {
17148   struct type *el_type, *inner_array;
17149
17150   base_type = copy_type (base_type);
17151   inner_array = base_type;
17152
17153   while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
17154     {
17155       TYPE_TARGET_TYPE (inner_array) =
17156         copy_type (TYPE_TARGET_TYPE (inner_array));
17157       inner_array = TYPE_TARGET_TYPE (inner_array);
17158     }
17159
17160   el_type = TYPE_TARGET_TYPE (inner_array);
17161   cnst |= TYPE_CONST (el_type);
17162   voltl |= TYPE_VOLATILE (el_type);
17163   TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, NULL);
17164
17165   return set_die_type (die, base_type, cu);
17166 }
17167
17168 static struct type *
17169 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
17170 {
17171   struct type *base_type, *cv_type;
17172
17173   base_type = die_type (die, cu);
17174
17175   /* The die_type call above may have already set the type for this DIE.  */
17176   cv_type = get_die_type (die, cu);
17177   if (cv_type)
17178     return cv_type;
17179
17180   /* In case the const qualifier is applied to an array type, the element type
17181      is so qualified, not the array type (section 6.7.3 of C99).  */
17182   if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
17183     return add_array_cv_type (die, cu, base_type, 1, 0);
17184
17185   cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
17186   return set_die_type (die, cv_type, cu);
17187 }
17188
17189 static struct type *
17190 read_tag_volatile_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 volatile qualifier is applied to an array type, the
17202      element type is so qualified, not the array type (section 6.7.3
17203      of C99).  */
17204   if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
17205     return add_array_cv_type (die, cu, base_type, 0, 1);
17206
17207   cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
17208   return set_die_type (die, cv_type, cu);
17209 }
17210
17211 /* Handle DW_TAG_restrict_type.  */
17212
17213 static struct type *
17214 read_tag_restrict_type (struct die_info *die, struct dwarf2_cu *cu)
17215 {
17216   struct type *base_type, *cv_type;
17217
17218   base_type = die_type (die, cu);
17219
17220   /* The die_type call above may have already set the type for this DIE.  */
17221   cv_type = get_die_type (die, cu);
17222   if (cv_type)
17223     return cv_type;
17224
17225   cv_type = make_restrict_type (base_type);
17226   return set_die_type (die, cv_type, cu);
17227 }
17228
17229 /* Handle DW_TAG_atomic_type.  */
17230
17231 static struct type *
17232 read_tag_atomic_type (struct die_info *die, struct dwarf2_cu *cu)
17233 {
17234   struct type *base_type, *cv_type;
17235
17236   base_type = die_type (die, cu);
17237
17238   /* The die_type call above may have already set the type for this DIE.  */
17239   cv_type = get_die_type (die, cu);
17240   if (cv_type)
17241     return cv_type;
17242
17243   cv_type = make_atomic_type (base_type);
17244   return set_die_type (die, cv_type, cu);
17245 }
17246
17247 /* Extract all information from a DW_TAG_string_type DIE and add to
17248    the user defined type vector.  It isn't really a user defined type,
17249    but it behaves like one, with other DIE's using an AT_user_def_type
17250    attribute to reference it.  */
17251
17252 static struct type *
17253 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
17254 {
17255   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17256   struct gdbarch *gdbarch = get_objfile_arch (objfile);
17257   struct type *type, *range_type, *index_type, *char_type;
17258   struct attribute *attr;
17259   unsigned int length;
17260
17261   attr = dwarf2_attr (die, DW_AT_string_length, cu);
17262   if (attr)
17263     {
17264       length = DW_UNSND (attr);
17265     }
17266   else
17267     {
17268       /* Check for the DW_AT_byte_size attribute.  */
17269       attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17270       if (attr)
17271         {
17272           length = DW_UNSND (attr);
17273         }
17274       else
17275         {
17276           length = 1;
17277         }
17278     }
17279
17280   index_type = objfile_type (objfile)->builtin_int;
17281   range_type = create_static_range_type (NULL, index_type, 1, length);
17282   char_type = language_string_char_type (cu->language_defn, gdbarch);
17283   type = create_string_type (NULL, char_type, range_type);
17284
17285   return set_die_type (die, type, cu);
17286 }
17287
17288 /* Assuming that DIE corresponds to a function, returns nonzero
17289    if the function is prototyped.  */
17290
17291 static int
17292 prototyped_function_p (struct die_info *die, struct dwarf2_cu *cu)
17293 {
17294   struct attribute *attr;
17295
17296   attr = dwarf2_attr (die, DW_AT_prototyped, cu);
17297   if (attr && (DW_UNSND (attr) != 0))
17298     return 1;
17299
17300   /* The DWARF standard implies that the DW_AT_prototyped attribute
17301      is only meaninful for C, but the concept also extends to other
17302      languages that allow unprototyped functions (Eg: Objective C).
17303      For all other languages, assume that functions are always
17304      prototyped.  */
17305   if (cu->language != language_c
17306       && cu->language != language_objc
17307       && cu->language != language_opencl)
17308     return 1;
17309
17310   /* RealView does not emit DW_AT_prototyped.  We can not distinguish
17311      prototyped and unprototyped functions; default to prototyped,
17312      since that is more common in modern code (and RealView warns
17313      about unprototyped functions).  */
17314   if (producer_is_realview (cu->producer))
17315     return 1;
17316
17317   return 0;
17318 }
17319
17320 /* Handle DIES due to C code like:
17321
17322    struct foo
17323    {
17324    int (*funcp)(int a, long l);
17325    int b;
17326    };
17327
17328    ('funcp' generates a DW_TAG_subroutine_type DIE).  */
17329
17330 static struct type *
17331 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
17332 {
17333   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17334   struct type *type;            /* Type that this function returns.  */
17335   struct type *ftype;           /* Function that returns above type.  */
17336   struct attribute *attr;
17337
17338   type = die_type (die, cu);
17339
17340   /* The die_type call above may have already set the type for this DIE.  */
17341   ftype = get_die_type (die, cu);
17342   if (ftype)
17343     return ftype;
17344
17345   ftype = lookup_function_type (type);
17346
17347   if (prototyped_function_p (die, cu))
17348     TYPE_PROTOTYPED (ftype) = 1;
17349
17350   /* Store the calling convention in the type if it's available in
17351      the subroutine die.  Otherwise set the calling convention to
17352      the default value DW_CC_normal.  */
17353   attr = dwarf2_attr (die, DW_AT_calling_convention, cu);
17354   if (attr)
17355     TYPE_CALLING_CONVENTION (ftype) = DW_UNSND (attr);
17356   else if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL"))
17357     TYPE_CALLING_CONVENTION (ftype) = DW_CC_GDB_IBM_OpenCL;
17358   else
17359     TYPE_CALLING_CONVENTION (ftype) = DW_CC_normal;
17360
17361   /* Record whether the function returns normally to its caller or not
17362      if the DWARF producer set that information.  */
17363   attr = dwarf2_attr (die, DW_AT_noreturn, cu);
17364   if (attr && (DW_UNSND (attr) != 0))
17365     TYPE_NO_RETURN (ftype) = 1;
17366
17367   /* We need to add the subroutine type to the die immediately so
17368      we don't infinitely recurse when dealing with parameters
17369      declared as the same subroutine type.  */
17370   set_die_type (die, ftype, cu);
17371
17372   if (die->child != NULL)
17373     {
17374       struct type *void_type = objfile_type (objfile)->builtin_void;
17375       struct die_info *child_die;
17376       int nparams, iparams;
17377
17378       /* Count the number of parameters.
17379          FIXME: GDB currently ignores vararg functions, but knows about
17380          vararg member functions.  */
17381       nparams = 0;
17382       child_die = die->child;
17383       while (child_die && child_die->tag)
17384         {
17385           if (child_die->tag == DW_TAG_formal_parameter)
17386             nparams++;
17387           else if (child_die->tag == DW_TAG_unspecified_parameters)
17388             TYPE_VARARGS (ftype) = 1;
17389           child_die = sibling_die (child_die);
17390         }
17391
17392       /* Allocate storage for parameters and fill them in.  */
17393       TYPE_NFIELDS (ftype) = nparams;
17394       TYPE_FIELDS (ftype) = (struct field *)
17395         TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
17396
17397       /* TYPE_FIELD_TYPE must never be NULL.  Pre-fill the array to ensure it
17398          even if we error out during the parameters reading below.  */
17399       for (iparams = 0; iparams < nparams; iparams++)
17400         TYPE_FIELD_TYPE (ftype, iparams) = void_type;
17401
17402       iparams = 0;
17403       child_die = die->child;
17404       while (child_die && child_die->tag)
17405         {
17406           if (child_die->tag == DW_TAG_formal_parameter)
17407             {
17408               struct type *arg_type;
17409
17410               /* DWARF version 2 has no clean way to discern C++
17411                  static and non-static member functions.  G++ helps
17412                  GDB by marking the first parameter for non-static
17413                  member functions (which is the this pointer) as
17414                  artificial.  We pass this information to
17415                  dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
17416
17417                  DWARF version 3 added DW_AT_object_pointer, which GCC
17418                  4.5 does not yet generate.  */
17419               attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
17420               if (attr)
17421                 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
17422               else
17423                 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
17424               arg_type = die_type (child_die, cu);
17425
17426               /* RealView does not mark THIS as const, which the testsuite
17427                  expects.  GCC marks THIS as const in method definitions,
17428                  but not in the class specifications (GCC PR 43053).  */
17429               if (cu->language == language_cplus && !TYPE_CONST (arg_type)
17430                   && TYPE_FIELD_ARTIFICIAL (ftype, iparams))
17431                 {
17432                   int is_this = 0;
17433                   struct dwarf2_cu *arg_cu = cu;
17434                   const char *name = dwarf2_name (child_die, cu);
17435
17436                   attr = dwarf2_attr (die, DW_AT_object_pointer, cu);
17437                   if (attr)
17438                     {
17439                       /* If the compiler emits this, use it.  */
17440                       if (follow_die_ref (die, attr, &arg_cu) == child_die)
17441                         is_this = 1;
17442                     }
17443                   else if (name && strcmp (name, "this") == 0)
17444                     /* Function definitions will have the argument names.  */
17445                     is_this = 1;
17446                   else if (name == NULL && iparams == 0)
17447                     /* Declarations may not have the names, so like
17448                        elsewhere in GDB, assume an artificial first
17449                        argument is "this".  */
17450                     is_this = 1;
17451
17452                   if (is_this)
17453                     arg_type = make_cv_type (1, TYPE_VOLATILE (arg_type),
17454                                              arg_type, 0);
17455                 }
17456
17457               TYPE_FIELD_TYPE (ftype, iparams) = arg_type;
17458               iparams++;
17459             }
17460           child_die = sibling_die (child_die);
17461         }
17462     }
17463
17464   return ftype;
17465 }
17466
17467 static struct type *
17468 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
17469 {
17470   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17471   const char *name = NULL;
17472   struct type *this_type, *target_type;
17473
17474   name = dwarf2_full_name (NULL, die, cu);
17475   this_type = init_type (objfile, TYPE_CODE_TYPEDEF, 0, name);
17476   TYPE_TARGET_STUB (this_type) = 1;
17477   set_die_type (die, this_type, cu);
17478   target_type = die_type (die, cu);
17479   if (target_type != this_type)
17480     TYPE_TARGET_TYPE (this_type) = target_type;
17481   else
17482     {
17483       /* Self-referential typedefs are, it seems, not allowed by the DWARF
17484          spec and cause infinite loops in GDB.  */
17485       complaint (_("Self-referential DW_TAG_typedef "
17486                    "- DIE at %s [in module %s]"),
17487                  sect_offset_str (die->sect_off), objfile_name (objfile));
17488       TYPE_TARGET_TYPE (this_type) = NULL;
17489     }
17490   return this_type;
17491 }
17492
17493 /* Allocate a floating-point type of size BITS and name NAME.  Pass NAME_HINT
17494    (which may be different from NAME) to the architecture back-end to allow
17495    it to guess the correct format if necessary.  */
17496
17497 static struct type *
17498 dwarf2_init_float_type (struct objfile *objfile, int bits, const char *name,
17499                         const char *name_hint)
17500 {
17501   struct gdbarch *gdbarch = get_objfile_arch (objfile);
17502   const struct floatformat **format;
17503   struct type *type;
17504
17505   format = gdbarch_floatformat_for_type (gdbarch, name_hint, bits);
17506   if (format)
17507     type = init_float_type (objfile, bits, name, format);
17508   else
17509     type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
17510
17511   return type;
17512 }
17513
17514 /* Allocate an integer type of size BITS and name NAME.  */
17515
17516 static struct type *
17517 dwarf2_init_integer_type (struct dwarf2_cu *cu, struct objfile *objfile,
17518                           int bits, int unsigned_p, const char *name)
17519 {
17520   struct type *type;
17521
17522   /* Versions of Intel's C Compiler generate an integer type called "void"
17523      instead of using DW_TAG_unspecified_type.  This has been seen on
17524      at least versions 14, 17, and 18.  */
17525   if (bits == 0 && producer_is_icc (cu) && name != nullptr
17526       && strcmp (name, "void") == 0)
17527     type = objfile_type (objfile)->builtin_void;
17528   else
17529     type = init_integer_type (objfile, bits, unsigned_p, name);
17530
17531   return type;
17532 }
17533
17534 /* Find a representation of a given base type and install
17535    it in the TYPE field of the die.  */
17536
17537 static struct type *
17538 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
17539 {
17540   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17541   struct type *type;
17542   struct attribute *attr;
17543   int encoding = 0, bits = 0;
17544   const char *name;
17545
17546   attr = dwarf2_attr (die, DW_AT_encoding, cu);
17547   if (attr)
17548     {
17549       encoding = DW_UNSND (attr);
17550     }
17551   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17552   if (attr)
17553     {
17554       bits = DW_UNSND (attr) * TARGET_CHAR_BIT;
17555     }
17556   name = dwarf2_name (die, cu);
17557   if (!name)
17558     {
17559       complaint (_("DW_AT_name missing from DW_TAG_base_type"));
17560     }
17561
17562   switch (encoding)
17563     {
17564       case DW_ATE_address:
17565         /* Turn DW_ATE_address into a void * pointer.  */
17566         type = init_type (objfile, TYPE_CODE_VOID, TARGET_CHAR_BIT, NULL);
17567         type = init_pointer_type (objfile, bits, name, type);
17568         break;
17569       case DW_ATE_boolean:
17570         type = init_boolean_type (objfile, bits, 1, name);
17571         break;
17572       case DW_ATE_complex_float:
17573         type = dwarf2_init_float_type (objfile, bits / 2, NULL, name);
17574         type = init_complex_type (objfile, name, type);
17575         break;
17576       case DW_ATE_decimal_float:
17577         type = init_decfloat_type (objfile, bits, name);
17578         break;
17579       case DW_ATE_float:
17580         type = dwarf2_init_float_type (objfile, bits, name, name);
17581         break;
17582       case DW_ATE_signed:
17583         type = dwarf2_init_integer_type (cu, objfile, bits, 0, name);
17584         break;
17585       case DW_ATE_unsigned:
17586         if (cu->language == language_fortran
17587             && name
17588             && startswith (name, "character("))
17589           type = init_character_type (objfile, bits, 1, name);
17590         else
17591           type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17592         break;
17593       case DW_ATE_signed_char:
17594         if (cu->language == language_ada || cu->language == language_m2
17595             || cu->language == language_pascal
17596             || cu->language == language_fortran)
17597           type = init_character_type (objfile, bits, 0, name);
17598         else
17599           type = dwarf2_init_integer_type (cu, objfile, bits, 0, name);
17600         break;
17601       case DW_ATE_unsigned_char:
17602         if (cu->language == language_ada || cu->language == language_m2
17603             || cu->language == language_pascal
17604             || cu->language == language_fortran
17605             || cu->language == language_rust)
17606           type = init_character_type (objfile, bits, 1, name);
17607         else
17608           type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17609         break;
17610       case DW_ATE_UTF:
17611         {
17612           gdbarch *arch = get_objfile_arch (objfile);
17613
17614           if (bits == 16)
17615             type = builtin_type (arch)->builtin_char16;
17616           else if (bits == 32)
17617             type = builtin_type (arch)->builtin_char32;
17618           else
17619             {
17620               complaint (_("unsupported DW_ATE_UTF bit size: '%d'"),
17621                          bits);
17622               type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17623             }
17624           return set_die_type (die, type, cu);
17625         }
17626         break;
17627
17628       default:
17629         complaint (_("unsupported DW_AT_encoding: '%s'"),
17630                    dwarf_type_encoding_name (encoding));
17631         type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
17632         break;
17633     }
17634
17635   if (name && strcmp (name, "char") == 0)
17636     TYPE_NOSIGN (type) = 1;
17637
17638   maybe_set_alignment (cu, die, type);
17639
17640   return set_die_type (die, type, cu);
17641 }
17642
17643 /* Parse dwarf attribute if it's a block, reference or constant and put the
17644    resulting value of the attribute into struct bound_prop.
17645    Returns 1 if ATTR could be resolved into PROP, 0 otherwise.  */
17646
17647 static int
17648 attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die,
17649                       struct dwarf2_cu *cu, struct dynamic_prop *prop)
17650 {
17651   struct dwarf2_property_baton *baton;
17652   struct obstack *obstack
17653     = &cu->per_cu->dwarf2_per_objfile->objfile->objfile_obstack;
17654
17655   if (attr == NULL || prop == NULL)
17656     return 0;
17657
17658   if (attr_form_is_block (attr))
17659     {
17660       baton = XOBNEW (obstack, struct dwarf2_property_baton);
17661       baton->referenced_type = NULL;
17662       baton->locexpr.per_cu = cu->per_cu;
17663       baton->locexpr.size = DW_BLOCK (attr)->size;
17664       baton->locexpr.data = DW_BLOCK (attr)->data;
17665       prop->data.baton = baton;
17666       prop->kind = PROP_LOCEXPR;
17667       gdb_assert (prop->data.baton != NULL);
17668     }
17669   else if (attr_form_is_ref (attr))
17670     {
17671       struct dwarf2_cu *target_cu = cu;
17672       struct die_info *target_die;
17673       struct attribute *target_attr;
17674
17675       target_die = follow_die_ref (die, attr, &target_cu);
17676       target_attr = dwarf2_attr (target_die, DW_AT_location, target_cu);
17677       if (target_attr == NULL)
17678         target_attr = dwarf2_attr (target_die, DW_AT_data_member_location,
17679                                    target_cu);
17680       if (target_attr == NULL)
17681         return 0;
17682
17683       switch (target_attr->name)
17684         {
17685           case DW_AT_location:
17686             if (attr_form_is_section_offset (target_attr))
17687               {
17688                 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17689                 baton->referenced_type = die_type (target_die, target_cu);
17690                 fill_in_loclist_baton (cu, &baton->loclist, target_attr);
17691                 prop->data.baton = baton;
17692                 prop->kind = PROP_LOCLIST;
17693                 gdb_assert (prop->data.baton != NULL);
17694               }
17695             else if (attr_form_is_block (target_attr))
17696               {
17697                 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17698                 baton->referenced_type = die_type (target_die, target_cu);
17699                 baton->locexpr.per_cu = cu->per_cu;
17700                 baton->locexpr.size = DW_BLOCK (target_attr)->size;
17701                 baton->locexpr.data = DW_BLOCK (target_attr)->data;
17702                 prop->data.baton = baton;
17703                 prop->kind = PROP_LOCEXPR;
17704                 gdb_assert (prop->data.baton != NULL);
17705               }
17706             else
17707               {
17708                 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
17709                                                        "dynamic property");
17710                 return 0;
17711               }
17712             break;
17713           case DW_AT_data_member_location:
17714             {
17715               LONGEST offset;
17716
17717               if (!handle_data_member_location (target_die, target_cu,
17718                                                 &offset))
17719                 return 0;
17720
17721               baton = XOBNEW (obstack, struct dwarf2_property_baton);
17722               baton->referenced_type = read_type_die (target_die->parent,
17723                                                       target_cu);
17724               baton->offset_info.offset = offset;
17725               baton->offset_info.type = die_type (target_die, target_cu);
17726               prop->data.baton = baton;
17727               prop->kind = PROP_ADDR_OFFSET;
17728               break;
17729             }
17730         }
17731     }
17732   else if (attr_form_is_constant (attr))
17733     {
17734       prop->data.const_val = dwarf2_get_attr_constant_value (attr, 0);
17735       prop->kind = PROP_CONST;
17736     }
17737   else
17738     {
17739       dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr->form),
17740                                              dwarf2_name (die, cu));
17741       return 0;
17742     }
17743
17744   return 1;
17745 }
17746
17747 /* Read the given DW_AT_subrange DIE.  */
17748
17749 static struct type *
17750 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
17751 {
17752   struct type *base_type, *orig_base_type;
17753   struct type *range_type;
17754   struct attribute *attr;
17755   struct dynamic_prop low, high;
17756   int low_default_is_valid;
17757   int high_bound_is_count = 0;
17758   const char *name;
17759   ULONGEST negative_mask;
17760
17761   orig_base_type = die_type (die, cu);
17762   /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
17763      whereas the real type might be.  So, we use ORIG_BASE_TYPE when
17764      creating the range type, but we use the result of check_typedef
17765      when examining properties of the type.  */
17766   base_type = check_typedef (orig_base_type);
17767
17768   /* The die_type call above may have already set the type for this DIE.  */
17769   range_type = get_die_type (die, cu);
17770   if (range_type)
17771     return range_type;
17772
17773   low.kind = PROP_CONST;
17774   high.kind = PROP_CONST;
17775   high.data.const_val = 0;
17776
17777   /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
17778      omitting DW_AT_lower_bound.  */
17779   switch (cu->language)
17780     {
17781     case language_c:
17782     case language_cplus:
17783       low.data.const_val = 0;
17784       low_default_is_valid = 1;
17785       break;
17786     case language_fortran:
17787       low.data.const_val = 1;
17788       low_default_is_valid = 1;
17789       break;
17790     case language_d:
17791     case language_objc:
17792     case language_rust:
17793       low.data.const_val = 0;
17794       low_default_is_valid = (cu->header.version >= 4);
17795       break;
17796     case language_ada:
17797     case language_m2:
17798     case language_pascal:
17799       low.data.const_val = 1;
17800       low_default_is_valid = (cu->header.version >= 4);
17801       break;
17802     default:
17803       low.data.const_val = 0;
17804       low_default_is_valid = 0;
17805       break;
17806     }
17807
17808   attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
17809   if (attr)
17810     attr_to_dynamic_prop (attr, die, cu, &low);
17811   else if (!low_default_is_valid)
17812     complaint (_("Missing DW_AT_lower_bound "
17813                                       "- DIE at %s [in module %s]"),
17814                sect_offset_str (die->sect_off),
17815                objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17816
17817   struct attribute *attr_ub, *attr_count;
17818   attr = attr_ub = dwarf2_attr (die, DW_AT_upper_bound, cu);
17819   if (!attr_to_dynamic_prop (attr, die, cu, &high))
17820     {
17821       attr = attr_count = dwarf2_attr (die, DW_AT_count, cu);
17822       if (attr_to_dynamic_prop (attr, die, cu, &high))
17823         {
17824           /* If bounds are constant do the final calculation here.  */
17825           if (low.kind == PROP_CONST && high.kind == PROP_CONST)
17826             high.data.const_val = low.data.const_val + high.data.const_val - 1;
17827           else
17828             high_bound_is_count = 1;
17829         }
17830       else
17831         {
17832           if (attr_ub != NULL)
17833             complaint (_("Unresolved DW_AT_upper_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           if (attr_count != NULL)
17838             complaint (_("Unresolved DW_AT_count "
17839                          "- DIE at %s [in module %s]"),
17840                        sect_offset_str (die->sect_off),
17841                        objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17842         }
17843         
17844     }
17845
17846   /* Dwarf-2 specifications explicitly allows to create subrange types
17847      without specifying a base type.
17848      In that case, the base type must be set to the type of
17849      the lower bound, upper bound or count, in that order, if any of these
17850      three attributes references an object that has a type.
17851      If no base type is found, the Dwarf-2 specifications say that
17852      a signed integer type of size equal to the size of an address should
17853      be used.
17854      For the following C code: `extern char gdb_int [];'
17855      GCC produces an empty range DIE.
17856      FIXME: muller/2010-05-28: Possible references to object for low bound,
17857      high bound or count are not yet handled by this code.  */
17858   if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
17859     {
17860       struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17861       struct gdbarch *gdbarch = get_objfile_arch (objfile);
17862       int addr_size = gdbarch_addr_bit (gdbarch) /8;
17863       struct type *int_type = objfile_type (objfile)->builtin_int;
17864
17865       /* Test "int", "long int", and "long long int" objfile types,
17866          and select the first one having a size above or equal to the
17867          architecture address size.  */
17868       if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17869         base_type = int_type;
17870       else
17871         {
17872           int_type = objfile_type (objfile)->builtin_long;
17873           if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17874             base_type = int_type;
17875           else
17876             {
17877               int_type = objfile_type (objfile)->builtin_long_long;
17878               if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17879                 base_type = int_type;
17880             }
17881         }
17882     }
17883
17884   /* Normally, the DWARF producers are expected to use a signed
17885      constant form (Eg. DW_FORM_sdata) to express negative bounds.
17886      But this is unfortunately not always the case, as witnessed
17887      with GCC, for instance, where the ambiguous DW_FORM_dataN form
17888      is used instead.  To work around that ambiguity, we treat
17889      the bounds as signed, and thus sign-extend their values, when
17890      the base type is signed.  */
17891   negative_mask =
17892     -((ULONGEST) 1 << (TYPE_LENGTH (base_type) * TARGET_CHAR_BIT - 1));
17893   if (low.kind == PROP_CONST
17894       && !TYPE_UNSIGNED (base_type) && (low.data.const_val & negative_mask))
17895     low.data.const_val |= negative_mask;
17896   if (high.kind == PROP_CONST
17897       && !TYPE_UNSIGNED (base_type) && (high.data.const_val & negative_mask))
17898     high.data.const_val |= negative_mask;
17899
17900   range_type = create_range_type (NULL, orig_base_type, &low, &high);
17901
17902   if (high_bound_is_count)
17903     TYPE_RANGE_DATA (range_type)->flag_upper_bound_is_count = 1;
17904
17905   /* Ada expects an empty array on no boundary attributes.  */
17906   if (attr == NULL && cu->language != language_ada)
17907     TYPE_HIGH_BOUND_KIND (range_type) = PROP_UNDEFINED;
17908
17909   name = dwarf2_name (die, cu);
17910   if (name)
17911     TYPE_NAME (range_type) = name;
17912
17913   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17914   if (attr)
17915     TYPE_LENGTH (range_type) = DW_UNSND (attr);
17916
17917   maybe_set_alignment (cu, die, range_type);
17918
17919   set_die_type (die, range_type, cu);
17920
17921   /* set_die_type should be already done.  */
17922   set_descriptive_type (range_type, die, cu);
17923
17924   return range_type;
17925 }
17926
17927 static struct type *
17928 read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
17929 {
17930   struct type *type;
17931
17932   type = init_type (cu->per_cu->dwarf2_per_objfile->objfile, TYPE_CODE_VOID,0,
17933                     NULL);
17934   TYPE_NAME (type) = dwarf2_name (die, cu);
17935
17936   /* In Ada, an unspecified type is typically used when the description
17937      of the type is defered to a different unit.  When encountering
17938      such a type, we treat it as a stub, and try to resolve it later on,
17939      when needed.  */
17940   if (cu->language == language_ada)
17941     TYPE_STUB (type) = 1;
17942
17943   return set_die_type (die, type, cu);
17944 }
17945
17946 /* Read a single die and all its descendents.  Set the die's sibling
17947    field to NULL; set other fields in the die correctly, and set all
17948    of the descendents' fields correctly.  Set *NEW_INFO_PTR to the
17949    location of the info_ptr after reading all of those dies.  PARENT
17950    is the parent of the die in question.  */
17951
17952 static struct die_info *
17953 read_die_and_children (const struct die_reader_specs *reader,
17954                        const gdb_byte *info_ptr,
17955                        const gdb_byte **new_info_ptr,
17956                        struct die_info *parent)
17957 {
17958   struct die_info *die;
17959   const gdb_byte *cur_ptr;
17960   int has_children;
17961
17962   cur_ptr = read_full_die_1 (reader, &die, info_ptr, &has_children, 0);
17963   if (die == NULL)
17964     {
17965       *new_info_ptr = cur_ptr;
17966       return NULL;
17967     }
17968   store_in_ref_table (die, reader->cu);
17969
17970   if (has_children)
17971     die->child = read_die_and_siblings_1 (reader, cur_ptr, new_info_ptr, die);
17972   else
17973     {
17974       die->child = NULL;
17975       *new_info_ptr = cur_ptr;
17976     }
17977
17978   die->sibling = NULL;
17979   die->parent = parent;
17980   return die;
17981 }
17982
17983 /* Read a die, all of its descendents, and all of its siblings; set
17984    all of the fields of all of the dies correctly.  Arguments are as
17985    in read_die_and_children.  */
17986
17987 static struct die_info *
17988 read_die_and_siblings_1 (const struct die_reader_specs *reader,
17989                          const gdb_byte *info_ptr,
17990                          const gdb_byte **new_info_ptr,
17991                          struct die_info *parent)
17992 {
17993   struct die_info *first_die, *last_sibling;
17994   const gdb_byte *cur_ptr;
17995
17996   cur_ptr = info_ptr;
17997   first_die = last_sibling = NULL;
17998
17999   while (1)
18000     {
18001       struct die_info *die
18002         = read_die_and_children (reader, cur_ptr, &cur_ptr, parent);
18003
18004       if (die == NULL)
18005         {
18006           *new_info_ptr = cur_ptr;
18007           return first_die;
18008         }
18009
18010       if (!first_die)
18011         first_die = die;
18012       else
18013         last_sibling->sibling = die;
18014
18015       last_sibling = die;
18016     }
18017 }
18018
18019 /* Read a die, all of its descendents, and all of its siblings; set
18020    all of the fields of all of the dies correctly.  Arguments are as
18021    in read_die_and_children.
18022    This the main entry point for reading a DIE and all its children.  */
18023
18024 static struct die_info *
18025 read_die_and_siblings (const struct die_reader_specs *reader,
18026                        const gdb_byte *info_ptr,
18027                        const gdb_byte **new_info_ptr,
18028                        struct die_info *parent)
18029 {
18030   struct die_info *die = read_die_and_siblings_1 (reader, info_ptr,
18031                                                   new_info_ptr, parent);
18032
18033   if (dwarf_die_debug)
18034     {
18035       fprintf_unfiltered (gdb_stdlog,
18036                           "Read die from %s@0x%x of %s:\n",
18037                           get_section_name (reader->die_section),
18038                           (unsigned) (info_ptr - reader->die_section->buffer),
18039                           bfd_get_filename (reader->abfd));
18040       dump_die (die, dwarf_die_debug);
18041     }
18042
18043   return die;
18044 }
18045
18046 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
18047    attributes.
18048    The caller is responsible for filling in the extra attributes
18049    and updating (*DIEP)->num_attrs.
18050    Set DIEP to point to a newly allocated die with its information,
18051    except for its child, sibling, and parent fields.
18052    Set HAS_CHILDREN to tell whether the die has children or not.  */
18053
18054 static const gdb_byte *
18055 read_full_die_1 (const struct die_reader_specs *reader,
18056                  struct die_info **diep, const gdb_byte *info_ptr,
18057                  int *has_children, int num_extra_attrs)
18058 {
18059   unsigned int abbrev_number, bytes_read, i;
18060   struct abbrev_info *abbrev;
18061   struct die_info *die;
18062   struct dwarf2_cu *cu = reader->cu;
18063   bfd *abfd = reader->abfd;
18064
18065   sect_offset sect_off = (sect_offset) (info_ptr - reader->buffer);
18066   abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
18067   info_ptr += bytes_read;
18068   if (!abbrev_number)
18069     {
18070       *diep = NULL;
18071       *has_children = 0;
18072       return info_ptr;
18073     }
18074
18075   abbrev = reader->abbrev_table->lookup_abbrev (abbrev_number);
18076   if (!abbrev)
18077     error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
18078            abbrev_number,
18079            bfd_get_filename (abfd));
18080
18081   die = dwarf_alloc_die (cu, abbrev->num_attrs + num_extra_attrs);
18082   die->sect_off = sect_off;
18083   die->tag = abbrev->tag;
18084   die->abbrev = abbrev_number;
18085
18086   /* Make the result usable.
18087      The caller needs to update num_attrs after adding the extra
18088      attributes.  */
18089   die->num_attrs = abbrev->num_attrs;
18090
18091   for (i = 0; i < abbrev->num_attrs; ++i)
18092     info_ptr = read_attribute (reader, &die->attrs[i], &abbrev->attrs[i],
18093                                info_ptr);
18094
18095   *diep = die;
18096   *has_children = abbrev->has_children;
18097   return info_ptr;
18098 }
18099
18100 /* Read a die and all its attributes.
18101    Set DIEP to point to a newly allocated die with its information,
18102    except for its child, sibling, and parent fields.
18103    Set HAS_CHILDREN to tell whether the die has children or not.  */
18104
18105 static const gdb_byte *
18106 read_full_die (const struct die_reader_specs *reader,
18107                struct die_info **diep, const gdb_byte *info_ptr,
18108                int *has_children)
18109 {
18110   const gdb_byte *result;
18111
18112   result = read_full_die_1 (reader, diep, info_ptr, has_children, 0);
18113
18114   if (dwarf_die_debug)
18115     {
18116       fprintf_unfiltered (gdb_stdlog,
18117                           "Read die from %s@0x%x of %s:\n",
18118                           get_section_name (reader->die_section),
18119                           (unsigned) (info_ptr - reader->die_section->buffer),
18120                           bfd_get_filename (reader->abfd));
18121       dump_die (*diep, dwarf_die_debug);
18122     }
18123
18124   return result;
18125 }
18126 \f
18127 /* Abbreviation tables.
18128
18129    In DWARF version 2, the description of the debugging information is
18130    stored in a separate .debug_abbrev section.  Before we read any
18131    dies from a section we read in all abbreviations and install them
18132    in a hash table.  */
18133
18134 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE.  */
18135
18136 struct abbrev_info *
18137 abbrev_table::alloc_abbrev ()
18138 {
18139   struct abbrev_info *abbrev;
18140
18141   abbrev = XOBNEW (&abbrev_obstack, struct abbrev_info);
18142   memset (abbrev, 0, sizeof (struct abbrev_info));
18143
18144   return abbrev;
18145 }
18146
18147 /* Add an abbreviation to the table.  */
18148
18149 void
18150 abbrev_table::add_abbrev (unsigned int abbrev_number,
18151                           struct abbrev_info *abbrev)
18152 {
18153   unsigned int hash_number;
18154
18155   hash_number = abbrev_number % ABBREV_HASH_SIZE;
18156   abbrev->next = m_abbrevs[hash_number];
18157   m_abbrevs[hash_number] = abbrev;
18158 }
18159
18160 /* Look up an abbrev in the table.
18161    Returns NULL if the abbrev is not found.  */
18162
18163 struct abbrev_info *
18164 abbrev_table::lookup_abbrev (unsigned int abbrev_number)
18165 {
18166   unsigned int hash_number;
18167   struct abbrev_info *abbrev;
18168
18169   hash_number = abbrev_number % ABBREV_HASH_SIZE;
18170   abbrev = m_abbrevs[hash_number];
18171
18172   while (abbrev)
18173     {
18174       if (abbrev->number == abbrev_number)
18175         return abbrev;
18176       abbrev = abbrev->next;
18177     }
18178   return NULL;
18179 }
18180
18181 /* Read in an abbrev table.  */
18182
18183 static abbrev_table_up
18184 abbrev_table_read_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
18185                          struct dwarf2_section_info *section,
18186                          sect_offset sect_off)
18187 {
18188   struct objfile *objfile = dwarf2_per_objfile->objfile;
18189   bfd *abfd = get_section_bfd_owner (section);
18190   const gdb_byte *abbrev_ptr;
18191   struct abbrev_info *cur_abbrev;
18192   unsigned int abbrev_number, bytes_read, abbrev_name;
18193   unsigned int abbrev_form;
18194   struct attr_abbrev *cur_attrs;
18195   unsigned int allocated_attrs;
18196
18197   abbrev_table_up abbrev_table (new struct abbrev_table (sect_off));
18198
18199   dwarf2_read_section (objfile, section);
18200   abbrev_ptr = section->buffer + to_underlying (sect_off);
18201   abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18202   abbrev_ptr += bytes_read;
18203
18204   allocated_attrs = ATTR_ALLOC_CHUNK;
18205   cur_attrs = XNEWVEC (struct attr_abbrev, allocated_attrs);
18206
18207   /* Loop until we reach an abbrev number of 0.  */
18208   while (abbrev_number)
18209     {
18210       cur_abbrev = abbrev_table->alloc_abbrev ();
18211
18212       /* read in abbrev header */
18213       cur_abbrev->number = abbrev_number;
18214       cur_abbrev->tag
18215         = (enum dwarf_tag) read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18216       abbrev_ptr += bytes_read;
18217       cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
18218       abbrev_ptr += 1;
18219
18220       /* now read in declarations */
18221       for (;;)
18222         {
18223           LONGEST implicit_const;
18224
18225           abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18226           abbrev_ptr += bytes_read;
18227           abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18228           abbrev_ptr += bytes_read;
18229           if (abbrev_form == DW_FORM_implicit_const)
18230             {
18231               implicit_const = read_signed_leb128 (abfd, abbrev_ptr,
18232                                                    &bytes_read);
18233               abbrev_ptr += bytes_read;
18234             }
18235           else
18236             {
18237               /* Initialize it due to a false compiler warning.  */
18238               implicit_const = -1;
18239             }
18240
18241           if (abbrev_name == 0)
18242             break;
18243
18244           if (cur_abbrev->num_attrs == allocated_attrs)
18245             {
18246               allocated_attrs += ATTR_ALLOC_CHUNK;
18247               cur_attrs
18248                 = XRESIZEVEC (struct attr_abbrev, cur_attrs, allocated_attrs);
18249             }
18250
18251           cur_attrs[cur_abbrev->num_attrs].name
18252             = (enum dwarf_attribute) abbrev_name;
18253           cur_attrs[cur_abbrev->num_attrs].form
18254             = (enum dwarf_form) abbrev_form;
18255           cur_attrs[cur_abbrev->num_attrs].implicit_const = implicit_const;
18256           ++cur_abbrev->num_attrs;
18257         }
18258
18259       cur_abbrev->attrs =
18260         XOBNEWVEC (&abbrev_table->abbrev_obstack, struct attr_abbrev,
18261                    cur_abbrev->num_attrs);
18262       memcpy (cur_abbrev->attrs, cur_attrs,
18263               cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
18264
18265       abbrev_table->add_abbrev (abbrev_number, cur_abbrev);
18266
18267       /* Get next abbreviation.
18268          Under Irix6 the abbreviations for a compilation unit are not
18269          always properly terminated with an abbrev number of 0.
18270          Exit loop if we encounter an abbreviation which we have
18271          already read (which means we are about to read the abbreviations
18272          for the next compile unit) or if the end of the abbreviation
18273          table is reached.  */
18274       if ((unsigned int) (abbrev_ptr - section->buffer) >= section->size)
18275         break;
18276       abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18277       abbrev_ptr += bytes_read;
18278       if (abbrev_table->lookup_abbrev (abbrev_number) != NULL)
18279         break;
18280     }
18281
18282   xfree (cur_attrs);
18283   return abbrev_table;
18284 }
18285
18286 /* Returns nonzero if TAG represents a type that we might generate a partial
18287    symbol for.  */
18288
18289 static int
18290 is_type_tag_for_partial (int tag)
18291 {
18292   switch (tag)
18293     {
18294 #if 0
18295     /* Some types that would be reasonable to generate partial symbols for,
18296        that we don't at present.  */
18297     case DW_TAG_array_type:
18298     case DW_TAG_file_type:
18299     case DW_TAG_ptr_to_member_type:
18300     case DW_TAG_set_type:
18301     case DW_TAG_string_type:
18302     case DW_TAG_subroutine_type:
18303 #endif
18304     case DW_TAG_base_type:
18305     case DW_TAG_class_type:
18306     case DW_TAG_interface_type:
18307     case DW_TAG_enumeration_type:
18308     case DW_TAG_structure_type:
18309     case DW_TAG_subrange_type:
18310     case DW_TAG_typedef:
18311     case DW_TAG_union_type:
18312       return 1;
18313     default:
18314       return 0;
18315     }
18316 }
18317
18318 /* Load all DIEs that are interesting for partial symbols into memory.  */
18319
18320 static struct partial_die_info *
18321 load_partial_dies (const struct die_reader_specs *reader,
18322                    const gdb_byte *info_ptr, int building_psymtab)
18323 {
18324   struct dwarf2_cu *cu = reader->cu;
18325   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
18326   struct partial_die_info *parent_die, *last_die, *first_die = NULL;
18327   unsigned int bytes_read;
18328   unsigned int load_all = 0;
18329   int nesting_level = 1;
18330
18331   parent_die = NULL;
18332   last_die = NULL;
18333
18334   gdb_assert (cu->per_cu != NULL);
18335   if (cu->per_cu->load_all_dies)
18336     load_all = 1;
18337
18338   cu->partial_dies
18339     = htab_create_alloc_ex (cu->header.length / 12,
18340                             partial_die_hash,
18341                             partial_die_eq,
18342                             NULL,
18343                             &cu->comp_unit_obstack,
18344                             hashtab_obstack_allocate,
18345                             dummy_obstack_deallocate);
18346
18347   while (1)
18348     {
18349       abbrev_info *abbrev = peek_die_abbrev (*reader, info_ptr, &bytes_read);
18350
18351       /* A NULL abbrev means the end of a series of children.  */
18352       if (abbrev == NULL)
18353         {
18354           if (--nesting_level == 0)
18355             return first_die;
18356
18357           info_ptr += bytes_read;
18358           last_die = parent_die;
18359           parent_die = parent_die->die_parent;
18360           continue;
18361         }
18362
18363       /* Check for template arguments.  We never save these; if
18364          they're seen, we just mark the parent, and go on our way.  */
18365       if (parent_die != NULL
18366           && cu->language == language_cplus
18367           && (abbrev->tag == DW_TAG_template_type_param
18368               || abbrev->tag == DW_TAG_template_value_param))
18369         {
18370           parent_die->has_template_arguments = 1;
18371
18372           if (!load_all)
18373             {
18374               /* We don't need a partial DIE for the template argument.  */
18375               info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18376               continue;
18377             }
18378         }
18379
18380       /* We only recurse into c++ subprograms looking for template arguments.
18381          Skip their other children.  */
18382       if (!load_all
18383           && cu->language == language_cplus
18384           && parent_die != NULL
18385           && parent_die->tag == DW_TAG_subprogram)
18386         {
18387           info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18388           continue;
18389         }
18390
18391       /* Check whether this DIE is interesting enough to save.  Normally
18392          we would not be interested in members here, but there may be
18393          later variables referencing them via DW_AT_specification (for
18394          static members).  */
18395       if (!load_all
18396           && !is_type_tag_for_partial (abbrev->tag)
18397           && abbrev->tag != DW_TAG_constant
18398           && abbrev->tag != DW_TAG_enumerator
18399           && abbrev->tag != DW_TAG_subprogram
18400           && abbrev->tag != DW_TAG_inlined_subroutine
18401           && abbrev->tag != DW_TAG_lexical_block
18402           && abbrev->tag != DW_TAG_variable
18403           && abbrev->tag != DW_TAG_namespace
18404           && abbrev->tag != DW_TAG_module
18405           && abbrev->tag != DW_TAG_member
18406           && abbrev->tag != DW_TAG_imported_unit
18407           && abbrev->tag != DW_TAG_imported_declaration)
18408         {
18409           /* Otherwise we skip to the next sibling, if any.  */
18410           info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18411           continue;
18412         }
18413
18414       struct partial_die_info pdi ((sect_offset) (info_ptr - reader->buffer),
18415                                    abbrev);
18416
18417       info_ptr = pdi.read (reader, *abbrev, info_ptr + bytes_read);
18418
18419       /* This two-pass algorithm for processing partial symbols has a
18420          high cost in cache pressure.  Thus, handle some simple cases
18421          here which cover the majority of C partial symbols.  DIEs
18422          which neither have specification tags in them, nor could have
18423          specification tags elsewhere pointing at them, can simply be
18424          processed and discarded.
18425
18426          This segment is also optional; scan_partial_symbols and
18427          add_partial_symbol will handle these DIEs if we chain
18428          them in normally.  When compilers which do not emit large
18429          quantities of duplicate debug information are more common,
18430          this code can probably be removed.  */
18431
18432       /* Any complete simple types at the top level (pretty much all
18433          of them, for a language without namespaces), can be processed
18434          directly.  */
18435       if (parent_die == NULL
18436           && pdi.has_specification == 0
18437           && pdi.is_declaration == 0
18438           && ((pdi.tag == DW_TAG_typedef && !pdi.has_children)
18439               || pdi.tag == DW_TAG_base_type
18440               || pdi.tag == DW_TAG_subrange_type))
18441         {
18442           if (building_psymtab && pdi.name != NULL)
18443             add_psymbol_to_list (pdi.name, strlen (pdi.name), 0,
18444                                  VAR_DOMAIN, LOC_TYPEDEF, -1,
18445                                  psymbol_placement::STATIC,
18446                                  0, cu->language, objfile);
18447           info_ptr = locate_pdi_sibling (reader, &pdi, info_ptr);
18448           continue;
18449         }
18450
18451       /* The exception for DW_TAG_typedef with has_children above is
18452          a workaround of GCC PR debug/47510.  In the case of this complaint
18453          type_name_or_error will error on such types later.
18454
18455          GDB skipped children of DW_TAG_typedef by the shortcut above and then
18456          it could not find the child DIEs referenced later, this is checked
18457          above.  In correct DWARF DW_TAG_typedef should have no children.  */
18458
18459       if (pdi.tag == DW_TAG_typedef && pdi.has_children)
18460         complaint (_("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
18461                      "- DIE at %s [in module %s]"),
18462                    sect_offset_str (pdi.sect_off), objfile_name (objfile));
18463
18464       /* If we're at the second level, and we're an enumerator, and
18465          our parent has no specification (meaning possibly lives in a
18466          namespace elsewhere), then we can add the partial symbol now
18467          instead of queueing it.  */
18468       if (pdi.tag == DW_TAG_enumerator
18469           && parent_die != NULL
18470           && parent_die->die_parent == NULL
18471           && parent_die->tag == DW_TAG_enumeration_type
18472           && parent_die->has_specification == 0)
18473         {
18474           if (pdi.name == NULL)
18475             complaint (_("malformed enumerator DIE ignored"));
18476           else if (building_psymtab)
18477             add_psymbol_to_list (pdi.name, strlen (pdi.name), 0,
18478                                  VAR_DOMAIN, LOC_CONST, -1,
18479                                  cu->language == language_cplus
18480                                  ? psymbol_placement::GLOBAL
18481                                  : psymbol_placement::STATIC,
18482                                  0, cu->language, objfile);
18483
18484           info_ptr = locate_pdi_sibling (reader, &pdi, info_ptr);
18485           continue;
18486         }
18487
18488       struct partial_die_info *part_die
18489         = new (&cu->comp_unit_obstack) partial_die_info (pdi);
18490
18491       /* We'll save this DIE so link it in.  */
18492       part_die->die_parent = parent_die;
18493       part_die->die_sibling = NULL;
18494       part_die->die_child = NULL;
18495
18496       if (last_die && last_die == parent_die)
18497         last_die->die_child = part_die;
18498       else if (last_die)
18499         last_die->die_sibling = part_die;
18500
18501       last_die = part_die;
18502
18503       if (first_die == NULL)
18504         first_die = part_die;
18505
18506       /* Maybe add the DIE to the hash table.  Not all DIEs that we
18507          find interesting need to be in the hash table, because we
18508          also have the parent/sibling/child chains; only those that we
18509          might refer to by offset later during partial symbol reading.
18510
18511          For now this means things that might have be the target of a
18512          DW_AT_specification, DW_AT_abstract_origin, or
18513          DW_AT_extension.  DW_AT_extension will refer only to
18514          namespaces; DW_AT_abstract_origin refers to functions (and
18515          many things under the function DIE, but we do not recurse
18516          into function DIEs during partial symbol reading) and
18517          possibly variables as well; DW_AT_specification refers to
18518          declarations.  Declarations ought to have the DW_AT_declaration
18519          flag.  It happens that GCC forgets to put it in sometimes, but
18520          only for functions, not for types.
18521
18522          Adding more things than necessary to the hash table is harmless
18523          except for the performance cost.  Adding too few will result in
18524          wasted time in find_partial_die, when we reread the compilation
18525          unit with load_all_dies set.  */
18526
18527       if (load_all
18528           || abbrev->tag == DW_TAG_constant
18529           || abbrev->tag == DW_TAG_subprogram
18530           || abbrev->tag == DW_TAG_variable
18531           || abbrev->tag == DW_TAG_namespace
18532           || part_die->is_declaration)
18533         {
18534           void **slot;
18535
18536           slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
18537                                            to_underlying (part_die->sect_off),
18538                                            INSERT);
18539           *slot = part_die;
18540         }
18541
18542       /* For some DIEs we want to follow their children (if any).  For C
18543          we have no reason to follow the children of structures; for other
18544          languages we have to, so that we can get at method physnames
18545          to infer fully qualified class names, for DW_AT_specification,
18546          and for C++ template arguments.  For C++, we also look one level
18547          inside functions to find template arguments (if the name of the
18548          function does not already contain the template arguments).
18549
18550          For Ada, we need to scan the children of subprograms and lexical
18551          blocks as well because Ada allows the definition of nested
18552          entities that could be interesting for the debugger, such as
18553          nested subprograms for instance.  */
18554       if (last_die->has_children
18555           && (load_all
18556               || last_die->tag == DW_TAG_namespace
18557               || last_die->tag == DW_TAG_module
18558               || last_die->tag == DW_TAG_enumeration_type
18559               || (cu->language == language_cplus
18560                   && last_die->tag == DW_TAG_subprogram
18561                   && (last_die->name == NULL
18562                       || strchr (last_die->name, '<') == NULL))
18563               || (cu->language != language_c
18564                   && (last_die->tag == DW_TAG_class_type
18565                       || last_die->tag == DW_TAG_interface_type
18566                       || last_die->tag == DW_TAG_structure_type
18567                       || last_die->tag == DW_TAG_union_type))
18568               || (cu->language == language_ada
18569                   && (last_die->tag == DW_TAG_subprogram
18570                       || last_die->tag == DW_TAG_lexical_block))))
18571         {
18572           nesting_level++;
18573           parent_die = last_die;
18574           continue;
18575         }
18576
18577       /* Otherwise we skip to the next sibling, if any.  */
18578       info_ptr = locate_pdi_sibling (reader, last_die, info_ptr);
18579
18580       /* Back to the top, do it again.  */
18581     }
18582 }
18583
18584 partial_die_info::partial_die_info (sect_offset sect_off_,
18585                                     struct abbrev_info *abbrev)
18586   : partial_die_info (sect_off_, abbrev->tag, abbrev->has_children)
18587 {
18588 }
18589
18590 /* Read a minimal amount of information into the minimal die structure.
18591    INFO_PTR should point just after the initial uleb128 of a DIE.  */
18592
18593 const gdb_byte *
18594 partial_die_info::read (const struct die_reader_specs *reader,
18595                         const struct abbrev_info &abbrev, const gdb_byte *info_ptr)
18596 {
18597   struct dwarf2_cu *cu = reader->cu;
18598   struct dwarf2_per_objfile *dwarf2_per_objfile
18599     = cu->per_cu->dwarf2_per_objfile;
18600   unsigned int i;
18601   int has_low_pc_attr = 0;
18602   int has_high_pc_attr = 0;
18603   int high_pc_relative = 0;
18604
18605   for (i = 0; i < abbrev.num_attrs; ++i)
18606     {
18607       struct attribute attr;
18608
18609       info_ptr = read_attribute (reader, &attr, &abbrev.attrs[i], info_ptr);
18610
18611       /* Store the data if it is of an attribute we want to keep in a
18612          partial symbol table.  */
18613       switch (attr.name)
18614         {
18615         case DW_AT_name:
18616           switch (tag)
18617             {
18618             case DW_TAG_compile_unit:
18619             case DW_TAG_partial_unit:
18620             case DW_TAG_type_unit:
18621               /* Compilation units have a DW_AT_name that is a filename, not
18622                  a source language identifier.  */
18623             case DW_TAG_enumeration_type:
18624             case DW_TAG_enumerator:
18625               /* These tags always have simple identifiers already; no need
18626                  to canonicalize them.  */
18627               name = DW_STRING (&attr);
18628               break;
18629             default:
18630               {
18631                 struct objfile *objfile = dwarf2_per_objfile->objfile;
18632
18633                 name
18634                   = dwarf2_canonicalize_name (DW_STRING (&attr), cu,
18635                                               &objfile->per_bfd->storage_obstack);
18636               }
18637               break;
18638             }
18639           break;
18640         case DW_AT_linkage_name:
18641         case DW_AT_MIPS_linkage_name:
18642           /* Note that both forms of linkage name might appear.  We
18643              assume they will be the same, and we only store the last
18644              one we see.  */
18645           if (cu->language == language_ada)
18646             name = DW_STRING (&attr);
18647           linkage_name = DW_STRING (&attr);
18648           break;
18649         case DW_AT_low_pc:
18650           has_low_pc_attr = 1;
18651           lowpc = attr_value_as_address (&attr);
18652           break;
18653         case DW_AT_high_pc:
18654           has_high_pc_attr = 1;
18655           highpc = attr_value_as_address (&attr);
18656           if (cu->header.version >= 4 && attr_form_is_constant (&attr))
18657                 high_pc_relative = 1;
18658           break;
18659         case DW_AT_location:
18660           /* Support the .debug_loc offsets.  */
18661           if (attr_form_is_block (&attr))
18662             {
18663                d.locdesc = DW_BLOCK (&attr);
18664             }
18665           else if (attr_form_is_section_offset (&attr))
18666             {
18667               dwarf2_complex_location_expr_complaint ();
18668             }
18669           else
18670             {
18671               dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
18672                                                      "partial symbol information");
18673             }
18674           break;
18675         case DW_AT_external:
18676           is_external = DW_UNSND (&attr);
18677           break;
18678         case DW_AT_declaration:
18679           is_declaration = DW_UNSND (&attr);
18680           break;
18681         case DW_AT_type:
18682           has_type = 1;
18683           break;
18684         case DW_AT_abstract_origin:
18685         case DW_AT_specification:
18686         case DW_AT_extension:
18687           has_specification = 1;
18688           spec_offset = dwarf2_get_ref_die_offset (&attr);
18689           spec_is_dwz = (attr.form == DW_FORM_GNU_ref_alt
18690                                    || cu->per_cu->is_dwz);
18691           break;
18692         case DW_AT_sibling:
18693           /* Ignore absolute siblings, they might point outside of
18694              the current compile unit.  */
18695           if (attr.form == DW_FORM_ref_addr)
18696             complaint (_("ignoring absolute DW_AT_sibling"));
18697           else
18698             {
18699               const gdb_byte *buffer = reader->buffer;
18700               sect_offset off = dwarf2_get_ref_die_offset (&attr);
18701               const gdb_byte *sibling_ptr = buffer + to_underlying (off);
18702
18703               if (sibling_ptr < info_ptr)
18704                 complaint (_("DW_AT_sibling points backwards"));
18705               else if (sibling_ptr > reader->buffer_end)
18706                 dwarf2_section_buffer_overflow_complaint (reader->die_section);
18707               else
18708                 sibling = sibling_ptr;
18709             }
18710           break;
18711         case DW_AT_byte_size:
18712           has_byte_size = 1;
18713           break;
18714         case DW_AT_const_value:
18715           has_const_value = 1;
18716           break;
18717         case DW_AT_calling_convention:
18718           /* DWARF doesn't provide a way to identify a program's source-level
18719              entry point.  DW_AT_calling_convention attributes are only meant
18720              to describe functions' calling conventions.
18721
18722              However, because it's a necessary piece of information in
18723              Fortran, and before DWARF 4 DW_CC_program was the only
18724              piece of debugging information whose definition refers to
18725              a 'main program' at all, several compilers marked Fortran
18726              main programs with DW_CC_program --- even when those
18727              functions use the standard calling conventions.
18728
18729              Although DWARF now specifies a way to provide this
18730              information, we support this practice for backward
18731              compatibility.  */
18732           if (DW_UNSND (&attr) == DW_CC_program
18733               && cu->language == language_fortran)
18734             main_subprogram = 1;
18735           break;
18736         case DW_AT_inline:
18737           if (DW_UNSND (&attr) == DW_INL_inlined
18738               || DW_UNSND (&attr) == DW_INL_declared_inlined)
18739             may_be_inlined = 1;
18740           break;
18741
18742         case DW_AT_import:
18743           if (tag == DW_TAG_imported_unit)
18744             {
18745               d.sect_off = dwarf2_get_ref_die_offset (&attr);
18746               is_dwz = (attr.form == DW_FORM_GNU_ref_alt
18747                                   || cu->per_cu->is_dwz);
18748             }
18749           break;
18750
18751         case DW_AT_main_subprogram:
18752           main_subprogram = DW_UNSND (&attr);
18753           break;
18754
18755         default:
18756           break;
18757         }
18758     }
18759
18760   if (high_pc_relative)
18761     highpc += lowpc;
18762
18763   if (has_low_pc_attr && has_high_pc_attr)
18764     {
18765       /* When using the GNU linker, .gnu.linkonce. sections are used to
18766          eliminate duplicate copies of functions and vtables and such.
18767          The linker will arbitrarily choose one and discard the others.
18768          The AT_*_pc values for such functions refer to local labels in
18769          these sections.  If the section from that file was discarded, the
18770          labels are not in the output, so the relocs get a value of 0.
18771          If this is a discarded function, mark the pc bounds as invalid,
18772          so that GDB will ignore it.  */
18773       if (lowpc == 0 && !dwarf2_per_objfile->has_section_at_zero)
18774         {
18775           struct objfile *objfile = dwarf2_per_objfile->objfile;
18776           struct gdbarch *gdbarch = get_objfile_arch (objfile);
18777
18778           complaint (_("DW_AT_low_pc %s is zero "
18779                        "for DIE at %s [in module %s]"),
18780                      paddress (gdbarch, lowpc),
18781                      sect_offset_str (sect_off),
18782                      objfile_name (objfile));
18783         }
18784       /* dwarf2_get_pc_bounds has also the strict low < high requirement.  */
18785       else if (lowpc >= highpc)
18786         {
18787           struct objfile *objfile = dwarf2_per_objfile->objfile;
18788           struct gdbarch *gdbarch = get_objfile_arch (objfile);
18789
18790           complaint (_("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
18791                        "for DIE at %s [in module %s]"),
18792                      paddress (gdbarch, lowpc),
18793                      paddress (gdbarch, highpc),
18794                      sect_offset_str (sect_off),
18795                      objfile_name (objfile));
18796         }
18797       else
18798         has_pc_info = 1;
18799     }
18800
18801   return info_ptr;
18802 }
18803
18804 /* Find a cached partial DIE at OFFSET in CU.  */
18805
18806 struct partial_die_info *
18807 dwarf2_cu::find_partial_die (sect_offset sect_off)
18808 {
18809   struct partial_die_info *lookup_die = NULL;
18810   struct partial_die_info part_die (sect_off);
18811
18812   lookup_die = ((struct partial_die_info *)
18813                 htab_find_with_hash (partial_dies, &part_die,
18814                                      to_underlying (sect_off)));
18815
18816   return lookup_die;
18817 }
18818
18819 /* Find a partial DIE at OFFSET, which may or may not be in CU,
18820    except in the case of .debug_types DIEs which do not reference
18821    outside their CU (they do however referencing other types via
18822    DW_FORM_ref_sig8).  */
18823
18824 static struct partial_die_info *
18825 find_partial_die (sect_offset sect_off, int offset_in_dwz, struct dwarf2_cu *cu)
18826 {
18827   struct dwarf2_per_objfile *dwarf2_per_objfile
18828     = cu->per_cu->dwarf2_per_objfile;
18829   struct objfile *objfile = dwarf2_per_objfile->objfile;
18830   struct dwarf2_per_cu_data *per_cu = NULL;
18831   struct partial_die_info *pd = NULL;
18832
18833   if (offset_in_dwz == cu->per_cu->is_dwz
18834       && offset_in_cu_p (&cu->header, sect_off))
18835     {
18836       pd = cu->find_partial_die (sect_off);
18837       if (pd != NULL)
18838         return pd;
18839       /* We missed recording what we needed.
18840          Load all dies and try again.  */
18841       per_cu = cu->per_cu;
18842     }
18843   else
18844     {
18845       /* TUs don't reference other CUs/TUs (except via type signatures).  */
18846       if (cu->per_cu->is_debug_types)
18847         {
18848           error (_("Dwarf Error: Type Unit at offset %s contains"
18849                    " external reference to offset %s [in module %s].\n"),
18850                  sect_offset_str (cu->header.sect_off), sect_offset_str (sect_off),
18851                  bfd_get_filename (objfile->obfd));
18852         }
18853       per_cu = dwarf2_find_containing_comp_unit (sect_off, offset_in_dwz,
18854                                                  dwarf2_per_objfile);
18855
18856       if (per_cu->cu == NULL || per_cu->cu->partial_dies == NULL)
18857         load_partial_comp_unit (per_cu);
18858
18859       per_cu->cu->last_used = 0;
18860       pd = per_cu->cu->find_partial_die (sect_off);
18861     }
18862
18863   /* If we didn't find it, and not all dies have been loaded,
18864      load them all and try again.  */
18865
18866   if (pd == NULL && per_cu->load_all_dies == 0)
18867     {
18868       per_cu->load_all_dies = 1;
18869
18870       /* This is nasty.  When we reread the DIEs, somewhere up the call chain
18871          THIS_CU->cu may already be in use.  So we can't just free it and
18872          replace its DIEs with the ones we read in.  Instead, we leave those
18873          DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
18874          and clobber THIS_CU->cu->partial_dies with the hash table for the new
18875          set.  */
18876       load_partial_comp_unit (per_cu);
18877
18878       pd = per_cu->cu->find_partial_die (sect_off);
18879     }
18880
18881   if (pd == NULL)
18882     internal_error (__FILE__, __LINE__,
18883                     _("could not find partial DIE %s "
18884                       "in cache [from module %s]\n"),
18885                     sect_offset_str (sect_off), bfd_get_filename (objfile->obfd));
18886   return pd;
18887 }
18888
18889 /* See if we can figure out if the class lives in a namespace.  We do
18890    this by looking for a member function; its demangled name will
18891    contain namespace info, if there is any.  */
18892
18893 static void
18894 guess_partial_die_structure_name (struct partial_die_info *struct_pdi,
18895                                   struct dwarf2_cu *cu)
18896 {
18897   /* NOTE: carlton/2003-10-07: Getting the info this way changes
18898      what template types look like, because the demangler
18899      frequently doesn't give the same name as the debug info.  We
18900      could fix this by only using the demangled name to get the
18901      prefix (but see comment in read_structure_type).  */
18902
18903   struct partial_die_info *real_pdi;
18904   struct partial_die_info *child_pdi;
18905
18906   /* If this DIE (this DIE's specification, if any) has a parent, then
18907      we should not do this.  We'll prepend the parent's fully qualified
18908      name when we create the partial symbol.  */
18909
18910   real_pdi = struct_pdi;
18911   while (real_pdi->has_specification)
18912     real_pdi = find_partial_die (real_pdi->spec_offset,
18913                                  real_pdi->spec_is_dwz, cu);
18914
18915   if (real_pdi->die_parent != NULL)
18916     return;
18917
18918   for (child_pdi = struct_pdi->die_child;
18919        child_pdi != NULL;
18920        child_pdi = child_pdi->die_sibling)
18921     {
18922       if (child_pdi->tag == DW_TAG_subprogram
18923           && child_pdi->linkage_name != NULL)
18924         {
18925           char *actual_class_name
18926             = language_class_name_from_physname (cu->language_defn,
18927                                                  child_pdi->linkage_name);
18928           if (actual_class_name != NULL)
18929             {
18930               struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
18931               struct_pdi->name
18932                 = ((const char *)
18933                    obstack_copy0 (&objfile->per_bfd->storage_obstack,
18934                                   actual_class_name,
18935                                   strlen (actual_class_name)));
18936               xfree (actual_class_name);
18937             }
18938           break;
18939         }
18940     }
18941 }
18942
18943 void
18944 partial_die_info::fixup (struct dwarf2_cu *cu)
18945 {
18946   /* Once we've fixed up a die, there's no point in doing so again.
18947      This also avoids a memory leak if we were to call
18948      guess_partial_die_structure_name multiple times.  */
18949   if (fixup_called)
18950     return;
18951
18952   /* If we found a reference attribute and the DIE has no name, try
18953      to find a name in the referred to DIE.  */
18954
18955   if (name == NULL && has_specification)
18956     {
18957       struct partial_die_info *spec_die;
18958
18959       spec_die = find_partial_die (spec_offset, spec_is_dwz, cu);
18960
18961       spec_die->fixup (cu);
18962
18963       if (spec_die->name)
18964         {
18965           name = spec_die->name;
18966
18967           /* Copy DW_AT_external attribute if it is set.  */
18968           if (spec_die->is_external)
18969             is_external = spec_die->is_external;
18970         }
18971     }
18972
18973   /* Set default names for some unnamed DIEs.  */
18974
18975   if (name == NULL && tag == DW_TAG_namespace)
18976     name = CP_ANONYMOUS_NAMESPACE_STR;
18977
18978   /* If there is no parent die to provide a namespace, and there are
18979      children, see if we can determine the namespace from their linkage
18980      name.  */
18981   if (cu->language == language_cplus
18982       && !VEC_empty (dwarf2_section_info_def,
18983                      cu->per_cu->dwarf2_per_objfile->types)
18984       && die_parent == NULL
18985       && has_children
18986       && (tag == DW_TAG_class_type
18987           || tag == DW_TAG_structure_type
18988           || tag == DW_TAG_union_type))
18989     guess_partial_die_structure_name (this, cu);
18990
18991   /* GCC might emit a nameless struct or union that has a linkage
18992      name.  See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510.  */
18993   if (name == NULL
18994       && (tag == DW_TAG_class_type
18995           || tag == DW_TAG_interface_type
18996           || tag == DW_TAG_structure_type
18997           || tag == DW_TAG_union_type)
18998       && linkage_name != NULL)
18999     {
19000       char *demangled;
19001
19002       demangled = gdb_demangle (linkage_name, DMGL_TYPES);
19003       if (demangled)
19004         {
19005           const char *base;
19006
19007           /* Strip any leading namespaces/classes, keep only the base name.
19008              DW_AT_name for named DIEs does not contain the prefixes.  */
19009           base = strrchr (demangled, ':');
19010           if (base && base > demangled && base[-1] == ':')
19011             base++;
19012           else
19013             base = demangled;
19014
19015           struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
19016           name
19017             = ((const char *)
19018                obstack_copy0 (&objfile->per_bfd->storage_obstack,
19019                               base, strlen (base)));
19020           xfree (demangled);
19021         }
19022     }
19023
19024   fixup_called = 1;
19025 }
19026
19027 /* Read an attribute value described by an attribute form.  */
19028
19029 static const gdb_byte *
19030 read_attribute_value (const struct die_reader_specs *reader,
19031                       struct attribute *attr, unsigned form,
19032                       LONGEST implicit_const, const gdb_byte *info_ptr)
19033 {
19034   struct dwarf2_cu *cu = reader->cu;
19035   struct dwarf2_per_objfile *dwarf2_per_objfile
19036     = cu->per_cu->dwarf2_per_objfile;
19037   struct objfile *objfile = dwarf2_per_objfile->objfile;
19038   struct gdbarch *gdbarch = get_objfile_arch (objfile);
19039   bfd *abfd = reader->abfd;
19040   struct comp_unit_head *cu_header = &cu->header;
19041   unsigned int bytes_read;
19042   struct dwarf_block *blk;
19043
19044   attr->form = (enum dwarf_form) form;
19045   switch (form)
19046     {
19047     case DW_FORM_ref_addr:
19048       if (cu->header.version == 2)
19049         DW_UNSND (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
19050       else
19051         DW_UNSND (attr) = read_offset (abfd, info_ptr,
19052                                        &cu->header, &bytes_read);
19053       info_ptr += bytes_read;
19054       break;
19055     case DW_FORM_GNU_ref_alt:
19056       DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
19057       info_ptr += bytes_read;
19058       break;
19059     case DW_FORM_addr:
19060       DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
19061       DW_ADDR (attr) = gdbarch_adjust_dwarf2_addr (gdbarch, DW_ADDR (attr));
19062       info_ptr += bytes_read;
19063       break;
19064     case DW_FORM_block2:
19065       blk = dwarf_alloc_block (cu);
19066       blk->size = read_2_bytes (abfd, info_ptr);
19067       info_ptr += 2;
19068       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19069       info_ptr += blk->size;
19070       DW_BLOCK (attr) = blk;
19071       break;
19072     case DW_FORM_block4:
19073       blk = dwarf_alloc_block (cu);
19074       blk->size = read_4_bytes (abfd, info_ptr);
19075       info_ptr += 4;
19076       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19077       info_ptr += blk->size;
19078       DW_BLOCK (attr) = blk;
19079       break;
19080     case DW_FORM_data2:
19081       DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
19082       info_ptr += 2;
19083       break;
19084     case DW_FORM_data4:
19085       DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
19086       info_ptr += 4;
19087       break;
19088     case DW_FORM_data8:
19089       DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
19090       info_ptr += 8;
19091       break;
19092     case DW_FORM_data16:
19093       blk = dwarf_alloc_block (cu);
19094       blk->size = 16;
19095       blk->data = read_n_bytes (abfd, info_ptr, 16);
19096       info_ptr += 16;
19097       DW_BLOCK (attr) = blk;
19098       break;
19099     case DW_FORM_sec_offset:
19100       DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
19101       info_ptr += bytes_read;
19102       break;
19103     case DW_FORM_string:
19104       DW_STRING (attr) = read_direct_string (abfd, info_ptr, &bytes_read);
19105       DW_STRING_IS_CANONICAL (attr) = 0;
19106       info_ptr += bytes_read;
19107       break;
19108     case DW_FORM_strp:
19109       if (!cu->per_cu->is_dwz)
19110         {
19111           DW_STRING (attr) = read_indirect_string (dwarf2_per_objfile,
19112                                                    abfd, info_ptr, cu_header,
19113                                                    &bytes_read);
19114           DW_STRING_IS_CANONICAL (attr) = 0;
19115           info_ptr += bytes_read;
19116           break;
19117         }
19118       /* FALLTHROUGH */
19119     case DW_FORM_line_strp:
19120       if (!cu->per_cu->is_dwz)
19121         {
19122           DW_STRING (attr) = read_indirect_line_string (dwarf2_per_objfile,
19123                                                         abfd, info_ptr,
19124                                                         cu_header, &bytes_read);
19125           DW_STRING_IS_CANONICAL (attr) = 0;
19126           info_ptr += bytes_read;
19127           break;
19128         }
19129       /* FALLTHROUGH */
19130     case DW_FORM_GNU_strp_alt:
19131       {
19132         struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
19133         LONGEST str_offset = read_offset (abfd, info_ptr, cu_header,
19134                                           &bytes_read);
19135
19136         DW_STRING (attr) = read_indirect_string_from_dwz (objfile,
19137                                                           dwz, str_offset);
19138         DW_STRING_IS_CANONICAL (attr) = 0;
19139         info_ptr += bytes_read;
19140       }
19141       break;
19142     case DW_FORM_exprloc:
19143     case DW_FORM_block:
19144       blk = dwarf_alloc_block (cu);
19145       blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19146       info_ptr += bytes_read;
19147       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19148       info_ptr += blk->size;
19149       DW_BLOCK (attr) = blk;
19150       break;
19151     case DW_FORM_block1:
19152       blk = dwarf_alloc_block (cu);
19153       blk->size = read_1_byte (abfd, info_ptr);
19154       info_ptr += 1;
19155       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19156       info_ptr += blk->size;
19157       DW_BLOCK (attr) = blk;
19158       break;
19159     case DW_FORM_data1:
19160       DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
19161       info_ptr += 1;
19162       break;
19163     case DW_FORM_flag:
19164       DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
19165       info_ptr += 1;
19166       break;
19167     case DW_FORM_flag_present:
19168       DW_UNSND (attr) = 1;
19169       break;
19170     case DW_FORM_sdata:
19171       DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
19172       info_ptr += bytes_read;
19173       break;
19174     case DW_FORM_udata:
19175       DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19176       info_ptr += bytes_read;
19177       break;
19178     case DW_FORM_ref1:
19179       DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19180                          + read_1_byte (abfd, info_ptr));
19181       info_ptr += 1;
19182       break;
19183     case DW_FORM_ref2:
19184       DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19185                          + read_2_bytes (abfd, info_ptr));
19186       info_ptr += 2;
19187       break;
19188     case DW_FORM_ref4:
19189       DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19190                          + read_4_bytes (abfd, info_ptr));
19191       info_ptr += 4;
19192       break;
19193     case DW_FORM_ref8:
19194       DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19195                          + read_8_bytes (abfd, info_ptr));
19196       info_ptr += 8;
19197       break;
19198     case DW_FORM_ref_sig8:
19199       DW_SIGNATURE (attr) = read_8_bytes (abfd, info_ptr);
19200       info_ptr += 8;
19201       break;
19202     case DW_FORM_ref_udata:
19203       DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19204                          + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
19205       info_ptr += bytes_read;
19206       break;
19207     case DW_FORM_indirect:
19208       form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19209       info_ptr += bytes_read;
19210       if (form == DW_FORM_implicit_const)
19211         {
19212           implicit_const = read_signed_leb128 (abfd, info_ptr, &bytes_read);
19213           info_ptr += bytes_read;
19214         }
19215       info_ptr = read_attribute_value (reader, attr, form, implicit_const,
19216                                        info_ptr);
19217       break;
19218     case DW_FORM_implicit_const:
19219       DW_SND (attr) = implicit_const;
19220       break;
19221     case DW_FORM_GNU_addr_index:
19222       if (reader->dwo_file == NULL)
19223         {
19224           /* For now flag a hard error.
19225              Later we can turn this into a complaint.  */
19226           error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19227                  dwarf_form_name (form),
19228                  bfd_get_filename (abfd));
19229         }
19230       DW_ADDR (attr) = read_addr_index_from_leb128 (cu, info_ptr, &bytes_read);
19231       info_ptr += bytes_read;
19232       break;
19233     case DW_FORM_GNU_str_index:
19234       if (reader->dwo_file == NULL)
19235         {
19236           /* For now flag a hard error.
19237              Later we can turn this into a complaint if warranted.  */
19238           error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19239                  dwarf_form_name (form),
19240                  bfd_get_filename (abfd));
19241         }
19242       {
19243         ULONGEST str_index =
19244           read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19245
19246         DW_STRING (attr) = read_str_index (reader, str_index);
19247         DW_STRING_IS_CANONICAL (attr) = 0;
19248         info_ptr += bytes_read;
19249       }
19250       break;
19251     default:
19252       error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
19253              dwarf_form_name (form),
19254              bfd_get_filename (abfd));
19255     }
19256
19257   /* Super hack.  */
19258   if (cu->per_cu->is_dwz && attr_form_is_ref (attr))
19259     attr->form = DW_FORM_GNU_ref_alt;
19260
19261   /* We have seen instances where the compiler tried to emit a byte
19262      size attribute of -1 which ended up being encoded as an unsigned
19263      0xffffffff.  Although 0xffffffff is technically a valid size value,
19264      an object of this size seems pretty unlikely so we can relatively
19265      safely treat these cases as if the size attribute was invalid and
19266      treat them as zero by default.  */
19267   if (attr->name == DW_AT_byte_size
19268       && form == DW_FORM_data4
19269       && DW_UNSND (attr) >= 0xffffffff)
19270     {
19271       complaint
19272         (_("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
19273          hex_string (DW_UNSND (attr)));
19274       DW_UNSND (attr) = 0;
19275     }
19276
19277   return info_ptr;
19278 }
19279
19280 /* Read an attribute described by an abbreviated attribute.  */
19281
19282 static const gdb_byte *
19283 read_attribute (const struct die_reader_specs *reader,
19284                 struct attribute *attr, struct attr_abbrev *abbrev,
19285                 const gdb_byte *info_ptr)
19286 {
19287   attr->name = abbrev->name;
19288   return read_attribute_value (reader, attr, abbrev->form,
19289                                abbrev->implicit_const, info_ptr);
19290 }
19291
19292 /* Read dwarf information from a buffer.  */
19293
19294 static unsigned int
19295 read_1_byte (bfd *abfd, const gdb_byte *buf)
19296 {
19297   return bfd_get_8 (abfd, buf);
19298 }
19299
19300 static int
19301 read_1_signed_byte (bfd *abfd, const gdb_byte *buf)
19302 {
19303   return bfd_get_signed_8 (abfd, buf);
19304 }
19305
19306 static unsigned int
19307 read_2_bytes (bfd *abfd, const gdb_byte *buf)
19308 {
19309   return bfd_get_16 (abfd, buf);
19310 }
19311
19312 static int
19313 read_2_signed_bytes (bfd *abfd, const gdb_byte *buf)
19314 {
19315   return bfd_get_signed_16 (abfd, buf);
19316 }
19317
19318 static unsigned int
19319 read_4_bytes (bfd *abfd, const gdb_byte *buf)
19320 {
19321   return bfd_get_32 (abfd, buf);
19322 }
19323
19324 static int
19325 read_4_signed_bytes (bfd *abfd, const gdb_byte *buf)
19326 {
19327   return bfd_get_signed_32 (abfd, buf);
19328 }
19329
19330 static ULONGEST
19331 read_8_bytes (bfd *abfd, const gdb_byte *buf)
19332 {
19333   return bfd_get_64 (abfd, buf);
19334 }
19335
19336 static CORE_ADDR
19337 read_address (bfd *abfd, const gdb_byte *buf, struct dwarf2_cu *cu,
19338               unsigned int *bytes_read)
19339 {
19340   struct comp_unit_head *cu_header = &cu->header;
19341   CORE_ADDR retval = 0;
19342
19343   if (cu_header->signed_addr_p)
19344     {
19345       switch (cu_header->addr_size)
19346         {
19347         case 2:
19348           retval = bfd_get_signed_16 (abfd, buf);
19349           break;
19350         case 4:
19351           retval = bfd_get_signed_32 (abfd, buf);
19352           break;
19353         case 8:
19354           retval = bfd_get_signed_64 (abfd, buf);
19355           break;
19356         default:
19357           internal_error (__FILE__, __LINE__,
19358                           _("read_address: bad switch, signed [in module %s]"),
19359                           bfd_get_filename (abfd));
19360         }
19361     }
19362   else
19363     {
19364       switch (cu_header->addr_size)
19365         {
19366         case 2:
19367           retval = bfd_get_16 (abfd, buf);
19368           break;
19369         case 4:
19370           retval = bfd_get_32 (abfd, buf);
19371           break;
19372         case 8:
19373           retval = bfd_get_64 (abfd, buf);
19374           break;
19375         default:
19376           internal_error (__FILE__, __LINE__,
19377                           _("read_address: bad switch, "
19378                             "unsigned [in module %s]"),
19379                           bfd_get_filename (abfd));
19380         }
19381     }
19382
19383   *bytes_read = cu_header->addr_size;
19384   return retval;
19385 }
19386
19387 /* Read the initial length from a section.  The (draft) DWARF 3
19388    specification allows the initial length to take up either 4 bytes
19389    or 12 bytes.  If the first 4 bytes are 0xffffffff, then the next 8
19390    bytes describe the length and all offsets will be 8 bytes in length
19391    instead of 4.
19392
19393    An older, non-standard 64-bit format is also handled by this
19394    function.  The older format in question stores the initial length
19395    as an 8-byte quantity without an escape value.  Lengths greater
19396    than 2^32 aren't very common which means that the initial 4 bytes
19397    is almost always zero.  Since a length value of zero doesn't make
19398    sense for the 32-bit format, this initial zero can be considered to
19399    be an escape value which indicates the presence of the older 64-bit
19400    format.  As written, the code can't detect (old format) lengths
19401    greater than 4GB.  If it becomes necessary to handle lengths
19402    somewhat larger than 4GB, we could allow other small values (such
19403    as the non-sensical values of 1, 2, and 3) to also be used as
19404    escape values indicating the presence of the old format.
19405
19406    The value returned via bytes_read should be used to increment the
19407    relevant pointer after calling read_initial_length().
19408
19409    [ Note:  read_initial_length() and read_offset() are based on the
19410      document entitled "DWARF Debugging Information Format", revision
19411      3, draft 8, dated November 19, 2001.  This document was obtained
19412      from:
19413
19414         http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
19415
19416      This document is only a draft and is subject to change.  (So beware.)
19417
19418      Details regarding the older, non-standard 64-bit format were
19419      determined empirically by examining 64-bit ELF files produced by
19420      the SGI toolchain on an IRIX 6.5 machine.
19421
19422      - Kevin, July 16, 2002
19423    ] */
19424
19425 static LONGEST
19426 read_initial_length (bfd *abfd, const gdb_byte *buf, unsigned int *bytes_read)
19427 {
19428   LONGEST length = bfd_get_32 (abfd, buf);
19429
19430   if (length == 0xffffffff)
19431     {
19432       length = bfd_get_64 (abfd, buf + 4);
19433       *bytes_read = 12;
19434     }
19435   else if (length == 0)
19436     {
19437       /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX.  */
19438       length = bfd_get_64 (abfd, buf);
19439       *bytes_read = 8;
19440     }
19441   else
19442     {
19443       *bytes_read = 4;
19444     }
19445
19446   return length;
19447 }
19448
19449 /* Cover function for read_initial_length.
19450    Returns the length of the object at BUF, and stores the size of the
19451    initial length in *BYTES_READ and stores the size that offsets will be in
19452    *OFFSET_SIZE.
19453    If the initial length size is not equivalent to that specified in
19454    CU_HEADER then issue a complaint.
19455    This is useful when reading non-comp-unit headers.  */
19456
19457 static LONGEST
19458 read_checked_initial_length_and_offset (bfd *abfd, const gdb_byte *buf,
19459                                         const struct comp_unit_head *cu_header,
19460                                         unsigned int *bytes_read,
19461                                         unsigned int *offset_size)
19462 {
19463   LONGEST length = read_initial_length (abfd, buf, bytes_read);
19464
19465   gdb_assert (cu_header->initial_length_size == 4
19466               || cu_header->initial_length_size == 8
19467               || cu_header->initial_length_size == 12);
19468
19469   if (cu_header->initial_length_size != *bytes_read)
19470     complaint (_("intermixed 32-bit and 64-bit DWARF sections"));
19471
19472   *offset_size = (*bytes_read == 4) ? 4 : 8;
19473   return length;
19474 }
19475
19476 /* Read an offset from the data stream.  The size of the offset is
19477    given by cu_header->offset_size.  */
19478
19479 static LONGEST
19480 read_offset (bfd *abfd, const gdb_byte *buf,
19481              const struct comp_unit_head *cu_header,
19482              unsigned int *bytes_read)
19483 {
19484   LONGEST offset = read_offset_1 (abfd, buf, cu_header->offset_size);
19485
19486   *bytes_read = cu_header->offset_size;
19487   return offset;
19488 }
19489
19490 /* Read an offset from the data stream.  */
19491
19492 static LONGEST
19493 read_offset_1 (bfd *abfd, const gdb_byte *buf, unsigned int offset_size)
19494 {
19495   LONGEST retval = 0;
19496
19497   switch (offset_size)
19498     {
19499     case 4:
19500       retval = bfd_get_32 (abfd, buf);
19501       break;
19502     case 8:
19503       retval = bfd_get_64 (abfd, buf);
19504       break;
19505     default:
19506       internal_error (__FILE__, __LINE__,
19507                       _("read_offset_1: bad switch [in module %s]"),
19508                       bfd_get_filename (abfd));
19509     }
19510
19511   return retval;
19512 }
19513
19514 static const gdb_byte *
19515 read_n_bytes (bfd *abfd, const gdb_byte *buf, unsigned int size)
19516 {
19517   /* If the size of a host char is 8 bits, we can return a pointer
19518      to the buffer, otherwise we have to copy the data to a buffer
19519      allocated on the temporary obstack.  */
19520   gdb_assert (HOST_CHAR_BIT == 8);
19521   return buf;
19522 }
19523
19524 static const char *
19525 read_direct_string (bfd *abfd, const gdb_byte *buf,
19526                     unsigned int *bytes_read_ptr)
19527 {
19528   /* If the size of a host char is 8 bits, we can return a pointer
19529      to the string, otherwise we have to copy the string to a buffer
19530      allocated on the temporary obstack.  */
19531   gdb_assert (HOST_CHAR_BIT == 8);
19532   if (*buf == '\0')
19533     {
19534       *bytes_read_ptr = 1;
19535       return NULL;
19536     }
19537   *bytes_read_ptr = strlen ((const char *) buf) + 1;
19538   return (const char *) buf;
19539 }
19540
19541 /* Return pointer to string at section SECT offset STR_OFFSET with error
19542    reporting strings FORM_NAME and SECT_NAME.  */
19543
19544 static const char *
19545 read_indirect_string_at_offset_from (struct objfile *objfile,
19546                                      bfd *abfd, LONGEST str_offset,
19547                                      struct dwarf2_section_info *sect,
19548                                      const char *form_name,
19549                                      const char *sect_name)
19550 {
19551   dwarf2_read_section (objfile, sect);
19552   if (sect->buffer == NULL)
19553     error (_("%s used without %s section [in module %s]"),
19554            form_name, sect_name, bfd_get_filename (abfd));
19555   if (str_offset >= sect->size)
19556     error (_("%s pointing outside of %s section [in module %s]"),
19557            form_name, sect_name, bfd_get_filename (abfd));
19558   gdb_assert (HOST_CHAR_BIT == 8);
19559   if (sect->buffer[str_offset] == '\0')
19560     return NULL;
19561   return (const char *) (sect->buffer + str_offset);
19562 }
19563
19564 /* Return pointer to string at .debug_str offset STR_OFFSET.  */
19565
19566 static const char *
19567 read_indirect_string_at_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
19568                                 bfd *abfd, LONGEST str_offset)
19569 {
19570   return read_indirect_string_at_offset_from (dwarf2_per_objfile->objfile,
19571                                               abfd, str_offset,
19572                                               &dwarf2_per_objfile->str,
19573                                               "DW_FORM_strp", ".debug_str");
19574 }
19575
19576 /* Return pointer to string at .debug_line_str offset STR_OFFSET.  */
19577
19578 static const char *
19579 read_indirect_line_string_at_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
19580                                      bfd *abfd, LONGEST str_offset)
19581 {
19582   return read_indirect_string_at_offset_from (dwarf2_per_objfile->objfile,
19583                                               abfd, str_offset,
19584                                               &dwarf2_per_objfile->line_str,
19585                                               "DW_FORM_line_strp",
19586                                               ".debug_line_str");
19587 }
19588
19589 /* Read a string at offset STR_OFFSET in the .debug_str section from
19590    the .dwz file DWZ.  Throw an error if the offset is too large.  If
19591    the string consists of a single NUL byte, return NULL; otherwise
19592    return a pointer to the string.  */
19593
19594 static const char *
19595 read_indirect_string_from_dwz (struct objfile *objfile, struct dwz_file *dwz,
19596                                LONGEST str_offset)
19597 {
19598   dwarf2_read_section (objfile, &dwz->str);
19599
19600   if (dwz->str.buffer == NULL)
19601     error (_("DW_FORM_GNU_strp_alt used without .debug_str "
19602              "section [in module %s]"),
19603            bfd_get_filename (dwz->dwz_bfd));
19604   if (str_offset >= dwz->str.size)
19605     error (_("DW_FORM_GNU_strp_alt pointing outside of "
19606              ".debug_str section [in module %s]"),
19607            bfd_get_filename (dwz->dwz_bfd));
19608   gdb_assert (HOST_CHAR_BIT == 8);
19609   if (dwz->str.buffer[str_offset] == '\0')
19610     return NULL;
19611   return (const char *) (dwz->str.buffer + str_offset);
19612 }
19613
19614 /* Return pointer to string at .debug_str offset as read from BUF.
19615    BUF is assumed to be in a compilation unit described by CU_HEADER.
19616    Return *BYTES_READ_PTR count of bytes read from BUF.  */
19617
19618 static const char *
19619 read_indirect_string (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *abfd,
19620                       const gdb_byte *buf,
19621                       const struct comp_unit_head *cu_header,
19622                       unsigned int *bytes_read_ptr)
19623 {
19624   LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
19625
19626   return read_indirect_string_at_offset (dwarf2_per_objfile, abfd, str_offset);
19627 }
19628
19629 /* Return pointer to string at .debug_line_str offset as read from BUF.
19630    BUF is assumed to be in a compilation unit described by CU_HEADER.
19631    Return *BYTES_READ_PTR count of bytes read from BUF.  */
19632
19633 static const char *
19634 read_indirect_line_string (struct dwarf2_per_objfile *dwarf2_per_objfile,
19635                            bfd *abfd, const gdb_byte *buf,
19636                            const struct comp_unit_head *cu_header,
19637                            unsigned int *bytes_read_ptr)
19638 {
19639   LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
19640
19641   return read_indirect_line_string_at_offset (dwarf2_per_objfile, abfd,
19642                                               str_offset);
19643 }
19644
19645 ULONGEST
19646 read_unsigned_leb128 (bfd *abfd, const gdb_byte *buf,
19647                           unsigned int *bytes_read_ptr)
19648 {
19649   ULONGEST result;
19650   unsigned int num_read;
19651   int shift;
19652   unsigned char byte;
19653
19654   result = 0;
19655   shift = 0;
19656   num_read = 0;
19657   while (1)
19658     {
19659       byte = bfd_get_8 (abfd, buf);
19660       buf++;
19661       num_read++;
19662       result |= ((ULONGEST) (byte & 127) << shift);
19663       if ((byte & 128) == 0)
19664         {
19665           break;
19666         }
19667       shift += 7;
19668     }
19669   *bytes_read_ptr = num_read;
19670   return result;
19671 }
19672
19673 static LONGEST
19674 read_signed_leb128 (bfd *abfd, const gdb_byte *buf,
19675                     unsigned int *bytes_read_ptr)
19676 {
19677   ULONGEST result;
19678   int shift, num_read;
19679   unsigned char byte;
19680
19681   result = 0;
19682   shift = 0;
19683   num_read = 0;
19684   while (1)
19685     {
19686       byte = bfd_get_8 (abfd, buf);
19687       buf++;
19688       num_read++;
19689       result |= ((ULONGEST) (byte & 127) << shift);
19690       shift += 7;
19691       if ((byte & 128) == 0)
19692         {
19693           break;
19694         }
19695     }
19696   if ((shift < 8 * sizeof (result)) && (byte & 0x40))
19697     result |= -(((ULONGEST) 1) << shift);
19698   *bytes_read_ptr = num_read;
19699   return result;
19700 }
19701
19702 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
19703    ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
19704    ADDR_SIZE is the size of addresses from the CU header.  */
19705
19706 static CORE_ADDR
19707 read_addr_index_1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
19708                    unsigned int addr_index, ULONGEST addr_base, int addr_size)
19709 {
19710   struct objfile *objfile = dwarf2_per_objfile->objfile;
19711   bfd *abfd = objfile->obfd;
19712   const gdb_byte *info_ptr;
19713
19714   dwarf2_read_section (objfile, &dwarf2_per_objfile->addr);
19715   if (dwarf2_per_objfile->addr.buffer == NULL)
19716     error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
19717            objfile_name (objfile));
19718   if (addr_base + addr_index * addr_size >= dwarf2_per_objfile->addr.size)
19719     error (_("DW_FORM_addr_index pointing outside of "
19720              ".debug_addr section [in module %s]"),
19721            objfile_name (objfile));
19722   info_ptr = (dwarf2_per_objfile->addr.buffer
19723               + addr_base + addr_index * addr_size);
19724   if (addr_size == 4)
19725     return bfd_get_32 (abfd, info_ptr);
19726   else
19727     return bfd_get_64 (abfd, info_ptr);
19728 }
19729
19730 /* Given index ADDR_INDEX in .debug_addr, fetch the value.  */
19731
19732 static CORE_ADDR
19733 read_addr_index (struct dwarf2_cu *cu, unsigned int addr_index)
19734 {
19735   return read_addr_index_1 (cu->per_cu->dwarf2_per_objfile, addr_index,
19736                             cu->addr_base, cu->header.addr_size);
19737 }
19738
19739 /* Given a pointer to an leb128 value, fetch the value from .debug_addr.  */
19740
19741 static CORE_ADDR
19742 read_addr_index_from_leb128 (struct dwarf2_cu *cu, const gdb_byte *info_ptr,
19743                              unsigned int *bytes_read)
19744 {
19745   bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
19746   unsigned int addr_index = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
19747
19748   return read_addr_index (cu, addr_index);
19749 }
19750
19751 /* Data structure to pass results from dwarf2_read_addr_index_reader
19752    back to dwarf2_read_addr_index.  */
19753
19754 struct dwarf2_read_addr_index_data
19755 {
19756   ULONGEST addr_base;
19757   int addr_size;
19758 };
19759
19760 /* die_reader_func for dwarf2_read_addr_index.  */
19761
19762 static void
19763 dwarf2_read_addr_index_reader (const struct die_reader_specs *reader,
19764                                const gdb_byte *info_ptr,
19765                                struct die_info *comp_unit_die,
19766                                int has_children,
19767                                void *data)
19768 {
19769   struct dwarf2_cu *cu = reader->cu;
19770   struct dwarf2_read_addr_index_data *aidata =
19771     (struct dwarf2_read_addr_index_data *) data;
19772
19773   aidata->addr_base = cu->addr_base;
19774   aidata->addr_size = cu->header.addr_size;
19775 }
19776
19777 /* Given an index in .debug_addr, fetch the value.
19778    NOTE: This can be called during dwarf expression evaluation,
19779    long after the debug information has been read, and thus per_cu->cu
19780    may no longer exist.  */
19781
19782 CORE_ADDR
19783 dwarf2_read_addr_index (struct dwarf2_per_cu_data *per_cu,
19784                         unsigned int addr_index)
19785 {
19786   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
19787   struct dwarf2_cu *cu = per_cu->cu;
19788   ULONGEST addr_base;
19789   int addr_size;
19790
19791   /* We need addr_base and addr_size.
19792      If we don't have PER_CU->cu, we have to get it.
19793      Nasty, but the alternative is storing the needed info in PER_CU,
19794      which at this point doesn't seem justified: it's not clear how frequently
19795      it would get used and it would increase the size of every PER_CU.
19796      Entry points like dwarf2_per_cu_addr_size do a similar thing
19797      so we're not in uncharted territory here.
19798      Alas we need to be a bit more complicated as addr_base is contained
19799      in the DIE.
19800
19801      We don't need to read the entire CU(/TU).
19802      We just need the header and top level die.
19803
19804      IWBN to use the aging mechanism to let us lazily later discard the CU.
19805      For now we skip this optimization.  */
19806
19807   if (cu != NULL)
19808     {
19809       addr_base = cu->addr_base;
19810       addr_size = cu->header.addr_size;
19811     }
19812   else
19813     {
19814       struct dwarf2_read_addr_index_data aidata;
19815
19816       /* Note: We can't use init_cutu_and_read_dies_simple here,
19817          we need addr_base.  */
19818       init_cutu_and_read_dies (per_cu, NULL, 0, 0, false,
19819                                dwarf2_read_addr_index_reader, &aidata);
19820       addr_base = aidata.addr_base;
19821       addr_size = aidata.addr_size;
19822     }
19823
19824   return read_addr_index_1 (dwarf2_per_objfile, addr_index, addr_base,
19825                             addr_size);
19826 }
19827
19828 /* Given a DW_FORM_GNU_str_index, fetch the string.
19829    This is only used by the Fission support.  */
19830
19831 static const char *
19832 read_str_index (const struct die_reader_specs *reader, ULONGEST str_index)
19833 {
19834   struct dwarf2_cu *cu = reader->cu;
19835   struct dwarf2_per_objfile *dwarf2_per_objfile
19836     = cu->per_cu->dwarf2_per_objfile;
19837   struct objfile *objfile = dwarf2_per_objfile->objfile;
19838   const char *objf_name = objfile_name (objfile);
19839   bfd *abfd = objfile->obfd;
19840   struct dwarf2_section_info *str_section = &reader->dwo_file->sections.str;
19841   struct dwarf2_section_info *str_offsets_section =
19842     &reader->dwo_file->sections.str_offsets;
19843   const gdb_byte *info_ptr;
19844   ULONGEST str_offset;
19845   static const char form_name[] = "DW_FORM_GNU_str_index";
19846
19847   dwarf2_read_section (objfile, str_section);
19848   dwarf2_read_section (objfile, str_offsets_section);
19849   if (str_section->buffer == NULL)
19850     error (_("%s used without .debug_str.dwo section"
19851              " in CU at offset %s [in module %s]"),
19852            form_name, sect_offset_str (cu->header.sect_off), objf_name);
19853   if (str_offsets_section->buffer == NULL)
19854     error (_("%s used without .debug_str_offsets.dwo section"
19855              " in CU at offset %s [in module %s]"),
19856            form_name, sect_offset_str (cu->header.sect_off), objf_name);
19857   if (str_index * cu->header.offset_size >= str_offsets_section->size)
19858     error (_("%s pointing outside of .debug_str_offsets.dwo"
19859              " section in CU at offset %s [in module %s]"),
19860            form_name, sect_offset_str (cu->header.sect_off), objf_name);
19861   info_ptr = (str_offsets_section->buffer
19862               + str_index * cu->header.offset_size);
19863   if (cu->header.offset_size == 4)
19864     str_offset = bfd_get_32 (abfd, info_ptr);
19865   else
19866     str_offset = bfd_get_64 (abfd, info_ptr);
19867   if (str_offset >= str_section->size)
19868     error (_("Offset from %s pointing outside of"
19869              " .debug_str.dwo section in CU at offset %s [in module %s]"),
19870            form_name, sect_offset_str (cu->header.sect_off), objf_name);
19871   return (const char *) (str_section->buffer + str_offset);
19872 }
19873
19874 /* Return the length of an LEB128 number in BUF.  */
19875
19876 static int
19877 leb128_size (const gdb_byte *buf)
19878 {
19879   const gdb_byte *begin = buf;
19880   gdb_byte byte;
19881
19882   while (1)
19883     {
19884       byte = *buf++;
19885       if ((byte & 128) == 0)
19886         return buf - begin;
19887     }
19888 }
19889
19890 static void
19891 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
19892 {
19893   switch (lang)
19894     {
19895     case DW_LANG_C89:
19896     case DW_LANG_C99:
19897     case DW_LANG_C11:
19898     case DW_LANG_C:
19899     case DW_LANG_UPC:
19900       cu->language = language_c;
19901       break;
19902     case DW_LANG_Java:
19903     case DW_LANG_C_plus_plus:
19904     case DW_LANG_C_plus_plus_11:
19905     case DW_LANG_C_plus_plus_14:
19906       cu->language = language_cplus;
19907       break;
19908     case DW_LANG_D:
19909       cu->language = language_d;
19910       break;
19911     case DW_LANG_Fortran77:
19912     case DW_LANG_Fortran90:
19913     case DW_LANG_Fortran95:
19914     case DW_LANG_Fortran03:
19915     case DW_LANG_Fortran08:
19916       cu->language = language_fortran;
19917       break;
19918     case DW_LANG_Go:
19919       cu->language = language_go;
19920       break;
19921     case DW_LANG_Mips_Assembler:
19922       cu->language = language_asm;
19923       break;
19924     case DW_LANG_Ada83:
19925     case DW_LANG_Ada95:
19926       cu->language = language_ada;
19927       break;
19928     case DW_LANG_Modula2:
19929       cu->language = language_m2;
19930       break;
19931     case DW_LANG_Pascal83:
19932       cu->language = language_pascal;
19933       break;
19934     case DW_LANG_ObjC:
19935       cu->language = language_objc;
19936       break;
19937     case DW_LANG_Rust:
19938     case DW_LANG_Rust_old:
19939       cu->language = language_rust;
19940       break;
19941     case DW_LANG_Cobol74:
19942     case DW_LANG_Cobol85:
19943     default:
19944       cu->language = language_minimal;
19945       break;
19946     }
19947   cu->language_defn = language_def (cu->language);
19948 }
19949
19950 /* Return the named attribute or NULL if not there.  */
19951
19952 static struct attribute *
19953 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
19954 {
19955   for (;;)
19956     {
19957       unsigned int i;
19958       struct attribute *spec = NULL;
19959
19960       for (i = 0; i < die->num_attrs; ++i)
19961         {
19962           if (die->attrs[i].name == name)
19963             return &die->attrs[i];
19964           if (die->attrs[i].name == DW_AT_specification
19965               || die->attrs[i].name == DW_AT_abstract_origin)
19966             spec = &die->attrs[i];
19967         }
19968
19969       if (!spec)
19970         break;
19971
19972       die = follow_die_ref (die, spec, &cu);
19973     }
19974
19975   return NULL;
19976 }
19977
19978 /* Return the named attribute or NULL if not there,
19979    but do not follow DW_AT_specification, etc.
19980    This is for use in contexts where we're reading .debug_types dies.
19981    Following DW_AT_specification, DW_AT_abstract_origin will take us
19982    back up the chain, and we want to go down.  */
19983
19984 static struct attribute *
19985 dwarf2_attr_no_follow (struct die_info *die, unsigned int name)
19986 {
19987   unsigned int i;
19988
19989   for (i = 0; i < die->num_attrs; ++i)
19990     if (die->attrs[i].name == name)
19991       return &die->attrs[i];
19992
19993   return NULL;
19994 }
19995
19996 /* Return the string associated with a string-typed attribute, or NULL if it
19997    is either not found or is of an incorrect type.  */
19998
19999 static const char *
20000 dwarf2_string_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
20001 {
20002   struct attribute *attr;
20003   const char *str = NULL;
20004
20005   attr = dwarf2_attr (die, name, cu);
20006
20007   if (attr != NULL)
20008     {
20009       if (attr->form == DW_FORM_strp || attr->form == DW_FORM_line_strp
20010           || attr->form == DW_FORM_string
20011           || attr->form == DW_FORM_GNU_str_index
20012           || attr->form == DW_FORM_GNU_strp_alt)
20013         str = DW_STRING (attr);
20014       else
20015         complaint (_("string type expected for attribute %s for "
20016                      "DIE at %s in module %s"),
20017                    dwarf_attr_name (name), sect_offset_str (die->sect_off),
20018                    objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
20019     }
20020
20021   return str;
20022 }
20023
20024 /* Return non-zero iff the attribute NAME is defined for the given DIE,
20025    and holds a non-zero value.  This function should only be used for
20026    DW_FORM_flag or DW_FORM_flag_present attributes.  */
20027
20028 static int
20029 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
20030 {
20031   struct attribute *attr = dwarf2_attr (die, name, cu);
20032
20033   return (attr && DW_UNSND (attr));
20034 }
20035
20036 static int
20037 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
20038 {
20039   /* A DIE is a declaration if it has a DW_AT_declaration attribute
20040      which value is non-zero.  However, we have to be careful with
20041      DIEs having a DW_AT_specification attribute, because dwarf2_attr()
20042      (via dwarf2_flag_true_p) follows this attribute.  So we may
20043      end up accidently finding a declaration attribute that belongs
20044      to a different DIE referenced by the specification attribute,
20045      even though the given DIE does not have a declaration attribute.  */
20046   return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
20047           && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
20048 }
20049
20050 /* Return the die giving the specification for DIE, if there is
20051    one.  *SPEC_CU is the CU containing DIE on input, and the CU
20052    containing the return value on output.  If there is no
20053    specification, but there is an abstract origin, that is
20054    returned.  */
20055
20056 static struct die_info *
20057 die_specification (struct die_info *die, struct dwarf2_cu **spec_cu)
20058 {
20059   struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification,
20060                                              *spec_cu);
20061
20062   if (spec_attr == NULL)
20063     spec_attr = dwarf2_attr (die, DW_AT_abstract_origin, *spec_cu);
20064
20065   if (spec_attr == NULL)
20066     return NULL;
20067   else
20068     return follow_die_ref (die, spec_attr, spec_cu);
20069 }
20070
20071 /* Stub for free_line_header to match void * callback types.  */
20072
20073 static void
20074 free_line_header_voidp (void *arg)
20075 {
20076   struct line_header *lh = (struct line_header *) arg;
20077
20078   delete lh;
20079 }
20080
20081 void
20082 line_header::add_include_dir (const char *include_dir)
20083 {
20084   if (dwarf_line_debug >= 2)
20085     fprintf_unfiltered (gdb_stdlog, "Adding dir %zu: %s\n",
20086                         include_dirs.size () + 1, include_dir);
20087
20088   include_dirs.push_back (include_dir);
20089 }
20090
20091 void
20092 line_header::add_file_name (const char *name,
20093                             dir_index d_index,
20094                             unsigned int mod_time,
20095                             unsigned int length)
20096 {
20097   if (dwarf_line_debug >= 2)
20098     fprintf_unfiltered (gdb_stdlog, "Adding file %u: %s\n",
20099                         (unsigned) file_names.size () + 1, name);
20100
20101   file_names.emplace_back (name, d_index, mod_time, length);
20102 }
20103
20104 /* A convenience function to find the proper .debug_line section for a CU.  */
20105
20106 static struct dwarf2_section_info *
20107 get_debug_line_section (struct dwarf2_cu *cu)
20108 {
20109   struct dwarf2_section_info *section;
20110   struct dwarf2_per_objfile *dwarf2_per_objfile
20111     = cu->per_cu->dwarf2_per_objfile;
20112
20113   /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
20114      DWO file.  */
20115   if (cu->dwo_unit && cu->per_cu->is_debug_types)
20116     section = &cu->dwo_unit->dwo_file->sections.line;
20117   else if (cu->per_cu->is_dwz)
20118     {
20119       struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
20120
20121       section = &dwz->line;
20122     }
20123   else
20124     section = &dwarf2_per_objfile->line;
20125
20126   return section;
20127 }
20128
20129 /* Read directory or file name entry format, starting with byte of
20130    format count entries, ULEB128 pairs of entry formats, ULEB128 of
20131    entries count and the entries themselves in the described entry
20132    format.  */
20133
20134 static void
20135 read_formatted_entries (struct dwarf2_per_objfile *dwarf2_per_objfile,
20136                         bfd *abfd, const gdb_byte **bufp,
20137                         struct line_header *lh,
20138                         const struct comp_unit_head *cu_header,
20139                         void (*callback) (struct line_header *lh,
20140                                           const char *name,
20141                                           dir_index d_index,
20142                                           unsigned int mod_time,
20143                                           unsigned int length))
20144 {
20145   gdb_byte format_count, formati;
20146   ULONGEST data_count, datai;
20147   const gdb_byte *buf = *bufp;
20148   const gdb_byte *format_header_data;
20149   unsigned int bytes_read;
20150
20151   format_count = read_1_byte (abfd, buf);
20152   buf += 1;
20153   format_header_data = buf;
20154   for (formati = 0; formati < format_count; formati++)
20155     {
20156       read_unsigned_leb128 (abfd, buf, &bytes_read);
20157       buf += bytes_read;
20158       read_unsigned_leb128 (abfd, buf, &bytes_read);
20159       buf += bytes_read;
20160     }
20161
20162   data_count = read_unsigned_leb128 (abfd, buf, &bytes_read);
20163   buf += bytes_read;
20164   for (datai = 0; datai < data_count; datai++)
20165     {
20166       const gdb_byte *format = format_header_data;
20167       struct file_entry fe;
20168
20169       for (formati = 0; formati < format_count; formati++)
20170         {
20171           ULONGEST content_type = read_unsigned_leb128 (abfd, format, &bytes_read);
20172           format += bytes_read;
20173
20174           ULONGEST form  = read_unsigned_leb128 (abfd, format, &bytes_read);
20175           format += bytes_read;
20176
20177           gdb::optional<const char *> string;
20178           gdb::optional<unsigned int> uint;
20179
20180           switch (form)
20181             {
20182             case DW_FORM_string:
20183               string.emplace (read_direct_string (abfd, buf, &bytes_read));
20184               buf += bytes_read;
20185               break;
20186
20187             case DW_FORM_line_strp:
20188               string.emplace (read_indirect_line_string (dwarf2_per_objfile,
20189                                                          abfd, buf,
20190                                                          cu_header,
20191                                                          &bytes_read));
20192               buf += bytes_read;
20193               break;
20194
20195             case DW_FORM_data1:
20196               uint.emplace (read_1_byte (abfd, buf));
20197               buf += 1;
20198               break;
20199
20200             case DW_FORM_data2:
20201               uint.emplace (read_2_bytes (abfd, buf));
20202               buf += 2;
20203               break;
20204
20205             case DW_FORM_data4:
20206               uint.emplace (read_4_bytes (abfd, buf));
20207               buf += 4;
20208               break;
20209
20210             case DW_FORM_data8:
20211               uint.emplace (read_8_bytes (abfd, buf));
20212               buf += 8;
20213               break;
20214
20215             case DW_FORM_udata:
20216               uint.emplace (read_unsigned_leb128 (abfd, buf, &bytes_read));
20217               buf += bytes_read;
20218               break;
20219
20220             case DW_FORM_block:
20221               /* It is valid only for DW_LNCT_timestamp which is ignored by
20222                  current GDB.  */
20223               break;
20224             }
20225
20226           switch (content_type)
20227             {
20228             case DW_LNCT_path:
20229               if (string.has_value ())
20230                 fe.name = *string;
20231               break;
20232             case DW_LNCT_directory_index:
20233               if (uint.has_value ())
20234                 fe.d_index = (dir_index) *uint;
20235               break;
20236             case DW_LNCT_timestamp:
20237               if (uint.has_value ())
20238                 fe.mod_time = *uint;
20239               break;
20240             case DW_LNCT_size:
20241               if (uint.has_value ())
20242                 fe.length = *uint;
20243               break;
20244             case DW_LNCT_MD5:
20245               break;
20246             default:
20247               complaint (_("Unknown format content type %s"),
20248                          pulongest (content_type));
20249             }
20250         }
20251
20252       callback (lh, fe.name, fe.d_index, fe.mod_time, fe.length);
20253     }
20254
20255   *bufp = buf;
20256 }
20257
20258 /* Read the statement program header starting at OFFSET in
20259    .debug_line, or .debug_line.dwo.  Return a pointer
20260    to a struct line_header, allocated using xmalloc.
20261    Returns NULL if there is a problem reading the header, e.g., if it
20262    has a version we don't understand.
20263
20264    NOTE: the strings in the include directory and file name tables of
20265    the returned object point into the dwarf line section buffer,
20266    and must not be freed.  */
20267
20268 static line_header_up
20269 dwarf_decode_line_header (sect_offset sect_off, struct dwarf2_cu *cu)
20270 {
20271   const gdb_byte *line_ptr;
20272   unsigned int bytes_read, offset_size;
20273   int i;
20274   const char *cur_dir, *cur_file;
20275   struct dwarf2_section_info *section;
20276   bfd *abfd;
20277   struct dwarf2_per_objfile *dwarf2_per_objfile
20278     = cu->per_cu->dwarf2_per_objfile;
20279
20280   section = get_debug_line_section (cu);
20281   dwarf2_read_section (dwarf2_per_objfile->objfile, section);
20282   if (section->buffer == NULL)
20283     {
20284       if (cu->dwo_unit && cu->per_cu->is_debug_types)
20285         complaint (_("missing .debug_line.dwo section"));
20286       else
20287         complaint (_("missing .debug_line section"));
20288       return 0;
20289     }
20290
20291   /* We can't do this until we know the section is non-empty.
20292      Only then do we know we have such a section.  */
20293   abfd = get_section_bfd_owner (section);
20294
20295   /* Make sure that at least there's room for the total_length field.
20296      That could be 12 bytes long, but we're just going to fudge that.  */
20297   if (to_underlying (sect_off) + 4 >= section->size)
20298     {
20299       dwarf2_statement_list_fits_in_line_number_section_complaint ();
20300       return 0;
20301     }
20302
20303   line_header_up lh (new line_header ());
20304
20305   lh->sect_off = sect_off;
20306   lh->offset_in_dwz = cu->per_cu->is_dwz;
20307
20308   line_ptr = section->buffer + to_underlying (sect_off);
20309
20310   /* Read in the header.  */
20311   lh->total_length =
20312     read_checked_initial_length_and_offset (abfd, line_ptr, &cu->header,
20313                                             &bytes_read, &offset_size);
20314   line_ptr += bytes_read;
20315   if (line_ptr + lh->total_length > (section->buffer + section->size))
20316     {
20317       dwarf2_statement_list_fits_in_line_number_section_complaint ();
20318       return 0;
20319     }
20320   lh->statement_program_end = line_ptr + lh->total_length;
20321   lh->version = read_2_bytes (abfd, line_ptr);
20322   line_ptr += 2;
20323   if (lh->version > 5)
20324     {
20325       /* This is a version we don't understand.  The format could have
20326          changed in ways we don't handle properly so just punt.  */
20327       complaint (_("unsupported version in .debug_line section"));
20328       return NULL;
20329     }
20330   if (lh->version >= 5)
20331     {
20332       gdb_byte segment_selector_size;
20333
20334       /* Skip address size.  */
20335       read_1_byte (abfd, line_ptr);
20336       line_ptr += 1;
20337
20338       segment_selector_size = read_1_byte (abfd, line_ptr);
20339       line_ptr += 1;
20340       if (segment_selector_size != 0)
20341         {
20342           complaint (_("unsupported segment selector size %u "
20343                        "in .debug_line section"),
20344                      segment_selector_size);
20345           return NULL;
20346         }
20347     }
20348   lh->header_length = read_offset_1 (abfd, line_ptr, offset_size);
20349   line_ptr += offset_size;
20350   lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
20351   line_ptr += 1;
20352   if (lh->version >= 4)
20353     {
20354       lh->maximum_ops_per_instruction = read_1_byte (abfd, line_ptr);
20355       line_ptr += 1;
20356     }
20357   else
20358     lh->maximum_ops_per_instruction = 1;
20359
20360   if (lh->maximum_ops_per_instruction == 0)
20361     {
20362       lh->maximum_ops_per_instruction = 1;
20363       complaint (_("invalid maximum_ops_per_instruction "
20364                    "in `.debug_line' section"));
20365     }
20366
20367   lh->default_is_stmt = read_1_byte (abfd, line_ptr);
20368   line_ptr += 1;
20369   lh->line_base = read_1_signed_byte (abfd, line_ptr);
20370   line_ptr += 1;
20371   lh->line_range = read_1_byte (abfd, line_ptr);
20372   line_ptr += 1;
20373   lh->opcode_base = read_1_byte (abfd, line_ptr);
20374   line_ptr += 1;
20375   lh->standard_opcode_lengths.reset (new unsigned char[lh->opcode_base]);
20376
20377   lh->standard_opcode_lengths[0] = 1;  /* This should never be used anyway.  */
20378   for (i = 1; i < lh->opcode_base; ++i)
20379     {
20380       lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
20381       line_ptr += 1;
20382     }
20383
20384   if (lh->version >= 5)
20385     {
20386       /* Read directory table.  */
20387       read_formatted_entries (dwarf2_per_objfile, abfd, &line_ptr, lh.get (),
20388                               &cu->header,
20389                               [] (struct line_header *header, const char *name,
20390                                   dir_index d_index, unsigned int mod_time,
20391                                   unsigned int length)
20392         {
20393           header->add_include_dir (name);
20394         });
20395
20396       /* Read file name table.  */
20397       read_formatted_entries (dwarf2_per_objfile, abfd, &line_ptr, lh.get (),
20398                               &cu->header,
20399                               [] (struct line_header *header, const char *name,
20400                                   dir_index d_index, unsigned int mod_time,
20401                                   unsigned int length)
20402         {
20403           header->add_file_name (name, d_index, mod_time, length);
20404         });
20405     }
20406   else
20407     {
20408       /* Read directory table.  */
20409       while ((cur_dir = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
20410         {
20411           line_ptr += bytes_read;
20412           lh->add_include_dir (cur_dir);
20413         }
20414       line_ptr += bytes_read;
20415
20416       /* Read file name table.  */
20417       while ((cur_file = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
20418         {
20419           unsigned int mod_time, length;
20420           dir_index d_index;
20421
20422           line_ptr += bytes_read;
20423           d_index = (dir_index) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20424           line_ptr += bytes_read;
20425           mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20426           line_ptr += bytes_read;
20427           length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20428           line_ptr += bytes_read;
20429
20430           lh->add_file_name (cur_file, d_index, mod_time, length);
20431         }
20432       line_ptr += bytes_read;
20433     }
20434   lh->statement_program_start = line_ptr;
20435
20436   if (line_ptr > (section->buffer + section->size))
20437     complaint (_("line number info header doesn't "
20438                  "fit in `.debug_line' section"));
20439
20440   return lh;
20441 }
20442
20443 /* Subroutine of dwarf_decode_lines to simplify it.
20444    Return the file name of the psymtab for included file FILE_INDEX
20445    in line header LH of PST.
20446    COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
20447    If space for the result is malloc'd, *NAME_HOLDER will be set.
20448    Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename.  */
20449
20450 static const char *
20451 psymtab_include_file_name (const struct line_header *lh, int file_index,
20452                            const struct partial_symtab *pst,
20453                            const char *comp_dir,
20454                            gdb::unique_xmalloc_ptr<char> *name_holder)
20455 {
20456   const file_entry &fe = lh->file_names[file_index];
20457   const char *include_name = fe.name;
20458   const char *include_name_to_compare = include_name;
20459   const char *pst_filename;
20460   int file_is_pst;
20461
20462   const char *dir_name = fe.include_dir (lh);
20463
20464   gdb::unique_xmalloc_ptr<char> hold_compare;
20465   if (!IS_ABSOLUTE_PATH (include_name)
20466       && (dir_name != NULL || comp_dir != NULL))
20467     {
20468       /* Avoid creating a duplicate psymtab for PST.
20469          We do this by comparing INCLUDE_NAME and PST_FILENAME.
20470          Before we do the comparison, however, we need to account
20471          for DIR_NAME and COMP_DIR.
20472          First prepend dir_name (if non-NULL).  If we still don't
20473          have an absolute path prepend comp_dir (if non-NULL).
20474          However, the directory we record in the include-file's
20475          psymtab does not contain COMP_DIR (to match the
20476          corresponding symtab(s)).
20477
20478          Example:
20479
20480          bash$ cd /tmp
20481          bash$ gcc -g ./hello.c
20482          include_name = "hello.c"
20483          dir_name = "."
20484          DW_AT_comp_dir = comp_dir = "/tmp"
20485          DW_AT_name = "./hello.c"
20486
20487       */
20488
20489       if (dir_name != NULL)
20490         {
20491           name_holder->reset (concat (dir_name, SLASH_STRING,
20492                                       include_name, (char *) NULL));
20493           include_name = name_holder->get ();
20494           include_name_to_compare = include_name;
20495         }
20496       if (!IS_ABSOLUTE_PATH (include_name) && comp_dir != NULL)
20497         {
20498           hold_compare.reset (concat (comp_dir, SLASH_STRING,
20499                                       include_name, (char *) NULL));
20500           include_name_to_compare = hold_compare.get ();
20501         }
20502     }
20503
20504   pst_filename = pst->filename;
20505   gdb::unique_xmalloc_ptr<char> copied_name;
20506   if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
20507     {
20508       copied_name.reset (concat (pst->dirname, SLASH_STRING,
20509                                  pst_filename, (char *) NULL));
20510       pst_filename = copied_name.get ();
20511     }
20512
20513   file_is_pst = FILENAME_CMP (include_name_to_compare, pst_filename) == 0;
20514
20515   if (file_is_pst)
20516     return NULL;
20517   return include_name;
20518 }
20519
20520 /* State machine to track the state of the line number program.  */
20521
20522 class lnp_state_machine
20523 {
20524 public:
20525   /* Initialize a machine state for the start of a line number
20526      program.  */
20527   lnp_state_machine (struct dwarf2_cu *cu, gdbarch *arch, line_header *lh,
20528                      bool record_lines_p);
20529
20530   file_entry *current_file ()
20531   {
20532     /* lh->file_names is 0-based, but the file name numbers in the
20533        statement program are 1-based.  */
20534     return m_line_header->file_name_at (m_file);
20535   }
20536
20537   /* Record the line in the state machine.  END_SEQUENCE is true if
20538      we're processing the end of a sequence.  */
20539   void record_line (bool end_sequence);
20540
20541   /* Check ADDRESS is zero and less than UNRELOCATED_LOWPC and if true
20542      nop-out rest of the lines in this sequence.  */
20543   void check_line_address (struct dwarf2_cu *cu,
20544                            const gdb_byte *line_ptr,
20545                            CORE_ADDR unrelocated_lowpc, CORE_ADDR address);
20546
20547   void handle_set_discriminator (unsigned int discriminator)
20548   {
20549     m_discriminator = discriminator;
20550     m_line_has_non_zero_discriminator |= discriminator != 0;
20551   }
20552
20553   /* Handle DW_LNE_set_address.  */
20554   void handle_set_address (CORE_ADDR baseaddr, CORE_ADDR address)
20555   {
20556     m_op_index = 0;
20557     address += baseaddr;
20558     m_address = gdbarch_adjust_dwarf2_line (m_gdbarch, address, false);
20559   }
20560
20561   /* Handle DW_LNS_advance_pc.  */
20562   void handle_advance_pc (CORE_ADDR adjust);
20563
20564   /* Handle a special opcode.  */
20565   void handle_special_opcode (unsigned char op_code);
20566
20567   /* Handle DW_LNS_advance_line.  */
20568   void handle_advance_line (int line_delta)
20569   {
20570     advance_line (line_delta);
20571   }
20572
20573   /* Handle DW_LNS_set_file.  */
20574   void handle_set_file (file_name_index file);
20575
20576   /* Handle DW_LNS_negate_stmt.  */
20577   void handle_negate_stmt ()
20578   {
20579     m_is_stmt = !m_is_stmt;
20580   }
20581
20582   /* Handle DW_LNS_const_add_pc.  */
20583   void handle_const_add_pc ();
20584
20585   /* Handle DW_LNS_fixed_advance_pc.  */
20586   void handle_fixed_advance_pc (CORE_ADDR addr_adj)
20587   {
20588     m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20589     m_op_index = 0;
20590   }
20591
20592   /* Handle DW_LNS_copy.  */
20593   void handle_copy ()
20594   {
20595     record_line (false);
20596     m_discriminator = 0;
20597   }
20598
20599   /* Handle DW_LNE_end_sequence.  */
20600   void handle_end_sequence ()
20601   {
20602     m_currently_recording_lines = true;
20603   }
20604
20605 private:
20606   /* Advance the line by LINE_DELTA.  */
20607   void advance_line (int line_delta)
20608   {
20609     m_line += line_delta;
20610
20611     if (line_delta != 0)
20612       m_line_has_non_zero_discriminator = m_discriminator != 0;
20613   }
20614
20615   struct dwarf2_cu *m_cu;
20616
20617   gdbarch *m_gdbarch;
20618
20619   /* True if we're recording lines.
20620      Otherwise we're building partial symtabs and are just interested in
20621      finding include files mentioned by the line number program.  */
20622   bool m_record_lines_p;
20623
20624   /* The line number header.  */
20625   line_header *m_line_header;
20626
20627   /* These are part of the standard DWARF line number state machine,
20628      and initialized according to the DWARF spec.  */
20629
20630   unsigned char m_op_index = 0;
20631   /* The line table index (1-based) of the current file.  */
20632   file_name_index m_file = (file_name_index) 1;
20633   unsigned int m_line = 1;
20634
20635   /* These are initialized in the constructor.  */
20636
20637   CORE_ADDR m_address;
20638   bool m_is_stmt;
20639   unsigned int m_discriminator;
20640
20641   /* Additional bits of state we need to track.  */
20642
20643   /* The last file that we called dwarf2_start_subfile for.
20644      This is only used for TLLs.  */
20645   unsigned int m_last_file = 0;
20646   /* The last file a line number was recorded for.  */
20647   struct subfile *m_last_subfile = NULL;
20648
20649   /* When true, record the lines we decode.  */
20650   bool m_currently_recording_lines = false;
20651
20652   /* The last line number that was recorded, used to coalesce
20653      consecutive entries for the same line.  This can happen, for
20654      example, when discriminators are present.  PR 17276.  */
20655   unsigned int m_last_line = 0;
20656   bool m_line_has_non_zero_discriminator = false;
20657 };
20658
20659 void
20660 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust)
20661 {
20662   CORE_ADDR addr_adj = (((m_op_index + adjust)
20663                          / m_line_header->maximum_ops_per_instruction)
20664                         * m_line_header->minimum_instruction_length);
20665   m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20666   m_op_index = ((m_op_index + adjust)
20667                 % m_line_header->maximum_ops_per_instruction);
20668 }
20669
20670 void
20671 lnp_state_machine::handle_special_opcode (unsigned char op_code)
20672 {
20673   unsigned char adj_opcode = op_code - m_line_header->opcode_base;
20674   CORE_ADDR addr_adj = (((m_op_index
20675                           + (adj_opcode / m_line_header->line_range))
20676                          / m_line_header->maximum_ops_per_instruction)
20677                         * m_line_header->minimum_instruction_length);
20678   m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20679   m_op_index = ((m_op_index + (adj_opcode / m_line_header->line_range))
20680                 % m_line_header->maximum_ops_per_instruction);
20681
20682   int line_delta = (m_line_header->line_base
20683                     + (adj_opcode % m_line_header->line_range));
20684   advance_line (line_delta);
20685   record_line (false);
20686   m_discriminator = 0;
20687 }
20688
20689 void
20690 lnp_state_machine::handle_set_file (file_name_index file)
20691 {
20692   m_file = file;
20693
20694   const file_entry *fe = current_file ();
20695   if (fe == NULL)
20696     dwarf2_debug_line_missing_file_complaint ();
20697   else if (m_record_lines_p)
20698     {
20699       const char *dir = fe->include_dir (m_line_header);
20700
20701       m_last_subfile = m_cu->get_builder ()->get_current_subfile ();
20702       m_line_has_non_zero_discriminator = m_discriminator != 0;
20703       dwarf2_start_subfile (m_cu, fe->name, dir);
20704     }
20705 }
20706
20707 void
20708 lnp_state_machine::handle_const_add_pc ()
20709 {
20710   CORE_ADDR adjust
20711     = (255 - m_line_header->opcode_base) / m_line_header->line_range;
20712
20713   CORE_ADDR addr_adj
20714     = (((m_op_index + adjust)
20715         / m_line_header->maximum_ops_per_instruction)
20716        * m_line_header->minimum_instruction_length);
20717
20718   m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20719   m_op_index = ((m_op_index + adjust)
20720                 % m_line_header->maximum_ops_per_instruction);
20721 }
20722
20723 /* Return non-zero if we should add LINE to the line number table.
20724    LINE is the line to add, LAST_LINE is the last line that was added,
20725    LAST_SUBFILE is the subfile for LAST_LINE.
20726    LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
20727    had a non-zero discriminator.
20728
20729    We have to be careful in the presence of discriminators.
20730    E.g., for this line:
20731
20732      for (i = 0; i < 100000; i++);
20733
20734    clang can emit four line number entries for that one line,
20735    each with a different discriminator.
20736    See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
20737
20738    However, we want gdb to coalesce all four entries into one.
20739    Otherwise the user could stepi into the middle of the line and
20740    gdb would get confused about whether the pc really was in the
20741    middle of the line.
20742
20743    Things are further complicated by the fact that two consecutive
20744    line number entries for the same line is a heuristic used by gcc
20745    to denote the end of the prologue.  So we can't just discard duplicate
20746    entries, we have to be selective about it.  The heuristic we use is
20747    that we only collapse consecutive entries for the same line if at least
20748    one of those entries has a non-zero discriminator.  PR 17276.
20749
20750    Note: Addresses in the line number state machine can never go backwards
20751    within one sequence, thus this coalescing is ok.  */
20752
20753 static int
20754 dwarf_record_line_p (struct dwarf2_cu *cu,
20755                      unsigned int line, unsigned int last_line,
20756                      int line_has_non_zero_discriminator,
20757                      struct subfile *last_subfile)
20758 {
20759   if (cu->get_builder ()->get_current_subfile () != last_subfile)
20760     return 1;
20761   if (line != last_line)
20762     return 1;
20763   /* Same line for the same file that we've seen already.
20764      As a last check, for pr 17276, only record the line if the line
20765      has never had a non-zero discriminator.  */
20766   if (!line_has_non_zero_discriminator)
20767     return 1;
20768   return 0;
20769 }
20770
20771 /* Use the CU's builder to record line number LINE beginning at
20772    address ADDRESS in the line table of subfile SUBFILE.  */
20773
20774 static void
20775 dwarf_record_line_1 (struct gdbarch *gdbarch, struct subfile *subfile,
20776                      unsigned int line, CORE_ADDR address,
20777                      struct dwarf2_cu *cu)
20778 {
20779   CORE_ADDR addr = gdbarch_addr_bits_remove (gdbarch, address);
20780
20781   if (dwarf_line_debug)
20782     {
20783       fprintf_unfiltered (gdb_stdlog,
20784                           "Recording line %u, file %s, address %s\n",
20785                           line, lbasename (subfile->name),
20786                           paddress (gdbarch, address));
20787     }
20788
20789   if (cu != nullptr)
20790     cu->get_builder ()->record_line (subfile, line, addr);
20791 }
20792
20793 /* Subroutine of dwarf_decode_lines_1 to simplify it.
20794    Mark the end of a set of line number records.
20795    The arguments are the same as for dwarf_record_line_1.
20796    If SUBFILE is NULL the request is ignored.  */
20797
20798 static void
20799 dwarf_finish_line (struct gdbarch *gdbarch, struct subfile *subfile,
20800                    CORE_ADDR address, struct dwarf2_cu *cu)
20801 {
20802   if (subfile == NULL)
20803     return;
20804
20805   if (dwarf_line_debug)
20806     {
20807       fprintf_unfiltered (gdb_stdlog,
20808                           "Finishing current line, file %s, address %s\n",
20809                           lbasename (subfile->name),
20810                           paddress (gdbarch, address));
20811     }
20812
20813   dwarf_record_line_1 (gdbarch, subfile, 0, address, cu);
20814 }
20815
20816 void
20817 lnp_state_machine::record_line (bool end_sequence)
20818 {
20819   if (dwarf_line_debug)
20820     {
20821       fprintf_unfiltered (gdb_stdlog,
20822                           "Processing actual line %u: file %u,"
20823                           " address %s, is_stmt %u, discrim %u\n",
20824                           m_line, to_underlying (m_file),
20825                           paddress (m_gdbarch, m_address),
20826                           m_is_stmt, m_discriminator);
20827     }
20828
20829   file_entry *fe = current_file ();
20830
20831   if (fe == NULL)
20832     dwarf2_debug_line_missing_file_complaint ();
20833   /* For now we ignore lines not starting on an instruction boundary.
20834      But not when processing end_sequence for compatibility with the
20835      previous version of the code.  */
20836   else if (m_op_index == 0 || end_sequence)
20837     {
20838       fe->included_p = 1;
20839       if (m_record_lines_p && (producer_is_codewarrior (m_cu) || m_is_stmt))
20840         {
20841           if (m_last_subfile != m_cu->get_builder ()->get_current_subfile ()
20842               || end_sequence)
20843             {
20844               dwarf_finish_line (m_gdbarch, m_last_subfile, m_address,
20845                                  m_currently_recording_lines ? m_cu : nullptr);
20846             }
20847
20848           if (!end_sequence)
20849             {
20850               if (dwarf_record_line_p (m_cu, m_line, m_last_line,
20851                                        m_line_has_non_zero_discriminator,
20852                                        m_last_subfile))
20853                 {
20854                   buildsym_compunit *builder = m_cu->get_builder ();
20855                   dwarf_record_line_1 (m_gdbarch,
20856                                        builder->get_current_subfile (),
20857                                        m_line, m_address,
20858                                        m_currently_recording_lines ? m_cu : nullptr);
20859                 }
20860               m_last_subfile = m_cu->get_builder ()->get_current_subfile ();
20861               m_last_line = m_line;
20862             }
20863         }
20864     }
20865 }
20866
20867 lnp_state_machine::lnp_state_machine (struct dwarf2_cu *cu, gdbarch *arch,
20868                                       line_header *lh, bool record_lines_p)
20869 {
20870   m_cu = cu;
20871   m_gdbarch = arch;
20872   m_record_lines_p = record_lines_p;
20873   m_line_header = lh;
20874
20875   m_currently_recording_lines = true;
20876
20877   /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
20878      was a line entry for it so that the backend has a chance to adjust it
20879      and also record it in case it needs it.  This is currently used by MIPS
20880      code, cf. `mips_adjust_dwarf2_line'.  */
20881   m_address = gdbarch_adjust_dwarf2_line (arch, 0, 0);
20882   m_is_stmt = lh->default_is_stmt;
20883   m_discriminator = 0;
20884 }
20885
20886 void
20887 lnp_state_machine::check_line_address (struct dwarf2_cu *cu,
20888                                        const gdb_byte *line_ptr,
20889                                        CORE_ADDR unrelocated_lowpc, CORE_ADDR address)
20890 {
20891   /* If ADDRESS < UNRELOCATED_LOWPC then it's not a usable value, it's outside
20892      the pc range of the CU.  However, we restrict the test to only ADDRESS
20893      values of zero to preserve GDB's previous behaviour which is to handle
20894      the specific case of a function being GC'd by the linker.  */
20895
20896   if (address == 0 && address < unrelocated_lowpc)
20897     {
20898       /* This line table is for a function which has been
20899          GCd by the linker.  Ignore it.  PR gdb/12528 */
20900
20901       struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
20902       long line_offset = line_ptr - get_debug_line_section (cu)->buffer;
20903
20904       complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
20905                  line_offset, objfile_name (objfile));
20906       m_currently_recording_lines = false;
20907       /* Note: m_currently_recording_lines is left as false until we see
20908          DW_LNE_end_sequence.  */
20909     }
20910 }
20911
20912 /* Subroutine of dwarf_decode_lines to simplify it.
20913    Process the line number information in LH.
20914    If DECODE_FOR_PST_P is non-zero, all we do is process the line number
20915    program in order to set included_p for every referenced header.  */
20916
20917 static void
20918 dwarf_decode_lines_1 (struct line_header *lh, struct dwarf2_cu *cu,
20919                       const int decode_for_pst_p, CORE_ADDR lowpc)
20920 {
20921   const gdb_byte *line_ptr, *extended_end;
20922   const gdb_byte *line_end;
20923   unsigned int bytes_read, extended_len;
20924   unsigned char op_code, extended_op;
20925   CORE_ADDR baseaddr;
20926   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
20927   bfd *abfd = objfile->obfd;
20928   struct gdbarch *gdbarch = get_objfile_arch (objfile);
20929   /* True if we're recording line info (as opposed to building partial
20930      symtabs and just interested in finding include files mentioned by
20931      the line number program).  */
20932   bool record_lines_p = !decode_for_pst_p;
20933
20934   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
20935
20936   line_ptr = lh->statement_program_start;
20937   line_end = lh->statement_program_end;
20938
20939   /* Read the statement sequences until there's nothing left.  */
20940   while (line_ptr < line_end)
20941     {
20942       /* The DWARF line number program state machine.  Reset the state
20943          machine at the start of each sequence.  */
20944       lnp_state_machine state_machine (cu, gdbarch, lh, record_lines_p);
20945       bool end_sequence = false;
20946
20947       if (record_lines_p)
20948         {
20949           /* Start a subfile for the current file of the state
20950              machine.  */
20951           const file_entry *fe = state_machine.current_file ();
20952
20953           if (fe != NULL)
20954             dwarf2_start_subfile (cu, fe->name, fe->include_dir (lh));
20955         }
20956
20957       /* Decode the table.  */
20958       while (line_ptr < line_end && !end_sequence)
20959         {
20960           op_code = read_1_byte (abfd, line_ptr);
20961           line_ptr += 1;
20962
20963           if (op_code >= lh->opcode_base)
20964             {
20965               /* Special opcode.  */
20966               state_machine.handle_special_opcode (op_code);
20967             }
20968           else switch (op_code)
20969             {
20970             case DW_LNS_extended_op:
20971               extended_len = read_unsigned_leb128 (abfd, line_ptr,
20972                                                    &bytes_read);
20973               line_ptr += bytes_read;
20974               extended_end = line_ptr + extended_len;
20975               extended_op = read_1_byte (abfd, line_ptr);
20976               line_ptr += 1;
20977               switch (extended_op)
20978                 {
20979                 case DW_LNE_end_sequence:
20980                   state_machine.handle_end_sequence ();
20981                   end_sequence = true;
20982                   break;
20983                 case DW_LNE_set_address:
20984                   {
20985                     CORE_ADDR address
20986                       = read_address (abfd, line_ptr, cu, &bytes_read);
20987                     line_ptr += bytes_read;
20988
20989                     state_machine.check_line_address (cu, line_ptr,
20990                                                       lowpc - baseaddr, address);
20991                     state_machine.handle_set_address (baseaddr, address);
20992                   }
20993                   break;
20994                 case DW_LNE_define_file:
20995                   {
20996                     const char *cur_file;
20997                     unsigned int mod_time, length;
20998                     dir_index dindex;
20999
21000                     cur_file = read_direct_string (abfd, line_ptr,
21001                                                    &bytes_read);
21002                     line_ptr += bytes_read;
21003                     dindex = (dir_index)
21004                       read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21005                     line_ptr += bytes_read;
21006                     mod_time =
21007                       read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21008                     line_ptr += bytes_read;
21009                     length =
21010                       read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21011                     line_ptr += bytes_read;
21012                     lh->add_file_name (cur_file, dindex, mod_time, length);
21013                   }
21014                   break;
21015                 case DW_LNE_set_discriminator:
21016                   {
21017                     /* The discriminator is not interesting to the
21018                        debugger; just ignore it.  We still need to
21019                        check its value though:
21020                        if there are consecutive entries for the same
21021                        (non-prologue) line we want to coalesce them.
21022                        PR 17276.  */
21023                     unsigned int discr
21024                       = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21025                     line_ptr += bytes_read;
21026
21027                     state_machine.handle_set_discriminator (discr);
21028                   }
21029                   break;
21030                 default:
21031                   complaint (_("mangled .debug_line section"));
21032                   return;
21033                 }
21034               /* Make sure that we parsed the extended op correctly.  If e.g.
21035                  we expected a different address size than the producer used,
21036                  we may have read the wrong number of bytes.  */
21037               if (line_ptr != extended_end)
21038                 {
21039                   complaint (_("mangled .debug_line section"));
21040                   return;
21041                 }
21042               break;
21043             case DW_LNS_copy:
21044               state_machine.handle_copy ();
21045               break;
21046             case DW_LNS_advance_pc:
21047               {
21048                 CORE_ADDR adjust
21049                   = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21050                 line_ptr += bytes_read;
21051
21052                 state_machine.handle_advance_pc (adjust);
21053               }
21054               break;
21055             case DW_LNS_advance_line:
21056               {
21057                 int line_delta
21058                   = read_signed_leb128 (abfd, line_ptr, &bytes_read);
21059                 line_ptr += bytes_read;
21060
21061                 state_machine.handle_advance_line (line_delta);
21062               }
21063               break;
21064             case DW_LNS_set_file:
21065               {
21066                 file_name_index file
21067                   = (file_name_index) read_unsigned_leb128 (abfd, line_ptr,
21068                                                             &bytes_read);
21069                 line_ptr += bytes_read;
21070
21071                 state_machine.handle_set_file (file);
21072               }
21073               break;
21074             case DW_LNS_set_column:
21075               (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21076               line_ptr += bytes_read;
21077               break;
21078             case DW_LNS_negate_stmt:
21079               state_machine.handle_negate_stmt ();
21080               break;
21081             case DW_LNS_set_basic_block:
21082               break;
21083             /* Add to the address register of the state machine the
21084                address increment value corresponding to special opcode
21085                255.  I.e., this value is scaled by the minimum
21086                instruction length since special opcode 255 would have
21087                scaled the increment.  */
21088             case DW_LNS_const_add_pc:
21089               state_machine.handle_const_add_pc ();
21090               break;
21091             case DW_LNS_fixed_advance_pc:
21092               {
21093                 CORE_ADDR addr_adj = read_2_bytes (abfd, line_ptr);
21094                 line_ptr += 2;
21095
21096                 state_machine.handle_fixed_advance_pc (addr_adj);
21097               }
21098               break;
21099             default:
21100               {
21101                 /* Unknown standard opcode, ignore it.  */
21102                 int i;
21103
21104                 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
21105                   {
21106                     (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21107                     line_ptr += bytes_read;
21108                   }
21109               }
21110             }
21111         }
21112
21113       if (!end_sequence)
21114         dwarf2_debug_line_missing_end_sequence_complaint ();
21115
21116       /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
21117          in which case we still finish recording the last line).  */
21118       state_machine.record_line (true);
21119     }
21120 }
21121
21122 /* Decode the Line Number Program (LNP) for the given line_header
21123    structure and CU.  The actual information extracted and the type
21124    of structures created from the LNP depends on the value of PST.
21125
21126    1. If PST is NULL, then this procedure uses the data from the program
21127       to create all necessary symbol tables, and their linetables.
21128
21129    2. If PST is not NULL, this procedure reads the program to determine
21130       the list of files included by the unit represented by PST, and
21131       builds all the associated partial symbol tables.
21132
21133    COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21134    It is used for relative paths in the line table.
21135    NOTE: When processing partial symtabs (pst != NULL),
21136    comp_dir == pst->dirname.
21137
21138    NOTE: It is important that psymtabs have the same file name (via strcmp)
21139    as the corresponding symtab.  Since COMP_DIR is not used in the name of the
21140    symtab we don't use it in the name of the psymtabs we create.
21141    E.g. expand_line_sal requires this when finding psymtabs to expand.
21142    A good testcase for this is mb-inline.exp.
21143
21144    LOWPC is the lowest address in CU (or 0 if not known).
21145
21146    Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
21147    for its PC<->lines mapping information.  Otherwise only the filename
21148    table is read in.  */
21149
21150 static void
21151 dwarf_decode_lines (struct line_header *lh, const char *comp_dir,
21152                     struct dwarf2_cu *cu, struct partial_symtab *pst,
21153                     CORE_ADDR lowpc, int decode_mapping)
21154 {
21155   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21156   const int decode_for_pst_p = (pst != NULL);
21157
21158   if (decode_mapping)
21159     dwarf_decode_lines_1 (lh, cu, decode_for_pst_p, lowpc);
21160
21161   if (decode_for_pst_p)
21162     {
21163       int file_index;
21164
21165       /* Now that we're done scanning the Line Header Program, we can
21166          create the psymtab of each included file.  */
21167       for (file_index = 0; file_index < lh->file_names.size (); file_index++)
21168         if (lh->file_names[file_index].included_p == 1)
21169           {
21170             gdb::unique_xmalloc_ptr<char> name_holder;
21171             const char *include_name =
21172               psymtab_include_file_name (lh, file_index, pst, comp_dir,
21173                                          &name_holder);
21174             if (include_name != NULL)
21175               dwarf2_create_include_psymtab (include_name, pst, objfile);
21176           }
21177     }
21178   else
21179     {
21180       /* Make sure a symtab is created for every file, even files
21181          which contain only variables (i.e. no code with associated
21182          line numbers).  */
21183       buildsym_compunit *builder = cu->get_builder ();
21184       struct compunit_symtab *cust = builder->get_compunit_symtab ();
21185       int i;
21186
21187       for (i = 0; i < lh->file_names.size (); i++)
21188         {
21189           file_entry &fe = lh->file_names[i];
21190
21191           dwarf2_start_subfile (cu, fe.name, fe.include_dir (lh));
21192
21193           if (builder->get_current_subfile ()->symtab == NULL)
21194             {
21195               builder->get_current_subfile ()->symtab
21196                 = allocate_symtab (cust,
21197                                    builder->get_current_subfile ()->name);
21198             }
21199           fe.symtab = builder->get_current_subfile ()->symtab;
21200         }
21201     }
21202 }
21203
21204 /* Start a subfile for DWARF.  FILENAME is the name of the file and
21205    DIRNAME the name of the source directory which contains FILENAME
21206    or NULL if not known.
21207    This routine tries to keep line numbers from identical absolute and
21208    relative file names in a common subfile.
21209
21210    Using the `list' example from the GDB testsuite, which resides in
21211    /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
21212    of /srcdir/list0.c yields the following debugging information for list0.c:
21213
21214    DW_AT_name:          /srcdir/list0.c
21215    DW_AT_comp_dir:      /compdir
21216    files.files[0].name: list0.h
21217    files.files[0].dir:  /srcdir
21218    files.files[1].name: list0.c
21219    files.files[1].dir:  /srcdir
21220
21221    The line number information for list0.c has to end up in a single
21222    subfile, so that `break /srcdir/list0.c:1' works as expected.
21223    start_subfile will ensure that this happens provided that we pass the
21224    concatenation of files.files[1].dir and files.files[1].name as the
21225    subfile's name.  */
21226
21227 static void
21228 dwarf2_start_subfile (struct dwarf2_cu *cu, const char *filename,
21229                       const char *dirname)
21230 {
21231   char *copy = NULL;
21232
21233   /* In order not to lose the line information directory,
21234      we concatenate it to the filename when it makes sense.
21235      Note that the Dwarf3 standard says (speaking of filenames in line
21236      information): ``The directory index is ignored for file names
21237      that represent full path names''.  Thus ignoring dirname in the
21238      `else' branch below isn't an issue.  */
21239
21240   if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
21241     {
21242       copy = concat (dirname, SLASH_STRING, filename, (char *)NULL);
21243       filename = copy;
21244     }
21245
21246   cu->get_builder ()->start_subfile (filename);
21247
21248   if (copy != NULL)
21249     xfree (copy);
21250 }
21251
21252 /* Start a symtab for DWARF.  NAME, COMP_DIR, LOW_PC are passed to the
21253    buildsym_compunit constructor.  */
21254
21255 struct compunit_symtab *
21256 dwarf2_cu::start_symtab (const char *name, const char *comp_dir,
21257                          CORE_ADDR low_pc)
21258 {
21259   gdb_assert (m_builder == nullptr);
21260
21261   m_builder.reset (new struct buildsym_compunit
21262                    (per_cu->dwarf2_per_objfile->objfile,
21263                     name, comp_dir, language, low_pc));
21264
21265   list_in_scope = get_builder ()->get_file_symbols ();
21266
21267   get_builder ()->record_debugformat ("DWARF 2");
21268   get_builder ()->record_producer (producer);
21269
21270   processing_has_namespace_info = false;
21271
21272   return get_builder ()->get_compunit_symtab ();
21273 }
21274
21275 static void
21276 var_decode_location (struct attribute *attr, struct symbol *sym,
21277                      struct dwarf2_cu *cu)
21278 {
21279   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21280   struct comp_unit_head *cu_header = &cu->header;
21281
21282   /* NOTE drow/2003-01-30: There used to be a comment and some special
21283      code here to turn a symbol with DW_AT_external and a
21284      SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol.  This was
21285      necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
21286      with some versions of binutils) where shared libraries could have
21287      relocations against symbols in their debug information - the
21288      minimal symbol would have the right address, but the debug info
21289      would not.  It's no longer necessary, because we will explicitly
21290      apply relocations when we read in the debug information now.  */
21291
21292   /* A DW_AT_location attribute with no contents indicates that a
21293      variable has been optimized away.  */
21294   if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
21295     {
21296       SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
21297       return;
21298     }
21299
21300   /* Handle one degenerate form of location expression specially, to
21301      preserve GDB's previous behavior when section offsets are
21302      specified.  If this is just a DW_OP_addr or DW_OP_GNU_addr_index
21303      then mark this symbol as LOC_STATIC.  */
21304
21305   if (attr_form_is_block (attr)
21306       && ((DW_BLOCK (attr)->data[0] == DW_OP_addr
21307            && DW_BLOCK (attr)->size == 1 + cu_header->addr_size)
21308           || (DW_BLOCK (attr)->data[0] == DW_OP_GNU_addr_index
21309               && (DW_BLOCK (attr)->size
21310                   == 1 + leb128_size (&DW_BLOCK (attr)->data[1])))))
21311     {
21312       unsigned int dummy;
21313
21314       if (DW_BLOCK (attr)->data[0] == DW_OP_addr)
21315         SYMBOL_VALUE_ADDRESS (sym) =
21316           read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
21317       else
21318         SYMBOL_VALUE_ADDRESS (sym) =
21319           read_addr_index_from_leb128 (cu, DW_BLOCK (attr)->data + 1, &dummy);
21320       SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
21321       fixup_symbol_section (sym, objfile);
21322       SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
21323                                               SYMBOL_SECTION (sym));
21324       return;
21325     }
21326
21327   /* NOTE drow/2002-01-30: It might be worthwhile to have a static
21328      expression evaluator, and use LOC_COMPUTED only when necessary
21329      (i.e. when the value of a register or memory location is
21330      referenced, or a thread-local block, etc.).  Then again, it might
21331      not be worthwhile.  I'm assuming that it isn't unless performance
21332      or memory numbers show me otherwise.  */
21333
21334   dwarf2_symbol_mark_computed (attr, sym, cu, 0);
21335
21336   if (SYMBOL_COMPUTED_OPS (sym)->location_has_loclist)
21337     cu->has_loclist = true;
21338 }
21339
21340 /* Given a pointer to a DWARF information entry, figure out if we need
21341    to make a symbol table entry for it, and if so, create a new entry
21342    and return a pointer to it.
21343    If TYPE is NULL, determine symbol type from the die, otherwise
21344    used the passed type.
21345    If SPACE is not NULL, use it to hold the new symbol.  If it is
21346    NULL, allocate a new symbol on the objfile's obstack.  */
21347
21348 static struct symbol *
21349 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
21350             struct symbol *space)
21351 {
21352   struct dwarf2_per_objfile *dwarf2_per_objfile
21353     = cu->per_cu->dwarf2_per_objfile;
21354   struct objfile *objfile = dwarf2_per_objfile->objfile;
21355   struct gdbarch *gdbarch = get_objfile_arch (objfile);
21356   struct symbol *sym = NULL;
21357   const char *name;
21358   struct attribute *attr = NULL;
21359   struct attribute *attr2 = NULL;
21360   CORE_ADDR baseaddr;
21361   struct pending **list_to_add = NULL;
21362
21363   int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
21364
21365   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
21366
21367   name = dwarf2_name (die, cu);
21368   if (name)
21369     {
21370       const char *linkagename;
21371       int suppress_add = 0;
21372
21373       if (space)
21374         sym = space;
21375       else
21376         sym = allocate_symbol (objfile);
21377       OBJSTAT (objfile, n_syms++);
21378
21379       /* Cache this symbol's name and the name's demangled form (if any).  */
21380       SYMBOL_SET_LANGUAGE (sym, cu->language, &objfile->objfile_obstack);
21381       linkagename = dwarf2_physname (name, die, cu);
21382       SYMBOL_SET_NAMES (sym, linkagename, strlen (linkagename), 0, objfile);
21383
21384       /* Fortran does not have mangling standard and the mangling does differ
21385          between gfortran, iFort etc.  */
21386       if (cu->language == language_fortran
21387           && symbol_get_demangled_name (&(sym->ginfo)) == NULL)
21388         symbol_set_demangled_name (&(sym->ginfo),
21389                                    dwarf2_full_name (name, die, cu),
21390                                    NULL);
21391
21392       /* Default assumptions.
21393          Use the passed type or decode it from the die.  */
21394       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21395       SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
21396       if (type != NULL)
21397         SYMBOL_TYPE (sym) = type;
21398       else
21399         SYMBOL_TYPE (sym) = die_type (die, cu);
21400       attr = dwarf2_attr (die,
21401                           inlined_func ? DW_AT_call_line : DW_AT_decl_line,
21402                           cu);
21403       if (attr)
21404         {
21405           SYMBOL_LINE (sym) = DW_UNSND (attr);
21406         }
21407
21408       attr = dwarf2_attr (die,
21409                           inlined_func ? DW_AT_call_file : DW_AT_decl_file,
21410                           cu);
21411       if (attr)
21412         {
21413           file_name_index file_index = (file_name_index) DW_UNSND (attr);
21414           struct file_entry *fe;
21415
21416           if (cu->line_header != NULL)
21417             fe = cu->line_header->file_name_at (file_index);
21418           else
21419             fe = NULL;
21420
21421           if (fe == NULL)
21422             complaint (_("file index out of range"));
21423           else
21424             symbol_set_symtab (sym, fe->symtab);
21425         }
21426
21427       switch (die->tag)
21428         {
21429         case DW_TAG_label:
21430           attr = dwarf2_attr (die, DW_AT_low_pc, cu);
21431           if (attr)
21432             {
21433               CORE_ADDR addr;
21434
21435               addr = attr_value_as_address (attr);
21436               addr = gdbarch_adjust_dwarf2_addr (gdbarch, addr + baseaddr);
21437               SYMBOL_VALUE_ADDRESS (sym) = addr;
21438             }
21439           SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_core_addr;
21440           SYMBOL_DOMAIN (sym) = LABEL_DOMAIN;
21441           SYMBOL_ACLASS_INDEX (sym) = LOC_LABEL;
21442           add_symbol_to_list (sym, cu->list_in_scope);
21443           break;
21444         case DW_TAG_subprogram:
21445           /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21446              finish_block.  */
21447           SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
21448           attr2 = dwarf2_attr (die, DW_AT_external, cu);
21449           if ((attr2 && (DW_UNSND (attr2) != 0))
21450               || cu->language == language_ada)
21451             {
21452               /* Subprograms marked external are stored as a global symbol.
21453                  Ada subprograms, whether marked external or not, are always
21454                  stored as a global symbol, because we want to be able to
21455                  access them globally.  For instance, we want to be able
21456                  to break on a nested subprogram without having to
21457                  specify the context.  */
21458               list_to_add = cu->get_builder ()->get_global_symbols ();
21459             }
21460           else
21461             {
21462               list_to_add = cu->list_in_scope;
21463             }
21464           break;
21465         case DW_TAG_inlined_subroutine:
21466           /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21467              finish_block.  */
21468           SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
21469           SYMBOL_INLINED (sym) = 1;
21470           list_to_add = cu->list_in_scope;
21471           break;
21472         case DW_TAG_template_value_param:
21473           suppress_add = 1;
21474           /* Fall through.  */
21475         case DW_TAG_constant:
21476         case DW_TAG_variable:
21477         case DW_TAG_member:
21478           /* Compilation with minimal debug info may result in
21479              variables with missing type entries.  Change the
21480              misleading `void' type to something sensible.  */
21481           if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
21482             SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_int;
21483
21484           attr = dwarf2_attr (die, DW_AT_const_value, cu);
21485           /* In the case of DW_TAG_member, we should only be called for
21486              static const members.  */
21487           if (die->tag == DW_TAG_member)
21488             {
21489               /* dwarf2_add_field uses die_is_declaration,
21490                  so we do the same.  */
21491               gdb_assert (die_is_declaration (die, cu));
21492               gdb_assert (attr);
21493             }
21494           if (attr)
21495             {
21496               dwarf2_const_value (attr, sym, cu);
21497               attr2 = dwarf2_attr (die, DW_AT_external, cu);
21498               if (!suppress_add)
21499                 {
21500                   if (attr2 && (DW_UNSND (attr2) != 0))
21501                     list_to_add = cu->get_builder ()->get_global_symbols ();
21502                   else
21503                     list_to_add = cu->list_in_scope;
21504                 }
21505               break;
21506             }
21507           attr = dwarf2_attr (die, DW_AT_location, cu);
21508           if (attr)
21509             {
21510               var_decode_location (attr, sym, cu);
21511               attr2 = dwarf2_attr (die, DW_AT_external, cu);
21512
21513               /* Fortran explicitly imports any global symbols to the local
21514                  scope by DW_TAG_common_block.  */
21515               if (cu->language == language_fortran && die->parent
21516                   && die->parent->tag == DW_TAG_common_block)
21517                 attr2 = NULL;
21518
21519               if (SYMBOL_CLASS (sym) == LOC_STATIC
21520                   && SYMBOL_VALUE_ADDRESS (sym) == 0
21521                   && !dwarf2_per_objfile->has_section_at_zero)
21522                 {
21523                   /* When a static variable is eliminated by the linker,
21524                      the corresponding debug information is not stripped
21525                      out, but the variable address is set to null;
21526                      do not add such variables into symbol table.  */
21527                 }
21528               else if (attr2 && (DW_UNSND (attr2) != 0))
21529                 {
21530                   /* Workaround gfortran PR debug/40040 - it uses
21531                      DW_AT_location for variables in -fPIC libraries which may
21532                      get overriden by other libraries/executable and get
21533                      a different address.  Resolve it by the minimal symbol
21534                      which may come from inferior's executable using copy
21535                      relocation.  Make this workaround only for gfortran as for
21536                      other compilers GDB cannot guess the minimal symbol
21537                      Fortran mangling kind.  */
21538                   if (cu->language == language_fortran && die->parent
21539                       && die->parent->tag == DW_TAG_module
21540                       && cu->producer
21541                       && startswith (cu->producer, "GNU Fortran"))
21542                     SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
21543
21544                   /* A variable with DW_AT_external is never static,
21545                      but it may be block-scoped.  */
21546                   list_to_add
21547                     = ((cu->list_in_scope
21548                         == cu->get_builder ()->get_file_symbols ())
21549                        ? cu->get_builder ()->get_global_symbols ()
21550                        : cu->list_in_scope);
21551                 }
21552               else
21553                 list_to_add = cu->list_in_scope;
21554             }
21555           else
21556             {
21557               /* We do not know the address of this symbol.
21558                  If it is an external symbol and we have type information
21559                  for it, enter the symbol as a LOC_UNRESOLVED symbol.
21560                  The address of the variable will then be determined from
21561                  the minimal symbol table whenever the variable is
21562                  referenced.  */
21563               attr2 = dwarf2_attr (die, DW_AT_external, cu);
21564
21565               /* Fortran explicitly imports any global symbols to the local
21566                  scope by DW_TAG_common_block.  */
21567               if (cu->language == language_fortran && die->parent
21568                   && die->parent->tag == DW_TAG_common_block)
21569                 {
21570                   /* SYMBOL_CLASS doesn't matter here because
21571                      read_common_block is going to reset it.  */
21572                   if (!suppress_add)
21573                     list_to_add = cu->list_in_scope;
21574                 }
21575               else if (attr2 && (DW_UNSND (attr2) != 0)
21576                        && dwarf2_attr (die, DW_AT_type, cu) != NULL)
21577                 {
21578                   /* A variable with DW_AT_external is never static, but it
21579                      may be block-scoped.  */
21580                   list_to_add
21581                     = ((cu->list_in_scope
21582                         == cu->get_builder ()->get_file_symbols ())
21583                        ? cu->get_builder ()->get_global_symbols ()
21584                        : cu->list_in_scope);
21585
21586                   SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
21587                 }
21588               else if (!die_is_declaration (die, cu))
21589                 {
21590                   /* Use the default LOC_OPTIMIZED_OUT class.  */
21591                   gdb_assert (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT);
21592                   if (!suppress_add)
21593                     list_to_add = cu->list_in_scope;
21594                 }
21595             }
21596           break;
21597         case DW_TAG_formal_parameter:
21598           {
21599             /* If we are inside a function, mark this as an argument.  If
21600                not, we might be looking at an argument to an inlined function
21601                when we do not have enough information to show inlined frames;
21602                pretend it's a local variable in that case so that the user can
21603                still see it.  */
21604             struct context_stack *curr
21605               = cu->get_builder ()->get_current_context_stack ();
21606             if (curr != nullptr && curr->name != nullptr)
21607               SYMBOL_IS_ARGUMENT (sym) = 1;
21608             attr = dwarf2_attr (die, DW_AT_location, cu);
21609             if (attr)
21610               {
21611                 var_decode_location (attr, sym, cu);
21612               }
21613             attr = dwarf2_attr (die, DW_AT_const_value, cu);
21614             if (attr)
21615               {
21616                 dwarf2_const_value (attr, sym, cu);
21617               }
21618
21619             list_to_add = cu->list_in_scope;
21620           }
21621           break;
21622         case DW_TAG_unspecified_parameters:
21623           /* From varargs functions; gdb doesn't seem to have any
21624              interest in this information, so just ignore it for now.
21625              (FIXME?) */
21626           break;
21627         case DW_TAG_template_type_param:
21628           suppress_add = 1;
21629           /* Fall through.  */
21630         case DW_TAG_class_type:
21631         case DW_TAG_interface_type:
21632         case DW_TAG_structure_type:
21633         case DW_TAG_union_type:
21634         case DW_TAG_set_type:
21635         case DW_TAG_enumeration_type:
21636           SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21637           SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
21638
21639           {
21640             /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
21641                really ever be static objects: otherwise, if you try
21642                to, say, break of a class's method and you're in a file
21643                which doesn't mention that class, it won't work unless
21644                the check for all static symbols in lookup_symbol_aux
21645                saves you.  See the OtherFileClass tests in
21646                gdb.c++/namespace.exp.  */
21647
21648             if (!suppress_add)
21649               {
21650                 buildsym_compunit *builder = cu->get_builder ();
21651                 list_to_add
21652                   = (cu->list_in_scope == builder->get_file_symbols ()
21653                      && cu->language == language_cplus
21654                      ? builder->get_global_symbols ()
21655                      : cu->list_in_scope);
21656
21657                 /* The semantics of C++ state that "struct foo {
21658                    ... }" also defines a typedef for "foo".  */
21659                 if (cu->language == language_cplus
21660                     || cu->language == language_ada
21661                     || cu->language == language_d
21662                     || cu->language == language_rust)
21663                   {
21664                     /* The symbol's name is already allocated along
21665                        with this objfile, so we don't need to
21666                        duplicate it for the type.  */
21667                     if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
21668                       TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
21669                   }
21670               }
21671           }
21672           break;
21673         case DW_TAG_typedef:
21674           SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21675           SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21676           list_to_add = cu->list_in_scope;
21677           break;
21678         case DW_TAG_base_type:
21679         case DW_TAG_subrange_type:
21680           SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21681           SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21682           list_to_add = cu->list_in_scope;
21683           break;
21684         case DW_TAG_enumerator:
21685           attr = dwarf2_attr (die, DW_AT_const_value, cu);
21686           if (attr)
21687             {
21688               dwarf2_const_value (attr, sym, cu);
21689             }
21690           {
21691             /* NOTE: carlton/2003-11-10: See comment above in the
21692                DW_TAG_class_type, etc. block.  */
21693
21694             list_to_add
21695               = (cu->list_in_scope == cu->get_builder ()->get_file_symbols ()
21696                  && cu->language == language_cplus
21697                  ? cu->get_builder ()->get_global_symbols ()
21698                  : cu->list_in_scope);
21699           }
21700           break;
21701         case DW_TAG_imported_declaration:
21702         case DW_TAG_namespace:
21703           SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21704           list_to_add = cu->get_builder ()->get_global_symbols ();
21705           break;
21706         case DW_TAG_module:
21707           SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21708           SYMBOL_DOMAIN (sym) = MODULE_DOMAIN;
21709           list_to_add = cu->get_builder ()->get_global_symbols ();
21710           break;
21711         case DW_TAG_common_block:
21712           SYMBOL_ACLASS_INDEX (sym) = LOC_COMMON_BLOCK;
21713           SYMBOL_DOMAIN (sym) = COMMON_BLOCK_DOMAIN;
21714           add_symbol_to_list (sym, cu->list_in_scope);
21715           break;
21716         default:
21717           /* Not a tag we recognize.  Hopefully we aren't processing
21718              trash data, but since we must specifically ignore things
21719              we don't recognize, there is nothing else we should do at
21720              this point.  */
21721           complaint (_("unsupported tag: '%s'"),
21722                      dwarf_tag_name (die->tag));
21723           break;
21724         }
21725
21726       if (suppress_add)
21727         {
21728           sym->hash_next = objfile->template_symbols;
21729           objfile->template_symbols = sym;
21730           list_to_add = NULL;
21731         }
21732
21733       if (list_to_add != NULL)
21734         add_symbol_to_list (sym, list_to_add);
21735
21736       /* For the benefit of old versions of GCC, check for anonymous
21737          namespaces based on the demangled name.  */
21738       if (!cu->processing_has_namespace_info
21739           && cu->language == language_cplus)
21740         cp_scan_for_anonymous_namespaces (cu->get_builder (), sym, objfile);
21741     }
21742   return (sym);
21743 }
21744
21745 /* Given an attr with a DW_FORM_dataN value in host byte order,
21746    zero-extend it as appropriate for the symbol's type.  The DWARF
21747    standard (v4) is not entirely clear about the meaning of using
21748    DW_FORM_dataN for a constant with a signed type, where the type is
21749    wider than the data.  The conclusion of a discussion on the DWARF
21750    list was that this is unspecified.  We choose to always zero-extend
21751    because that is the interpretation long in use by GCC.  */
21752
21753 static gdb_byte *
21754 dwarf2_const_value_data (const struct attribute *attr, struct obstack *obstack,
21755                          struct dwarf2_cu *cu, LONGEST *value, int bits)
21756 {
21757   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21758   enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ?
21759                                 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
21760   LONGEST l = DW_UNSND (attr);
21761
21762   if (bits < sizeof (*value) * 8)
21763     {
21764       l &= ((LONGEST) 1 << bits) - 1;
21765       *value = l;
21766     }
21767   else if (bits == sizeof (*value) * 8)
21768     *value = l;
21769   else
21770     {
21771       gdb_byte *bytes = (gdb_byte *) obstack_alloc (obstack, bits / 8);
21772       store_unsigned_integer (bytes, bits / 8, byte_order, l);
21773       return bytes;
21774     }
21775
21776   return NULL;
21777 }
21778
21779 /* Read a constant value from an attribute.  Either set *VALUE, or if
21780    the value does not fit in *VALUE, set *BYTES - either already
21781    allocated on the objfile obstack, or newly allocated on OBSTACK,
21782    or, set *BATON, if we translated the constant to a location
21783    expression.  */
21784
21785 static void
21786 dwarf2_const_value_attr (const struct attribute *attr, struct type *type,
21787                          const char *name, struct obstack *obstack,
21788                          struct dwarf2_cu *cu,
21789                          LONGEST *value, const gdb_byte **bytes,
21790                          struct dwarf2_locexpr_baton **baton)
21791 {
21792   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21793   struct comp_unit_head *cu_header = &cu->header;
21794   struct dwarf_block *blk;
21795   enum bfd_endian byte_order = (bfd_big_endian (objfile->obfd) ?
21796                                 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
21797
21798   *value = 0;
21799   *bytes = NULL;
21800   *baton = NULL;
21801
21802   switch (attr->form)
21803     {
21804     case DW_FORM_addr:
21805     case DW_FORM_GNU_addr_index:
21806       {
21807         gdb_byte *data;
21808
21809         if (TYPE_LENGTH (type) != cu_header->addr_size)
21810           dwarf2_const_value_length_mismatch_complaint (name,
21811                                                         cu_header->addr_size,
21812                                                         TYPE_LENGTH (type));
21813         /* Symbols of this form are reasonably rare, so we just
21814            piggyback on the existing location code rather than writing
21815            a new implementation of symbol_computed_ops.  */
21816         *baton = XOBNEW (obstack, struct dwarf2_locexpr_baton);
21817         (*baton)->per_cu = cu->per_cu;
21818         gdb_assert ((*baton)->per_cu);
21819
21820         (*baton)->size = 2 + cu_header->addr_size;
21821         data = (gdb_byte *) obstack_alloc (obstack, (*baton)->size);
21822         (*baton)->data = data;
21823
21824         data[0] = DW_OP_addr;
21825         store_unsigned_integer (&data[1], cu_header->addr_size,
21826                                 byte_order, DW_ADDR (attr));
21827         data[cu_header->addr_size + 1] = DW_OP_stack_value;
21828       }
21829       break;
21830     case DW_FORM_string:
21831     case DW_FORM_strp:
21832     case DW_FORM_GNU_str_index:
21833     case DW_FORM_GNU_strp_alt:
21834       /* DW_STRING is already allocated on the objfile obstack, point
21835          directly to it.  */
21836       *bytes = (const gdb_byte *) DW_STRING (attr);
21837       break;
21838     case DW_FORM_block1:
21839     case DW_FORM_block2:
21840     case DW_FORM_block4:
21841     case DW_FORM_block:
21842     case DW_FORM_exprloc:
21843     case DW_FORM_data16:
21844       blk = DW_BLOCK (attr);
21845       if (TYPE_LENGTH (type) != blk->size)
21846         dwarf2_const_value_length_mismatch_complaint (name, blk->size,
21847                                                       TYPE_LENGTH (type));
21848       *bytes = blk->data;
21849       break;
21850
21851       /* The DW_AT_const_value attributes are supposed to carry the
21852          symbol's value "represented as it would be on the target
21853          architecture."  By the time we get here, it's already been
21854          converted to host endianness, so we just need to sign- or
21855          zero-extend it as appropriate.  */
21856     case DW_FORM_data1:
21857       *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 8);
21858       break;
21859     case DW_FORM_data2:
21860       *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 16);
21861       break;
21862     case DW_FORM_data4:
21863       *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 32);
21864       break;
21865     case DW_FORM_data8:
21866       *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 64);
21867       break;
21868
21869     case DW_FORM_sdata:
21870     case DW_FORM_implicit_const:
21871       *value = DW_SND (attr);
21872       break;
21873
21874     case DW_FORM_udata:
21875       *value = DW_UNSND (attr);
21876       break;
21877
21878     default:
21879       complaint (_("unsupported const value attribute form: '%s'"),
21880                  dwarf_form_name (attr->form));
21881       *value = 0;
21882       break;
21883     }
21884 }
21885
21886
21887 /* Copy constant value from an attribute to a symbol.  */
21888
21889 static void
21890 dwarf2_const_value (const struct attribute *attr, struct symbol *sym,
21891                     struct dwarf2_cu *cu)
21892 {
21893   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21894   LONGEST value;
21895   const gdb_byte *bytes;
21896   struct dwarf2_locexpr_baton *baton;
21897
21898   dwarf2_const_value_attr (attr, SYMBOL_TYPE (sym),
21899                            SYMBOL_PRINT_NAME (sym),
21900                            &objfile->objfile_obstack, cu,
21901                            &value, &bytes, &baton);
21902
21903   if (baton != NULL)
21904     {
21905       SYMBOL_LOCATION_BATON (sym) = baton;
21906       SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
21907     }
21908   else if (bytes != NULL)
21909      {
21910       SYMBOL_VALUE_BYTES (sym) = bytes;
21911       SYMBOL_ACLASS_INDEX (sym) = LOC_CONST_BYTES;
21912     }
21913   else
21914     {
21915       SYMBOL_VALUE (sym) = value;
21916       SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
21917     }
21918 }
21919
21920 /* Return the type of the die in question using its DW_AT_type attribute.  */
21921
21922 static struct type *
21923 die_type (struct die_info *die, struct dwarf2_cu *cu)
21924 {
21925   struct attribute *type_attr;
21926
21927   type_attr = dwarf2_attr (die, DW_AT_type, cu);
21928   if (!type_attr)
21929     {
21930       struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21931       /* A missing DW_AT_type represents a void type.  */
21932       return objfile_type (objfile)->builtin_void;
21933     }
21934
21935   return lookup_die_type (die, type_attr, cu);
21936 }
21937
21938 /* True iff CU's producer generates GNAT Ada auxiliary information
21939    that allows to find parallel types through that information instead
21940    of having to do expensive parallel lookups by type name.  */
21941
21942 static int
21943 need_gnat_info (struct dwarf2_cu *cu)
21944 {
21945   /* Assume that the Ada compiler was GNAT, which always produces
21946      the auxiliary information.  */
21947   return (cu->language == language_ada);
21948 }
21949
21950 /* Return the auxiliary type of the die in question using its
21951    DW_AT_GNAT_descriptive_type attribute.  Returns NULL if the
21952    attribute is not present.  */
21953
21954 static struct type *
21955 die_descriptive_type (struct die_info *die, struct dwarf2_cu *cu)
21956 {
21957   struct attribute *type_attr;
21958
21959   type_attr = dwarf2_attr (die, DW_AT_GNAT_descriptive_type, cu);
21960   if (!type_attr)
21961     return NULL;
21962
21963   return lookup_die_type (die, type_attr, cu);
21964 }
21965
21966 /* If DIE has a descriptive_type attribute, then set the TYPE's
21967    descriptive type accordingly.  */
21968
21969 static void
21970 set_descriptive_type (struct type *type, struct die_info *die,
21971                       struct dwarf2_cu *cu)
21972 {
21973   struct type *descriptive_type = die_descriptive_type (die, cu);
21974
21975   if (descriptive_type)
21976     {
21977       ALLOCATE_GNAT_AUX_TYPE (type);
21978       TYPE_DESCRIPTIVE_TYPE (type) = descriptive_type;
21979     }
21980 }
21981
21982 /* Return the containing type of the die in question using its
21983    DW_AT_containing_type attribute.  */
21984
21985 static struct type *
21986 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
21987 {
21988   struct attribute *type_attr;
21989   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21990
21991   type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
21992   if (!type_attr)
21993     error (_("Dwarf Error: Problem turning containing type into gdb type "
21994              "[in module %s]"), objfile_name (objfile));
21995
21996   return lookup_die_type (die, type_attr, cu);
21997 }
21998
21999 /* Return an error marker type to use for the ill formed type in DIE/CU.  */
22000
22001 static struct type *
22002 build_error_marker_type (struct dwarf2_cu *cu, struct die_info *die)
22003 {
22004   struct dwarf2_per_objfile *dwarf2_per_objfile
22005     = cu->per_cu->dwarf2_per_objfile;
22006   struct objfile *objfile = dwarf2_per_objfile->objfile;
22007   char *saved;
22008
22009   std::string message
22010     = string_printf (_("<unknown type in %s, CU %s, DIE %s>"),
22011                      objfile_name (objfile),
22012                      sect_offset_str (cu->header.sect_off),
22013                      sect_offset_str (die->sect_off));
22014   saved = (char *) obstack_copy0 (&objfile->objfile_obstack,
22015                                   message.c_str (), message.length ());
22016
22017   return init_type (objfile, TYPE_CODE_ERROR, 0, saved);
22018 }
22019
22020 /* Look up the type of DIE in CU using its type attribute ATTR.
22021    ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
22022    DW_AT_containing_type.
22023    If there is no type substitute an error marker.  */
22024
22025 static struct type *
22026 lookup_die_type (struct die_info *die, const struct attribute *attr,
22027                  struct dwarf2_cu *cu)
22028 {
22029   struct dwarf2_per_objfile *dwarf2_per_objfile
22030     = cu->per_cu->dwarf2_per_objfile;
22031   struct objfile *objfile = dwarf2_per_objfile->objfile;
22032   struct type *this_type;
22033
22034   gdb_assert (attr->name == DW_AT_type
22035               || attr->name == DW_AT_GNAT_descriptive_type
22036               || attr->name == DW_AT_containing_type);
22037
22038   /* First see if we have it cached.  */
22039
22040   if (attr->form == DW_FORM_GNU_ref_alt)
22041     {
22042       struct dwarf2_per_cu_data *per_cu;
22043       sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
22044
22045       per_cu = dwarf2_find_containing_comp_unit (sect_off, 1,
22046                                                  dwarf2_per_objfile);
22047       this_type = get_die_type_at_offset (sect_off, per_cu);
22048     }
22049   else if (attr_form_is_ref (attr))
22050     {
22051       sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
22052
22053       this_type = get_die_type_at_offset (sect_off, cu->per_cu);
22054     }
22055   else if (attr->form == DW_FORM_ref_sig8)
22056     {
22057       ULONGEST signature = DW_SIGNATURE (attr);
22058
22059       return get_signatured_type (die, signature, cu);
22060     }
22061   else
22062     {
22063       complaint (_("Dwarf Error: Bad type attribute %s in DIE"
22064                    " at %s [in module %s]"),
22065                  dwarf_attr_name (attr->name), sect_offset_str (die->sect_off),
22066                  objfile_name (objfile));
22067       return build_error_marker_type (cu, die);
22068     }
22069
22070   /* If not cached we need to read it in.  */
22071
22072   if (this_type == NULL)
22073     {
22074       struct die_info *type_die = NULL;
22075       struct dwarf2_cu *type_cu = cu;
22076
22077       if (attr_form_is_ref (attr))
22078         type_die = follow_die_ref (die, attr, &type_cu);
22079       if (type_die == NULL)
22080         return build_error_marker_type (cu, die);
22081       /* If we find the type now, it's probably because the type came
22082          from an inter-CU reference and the type's CU got expanded before
22083          ours.  */
22084       this_type = read_type_die (type_die, type_cu);
22085     }
22086
22087   /* If we still don't have a type use an error marker.  */
22088
22089   if (this_type == NULL)
22090     return build_error_marker_type (cu, die);
22091
22092   return this_type;
22093 }
22094
22095 /* Return the type in DIE, CU.
22096    Returns NULL for invalid types.
22097
22098    This first does a lookup in die_type_hash,
22099    and only reads the die in if necessary.
22100
22101    NOTE: This can be called when reading in partial or full symbols.  */
22102
22103 static struct type *
22104 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
22105 {
22106   struct type *this_type;
22107
22108   this_type = get_die_type (die, cu);
22109   if (this_type)
22110     return this_type;
22111
22112   return read_type_die_1 (die, cu);
22113 }
22114
22115 /* Read the type in DIE, CU.
22116    Returns NULL for invalid types.  */
22117
22118 static struct type *
22119 read_type_die_1 (struct die_info *die, struct dwarf2_cu *cu)
22120 {
22121   struct type *this_type = NULL;
22122
22123   switch (die->tag)
22124     {
22125     case DW_TAG_class_type:
22126     case DW_TAG_interface_type:
22127     case DW_TAG_structure_type:
22128     case DW_TAG_union_type:
22129       this_type = read_structure_type (die, cu);
22130       break;
22131     case DW_TAG_enumeration_type:
22132       this_type = read_enumeration_type (die, cu);
22133       break;
22134     case DW_TAG_subprogram:
22135     case DW_TAG_subroutine_type:
22136     case DW_TAG_inlined_subroutine:
22137       this_type = read_subroutine_type (die, cu);
22138       break;
22139     case DW_TAG_array_type:
22140       this_type = read_array_type (die, cu);
22141       break;
22142     case DW_TAG_set_type:
22143       this_type = read_set_type (die, cu);
22144       break;
22145     case DW_TAG_pointer_type:
22146       this_type = read_tag_pointer_type (die, cu);
22147       break;
22148     case DW_TAG_ptr_to_member_type:
22149       this_type = read_tag_ptr_to_member_type (die, cu);
22150       break;
22151     case DW_TAG_reference_type:
22152       this_type = read_tag_reference_type (die, cu, TYPE_CODE_REF);
22153       break;
22154     case DW_TAG_rvalue_reference_type:
22155       this_type = read_tag_reference_type (die, cu, TYPE_CODE_RVALUE_REF);
22156       break;
22157     case DW_TAG_const_type:
22158       this_type = read_tag_const_type (die, cu);
22159       break;
22160     case DW_TAG_volatile_type:
22161       this_type = read_tag_volatile_type (die, cu);
22162       break;
22163     case DW_TAG_restrict_type:
22164       this_type = read_tag_restrict_type (die, cu);
22165       break;
22166     case DW_TAG_string_type:
22167       this_type = read_tag_string_type (die, cu);
22168       break;
22169     case DW_TAG_typedef:
22170       this_type = read_typedef (die, cu);
22171       break;
22172     case DW_TAG_subrange_type:
22173       this_type = read_subrange_type (die, cu);
22174       break;
22175     case DW_TAG_base_type:
22176       this_type = read_base_type (die, cu);
22177       break;
22178     case DW_TAG_unspecified_type:
22179       this_type = read_unspecified_type (die, cu);
22180       break;
22181     case DW_TAG_namespace:
22182       this_type = read_namespace_type (die, cu);
22183       break;
22184     case DW_TAG_module:
22185       this_type = read_module_type (die, cu);
22186       break;
22187     case DW_TAG_atomic_type:
22188       this_type = read_tag_atomic_type (die, cu);
22189       break;
22190     default:
22191       complaint (_("unexpected tag in read_type_die: '%s'"),
22192                  dwarf_tag_name (die->tag));
22193       break;
22194     }
22195
22196   return this_type;
22197 }
22198
22199 /* See if we can figure out if the class lives in a namespace.  We do
22200    this by looking for a member function; its demangled name will
22201    contain namespace info, if there is any.
22202    Return the computed name or NULL.
22203    Space for the result is allocated on the objfile's obstack.
22204    This is the full-die version of guess_partial_die_structure_name.
22205    In this case we know DIE has no useful parent.  */
22206
22207 static char *
22208 guess_full_die_structure_name (struct die_info *die, struct dwarf2_cu *cu)
22209 {
22210   struct die_info *spec_die;
22211   struct dwarf2_cu *spec_cu;
22212   struct die_info *child;
22213   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22214
22215   spec_cu = cu;
22216   spec_die = die_specification (die, &spec_cu);
22217   if (spec_die != NULL)
22218     {
22219       die = spec_die;
22220       cu = spec_cu;
22221     }
22222
22223   for (child = die->child;
22224        child != NULL;
22225        child = child->sibling)
22226     {
22227       if (child->tag == DW_TAG_subprogram)
22228         {
22229           const char *linkage_name = dw2_linkage_name (child, cu);
22230
22231           if (linkage_name != NULL)
22232             {
22233               char *actual_name
22234                 = language_class_name_from_physname (cu->language_defn,
22235                                                      linkage_name);
22236               char *name = NULL;
22237
22238               if (actual_name != NULL)
22239                 {
22240                   const char *die_name = dwarf2_name (die, cu);
22241
22242                   if (die_name != NULL
22243                       && strcmp (die_name, actual_name) != 0)
22244                     {
22245                       /* Strip off the class name from the full name.
22246                          We want the prefix.  */
22247                       int die_name_len = strlen (die_name);
22248                       int actual_name_len = strlen (actual_name);
22249
22250                       /* Test for '::' as a sanity check.  */
22251                       if (actual_name_len > die_name_len + 2
22252                           && actual_name[actual_name_len
22253                                          - die_name_len - 1] == ':')
22254                         name = (char *) obstack_copy0 (
22255                           &objfile->per_bfd->storage_obstack,
22256                           actual_name, actual_name_len - die_name_len - 2);
22257                     }
22258                 }
22259               xfree (actual_name);
22260               return name;
22261             }
22262         }
22263     }
22264
22265   return NULL;
22266 }
22267
22268 /* GCC might emit a nameless typedef that has a linkage name.  Determine the
22269    prefix part in such case.  See
22270    http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510.  */
22271
22272 static const char *
22273 anonymous_struct_prefix (struct die_info *die, struct dwarf2_cu *cu)
22274 {
22275   struct attribute *attr;
22276   const char *base;
22277
22278   if (die->tag != DW_TAG_class_type && die->tag != DW_TAG_interface_type
22279       && die->tag != DW_TAG_structure_type && die->tag != DW_TAG_union_type)
22280     return NULL;
22281
22282   if (dwarf2_string_attr (die, DW_AT_name, cu) != NULL)
22283     return NULL;
22284
22285   attr = dw2_linkage_name_attr (die, cu);
22286   if (attr == NULL || DW_STRING (attr) == NULL)
22287     return NULL;
22288
22289   /* dwarf2_name had to be already called.  */
22290   gdb_assert (DW_STRING_IS_CANONICAL (attr));
22291
22292   /* Strip the base name, keep any leading namespaces/classes.  */
22293   base = strrchr (DW_STRING (attr), ':');
22294   if (base == NULL || base == DW_STRING (attr) || base[-1] != ':')
22295     return "";
22296
22297   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22298   return (char *) obstack_copy0 (&objfile->per_bfd->storage_obstack,
22299                                  DW_STRING (attr),
22300                                  &base[-1] - DW_STRING (attr));
22301 }
22302
22303 /* Return the name of the namespace/class that DIE is defined within,
22304    or "" if we can't tell.  The caller should not xfree the result.
22305
22306    For example, if we're within the method foo() in the following
22307    code:
22308
22309    namespace N {
22310      class C {
22311        void foo () {
22312        }
22313      };
22314    }
22315
22316    then determine_prefix on foo's die will return "N::C".  */
22317
22318 static const char *
22319 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
22320 {
22321   struct dwarf2_per_objfile *dwarf2_per_objfile
22322     = cu->per_cu->dwarf2_per_objfile;
22323   struct die_info *parent, *spec_die;
22324   struct dwarf2_cu *spec_cu;
22325   struct type *parent_type;
22326   const char *retval;
22327
22328   if (cu->language != language_cplus
22329       && cu->language != language_fortran && cu->language != language_d
22330       && cu->language != language_rust)
22331     return "";
22332
22333   retval = anonymous_struct_prefix (die, cu);
22334   if (retval)
22335     return retval;
22336
22337   /* We have to be careful in the presence of DW_AT_specification.
22338      For example, with GCC 3.4, given the code
22339
22340      namespace N {
22341        void foo() {
22342          // Definition of N::foo.
22343        }
22344      }
22345
22346      then we'll have a tree of DIEs like this:
22347
22348      1: DW_TAG_compile_unit
22349        2: DW_TAG_namespace        // N
22350          3: DW_TAG_subprogram     // declaration of N::foo
22351        4: DW_TAG_subprogram       // definition of N::foo
22352             DW_AT_specification   // refers to die #3
22353
22354      Thus, when processing die #4, we have to pretend that we're in
22355      the context of its DW_AT_specification, namely the contex of die
22356      #3.  */
22357   spec_cu = cu;
22358   spec_die = die_specification (die, &spec_cu);
22359   if (spec_die == NULL)
22360     parent = die->parent;
22361   else
22362     {
22363       parent = spec_die->parent;
22364       cu = spec_cu;
22365     }
22366
22367   if (parent == NULL)
22368     return "";
22369   else if (parent->building_fullname)
22370     {
22371       const char *name;
22372       const char *parent_name;
22373
22374       /* It has been seen on RealView 2.2 built binaries,
22375          DW_TAG_template_type_param types actually _defined_ as
22376          children of the parent class:
22377
22378          enum E {};
22379          template class <class Enum> Class{};
22380          Class<enum E> class_e;
22381
22382          1: DW_TAG_class_type (Class)
22383            2: DW_TAG_enumeration_type (E)
22384              3: DW_TAG_enumerator (enum1:0)
22385              3: DW_TAG_enumerator (enum2:1)
22386              ...
22387            2: DW_TAG_template_type_param
22388               DW_AT_type  DW_FORM_ref_udata (E)
22389
22390          Besides being broken debug info, it can put GDB into an
22391          infinite loop.  Consider:
22392
22393          When we're building the full name for Class<E>, we'll start
22394          at Class, and go look over its template type parameters,
22395          finding E.  We'll then try to build the full name of E, and
22396          reach here.  We're now trying to build the full name of E,
22397          and look over the parent DIE for containing scope.  In the
22398          broken case, if we followed the parent DIE of E, we'd again
22399          find Class, and once again go look at its template type
22400          arguments, etc., etc.  Simply don't consider such parent die
22401          as source-level parent of this die (it can't be, the language
22402          doesn't allow it), and break the loop here.  */
22403       name = dwarf2_name (die, cu);
22404       parent_name = dwarf2_name (parent, cu);
22405       complaint (_("template param type '%s' defined within parent '%s'"),
22406                  name ? name : "<unknown>",
22407                  parent_name ? parent_name : "<unknown>");
22408       return "";
22409     }
22410   else
22411     switch (parent->tag)
22412       {
22413       case DW_TAG_namespace:
22414         parent_type = read_type_die (parent, cu);
22415         /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
22416            DW_TAG_namespace DIEs with a name of "::" for the global namespace.
22417            Work around this problem here.  */
22418         if (cu->language == language_cplus
22419             && strcmp (TYPE_NAME (parent_type), "::") == 0)
22420           return "";
22421         /* We give a name to even anonymous namespaces.  */
22422         return TYPE_NAME (parent_type);
22423       case DW_TAG_class_type:
22424       case DW_TAG_interface_type:
22425       case DW_TAG_structure_type:
22426       case DW_TAG_union_type:
22427       case DW_TAG_module:
22428         parent_type = read_type_die (parent, cu);
22429         if (TYPE_NAME (parent_type) != NULL)
22430           return TYPE_NAME (parent_type);
22431         else
22432           /* An anonymous structure is only allowed non-static data
22433              members; no typedefs, no member functions, et cetera.
22434              So it does not need a prefix.  */
22435           return "";
22436       case DW_TAG_compile_unit:
22437       case DW_TAG_partial_unit:
22438         /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace.  Cope.  */
22439         if (cu->language == language_cplus
22440             && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
22441             && die->child != NULL
22442             && (die->tag == DW_TAG_class_type
22443                 || die->tag == DW_TAG_structure_type
22444                 || die->tag == DW_TAG_union_type))
22445           {
22446             char *name = guess_full_die_structure_name (die, cu);
22447             if (name != NULL)
22448               return name;
22449           }
22450         return "";
22451       case DW_TAG_enumeration_type:
22452         parent_type = read_type_die (parent, cu);
22453         if (TYPE_DECLARED_CLASS (parent_type))
22454           {
22455             if (TYPE_NAME (parent_type) != NULL)
22456               return TYPE_NAME (parent_type);
22457             return "";
22458           }
22459         /* Fall through.  */
22460       default:
22461         return determine_prefix (parent, cu);
22462       }
22463 }
22464
22465 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
22466    with appropriate separator.  If PREFIX or SUFFIX is NULL or empty, then
22467    simply copy the SUFFIX or PREFIX, respectively.  If OBS is non-null, perform
22468    an obconcat, otherwise allocate storage for the result.  The CU argument is
22469    used to determine the language and hence, the appropriate separator.  */
22470
22471 #define MAX_SEP_LEN 7  /* strlen ("__") + strlen ("_MOD_")  */
22472
22473 static char *
22474 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
22475                  int physname, struct dwarf2_cu *cu)
22476 {
22477   const char *lead = "";
22478   const char *sep;
22479
22480   if (suffix == NULL || suffix[0] == '\0'
22481       || prefix == NULL || prefix[0] == '\0')
22482     sep = "";
22483   else if (cu->language == language_d)
22484     {
22485       /* For D, the 'main' function could be defined in any module, but it
22486          should never be prefixed.  */
22487       if (strcmp (suffix, "D main") == 0)
22488         {
22489           prefix = "";
22490           sep = "";
22491         }
22492       else
22493         sep = ".";
22494     }
22495   else if (cu->language == language_fortran && physname)
22496     {
22497       /* This is gfortran specific mangling.  Normally DW_AT_linkage_name or
22498          DW_AT_MIPS_linkage_name is preferred and used instead.  */
22499
22500       lead = "__";
22501       sep = "_MOD_";
22502     }
22503   else
22504     sep = "::";
22505
22506   if (prefix == NULL)
22507     prefix = "";
22508   if (suffix == NULL)
22509     suffix = "";
22510
22511   if (obs == NULL)
22512     {
22513       char *retval
22514         = ((char *)
22515            xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1));
22516
22517       strcpy (retval, lead);
22518       strcat (retval, prefix);
22519       strcat (retval, sep);
22520       strcat (retval, suffix);
22521       return retval;
22522     }
22523   else
22524     {
22525       /* We have an obstack.  */
22526       return obconcat (obs, lead, prefix, sep, suffix, (char *) NULL);
22527     }
22528 }
22529
22530 /* Return sibling of die, NULL if no sibling.  */
22531
22532 static struct die_info *
22533 sibling_die (struct die_info *die)
22534 {
22535   return die->sibling;
22536 }
22537
22538 /* Get name of a die, return NULL if not found.  */
22539
22540 static const char *
22541 dwarf2_canonicalize_name (const char *name, struct dwarf2_cu *cu,
22542                           struct obstack *obstack)
22543 {
22544   if (name && cu->language == language_cplus)
22545     {
22546       std::string canon_name = cp_canonicalize_string (name);
22547
22548       if (!canon_name.empty ())
22549         {
22550           if (canon_name != name)
22551             name = (const char *) obstack_copy0 (obstack,
22552                                                  canon_name.c_str (),
22553                                                  canon_name.length ());
22554         }
22555     }
22556
22557   return name;
22558 }
22559
22560 /* Get name of a die, return NULL if not found.
22561    Anonymous namespaces are converted to their magic string.  */
22562
22563 static const char *
22564 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
22565 {
22566   struct attribute *attr;
22567   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22568
22569   attr = dwarf2_attr (die, DW_AT_name, cu);
22570   if ((!attr || !DW_STRING (attr))
22571       && die->tag != DW_TAG_namespace
22572       && die->tag != DW_TAG_class_type
22573       && die->tag != DW_TAG_interface_type
22574       && die->tag != DW_TAG_structure_type
22575       && die->tag != DW_TAG_union_type)
22576     return NULL;
22577
22578   switch (die->tag)
22579     {
22580     case DW_TAG_compile_unit:
22581     case DW_TAG_partial_unit:
22582       /* Compilation units have a DW_AT_name that is a filename, not
22583          a source language identifier.  */
22584     case DW_TAG_enumeration_type:
22585     case DW_TAG_enumerator:
22586       /* These tags always have simple identifiers already; no need
22587          to canonicalize them.  */
22588       return DW_STRING (attr);
22589
22590     case DW_TAG_namespace:
22591       if (attr != NULL && DW_STRING (attr) != NULL)
22592         return DW_STRING (attr);
22593       return CP_ANONYMOUS_NAMESPACE_STR;
22594
22595     case DW_TAG_class_type:
22596     case DW_TAG_interface_type:
22597     case DW_TAG_structure_type:
22598     case DW_TAG_union_type:
22599       /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
22600          structures or unions.  These were of the form "._%d" in GCC 4.1,
22601          or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
22602          and GCC 4.4.  We work around this problem by ignoring these.  */
22603       if (attr && DW_STRING (attr)
22604           && (startswith (DW_STRING (attr), "._")
22605               || startswith (DW_STRING (attr), "<anonymous")))
22606         return NULL;
22607
22608       /* GCC might emit a nameless typedef that has a linkage name.  See
22609          http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510.  */
22610       if (!attr || DW_STRING (attr) == NULL)
22611         {
22612           char *demangled = NULL;
22613
22614           attr = dw2_linkage_name_attr (die, cu);
22615           if (attr == NULL || DW_STRING (attr) == NULL)
22616             return NULL;
22617
22618           /* Avoid demangling DW_STRING (attr) the second time on a second
22619              call for the same DIE.  */
22620           if (!DW_STRING_IS_CANONICAL (attr))
22621             demangled = gdb_demangle (DW_STRING (attr), DMGL_TYPES);
22622
22623           if (demangled)
22624             {
22625               const char *base;
22626
22627               /* FIXME: we already did this for the partial symbol... */
22628               DW_STRING (attr)
22629                 = ((const char *)
22630                    obstack_copy0 (&objfile->per_bfd->storage_obstack,
22631                                   demangled, strlen (demangled)));
22632               DW_STRING_IS_CANONICAL (attr) = 1;
22633               xfree (demangled);
22634
22635               /* Strip any leading namespaces/classes, keep only the base name.
22636                  DW_AT_name for named DIEs does not contain the prefixes.  */
22637               base = strrchr (DW_STRING (attr), ':');
22638               if (base && base > DW_STRING (attr) && base[-1] == ':')
22639                 return &base[1];
22640               else
22641                 return DW_STRING (attr);
22642             }
22643         }
22644       break;
22645
22646     default:
22647       break;
22648     }
22649
22650   if (!DW_STRING_IS_CANONICAL (attr))
22651     {
22652       DW_STRING (attr)
22653         = dwarf2_canonicalize_name (DW_STRING (attr), cu,
22654                                     &objfile->per_bfd->storage_obstack);
22655       DW_STRING_IS_CANONICAL (attr) = 1;
22656     }
22657   return DW_STRING (attr);
22658 }
22659
22660 /* Return the die that this die in an extension of, or NULL if there
22661    is none.  *EXT_CU is the CU containing DIE on input, and the CU
22662    containing the return value on output.  */
22663
22664 static struct die_info *
22665 dwarf2_extension (struct die_info *die, struct dwarf2_cu **ext_cu)
22666 {
22667   struct attribute *attr;
22668
22669   attr = dwarf2_attr (die, DW_AT_extension, *ext_cu);
22670   if (attr == NULL)
22671     return NULL;
22672
22673   return follow_die_ref (die, attr, ext_cu);
22674 }
22675
22676 /* Convert a DIE tag into its string name.  */
22677
22678 static const char *
22679 dwarf_tag_name (unsigned tag)
22680 {
22681   const char *name = get_DW_TAG_name (tag);
22682
22683   if (name == NULL)
22684     return "DW_TAG_<unknown>";
22685
22686   return name;
22687 }
22688
22689 /* Convert a DWARF attribute code into its string name.  */
22690
22691 static const char *
22692 dwarf_attr_name (unsigned attr)
22693 {
22694   const char *name;
22695
22696 #ifdef MIPS /* collides with DW_AT_HP_block_index */
22697   if (attr == DW_AT_MIPS_fde)
22698     return "DW_AT_MIPS_fde";
22699 #else
22700   if (attr == DW_AT_HP_block_index)
22701     return "DW_AT_HP_block_index";
22702 #endif
22703
22704   name = get_DW_AT_name (attr);
22705
22706   if (name == NULL)
22707     return "DW_AT_<unknown>";
22708
22709   return name;
22710 }
22711
22712 /* Convert a DWARF value form code into its string name.  */
22713
22714 static const char *
22715 dwarf_form_name (unsigned form)
22716 {
22717   const char *name = get_DW_FORM_name (form);
22718
22719   if (name == NULL)
22720     return "DW_FORM_<unknown>";
22721
22722   return name;
22723 }
22724
22725 static const char *
22726 dwarf_bool_name (unsigned mybool)
22727 {
22728   if (mybool)
22729     return "TRUE";
22730   else
22731     return "FALSE";
22732 }
22733
22734 /* Convert a DWARF type code into its string name.  */
22735
22736 static const char *
22737 dwarf_type_encoding_name (unsigned enc)
22738 {
22739   const char *name = get_DW_ATE_name (enc);
22740
22741   if (name == NULL)
22742     return "DW_ATE_<unknown>";
22743
22744   return name;
22745 }
22746
22747 static void
22748 dump_die_shallow (struct ui_file *f, int indent, struct die_info *die)
22749 {
22750   unsigned int i;
22751
22752   print_spaces (indent, f);
22753   fprintf_unfiltered (f, "Die: %s (abbrev %d, offset %s)\n",
22754                       dwarf_tag_name (die->tag), die->abbrev,
22755                       sect_offset_str (die->sect_off));
22756
22757   if (die->parent != NULL)
22758     {
22759       print_spaces (indent, f);
22760       fprintf_unfiltered (f, "  parent at offset: %s\n",
22761                           sect_offset_str (die->parent->sect_off));
22762     }
22763
22764   print_spaces (indent, f);
22765   fprintf_unfiltered (f, "  has children: %s\n",
22766            dwarf_bool_name (die->child != NULL));
22767
22768   print_spaces (indent, f);
22769   fprintf_unfiltered (f, "  attributes:\n");
22770
22771   for (i = 0; i < die->num_attrs; ++i)
22772     {
22773       print_spaces (indent, f);
22774       fprintf_unfiltered (f, "    %s (%s) ",
22775                dwarf_attr_name (die->attrs[i].name),
22776                dwarf_form_name (die->attrs[i].form));
22777
22778       switch (die->attrs[i].form)
22779         {
22780         case DW_FORM_addr:
22781         case DW_FORM_GNU_addr_index:
22782           fprintf_unfiltered (f, "address: ");
22783           fputs_filtered (hex_string (DW_ADDR (&die->attrs[i])), f);
22784           break;
22785         case DW_FORM_block2:
22786         case DW_FORM_block4:
22787         case DW_FORM_block:
22788         case DW_FORM_block1:
22789           fprintf_unfiltered (f, "block: size %s",
22790                               pulongest (DW_BLOCK (&die->attrs[i])->size));
22791           break;
22792         case DW_FORM_exprloc:
22793           fprintf_unfiltered (f, "expression: size %s",
22794                               pulongest (DW_BLOCK (&die->attrs[i])->size));
22795           break;
22796         case DW_FORM_data16:
22797           fprintf_unfiltered (f, "constant of 16 bytes");
22798           break;
22799         case DW_FORM_ref_addr:
22800           fprintf_unfiltered (f, "ref address: ");
22801           fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
22802           break;
22803         case DW_FORM_GNU_ref_alt:
22804           fprintf_unfiltered (f, "alt ref address: ");
22805           fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
22806           break;
22807         case DW_FORM_ref1:
22808         case DW_FORM_ref2:
22809         case DW_FORM_ref4:
22810         case DW_FORM_ref8:
22811         case DW_FORM_ref_udata:
22812           fprintf_unfiltered (f, "constant ref: 0x%lx (adjusted)",
22813                               (long) (DW_UNSND (&die->attrs[i])));
22814           break;
22815         case DW_FORM_data1:
22816         case DW_FORM_data2:
22817         case DW_FORM_data4:
22818         case DW_FORM_data8:
22819         case DW_FORM_udata:
22820         case DW_FORM_sdata:
22821           fprintf_unfiltered (f, "constant: %s",
22822                               pulongest (DW_UNSND (&die->attrs[i])));
22823           break;
22824         case DW_FORM_sec_offset:
22825           fprintf_unfiltered (f, "section offset: %s",
22826                               pulongest (DW_UNSND (&die->attrs[i])));
22827           break;
22828         case DW_FORM_ref_sig8:
22829           fprintf_unfiltered (f, "signature: %s",
22830                               hex_string (DW_SIGNATURE (&die->attrs[i])));
22831           break;
22832         case DW_FORM_string:
22833         case DW_FORM_strp:
22834         case DW_FORM_line_strp:
22835         case DW_FORM_GNU_str_index:
22836         case DW_FORM_GNU_strp_alt:
22837           fprintf_unfiltered (f, "string: \"%s\" (%s canonicalized)",
22838                    DW_STRING (&die->attrs[i])
22839                    ? DW_STRING (&die->attrs[i]) : "",
22840                    DW_STRING_IS_CANONICAL (&die->attrs[i]) ? "is" : "not");
22841           break;
22842         case DW_FORM_flag:
22843           if (DW_UNSND (&die->attrs[i]))
22844             fprintf_unfiltered (f, "flag: TRUE");
22845           else
22846             fprintf_unfiltered (f, "flag: FALSE");
22847           break;
22848         case DW_FORM_flag_present:
22849           fprintf_unfiltered (f, "flag: TRUE");
22850           break;
22851         case DW_FORM_indirect:
22852           /* The reader will have reduced the indirect form to
22853              the "base form" so this form should not occur.  */
22854           fprintf_unfiltered (f, 
22855                               "unexpected attribute form: DW_FORM_indirect");
22856           break;
22857         case DW_FORM_implicit_const:
22858           fprintf_unfiltered (f, "constant: %s",
22859                               plongest (DW_SND (&die->attrs[i])));
22860           break;
22861         default:
22862           fprintf_unfiltered (f, "unsupported attribute form: %d.",
22863                    die->attrs[i].form);
22864           break;
22865         }
22866       fprintf_unfiltered (f, "\n");
22867     }
22868 }
22869
22870 static void
22871 dump_die_for_error (struct die_info *die)
22872 {
22873   dump_die_shallow (gdb_stderr, 0, die);
22874 }
22875
22876 static void
22877 dump_die_1 (struct ui_file *f, int level, int max_level, struct die_info *die)
22878 {
22879   int indent = level * 4;
22880
22881   gdb_assert (die != NULL);
22882
22883   if (level >= max_level)
22884     return;
22885
22886   dump_die_shallow (f, indent, die);
22887
22888   if (die->child != NULL)
22889     {
22890       print_spaces (indent, f);
22891       fprintf_unfiltered (f, "  Children:");
22892       if (level + 1 < max_level)
22893         {
22894           fprintf_unfiltered (f, "\n");
22895           dump_die_1 (f, level + 1, max_level, die->child);
22896         }
22897       else
22898         {
22899           fprintf_unfiltered (f,
22900                               " [not printed, max nesting level reached]\n");
22901         }
22902     }
22903
22904   if (die->sibling != NULL && level > 0)
22905     {
22906       dump_die_1 (f, level, max_level, die->sibling);
22907     }
22908 }
22909
22910 /* This is called from the pdie macro in gdbinit.in.
22911    It's not static so gcc will keep a copy callable from gdb.  */
22912
22913 void
22914 dump_die (struct die_info *die, int max_level)
22915 {
22916   dump_die_1 (gdb_stdlog, 0, max_level, die);
22917 }
22918
22919 static void
22920 store_in_ref_table (struct die_info *die, struct dwarf2_cu *cu)
22921 {
22922   void **slot;
22923
22924   slot = htab_find_slot_with_hash (cu->die_hash, die,
22925                                    to_underlying (die->sect_off),
22926                                    INSERT);
22927
22928   *slot = die;
22929 }
22930
22931 /* Return DIE offset of ATTR.  Return 0 with complaint if ATTR is not of the
22932    required kind.  */
22933
22934 static sect_offset
22935 dwarf2_get_ref_die_offset (const struct attribute *attr)
22936 {
22937   if (attr_form_is_ref (attr))
22938     return (sect_offset) DW_UNSND (attr);
22939
22940   complaint (_("unsupported die ref attribute form: '%s'"),
22941              dwarf_form_name (attr->form));
22942   return {};
22943 }
22944
22945 /* Return the constant value held by ATTR.  Return DEFAULT_VALUE if
22946  * the value held by the attribute is not constant.  */
22947
22948 static LONGEST
22949 dwarf2_get_attr_constant_value (const struct attribute *attr, int default_value)
22950 {
22951   if (attr->form == DW_FORM_sdata || attr->form == DW_FORM_implicit_const)
22952     return DW_SND (attr);
22953   else if (attr->form == DW_FORM_udata
22954            || attr->form == DW_FORM_data1
22955            || attr->form == DW_FORM_data2
22956            || attr->form == DW_FORM_data4
22957            || attr->form == DW_FORM_data8)
22958     return DW_UNSND (attr);
22959   else
22960     {
22961       /* For DW_FORM_data16 see attr_form_is_constant.  */
22962       complaint (_("Attribute value is not a constant (%s)"),
22963                  dwarf_form_name (attr->form));
22964       return default_value;
22965     }
22966 }
22967
22968 /* Follow reference or signature attribute ATTR of SRC_DIE.
22969    On entry *REF_CU is the CU of SRC_DIE.
22970    On exit *REF_CU is the CU of the result.  */
22971
22972 static struct die_info *
22973 follow_die_ref_or_sig (struct die_info *src_die, const struct attribute *attr,
22974                        struct dwarf2_cu **ref_cu)
22975 {
22976   struct die_info *die;
22977
22978   if (attr_form_is_ref (attr))
22979     die = follow_die_ref (src_die, attr, ref_cu);
22980   else if (attr->form == DW_FORM_ref_sig8)
22981     die = follow_die_sig (src_die, attr, ref_cu);
22982   else
22983     {
22984       dump_die_for_error (src_die);
22985       error (_("Dwarf Error: Expected reference attribute [in module %s]"),
22986              objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
22987     }
22988
22989   return die;
22990 }
22991
22992 /* Follow reference OFFSET.
22993    On entry *REF_CU is the CU of the source die referencing OFFSET.
22994    On exit *REF_CU is the CU of the result.
22995    Returns NULL if OFFSET is invalid.  */
22996
22997 static struct die_info *
22998 follow_die_offset (sect_offset sect_off, int offset_in_dwz,
22999                    struct dwarf2_cu **ref_cu)
23000 {
23001   struct die_info temp_die;
23002   struct dwarf2_cu *target_cu, *cu = *ref_cu;
23003   struct dwarf2_per_objfile *dwarf2_per_objfile
23004     = cu->per_cu->dwarf2_per_objfile;
23005
23006   gdb_assert (cu->per_cu != NULL);
23007
23008   target_cu = cu;
23009
23010   if (cu->per_cu->is_debug_types)
23011     {
23012       /* .debug_types CUs cannot reference anything outside their CU.
23013          If they need to, they have to reference a signatured type via
23014          DW_FORM_ref_sig8.  */
23015       if (!offset_in_cu_p (&cu->header, sect_off))
23016         return NULL;
23017     }
23018   else if (offset_in_dwz != cu->per_cu->is_dwz
23019            || !offset_in_cu_p (&cu->header, sect_off))
23020     {
23021       struct dwarf2_per_cu_data *per_cu;
23022
23023       per_cu = dwarf2_find_containing_comp_unit (sect_off, offset_in_dwz,
23024                                                  dwarf2_per_objfile);
23025
23026       /* If necessary, add it to the queue and load its DIEs.  */
23027       if (maybe_queue_comp_unit (cu, per_cu, cu->language))
23028         load_full_comp_unit (per_cu, false, cu->language);
23029
23030       target_cu = per_cu->cu;
23031     }
23032   else if (cu->dies == NULL)
23033     {
23034       /* We're loading full DIEs during partial symbol reading.  */
23035       gdb_assert (dwarf2_per_objfile->reading_partial_symbols);
23036       load_full_comp_unit (cu->per_cu, false, language_minimal);
23037     }
23038
23039   *ref_cu = target_cu;
23040   temp_die.sect_off = sect_off;
23041
23042   if (target_cu != cu)
23043     target_cu->ancestor = cu;
23044
23045   return (struct die_info *) htab_find_with_hash (target_cu->die_hash,
23046                                                   &temp_die,
23047                                                   to_underlying (sect_off));
23048 }
23049
23050 /* Follow reference attribute ATTR of SRC_DIE.
23051    On entry *REF_CU is the CU of SRC_DIE.
23052    On exit *REF_CU is the CU of the result.  */
23053
23054 static struct die_info *
23055 follow_die_ref (struct die_info *src_die, const struct attribute *attr,
23056                 struct dwarf2_cu **ref_cu)
23057 {
23058   sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
23059   struct dwarf2_cu *cu = *ref_cu;
23060   struct die_info *die;
23061
23062   die = follow_die_offset (sect_off,
23063                            (attr->form == DW_FORM_GNU_ref_alt
23064                             || cu->per_cu->is_dwz),
23065                            ref_cu);
23066   if (!die)
23067     error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
23068            "at %s [in module %s]"),
23069            sect_offset_str (sect_off), sect_offset_str (src_die->sect_off),
23070            objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
23071
23072   return die;
23073 }
23074
23075 /* Return DWARF block referenced by DW_AT_location of DIE at SECT_OFF at PER_CU.
23076    Returned value is intended for DW_OP_call*.  Returned
23077    dwarf2_locexpr_baton->data has lifetime of
23078    PER_CU->DWARF2_PER_OBJFILE->OBJFILE.  */
23079
23080 struct dwarf2_locexpr_baton
23081 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off,
23082                                struct dwarf2_per_cu_data *per_cu,
23083                                CORE_ADDR (*get_frame_pc) (void *baton),
23084                                void *baton, bool resolve_abstract_p)
23085 {
23086   struct dwarf2_cu *cu;
23087   struct die_info *die;
23088   struct attribute *attr;
23089   struct dwarf2_locexpr_baton retval;
23090   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
23091   struct objfile *objfile = dwarf2_per_objfile->objfile;
23092
23093   if (per_cu->cu == NULL)
23094     load_cu (per_cu, false);
23095   cu = per_cu->cu;
23096   if (cu == NULL)
23097     {
23098       /* We shouldn't get here for a dummy CU, but don't crash on the user.
23099          Instead just throw an error, not much else we can do.  */
23100       error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23101              sect_offset_str (sect_off), objfile_name (objfile));
23102     }
23103
23104   die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23105   if (!die)
23106     error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23107            sect_offset_str (sect_off), objfile_name (objfile));
23108
23109   attr = dwarf2_attr (die, DW_AT_location, cu);
23110   if (!attr && resolve_abstract_p
23111       && (dwarf2_per_objfile->abstract_to_concrete.find (die)
23112           != dwarf2_per_objfile->abstract_to_concrete.end ()))
23113     {
23114       CORE_ADDR pc = (*get_frame_pc) (baton);
23115
23116       for (const auto &cand : dwarf2_per_objfile->abstract_to_concrete[die])
23117         {
23118           if (!cand->parent
23119               || cand->parent->tag != DW_TAG_subprogram)
23120             continue;
23121
23122           CORE_ADDR pc_low, pc_high;
23123           get_scope_pc_bounds (cand->parent, &pc_low, &pc_high, cu);
23124           if (pc_low == ((CORE_ADDR) -1)
23125               || !(pc_low <= pc && pc < pc_high))
23126             continue;
23127
23128           die = cand;
23129           attr = dwarf2_attr (die, DW_AT_location, cu);
23130           break;
23131         }
23132     }
23133
23134   if (!attr)
23135     {
23136       /* DWARF: "If there is no such attribute, then there is no effect.".
23137          DATA is ignored if SIZE is 0.  */
23138
23139       retval.data = NULL;
23140       retval.size = 0;
23141     }
23142   else if (attr_form_is_section_offset (attr))
23143     {
23144       struct dwarf2_loclist_baton loclist_baton;
23145       CORE_ADDR pc = (*get_frame_pc) (baton);
23146       size_t size;
23147
23148       fill_in_loclist_baton (cu, &loclist_baton, attr);
23149
23150       retval.data = dwarf2_find_location_expression (&loclist_baton,
23151                                                      &size, pc);
23152       retval.size = size;
23153     }
23154   else
23155     {
23156       if (!attr_form_is_block (attr))
23157         error (_("Dwarf Error: DIE at %s referenced in module %s "
23158                  "is neither DW_FORM_block* nor DW_FORM_exprloc"),
23159                sect_offset_str (sect_off), objfile_name (objfile));
23160
23161       retval.data = DW_BLOCK (attr)->data;
23162       retval.size = DW_BLOCK (attr)->size;
23163     }
23164   retval.per_cu = cu->per_cu;
23165
23166   age_cached_comp_units (dwarf2_per_objfile);
23167
23168   return retval;
23169 }
23170
23171 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
23172    offset.  */
23173
23174 struct dwarf2_locexpr_baton
23175 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu,
23176                              struct dwarf2_per_cu_data *per_cu,
23177                              CORE_ADDR (*get_frame_pc) (void *baton),
23178                              void *baton)
23179 {
23180   sect_offset sect_off = per_cu->sect_off + to_underlying (offset_in_cu);
23181
23182   return dwarf2_fetch_die_loc_sect_off (sect_off, per_cu, get_frame_pc, baton);
23183 }
23184
23185 /* Write a constant of a given type as target-ordered bytes into
23186    OBSTACK.  */
23187
23188 static const gdb_byte *
23189 write_constant_as_bytes (struct obstack *obstack,
23190                          enum bfd_endian byte_order,
23191                          struct type *type,
23192                          ULONGEST value,
23193                          LONGEST *len)
23194 {
23195   gdb_byte *result;
23196
23197   *len = TYPE_LENGTH (type);
23198   result = (gdb_byte *) obstack_alloc (obstack, *len);
23199   store_unsigned_integer (result, *len, byte_order, value);
23200
23201   return result;
23202 }
23203
23204 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
23205    pointer to the constant bytes and set LEN to the length of the
23206    data.  If memory is needed, allocate it on OBSTACK.  If the DIE
23207    does not have a DW_AT_const_value, return NULL.  */
23208
23209 const gdb_byte *
23210 dwarf2_fetch_constant_bytes (sect_offset sect_off,
23211                              struct dwarf2_per_cu_data *per_cu,
23212                              struct obstack *obstack,
23213                              LONGEST *len)
23214 {
23215   struct dwarf2_cu *cu;
23216   struct die_info *die;
23217   struct attribute *attr;
23218   const gdb_byte *result = NULL;
23219   struct type *type;
23220   LONGEST value;
23221   enum bfd_endian byte_order;
23222   struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
23223
23224   if (per_cu->cu == NULL)
23225     load_cu (per_cu, false);
23226   cu = per_cu->cu;
23227   if (cu == NULL)
23228     {
23229       /* We shouldn't get here for a dummy CU, but don't crash on the user.
23230          Instead just throw an error, not much else we can do.  */
23231       error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23232              sect_offset_str (sect_off), objfile_name (objfile));
23233     }
23234
23235   die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23236   if (!die)
23237     error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23238            sect_offset_str (sect_off), objfile_name (objfile));
23239
23240   attr = dwarf2_attr (die, DW_AT_const_value, cu);
23241   if (attr == NULL)
23242     return NULL;
23243
23244   byte_order = (bfd_big_endian (objfile->obfd)
23245                 ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
23246
23247   switch (attr->form)
23248     {
23249     case DW_FORM_addr:
23250     case DW_FORM_GNU_addr_index:
23251       {
23252         gdb_byte *tem;
23253
23254         *len = cu->header.addr_size;
23255         tem = (gdb_byte *) obstack_alloc (obstack, *len);
23256         store_unsigned_integer (tem, *len, byte_order, DW_ADDR (attr));
23257         result = tem;
23258       }
23259       break;
23260     case DW_FORM_string:
23261     case DW_FORM_strp:
23262     case DW_FORM_GNU_str_index:
23263     case DW_FORM_GNU_strp_alt:
23264       /* DW_STRING is already allocated on the objfile obstack, point
23265          directly to it.  */
23266       result = (const gdb_byte *) DW_STRING (attr);
23267       *len = strlen (DW_STRING (attr));
23268       break;
23269     case DW_FORM_block1:
23270     case DW_FORM_block2:
23271     case DW_FORM_block4:
23272     case DW_FORM_block:
23273     case DW_FORM_exprloc:
23274     case DW_FORM_data16:
23275       result = DW_BLOCK (attr)->data;
23276       *len = DW_BLOCK (attr)->size;
23277       break;
23278
23279       /* The DW_AT_const_value attributes are supposed to carry the
23280          symbol's value "represented as it would be on the target
23281          architecture."  By the time we get here, it's already been
23282          converted to host endianness, so we just need to sign- or
23283          zero-extend it as appropriate.  */
23284     case DW_FORM_data1:
23285       type = die_type (die, cu);
23286       result = dwarf2_const_value_data (attr, obstack, cu, &value, 8);
23287       if (result == NULL)
23288         result = write_constant_as_bytes (obstack, byte_order,
23289                                           type, value, len);
23290       break;
23291     case DW_FORM_data2:
23292       type = die_type (die, cu);
23293       result = dwarf2_const_value_data (attr, obstack, cu, &value, 16);
23294       if (result == NULL)
23295         result = write_constant_as_bytes (obstack, byte_order,
23296                                           type, value, len);
23297       break;
23298     case DW_FORM_data4:
23299       type = die_type (die, cu);
23300       result = dwarf2_const_value_data (attr, obstack, cu, &value, 32);
23301       if (result == NULL)
23302         result = write_constant_as_bytes (obstack, byte_order,
23303                                           type, value, len);
23304       break;
23305     case DW_FORM_data8:
23306       type = die_type (die, cu);
23307       result = dwarf2_const_value_data (attr, obstack, cu, &value, 64);
23308       if (result == NULL)
23309         result = write_constant_as_bytes (obstack, byte_order,
23310                                           type, value, len);
23311       break;
23312
23313     case DW_FORM_sdata:
23314     case DW_FORM_implicit_const:
23315       type = die_type (die, cu);
23316       result = write_constant_as_bytes (obstack, byte_order,
23317                                         type, DW_SND (attr), len);
23318       break;
23319
23320     case DW_FORM_udata:
23321       type = die_type (die, cu);
23322       result = write_constant_as_bytes (obstack, byte_order,
23323                                         type, DW_UNSND (attr), len);
23324       break;
23325
23326     default:
23327       complaint (_("unsupported const value attribute form: '%s'"),
23328                  dwarf_form_name (attr->form));
23329       break;
23330     }
23331
23332   return result;
23333 }
23334
23335 /* Return the type of the die at OFFSET in PER_CU.  Return NULL if no
23336    valid type for this die is found.  */
23337
23338 struct type *
23339 dwarf2_fetch_die_type_sect_off (sect_offset sect_off,
23340                                 struct dwarf2_per_cu_data *per_cu)
23341 {
23342   struct dwarf2_cu *cu;
23343   struct die_info *die;
23344
23345   if (per_cu->cu == NULL)
23346     load_cu (per_cu, false);
23347   cu = per_cu->cu;
23348   if (!cu)
23349     return NULL;
23350
23351   die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23352   if (!die)
23353     return NULL;
23354
23355   return die_type (die, cu);
23356 }
23357
23358 /* Return the type of the DIE at DIE_OFFSET in the CU named by
23359    PER_CU.  */
23360
23361 struct type *
23362 dwarf2_get_die_type (cu_offset die_offset,
23363                      struct dwarf2_per_cu_data *per_cu)
23364 {
23365   sect_offset die_offset_sect = per_cu->sect_off + to_underlying (die_offset);
23366   return get_die_type_at_offset (die_offset_sect, per_cu);
23367 }
23368
23369 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
23370    On entry *REF_CU is the CU of SRC_DIE.
23371    On exit *REF_CU is the CU of the result.
23372    Returns NULL if the referenced DIE isn't found.  */
23373
23374 static struct die_info *
23375 follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type,
23376                   struct dwarf2_cu **ref_cu)
23377 {
23378   struct die_info temp_die;
23379   struct dwarf2_cu *sig_cu, *cu = *ref_cu;
23380   struct die_info *die;
23381
23382   /* While it might be nice to assert sig_type->type == NULL here,
23383      we can get here for DW_AT_imported_declaration where we need
23384      the DIE not the type.  */
23385
23386   /* If necessary, add it to the queue and load its DIEs.  */
23387
23388   if (maybe_queue_comp_unit (*ref_cu, &sig_type->per_cu, language_minimal))
23389     read_signatured_type (sig_type);
23390
23391   sig_cu = sig_type->per_cu.cu;
23392   gdb_assert (sig_cu != NULL);
23393   gdb_assert (to_underlying (sig_type->type_offset_in_section) != 0);
23394   temp_die.sect_off = sig_type->type_offset_in_section;
23395   die = (struct die_info *) htab_find_with_hash (sig_cu->die_hash, &temp_die,
23396                                                  to_underlying (temp_die.sect_off));
23397   if (die)
23398     {
23399       struct dwarf2_per_objfile *dwarf2_per_objfile
23400         = (*ref_cu)->per_cu->dwarf2_per_objfile;
23401
23402       /* For .gdb_index version 7 keep track of included TUs.
23403          http://sourceware.org/bugzilla/show_bug.cgi?id=15021.  */
23404       if (dwarf2_per_objfile->index_table != NULL
23405           && dwarf2_per_objfile->index_table->version <= 7)
23406         {
23407           VEC_safe_push (dwarf2_per_cu_ptr,
23408                          (*ref_cu)->per_cu->imported_symtabs,
23409                          sig_cu->per_cu);
23410         }
23411
23412       *ref_cu = sig_cu;
23413       if (sig_cu != cu)
23414         sig_cu->ancestor = cu;
23415
23416       return die;
23417     }
23418
23419   return NULL;
23420 }
23421
23422 /* Follow signatured type referenced by ATTR in SRC_DIE.
23423    On entry *REF_CU is the CU of SRC_DIE.
23424    On exit *REF_CU is the CU of the result.
23425    The result is the DIE of the type.
23426    If the referenced type cannot be found an error is thrown.  */
23427
23428 static struct die_info *
23429 follow_die_sig (struct die_info *src_die, const struct attribute *attr,
23430                 struct dwarf2_cu **ref_cu)
23431 {
23432   ULONGEST signature = DW_SIGNATURE (attr);
23433   struct signatured_type *sig_type;
23434   struct die_info *die;
23435
23436   gdb_assert (attr->form == DW_FORM_ref_sig8);
23437
23438   sig_type = lookup_signatured_type (*ref_cu, signature);
23439   /* sig_type will be NULL if the signatured type is missing from
23440      the debug info.  */
23441   if (sig_type == NULL)
23442     {
23443       error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23444                " from DIE at %s [in module %s]"),
23445              hex_string (signature), sect_offset_str (src_die->sect_off),
23446              objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23447     }
23448
23449   die = follow_die_sig_1 (src_die, sig_type, ref_cu);
23450   if (die == NULL)
23451     {
23452       dump_die_for_error (src_die);
23453       error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23454                " from DIE at %s [in module %s]"),
23455              hex_string (signature), sect_offset_str (src_die->sect_off),
23456              objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23457     }
23458
23459   return die;
23460 }
23461
23462 /* Get the type specified by SIGNATURE referenced in DIE/CU,
23463    reading in and processing the type unit if necessary.  */
23464
23465 static struct type *
23466 get_signatured_type (struct die_info *die, ULONGEST signature,
23467                      struct dwarf2_cu *cu)
23468 {
23469   struct dwarf2_per_objfile *dwarf2_per_objfile
23470     = cu->per_cu->dwarf2_per_objfile;
23471   struct signatured_type *sig_type;
23472   struct dwarf2_cu *type_cu;
23473   struct die_info *type_die;
23474   struct type *type;
23475
23476   sig_type = lookup_signatured_type (cu, signature);
23477   /* sig_type will be NULL if the signatured type is missing from
23478      the debug info.  */
23479   if (sig_type == NULL)
23480     {
23481       complaint (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23482                    " from DIE at %s [in module %s]"),
23483                  hex_string (signature), sect_offset_str (die->sect_off),
23484                  objfile_name (dwarf2_per_objfile->objfile));
23485       return build_error_marker_type (cu, die);
23486     }
23487
23488   /* If we already know the type we're done.  */
23489   if (sig_type->type != NULL)
23490     return sig_type->type;
23491
23492   type_cu = cu;
23493   type_die = follow_die_sig_1 (die, sig_type, &type_cu);
23494   if (type_die != NULL)
23495     {
23496       /* N.B. We need to call get_die_type to ensure only one type for this DIE
23497          is created.  This is important, for example, because for c++ classes
23498          we need TYPE_NAME set which is only done by new_symbol.  Blech.  */
23499       type = read_type_die (type_die, type_cu);
23500       if (type == NULL)
23501         {
23502           complaint (_("Dwarf Error: Cannot build signatured type %s"
23503                        " referenced 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           type = build_error_marker_type (cu, die);
23507         }
23508     }
23509   else
23510     {
23511       complaint (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23512                    " from DIE at %s [in module %s]"),
23513                  hex_string (signature), sect_offset_str (die->sect_off),
23514                  objfile_name (dwarf2_per_objfile->objfile));
23515       type = build_error_marker_type (cu, die);
23516     }
23517   sig_type->type = type;
23518
23519   return type;
23520 }
23521
23522 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
23523    reading in and processing the type unit if necessary.  */
23524
23525 static struct type *
23526 get_DW_AT_signature_type (struct die_info *die, const struct attribute *attr,
23527                           struct dwarf2_cu *cu) /* ARI: editCase function */
23528 {
23529   /* Yes, DW_AT_signature can use a non-ref_sig8 reference.  */
23530   if (attr_form_is_ref (attr))
23531     {
23532       struct dwarf2_cu *type_cu = cu;
23533       struct die_info *type_die = follow_die_ref (die, attr, &type_cu);
23534
23535       return read_type_die (type_die, type_cu);
23536     }
23537   else if (attr->form == DW_FORM_ref_sig8)
23538     {
23539       return get_signatured_type (die, DW_SIGNATURE (attr), cu);
23540     }
23541   else
23542     {
23543       struct dwarf2_per_objfile *dwarf2_per_objfile
23544         = cu->per_cu->dwarf2_per_objfile;
23545
23546       complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
23547                    " at %s [in module %s]"),
23548                  dwarf_form_name (attr->form), sect_offset_str (die->sect_off),
23549                  objfile_name (dwarf2_per_objfile->objfile));
23550       return build_error_marker_type (cu, die);
23551     }
23552 }
23553
23554 /* Load the DIEs associated with type unit PER_CU into memory.  */
23555
23556 static void
23557 load_full_type_unit (struct dwarf2_per_cu_data *per_cu)
23558 {
23559   struct signatured_type *sig_type;
23560
23561   /* Caller is responsible for ensuring type_unit_groups don't get here.  */
23562   gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu));
23563
23564   /* We have the per_cu, but we need the signatured_type.
23565      Fortunately this is an easy translation.  */
23566   gdb_assert (per_cu->is_debug_types);
23567   sig_type = (struct signatured_type *) per_cu;
23568
23569   gdb_assert (per_cu->cu == NULL);
23570
23571   read_signatured_type (sig_type);
23572
23573   gdb_assert (per_cu->cu != NULL);
23574 }
23575
23576 /* die_reader_func for read_signatured_type.
23577    This is identical to load_full_comp_unit_reader,
23578    but is kept separate for now.  */
23579
23580 static void
23581 read_signatured_type_reader (const struct die_reader_specs *reader,
23582                              const gdb_byte *info_ptr,
23583                              struct die_info *comp_unit_die,
23584                              int has_children,
23585                              void *data)
23586 {
23587   struct dwarf2_cu *cu = reader->cu;
23588
23589   gdb_assert (cu->die_hash == NULL);
23590   cu->die_hash =
23591     htab_create_alloc_ex (cu->header.length / 12,
23592                           die_hash,
23593                           die_eq,
23594                           NULL,
23595                           &cu->comp_unit_obstack,
23596                           hashtab_obstack_allocate,
23597                           dummy_obstack_deallocate);
23598
23599   if (has_children)
23600     comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
23601                                                   &info_ptr, comp_unit_die);
23602   cu->dies = comp_unit_die;
23603   /* comp_unit_die is not stored in die_hash, no need.  */
23604
23605   /* We try not to read any attributes in this function, because not
23606      all CUs needed for references have been loaded yet, and symbol
23607      table processing isn't initialized.  But we have to set the CU language,
23608      or we won't be able to build types correctly.
23609      Similarly, if we do not read the producer, we can not apply
23610      producer-specific interpretation.  */
23611   prepare_one_comp_unit (cu, cu->dies, language_minimal);
23612 }
23613
23614 /* Read in a signatured type and build its CU and DIEs.
23615    If the type is a stub for the real type in a DWO file,
23616    read in the real type from the DWO file as well.  */
23617
23618 static void
23619 read_signatured_type (struct signatured_type *sig_type)
23620 {
23621   struct dwarf2_per_cu_data *per_cu = &sig_type->per_cu;
23622
23623   gdb_assert (per_cu->is_debug_types);
23624   gdb_assert (per_cu->cu == NULL);
23625
23626   init_cutu_and_read_dies (per_cu, NULL, 0, 1, false,
23627                            read_signatured_type_reader, NULL);
23628   sig_type->per_cu.tu_read = 1;
23629 }
23630
23631 /* Decode simple location descriptions.
23632    Given a pointer to a dwarf block that defines a location, compute
23633    the location and return the value.
23634
23635    NOTE drow/2003-11-18: This function is called in two situations
23636    now: for the address of static or global variables (partial symbols
23637    only) and for offsets into structures which are expected to be
23638    (more or less) constant.  The partial symbol case should go away,
23639    and only the constant case should remain.  That will let this
23640    function complain more accurately.  A few special modes are allowed
23641    without complaint for global variables (for instance, global
23642    register values and thread-local values).
23643
23644    A location description containing no operations indicates that the
23645    object is optimized out.  The return value is 0 for that case.
23646    FIXME drow/2003-11-16: No callers check for this case any more; soon all
23647    callers will only want a very basic result and this can become a
23648    complaint.
23649
23650    Note that stack[0] is unused except as a default error return.  */
23651
23652 static CORE_ADDR
23653 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
23654 {
23655   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
23656   size_t i;
23657   size_t size = blk->size;
23658   const gdb_byte *data = blk->data;
23659   CORE_ADDR stack[64];
23660   int stacki;
23661   unsigned int bytes_read, unsnd;
23662   gdb_byte op;
23663
23664   i = 0;
23665   stacki = 0;
23666   stack[stacki] = 0;
23667   stack[++stacki] = 0;
23668
23669   while (i < size)
23670     {
23671       op = data[i++];
23672       switch (op)
23673         {
23674         case DW_OP_lit0:
23675         case DW_OP_lit1:
23676         case DW_OP_lit2:
23677         case DW_OP_lit3:
23678         case DW_OP_lit4:
23679         case DW_OP_lit5:
23680         case DW_OP_lit6:
23681         case DW_OP_lit7:
23682         case DW_OP_lit8:
23683         case DW_OP_lit9:
23684         case DW_OP_lit10:
23685         case DW_OP_lit11:
23686         case DW_OP_lit12:
23687         case DW_OP_lit13:
23688         case DW_OP_lit14:
23689         case DW_OP_lit15:
23690         case DW_OP_lit16:
23691         case DW_OP_lit17:
23692         case DW_OP_lit18:
23693         case DW_OP_lit19:
23694         case DW_OP_lit20:
23695         case DW_OP_lit21:
23696         case DW_OP_lit22:
23697         case DW_OP_lit23:
23698         case DW_OP_lit24:
23699         case DW_OP_lit25:
23700         case DW_OP_lit26:
23701         case DW_OP_lit27:
23702         case DW_OP_lit28:
23703         case DW_OP_lit29:
23704         case DW_OP_lit30:
23705         case DW_OP_lit31:
23706           stack[++stacki] = op - DW_OP_lit0;
23707           break;
23708
23709         case DW_OP_reg0:
23710         case DW_OP_reg1:
23711         case DW_OP_reg2:
23712         case DW_OP_reg3:
23713         case DW_OP_reg4:
23714         case DW_OP_reg5:
23715         case DW_OP_reg6:
23716         case DW_OP_reg7:
23717         case DW_OP_reg8:
23718         case DW_OP_reg9:
23719         case DW_OP_reg10:
23720         case DW_OP_reg11:
23721         case DW_OP_reg12:
23722         case DW_OP_reg13:
23723         case DW_OP_reg14:
23724         case DW_OP_reg15:
23725         case DW_OP_reg16:
23726         case DW_OP_reg17:
23727         case DW_OP_reg18:
23728         case DW_OP_reg19:
23729         case DW_OP_reg20:
23730         case DW_OP_reg21:
23731         case DW_OP_reg22:
23732         case DW_OP_reg23:
23733         case DW_OP_reg24:
23734         case DW_OP_reg25:
23735         case DW_OP_reg26:
23736         case DW_OP_reg27:
23737         case DW_OP_reg28:
23738         case DW_OP_reg29:
23739         case DW_OP_reg30:
23740         case DW_OP_reg31:
23741           stack[++stacki] = op - DW_OP_reg0;
23742           if (i < size)
23743             dwarf2_complex_location_expr_complaint ();
23744           break;
23745
23746         case DW_OP_regx:
23747           unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
23748           i += bytes_read;
23749           stack[++stacki] = unsnd;
23750           if (i < size)
23751             dwarf2_complex_location_expr_complaint ();
23752           break;
23753
23754         case DW_OP_addr:
23755           stack[++stacki] = read_address (objfile->obfd, &data[i],
23756                                           cu, &bytes_read);
23757           i += bytes_read;
23758           break;
23759
23760         case DW_OP_const1u:
23761           stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
23762           i += 1;
23763           break;
23764
23765         case DW_OP_const1s:
23766           stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
23767           i += 1;
23768           break;
23769
23770         case DW_OP_const2u:
23771           stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
23772           i += 2;
23773           break;
23774
23775         case DW_OP_const2s:
23776           stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
23777           i += 2;
23778           break;
23779
23780         case DW_OP_const4u:
23781           stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
23782           i += 4;
23783           break;
23784
23785         case DW_OP_const4s:
23786           stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
23787           i += 4;
23788           break;
23789
23790         case DW_OP_const8u:
23791           stack[++stacki] = read_8_bytes (objfile->obfd, &data[i]);
23792           i += 8;
23793           break;
23794
23795         case DW_OP_constu:
23796           stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
23797                                                   &bytes_read);
23798           i += bytes_read;
23799           break;
23800
23801         case DW_OP_consts:
23802           stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
23803           i += bytes_read;
23804           break;
23805
23806         case DW_OP_dup:
23807           stack[stacki + 1] = stack[stacki];
23808           stacki++;
23809           break;
23810
23811         case DW_OP_plus:
23812           stack[stacki - 1] += stack[stacki];
23813           stacki--;
23814           break;
23815
23816         case DW_OP_plus_uconst:
23817           stack[stacki] += read_unsigned_leb128 (NULL, (data + i),
23818                                                  &bytes_read);
23819           i += bytes_read;
23820           break;
23821
23822         case DW_OP_minus:
23823           stack[stacki - 1] -= stack[stacki];
23824           stacki--;
23825           break;
23826
23827         case DW_OP_deref:
23828           /* If we're not the last op, then we definitely can't encode
23829              this using GDB's address_class enum.  This is valid for partial
23830              global symbols, although the variable's address will be bogus
23831              in the psymtab.  */
23832           if (i < size)
23833             dwarf2_complex_location_expr_complaint ();
23834           break;
23835
23836         case DW_OP_GNU_push_tls_address:
23837         case DW_OP_form_tls_address:
23838           /* The top of the stack has the offset from the beginning
23839              of the thread control block at which the variable is located.  */
23840           /* Nothing should follow this operator, so the top of stack would
23841              be returned.  */
23842           /* This is valid for partial global symbols, but the variable's
23843              address will be bogus in the psymtab.  Make it always at least
23844              non-zero to not look as a variable garbage collected by linker
23845              which have DW_OP_addr 0.  */
23846           if (i < size)
23847             dwarf2_complex_location_expr_complaint ();
23848           stack[stacki]++;
23849           break;
23850
23851         case DW_OP_GNU_uninit:
23852           break;
23853
23854         case DW_OP_GNU_addr_index:
23855         case DW_OP_GNU_const_index:
23856           stack[++stacki] = read_addr_index_from_leb128 (cu, &data[i],
23857                                                          &bytes_read);
23858           i += bytes_read;
23859           break;
23860
23861         default:
23862           {
23863             const char *name = get_DW_OP_name (op);
23864
23865             if (name)
23866               complaint (_("unsupported stack op: '%s'"),
23867                          name);
23868             else
23869               complaint (_("unsupported stack op: '%02x'"),
23870                          op);
23871           }
23872
23873           return (stack[stacki]);
23874         }
23875
23876       /* Enforce maximum stack depth of SIZE-1 to avoid writing
23877          outside of the allocated space.  Also enforce minimum>0.  */
23878       if (stacki >= ARRAY_SIZE (stack) - 1)
23879         {
23880           complaint (_("location description stack overflow"));
23881           return 0;
23882         }
23883
23884       if (stacki <= 0)
23885         {
23886           complaint (_("location description stack underflow"));
23887           return 0;
23888         }
23889     }
23890   return (stack[stacki]);
23891 }
23892
23893 /* memory allocation interface */
23894
23895 static struct dwarf_block *
23896 dwarf_alloc_block (struct dwarf2_cu *cu)
23897 {
23898   return XOBNEW (&cu->comp_unit_obstack, struct dwarf_block);
23899 }
23900
23901 static struct die_info *
23902 dwarf_alloc_die (struct dwarf2_cu *cu, int num_attrs)
23903 {
23904   struct die_info *die;
23905   size_t size = sizeof (struct die_info);
23906
23907   if (num_attrs > 1)
23908     size += (num_attrs - 1) * sizeof (struct attribute);
23909
23910   die = (struct die_info *) obstack_alloc (&cu->comp_unit_obstack, size);
23911   memset (die, 0, sizeof (struct die_info));
23912   return (die);
23913 }
23914
23915 \f
23916 /* Macro support.  */
23917
23918 /* Return file name relative to the compilation directory of file number I in
23919    *LH's file name table.  The result is allocated using xmalloc; the caller is
23920    responsible for freeing it.  */
23921
23922 static char *
23923 file_file_name (int file, struct line_header *lh)
23924 {
23925   /* Is the file number a valid index into the line header's file name
23926      table?  Remember that file numbers start with one, not zero.  */
23927   if (1 <= file && file <= lh->file_names.size ())
23928     {
23929       const file_entry &fe = lh->file_names[file - 1];
23930
23931       if (!IS_ABSOLUTE_PATH (fe.name))
23932         {
23933           const char *dir = fe.include_dir (lh);
23934           if (dir != NULL)
23935             return concat (dir, SLASH_STRING, fe.name, (char *) NULL);
23936         }
23937       return xstrdup (fe.name);
23938     }
23939   else
23940     {
23941       /* The compiler produced a bogus file number.  We can at least
23942          record the macro definitions made in the file, even if we
23943          won't be able to find the file by name.  */
23944       char fake_name[80];
23945
23946       xsnprintf (fake_name, sizeof (fake_name),
23947                  "<bad macro file number %d>", file);
23948
23949       complaint (_("bad file number in macro information (%d)"),
23950                  file);
23951
23952       return xstrdup (fake_name);
23953     }
23954 }
23955
23956 /* Return the full name of file number I in *LH's file name table.
23957    Use COMP_DIR as the name of the current directory of the
23958    compilation.  The result is allocated using xmalloc; the caller is
23959    responsible for freeing it.  */
23960 static char *
23961 file_full_name (int file, struct line_header *lh, const char *comp_dir)
23962 {
23963   /* Is the file number a valid index into the line header's file name
23964      table?  Remember that file numbers start with one, not zero.  */
23965   if (1 <= file && file <= lh->file_names.size ())
23966     {
23967       char *relative = file_file_name (file, lh);
23968
23969       if (IS_ABSOLUTE_PATH (relative) || comp_dir == NULL)
23970         return relative;
23971       return reconcat (relative, comp_dir, SLASH_STRING,
23972                        relative, (char *) NULL);
23973     }
23974   else
23975     return file_file_name (file, lh);
23976 }
23977
23978
23979 static struct macro_source_file *
23980 macro_start_file (struct dwarf2_cu *cu,
23981                   int file, int line,
23982                   struct macro_source_file *current_file,
23983                   struct line_header *lh)
23984 {
23985   /* File name relative to the compilation directory of this source file.  */
23986   char *file_name = file_file_name (file, lh);
23987
23988   if (! current_file)
23989     {
23990       /* Note: We don't create a macro table for this compilation unit
23991          at all until we actually get a filename.  */
23992       struct macro_table *macro_table = cu->get_builder ()->get_macro_table ();
23993
23994       /* If we have no current file, then this must be the start_file
23995          directive for the compilation unit's main source file.  */
23996       current_file = macro_set_main (macro_table, file_name);
23997       macro_define_special (macro_table);
23998     }
23999   else
24000     current_file = macro_include (current_file, line, file_name);
24001
24002   xfree (file_name);
24003
24004   return current_file;
24005 }
24006
24007 static const char *
24008 consume_improper_spaces (const char *p, const char *body)
24009 {
24010   if (*p == ' ')
24011     {
24012       complaint (_("macro definition contains spaces "
24013                    "in formal argument list:\n`%s'"),
24014                  body);
24015
24016       while (*p == ' ')
24017         p++;
24018     }
24019
24020   return p;
24021 }
24022
24023
24024 static void
24025 parse_macro_definition (struct macro_source_file *file, int line,
24026                         const char *body)
24027 {
24028   const char *p;
24029
24030   /* The body string takes one of two forms.  For object-like macro
24031      definitions, it should be:
24032
24033         <macro name> " " <definition>
24034
24035      For function-like macro definitions, it should be:
24036
24037         <macro name> "() " <definition>
24038      or
24039         <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
24040
24041      Spaces may appear only where explicitly indicated, and in the
24042      <definition>.
24043
24044      The Dwarf 2 spec says that an object-like macro's name is always
24045      followed by a space, but versions of GCC around March 2002 omit
24046      the space when the macro's definition is the empty string.
24047
24048      The Dwarf 2 spec says that there should be no spaces between the
24049      formal arguments in a function-like macro's formal argument list,
24050      but versions of GCC around March 2002 include spaces after the
24051      commas.  */
24052
24053
24054   /* Find the extent of the macro name.  The macro name is terminated
24055      by either a space or null character (for an object-like macro) or
24056      an opening paren (for a function-like macro).  */
24057   for (p = body; *p; p++)
24058     if (*p == ' ' || *p == '(')
24059       break;
24060
24061   if (*p == ' ' || *p == '\0')
24062     {
24063       /* It's an object-like macro.  */
24064       int name_len = p - body;
24065       char *name = savestring (body, name_len);
24066       const char *replacement;
24067
24068       if (*p == ' ')
24069         replacement = body + name_len + 1;
24070       else
24071         {
24072           dwarf2_macro_malformed_definition_complaint (body);
24073           replacement = body + name_len;
24074         }
24075
24076       macro_define_object (file, line, name, replacement);
24077
24078       xfree (name);
24079     }
24080   else if (*p == '(')
24081     {
24082       /* It's a function-like macro.  */
24083       char *name = savestring (body, p - body);
24084       int argc = 0;
24085       int argv_size = 1;
24086       char **argv = XNEWVEC (char *, argv_size);
24087
24088       p++;
24089
24090       p = consume_improper_spaces (p, body);
24091
24092       /* Parse the formal argument list.  */
24093       while (*p && *p != ')')
24094         {
24095           /* Find the extent of the current argument name.  */
24096           const char *arg_start = p;
24097
24098           while (*p && *p != ',' && *p != ')' && *p != ' ')
24099             p++;
24100
24101           if (! *p || p == arg_start)
24102             dwarf2_macro_malformed_definition_complaint (body);
24103           else
24104             {
24105               /* Make sure argv has room for the new argument.  */
24106               if (argc >= argv_size)
24107                 {
24108                   argv_size *= 2;
24109                   argv = XRESIZEVEC (char *, argv, argv_size);
24110                 }
24111
24112               argv[argc++] = savestring (arg_start, p - arg_start);
24113             }
24114
24115           p = consume_improper_spaces (p, body);
24116
24117           /* Consume the comma, if present.  */
24118           if (*p == ',')
24119             {
24120               p++;
24121
24122               p = consume_improper_spaces (p, body);
24123             }
24124         }
24125
24126       if (*p == ')')
24127         {
24128           p++;
24129
24130           if (*p == ' ')
24131             /* Perfectly formed definition, no complaints.  */
24132             macro_define_function (file, line, name,
24133                                    argc, (const char **) argv,
24134                                    p + 1);
24135           else if (*p == '\0')
24136             {
24137               /* Complain, but do define it.  */
24138               dwarf2_macro_malformed_definition_complaint (body);
24139               macro_define_function (file, line, name,
24140                                      argc, (const char **) argv,
24141                                      p);
24142             }
24143           else
24144             /* Just complain.  */
24145             dwarf2_macro_malformed_definition_complaint (body);
24146         }
24147       else
24148         /* Just complain.  */
24149         dwarf2_macro_malformed_definition_complaint (body);
24150
24151       xfree (name);
24152       {
24153         int i;
24154
24155         for (i = 0; i < argc; i++)
24156           xfree (argv[i]);
24157       }
24158       xfree (argv);
24159     }
24160   else
24161     dwarf2_macro_malformed_definition_complaint (body);
24162 }
24163
24164 /* Skip some bytes from BYTES according to the form given in FORM.
24165    Returns the new pointer.  */
24166
24167 static const gdb_byte *
24168 skip_form_bytes (bfd *abfd, const gdb_byte *bytes, const gdb_byte *buffer_end,
24169                  enum dwarf_form form,
24170                  unsigned int offset_size,
24171                  struct dwarf2_section_info *section)
24172 {
24173   unsigned int bytes_read;
24174
24175   switch (form)
24176     {
24177     case DW_FORM_data1:
24178     case DW_FORM_flag:
24179       ++bytes;
24180       break;
24181
24182     case DW_FORM_data2:
24183       bytes += 2;
24184       break;
24185
24186     case DW_FORM_data4:
24187       bytes += 4;
24188       break;
24189
24190     case DW_FORM_data8:
24191       bytes += 8;
24192       break;
24193
24194     case DW_FORM_data16:
24195       bytes += 16;
24196       break;
24197
24198     case DW_FORM_string:
24199       read_direct_string (abfd, bytes, &bytes_read);
24200       bytes += bytes_read;
24201       break;
24202
24203     case DW_FORM_sec_offset:
24204     case DW_FORM_strp:
24205     case DW_FORM_GNU_strp_alt:
24206       bytes += offset_size;
24207       break;
24208
24209     case DW_FORM_block:
24210       bytes += read_unsigned_leb128 (abfd, bytes, &bytes_read);
24211       bytes += bytes_read;
24212       break;
24213
24214     case DW_FORM_block1:
24215       bytes += 1 + read_1_byte (abfd, bytes);
24216       break;
24217     case DW_FORM_block2:
24218       bytes += 2 + read_2_bytes (abfd, bytes);
24219       break;
24220     case DW_FORM_block4:
24221       bytes += 4 + read_4_bytes (abfd, bytes);
24222       break;
24223
24224     case DW_FORM_sdata:
24225     case DW_FORM_udata:
24226     case DW_FORM_GNU_addr_index:
24227     case DW_FORM_GNU_str_index:
24228       bytes = gdb_skip_leb128 (bytes, buffer_end);
24229       if (bytes == NULL)
24230         {
24231           dwarf2_section_buffer_overflow_complaint (section);
24232           return NULL;
24233         }
24234       break;
24235
24236     case DW_FORM_implicit_const:
24237       break;
24238
24239     default:
24240       {
24241         complaint (_("invalid form 0x%x in `%s'"),
24242                    form, get_section_name (section));
24243         return NULL;
24244       }
24245     }
24246
24247   return bytes;
24248 }
24249
24250 /* A helper for dwarf_decode_macros that handles skipping an unknown
24251    opcode.  Returns an updated pointer to the macro data buffer; or,
24252    on error, issues a complaint and returns NULL.  */
24253
24254 static const gdb_byte *
24255 skip_unknown_opcode (unsigned int opcode,
24256                      const gdb_byte **opcode_definitions,
24257                      const gdb_byte *mac_ptr, const gdb_byte *mac_end,
24258                      bfd *abfd,
24259                      unsigned int offset_size,
24260                      struct dwarf2_section_info *section)
24261 {
24262   unsigned int bytes_read, i;
24263   unsigned long arg;
24264   const gdb_byte *defn;
24265
24266   if (opcode_definitions[opcode] == NULL)
24267     {
24268       complaint (_("unrecognized DW_MACFINO opcode 0x%x"),
24269                  opcode);
24270       return NULL;
24271     }
24272
24273   defn = opcode_definitions[opcode];
24274   arg = read_unsigned_leb128 (abfd, defn, &bytes_read);
24275   defn += bytes_read;
24276
24277   for (i = 0; i < arg; ++i)
24278     {
24279       mac_ptr = skip_form_bytes (abfd, mac_ptr, mac_end,
24280                                  (enum dwarf_form) defn[i], offset_size,
24281                                  section);
24282       if (mac_ptr == NULL)
24283         {
24284           /* skip_form_bytes already issued the complaint.  */
24285           return NULL;
24286         }
24287     }
24288
24289   return mac_ptr;
24290 }
24291
24292 /* A helper function which parses the header of a macro section.
24293    If the macro section is the extended (for now called "GNU") type,
24294    then this updates *OFFSET_SIZE.  Returns a pointer to just after
24295    the header, or issues a complaint and returns NULL on error.  */
24296
24297 static const gdb_byte *
24298 dwarf_parse_macro_header (const gdb_byte **opcode_definitions,
24299                           bfd *abfd,
24300                           const gdb_byte *mac_ptr,
24301                           unsigned int *offset_size,
24302                           int section_is_gnu)
24303 {
24304   memset (opcode_definitions, 0, 256 * sizeof (gdb_byte *));
24305
24306   if (section_is_gnu)
24307     {
24308       unsigned int version, flags;
24309
24310       version = read_2_bytes (abfd, mac_ptr);
24311       if (version != 4 && version != 5)
24312         {
24313           complaint (_("unrecognized version `%d' in .debug_macro section"),
24314                      version);
24315           return NULL;
24316         }
24317       mac_ptr += 2;
24318
24319       flags = read_1_byte (abfd, mac_ptr);
24320       ++mac_ptr;
24321       *offset_size = (flags & 1) ? 8 : 4;
24322
24323       if ((flags & 2) != 0)
24324         /* We don't need the line table offset.  */
24325         mac_ptr += *offset_size;
24326
24327       /* Vendor opcode descriptions.  */
24328       if ((flags & 4) != 0)
24329         {
24330           unsigned int i, count;
24331
24332           count = read_1_byte (abfd, mac_ptr);
24333           ++mac_ptr;
24334           for (i = 0; i < count; ++i)
24335             {
24336               unsigned int opcode, bytes_read;
24337               unsigned long arg;
24338
24339               opcode = read_1_byte (abfd, mac_ptr);
24340               ++mac_ptr;
24341               opcode_definitions[opcode] = mac_ptr;
24342               arg = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24343               mac_ptr += bytes_read;
24344               mac_ptr += arg;
24345             }
24346         }
24347     }
24348
24349   return mac_ptr;
24350 }
24351
24352 /* A helper for dwarf_decode_macros that handles the GNU extensions,
24353    including DW_MACRO_import.  */
24354
24355 static void
24356 dwarf_decode_macro_bytes (struct dwarf2_cu *cu,
24357                           bfd *abfd,
24358                           const gdb_byte *mac_ptr, const gdb_byte *mac_end,
24359                           struct macro_source_file *current_file,
24360                           struct line_header *lh,
24361                           struct dwarf2_section_info *section,
24362                           int section_is_gnu, int section_is_dwz,
24363                           unsigned int offset_size,
24364                           htab_t include_hash)
24365 {
24366   struct dwarf2_per_objfile *dwarf2_per_objfile
24367     = cu->per_cu->dwarf2_per_objfile;
24368   struct objfile *objfile = dwarf2_per_objfile->objfile;
24369   enum dwarf_macro_record_type macinfo_type;
24370   int at_commandline;
24371   const gdb_byte *opcode_definitions[256];
24372
24373   mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
24374                                       &offset_size, section_is_gnu);
24375   if (mac_ptr == NULL)
24376     {
24377       /* We already issued a complaint.  */
24378       return;
24379     }
24380
24381   /* Determines if GDB is still before first DW_MACINFO_start_file.  If true
24382      GDB is still reading the definitions from command line.  First
24383      DW_MACINFO_start_file will need to be ignored as it was already executed
24384      to create CURRENT_FILE for the main source holding also the command line
24385      definitions.  On first met DW_MACINFO_start_file this flag is reset to
24386      normally execute all the remaining DW_MACINFO_start_file macinfos.  */
24387
24388   at_commandline = 1;
24389
24390   do
24391     {
24392       /* Do we at least have room for a macinfo type byte?  */
24393       if (mac_ptr >= mac_end)
24394         {
24395           dwarf2_section_buffer_overflow_complaint (section);
24396           break;
24397         }
24398
24399       macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr);
24400       mac_ptr++;
24401
24402       /* Note that we rely on the fact that the corresponding GNU and
24403          DWARF constants are the same.  */
24404       DIAGNOSTIC_PUSH
24405       DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24406       switch (macinfo_type)
24407         {
24408           /* A zero macinfo type indicates the end of the macro
24409              information.  */
24410         case 0:
24411           break;
24412
24413         case DW_MACRO_define:
24414         case DW_MACRO_undef:
24415         case DW_MACRO_define_strp:
24416         case DW_MACRO_undef_strp:
24417         case DW_MACRO_define_sup:
24418         case DW_MACRO_undef_sup:
24419           {
24420             unsigned int bytes_read;
24421             int line;
24422             const char *body;
24423             int is_define;
24424
24425             line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24426             mac_ptr += bytes_read;
24427
24428             if (macinfo_type == DW_MACRO_define
24429                 || macinfo_type == DW_MACRO_undef)
24430               {
24431                 body = read_direct_string (abfd, mac_ptr, &bytes_read);
24432                 mac_ptr += bytes_read;
24433               }
24434             else
24435               {
24436                 LONGEST str_offset;
24437
24438                 str_offset = read_offset_1 (abfd, mac_ptr, offset_size);
24439                 mac_ptr += offset_size;
24440
24441                 if (macinfo_type == DW_MACRO_define_sup
24442                     || macinfo_type == DW_MACRO_undef_sup
24443                     || section_is_dwz)
24444                   {
24445                     struct dwz_file *dwz
24446                       = dwarf2_get_dwz_file (dwarf2_per_objfile);
24447
24448                     body = read_indirect_string_from_dwz (objfile,
24449                                                           dwz, str_offset);
24450                   }
24451                 else
24452                   body = read_indirect_string_at_offset (dwarf2_per_objfile,
24453                                                          abfd, str_offset);
24454               }
24455
24456             is_define = (macinfo_type == DW_MACRO_define
24457                          || macinfo_type == DW_MACRO_define_strp
24458                          || macinfo_type == DW_MACRO_define_sup);
24459             if (! current_file)
24460               {
24461                 /* DWARF violation as no main source is present.  */
24462                 complaint (_("debug info with no main source gives macro %s "
24463                              "on line %d: %s"),
24464                            is_define ? _("definition") : _("undefinition"),
24465                            line, body);
24466                 break;
24467               }
24468             if ((line == 0 && !at_commandline)
24469                 || (line != 0 && at_commandline))
24470               complaint (_("debug info gives %s macro %s with %s line %d: %s"),
24471                          at_commandline ? _("command-line") : _("in-file"),
24472                          is_define ? _("definition") : _("undefinition"),
24473                          line == 0 ? _("zero") : _("non-zero"), line, body);
24474
24475             if (is_define)
24476               parse_macro_definition (current_file, line, body);
24477             else
24478               {
24479                 gdb_assert (macinfo_type == DW_MACRO_undef
24480                             || macinfo_type == DW_MACRO_undef_strp
24481                             || macinfo_type == DW_MACRO_undef_sup);
24482                 macro_undef (current_file, line, body);
24483               }
24484           }
24485           break;
24486
24487         case DW_MACRO_start_file:
24488           {
24489             unsigned int bytes_read;
24490             int line, file;
24491
24492             line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24493             mac_ptr += bytes_read;
24494             file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24495             mac_ptr += bytes_read;
24496
24497             if ((line == 0 && !at_commandline)
24498                 || (line != 0 && at_commandline))
24499               complaint (_("debug info gives source %d included "
24500                            "from %s at %s line %d"),
24501                          file, at_commandline ? _("command-line") : _("file"),
24502                          line == 0 ? _("zero") : _("non-zero"), line);
24503
24504             if (at_commandline)
24505               {
24506                 /* This DW_MACRO_start_file was executed in the
24507                    pass one.  */
24508                 at_commandline = 0;
24509               }
24510             else
24511               current_file = macro_start_file (cu, file, line, current_file,
24512                                                lh);
24513           }
24514           break;
24515
24516         case DW_MACRO_end_file:
24517           if (! current_file)
24518             complaint (_("macro debug info has an unmatched "
24519                          "`close_file' directive"));
24520           else
24521             {
24522               current_file = current_file->included_by;
24523               if (! current_file)
24524                 {
24525                   enum dwarf_macro_record_type next_type;
24526
24527                   /* GCC circa March 2002 doesn't produce the zero
24528                      type byte marking the end of the compilation
24529                      unit.  Complain if it's not there, but exit no
24530                      matter what.  */
24531
24532                   /* Do we at least have room for a macinfo type byte?  */
24533                   if (mac_ptr >= mac_end)
24534                     {
24535                       dwarf2_section_buffer_overflow_complaint (section);
24536                       return;
24537                     }
24538
24539                   /* We don't increment mac_ptr here, so this is just
24540                      a look-ahead.  */
24541                   next_type
24542                     = (enum dwarf_macro_record_type) read_1_byte (abfd,
24543                                                                   mac_ptr);
24544                   if (next_type != 0)
24545                     complaint (_("no terminating 0-type entry for "
24546                                  "macros in `.debug_macinfo' section"));
24547
24548                   return;
24549                 }
24550             }
24551           break;
24552
24553         case DW_MACRO_import:
24554         case DW_MACRO_import_sup:
24555           {
24556             LONGEST offset;
24557             void **slot;
24558             bfd *include_bfd = abfd;
24559             struct dwarf2_section_info *include_section = section;
24560             const gdb_byte *include_mac_end = mac_end;
24561             int is_dwz = section_is_dwz;
24562             const gdb_byte *new_mac_ptr;
24563
24564             offset = read_offset_1 (abfd, mac_ptr, offset_size);
24565             mac_ptr += offset_size;
24566
24567             if (macinfo_type == DW_MACRO_import_sup)
24568               {
24569                 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
24570
24571                 dwarf2_read_section (objfile, &dwz->macro);
24572
24573                 include_section = &dwz->macro;
24574                 include_bfd = get_section_bfd_owner (include_section);
24575                 include_mac_end = dwz->macro.buffer + dwz->macro.size;
24576                 is_dwz = 1;
24577               }
24578
24579             new_mac_ptr = include_section->buffer + offset;
24580             slot = htab_find_slot (include_hash, new_mac_ptr, INSERT);
24581
24582             if (*slot != NULL)
24583               {
24584                 /* This has actually happened; see
24585                    http://sourceware.org/bugzilla/show_bug.cgi?id=13568.  */
24586                 complaint (_("recursive DW_MACRO_import in "
24587                              ".debug_macro section"));
24588               }
24589             else
24590               {
24591                 *slot = (void *) new_mac_ptr;
24592
24593                 dwarf_decode_macro_bytes (cu, include_bfd, new_mac_ptr,
24594                                           include_mac_end, current_file, lh,
24595                                           section, section_is_gnu, is_dwz,
24596                                           offset_size, include_hash);
24597
24598                 htab_remove_elt (include_hash, (void *) new_mac_ptr);
24599               }
24600           }
24601           break;
24602
24603         case DW_MACINFO_vendor_ext:
24604           if (!section_is_gnu)
24605             {
24606               unsigned int bytes_read;
24607
24608               /* This reads the constant, but since we don't recognize
24609                  any vendor extensions, we ignore it.  */
24610               read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24611               mac_ptr += bytes_read;
24612               read_direct_string (abfd, mac_ptr, &bytes_read);
24613               mac_ptr += bytes_read;
24614
24615               /* We don't recognize any vendor extensions.  */
24616               break;
24617             }
24618           /* FALLTHROUGH */
24619
24620         default:
24621           mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
24622                                          mac_ptr, mac_end, abfd, offset_size,
24623                                          section);
24624           if (mac_ptr == NULL)
24625             return;
24626           break;
24627         }
24628       DIAGNOSTIC_POP
24629     } while (macinfo_type != 0);
24630 }
24631
24632 static void
24633 dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset,
24634                      int section_is_gnu)
24635 {
24636   struct dwarf2_per_objfile *dwarf2_per_objfile
24637     = cu->per_cu->dwarf2_per_objfile;
24638   struct objfile *objfile = dwarf2_per_objfile->objfile;
24639   struct line_header *lh = cu->line_header;
24640   bfd *abfd;
24641   const gdb_byte *mac_ptr, *mac_end;
24642   struct macro_source_file *current_file = 0;
24643   enum dwarf_macro_record_type macinfo_type;
24644   unsigned int offset_size = cu->header.offset_size;
24645   const gdb_byte *opcode_definitions[256];
24646   void **slot;
24647   struct dwarf2_section_info *section;
24648   const char *section_name;
24649
24650   if (cu->dwo_unit != NULL)
24651     {
24652       if (section_is_gnu)
24653         {
24654           section = &cu->dwo_unit->dwo_file->sections.macro;
24655           section_name = ".debug_macro.dwo";
24656         }
24657       else
24658         {
24659           section = &cu->dwo_unit->dwo_file->sections.macinfo;
24660           section_name = ".debug_macinfo.dwo";
24661         }
24662     }
24663   else
24664     {
24665       if (section_is_gnu)
24666         {
24667           section = &dwarf2_per_objfile->macro;
24668           section_name = ".debug_macro";
24669         }
24670       else
24671         {
24672           section = &dwarf2_per_objfile->macinfo;
24673           section_name = ".debug_macinfo";
24674         }
24675     }
24676
24677   dwarf2_read_section (objfile, section);
24678   if (section->buffer == NULL)
24679     {
24680       complaint (_("missing %s section"), section_name);
24681       return;
24682     }
24683   abfd = get_section_bfd_owner (section);
24684
24685   /* First pass: Find the name of the base filename.
24686      This filename is needed in order to process all macros whose definition
24687      (or undefinition) comes from the command line.  These macros are defined
24688      before the first DW_MACINFO_start_file entry, and yet still need to be
24689      associated to the base file.
24690
24691      To determine the base file name, we scan the macro definitions until we
24692      reach the first DW_MACINFO_start_file entry.  We then initialize
24693      CURRENT_FILE accordingly so that any macro definition found before the
24694      first DW_MACINFO_start_file can still be associated to the base file.  */
24695
24696   mac_ptr = section->buffer + offset;
24697   mac_end = section->buffer + section->size;
24698
24699   mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
24700                                       &offset_size, section_is_gnu);
24701   if (mac_ptr == NULL)
24702     {
24703       /* We already issued a complaint.  */
24704       return;
24705     }
24706
24707   do
24708     {
24709       /* Do we at least have room for a macinfo type byte?  */
24710       if (mac_ptr >= mac_end)
24711         {
24712           /* Complaint is printed during the second pass as GDB will probably
24713              stop the first pass earlier upon finding
24714              DW_MACINFO_start_file.  */
24715           break;
24716         }
24717
24718       macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr);
24719       mac_ptr++;
24720
24721       /* Note that we rely on the fact that the corresponding GNU and
24722          DWARF constants are the same.  */
24723       DIAGNOSTIC_PUSH
24724       DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24725       switch (macinfo_type)
24726         {
24727           /* A zero macinfo type indicates the end of the macro
24728              information.  */
24729         case 0:
24730           break;
24731
24732         case DW_MACRO_define:
24733         case DW_MACRO_undef:
24734           /* Only skip the data by MAC_PTR.  */
24735           {
24736             unsigned int bytes_read;
24737
24738             read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24739             mac_ptr += bytes_read;
24740             read_direct_string (abfd, mac_ptr, &bytes_read);
24741             mac_ptr += bytes_read;
24742           }
24743           break;
24744
24745         case DW_MACRO_start_file:
24746           {
24747             unsigned int bytes_read;
24748             int line, file;
24749
24750             line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24751             mac_ptr += bytes_read;
24752             file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24753             mac_ptr += bytes_read;
24754
24755             current_file = macro_start_file (cu, file, line, current_file, lh);
24756           }
24757           break;
24758
24759         case DW_MACRO_end_file:
24760           /* No data to skip by MAC_PTR.  */
24761           break;
24762
24763         case DW_MACRO_define_strp:
24764         case DW_MACRO_undef_strp:
24765         case DW_MACRO_define_sup:
24766         case DW_MACRO_undef_sup:
24767           {
24768             unsigned int bytes_read;
24769
24770             read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24771             mac_ptr += bytes_read;
24772             mac_ptr += offset_size;
24773           }
24774           break;
24775
24776         case DW_MACRO_import:
24777         case DW_MACRO_import_sup:
24778           /* Note that, according to the spec, a transparent include
24779              chain cannot call DW_MACRO_start_file.  So, we can just
24780              skip this opcode.  */
24781           mac_ptr += offset_size;
24782           break;
24783
24784         case DW_MACINFO_vendor_ext:
24785           /* Only skip the data by MAC_PTR.  */
24786           if (!section_is_gnu)
24787             {
24788               unsigned int bytes_read;
24789
24790               read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24791               mac_ptr += bytes_read;
24792               read_direct_string (abfd, mac_ptr, &bytes_read);
24793               mac_ptr += bytes_read;
24794             }
24795           /* FALLTHROUGH */
24796
24797         default:
24798           mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
24799                                          mac_ptr, mac_end, abfd, offset_size,
24800                                          section);
24801           if (mac_ptr == NULL)
24802             return;
24803           break;
24804         }
24805       DIAGNOSTIC_POP
24806     } while (macinfo_type != 0 && current_file == NULL);
24807
24808   /* Second pass: Process all entries.
24809
24810      Use the AT_COMMAND_LINE flag to determine whether we are still processing
24811      command-line macro definitions/undefinitions.  This flag is unset when we
24812      reach the first DW_MACINFO_start_file entry.  */
24813
24814   htab_up include_hash (htab_create_alloc (1, htab_hash_pointer,
24815                                            htab_eq_pointer,
24816                                            NULL, xcalloc, xfree));
24817   mac_ptr = section->buffer + offset;
24818   slot = htab_find_slot (include_hash.get (), mac_ptr, INSERT);
24819   *slot = (void *) mac_ptr;
24820   dwarf_decode_macro_bytes (cu, abfd, mac_ptr, mac_end,
24821                             current_file, lh, section,
24822                             section_is_gnu, 0, offset_size,
24823                             include_hash.get ());
24824 }
24825
24826 /* Check if the attribute's form is a DW_FORM_block*
24827    if so return true else false.  */
24828
24829 static int
24830 attr_form_is_block (const struct attribute *attr)
24831 {
24832   return (attr == NULL ? 0 :
24833       attr->form == DW_FORM_block1
24834       || attr->form == DW_FORM_block2
24835       || attr->form == DW_FORM_block4
24836       || attr->form == DW_FORM_block
24837       || attr->form == DW_FORM_exprloc);
24838 }
24839
24840 /* Return non-zero if ATTR's value is a section offset --- classes
24841    lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
24842    You may use DW_UNSND (attr) to retrieve such offsets.
24843
24844    Section 7.5.4, "Attribute Encodings", explains that no attribute
24845    may have a value that belongs to more than one of these classes; it
24846    would be ambiguous if we did, because we use the same forms for all
24847    of them.  */
24848
24849 static int
24850 attr_form_is_section_offset (const struct attribute *attr)
24851 {
24852   return (attr->form == DW_FORM_data4
24853           || attr->form == DW_FORM_data8
24854           || attr->form == DW_FORM_sec_offset);
24855 }
24856
24857 /* Return non-zero if ATTR's value falls in the 'constant' class, or
24858    zero otherwise.  When this function returns true, you can apply
24859    dwarf2_get_attr_constant_value to it.
24860
24861    However, note that for some attributes you must check
24862    attr_form_is_section_offset before using this test.  DW_FORM_data4
24863    and DW_FORM_data8 are members of both the constant class, and of
24864    the classes that contain offsets into other debug sections
24865    (lineptr, loclistptr, macptr or rangelistptr).  The DWARF spec says
24866    that, if an attribute's can be either a constant or one of the
24867    section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
24868    taken as section offsets, not constants.
24869
24870    DW_FORM_data16 is not considered as dwarf2_get_attr_constant_value
24871    cannot handle that.  */
24872
24873 static int
24874 attr_form_is_constant (const struct attribute *attr)
24875 {
24876   switch (attr->form)
24877     {
24878     case DW_FORM_sdata:
24879     case DW_FORM_udata:
24880     case DW_FORM_data1:
24881     case DW_FORM_data2:
24882     case DW_FORM_data4:
24883     case DW_FORM_data8:
24884     case DW_FORM_implicit_const:
24885       return 1;
24886     default:
24887       return 0;
24888     }
24889 }
24890
24891
24892 /* DW_ADDR is always stored already as sect_offset; despite for the forms
24893    besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file.  */
24894
24895 static int
24896 attr_form_is_ref (const struct attribute *attr)
24897 {
24898   switch (attr->form)
24899     {
24900     case DW_FORM_ref_addr:
24901     case DW_FORM_ref1:
24902     case DW_FORM_ref2:
24903     case DW_FORM_ref4:
24904     case DW_FORM_ref8:
24905     case DW_FORM_ref_udata:
24906     case DW_FORM_GNU_ref_alt:
24907       return 1;
24908     default:
24909       return 0;
24910     }
24911 }
24912
24913 /* Return the .debug_loc section to use for CU.
24914    For DWO files use .debug_loc.dwo.  */
24915
24916 static struct dwarf2_section_info *
24917 cu_debug_loc_section (struct dwarf2_cu *cu)
24918 {
24919   struct dwarf2_per_objfile *dwarf2_per_objfile
24920     = cu->per_cu->dwarf2_per_objfile;
24921
24922   if (cu->dwo_unit)
24923     {
24924       struct dwo_sections *sections = &cu->dwo_unit->dwo_file->sections;
24925       
24926       return cu->header.version >= 5 ? &sections->loclists : &sections->loc;
24927     }
24928   return (cu->header.version >= 5 ? &dwarf2_per_objfile->loclists
24929                                   : &dwarf2_per_objfile->loc);
24930 }
24931
24932 /* A helper function that fills in a dwarf2_loclist_baton.  */
24933
24934 static void
24935 fill_in_loclist_baton (struct dwarf2_cu *cu,
24936                        struct dwarf2_loclist_baton *baton,
24937                        const struct attribute *attr)
24938 {
24939   struct dwarf2_per_objfile *dwarf2_per_objfile
24940     = cu->per_cu->dwarf2_per_objfile;
24941   struct dwarf2_section_info *section = cu_debug_loc_section (cu);
24942
24943   dwarf2_read_section (dwarf2_per_objfile->objfile, section);
24944
24945   baton->per_cu = cu->per_cu;
24946   gdb_assert (baton->per_cu);
24947   /* We don't know how long the location list is, but make sure we
24948      don't run off the edge of the section.  */
24949   baton->size = section->size - DW_UNSND (attr);
24950   baton->data = section->buffer + DW_UNSND (attr);
24951   baton->base_address = cu->base_address;
24952   baton->from_dwo = cu->dwo_unit != NULL;
24953 }
24954
24955 static void
24956 dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym,
24957                              struct dwarf2_cu *cu, int is_block)
24958 {
24959   struct dwarf2_per_objfile *dwarf2_per_objfile
24960     = cu->per_cu->dwarf2_per_objfile;
24961   struct objfile *objfile = dwarf2_per_objfile->objfile;
24962   struct dwarf2_section_info *section = cu_debug_loc_section (cu);
24963
24964   if (attr_form_is_section_offset (attr)
24965       /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
24966          the section.  If so, fall through to the complaint in the
24967          other branch.  */
24968       && DW_UNSND (attr) < dwarf2_section_size (objfile, section))
24969     {
24970       struct dwarf2_loclist_baton *baton;
24971
24972       baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_loclist_baton);
24973
24974       fill_in_loclist_baton (cu, baton, attr);
24975
24976       if (cu->base_known == 0)
24977         complaint (_("Location list used without "
24978                      "specifying the CU base address."));
24979
24980       SYMBOL_ACLASS_INDEX (sym) = (is_block
24981                                    ? dwarf2_loclist_block_index
24982                                    : dwarf2_loclist_index);
24983       SYMBOL_LOCATION_BATON (sym) = baton;
24984     }
24985   else
24986     {
24987       struct dwarf2_locexpr_baton *baton;
24988
24989       baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
24990       baton->per_cu = cu->per_cu;
24991       gdb_assert (baton->per_cu);
24992
24993       if (attr_form_is_block (attr))
24994         {
24995           /* Note that we're just copying the block's data pointer
24996              here, not the actual data.  We're still pointing into the
24997              info_buffer for SYM's objfile; right now we never release
24998              that buffer, but when we do clean up properly this may
24999              need to change.  */
25000           baton->size = DW_BLOCK (attr)->size;
25001           baton->data = DW_BLOCK (attr)->data;
25002         }
25003       else
25004         {
25005           dwarf2_invalid_attrib_class_complaint ("location description",
25006                                                  SYMBOL_NATURAL_NAME (sym));
25007           baton->size = 0;
25008         }
25009
25010       SYMBOL_ACLASS_INDEX (sym) = (is_block
25011                                    ? dwarf2_locexpr_block_index
25012                                    : dwarf2_locexpr_index);
25013       SYMBOL_LOCATION_BATON (sym) = baton;
25014     }
25015 }
25016
25017 /* Return the OBJFILE associated with the compilation unit CU.  If CU
25018    came from a separate debuginfo file, then the master objfile is
25019    returned.  */
25020
25021 struct objfile *
25022 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data *per_cu)
25023 {
25024   struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
25025
25026   /* Return the master objfile, so that we can report and look up the
25027      correct file containing this variable.  */
25028   if (objfile->separate_debug_objfile_backlink)
25029     objfile = objfile->separate_debug_objfile_backlink;
25030
25031   return objfile;
25032 }
25033
25034 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
25035    (CU_HEADERP is unused in such case) or prepare a temporary copy at
25036    CU_HEADERP first.  */
25037
25038 static const struct comp_unit_head *
25039 per_cu_header_read_in (struct comp_unit_head *cu_headerp,
25040                        struct dwarf2_per_cu_data *per_cu)
25041 {
25042   const gdb_byte *info_ptr;
25043
25044   if (per_cu->cu)
25045     return &per_cu->cu->header;
25046
25047   info_ptr = per_cu->section->buffer + to_underlying (per_cu->sect_off);
25048
25049   memset (cu_headerp, 0, sizeof (*cu_headerp));
25050   read_comp_unit_head (cu_headerp, info_ptr, per_cu->section,
25051                        rcuh_kind::COMPILE);
25052
25053   return cu_headerp;
25054 }
25055
25056 /* Return the address size given in the compilation unit header for CU.  */
25057
25058 int
25059 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data *per_cu)
25060 {
25061   struct comp_unit_head cu_header_local;
25062   const struct comp_unit_head *cu_headerp;
25063
25064   cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25065
25066   return cu_headerp->addr_size;
25067 }
25068
25069 /* Return the offset size given in the compilation unit header for CU.  */
25070
25071 int
25072 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data *per_cu)
25073 {
25074   struct comp_unit_head cu_header_local;
25075   const struct comp_unit_head *cu_headerp;
25076
25077   cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25078
25079   return cu_headerp->offset_size;
25080 }
25081
25082 /* See its dwarf2loc.h declaration.  */
25083
25084 int
25085 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data *per_cu)
25086 {
25087   struct comp_unit_head cu_header_local;
25088   const struct comp_unit_head *cu_headerp;
25089
25090   cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25091
25092   if (cu_headerp->version == 2)
25093     return cu_headerp->addr_size;
25094   else
25095     return cu_headerp->offset_size;
25096 }
25097
25098 /* Return the text offset of the CU.  The returned offset comes from
25099    this CU's objfile.  If this objfile came from a separate debuginfo
25100    file, then the offset may be different from the corresponding
25101    offset in the parent objfile.  */
25102
25103 CORE_ADDR
25104 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data *per_cu)
25105 {
25106   struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
25107
25108   return ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
25109 }
25110
25111 /* Return DWARF version number of PER_CU.  */
25112
25113 short
25114 dwarf2_version (struct dwarf2_per_cu_data *per_cu)
25115 {
25116   return per_cu->dwarf_version;
25117 }
25118
25119 /* Locate the .debug_info compilation unit from CU's objfile which contains
25120    the DIE at OFFSET.  Raises an error on failure.  */
25121
25122 static struct dwarf2_per_cu_data *
25123 dwarf2_find_containing_comp_unit (sect_offset sect_off,
25124                                   unsigned int offset_in_dwz,
25125                                   struct dwarf2_per_objfile *dwarf2_per_objfile)
25126 {
25127   struct dwarf2_per_cu_data *this_cu;
25128   int low, high;
25129
25130   low = 0;
25131   high = dwarf2_per_objfile->all_comp_units.size () - 1;
25132   while (high > low)
25133     {
25134       struct dwarf2_per_cu_data *mid_cu;
25135       int mid = low + (high - low) / 2;
25136
25137       mid_cu = dwarf2_per_objfile->all_comp_units[mid];
25138       if (mid_cu->is_dwz > offset_in_dwz
25139           || (mid_cu->is_dwz == offset_in_dwz
25140               && mid_cu->sect_off + mid_cu->length >= sect_off))
25141         high = mid;
25142       else
25143         low = mid + 1;
25144     }
25145   gdb_assert (low == high);
25146   this_cu = dwarf2_per_objfile->all_comp_units[low];
25147   if (this_cu->is_dwz != offset_in_dwz || this_cu->sect_off > sect_off)
25148     {
25149       if (low == 0 || this_cu->is_dwz != offset_in_dwz)
25150         error (_("Dwarf Error: could not find partial DIE containing "
25151                "offset %s [in module %s]"),
25152                sect_offset_str (sect_off),
25153                bfd_get_filename (dwarf2_per_objfile->objfile->obfd));
25154
25155       gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->sect_off
25156                   <= sect_off);
25157       return dwarf2_per_objfile->all_comp_units[low-1];
25158     }
25159   else
25160     {
25161       this_cu = dwarf2_per_objfile->all_comp_units[low];
25162       if (low == dwarf2_per_objfile->all_comp_units.size () - 1
25163           && sect_off >= this_cu->sect_off + this_cu->length)
25164         error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off));
25165       gdb_assert (sect_off < this_cu->sect_off + this_cu->length);
25166       return this_cu;
25167     }
25168 }
25169
25170 /* Initialize dwarf2_cu CU, owned by PER_CU.  */
25171
25172 dwarf2_cu::dwarf2_cu (struct dwarf2_per_cu_data *per_cu_)
25173   : per_cu (per_cu_),
25174     mark (false),
25175     has_loclist (false),
25176     checked_producer (false),
25177     producer_is_gxx_lt_4_6 (false),
25178     producer_is_gcc_lt_4_3 (false),
25179     producer_is_icc (false),
25180     producer_is_icc_lt_14 (false),
25181     producer_is_codewarrior (false),
25182     processing_has_namespace_info (false)
25183 {
25184   per_cu->cu = this;
25185 }
25186
25187 /* Destroy a dwarf2_cu.  */
25188
25189 dwarf2_cu::~dwarf2_cu ()
25190 {
25191   per_cu->cu = NULL;
25192 }
25193
25194 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE.  */
25195
25196 static void
25197 prepare_one_comp_unit (struct dwarf2_cu *cu, struct die_info *comp_unit_die,
25198                        enum language pretend_language)
25199 {
25200   struct attribute *attr;
25201
25202   /* Set the language we're debugging.  */
25203   attr = dwarf2_attr (comp_unit_die, DW_AT_language, cu);
25204   if (attr)
25205     set_cu_language (DW_UNSND (attr), cu);
25206   else
25207     {
25208       cu->language = pretend_language;
25209       cu->language_defn = language_def (cu->language);
25210     }
25211
25212   cu->producer = dwarf2_string_attr (comp_unit_die, DW_AT_producer, cu);
25213 }
25214
25215 /* Increase the age counter on each cached compilation unit, and free
25216    any that are too old.  */
25217
25218 static void
25219 age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
25220 {
25221   struct dwarf2_per_cu_data *per_cu, **last_chain;
25222
25223   dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
25224   per_cu = dwarf2_per_objfile->read_in_chain;
25225   while (per_cu != NULL)
25226     {
25227       per_cu->cu->last_used ++;
25228       if (per_cu->cu->last_used <= dwarf_max_cache_age)
25229         dwarf2_mark (per_cu->cu);
25230       per_cu = per_cu->cu->read_in_chain;
25231     }
25232
25233   per_cu = dwarf2_per_objfile->read_in_chain;
25234   last_chain = &dwarf2_per_objfile->read_in_chain;
25235   while (per_cu != NULL)
25236     {
25237       struct dwarf2_per_cu_data *next_cu;
25238
25239       next_cu = per_cu->cu->read_in_chain;
25240
25241       if (!per_cu->cu->mark)
25242         {
25243           delete per_cu->cu;
25244           *last_chain = next_cu;
25245         }
25246       else
25247         last_chain = &per_cu->cu->read_in_chain;
25248
25249       per_cu = next_cu;
25250     }
25251 }
25252
25253 /* Remove a single compilation unit from the cache.  */
25254
25255 static void
25256 free_one_cached_comp_unit (struct dwarf2_per_cu_data *target_per_cu)
25257 {
25258   struct dwarf2_per_cu_data *per_cu, **last_chain;
25259   struct dwarf2_per_objfile *dwarf2_per_objfile
25260     = target_per_cu->dwarf2_per_objfile;
25261
25262   per_cu = dwarf2_per_objfile->read_in_chain;
25263   last_chain = &dwarf2_per_objfile->read_in_chain;
25264   while (per_cu != NULL)
25265     {
25266       struct dwarf2_per_cu_data *next_cu;
25267
25268       next_cu = per_cu->cu->read_in_chain;
25269
25270       if (per_cu == target_per_cu)
25271         {
25272           delete per_cu->cu;
25273           per_cu->cu = NULL;
25274           *last_chain = next_cu;
25275           break;
25276         }
25277       else
25278         last_chain = &per_cu->cu->read_in_chain;
25279
25280       per_cu = next_cu;
25281     }
25282 }
25283
25284 /* Cleanup function for the dwarf2_per_objfile data.  */
25285
25286 static void
25287 dwarf2_free_objfile (struct objfile *objfile, void *datum)
25288 {
25289   struct dwarf2_per_objfile *dwarf2_per_objfile
25290     = static_cast<struct dwarf2_per_objfile *> (datum);
25291
25292   delete dwarf2_per_objfile;
25293 }
25294
25295 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
25296    We store these in a hash table separate from the DIEs, and preserve them
25297    when the DIEs are flushed out of cache.
25298
25299    The CU "per_cu" pointer is needed because offset alone is not enough to
25300    uniquely identify the type.  A file may have multiple .debug_types sections,
25301    or the type may come from a DWO file.  Furthermore, while it's more logical
25302    to use per_cu->section+offset, with Fission the section with the data is in
25303    the DWO file but we don't know that section at the point we need it.
25304    We have to use something in dwarf2_per_cu_data (or the pointer to it)
25305    because we can enter the lookup routine, get_die_type_at_offset, from
25306    outside this file, and thus won't necessarily have PER_CU->cu.
25307    Fortunately, PER_CU is stable for the life of the objfile.  */
25308
25309 struct dwarf2_per_cu_offset_and_type
25310 {
25311   const struct dwarf2_per_cu_data *per_cu;
25312   sect_offset sect_off;
25313   struct type *type;
25314 };
25315
25316 /* Hash function for a dwarf2_per_cu_offset_and_type.  */
25317
25318 static hashval_t
25319 per_cu_offset_and_type_hash (const void *item)
25320 {
25321   const struct dwarf2_per_cu_offset_and_type *ofs
25322     = (const struct dwarf2_per_cu_offset_and_type *) item;
25323
25324   return (uintptr_t) ofs->per_cu + to_underlying (ofs->sect_off);
25325 }
25326
25327 /* Equality function for a dwarf2_per_cu_offset_and_type.  */
25328
25329 static int
25330 per_cu_offset_and_type_eq (const void *item_lhs, const void *item_rhs)
25331 {
25332   const struct dwarf2_per_cu_offset_and_type *ofs_lhs
25333     = (const struct dwarf2_per_cu_offset_and_type *) item_lhs;
25334   const struct dwarf2_per_cu_offset_and_type *ofs_rhs
25335     = (const struct dwarf2_per_cu_offset_and_type *) item_rhs;
25336
25337   return (ofs_lhs->per_cu == ofs_rhs->per_cu
25338           && ofs_lhs->sect_off == ofs_rhs->sect_off);
25339 }
25340
25341 /* Set the type associated with DIE to TYPE.  Save it in CU's hash
25342    table if necessary.  For convenience, return TYPE.
25343
25344    The DIEs reading must have careful ordering to:
25345     * Not cause infite loops trying to read in DIEs as a prerequisite for
25346       reading current DIE.
25347     * Not trying to dereference contents of still incompletely read in types
25348       while reading in other DIEs.
25349     * Enable referencing still incompletely read in types just by a pointer to
25350       the type without accessing its fields.
25351
25352    Therefore caller should follow these rules:
25353      * Try to fetch any prerequisite types we may need to build this DIE type
25354        before building the type and calling set_die_type.
25355      * After building type call set_die_type for current DIE as soon as
25356        possible before fetching more types to complete the current type.
25357      * Make the type as complete as possible before fetching more types.  */
25358
25359 static struct type *
25360 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
25361 {
25362   struct dwarf2_per_objfile *dwarf2_per_objfile
25363     = cu->per_cu->dwarf2_per_objfile;
25364   struct dwarf2_per_cu_offset_and_type **slot, ofs;
25365   struct objfile *objfile = dwarf2_per_objfile->objfile;
25366   struct attribute *attr;
25367   struct dynamic_prop prop;
25368
25369   /* For Ada types, make sure that the gnat-specific data is always
25370      initialized (if not already set).  There are a few types where
25371      we should not be doing so, because the type-specific area is
25372      already used to hold some other piece of info (eg: TYPE_CODE_FLT
25373      where the type-specific area is used to store the floatformat).
25374      But this is not a problem, because the gnat-specific information
25375      is actually not needed for these types.  */
25376   if (need_gnat_info (cu)
25377       && TYPE_CODE (type) != TYPE_CODE_FUNC
25378       && TYPE_CODE (type) != TYPE_CODE_FLT
25379       && TYPE_CODE (type) != TYPE_CODE_METHODPTR
25380       && TYPE_CODE (type) != TYPE_CODE_MEMBERPTR
25381       && TYPE_CODE (type) != TYPE_CODE_METHOD
25382       && !HAVE_GNAT_AUX_INFO (type))
25383     INIT_GNAT_SPECIFIC (type);
25384
25385   /* Read DW_AT_allocated and set in type.  */
25386   attr = dwarf2_attr (die, DW_AT_allocated, cu);
25387   if (attr_form_is_block (attr))
25388     {
25389       if (attr_to_dynamic_prop (attr, die, cu, &prop))
25390         add_dyn_prop (DYN_PROP_ALLOCATED, prop, type);
25391     }
25392   else if (attr != NULL)
25393     {
25394       complaint (_("DW_AT_allocated has the wrong form (%s) at DIE %s"),
25395                  (attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
25396                  sect_offset_str (die->sect_off));
25397     }
25398
25399   /* Read DW_AT_associated and set in type.  */
25400   attr = dwarf2_attr (die, DW_AT_associated, cu);
25401   if (attr_form_is_block (attr))
25402     {
25403       if (attr_to_dynamic_prop (attr, die, cu, &prop))
25404         add_dyn_prop (DYN_PROP_ASSOCIATED, prop, type);
25405     }
25406   else if (attr != NULL)
25407     {
25408       complaint (_("DW_AT_associated has the wrong form (%s) at DIE %s"),
25409                  (attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
25410                  sect_offset_str (die->sect_off));
25411     }
25412
25413   /* Read DW_AT_data_location and set in type.  */
25414   attr = dwarf2_attr (die, DW_AT_data_location, cu);
25415   if (attr_to_dynamic_prop (attr, die, cu, &prop))
25416     add_dyn_prop (DYN_PROP_DATA_LOCATION, prop, type);
25417
25418   if (dwarf2_per_objfile->die_type_hash == NULL)
25419     {
25420       dwarf2_per_objfile->die_type_hash =
25421         htab_create_alloc_ex (127,
25422                               per_cu_offset_and_type_hash,
25423                               per_cu_offset_and_type_eq,
25424                               NULL,
25425                               &objfile->objfile_obstack,
25426                               hashtab_obstack_allocate,
25427                               dummy_obstack_deallocate);
25428     }
25429
25430   ofs.per_cu = cu->per_cu;
25431   ofs.sect_off = die->sect_off;
25432   ofs.type = type;
25433   slot = (struct dwarf2_per_cu_offset_and_type **)
25434     htab_find_slot (dwarf2_per_objfile->die_type_hash, &ofs, INSERT);
25435   if (*slot)
25436     complaint (_("A problem internal to GDB: DIE %s has type already set"),
25437                sect_offset_str (die->sect_off));
25438   *slot = XOBNEW (&objfile->objfile_obstack,
25439                   struct dwarf2_per_cu_offset_and_type);
25440   **slot = ofs;
25441   return type;
25442 }
25443
25444 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
25445    or return NULL if the die does not have a saved type.  */
25446
25447 static struct type *
25448 get_die_type_at_offset (sect_offset sect_off,
25449                         struct dwarf2_per_cu_data *per_cu)
25450 {
25451   struct dwarf2_per_cu_offset_and_type *slot, ofs;
25452   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
25453
25454   if (dwarf2_per_objfile->die_type_hash == NULL)
25455     return NULL;
25456
25457   ofs.per_cu = per_cu;
25458   ofs.sect_off = sect_off;
25459   slot = ((struct dwarf2_per_cu_offset_and_type *)
25460           htab_find (dwarf2_per_objfile->die_type_hash, &ofs));
25461   if (slot)
25462     return slot->type;
25463   else
25464     return NULL;
25465 }
25466
25467 /* Look up the type for DIE in CU in die_type_hash,
25468    or return NULL if DIE does not have a saved type.  */
25469
25470 static struct type *
25471 get_die_type (struct die_info *die, struct dwarf2_cu *cu)
25472 {
25473   return get_die_type_at_offset (die->sect_off, cu->per_cu);
25474 }
25475
25476 /* Add a dependence relationship from CU to REF_PER_CU.  */
25477
25478 static void
25479 dwarf2_add_dependence (struct dwarf2_cu *cu,
25480                        struct dwarf2_per_cu_data *ref_per_cu)
25481 {
25482   void **slot;
25483
25484   if (cu->dependencies == NULL)
25485     cu->dependencies
25486       = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
25487                               NULL, &cu->comp_unit_obstack,
25488                               hashtab_obstack_allocate,
25489                               dummy_obstack_deallocate);
25490
25491   slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
25492   if (*slot == NULL)
25493     *slot = ref_per_cu;
25494 }
25495
25496 /* Subroutine of dwarf2_mark to pass to htab_traverse.
25497    Set the mark field in every compilation unit in the
25498    cache that we must keep because we are keeping CU.  */
25499
25500 static int
25501 dwarf2_mark_helper (void **slot, void *data)
25502 {
25503   struct dwarf2_per_cu_data *per_cu;
25504
25505   per_cu = (struct dwarf2_per_cu_data *) *slot;
25506
25507   /* cu->dependencies references may not yet have been ever read if QUIT aborts
25508      reading of the chain.  As such dependencies remain valid it is not much
25509      useful to track and undo them during QUIT cleanups.  */
25510   if (per_cu->cu == NULL)
25511     return 1;
25512
25513   if (per_cu->cu->mark)
25514     return 1;
25515   per_cu->cu->mark = true;
25516
25517   if (per_cu->cu->dependencies != NULL)
25518     htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
25519
25520   return 1;
25521 }
25522
25523 /* Set the mark field in CU and in every other compilation unit in the
25524    cache that we must keep because we are keeping CU.  */
25525
25526 static void
25527 dwarf2_mark (struct dwarf2_cu *cu)
25528 {
25529   if (cu->mark)
25530     return;
25531   cu->mark = true;
25532   if (cu->dependencies != NULL)
25533     htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
25534 }
25535
25536 static void
25537 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
25538 {
25539   while (per_cu)
25540     {
25541       per_cu->cu->mark = false;
25542       per_cu = per_cu->cu->read_in_chain;
25543     }
25544 }
25545
25546 /* Trivial hash function for partial_die_info: the hash value of a DIE
25547    is its offset in .debug_info for this objfile.  */
25548
25549 static hashval_t
25550 partial_die_hash (const void *item)
25551 {
25552   const struct partial_die_info *part_die
25553     = (const struct partial_die_info *) item;
25554
25555   return to_underlying (part_die->sect_off);
25556 }
25557
25558 /* Trivial comparison function for partial_die_info structures: two DIEs
25559    are equal if they have the same offset.  */
25560
25561 static int
25562 partial_die_eq (const void *item_lhs, const void *item_rhs)
25563 {
25564   const struct partial_die_info *part_die_lhs
25565     = (const struct partial_die_info *) item_lhs;
25566   const struct partial_die_info *part_die_rhs
25567     = (const struct partial_die_info *) item_rhs;
25568
25569   return part_die_lhs->sect_off == part_die_rhs->sect_off;
25570 }
25571
25572 struct cmd_list_element *set_dwarf_cmdlist;
25573 struct cmd_list_element *show_dwarf_cmdlist;
25574
25575 static void
25576 set_dwarf_cmd (const char *args, int from_tty)
25577 {
25578   help_list (set_dwarf_cmdlist, "maintenance set dwarf ", all_commands,
25579              gdb_stdout);
25580 }
25581
25582 static void
25583 show_dwarf_cmd (const char *args, int from_tty)
25584 {
25585   cmd_show_list (show_dwarf_cmdlist, from_tty, "");
25586 }
25587
25588 int dwarf_always_disassemble;
25589
25590 static void
25591 show_dwarf_always_disassemble (struct ui_file *file, int from_tty,
25592                                struct cmd_list_element *c, const char *value)
25593 {
25594   fprintf_filtered (file,
25595                     _("Whether to always disassemble "
25596                       "DWARF expressions is %s.\n"),
25597                     value);
25598 }
25599
25600 static void
25601 show_check_physname (struct ui_file *file, int from_tty,
25602                      struct cmd_list_element *c, const char *value)
25603 {
25604   fprintf_filtered (file,
25605                     _("Whether to check \"physname\" is %s.\n"),
25606                     value);
25607 }
25608
25609 void
25610 _initialize_dwarf2_read (void)
25611 {
25612   dwarf2_objfile_data_key
25613     = register_objfile_data_with_cleanup (nullptr, dwarf2_free_objfile);
25614
25615   add_prefix_cmd ("dwarf", class_maintenance, set_dwarf_cmd, _("\
25616 Set DWARF specific variables.\n\
25617 Configure DWARF variables such as the cache size"),
25618                   &set_dwarf_cmdlist, "maintenance set dwarf ",
25619                   0/*allow-unknown*/, &maintenance_set_cmdlist);
25620
25621   add_prefix_cmd ("dwarf", class_maintenance, show_dwarf_cmd, _("\
25622 Show DWARF specific variables\n\
25623 Show DWARF variables such as the cache size"),
25624                   &show_dwarf_cmdlist, "maintenance show dwarf ",
25625                   0/*allow-unknown*/, &maintenance_show_cmdlist);
25626
25627   add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
25628                             &dwarf_max_cache_age, _("\
25629 Set the upper bound on the age of cached DWARF compilation units."), _("\
25630 Show the upper bound on the age of cached DWARF compilation units."), _("\
25631 A higher limit means that cached compilation units will be stored\n\
25632 in memory longer, and more total memory will be used.  Zero disables\n\
25633 caching, which can slow down startup."),
25634                             NULL,
25635                             show_dwarf_max_cache_age,
25636                             &set_dwarf_cmdlist,
25637                             &show_dwarf_cmdlist);
25638
25639   add_setshow_boolean_cmd ("always-disassemble", class_obscure,
25640                            &dwarf_always_disassemble, _("\
25641 Set whether `info address' always disassembles DWARF expressions."), _("\
25642 Show whether `info address' always disassembles DWARF expressions."), _("\
25643 When enabled, DWARF expressions are always printed in an assembly-like\n\
25644 syntax.  When disabled, expressions will be printed in a more\n\
25645 conversational style, when possible."),
25646                            NULL,
25647                            show_dwarf_always_disassemble,
25648                            &set_dwarf_cmdlist,
25649                            &show_dwarf_cmdlist);
25650
25651   add_setshow_zuinteger_cmd ("dwarf-read", no_class, &dwarf_read_debug, _("\
25652 Set debugging of the DWARF reader."), _("\
25653 Show debugging of the DWARF reader."), _("\
25654 When enabled (non-zero), debugging messages are printed during DWARF\n\
25655 reading and symtab expansion.  A value of 1 (one) provides basic\n\
25656 information.  A value greater than 1 provides more verbose information."),
25657                             NULL,
25658                             NULL,
25659                             &setdebuglist, &showdebuglist);
25660
25661   add_setshow_zuinteger_cmd ("dwarf-die", no_class, &dwarf_die_debug, _("\
25662 Set debugging of the DWARF DIE reader."), _("\
25663 Show debugging of the DWARF DIE reader."), _("\
25664 When enabled (non-zero), DIEs are dumped after they are read in.\n\
25665 The value is the maximum depth to print."),
25666                              NULL,
25667                              NULL,
25668                              &setdebuglist, &showdebuglist);
25669
25670   add_setshow_zuinteger_cmd ("dwarf-line", no_class, &dwarf_line_debug, _("\
25671 Set debugging of the dwarf line reader."), _("\
25672 Show debugging of the dwarf line reader."), _("\
25673 When enabled (non-zero), line number entries are dumped as they are read in.\n\
25674 A value of 1 (one) provides basic information.\n\
25675 A value greater than 1 provides more verbose information."),
25676                              NULL,
25677                              NULL,
25678                              &setdebuglist, &showdebuglist);
25679
25680   add_setshow_boolean_cmd ("check-physname", no_class, &check_physname, _("\
25681 Set cross-checking of \"physname\" code against demangler."), _("\
25682 Show cross-checking of \"physname\" code against demangler."), _("\
25683 When enabled, GDB's internal \"physname\" code is checked against\n\
25684 the demangler."),
25685                            NULL, show_check_physname,
25686                            &setdebuglist, &showdebuglist);
25687
25688   add_setshow_boolean_cmd ("use-deprecated-index-sections",
25689                            no_class, &use_deprecated_index_sections, _("\
25690 Set whether to use deprecated gdb_index sections."), _("\
25691 Show whether to use deprecated gdb_index sections."), _("\
25692 When enabled, deprecated .gdb_index sections are used anyway.\n\
25693 Normally they are ignored either because of a missing feature or\n\
25694 performance issue.\n\
25695 Warning: This option must be enabled before gdb reads the file."),
25696                            NULL,
25697                            NULL,
25698                            &setlist, &showlist);
25699
25700   dwarf2_locexpr_index = register_symbol_computed_impl (LOC_COMPUTED,
25701                                                         &dwarf2_locexpr_funcs);
25702   dwarf2_loclist_index = register_symbol_computed_impl (LOC_COMPUTED,
25703                                                         &dwarf2_loclist_funcs);
25704
25705   dwarf2_locexpr_block_index = register_symbol_block_impl (LOC_BLOCK,
25706                                         &dwarf2_block_frame_base_locexpr_funcs);
25707   dwarf2_loclist_block_index = register_symbol_block_impl (LOC_BLOCK,
25708                                         &dwarf2_block_frame_base_loclist_funcs);
25709
25710 #if GDB_SELF_TEST
25711   selftests::register_test ("dw2_expand_symtabs_matching",
25712                             selftests::dw2_expand_symtabs_matching::run_test);
25713 #endif
25714 }