Fix crash in dwarf2read.c with template parameters
[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 "dwarf2expr.h"
50 #include "dwarf2loc.h"
51 #include "cp-support.h"
52 #include "hashtab.h"
53 #include "command.h"
54 #include "gdbcmd.h"
55 #include "block.h"
56 #include "addrmap.h"
57 #include "typeprint.h"
58 #include "psympriv.h"
59 #include <sys/stat.h>
60 #include "completer.h"
61 #include "common/vec.h"
62 #include "c-lang.h"
63 #include "go-lang.h"
64 #include "valprint.h"
65 #include "gdbcore.h" /* for gnutarget */
66 #include "gdb/gdb-index.h"
67 #include <ctype.h>
68 #include "gdb_bfd.h"
69 #include "f-lang.h"
70 #include "source.h"
71 #include "common/filestuff.h"
72 #include "build-id.h"
73 #include "namespace.h"
74 #include "common/gdb_unlinker.h"
75 #include "common/function-view.h"
76 #include "common/gdb_optional.h"
77 #include "common/underlying.h"
78 #include "common/byte-vector.h"
79 #include "common/hash_enum.h"
80 #include "filename-seen-cache.h"
81 #include "producer.h"
82 #include <fcntl.h>
83 #include <sys/types.h>
84 #include <algorithm>
85 #include <unordered_set>
86 #include <unordered_map>
87 #include "common/selftest.h"
88 #include <cmath>
89 #include <set>
90 #include <forward_list>
91 #include "rust-lang.h"
92 #include "common/pathstuff.h"
93
94 /* When == 1, print basic high level tracing messages.
95    When > 1, be more verbose.
96    This is in contrast to the low level DIE reading of dwarf_die_debug.  */
97 static unsigned int dwarf_read_debug = 0;
98
99 /* When non-zero, dump DIEs after they are read in.  */
100 static unsigned int dwarf_die_debug = 0;
101
102 /* When non-zero, dump line number entries as they are read in.  */
103 static unsigned int dwarf_line_debug = 0;
104
105 /* When non-zero, cross-check physname against demangler.  */
106 static int check_physname = 0;
107
108 /* When non-zero, do not reject deprecated .gdb_index sections.  */
109 static int use_deprecated_index_sections = 0;
110
111 static const struct objfile_data *dwarf2_objfile_data_key;
112
113 /* The "aclass" indices for various kinds of computed DWARF symbols.  */
114
115 static int dwarf2_locexpr_index;
116 static int dwarf2_loclist_index;
117 static int dwarf2_locexpr_block_index;
118 static int dwarf2_loclist_block_index;
119
120 /* An index into a (C++) symbol name component in a symbol name as
121    recorded in the mapped_index's symbol table.  For each C++ symbol
122    in the symbol table, we record one entry for the start of each
123    component in the symbol in a table of name components, and then
124    sort the table, in order to be able to binary search symbol names,
125    ignoring leading namespaces, both completion and regular look up.
126    For example, for symbol "A::B::C", we'll have an entry that points
127    to "A::B::C", another that points to "B::C", and another for "C".
128    Note that function symbols in GDB index have no parameter
129    information, just the function/method names.  You can convert a
130    name_component to a "const char *" using the
131    'mapped_index::symbol_name_at(offset_type)' method.  */
132
133 struct name_component
134 {
135   /* Offset in the symbol name where the component starts.  Stored as
136      a (32-bit) offset instead of a pointer to save memory and improve
137      locality on 64-bit architectures.  */
138   offset_type name_offset;
139
140   /* The symbol's index in the symbol and constant pool tables of a
141      mapped_index.  */
142   offset_type idx;
143 };
144
145 /* Base class containing bits shared by both .gdb_index and
146    .debug_name indexes.  */
147
148 struct mapped_index_base
149 {
150   mapped_index_base () = default;
151   DISABLE_COPY_AND_ASSIGN (mapped_index_base);
152
153   /* The name_component table (a sorted vector).  See name_component's
154      description above.  */
155   std::vector<name_component> name_components;
156
157   /* How NAME_COMPONENTS is sorted.  */
158   enum case_sensitivity name_components_casing;
159
160   /* Return the number of names in the symbol table.  */
161   virtual size_t symbol_name_count () const = 0;
162
163   /* Get the name of the symbol at IDX in the symbol table.  */
164   virtual const char *symbol_name_at (offset_type idx) const = 0;
165
166   /* Return whether the name at IDX in the symbol table should be
167      ignored.  */
168   virtual bool symbol_name_slot_invalid (offset_type idx) const
169   {
170     return false;
171   }
172
173   /* Build the symbol name component sorted vector, if we haven't
174      yet.  */
175   void build_name_components ();
176
177   /* Returns the lower (inclusive) and upper (exclusive) bounds of the
178      possible matches for LN_NO_PARAMS in the name component
179      vector.  */
180   std::pair<std::vector<name_component>::const_iterator,
181             std::vector<name_component>::const_iterator>
182     find_name_components_bounds (const lookup_name_info &ln_no_params) const;
183
184   /* Prevent deleting/destroying via a base class pointer.  */
185 protected:
186   ~mapped_index_base() = default;
187 };
188
189 /* A description of the mapped index.  The file format is described in
190    a comment by the code that writes the index.  */
191 struct mapped_index final : public mapped_index_base
192 {
193   /* A slot/bucket in the symbol table hash.  */
194   struct symbol_table_slot
195   {
196     const offset_type name;
197     const offset_type vec;
198   };
199
200   /* Index data format version.  */
201   int version = 0;
202
203   /* The address table data.  */
204   gdb::array_view<const gdb_byte> address_table;
205
206   /* The symbol table, implemented as a hash table.  */
207   gdb::array_view<symbol_table_slot> symbol_table;
208
209   /* A pointer to the constant pool.  */
210   const char *constant_pool = nullptr;
211
212   bool symbol_name_slot_invalid (offset_type idx) const override
213   {
214     const auto &bucket = this->symbol_table[idx];
215     return bucket.name == 0 && bucket.vec;
216   }
217
218   /* Convenience method to get at the name of the symbol at IDX in the
219      symbol table.  */
220   const char *symbol_name_at (offset_type idx) const override
221   { return this->constant_pool + MAYBE_SWAP (this->symbol_table[idx].name); }
222
223   size_t symbol_name_count () const override
224   { return this->symbol_table.size (); }
225 };
226
227 /* A description of the mapped .debug_names.
228    Uninitialized map has CU_COUNT 0.  */
229 struct mapped_debug_names final : public mapped_index_base
230 {
231   mapped_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile_)
232   : dwarf2_per_objfile (dwarf2_per_objfile_)
233   {}
234
235   struct dwarf2_per_objfile *dwarf2_per_objfile;
236   bfd_endian dwarf5_byte_order;
237   bool dwarf5_is_dwarf64;
238   bool augmentation_is_gdb;
239   uint8_t offset_size;
240   uint32_t cu_count = 0;
241   uint32_t tu_count, bucket_count, name_count;
242   const gdb_byte *cu_table_reordered, *tu_table_reordered;
243   const uint32_t *bucket_table_reordered, *hash_table_reordered;
244   const gdb_byte *name_table_string_offs_reordered;
245   const gdb_byte *name_table_entry_offs_reordered;
246   const gdb_byte *entry_pool;
247
248   struct index_val
249   {
250     ULONGEST dwarf_tag;
251     struct attr
252     {
253       /* Attribute name DW_IDX_*.  */
254       ULONGEST dw_idx;
255
256       /* Attribute form DW_FORM_*.  */
257       ULONGEST form;
258
259       /* Value if FORM is DW_FORM_implicit_const.  */
260       LONGEST implicit_const;
261     };
262     std::vector<attr> attr_vec;
263   };
264
265   std::unordered_map<ULONGEST, index_val> abbrev_map;
266
267   const char *namei_to_name (uint32_t namei) const;
268
269   /* Implementation of the mapped_index_base virtual interface, for
270      the name_components cache.  */
271
272   const char *symbol_name_at (offset_type idx) const override
273   { return namei_to_name (idx); }
274
275   size_t symbol_name_count () const override
276   { return this->name_count; }
277 };
278
279 /* See dwarf2read.h.  */
280
281 dwarf2_per_objfile *
282 get_dwarf2_per_objfile (struct objfile *objfile)
283 {
284   return ((struct dwarf2_per_objfile *)
285           objfile_data (objfile, dwarf2_objfile_data_key));
286 }
287
288 /* Set the dwarf2_per_objfile associated to OBJFILE.  */
289
290 void
291 set_dwarf2_per_objfile (struct objfile *objfile,
292                         struct dwarf2_per_objfile *dwarf2_per_objfile)
293 {
294   gdb_assert (get_dwarf2_per_objfile (objfile) == NULL);
295   set_objfile_data (objfile, dwarf2_objfile_data_key, dwarf2_per_objfile);
296 }
297
298 /* Default names of the debugging sections.  */
299
300 /* Note that if the debugging section has been compressed, it might
301    have a name like .zdebug_info.  */
302
303 static const struct dwarf2_debug_sections dwarf2_elf_names =
304 {
305   { ".debug_info", ".zdebug_info" },
306   { ".debug_abbrev", ".zdebug_abbrev" },
307   { ".debug_line", ".zdebug_line" },
308   { ".debug_loc", ".zdebug_loc" },
309   { ".debug_loclists", ".zdebug_loclists" },
310   { ".debug_macinfo", ".zdebug_macinfo" },
311   { ".debug_macro", ".zdebug_macro" },
312   { ".debug_str", ".zdebug_str" },
313   { ".debug_line_str", ".zdebug_line_str" },
314   { ".debug_ranges", ".zdebug_ranges" },
315   { ".debug_rnglists", ".zdebug_rnglists" },
316   { ".debug_types", ".zdebug_types" },
317   { ".debug_addr", ".zdebug_addr" },
318   { ".debug_frame", ".zdebug_frame" },
319   { ".eh_frame", NULL },
320   { ".gdb_index", ".zgdb_index" },
321   { ".debug_names", ".zdebug_names" },
322   { ".debug_aranges", ".zdebug_aranges" },
323   23
324 };
325
326 /* List of DWO/DWP sections.  */
327
328 static const struct dwop_section_names
329 {
330   struct dwarf2_section_names abbrev_dwo;
331   struct dwarf2_section_names info_dwo;
332   struct dwarf2_section_names line_dwo;
333   struct dwarf2_section_names loc_dwo;
334   struct dwarf2_section_names loclists_dwo;
335   struct dwarf2_section_names macinfo_dwo;
336   struct dwarf2_section_names macro_dwo;
337   struct dwarf2_section_names str_dwo;
338   struct dwarf2_section_names str_offsets_dwo;
339   struct dwarf2_section_names types_dwo;
340   struct dwarf2_section_names cu_index;
341   struct dwarf2_section_names tu_index;
342 }
343 dwop_section_names =
344 {
345   { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
346   { ".debug_info.dwo", ".zdebug_info.dwo" },
347   { ".debug_line.dwo", ".zdebug_line.dwo" },
348   { ".debug_loc.dwo", ".zdebug_loc.dwo" },
349   { ".debug_loclists.dwo", ".zdebug_loclists.dwo" },
350   { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
351   { ".debug_macro.dwo", ".zdebug_macro.dwo" },
352   { ".debug_str.dwo", ".zdebug_str.dwo" },
353   { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
354   { ".debug_types.dwo", ".zdebug_types.dwo" },
355   { ".debug_cu_index", ".zdebug_cu_index" },
356   { ".debug_tu_index", ".zdebug_tu_index" },
357 };
358
359 /* local data types */
360
361 /* The data in a compilation unit header, after target2host
362    translation, looks like this.  */
363 struct comp_unit_head
364 {
365   unsigned int length;
366   short version;
367   unsigned char addr_size;
368   unsigned char signed_addr_p;
369   sect_offset abbrev_sect_off;
370
371   /* Size of file offsets; either 4 or 8.  */
372   unsigned int offset_size;
373
374   /* Size of the length field; either 4 or 12.  */
375   unsigned int initial_length_size;
376
377   enum dwarf_unit_type unit_type;
378
379   /* Offset to the first byte of this compilation unit header in the
380      .debug_info section, for resolving relative reference dies.  */
381   sect_offset sect_off;
382
383   /* Offset to first die in this cu from the start of the cu.
384      This will be the first byte following the compilation unit header.  */
385   cu_offset first_die_cu_offset;
386
387   /* 64-bit signature of this type unit - it is valid only for
388      UNIT_TYPE DW_UT_type.  */
389   ULONGEST signature;
390
391   /* For types, offset in the type's DIE of the type defined by this TU.  */
392   cu_offset type_cu_offset_in_tu;
393 };
394
395 /* Type used for delaying computation of method physnames.
396    See comments for compute_delayed_physnames.  */
397 struct delayed_method_info
398 {
399   /* The type to which the method is attached, i.e., its parent class.  */
400   struct type *type;
401
402   /* The index of the method in the type's function fieldlists.  */
403   int fnfield_index;
404
405   /* The index of the method in the fieldlist.  */
406   int index;
407
408   /* The name of the DIE.  */
409   const char *name;
410
411   /*  The DIE associated with this method.  */
412   struct die_info *die;
413 };
414
415 /* Internal state when decoding a particular compilation unit.  */
416 struct dwarf2_cu
417 {
418   explicit dwarf2_cu (struct dwarf2_per_cu_data *per_cu);
419   ~dwarf2_cu ();
420
421   DISABLE_COPY_AND_ASSIGN (dwarf2_cu);
422
423   /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
424      Create the set of symtabs used by this TU, or if this TU is sharing
425      symtabs with another TU and the symtabs have already been created
426      then restore those symtabs in the line header.
427      We don't need the pc/line-number mapping for type units.  */
428   void setup_type_unit_groups (struct die_info *die);
429
430   /* Start a symtab for DWARF.  NAME, COMP_DIR, LOW_PC are passed to the
431      buildsym_compunit constructor.  */
432   struct compunit_symtab *start_symtab (const char *name,
433                                         const char *comp_dir,
434                                         CORE_ADDR low_pc);
435
436   /* Reset the builder.  */
437   void reset_builder () { m_builder.reset (); }
438
439   /* The header of the compilation unit.  */
440   struct comp_unit_head header {};
441
442   /* Base address of this compilation unit.  */
443   CORE_ADDR base_address = 0;
444
445   /* Non-zero if base_address has been set.  */
446   int base_known = 0;
447
448   /* The language we are debugging.  */
449   enum language language = language_unknown;
450   const struct language_defn *language_defn = nullptr;
451
452   const char *producer = nullptr;
453
454 private:
455   /* The symtab builder for this CU.  This is only non-NULL when full
456      symbols are being read.  */
457   std::unique_ptr<buildsym_compunit> m_builder;
458
459 public:
460   /* The generic symbol table building routines have separate lists for
461      file scope symbols and all all other scopes (local scopes).  So
462      we need to select the right one to pass to add_symbol_to_list().
463      We do it by keeping a pointer to the correct list in list_in_scope.
464
465      FIXME: The original dwarf code just treated the file scope as the
466      first local scope, and all other local scopes as nested local
467      scopes, and worked fine.  Check to see if we really need to
468      distinguish these in buildsym.c.  */
469   struct pending **list_in_scope = nullptr;
470
471   /* Hash table holding all the loaded partial DIEs
472      with partial_die->offset.SECT_OFF as hash.  */
473   htab_t partial_dies = nullptr;
474
475   /* Storage for things with the same lifetime as this read-in compilation
476      unit, including partial DIEs.  */
477   auto_obstack comp_unit_obstack;
478
479   /* When multiple dwarf2_cu structures are living in memory, this field
480      chains them all together, so that they can be released efficiently.
481      We will probably also want a generation counter so that most-recently-used
482      compilation units are cached...  */
483   struct dwarf2_per_cu_data *read_in_chain = nullptr;
484
485   /* Backlink to our per_cu entry.  */
486   struct dwarf2_per_cu_data *per_cu;
487
488   /* How many compilation units ago was this CU last referenced?  */
489   int last_used = 0;
490
491   /* A hash table of DIE cu_offset for following references with
492      die_info->offset.sect_off as hash.  */
493   htab_t die_hash = nullptr;
494
495   /* Full DIEs if read in.  */
496   struct die_info *dies = nullptr;
497
498   /* A set of pointers to dwarf2_per_cu_data objects for compilation
499      units referenced by this one.  Only set during full symbol processing;
500      partial symbol tables do not have dependencies.  */
501   htab_t dependencies = nullptr;
502
503   /* Header data from the line table, during full symbol processing.  */
504   struct line_header *line_header = nullptr;
505   /* Non-NULL if LINE_HEADER is owned by this DWARF_CU.  Otherwise,
506      it's owned by dwarf2_per_objfile::line_header_hash.  If non-NULL,
507      this is the DW_TAG_compile_unit die for this CU.  We'll hold on
508      to the line header as long as this DIE is being processed.  See
509      process_die_scope.  */
510   die_info *line_header_die_owner = nullptr;
511
512   /* A list of methods which need to have physnames computed
513      after all type information has been read.  */
514   std::vector<delayed_method_info> method_list;
515
516   /* To be copied to symtab->call_site_htab.  */
517   htab_t call_site_htab = nullptr;
518
519   /* Non-NULL if this CU came from a DWO file.
520      There is an invariant here that is important to remember:
521      Except for attributes copied from the top level DIE in the "main"
522      (or "stub") file in preparation for reading the DWO file
523      (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
524      Either there isn't a DWO file (in which case this is NULL and the point
525      is moot), or there is and either we're not going to read it (in which
526      case this is NULL) or there is and we are reading it (in which case this
527      is non-NULL).  */
528   struct dwo_unit *dwo_unit = nullptr;
529
530   /* The DW_AT_addr_base attribute if present, zero otherwise
531      (zero is a valid value though).
532      Note this value comes from the Fission stub CU/TU's DIE.  */
533   ULONGEST addr_base = 0;
534
535   /* The DW_AT_ranges_base attribute if present, zero otherwise
536      (zero is a valid value though).
537      Note this value comes from the Fission stub CU/TU's DIE.
538      Also note that the value is zero in the non-DWO case so this value can
539      be used without needing to know whether DWO files are in use or not.
540      N.B. This does not apply to DW_AT_ranges appearing in
541      DW_TAG_compile_unit dies.  This is a bit of a wart, consider if ever
542      DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
543      DW_AT_ranges_base *would* have to be applied, and we'd have to care
544      whether the DW_AT_ranges attribute came from the skeleton or DWO.  */
545   ULONGEST ranges_base = 0;
546
547   /* When reading debug info generated by older versions of rustc, we
548      have to rewrite some union types to be struct types with a
549      variant part.  This rewriting must be done after the CU is fully
550      read in, because otherwise at the point of rewriting some struct
551      type might not have been fully processed.  So, we keep a list of
552      all such types here and process them after expansion.  */
553   std::vector<struct type *> rust_unions;
554
555   /* Mark used when releasing cached dies.  */
556   bool mark : 1;
557
558   /* This CU references .debug_loc.  See the symtab->locations_valid field.
559      This test is imperfect as there may exist optimized debug code not using
560      any location list and still facing inlining issues if handled as
561      unoptimized code.  For a future better test see GCC PR other/32998.  */
562   bool has_loclist : 1;
563
564   /* These cache the results for producer_is_* fields.  CHECKED_PRODUCER is true
565      if all the producer_is_* fields are valid.  This information is cached
566      because profiling CU expansion showed excessive time spent in
567      producer_is_gxx_lt_4_6.  */
568   bool checked_producer : 1;
569   bool producer_is_gxx_lt_4_6 : 1;
570   bool producer_is_gcc_lt_4_3 : 1;
571   bool producer_is_icc : 1;
572   bool producer_is_icc_lt_14 : 1;
573   bool producer_is_codewarrior : 1;
574
575   /* When true, the file that we're processing is known to have
576      debugging info for C++ namespaces.  GCC 3.3.x did not produce
577      this information, but later versions do.  */
578
579   bool processing_has_namespace_info : 1;
580
581   struct partial_die_info *find_partial_die (sect_offset sect_off);
582
583   /* If this CU was inherited by another CU (via specification,
584      abstract_origin, etc), this is the ancestor CU.  */
585   dwarf2_cu *ancestor;
586
587   /* Get the buildsym_compunit for this CU.  */
588   buildsym_compunit *get_builder ()
589   {
590     /* If this CU has a builder associated with it, use that.  */
591     if (m_builder != nullptr)
592       return m_builder.get ();
593
594     /* Otherwise, search ancestors for a valid builder.  */
595     if (ancestor != nullptr)
596       return ancestor->get_builder ();
597
598     return nullptr;
599   }
600 };
601
602 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
603    This includes type_unit_group and quick_file_names.  */
604
605 struct stmt_list_hash
606 {
607   /* The DWO unit this table is from or NULL if there is none.  */
608   struct dwo_unit *dwo_unit;
609
610   /* Offset in .debug_line or .debug_line.dwo.  */
611   sect_offset line_sect_off;
612 };
613
614 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
615    an object of this type.  */
616
617 struct type_unit_group
618 {
619   /* dwarf2read.c's main "handle" on a TU symtab.
620      To simplify things we create an artificial CU that "includes" all the
621      type units using this stmt_list so that the rest of the code still has
622      a "per_cu" handle on the symtab.
623      This PER_CU is recognized by having no section.  */
624 #define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->section == NULL)
625   struct dwarf2_per_cu_data per_cu;
626
627   /* The TUs that share this DW_AT_stmt_list entry.
628      This is added to while parsing type units to build partial symtabs,
629      and is deleted afterwards and not used again.  */
630   VEC (sig_type_ptr) *tus;
631
632   /* The compunit symtab.
633      Type units in a group needn't all be defined in the same source file,
634      so we create an essentially anonymous symtab as the compunit symtab.  */
635   struct compunit_symtab *compunit_symtab;
636
637   /* The data used to construct the hash key.  */
638   struct stmt_list_hash hash;
639
640   /* The number of symtabs from the line header.
641      The value here must match line_header.num_file_names.  */
642   unsigned int num_symtabs;
643
644   /* The symbol tables for this TU (obtained from the files listed in
645      DW_AT_stmt_list).
646      WARNING: The order of entries here must match the order of entries
647      in the line header.  After the first TU using this type_unit_group, the
648      line header for the subsequent TUs is recreated from this.  This is done
649      because we need to use the same symtabs for each TU using the same
650      DW_AT_stmt_list value.  Also note that symtabs may be repeated here,
651      there's no guarantee the line header doesn't have duplicate entries.  */
652   struct symtab **symtabs;
653 };
654
655 /* These sections are what may appear in a (real or virtual) DWO file.  */
656
657 struct dwo_sections
658 {
659   struct dwarf2_section_info abbrev;
660   struct dwarf2_section_info line;
661   struct dwarf2_section_info loc;
662   struct dwarf2_section_info loclists;
663   struct dwarf2_section_info macinfo;
664   struct dwarf2_section_info macro;
665   struct dwarf2_section_info str;
666   struct dwarf2_section_info str_offsets;
667   /* In the case of a virtual DWO file, these two are unused.  */
668   struct dwarf2_section_info info;
669   VEC (dwarf2_section_info_def) *types;
670 };
671
672 /* CUs/TUs in DWP/DWO files.  */
673
674 struct dwo_unit
675 {
676   /* Backlink to the containing struct dwo_file.  */
677   struct dwo_file *dwo_file;
678
679   /* The "id" that distinguishes this CU/TU.
680      .debug_info calls this "dwo_id", .debug_types calls this "signature".
681      Since signatures came first, we stick with it for consistency.  */
682   ULONGEST signature;
683
684   /* The section this CU/TU lives in, in the DWO file.  */
685   struct dwarf2_section_info *section;
686
687   /* Same as dwarf2_per_cu_data:{sect_off,length} but in the DWO section.  */
688   sect_offset sect_off;
689   unsigned int length;
690
691   /* For types, offset in the type's DIE of the type defined by this TU.  */
692   cu_offset type_offset_in_tu;
693 };
694
695 /* include/dwarf2.h defines the DWP section codes.
696    It defines a max value but it doesn't define a min value, which we
697    use for error checking, so provide one.  */
698
699 enum dwp_v2_section_ids
700 {
701   DW_SECT_MIN = 1
702 };
703
704 /* Data for one DWO file.
705
706    This includes virtual DWO files (a virtual DWO file is a DWO file as it
707    appears in a DWP file).  DWP files don't really have DWO files per se -
708    comdat folding of types "loses" the DWO file they came from, and from
709    a high level view DWP files appear to contain a mass of random types.
710    However, to maintain consistency with the non-DWP case we pretend DWP
711    files contain virtual DWO files, and we assign each TU with one virtual
712    DWO file (generally based on the line and abbrev section offsets -
713    a heuristic that seems to work in practice).  */
714
715 struct dwo_file
716 {
717   /* The DW_AT_GNU_dwo_name attribute.
718      For virtual DWO files the name is constructed from the section offsets
719      of abbrev,line,loc,str_offsets so that we combine virtual DWO files
720      from related CU+TUs.  */
721   const char *dwo_name;
722
723   /* The DW_AT_comp_dir attribute.  */
724   const char *comp_dir;
725
726   /* The bfd, when the file is open.  Otherwise this is NULL.
727      This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd.  */
728   bfd *dbfd;
729
730   /* The sections that make up this DWO file.
731      Remember that for virtual DWO files in DWP V2, these are virtual
732      sections (for lack of a better name).  */
733   struct dwo_sections sections;
734
735   /* The CUs in the file.
736      Each element is a struct dwo_unit. Multiple CUs per DWO are supported as
737      an extension to handle LLVM's Link Time Optimization output (where
738      multiple source files may be compiled into a single object/dwo pair). */
739   htab_t cus;
740
741   /* Table of TUs in the file.
742      Each element is a struct dwo_unit.  */
743   htab_t tus;
744 };
745
746 /* These sections are what may appear in a DWP file.  */
747
748 struct dwp_sections
749 {
750   /* These are used by both DWP version 1 and 2.  */
751   struct dwarf2_section_info str;
752   struct dwarf2_section_info cu_index;
753   struct dwarf2_section_info tu_index;
754
755   /* These are only used by DWP version 2 files.
756      In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
757      sections are referenced by section number, and are not recorded here.
758      In DWP version 2 there is at most one copy of all these sections, each
759      section being (effectively) comprised of the concatenation of all of the
760      individual sections that exist in the version 1 format.
761      To keep the code simple we treat each of these concatenated pieces as a
762      section itself (a virtual section?).  */
763   struct dwarf2_section_info abbrev;
764   struct dwarf2_section_info info;
765   struct dwarf2_section_info line;
766   struct dwarf2_section_info loc;
767   struct dwarf2_section_info macinfo;
768   struct dwarf2_section_info macro;
769   struct dwarf2_section_info str_offsets;
770   struct dwarf2_section_info types;
771 };
772
773 /* These sections are what may appear in a virtual DWO file in DWP version 1.
774    A virtual DWO file is a DWO file as it appears in a DWP file.  */
775
776 struct virtual_v1_dwo_sections
777 {
778   struct dwarf2_section_info abbrev;
779   struct dwarf2_section_info line;
780   struct dwarf2_section_info loc;
781   struct dwarf2_section_info macinfo;
782   struct dwarf2_section_info macro;
783   struct dwarf2_section_info str_offsets;
784   /* Each DWP hash table entry records one CU or one TU.
785      That is recorded here, and copied to dwo_unit.section.  */
786   struct dwarf2_section_info info_or_types;
787 };
788
789 /* Similar to virtual_v1_dwo_sections, but for DWP version 2.
790    In version 2, the sections of the DWO files are concatenated together
791    and stored in one section of that name.  Thus each ELF section contains
792    several "virtual" sections.  */
793
794 struct virtual_v2_dwo_sections
795 {
796   bfd_size_type abbrev_offset;
797   bfd_size_type abbrev_size;
798
799   bfd_size_type line_offset;
800   bfd_size_type line_size;
801
802   bfd_size_type loc_offset;
803   bfd_size_type loc_size;
804
805   bfd_size_type macinfo_offset;
806   bfd_size_type macinfo_size;
807
808   bfd_size_type macro_offset;
809   bfd_size_type macro_size;
810
811   bfd_size_type str_offsets_offset;
812   bfd_size_type str_offsets_size;
813
814   /* Each DWP hash table entry records one CU or one TU.
815      That is recorded here, and copied to dwo_unit.section.  */
816   bfd_size_type info_or_types_offset;
817   bfd_size_type info_or_types_size;
818 };
819
820 /* Contents of DWP hash tables.  */
821
822 struct dwp_hash_table
823 {
824   uint32_t version, nr_columns;
825   uint32_t nr_units, nr_slots;
826   const gdb_byte *hash_table, *unit_table;
827   union
828   {
829     struct
830     {
831       const gdb_byte *indices;
832     } v1;
833     struct
834     {
835       /* This is indexed by column number and gives the id of the section
836          in that column.  */
837 #define MAX_NR_V2_DWO_SECTIONS \
838   (1 /* .debug_info or .debug_types */ \
839    + 1 /* .debug_abbrev */ \
840    + 1 /* .debug_line */ \
841    + 1 /* .debug_loc */ \
842    + 1 /* .debug_str_offsets */ \
843    + 1 /* .debug_macro or .debug_macinfo */)
844       int section_ids[MAX_NR_V2_DWO_SECTIONS];
845       const gdb_byte *offsets;
846       const gdb_byte *sizes;
847     } v2;
848   } section_pool;
849 };
850
851 /* Data for one DWP file.  */
852
853 struct dwp_file
854 {
855   dwp_file (const char *name_, gdb_bfd_ref_ptr &&abfd)
856     : name (name_),
857       dbfd (std::move (abfd))
858   {
859   }
860
861   /* Name of the file.  */
862   const char *name;
863
864   /* File format version.  */
865   int version = 0;
866
867   /* The bfd.  */
868   gdb_bfd_ref_ptr dbfd;
869
870   /* Section info for this file.  */
871   struct dwp_sections sections {};
872
873   /* Table of CUs in the file.  */
874   const struct dwp_hash_table *cus = nullptr;
875
876   /* Table of TUs in the file.  */
877   const struct dwp_hash_table *tus = nullptr;
878
879   /* Tables of loaded CUs/TUs.  Each entry is a struct dwo_unit *.  */
880   htab_t loaded_cus {};
881   htab_t loaded_tus {};
882
883   /* Table to map ELF section numbers to their sections.
884      This is only needed for the DWP V1 file format.  */
885   unsigned int num_sections = 0;
886   asection **elf_sections = nullptr;
887 };
888
889 /* This represents a '.dwz' file.  */
890
891 struct dwz_file
892 {
893   dwz_file (gdb_bfd_ref_ptr &&bfd)
894     : dwz_bfd (std::move (bfd))
895   {
896   }
897
898   /* A dwz file can only contain a few sections.  */
899   struct dwarf2_section_info abbrev {};
900   struct dwarf2_section_info info {};
901   struct dwarf2_section_info str {};
902   struct dwarf2_section_info line {};
903   struct dwarf2_section_info macro {};
904   struct dwarf2_section_info gdb_index {};
905   struct dwarf2_section_info debug_names {};
906
907   /* The dwz's BFD.  */
908   gdb_bfd_ref_ptr dwz_bfd;
909
910   /* If we loaded the index from an external file, this contains the
911      resources associated to the open file, memory mapping, etc.  */
912   std::unique_ptr<index_cache_resource> index_cache_res;
913 };
914
915 /* Struct used to pass misc. parameters to read_die_and_children, et
916    al.  which are used for both .debug_info and .debug_types dies.
917    All parameters here are unchanging for the life of the call.  This
918    struct exists to abstract away the constant parameters of die reading.  */
919
920 struct die_reader_specs
921 {
922   /* The bfd of die_section.  */
923   bfd* abfd;
924
925   /* The CU of the DIE we are parsing.  */
926   struct dwarf2_cu *cu;
927
928   /* Non-NULL if reading a DWO file (including one packaged into a DWP).  */
929   struct dwo_file *dwo_file;
930
931   /* The section the die comes from.
932      This is either .debug_info or .debug_types, or the .dwo variants.  */
933   struct dwarf2_section_info *die_section;
934
935   /* die_section->buffer.  */
936   const gdb_byte *buffer;
937
938   /* The end of the buffer.  */
939   const gdb_byte *buffer_end;
940
941   /* The value of the DW_AT_comp_dir attribute.  */
942   const char *comp_dir;
943
944   /* The abbreviation table to use when reading the DIEs.  */
945   struct abbrev_table *abbrev_table;
946 };
947
948 /* Type of function passed to init_cutu_and_read_dies, et.al.  */
949 typedef void (die_reader_func_ftype) (const struct die_reader_specs *reader,
950                                       const gdb_byte *info_ptr,
951                                       struct die_info *comp_unit_die,
952                                       int has_children,
953                                       void *data);
954
955 /* A 1-based directory index.  This is a strong typedef to prevent
956    accidentally using a directory index as a 0-based index into an
957    array/vector.  */
958 enum class dir_index : unsigned int {};
959
960 /* Likewise, a 1-based file name index.  */
961 enum class file_name_index : unsigned int {};
962
963 struct file_entry
964 {
965   file_entry () = default;
966
967   file_entry (const char *name_, dir_index d_index_,
968               unsigned int mod_time_, unsigned int length_)
969     : name (name_),
970       d_index (d_index_),
971       mod_time (mod_time_),
972       length (length_)
973   {}
974
975   /* Return the include directory at D_INDEX stored in LH.  Returns
976      NULL if D_INDEX is out of bounds.  */
977   const char *include_dir (const line_header *lh) const;
978
979   /* The file name.  Note this is an observing pointer.  The memory is
980      owned by debug_line_buffer.  */
981   const char *name {};
982
983   /* The directory index (1-based).  */
984   dir_index d_index {};
985
986   unsigned int mod_time {};
987
988   unsigned int length {};
989
990   /* True if referenced by the Line Number Program.  */
991   bool included_p {};
992
993   /* The associated symbol table, if any.  */
994   struct symtab *symtab {};
995 };
996
997 /* The line number information for a compilation unit (found in the
998    .debug_line section) begins with a "statement program header",
999    which contains the following information.  */
1000 struct line_header
1001 {
1002   line_header ()
1003     : offset_in_dwz {}
1004   {}
1005
1006   /* Add an entry to the include directory table.  */
1007   void add_include_dir (const char *include_dir);
1008
1009   /* Add an entry to the file name table.  */
1010   void add_file_name (const char *name, dir_index d_index,
1011                       unsigned int mod_time, unsigned int length);
1012
1013   /* Return the include dir at INDEX (1-based).  Returns NULL if INDEX
1014      is out of bounds.  */
1015   const char *include_dir_at (dir_index index) const
1016   {
1017     /* Convert directory index number (1-based) to vector index
1018        (0-based).  */
1019     size_t vec_index = to_underlying (index) - 1;
1020
1021     if (vec_index >= include_dirs.size ())
1022       return NULL;
1023     return include_dirs[vec_index];
1024   }
1025
1026   /* Return the file name at INDEX (1-based).  Returns NULL if INDEX
1027      is out of bounds.  */
1028   file_entry *file_name_at (file_name_index index)
1029   {
1030     /* Convert file name index number (1-based) to vector index
1031        (0-based).  */
1032     size_t vec_index = to_underlying (index) - 1;
1033
1034     if (vec_index >= file_names.size ())
1035       return NULL;
1036     return &file_names[vec_index];
1037   }
1038
1039   /* Offset of line number information in .debug_line section.  */
1040   sect_offset sect_off {};
1041
1042   /* OFFSET is for struct dwz_file associated with dwarf2_per_objfile.  */
1043   unsigned offset_in_dwz : 1; /* Can't initialize bitfields in-class.  */
1044
1045   unsigned int total_length {};
1046   unsigned short version {};
1047   unsigned int header_length {};
1048   unsigned char minimum_instruction_length {};
1049   unsigned char maximum_ops_per_instruction {};
1050   unsigned char default_is_stmt {};
1051   int line_base {};
1052   unsigned char line_range {};
1053   unsigned char opcode_base {};
1054
1055   /* standard_opcode_lengths[i] is the number of operands for the
1056      standard opcode whose value is i.  This means that
1057      standard_opcode_lengths[0] is unused, and the last meaningful
1058      element is standard_opcode_lengths[opcode_base - 1].  */
1059   std::unique_ptr<unsigned char[]> standard_opcode_lengths;
1060
1061   /* The include_directories table.  Note these are observing
1062      pointers.  The memory is owned by debug_line_buffer.  */
1063   std::vector<const char *> include_dirs;
1064
1065   /* The file_names table.  */
1066   std::vector<file_entry> file_names;
1067
1068   /* The start and end of the statement program following this
1069      header.  These point into dwarf2_per_objfile->line_buffer.  */
1070   const gdb_byte *statement_program_start {}, *statement_program_end {};
1071 };
1072
1073 typedef std::unique_ptr<line_header> line_header_up;
1074
1075 const char *
1076 file_entry::include_dir (const line_header *lh) const
1077 {
1078   return lh->include_dir_at (d_index);
1079 }
1080
1081 /* When we construct a partial symbol table entry we only
1082    need this much information.  */
1083 struct partial_die_info : public allocate_on_obstack
1084   {
1085     partial_die_info (sect_offset sect_off, struct abbrev_info *abbrev);
1086
1087     /* Disable assign but still keep copy ctor, which is needed
1088        load_partial_dies.   */
1089     partial_die_info& operator=(const partial_die_info& rhs) = delete;
1090
1091     /* Adjust the partial die before generating a symbol for it.  This
1092        function may set the is_external flag or change the DIE's
1093        name.  */
1094     void fixup (struct dwarf2_cu *cu);
1095
1096     /* Read a minimal amount of information into the minimal die
1097        structure.  */
1098     const gdb_byte *read (const struct die_reader_specs *reader,
1099                           const struct abbrev_info &abbrev,
1100                           const gdb_byte *info_ptr);
1101
1102     /* Offset of this DIE.  */
1103     const sect_offset sect_off;
1104
1105     /* DWARF-2 tag for this DIE.  */
1106     const ENUM_BITFIELD(dwarf_tag) tag : 16;
1107
1108     /* Assorted flags describing the data found in this DIE.  */
1109     const unsigned int has_children : 1;
1110
1111     unsigned int is_external : 1;
1112     unsigned int is_declaration : 1;
1113     unsigned int has_type : 1;
1114     unsigned int has_specification : 1;
1115     unsigned int has_pc_info : 1;
1116     unsigned int may_be_inlined : 1;
1117
1118     /* This DIE has been marked DW_AT_main_subprogram.  */
1119     unsigned int main_subprogram : 1;
1120
1121     /* Flag set if the SCOPE field of this structure has been
1122        computed.  */
1123     unsigned int scope_set : 1;
1124
1125     /* Flag set if the DIE has a byte_size attribute.  */
1126     unsigned int has_byte_size : 1;
1127
1128     /* Flag set if the DIE has a DW_AT_const_value attribute.  */
1129     unsigned int has_const_value : 1;
1130
1131     /* Flag set if any of the DIE's children are template arguments.  */
1132     unsigned int has_template_arguments : 1;
1133
1134     /* Flag set if fixup has been called on this die.  */
1135     unsigned int fixup_called : 1;
1136
1137     /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt.  */
1138     unsigned int is_dwz : 1;
1139
1140     /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt.  */
1141     unsigned int spec_is_dwz : 1;
1142
1143     /* The name of this DIE.  Normally the value of DW_AT_name, but
1144        sometimes a default name for unnamed DIEs.  */
1145     const char *name = nullptr;
1146
1147     /* The linkage name, if present.  */
1148     const char *linkage_name = nullptr;
1149
1150     /* The scope to prepend to our children.  This is generally
1151        allocated on the comp_unit_obstack, so will disappear
1152        when this compilation unit leaves the cache.  */
1153     const char *scope = nullptr;
1154
1155     /* Some data associated with the partial DIE.  The tag determines
1156        which field is live.  */
1157     union
1158     {
1159       /* The location description associated with this DIE, if any.  */
1160       struct dwarf_block *locdesc;
1161       /* The offset of an import, for DW_TAG_imported_unit.  */
1162       sect_offset sect_off;
1163     } d {};
1164
1165     /* If HAS_PC_INFO, the PC range associated with this DIE.  */
1166     CORE_ADDR lowpc = 0;
1167     CORE_ADDR highpc = 0;
1168
1169     /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1170        DW_AT_sibling, if any.  */
1171     /* NOTE: This member isn't strictly necessary, partial_die_info::read
1172        could return DW_AT_sibling values to its caller load_partial_dies.  */
1173     const gdb_byte *sibling = nullptr;
1174
1175     /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1176        DW_AT_specification (or DW_AT_abstract_origin or
1177        DW_AT_extension).  */
1178     sect_offset spec_offset {};
1179
1180     /* Pointers to this DIE's parent, first child, and next sibling,
1181        if any.  */
1182     struct partial_die_info *die_parent = nullptr;
1183     struct partial_die_info *die_child = nullptr;
1184     struct partial_die_info *die_sibling = nullptr;
1185
1186     friend struct partial_die_info *
1187     dwarf2_cu::find_partial_die (sect_offset sect_off);
1188
1189   private:
1190     /* Only need to do look up in dwarf2_cu::find_partial_die.  */
1191     partial_die_info (sect_offset sect_off)
1192       : partial_die_info (sect_off, DW_TAG_padding, 0)
1193     {
1194     }
1195
1196     partial_die_info (sect_offset sect_off_, enum dwarf_tag tag_,
1197                       int has_children_)
1198       : sect_off (sect_off_), tag (tag_), has_children (has_children_)
1199     {
1200       is_external = 0;
1201       is_declaration = 0;
1202       has_type = 0;
1203       has_specification = 0;
1204       has_pc_info = 0;
1205       may_be_inlined = 0;
1206       main_subprogram = 0;
1207       scope_set = 0;
1208       has_byte_size = 0;
1209       has_const_value = 0;
1210       has_template_arguments = 0;
1211       fixup_called = 0;
1212       is_dwz = 0;
1213       spec_is_dwz = 0;
1214     }
1215   };
1216
1217 /* This data structure holds the information of an abbrev.  */
1218 struct abbrev_info
1219   {
1220     unsigned int number;        /* number identifying abbrev */
1221     enum dwarf_tag tag;         /* dwarf tag */
1222     unsigned short has_children;                /* boolean */
1223     unsigned short num_attrs;   /* number of attributes */
1224     struct attr_abbrev *attrs;  /* an array of attribute descriptions */
1225     struct abbrev_info *next;   /* next in chain */
1226   };
1227
1228 struct attr_abbrev
1229   {
1230     ENUM_BITFIELD(dwarf_attribute) name : 16;
1231     ENUM_BITFIELD(dwarf_form) form : 16;
1232
1233     /* It is valid only if FORM is DW_FORM_implicit_const.  */
1234     LONGEST implicit_const;
1235   };
1236
1237 /* Size of abbrev_table.abbrev_hash_table.  */
1238 #define ABBREV_HASH_SIZE 121
1239
1240 /* Top level data structure to contain an abbreviation table.  */
1241
1242 struct abbrev_table
1243 {
1244   explicit abbrev_table (sect_offset off)
1245     : sect_off (off)
1246   {
1247     m_abbrevs =
1248       XOBNEWVEC (&abbrev_obstack, struct abbrev_info *, ABBREV_HASH_SIZE);
1249     memset (m_abbrevs, 0, ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
1250   }
1251
1252   DISABLE_COPY_AND_ASSIGN (abbrev_table);
1253
1254   /* Allocate space for a struct abbrev_info object in
1255      ABBREV_TABLE.  */
1256   struct abbrev_info *alloc_abbrev ();
1257
1258   /* Add an abbreviation to the table.  */
1259   void add_abbrev (unsigned int abbrev_number, struct abbrev_info *abbrev);
1260
1261   /* Look up an abbrev in the table.
1262      Returns NULL if the abbrev is not found.  */
1263
1264   struct abbrev_info *lookup_abbrev (unsigned int abbrev_number);
1265
1266
1267   /* Where the abbrev table came from.
1268      This is used as a sanity check when the table is used.  */
1269   const sect_offset sect_off;
1270
1271   /* Storage for the abbrev table.  */
1272   auto_obstack abbrev_obstack;
1273
1274 private:
1275
1276   /* Hash table of abbrevs.
1277      This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1278      It could be statically allocated, but the previous code didn't so we
1279      don't either.  */
1280   struct abbrev_info **m_abbrevs;
1281 };
1282
1283 typedef std::unique_ptr<struct abbrev_table> abbrev_table_up;
1284
1285 /* Attributes have a name and a value.  */
1286 struct attribute
1287   {
1288     ENUM_BITFIELD(dwarf_attribute) name : 16;
1289     ENUM_BITFIELD(dwarf_form) form : 15;
1290
1291     /* Has DW_STRING already been updated by dwarf2_canonicalize_name?  This
1292        field should be in u.str (existing only for DW_STRING) but it is kept
1293        here for better struct attribute alignment.  */
1294     unsigned int string_is_canonical : 1;
1295
1296     union
1297       {
1298         const char *str;
1299         struct dwarf_block *blk;
1300         ULONGEST unsnd;
1301         LONGEST snd;
1302         CORE_ADDR addr;
1303         ULONGEST signature;
1304       }
1305     u;
1306   };
1307
1308 /* This data structure holds a complete die structure.  */
1309 struct die_info
1310   {
1311     /* DWARF-2 tag for this DIE.  */
1312     ENUM_BITFIELD(dwarf_tag) tag : 16;
1313
1314     /* Number of attributes */
1315     unsigned char num_attrs;
1316
1317     /* True if we're presently building the full type name for the
1318        type derived from this DIE.  */
1319     unsigned char building_fullname : 1;
1320
1321     /* True if this die is in process.  PR 16581.  */
1322     unsigned char in_process : 1;
1323
1324     /* Abbrev number */
1325     unsigned int abbrev;
1326
1327     /* Offset in .debug_info or .debug_types section.  */
1328     sect_offset sect_off;
1329
1330     /* The dies in a compilation unit form an n-ary tree.  PARENT
1331        points to this die's parent; CHILD points to the first child of
1332        this node; and all the children of a given node are chained
1333        together via their SIBLING fields.  */
1334     struct die_info *child;     /* Its first child, if any.  */
1335     struct die_info *sibling;   /* Its next sibling, if any.  */
1336     struct die_info *parent;    /* Its parent, if any.  */
1337
1338     /* An array of attributes, with NUM_ATTRS elements.  There may be
1339        zero, but it's not common and zero-sized arrays are not
1340        sufficiently portable C.  */
1341     struct attribute attrs[1];
1342   };
1343
1344 /* Get at parts of an attribute structure.  */
1345
1346 #define DW_STRING(attr)    ((attr)->u.str)
1347 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1348 #define DW_UNSND(attr)     ((attr)->u.unsnd)
1349 #define DW_BLOCK(attr)     ((attr)->u.blk)
1350 #define DW_SND(attr)       ((attr)->u.snd)
1351 #define DW_ADDR(attr)      ((attr)->u.addr)
1352 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1353
1354 /* Blocks are a bunch of untyped bytes.  */
1355 struct dwarf_block
1356   {
1357     size_t size;
1358
1359     /* Valid only if SIZE is not zero.  */
1360     const gdb_byte *data;
1361   };
1362
1363 #ifndef ATTR_ALLOC_CHUNK
1364 #define ATTR_ALLOC_CHUNK 4
1365 #endif
1366
1367 /* Allocate fields for structs, unions and enums in this size.  */
1368 #ifndef DW_FIELD_ALLOC_CHUNK
1369 #define DW_FIELD_ALLOC_CHUNK 4
1370 #endif
1371
1372 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1373    but this would require a corresponding change in unpack_field_as_long
1374    and friends.  */
1375 static int bits_per_byte = 8;
1376
1377 /* When reading a variant or variant part, we track a bit more
1378    information about the field, and store it in an object of this
1379    type.  */
1380
1381 struct variant_field
1382 {
1383   /* If we see a DW_TAG_variant, then this will be the discriminant
1384      value.  */
1385   ULONGEST discriminant_value;
1386   /* If we see a DW_TAG_variant, then this will be set if this is the
1387      default branch.  */
1388   bool default_branch;
1389   /* While reading a DW_TAG_variant_part, this will be set if this
1390      field is the discriminant.  */
1391   bool is_discriminant;
1392 };
1393
1394 struct nextfield
1395 {
1396   int accessibility = 0;
1397   int virtuality = 0;
1398   /* Extra information to describe a variant or variant part.  */
1399   struct variant_field variant {};
1400   struct field field {};
1401 };
1402
1403 struct fnfieldlist
1404 {
1405   const char *name = nullptr;
1406   std::vector<struct fn_field> fnfields;
1407 };
1408
1409 /* The routines that read and process dies for a C struct or C++ class
1410    pass lists of data member fields and lists of member function fields
1411    in an instance of a field_info structure, as defined below.  */
1412 struct field_info
1413   {
1414     /* List of data member and baseclasses fields.  */
1415     std::vector<struct nextfield> fields;
1416     std::vector<struct nextfield> baseclasses;
1417
1418     /* Number of fields (including baseclasses).  */
1419     int nfields = 0;
1420
1421     /* Set if the accesibility of one of the fields is not public.  */
1422     int non_public_fields = 0;
1423
1424     /* Member function fieldlist array, contains name of possibly overloaded
1425        member function, number of overloaded member functions and a pointer
1426        to the head of the member function field chain.  */
1427     std::vector<struct fnfieldlist> fnfieldlists;
1428
1429     /* typedefs defined inside this class.  TYPEDEF_FIELD_LIST contains head of
1430        a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements.  */
1431     std::vector<struct decl_field> typedef_field_list;
1432
1433     /* Nested types defined by this class and the number of elements in this
1434        list.  */
1435     std::vector<struct decl_field> nested_types_list;
1436   };
1437
1438 /* One item on the queue of compilation units to read in full symbols
1439    for.  */
1440 struct dwarf2_queue_item
1441 {
1442   struct dwarf2_per_cu_data *per_cu;
1443   enum language pretend_language;
1444   struct dwarf2_queue_item *next;
1445 };
1446
1447 /* The current queue.  */
1448 static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail;
1449
1450 /* Loaded secondary compilation units are kept in memory until they
1451    have not been referenced for the processing of this many
1452    compilation units.  Set this to zero to disable caching.  Cache
1453    sizes of up to at least twenty will improve startup time for
1454    typical inter-CU-reference binaries, at an obvious memory cost.  */
1455 static int dwarf_max_cache_age = 5;
1456 static void
1457 show_dwarf_max_cache_age (struct ui_file *file, int from_tty,
1458                           struct cmd_list_element *c, const char *value)
1459 {
1460   fprintf_filtered (file, _("The upper bound on the age of cached "
1461                             "DWARF compilation units is %s.\n"),
1462                     value);
1463 }
1464 \f
1465 /* local function prototypes */
1466
1467 static const char *get_section_name (const struct dwarf2_section_info *);
1468
1469 static const char *get_section_file_name (const struct dwarf2_section_info *);
1470
1471 static void dwarf2_find_base_address (struct die_info *die,
1472                                       struct dwarf2_cu *cu);
1473
1474 static struct partial_symtab *create_partial_symtab
1475   (struct dwarf2_per_cu_data *per_cu, const char *name);
1476
1477 static void build_type_psymtabs_reader (const struct die_reader_specs *reader,
1478                                         const gdb_byte *info_ptr,
1479                                         struct die_info *type_unit_die,
1480                                         int has_children, void *data);
1481
1482 static void dwarf2_build_psymtabs_hard
1483   (struct dwarf2_per_objfile *dwarf2_per_objfile);
1484
1485 static void scan_partial_symbols (struct partial_die_info *,
1486                                   CORE_ADDR *, CORE_ADDR *,
1487                                   int, struct dwarf2_cu *);
1488
1489 static void add_partial_symbol (struct partial_die_info *,
1490                                 struct dwarf2_cu *);
1491
1492 static void add_partial_namespace (struct partial_die_info *pdi,
1493                                    CORE_ADDR *lowpc, CORE_ADDR *highpc,
1494                                    int set_addrmap, struct dwarf2_cu *cu);
1495
1496 static void add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
1497                                 CORE_ADDR *highpc, int set_addrmap,
1498                                 struct dwarf2_cu *cu);
1499
1500 static void add_partial_enumeration (struct partial_die_info *enum_pdi,
1501                                      struct dwarf2_cu *cu);
1502
1503 static void add_partial_subprogram (struct partial_die_info *pdi,
1504                                     CORE_ADDR *lowpc, CORE_ADDR *highpc,
1505                                     int need_pc, struct dwarf2_cu *cu);
1506
1507 static void dwarf2_read_symtab (struct partial_symtab *,
1508                                 struct objfile *);
1509
1510 static void psymtab_to_symtab_1 (struct partial_symtab *);
1511
1512 static abbrev_table_up abbrev_table_read_table
1513   (struct dwarf2_per_objfile *dwarf2_per_objfile, struct dwarf2_section_info *,
1514    sect_offset);
1515
1516 static unsigned int peek_abbrev_code (bfd *, const gdb_byte *);
1517
1518 static struct partial_die_info *load_partial_dies
1519   (const struct die_reader_specs *, const gdb_byte *, int);
1520
1521 static struct partial_die_info *find_partial_die (sect_offset, int,
1522                                                   struct dwarf2_cu *);
1523
1524 static const gdb_byte *read_attribute (const struct die_reader_specs *,
1525                                        struct attribute *, struct attr_abbrev *,
1526                                        const gdb_byte *);
1527
1528 static unsigned int read_1_byte (bfd *, const gdb_byte *);
1529
1530 static int read_1_signed_byte (bfd *, const gdb_byte *);
1531
1532 static unsigned int read_2_bytes (bfd *, const gdb_byte *);
1533
1534 static unsigned int read_4_bytes (bfd *, const gdb_byte *);
1535
1536 static ULONGEST read_8_bytes (bfd *, const gdb_byte *);
1537
1538 static CORE_ADDR read_address (bfd *, const gdb_byte *ptr, struct dwarf2_cu *,
1539                                unsigned int *);
1540
1541 static LONGEST read_initial_length (bfd *, const gdb_byte *, unsigned int *);
1542
1543 static LONGEST read_checked_initial_length_and_offset
1544   (bfd *, const gdb_byte *, const struct comp_unit_head *,
1545    unsigned int *, unsigned int *);
1546
1547 static LONGEST read_offset (bfd *, const gdb_byte *,
1548                             const struct comp_unit_head *,
1549                             unsigned int *);
1550
1551 static LONGEST read_offset_1 (bfd *, const gdb_byte *, unsigned int);
1552
1553 static sect_offset read_abbrev_offset
1554   (struct dwarf2_per_objfile *dwarf2_per_objfile,
1555    struct dwarf2_section_info *, sect_offset);
1556
1557 static const gdb_byte *read_n_bytes (bfd *, const gdb_byte *, unsigned int);
1558
1559 static const char *read_direct_string (bfd *, const gdb_byte *, unsigned int *);
1560
1561 static const char *read_indirect_string
1562   (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *, const gdb_byte *,
1563    const struct comp_unit_head *, unsigned int *);
1564
1565 static const char *read_indirect_line_string
1566   (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *, const gdb_byte *,
1567    const struct comp_unit_head *, unsigned int *);
1568
1569 static const char *read_indirect_string_at_offset
1570   (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *abfd,
1571    LONGEST str_offset);
1572
1573 static const char *read_indirect_string_from_dwz
1574   (struct objfile *objfile, struct dwz_file *, LONGEST);
1575
1576 static LONGEST read_signed_leb128 (bfd *, const gdb_byte *, unsigned int *);
1577
1578 static CORE_ADDR read_addr_index_from_leb128 (struct dwarf2_cu *,
1579                                               const gdb_byte *,
1580                                               unsigned int *);
1581
1582 static const char *read_str_index (const struct die_reader_specs *reader,
1583                                    ULONGEST str_index);
1584
1585 static void set_cu_language (unsigned int, struct dwarf2_cu *);
1586
1587 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
1588                                       struct dwarf2_cu *);
1589
1590 static struct attribute *dwarf2_attr_no_follow (struct die_info *,
1591                                                 unsigned int);
1592
1593 static const char *dwarf2_string_attr (struct die_info *die, unsigned int name,
1594                                        struct dwarf2_cu *cu);
1595
1596 static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
1597                                struct dwarf2_cu *cu);
1598
1599 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
1600
1601 static struct die_info *die_specification (struct die_info *die,
1602                                            struct dwarf2_cu **);
1603
1604 static line_header_up dwarf_decode_line_header (sect_offset sect_off,
1605                                                 struct dwarf2_cu *cu);
1606
1607 static void dwarf_decode_lines (struct line_header *, const char *,
1608                                 struct dwarf2_cu *, struct partial_symtab *,
1609                                 CORE_ADDR, int decode_mapping);
1610
1611 static void dwarf2_start_subfile (struct dwarf2_cu *, const char *,
1612                                   const char *);
1613
1614 static struct symbol *new_symbol (struct die_info *, struct type *,
1615                                   struct dwarf2_cu *, struct symbol * = NULL);
1616
1617 static void dwarf2_const_value (const struct attribute *, struct symbol *,
1618                                 struct dwarf2_cu *);
1619
1620 static void dwarf2_const_value_attr (const struct attribute *attr,
1621                                      struct type *type,
1622                                      const char *name,
1623                                      struct obstack *obstack,
1624                                      struct dwarf2_cu *cu, LONGEST *value,
1625                                      const gdb_byte **bytes,
1626                                      struct dwarf2_locexpr_baton **baton);
1627
1628 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
1629
1630 static int need_gnat_info (struct dwarf2_cu *);
1631
1632 static struct type *die_descriptive_type (struct die_info *,
1633                                           struct dwarf2_cu *);
1634
1635 static void set_descriptive_type (struct type *, struct die_info *,
1636                                   struct dwarf2_cu *);
1637
1638 static struct type *die_containing_type (struct die_info *,
1639                                          struct dwarf2_cu *);
1640
1641 static struct type *lookup_die_type (struct die_info *, const struct attribute *,
1642                                      struct dwarf2_cu *);
1643
1644 static struct type *read_type_die (struct die_info *, struct dwarf2_cu *);
1645
1646 static struct type *read_type_die_1 (struct die_info *, struct dwarf2_cu *);
1647
1648 static const char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
1649
1650 static char *typename_concat (struct obstack *obs, const char *prefix,
1651                               const char *suffix, int physname,
1652                               struct dwarf2_cu *cu);
1653
1654 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
1655
1656 static void read_type_unit_scope (struct die_info *, struct dwarf2_cu *);
1657
1658 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
1659
1660 static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
1661
1662 static void read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu);
1663
1664 static void read_variable (struct die_info *die, struct dwarf2_cu *cu);
1665
1666 static int dwarf2_ranges_read (unsigned, CORE_ADDR *, CORE_ADDR *,
1667                                struct dwarf2_cu *, struct partial_symtab *);
1668
1669 /* How dwarf2_get_pc_bounds constructed its *LOWPC and *HIGHPC return
1670    values.  Keep the items ordered with increasing constraints compliance.  */
1671 enum pc_bounds_kind
1672 {
1673   /* No attribute DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges was found.  */
1674   PC_BOUNDS_NOT_PRESENT,
1675
1676   /* Some of the attributes DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges
1677      were present but they do not form a valid range of PC addresses.  */
1678   PC_BOUNDS_INVALID,
1679
1680   /* Discontiguous range was found - that is DW_AT_ranges was found.  */
1681   PC_BOUNDS_RANGES,
1682
1683   /* Contiguous range was found - DW_AT_low_pc and DW_AT_high_pc were found.  */
1684   PC_BOUNDS_HIGH_LOW,
1685 };
1686
1687 static enum pc_bounds_kind dwarf2_get_pc_bounds (struct die_info *,
1688                                                  CORE_ADDR *, CORE_ADDR *,
1689                                                  struct dwarf2_cu *,
1690                                                  struct partial_symtab *);
1691
1692 static void get_scope_pc_bounds (struct die_info *,
1693                                  CORE_ADDR *, CORE_ADDR *,
1694                                  struct dwarf2_cu *);
1695
1696 static void dwarf2_record_block_ranges (struct die_info *, struct block *,
1697                                         CORE_ADDR, struct dwarf2_cu *);
1698
1699 static void dwarf2_add_field (struct field_info *, struct die_info *,
1700                               struct dwarf2_cu *);
1701
1702 static void dwarf2_attach_fields_to_type (struct field_info *,
1703                                           struct type *, struct dwarf2_cu *);
1704
1705 static void dwarf2_add_member_fn (struct field_info *,
1706                                   struct die_info *, struct type *,
1707                                   struct dwarf2_cu *);
1708
1709 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
1710                                              struct type *,
1711                                              struct dwarf2_cu *);
1712
1713 static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
1714
1715 static void read_common_block (struct die_info *, struct dwarf2_cu *);
1716
1717 static void read_namespace (struct die_info *die, struct dwarf2_cu *);
1718
1719 static void read_module (struct die_info *die, struct dwarf2_cu *cu);
1720
1721 static struct using_direct **using_directives (struct dwarf2_cu *cu);
1722
1723 static void read_import_statement (struct die_info *die, struct dwarf2_cu *);
1724
1725 static int read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu);
1726
1727 static struct type *read_module_type (struct die_info *die,
1728                                       struct dwarf2_cu *cu);
1729
1730 static const char *namespace_name (struct die_info *die,
1731                                    int *is_anonymous, struct dwarf2_cu *);
1732
1733 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
1734
1735 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
1736
1737 static enum dwarf_array_dim_ordering read_array_order (struct die_info *,
1738                                                        struct dwarf2_cu *);
1739
1740 static struct die_info *read_die_and_siblings_1
1741   (const struct die_reader_specs *, const gdb_byte *, const gdb_byte **,
1742    struct die_info *);
1743
1744 static struct die_info *read_die_and_siblings (const struct die_reader_specs *,
1745                                                const gdb_byte *info_ptr,
1746                                                const gdb_byte **new_info_ptr,
1747                                                struct die_info *parent);
1748
1749 static const gdb_byte *read_full_die_1 (const struct die_reader_specs *,
1750                                         struct die_info **, const gdb_byte *,
1751                                         int *, int);
1752
1753 static const gdb_byte *read_full_die (const struct die_reader_specs *,
1754                                       struct die_info **, const gdb_byte *,
1755                                       int *);
1756
1757 static void process_die (struct die_info *, struct dwarf2_cu *);
1758
1759 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu *,
1760                                              struct obstack *);
1761
1762 static const char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
1763
1764 static const char *dwarf2_full_name (const char *name,
1765                                      struct die_info *die,
1766                                      struct dwarf2_cu *cu);
1767
1768 static const char *dwarf2_physname (const char *name, struct die_info *die,
1769                                     struct dwarf2_cu *cu);
1770
1771 static struct die_info *dwarf2_extension (struct die_info *die,
1772                                           struct dwarf2_cu **);
1773
1774 static const char *dwarf_tag_name (unsigned int);
1775
1776 static const char *dwarf_attr_name (unsigned int);
1777
1778 static const char *dwarf_form_name (unsigned int);
1779
1780 static const char *dwarf_bool_name (unsigned int);
1781
1782 static const char *dwarf_type_encoding_name (unsigned int);
1783
1784 static struct die_info *sibling_die (struct die_info *);
1785
1786 static void dump_die_shallow (struct ui_file *, int indent, struct die_info *);
1787
1788 static void dump_die_for_error (struct die_info *);
1789
1790 static void dump_die_1 (struct ui_file *, int level, int max_level,
1791                         struct die_info *);
1792
1793 /*static*/ void dump_die (struct die_info *, int max_level);
1794
1795 static void store_in_ref_table (struct die_info *,
1796                                 struct dwarf2_cu *);
1797
1798 static sect_offset dwarf2_get_ref_die_offset (const struct attribute *);
1799
1800 static LONGEST dwarf2_get_attr_constant_value (const struct attribute *, int);
1801
1802 static struct die_info *follow_die_ref_or_sig (struct die_info *,
1803                                                const struct attribute *,
1804                                                struct dwarf2_cu **);
1805
1806 static struct die_info *follow_die_ref (struct die_info *,
1807                                         const struct attribute *,
1808                                         struct dwarf2_cu **);
1809
1810 static struct die_info *follow_die_sig (struct die_info *,
1811                                         const struct attribute *,
1812                                         struct dwarf2_cu **);
1813
1814 static struct type *get_signatured_type (struct die_info *, ULONGEST,
1815                                          struct dwarf2_cu *);
1816
1817 static struct type *get_DW_AT_signature_type (struct die_info *,
1818                                               const struct attribute *,
1819                                               struct dwarf2_cu *);
1820
1821 static void load_full_type_unit (struct dwarf2_per_cu_data *per_cu);
1822
1823 static void read_signatured_type (struct signatured_type *);
1824
1825 static int attr_to_dynamic_prop (const struct attribute *attr,
1826                                  struct die_info *die, struct dwarf2_cu *cu,
1827                                  struct dynamic_prop *prop);
1828
1829 /* memory allocation interface */
1830
1831 static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
1832
1833 static struct die_info *dwarf_alloc_die (struct dwarf2_cu *, int);
1834
1835 static void dwarf_decode_macros (struct dwarf2_cu *, unsigned int, int);
1836
1837 static int attr_form_is_block (const struct attribute *);
1838
1839 static int attr_form_is_section_offset (const struct attribute *);
1840
1841 static int attr_form_is_constant (const struct attribute *);
1842
1843 static int attr_form_is_ref (const struct attribute *);
1844
1845 static void fill_in_loclist_baton (struct dwarf2_cu *cu,
1846                                    struct dwarf2_loclist_baton *baton,
1847                                    const struct attribute *attr);
1848
1849 static void dwarf2_symbol_mark_computed (const struct attribute *attr,
1850                                          struct symbol *sym,
1851                                          struct dwarf2_cu *cu,
1852                                          int is_block);
1853
1854 static const gdb_byte *skip_one_die (const struct die_reader_specs *reader,
1855                                      const gdb_byte *info_ptr,
1856                                      struct abbrev_info *abbrev);
1857
1858 static hashval_t partial_die_hash (const void *item);
1859
1860 static int partial_die_eq (const void *item_lhs, const void *item_rhs);
1861
1862 static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit
1863   (sect_offset sect_off, unsigned int offset_in_dwz,
1864    struct dwarf2_per_objfile *dwarf2_per_objfile);
1865
1866 static void prepare_one_comp_unit (struct dwarf2_cu *cu,
1867                                    struct die_info *comp_unit_die,
1868                                    enum language pretend_language);
1869
1870 static void age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
1871
1872 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data *);
1873
1874 static struct type *set_die_type (struct die_info *, struct type *,
1875                                   struct dwarf2_cu *);
1876
1877 static void create_all_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
1878
1879 static int create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
1880
1881 static void load_full_comp_unit (struct dwarf2_per_cu_data *, bool,
1882                                  enum language);
1883
1884 static void process_full_comp_unit (struct dwarf2_per_cu_data *,
1885                                     enum language);
1886
1887 static void process_full_type_unit (struct dwarf2_per_cu_data *,
1888                                     enum language);
1889
1890 static void dwarf2_add_dependence (struct dwarf2_cu *,
1891                                    struct dwarf2_per_cu_data *);
1892
1893 static void dwarf2_mark (struct dwarf2_cu *);
1894
1895 static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
1896
1897 static struct type *get_die_type_at_offset (sect_offset,
1898                                             struct dwarf2_per_cu_data *);
1899
1900 static struct type *get_die_type (struct die_info *die, struct dwarf2_cu *cu);
1901
1902 static void queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
1903                              enum language pretend_language);
1904
1905 static void process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile);
1906
1907 /* Class, the destructor of which frees all allocated queue entries.  This
1908    will only have work to do if an error was thrown while processing the
1909    dwarf.  If no error was thrown then the queue entries should have all
1910    been processed, and freed, as we went along.  */
1911
1912 class dwarf2_queue_guard
1913 {
1914 public:
1915   dwarf2_queue_guard () = default;
1916
1917   /* Free any entries remaining on the queue.  There should only be
1918      entries left if we hit an error while processing the dwarf.  */
1919   ~dwarf2_queue_guard ()
1920   {
1921     struct dwarf2_queue_item *item, *last;
1922
1923     item = dwarf2_queue;
1924     while (item)
1925       {
1926         /* Anything still marked queued is likely to be in an
1927            inconsistent state, so discard it.  */
1928         if (item->per_cu->queued)
1929           {
1930             if (item->per_cu->cu != NULL)
1931               free_one_cached_comp_unit (item->per_cu);
1932             item->per_cu->queued = 0;
1933           }
1934
1935         last = item;
1936         item = item->next;
1937         xfree (last);
1938       }
1939
1940     dwarf2_queue = dwarf2_queue_tail = NULL;
1941   }
1942 };
1943
1944 /* The return type of find_file_and_directory.  Note, the enclosed
1945    string pointers are only valid while this object is valid.  */
1946
1947 struct file_and_directory
1948 {
1949   /* The filename.  This is never NULL.  */
1950   const char *name;
1951
1952   /* The compilation directory.  NULL if not known.  If we needed to
1953      compute a new string, this points to COMP_DIR_STORAGE, otherwise,
1954      points directly to the DW_AT_comp_dir string attribute owned by
1955      the obstack that owns the DIE.  */
1956   const char *comp_dir;
1957
1958   /* If we needed to build a new string for comp_dir, this is what
1959      owns the storage.  */
1960   std::string comp_dir_storage;
1961 };
1962
1963 static file_and_directory find_file_and_directory (struct die_info *die,
1964                                                    struct dwarf2_cu *cu);
1965
1966 static char *file_full_name (int file, struct line_header *lh,
1967                              const char *comp_dir);
1968
1969 /* Expected enum dwarf_unit_type for read_comp_unit_head.  */
1970 enum class rcuh_kind { COMPILE, TYPE };
1971
1972 static const gdb_byte *read_and_check_comp_unit_head
1973   (struct dwarf2_per_objfile* dwarf2_per_objfile,
1974    struct comp_unit_head *header,
1975    struct dwarf2_section_info *section,
1976    struct dwarf2_section_info *abbrev_section, const gdb_byte *info_ptr,
1977    rcuh_kind section_kind);
1978
1979 static void init_cutu_and_read_dies
1980   (struct dwarf2_per_cu_data *this_cu, struct abbrev_table *abbrev_table,
1981    int use_existing_cu, int keep, bool skip_partial,
1982    die_reader_func_ftype *die_reader_func, void *data);
1983
1984 static void init_cutu_and_read_dies_simple
1985   (struct dwarf2_per_cu_data *this_cu,
1986    die_reader_func_ftype *die_reader_func, void *data);
1987
1988 static htab_t allocate_signatured_type_table (struct objfile *objfile);
1989
1990 static htab_t allocate_dwo_unit_table (struct objfile *objfile);
1991
1992 static struct dwo_unit *lookup_dwo_unit_in_dwp
1993   (struct dwarf2_per_objfile *dwarf2_per_objfile,
1994    struct dwp_file *dwp_file, const char *comp_dir,
1995    ULONGEST signature, int is_debug_types);
1996
1997 static struct dwp_file *get_dwp_file
1998   (struct dwarf2_per_objfile *dwarf2_per_objfile);
1999
2000 static struct dwo_unit *lookup_dwo_comp_unit
2001   (struct dwarf2_per_cu_data *, const char *, const char *, ULONGEST);
2002
2003 static struct dwo_unit *lookup_dwo_type_unit
2004   (struct signatured_type *, const char *, const char *);
2005
2006 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *);
2007
2008 static void free_dwo_file (struct dwo_file *);
2009
2010 /* A unique_ptr helper to free a dwo_file.  */
2011
2012 struct dwo_file_deleter
2013 {
2014   void operator() (struct dwo_file *df) const
2015   {
2016     free_dwo_file (df);
2017   }
2018 };
2019
2020 /* A unique pointer to a dwo_file.  */
2021
2022 typedef std::unique_ptr<struct dwo_file, dwo_file_deleter> dwo_file_up;
2023
2024 static void process_cu_includes (struct dwarf2_per_objfile *dwarf2_per_objfile);
2025
2026 static void check_producer (struct dwarf2_cu *cu);
2027
2028 static void free_line_header_voidp (void *arg);
2029 \f
2030 /* Various complaints about symbol reading that don't abort the process.  */
2031
2032 static void
2033 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
2034 {
2035   complaint (_("statement list doesn't fit in .debug_line section"));
2036 }
2037
2038 static void
2039 dwarf2_debug_line_missing_file_complaint (void)
2040 {
2041   complaint (_(".debug_line section has line data without a file"));
2042 }
2043
2044 static void
2045 dwarf2_debug_line_missing_end_sequence_complaint (void)
2046 {
2047   complaint (_(".debug_line section has line "
2048                "program sequence without an end"));
2049 }
2050
2051 static void
2052 dwarf2_complex_location_expr_complaint (void)
2053 {
2054   complaint (_("location expression too complex"));
2055 }
2056
2057 static void
2058 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
2059                                               int arg3)
2060 {
2061   complaint (_("const value length mismatch for '%s', got %d, expected %d"),
2062              arg1, arg2, arg3);
2063 }
2064
2065 static void
2066 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info *section)
2067 {
2068   complaint (_("debug info runs off end of %s section"
2069                " [in module %s]"),
2070              get_section_name (section),
2071              get_section_file_name (section));
2072 }
2073
2074 static void
2075 dwarf2_macro_malformed_definition_complaint (const char *arg1)
2076 {
2077   complaint (_("macro debug info contains a "
2078                "malformed macro definition:\n`%s'"),
2079              arg1);
2080 }
2081
2082 static void
2083 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
2084 {
2085   complaint (_("invalid attribute class or form for '%s' in '%s'"),
2086              arg1, arg2);
2087 }
2088
2089 /* Hash function for line_header_hash.  */
2090
2091 static hashval_t
2092 line_header_hash (const struct line_header *ofs)
2093 {
2094   return to_underlying (ofs->sect_off) ^ ofs->offset_in_dwz;
2095 }
2096
2097 /* Hash function for htab_create_alloc_ex for line_header_hash.  */
2098
2099 static hashval_t
2100 line_header_hash_voidp (const void *item)
2101 {
2102   const struct line_header *ofs = (const struct line_header *) item;
2103
2104   return line_header_hash (ofs);
2105 }
2106
2107 /* Equality function for line_header_hash.  */
2108
2109 static int
2110 line_header_eq_voidp (const void *item_lhs, const void *item_rhs)
2111 {
2112   const struct line_header *ofs_lhs = (const struct line_header *) item_lhs;
2113   const struct line_header *ofs_rhs = (const struct line_header *) item_rhs;
2114
2115   return (ofs_lhs->sect_off == ofs_rhs->sect_off
2116           && ofs_lhs->offset_in_dwz == ofs_rhs->offset_in_dwz);
2117 }
2118
2119 \f
2120
2121 /* Read the given attribute value as an address, taking the attribute's
2122    form into account.  */
2123
2124 static CORE_ADDR
2125 attr_value_as_address (struct attribute *attr)
2126 {
2127   CORE_ADDR addr;
2128
2129   if (attr->form != DW_FORM_addr && attr->form != DW_FORM_addrx
2130       && attr->form != DW_FORM_GNU_addr_index)
2131     {
2132       /* Aside from a few clearly defined exceptions, attributes that
2133          contain an address must always be in DW_FORM_addr form.
2134          Unfortunately, some compilers happen to be violating this
2135          requirement by encoding addresses using other forms, such
2136          as DW_FORM_data4 for example.  For those broken compilers,
2137          we try to do our best, without any guarantee of success,
2138          to interpret the address correctly.  It would also be nice
2139          to generate a complaint, but that would require us to maintain
2140          a list of legitimate cases where a non-address form is allowed,
2141          as well as update callers to pass in at least the CU's DWARF
2142          version.  This is more overhead than what we're willing to
2143          expand for a pretty rare case.  */
2144       addr = DW_UNSND (attr);
2145     }
2146   else
2147     addr = DW_ADDR (attr);
2148
2149   return addr;
2150 }
2151
2152 /* See declaration.  */
2153
2154 dwarf2_per_objfile::dwarf2_per_objfile (struct objfile *objfile_,
2155                                         const dwarf2_debug_sections *names)
2156   : objfile (objfile_)
2157 {
2158   if (names == NULL)
2159     names = &dwarf2_elf_names;
2160
2161   bfd *obfd = objfile->obfd;
2162
2163   for (asection *sec = obfd->sections; sec != NULL; sec = sec->next)
2164     locate_sections (obfd, sec, *names);
2165 }
2166
2167 static void free_dwo_files (htab_t dwo_files, struct objfile *objfile);
2168
2169 dwarf2_per_objfile::~dwarf2_per_objfile ()
2170 {
2171   /* Cached DIE trees use xmalloc and the comp_unit_obstack.  */
2172   free_cached_comp_units ();
2173
2174   if (quick_file_names_table)
2175     htab_delete (quick_file_names_table);
2176
2177   if (line_header_hash)
2178     htab_delete (line_header_hash);
2179
2180   for (dwarf2_per_cu_data *per_cu : all_comp_units)
2181     VEC_free (dwarf2_per_cu_ptr, per_cu->imported_symtabs);
2182
2183   for (signatured_type *sig_type : all_type_units)
2184     VEC_free (dwarf2_per_cu_ptr, sig_type->per_cu.imported_symtabs);
2185
2186   VEC_free (dwarf2_section_info_def, types);
2187
2188   if (dwo_files != NULL)
2189     free_dwo_files (dwo_files, objfile);
2190
2191   /* Everything else should be on the objfile obstack.  */
2192 }
2193
2194 /* See declaration.  */
2195
2196 void
2197 dwarf2_per_objfile::free_cached_comp_units ()
2198 {
2199   dwarf2_per_cu_data *per_cu = read_in_chain;
2200   dwarf2_per_cu_data **last_chain = &read_in_chain;
2201   while (per_cu != NULL)
2202     {
2203       dwarf2_per_cu_data *next_cu = per_cu->cu->read_in_chain;
2204
2205       delete per_cu->cu;
2206       *last_chain = next_cu;
2207       per_cu = next_cu;
2208     }
2209 }
2210
2211 /* A helper class that calls free_cached_comp_units on
2212    destruction.  */
2213
2214 class free_cached_comp_units
2215 {
2216 public:
2217
2218   explicit free_cached_comp_units (dwarf2_per_objfile *per_objfile)
2219     : m_per_objfile (per_objfile)
2220   {
2221   }
2222
2223   ~free_cached_comp_units ()
2224   {
2225     m_per_objfile->free_cached_comp_units ();
2226   }
2227
2228   DISABLE_COPY_AND_ASSIGN (free_cached_comp_units);
2229
2230 private:
2231
2232   dwarf2_per_objfile *m_per_objfile;
2233 };
2234
2235 /* Try to locate the sections we need for DWARF 2 debugging
2236    information and return true if we have enough to do something.
2237    NAMES points to the dwarf2 section names, or is NULL if the standard
2238    ELF names are used.  */
2239
2240 int
2241 dwarf2_has_info (struct objfile *objfile,
2242                  const struct dwarf2_debug_sections *names)
2243 {
2244   if (objfile->flags & OBJF_READNEVER)
2245     return 0;
2246
2247   struct dwarf2_per_objfile *dwarf2_per_objfile
2248     = get_dwarf2_per_objfile (objfile);
2249
2250   if (dwarf2_per_objfile == NULL)
2251     {
2252       /* Initialize per-objfile state.  */
2253       dwarf2_per_objfile
2254         = new (&objfile->objfile_obstack) struct dwarf2_per_objfile (objfile,
2255                                                                      names);
2256       set_dwarf2_per_objfile (objfile, dwarf2_per_objfile);
2257     }
2258   return (!dwarf2_per_objfile->info.is_virtual
2259           && dwarf2_per_objfile->info.s.section != NULL
2260           && !dwarf2_per_objfile->abbrev.is_virtual
2261           && dwarf2_per_objfile->abbrev.s.section != NULL);
2262 }
2263
2264 /* Return the containing section of virtual section SECTION.  */
2265
2266 static struct dwarf2_section_info *
2267 get_containing_section (const struct dwarf2_section_info *section)
2268 {
2269   gdb_assert (section->is_virtual);
2270   return section->s.containing_section;
2271 }
2272
2273 /* Return the bfd owner of SECTION.  */
2274
2275 static struct bfd *
2276 get_section_bfd_owner (const struct dwarf2_section_info *section)
2277 {
2278   if (section->is_virtual)
2279     {
2280       section = get_containing_section (section);
2281       gdb_assert (!section->is_virtual);
2282     }
2283   return section->s.section->owner;
2284 }
2285
2286 /* Return the bfd section of SECTION.
2287    Returns NULL if the section is not present.  */
2288
2289 static asection *
2290 get_section_bfd_section (const struct dwarf2_section_info *section)
2291 {
2292   if (section->is_virtual)
2293     {
2294       section = get_containing_section (section);
2295       gdb_assert (!section->is_virtual);
2296     }
2297   return section->s.section;
2298 }
2299
2300 /* Return the name of SECTION.  */
2301
2302 static const char *
2303 get_section_name (const struct dwarf2_section_info *section)
2304 {
2305   asection *sectp = get_section_bfd_section (section);
2306
2307   gdb_assert (sectp != NULL);
2308   return bfd_section_name (get_section_bfd_owner (section), sectp);
2309 }
2310
2311 /* Return the name of the file SECTION is in.  */
2312
2313 static const char *
2314 get_section_file_name (const struct dwarf2_section_info *section)
2315 {
2316   bfd *abfd = get_section_bfd_owner (section);
2317
2318   return bfd_get_filename (abfd);
2319 }
2320
2321 /* Return the id of SECTION.
2322    Returns 0 if SECTION doesn't exist.  */
2323
2324 static int
2325 get_section_id (const struct dwarf2_section_info *section)
2326 {
2327   asection *sectp = get_section_bfd_section (section);
2328
2329   if (sectp == NULL)
2330     return 0;
2331   return sectp->id;
2332 }
2333
2334 /* Return the flags of SECTION.
2335    SECTION (or containing section if this is a virtual section) must exist.  */
2336
2337 static int
2338 get_section_flags (const struct dwarf2_section_info *section)
2339 {
2340   asection *sectp = get_section_bfd_section (section);
2341
2342   gdb_assert (sectp != NULL);
2343   return bfd_get_section_flags (sectp->owner, sectp);
2344 }
2345
2346 /* When loading sections, we look either for uncompressed section or for
2347    compressed section names.  */
2348
2349 static int
2350 section_is_p (const char *section_name,
2351               const struct dwarf2_section_names *names)
2352 {
2353   if (names->normal != NULL
2354       && strcmp (section_name, names->normal) == 0)
2355     return 1;
2356   if (names->compressed != NULL
2357       && strcmp (section_name, names->compressed) == 0)
2358     return 1;
2359   return 0;
2360 }
2361
2362 /* See declaration.  */
2363
2364 void
2365 dwarf2_per_objfile::locate_sections (bfd *abfd, asection *sectp,
2366                                      const dwarf2_debug_sections &names)
2367 {
2368   flagword aflag = bfd_get_section_flags (abfd, sectp);
2369
2370   if ((aflag & SEC_HAS_CONTENTS) == 0)
2371     {
2372     }
2373   else if (section_is_p (sectp->name, &names.info))
2374     {
2375       this->info.s.section = sectp;
2376       this->info.size = bfd_get_section_size (sectp);
2377     }
2378   else if (section_is_p (sectp->name, &names.abbrev))
2379     {
2380       this->abbrev.s.section = sectp;
2381       this->abbrev.size = bfd_get_section_size (sectp);
2382     }
2383   else if (section_is_p (sectp->name, &names.line))
2384     {
2385       this->line.s.section = sectp;
2386       this->line.size = bfd_get_section_size (sectp);
2387     }
2388   else if (section_is_p (sectp->name, &names.loc))
2389     {
2390       this->loc.s.section = sectp;
2391       this->loc.size = bfd_get_section_size (sectp);
2392     }
2393   else if (section_is_p (sectp->name, &names.loclists))
2394     {
2395       this->loclists.s.section = sectp;
2396       this->loclists.size = bfd_get_section_size (sectp);
2397     }
2398   else if (section_is_p (sectp->name, &names.macinfo))
2399     {
2400       this->macinfo.s.section = sectp;
2401       this->macinfo.size = bfd_get_section_size (sectp);
2402     }
2403   else if (section_is_p (sectp->name, &names.macro))
2404     {
2405       this->macro.s.section = sectp;
2406       this->macro.size = bfd_get_section_size (sectp);
2407     }
2408   else if (section_is_p (sectp->name, &names.str))
2409     {
2410       this->str.s.section = sectp;
2411       this->str.size = bfd_get_section_size (sectp);
2412     }
2413   else if (section_is_p (sectp->name, &names.line_str))
2414     {
2415       this->line_str.s.section = sectp;
2416       this->line_str.size = bfd_get_section_size (sectp);
2417     }
2418   else if (section_is_p (sectp->name, &names.addr))
2419     {
2420       this->addr.s.section = sectp;
2421       this->addr.size = bfd_get_section_size (sectp);
2422     }
2423   else if (section_is_p (sectp->name, &names.frame))
2424     {
2425       this->frame.s.section = sectp;
2426       this->frame.size = bfd_get_section_size (sectp);
2427     }
2428   else if (section_is_p (sectp->name, &names.eh_frame))
2429     {
2430       this->eh_frame.s.section = sectp;
2431       this->eh_frame.size = bfd_get_section_size (sectp);
2432     }
2433   else if (section_is_p (sectp->name, &names.ranges))
2434     {
2435       this->ranges.s.section = sectp;
2436       this->ranges.size = bfd_get_section_size (sectp);
2437     }
2438   else if (section_is_p (sectp->name, &names.rnglists))
2439     {
2440       this->rnglists.s.section = sectp;
2441       this->rnglists.size = bfd_get_section_size (sectp);
2442     }
2443   else if (section_is_p (sectp->name, &names.types))
2444     {
2445       struct dwarf2_section_info type_section;
2446
2447       memset (&type_section, 0, sizeof (type_section));
2448       type_section.s.section = sectp;
2449       type_section.size = bfd_get_section_size (sectp);
2450
2451       VEC_safe_push (dwarf2_section_info_def, this->types,
2452                      &type_section);
2453     }
2454   else if (section_is_p (sectp->name, &names.gdb_index))
2455     {
2456       this->gdb_index.s.section = sectp;
2457       this->gdb_index.size = bfd_get_section_size (sectp);
2458     }
2459   else if (section_is_p (sectp->name, &names.debug_names))
2460     {
2461       this->debug_names.s.section = sectp;
2462       this->debug_names.size = bfd_get_section_size (sectp);
2463     }
2464   else if (section_is_p (sectp->name, &names.debug_aranges))
2465     {
2466       this->debug_aranges.s.section = sectp;
2467       this->debug_aranges.size = bfd_get_section_size (sectp);
2468     }
2469
2470   if ((bfd_get_section_flags (abfd, sectp) & (SEC_LOAD | SEC_ALLOC))
2471       && bfd_section_vma (abfd, sectp) == 0)
2472     this->has_section_at_zero = true;
2473 }
2474
2475 /* A helper function that decides whether a section is empty,
2476    or not present.  */
2477
2478 static int
2479 dwarf2_section_empty_p (const struct dwarf2_section_info *section)
2480 {
2481   if (section->is_virtual)
2482     return section->size == 0;
2483   return section->s.section == NULL || section->size == 0;
2484 }
2485
2486 /* See dwarf2read.h.  */
2487
2488 void
2489 dwarf2_read_section (struct objfile *objfile, dwarf2_section_info *info)
2490 {
2491   asection *sectp;
2492   bfd *abfd;
2493   gdb_byte *buf, *retbuf;
2494
2495   if (info->readin)
2496     return;
2497   info->buffer = NULL;
2498   info->readin = 1;
2499
2500   if (dwarf2_section_empty_p (info))
2501     return;
2502
2503   sectp = get_section_bfd_section (info);
2504
2505   /* If this is a virtual section we need to read in the real one first.  */
2506   if (info->is_virtual)
2507     {
2508       struct dwarf2_section_info *containing_section =
2509         get_containing_section (info);
2510
2511       gdb_assert (sectp != NULL);
2512       if ((sectp->flags & SEC_RELOC) != 0)
2513         {
2514           error (_("Dwarf Error: DWP format V2 with relocations is not"
2515                    " supported in section %s [in module %s]"),
2516                  get_section_name (info), get_section_file_name (info));
2517         }
2518       dwarf2_read_section (objfile, containing_section);
2519       /* Other code should have already caught virtual sections that don't
2520          fit.  */
2521       gdb_assert (info->virtual_offset + info->size
2522                   <= containing_section->size);
2523       /* If the real section is empty or there was a problem reading the
2524          section we shouldn't get here.  */
2525       gdb_assert (containing_section->buffer != NULL);
2526       info->buffer = containing_section->buffer + info->virtual_offset;
2527       return;
2528     }
2529
2530   /* If the section has relocations, we must read it ourselves.
2531      Otherwise we attach it to the BFD.  */
2532   if ((sectp->flags & SEC_RELOC) == 0)
2533     {
2534       info->buffer = gdb_bfd_map_section (sectp, &info->size);
2535       return;
2536     }
2537
2538   buf = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, info->size);
2539   info->buffer = buf;
2540
2541   /* When debugging .o files, we may need to apply relocations; see
2542      http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2543      We never compress sections in .o files, so we only need to
2544      try this when the section is not compressed.  */
2545   retbuf = symfile_relocate_debug_section (objfile, sectp, buf);
2546   if (retbuf != NULL)
2547     {
2548       info->buffer = retbuf;
2549       return;
2550     }
2551
2552   abfd = get_section_bfd_owner (info);
2553   gdb_assert (abfd != NULL);
2554
2555   if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
2556       || bfd_bread (buf, info->size, abfd) != info->size)
2557     {
2558       error (_("Dwarf Error: Can't read DWARF data"
2559                " in section %s [in module %s]"),
2560              bfd_section_name (abfd, sectp), bfd_get_filename (abfd));
2561     }
2562 }
2563
2564 /* A helper function that returns the size of a section in a safe way.
2565    If you are positive that the section has been read before using the
2566    size, then it is safe to refer to the dwarf2_section_info object's
2567    "size" field directly.  In other cases, you must call this
2568    function, because for compressed sections the size field is not set
2569    correctly until the section has been read.  */
2570
2571 static bfd_size_type
2572 dwarf2_section_size (struct objfile *objfile,
2573                      struct dwarf2_section_info *info)
2574 {
2575   if (!info->readin)
2576     dwarf2_read_section (objfile, info);
2577   return info->size;
2578 }
2579
2580 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2581    SECTION_NAME.  */
2582
2583 void
2584 dwarf2_get_section_info (struct objfile *objfile,
2585                          enum dwarf2_section_enum sect,
2586                          asection **sectp, const gdb_byte **bufp,
2587                          bfd_size_type *sizep)
2588 {
2589   struct dwarf2_per_objfile *data
2590     = (struct dwarf2_per_objfile *) objfile_data (objfile,
2591                                                   dwarf2_objfile_data_key);
2592   struct dwarf2_section_info *info;
2593
2594   /* We may see an objfile without any DWARF, in which case we just
2595      return nothing.  */
2596   if (data == NULL)
2597     {
2598       *sectp = NULL;
2599       *bufp = NULL;
2600       *sizep = 0;
2601       return;
2602     }
2603   switch (sect)
2604     {
2605     case DWARF2_DEBUG_FRAME:
2606       info = &data->frame;
2607       break;
2608     case DWARF2_EH_FRAME:
2609       info = &data->eh_frame;
2610       break;
2611     default:
2612       gdb_assert_not_reached ("unexpected section");
2613     }
2614
2615   dwarf2_read_section (objfile, info);
2616
2617   *sectp = get_section_bfd_section (info);
2618   *bufp = info->buffer;
2619   *sizep = info->size;
2620 }
2621
2622 /* A helper function to find the sections for a .dwz file.  */
2623
2624 static void
2625 locate_dwz_sections (bfd *abfd, asection *sectp, void *arg)
2626 {
2627   struct dwz_file *dwz_file = (struct dwz_file *) arg;
2628
2629   /* Note that we only support the standard ELF names, because .dwz
2630      is ELF-only (at the time of writing).  */
2631   if (section_is_p (sectp->name, &dwarf2_elf_names.abbrev))
2632     {
2633       dwz_file->abbrev.s.section = sectp;
2634       dwz_file->abbrev.size = bfd_get_section_size (sectp);
2635     }
2636   else if (section_is_p (sectp->name, &dwarf2_elf_names.info))
2637     {
2638       dwz_file->info.s.section = sectp;
2639       dwz_file->info.size = bfd_get_section_size (sectp);
2640     }
2641   else if (section_is_p (sectp->name, &dwarf2_elf_names.str))
2642     {
2643       dwz_file->str.s.section = sectp;
2644       dwz_file->str.size = bfd_get_section_size (sectp);
2645     }
2646   else if (section_is_p (sectp->name, &dwarf2_elf_names.line))
2647     {
2648       dwz_file->line.s.section = sectp;
2649       dwz_file->line.size = bfd_get_section_size (sectp);
2650     }
2651   else if (section_is_p (sectp->name, &dwarf2_elf_names.macro))
2652     {
2653       dwz_file->macro.s.section = sectp;
2654       dwz_file->macro.size = bfd_get_section_size (sectp);
2655     }
2656   else if (section_is_p (sectp->name, &dwarf2_elf_names.gdb_index))
2657     {
2658       dwz_file->gdb_index.s.section = sectp;
2659       dwz_file->gdb_index.size = bfd_get_section_size (sectp);
2660     }
2661   else if (section_is_p (sectp->name, &dwarf2_elf_names.debug_names))
2662     {
2663       dwz_file->debug_names.s.section = sectp;
2664       dwz_file->debug_names.size = bfd_get_section_size (sectp);
2665     }
2666 }
2667
2668 /* Open the separate '.dwz' debug file, if needed.  Return NULL if
2669    there is no .gnu_debugaltlink section in the file.  Error if there
2670    is such a section but the file cannot be found.  */
2671
2672 static struct dwz_file *
2673 dwarf2_get_dwz_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
2674 {
2675   const char *filename;
2676   bfd_size_type buildid_len_arg;
2677   size_t buildid_len;
2678   bfd_byte *buildid;
2679
2680   if (dwarf2_per_objfile->dwz_file != NULL)
2681     return dwarf2_per_objfile->dwz_file.get ();
2682
2683   bfd_set_error (bfd_error_no_error);
2684   gdb::unique_xmalloc_ptr<char> data
2685     (bfd_get_alt_debug_link_info (dwarf2_per_objfile->objfile->obfd,
2686                                   &buildid_len_arg, &buildid));
2687   if (data == NULL)
2688     {
2689       if (bfd_get_error () == bfd_error_no_error)
2690         return NULL;
2691       error (_("could not read '.gnu_debugaltlink' section: %s"),
2692              bfd_errmsg (bfd_get_error ()));
2693     }
2694
2695   gdb::unique_xmalloc_ptr<bfd_byte> buildid_holder (buildid);
2696
2697   buildid_len = (size_t) buildid_len_arg;
2698
2699   filename = data.get ();
2700
2701   std::string abs_storage;
2702   if (!IS_ABSOLUTE_PATH (filename))
2703     {
2704       gdb::unique_xmalloc_ptr<char> abs
2705         = gdb_realpath (objfile_name (dwarf2_per_objfile->objfile));
2706
2707       abs_storage = ldirname (abs.get ()) + SLASH_STRING + filename;
2708       filename = abs_storage.c_str ();
2709     }
2710
2711   /* First try the file name given in the section.  If that doesn't
2712      work, try to use the build-id instead.  */
2713   gdb_bfd_ref_ptr dwz_bfd (gdb_bfd_open (filename, gnutarget, -1));
2714   if (dwz_bfd != NULL)
2715     {
2716       if (!build_id_verify (dwz_bfd.get (), buildid_len, buildid))
2717         dwz_bfd.reset (nullptr);
2718     }
2719
2720   if (dwz_bfd == NULL)
2721     dwz_bfd = build_id_to_debug_bfd (buildid_len, buildid);
2722
2723   if (dwz_bfd == NULL)
2724     error (_("could not find '.gnu_debugaltlink' file for %s"),
2725            objfile_name (dwarf2_per_objfile->objfile));
2726
2727   std::unique_ptr<struct dwz_file> result
2728     (new struct dwz_file (std::move (dwz_bfd)));
2729
2730   bfd_map_over_sections (result->dwz_bfd.get (), locate_dwz_sections,
2731                          result.get ());
2732
2733   gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd,
2734                             result->dwz_bfd.get ());
2735   dwarf2_per_objfile->dwz_file = std::move (result);
2736   return dwarf2_per_objfile->dwz_file.get ();
2737 }
2738 \f
2739 /* DWARF quick_symbols_functions support.  */
2740
2741 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2742    unique line tables, so we maintain a separate table of all .debug_line
2743    derived entries to support the sharing.
2744    All the quick functions need is the list of file names.  We discard the
2745    line_header when we're done and don't need to record it here.  */
2746 struct quick_file_names
2747 {
2748   /* The data used to construct the hash key.  */
2749   struct stmt_list_hash hash;
2750
2751   /* The number of entries in file_names, real_names.  */
2752   unsigned int num_file_names;
2753
2754   /* The file names from the line table, after being run through
2755      file_full_name.  */
2756   const char **file_names;
2757
2758   /* The file names from the line table after being run through
2759      gdb_realpath.  These are computed lazily.  */
2760   const char **real_names;
2761 };
2762
2763 /* When using the index (and thus not using psymtabs), each CU has an
2764    object of this type.  This is used to hold information needed by
2765    the various "quick" methods.  */
2766 struct dwarf2_per_cu_quick_data
2767 {
2768   /* The file table.  This can be NULL if there was no file table
2769      or it's currently not read in.
2770      NOTE: This points into dwarf2_per_objfile->quick_file_names_table.  */
2771   struct quick_file_names *file_names;
2772
2773   /* The corresponding symbol table.  This is NULL if symbols for this
2774      CU have not yet been read.  */
2775   struct compunit_symtab *compunit_symtab;
2776
2777   /* A temporary mark bit used when iterating over all CUs in
2778      expand_symtabs_matching.  */
2779   unsigned int mark : 1;
2780
2781   /* True if we've tried to read the file table and found there isn't one.
2782      There will be no point in trying to read it again next time.  */
2783   unsigned int no_file_data : 1;
2784 };
2785
2786 /* Utility hash function for a stmt_list_hash.  */
2787
2788 static hashval_t
2789 hash_stmt_list_entry (const struct stmt_list_hash *stmt_list_hash)
2790 {
2791   hashval_t v = 0;
2792
2793   if (stmt_list_hash->dwo_unit != NULL)
2794     v += (uintptr_t) stmt_list_hash->dwo_unit->dwo_file;
2795   v += to_underlying (stmt_list_hash->line_sect_off);
2796   return v;
2797 }
2798
2799 /* Utility equality function for a stmt_list_hash.  */
2800
2801 static int
2802 eq_stmt_list_entry (const struct stmt_list_hash *lhs,
2803                     const struct stmt_list_hash *rhs)
2804 {
2805   if ((lhs->dwo_unit != NULL) != (rhs->dwo_unit != NULL))
2806     return 0;
2807   if (lhs->dwo_unit != NULL
2808       && lhs->dwo_unit->dwo_file != rhs->dwo_unit->dwo_file)
2809     return 0;
2810
2811   return lhs->line_sect_off == rhs->line_sect_off;
2812 }
2813
2814 /* Hash function for a quick_file_names.  */
2815
2816 static hashval_t
2817 hash_file_name_entry (const void *e)
2818 {
2819   const struct quick_file_names *file_data
2820     = (const struct quick_file_names *) e;
2821
2822   return hash_stmt_list_entry (&file_data->hash);
2823 }
2824
2825 /* Equality function for a quick_file_names.  */
2826
2827 static int
2828 eq_file_name_entry (const void *a, const void *b)
2829 {
2830   const struct quick_file_names *ea = (const struct quick_file_names *) a;
2831   const struct quick_file_names *eb = (const struct quick_file_names *) b;
2832
2833   return eq_stmt_list_entry (&ea->hash, &eb->hash);
2834 }
2835
2836 /* Delete function for a quick_file_names.  */
2837
2838 static void
2839 delete_file_name_entry (void *e)
2840 {
2841   struct quick_file_names *file_data = (struct quick_file_names *) e;
2842   int i;
2843
2844   for (i = 0; i < file_data->num_file_names; ++i)
2845     {
2846       xfree ((void*) file_data->file_names[i]);
2847       if (file_data->real_names)
2848         xfree ((void*) file_data->real_names[i]);
2849     }
2850
2851   /* The space for the struct itself lives on objfile_obstack,
2852      so we don't free it here.  */
2853 }
2854
2855 /* Create a quick_file_names hash table.  */
2856
2857 static htab_t
2858 create_quick_file_names_table (unsigned int nr_initial_entries)
2859 {
2860   return htab_create_alloc (nr_initial_entries,
2861                             hash_file_name_entry, eq_file_name_entry,
2862                             delete_file_name_entry, xcalloc, xfree);
2863 }
2864
2865 /* Read in PER_CU->CU.  This function is unrelated to symtabs, symtab would
2866    have to be created afterwards.  You should call age_cached_comp_units after
2867    processing PER_CU->CU.  dw2_setup must have been already called.  */
2868
2869 static void
2870 load_cu (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
2871 {
2872   if (per_cu->is_debug_types)
2873     load_full_type_unit (per_cu);
2874   else
2875     load_full_comp_unit (per_cu, skip_partial, language_minimal);
2876
2877   if (per_cu->cu == NULL)
2878     return;  /* Dummy CU.  */
2879
2880   dwarf2_find_base_address (per_cu->cu->dies, per_cu->cu);
2881 }
2882
2883 /* Read in the symbols for PER_CU.  */
2884
2885 static void
2886 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
2887 {
2888   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
2889
2890   /* Skip type_unit_groups, reading the type units they contain
2891      is handled elsewhere.  */
2892   if (IS_TYPE_UNIT_GROUP (per_cu))
2893     return;
2894
2895   /* The destructor of dwarf2_queue_guard frees any entries left on
2896      the queue.  After this point we're guaranteed to leave this function
2897      with the dwarf queue empty.  */
2898   dwarf2_queue_guard q_guard;
2899
2900   if (dwarf2_per_objfile->using_index
2901       ? per_cu->v.quick->compunit_symtab == NULL
2902       : (per_cu->v.psymtab == NULL || !per_cu->v.psymtab->readin))
2903     {
2904       queue_comp_unit (per_cu, language_minimal);
2905       load_cu (per_cu, skip_partial);
2906
2907       /* If we just loaded a CU from a DWO, and we're working with an index
2908          that may badly handle TUs, load all the TUs in that DWO as well.
2909          http://sourceware.org/bugzilla/show_bug.cgi?id=15021  */
2910       if (!per_cu->is_debug_types
2911           && per_cu->cu != NULL
2912           && per_cu->cu->dwo_unit != NULL
2913           && dwarf2_per_objfile->index_table != NULL
2914           && dwarf2_per_objfile->index_table->version <= 7
2915           /* DWP files aren't supported yet.  */
2916           && get_dwp_file (dwarf2_per_objfile) == NULL)
2917         queue_and_load_all_dwo_tus (per_cu);
2918     }
2919
2920   process_queue (dwarf2_per_objfile);
2921
2922   /* Age the cache, releasing compilation units that have not
2923      been used recently.  */
2924   age_cached_comp_units (dwarf2_per_objfile);
2925 }
2926
2927 /* Ensure that the symbols for PER_CU have been read in.  OBJFILE is
2928    the objfile from which this CU came.  Returns the resulting symbol
2929    table.  */
2930
2931 static struct compunit_symtab *
2932 dw2_instantiate_symtab (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
2933 {
2934   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
2935
2936   gdb_assert (dwarf2_per_objfile->using_index);
2937   if (!per_cu->v.quick->compunit_symtab)
2938     {
2939       free_cached_comp_units freer (dwarf2_per_objfile);
2940       scoped_restore decrementer = increment_reading_symtab ();
2941       dw2_do_instantiate_symtab (per_cu, skip_partial);
2942       process_cu_includes (dwarf2_per_objfile);
2943     }
2944
2945   return per_cu->v.quick->compunit_symtab;
2946 }
2947
2948 /* See declaration.  */
2949
2950 dwarf2_per_cu_data *
2951 dwarf2_per_objfile::get_cutu (int index)
2952 {
2953   if (index >= this->all_comp_units.size ())
2954     {
2955       index -= this->all_comp_units.size ();
2956       gdb_assert (index < this->all_type_units.size ());
2957       return &this->all_type_units[index]->per_cu;
2958     }
2959
2960   return this->all_comp_units[index];
2961 }
2962
2963 /* See declaration.  */
2964
2965 dwarf2_per_cu_data *
2966 dwarf2_per_objfile::get_cu (int index)
2967 {
2968   gdb_assert (index >= 0 && index < this->all_comp_units.size ());
2969
2970   return this->all_comp_units[index];
2971 }
2972
2973 /* See declaration.  */
2974
2975 signatured_type *
2976 dwarf2_per_objfile::get_tu (int index)
2977 {
2978   gdb_assert (index >= 0 && index < this->all_type_units.size ());
2979
2980   return this->all_type_units[index];
2981 }
2982
2983 /* Return a new dwarf2_per_cu_data allocated on OBJFILE's
2984    objfile_obstack, and constructed with the specified field
2985    values.  */
2986
2987 static dwarf2_per_cu_data *
2988 create_cu_from_index_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
2989                           struct dwarf2_section_info *section,
2990                           int is_dwz,
2991                           sect_offset sect_off, ULONGEST length)
2992 {
2993   struct objfile *objfile = dwarf2_per_objfile->objfile;
2994   dwarf2_per_cu_data *the_cu
2995     = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2996                      struct dwarf2_per_cu_data);
2997   the_cu->sect_off = sect_off;
2998   the_cu->length = length;
2999   the_cu->dwarf2_per_objfile = dwarf2_per_objfile;
3000   the_cu->section = section;
3001   the_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3002                                    struct dwarf2_per_cu_quick_data);
3003   the_cu->is_dwz = is_dwz;
3004   return the_cu;
3005 }
3006
3007 /* A helper for create_cus_from_index that handles a given list of
3008    CUs.  */
3009
3010 static void
3011 create_cus_from_index_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
3012                             const gdb_byte *cu_list, offset_type n_elements,
3013                             struct dwarf2_section_info *section,
3014                             int is_dwz)
3015 {
3016   for (offset_type i = 0; i < n_elements; i += 2)
3017     {
3018       gdb_static_assert (sizeof (ULONGEST) >= 8);
3019
3020       sect_offset sect_off
3021         = (sect_offset) extract_unsigned_integer (cu_list, 8, BFD_ENDIAN_LITTLE);
3022       ULONGEST length = extract_unsigned_integer (cu_list + 8, 8, BFD_ENDIAN_LITTLE);
3023       cu_list += 2 * 8;
3024
3025       dwarf2_per_cu_data *per_cu
3026         = create_cu_from_index_list (dwarf2_per_objfile, section, is_dwz,
3027                                      sect_off, length);
3028       dwarf2_per_objfile->all_comp_units.push_back (per_cu);
3029     }
3030 }
3031
3032 /* Read the CU list from the mapped index, and use it to create all
3033    the CU objects for this objfile.  */
3034
3035 static void
3036 create_cus_from_index (struct dwarf2_per_objfile *dwarf2_per_objfile,
3037                        const gdb_byte *cu_list, offset_type cu_list_elements,
3038                        const gdb_byte *dwz_list, offset_type dwz_elements)
3039 {
3040   gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
3041   dwarf2_per_objfile->all_comp_units.reserve
3042     ((cu_list_elements + dwz_elements) / 2);
3043
3044   create_cus_from_index_list (dwarf2_per_objfile, cu_list, cu_list_elements,
3045                               &dwarf2_per_objfile->info, 0);
3046
3047   if (dwz_elements == 0)
3048     return;
3049
3050   dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
3051   create_cus_from_index_list (dwarf2_per_objfile, dwz_list, dwz_elements,
3052                               &dwz->info, 1);
3053 }
3054
3055 /* Create the signatured type hash table from the index.  */
3056
3057 static void
3058 create_signatured_type_table_from_index
3059   (struct dwarf2_per_objfile *dwarf2_per_objfile,
3060    struct dwarf2_section_info *section,
3061    const gdb_byte *bytes,
3062    offset_type elements)
3063 {
3064   struct objfile *objfile = dwarf2_per_objfile->objfile;
3065
3066   gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
3067   dwarf2_per_objfile->all_type_units.reserve (elements / 3);
3068
3069   htab_t sig_types_hash = allocate_signatured_type_table (objfile);
3070
3071   for (offset_type i = 0; i < elements; i += 3)
3072     {
3073       struct signatured_type *sig_type;
3074       ULONGEST signature;
3075       void **slot;
3076       cu_offset type_offset_in_tu;
3077
3078       gdb_static_assert (sizeof (ULONGEST) >= 8);
3079       sect_offset sect_off
3080         = (sect_offset) extract_unsigned_integer (bytes, 8, BFD_ENDIAN_LITTLE);
3081       type_offset_in_tu
3082         = (cu_offset) extract_unsigned_integer (bytes + 8, 8,
3083                                                 BFD_ENDIAN_LITTLE);
3084       signature = extract_unsigned_integer (bytes + 16, 8, BFD_ENDIAN_LITTLE);
3085       bytes += 3 * 8;
3086
3087       sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3088                                  struct signatured_type);
3089       sig_type->signature = signature;
3090       sig_type->type_offset_in_tu = type_offset_in_tu;
3091       sig_type->per_cu.is_debug_types = 1;
3092       sig_type->per_cu.section = section;
3093       sig_type->per_cu.sect_off = sect_off;
3094       sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
3095       sig_type->per_cu.v.quick
3096         = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3097                           struct dwarf2_per_cu_quick_data);
3098
3099       slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
3100       *slot = sig_type;
3101
3102       dwarf2_per_objfile->all_type_units.push_back (sig_type);
3103     }
3104
3105   dwarf2_per_objfile->signatured_types = sig_types_hash;
3106 }
3107
3108 /* Create the signatured type hash table from .debug_names.  */
3109
3110 static void
3111 create_signatured_type_table_from_debug_names
3112   (struct dwarf2_per_objfile *dwarf2_per_objfile,
3113    const mapped_debug_names &map,
3114    struct dwarf2_section_info *section,
3115    struct dwarf2_section_info *abbrev_section)
3116 {
3117   struct objfile *objfile = dwarf2_per_objfile->objfile;
3118
3119   dwarf2_read_section (objfile, section);
3120   dwarf2_read_section (objfile, abbrev_section);
3121
3122   gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
3123   dwarf2_per_objfile->all_type_units.reserve (map.tu_count);
3124
3125   htab_t sig_types_hash = allocate_signatured_type_table (objfile);
3126
3127   for (uint32_t i = 0; i < map.tu_count; ++i)
3128     {
3129       struct signatured_type *sig_type;
3130       void **slot;
3131
3132       sect_offset sect_off
3133         = (sect_offset) (extract_unsigned_integer
3134                          (map.tu_table_reordered + i * map.offset_size,
3135                           map.offset_size,
3136                           map.dwarf5_byte_order));
3137
3138       comp_unit_head cu_header;
3139       read_and_check_comp_unit_head (dwarf2_per_objfile, &cu_header, section,
3140                                      abbrev_section,
3141                                      section->buffer + to_underlying (sect_off),
3142                                      rcuh_kind::TYPE);
3143
3144       sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3145                                  struct signatured_type);
3146       sig_type->signature = cu_header.signature;
3147       sig_type->type_offset_in_tu = cu_header.type_cu_offset_in_tu;
3148       sig_type->per_cu.is_debug_types = 1;
3149       sig_type->per_cu.section = section;
3150       sig_type->per_cu.sect_off = sect_off;
3151       sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
3152       sig_type->per_cu.v.quick
3153         = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3154                           struct dwarf2_per_cu_quick_data);
3155
3156       slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
3157       *slot = sig_type;
3158
3159       dwarf2_per_objfile->all_type_units.push_back (sig_type);
3160     }
3161
3162   dwarf2_per_objfile->signatured_types = sig_types_hash;
3163 }
3164
3165 /* Read the address map data from the mapped index, and use it to
3166    populate the objfile's psymtabs_addrmap.  */
3167
3168 static void
3169 create_addrmap_from_index (struct dwarf2_per_objfile *dwarf2_per_objfile,
3170                            struct mapped_index *index)
3171 {
3172   struct objfile *objfile = dwarf2_per_objfile->objfile;
3173   struct gdbarch *gdbarch = get_objfile_arch (objfile);
3174   const gdb_byte *iter, *end;
3175   struct addrmap *mutable_map;
3176   CORE_ADDR baseaddr;
3177
3178   auto_obstack temp_obstack;
3179
3180   mutable_map = addrmap_create_mutable (&temp_obstack);
3181
3182   iter = index->address_table.data ();
3183   end = iter + index->address_table.size ();
3184
3185   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3186
3187   while (iter < end)
3188     {
3189       ULONGEST hi, lo, cu_index;
3190       lo = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
3191       iter += 8;
3192       hi = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
3193       iter += 8;
3194       cu_index = extract_unsigned_integer (iter, 4, BFD_ENDIAN_LITTLE);
3195       iter += 4;
3196
3197       if (lo > hi)
3198         {
3199           complaint (_(".gdb_index address table has invalid range (%s - %s)"),
3200                      hex_string (lo), hex_string (hi));
3201           continue;
3202         }
3203
3204       if (cu_index >= dwarf2_per_objfile->all_comp_units.size ())
3205         {
3206           complaint (_(".gdb_index address table has invalid CU number %u"),
3207                      (unsigned) cu_index);
3208           continue;
3209         }
3210
3211       lo = gdbarch_adjust_dwarf2_addr (gdbarch, lo + baseaddr) - baseaddr;
3212       hi = gdbarch_adjust_dwarf2_addr (gdbarch, hi + baseaddr) - baseaddr;
3213       addrmap_set_empty (mutable_map, lo, hi - 1,
3214                          dwarf2_per_objfile->get_cu (cu_index));
3215     }
3216
3217   objfile->partial_symtabs->psymtabs_addrmap
3218     = addrmap_create_fixed (mutable_map, objfile->partial_symtabs->obstack ());
3219 }
3220
3221 /* Read the address map data from DWARF-5 .debug_aranges, and use it to
3222    populate the objfile's psymtabs_addrmap.  */
3223
3224 static void
3225 create_addrmap_from_aranges (struct dwarf2_per_objfile *dwarf2_per_objfile,
3226                              struct dwarf2_section_info *section)
3227 {
3228   struct objfile *objfile = dwarf2_per_objfile->objfile;
3229   bfd *abfd = objfile->obfd;
3230   struct gdbarch *gdbarch = get_objfile_arch (objfile);
3231   const CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
3232                                        SECT_OFF_TEXT (objfile));
3233
3234   auto_obstack temp_obstack;
3235   addrmap *mutable_map = addrmap_create_mutable (&temp_obstack);
3236
3237   std::unordered_map<sect_offset,
3238                      dwarf2_per_cu_data *,
3239                      gdb::hash_enum<sect_offset>>
3240     debug_info_offset_to_per_cu;
3241   for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
3242     {
3243       const auto insertpair
3244         = debug_info_offset_to_per_cu.emplace (per_cu->sect_off, per_cu);
3245       if (!insertpair.second)
3246         {
3247           warning (_("Section .debug_aranges in %s has duplicate "
3248                      "debug_info_offset %s, ignoring .debug_aranges."),
3249                    objfile_name (objfile), sect_offset_str (per_cu->sect_off));
3250           return;
3251         }
3252     }
3253
3254   dwarf2_read_section (objfile, section);
3255
3256   const bfd_endian dwarf5_byte_order = gdbarch_byte_order (gdbarch);
3257
3258   const gdb_byte *addr = section->buffer;
3259
3260   while (addr < section->buffer + section->size)
3261     {
3262       const gdb_byte *const entry_addr = addr;
3263       unsigned int bytes_read;
3264
3265       const LONGEST entry_length = read_initial_length (abfd, addr,
3266                                                         &bytes_read);
3267       addr += bytes_read;
3268
3269       const gdb_byte *const entry_end = addr + entry_length;
3270       const bool dwarf5_is_dwarf64 = bytes_read != 4;
3271       const uint8_t offset_size = dwarf5_is_dwarf64 ? 8 : 4;
3272       if (addr + entry_length > section->buffer + section->size)
3273         {
3274           warning (_("Section .debug_aranges in %s entry at offset %zu "
3275                      "length %s exceeds section length %s, "
3276                      "ignoring .debug_aranges."),
3277                    objfile_name (objfile), entry_addr - section->buffer,
3278                    plongest (bytes_read + entry_length),
3279                    pulongest (section->size));
3280           return;
3281         }
3282
3283       /* The version number.  */
3284       const uint16_t version = read_2_bytes (abfd, addr);
3285       addr += 2;
3286       if (version != 2)
3287         {
3288           warning (_("Section .debug_aranges in %s entry at offset %zu "
3289                      "has unsupported version %d, ignoring .debug_aranges."),
3290                    objfile_name (objfile), entry_addr - section->buffer,
3291                    version);
3292           return;
3293         }
3294
3295       const uint64_t debug_info_offset
3296         = extract_unsigned_integer (addr, offset_size, dwarf5_byte_order);
3297       addr += offset_size;
3298       const auto per_cu_it
3299         = debug_info_offset_to_per_cu.find (sect_offset (debug_info_offset));
3300       if (per_cu_it == debug_info_offset_to_per_cu.cend ())
3301         {
3302           warning (_("Section .debug_aranges in %s entry at offset %zu "
3303                      "debug_info_offset %s does not exists, "
3304                      "ignoring .debug_aranges."),
3305                    objfile_name (objfile), entry_addr - section->buffer,
3306                    pulongest (debug_info_offset));
3307           return;
3308         }
3309       dwarf2_per_cu_data *const per_cu = per_cu_it->second;
3310
3311       const uint8_t address_size = *addr++;
3312       if (address_size < 1 || address_size > 8)
3313         {
3314           warning (_("Section .debug_aranges in %s entry at offset %zu "
3315                      "address_size %u is invalid, ignoring .debug_aranges."),
3316                    objfile_name (objfile), entry_addr - section->buffer,
3317                    address_size);
3318           return;
3319         }
3320
3321       const uint8_t segment_selector_size = *addr++;
3322       if (segment_selector_size != 0)
3323         {
3324           warning (_("Section .debug_aranges in %s entry at offset %zu "
3325                      "segment_selector_size %u is not supported, "
3326                      "ignoring .debug_aranges."),
3327                    objfile_name (objfile), entry_addr - section->buffer,
3328                    segment_selector_size);
3329           return;
3330         }
3331
3332       /* Must pad to an alignment boundary that is twice the address
3333          size.  It is undocumented by the DWARF standard but GCC does
3334          use it.  */
3335       for (size_t padding = ((-(addr - section->buffer))
3336                              & (2 * address_size - 1));
3337            padding > 0; padding--)
3338         if (*addr++ != 0)
3339           {
3340             warning (_("Section .debug_aranges in %s entry at offset %zu "
3341                        "padding is not zero, ignoring .debug_aranges."),
3342                      objfile_name (objfile), entry_addr - section->buffer);
3343             return;
3344           }
3345
3346       for (;;)
3347         {
3348           if (addr + 2 * address_size > entry_end)
3349             {
3350               warning (_("Section .debug_aranges in %s entry at offset %zu "
3351                          "address list is not properly terminated, "
3352                          "ignoring .debug_aranges."),
3353                        objfile_name (objfile), entry_addr - section->buffer);
3354               return;
3355             }
3356           ULONGEST start = extract_unsigned_integer (addr, address_size,
3357                                                      dwarf5_byte_order);
3358           addr += address_size;
3359           ULONGEST length = extract_unsigned_integer (addr, address_size,
3360                                                       dwarf5_byte_order);
3361           addr += address_size;
3362           if (start == 0 && length == 0)
3363             break;
3364           if (start == 0 && !dwarf2_per_objfile->has_section_at_zero)
3365             {
3366               /* Symbol was eliminated due to a COMDAT group.  */
3367               continue;
3368             }
3369           ULONGEST end = start + length;
3370           start = (gdbarch_adjust_dwarf2_addr (gdbarch, start + baseaddr)
3371                    - baseaddr);
3372           end = (gdbarch_adjust_dwarf2_addr (gdbarch, end + baseaddr)
3373                  - baseaddr);
3374           addrmap_set_empty (mutable_map, start, end - 1, per_cu);
3375         }
3376     }
3377
3378   objfile->partial_symtabs->psymtabs_addrmap
3379     = addrmap_create_fixed (mutable_map, objfile->partial_symtabs->obstack ());
3380 }
3381
3382 /* Find a slot in the mapped index INDEX for the object named NAME.
3383    If NAME is found, set *VEC_OUT to point to the CU vector in the
3384    constant pool and return true.  If NAME cannot be found, return
3385    false.  */
3386
3387 static bool
3388 find_slot_in_mapped_hash (struct mapped_index *index, const char *name,
3389                           offset_type **vec_out)
3390 {
3391   offset_type hash;
3392   offset_type slot, step;
3393   int (*cmp) (const char *, const char *);
3394
3395   gdb::unique_xmalloc_ptr<char> without_params;
3396   if (current_language->la_language == language_cplus
3397       || current_language->la_language == language_fortran
3398       || current_language->la_language == language_d)
3399     {
3400       /* NAME is already canonical.  Drop any qualifiers as .gdb_index does
3401          not contain any.  */
3402
3403       if (strchr (name, '(') != NULL)
3404         {
3405           without_params = cp_remove_params (name);
3406
3407           if (without_params != NULL)
3408             name = without_params.get ();
3409         }
3410     }
3411
3412   /* Index version 4 did not support case insensitive searches.  But the
3413      indices for case insensitive languages are built in lowercase, therefore
3414      simulate our NAME being searched is also lowercased.  */
3415   hash = mapped_index_string_hash ((index->version == 4
3416                                     && case_sensitivity == case_sensitive_off
3417                                     ? 5 : index->version),
3418                                    name);
3419
3420   slot = hash & (index->symbol_table.size () - 1);
3421   step = ((hash * 17) & (index->symbol_table.size () - 1)) | 1;
3422   cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
3423
3424   for (;;)
3425     {
3426       const char *str;
3427
3428       const auto &bucket = index->symbol_table[slot];
3429       if (bucket.name == 0 && bucket.vec == 0)
3430         return false;
3431
3432       str = index->constant_pool + MAYBE_SWAP (bucket.name);
3433       if (!cmp (name, str))
3434         {
3435           *vec_out = (offset_type *) (index->constant_pool
3436                                       + MAYBE_SWAP (bucket.vec));
3437           return true;
3438         }
3439
3440       slot = (slot + step) & (index->symbol_table.size () - 1);
3441     }
3442 }
3443
3444 /* A helper function that reads the .gdb_index from BUFFER and fills
3445    in MAP.  FILENAME is the name of the file containing the data;
3446    it is used for error reporting.  DEPRECATED_OK is true if it is
3447    ok to use deprecated sections.
3448
3449    CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
3450    out parameters that are filled in with information about the CU and
3451    TU lists in the section.
3452
3453    Returns true if all went well, false otherwise.  */
3454
3455 static bool
3456 read_gdb_index_from_buffer (struct objfile *objfile,
3457                             const char *filename,
3458                             bool deprecated_ok,
3459                             gdb::array_view<const gdb_byte> buffer,
3460                             struct mapped_index *map,
3461                             const gdb_byte **cu_list,
3462                             offset_type *cu_list_elements,
3463                             const gdb_byte **types_list,
3464                             offset_type *types_list_elements)
3465 {
3466   const gdb_byte *addr = &buffer[0];
3467
3468   /* Version check.  */
3469   offset_type version = MAYBE_SWAP (*(offset_type *) addr);
3470   /* Versions earlier than 3 emitted every copy of a psymbol.  This
3471      causes the index to behave very poorly for certain requests.  Version 3
3472      contained incomplete addrmap.  So, it seems better to just ignore such
3473      indices.  */
3474   if (version < 4)
3475     {
3476       static int warning_printed = 0;
3477       if (!warning_printed)
3478         {
3479           warning (_("Skipping obsolete .gdb_index section in %s."),
3480                    filename);
3481           warning_printed = 1;
3482         }
3483       return 0;
3484     }
3485   /* Index version 4 uses a different hash function than index version
3486      5 and later.
3487
3488      Versions earlier than 6 did not emit psymbols for inlined
3489      functions.  Using these files will cause GDB not to be able to
3490      set breakpoints on inlined functions by name, so we ignore these
3491      indices unless the user has done
3492      "set use-deprecated-index-sections on".  */
3493   if (version < 6 && !deprecated_ok)
3494     {
3495       static int warning_printed = 0;
3496       if (!warning_printed)
3497         {
3498           warning (_("\
3499 Skipping deprecated .gdb_index section in %s.\n\
3500 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3501 to use the section anyway."),
3502                    filename);
3503           warning_printed = 1;
3504         }
3505       return 0;
3506     }
3507   /* Version 7 indices generated by gold refer to the CU for a symbol instead
3508      of the TU (for symbols coming from TUs),
3509      http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3510      Plus gold-generated indices can have duplicate entries for global symbols,
3511      http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3512      These are just performance bugs, and we can't distinguish gdb-generated
3513      indices from gold-generated ones, so issue no warning here.  */
3514
3515   /* Indexes with higher version than the one supported by GDB may be no
3516      longer backward compatible.  */
3517   if (version > 8)
3518     return 0;
3519
3520   map->version = version;
3521
3522   offset_type *metadata = (offset_type *) (addr + sizeof (offset_type));
3523
3524   int i = 0;
3525   *cu_list = addr + MAYBE_SWAP (metadata[i]);
3526   *cu_list_elements = ((MAYBE_SWAP (metadata[i + 1]) - MAYBE_SWAP (metadata[i]))
3527                        / 8);
3528   ++i;
3529
3530   *types_list = addr + MAYBE_SWAP (metadata[i]);
3531   *types_list_elements = ((MAYBE_SWAP (metadata[i + 1])
3532                            - MAYBE_SWAP (metadata[i]))
3533                           / 8);
3534   ++i;
3535
3536   const gdb_byte *address_table = addr + MAYBE_SWAP (metadata[i]);
3537   const gdb_byte *address_table_end = addr + MAYBE_SWAP (metadata[i + 1]);
3538   map->address_table
3539     = gdb::array_view<const gdb_byte> (address_table, address_table_end);
3540   ++i;
3541
3542   const gdb_byte *symbol_table = addr + MAYBE_SWAP (metadata[i]);
3543   const gdb_byte *symbol_table_end = addr + MAYBE_SWAP (metadata[i + 1]);
3544   map->symbol_table
3545     = gdb::array_view<mapped_index::symbol_table_slot>
3546        ((mapped_index::symbol_table_slot *) symbol_table,
3547         (mapped_index::symbol_table_slot *) symbol_table_end);
3548
3549   ++i;
3550   map->constant_pool = (char *) (addr + MAYBE_SWAP (metadata[i]));
3551
3552   return 1;
3553 }
3554
3555 /* Callback types for dwarf2_read_gdb_index.  */
3556
3557 typedef gdb::function_view
3558     <gdb::array_view<const gdb_byte>(objfile *, dwarf2_per_objfile *)>
3559     get_gdb_index_contents_ftype;
3560 typedef gdb::function_view
3561     <gdb::array_view<const gdb_byte>(objfile *, dwz_file *)>
3562     get_gdb_index_contents_dwz_ftype;
3563
3564 /* Read .gdb_index.  If everything went ok, initialize the "quick"
3565    elements of all the CUs and return 1.  Otherwise, return 0.  */
3566
3567 static int
3568 dwarf2_read_gdb_index
3569   (struct dwarf2_per_objfile *dwarf2_per_objfile,
3570    get_gdb_index_contents_ftype get_gdb_index_contents,
3571    get_gdb_index_contents_dwz_ftype get_gdb_index_contents_dwz)
3572 {
3573   const gdb_byte *cu_list, *types_list, *dwz_list = NULL;
3574   offset_type cu_list_elements, types_list_elements, dwz_list_elements = 0;
3575   struct dwz_file *dwz;
3576   struct objfile *objfile = dwarf2_per_objfile->objfile;
3577
3578   gdb::array_view<const gdb_byte> main_index_contents
3579     = get_gdb_index_contents (objfile, dwarf2_per_objfile);
3580
3581   if (main_index_contents.empty ())
3582     return 0;
3583
3584   std::unique_ptr<struct mapped_index> map (new struct mapped_index);
3585   if (!read_gdb_index_from_buffer (objfile, objfile_name (objfile),
3586                                    use_deprecated_index_sections,
3587                                    main_index_contents, map.get (), &cu_list,
3588                                    &cu_list_elements, &types_list,
3589                                    &types_list_elements))
3590     return 0;
3591
3592   /* Don't use the index if it's empty.  */
3593   if (map->symbol_table.empty ())
3594     return 0;
3595
3596   /* If there is a .dwz file, read it so we can get its CU list as
3597      well.  */
3598   dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
3599   if (dwz != NULL)
3600     {
3601       struct mapped_index dwz_map;
3602       const gdb_byte *dwz_types_ignore;
3603       offset_type dwz_types_elements_ignore;
3604
3605       gdb::array_view<const gdb_byte> dwz_index_content
3606         = get_gdb_index_contents_dwz (objfile, dwz);
3607
3608       if (dwz_index_content.empty ())
3609         return 0;
3610
3611       if (!read_gdb_index_from_buffer (objfile,
3612                                        bfd_get_filename (dwz->dwz_bfd), 1,
3613                                        dwz_index_content, &dwz_map,
3614                                        &dwz_list, &dwz_list_elements,
3615                                        &dwz_types_ignore,
3616                                        &dwz_types_elements_ignore))
3617         {
3618           warning (_("could not read '.gdb_index' section from %s; skipping"),
3619                    bfd_get_filename (dwz->dwz_bfd));
3620           return 0;
3621         }
3622     }
3623
3624   create_cus_from_index (dwarf2_per_objfile, cu_list, cu_list_elements,
3625                          dwz_list, dwz_list_elements);
3626
3627   if (types_list_elements)
3628     {
3629       struct dwarf2_section_info *section;
3630
3631       /* We can only handle a single .debug_types when we have an
3632          index.  */
3633       if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) != 1)
3634         return 0;
3635
3636       section = VEC_index (dwarf2_section_info_def,
3637                            dwarf2_per_objfile->types, 0);
3638
3639       create_signatured_type_table_from_index (dwarf2_per_objfile, section,
3640                                                types_list, types_list_elements);
3641     }
3642
3643   create_addrmap_from_index (dwarf2_per_objfile, map.get ());
3644
3645   dwarf2_per_objfile->index_table = std::move (map);
3646   dwarf2_per_objfile->using_index = 1;
3647   dwarf2_per_objfile->quick_file_names_table =
3648     create_quick_file_names_table (dwarf2_per_objfile->all_comp_units.size ());
3649
3650   return 1;
3651 }
3652
3653 /* die_reader_func for dw2_get_file_names.  */
3654
3655 static void
3656 dw2_get_file_names_reader (const struct die_reader_specs *reader,
3657                            const gdb_byte *info_ptr,
3658                            struct die_info *comp_unit_die,
3659                            int has_children,
3660                            void *data)
3661 {
3662   struct dwarf2_cu *cu = reader->cu;
3663   struct dwarf2_per_cu_data *this_cu = cu->per_cu;
3664   struct dwarf2_per_objfile *dwarf2_per_objfile
3665     = cu->per_cu->dwarf2_per_objfile;
3666   struct objfile *objfile = dwarf2_per_objfile->objfile;
3667   struct dwarf2_per_cu_data *lh_cu;
3668   struct attribute *attr;
3669   int i;
3670   void **slot;
3671   struct quick_file_names *qfn;
3672
3673   gdb_assert (! this_cu->is_debug_types);
3674
3675   /* Our callers never want to match partial units -- instead they
3676      will match the enclosing full CU.  */
3677   if (comp_unit_die->tag == DW_TAG_partial_unit)
3678     {
3679       this_cu->v.quick->no_file_data = 1;
3680       return;
3681     }
3682
3683   lh_cu = this_cu;
3684   slot = NULL;
3685
3686   line_header_up lh;
3687   sect_offset line_offset {};
3688
3689   attr = dwarf2_attr (comp_unit_die, DW_AT_stmt_list, cu);
3690   if (attr)
3691     {
3692       struct quick_file_names find_entry;
3693
3694       line_offset = (sect_offset) DW_UNSND (attr);
3695
3696       /* We may have already read in this line header (TU line header sharing).
3697          If we have we're done.  */
3698       find_entry.hash.dwo_unit = cu->dwo_unit;
3699       find_entry.hash.line_sect_off = line_offset;
3700       slot = htab_find_slot (dwarf2_per_objfile->quick_file_names_table,
3701                              &find_entry, INSERT);
3702       if (*slot != NULL)
3703         {
3704           lh_cu->v.quick->file_names = (struct quick_file_names *) *slot;
3705           return;
3706         }
3707
3708       lh = dwarf_decode_line_header (line_offset, cu);
3709     }
3710   if (lh == NULL)
3711     {
3712       lh_cu->v.quick->no_file_data = 1;
3713       return;
3714     }
3715
3716   qfn = XOBNEW (&objfile->objfile_obstack, struct quick_file_names);
3717   qfn->hash.dwo_unit = cu->dwo_unit;
3718   qfn->hash.line_sect_off = line_offset;
3719   gdb_assert (slot != NULL);
3720   *slot = qfn;
3721
3722   file_and_directory fnd = find_file_and_directory (comp_unit_die, cu);
3723
3724   qfn->num_file_names = lh->file_names.size ();
3725   qfn->file_names =
3726     XOBNEWVEC (&objfile->objfile_obstack, const char *, lh->file_names.size ());
3727   for (i = 0; i < lh->file_names.size (); ++i)
3728     qfn->file_names[i] = file_full_name (i + 1, lh.get (), fnd.comp_dir);
3729   qfn->real_names = NULL;
3730
3731   lh_cu->v.quick->file_names = qfn;
3732 }
3733
3734 /* A helper for the "quick" functions which attempts to read the line
3735    table for THIS_CU.  */
3736
3737 static struct quick_file_names *
3738 dw2_get_file_names (struct dwarf2_per_cu_data *this_cu)
3739 {
3740   /* This should never be called for TUs.  */
3741   gdb_assert (! this_cu->is_debug_types);
3742   /* Nor type unit groups.  */
3743   gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu));
3744
3745   if (this_cu->v.quick->file_names != NULL)
3746     return this_cu->v.quick->file_names;
3747   /* If we know there is no line data, no point in looking again.  */
3748   if (this_cu->v.quick->no_file_data)
3749     return NULL;
3750
3751   init_cutu_and_read_dies_simple (this_cu, dw2_get_file_names_reader, NULL);
3752
3753   if (this_cu->v.quick->no_file_data)
3754     return NULL;
3755   return this_cu->v.quick->file_names;
3756 }
3757
3758 /* A helper for the "quick" functions which computes and caches the
3759    real path for a given file name from the line table.  */
3760
3761 static const char *
3762 dw2_get_real_path (struct objfile *objfile,
3763                    struct quick_file_names *qfn, int index)
3764 {
3765   if (qfn->real_names == NULL)
3766     qfn->real_names = OBSTACK_CALLOC (&objfile->objfile_obstack,
3767                                       qfn->num_file_names, const char *);
3768
3769   if (qfn->real_names[index] == NULL)
3770     qfn->real_names[index] = gdb_realpath (qfn->file_names[index]).release ();
3771
3772   return qfn->real_names[index];
3773 }
3774
3775 static struct symtab *
3776 dw2_find_last_source_symtab (struct objfile *objfile)
3777 {
3778   struct dwarf2_per_objfile *dwarf2_per_objfile
3779     = get_dwarf2_per_objfile (objfile);
3780   dwarf2_per_cu_data *dwarf_cu = dwarf2_per_objfile->all_comp_units.back ();
3781   compunit_symtab *cust = dw2_instantiate_symtab (dwarf_cu, false);
3782
3783   if (cust == NULL)
3784     return NULL;
3785
3786   return compunit_primary_filetab (cust);
3787 }
3788
3789 /* Traversal function for dw2_forget_cached_source_info.  */
3790
3791 static int
3792 dw2_free_cached_file_names (void **slot, void *info)
3793 {
3794   struct quick_file_names *file_data = (struct quick_file_names *) *slot;
3795
3796   if (file_data->real_names)
3797     {
3798       int i;
3799
3800       for (i = 0; i < file_data->num_file_names; ++i)
3801         {
3802           xfree ((void*) file_data->real_names[i]);
3803           file_data->real_names[i] = NULL;
3804         }
3805     }
3806
3807   return 1;
3808 }
3809
3810 static void
3811 dw2_forget_cached_source_info (struct objfile *objfile)
3812 {
3813   struct dwarf2_per_objfile *dwarf2_per_objfile
3814     = get_dwarf2_per_objfile (objfile);
3815
3816   htab_traverse_noresize (dwarf2_per_objfile->quick_file_names_table,
3817                           dw2_free_cached_file_names, NULL);
3818 }
3819
3820 /* Helper function for dw2_map_symtabs_matching_filename that expands
3821    the symtabs and calls the iterator.  */
3822
3823 static int
3824 dw2_map_expand_apply (struct objfile *objfile,
3825                       struct dwarf2_per_cu_data *per_cu,
3826                       const char *name, const char *real_path,
3827                       gdb::function_view<bool (symtab *)> callback)
3828 {
3829   struct compunit_symtab *last_made = objfile->compunit_symtabs;
3830
3831   /* Don't visit already-expanded CUs.  */
3832   if (per_cu->v.quick->compunit_symtab)
3833     return 0;
3834
3835   /* This may expand more than one symtab, and we want to iterate over
3836      all of them.  */
3837   dw2_instantiate_symtab (per_cu, false);
3838
3839   return iterate_over_some_symtabs (name, real_path, objfile->compunit_symtabs,
3840                                     last_made, callback);
3841 }
3842
3843 /* Implementation of the map_symtabs_matching_filename method.  */
3844
3845 static bool
3846 dw2_map_symtabs_matching_filename
3847   (struct objfile *objfile, const char *name, const char *real_path,
3848    gdb::function_view<bool (symtab *)> callback)
3849 {
3850   const char *name_basename = lbasename (name);
3851   struct dwarf2_per_objfile *dwarf2_per_objfile
3852     = get_dwarf2_per_objfile (objfile);
3853
3854   /* The rule is CUs specify all the files, including those used by
3855      any TU, so there's no need to scan TUs here.  */
3856
3857   for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
3858     {
3859       /* We only need to look at symtabs not already expanded.  */
3860       if (per_cu->v.quick->compunit_symtab)
3861         continue;
3862
3863       quick_file_names *file_data = dw2_get_file_names (per_cu);
3864       if (file_data == NULL)
3865         continue;
3866
3867       for (int j = 0; j < file_data->num_file_names; ++j)
3868         {
3869           const char *this_name = file_data->file_names[j];
3870           const char *this_real_name;
3871
3872           if (compare_filenames_for_search (this_name, name))
3873             {
3874               if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3875                                         callback))
3876                 return true;
3877               continue;
3878             }
3879
3880           /* Before we invoke realpath, which can get expensive when many
3881              files are involved, do a quick comparison of the basenames.  */
3882           if (! basenames_may_differ
3883               && FILENAME_CMP (lbasename (this_name), name_basename) != 0)
3884             continue;
3885
3886           this_real_name = dw2_get_real_path (objfile, file_data, j);
3887           if (compare_filenames_for_search (this_real_name, name))
3888             {
3889               if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3890                                         callback))
3891                 return true;
3892               continue;
3893             }
3894
3895           if (real_path != NULL)
3896             {
3897               gdb_assert (IS_ABSOLUTE_PATH (real_path));
3898               gdb_assert (IS_ABSOLUTE_PATH (name));
3899               if (this_real_name != NULL
3900                   && FILENAME_CMP (real_path, this_real_name) == 0)
3901                 {
3902                   if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3903                                             callback))
3904                     return true;
3905                   continue;
3906                 }
3907             }
3908         }
3909     }
3910
3911   return false;
3912 }
3913
3914 /* Struct used to manage iterating over all CUs looking for a symbol.  */
3915
3916 struct dw2_symtab_iterator
3917 {
3918   /* The dwarf2_per_objfile owning the CUs we are iterating on.  */
3919   struct dwarf2_per_objfile *dwarf2_per_objfile;
3920   /* If non-zero, only look for symbols that match BLOCK_INDEX.  */
3921   int want_specific_block;
3922   /* One of GLOBAL_BLOCK or STATIC_BLOCK.
3923      Unused if !WANT_SPECIFIC_BLOCK.  */
3924   int block_index;
3925   /* The kind of symbol we're looking for.  */
3926   domain_enum domain;
3927   /* The list of CUs from the index entry of the symbol,
3928      or NULL if not found.  */
3929   offset_type *vec;
3930   /* The next element in VEC to look at.  */
3931   int next;
3932   /* The number of elements in VEC, or zero if there is no match.  */
3933   int length;
3934   /* Have we seen a global version of the symbol?
3935      If so we can ignore all further global instances.
3936      This is to work around gold/15646, inefficient gold-generated
3937      indices.  */
3938   int global_seen;
3939 };
3940
3941 /* Initialize the index symtab iterator ITER.
3942    If WANT_SPECIFIC_BLOCK is non-zero, only look for symbols
3943    in block BLOCK_INDEX.  Otherwise BLOCK_INDEX is ignored.  */
3944
3945 static void
3946 dw2_symtab_iter_init (struct dw2_symtab_iterator *iter,
3947                       struct dwarf2_per_objfile *dwarf2_per_objfile,
3948                       int want_specific_block,
3949                       int block_index,
3950                       domain_enum domain,
3951                       const char *name)
3952 {
3953   iter->dwarf2_per_objfile = dwarf2_per_objfile;
3954   iter->want_specific_block = want_specific_block;
3955   iter->block_index = block_index;
3956   iter->domain = domain;
3957   iter->next = 0;
3958   iter->global_seen = 0;
3959
3960   mapped_index *index = dwarf2_per_objfile->index_table.get ();
3961
3962   /* index is NULL if OBJF_READNOW.  */
3963   if (index != NULL && find_slot_in_mapped_hash (index, name, &iter->vec))
3964     iter->length = MAYBE_SWAP (*iter->vec);
3965   else
3966     {
3967       iter->vec = NULL;
3968       iter->length = 0;
3969     }
3970 }
3971
3972 /* Return the next matching CU or NULL if there are no more.  */
3973
3974 static struct dwarf2_per_cu_data *
3975 dw2_symtab_iter_next (struct dw2_symtab_iterator *iter)
3976 {
3977   struct dwarf2_per_objfile *dwarf2_per_objfile = iter->dwarf2_per_objfile;
3978
3979   for ( ; iter->next < iter->length; ++iter->next)
3980     {
3981       offset_type cu_index_and_attrs =
3982         MAYBE_SWAP (iter->vec[iter->next + 1]);
3983       offset_type cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
3984       int want_static = iter->block_index != GLOBAL_BLOCK;
3985       /* This value is only valid for index versions >= 7.  */
3986       int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
3987       gdb_index_symbol_kind symbol_kind =
3988         GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
3989       /* Only check the symbol attributes if they're present.
3990          Indices prior to version 7 don't record them,
3991          and indices >= 7 may elide them for certain symbols
3992          (gold does this).  */
3993       int attrs_valid =
3994         (dwarf2_per_objfile->index_table->version >= 7
3995          && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
3996
3997       /* Don't crash on bad data.  */
3998       if (cu_index >= (dwarf2_per_objfile->all_comp_units.size ()
3999                        + dwarf2_per_objfile->all_type_units.size ()))
4000         {
4001           complaint (_(".gdb_index entry has bad CU index"
4002                        " [in module %s]"),
4003                      objfile_name (dwarf2_per_objfile->objfile));
4004           continue;
4005         }
4006
4007       dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (cu_index);
4008
4009       /* Skip if already read in.  */
4010       if (per_cu->v.quick->compunit_symtab)
4011         continue;
4012
4013       /* Check static vs global.  */
4014       if (attrs_valid)
4015         {
4016           if (iter->want_specific_block
4017               && want_static != is_static)
4018             continue;
4019           /* Work around gold/15646.  */
4020           if (!is_static && iter->global_seen)
4021             continue;
4022           if (!is_static)
4023             iter->global_seen = 1;
4024         }
4025
4026       /* Only check the symbol's kind if it has one.  */
4027       if (attrs_valid)
4028         {
4029           switch (iter->domain)
4030             {
4031             case VAR_DOMAIN:
4032               if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE
4033                   && symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION
4034                   /* Some types are also in VAR_DOMAIN.  */
4035                   && symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
4036                 continue;
4037               break;
4038             case STRUCT_DOMAIN:
4039               if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
4040                 continue;
4041               break;
4042             case LABEL_DOMAIN:
4043               if (symbol_kind != GDB_INDEX_SYMBOL_KIND_OTHER)
4044                 continue;
4045               break;
4046             default:
4047               break;
4048             }
4049         }
4050
4051       ++iter->next;
4052       return per_cu;
4053     }
4054
4055   return NULL;
4056 }
4057
4058 static struct compunit_symtab *
4059 dw2_lookup_symbol (struct objfile *objfile, int block_index,
4060                    const char *name, domain_enum domain)
4061 {
4062   struct compunit_symtab *stab_best = NULL;
4063   struct dwarf2_per_objfile *dwarf2_per_objfile
4064     = get_dwarf2_per_objfile (objfile);
4065
4066   lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
4067
4068   struct dw2_symtab_iterator iter;
4069   struct dwarf2_per_cu_data *per_cu;
4070
4071   dw2_symtab_iter_init (&iter, dwarf2_per_objfile, 1, block_index, domain, name);
4072
4073   while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
4074     {
4075       struct symbol *sym, *with_opaque = NULL;
4076       struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu, false);
4077       const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
4078       const struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
4079
4080       sym = block_find_symbol (block, name, domain,
4081                                block_find_non_opaque_type_preferred,
4082                                &with_opaque);
4083
4084       /* Some caution must be observed with overloaded functions
4085          and methods, since the index will not contain any overload
4086          information (but NAME might contain it).  */
4087
4088       if (sym != NULL
4089           && SYMBOL_MATCHES_SEARCH_NAME (sym, lookup_name))
4090         return stab;
4091       if (with_opaque != NULL
4092           && SYMBOL_MATCHES_SEARCH_NAME (with_opaque, lookup_name))
4093         stab_best = stab;
4094
4095       /* Keep looking through other CUs.  */
4096     }
4097
4098   return stab_best;
4099 }
4100
4101 static void
4102 dw2_print_stats (struct objfile *objfile)
4103 {
4104   struct dwarf2_per_objfile *dwarf2_per_objfile
4105     = get_dwarf2_per_objfile (objfile);
4106   int total = (dwarf2_per_objfile->all_comp_units.size ()
4107                + dwarf2_per_objfile->all_type_units.size ());
4108   int count = 0;
4109
4110   for (int i = 0; i < total; ++i)
4111     {
4112       dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
4113
4114       if (!per_cu->v.quick->compunit_symtab)
4115         ++count;
4116     }
4117   printf_filtered (_("  Number of read CUs: %d\n"), total - count);
4118   printf_filtered (_("  Number of unread CUs: %d\n"), count);
4119 }
4120
4121 /* This dumps minimal information about the index.
4122    It is called via "mt print objfiles".
4123    One use is to verify .gdb_index has been loaded by the
4124    gdb.dwarf2/gdb-index.exp testcase.  */
4125
4126 static void
4127 dw2_dump (struct objfile *objfile)
4128 {
4129   struct dwarf2_per_objfile *dwarf2_per_objfile
4130     = get_dwarf2_per_objfile (objfile);
4131
4132   gdb_assert (dwarf2_per_objfile->using_index);
4133   printf_filtered (".gdb_index:");
4134   if (dwarf2_per_objfile->index_table != NULL)
4135     {
4136       printf_filtered (" version %d\n",
4137                        dwarf2_per_objfile->index_table->version);
4138     }
4139   else
4140     printf_filtered (" faked for \"readnow\"\n");
4141   printf_filtered ("\n");
4142 }
4143
4144 static void
4145 dw2_expand_symtabs_for_function (struct objfile *objfile,
4146                                  const char *func_name)
4147 {
4148   struct dwarf2_per_objfile *dwarf2_per_objfile
4149     = get_dwarf2_per_objfile (objfile);
4150
4151   struct dw2_symtab_iterator iter;
4152   struct dwarf2_per_cu_data *per_cu;
4153
4154   /* Note: It doesn't matter what we pass for block_index here.  */
4155   dw2_symtab_iter_init (&iter, dwarf2_per_objfile, 0, GLOBAL_BLOCK, VAR_DOMAIN,
4156                         func_name);
4157
4158   while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
4159     dw2_instantiate_symtab (per_cu, false);
4160
4161 }
4162
4163 static void
4164 dw2_expand_all_symtabs (struct objfile *objfile)
4165 {
4166   struct dwarf2_per_objfile *dwarf2_per_objfile
4167     = get_dwarf2_per_objfile (objfile);
4168   int total_units = (dwarf2_per_objfile->all_comp_units.size ()
4169                      + dwarf2_per_objfile->all_type_units.size ());
4170
4171   for (int i = 0; i < total_units; ++i)
4172     {
4173       dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
4174
4175       /* We don't want to directly expand a partial CU, because if we
4176          read it with the wrong language, then assertion failures can
4177          be triggered later on.  See PR symtab/23010.  So, tell
4178          dw2_instantiate_symtab to skip partial CUs -- any important
4179          partial CU will be read via DW_TAG_imported_unit anyway.  */
4180       dw2_instantiate_symtab (per_cu, true);
4181     }
4182 }
4183
4184 static void
4185 dw2_expand_symtabs_with_fullname (struct objfile *objfile,
4186                                   const char *fullname)
4187 {
4188   struct dwarf2_per_objfile *dwarf2_per_objfile
4189     = get_dwarf2_per_objfile (objfile);
4190
4191   /* We don't need to consider type units here.
4192      This is only called for examining code, e.g. expand_line_sal.
4193      There can be an order of magnitude (or more) more type units
4194      than comp units, and we avoid them if we can.  */
4195
4196   for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
4197     {
4198       /* We only need to look at symtabs not already expanded.  */
4199       if (per_cu->v.quick->compunit_symtab)
4200         continue;
4201
4202       quick_file_names *file_data = dw2_get_file_names (per_cu);
4203       if (file_data == NULL)
4204         continue;
4205
4206       for (int j = 0; j < file_data->num_file_names; ++j)
4207         {
4208           const char *this_fullname = file_data->file_names[j];
4209
4210           if (filename_cmp (this_fullname, fullname) == 0)
4211             {
4212               dw2_instantiate_symtab (per_cu, false);
4213               break;
4214             }
4215         }
4216     }
4217 }
4218
4219 static void
4220 dw2_map_matching_symbols (struct objfile *objfile,
4221                           const char * name, domain_enum domain,
4222                           int global,
4223                           int (*callback) (const struct block *,
4224                                            struct symbol *, void *),
4225                           void *data, symbol_name_match_type match,
4226                           symbol_compare_ftype *ordered_compare)
4227 {
4228   /* Currently unimplemented; used for Ada.  The function can be called if the
4229      current language is Ada for a non-Ada objfile using GNU index.  As Ada
4230      does not look for non-Ada symbols this function should just return.  */
4231 }
4232
4233 /* Symbol name matcher for .gdb_index names.
4234
4235    Symbol names in .gdb_index have a few particularities:
4236
4237    - There's no indication of which is the language of each symbol.
4238
4239      Since each language has its own symbol name matching algorithm,
4240      and we don't know which language is the right one, we must match
4241      each symbol against all languages.  This would be a potential
4242      performance problem if it were not mitigated by the
4243      mapped_index::name_components lookup table, which significantly
4244      reduces the number of times we need to call into this matcher,
4245      making it a non-issue.
4246
4247    - Symbol names in the index have no overload (parameter)
4248      information.  I.e., in C++, "foo(int)" and "foo(long)" both
4249      appear as "foo" in the index, for example.
4250
4251      This means that the lookup names passed to the symbol name
4252      matcher functions must have no parameter information either
4253      because (e.g.) symbol search name "foo" does not match
4254      lookup-name "foo(int)" [while swapping search name for lookup
4255      name would match].
4256 */
4257 class gdb_index_symbol_name_matcher
4258 {
4259 public:
4260   /* Prepares the vector of comparison functions for LOOKUP_NAME.  */
4261   gdb_index_symbol_name_matcher (const lookup_name_info &lookup_name);
4262
4263   /* Walk all the matcher routines and match SYMBOL_NAME against them.
4264      Returns true if any matcher matches.  */
4265   bool matches (const char *symbol_name);
4266
4267 private:
4268   /* A reference to the lookup name we're matching against.  */
4269   const lookup_name_info &m_lookup_name;
4270
4271   /* A vector holding all the different symbol name matchers, for all
4272      languages.  */
4273   std::vector<symbol_name_matcher_ftype *> m_symbol_name_matcher_funcs;
4274 };
4275
4276 gdb_index_symbol_name_matcher::gdb_index_symbol_name_matcher
4277   (const lookup_name_info &lookup_name)
4278     : m_lookup_name (lookup_name)
4279 {
4280   /* Prepare the vector of comparison functions upfront, to avoid
4281      doing the same work for each symbol.  Care is taken to avoid
4282      matching with the same matcher more than once if/when multiple
4283      languages use the same matcher function.  */
4284   auto &matchers = m_symbol_name_matcher_funcs;
4285   matchers.reserve (nr_languages);
4286
4287   matchers.push_back (default_symbol_name_matcher);
4288
4289   for (int i = 0; i < nr_languages; i++)
4290     {
4291       const language_defn *lang = language_def ((enum language) i);
4292       symbol_name_matcher_ftype *name_matcher
4293         = get_symbol_name_matcher (lang, m_lookup_name);
4294
4295       /* Don't insert the same comparison routine more than once.
4296          Note that we do this linear walk instead of a seemingly
4297          cheaper sorted insert, or use a std::set or something like
4298          that, because relative order of function addresses is not
4299          stable.  This is not a problem in practice because the number
4300          of supported languages is low, and the cost here is tiny
4301          compared to the number of searches we'll do afterwards using
4302          this object.  */
4303       if (name_matcher != default_symbol_name_matcher
4304           && (std::find (matchers.begin (), matchers.end (), name_matcher)
4305               == matchers.end ()))
4306         matchers.push_back (name_matcher);
4307     }
4308 }
4309
4310 bool
4311 gdb_index_symbol_name_matcher::matches (const char *symbol_name)
4312 {
4313   for (auto matches_name : m_symbol_name_matcher_funcs)
4314     if (matches_name (symbol_name, m_lookup_name, NULL))
4315       return true;
4316
4317   return false;
4318 }
4319
4320 /* Starting from a search name, return the string that finds the upper
4321    bound of all strings that start with SEARCH_NAME in a sorted name
4322    list.  Returns the empty string to indicate that the upper bound is
4323    the end of the list.  */
4324
4325 static std::string
4326 make_sort_after_prefix_name (const char *search_name)
4327 {
4328   /* When looking to complete "func", we find the upper bound of all
4329      symbols that start with "func" by looking for where we'd insert
4330      the closest string that would follow "func" in lexicographical
4331      order.  Usually, that's "func"-with-last-character-incremented,
4332      i.e. "fund".  Mind non-ASCII characters, though.  Usually those
4333      will be UTF-8 multi-byte sequences, but we can't be certain.
4334      Especially mind the 0xff character, which is a valid character in
4335      non-UTF-8 source character sets (e.g. Latin1 'ÿ'), and we can't
4336      rule out compilers allowing it in identifiers.  Note that
4337      conveniently, strcmp/strcasecmp are specified to compare
4338      characters interpreted as unsigned char.  So what we do is treat
4339      the whole string as a base 256 number composed of a sequence of
4340      base 256 "digits" and add 1 to it.  I.e., adding 1 to 0xff wraps
4341      to 0, and carries 1 to the following more-significant position.
4342      If the very first character in SEARCH_NAME ends up incremented
4343      and carries/overflows, then the upper bound is the end of the
4344      list.  The string after the empty string is also the empty
4345      string.
4346
4347      Some examples of this operation:
4348
4349        SEARCH_NAME  => "+1" RESULT
4350
4351        "abc"              => "abd"
4352        "ab\xff"           => "ac"
4353        "\xff" "a" "\xff"  => "\xff" "b"
4354        "\xff"             => ""
4355        "\xff\xff"         => ""
4356        ""                 => ""
4357
4358      Then, with these symbols for example:
4359
4360       func
4361       func1
4362       fund
4363
4364      completing "func" looks for symbols between "func" and
4365      "func"-with-last-character-incremented, i.e. "fund" (exclusive),
4366      which finds "func" and "func1", but not "fund".
4367
4368      And with:
4369
4370       funcÿ     (Latin1 'ÿ' [0xff])
4371       funcÿ1
4372       fund
4373
4374      completing "funcÿ" looks for symbols between "funcÿ" and "fund"
4375      (exclusive), which finds "funcÿ" and "funcÿ1", but not "fund".
4376
4377      And with:
4378
4379       ÿÿ        (Latin1 'ÿ' [0xff])
4380       ÿÿ1
4381
4382      completing "ÿ" or "ÿÿ" looks for symbols between between "ÿÿ" and
4383      the end of the list.
4384   */
4385   std::string after = search_name;
4386   while (!after.empty () && (unsigned char) after.back () == 0xff)
4387     after.pop_back ();
4388   if (!after.empty ())
4389     after.back () = (unsigned char) after.back () + 1;
4390   return after;
4391 }
4392
4393 /* See declaration.  */
4394
4395 std::pair<std::vector<name_component>::const_iterator,
4396           std::vector<name_component>::const_iterator>
4397 mapped_index_base::find_name_components_bounds
4398   (const lookup_name_info &lookup_name_without_params) const
4399 {
4400   auto *name_cmp
4401     = this->name_components_casing == case_sensitive_on ? strcmp : strcasecmp;
4402
4403   const char *cplus
4404     = lookup_name_without_params.cplus ().lookup_name ().c_str ();
4405
4406   /* Comparison function object for lower_bound that matches against a
4407      given symbol name.  */
4408   auto lookup_compare_lower = [&] (const name_component &elem,
4409                                    const char *name)
4410     {
4411       const char *elem_qualified = this->symbol_name_at (elem.idx);
4412       const char *elem_name = elem_qualified + elem.name_offset;
4413       return name_cmp (elem_name, name) < 0;
4414     };
4415
4416   /* Comparison function object for upper_bound that matches against a
4417      given symbol name.  */
4418   auto lookup_compare_upper = [&] (const char *name,
4419                                    const name_component &elem)
4420     {
4421       const char *elem_qualified = this->symbol_name_at (elem.idx);
4422       const char *elem_name = elem_qualified + elem.name_offset;
4423       return name_cmp (name, elem_name) < 0;
4424     };
4425
4426   auto begin = this->name_components.begin ();
4427   auto end = this->name_components.end ();
4428
4429   /* Find the lower bound.  */
4430   auto lower = [&] ()
4431     {
4432       if (lookup_name_without_params.completion_mode () && cplus[0] == '\0')
4433         return begin;
4434       else
4435         return std::lower_bound (begin, end, cplus, lookup_compare_lower);
4436     } ();
4437
4438   /* Find the upper bound.  */
4439   auto upper = [&] ()
4440     {
4441       if (lookup_name_without_params.completion_mode ())
4442         {
4443           /* In completion mode, we want UPPER to point past all
4444              symbols names that have the same prefix.  I.e., with
4445              these symbols, and completing "func":
4446
4447               function        << lower bound
4448               function1
4449               other_function  << upper bound
4450
4451              We find the upper bound by looking for the insertion
4452              point of "func"-with-last-character-incremented,
4453              i.e. "fund".  */
4454           std::string after = make_sort_after_prefix_name (cplus);
4455           if (after.empty ())
4456             return end;
4457           return std::lower_bound (lower, end, after.c_str (),
4458                                    lookup_compare_lower);
4459         }
4460       else
4461         return std::upper_bound (lower, end, cplus, lookup_compare_upper);
4462     } ();
4463
4464   return {lower, upper};
4465 }
4466
4467 /* See declaration.  */
4468
4469 void
4470 mapped_index_base::build_name_components ()
4471 {
4472   if (!this->name_components.empty ())
4473     return;
4474
4475   this->name_components_casing = case_sensitivity;
4476   auto *name_cmp
4477     = this->name_components_casing == case_sensitive_on ? strcmp : strcasecmp;
4478
4479   /* The code below only knows how to break apart components of C++
4480      symbol names (and other languages that use '::' as
4481      namespace/module separator).  If we add support for wild matching
4482      to some language that uses some other operator (E.g., Ada, Go and
4483      D use '.'), then we'll need to try splitting the symbol name
4484      according to that language too.  Note that Ada does support wild
4485      matching, but doesn't currently support .gdb_index.  */
4486   auto count = this->symbol_name_count ();
4487   for (offset_type idx = 0; idx < count; idx++)
4488     {
4489       if (this->symbol_name_slot_invalid (idx))
4490         continue;
4491
4492       const char *name = this->symbol_name_at (idx);
4493
4494       /* Add each name component to the name component table.  */
4495       unsigned int previous_len = 0;
4496       for (unsigned int current_len = cp_find_first_component (name);
4497            name[current_len] != '\0';
4498            current_len += cp_find_first_component (name + current_len))
4499         {
4500           gdb_assert (name[current_len] == ':');
4501           this->name_components.push_back ({previous_len, idx});
4502           /* Skip the '::'.  */
4503           current_len += 2;
4504           previous_len = current_len;
4505         }
4506       this->name_components.push_back ({previous_len, idx});
4507     }
4508
4509   /* Sort name_components elements by name.  */
4510   auto name_comp_compare = [&] (const name_component &left,
4511                                 const name_component &right)
4512     {
4513       const char *left_qualified = this->symbol_name_at (left.idx);
4514       const char *right_qualified = this->symbol_name_at (right.idx);
4515
4516       const char *left_name = left_qualified + left.name_offset;
4517       const char *right_name = right_qualified + right.name_offset;
4518
4519       return name_cmp (left_name, right_name) < 0;
4520     };
4521
4522   std::sort (this->name_components.begin (),
4523              this->name_components.end (),
4524              name_comp_compare);
4525 }
4526
4527 /* Helper for dw2_expand_symtabs_matching that works with a
4528    mapped_index_base instead of the containing objfile.  This is split
4529    to a separate function in order to be able to unit test the
4530    name_components matching using a mock mapped_index_base.  For each
4531    symbol name that matches, calls MATCH_CALLBACK, passing it the
4532    symbol's index in the mapped_index_base symbol table.  */
4533
4534 static void
4535 dw2_expand_symtabs_matching_symbol
4536   (mapped_index_base &index,
4537    const lookup_name_info &lookup_name_in,
4538    gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
4539    enum search_domain kind,
4540    gdb::function_view<void (offset_type)> match_callback)
4541 {
4542   lookup_name_info lookup_name_without_params
4543     = lookup_name_in.make_ignore_params ();
4544   gdb_index_symbol_name_matcher lookup_name_matcher
4545     (lookup_name_without_params);
4546
4547   /* Build the symbol name component sorted vector, if we haven't
4548      yet.  */
4549   index.build_name_components ();
4550
4551   auto bounds = index.find_name_components_bounds (lookup_name_without_params);
4552
4553   /* Now for each symbol name in range, check to see if we have a name
4554      match, and if so, call the MATCH_CALLBACK callback.  */
4555
4556   /* The same symbol may appear more than once in the range though.
4557      E.g., if we're looking for symbols that complete "w", and we have
4558      a symbol named "w1::w2", we'll find the two name components for
4559      that same symbol in the range.  To be sure we only call the
4560      callback once per symbol, we first collect the symbol name
4561      indexes that matched in a temporary vector and ignore
4562      duplicates.  */
4563   std::vector<offset_type> matches;
4564   matches.reserve (std::distance (bounds.first, bounds.second));
4565
4566   for (; bounds.first != bounds.second; ++bounds.first)
4567     {
4568       const char *qualified = index.symbol_name_at (bounds.first->idx);
4569
4570       if (!lookup_name_matcher.matches (qualified)
4571           || (symbol_matcher != NULL && !symbol_matcher (qualified)))
4572         continue;
4573
4574       matches.push_back (bounds.first->idx);
4575     }
4576
4577   std::sort (matches.begin (), matches.end ());
4578
4579   /* Finally call the callback, once per match.  */
4580   ULONGEST prev = -1;
4581   for (offset_type idx : matches)
4582     {
4583       if (prev != idx)
4584         {
4585           match_callback (idx);
4586           prev = idx;
4587         }
4588     }
4589
4590   /* Above we use a type wider than idx's for 'prev', since 0 and
4591      (offset_type)-1 are both possible values.  */
4592   static_assert (sizeof (prev) > sizeof (offset_type), "");
4593 }
4594
4595 #if GDB_SELF_TEST
4596
4597 namespace selftests { namespace dw2_expand_symtabs_matching {
4598
4599 /* A mock .gdb_index/.debug_names-like name index table, enough to
4600    exercise dw2_expand_symtabs_matching_symbol, which works with the
4601    mapped_index_base interface.  Builds an index from the symbol list
4602    passed as parameter to the constructor.  */
4603 class mock_mapped_index : public mapped_index_base
4604 {
4605 public:
4606   mock_mapped_index (gdb::array_view<const char *> symbols)
4607     : m_symbol_table (symbols)
4608   {}
4609
4610   DISABLE_COPY_AND_ASSIGN (mock_mapped_index);
4611
4612   /* Return the number of names in the symbol table.  */
4613   size_t symbol_name_count () const override
4614   {
4615     return m_symbol_table.size ();
4616   }
4617
4618   /* Get the name of the symbol at IDX in the symbol table.  */
4619   const char *symbol_name_at (offset_type idx) const override
4620   {
4621     return m_symbol_table[idx];
4622   }
4623
4624 private:
4625   gdb::array_view<const char *> m_symbol_table;
4626 };
4627
4628 /* Convenience function that converts a NULL pointer to a "<null>"
4629    string, to pass to print routines.  */
4630
4631 static const char *
4632 string_or_null (const char *str)
4633 {
4634   return str != NULL ? str : "<null>";
4635 }
4636
4637 /* Check if a lookup_name_info built from
4638    NAME/MATCH_TYPE/COMPLETION_MODE matches the symbols in the mock
4639    index.  EXPECTED_LIST is the list of expected matches, in expected
4640    matching order.  If no match expected, then an empty list is
4641    specified.  Returns true on success.  On failure prints a warning
4642    indicating the file:line that failed, and returns false.  */
4643
4644 static bool
4645 check_match (const char *file, int line,
4646              mock_mapped_index &mock_index,
4647              const char *name, symbol_name_match_type match_type,
4648              bool completion_mode,
4649              std::initializer_list<const char *> expected_list)
4650 {
4651   lookup_name_info lookup_name (name, match_type, completion_mode);
4652
4653   bool matched = true;
4654
4655   auto mismatch = [&] (const char *expected_str,
4656                        const char *got)
4657   {
4658     warning (_("%s:%d: match_type=%s, looking-for=\"%s\", "
4659                "expected=\"%s\", got=\"%s\"\n"),
4660              file, line,
4661              (match_type == symbol_name_match_type::FULL
4662               ? "FULL" : "WILD"),
4663              name, string_or_null (expected_str), string_or_null (got));
4664     matched = false;
4665   };
4666
4667   auto expected_it = expected_list.begin ();
4668   auto expected_end = expected_list.end ();
4669
4670   dw2_expand_symtabs_matching_symbol (mock_index, lookup_name,
4671                                       NULL, ALL_DOMAIN,
4672                                       [&] (offset_type idx)
4673   {
4674     const char *matched_name = mock_index.symbol_name_at (idx);
4675     const char *expected_str
4676       = expected_it == expected_end ? NULL : *expected_it++;
4677
4678     if (expected_str == NULL || strcmp (expected_str, matched_name) != 0)
4679       mismatch (expected_str, matched_name);
4680   });
4681
4682   const char *expected_str
4683   = expected_it == expected_end ? NULL : *expected_it++;
4684   if (expected_str != NULL)
4685     mismatch (expected_str, NULL);
4686
4687   return matched;
4688 }
4689
4690 /* The symbols added to the mock mapped_index for testing (in
4691    canonical form).  */
4692 static const char *test_symbols[] = {
4693   "function",
4694   "std::bar",
4695   "std::zfunction",
4696   "std::zfunction2",
4697   "w1::w2",
4698   "ns::foo<char*>",
4699   "ns::foo<int>",
4700   "ns::foo<long>",
4701   "ns2::tmpl<int>::foo2",
4702   "(anonymous namespace)::A::B::C",
4703
4704   /* These are used to check that the increment-last-char in the
4705      matching algorithm for completion doesn't match "t1_fund" when
4706      completing "t1_func".  */
4707   "t1_func",
4708   "t1_func1",
4709   "t1_fund",
4710   "t1_fund1",
4711
4712   /* A UTF-8 name with multi-byte sequences to make sure that
4713      cp-name-parser understands this as a single identifier ("função"
4714      is "function" in PT).  */
4715   u8"u8função",
4716
4717   /* \377 (0xff) is Latin1 'ÿ'.  */
4718   "yfunc\377",
4719
4720   /* \377 (0xff) is Latin1 'ÿ'.  */
4721   "\377",
4722   "\377\377123",
4723
4724   /* A name with all sorts of complications.  Starts with "z" to make
4725      it easier for the completion tests below.  */
4726 #define Z_SYM_NAME \
4727   "z::std::tuple<(anonymous namespace)::ui*, std::bar<(anonymous namespace)::ui> >" \
4728     "::tuple<(anonymous namespace)::ui*, " \
4729     "std::default_delete<(anonymous namespace)::ui>, void>"
4730
4731   Z_SYM_NAME
4732 };
4733
4734 /* Returns true if the mapped_index_base::find_name_component_bounds
4735    method finds EXPECTED_SYMS in INDEX when looking for SEARCH_NAME,
4736    in completion mode.  */
4737
4738 static bool
4739 check_find_bounds_finds (mapped_index_base &index,
4740                          const char *search_name,
4741                          gdb::array_view<const char *> expected_syms)
4742 {
4743   lookup_name_info lookup_name (search_name,
4744                                 symbol_name_match_type::FULL, true);
4745
4746   auto bounds = index.find_name_components_bounds (lookup_name);
4747
4748   size_t distance = std::distance (bounds.first, bounds.second);
4749   if (distance != expected_syms.size ())
4750     return false;
4751
4752   for (size_t exp_elem = 0; exp_elem < distance; exp_elem++)
4753     {
4754       auto nc_elem = bounds.first + exp_elem;
4755       const char *qualified = index.symbol_name_at (nc_elem->idx);
4756       if (strcmp (qualified, expected_syms[exp_elem]) != 0)
4757         return false;
4758     }
4759
4760   return true;
4761 }
4762
4763 /* Test the lower-level mapped_index::find_name_component_bounds
4764    method.  */
4765
4766 static void
4767 test_mapped_index_find_name_component_bounds ()
4768 {
4769   mock_mapped_index mock_index (test_symbols);
4770
4771   mock_index.build_name_components ();
4772
4773   /* Test the lower-level mapped_index::find_name_component_bounds
4774      method in completion mode.  */
4775   {
4776     static const char *expected_syms[] = {
4777       "t1_func",
4778       "t1_func1",
4779     };
4780
4781     SELF_CHECK (check_find_bounds_finds (mock_index,
4782                                          "t1_func", expected_syms));
4783   }
4784
4785   /* Check that the increment-last-char in the name matching algorithm
4786      for completion doesn't get confused with Ansi1 'ÿ' / 0xff.  */
4787   {
4788     static const char *expected_syms1[] = {
4789       "\377",
4790       "\377\377123",
4791     };
4792     SELF_CHECK (check_find_bounds_finds (mock_index,
4793                                          "\377", expected_syms1));
4794
4795     static const char *expected_syms2[] = {
4796       "\377\377123",
4797     };
4798     SELF_CHECK (check_find_bounds_finds (mock_index,
4799                                          "\377\377", expected_syms2));
4800   }
4801 }
4802
4803 /* Test dw2_expand_symtabs_matching_symbol.  */
4804
4805 static void
4806 test_dw2_expand_symtabs_matching_symbol ()
4807 {
4808   mock_mapped_index mock_index (test_symbols);
4809
4810   /* We let all tests run until the end even if some fails, for debug
4811      convenience.  */
4812   bool any_mismatch = false;
4813
4814   /* Create the expected symbols list (an initializer_list).  Needed
4815      because lists have commas, and we need to pass them to CHECK,
4816      which is a macro.  */
4817 #define EXPECT(...) { __VA_ARGS__ }
4818
4819   /* Wrapper for check_match that passes down the current
4820      __FILE__/__LINE__.  */
4821 #define CHECK_MATCH(NAME, MATCH_TYPE, COMPLETION_MODE, EXPECTED_LIST)   \
4822   any_mismatch |= !check_match (__FILE__, __LINE__,                     \
4823                                 mock_index,                             \
4824                                 NAME, MATCH_TYPE, COMPLETION_MODE,      \
4825                                 EXPECTED_LIST)
4826
4827   /* Identity checks.  */
4828   for (const char *sym : test_symbols)
4829     {
4830       /* Should be able to match all existing symbols.  */
4831       CHECK_MATCH (sym, symbol_name_match_type::FULL, false,
4832                    EXPECT (sym));
4833
4834       /* Should be able to match all existing symbols with
4835          parameters.  */
4836       std::string with_params = std::string (sym) + "(int)";
4837       CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
4838                    EXPECT (sym));
4839
4840       /* Should be able to match all existing symbols with
4841          parameters and qualifiers.  */
4842       with_params = std::string (sym) + " ( int ) const";
4843       CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
4844                    EXPECT (sym));
4845
4846       /* This should really find sym, but cp-name-parser.y doesn't
4847          know about lvalue/rvalue qualifiers yet.  */
4848       with_params = std::string (sym) + " ( int ) &&";
4849       CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
4850                    {});
4851     }
4852
4853   /* Check that the name matching algorithm for completion doesn't get
4854      confused with Latin1 'ÿ' / 0xff.  */
4855   {
4856     static const char str[] = "\377";
4857     CHECK_MATCH (str, symbol_name_match_type::FULL, true,
4858                  EXPECT ("\377", "\377\377123"));
4859   }
4860
4861   /* Check that the increment-last-char in the matching algorithm for
4862      completion doesn't match "t1_fund" when completing "t1_func".  */
4863   {
4864     static const char str[] = "t1_func";
4865     CHECK_MATCH (str, symbol_name_match_type::FULL, true,
4866                  EXPECT ("t1_func", "t1_func1"));
4867   }
4868
4869   /* Check that completion mode works at each prefix of the expected
4870      symbol name.  */
4871   {
4872     static const char str[] = "function(int)";
4873     size_t len = strlen (str);
4874     std::string lookup;
4875
4876     for (size_t i = 1; i < len; i++)
4877       {
4878         lookup.assign (str, i);
4879         CHECK_MATCH (lookup.c_str (), symbol_name_match_type::FULL, true,
4880                      EXPECT ("function"));
4881       }
4882   }
4883
4884   /* While "w" is a prefix of both components, the match function
4885      should still only be called once.  */
4886   {
4887     CHECK_MATCH ("w", symbol_name_match_type::FULL, true,
4888                  EXPECT ("w1::w2"));
4889     CHECK_MATCH ("w", symbol_name_match_type::WILD, true,
4890                  EXPECT ("w1::w2"));
4891   }
4892
4893   /* Same, with a "complicated" symbol.  */
4894   {
4895     static const char str[] = Z_SYM_NAME;
4896     size_t len = strlen (str);
4897     std::string lookup;
4898
4899     for (size_t i = 1; i < len; i++)
4900       {
4901         lookup.assign (str, i);
4902         CHECK_MATCH (lookup.c_str (), symbol_name_match_type::FULL, true,
4903                      EXPECT (Z_SYM_NAME));
4904       }
4905   }
4906
4907   /* In FULL mode, an incomplete symbol doesn't match.  */
4908   {
4909     CHECK_MATCH ("std::zfunction(int", symbol_name_match_type::FULL, false,
4910                  {});
4911   }
4912
4913   /* A complete symbol with parameters matches any overload, since the
4914      index has no overload info.  */
4915   {
4916     CHECK_MATCH ("std::zfunction(int)", symbol_name_match_type::FULL, true,
4917                  EXPECT ("std::zfunction", "std::zfunction2"));
4918     CHECK_MATCH ("zfunction(int)", symbol_name_match_type::WILD, true,
4919                  EXPECT ("std::zfunction", "std::zfunction2"));
4920     CHECK_MATCH ("zfunc", symbol_name_match_type::WILD, true,
4921                  EXPECT ("std::zfunction", "std::zfunction2"));
4922   }
4923
4924   /* Check that whitespace is ignored appropriately.  A symbol with a
4925      template argument list. */
4926   {
4927     static const char expected[] = "ns::foo<int>";
4928     CHECK_MATCH ("ns :: foo < int > ", symbol_name_match_type::FULL, false,
4929                  EXPECT (expected));
4930     CHECK_MATCH ("foo < int > ", symbol_name_match_type::WILD, false,
4931                  EXPECT (expected));
4932   }
4933
4934   /* Check that whitespace is ignored appropriately.  A symbol with a
4935      template argument list that includes a pointer.  */
4936   {
4937     static const char expected[] = "ns::foo<char*>";
4938     /* Try both completion and non-completion modes.  */
4939     static const bool completion_mode[2] = {false, true};
4940     for (size_t i = 0; i < 2; i++)
4941       {
4942         CHECK_MATCH ("ns :: foo < char * >", symbol_name_match_type::FULL,
4943                      completion_mode[i], EXPECT (expected));
4944         CHECK_MATCH ("foo < char * >", symbol_name_match_type::WILD,
4945                      completion_mode[i], EXPECT (expected));
4946
4947         CHECK_MATCH ("ns :: foo < char * > (int)", symbol_name_match_type::FULL,
4948                      completion_mode[i], EXPECT (expected));
4949         CHECK_MATCH ("foo < char * > (int)", symbol_name_match_type::WILD,
4950                      completion_mode[i], EXPECT (expected));
4951       }
4952   }
4953
4954   {
4955     /* Check method qualifiers are ignored.  */
4956     static const char expected[] = "ns::foo<char*>";
4957     CHECK_MATCH ("ns :: foo < char * >  ( int ) const",
4958                  symbol_name_match_type::FULL, true, EXPECT (expected));
4959     CHECK_MATCH ("ns :: foo < char * >  ( int ) &&",
4960                  symbol_name_match_type::FULL, true, EXPECT (expected));
4961     CHECK_MATCH ("foo < char * >  ( int ) const",
4962                  symbol_name_match_type::WILD, true, EXPECT (expected));
4963     CHECK_MATCH ("foo < char * >  ( int ) &&",
4964                  symbol_name_match_type::WILD, true, EXPECT (expected));
4965   }
4966
4967   /* Test lookup names that don't match anything.  */
4968   {
4969     CHECK_MATCH ("bar2", symbol_name_match_type::WILD, false,
4970                  {});
4971
4972     CHECK_MATCH ("doesntexist", symbol_name_match_type::FULL, false,
4973                  {});
4974   }
4975
4976   /* Some wild matching tests, exercising "(anonymous namespace)",
4977      which should not be confused with a parameter list.  */
4978   {
4979     static const char *syms[] = {
4980       "A::B::C",
4981       "B::C",
4982       "C",
4983       "A :: B :: C ( int )",
4984       "B :: C ( int )",
4985       "C ( int )",
4986     };
4987
4988     for (const char *s : syms)
4989       {
4990         CHECK_MATCH (s, symbol_name_match_type::WILD, false,
4991                      EXPECT ("(anonymous namespace)::A::B::C"));
4992       }
4993   }
4994
4995   {
4996     static const char expected[] = "ns2::tmpl<int>::foo2";
4997     CHECK_MATCH ("tmp", symbol_name_match_type::WILD, true,
4998                  EXPECT (expected));
4999     CHECK_MATCH ("tmpl<", symbol_name_match_type::WILD, true,
5000                  EXPECT (expected));
5001   }
5002
5003   SELF_CHECK (!any_mismatch);
5004
5005 #undef EXPECT
5006 #undef CHECK_MATCH
5007 }
5008
5009 static void
5010 run_test ()
5011 {
5012   test_mapped_index_find_name_component_bounds ();
5013   test_dw2_expand_symtabs_matching_symbol ();
5014 }
5015
5016 }} // namespace selftests::dw2_expand_symtabs_matching
5017
5018 #endif /* GDB_SELF_TEST */
5019
5020 /* If FILE_MATCHER is NULL or if PER_CU has
5021    dwarf2_per_cu_quick_data::MARK set (see
5022    dw_expand_symtabs_matching_file_matcher), expand the CU and call
5023    EXPANSION_NOTIFY on it.  */
5024
5025 static void
5026 dw2_expand_symtabs_matching_one
5027   (struct dwarf2_per_cu_data *per_cu,
5028    gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5029    gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify)
5030 {
5031   if (file_matcher == NULL || per_cu->v.quick->mark)
5032     {
5033       bool symtab_was_null
5034         = (per_cu->v.quick->compunit_symtab == NULL);
5035
5036       dw2_instantiate_symtab (per_cu, false);
5037
5038       if (expansion_notify != NULL
5039           && symtab_was_null
5040           && per_cu->v.quick->compunit_symtab != NULL)
5041         expansion_notify (per_cu->v.quick->compunit_symtab);
5042     }
5043 }
5044
5045 /* Helper for dw2_expand_matching symtabs.  Called on each symbol
5046    matched, to expand corresponding CUs that were marked.  IDX is the
5047    index of the symbol name that matched.  */
5048
5049 static void
5050 dw2_expand_marked_cus
5051   (struct dwarf2_per_objfile *dwarf2_per_objfile, offset_type idx,
5052    gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5053    gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
5054    search_domain kind)
5055 {
5056   offset_type *vec, vec_len, vec_idx;
5057   bool global_seen = false;
5058   mapped_index &index = *dwarf2_per_objfile->index_table;
5059
5060   vec = (offset_type *) (index.constant_pool
5061                          + MAYBE_SWAP (index.symbol_table[idx].vec));
5062   vec_len = MAYBE_SWAP (vec[0]);
5063   for (vec_idx = 0; vec_idx < vec_len; ++vec_idx)
5064     {
5065       offset_type cu_index_and_attrs = MAYBE_SWAP (vec[vec_idx + 1]);
5066       /* This value is only valid for index versions >= 7.  */
5067       int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
5068       gdb_index_symbol_kind symbol_kind =
5069         GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
5070       int cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
5071       /* Only check the symbol attributes if they're present.
5072          Indices prior to version 7 don't record them,
5073          and indices >= 7 may elide them for certain symbols
5074          (gold does this).  */
5075       int attrs_valid =
5076         (index.version >= 7
5077          && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
5078
5079       /* Work around gold/15646.  */
5080       if (attrs_valid)
5081         {
5082           if (!is_static && global_seen)
5083             continue;
5084           if (!is_static)
5085             global_seen = true;
5086         }
5087
5088       /* Only check the symbol's kind if it has one.  */
5089       if (attrs_valid)
5090         {
5091           switch (kind)
5092             {
5093             case VARIABLES_DOMAIN:
5094               if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE)
5095                 continue;
5096               break;
5097             case FUNCTIONS_DOMAIN:
5098               if (symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION)
5099                 continue;
5100               break;
5101             case TYPES_DOMAIN:
5102               if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
5103                 continue;
5104               break;
5105             default:
5106               break;
5107             }
5108         }
5109
5110       /* Don't crash on bad data.  */
5111       if (cu_index >= (dwarf2_per_objfile->all_comp_units.size ()
5112                        + dwarf2_per_objfile->all_type_units.size ()))
5113         {
5114           complaint (_(".gdb_index entry has bad CU index"
5115                        " [in module %s]"),
5116                        objfile_name (dwarf2_per_objfile->objfile));
5117           continue;
5118         }
5119
5120       dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (cu_index);
5121       dw2_expand_symtabs_matching_one (per_cu, file_matcher,
5122                                        expansion_notify);
5123     }
5124 }
5125
5126 /* If FILE_MATCHER is non-NULL, set all the
5127    dwarf2_per_cu_quick_data::MARK of the current DWARF2_PER_OBJFILE
5128    that match FILE_MATCHER.  */
5129
5130 static void
5131 dw_expand_symtabs_matching_file_matcher
5132   (struct dwarf2_per_objfile *dwarf2_per_objfile,
5133    gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher)
5134 {
5135   if (file_matcher == NULL)
5136     return;
5137
5138   objfile *const objfile = dwarf2_per_objfile->objfile;
5139
5140   htab_up visited_found (htab_create_alloc (10, htab_hash_pointer,
5141                                             htab_eq_pointer,
5142                                             NULL, xcalloc, xfree));
5143   htab_up visited_not_found (htab_create_alloc (10, htab_hash_pointer,
5144                                                 htab_eq_pointer,
5145                                                 NULL, xcalloc, xfree));
5146
5147   /* The rule is CUs specify all the files, including those used by
5148      any TU, so there's no need to scan TUs here.  */
5149
5150   for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
5151     {
5152       QUIT;
5153
5154       per_cu->v.quick->mark = 0;
5155
5156       /* We only need to look at symtabs not already expanded.  */
5157       if (per_cu->v.quick->compunit_symtab)
5158         continue;
5159
5160       quick_file_names *file_data = dw2_get_file_names (per_cu);
5161       if (file_data == NULL)
5162         continue;
5163
5164       if (htab_find (visited_not_found.get (), file_data) != NULL)
5165         continue;
5166       else if (htab_find (visited_found.get (), file_data) != NULL)
5167         {
5168           per_cu->v.quick->mark = 1;
5169           continue;
5170         }
5171
5172       for (int j = 0; j < file_data->num_file_names; ++j)
5173         {
5174           const char *this_real_name;
5175
5176           if (file_matcher (file_data->file_names[j], false))
5177             {
5178               per_cu->v.quick->mark = 1;
5179               break;
5180             }
5181
5182           /* Before we invoke realpath, which can get expensive when many
5183              files are involved, do a quick comparison of the basenames.  */
5184           if (!basenames_may_differ
5185               && !file_matcher (lbasename (file_data->file_names[j]),
5186                                 true))
5187             continue;
5188
5189           this_real_name = dw2_get_real_path (objfile, file_data, j);
5190           if (file_matcher (this_real_name, false))
5191             {
5192               per_cu->v.quick->mark = 1;
5193               break;
5194             }
5195         }
5196
5197       void **slot = htab_find_slot (per_cu->v.quick->mark
5198                                     ? visited_found.get ()
5199                                     : visited_not_found.get (),
5200                                     file_data, INSERT);
5201       *slot = file_data;
5202     }
5203 }
5204
5205 static void
5206 dw2_expand_symtabs_matching
5207   (struct objfile *objfile,
5208    gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5209    const lookup_name_info &lookup_name,
5210    gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
5211    gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
5212    enum search_domain kind)
5213 {
5214   struct dwarf2_per_objfile *dwarf2_per_objfile
5215     = get_dwarf2_per_objfile (objfile);
5216
5217   /* index_table is NULL if OBJF_READNOW.  */
5218   if (!dwarf2_per_objfile->index_table)
5219     return;
5220
5221   dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile, file_matcher);
5222
5223   mapped_index &index = *dwarf2_per_objfile->index_table;
5224
5225   dw2_expand_symtabs_matching_symbol (index, lookup_name,
5226                                       symbol_matcher,
5227                                       kind, [&] (offset_type idx)
5228     {
5229       dw2_expand_marked_cus (dwarf2_per_objfile, idx, file_matcher,
5230                              expansion_notify, kind);
5231     });
5232 }
5233
5234 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
5235    symtab.  */
5236
5237 static struct compunit_symtab *
5238 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab *cust,
5239                                           CORE_ADDR pc)
5240 {
5241   int i;
5242
5243   if (COMPUNIT_BLOCKVECTOR (cust) != NULL
5244       && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust), pc))
5245     return cust;
5246
5247   if (cust->includes == NULL)
5248     return NULL;
5249
5250   for (i = 0; cust->includes[i]; ++i)
5251     {
5252       struct compunit_symtab *s = cust->includes[i];
5253
5254       s = recursively_find_pc_sect_compunit_symtab (s, pc);
5255       if (s != NULL)
5256         return s;
5257     }
5258
5259   return NULL;
5260 }
5261
5262 static struct compunit_symtab *
5263 dw2_find_pc_sect_compunit_symtab (struct objfile *objfile,
5264                                   struct bound_minimal_symbol msymbol,
5265                                   CORE_ADDR pc,
5266                                   struct obj_section *section,
5267                                   int warn_if_readin)
5268 {
5269   struct dwarf2_per_cu_data *data;
5270   struct compunit_symtab *result;
5271
5272   if (!objfile->partial_symtabs->psymtabs_addrmap)
5273     return NULL;
5274
5275   CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
5276                                  SECT_OFF_TEXT (objfile));
5277   data = (struct dwarf2_per_cu_data *) addrmap_find
5278     (objfile->partial_symtabs->psymtabs_addrmap, pc - baseaddr);
5279   if (!data)
5280     return NULL;
5281
5282   if (warn_if_readin && data->v.quick->compunit_symtab)
5283     warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
5284              paddress (get_objfile_arch (objfile), pc));
5285
5286   result
5287     = recursively_find_pc_sect_compunit_symtab (dw2_instantiate_symtab (data,
5288                                                                         false),
5289                                                 pc);
5290   gdb_assert (result != NULL);
5291   return result;
5292 }
5293
5294 static void
5295 dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun,
5296                           void *data, int need_fullname)
5297 {
5298   struct dwarf2_per_objfile *dwarf2_per_objfile
5299     = get_dwarf2_per_objfile (objfile);
5300
5301   if (!dwarf2_per_objfile->filenames_cache)
5302     {
5303       dwarf2_per_objfile->filenames_cache.emplace ();
5304
5305       htab_up visited (htab_create_alloc (10,
5306                                           htab_hash_pointer, htab_eq_pointer,
5307                                           NULL, xcalloc, xfree));
5308
5309       /* The rule is CUs specify all the files, including those used
5310          by any TU, so there's no need to scan TUs here.  We can
5311          ignore file names coming from already-expanded CUs.  */
5312
5313       for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
5314         {
5315           if (per_cu->v.quick->compunit_symtab)
5316             {
5317               void **slot = htab_find_slot (visited.get (),
5318                                             per_cu->v.quick->file_names,
5319                                             INSERT);
5320
5321               *slot = per_cu->v.quick->file_names;
5322             }
5323         }
5324
5325       for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
5326         {
5327           /* We only need to look at symtabs not already expanded.  */
5328           if (per_cu->v.quick->compunit_symtab)
5329             continue;
5330
5331           quick_file_names *file_data = dw2_get_file_names (per_cu);
5332           if (file_data == NULL)
5333             continue;
5334
5335           void **slot = htab_find_slot (visited.get (), file_data, INSERT);
5336           if (*slot)
5337             {
5338               /* Already visited.  */
5339               continue;
5340             }
5341           *slot = file_data;
5342
5343           for (int j = 0; j < file_data->num_file_names; ++j)
5344             {
5345               const char *filename = file_data->file_names[j];
5346               dwarf2_per_objfile->filenames_cache->seen (filename);
5347             }
5348         }
5349     }
5350
5351   dwarf2_per_objfile->filenames_cache->traverse ([&] (const char *filename)
5352     {
5353       gdb::unique_xmalloc_ptr<char> this_real_name;
5354
5355       if (need_fullname)
5356         this_real_name = gdb_realpath (filename);
5357       (*fun) (filename, this_real_name.get (), data);
5358     });
5359 }
5360
5361 static int
5362 dw2_has_symbols (struct objfile *objfile)
5363 {
5364   return 1;
5365 }
5366
5367 const struct quick_symbol_functions dwarf2_gdb_index_functions =
5368 {
5369   dw2_has_symbols,
5370   dw2_find_last_source_symtab,
5371   dw2_forget_cached_source_info,
5372   dw2_map_symtabs_matching_filename,
5373   dw2_lookup_symbol,
5374   dw2_print_stats,
5375   dw2_dump,
5376   dw2_expand_symtabs_for_function,
5377   dw2_expand_all_symtabs,
5378   dw2_expand_symtabs_with_fullname,
5379   dw2_map_matching_symbols,
5380   dw2_expand_symtabs_matching,
5381   dw2_find_pc_sect_compunit_symtab,
5382   NULL,
5383   dw2_map_symbol_filenames
5384 };
5385
5386 /* DWARF-5 debug_names reader.  */
5387
5388 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension.  */
5389 static const gdb_byte dwarf5_augmentation[] = { 'G', 'D', 'B', 0 };
5390
5391 /* A helper function that reads the .debug_names section in SECTION
5392    and fills in MAP.  FILENAME is the name of the file containing the
5393    section; it is used for error reporting.
5394
5395    Returns true if all went well, false otherwise.  */
5396
5397 static bool
5398 read_debug_names_from_section (struct objfile *objfile,
5399                                const char *filename,
5400                                struct dwarf2_section_info *section,
5401                                mapped_debug_names &map)
5402 {
5403   if (dwarf2_section_empty_p (section))
5404     return false;
5405
5406   /* Older elfutils strip versions could keep the section in the main
5407      executable while splitting it for the separate debug info file.  */
5408   if ((get_section_flags (section) & SEC_HAS_CONTENTS) == 0)
5409     return false;
5410
5411   dwarf2_read_section (objfile, section);
5412
5413   map.dwarf5_byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
5414
5415   const gdb_byte *addr = section->buffer;
5416
5417   bfd *const abfd = get_section_bfd_owner (section);
5418
5419   unsigned int bytes_read;
5420   LONGEST length = read_initial_length (abfd, addr, &bytes_read);
5421   addr += bytes_read;
5422
5423   map.dwarf5_is_dwarf64 = bytes_read != 4;
5424   map.offset_size = map.dwarf5_is_dwarf64 ? 8 : 4;
5425   if (bytes_read + length != section->size)
5426     {
5427       /* There may be multiple per-CU indices.  */
5428       warning (_("Section .debug_names in %s length %s does not match "
5429                  "section length %s, ignoring .debug_names."),
5430                filename, plongest (bytes_read + length),
5431                pulongest (section->size));
5432       return false;
5433     }
5434
5435   /* The version number.  */
5436   uint16_t version = read_2_bytes (abfd, addr);
5437   addr += 2;
5438   if (version != 5)
5439     {
5440       warning (_("Section .debug_names in %s has unsupported version %d, "
5441                  "ignoring .debug_names."),
5442                filename, version);
5443       return false;
5444     }
5445
5446   /* Padding.  */
5447   uint16_t padding = read_2_bytes (abfd, addr);
5448   addr += 2;
5449   if (padding != 0)
5450     {
5451       warning (_("Section .debug_names in %s has unsupported padding %d, "
5452                  "ignoring .debug_names."),
5453                filename, padding);
5454       return false;
5455     }
5456
5457   /* comp_unit_count - The number of CUs in the CU list.  */
5458   map.cu_count = read_4_bytes (abfd, addr);
5459   addr += 4;
5460
5461   /* local_type_unit_count - The number of TUs in the local TU
5462      list.  */
5463   map.tu_count = read_4_bytes (abfd, addr);
5464   addr += 4;
5465
5466   /* foreign_type_unit_count - The number of TUs in the foreign TU
5467      list.  */
5468   uint32_t foreign_tu_count = read_4_bytes (abfd, addr);
5469   addr += 4;
5470   if (foreign_tu_count != 0)
5471     {
5472       warning (_("Section .debug_names in %s has unsupported %lu foreign TUs, "
5473                  "ignoring .debug_names."),
5474                filename, static_cast<unsigned long> (foreign_tu_count));
5475       return false;
5476     }
5477
5478   /* bucket_count - The number of hash buckets in the hash lookup
5479      table.  */
5480   map.bucket_count = read_4_bytes (abfd, addr);
5481   addr += 4;
5482
5483   /* name_count - The number of unique names in the index.  */
5484   map.name_count = read_4_bytes (abfd, addr);
5485   addr += 4;
5486
5487   /* abbrev_table_size - The size in bytes of the abbreviations
5488      table.  */
5489   uint32_t abbrev_table_size = read_4_bytes (abfd, addr);
5490   addr += 4;
5491
5492   /* augmentation_string_size - The size in bytes of the augmentation
5493      string.  This value is rounded up to a multiple of 4.  */
5494   uint32_t augmentation_string_size = read_4_bytes (abfd, addr);
5495   addr += 4;
5496   map.augmentation_is_gdb = ((augmentation_string_size
5497                               == sizeof (dwarf5_augmentation))
5498                              && memcmp (addr, dwarf5_augmentation,
5499                                         sizeof (dwarf5_augmentation)) == 0);
5500   augmentation_string_size += (-augmentation_string_size) & 3;
5501   addr += augmentation_string_size;
5502
5503   /* List of CUs */
5504   map.cu_table_reordered = addr;
5505   addr += map.cu_count * map.offset_size;
5506
5507   /* List of Local TUs */
5508   map.tu_table_reordered = addr;
5509   addr += map.tu_count * map.offset_size;
5510
5511   /* Hash Lookup Table */
5512   map.bucket_table_reordered = reinterpret_cast<const uint32_t *> (addr);
5513   addr += map.bucket_count * 4;
5514   map.hash_table_reordered = reinterpret_cast<const uint32_t *> (addr);
5515   addr += map.name_count * 4;
5516
5517   /* Name Table */
5518   map.name_table_string_offs_reordered = addr;
5519   addr += map.name_count * map.offset_size;
5520   map.name_table_entry_offs_reordered = addr;
5521   addr += map.name_count * map.offset_size;
5522
5523   const gdb_byte *abbrev_table_start = addr;
5524   for (;;)
5525     {
5526       const ULONGEST index_num = read_unsigned_leb128 (abfd, addr, &bytes_read);
5527       addr += bytes_read;
5528       if (index_num == 0)
5529         break;
5530
5531       const auto insertpair
5532         = map.abbrev_map.emplace (index_num, mapped_debug_names::index_val ());
5533       if (!insertpair.second)
5534         {
5535           warning (_("Section .debug_names in %s has duplicate index %s, "
5536                      "ignoring .debug_names."),
5537                    filename, pulongest (index_num));
5538           return false;
5539         }
5540       mapped_debug_names::index_val &indexval = insertpair.first->second;
5541       indexval.dwarf_tag = read_unsigned_leb128 (abfd, addr, &bytes_read);
5542       addr += bytes_read;
5543
5544       for (;;)
5545         {
5546           mapped_debug_names::index_val::attr attr;
5547           attr.dw_idx = read_unsigned_leb128 (abfd, addr, &bytes_read);
5548           addr += bytes_read;
5549           attr.form = read_unsigned_leb128 (abfd, addr, &bytes_read);
5550           addr += bytes_read;
5551           if (attr.form == DW_FORM_implicit_const)
5552             {
5553               attr.implicit_const = read_signed_leb128 (abfd, addr,
5554                                                         &bytes_read);
5555               addr += bytes_read;
5556             }
5557           if (attr.dw_idx == 0 && attr.form == 0)
5558             break;
5559           indexval.attr_vec.push_back (std::move (attr));
5560         }
5561     }
5562   if (addr != abbrev_table_start + abbrev_table_size)
5563     {
5564       warning (_("Section .debug_names in %s has abbreviation_table "
5565                  "of size %zu vs. written as %u, ignoring .debug_names."),
5566                filename, addr - abbrev_table_start, abbrev_table_size);
5567       return false;
5568     }
5569   map.entry_pool = addr;
5570
5571   return true;
5572 }
5573
5574 /* A helper for create_cus_from_debug_names that handles the MAP's CU
5575    list.  */
5576
5577 static void
5578 create_cus_from_debug_names_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
5579                                   const mapped_debug_names &map,
5580                                   dwarf2_section_info &section,
5581                                   bool is_dwz)
5582 {
5583   sect_offset sect_off_prev;
5584   for (uint32_t i = 0; i <= map.cu_count; ++i)
5585     {
5586       sect_offset sect_off_next;
5587       if (i < map.cu_count)
5588         {
5589           sect_off_next
5590             = (sect_offset) (extract_unsigned_integer
5591                              (map.cu_table_reordered + i * map.offset_size,
5592                               map.offset_size,
5593                               map.dwarf5_byte_order));
5594         }
5595       else
5596         sect_off_next = (sect_offset) section.size;
5597       if (i >= 1)
5598         {
5599           const ULONGEST length = sect_off_next - sect_off_prev;
5600           dwarf2_per_cu_data *per_cu
5601             = create_cu_from_index_list (dwarf2_per_objfile, &section, is_dwz,
5602                                          sect_off_prev, length);
5603           dwarf2_per_objfile->all_comp_units.push_back (per_cu);
5604         }
5605       sect_off_prev = sect_off_next;
5606     }
5607 }
5608
5609 /* Read the CU list from the mapped index, and use it to create all
5610    the CU objects for this dwarf2_per_objfile.  */
5611
5612 static void
5613 create_cus_from_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile,
5614                              const mapped_debug_names &map,
5615                              const mapped_debug_names &dwz_map)
5616 {
5617   gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
5618   dwarf2_per_objfile->all_comp_units.reserve (map.cu_count + dwz_map.cu_count);
5619
5620   create_cus_from_debug_names_list (dwarf2_per_objfile, map,
5621                                     dwarf2_per_objfile->info,
5622                                     false /* is_dwz */);
5623
5624   if (dwz_map.cu_count == 0)
5625     return;
5626
5627   dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
5628   create_cus_from_debug_names_list (dwarf2_per_objfile, dwz_map, dwz->info,
5629                                     true /* is_dwz */);
5630 }
5631
5632 /* Read .debug_names.  If everything went ok, initialize the "quick"
5633    elements of all the CUs and return true.  Otherwise, return false.  */
5634
5635 static bool
5636 dwarf2_read_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile)
5637 {
5638   std::unique_ptr<mapped_debug_names> map
5639     (new mapped_debug_names (dwarf2_per_objfile));
5640   mapped_debug_names dwz_map (dwarf2_per_objfile);
5641   struct objfile *objfile = dwarf2_per_objfile->objfile;
5642
5643   if (!read_debug_names_from_section (objfile, objfile_name (objfile),
5644                                       &dwarf2_per_objfile->debug_names,
5645                                       *map))
5646     return false;
5647
5648   /* Don't use the index if it's empty.  */
5649   if (map->name_count == 0)
5650     return false;
5651
5652   /* If there is a .dwz file, read it so we can get its CU list as
5653      well.  */
5654   dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
5655   if (dwz != NULL)
5656     {
5657       if (!read_debug_names_from_section (objfile,
5658                                           bfd_get_filename (dwz->dwz_bfd),
5659                                           &dwz->debug_names, dwz_map))
5660         {
5661           warning (_("could not read '.debug_names' section from %s; skipping"),
5662                    bfd_get_filename (dwz->dwz_bfd));
5663           return false;
5664         }
5665     }
5666
5667   create_cus_from_debug_names (dwarf2_per_objfile, *map, dwz_map);
5668
5669   if (map->tu_count != 0)
5670     {
5671       /* We can only handle a single .debug_types when we have an
5672          index.  */
5673       if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) != 1)
5674         return false;
5675
5676       dwarf2_section_info *section = VEC_index (dwarf2_section_info_def,
5677                                                 dwarf2_per_objfile->types, 0);
5678
5679       create_signatured_type_table_from_debug_names
5680         (dwarf2_per_objfile, *map, section, &dwarf2_per_objfile->abbrev);
5681     }
5682
5683   create_addrmap_from_aranges (dwarf2_per_objfile,
5684                                &dwarf2_per_objfile->debug_aranges);
5685
5686   dwarf2_per_objfile->debug_names_table = std::move (map);
5687   dwarf2_per_objfile->using_index = 1;
5688   dwarf2_per_objfile->quick_file_names_table =
5689     create_quick_file_names_table (dwarf2_per_objfile->all_comp_units.size ());
5690
5691   return true;
5692 }
5693
5694 /* Type used to manage iterating over all CUs looking for a symbol for
5695    .debug_names.  */
5696
5697 class dw2_debug_names_iterator
5698 {
5699 public:
5700   /* If WANT_SPECIFIC_BLOCK is true, only look for symbols in block
5701      BLOCK_INDEX.  Otherwise BLOCK_INDEX is ignored.  */
5702   dw2_debug_names_iterator (const mapped_debug_names &map,
5703                             bool want_specific_block,
5704                             block_enum block_index, domain_enum domain,
5705                             const char *name)
5706     : m_map (map), m_want_specific_block (want_specific_block),
5707       m_block_index (block_index), m_domain (domain),
5708       m_addr (find_vec_in_debug_names (map, name))
5709   {}
5710
5711   dw2_debug_names_iterator (const mapped_debug_names &map,
5712                             search_domain search, uint32_t namei)
5713     : m_map (map),
5714       m_search (search),
5715       m_addr (find_vec_in_debug_names (map, namei))
5716   {}
5717
5718   /* Return the next matching CU or NULL if there are no more.  */
5719   dwarf2_per_cu_data *next ();
5720
5721 private:
5722   static const gdb_byte *find_vec_in_debug_names (const mapped_debug_names &map,
5723                                                   const char *name);
5724   static const gdb_byte *find_vec_in_debug_names (const mapped_debug_names &map,
5725                                                   uint32_t namei);
5726
5727   /* The internalized form of .debug_names.  */
5728   const mapped_debug_names &m_map;
5729
5730   /* If true, only look for symbols that match BLOCK_INDEX.  */
5731   const bool m_want_specific_block = false;
5732
5733   /* One of GLOBAL_BLOCK or STATIC_BLOCK.
5734      Unused if !WANT_SPECIFIC_BLOCK - FIRST_LOCAL_BLOCK is an invalid
5735      value.  */
5736   const block_enum m_block_index = FIRST_LOCAL_BLOCK;
5737
5738   /* The kind of symbol we're looking for.  */
5739   const domain_enum m_domain = UNDEF_DOMAIN;
5740   const search_domain m_search = ALL_DOMAIN;
5741
5742   /* The list of CUs from the index entry of the symbol, or NULL if
5743      not found.  */
5744   const gdb_byte *m_addr;
5745 };
5746
5747 const char *
5748 mapped_debug_names::namei_to_name (uint32_t namei) const
5749 {
5750   const ULONGEST namei_string_offs
5751     = extract_unsigned_integer ((name_table_string_offs_reordered
5752                                  + namei * offset_size),
5753                                 offset_size,
5754                                 dwarf5_byte_order);
5755   return read_indirect_string_at_offset
5756     (dwarf2_per_objfile, dwarf2_per_objfile->objfile->obfd, namei_string_offs);
5757 }
5758
5759 /* Find a slot in .debug_names for the object named NAME.  If NAME is
5760    found, return pointer to its pool data.  If NAME cannot be found,
5761    return NULL.  */
5762
5763 const gdb_byte *
5764 dw2_debug_names_iterator::find_vec_in_debug_names
5765   (const mapped_debug_names &map, const char *name)
5766 {
5767   int (*cmp) (const char *, const char *);
5768
5769   if (current_language->la_language == language_cplus
5770       || current_language->la_language == language_fortran
5771       || current_language->la_language == language_d)
5772     {
5773       /* NAME is already canonical.  Drop any qualifiers as
5774          .debug_names does not contain any.  */
5775
5776       if (strchr (name, '(') != NULL)
5777         {
5778           gdb::unique_xmalloc_ptr<char> without_params
5779             = cp_remove_params (name);
5780
5781           if (without_params != NULL)
5782             {
5783               name = without_params.get();
5784             }
5785         }
5786     }
5787
5788   cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
5789
5790   const uint32_t full_hash = dwarf5_djb_hash (name);
5791   uint32_t namei
5792     = extract_unsigned_integer (reinterpret_cast<const gdb_byte *>
5793                                 (map.bucket_table_reordered
5794                                  + (full_hash % map.bucket_count)), 4,
5795                                 map.dwarf5_byte_order);
5796   if (namei == 0)
5797     return NULL;
5798   --namei;
5799   if (namei >= map.name_count)
5800     {
5801       complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5802                    "[in module %s]"),
5803                  namei, map.name_count,
5804                  objfile_name (map.dwarf2_per_objfile->objfile));
5805       return NULL;
5806     }
5807
5808   for (;;)
5809     {
5810       const uint32_t namei_full_hash
5811         = extract_unsigned_integer (reinterpret_cast<const gdb_byte *>
5812                                     (map.hash_table_reordered + namei), 4,
5813                                     map.dwarf5_byte_order);
5814       if (full_hash % map.bucket_count != namei_full_hash % map.bucket_count)
5815         return NULL;
5816
5817       if (full_hash == namei_full_hash)
5818         {
5819           const char *const namei_string = map.namei_to_name (namei);
5820
5821 #if 0 /* An expensive sanity check.  */
5822           if (namei_full_hash != dwarf5_djb_hash (namei_string))
5823             {
5824               complaint (_("Wrong .debug_names hash for string at index %u "
5825                            "[in module %s]"),
5826                          namei, objfile_name (dwarf2_per_objfile->objfile));
5827               return NULL;
5828             }
5829 #endif
5830
5831           if (cmp (namei_string, name) == 0)
5832             {
5833               const ULONGEST namei_entry_offs
5834                 = extract_unsigned_integer ((map.name_table_entry_offs_reordered
5835                                              + namei * map.offset_size),
5836                                             map.offset_size, map.dwarf5_byte_order);
5837               return map.entry_pool + namei_entry_offs;
5838             }
5839         }
5840
5841       ++namei;
5842       if (namei >= map.name_count)
5843         return NULL;
5844     }
5845 }
5846
5847 const gdb_byte *
5848 dw2_debug_names_iterator::find_vec_in_debug_names
5849   (const mapped_debug_names &map, uint32_t namei)
5850 {
5851   if (namei >= map.name_count)
5852     {
5853       complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5854                    "[in module %s]"),
5855                  namei, map.name_count,
5856                  objfile_name (map.dwarf2_per_objfile->objfile));
5857       return NULL;
5858     }
5859
5860   const ULONGEST namei_entry_offs
5861     = extract_unsigned_integer ((map.name_table_entry_offs_reordered
5862                                  + namei * map.offset_size),
5863                                 map.offset_size, map.dwarf5_byte_order);
5864   return map.entry_pool + namei_entry_offs;
5865 }
5866
5867 /* See dw2_debug_names_iterator.  */
5868
5869 dwarf2_per_cu_data *
5870 dw2_debug_names_iterator::next ()
5871 {
5872   if (m_addr == NULL)
5873     return NULL;
5874
5875   struct dwarf2_per_objfile *dwarf2_per_objfile = m_map.dwarf2_per_objfile;
5876   struct objfile *objfile = dwarf2_per_objfile->objfile;
5877   bfd *const abfd = objfile->obfd;
5878
5879  again:
5880
5881   unsigned int bytes_read;
5882   const ULONGEST abbrev = read_unsigned_leb128 (abfd, m_addr, &bytes_read);
5883   m_addr += bytes_read;
5884   if (abbrev == 0)
5885     return NULL;
5886
5887   const auto indexval_it = m_map.abbrev_map.find (abbrev);
5888   if (indexval_it == m_map.abbrev_map.cend ())
5889     {
5890       complaint (_("Wrong .debug_names undefined abbrev code %s "
5891                    "[in module %s]"),
5892                  pulongest (abbrev), objfile_name (objfile));
5893       return NULL;
5894     }
5895   const mapped_debug_names::index_val &indexval = indexval_it->second;
5896   bool have_is_static = false;
5897   bool is_static;
5898   dwarf2_per_cu_data *per_cu = NULL;
5899   for (const mapped_debug_names::index_val::attr &attr : indexval.attr_vec)
5900     {
5901       ULONGEST ull;
5902       switch (attr.form)
5903         {
5904         case DW_FORM_implicit_const:
5905           ull = attr.implicit_const;
5906           break;
5907         case DW_FORM_flag_present:
5908           ull = 1;
5909           break;
5910         case DW_FORM_udata:
5911           ull = read_unsigned_leb128 (abfd, m_addr, &bytes_read);
5912           m_addr += bytes_read;
5913           break;
5914         default:
5915           complaint (_("Unsupported .debug_names form %s [in module %s]"),
5916                      dwarf_form_name (attr.form),
5917                      objfile_name (objfile));
5918           return NULL;
5919         }
5920       switch (attr.dw_idx)
5921         {
5922         case DW_IDX_compile_unit:
5923           /* Don't crash on bad data.  */
5924           if (ull >= dwarf2_per_objfile->all_comp_units.size ())
5925             {
5926               complaint (_(".debug_names entry has bad CU index %s"
5927                            " [in module %s]"),
5928                          pulongest (ull),
5929                          objfile_name (dwarf2_per_objfile->objfile));
5930               continue;
5931             }
5932           per_cu = dwarf2_per_objfile->get_cutu (ull);
5933           break;
5934         case DW_IDX_type_unit:
5935           /* Don't crash on bad data.  */
5936           if (ull >= dwarf2_per_objfile->all_type_units.size ())
5937             {
5938               complaint (_(".debug_names entry has bad TU index %s"
5939                            " [in module %s]"),
5940                          pulongest (ull),
5941                          objfile_name (dwarf2_per_objfile->objfile));
5942               continue;
5943             }
5944           per_cu = &dwarf2_per_objfile->get_tu (ull)->per_cu;
5945           break;
5946         case DW_IDX_GNU_internal:
5947           if (!m_map.augmentation_is_gdb)
5948             break;
5949           have_is_static = true;
5950           is_static = true;
5951           break;
5952         case DW_IDX_GNU_external:
5953           if (!m_map.augmentation_is_gdb)
5954             break;
5955           have_is_static = true;
5956           is_static = false;
5957           break;
5958         }
5959     }
5960
5961   /* Skip if already read in.  */
5962   if (per_cu->v.quick->compunit_symtab)
5963     goto again;
5964
5965   /* Check static vs global.  */
5966   if (have_is_static)
5967     {
5968       const bool want_static = m_block_index != GLOBAL_BLOCK;
5969       if (m_want_specific_block && want_static != is_static)
5970         goto again;
5971     }
5972
5973   /* Match dw2_symtab_iter_next, symbol_kind
5974      and debug_names::psymbol_tag.  */
5975   switch (m_domain)
5976     {
5977     case VAR_DOMAIN:
5978       switch (indexval.dwarf_tag)
5979         {
5980         case DW_TAG_variable:
5981         case DW_TAG_subprogram:
5982         /* Some types are also in VAR_DOMAIN.  */
5983         case DW_TAG_typedef:
5984         case DW_TAG_structure_type:
5985           break;
5986         default:
5987           goto again;
5988         }
5989       break;
5990     case STRUCT_DOMAIN:
5991       switch (indexval.dwarf_tag)
5992         {
5993         case DW_TAG_typedef:
5994         case DW_TAG_structure_type:
5995           break;
5996         default:
5997           goto again;
5998         }
5999       break;
6000     case LABEL_DOMAIN:
6001       switch (indexval.dwarf_tag)
6002         {
6003         case 0:
6004         case DW_TAG_variable:
6005           break;
6006         default:
6007           goto again;
6008         }
6009       break;
6010     default:
6011       break;
6012     }
6013
6014   /* Match dw2_expand_symtabs_matching, symbol_kind and
6015      debug_names::psymbol_tag.  */
6016   switch (m_search)
6017     {
6018     case VARIABLES_DOMAIN:
6019       switch (indexval.dwarf_tag)
6020         {
6021         case DW_TAG_variable:
6022           break;
6023         default:
6024           goto again;
6025         }
6026       break;
6027     case FUNCTIONS_DOMAIN:
6028       switch (indexval.dwarf_tag)
6029         {
6030         case DW_TAG_subprogram:
6031           break;
6032         default:
6033           goto again;
6034         }
6035       break;
6036     case TYPES_DOMAIN:
6037       switch (indexval.dwarf_tag)
6038         {
6039         case DW_TAG_typedef:
6040         case DW_TAG_structure_type:
6041           break;
6042         default:
6043           goto again;
6044         }
6045       break;
6046     default:
6047       break;
6048     }
6049
6050   return per_cu;
6051 }
6052
6053 static struct compunit_symtab *
6054 dw2_debug_names_lookup_symbol (struct objfile *objfile, int block_index_int,
6055                                const char *name, domain_enum domain)
6056 {
6057   const block_enum block_index = static_cast<block_enum> (block_index_int);
6058   struct dwarf2_per_objfile *dwarf2_per_objfile
6059     = get_dwarf2_per_objfile (objfile);
6060
6061   const auto &mapp = dwarf2_per_objfile->debug_names_table;
6062   if (!mapp)
6063     {
6064       /* index is NULL if OBJF_READNOW.  */
6065       return NULL;
6066     }
6067   const auto &map = *mapp;
6068
6069   dw2_debug_names_iterator iter (map, true /* want_specific_block */,
6070                                  block_index, domain, name);
6071
6072   struct compunit_symtab *stab_best = NULL;
6073   struct dwarf2_per_cu_data *per_cu;
6074   while ((per_cu = iter.next ()) != NULL)
6075     {
6076       struct symbol *sym, *with_opaque = NULL;
6077       struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu, false);
6078       const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
6079       const struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
6080
6081       sym = block_find_symbol (block, name, domain,
6082                                block_find_non_opaque_type_preferred,
6083                                &with_opaque);
6084
6085       /* Some caution must be observed with overloaded functions and
6086          methods, since the index will not contain any overload
6087          information (but NAME might contain it).  */
6088
6089       if (sym != NULL
6090           && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
6091         return stab;
6092       if (with_opaque != NULL
6093           && strcmp_iw (SYMBOL_SEARCH_NAME (with_opaque), name) == 0)
6094         stab_best = stab;
6095
6096       /* Keep looking through other CUs.  */
6097     }
6098
6099   return stab_best;
6100 }
6101
6102 /* This dumps minimal information about .debug_names.  It is called
6103    via "mt print objfiles".  The gdb.dwarf2/gdb-index.exp testcase
6104    uses this to verify that .debug_names has been loaded.  */
6105
6106 static void
6107 dw2_debug_names_dump (struct objfile *objfile)
6108 {
6109   struct dwarf2_per_objfile *dwarf2_per_objfile
6110     = get_dwarf2_per_objfile (objfile);
6111
6112   gdb_assert (dwarf2_per_objfile->using_index);
6113   printf_filtered (".debug_names:");
6114   if (dwarf2_per_objfile->debug_names_table)
6115     printf_filtered (" exists\n");
6116   else
6117     printf_filtered (" faked for \"readnow\"\n");
6118   printf_filtered ("\n");
6119 }
6120
6121 static void
6122 dw2_debug_names_expand_symtabs_for_function (struct objfile *objfile,
6123                                              const char *func_name)
6124 {
6125   struct dwarf2_per_objfile *dwarf2_per_objfile
6126     = get_dwarf2_per_objfile (objfile);
6127
6128   /* dwarf2_per_objfile->debug_names_table is NULL if OBJF_READNOW.  */
6129   if (dwarf2_per_objfile->debug_names_table)
6130     {
6131       const mapped_debug_names &map = *dwarf2_per_objfile->debug_names_table;
6132
6133       /* Note: It doesn't matter what we pass for block_index here.  */
6134       dw2_debug_names_iterator iter (map, false /* want_specific_block */,
6135                                      GLOBAL_BLOCK, VAR_DOMAIN, func_name);
6136
6137       struct dwarf2_per_cu_data *per_cu;
6138       while ((per_cu = iter.next ()) != NULL)
6139         dw2_instantiate_symtab (per_cu, false);
6140     }
6141 }
6142
6143 static void
6144 dw2_debug_names_expand_symtabs_matching
6145   (struct objfile *objfile,
6146    gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
6147    const lookup_name_info &lookup_name,
6148    gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
6149    gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
6150    enum search_domain kind)
6151 {
6152   struct dwarf2_per_objfile *dwarf2_per_objfile
6153     = get_dwarf2_per_objfile (objfile);
6154
6155   /* debug_names_table is NULL if OBJF_READNOW.  */
6156   if (!dwarf2_per_objfile->debug_names_table)
6157     return;
6158
6159   dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile, file_matcher);
6160
6161   mapped_debug_names &map = *dwarf2_per_objfile->debug_names_table;
6162
6163   dw2_expand_symtabs_matching_symbol (map, lookup_name,
6164                                       symbol_matcher,
6165                                       kind, [&] (offset_type namei)
6166     {
6167       /* The name was matched, now expand corresponding CUs that were
6168          marked.  */
6169       dw2_debug_names_iterator iter (map, kind, namei);
6170
6171       struct dwarf2_per_cu_data *per_cu;
6172       while ((per_cu = iter.next ()) != NULL)
6173         dw2_expand_symtabs_matching_one (per_cu, file_matcher,
6174                                          expansion_notify);
6175     });
6176 }
6177
6178 const struct quick_symbol_functions dwarf2_debug_names_functions =
6179 {
6180   dw2_has_symbols,
6181   dw2_find_last_source_symtab,
6182   dw2_forget_cached_source_info,
6183   dw2_map_symtabs_matching_filename,
6184   dw2_debug_names_lookup_symbol,
6185   dw2_print_stats,
6186   dw2_debug_names_dump,
6187   dw2_debug_names_expand_symtabs_for_function,
6188   dw2_expand_all_symtabs,
6189   dw2_expand_symtabs_with_fullname,
6190   dw2_map_matching_symbols,
6191   dw2_debug_names_expand_symtabs_matching,
6192   dw2_find_pc_sect_compunit_symtab,
6193   NULL,
6194   dw2_map_symbol_filenames
6195 };
6196
6197 /* Get the content of the .gdb_index section of OBJ.  SECTION_OWNER should point
6198    to either a dwarf2_per_objfile or dwz_file object.  */
6199
6200 template <typename T>
6201 static gdb::array_view<const gdb_byte>
6202 get_gdb_index_contents_from_section (objfile *obj, T *section_owner)
6203 {
6204   dwarf2_section_info *section = &section_owner->gdb_index;
6205
6206   if (dwarf2_section_empty_p (section))
6207     return {};
6208
6209   /* Older elfutils strip versions could keep the section in the main
6210      executable while splitting it for the separate debug info file.  */
6211   if ((get_section_flags (section) & SEC_HAS_CONTENTS) == 0)
6212     return {};
6213
6214   dwarf2_read_section (obj, section);
6215
6216   /* dwarf2_section_info::size is a bfd_size_type, while
6217      gdb::array_view works with size_t.  On 32-bit hosts, with
6218      --enable-64-bit-bfd, bfd_size_type is a 64-bit type, while size_t
6219      is 32-bit.  So we need an explicit narrowing conversion here.
6220      This is fine, because it's impossible to allocate or mmap an
6221      array/buffer larger than what size_t can represent.  */
6222   return gdb::make_array_view (section->buffer, section->size);
6223 }
6224
6225 /* Lookup the index cache for the contents of the index associated to
6226    DWARF2_OBJ.  */
6227
6228 static gdb::array_view<const gdb_byte>
6229 get_gdb_index_contents_from_cache (objfile *obj, dwarf2_per_objfile *dwarf2_obj)
6230 {
6231   const bfd_build_id *build_id = build_id_bfd_get (obj->obfd);
6232   if (build_id == nullptr)
6233     return {};
6234
6235   return global_index_cache.lookup_gdb_index (build_id,
6236                                               &dwarf2_obj->index_cache_res);
6237 }
6238
6239 /* Same as the above, but for DWZ.  */
6240
6241 static gdb::array_view<const gdb_byte>
6242 get_gdb_index_contents_from_cache_dwz (objfile *obj, dwz_file *dwz)
6243 {
6244   const bfd_build_id *build_id = build_id_bfd_get (dwz->dwz_bfd.get ());
6245   if (build_id == nullptr)
6246     return {};
6247
6248   return global_index_cache.lookup_gdb_index (build_id, &dwz->index_cache_res);
6249 }
6250
6251 /* See symfile.h.  */
6252
6253 bool
6254 dwarf2_initialize_objfile (struct objfile *objfile, dw_index_kind *index_kind)
6255 {
6256   struct dwarf2_per_objfile *dwarf2_per_objfile
6257     = get_dwarf2_per_objfile (objfile);
6258
6259   /* If we're about to read full symbols, don't bother with the
6260      indices.  In this case we also don't care if some other debug
6261      format is making psymtabs, because they are all about to be
6262      expanded anyway.  */
6263   if ((objfile->flags & OBJF_READNOW))
6264     {
6265       dwarf2_per_objfile->using_index = 1;
6266       create_all_comp_units (dwarf2_per_objfile);
6267       create_all_type_units (dwarf2_per_objfile);
6268       dwarf2_per_objfile->quick_file_names_table
6269         = create_quick_file_names_table
6270             (dwarf2_per_objfile->all_comp_units.size ());
6271
6272       for (int i = 0; i < (dwarf2_per_objfile->all_comp_units.size ()
6273                            + dwarf2_per_objfile->all_type_units.size ()); ++i)
6274         {
6275           dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
6276
6277           per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6278                                             struct dwarf2_per_cu_quick_data);
6279         }
6280
6281       /* Return 1 so that gdb sees the "quick" functions.  However,
6282          these functions will be no-ops because we will have expanded
6283          all symtabs.  */
6284       *index_kind = dw_index_kind::GDB_INDEX;
6285       return true;
6286     }
6287
6288   if (dwarf2_read_debug_names (dwarf2_per_objfile))
6289     {
6290       *index_kind = dw_index_kind::DEBUG_NAMES;
6291       return true;
6292     }
6293
6294   if (dwarf2_read_gdb_index (dwarf2_per_objfile,
6295                              get_gdb_index_contents_from_section<struct dwarf2_per_objfile>,
6296                              get_gdb_index_contents_from_section<dwz_file>))
6297     {
6298       *index_kind = dw_index_kind::GDB_INDEX;
6299       return true;
6300     }
6301
6302   /* ... otherwise, try to find the index in the index cache.  */
6303   if (dwarf2_read_gdb_index (dwarf2_per_objfile,
6304                              get_gdb_index_contents_from_cache,
6305                              get_gdb_index_contents_from_cache_dwz))
6306     {
6307       global_index_cache.hit ();
6308       *index_kind = dw_index_kind::GDB_INDEX;
6309       return true;
6310     }
6311
6312   global_index_cache.miss ();
6313   return false;
6314 }
6315
6316 \f
6317
6318 /* Build a partial symbol table.  */
6319
6320 void
6321 dwarf2_build_psymtabs (struct objfile *objfile)
6322 {
6323   struct dwarf2_per_objfile *dwarf2_per_objfile
6324     = get_dwarf2_per_objfile (objfile);
6325
6326   init_psymbol_list (objfile, 1024);
6327
6328   try
6329     {
6330       /* This isn't really ideal: all the data we allocate on the
6331          objfile's obstack is still uselessly kept around.  However,
6332          freeing it seems unsafe.  */
6333       psymtab_discarder psymtabs (objfile);
6334       dwarf2_build_psymtabs_hard (dwarf2_per_objfile);
6335       psymtabs.keep ();
6336
6337       /* (maybe) store an index in the cache.  */
6338       global_index_cache.store (dwarf2_per_objfile);
6339     }
6340   catch (const gdb_exception_error &except)
6341     {
6342       exception_print (gdb_stderr, except);
6343     }
6344 }
6345
6346 /* Return the total length of the CU described by HEADER.  */
6347
6348 static unsigned int
6349 get_cu_length (const struct comp_unit_head *header)
6350 {
6351   return header->initial_length_size + header->length;
6352 }
6353
6354 /* Return TRUE if SECT_OFF is within CU_HEADER.  */
6355
6356 static inline bool
6357 offset_in_cu_p (const comp_unit_head *cu_header, sect_offset sect_off)
6358 {
6359   sect_offset bottom = cu_header->sect_off;
6360   sect_offset top = cu_header->sect_off + get_cu_length (cu_header);
6361
6362   return sect_off >= bottom && sect_off < top;
6363 }
6364
6365 /* Find the base address of the compilation unit for range lists and
6366    location lists.  It will normally be specified by DW_AT_low_pc.
6367    In DWARF-3 draft 4, the base address could be overridden by
6368    DW_AT_entry_pc.  It's been removed, but GCC still uses this for
6369    compilation units with discontinuous ranges.  */
6370
6371 static void
6372 dwarf2_find_base_address (struct die_info *die, struct dwarf2_cu *cu)
6373 {
6374   struct attribute *attr;
6375
6376   cu->base_known = 0;
6377   cu->base_address = 0;
6378
6379   attr = dwarf2_attr (die, DW_AT_entry_pc, cu);
6380   if (attr)
6381     {
6382       cu->base_address = attr_value_as_address (attr);
6383       cu->base_known = 1;
6384     }
6385   else
6386     {
6387       attr = dwarf2_attr (die, DW_AT_low_pc, cu);
6388       if (attr)
6389         {
6390           cu->base_address = attr_value_as_address (attr);
6391           cu->base_known = 1;
6392         }
6393     }
6394 }
6395
6396 /* Read in the comp unit header information from the debug_info at info_ptr.
6397    Use rcuh_kind::COMPILE as the default type if not known by the caller.
6398    NOTE: This leaves members offset, first_die_offset to be filled in
6399    by the caller.  */
6400
6401 static const gdb_byte *
6402 read_comp_unit_head (struct comp_unit_head *cu_header,
6403                      const gdb_byte *info_ptr,
6404                      struct dwarf2_section_info *section,
6405                      rcuh_kind section_kind)
6406 {
6407   int signed_addr;
6408   unsigned int bytes_read;
6409   const char *filename = get_section_file_name (section);
6410   bfd *abfd = get_section_bfd_owner (section);
6411
6412   cu_header->length = read_initial_length (abfd, info_ptr, &bytes_read);
6413   cu_header->initial_length_size = bytes_read;
6414   cu_header->offset_size = (bytes_read == 4) ? 4 : 8;
6415   info_ptr += bytes_read;
6416   cu_header->version = read_2_bytes (abfd, info_ptr);
6417   if (cu_header->version < 2 || cu_header->version > 5)
6418     error (_("Dwarf Error: wrong version in compilation unit header "
6419            "(is %d, should be 2, 3, 4 or 5) [in module %s]"),
6420            cu_header->version, filename);
6421   info_ptr += 2;
6422   if (cu_header->version < 5)
6423     switch (section_kind)
6424       {
6425       case rcuh_kind::COMPILE:
6426         cu_header->unit_type = DW_UT_compile;
6427         break;
6428       case rcuh_kind::TYPE:
6429         cu_header->unit_type = DW_UT_type;
6430         break;
6431       default:
6432         internal_error (__FILE__, __LINE__,
6433                         _("read_comp_unit_head: invalid section_kind"));
6434       }
6435   else
6436     {
6437       cu_header->unit_type = static_cast<enum dwarf_unit_type>
6438                                                  (read_1_byte (abfd, info_ptr));
6439       info_ptr += 1;
6440       switch (cu_header->unit_type)
6441         {
6442         case DW_UT_compile:
6443           if (section_kind != rcuh_kind::COMPILE)
6444             error (_("Dwarf Error: wrong unit_type in compilation unit header "
6445                    "(is DW_UT_compile, should be DW_UT_type) [in module %s]"),
6446                    filename);
6447           break;
6448         case DW_UT_type:
6449           section_kind = rcuh_kind::TYPE;
6450           break;
6451         default:
6452           error (_("Dwarf Error: wrong unit_type in compilation unit header "
6453                  "(is %d, should be %d or %d) [in module %s]"),
6454                  cu_header->unit_type, DW_UT_compile, DW_UT_type, filename);
6455         }
6456
6457       cu_header->addr_size = read_1_byte (abfd, info_ptr);
6458       info_ptr += 1;
6459     }
6460   cu_header->abbrev_sect_off = (sect_offset) read_offset (abfd, info_ptr,
6461                                                           cu_header,
6462                                                           &bytes_read);
6463   info_ptr += bytes_read;
6464   if (cu_header->version < 5)
6465     {
6466       cu_header->addr_size = read_1_byte (abfd, info_ptr);
6467       info_ptr += 1;
6468     }
6469   signed_addr = bfd_get_sign_extend_vma (abfd);
6470   if (signed_addr < 0)
6471     internal_error (__FILE__, __LINE__,
6472                     _("read_comp_unit_head: dwarf from non elf file"));
6473   cu_header->signed_addr_p = signed_addr;
6474
6475   if (section_kind == rcuh_kind::TYPE)
6476     {
6477       LONGEST type_offset;
6478
6479       cu_header->signature = read_8_bytes (abfd, info_ptr);
6480       info_ptr += 8;
6481
6482       type_offset = read_offset (abfd, info_ptr, cu_header, &bytes_read);
6483       info_ptr += bytes_read;
6484       cu_header->type_cu_offset_in_tu = (cu_offset) type_offset;
6485       if (to_underlying (cu_header->type_cu_offset_in_tu) != type_offset)
6486         error (_("Dwarf Error: Too big type_offset in compilation unit "
6487                "header (is %s) [in module %s]"), plongest (type_offset),
6488                filename);
6489     }
6490
6491   return info_ptr;
6492 }
6493
6494 /* Helper function that returns the proper abbrev section for
6495    THIS_CU.  */
6496
6497 static struct dwarf2_section_info *
6498 get_abbrev_section_for_cu (struct dwarf2_per_cu_data *this_cu)
6499 {
6500   struct dwarf2_section_info *abbrev;
6501   struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
6502
6503   if (this_cu->is_dwz)
6504     abbrev = &dwarf2_get_dwz_file (dwarf2_per_objfile)->abbrev;
6505   else
6506     abbrev = &dwarf2_per_objfile->abbrev;
6507
6508   return abbrev;
6509 }
6510
6511 /* Subroutine of read_and_check_comp_unit_head and
6512    read_and_check_type_unit_head to simplify them.
6513    Perform various error checking on the header.  */
6514
6515 static void
6516 error_check_comp_unit_head (struct dwarf2_per_objfile *dwarf2_per_objfile,
6517                             struct comp_unit_head *header,
6518                             struct dwarf2_section_info *section,
6519                             struct dwarf2_section_info *abbrev_section)
6520 {
6521   const char *filename = get_section_file_name (section);
6522
6523   if (to_underlying (header->abbrev_sect_off)
6524       >= dwarf2_section_size (dwarf2_per_objfile->objfile, abbrev_section))
6525     error (_("Dwarf Error: bad offset (%s) in compilation unit header "
6526            "(offset %s + 6) [in module %s]"),
6527            sect_offset_str (header->abbrev_sect_off),
6528            sect_offset_str (header->sect_off),
6529            filename);
6530
6531   /* Cast to ULONGEST to use 64-bit arithmetic when possible to
6532      avoid potential 32-bit overflow.  */
6533   if (((ULONGEST) header->sect_off + get_cu_length (header))
6534       > section->size)
6535     error (_("Dwarf Error: bad length (0x%x) in compilation unit header "
6536            "(offset %s + 0) [in module %s]"),
6537            header->length, sect_offset_str (header->sect_off),
6538            filename);
6539 }
6540
6541 /* Read in a CU/TU header and perform some basic error checking.
6542    The contents of the header are stored in HEADER.
6543    The result is a pointer to the start of the first DIE.  */
6544
6545 static const gdb_byte *
6546 read_and_check_comp_unit_head (struct dwarf2_per_objfile *dwarf2_per_objfile,
6547                                struct comp_unit_head *header,
6548                                struct dwarf2_section_info *section,
6549                                struct dwarf2_section_info *abbrev_section,
6550                                const gdb_byte *info_ptr,
6551                                rcuh_kind section_kind)
6552 {
6553   const gdb_byte *beg_of_comp_unit = info_ptr;
6554
6555   header->sect_off = (sect_offset) (beg_of_comp_unit - section->buffer);
6556
6557   info_ptr = read_comp_unit_head (header, info_ptr, section, section_kind);
6558
6559   header->first_die_cu_offset = (cu_offset) (info_ptr - beg_of_comp_unit);
6560
6561   error_check_comp_unit_head (dwarf2_per_objfile, header, section,
6562                               abbrev_section);
6563
6564   return info_ptr;
6565 }
6566
6567 /* Fetch the abbreviation table offset from a comp or type unit header.  */
6568
6569 static sect_offset
6570 read_abbrev_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
6571                     struct dwarf2_section_info *section,
6572                     sect_offset sect_off)
6573 {
6574   bfd *abfd = get_section_bfd_owner (section);
6575   const gdb_byte *info_ptr;
6576   unsigned int initial_length_size, offset_size;
6577   uint16_t version;
6578
6579   dwarf2_read_section (dwarf2_per_objfile->objfile, section);
6580   info_ptr = section->buffer + to_underlying (sect_off);
6581   read_initial_length (abfd, info_ptr, &initial_length_size);
6582   offset_size = initial_length_size == 4 ? 4 : 8;
6583   info_ptr += initial_length_size;
6584
6585   version = read_2_bytes (abfd, info_ptr);
6586   info_ptr += 2;
6587   if (version >= 5)
6588     {
6589       /* Skip unit type and address size.  */
6590       info_ptr += 2;
6591     }
6592
6593   return (sect_offset) read_offset_1 (abfd, info_ptr, offset_size);
6594 }
6595
6596 /* Allocate a new partial symtab for file named NAME and mark this new
6597    partial symtab as being an include of PST.  */
6598
6599 static void
6600 dwarf2_create_include_psymtab (const char *name, struct partial_symtab *pst,
6601                                struct objfile *objfile)
6602 {
6603   struct partial_symtab *subpst = allocate_psymtab (name, objfile);
6604
6605   if (!IS_ABSOLUTE_PATH (subpst->filename))
6606     {
6607       /* It shares objfile->objfile_obstack.  */
6608       subpst->dirname = pst->dirname;
6609     }
6610
6611   subpst->dependencies = objfile->partial_symtabs->allocate_dependencies (1);
6612   subpst->dependencies[0] = pst;
6613   subpst->number_of_dependencies = 1;
6614
6615   subpst->read_symtab = pst->read_symtab;
6616
6617   /* No private part is necessary for include psymtabs.  This property
6618      can be used to differentiate between such include psymtabs and
6619      the regular ones.  */
6620   subpst->read_symtab_private = NULL;
6621 }
6622
6623 /* Read the Line Number Program data and extract the list of files
6624    included by the source file represented by PST.  Build an include
6625    partial symtab for each of these included files.  */
6626
6627 static void
6628 dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
6629                                struct die_info *die,
6630                                struct partial_symtab *pst)
6631 {
6632   line_header_up lh;
6633   struct attribute *attr;
6634
6635   attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
6636   if (attr)
6637     lh = dwarf_decode_line_header ((sect_offset) DW_UNSND (attr), cu);
6638   if (lh == NULL)
6639     return;  /* No linetable, so no includes.  */
6640
6641   /* NOTE: pst->dirname is DW_AT_comp_dir (if present).  Also note
6642      that we pass in the raw text_low here; that is ok because we're
6643      only decoding the line table to make include partial symtabs, and
6644      so the addresses aren't really used.  */
6645   dwarf_decode_lines (lh.get (), pst->dirname, cu, pst,
6646                       pst->raw_text_low (), 1);
6647 }
6648
6649 static hashval_t
6650 hash_signatured_type (const void *item)
6651 {
6652   const struct signatured_type *sig_type
6653     = (const struct signatured_type *) item;
6654
6655   /* This drops the top 32 bits of the signature, but is ok for a hash.  */
6656   return sig_type->signature;
6657 }
6658
6659 static int
6660 eq_signatured_type (const void *item_lhs, const void *item_rhs)
6661 {
6662   const struct signatured_type *lhs = (const struct signatured_type *) item_lhs;
6663   const struct signatured_type *rhs = (const struct signatured_type *) item_rhs;
6664
6665   return lhs->signature == rhs->signature;
6666 }
6667
6668 /* Allocate a hash table for signatured types.  */
6669
6670 static htab_t
6671 allocate_signatured_type_table (struct objfile *objfile)
6672 {
6673   return htab_create_alloc_ex (41,
6674                                hash_signatured_type,
6675                                eq_signatured_type,
6676                                NULL,
6677                                &objfile->objfile_obstack,
6678                                hashtab_obstack_allocate,
6679                                dummy_obstack_deallocate);
6680 }
6681
6682 /* A helper function to add a signatured type CU to a table.  */
6683
6684 static int
6685 add_signatured_type_cu_to_table (void **slot, void *datum)
6686 {
6687   struct signatured_type *sigt = (struct signatured_type *) *slot;
6688   std::vector<signatured_type *> *all_type_units
6689     = (std::vector<signatured_type *> *) datum;
6690
6691   all_type_units->push_back (sigt);
6692
6693   return 1;
6694 }
6695
6696 /* A helper for create_debug_types_hash_table.  Read types from SECTION
6697    and fill them into TYPES_HTAB.  It will process only type units,
6698    therefore DW_UT_type.  */
6699
6700 static void
6701 create_debug_type_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
6702                               struct dwo_file *dwo_file,
6703                               dwarf2_section_info *section, htab_t &types_htab,
6704                               rcuh_kind section_kind)
6705 {
6706   struct objfile *objfile = dwarf2_per_objfile->objfile;
6707   struct dwarf2_section_info *abbrev_section;
6708   bfd *abfd;
6709   const gdb_byte *info_ptr, *end_ptr;
6710
6711   abbrev_section = (dwo_file != NULL
6712                     ? &dwo_file->sections.abbrev
6713                     : &dwarf2_per_objfile->abbrev);
6714
6715   if (dwarf_read_debug)
6716     fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
6717                         get_section_name (section),
6718                         get_section_file_name (abbrev_section));
6719
6720   dwarf2_read_section (objfile, section);
6721   info_ptr = section->buffer;
6722
6723   if (info_ptr == NULL)
6724     return;
6725
6726   /* We can't set abfd until now because the section may be empty or
6727      not present, in which case the bfd is unknown.  */
6728   abfd = get_section_bfd_owner (section);
6729
6730   /* We don't use init_cutu_and_read_dies_simple, or some such, here
6731      because we don't need to read any dies: the signature is in the
6732      header.  */
6733
6734   end_ptr = info_ptr + section->size;
6735   while (info_ptr < end_ptr)
6736     {
6737       struct signatured_type *sig_type;
6738       struct dwo_unit *dwo_tu;
6739       void **slot;
6740       const gdb_byte *ptr = info_ptr;
6741       struct comp_unit_head header;
6742       unsigned int length;
6743
6744       sect_offset sect_off = (sect_offset) (ptr - section->buffer);
6745
6746       /* Initialize it due to a false compiler warning.  */
6747       header.signature = -1;
6748       header.type_cu_offset_in_tu = (cu_offset) -1;
6749
6750       /* We need to read the type's signature in order to build the hash
6751          table, but we don't need anything else just yet.  */
6752
6753       ptr = read_and_check_comp_unit_head (dwarf2_per_objfile, &header, section,
6754                                            abbrev_section, ptr, section_kind);
6755
6756       length = get_cu_length (&header);
6757
6758       /* Skip dummy type units.  */
6759       if (ptr >= info_ptr + length
6760           || peek_abbrev_code (abfd, ptr) == 0
6761           || header.unit_type != DW_UT_type)
6762         {
6763           info_ptr += length;
6764           continue;
6765         }
6766
6767       if (types_htab == NULL)
6768         {
6769           if (dwo_file)
6770             types_htab = allocate_dwo_unit_table (objfile);
6771           else
6772             types_htab = allocate_signatured_type_table (objfile);
6773         }
6774
6775       if (dwo_file)
6776         {
6777           sig_type = NULL;
6778           dwo_tu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6779                                    struct dwo_unit);
6780           dwo_tu->dwo_file = dwo_file;
6781           dwo_tu->signature = header.signature;
6782           dwo_tu->type_offset_in_tu = header.type_cu_offset_in_tu;
6783           dwo_tu->section = section;
6784           dwo_tu->sect_off = sect_off;
6785           dwo_tu->length = length;
6786         }
6787       else
6788         {
6789           /* N.B.: type_offset is not usable if this type uses a DWO file.
6790              The real type_offset is in the DWO file.  */
6791           dwo_tu = NULL;
6792           sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6793                                      struct signatured_type);
6794           sig_type->signature = header.signature;
6795           sig_type->type_offset_in_tu = header.type_cu_offset_in_tu;
6796           sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
6797           sig_type->per_cu.is_debug_types = 1;
6798           sig_type->per_cu.section = section;
6799           sig_type->per_cu.sect_off = sect_off;
6800           sig_type->per_cu.length = length;
6801         }
6802
6803       slot = htab_find_slot (types_htab,
6804                              dwo_file ? (void*) dwo_tu : (void *) sig_type,
6805                              INSERT);
6806       gdb_assert (slot != NULL);
6807       if (*slot != NULL)
6808         {
6809           sect_offset dup_sect_off;
6810
6811           if (dwo_file)
6812             {
6813               const struct dwo_unit *dup_tu
6814                 = (const struct dwo_unit *) *slot;
6815
6816               dup_sect_off = dup_tu->sect_off;
6817             }
6818           else
6819             {
6820               const struct signatured_type *dup_tu
6821                 = (const struct signatured_type *) *slot;
6822
6823               dup_sect_off = dup_tu->per_cu.sect_off;
6824             }
6825
6826           complaint (_("debug type entry at offset %s is duplicate to"
6827                        " the entry at offset %s, signature %s"),
6828                      sect_offset_str (sect_off), sect_offset_str (dup_sect_off),
6829                      hex_string (header.signature));
6830         }
6831       *slot = dwo_file ? (void *) dwo_tu : (void *) sig_type;
6832
6833       if (dwarf_read_debug > 1)
6834         fprintf_unfiltered (gdb_stdlog, "  offset %s, signature %s\n",
6835                             sect_offset_str (sect_off),
6836                             hex_string (header.signature));
6837
6838       info_ptr += length;
6839     }
6840 }
6841
6842 /* Create the hash table of all entries in the .debug_types
6843    (or .debug_types.dwo) section(s).
6844    If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
6845    otherwise it is NULL.
6846
6847    The result is a pointer to the hash table or NULL if there are no types.
6848
6849    Note: This function processes DWO files only, not DWP files.  */
6850
6851 static void
6852 create_debug_types_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
6853                                struct dwo_file *dwo_file,
6854                                VEC (dwarf2_section_info_def) *types,
6855                                htab_t &types_htab)
6856 {
6857   int ix;
6858   struct dwarf2_section_info *section;
6859
6860   if (VEC_empty (dwarf2_section_info_def, types))
6861     return;
6862
6863   for (ix = 0;
6864        VEC_iterate (dwarf2_section_info_def, types, ix, section);
6865        ++ix)
6866     create_debug_type_hash_table (dwarf2_per_objfile, dwo_file, section,
6867                                   types_htab, rcuh_kind::TYPE);
6868 }
6869
6870 /* Create the hash table of all entries in the .debug_types section,
6871    and initialize all_type_units.
6872    The result is zero if there is an error (e.g. missing .debug_types section),
6873    otherwise non-zero.  */
6874
6875 static int
6876 create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
6877 {
6878   htab_t types_htab = NULL;
6879
6880   create_debug_type_hash_table (dwarf2_per_objfile, NULL,
6881                                 &dwarf2_per_objfile->info, types_htab,
6882                                 rcuh_kind::COMPILE);
6883   create_debug_types_hash_table (dwarf2_per_objfile, NULL,
6884                                  dwarf2_per_objfile->types, types_htab);
6885   if (types_htab == NULL)
6886     {
6887       dwarf2_per_objfile->signatured_types = NULL;
6888       return 0;
6889     }
6890
6891   dwarf2_per_objfile->signatured_types = types_htab;
6892
6893   gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
6894   dwarf2_per_objfile->all_type_units.reserve (htab_elements (types_htab));
6895
6896   htab_traverse_noresize (types_htab, add_signatured_type_cu_to_table,
6897                           &dwarf2_per_objfile->all_type_units);
6898
6899   return 1;
6900 }
6901
6902 /* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
6903    If SLOT is non-NULL, it is the entry to use in the hash table.
6904    Otherwise we find one.  */
6905
6906 static struct signatured_type *
6907 add_type_unit (struct dwarf2_per_objfile *dwarf2_per_objfile, ULONGEST sig,
6908                void **slot)
6909 {
6910   struct objfile *objfile = dwarf2_per_objfile->objfile;
6911
6912   if (dwarf2_per_objfile->all_type_units.size ()
6913       == dwarf2_per_objfile->all_type_units.capacity ())
6914     ++dwarf2_per_objfile->tu_stats.nr_all_type_units_reallocs;
6915
6916   signatured_type *sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6917                                               struct signatured_type);
6918
6919   dwarf2_per_objfile->all_type_units.push_back (sig_type);
6920   sig_type->signature = sig;
6921   sig_type->per_cu.is_debug_types = 1;
6922   if (dwarf2_per_objfile->using_index)
6923     {
6924       sig_type->per_cu.v.quick =
6925         OBSTACK_ZALLOC (&objfile->objfile_obstack,
6926                         struct dwarf2_per_cu_quick_data);
6927     }
6928
6929   if (slot == NULL)
6930     {
6931       slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
6932                              sig_type, INSERT);
6933     }
6934   gdb_assert (*slot == NULL);
6935   *slot = sig_type;
6936   /* The rest of sig_type must be filled in by the caller.  */
6937   return sig_type;
6938 }
6939
6940 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
6941    Fill in SIG_ENTRY with DWO_ENTRY.  */
6942
6943 static void
6944 fill_in_sig_entry_from_dwo_entry (struct dwarf2_per_objfile *dwarf2_per_objfile,
6945                                   struct signatured_type *sig_entry,
6946                                   struct dwo_unit *dwo_entry)
6947 {
6948   /* Make sure we're not clobbering something we don't expect to.  */
6949   gdb_assert (! sig_entry->per_cu.queued);
6950   gdb_assert (sig_entry->per_cu.cu == NULL);
6951   if (dwarf2_per_objfile->using_index)
6952     {
6953       gdb_assert (sig_entry->per_cu.v.quick != NULL);
6954       gdb_assert (sig_entry->per_cu.v.quick->compunit_symtab == NULL);
6955     }
6956   else
6957       gdb_assert (sig_entry->per_cu.v.psymtab == NULL);
6958   gdb_assert (sig_entry->signature == dwo_entry->signature);
6959   gdb_assert (to_underlying (sig_entry->type_offset_in_section) == 0);
6960   gdb_assert (sig_entry->type_unit_group == NULL);
6961   gdb_assert (sig_entry->dwo_unit == NULL);
6962
6963   sig_entry->per_cu.section = dwo_entry->section;
6964   sig_entry->per_cu.sect_off = dwo_entry->sect_off;
6965   sig_entry->per_cu.length = dwo_entry->length;
6966   sig_entry->per_cu.reading_dwo_directly = 1;
6967   sig_entry->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
6968   sig_entry->type_offset_in_tu = dwo_entry->type_offset_in_tu;
6969   sig_entry->dwo_unit = dwo_entry;
6970 }
6971
6972 /* Subroutine of lookup_signatured_type.
6973    If we haven't read the TU yet, create the signatured_type data structure
6974    for a TU to be read in directly from a DWO file, bypassing the stub.
6975    This is the "Stay in DWO Optimization": When there is no DWP file and we're
6976    using .gdb_index, then when reading a CU we want to stay in the DWO file
6977    containing that CU.  Otherwise we could end up reading several other DWO
6978    files (due to comdat folding) to process the transitive closure of all the
6979    mentioned TUs, and that can be slow.  The current DWO file will have every
6980    type signature that it needs.
6981    We only do this for .gdb_index because in the psymtab case we already have
6982    to read all the DWOs to build the type unit groups.  */
6983
6984 static struct signatured_type *
6985 lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
6986 {
6987   struct dwarf2_per_objfile *dwarf2_per_objfile
6988     = cu->per_cu->dwarf2_per_objfile;
6989   struct objfile *objfile = dwarf2_per_objfile->objfile;
6990   struct dwo_file *dwo_file;
6991   struct dwo_unit find_dwo_entry, *dwo_entry;
6992   struct signatured_type find_sig_entry, *sig_entry;
6993   void **slot;
6994
6995   gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
6996
6997   /* If TU skeletons have been removed then we may not have read in any
6998      TUs yet.  */
6999   if (dwarf2_per_objfile->signatured_types == NULL)
7000     {
7001       dwarf2_per_objfile->signatured_types
7002         = allocate_signatured_type_table (objfile);
7003     }
7004
7005   /* We only ever need to read in one copy of a signatured type.
7006      Use the global signatured_types array to do our own comdat-folding
7007      of types.  If this is the first time we're reading this TU, and
7008      the TU has an entry in .gdb_index, replace the recorded data from
7009      .gdb_index with this TU.  */
7010
7011   find_sig_entry.signature = sig;
7012   slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
7013                          &find_sig_entry, INSERT);
7014   sig_entry = (struct signatured_type *) *slot;
7015
7016   /* We can get here with the TU already read, *or* in the process of being
7017      read.  Don't reassign the global entry to point to this DWO if that's
7018      the case.  Also note that if the TU is already being read, it may not
7019      have come from a DWO, the program may be a mix of Fission-compiled
7020      code and non-Fission-compiled code.  */
7021
7022   /* Have we already tried to read this TU?
7023      Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7024      needn't exist in the global table yet).  */
7025   if (sig_entry != NULL && sig_entry->per_cu.tu_read)
7026     return sig_entry;
7027
7028   /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
7029      dwo_unit of the TU itself.  */
7030   dwo_file = cu->dwo_unit->dwo_file;
7031
7032   /* Ok, this is the first time we're reading this TU.  */
7033   if (dwo_file->tus == NULL)
7034     return NULL;
7035   find_dwo_entry.signature = sig;
7036   dwo_entry = (struct dwo_unit *) htab_find (dwo_file->tus, &find_dwo_entry);
7037   if (dwo_entry == NULL)
7038     return NULL;
7039
7040   /* If the global table doesn't have an entry for this TU, add one.  */
7041   if (sig_entry == NULL)
7042     sig_entry = add_type_unit (dwarf2_per_objfile, sig, slot);
7043
7044   fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, sig_entry, dwo_entry);
7045   sig_entry->per_cu.tu_read = 1;
7046   return sig_entry;
7047 }
7048
7049 /* Subroutine of lookup_signatured_type.
7050    Look up the type for signature SIG, and if we can't find SIG in .gdb_index
7051    then try the DWP file.  If the TU stub (skeleton) has been removed then
7052    it won't be in .gdb_index.  */
7053
7054 static struct signatured_type *
7055 lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
7056 {
7057   struct dwarf2_per_objfile *dwarf2_per_objfile
7058     = cu->per_cu->dwarf2_per_objfile;
7059   struct objfile *objfile = dwarf2_per_objfile->objfile;
7060   struct dwp_file *dwp_file = get_dwp_file (dwarf2_per_objfile);
7061   struct dwo_unit *dwo_entry;
7062   struct signatured_type find_sig_entry, *sig_entry;
7063   void **slot;
7064
7065   gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
7066   gdb_assert (dwp_file != NULL);
7067
7068   /* If TU skeletons have been removed then we may not have read in any
7069      TUs yet.  */
7070   if (dwarf2_per_objfile->signatured_types == NULL)
7071     {
7072       dwarf2_per_objfile->signatured_types
7073         = allocate_signatured_type_table (objfile);
7074     }
7075
7076   find_sig_entry.signature = sig;
7077   slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
7078                          &find_sig_entry, INSERT);
7079   sig_entry = (struct signatured_type *) *slot;
7080
7081   /* Have we already tried to read this TU?
7082      Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7083      needn't exist in the global table yet).  */
7084   if (sig_entry != NULL)
7085     return sig_entry;
7086
7087   if (dwp_file->tus == NULL)
7088     return NULL;
7089   dwo_entry = lookup_dwo_unit_in_dwp (dwarf2_per_objfile, dwp_file, NULL,
7090                                       sig, 1 /* is_debug_types */);
7091   if (dwo_entry == NULL)
7092     return NULL;
7093
7094   sig_entry = add_type_unit (dwarf2_per_objfile, sig, slot);
7095   fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, sig_entry, dwo_entry);
7096
7097   return sig_entry;
7098 }
7099
7100 /* Lookup a signature based type for DW_FORM_ref_sig8.
7101    Returns NULL if signature SIG is not present in the table.
7102    It is up to the caller to complain about this.  */
7103
7104 static struct signatured_type *
7105 lookup_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
7106 {
7107   struct dwarf2_per_objfile *dwarf2_per_objfile
7108     = cu->per_cu->dwarf2_per_objfile;
7109
7110   if (cu->dwo_unit
7111       && dwarf2_per_objfile->using_index)
7112     {
7113       /* We're in a DWO/DWP file, and we're using .gdb_index.
7114          These cases require special processing.  */
7115       if (get_dwp_file (dwarf2_per_objfile) == NULL)
7116         return lookup_dwo_signatured_type (cu, sig);
7117       else
7118         return lookup_dwp_signatured_type (cu, sig);
7119     }
7120   else
7121     {
7122       struct signatured_type find_entry, *entry;
7123
7124       if (dwarf2_per_objfile->signatured_types == NULL)
7125         return NULL;
7126       find_entry.signature = sig;
7127       entry = ((struct signatured_type *)
7128                htab_find (dwarf2_per_objfile->signatured_types, &find_entry));
7129       return entry;
7130     }
7131 }
7132 \f
7133 /* Low level DIE reading support.  */
7134
7135 /* Initialize a die_reader_specs struct from a dwarf2_cu struct.  */
7136
7137 static void
7138 init_cu_die_reader (struct die_reader_specs *reader,
7139                     struct dwarf2_cu *cu,
7140                     struct dwarf2_section_info *section,
7141                     struct dwo_file *dwo_file,
7142                     struct abbrev_table *abbrev_table)
7143 {
7144   gdb_assert (section->readin && section->buffer != NULL);
7145   reader->abfd = get_section_bfd_owner (section);
7146   reader->cu = cu;
7147   reader->dwo_file = dwo_file;
7148   reader->die_section = section;
7149   reader->buffer = section->buffer;
7150   reader->buffer_end = section->buffer + section->size;
7151   reader->comp_dir = NULL;
7152   reader->abbrev_table = abbrev_table;
7153 }
7154
7155 /* Subroutine of init_cutu_and_read_dies to simplify it.
7156    Read in the rest of a CU/TU top level DIE from DWO_UNIT.
7157    There's just a lot of work to do, and init_cutu_and_read_dies is big enough
7158    already.
7159
7160    STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
7161    from it to the DIE in the DWO.  If NULL we are skipping the stub.
7162    STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
7163    from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
7164    attribute of the referencing CU.  At most one of STUB_COMP_UNIT_DIE and
7165    STUB_COMP_DIR may be non-NULL.
7166    *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
7167    are filled in with the info of the DIE from the DWO file.
7168    *RESULT_DWO_ABBREV_TABLE will be filled in with the abbrev table allocated
7169    from the dwo.  Since *RESULT_READER references this abbrev table, it must be
7170    kept around for at least as long as *RESULT_READER.
7171
7172    The result is non-zero if a valid (non-dummy) DIE was found.  */
7173
7174 static int
7175 read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu,
7176                         struct dwo_unit *dwo_unit,
7177                         struct die_info *stub_comp_unit_die,
7178                         const char *stub_comp_dir,
7179                         struct die_reader_specs *result_reader,
7180                         const gdb_byte **result_info_ptr,
7181                         struct die_info **result_comp_unit_die,
7182                         int *result_has_children,
7183                         abbrev_table_up *result_dwo_abbrev_table)
7184 {
7185   struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7186   struct objfile *objfile = dwarf2_per_objfile->objfile;
7187   struct dwarf2_cu *cu = this_cu->cu;
7188   bfd *abfd;
7189   const gdb_byte *begin_info_ptr, *info_ptr;
7190   struct attribute *comp_dir, *stmt_list, *low_pc, *high_pc, *ranges;
7191   int i,num_extra_attrs;
7192   struct dwarf2_section_info *dwo_abbrev_section;
7193   struct attribute *attr;
7194   struct die_info *comp_unit_die;
7195
7196   /* At most one of these may be provided.  */
7197   gdb_assert ((stub_comp_unit_die != NULL) + (stub_comp_dir != NULL) <= 1);
7198
7199   /* These attributes aren't processed until later:
7200      DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
7201      DW_AT_comp_dir is used now, to find the DWO file, but it is also
7202      referenced later.  However, these attributes are found in the stub
7203      which we won't have later.  In order to not impose this complication
7204      on the rest of the code, we read them here and copy them to the
7205      DWO CU/TU die.  */
7206
7207   stmt_list = NULL;
7208   low_pc = NULL;
7209   high_pc = NULL;
7210   ranges = NULL;
7211   comp_dir = NULL;
7212
7213   if (stub_comp_unit_die != NULL)
7214     {
7215       /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
7216          DWO file.  */
7217       if (! this_cu->is_debug_types)
7218         stmt_list = dwarf2_attr (stub_comp_unit_die, DW_AT_stmt_list, cu);
7219       low_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_low_pc, cu);
7220       high_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_high_pc, cu);
7221       ranges = dwarf2_attr (stub_comp_unit_die, DW_AT_ranges, cu);
7222       comp_dir = dwarf2_attr (stub_comp_unit_die, DW_AT_comp_dir, cu);
7223
7224       /* There should be a DW_AT_addr_base attribute here (if needed).
7225          We need the value before we can process DW_FORM_GNU_addr_index
7226          or DW_FORM_addrx.  */
7227       cu->addr_base = 0;
7228       attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_addr_base, cu);
7229       if (attr)
7230         cu->addr_base = DW_UNSND (attr);
7231
7232       /* There should be a DW_AT_ranges_base attribute here (if needed).
7233          We need the value before we can process DW_AT_ranges.  */
7234       cu->ranges_base = 0;
7235       attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_ranges_base, cu);
7236       if (attr)
7237         cu->ranges_base = DW_UNSND (attr);
7238     }
7239   else if (stub_comp_dir != NULL)
7240     {
7241       /* Reconstruct the comp_dir attribute to simplify the code below.  */
7242       comp_dir = XOBNEW (&cu->comp_unit_obstack, struct attribute);
7243       comp_dir->name = DW_AT_comp_dir;
7244       comp_dir->form = DW_FORM_string;
7245       DW_STRING_IS_CANONICAL (comp_dir) = 0;
7246       DW_STRING (comp_dir) = stub_comp_dir;
7247     }
7248
7249   /* Set up for reading the DWO CU/TU.  */
7250   cu->dwo_unit = dwo_unit;
7251   dwarf2_section_info *section = dwo_unit->section;
7252   dwarf2_read_section (objfile, section);
7253   abfd = get_section_bfd_owner (section);
7254   begin_info_ptr = info_ptr = (section->buffer
7255                                + to_underlying (dwo_unit->sect_off));
7256   dwo_abbrev_section = &dwo_unit->dwo_file->sections.abbrev;
7257
7258   if (this_cu->is_debug_types)
7259     {
7260       struct signatured_type *sig_type = (struct signatured_type *) this_cu;
7261
7262       info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7263                                                 &cu->header, section,
7264                                                 dwo_abbrev_section,
7265                                                 info_ptr, rcuh_kind::TYPE);
7266       /* This is not an assert because it can be caused by bad debug info.  */
7267       if (sig_type->signature != cu->header.signature)
7268         {
7269           error (_("Dwarf Error: signature mismatch %s vs %s while reading"
7270                    " TU at offset %s [in module %s]"),
7271                  hex_string (sig_type->signature),
7272                  hex_string (cu->header.signature),
7273                  sect_offset_str (dwo_unit->sect_off),
7274                  bfd_get_filename (abfd));
7275         }
7276       gdb_assert (dwo_unit->sect_off == cu->header.sect_off);
7277       /* For DWOs coming from DWP files, we don't know the CU length
7278          nor the type's offset in the TU until now.  */
7279       dwo_unit->length = get_cu_length (&cu->header);
7280       dwo_unit->type_offset_in_tu = cu->header.type_cu_offset_in_tu;
7281
7282       /* Establish the type offset that can be used to lookup the type.
7283          For DWO files, we don't know it until now.  */
7284       sig_type->type_offset_in_section
7285         = dwo_unit->sect_off + to_underlying (dwo_unit->type_offset_in_tu);
7286     }
7287   else
7288     {
7289       info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7290                                                 &cu->header, section,
7291                                                 dwo_abbrev_section,
7292                                                 info_ptr, rcuh_kind::COMPILE);
7293       gdb_assert (dwo_unit->sect_off == cu->header.sect_off);
7294       /* For DWOs coming from DWP files, we don't know the CU length
7295          until now.  */
7296       dwo_unit->length = get_cu_length (&cu->header);
7297     }
7298
7299   *result_dwo_abbrev_table
7300     = abbrev_table_read_table (dwarf2_per_objfile, dwo_abbrev_section,
7301                                cu->header.abbrev_sect_off);
7302   init_cu_die_reader (result_reader, cu, section, dwo_unit->dwo_file,
7303                       result_dwo_abbrev_table->get ());
7304
7305   /* Read in the die, but leave space to copy over the attributes
7306      from the stub.  This has the benefit of simplifying the rest of
7307      the code - all the work to maintain the illusion of a single
7308      DW_TAG_{compile,type}_unit DIE is done here.  */
7309   num_extra_attrs = ((stmt_list != NULL)
7310                      + (low_pc != NULL)
7311                      + (high_pc != NULL)
7312                      + (ranges != NULL)
7313                      + (comp_dir != NULL));
7314   info_ptr = read_full_die_1 (result_reader, result_comp_unit_die, info_ptr,
7315                               result_has_children, num_extra_attrs);
7316
7317   /* Copy over the attributes from the stub to the DIE we just read in.  */
7318   comp_unit_die = *result_comp_unit_die;
7319   i = comp_unit_die->num_attrs;
7320   if (stmt_list != NULL)
7321     comp_unit_die->attrs[i++] = *stmt_list;
7322   if (low_pc != NULL)
7323     comp_unit_die->attrs[i++] = *low_pc;
7324   if (high_pc != NULL)
7325     comp_unit_die->attrs[i++] = *high_pc;
7326   if (ranges != NULL)
7327     comp_unit_die->attrs[i++] = *ranges;
7328   if (comp_dir != NULL)
7329     comp_unit_die->attrs[i++] = *comp_dir;
7330   comp_unit_die->num_attrs += num_extra_attrs;
7331
7332   if (dwarf_die_debug)
7333     {
7334       fprintf_unfiltered (gdb_stdlog,
7335                           "Read die from %s@0x%x of %s:\n",
7336                           get_section_name (section),
7337                           (unsigned) (begin_info_ptr - section->buffer),
7338                           bfd_get_filename (abfd));
7339       dump_die (comp_unit_die, dwarf_die_debug);
7340     }
7341
7342   /* Save the comp_dir attribute.  If there is no DWP file then we'll read
7343      TUs by skipping the stub and going directly to the entry in the DWO file.
7344      However, skipping the stub means we won't get DW_AT_comp_dir, so we have
7345      to get it via circuitous means.  Blech.  */
7346   if (comp_dir != NULL)
7347     result_reader->comp_dir = DW_STRING (comp_dir);
7348
7349   /* Skip dummy compilation units.  */
7350   if (info_ptr >= begin_info_ptr + dwo_unit->length
7351       || peek_abbrev_code (abfd, info_ptr) == 0)
7352     return 0;
7353
7354   *result_info_ptr = info_ptr;
7355   return 1;
7356 }
7357
7358 /* Subroutine of init_cutu_and_read_dies to simplify it.
7359    Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
7360    Returns NULL if the specified DWO unit cannot be found.  */
7361
7362 static struct dwo_unit *
7363 lookup_dwo_unit (struct dwarf2_per_cu_data *this_cu,
7364                  struct die_info *comp_unit_die)
7365 {
7366   struct dwarf2_cu *cu = this_cu->cu;
7367   ULONGEST signature;
7368   struct dwo_unit *dwo_unit;
7369   const char *comp_dir, *dwo_name;
7370
7371   gdb_assert (cu != NULL);
7372
7373   /* Yeah, we look dwo_name up again, but it simplifies the code.  */
7374   dwo_name = dwarf2_string_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
7375   comp_dir = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
7376
7377   if (this_cu->is_debug_types)
7378     {
7379       struct signatured_type *sig_type;
7380
7381       /* Since this_cu is the first member of struct signatured_type,
7382          we can go from a pointer to one to a pointer to the other.  */
7383       sig_type = (struct signatured_type *) this_cu;
7384       signature = sig_type->signature;
7385       dwo_unit = lookup_dwo_type_unit (sig_type, dwo_name, comp_dir);
7386     }
7387   else
7388     {
7389       struct attribute *attr;
7390
7391       attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
7392       if (! attr)
7393         error (_("Dwarf Error: missing dwo_id for dwo_name %s"
7394                  " [in module %s]"),
7395                dwo_name, objfile_name (this_cu->dwarf2_per_objfile->objfile));
7396       signature = DW_UNSND (attr);
7397       dwo_unit = lookup_dwo_comp_unit (this_cu, dwo_name, comp_dir,
7398                                        signature);
7399     }
7400
7401   return dwo_unit;
7402 }
7403
7404 /* Subroutine of init_cutu_and_read_dies to simplify it.
7405    See it for a description of the parameters.
7406    Read a TU directly from a DWO file, bypassing the stub.  */
7407
7408 static void
7409 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data *this_cu,
7410                            int use_existing_cu, int keep,
7411                            die_reader_func_ftype *die_reader_func,
7412                            void *data)
7413 {
7414   std::unique_ptr<dwarf2_cu> new_cu;
7415   struct signatured_type *sig_type;
7416   struct die_reader_specs reader;
7417   const gdb_byte *info_ptr;
7418   struct die_info *comp_unit_die;
7419   int has_children;
7420   struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7421
7422   /* Verify we can do the following downcast, and that we have the
7423      data we need.  */
7424   gdb_assert (this_cu->is_debug_types && this_cu->reading_dwo_directly);
7425   sig_type = (struct signatured_type *) this_cu;
7426   gdb_assert (sig_type->dwo_unit != NULL);
7427
7428   if (use_existing_cu && this_cu->cu != NULL)
7429     {
7430       gdb_assert (this_cu->cu->dwo_unit == sig_type->dwo_unit);
7431       /* There's no need to do the rereading_dwo_cu handling that
7432          init_cutu_and_read_dies does since we don't read the stub.  */
7433     }
7434   else
7435     {
7436       /* If !use_existing_cu, this_cu->cu must be NULL.  */
7437       gdb_assert (this_cu->cu == NULL);
7438       new_cu.reset (new dwarf2_cu (this_cu));
7439     }
7440
7441   /* A future optimization, if needed, would be to use an existing
7442      abbrev table.  When reading DWOs with skeletonless TUs, all the TUs
7443      could share abbrev tables.  */
7444
7445   /* The abbreviation table used by READER, this must live at least as long as
7446      READER.  */
7447   abbrev_table_up dwo_abbrev_table;
7448
7449   if (read_cutu_die_from_dwo (this_cu, sig_type->dwo_unit,
7450                               NULL /* stub_comp_unit_die */,
7451                               sig_type->dwo_unit->dwo_file->comp_dir,
7452                               &reader, &info_ptr,
7453                               &comp_unit_die, &has_children,
7454                               &dwo_abbrev_table) == 0)
7455     {
7456       /* Dummy die.  */
7457       return;
7458     }
7459
7460   /* All the "real" work is done here.  */
7461   die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7462
7463   /* This duplicates the code in init_cutu_and_read_dies,
7464      but the alternative is making the latter more complex.
7465      This function is only for the special case of using DWO files directly:
7466      no point in overly complicating the general case just to handle this.  */
7467   if (new_cu != NULL && keep)
7468     {
7469       /* Link this CU into read_in_chain.  */
7470       this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
7471       dwarf2_per_objfile->read_in_chain = this_cu;
7472       /* The chain owns it now.  */
7473       new_cu.release ();
7474     }
7475 }
7476
7477 /* Initialize a CU (or TU) and read its DIEs.
7478    If the CU defers to a DWO file, read the DWO file as well.
7479
7480    ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
7481    Otherwise the table specified in the comp unit header is read in and used.
7482    This is an optimization for when we already have the abbrev table.
7483
7484    If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
7485    Otherwise, a new CU is allocated with xmalloc.
7486
7487    If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
7488    read_in_chain.  Otherwise the dwarf2_cu data is freed at the end.
7489
7490    WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7491    linker) then DIE_READER_FUNC will not get called.  */
7492
7493 static void
7494 init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu,
7495                          struct abbrev_table *abbrev_table,
7496                          int use_existing_cu, int keep,
7497                          bool skip_partial,
7498                          die_reader_func_ftype *die_reader_func,
7499                          void *data)
7500 {
7501   struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7502   struct objfile *objfile = dwarf2_per_objfile->objfile;
7503   struct dwarf2_section_info *section = this_cu->section;
7504   bfd *abfd = get_section_bfd_owner (section);
7505   struct dwarf2_cu *cu;
7506   const gdb_byte *begin_info_ptr, *info_ptr;
7507   struct die_reader_specs reader;
7508   struct die_info *comp_unit_die;
7509   int has_children;
7510   struct attribute *attr;
7511   struct signatured_type *sig_type = NULL;
7512   struct dwarf2_section_info *abbrev_section;
7513   /* Non-zero if CU currently points to a DWO file and we need to
7514      reread it.  When this happens we need to reread the skeleton die
7515      before we can reread the DWO file (this only applies to CUs, not TUs).  */
7516   int rereading_dwo_cu = 0;
7517
7518   if (dwarf_die_debug)
7519     fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset %s\n",
7520                         this_cu->is_debug_types ? "type" : "comp",
7521                         sect_offset_str (this_cu->sect_off));
7522
7523   if (use_existing_cu)
7524     gdb_assert (keep);
7525
7526   /* If we're reading a TU directly from a DWO file, including a virtual DWO
7527      file (instead of going through the stub), short-circuit all of this.  */
7528   if (this_cu->reading_dwo_directly)
7529     {
7530       /* Narrow down the scope of possibilities to have to understand.  */
7531       gdb_assert (this_cu->is_debug_types);
7532       gdb_assert (abbrev_table == NULL);
7533       init_tu_and_read_dwo_dies (this_cu, use_existing_cu, keep,
7534                                  die_reader_func, data);
7535       return;
7536     }
7537
7538   /* This is cheap if the section is already read in.  */
7539   dwarf2_read_section (objfile, section);
7540
7541   begin_info_ptr = info_ptr = section->buffer + to_underlying (this_cu->sect_off);
7542
7543   abbrev_section = get_abbrev_section_for_cu (this_cu);
7544
7545   std::unique_ptr<dwarf2_cu> new_cu;
7546   if (use_existing_cu && this_cu->cu != NULL)
7547     {
7548       cu = this_cu->cu;
7549       /* If this CU is from a DWO file we need to start over, we need to
7550          refetch the attributes from the skeleton CU.
7551          This could be optimized by retrieving those attributes from when we
7552          were here the first time: the previous comp_unit_die was stored in
7553          comp_unit_obstack.  But there's no data yet that we need this
7554          optimization.  */
7555       if (cu->dwo_unit != NULL)
7556         rereading_dwo_cu = 1;
7557     }
7558   else
7559     {
7560       /* If !use_existing_cu, this_cu->cu must be NULL.  */
7561       gdb_assert (this_cu->cu == NULL);
7562       new_cu.reset (new dwarf2_cu (this_cu));
7563       cu = new_cu.get ();
7564     }
7565
7566   /* Get the header.  */
7567   if (to_underlying (cu->header.first_die_cu_offset) != 0 && !rereading_dwo_cu)
7568     {
7569       /* We already have the header, there's no need to read it in again.  */
7570       info_ptr += to_underlying (cu->header.first_die_cu_offset);
7571     }
7572   else
7573     {
7574       if (this_cu->is_debug_types)
7575         {
7576           info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7577                                                     &cu->header, section,
7578                                                     abbrev_section, info_ptr,
7579                                                     rcuh_kind::TYPE);
7580
7581           /* Since per_cu is the first member of struct signatured_type,
7582              we can go from a pointer to one to a pointer to the other.  */
7583           sig_type = (struct signatured_type *) this_cu;
7584           gdb_assert (sig_type->signature == cu->header.signature);
7585           gdb_assert (sig_type->type_offset_in_tu
7586                       == cu->header.type_cu_offset_in_tu);
7587           gdb_assert (this_cu->sect_off == cu->header.sect_off);
7588
7589           /* LENGTH has not been set yet for type units if we're
7590              using .gdb_index.  */
7591           this_cu->length = get_cu_length (&cu->header);
7592
7593           /* Establish the type offset that can be used to lookup the type.  */
7594           sig_type->type_offset_in_section =
7595             this_cu->sect_off + to_underlying (sig_type->type_offset_in_tu);
7596
7597           this_cu->dwarf_version = cu->header.version;
7598         }
7599       else
7600         {
7601           info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7602                                                     &cu->header, section,
7603                                                     abbrev_section,
7604                                                     info_ptr,
7605                                                     rcuh_kind::COMPILE);
7606
7607           gdb_assert (this_cu->sect_off == cu->header.sect_off);
7608           gdb_assert (this_cu->length == get_cu_length (&cu->header));
7609           this_cu->dwarf_version = cu->header.version;
7610         }
7611     }
7612
7613   /* Skip dummy compilation units.  */
7614   if (info_ptr >= begin_info_ptr + this_cu->length
7615       || peek_abbrev_code (abfd, info_ptr) == 0)
7616     return;
7617
7618   /* If we don't have them yet, read the abbrevs for this compilation unit.
7619      And if we need to read them now, make sure they're freed when we're
7620      done (own the table through ABBREV_TABLE_HOLDER).  */
7621   abbrev_table_up abbrev_table_holder;
7622   if (abbrev_table != NULL)
7623     gdb_assert (cu->header.abbrev_sect_off == abbrev_table->sect_off);
7624   else
7625     {
7626       abbrev_table_holder
7627         = abbrev_table_read_table (dwarf2_per_objfile, abbrev_section,
7628                                    cu->header.abbrev_sect_off);
7629       abbrev_table = abbrev_table_holder.get ();
7630     }
7631
7632   /* Read the top level CU/TU die.  */
7633   init_cu_die_reader (&reader, cu, section, NULL, abbrev_table);
7634   info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
7635
7636   if (skip_partial && comp_unit_die->tag == DW_TAG_partial_unit)
7637     return;
7638
7639   /* If we are in a DWO stub, process it and then read in the "real" CU/TU
7640      from the DWO file.  read_cutu_die_from_dwo will allocate the abbreviation
7641      table from the DWO file and pass the ownership over to us.  It will be
7642      referenced from READER, so we must make sure to free it after we're done
7643      with READER.
7644
7645      Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
7646      DWO CU, that this test will fail (the attribute will not be present).  */
7647   attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
7648   abbrev_table_up dwo_abbrev_table;
7649   if (attr)
7650     {
7651       struct dwo_unit *dwo_unit;
7652       struct die_info *dwo_comp_unit_die;
7653
7654       if (has_children)
7655         {
7656           complaint (_("compilation unit with DW_AT_GNU_dwo_name"
7657                        " has children (offset %s) [in module %s]"),
7658                      sect_offset_str (this_cu->sect_off),
7659                      bfd_get_filename (abfd));
7660         }
7661       dwo_unit = lookup_dwo_unit (this_cu, comp_unit_die);
7662       if (dwo_unit != NULL)
7663         {
7664           if (read_cutu_die_from_dwo (this_cu, dwo_unit,
7665                                       comp_unit_die, NULL,
7666                                       &reader, &info_ptr,
7667                                       &dwo_comp_unit_die, &has_children,
7668                                       &dwo_abbrev_table) == 0)
7669             {
7670               /* Dummy die.  */
7671               return;
7672             }
7673           comp_unit_die = dwo_comp_unit_die;
7674         }
7675       else
7676         {
7677           /* Yikes, we couldn't find the rest of the DIE, we only have
7678              the stub.  A complaint has already been logged.  There's
7679              not much more we can do except pass on the stub DIE to
7680              die_reader_func.  We don't want to throw an error on bad
7681              debug info.  */
7682         }
7683     }
7684
7685   /* All of the above is setup for this call.  Yikes.  */
7686   die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7687
7688   /* Done, clean up.  */
7689   if (new_cu != NULL && keep)
7690     {
7691       /* Link this CU into read_in_chain.  */
7692       this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
7693       dwarf2_per_objfile->read_in_chain = this_cu;
7694       /* The chain owns it now.  */
7695       new_cu.release ();
7696     }
7697 }
7698
7699 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
7700    DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
7701    to have already done the lookup to find the DWO file).
7702
7703    The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
7704    THIS_CU->is_debug_types, but nothing else.
7705
7706    We fill in THIS_CU->length.
7707
7708    WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7709    linker) then DIE_READER_FUNC will not get called.
7710
7711    THIS_CU->cu is always freed when done.
7712    This is done in order to not leave THIS_CU->cu in a state where we have
7713    to care whether it refers to the "main" CU or the DWO CU.  */
7714
7715 static void
7716 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data *this_cu,
7717                                    struct dwo_file *dwo_file,
7718                                    die_reader_func_ftype *die_reader_func,
7719                                    void *data)
7720 {
7721   struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7722   struct objfile *objfile = dwarf2_per_objfile->objfile;
7723   struct dwarf2_section_info *section = this_cu->section;
7724   bfd *abfd = get_section_bfd_owner (section);
7725   struct dwarf2_section_info *abbrev_section;
7726   const gdb_byte *begin_info_ptr, *info_ptr;
7727   struct die_reader_specs reader;
7728   struct die_info *comp_unit_die;
7729   int has_children;
7730
7731   if (dwarf_die_debug)
7732     fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset %s\n",
7733                         this_cu->is_debug_types ? "type" : "comp",
7734                         sect_offset_str (this_cu->sect_off));
7735
7736   gdb_assert (this_cu->cu == NULL);
7737
7738   abbrev_section = (dwo_file != NULL
7739                     ? &dwo_file->sections.abbrev
7740                     : get_abbrev_section_for_cu (this_cu));
7741
7742   /* This is cheap if the section is already read in.  */
7743   dwarf2_read_section (objfile, section);
7744
7745   struct dwarf2_cu cu (this_cu);
7746
7747   begin_info_ptr = info_ptr = section->buffer + to_underlying (this_cu->sect_off);
7748   info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7749                                             &cu.header, section,
7750                                             abbrev_section, info_ptr,
7751                                             (this_cu->is_debug_types
7752                                              ? rcuh_kind::TYPE
7753                                              : rcuh_kind::COMPILE));
7754
7755   this_cu->length = get_cu_length (&cu.header);
7756
7757   /* Skip dummy compilation units.  */
7758   if (info_ptr >= begin_info_ptr + this_cu->length
7759       || peek_abbrev_code (abfd, info_ptr) == 0)
7760     return;
7761
7762   abbrev_table_up abbrev_table
7763     = abbrev_table_read_table (dwarf2_per_objfile, abbrev_section,
7764                                cu.header.abbrev_sect_off);
7765
7766   init_cu_die_reader (&reader, &cu, section, dwo_file, abbrev_table.get ());
7767   info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
7768
7769   die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7770 }
7771
7772 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
7773    does not lookup the specified DWO file.
7774    This cannot be used to read DWO files.
7775
7776    THIS_CU->cu is always freed when done.
7777    This is done in order to not leave THIS_CU->cu in a state where we have
7778    to care whether it refers to the "main" CU or the DWO CU.
7779    We can revisit this if the data shows there's a performance issue.  */
7780
7781 static void
7782 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data *this_cu,
7783                                 die_reader_func_ftype *die_reader_func,
7784                                 void *data)
7785 {
7786   init_cutu_and_read_dies_no_follow (this_cu, NULL, die_reader_func, data);
7787 }
7788 \f
7789 /* Type Unit Groups.
7790
7791    Type Unit Groups are a way to collapse the set of all TUs (type units) into
7792    a more manageable set.  The grouping is done by DW_AT_stmt_list entry
7793    so that all types coming from the same compilation (.o file) are grouped
7794    together.  A future step could be to put the types in the same symtab as
7795    the CU the types ultimately came from.  */
7796
7797 static hashval_t
7798 hash_type_unit_group (const void *item)
7799 {
7800   const struct type_unit_group *tu_group
7801     = (const struct type_unit_group *) item;
7802
7803   return hash_stmt_list_entry (&tu_group->hash);
7804 }
7805
7806 static int
7807 eq_type_unit_group (const void *item_lhs, const void *item_rhs)
7808 {
7809   const struct type_unit_group *lhs = (const struct type_unit_group *) item_lhs;
7810   const struct type_unit_group *rhs = (const struct type_unit_group *) item_rhs;
7811
7812   return eq_stmt_list_entry (&lhs->hash, &rhs->hash);
7813 }
7814
7815 /* Allocate a hash table for type unit groups.  */
7816
7817 static htab_t
7818 allocate_type_unit_groups_table (struct objfile *objfile)
7819 {
7820   return htab_create_alloc_ex (3,
7821                                hash_type_unit_group,
7822                                eq_type_unit_group,
7823                                NULL,
7824                                &objfile->objfile_obstack,
7825                                hashtab_obstack_allocate,
7826                                dummy_obstack_deallocate);
7827 }
7828
7829 /* Type units that don't have DW_AT_stmt_list are grouped into their own
7830    partial symtabs.  We combine several TUs per psymtab to not let the size
7831    of any one psymtab grow too big.  */
7832 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
7833 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
7834
7835 /* Helper routine for get_type_unit_group.
7836    Create the type_unit_group object used to hold one or more TUs.  */
7837
7838 static struct type_unit_group *
7839 create_type_unit_group (struct dwarf2_cu *cu, sect_offset line_offset_struct)
7840 {
7841   struct dwarf2_per_objfile *dwarf2_per_objfile
7842     = cu->per_cu->dwarf2_per_objfile;
7843   struct objfile *objfile = dwarf2_per_objfile->objfile;
7844   struct dwarf2_per_cu_data *per_cu;
7845   struct type_unit_group *tu_group;
7846
7847   tu_group = OBSTACK_ZALLOC (&objfile->objfile_obstack,
7848                              struct type_unit_group);
7849   per_cu = &tu_group->per_cu;
7850   per_cu->dwarf2_per_objfile = dwarf2_per_objfile;
7851
7852   if (dwarf2_per_objfile->using_index)
7853     {
7854       per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
7855                                         struct dwarf2_per_cu_quick_data);
7856     }
7857   else
7858     {
7859       unsigned int line_offset = to_underlying (line_offset_struct);
7860       struct partial_symtab *pst;
7861       std::string name;
7862
7863       /* Give the symtab a useful name for debug purposes.  */
7864       if ((line_offset & NO_STMT_LIST_TYPE_UNIT_PSYMTAB) != 0)
7865         name = string_printf ("<type_units_%d>",
7866                               (line_offset & ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB));
7867       else
7868         name = string_printf ("<type_units_at_0x%x>", line_offset);
7869
7870       pst = create_partial_symtab (per_cu, name.c_str ());
7871       pst->anonymous = 1;
7872     }
7873
7874   tu_group->hash.dwo_unit = cu->dwo_unit;
7875   tu_group->hash.line_sect_off = line_offset_struct;
7876
7877   return tu_group;
7878 }
7879
7880 /* Look up the type_unit_group for type unit CU, and create it if necessary.
7881    STMT_LIST is a DW_AT_stmt_list attribute.  */
7882
7883 static struct type_unit_group *
7884 get_type_unit_group (struct dwarf2_cu *cu, const struct attribute *stmt_list)
7885 {
7886   struct dwarf2_per_objfile *dwarf2_per_objfile
7887     = cu->per_cu->dwarf2_per_objfile;
7888   struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
7889   struct type_unit_group *tu_group;
7890   void **slot;
7891   unsigned int line_offset;
7892   struct type_unit_group type_unit_group_for_lookup;
7893
7894   if (dwarf2_per_objfile->type_unit_groups == NULL)
7895     {
7896       dwarf2_per_objfile->type_unit_groups =
7897         allocate_type_unit_groups_table (dwarf2_per_objfile->objfile);
7898     }
7899
7900   /* Do we need to create a new group, or can we use an existing one?  */
7901
7902   if (stmt_list)
7903     {
7904       line_offset = DW_UNSND (stmt_list);
7905       ++tu_stats->nr_symtab_sharers;
7906     }
7907   else
7908     {
7909       /* Ugh, no stmt_list.  Rare, but we have to handle it.
7910          We can do various things here like create one group per TU or
7911          spread them over multiple groups to split up the expansion work.
7912          To avoid worst case scenarios (too many groups or too large groups)
7913          we, umm, group them in bunches.  */
7914       line_offset = (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
7915                      | (tu_stats->nr_stmt_less_type_units
7916                         / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE));
7917       ++tu_stats->nr_stmt_less_type_units;
7918     }
7919
7920   type_unit_group_for_lookup.hash.dwo_unit = cu->dwo_unit;
7921   type_unit_group_for_lookup.hash.line_sect_off = (sect_offset) line_offset;
7922   slot = htab_find_slot (dwarf2_per_objfile->type_unit_groups,
7923                          &type_unit_group_for_lookup, INSERT);
7924   if (*slot != NULL)
7925     {
7926       tu_group = (struct type_unit_group *) *slot;
7927       gdb_assert (tu_group != NULL);
7928     }
7929   else
7930     {
7931       sect_offset line_offset_struct = (sect_offset) line_offset;
7932       tu_group = create_type_unit_group (cu, line_offset_struct);
7933       *slot = tu_group;
7934       ++tu_stats->nr_symtabs;
7935     }
7936
7937   return tu_group;
7938 }
7939 \f
7940 /* Partial symbol tables.  */
7941
7942 /* Create a psymtab named NAME and assign it to PER_CU.
7943
7944    The caller must fill in the following details:
7945    dirname, textlow, texthigh.  */
7946
7947 static struct partial_symtab *
7948 create_partial_symtab (struct dwarf2_per_cu_data *per_cu, const char *name)
7949 {
7950   struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
7951   struct partial_symtab *pst;
7952
7953   pst = start_psymtab_common (objfile, name, 0);
7954
7955   pst->psymtabs_addrmap_supported = 1;
7956
7957   /* This is the glue that links PST into GDB's symbol API.  */
7958   pst->read_symtab_private = per_cu;
7959   pst->read_symtab = dwarf2_read_symtab;
7960   per_cu->v.psymtab = pst;
7961
7962   return pst;
7963 }
7964
7965 /* The DATA object passed to process_psymtab_comp_unit_reader has this
7966    type.  */
7967
7968 struct process_psymtab_comp_unit_data
7969 {
7970   /* True if we are reading a DW_TAG_partial_unit.  */
7971
7972   int want_partial_unit;
7973
7974   /* The "pretend" language that is used if the CU doesn't declare a
7975      language.  */
7976
7977   enum language pretend_language;
7978 };
7979
7980 /* die_reader_func for process_psymtab_comp_unit.  */
7981
7982 static void
7983 process_psymtab_comp_unit_reader (const struct die_reader_specs *reader,
7984                                   const gdb_byte *info_ptr,
7985                                   struct die_info *comp_unit_die,
7986                                   int has_children,
7987                                   void *data)
7988 {
7989   struct dwarf2_cu *cu = reader->cu;
7990   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
7991   struct gdbarch *gdbarch = get_objfile_arch (objfile);
7992   struct dwarf2_per_cu_data *per_cu = cu->per_cu;
7993   CORE_ADDR baseaddr;
7994   CORE_ADDR best_lowpc = 0, best_highpc = 0;
7995   struct partial_symtab *pst;
7996   enum pc_bounds_kind cu_bounds_kind;
7997   const char *filename;
7998   struct process_psymtab_comp_unit_data *info
7999     = (struct process_psymtab_comp_unit_data *) data;
8000
8001   if (comp_unit_die->tag == DW_TAG_partial_unit && !info->want_partial_unit)
8002     return;
8003
8004   gdb_assert (! per_cu->is_debug_types);
8005
8006   prepare_one_comp_unit (cu, comp_unit_die, info->pretend_language);
8007
8008   /* Allocate a new partial symbol table structure.  */
8009   filename = dwarf2_string_attr (comp_unit_die, DW_AT_name, cu);
8010   if (filename == NULL)
8011     filename = "";
8012
8013   pst = create_partial_symtab (per_cu, filename);
8014
8015   /* This must be done before calling dwarf2_build_include_psymtabs.  */
8016   pst->dirname = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
8017
8018   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
8019
8020   dwarf2_find_base_address (comp_unit_die, cu);
8021
8022   /* Possibly set the default values of LOWPC and HIGHPC from
8023      `DW_AT_ranges'.  */
8024   cu_bounds_kind = dwarf2_get_pc_bounds (comp_unit_die, &best_lowpc,
8025                                          &best_highpc, cu, pst);
8026   if (cu_bounds_kind == PC_BOUNDS_HIGH_LOW && best_lowpc < best_highpc)
8027     {
8028       CORE_ADDR low
8029         = (gdbarch_adjust_dwarf2_addr (gdbarch, best_lowpc + baseaddr)
8030            - baseaddr);
8031       CORE_ADDR high
8032         = (gdbarch_adjust_dwarf2_addr (gdbarch, best_highpc + baseaddr)
8033            - baseaddr - 1);
8034       /* Store the contiguous range if it is not empty; it can be
8035          empty for CUs with no code.  */
8036       addrmap_set_empty (objfile->partial_symtabs->psymtabs_addrmap,
8037                          low, high, pst);
8038     }
8039
8040   /* Check if comp unit has_children.
8041      If so, read the rest of the partial symbols from this comp unit.
8042      If not, there's no more debug_info for this comp unit.  */
8043   if (has_children)
8044     {
8045       struct partial_die_info *first_die;
8046       CORE_ADDR lowpc, highpc;
8047
8048       lowpc = ((CORE_ADDR) -1);
8049       highpc = ((CORE_ADDR) 0);
8050
8051       first_die = load_partial_dies (reader, info_ptr, 1);
8052
8053       scan_partial_symbols (first_die, &lowpc, &highpc,
8054                             cu_bounds_kind <= PC_BOUNDS_INVALID, cu);
8055
8056       /* If we didn't find a lowpc, set it to highpc to avoid
8057          complaints from `maint check'.  */
8058       if (lowpc == ((CORE_ADDR) -1))
8059         lowpc = highpc;
8060
8061       /* If the compilation unit didn't have an explicit address range,
8062          then use the information extracted from its child dies.  */
8063       if (cu_bounds_kind <= PC_BOUNDS_INVALID)
8064         {
8065           best_lowpc = lowpc;
8066           best_highpc = highpc;
8067         }
8068     }
8069   pst->set_text_low (gdbarch_adjust_dwarf2_addr (gdbarch,
8070                                                  best_lowpc + baseaddr)
8071                      - baseaddr);
8072   pst->set_text_high (gdbarch_adjust_dwarf2_addr (gdbarch,
8073                                                   best_highpc + baseaddr)
8074                       - baseaddr);
8075
8076   end_psymtab_common (objfile, pst);
8077
8078   if (!VEC_empty (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs))
8079     {
8080       int i;
8081       int len = VEC_length (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
8082       struct dwarf2_per_cu_data *iter;
8083
8084       /* Fill in 'dependencies' here; we fill in 'users' in a
8085          post-pass.  */
8086       pst->number_of_dependencies = len;
8087       pst->dependencies
8088         = objfile->partial_symtabs->allocate_dependencies (len);
8089       for (i = 0;
8090            VEC_iterate (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
8091                         i, iter);
8092            ++i)
8093         pst->dependencies[i] = iter->v.psymtab;
8094
8095       VEC_free (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
8096     }
8097
8098   /* Get the list of files included in the current compilation unit,
8099      and build a psymtab for each of them.  */
8100   dwarf2_build_include_psymtabs (cu, comp_unit_die, pst);
8101
8102   if (dwarf_read_debug)
8103     fprintf_unfiltered (gdb_stdlog,
8104                         "Psymtab for %s unit @%s: %s - %s"
8105                         ", %d global, %d static syms\n",
8106                         per_cu->is_debug_types ? "type" : "comp",
8107                         sect_offset_str (per_cu->sect_off),
8108                         paddress (gdbarch, pst->text_low (objfile)),
8109                         paddress (gdbarch, pst->text_high (objfile)),
8110                         pst->n_global_syms, pst->n_static_syms);
8111 }
8112
8113 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8114    Process compilation unit THIS_CU for a psymtab.  */
8115
8116 static void
8117 process_psymtab_comp_unit (struct dwarf2_per_cu_data *this_cu,
8118                            int want_partial_unit,
8119                            enum language pretend_language)
8120 {
8121   /* If this compilation unit was already read in, free the
8122      cached copy in order to read it in again.  This is
8123      necessary because we skipped some symbols when we first
8124      read in the compilation unit (see load_partial_dies).
8125      This problem could be avoided, but the benefit is unclear.  */
8126   if (this_cu->cu != NULL)
8127     free_one_cached_comp_unit (this_cu);
8128
8129   if (this_cu->is_debug_types)
8130     init_cutu_and_read_dies (this_cu, NULL, 0, 0, false,
8131                              build_type_psymtabs_reader, NULL);
8132   else
8133     {
8134       process_psymtab_comp_unit_data info;
8135       info.want_partial_unit = want_partial_unit;
8136       info.pretend_language = pretend_language;
8137       init_cutu_and_read_dies (this_cu, NULL, 0, 0, false,
8138                                process_psymtab_comp_unit_reader, &info);
8139     }
8140
8141   /* Age out any secondary CUs.  */
8142   age_cached_comp_units (this_cu->dwarf2_per_objfile);
8143 }
8144
8145 /* Reader function for build_type_psymtabs.  */
8146
8147 static void
8148 build_type_psymtabs_reader (const struct die_reader_specs *reader,
8149                             const gdb_byte *info_ptr,
8150                             struct die_info *type_unit_die,
8151                             int has_children,
8152                             void *data)
8153 {
8154   struct dwarf2_per_objfile *dwarf2_per_objfile
8155     = reader->cu->per_cu->dwarf2_per_objfile;
8156   struct objfile *objfile = dwarf2_per_objfile->objfile;
8157   struct dwarf2_cu *cu = reader->cu;
8158   struct dwarf2_per_cu_data *per_cu = cu->per_cu;
8159   struct signatured_type *sig_type;
8160   struct type_unit_group *tu_group;
8161   struct attribute *attr;
8162   struct partial_die_info *first_die;
8163   CORE_ADDR lowpc, highpc;
8164   struct partial_symtab *pst;
8165
8166   gdb_assert (data == NULL);
8167   gdb_assert (per_cu->is_debug_types);
8168   sig_type = (struct signatured_type *) per_cu;
8169
8170   if (! has_children)
8171     return;
8172
8173   attr = dwarf2_attr_no_follow (type_unit_die, DW_AT_stmt_list);
8174   tu_group = get_type_unit_group (cu, attr);
8175
8176   VEC_safe_push (sig_type_ptr, tu_group->tus, sig_type);
8177
8178   prepare_one_comp_unit (cu, type_unit_die, language_minimal);
8179   pst = create_partial_symtab (per_cu, "");
8180   pst->anonymous = 1;
8181
8182   first_die = load_partial_dies (reader, info_ptr, 1);
8183
8184   lowpc = (CORE_ADDR) -1;
8185   highpc = (CORE_ADDR) 0;
8186   scan_partial_symbols (first_die, &lowpc, &highpc, 0, cu);
8187
8188   end_psymtab_common (objfile, pst);
8189 }
8190
8191 /* Struct used to sort TUs by their abbreviation table offset.  */
8192
8193 struct tu_abbrev_offset
8194 {
8195   tu_abbrev_offset (signatured_type *sig_type_, sect_offset abbrev_offset_)
8196   : sig_type (sig_type_), abbrev_offset (abbrev_offset_)
8197   {}
8198
8199   signatured_type *sig_type;
8200   sect_offset abbrev_offset;
8201 };
8202
8203 /* Helper routine for build_type_psymtabs_1, passed to std::sort.  */
8204
8205 static bool
8206 sort_tu_by_abbrev_offset (const struct tu_abbrev_offset &a,
8207                           const struct tu_abbrev_offset &b)
8208 {
8209   return a.abbrev_offset < b.abbrev_offset;
8210 }
8211
8212 /* Efficiently read all the type units.
8213    This does the bulk of the work for build_type_psymtabs.
8214
8215    The efficiency is because we sort TUs by the abbrev table they use and
8216    only read each abbrev table once.  In one program there are 200K TUs
8217    sharing 8K abbrev tables.
8218
8219    The main purpose of this function is to support building the
8220    dwarf2_per_objfile->type_unit_groups table.
8221    TUs typically share the DW_AT_stmt_list of the CU they came from, so we
8222    can collapse the search space by grouping them by stmt_list.
8223    The savings can be significant, in the same program from above the 200K TUs
8224    share 8K stmt_list tables.
8225
8226    FUNC is expected to call get_type_unit_group, which will create the
8227    struct type_unit_group if necessary and add it to
8228    dwarf2_per_objfile->type_unit_groups.  */
8229
8230 static void
8231 build_type_psymtabs_1 (struct dwarf2_per_objfile *dwarf2_per_objfile)
8232 {
8233   struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
8234   abbrev_table_up abbrev_table;
8235   sect_offset abbrev_offset;
8236
8237   /* It's up to the caller to not call us multiple times.  */
8238   gdb_assert (dwarf2_per_objfile->type_unit_groups == NULL);
8239
8240   if (dwarf2_per_objfile->all_type_units.empty ())
8241     return;
8242
8243   /* TUs typically share abbrev tables, and there can be way more TUs than
8244      abbrev tables.  Sort by abbrev table to reduce the number of times we
8245      read each abbrev table in.
8246      Alternatives are to punt or to maintain a cache of abbrev tables.
8247      This is simpler and efficient enough for now.
8248
8249      Later we group TUs by their DW_AT_stmt_list value (as this defines the
8250      symtab to use).  Typically TUs with the same abbrev offset have the same
8251      stmt_list value too so in practice this should work well.
8252
8253      The basic algorithm here is:
8254
8255       sort TUs by abbrev table
8256       for each TU with same abbrev table:
8257         read abbrev table if first user
8258         read TU top level DIE
8259           [IWBN if DWO skeletons had DW_AT_stmt_list]
8260         call FUNC  */
8261
8262   if (dwarf_read_debug)
8263     fprintf_unfiltered (gdb_stdlog, "Building type unit groups ...\n");
8264
8265   /* Sort in a separate table to maintain the order of all_type_units
8266      for .gdb_index: TU indices directly index all_type_units.  */
8267   std::vector<tu_abbrev_offset> sorted_by_abbrev;
8268   sorted_by_abbrev.reserve (dwarf2_per_objfile->all_type_units.size ());
8269
8270   for (signatured_type *sig_type : dwarf2_per_objfile->all_type_units)
8271     sorted_by_abbrev.emplace_back
8272       (sig_type, read_abbrev_offset (dwarf2_per_objfile,
8273                                      sig_type->per_cu.section,
8274                                      sig_type->per_cu.sect_off));
8275
8276   std::sort (sorted_by_abbrev.begin (), sorted_by_abbrev.end (),
8277              sort_tu_by_abbrev_offset);
8278
8279   abbrev_offset = (sect_offset) ~(unsigned) 0;
8280
8281   for (const tu_abbrev_offset &tu : sorted_by_abbrev)
8282     {
8283       /* Switch to the next abbrev table if necessary.  */
8284       if (abbrev_table == NULL
8285           || tu.abbrev_offset != abbrev_offset)
8286         {
8287           abbrev_offset = tu.abbrev_offset;
8288           abbrev_table =
8289             abbrev_table_read_table (dwarf2_per_objfile,
8290                                      &dwarf2_per_objfile->abbrev,
8291                                      abbrev_offset);
8292           ++tu_stats->nr_uniq_abbrev_tables;
8293         }
8294
8295       init_cutu_and_read_dies (&tu.sig_type->per_cu, abbrev_table.get (),
8296                                0, 0, false, build_type_psymtabs_reader, NULL);
8297     }
8298 }
8299
8300 /* Print collected type unit statistics.  */
8301
8302 static void
8303 print_tu_stats (struct dwarf2_per_objfile *dwarf2_per_objfile)
8304 {
8305   struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
8306
8307   fprintf_unfiltered (gdb_stdlog, "Type unit statistics:\n");
8308   fprintf_unfiltered (gdb_stdlog, "  %zu TUs\n",
8309                       dwarf2_per_objfile->all_type_units.size ());
8310   fprintf_unfiltered (gdb_stdlog, "  %d uniq abbrev tables\n",
8311                       tu_stats->nr_uniq_abbrev_tables);
8312   fprintf_unfiltered (gdb_stdlog, "  %d symtabs from stmt_list entries\n",
8313                       tu_stats->nr_symtabs);
8314   fprintf_unfiltered (gdb_stdlog, "  %d symtab sharers\n",
8315                       tu_stats->nr_symtab_sharers);
8316   fprintf_unfiltered (gdb_stdlog, "  %d type units without a stmt_list\n",
8317                       tu_stats->nr_stmt_less_type_units);
8318   fprintf_unfiltered (gdb_stdlog, "  %d all_type_units reallocs\n",
8319                       tu_stats->nr_all_type_units_reallocs);
8320 }
8321
8322 /* Traversal function for build_type_psymtabs.  */
8323
8324 static int
8325 build_type_psymtab_dependencies (void **slot, void *info)
8326 {
8327   struct dwarf2_per_objfile *dwarf2_per_objfile
8328     = (struct dwarf2_per_objfile *) info;
8329   struct objfile *objfile = dwarf2_per_objfile->objfile;
8330   struct type_unit_group *tu_group = (struct type_unit_group *) *slot;
8331   struct dwarf2_per_cu_data *per_cu = &tu_group->per_cu;
8332   struct partial_symtab *pst = per_cu->v.psymtab;
8333   int len = VEC_length (sig_type_ptr, tu_group->tus);
8334   struct signatured_type *iter;
8335   int i;
8336
8337   gdb_assert (len > 0);
8338   gdb_assert (IS_TYPE_UNIT_GROUP (per_cu));
8339
8340   pst->number_of_dependencies = len;
8341   pst->dependencies = objfile->partial_symtabs->allocate_dependencies (len);
8342   for (i = 0;
8343        VEC_iterate (sig_type_ptr, tu_group->tus, i, iter);
8344        ++i)
8345     {
8346       gdb_assert (iter->per_cu.is_debug_types);
8347       pst->dependencies[i] = iter->per_cu.v.psymtab;
8348       iter->type_unit_group = tu_group;
8349     }
8350
8351   VEC_free (sig_type_ptr, tu_group->tus);
8352
8353   return 1;
8354 }
8355
8356 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8357    Build partial symbol tables for the .debug_types comp-units.  */
8358
8359 static void
8360 build_type_psymtabs (struct dwarf2_per_objfile *dwarf2_per_objfile)
8361 {
8362   if (! create_all_type_units (dwarf2_per_objfile))
8363     return;
8364
8365   build_type_psymtabs_1 (dwarf2_per_objfile);
8366 }
8367
8368 /* Traversal function for process_skeletonless_type_unit.
8369    Read a TU in a DWO file and build partial symbols for it.  */
8370
8371 static int
8372 process_skeletonless_type_unit (void **slot, void *info)
8373 {
8374   struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
8375   struct dwarf2_per_objfile *dwarf2_per_objfile
8376     = (struct dwarf2_per_objfile *) info;
8377   struct signatured_type find_entry, *entry;
8378
8379   /* If this TU doesn't exist in the global table, add it and read it in.  */
8380
8381   if (dwarf2_per_objfile->signatured_types == NULL)
8382     {
8383       dwarf2_per_objfile->signatured_types
8384         = allocate_signatured_type_table (dwarf2_per_objfile->objfile);
8385     }
8386
8387   find_entry.signature = dwo_unit->signature;
8388   slot = htab_find_slot (dwarf2_per_objfile->signatured_types, &find_entry,
8389                          INSERT);
8390   /* If we've already seen this type there's nothing to do.  What's happening
8391      is we're doing our own version of comdat-folding here.  */
8392   if (*slot != NULL)
8393     return 1;
8394
8395   /* This does the job that create_all_type_units would have done for
8396      this TU.  */
8397   entry = add_type_unit (dwarf2_per_objfile, dwo_unit->signature, slot);
8398   fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, entry, dwo_unit);
8399   *slot = entry;
8400
8401   /* This does the job that build_type_psymtabs_1 would have done.  */
8402   init_cutu_and_read_dies (&entry->per_cu, NULL, 0, 0, false,
8403                            build_type_psymtabs_reader, NULL);
8404
8405   return 1;
8406 }
8407
8408 /* Traversal function for process_skeletonless_type_units.  */
8409
8410 static int
8411 process_dwo_file_for_skeletonless_type_units (void **slot, void *info)
8412 {
8413   struct dwo_file *dwo_file = (struct dwo_file *) *slot;
8414
8415   if (dwo_file->tus != NULL)
8416     {
8417       htab_traverse_noresize (dwo_file->tus,
8418                               process_skeletonless_type_unit, info);
8419     }
8420
8421   return 1;
8422 }
8423
8424 /* Scan all TUs of DWO files, verifying we've processed them.
8425    This is needed in case a TU was emitted without its skeleton.
8426    Note: This can't be done until we know what all the DWO files are.  */
8427
8428 static void
8429 process_skeletonless_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
8430 {
8431   /* Skeletonless TUs in DWP files without .gdb_index is not supported yet.  */
8432   if (get_dwp_file (dwarf2_per_objfile) == NULL
8433       && dwarf2_per_objfile->dwo_files != NULL)
8434     {
8435       htab_traverse_noresize (dwarf2_per_objfile->dwo_files,
8436                               process_dwo_file_for_skeletonless_type_units,
8437                               dwarf2_per_objfile);
8438     }
8439 }
8440
8441 /* Compute the 'user' field for each psymtab in DWARF2_PER_OBJFILE.  */
8442
8443 static void
8444 set_partial_user (struct dwarf2_per_objfile *dwarf2_per_objfile)
8445 {
8446   for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
8447     {
8448       struct partial_symtab *pst = per_cu->v.psymtab;
8449
8450       if (pst == NULL)
8451         continue;
8452
8453       for (int j = 0; j < pst->number_of_dependencies; ++j)
8454         {
8455           /* Set the 'user' field only if it is not already set.  */
8456           if (pst->dependencies[j]->user == NULL)
8457             pst->dependencies[j]->user = pst;
8458         }
8459     }
8460 }
8461
8462 /* Build the partial symbol table by doing a quick pass through the
8463    .debug_info and .debug_abbrev sections.  */
8464
8465 static void
8466 dwarf2_build_psymtabs_hard (struct dwarf2_per_objfile *dwarf2_per_objfile)
8467 {
8468   struct objfile *objfile = dwarf2_per_objfile->objfile;
8469
8470   if (dwarf_read_debug)
8471     {
8472       fprintf_unfiltered (gdb_stdlog, "Building psymtabs of objfile %s ...\n",
8473                           objfile_name (objfile));
8474     }
8475
8476   dwarf2_per_objfile->reading_partial_symbols = 1;
8477
8478   dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
8479
8480   /* Any cached compilation units will be linked by the per-objfile
8481      read_in_chain.  Make sure to free them when we're done.  */
8482   free_cached_comp_units freer (dwarf2_per_objfile);
8483
8484   build_type_psymtabs (dwarf2_per_objfile);
8485
8486   create_all_comp_units (dwarf2_per_objfile);
8487
8488   /* Create a temporary address map on a temporary obstack.  We later
8489      copy this to the final obstack.  */
8490   auto_obstack temp_obstack;
8491
8492   scoped_restore save_psymtabs_addrmap
8493     = make_scoped_restore (&objfile->partial_symtabs->psymtabs_addrmap,
8494                            addrmap_create_mutable (&temp_obstack));
8495
8496   for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
8497     process_psymtab_comp_unit (per_cu, 0, language_minimal);
8498
8499   /* This has to wait until we read the CUs, we need the list of DWOs.  */
8500   process_skeletonless_type_units (dwarf2_per_objfile);
8501
8502   /* Now that all TUs have been processed we can fill in the dependencies.  */
8503   if (dwarf2_per_objfile->type_unit_groups != NULL)
8504     {
8505       htab_traverse_noresize (dwarf2_per_objfile->type_unit_groups,
8506                               build_type_psymtab_dependencies, dwarf2_per_objfile);
8507     }
8508
8509   if (dwarf_read_debug)
8510     print_tu_stats (dwarf2_per_objfile);
8511
8512   set_partial_user (dwarf2_per_objfile);
8513
8514   objfile->partial_symtabs->psymtabs_addrmap
8515     = addrmap_create_fixed (objfile->partial_symtabs->psymtabs_addrmap,
8516                             objfile->partial_symtabs->obstack ());
8517   /* At this point we want to keep the address map.  */
8518   save_psymtabs_addrmap.release ();
8519
8520   if (dwarf_read_debug)
8521     fprintf_unfiltered (gdb_stdlog, "Done building psymtabs of %s\n",
8522                         objfile_name (objfile));
8523 }
8524
8525 /* die_reader_func for load_partial_comp_unit.  */
8526
8527 static void
8528 load_partial_comp_unit_reader (const struct die_reader_specs *reader,
8529                                const gdb_byte *info_ptr,
8530                                struct die_info *comp_unit_die,
8531                                int has_children,
8532                                void *data)
8533 {
8534   struct dwarf2_cu *cu = reader->cu;
8535
8536   prepare_one_comp_unit (cu, comp_unit_die, language_minimal);
8537
8538   /* Check if comp unit has_children.
8539      If so, read the rest of the partial symbols from this comp unit.
8540      If not, there's no more debug_info for this comp unit.  */
8541   if (has_children)
8542     load_partial_dies (reader, info_ptr, 0);
8543 }
8544
8545 /* Load the partial DIEs for a secondary CU into memory.
8546    This is also used when rereading a primary CU with load_all_dies.  */
8547
8548 static void
8549 load_partial_comp_unit (struct dwarf2_per_cu_data *this_cu)
8550 {
8551   init_cutu_and_read_dies (this_cu, NULL, 1, 1, false,
8552                            load_partial_comp_unit_reader, NULL);
8553 }
8554
8555 static void
8556 read_comp_units_from_section (struct dwarf2_per_objfile *dwarf2_per_objfile,
8557                               struct dwarf2_section_info *section,
8558                               struct dwarf2_section_info *abbrev_section,
8559                               unsigned int is_dwz)
8560 {
8561   const gdb_byte *info_ptr;
8562   struct objfile *objfile = dwarf2_per_objfile->objfile;
8563
8564   if (dwarf_read_debug)
8565     fprintf_unfiltered (gdb_stdlog, "Reading %s for %s\n",
8566                         get_section_name (section),
8567                         get_section_file_name (section));
8568
8569   dwarf2_read_section (objfile, section);
8570
8571   info_ptr = section->buffer;
8572
8573   while (info_ptr < section->buffer + section->size)
8574     {
8575       struct dwarf2_per_cu_data *this_cu;
8576
8577       sect_offset sect_off = (sect_offset) (info_ptr - section->buffer);
8578
8579       comp_unit_head cu_header;
8580       read_and_check_comp_unit_head (dwarf2_per_objfile, &cu_header, section,
8581                                      abbrev_section, info_ptr,
8582                                      rcuh_kind::COMPILE);
8583
8584       /* Save the compilation unit for later lookup.  */
8585       if (cu_header.unit_type != DW_UT_type)
8586         {
8587           this_cu = XOBNEW (&objfile->objfile_obstack,
8588                             struct dwarf2_per_cu_data);
8589           memset (this_cu, 0, sizeof (*this_cu));
8590         }
8591       else
8592         {
8593           auto sig_type = XOBNEW (&objfile->objfile_obstack,
8594                                   struct signatured_type);
8595           memset (sig_type, 0, sizeof (*sig_type));
8596           sig_type->signature = cu_header.signature;
8597           sig_type->type_offset_in_tu = cu_header.type_cu_offset_in_tu;
8598           this_cu = &sig_type->per_cu;
8599         }
8600       this_cu->is_debug_types = (cu_header.unit_type == DW_UT_type);
8601       this_cu->sect_off = sect_off;
8602       this_cu->length = cu_header.length + cu_header.initial_length_size;
8603       this_cu->is_dwz = is_dwz;
8604       this_cu->dwarf2_per_objfile = dwarf2_per_objfile;
8605       this_cu->section = section;
8606
8607       dwarf2_per_objfile->all_comp_units.push_back (this_cu);
8608
8609       info_ptr = info_ptr + this_cu->length;
8610     }
8611 }
8612
8613 /* Create a list of all compilation units in OBJFILE.
8614    This is only done for -readnow and building partial symtabs.  */
8615
8616 static void
8617 create_all_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
8618 {
8619   gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
8620   read_comp_units_from_section (dwarf2_per_objfile, &dwarf2_per_objfile->info,
8621                                 &dwarf2_per_objfile->abbrev, 0);
8622
8623   dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
8624   if (dwz != NULL)
8625     read_comp_units_from_section (dwarf2_per_objfile, &dwz->info, &dwz->abbrev,
8626                                   1);
8627 }
8628
8629 /* Process all loaded DIEs for compilation unit CU, starting at
8630    FIRST_DIE.  The caller should pass SET_ADDRMAP == 1 if the compilation
8631    unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
8632    DW_AT_ranges).  See the comments of add_partial_subprogram on how
8633    SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated.  */
8634
8635 static void
8636 scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
8637                       CORE_ADDR *highpc, int set_addrmap,
8638                       struct dwarf2_cu *cu)
8639 {
8640   struct partial_die_info *pdi;
8641
8642   /* Now, march along the PDI's, descending into ones which have
8643      interesting children but skipping the children of the other ones,
8644      until we reach the end of the compilation unit.  */
8645
8646   pdi = first_die;
8647
8648   while (pdi != NULL)
8649     {
8650       pdi->fixup (cu);
8651
8652       /* Anonymous namespaces or modules have no name but have interesting
8653          children, so we need to look at them.  Ditto for anonymous
8654          enums.  */
8655
8656       if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
8657           || pdi->tag == DW_TAG_module || pdi->tag == DW_TAG_enumeration_type
8658           || pdi->tag == DW_TAG_imported_unit
8659           || pdi->tag == DW_TAG_inlined_subroutine)
8660         {
8661           switch (pdi->tag)
8662             {
8663             case DW_TAG_subprogram:
8664             case DW_TAG_inlined_subroutine:
8665               add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
8666               break;
8667             case DW_TAG_constant:
8668             case DW_TAG_variable:
8669             case DW_TAG_typedef:
8670             case DW_TAG_union_type:
8671               if (!pdi->is_declaration)
8672                 {
8673                   add_partial_symbol (pdi, cu);
8674                 }
8675               break;
8676             case DW_TAG_class_type:
8677             case DW_TAG_interface_type:
8678             case DW_TAG_structure_type:
8679               if (!pdi->is_declaration)
8680                 {
8681                   add_partial_symbol (pdi, cu);
8682                 }
8683               if ((cu->language == language_rust
8684                    || cu->language == language_cplus) && pdi->has_children)
8685                 scan_partial_symbols (pdi->die_child, lowpc, highpc,
8686                                       set_addrmap, cu);
8687               break;
8688             case DW_TAG_enumeration_type:
8689               if (!pdi->is_declaration)
8690                 add_partial_enumeration (pdi, cu);
8691               break;
8692             case DW_TAG_base_type:
8693             case DW_TAG_subrange_type:
8694               /* File scope base type definitions are added to the partial
8695                  symbol table.  */
8696               add_partial_symbol (pdi, cu);
8697               break;
8698             case DW_TAG_namespace:
8699               add_partial_namespace (pdi, lowpc, highpc, set_addrmap, cu);
8700               break;
8701             case DW_TAG_module:
8702               add_partial_module (pdi, lowpc, highpc, set_addrmap, cu);
8703               break;
8704             case DW_TAG_imported_unit:
8705               {
8706                 struct dwarf2_per_cu_data *per_cu;
8707
8708                 /* For now we don't handle imported units in type units.  */
8709                 if (cu->per_cu->is_debug_types)
8710                   {
8711                     error (_("Dwarf Error: DW_TAG_imported_unit is not"
8712                              " supported in type units [in module %s]"),
8713                            objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
8714                   }
8715
8716                 per_cu = dwarf2_find_containing_comp_unit
8717                            (pdi->d.sect_off, pdi->is_dwz,
8718                             cu->per_cu->dwarf2_per_objfile);
8719
8720                 /* Go read the partial unit, if needed.  */
8721                 if (per_cu->v.psymtab == NULL)
8722                   process_psymtab_comp_unit (per_cu, 1, cu->language);
8723
8724                 VEC_safe_push (dwarf2_per_cu_ptr,
8725                                cu->per_cu->imported_symtabs, per_cu);
8726               }
8727               break;
8728             case DW_TAG_imported_declaration:
8729               add_partial_symbol (pdi, cu);
8730               break;
8731             default:
8732               break;
8733             }
8734         }
8735
8736       /* If the die has a sibling, skip to the sibling.  */
8737
8738       pdi = pdi->die_sibling;
8739     }
8740 }
8741
8742 /* Functions used to compute the fully scoped name of a partial DIE.
8743
8744    Normally, this is simple.  For C++, the parent DIE's fully scoped
8745    name is concatenated with "::" and the partial DIE's name.
8746    Enumerators are an exception; they use the scope of their parent
8747    enumeration type, i.e. the name of the enumeration type is not
8748    prepended to the enumerator.
8749
8750    There are two complexities.  One is DW_AT_specification; in this
8751    case "parent" means the parent of the target of the specification,
8752    instead of the direct parent of the DIE.  The other is compilers
8753    which do not emit DW_TAG_namespace; in this case we try to guess
8754    the fully qualified name of structure types from their members'
8755    linkage names.  This must be done using the DIE's children rather
8756    than the children of any DW_AT_specification target.  We only need
8757    to do this for structures at the top level, i.e. if the target of
8758    any DW_AT_specification (if any; otherwise the DIE itself) does not
8759    have a parent.  */
8760
8761 /* Compute the scope prefix associated with PDI's parent, in
8762    compilation unit CU.  The result will be allocated on CU's
8763    comp_unit_obstack, or a copy of the already allocated PDI->NAME
8764    field.  NULL is returned if no prefix is necessary.  */
8765 static const char *
8766 partial_die_parent_scope (struct partial_die_info *pdi,
8767                           struct dwarf2_cu *cu)
8768 {
8769   const char *grandparent_scope;
8770   struct partial_die_info *parent, *real_pdi;
8771
8772   /* We need to look at our parent DIE; if we have a DW_AT_specification,
8773      then this means the parent of the specification DIE.  */
8774
8775   real_pdi = pdi;
8776   while (real_pdi->has_specification)
8777     real_pdi = find_partial_die (real_pdi->spec_offset,
8778                                  real_pdi->spec_is_dwz, cu);
8779
8780   parent = real_pdi->die_parent;
8781   if (parent == NULL)
8782     return NULL;
8783
8784   if (parent->scope_set)
8785     return parent->scope;
8786
8787   parent->fixup (cu);
8788
8789   grandparent_scope = partial_die_parent_scope (parent, cu);
8790
8791   /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
8792      DW_TAG_namespace DIEs with a name of "::" for the global namespace.
8793      Work around this problem here.  */
8794   if (cu->language == language_cplus
8795       && parent->tag == DW_TAG_namespace
8796       && strcmp (parent->name, "::") == 0
8797       && grandparent_scope == NULL)
8798     {
8799       parent->scope = NULL;
8800       parent->scope_set = 1;
8801       return NULL;
8802     }
8803
8804   if (pdi->tag == DW_TAG_enumerator)
8805     /* Enumerators should not get the name of the enumeration as a prefix.  */
8806     parent->scope = grandparent_scope;
8807   else if (parent->tag == DW_TAG_namespace
8808       || parent->tag == DW_TAG_module
8809       || parent->tag == DW_TAG_structure_type
8810       || parent->tag == DW_TAG_class_type
8811       || parent->tag == DW_TAG_interface_type
8812       || parent->tag == DW_TAG_union_type
8813       || parent->tag == DW_TAG_enumeration_type)
8814     {
8815       if (grandparent_scope == NULL)
8816         parent->scope = parent->name;
8817       else
8818         parent->scope = typename_concat (&cu->comp_unit_obstack,
8819                                          grandparent_scope,
8820                                          parent->name, 0, cu);
8821     }
8822   else
8823     {
8824       /* FIXME drow/2004-04-01: What should we be doing with
8825          function-local names?  For partial symbols, we should probably be
8826          ignoring them.  */
8827       complaint (_("unhandled containing DIE tag %d for DIE at %s"),
8828                  parent->tag, sect_offset_str (pdi->sect_off));
8829       parent->scope = grandparent_scope;
8830     }
8831
8832   parent->scope_set = 1;
8833   return parent->scope;
8834 }
8835
8836 /* Return the fully scoped name associated with PDI, from compilation unit
8837    CU.  The result will be allocated with malloc.  */
8838
8839 static char *
8840 partial_die_full_name (struct partial_die_info *pdi,
8841                        struct dwarf2_cu *cu)
8842 {
8843   const char *parent_scope;
8844
8845   /* If this is a template instantiation, we can not work out the
8846      template arguments from partial DIEs.  So, unfortunately, we have
8847      to go through the full DIEs.  At least any work we do building
8848      types here will be reused if full symbols are loaded later.  */
8849   if (pdi->has_template_arguments)
8850     {
8851       pdi->fixup (cu);
8852
8853       if (pdi->name != NULL && strchr (pdi->name, '<') == NULL)
8854         {
8855           struct die_info *die;
8856           struct attribute attr;
8857           struct dwarf2_cu *ref_cu = cu;
8858
8859           /* DW_FORM_ref_addr is using section offset.  */
8860           attr.name = (enum dwarf_attribute) 0;
8861           attr.form = DW_FORM_ref_addr;
8862           attr.u.unsnd = to_underlying (pdi->sect_off);
8863           die = follow_die_ref (NULL, &attr, &ref_cu);
8864
8865           return xstrdup (dwarf2_full_name (NULL, die, ref_cu));
8866         }
8867     }
8868
8869   parent_scope = partial_die_parent_scope (pdi, cu);
8870   if (parent_scope == NULL)
8871     return NULL;
8872   else
8873     return typename_concat (NULL, parent_scope, pdi->name, 0, cu);
8874 }
8875
8876 static void
8877 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
8878 {
8879   struct dwarf2_per_objfile *dwarf2_per_objfile
8880     = cu->per_cu->dwarf2_per_objfile;
8881   struct objfile *objfile = dwarf2_per_objfile->objfile;
8882   struct gdbarch *gdbarch = get_objfile_arch (objfile);
8883   CORE_ADDR addr = 0;
8884   const char *actual_name = NULL;
8885   CORE_ADDR baseaddr;
8886   char *built_actual_name;
8887
8888   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
8889
8890   built_actual_name = partial_die_full_name (pdi, cu);
8891   if (built_actual_name != NULL)
8892     actual_name = built_actual_name;
8893
8894   if (actual_name == NULL)
8895     actual_name = pdi->name;
8896
8897   switch (pdi->tag)
8898     {
8899     case DW_TAG_inlined_subroutine:
8900     case DW_TAG_subprogram:
8901       addr = (gdbarch_adjust_dwarf2_addr (gdbarch, pdi->lowpc + baseaddr)
8902               - baseaddr);
8903       if (pdi->is_external || cu->language == language_ada)
8904         {
8905           /* brobecker/2007-12-26: Normally, only "external" DIEs are part
8906              of the global scope.  But in Ada, we want to be able to access
8907              nested procedures globally.  So all Ada subprograms are stored
8908              in the global scope.  */
8909           add_psymbol_to_list (actual_name, strlen (actual_name),
8910                                built_actual_name != NULL,
8911                                VAR_DOMAIN, LOC_BLOCK,
8912                                SECT_OFF_TEXT (objfile),
8913                                psymbol_placement::GLOBAL,
8914                                addr,
8915                                cu->language, objfile);
8916         }
8917       else
8918         {
8919           add_psymbol_to_list (actual_name, strlen (actual_name),
8920                                built_actual_name != NULL,
8921                                VAR_DOMAIN, LOC_BLOCK,
8922                                SECT_OFF_TEXT (objfile),
8923                                psymbol_placement::STATIC,
8924                                addr, cu->language, objfile);
8925         }
8926
8927       if (pdi->main_subprogram && actual_name != NULL)
8928         set_objfile_main_name (objfile, actual_name, cu->language);
8929       break;
8930     case DW_TAG_constant:
8931       add_psymbol_to_list (actual_name, strlen (actual_name),
8932                            built_actual_name != NULL, VAR_DOMAIN, LOC_STATIC,
8933                            -1, (pdi->is_external
8934                                 ? psymbol_placement::GLOBAL
8935                                 : psymbol_placement::STATIC),
8936                            0, cu->language, objfile);
8937       break;
8938     case DW_TAG_variable:
8939       if (pdi->d.locdesc)
8940         addr = decode_locdesc (pdi->d.locdesc, cu);
8941
8942       if (pdi->d.locdesc
8943           && addr == 0
8944           && !dwarf2_per_objfile->has_section_at_zero)
8945         {
8946           /* A global or static variable may also have been stripped
8947              out by the linker if unused, in which case its address
8948              will be nullified; do not add such variables into partial
8949              symbol table then.  */
8950         }
8951       else if (pdi->is_external)
8952         {
8953           /* Global Variable.
8954              Don't enter into the minimal symbol tables as there is
8955              a minimal symbol table entry from the ELF symbols already.
8956              Enter into partial symbol table if it has a location
8957              descriptor or a type.
8958              If the location descriptor is missing, new_symbol will create
8959              a LOC_UNRESOLVED symbol, the address of the variable will then
8960              be determined from the minimal symbol table whenever the variable
8961              is referenced.
8962              The address for the partial symbol table entry is not
8963              used by GDB, but it comes in handy for debugging partial symbol
8964              table building.  */
8965
8966           if (pdi->d.locdesc || pdi->has_type)
8967             add_psymbol_to_list (actual_name, strlen (actual_name),
8968                                  built_actual_name != NULL,
8969                                  VAR_DOMAIN, LOC_STATIC,
8970                                  SECT_OFF_TEXT (objfile),
8971                                  psymbol_placement::GLOBAL,
8972                                  addr, cu->language, objfile);
8973         }
8974       else
8975         {
8976           int has_loc = pdi->d.locdesc != NULL;
8977
8978           /* Static Variable.  Skip symbols whose value we cannot know (those
8979              without location descriptors or constant values).  */
8980           if (!has_loc && !pdi->has_const_value)
8981             {
8982               xfree (built_actual_name);
8983               return;
8984             }
8985
8986           add_psymbol_to_list (actual_name, strlen (actual_name),
8987                                built_actual_name != NULL,
8988                                VAR_DOMAIN, LOC_STATIC,
8989                                SECT_OFF_TEXT (objfile),
8990                                psymbol_placement::STATIC,
8991                                has_loc ? addr : 0,
8992                                cu->language, objfile);
8993         }
8994       break;
8995     case DW_TAG_typedef:
8996     case DW_TAG_base_type:
8997     case DW_TAG_subrange_type:
8998       add_psymbol_to_list (actual_name, strlen (actual_name),
8999                            built_actual_name != NULL,
9000                            VAR_DOMAIN, LOC_TYPEDEF, -1,
9001                            psymbol_placement::STATIC,
9002                            0, cu->language, objfile);
9003       break;
9004     case DW_TAG_imported_declaration:
9005     case DW_TAG_namespace:
9006       add_psymbol_to_list (actual_name, strlen (actual_name),
9007                            built_actual_name != NULL,
9008                            VAR_DOMAIN, LOC_TYPEDEF, -1,
9009                            psymbol_placement::GLOBAL,
9010                            0, cu->language, objfile);
9011       break;
9012     case DW_TAG_module:
9013       add_psymbol_to_list (actual_name, strlen (actual_name),
9014                            built_actual_name != NULL,
9015                            MODULE_DOMAIN, LOC_TYPEDEF, -1,
9016                            psymbol_placement::GLOBAL,
9017                            0, cu->language, objfile);
9018       break;
9019     case DW_TAG_class_type:
9020     case DW_TAG_interface_type:
9021     case DW_TAG_structure_type:
9022     case DW_TAG_union_type:
9023     case DW_TAG_enumeration_type:
9024       /* Skip external references.  The DWARF standard says in the section
9025          about "Structure, Union, and Class Type Entries": "An incomplete
9026          structure, union or class type is represented by a structure,
9027          union or class entry that does not have a byte size attribute
9028          and that has a DW_AT_declaration attribute."  */
9029       if (!pdi->has_byte_size && pdi->is_declaration)
9030         {
9031           xfree (built_actual_name);
9032           return;
9033         }
9034
9035       /* NOTE: carlton/2003-10-07: See comment in new_symbol about
9036          static vs. global.  */
9037       add_psymbol_to_list (actual_name, strlen (actual_name),
9038                            built_actual_name != NULL,
9039                            STRUCT_DOMAIN, LOC_TYPEDEF, -1,
9040                            cu->language == language_cplus
9041                            ? psymbol_placement::GLOBAL
9042                            : psymbol_placement::STATIC,
9043                            0, cu->language, objfile);
9044
9045       break;
9046     case DW_TAG_enumerator:
9047       add_psymbol_to_list (actual_name, strlen (actual_name),
9048                            built_actual_name != NULL,
9049                            VAR_DOMAIN, LOC_CONST, -1,
9050                            cu->language == language_cplus
9051                            ? psymbol_placement::GLOBAL
9052                            : psymbol_placement::STATIC,
9053                            0, cu->language, objfile);
9054       break;
9055     default:
9056       break;
9057     }
9058
9059   xfree (built_actual_name);
9060 }
9061
9062 /* Read a partial die corresponding to a namespace; also, add a symbol
9063    corresponding to that namespace to the symbol table.  NAMESPACE is
9064    the name of the enclosing namespace.  */
9065
9066 static void
9067 add_partial_namespace (struct partial_die_info *pdi,
9068                        CORE_ADDR *lowpc, CORE_ADDR *highpc,
9069                        int set_addrmap, struct dwarf2_cu *cu)
9070 {
9071   /* Add a symbol for the namespace.  */
9072
9073   add_partial_symbol (pdi, cu);
9074
9075   /* Now scan partial symbols in that namespace.  */
9076
9077   if (pdi->has_children)
9078     scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
9079 }
9080
9081 /* Read a partial die corresponding to a Fortran module.  */
9082
9083 static void
9084 add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
9085                     CORE_ADDR *highpc, int set_addrmap, struct dwarf2_cu *cu)
9086 {
9087   /* Add a symbol for the namespace.  */
9088
9089   add_partial_symbol (pdi, cu);
9090
9091   /* Now scan partial symbols in that module.  */
9092
9093   if (pdi->has_children)
9094     scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
9095 }
9096
9097 /* Read a partial die corresponding to a subprogram or an inlined
9098    subprogram and create a partial symbol for that subprogram.
9099    When the CU language allows it, this routine also defines a partial
9100    symbol for each nested subprogram that this subprogram contains.
9101    If SET_ADDRMAP is true, record the covered ranges in the addrmap.
9102    Set *LOWPC and *HIGHPC to the lowest and highest PC values found in PDI.
9103
9104    PDI may also be a lexical block, in which case we simply search
9105    recursively for subprograms defined inside that lexical block.
9106    Again, this is only performed when the CU language allows this
9107    type of definitions.  */
9108
9109 static void
9110 add_partial_subprogram (struct partial_die_info *pdi,
9111                         CORE_ADDR *lowpc, CORE_ADDR *highpc,
9112                         int set_addrmap, struct dwarf2_cu *cu)
9113 {
9114   if (pdi->tag == DW_TAG_subprogram || pdi->tag == DW_TAG_inlined_subroutine)
9115     {
9116       if (pdi->has_pc_info)
9117         {
9118           if (pdi->lowpc < *lowpc)
9119             *lowpc = pdi->lowpc;
9120           if (pdi->highpc > *highpc)
9121             *highpc = pdi->highpc;
9122           if (set_addrmap)
9123             {
9124               struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
9125               struct gdbarch *gdbarch = get_objfile_arch (objfile);
9126               CORE_ADDR baseaddr;
9127               CORE_ADDR this_highpc;
9128               CORE_ADDR this_lowpc;
9129
9130               baseaddr = ANOFFSET (objfile->section_offsets,
9131                                    SECT_OFF_TEXT (objfile));
9132               this_lowpc
9133                 = (gdbarch_adjust_dwarf2_addr (gdbarch,
9134                                                pdi->lowpc + baseaddr)
9135                    - baseaddr);
9136               this_highpc
9137                 = (gdbarch_adjust_dwarf2_addr (gdbarch,
9138                                                pdi->highpc + baseaddr)
9139                    - baseaddr);
9140               addrmap_set_empty (objfile->partial_symtabs->psymtabs_addrmap,
9141                                  this_lowpc, this_highpc - 1,
9142                                  cu->per_cu->v.psymtab);
9143             }
9144         }
9145
9146       if (pdi->has_pc_info || (!pdi->is_external && pdi->may_be_inlined))
9147         {
9148           if (!pdi->is_declaration)
9149             /* Ignore subprogram DIEs that do not have a name, they are
9150                illegal.  Do not emit a complaint at this point, we will
9151                do so when we convert this psymtab into a symtab.  */
9152             if (pdi->name)
9153               add_partial_symbol (pdi, cu);
9154         }
9155     }
9156
9157   if (! pdi->has_children)
9158     return;
9159
9160   if (cu->language == language_ada)
9161     {
9162       pdi = pdi->die_child;
9163       while (pdi != NULL)
9164         {
9165           pdi->fixup (cu);
9166           if (pdi->tag == DW_TAG_subprogram
9167               || pdi->tag == DW_TAG_inlined_subroutine
9168               || pdi->tag == DW_TAG_lexical_block)
9169             add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
9170           pdi = pdi->die_sibling;
9171         }
9172     }
9173 }
9174
9175 /* Read a partial die corresponding to an enumeration type.  */
9176
9177 static void
9178 add_partial_enumeration (struct partial_die_info *enum_pdi,
9179                          struct dwarf2_cu *cu)
9180 {
9181   struct partial_die_info *pdi;
9182
9183   if (enum_pdi->name != NULL)
9184     add_partial_symbol (enum_pdi, cu);
9185
9186   pdi = enum_pdi->die_child;
9187   while (pdi)
9188     {
9189       if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
9190         complaint (_("malformed enumerator DIE ignored"));
9191       else
9192         add_partial_symbol (pdi, cu);
9193       pdi = pdi->die_sibling;
9194     }
9195 }
9196
9197 /* Return the initial uleb128 in the die at INFO_PTR.  */
9198
9199 static unsigned int
9200 peek_abbrev_code (bfd *abfd, const gdb_byte *info_ptr)
9201 {
9202   unsigned int bytes_read;
9203
9204   return read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9205 }
9206
9207 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit
9208    READER::CU.  Use READER::ABBREV_TABLE to lookup any abbreviation.
9209
9210    Return the corresponding abbrev, or NULL if the number is zero (indicating
9211    an empty DIE).  In either case *BYTES_READ will be set to the length of
9212    the initial number.  */
9213
9214 static struct abbrev_info *
9215 peek_die_abbrev (const die_reader_specs &reader,
9216                  const gdb_byte *info_ptr, unsigned int *bytes_read)
9217 {
9218   dwarf2_cu *cu = reader.cu;
9219   bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
9220   unsigned int abbrev_number
9221     = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
9222
9223   if (abbrev_number == 0)
9224     return NULL;
9225
9226   abbrev_info *abbrev = reader.abbrev_table->lookup_abbrev (abbrev_number);
9227   if (!abbrev)
9228     {
9229       error (_("Dwarf Error: Could not find abbrev number %d in %s"
9230                " at offset %s [in module %s]"),
9231              abbrev_number, cu->per_cu->is_debug_types ? "TU" : "CU",
9232              sect_offset_str (cu->header.sect_off), bfd_get_filename (abfd));
9233     }
9234
9235   return abbrev;
9236 }
9237
9238 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9239    Returns a pointer to the end of a series of DIEs, terminated by an empty
9240    DIE.  Any children of the skipped DIEs will also be skipped.  */
9241
9242 static const gdb_byte *
9243 skip_children (const struct die_reader_specs *reader, const gdb_byte *info_ptr)
9244 {
9245   while (1)
9246     {
9247       unsigned int bytes_read;
9248       abbrev_info *abbrev = peek_die_abbrev (*reader, info_ptr, &bytes_read);
9249
9250       if (abbrev == NULL)
9251         return info_ptr + bytes_read;
9252       else
9253         info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
9254     }
9255 }
9256
9257 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9258    INFO_PTR should point just after the initial uleb128 of a DIE, and the
9259    abbrev corresponding to that skipped uleb128 should be passed in
9260    ABBREV.  Returns a pointer to this DIE's sibling, skipping any
9261    children.  */
9262
9263 static const gdb_byte *
9264 skip_one_die (const struct die_reader_specs *reader, const gdb_byte *info_ptr,
9265               struct abbrev_info *abbrev)
9266 {
9267   unsigned int bytes_read;
9268   struct attribute attr;
9269   bfd *abfd = reader->abfd;
9270   struct dwarf2_cu *cu = reader->cu;
9271   const gdb_byte *buffer = reader->buffer;
9272   const gdb_byte *buffer_end = reader->buffer_end;
9273   unsigned int form, i;
9274
9275   for (i = 0; i < abbrev->num_attrs; i++)
9276     {
9277       /* The only abbrev we care about is DW_AT_sibling.  */
9278       if (abbrev->attrs[i].name == DW_AT_sibling)
9279         {
9280           read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
9281           if (attr.form == DW_FORM_ref_addr)
9282             complaint (_("ignoring absolute DW_AT_sibling"));
9283           else
9284             {
9285               sect_offset off = dwarf2_get_ref_die_offset (&attr);
9286               const gdb_byte *sibling_ptr = buffer + to_underlying (off);
9287
9288               if (sibling_ptr < info_ptr)
9289                 complaint (_("DW_AT_sibling points backwards"));
9290               else if (sibling_ptr > reader->buffer_end)
9291                 dwarf2_section_buffer_overflow_complaint (reader->die_section);
9292               else
9293                 return sibling_ptr;
9294             }
9295         }
9296
9297       /* If it isn't DW_AT_sibling, skip this attribute.  */
9298       form = abbrev->attrs[i].form;
9299     skip_attribute:
9300       switch (form)
9301         {
9302         case DW_FORM_ref_addr:
9303           /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
9304              and later it is offset sized.  */
9305           if (cu->header.version == 2)
9306             info_ptr += cu->header.addr_size;
9307           else
9308             info_ptr += cu->header.offset_size;
9309           break;
9310         case DW_FORM_GNU_ref_alt:
9311           info_ptr += cu->header.offset_size;
9312           break;
9313         case DW_FORM_addr:
9314           info_ptr += cu->header.addr_size;
9315           break;
9316         case DW_FORM_data1:
9317         case DW_FORM_ref1:
9318         case DW_FORM_flag:
9319           info_ptr += 1;
9320           break;
9321         case DW_FORM_flag_present:
9322         case DW_FORM_implicit_const:
9323           break;
9324         case DW_FORM_data2:
9325         case DW_FORM_ref2:
9326           info_ptr += 2;
9327           break;
9328         case DW_FORM_data4:
9329         case DW_FORM_ref4:
9330           info_ptr += 4;
9331           break;
9332         case DW_FORM_data8:
9333         case DW_FORM_ref8:
9334         case DW_FORM_ref_sig8:
9335           info_ptr += 8;
9336           break;
9337         case DW_FORM_data16:
9338           info_ptr += 16;
9339           break;
9340         case DW_FORM_string:
9341           read_direct_string (abfd, info_ptr, &bytes_read);
9342           info_ptr += bytes_read;
9343           break;
9344         case DW_FORM_sec_offset:
9345         case DW_FORM_strp:
9346         case DW_FORM_GNU_strp_alt:
9347           info_ptr += cu->header.offset_size;
9348           break;
9349         case DW_FORM_exprloc:
9350         case DW_FORM_block:
9351           info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9352           info_ptr += bytes_read;
9353           break;
9354         case DW_FORM_block1:
9355           info_ptr += 1 + read_1_byte (abfd, info_ptr);
9356           break;
9357         case DW_FORM_block2:
9358           info_ptr += 2 + read_2_bytes (abfd, info_ptr);
9359           break;
9360         case DW_FORM_block4:
9361           info_ptr += 4 + read_4_bytes (abfd, info_ptr);
9362           break;
9363         case DW_FORM_addrx:
9364         case DW_FORM_strx:
9365         case DW_FORM_sdata:
9366         case DW_FORM_udata:
9367         case DW_FORM_ref_udata:
9368         case DW_FORM_GNU_addr_index:
9369         case DW_FORM_GNU_str_index:
9370           info_ptr = safe_skip_leb128 (info_ptr, buffer_end);
9371           break;
9372         case DW_FORM_indirect:
9373           form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9374           info_ptr += bytes_read;
9375           /* We need to continue parsing from here, so just go back to
9376              the top.  */
9377           goto skip_attribute;
9378
9379         default:
9380           error (_("Dwarf Error: Cannot handle %s "
9381                    "in DWARF reader [in module %s]"),
9382                  dwarf_form_name (form),
9383                  bfd_get_filename (abfd));
9384         }
9385     }
9386
9387   if (abbrev->has_children)
9388     return skip_children (reader, info_ptr);
9389   else
9390     return info_ptr;
9391 }
9392
9393 /* Locate ORIG_PDI's sibling.
9394    INFO_PTR should point to the start of the next DIE after ORIG_PDI.  */
9395
9396 static const gdb_byte *
9397 locate_pdi_sibling (const struct die_reader_specs *reader,
9398                     struct partial_die_info *orig_pdi,
9399                     const gdb_byte *info_ptr)
9400 {
9401   /* Do we know the sibling already?  */
9402
9403   if (orig_pdi->sibling)
9404     return orig_pdi->sibling;
9405
9406   /* Are there any children to deal with?  */
9407
9408   if (!orig_pdi->has_children)
9409     return info_ptr;
9410
9411   /* Skip the children the long way.  */
9412
9413   return skip_children (reader, info_ptr);
9414 }
9415
9416 /* Expand this partial symbol table into a full symbol table.  SELF is
9417    not NULL.  */
9418
9419 static void
9420 dwarf2_read_symtab (struct partial_symtab *self,
9421                     struct objfile *objfile)
9422 {
9423   struct dwarf2_per_objfile *dwarf2_per_objfile
9424     = get_dwarf2_per_objfile (objfile);
9425
9426   if (self->readin)
9427     {
9428       warning (_("bug: psymtab for %s is already read in."),
9429                self->filename);
9430     }
9431   else
9432     {
9433       if (info_verbose)
9434         {
9435           printf_filtered (_("Reading in symbols for %s..."),
9436                            self->filename);
9437           gdb_flush (gdb_stdout);
9438         }
9439
9440       /* If this psymtab is constructed from a debug-only objfile, the
9441          has_section_at_zero flag will not necessarily be correct.  We
9442          can get the correct value for this flag by looking at the data
9443          associated with the (presumably stripped) associated objfile.  */
9444       if (objfile->separate_debug_objfile_backlink)
9445         {
9446           struct dwarf2_per_objfile *dpo_backlink
9447             = get_dwarf2_per_objfile (objfile->separate_debug_objfile_backlink);
9448
9449           dwarf2_per_objfile->has_section_at_zero
9450             = dpo_backlink->has_section_at_zero;
9451         }
9452
9453       dwarf2_per_objfile->reading_partial_symbols = 0;
9454
9455       psymtab_to_symtab_1 (self);
9456
9457       /* Finish up the debug error message.  */
9458       if (info_verbose)
9459         printf_filtered (_("done.\n"));
9460     }
9461
9462   process_cu_includes (dwarf2_per_objfile);
9463 }
9464 \f
9465 /* Reading in full CUs.  */
9466
9467 /* Add PER_CU to the queue.  */
9468
9469 static void
9470 queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
9471                  enum language pretend_language)
9472 {
9473   struct dwarf2_queue_item *item;
9474
9475   per_cu->queued = 1;
9476   item = XNEW (struct dwarf2_queue_item);
9477   item->per_cu = per_cu;
9478   item->pretend_language = pretend_language;
9479   item->next = NULL;
9480
9481   if (dwarf2_queue == NULL)
9482     dwarf2_queue = item;
9483   else
9484     dwarf2_queue_tail->next = item;
9485
9486   dwarf2_queue_tail = item;
9487 }
9488
9489 /* If PER_CU is not yet queued, add it to the queue.
9490    If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
9491    dependency.
9492    The result is non-zero if PER_CU was queued, otherwise the result is zero
9493    meaning either PER_CU is already queued or it is already loaded.
9494
9495    N.B. There is an invariant here that if a CU is queued then it is loaded.
9496    The caller is required to load PER_CU if we return non-zero.  */
9497
9498 static int
9499 maybe_queue_comp_unit (struct dwarf2_cu *dependent_cu,
9500                        struct dwarf2_per_cu_data *per_cu,
9501                        enum language pretend_language)
9502 {
9503   /* We may arrive here during partial symbol reading, if we need full
9504      DIEs to process an unusual case (e.g. template arguments).  Do
9505      not queue PER_CU, just tell our caller to load its DIEs.  */
9506   if (per_cu->dwarf2_per_objfile->reading_partial_symbols)
9507     {
9508       if (per_cu->cu == NULL || per_cu->cu->dies == NULL)
9509         return 1;
9510       return 0;
9511     }
9512
9513   /* Mark the dependence relation so that we don't flush PER_CU
9514      too early.  */
9515   if (dependent_cu != NULL)
9516     dwarf2_add_dependence (dependent_cu, per_cu);
9517
9518   /* If it's already on the queue, we have nothing to do.  */
9519   if (per_cu->queued)
9520     return 0;
9521
9522   /* If the compilation unit is already loaded, just mark it as
9523      used.  */
9524   if (per_cu->cu != NULL)
9525     {
9526       per_cu->cu->last_used = 0;
9527       return 0;
9528     }
9529
9530   /* Add it to the queue.  */
9531   queue_comp_unit (per_cu, pretend_language);
9532
9533   return 1;
9534 }
9535
9536 /* Process the queue.  */
9537
9538 static void
9539 process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile)
9540 {
9541   struct dwarf2_queue_item *item, *next_item;
9542
9543   if (dwarf_read_debug)
9544     {
9545       fprintf_unfiltered (gdb_stdlog,
9546                           "Expanding one or more symtabs of objfile %s ...\n",
9547                           objfile_name (dwarf2_per_objfile->objfile));
9548     }
9549
9550   /* The queue starts out with one item, but following a DIE reference
9551      may load a new CU, adding it to the end of the queue.  */
9552   for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
9553     {
9554       if ((dwarf2_per_objfile->using_index
9555            ? !item->per_cu->v.quick->compunit_symtab
9556            : (item->per_cu->v.psymtab && !item->per_cu->v.psymtab->readin))
9557           /* Skip dummy CUs.  */
9558           && item->per_cu->cu != NULL)
9559         {
9560           struct dwarf2_per_cu_data *per_cu = item->per_cu;
9561           unsigned int debug_print_threshold;
9562           char buf[100];
9563
9564           if (per_cu->is_debug_types)
9565             {
9566               struct signatured_type *sig_type =
9567                 (struct signatured_type *) per_cu;
9568
9569               sprintf (buf, "TU %s at offset %s",
9570                        hex_string (sig_type->signature),
9571                        sect_offset_str (per_cu->sect_off));
9572               /* There can be 100s of TUs.
9573                  Only print them in verbose mode.  */
9574               debug_print_threshold = 2;
9575             }
9576           else
9577             {
9578               sprintf (buf, "CU at offset %s",
9579                        sect_offset_str (per_cu->sect_off));
9580               debug_print_threshold = 1;
9581             }
9582
9583           if (dwarf_read_debug >= debug_print_threshold)
9584             fprintf_unfiltered (gdb_stdlog, "Expanding symtab of %s\n", buf);
9585
9586           if (per_cu->is_debug_types)
9587             process_full_type_unit (per_cu, item->pretend_language);
9588           else
9589             process_full_comp_unit (per_cu, item->pretend_language);
9590
9591           if (dwarf_read_debug >= debug_print_threshold)
9592             fprintf_unfiltered (gdb_stdlog, "Done expanding %s\n", buf);
9593         }
9594
9595       item->per_cu->queued = 0;
9596       next_item = item->next;
9597       xfree (item);
9598     }
9599
9600   dwarf2_queue_tail = NULL;
9601
9602   if (dwarf_read_debug)
9603     {
9604       fprintf_unfiltered (gdb_stdlog, "Done expanding symtabs of %s.\n",
9605                           objfile_name (dwarf2_per_objfile->objfile));
9606     }
9607 }
9608
9609 /* Read in full symbols for PST, and anything it depends on.  */
9610
9611 static void
9612 psymtab_to_symtab_1 (struct partial_symtab *pst)
9613 {
9614   struct dwarf2_per_cu_data *per_cu;
9615   int i;
9616
9617   if (pst->readin)
9618     return;
9619
9620   for (i = 0; i < pst->number_of_dependencies; i++)
9621     if (!pst->dependencies[i]->readin
9622         && pst->dependencies[i]->user == NULL)
9623       {
9624         /* Inform about additional files that need to be read in.  */
9625         if (info_verbose)
9626           {
9627             /* FIXME: i18n: Need to make this a single string.  */
9628             fputs_filtered (" ", gdb_stdout);
9629             wrap_here ("");
9630             fputs_filtered ("and ", gdb_stdout);
9631             wrap_here ("");
9632             printf_filtered ("%s...", pst->dependencies[i]->filename);
9633             wrap_here ("");     /* Flush output.  */
9634             gdb_flush (gdb_stdout);
9635           }
9636         psymtab_to_symtab_1 (pst->dependencies[i]);
9637       }
9638
9639   per_cu = (struct dwarf2_per_cu_data *) pst->read_symtab_private;
9640
9641   if (per_cu == NULL)
9642     {
9643       /* It's an include file, no symbols to read for it.
9644          Everything is in the parent symtab.  */
9645       pst->readin = 1;
9646       return;
9647     }
9648
9649   dw2_do_instantiate_symtab (per_cu, false);
9650 }
9651
9652 /* Trivial hash function for die_info: the hash value of a DIE
9653    is its offset in .debug_info for this objfile.  */
9654
9655 static hashval_t
9656 die_hash (const void *item)
9657 {
9658   const struct die_info *die = (const struct die_info *) item;
9659
9660   return to_underlying (die->sect_off);
9661 }
9662
9663 /* Trivial comparison function for die_info structures: two DIEs
9664    are equal if they have the same offset.  */
9665
9666 static int
9667 die_eq (const void *item_lhs, const void *item_rhs)
9668 {
9669   const struct die_info *die_lhs = (const struct die_info *) item_lhs;
9670   const struct die_info *die_rhs = (const struct die_info *) item_rhs;
9671
9672   return die_lhs->sect_off == die_rhs->sect_off;
9673 }
9674
9675 /* die_reader_func for load_full_comp_unit.
9676    This is identical to read_signatured_type_reader,
9677    but is kept separate for now.  */
9678
9679 static void
9680 load_full_comp_unit_reader (const struct die_reader_specs *reader,
9681                             const gdb_byte *info_ptr,
9682                             struct die_info *comp_unit_die,
9683                             int has_children,
9684                             void *data)
9685 {
9686   struct dwarf2_cu *cu = reader->cu;
9687   enum language *language_ptr = (enum language *) data;
9688
9689   gdb_assert (cu->die_hash == NULL);
9690   cu->die_hash =
9691     htab_create_alloc_ex (cu->header.length / 12,
9692                           die_hash,
9693                           die_eq,
9694                           NULL,
9695                           &cu->comp_unit_obstack,
9696                           hashtab_obstack_allocate,
9697                           dummy_obstack_deallocate);
9698
9699   if (has_children)
9700     comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
9701                                                   &info_ptr, comp_unit_die);
9702   cu->dies = comp_unit_die;
9703   /* comp_unit_die is not stored in die_hash, no need.  */
9704
9705   /* We try not to read any attributes in this function, because not
9706      all CUs needed for references have been loaded yet, and symbol
9707      table processing isn't initialized.  But we have to set the CU language,
9708      or we won't be able to build types correctly.
9709      Similarly, if we do not read the producer, we can not apply
9710      producer-specific interpretation.  */
9711   prepare_one_comp_unit (cu, cu->dies, *language_ptr);
9712 }
9713
9714 /* Load the DIEs associated with PER_CU into memory.  */
9715
9716 static void
9717 load_full_comp_unit (struct dwarf2_per_cu_data *this_cu,
9718                      bool skip_partial,
9719                      enum language pretend_language)
9720 {
9721   gdb_assert (! this_cu->is_debug_types);
9722
9723   init_cutu_and_read_dies (this_cu, NULL, 1, 1, skip_partial,
9724                            load_full_comp_unit_reader, &pretend_language);
9725 }
9726
9727 /* Add a DIE to the delayed physname list.  */
9728
9729 static void
9730 add_to_method_list (struct type *type, int fnfield_index, int index,
9731                     const char *name, struct die_info *die,
9732                     struct dwarf2_cu *cu)
9733 {
9734   struct delayed_method_info mi;
9735   mi.type = type;
9736   mi.fnfield_index = fnfield_index;
9737   mi.index = index;
9738   mi.name = name;
9739   mi.die = die;
9740   cu->method_list.push_back (mi);
9741 }
9742
9743 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
9744    "const" / "volatile".  If so, decrements LEN by the length of the
9745    modifier and return true.  Otherwise return false.  */
9746
9747 template<size_t N>
9748 static bool
9749 check_modifier (const char *physname, size_t &len, const char (&mod)[N])
9750 {
9751   size_t mod_len = sizeof (mod) - 1;
9752   if (len > mod_len && startswith (physname + (len - mod_len), mod))
9753     {
9754       len -= mod_len;
9755       return true;
9756     }
9757   return false;
9758 }
9759
9760 /* Compute the physnames of any methods on the CU's method list.
9761
9762    The computation of method physnames is delayed in order to avoid the
9763    (bad) condition that one of the method's formal parameters is of an as yet
9764    incomplete type.  */
9765
9766 static void
9767 compute_delayed_physnames (struct dwarf2_cu *cu)
9768 {
9769   /* Only C++ delays computing physnames.  */
9770   if (cu->method_list.empty ())
9771     return;
9772   gdb_assert (cu->language == language_cplus);
9773
9774   for (const delayed_method_info &mi : cu->method_list)
9775     {
9776       const char *physname;
9777       struct fn_fieldlist *fn_flp
9778         = &TYPE_FN_FIELDLIST (mi.type, mi.fnfield_index);
9779       physname = dwarf2_physname (mi.name, mi.die, cu);
9780       TYPE_FN_FIELD_PHYSNAME (fn_flp->fn_fields, mi.index)
9781         = physname ? physname : "";
9782
9783       /* Since there's no tag to indicate whether a method is a
9784          const/volatile overload, extract that information out of the
9785          demangled name.  */
9786       if (physname != NULL)
9787         {
9788           size_t len = strlen (physname);
9789
9790           while (1)
9791             {
9792               if (physname[len] == ')') /* shortcut */
9793                 break;
9794               else if (check_modifier (physname, len, " const"))
9795                 TYPE_FN_FIELD_CONST (fn_flp->fn_fields, mi.index) = 1;
9796               else if (check_modifier (physname, len, " volatile"))
9797                 TYPE_FN_FIELD_VOLATILE (fn_flp->fn_fields, mi.index) = 1;
9798               else
9799                 break;
9800             }
9801         }
9802     }
9803
9804   /* The list is no longer needed.  */
9805   cu->method_list.clear ();
9806 }
9807
9808 /* Go objects should be embedded in a DW_TAG_module DIE,
9809    and it's not clear if/how imported objects will appear.
9810    To keep Go support simple until that's worked out,
9811    go back through what we've read and create something usable.
9812    We could do this while processing each DIE, and feels kinda cleaner,
9813    but that way is more invasive.
9814    This is to, for example, allow the user to type "p var" or "b main"
9815    without having to specify the package name, and allow lookups
9816    of module.object to work in contexts that use the expression
9817    parser.  */
9818
9819 static void
9820 fixup_go_packaging (struct dwarf2_cu *cu)
9821 {
9822   char *package_name = NULL;
9823   struct pending *list;
9824   int i;
9825
9826   for (list = *cu->get_builder ()->get_global_symbols ();
9827        list != NULL;
9828        list = list->next)
9829     {
9830       for (i = 0; i < list->nsyms; ++i)
9831         {
9832           struct symbol *sym = list->symbol[i];
9833
9834           if (SYMBOL_LANGUAGE (sym) == language_go
9835               && SYMBOL_CLASS (sym) == LOC_BLOCK)
9836             {
9837               char *this_package_name = go_symbol_package_name (sym);
9838
9839               if (this_package_name == NULL)
9840                 continue;
9841               if (package_name == NULL)
9842                 package_name = this_package_name;
9843               else
9844                 {
9845                   struct objfile *objfile
9846                     = cu->per_cu->dwarf2_per_objfile->objfile;
9847                   if (strcmp (package_name, this_package_name) != 0)
9848                     complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
9849                                (symbol_symtab (sym) != NULL
9850                                 ? symtab_to_filename_for_display
9851                                     (symbol_symtab (sym))
9852                                 : objfile_name (objfile)),
9853                                this_package_name, package_name);
9854                   xfree (this_package_name);
9855                 }
9856             }
9857         }
9858     }
9859
9860   if (package_name != NULL)
9861     {
9862       struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
9863       const char *saved_package_name
9864         = (const char *) obstack_copy0 (&objfile->per_bfd->storage_obstack,
9865                                         package_name,
9866                                         strlen (package_name));
9867       struct type *type = init_type (objfile, TYPE_CODE_MODULE, 0,
9868                                      saved_package_name);
9869       struct symbol *sym;
9870
9871       sym = allocate_symbol (objfile);
9872       SYMBOL_SET_LANGUAGE (sym, language_go, &objfile->objfile_obstack);
9873       SYMBOL_SET_NAMES (sym, saved_package_name,
9874                         strlen (saved_package_name), 0, objfile);
9875       /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
9876          e.g., "main" finds the "main" module and not C's main().  */
9877       SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
9878       SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
9879       SYMBOL_TYPE (sym) = type;
9880
9881       add_symbol_to_list (sym, cu->get_builder ()->get_global_symbols ());
9882
9883       xfree (package_name);
9884     }
9885 }
9886
9887 /* Allocate a fully-qualified name consisting of the two parts on the
9888    obstack.  */
9889
9890 static const char *
9891 rust_fully_qualify (struct obstack *obstack, const char *p1, const char *p2)
9892 {
9893   return obconcat (obstack, p1, "::", p2, (char *) NULL);
9894 }
9895
9896 /* A helper that allocates a struct discriminant_info to attach to a
9897    union type.  */
9898
9899 static struct discriminant_info *
9900 alloc_discriminant_info (struct type *type, int discriminant_index,
9901                          int default_index)
9902 {
9903   gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
9904   gdb_assert (discriminant_index == -1
9905               || (discriminant_index >= 0
9906                   && discriminant_index < TYPE_NFIELDS (type)));
9907   gdb_assert (default_index == -1
9908               || (default_index >= 0 && default_index < TYPE_NFIELDS (type)));
9909
9910   TYPE_FLAG_DISCRIMINATED_UNION (type) = 1;
9911
9912   struct discriminant_info *disc
9913     = ((struct discriminant_info *)
9914        TYPE_ZALLOC (type,
9915                     offsetof (struct discriminant_info, discriminants)
9916                     + TYPE_NFIELDS (type) * sizeof (disc->discriminants[0])));
9917   disc->default_index = default_index;
9918   disc->discriminant_index = discriminant_index;
9919
9920   struct dynamic_prop prop;
9921   prop.kind = PROP_UNDEFINED;
9922   prop.data.baton = disc;
9923
9924   add_dyn_prop (DYN_PROP_DISCRIMINATED, prop, type);
9925
9926   return disc;
9927 }
9928
9929 /* Some versions of rustc emitted enums in an unusual way.
9930
9931    Ordinary enums were emitted as unions.  The first element of each
9932    structure in the union was named "RUST$ENUM$DISR".  This element
9933    held the discriminant.
9934
9935    These versions of Rust also implemented the "non-zero"
9936    optimization.  When the enum had two values, and one is empty and
9937    the other holds a pointer that cannot be zero, the pointer is used
9938    as the discriminant, with a zero value meaning the empty variant.
9939    Here, the union's first member is of the form
9940    RUST$ENCODED$ENUM$<fieldno>$<fieldno>$...$<variantname>
9941    where the fieldnos are the indices of the fields that should be
9942    traversed in order to find the field (which may be several fields deep)
9943    and the variantname is the name of the variant of the case when the
9944    field is zero.
9945
9946    This function recognizes whether TYPE is of one of these forms,
9947    and, if so, smashes it to be a variant type.  */
9948
9949 static void
9950 quirk_rust_enum (struct type *type, struct objfile *objfile)
9951 {
9952   gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
9953
9954   /* We don't need to deal with empty enums.  */
9955   if (TYPE_NFIELDS (type) == 0)
9956     return;
9957
9958 #define RUST_ENUM_PREFIX "RUST$ENCODED$ENUM$"
9959   if (TYPE_NFIELDS (type) == 1
9960       && startswith (TYPE_FIELD_NAME (type, 0), RUST_ENUM_PREFIX))
9961     {
9962       const char *name = TYPE_FIELD_NAME (type, 0) + strlen (RUST_ENUM_PREFIX);
9963
9964       /* Decode the field name to find the offset of the
9965          discriminant.  */
9966       ULONGEST bit_offset = 0;
9967       struct type *field_type = TYPE_FIELD_TYPE (type, 0);
9968       while (name[0] >= '0' && name[0] <= '9')
9969         {
9970           char *tail;
9971           unsigned long index = strtoul (name, &tail, 10);
9972           name = tail;
9973           if (*name != '$'
9974               || index >= TYPE_NFIELDS (field_type)
9975               || (TYPE_FIELD_LOC_KIND (field_type, index)
9976                   != FIELD_LOC_KIND_BITPOS))
9977             {
9978               complaint (_("Could not parse Rust enum encoding string \"%s\""
9979                            "[in module %s]"),
9980                          TYPE_FIELD_NAME (type, 0),
9981                          objfile_name (objfile));
9982               return;
9983             }
9984           ++name;
9985
9986           bit_offset += TYPE_FIELD_BITPOS (field_type, index);
9987           field_type = TYPE_FIELD_TYPE (field_type, index);
9988         }
9989
9990       /* Make a union to hold the variants.  */
9991       struct type *union_type = alloc_type (objfile);
9992       TYPE_CODE (union_type) = TYPE_CODE_UNION;
9993       TYPE_NFIELDS (union_type) = 3;
9994       TYPE_FIELDS (union_type)
9995         = (struct field *) TYPE_ZALLOC (type, 3 * sizeof (struct field));
9996       TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
9997       set_type_align (union_type, TYPE_RAW_ALIGN (type));
9998
9999       /* Put the discriminant must at index 0.  */
10000       TYPE_FIELD_TYPE (union_type, 0) = field_type;
10001       TYPE_FIELD_ARTIFICIAL (union_type, 0) = 1;
10002       TYPE_FIELD_NAME (union_type, 0) = "<<discriminant>>";
10003       SET_FIELD_BITPOS (TYPE_FIELD (union_type, 0), bit_offset);
10004
10005       /* The order of fields doesn't really matter, so put the real
10006          field at index 1 and the data-less field at index 2.  */
10007       struct discriminant_info *disc
10008         = alloc_discriminant_info (union_type, 0, 1);
10009       TYPE_FIELD (union_type, 1) = TYPE_FIELD (type, 0);
10010       TYPE_FIELD_NAME (union_type, 1)
10011         = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type, 1)));
10012       TYPE_NAME (TYPE_FIELD_TYPE (union_type, 1))
10013         = rust_fully_qualify (&objfile->objfile_obstack, TYPE_NAME (type),
10014                               TYPE_FIELD_NAME (union_type, 1));
10015
10016       const char *dataless_name
10017         = rust_fully_qualify (&objfile->objfile_obstack, TYPE_NAME (type),
10018                               name);
10019       struct type *dataless_type = init_type (objfile, TYPE_CODE_VOID, 0,
10020                                               dataless_name);
10021       TYPE_FIELD_TYPE (union_type, 2) = dataless_type;
10022       /* NAME points into the original discriminant name, which
10023          already has the correct lifetime.  */
10024       TYPE_FIELD_NAME (union_type, 2) = name;
10025       SET_FIELD_BITPOS (TYPE_FIELD (union_type, 2), 0);
10026       disc->discriminants[2] = 0;
10027
10028       /* Smash this type to be a structure type.  We have to do this
10029          because the type has already been recorded.  */
10030       TYPE_CODE (type) = TYPE_CODE_STRUCT;
10031       TYPE_NFIELDS (type) = 1;
10032       TYPE_FIELDS (type)
10033         = (struct field *) TYPE_ZALLOC (type, sizeof (struct field));
10034
10035       /* Install the variant part.  */
10036       TYPE_FIELD_TYPE (type, 0) = union_type;
10037       SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
10038       TYPE_FIELD_NAME (type, 0) = "<<variants>>";
10039     }
10040   else if (TYPE_NFIELDS (type) == 1)
10041     {
10042       /* We assume that a union with a single field is a univariant
10043          enum.  */
10044       /* Smash this type to be a structure type.  We have to do this
10045          because the type has already been recorded.  */
10046       TYPE_CODE (type) = TYPE_CODE_STRUCT;
10047
10048       /* Make a union to hold the variants.  */
10049       struct type *union_type = alloc_type (objfile);
10050       TYPE_CODE (union_type) = TYPE_CODE_UNION;
10051       TYPE_NFIELDS (union_type) = TYPE_NFIELDS (type);
10052       TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
10053       set_type_align (union_type, TYPE_RAW_ALIGN (type));
10054       TYPE_FIELDS (union_type) = TYPE_FIELDS (type);
10055
10056       struct type *field_type = TYPE_FIELD_TYPE (union_type, 0);
10057       const char *variant_name
10058         = rust_last_path_segment (TYPE_NAME (field_type));
10059       TYPE_FIELD_NAME (union_type, 0) = variant_name;
10060       TYPE_NAME (field_type)
10061         = rust_fully_qualify (&objfile->objfile_obstack,
10062                               TYPE_NAME (type), variant_name);
10063
10064       /* Install the union in the outer struct type.  */
10065       TYPE_NFIELDS (type) = 1;
10066       TYPE_FIELDS (type)
10067         = (struct field *) TYPE_ZALLOC (union_type, sizeof (struct field));
10068       TYPE_FIELD_TYPE (type, 0) = union_type;
10069       TYPE_FIELD_NAME (type, 0) = "<<variants>>";
10070       SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
10071
10072       alloc_discriminant_info (union_type, -1, 0);
10073     }
10074   else
10075     {
10076       struct type *disr_type = nullptr;
10077       for (int i = 0; i < TYPE_NFIELDS (type); ++i)
10078         {
10079           disr_type = TYPE_FIELD_TYPE (type, i);
10080
10081           if (TYPE_CODE (disr_type) != TYPE_CODE_STRUCT)
10082             {
10083               /* All fields of a true enum will be structs.  */
10084               return;
10085             }
10086           else if (TYPE_NFIELDS (disr_type) == 0)
10087             {
10088               /* Could be data-less variant, so keep going.  */
10089               disr_type = nullptr;
10090             }
10091           else if (strcmp (TYPE_FIELD_NAME (disr_type, 0),
10092                            "RUST$ENUM$DISR") != 0)
10093             {
10094               /* Not a Rust enum.  */
10095               return;
10096             }
10097           else
10098             {
10099               /* Found one.  */
10100               break;
10101             }
10102         }
10103
10104       /* If we got here without a discriminant, then it's probably
10105          just a union.  */
10106       if (disr_type == nullptr)
10107         return;
10108
10109       /* Smash this type to be a structure type.  We have to do this
10110          because the type has already been recorded.  */
10111       TYPE_CODE (type) = TYPE_CODE_STRUCT;
10112
10113       /* Make a union to hold the variants.  */
10114       struct field *disr_field = &TYPE_FIELD (disr_type, 0);
10115       struct type *union_type = alloc_type (objfile);
10116       TYPE_CODE (union_type) = TYPE_CODE_UNION;
10117       TYPE_NFIELDS (union_type) = 1 + TYPE_NFIELDS (type);
10118       TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
10119       set_type_align (union_type, TYPE_RAW_ALIGN (type));
10120       TYPE_FIELDS (union_type)
10121         = (struct field *) TYPE_ZALLOC (union_type,
10122                                         (TYPE_NFIELDS (union_type)
10123                                          * sizeof (struct field)));
10124
10125       memcpy (TYPE_FIELDS (union_type) + 1, TYPE_FIELDS (type),
10126               TYPE_NFIELDS (type) * sizeof (struct field));
10127
10128       /* Install the discriminant at index 0 in the union.  */
10129       TYPE_FIELD (union_type, 0) = *disr_field;
10130       TYPE_FIELD_ARTIFICIAL (union_type, 0) = 1;
10131       TYPE_FIELD_NAME (union_type, 0) = "<<discriminant>>";
10132
10133       /* Install the union in the outer struct type.  */
10134       TYPE_FIELD_TYPE (type, 0) = union_type;
10135       TYPE_FIELD_NAME (type, 0) = "<<variants>>";
10136       TYPE_NFIELDS (type) = 1;
10137
10138       /* Set the size and offset of the union type.  */
10139       SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
10140
10141       /* We need a way to find the correct discriminant given a
10142          variant name.  For convenience we build a map here.  */
10143       struct type *enum_type = FIELD_TYPE (*disr_field);
10144       std::unordered_map<std::string, ULONGEST> discriminant_map;
10145       for (int i = 0; i < TYPE_NFIELDS (enum_type); ++i)
10146         {
10147           if (TYPE_FIELD_LOC_KIND (enum_type, i) == FIELD_LOC_KIND_ENUMVAL)
10148             {
10149               const char *name
10150                 = rust_last_path_segment (TYPE_FIELD_NAME (enum_type, i));
10151               discriminant_map[name] = TYPE_FIELD_ENUMVAL (enum_type, i);
10152             }
10153         }
10154
10155       int n_fields = TYPE_NFIELDS (union_type);
10156       struct discriminant_info *disc
10157         = alloc_discriminant_info (union_type, 0, -1);
10158       /* Skip the discriminant here.  */
10159       for (int i = 1; i < n_fields; ++i)
10160         {
10161           /* Find the final word in the name of this variant's type.
10162              That name can be used to look up the correct
10163              discriminant.  */
10164           const char *variant_name
10165             = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type,
10166                                                                   i)));
10167
10168           auto iter = discriminant_map.find (variant_name);
10169           if (iter != discriminant_map.end ())
10170             disc->discriminants[i] = iter->second;
10171
10172           /* Remove the discriminant field, if it exists.  */
10173           struct type *sub_type = TYPE_FIELD_TYPE (union_type, i);
10174           if (TYPE_NFIELDS (sub_type) > 0)
10175             {
10176               --TYPE_NFIELDS (sub_type);
10177               ++TYPE_FIELDS (sub_type);
10178             }
10179           TYPE_FIELD_NAME (union_type, i) = variant_name;
10180           TYPE_NAME (sub_type)
10181             = rust_fully_qualify (&objfile->objfile_obstack,
10182                                   TYPE_NAME (type), variant_name);
10183         }
10184     }
10185 }
10186
10187 /* Rewrite some Rust unions to be structures with variants parts.  */
10188
10189 static void
10190 rust_union_quirks (struct dwarf2_cu *cu)
10191 {
10192   gdb_assert (cu->language == language_rust);
10193   for (type *type_ : cu->rust_unions)
10194     quirk_rust_enum (type_, cu->per_cu->dwarf2_per_objfile->objfile);
10195   /* We don't need this any more.  */
10196   cu->rust_unions.clear ();
10197 }
10198
10199 /* Return the symtab for PER_CU.  This works properly regardless of
10200    whether we're using the index or psymtabs.  */
10201
10202 static struct compunit_symtab *
10203 get_compunit_symtab (struct dwarf2_per_cu_data *per_cu)
10204 {
10205   return (per_cu->dwarf2_per_objfile->using_index
10206           ? per_cu->v.quick->compunit_symtab
10207           : per_cu->v.psymtab->compunit_symtab);
10208 }
10209
10210 /* A helper function for computing the list of all symbol tables
10211    included by PER_CU.  */
10212
10213 static void
10214 recursively_compute_inclusions (std::vector<compunit_symtab *> *result,
10215                                 htab_t all_children, htab_t all_type_symtabs,
10216                                 struct dwarf2_per_cu_data *per_cu,
10217                                 struct compunit_symtab *immediate_parent)
10218 {
10219   void **slot;
10220   int ix;
10221   struct compunit_symtab *cust;
10222   struct dwarf2_per_cu_data *iter;
10223
10224   slot = htab_find_slot (all_children, per_cu, INSERT);
10225   if (*slot != NULL)
10226     {
10227       /* This inclusion and its children have been processed.  */
10228       return;
10229     }
10230
10231   *slot = per_cu;
10232   /* Only add a CU if it has a symbol table.  */
10233   cust = get_compunit_symtab (per_cu);
10234   if (cust != NULL)
10235     {
10236       /* If this is a type unit only add its symbol table if we haven't
10237          seen it yet (type unit per_cu's can share symtabs).  */
10238       if (per_cu->is_debug_types)
10239         {
10240           slot = htab_find_slot (all_type_symtabs, cust, INSERT);
10241           if (*slot == NULL)
10242             {
10243               *slot = cust;
10244               result->push_back (cust);
10245               if (cust->user == NULL)
10246                 cust->user = immediate_parent;
10247             }
10248         }
10249       else
10250         {
10251           result->push_back (cust);
10252           if (cust->user == NULL)
10253             cust->user = immediate_parent;
10254         }
10255     }
10256
10257   for (ix = 0;
10258        VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs, ix, iter);
10259        ++ix)
10260     {
10261       recursively_compute_inclusions (result, all_children,
10262                                       all_type_symtabs, iter, cust);
10263     }
10264 }
10265
10266 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
10267    PER_CU.  */
10268
10269 static void
10270 compute_compunit_symtab_includes (struct dwarf2_per_cu_data *per_cu)
10271 {
10272   gdb_assert (! per_cu->is_debug_types);
10273
10274   if (!VEC_empty (dwarf2_per_cu_ptr, per_cu->imported_symtabs))
10275     {
10276       int ix, len;
10277       struct dwarf2_per_cu_data *per_cu_iter;
10278       std::vector<compunit_symtab *> result_symtabs;
10279       htab_t all_children, all_type_symtabs;
10280       struct compunit_symtab *cust = get_compunit_symtab (per_cu);
10281
10282       /* If we don't have a symtab, we can just skip this case.  */
10283       if (cust == NULL)
10284         return;
10285
10286       all_children = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
10287                                         NULL, xcalloc, xfree);
10288       all_type_symtabs = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
10289                                             NULL, xcalloc, xfree);
10290
10291       for (ix = 0;
10292            VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs,
10293                         ix, per_cu_iter);
10294            ++ix)
10295         {
10296           recursively_compute_inclusions (&result_symtabs, all_children,
10297                                           all_type_symtabs, per_cu_iter,
10298                                           cust);
10299         }
10300
10301       /* Now we have a transitive closure of all the included symtabs.  */
10302       len = result_symtabs.size ();
10303       cust->includes
10304         = XOBNEWVEC (&per_cu->dwarf2_per_objfile->objfile->objfile_obstack,
10305                      struct compunit_symtab *, len + 1);
10306       memcpy (cust->includes, result_symtabs.data (),
10307               len * sizeof (compunit_symtab *));
10308       cust->includes[len] = NULL;
10309
10310       htab_delete (all_children);
10311       htab_delete (all_type_symtabs);
10312     }
10313 }
10314
10315 /* Compute the 'includes' field for the symtabs of all the CUs we just
10316    read.  */
10317
10318 static void
10319 process_cu_includes (struct dwarf2_per_objfile *dwarf2_per_objfile)
10320 {
10321   for (dwarf2_per_cu_data *iter : dwarf2_per_objfile->just_read_cus)
10322     {
10323       if (! iter->is_debug_types)
10324         compute_compunit_symtab_includes (iter);
10325     }
10326
10327   dwarf2_per_objfile->just_read_cus.clear ();
10328 }
10329
10330 /* Generate full symbol information for PER_CU, whose DIEs have
10331    already been loaded into memory.  */
10332
10333 static void
10334 process_full_comp_unit (struct dwarf2_per_cu_data *per_cu,
10335                         enum language pretend_language)
10336 {
10337   struct dwarf2_cu *cu = per_cu->cu;
10338   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
10339   struct objfile *objfile = dwarf2_per_objfile->objfile;
10340   struct gdbarch *gdbarch = get_objfile_arch (objfile);
10341   CORE_ADDR lowpc, highpc;
10342   struct compunit_symtab *cust;
10343   CORE_ADDR baseaddr;
10344   struct block *static_block;
10345   CORE_ADDR addr;
10346
10347   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
10348
10349   /* Clear the list here in case something was left over.  */
10350   cu->method_list.clear ();
10351
10352   cu->language = pretend_language;
10353   cu->language_defn = language_def (cu->language);
10354
10355   /* Do line number decoding in read_file_scope () */
10356   process_die (cu->dies, cu);
10357
10358   /* For now fudge the Go package.  */
10359   if (cu->language == language_go)
10360     fixup_go_packaging (cu);
10361
10362   /* Now that we have processed all the DIEs in the CU, all the types 
10363      should be complete, and it should now be safe to compute all of the
10364      physnames.  */
10365   compute_delayed_physnames (cu);
10366
10367   if (cu->language == language_rust)
10368     rust_union_quirks (cu);
10369
10370   /* Some compilers don't define a DW_AT_high_pc attribute for the
10371      compilation unit.  If the DW_AT_high_pc is missing, synthesize
10372      it, by scanning the DIE's below the compilation unit.  */
10373   get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
10374
10375   addr = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
10376   static_block = cu->get_builder ()->end_symtab_get_static_block (addr, 0, 1);
10377
10378   /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
10379      Also, DW_AT_ranges may record ranges not belonging to any child DIEs
10380      (such as virtual method tables).  Record the ranges in STATIC_BLOCK's
10381      addrmap to help ensure it has an accurate map of pc values belonging to
10382      this comp unit.  */
10383   dwarf2_record_block_ranges (cu->dies, static_block, baseaddr, cu);
10384
10385   cust = cu->get_builder ()->end_symtab_from_static_block (static_block,
10386                                                     SECT_OFF_TEXT (objfile),
10387                                                     0);
10388
10389   if (cust != NULL)
10390     {
10391       int gcc_4_minor = producer_is_gcc_ge_4 (cu->producer);
10392
10393       /* Set symtab language to language from DW_AT_language.  If the
10394          compilation is from a C file generated by language preprocessors, do
10395          not set the language if it was already deduced by start_subfile.  */
10396       if (!(cu->language == language_c
10397             && COMPUNIT_FILETABS (cust)->language != language_unknown))
10398         COMPUNIT_FILETABS (cust)->language = cu->language;
10399
10400       /* GCC-4.0 has started to support -fvar-tracking.  GCC-3.x still can
10401          produce DW_AT_location with location lists but it can be possibly
10402          invalid without -fvar-tracking.  Still up to GCC-4.4.x incl. 4.4.0
10403          there were bugs in prologue debug info, fixed later in GCC-4.5
10404          by "unwind info for epilogues" patch (which is not directly related).
10405
10406          For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
10407          needed, it would be wrong due to missing DW_AT_producer there.
10408
10409          Still one can confuse GDB by using non-standard GCC compilation
10410          options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
10411          */ 
10412       if (cu->has_loclist && gcc_4_minor >= 5)
10413         cust->locations_valid = 1;
10414
10415       if (gcc_4_minor >= 5)
10416         cust->epilogue_unwind_valid = 1;
10417
10418       cust->call_site_htab = cu->call_site_htab;
10419     }
10420
10421   if (dwarf2_per_objfile->using_index)
10422     per_cu->v.quick->compunit_symtab = cust;
10423   else
10424     {
10425       struct partial_symtab *pst = per_cu->v.psymtab;
10426       pst->compunit_symtab = cust;
10427       pst->readin = 1;
10428     }
10429
10430   /* Push it for inclusion processing later.  */
10431   dwarf2_per_objfile->just_read_cus.push_back (per_cu);
10432
10433   /* Not needed any more.  */
10434   cu->reset_builder ();
10435 }
10436
10437 /* Generate full symbol information for type unit PER_CU, whose DIEs have
10438    already been loaded into memory.  */
10439
10440 static void
10441 process_full_type_unit (struct dwarf2_per_cu_data *per_cu,
10442                         enum language pretend_language)
10443 {
10444   struct dwarf2_cu *cu = per_cu->cu;
10445   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
10446   struct objfile *objfile = dwarf2_per_objfile->objfile;
10447   struct compunit_symtab *cust;
10448   struct signatured_type *sig_type;
10449
10450   gdb_assert (per_cu->is_debug_types);
10451   sig_type = (struct signatured_type *) per_cu;
10452
10453   /* Clear the list here in case something was left over.  */
10454   cu->method_list.clear ();
10455
10456   cu->language = pretend_language;
10457   cu->language_defn = language_def (cu->language);
10458
10459   /* The symbol tables are set up in read_type_unit_scope.  */
10460   process_die (cu->dies, cu);
10461
10462   /* For now fudge the Go package.  */
10463   if (cu->language == language_go)
10464     fixup_go_packaging (cu);
10465
10466   /* Now that we have processed all the DIEs in the CU, all the types 
10467      should be complete, and it should now be safe to compute all of the
10468      physnames.  */
10469   compute_delayed_physnames (cu);
10470
10471   if (cu->language == language_rust)
10472     rust_union_quirks (cu);
10473
10474   /* TUs share symbol tables.
10475      If this is the first TU to use this symtab, complete the construction
10476      of it with end_expandable_symtab.  Otherwise, complete the addition of
10477      this TU's symbols to the existing symtab.  */
10478   if (sig_type->type_unit_group->compunit_symtab == NULL)
10479     {
10480       buildsym_compunit *builder = cu->get_builder ();
10481       cust = builder->end_expandable_symtab (0, SECT_OFF_TEXT (objfile));
10482       sig_type->type_unit_group->compunit_symtab = cust;
10483
10484       if (cust != NULL)
10485         {
10486           /* Set symtab language to language from DW_AT_language.  If the
10487              compilation is from a C file generated by language preprocessors,
10488              do not set the language if it was already deduced by
10489              start_subfile.  */
10490           if (!(cu->language == language_c
10491                 && COMPUNIT_FILETABS (cust)->language != language_c))
10492             COMPUNIT_FILETABS (cust)->language = cu->language;
10493         }
10494     }
10495   else
10496     {
10497       cu->get_builder ()->augment_type_symtab ();
10498       cust = sig_type->type_unit_group->compunit_symtab;
10499     }
10500
10501   if (dwarf2_per_objfile->using_index)
10502     per_cu->v.quick->compunit_symtab = cust;
10503   else
10504     {
10505       struct partial_symtab *pst = per_cu->v.psymtab;
10506       pst->compunit_symtab = cust;
10507       pst->readin = 1;
10508     }
10509
10510   /* Not needed any more.  */
10511   cu->reset_builder ();
10512 }
10513
10514 /* Process an imported unit DIE.  */
10515
10516 static void
10517 process_imported_unit_die (struct die_info *die, struct dwarf2_cu *cu)
10518 {
10519   struct attribute *attr;
10520
10521   /* For now we don't handle imported units in type units.  */
10522   if (cu->per_cu->is_debug_types)
10523     {
10524       error (_("Dwarf Error: DW_TAG_imported_unit is not"
10525                " supported in type units [in module %s]"),
10526              objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
10527     }
10528
10529   attr = dwarf2_attr (die, DW_AT_import, cu);
10530   if (attr != NULL)
10531     {
10532       sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
10533       bool is_dwz = (attr->form == DW_FORM_GNU_ref_alt || cu->per_cu->is_dwz);
10534       dwarf2_per_cu_data *per_cu
10535         = dwarf2_find_containing_comp_unit (sect_off, is_dwz,
10536                                             cu->per_cu->dwarf2_per_objfile);
10537
10538       /* If necessary, add it to the queue and load its DIEs.  */
10539       if (maybe_queue_comp_unit (cu, per_cu, cu->language))
10540         load_full_comp_unit (per_cu, false, cu->language);
10541
10542       VEC_safe_push (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
10543                      per_cu);
10544     }
10545 }
10546
10547 /* RAII object that represents a process_die scope: i.e.,
10548    starts/finishes processing a DIE.  */
10549 class process_die_scope
10550 {
10551 public:
10552   process_die_scope (die_info *die, dwarf2_cu *cu)
10553     : m_die (die), m_cu (cu)
10554   {
10555     /* We should only be processing DIEs not already in process.  */
10556     gdb_assert (!m_die->in_process);
10557     m_die->in_process = true;
10558   }
10559
10560   ~process_die_scope ()
10561   {
10562     m_die->in_process = false;
10563
10564     /* If we're done processing the DIE for the CU that owns the line
10565        header, we don't need the line header anymore.  */
10566     if (m_cu->line_header_die_owner == m_die)
10567       {
10568         delete m_cu->line_header;
10569         m_cu->line_header = NULL;
10570         m_cu->line_header_die_owner = NULL;
10571       }
10572   }
10573
10574 private:
10575   die_info *m_die;
10576   dwarf2_cu *m_cu;
10577 };
10578
10579 /* Process a die and its children.  */
10580
10581 static void
10582 process_die (struct die_info *die, struct dwarf2_cu *cu)
10583 {
10584   process_die_scope scope (die, cu);
10585
10586   switch (die->tag)
10587     {
10588     case DW_TAG_padding:
10589       break;
10590     case DW_TAG_compile_unit:
10591     case DW_TAG_partial_unit:
10592       read_file_scope (die, cu);
10593       break;
10594     case DW_TAG_type_unit:
10595       read_type_unit_scope (die, cu);
10596       break;
10597     case DW_TAG_subprogram:
10598     case DW_TAG_inlined_subroutine:
10599       read_func_scope (die, cu);
10600       break;
10601     case DW_TAG_lexical_block:
10602     case DW_TAG_try_block:
10603     case DW_TAG_catch_block:
10604       read_lexical_block_scope (die, cu);
10605       break;
10606     case DW_TAG_call_site:
10607     case DW_TAG_GNU_call_site:
10608       read_call_site_scope (die, cu);
10609       break;
10610     case DW_TAG_class_type:
10611     case DW_TAG_interface_type:
10612     case DW_TAG_structure_type:
10613     case DW_TAG_union_type:
10614       process_structure_scope (die, cu);
10615       break;
10616     case DW_TAG_enumeration_type:
10617       process_enumeration_scope (die, cu);
10618       break;
10619
10620     /* These dies have a type, but processing them does not create
10621        a symbol or recurse to process the children.  Therefore we can
10622        read them on-demand through read_type_die.  */
10623     case DW_TAG_subroutine_type:
10624     case DW_TAG_set_type:
10625     case DW_TAG_array_type:
10626     case DW_TAG_pointer_type:
10627     case DW_TAG_ptr_to_member_type:
10628     case DW_TAG_reference_type:
10629     case DW_TAG_rvalue_reference_type:
10630     case DW_TAG_string_type:
10631       break;
10632
10633     case DW_TAG_base_type:
10634     case DW_TAG_subrange_type:
10635     case DW_TAG_typedef:
10636       /* Add a typedef symbol for the type definition, if it has a
10637          DW_AT_name.  */
10638       new_symbol (die, read_type_die (die, cu), cu);
10639       break;
10640     case DW_TAG_common_block:
10641       read_common_block (die, cu);
10642       break;
10643     case DW_TAG_common_inclusion:
10644       break;
10645     case DW_TAG_namespace:
10646       cu->processing_has_namespace_info = true;
10647       read_namespace (die, cu);
10648       break;
10649     case DW_TAG_module:
10650       cu->processing_has_namespace_info = true;
10651       read_module (die, cu);
10652       break;
10653     case DW_TAG_imported_declaration:
10654       cu->processing_has_namespace_info = true;
10655       if (read_namespace_alias (die, cu))
10656         break;
10657       /* The declaration is not a global namespace alias.  */
10658       /* Fall through.  */
10659     case DW_TAG_imported_module:
10660       cu->processing_has_namespace_info = true;
10661       if (die->child != NULL && (die->tag == DW_TAG_imported_declaration
10662                                  || cu->language != language_fortran))
10663         complaint (_("Tag '%s' has unexpected children"),
10664                    dwarf_tag_name (die->tag));
10665       read_import_statement (die, cu);
10666       break;
10667
10668     case DW_TAG_imported_unit:
10669       process_imported_unit_die (die, cu);
10670       break;
10671
10672     case DW_TAG_variable:
10673       read_variable (die, cu);
10674       break;
10675
10676     default:
10677       new_symbol (die, NULL, cu);
10678       break;
10679     }
10680 }
10681 \f
10682 /* DWARF name computation.  */
10683
10684 /* A helper function for dwarf2_compute_name which determines whether DIE
10685    needs to have the name of the scope prepended to the name listed in the
10686    die.  */
10687
10688 static int
10689 die_needs_namespace (struct die_info *die, struct dwarf2_cu *cu)
10690 {
10691   struct attribute *attr;
10692
10693   switch (die->tag)
10694     {
10695     case DW_TAG_namespace:
10696     case DW_TAG_typedef:
10697     case DW_TAG_class_type:
10698     case DW_TAG_interface_type:
10699     case DW_TAG_structure_type:
10700     case DW_TAG_union_type:
10701     case DW_TAG_enumeration_type:
10702     case DW_TAG_enumerator:
10703     case DW_TAG_subprogram:
10704     case DW_TAG_inlined_subroutine:
10705     case DW_TAG_member:
10706     case DW_TAG_imported_declaration:
10707       return 1;
10708
10709     case DW_TAG_variable:
10710     case DW_TAG_constant:
10711       /* We only need to prefix "globally" visible variables.  These include
10712          any variable marked with DW_AT_external or any variable that
10713          lives in a namespace.  [Variables in anonymous namespaces
10714          require prefixing, but they are not DW_AT_external.]  */
10715
10716       if (dwarf2_attr (die, DW_AT_specification, cu))
10717         {
10718           struct dwarf2_cu *spec_cu = cu;
10719
10720           return die_needs_namespace (die_specification (die, &spec_cu),
10721                                       spec_cu);
10722         }
10723
10724       attr = dwarf2_attr (die, DW_AT_external, cu);
10725       if (attr == NULL && die->parent->tag != DW_TAG_namespace
10726           && die->parent->tag != DW_TAG_module)
10727         return 0;
10728       /* A variable in a lexical block of some kind does not need a
10729          namespace, even though in C++ such variables may be external
10730          and have a mangled name.  */
10731       if (die->parent->tag ==  DW_TAG_lexical_block
10732           || die->parent->tag ==  DW_TAG_try_block
10733           || die->parent->tag ==  DW_TAG_catch_block
10734           || die->parent->tag == DW_TAG_subprogram)
10735         return 0;
10736       return 1;
10737
10738     default:
10739       return 0;
10740     }
10741 }
10742
10743 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
10744    or DW_AT_MIPS_linkage_name.  Returns NULL if the attribute is not
10745    defined for the given DIE.  */
10746
10747 static struct attribute *
10748 dw2_linkage_name_attr (struct die_info *die, struct dwarf2_cu *cu)
10749 {
10750   struct attribute *attr;
10751
10752   attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
10753   if (attr == NULL)
10754     attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
10755
10756   return attr;
10757 }
10758
10759 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
10760    or DW_AT_MIPS_linkage_name.  Returns NULL if the attribute is not
10761    defined for the given DIE.  */
10762
10763 static const char *
10764 dw2_linkage_name (struct die_info *die, struct dwarf2_cu *cu)
10765 {
10766   const char *linkage_name;
10767
10768   linkage_name = dwarf2_string_attr (die, DW_AT_linkage_name, cu);
10769   if (linkage_name == NULL)
10770     linkage_name = dwarf2_string_attr (die, DW_AT_MIPS_linkage_name, cu);
10771
10772   return linkage_name;
10773 }
10774
10775 /* Compute the fully qualified name of DIE in CU.  If PHYSNAME is nonzero,
10776    compute the physname for the object, which include a method's:
10777    - formal parameters (C++),
10778    - receiver type (Go),
10779
10780    The term "physname" is a bit confusing.
10781    For C++, for example, it is the demangled name.
10782    For Go, for example, it's the mangled name.
10783
10784    For Ada, return the DIE's linkage name rather than the fully qualified
10785    name.  PHYSNAME is ignored..
10786
10787    The result is allocated on the objfile_obstack and canonicalized.  */
10788
10789 static const char *
10790 dwarf2_compute_name (const char *name,
10791                      struct die_info *die, struct dwarf2_cu *cu,
10792                      int physname)
10793 {
10794   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
10795
10796   if (name == NULL)
10797     name = dwarf2_name (die, cu);
10798
10799   /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
10800      but otherwise compute it by typename_concat inside GDB.
10801      FIXME: Actually this is not really true, or at least not always true.
10802      It's all very confusing.  SYMBOL_SET_NAMES doesn't try to demangle
10803      Fortran names because there is no mangling standard.  So new_symbol
10804      will set the demangled name to the result of dwarf2_full_name, and it is
10805      the demangled name that GDB uses if it exists.  */
10806   if (cu->language == language_ada
10807       || (cu->language == language_fortran && physname))
10808     {
10809       /* For Ada unit, we prefer the linkage name over the name, as
10810          the former contains the exported name, which the user expects
10811          to be able to reference.  Ideally, we want the user to be able
10812          to reference this entity using either natural or linkage name,
10813          but we haven't started looking at this enhancement yet.  */
10814       const char *linkage_name = dw2_linkage_name (die, cu);
10815
10816       if (linkage_name != NULL)
10817         return linkage_name;
10818     }
10819
10820   /* These are the only languages we know how to qualify names in.  */
10821   if (name != NULL
10822       && (cu->language == language_cplus
10823           || cu->language == language_fortran || cu->language == language_d
10824           || cu->language == language_rust))
10825     {
10826       if (die_needs_namespace (die, cu))
10827         {
10828           const char *prefix;
10829           const char *canonical_name = NULL;
10830
10831           string_file buf;
10832
10833           prefix = determine_prefix (die, cu);
10834           if (*prefix != '\0')
10835             {
10836               char *prefixed_name = typename_concat (NULL, prefix, name,
10837                                                      physname, cu);
10838
10839               buf.puts (prefixed_name);
10840               xfree (prefixed_name);
10841             }
10842           else
10843             buf.puts (name);
10844
10845           /* Template parameters may be specified in the DIE's DW_AT_name, or
10846              as children with DW_TAG_template_type_param or
10847              DW_TAG_value_type_param.  If the latter, add them to the name
10848              here.  If the name already has template parameters, then
10849              skip this step; some versions of GCC emit both, and
10850              it is more efficient to use the pre-computed name.
10851
10852              Something to keep in mind about this process: it is very
10853              unlikely, or in some cases downright impossible, to produce
10854              something that will match the mangled name of a function.
10855              If the definition of the function has the same debug info,
10856              we should be able to match up with it anyway.  But fallbacks
10857              using the minimal symbol, for instance to find a method
10858              implemented in a stripped copy of libstdc++, will not work.
10859              If we do not have debug info for the definition, we will have to
10860              match them up some other way.
10861
10862              When we do name matching there is a related problem with function
10863              templates; two instantiated function templates are allowed to
10864              differ only by their return types, which we do not add here.  */
10865
10866           if (cu->language == language_cplus && strchr (name, '<') == NULL)
10867             {
10868               struct attribute *attr;
10869               struct die_info *child;
10870               int first = 1;
10871
10872               die->building_fullname = 1;
10873
10874               for (child = die->child; child != NULL; child = child->sibling)
10875                 {
10876                   struct type *type;
10877                   LONGEST value;
10878                   const gdb_byte *bytes;
10879                   struct dwarf2_locexpr_baton *baton;
10880                   struct value *v;
10881
10882                   if (child->tag != DW_TAG_template_type_param
10883                       && child->tag != DW_TAG_template_value_param)
10884                     continue;
10885
10886                   if (first)
10887                     {
10888                       buf.puts ("<");
10889                       first = 0;
10890                     }
10891                   else
10892                     buf.puts (", ");
10893
10894                   attr = dwarf2_attr (child, DW_AT_type, cu);
10895                   if (attr == NULL)
10896                     {
10897                       complaint (_("template parameter missing DW_AT_type"));
10898                       buf.puts ("UNKNOWN_TYPE");
10899                       continue;
10900                     }
10901                   type = die_type (child, cu);
10902
10903                   if (child->tag == DW_TAG_template_type_param)
10904                     {
10905                       c_print_type (type, "", &buf, -1, 0, cu->language,
10906                                     &type_print_raw_options);
10907                       continue;
10908                     }
10909
10910                   attr = dwarf2_attr (child, DW_AT_const_value, cu);
10911                   if (attr == NULL)
10912                     {
10913                       complaint (_("template parameter missing "
10914                                    "DW_AT_const_value"));
10915                       buf.puts ("UNKNOWN_VALUE");
10916                       continue;
10917                     }
10918
10919                   dwarf2_const_value_attr (attr, type, name,
10920                                            &cu->comp_unit_obstack, cu,
10921                                            &value, &bytes, &baton);
10922
10923                   if (TYPE_NOSIGN (type))
10924                     /* GDB prints characters as NUMBER 'CHAR'.  If that's
10925                        changed, this can use value_print instead.  */
10926                     c_printchar (value, type, &buf);
10927                   else
10928                     {
10929                       struct value_print_options opts;
10930
10931                       if (baton != NULL)
10932                         v = dwarf2_evaluate_loc_desc (type, NULL,
10933                                                       baton->data,
10934                                                       baton->size,
10935                                                       baton->per_cu);
10936                       else if (bytes != NULL)
10937                         {
10938                           v = allocate_value (type);
10939                           memcpy (value_contents_writeable (v), bytes,
10940                                   TYPE_LENGTH (type));
10941                         }
10942                       else
10943                         v = value_from_longest (type, value);
10944
10945                       /* Specify decimal so that we do not depend on
10946                          the radix.  */
10947                       get_formatted_print_options (&opts, 'd');
10948                       opts.raw = 1;
10949                       value_print (v, &buf, &opts);
10950                       release_value (v);
10951                     }
10952                 }
10953
10954               die->building_fullname = 0;
10955
10956               if (!first)
10957                 {
10958                   /* Close the argument list, with a space if necessary
10959                      (nested templates).  */
10960                   if (!buf.empty () && buf.string ().back () == '>')
10961                     buf.puts (" >");
10962                   else
10963                     buf.puts (">");
10964                 }
10965             }
10966
10967           /* For C++ methods, append formal parameter type
10968              information, if PHYSNAME.  */
10969
10970           if (physname && die->tag == DW_TAG_subprogram
10971               && cu->language == language_cplus)
10972             {
10973               struct type *type = read_type_die (die, cu);
10974
10975               c_type_print_args (type, &buf, 1, cu->language,
10976                                  &type_print_raw_options);
10977
10978               if (cu->language == language_cplus)
10979                 {
10980                   /* Assume that an artificial first parameter is
10981                      "this", but do not crash if it is not.  RealView
10982                      marks unnamed (and thus unused) parameters as
10983                      artificial; there is no way to differentiate
10984                      the two cases.  */
10985                   if (TYPE_NFIELDS (type) > 0
10986                       && TYPE_FIELD_ARTIFICIAL (type, 0)
10987                       && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_PTR
10988                       && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type,
10989                                                                         0))))
10990                     buf.puts (" const");
10991                 }
10992             }
10993
10994           const std::string &intermediate_name = buf.string ();
10995
10996           if (cu->language == language_cplus)
10997             canonical_name
10998               = dwarf2_canonicalize_name (intermediate_name.c_str (), cu,
10999                                           &objfile->per_bfd->storage_obstack);
11000
11001           /* If we only computed INTERMEDIATE_NAME, or if
11002              INTERMEDIATE_NAME is already canonical, then we need to
11003              copy it to the appropriate obstack.  */
11004           if (canonical_name == NULL || canonical_name == intermediate_name.c_str ())
11005             name = ((const char *)
11006                     obstack_copy0 (&objfile->per_bfd->storage_obstack,
11007                                    intermediate_name.c_str (),
11008                                    intermediate_name.length ()));
11009           else
11010             name = canonical_name;
11011         }
11012     }
11013
11014   return name;
11015 }
11016
11017 /* Return the fully qualified name of DIE, based on its DW_AT_name.
11018    If scope qualifiers are appropriate they will be added.  The result
11019    will be allocated on the storage_obstack, or NULL if the DIE does
11020    not have a name.  NAME may either be from a previous call to
11021    dwarf2_name or NULL.
11022
11023    The output string will be canonicalized (if C++).  */
11024
11025 static const char *
11026 dwarf2_full_name (const char *name, struct die_info *die, struct dwarf2_cu *cu)
11027 {
11028   return dwarf2_compute_name (name, die, cu, 0);
11029 }
11030
11031 /* Construct a physname for the given DIE in CU.  NAME may either be
11032    from a previous call to dwarf2_name or NULL.  The result will be
11033    allocated on the objfile_objstack or NULL if the DIE does not have a
11034    name.
11035
11036    The output string will be canonicalized (if C++).  */
11037
11038 static const char *
11039 dwarf2_physname (const char *name, struct die_info *die, struct dwarf2_cu *cu)
11040 {
11041   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
11042   const char *retval, *mangled = NULL, *canon = NULL;
11043   int need_copy = 1;
11044
11045   /* In this case dwarf2_compute_name is just a shortcut not building anything
11046      on its own.  */
11047   if (!die_needs_namespace (die, cu))
11048     return dwarf2_compute_name (name, die, cu, 1);
11049
11050   mangled = dw2_linkage_name (die, cu);
11051
11052   /* rustc emits invalid values for DW_AT_linkage_name.  Ignore these.
11053      See https://github.com/rust-lang/rust/issues/32925.  */
11054   if (cu->language == language_rust && mangled != NULL
11055       && strchr (mangled, '{') != NULL)
11056     mangled = NULL;
11057
11058   /* DW_AT_linkage_name is missing in some cases - depend on what GDB
11059      has computed.  */
11060   gdb::unique_xmalloc_ptr<char> demangled;
11061   if (mangled != NULL)
11062     {
11063
11064       if (language_def (cu->language)->la_store_sym_names_in_linkage_form_p)
11065         {
11066           /* Do nothing (do not demangle the symbol name).  */
11067         }
11068       else if (cu->language == language_go)
11069         {
11070           /* This is a lie, but we already lie to the caller new_symbol.
11071              new_symbol assumes we return the mangled name.
11072              This just undoes that lie until things are cleaned up.  */
11073         }
11074       else
11075         {
11076           /* Use DMGL_RET_DROP for C++ template functions to suppress
11077              their return type.  It is easier for GDB users to search
11078              for such functions as `name(params)' than `long name(params)'.
11079              In such case the minimal symbol names do not match the full
11080              symbol names but for template functions there is never a need
11081              to look up their definition from their declaration so
11082              the only disadvantage remains the minimal symbol variant
11083              `long name(params)' does not have the proper inferior type.  */
11084           demangled.reset (gdb_demangle (mangled,
11085                                          (DMGL_PARAMS | DMGL_ANSI
11086                                           | DMGL_RET_DROP)));
11087         }
11088       if (demangled)
11089         canon = demangled.get ();
11090       else
11091         {
11092           canon = mangled;
11093           need_copy = 0;
11094         }
11095     }
11096
11097   if (canon == NULL || check_physname)
11098     {
11099       const char *physname = dwarf2_compute_name (name, die, cu, 1);
11100
11101       if (canon != NULL && strcmp (physname, canon) != 0)
11102         {
11103           /* It may not mean a bug in GDB.  The compiler could also
11104              compute DW_AT_linkage_name incorrectly.  But in such case
11105              GDB would need to be bug-to-bug compatible.  */
11106
11107           complaint (_("Computed physname <%s> does not match demangled <%s> "
11108                        "(from linkage <%s>) - DIE at %s [in module %s]"),
11109                      physname, canon, mangled, sect_offset_str (die->sect_off),
11110                      objfile_name (objfile));
11111
11112           /* Prefer DW_AT_linkage_name (in the CANON form) - when it
11113              is available here - over computed PHYSNAME.  It is safer
11114              against both buggy GDB and buggy compilers.  */
11115
11116           retval = canon;
11117         }
11118       else
11119         {
11120           retval = physname;
11121           need_copy = 0;
11122         }
11123     }
11124   else
11125     retval = canon;
11126
11127   if (need_copy)
11128     retval = ((const char *)
11129               obstack_copy0 (&objfile->per_bfd->storage_obstack,
11130                              retval, strlen (retval)));
11131
11132   return retval;
11133 }
11134
11135 /* Inspect DIE in CU for a namespace alias.  If one exists, record
11136    a new symbol for it.
11137
11138    Returns 1 if a namespace alias was recorded, 0 otherwise.  */
11139
11140 static int
11141 read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu)
11142 {
11143   struct attribute *attr;
11144
11145   /* If the die does not have a name, this is not a namespace
11146      alias.  */
11147   attr = dwarf2_attr (die, DW_AT_name, cu);
11148   if (attr != NULL)
11149     {
11150       int num;
11151       struct die_info *d = die;
11152       struct dwarf2_cu *imported_cu = cu;
11153
11154       /* If the compiler has nested DW_AT_imported_declaration DIEs,
11155          keep inspecting DIEs until we hit the underlying import.  */
11156 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
11157       for (num = 0; num  < MAX_NESTED_IMPORTED_DECLARATIONS; ++num)
11158         {
11159           attr = dwarf2_attr (d, DW_AT_import, cu);
11160           if (attr == NULL)
11161             break;
11162
11163           d = follow_die_ref (d, attr, &imported_cu);
11164           if (d->tag != DW_TAG_imported_declaration)
11165             break;
11166         }
11167
11168       if (num == MAX_NESTED_IMPORTED_DECLARATIONS)
11169         {
11170           complaint (_("DIE at %s has too many recursively imported "
11171                        "declarations"), sect_offset_str (d->sect_off));
11172           return 0;
11173         }
11174
11175       if (attr != NULL)
11176         {
11177           struct type *type;
11178           sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
11179
11180           type = get_die_type_at_offset (sect_off, cu->per_cu);
11181           if (type != NULL && TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
11182             {
11183               /* This declaration is a global namespace alias.  Add
11184                  a symbol for it whose type is the aliased namespace.  */
11185               new_symbol (die, type, cu);
11186               return 1;
11187             }
11188         }
11189     }
11190
11191   return 0;
11192 }
11193
11194 /* Return the using directives repository (global or local?) to use in the
11195    current context for CU.
11196
11197    For Ada, imported declarations can materialize renamings, which *may* be
11198    global.  However it is impossible (for now?) in DWARF to distinguish
11199    "external" imported declarations and "static" ones.  As all imported
11200    declarations seem to be static in all other languages, make them all CU-wide
11201    global only in Ada.  */
11202
11203 static struct using_direct **
11204 using_directives (struct dwarf2_cu *cu)
11205 {
11206   if (cu->language == language_ada
11207       && cu->get_builder ()->outermost_context_p ())
11208     return cu->get_builder ()->get_global_using_directives ();
11209   else
11210     return cu->get_builder ()->get_local_using_directives ();
11211 }
11212
11213 /* Read the import statement specified by the given die and record it.  */
11214
11215 static void
11216 read_import_statement (struct die_info *die, struct dwarf2_cu *cu)
11217 {
11218   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
11219   struct attribute *import_attr;
11220   struct die_info *imported_die, *child_die;
11221   struct dwarf2_cu *imported_cu;
11222   const char *imported_name;
11223   const char *imported_name_prefix;
11224   const char *canonical_name;
11225   const char *import_alias;
11226   const char *imported_declaration = NULL;
11227   const char *import_prefix;
11228   std::vector<const char *> excludes;
11229
11230   import_attr = dwarf2_attr (die, DW_AT_import, cu);
11231   if (import_attr == NULL)
11232     {
11233       complaint (_("Tag '%s' has no DW_AT_import"),
11234                  dwarf_tag_name (die->tag));
11235       return;
11236     }
11237
11238   imported_cu = cu;
11239   imported_die = follow_die_ref_or_sig (die, import_attr, &imported_cu);
11240   imported_name = dwarf2_name (imported_die, imported_cu);
11241   if (imported_name == NULL)
11242     {
11243       /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
11244
11245         The import in the following code:
11246         namespace A
11247           {
11248             typedef int B;
11249           }
11250
11251         int main ()
11252           {
11253             using A::B;
11254             B b;
11255             return b;
11256           }
11257
11258         ...
11259          <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
11260             <52>   DW_AT_decl_file   : 1
11261             <53>   DW_AT_decl_line   : 6
11262             <54>   DW_AT_import      : <0x75>
11263          <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
11264             <59>   DW_AT_name        : B
11265             <5b>   DW_AT_decl_file   : 1
11266             <5c>   DW_AT_decl_line   : 2
11267             <5d>   DW_AT_type        : <0x6e>
11268         ...
11269          <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
11270             <76>   DW_AT_byte_size   : 4
11271             <77>   DW_AT_encoding    : 5        (signed)
11272
11273         imports the wrong die ( 0x75 instead of 0x58 ).
11274         This case will be ignored until the gcc bug is fixed.  */
11275       return;
11276     }
11277
11278   /* Figure out the local name after import.  */
11279   import_alias = dwarf2_name (die, cu);
11280
11281   /* Figure out where the statement is being imported to.  */
11282   import_prefix = determine_prefix (die, cu);
11283
11284   /* Figure out what the scope of the imported die is and prepend it
11285      to the name of the imported die.  */
11286   imported_name_prefix = determine_prefix (imported_die, imported_cu);
11287
11288   if (imported_die->tag != DW_TAG_namespace
11289       && imported_die->tag != DW_TAG_module)
11290     {
11291       imported_declaration = imported_name;
11292       canonical_name = imported_name_prefix;
11293     }
11294   else if (strlen (imported_name_prefix) > 0)
11295     canonical_name = obconcat (&objfile->objfile_obstack,
11296                                imported_name_prefix,
11297                                (cu->language == language_d ? "." : "::"),
11298                                imported_name, (char *) NULL);
11299   else
11300     canonical_name = imported_name;
11301
11302   if (die->tag == DW_TAG_imported_module && cu->language == language_fortran)
11303     for (child_die = die->child; child_die && child_die->tag;
11304          child_die = sibling_die (child_die))
11305       {
11306         /* DWARF-4: A Fortran use statement with a “rename list” may be
11307            represented by an imported module entry with an import attribute
11308            referring to the module and owned entries corresponding to those
11309            entities that are renamed as part of being imported.  */
11310
11311         if (child_die->tag != DW_TAG_imported_declaration)
11312           {
11313             complaint (_("child DW_TAG_imported_declaration expected "
11314                          "- DIE at %s [in module %s]"),
11315                        sect_offset_str (child_die->sect_off),
11316                        objfile_name (objfile));
11317             continue;
11318           }
11319
11320         import_attr = dwarf2_attr (child_die, DW_AT_import, cu);
11321         if (import_attr == NULL)
11322           {
11323             complaint (_("Tag '%s' has no DW_AT_import"),
11324                        dwarf_tag_name (child_die->tag));
11325             continue;
11326           }
11327
11328         imported_cu = cu;
11329         imported_die = follow_die_ref_or_sig (child_die, import_attr,
11330                                               &imported_cu);
11331         imported_name = dwarf2_name (imported_die, imported_cu);
11332         if (imported_name == NULL)
11333           {
11334             complaint (_("child DW_TAG_imported_declaration has unknown "
11335                          "imported name - DIE at %s [in module %s]"),
11336                        sect_offset_str (child_die->sect_off),
11337                        objfile_name (objfile));
11338             continue;
11339           }
11340
11341         excludes.push_back (imported_name);
11342
11343         process_die (child_die, cu);
11344       }
11345
11346   add_using_directive (using_directives (cu),
11347                        import_prefix,
11348                        canonical_name,
11349                        import_alias,
11350                        imported_declaration,
11351                        excludes,
11352                        0,
11353                        &objfile->objfile_obstack);
11354 }
11355
11356 /* ICC<14 does not output the required DW_AT_declaration on incomplete
11357    types, but gives them a size of zero.  Starting with version 14,
11358    ICC is compatible with GCC.  */
11359
11360 static bool
11361 producer_is_icc_lt_14 (struct dwarf2_cu *cu)
11362 {
11363   if (!cu->checked_producer)
11364     check_producer (cu);
11365
11366   return cu->producer_is_icc_lt_14;
11367 }
11368
11369 /* ICC generates a DW_AT_type for C void functions.  This was observed on
11370    ICC 14.0.5.212, and appears to be against the DWARF spec (V5 3.3.2)
11371    which says that void functions should not have a DW_AT_type.  */
11372
11373 static bool
11374 producer_is_icc (struct dwarf2_cu *cu)
11375 {
11376   if (!cu->checked_producer)
11377     check_producer (cu);
11378
11379   return cu->producer_is_icc;
11380 }
11381
11382 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
11383    directory paths.  GCC SVN r127613 (new option -fdebug-prefix-map) fixed
11384    this, it was first present in GCC release 4.3.0.  */
11385
11386 static bool
11387 producer_is_gcc_lt_4_3 (struct dwarf2_cu *cu)
11388 {
11389   if (!cu->checked_producer)
11390     check_producer (cu);
11391
11392   return cu->producer_is_gcc_lt_4_3;
11393 }
11394
11395 static file_and_directory
11396 find_file_and_directory (struct die_info *die, struct dwarf2_cu *cu)
11397 {
11398   file_and_directory res;
11399
11400   /* Find the filename.  Do not use dwarf2_name here, since the filename
11401      is not a source language identifier.  */
11402   res.name = dwarf2_string_attr (die, DW_AT_name, cu);
11403   res.comp_dir = dwarf2_string_attr (die, DW_AT_comp_dir, cu);
11404
11405   if (res.comp_dir == NULL
11406       && producer_is_gcc_lt_4_3 (cu) && res.name != NULL
11407       && IS_ABSOLUTE_PATH (res.name))
11408     {
11409       res.comp_dir_storage = ldirname (res.name);
11410       if (!res.comp_dir_storage.empty ())
11411         res.comp_dir = res.comp_dir_storage.c_str ();
11412     }
11413   if (res.comp_dir != NULL)
11414     {
11415       /* Irix 6.2 native cc prepends <machine>.: to the compilation
11416          directory, get rid of it.  */
11417       const char *cp = strchr (res.comp_dir, ':');
11418
11419       if (cp && cp != res.comp_dir && cp[-1] == '.' && cp[1] == '/')
11420         res.comp_dir = cp + 1;
11421     }
11422
11423   if (res.name == NULL)
11424     res.name = "<unknown>";
11425
11426   return res;
11427 }
11428
11429 /* Handle DW_AT_stmt_list for a compilation unit.
11430    DIE is the DW_TAG_compile_unit die for CU.
11431    COMP_DIR is the compilation directory.  LOWPC is passed to
11432    dwarf_decode_lines.  See dwarf_decode_lines comments about it.  */
11433
11434 static void
11435 handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
11436                         const char *comp_dir, CORE_ADDR lowpc) /* ARI: editCase function */
11437 {
11438   struct dwarf2_per_objfile *dwarf2_per_objfile
11439     = cu->per_cu->dwarf2_per_objfile;
11440   struct objfile *objfile = dwarf2_per_objfile->objfile;
11441   struct attribute *attr;
11442   struct line_header line_header_local;
11443   hashval_t line_header_local_hash;
11444   void **slot;
11445   int decode_mapping;
11446
11447   gdb_assert (! cu->per_cu->is_debug_types);
11448
11449   attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
11450   if (attr == NULL)
11451     return;
11452
11453   sect_offset line_offset = (sect_offset) DW_UNSND (attr);
11454
11455   /* The line header hash table is only created if needed (it exists to
11456      prevent redundant reading of the line table for partial_units).
11457      If we're given a partial_unit, we'll need it.  If we're given a
11458      compile_unit, then use the line header hash table if it's already
11459      created, but don't create one just yet.  */
11460
11461   if (dwarf2_per_objfile->line_header_hash == NULL
11462       && die->tag == DW_TAG_partial_unit)
11463     {
11464       dwarf2_per_objfile->line_header_hash
11465         = htab_create_alloc_ex (127, line_header_hash_voidp,
11466                                 line_header_eq_voidp,
11467                                 free_line_header_voidp,
11468                                 &objfile->objfile_obstack,
11469                                 hashtab_obstack_allocate,
11470                                 dummy_obstack_deallocate);
11471     }
11472
11473   line_header_local.sect_off = line_offset;
11474   line_header_local.offset_in_dwz = cu->per_cu->is_dwz;
11475   line_header_local_hash = line_header_hash (&line_header_local);
11476   if (dwarf2_per_objfile->line_header_hash != NULL)
11477     {
11478       slot = htab_find_slot_with_hash (dwarf2_per_objfile->line_header_hash,
11479                                        &line_header_local,
11480                                        line_header_local_hash, NO_INSERT);
11481
11482       /* For DW_TAG_compile_unit we need info like symtab::linetable which
11483          is not present in *SLOT (since if there is something in *SLOT then
11484          it will be for a partial_unit).  */
11485       if (die->tag == DW_TAG_partial_unit && slot != NULL)
11486         {
11487           gdb_assert (*slot != NULL);
11488           cu->line_header = (struct line_header *) *slot;
11489           return;
11490         }
11491     }
11492
11493   /* dwarf_decode_line_header does not yet provide sufficient information.
11494      We always have to call also dwarf_decode_lines for it.  */
11495   line_header_up lh = dwarf_decode_line_header (line_offset, cu);
11496   if (lh == NULL)
11497     return;
11498
11499   cu->line_header = lh.release ();
11500   cu->line_header_die_owner = die;
11501
11502   if (dwarf2_per_objfile->line_header_hash == NULL)
11503     slot = NULL;
11504   else
11505     {
11506       slot = htab_find_slot_with_hash (dwarf2_per_objfile->line_header_hash,
11507                                        &line_header_local,
11508                                        line_header_local_hash, INSERT);
11509       gdb_assert (slot != NULL);
11510     }
11511   if (slot != NULL && *slot == NULL)
11512     {
11513       /* This newly decoded line number information unit will be owned
11514          by line_header_hash hash table.  */
11515       *slot = cu->line_header;
11516       cu->line_header_die_owner = NULL;
11517     }
11518   else
11519     {
11520       /* We cannot free any current entry in (*slot) as that struct line_header
11521          may be already used by multiple CUs.  Create only temporary decoded
11522          line_header for this CU - it may happen at most once for each line
11523          number information unit.  And if we're not using line_header_hash
11524          then this is what we want as well.  */
11525       gdb_assert (die->tag != DW_TAG_partial_unit);
11526     }
11527   decode_mapping = (die->tag != DW_TAG_partial_unit);
11528   dwarf_decode_lines (cu->line_header, comp_dir, cu, NULL, lowpc,
11529                       decode_mapping);
11530
11531 }
11532
11533 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit.  */
11534
11535 static void
11536 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
11537 {
11538   struct dwarf2_per_objfile *dwarf2_per_objfile
11539     = cu->per_cu->dwarf2_per_objfile;
11540   struct objfile *objfile = dwarf2_per_objfile->objfile;
11541   struct gdbarch *gdbarch = get_objfile_arch (objfile);
11542   CORE_ADDR lowpc = ((CORE_ADDR) -1);
11543   CORE_ADDR highpc = ((CORE_ADDR) 0);
11544   struct attribute *attr;
11545   struct die_info *child_die;
11546   CORE_ADDR baseaddr;
11547
11548   prepare_one_comp_unit (cu, die, cu->language);
11549   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11550
11551   get_scope_pc_bounds (die, &lowpc, &highpc, cu);
11552
11553   /* If we didn't find a lowpc, set it to highpc to avoid complaints
11554      from finish_block.  */
11555   if (lowpc == ((CORE_ADDR) -1))
11556     lowpc = highpc;
11557   lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
11558
11559   file_and_directory fnd = find_file_and_directory (die, cu);
11560
11561   /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
11562      standardised yet.  As a workaround for the language detection we fall
11563      back to the DW_AT_producer string.  */
11564   if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL") != NULL)
11565     cu->language = language_opencl;
11566
11567   /* Similar hack for Go.  */
11568   if (cu->producer && strstr (cu->producer, "GNU Go ") != NULL)
11569     set_cu_language (DW_LANG_Go, cu);
11570
11571   cu->start_symtab (fnd.name, fnd.comp_dir, lowpc);
11572
11573   /* Decode line number information if present.  We do this before
11574      processing child DIEs, so that the line header table is available
11575      for DW_AT_decl_file.  */
11576   handle_DW_AT_stmt_list (die, cu, fnd.comp_dir, lowpc);
11577
11578   /* Process all dies in compilation unit.  */
11579   if (die->child != NULL)
11580     {
11581       child_die = die->child;
11582       while (child_die && child_die->tag)
11583         {
11584           process_die (child_die, cu);
11585           child_die = sibling_die (child_die);
11586         }
11587     }
11588
11589   /* Decode macro information, if present.  Dwarf 2 macro information
11590      refers to information in the line number info statement program
11591      header, so we can only read it if we've read the header
11592      successfully.  */
11593   attr = dwarf2_attr (die, DW_AT_macros, cu);
11594   if (attr == NULL)
11595     attr = dwarf2_attr (die, DW_AT_GNU_macros, cu);
11596   if (attr && cu->line_header)
11597     {
11598       if (dwarf2_attr (die, DW_AT_macro_info, cu))
11599         complaint (_("CU refers to both DW_AT_macros and DW_AT_macro_info"));
11600
11601       dwarf_decode_macros (cu, DW_UNSND (attr), 1);
11602     }
11603   else
11604     {
11605       attr = dwarf2_attr (die, DW_AT_macro_info, cu);
11606       if (attr && cu->line_header)
11607         {
11608           unsigned int macro_offset = DW_UNSND (attr);
11609
11610           dwarf_decode_macros (cu, macro_offset, 0);
11611         }
11612     }
11613 }
11614
11615 void
11616 dwarf2_cu::setup_type_unit_groups (struct die_info *die)
11617 {
11618   struct type_unit_group *tu_group;
11619   int first_time;
11620   struct attribute *attr;
11621   unsigned int i;
11622   struct signatured_type *sig_type;
11623
11624   gdb_assert (per_cu->is_debug_types);
11625   sig_type = (struct signatured_type *) per_cu;
11626
11627   attr = dwarf2_attr (die, DW_AT_stmt_list, this);
11628
11629   /* If we're using .gdb_index (includes -readnow) then
11630      per_cu->type_unit_group may not have been set up yet.  */
11631   if (sig_type->type_unit_group == NULL)
11632     sig_type->type_unit_group = get_type_unit_group (this, attr);
11633   tu_group = sig_type->type_unit_group;
11634
11635   /* If we've already processed this stmt_list there's no real need to
11636      do it again, we could fake it and just recreate the part we need
11637      (file name,index -> symtab mapping).  If data shows this optimization
11638      is useful we can do it then.  */
11639   first_time = tu_group->compunit_symtab == NULL;
11640
11641   /* We have to handle the case of both a missing DW_AT_stmt_list or bad
11642      debug info.  */
11643   line_header_up lh;
11644   if (attr != NULL)
11645     {
11646       sect_offset line_offset = (sect_offset) DW_UNSND (attr);
11647       lh = dwarf_decode_line_header (line_offset, this);
11648     }
11649   if (lh == NULL)
11650     {
11651       if (first_time)
11652         start_symtab ("", NULL, 0);
11653       else
11654         {
11655           gdb_assert (tu_group->symtabs == NULL);
11656           gdb_assert (m_builder == nullptr);
11657           struct compunit_symtab *cust = tu_group->compunit_symtab;
11658           m_builder.reset (new struct buildsym_compunit
11659                            (COMPUNIT_OBJFILE (cust), "",
11660                             COMPUNIT_DIRNAME (cust),
11661                             compunit_language (cust),
11662                             0, cust));
11663         }
11664       return;
11665     }
11666
11667   line_header = lh.release ();
11668   line_header_die_owner = die;
11669
11670   if (first_time)
11671     {
11672       struct compunit_symtab *cust = start_symtab ("", NULL, 0);
11673
11674       /* Note: We don't assign tu_group->compunit_symtab yet because we're
11675          still initializing it, and our caller (a few levels up)
11676          process_full_type_unit still needs to know if this is the first
11677          time.  */
11678
11679       tu_group->num_symtabs = line_header->file_names.size ();
11680       tu_group->symtabs = XNEWVEC (struct symtab *,
11681                                    line_header->file_names.size ());
11682
11683       for (i = 0; i < line_header->file_names.size (); ++i)
11684         {
11685           file_entry &fe = line_header->file_names[i];
11686
11687           dwarf2_start_subfile (this, fe.name,
11688                                 fe.include_dir (line_header));
11689           buildsym_compunit *b = get_builder ();
11690           if (b->get_current_subfile ()->symtab == NULL)
11691             {
11692               /* NOTE: start_subfile will recognize when it's been
11693                  passed a file it has already seen.  So we can't
11694                  assume there's a simple mapping from
11695                  cu->line_header->file_names to subfiles, plus
11696                  cu->line_header->file_names may contain dups.  */
11697               b->get_current_subfile ()->symtab
11698                 = allocate_symtab (cust, b->get_current_subfile ()->name);
11699             }
11700
11701           fe.symtab = b->get_current_subfile ()->symtab;
11702           tu_group->symtabs[i] = fe.symtab;
11703         }
11704     }
11705   else
11706     {
11707       gdb_assert (m_builder == nullptr);
11708       struct compunit_symtab *cust = tu_group->compunit_symtab;
11709       m_builder.reset (new struct buildsym_compunit
11710                        (COMPUNIT_OBJFILE (cust), "",
11711                         COMPUNIT_DIRNAME (cust),
11712                         compunit_language (cust),
11713                         0, cust));
11714
11715       for (i = 0; i < line_header->file_names.size (); ++i)
11716         {
11717           file_entry &fe = line_header->file_names[i];
11718
11719           fe.symtab = tu_group->symtabs[i];
11720         }
11721     }
11722
11723   /* The main symtab is allocated last.  Type units don't have DW_AT_name
11724      so they don't have a "real" (so to speak) symtab anyway.
11725      There is later code that will assign the main symtab to all symbols
11726      that don't have one.  We need to handle the case of a symbol with a
11727      missing symtab (DW_AT_decl_file) anyway.  */
11728 }
11729
11730 /* Process DW_TAG_type_unit.
11731    For TUs we want to skip the first top level sibling if it's not the
11732    actual type being defined by this TU.  In this case the first top
11733    level sibling is there to provide context only.  */
11734
11735 static void
11736 read_type_unit_scope (struct die_info *die, struct dwarf2_cu *cu)
11737 {
11738   struct die_info *child_die;
11739
11740   prepare_one_comp_unit (cu, die, language_minimal);
11741
11742   /* Initialize (or reinitialize) the machinery for building symtabs.
11743      We do this before processing child DIEs, so that the line header table
11744      is available for DW_AT_decl_file.  */
11745   cu->setup_type_unit_groups (die);
11746
11747   if (die->child != NULL)
11748     {
11749       child_die = die->child;
11750       while (child_die && child_die->tag)
11751         {
11752           process_die (child_die, cu);
11753           child_die = sibling_die (child_die);
11754         }
11755     }
11756 }
11757 \f
11758 /* DWO/DWP files.
11759
11760    http://gcc.gnu.org/wiki/DebugFission
11761    http://gcc.gnu.org/wiki/DebugFissionDWP
11762
11763    To simplify handling of both DWO files ("object" files with the DWARF info)
11764    and DWP files (a file with the DWOs packaged up into one file), we treat
11765    DWP files as having a collection of virtual DWO files.  */
11766
11767 static hashval_t
11768 hash_dwo_file (const void *item)
11769 {
11770   const struct dwo_file *dwo_file = (const struct dwo_file *) item;
11771   hashval_t hash;
11772
11773   hash = htab_hash_string (dwo_file->dwo_name);
11774   if (dwo_file->comp_dir != NULL)
11775     hash += htab_hash_string (dwo_file->comp_dir);
11776   return hash;
11777 }
11778
11779 static int
11780 eq_dwo_file (const void *item_lhs, const void *item_rhs)
11781 {
11782   const struct dwo_file *lhs = (const struct dwo_file *) item_lhs;
11783   const struct dwo_file *rhs = (const struct dwo_file *) item_rhs;
11784
11785   if (strcmp (lhs->dwo_name, rhs->dwo_name) != 0)
11786     return 0;
11787   if (lhs->comp_dir == NULL || rhs->comp_dir == NULL)
11788     return lhs->comp_dir == rhs->comp_dir;
11789   return strcmp (lhs->comp_dir, rhs->comp_dir) == 0;
11790 }
11791
11792 /* Allocate a hash table for DWO files.  */
11793
11794 static htab_t
11795 allocate_dwo_file_hash_table (struct objfile *objfile)
11796 {
11797   return htab_create_alloc_ex (41,
11798                                hash_dwo_file,
11799                                eq_dwo_file,
11800                                NULL,
11801                                &objfile->objfile_obstack,
11802                                hashtab_obstack_allocate,
11803                                dummy_obstack_deallocate);
11804 }
11805
11806 /* Lookup DWO file DWO_NAME.  */
11807
11808 static void **
11809 lookup_dwo_file_slot (struct dwarf2_per_objfile *dwarf2_per_objfile,
11810                       const char *dwo_name,
11811                       const char *comp_dir)
11812 {
11813   struct dwo_file find_entry;
11814   void **slot;
11815
11816   if (dwarf2_per_objfile->dwo_files == NULL)
11817     dwarf2_per_objfile->dwo_files
11818       = allocate_dwo_file_hash_table (dwarf2_per_objfile->objfile);
11819
11820   memset (&find_entry, 0, sizeof (find_entry));
11821   find_entry.dwo_name = dwo_name;
11822   find_entry.comp_dir = comp_dir;
11823   slot = htab_find_slot (dwarf2_per_objfile->dwo_files, &find_entry, INSERT);
11824
11825   return slot;
11826 }
11827
11828 static hashval_t
11829 hash_dwo_unit (const void *item)
11830 {
11831   const struct dwo_unit *dwo_unit = (const struct dwo_unit *) item;
11832
11833   /* This drops the top 32 bits of the id, but is ok for a hash.  */
11834   return dwo_unit->signature;
11835 }
11836
11837 static int
11838 eq_dwo_unit (const void *item_lhs, const void *item_rhs)
11839 {
11840   const struct dwo_unit *lhs = (const struct dwo_unit *) item_lhs;
11841   const struct dwo_unit *rhs = (const struct dwo_unit *) item_rhs;
11842
11843   /* The signature is assumed to be unique within the DWO file.
11844      So while object file CU dwo_id's always have the value zero,
11845      that's OK, assuming each object file DWO file has only one CU,
11846      and that's the rule for now.  */
11847   return lhs->signature == rhs->signature;
11848 }
11849
11850 /* Allocate a hash table for DWO CUs,TUs.
11851    There is one of these tables for each of CUs,TUs for each DWO file.  */
11852
11853 static htab_t
11854 allocate_dwo_unit_table (struct objfile *objfile)
11855 {
11856   /* Start out with a pretty small number.
11857      Generally DWO files contain only one CU and maybe some TUs.  */
11858   return htab_create_alloc_ex (3,
11859                                hash_dwo_unit,
11860                                eq_dwo_unit,
11861                                NULL,
11862                                &objfile->objfile_obstack,
11863                                hashtab_obstack_allocate,
11864                                dummy_obstack_deallocate);
11865 }
11866
11867 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader.  */
11868
11869 struct create_dwo_cu_data
11870 {
11871   struct dwo_file *dwo_file;
11872   struct dwo_unit dwo_unit;
11873 };
11874
11875 /* die_reader_func for create_dwo_cu.  */
11876
11877 static void
11878 create_dwo_cu_reader (const struct die_reader_specs *reader,
11879                       const gdb_byte *info_ptr,
11880                       struct die_info *comp_unit_die,
11881                       int has_children,
11882                       void *datap)
11883 {
11884   struct dwarf2_cu *cu = reader->cu;
11885   sect_offset sect_off = cu->per_cu->sect_off;
11886   struct dwarf2_section_info *section = cu->per_cu->section;
11887   struct create_dwo_cu_data *data = (struct create_dwo_cu_data *) datap;
11888   struct dwo_file *dwo_file = data->dwo_file;
11889   struct dwo_unit *dwo_unit = &data->dwo_unit;
11890   struct attribute *attr;
11891
11892   attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
11893   if (attr == NULL)
11894     {
11895       complaint (_("Dwarf Error: debug entry at offset %s is missing"
11896                    " its dwo_id [in module %s]"),
11897                  sect_offset_str (sect_off), dwo_file->dwo_name);
11898       return;
11899     }
11900
11901   dwo_unit->dwo_file = dwo_file;
11902   dwo_unit->signature = DW_UNSND (attr);
11903   dwo_unit->section = section;
11904   dwo_unit->sect_off = sect_off;
11905   dwo_unit->length = cu->per_cu->length;
11906
11907   if (dwarf_read_debug)
11908     fprintf_unfiltered (gdb_stdlog, "  offset %s, dwo_id %s\n",
11909                         sect_offset_str (sect_off),
11910                         hex_string (dwo_unit->signature));
11911 }
11912
11913 /* Create the dwo_units for the CUs in a DWO_FILE.
11914    Note: This function processes DWO files only, not DWP files.  */
11915
11916 static void
11917 create_cus_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
11918                        struct dwo_file &dwo_file, dwarf2_section_info &section,
11919                        htab_t &cus_htab)
11920 {
11921   struct objfile *objfile = dwarf2_per_objfile->objfile;
11922   const gdb_byte *info_ptr, *end_ptr;
11923
11924   dwarf2_read_section (objfile, &section);
11925   info_ptr = section.buffer;
11926
11927   if (info_ptr == NULL)
11928     return;
11929
11930   if (dwarf_read_debug)
11931     {
11932       fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
11933                           get_section_name (&section),
11934                           get_section_file_name (&section));
11935     }
11936
11937   end_ptr = info_ptr + section.size;
11938   while (info_ptr < end_ptr)
11939     {
11940       struct dwarf2_per_cu_data per_cu;
11941       struct create_dwo_cu_data create_dwo_cu_data;
11942       struct dwo_unit *dwo_unit;
11943       void **slot;
11944       sect_offset sect_off = (sect_offset) (info_ptr - section.buffer);
11945
11946       memset (&create_dwo_cu_data.dwo_unit, 0,
11947               sizeof (create_dwo_cu_data.dwo_unit));
11948       memset (&per_cu, 0, sizeof (per_cu));
11949       per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
11950       per_cu.is_debug_types = 0;
11951       per_cu.sect_off = sect_offset (info_ptr - section.buffer);
11952       per_cu.section = &section;
11953       create_dwo_cu_data.dwo_file = &dwo_file;
11954
11955       init_cutu_and_read_dies_no_follow (
11956           &per_cu, &dwo_file, create_dwo_cu_reader, &create_dwo_cu_data);
11957       info_ptr += per_cu.length;
11958
11959       // If the unit could not be parsed, skip it.
11960       if (create_dwo_cu_data.dwo_unit.dwo_file == NULL)
11961         continue;
11962
11963       if (cus_htab == NULL)
11964         cus_htab = allocate_dwo_unit_table (objfile);
11965
11966       dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
11967       *dwo_unit = create_dwo_cu_data.dwo_unit;
11968       slot = htab_find_slot (cus_htab, dwo_unit, INSERT);
11969       gdb_assert (slot != NULL);
11970       if (*slot != NULL)
11971         {
11972           const struct dwo_unit *dup_cu = (const struct dwo_unit *)*slot;
11973           sect_offset dup_sect_off = dup_cu->sect_off;
11974
11975           complaint (_("debug cu entry at offset %s is duplicate to"
11976                        " the entry at offset %s, signature %s"),
11977                      sect_offset_str (sect_off), sect_offset_str (dup_sect_off),
11978                      hex_string (dwo_unit->signature));
11979         }
11980       *slot = (void *)dwo_unit;
11981     }
11982 }
11983
11984 /* DWP file .debug_{cu,tu}_index section format:
11985    [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
11986
11987    DWP Version 1:
11988
11989    Both index sections have the same format, and serve to map a 64-bit
11990    signature to a set of section numbers.  Each section begins with a header,
11991    followed by a hash table of 64-bit signatures, a parallel table of 32-bit
11992    indexes, and a pool of 32-bit section numbers.  The index sections will be
11993    aligned at 8-byte boundaries in the file.
11994
11995    The index section header consists of:
11996
11997     V, 32 bit version number
11998     -, 32 bits unused
11999     N, 32 bit number of compilation units or type units in the index
12000     M, 32 bit number of slots in the hash table
12001
12002    Numbers are recorded using the byte order of the application binary.
12003
12004    The hash table begins at offset 16 in the section, and consists of an array
12005    of M 64-bit slots.  Each slot contains a 64-bit signature (using the byte
12006    order of the application binary).  Unused slots in the hash table are 0.
12007    (We rely on the extreme unlikeliness of a signature being exactly 0.)
12008
12009    The parallel table begins immediately after the hash table
12010    (at offset 16 + 8 * M from the beginning of the section), and consists of an
12011    array of 32-bit indexes (using the byte order of the application binary),
12012    corresponding 1-1 with slots in the hash table.  Each entry in the parallel
12013    table contains a 32-bit index into the pool of section numbers.  For unused
12014    hash table slots, the corresponding entry in the parallel table will be 0.
12015
12016    The pool of section numbers begins immediately following the hash table
12017    (at offset 16 + 12 * M from the beginning of the section).  The pool of
12018    section numbers consists of an array of 32-bit words (using the byte order
12019    of the application binary).  Each item in the array is indexed starting
12020    from 0.  The hash table entry provides the index of the first section
12021    number in the set.  Additional section numbers in the set follow, and the
12022    set is terminated by a 0 entry (section number 0 is not used in ELF).
12023
12024    In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
12025    section must be the first entry in the set, and the .debug_abbrev.dwo must
12026    be the second entry. Other members of the set may follow in any order.
12027
12028    ---
12029
12030    DWP Version 2:
12031
12032    DWP Version 2 combines all the .debug_info, etc. sections into one,
12033    and the entries in the index tables are now offsets into these sections.
12034    CU offsets begin at 0.  TU offsets begin at the size of the .debug_info
12035    section.
12036
12037    Index Section Contents:
12038     Header
12039     Hash Table of Signatures   dwp_hash_table.hash_table
12040     Parallel Table of Indices  dwp_hash_table.unit_table
12041     Table of Section Offsets   dwp_hash_table.v2.{section_ids,offsets}
12042     Table of Section Sizes     dwp_hash_table.v2.sizes
12043
12044    The index section header consists of:
12045
12046     V, 32 bit version number
12047     L, 32 bit number of columns in the table of section offsets
12048     N, 32 bit number of compilation units or type units in the index
12049     M, 32 bit number of slots in the hash table
12050
12051    Numbers are recorded using the byte order of the application binary.
12052
12053    The hash table has the same format as version 1.
12054    The parallel table of indices has the same format as version 1,
12055    except that the entries are origin-1 indices into the table of sections
12056    offsets and the table of section sizes.
12057
12058    The table of offsets begins immediately following the parallel table
12059    (at offset 16 + 12 * M from the beginning of the section).  The table is
12060    a two-dimensional array of 32-bit words (using the byte order of the
12061    application binary), with L columns and N+1 rows, in row-major order.
12062    Each row in the array is indexed starting from 0.  The first row provides
12063    a key to the remaining rows: each column in this row provides an identifier
12064    for a debug section, and the offsets in the same column of subsequent rows
12065    refer to that section.  The section identifiers are:
12066
12067     DW_SECT_INFO         1  .debug_info.dwo
12068     DW_SECT_TYPES        2  .debug_types.dwo
12069     DW_SECT_ABBREV       3  .debug_abbrev.dwo
12070     DW_SECT_LINE         4  .debug_line.dwo
12071     DW_SECT_LOC          5  .debug_loc.dwo
12072     DW_SECT_STR_OFFSETS  6  .debug_str_offsets.dwo
12073     DW_SECT_MACINFO      7  .debug_macinfo.dwo
12074     DW_SECT_MACRO        8  .debug_macro.dwo
12075
12076    The offsets provided by the CU and TU index sections are the base offsets
12077    for the contributions made by each CU or TU to the corresponding section
12078    in the package file.  Each CU and TU header contains an abbrev_offset
12079    field, used to find the abbreviations table for that CU or TU within the
12080    contribution to the .debug_abbrev.dwo section for that CU or TU, and should
12081    be interpreted as relative to the base offset given in the index section.
12082    Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
12083    should be interpreted as relative to the base offset for .debug_line.dwo,
12084    and offsets into other debug sections obtained from DWARF attributes should
12085    also be interpreted as relative to the corresponding base offset.
12086
12087    The table of sizes begins immediately following the table of offsets.
12088    Like the table of offsets, it is a two-dimensional array of 32-bit words,
12089    with L columns and N rows, in row-major order.  Each row in the array is
12090    indexed starting from 1 (row 0 is shared by the two tables).
12091
12092    ---
12093
12094    Hash table lookup is handled the same in version 1 and 2:
12095
12096    We assume that N and M will not exceed 2^32 - 1.
12097    The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
12098
12099    Given a 64-bit compilation unit signature or a type signature S, an entry
12100    in the hash table is located as follows:
12101
12102    1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
12103       the low-order k bits all set to 1.
12104
12105    2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
12106
12107    3) If the hash table entry at index H matches the signature, use that
12108       entry.  If the hash table entry at index H is unused (all zeroes),
12109       terminate the search: the signature is not present in the table.
12110
12111    4) Let H = (H + H') modulo M. Repeat at Step 3.
12112
12113    Because M > N and H' and M are relatively prime, the search is guaranteed
12114    to stop at an unused slot or find the match.  */
12115
12116 /* Create a hash table to map DWO IDs to their CU/TU entry in
12117    .debug_{info,types}.dwo in DWP_FILE.
12118    Returns NULL if there isn't one.
12119    Note: This function processes DWP files only, not DWO files.  */
12120
12121 static struct dwp_hash_table *
12122 create_dwp_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
12123                        struct dwp_file *dwp_file, int is_debug_types)
12124 {
12125   struct objfile *objfile = dwarf2_per_objfile->objfile;
12126   bfd *dbfd = dwp_file->dbfd.get ();
12127   const gdb_byte *index_ptr, *index_end;
12128   struct dwarf2_section_info *index;
12129   uint32_t version, nr_columns, nr_units, nr_slots;
12130   struct dwp_hash_table *htab;
12131
12132   if (is_debug_types)
12133     index = &dwp_file->sections.tu_index;
12134   else
12135     index = &dwp_file->sections.cu_index;
12136
12137   if (dwarf2_section_empty_p (index))
12138     return NULL;
12139   dwarf2_read_section (objfile, index);
12140
12141   index_ptr = index->buffer;
12142   index_end = index_ptr + index->size;
12143
12144   version = read_4_bytes (dbfd, index_ptr);
12145   index_ptr += 4;
12146   if (version == 2)
12147     nr_columns = read_4_bytes (dbfd, index_ptr);
12148   else
12149     nr_columns = 0;
12150   index_ptr += 4;
12151   nr_units = read_4_bytes (dbfd, index_ptr);
12152   index_ptr += 4;
12153   nr_slots = read_4_bytes (dbfd, index_ptr);
12154   index_ptr += 4;
12155
12156   if (version != 1 && version != 2)
12157     {
12158       error (_("Dwarf Error: unsupported DWP file version (%s)"
12159                " [in module %s]"),
12160              pulongest (version), dwp_file->name);
12161     }
12162   if (nr_slots != (nr_slots & -nr_slots))
12163     {
12164       error (_("Dwarf Error: number of slots in DWP hash table (%s)"
12165                " is not power of 2 [in module %s]"),
12166              pulongest (nr_slots), dwp_file->name);
12167     }
12168
12169   htab = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_hash_table);
12170   htab->version = version;
12171   htab->nr_columns = nr_columns;
12172   htab->nr_units = nr_units;
12173   htab->nr_slots = nr_slots;
12174   htab->hash_table = index_ptr;
12175   htab->unit_table = htab->hash_table + sizeof (uint64_t) * nr_slots;
12176
12177   /* Exit early if the table is empty.  */
12178   if (nr_slots == 0 || nr_units == 0
12179       || (version == 2 && nr_columns == 0))
12180     {
12181       /* All must be zero.  */
12182       if (nr_slots != 0 || nr_units != 0
12183           || (version == 2 && nr_columns != 0))
12184         {
12185           complaint (_("Empty DWP but nr_slots,nr_units,nr_columns not"
12186                        " all zero [in modules %s]"),
12187                      dwp_file->name);
12188         }
12189       return htab;
12190     }
12191
12192   if (version == 1)
12193     {
12194       htab->section_pool.v1.indices =
12195         htab->unit_table + sizeof (uint32_t) * nr_slots;
12196       /* It's harder to decide whether the section is too small in v1.
12197          V1 is deprecated anyway so we punt.  */
12198     }
12199   else
12200     {
12201       const gdb_byte *ids_ptr = htab->unit_table + sizeof (uint32_t) * nr_slots;
12202       int *ids = htab->section_pool.v2.section_ids;
12203       size_t sizeof_ids = sizeof (htab->section_pool.v2.section_ids);
12204       /* Reverse map for error checking.  */
12205       int ids_seen[DW_SECT_MAX + 1];
12206       int i;
12207
12208       if (nr_columns < 2)
12209         {
12210           error (_("Dwarf Error: bad DWP hash table, too few columns"
12211                    " in section table [in module %s]"),
12212                  dwp_file->name);
12213         }
12214       if (nr_columns > MAX_NR_V2_DWO_SECTIONS)
12215         {
12216           error (_("Dwarf Error: bad DWP hash table, too many columns"
12217                    " in section table [in module %s]"),
12218                  dwp_file->name);
12219         }
12220       memset (ids, 255, sizeof_ids);
12221       memset (ids_seen, 255, sizeof (ids_seen));
12222       for (i = 0; i < nr_columns; ++i)
12223         {
12224           int id = read_4_bytes (dbfd, ids_ptr + i * sizeof (uint32_t));
12225
12226           if (id < DW_SECT_MIN || id > DW_SECT_MAX)
12227             {
12228               error (_("Dwarf Error: bad DWP hash table, bad section id %d"
12229                        " in section table [in module %s]"),
12230                      id, dwp_file->name);
12231             }
12232           if (ids_seen[id] != -1)
12233             {
12234               error (_("Dwarf Error: bad DWP hash table, duplicate section"
12235                        " id %d in section table [in module %s]"),
12236                      id, dwp_file->name);
12237             }
12238           ids_seen[id] = i;
12239           ids[i] = id;
12240         }
12241       /* Must have exactly one info or types section.  */
12242       if (((ids_seen[DW_SECT_INFO] != -1)
12243            + (ids_seen[DW_SECT_TYPES] != -1))
12244           != 1)
12245         {
12246           error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
12247                    " DWO info/types section [in module %s]"),
12248                  dwp_file->name);
12249         }
12250       /* Must have an abbrev section.  */
12251       if (ids_seen[DW_SECT_ABBREV] == -1)
12252         {
12253           error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
12254                    " section [in module %s]"),
12255                  dwp_file->name);
12256         }
12257       htab->section_pool.v2.offsets = ids_ptr + sizeof (uint32_t) * nr_columns;
12258       htab->section_pool.v2.sizes =
12259         htab->section_pool.v2.offsets + (sizeof (uint32_t)
12260                                          * nr_units * nr_columns);
12261       if ((htab->section_pool.v2.sizes + (sizeof (uint32_t)
12262                                           * nr_units * nr_columns))
12263           > index_end)
12264         {
12265           error (_("Dwarf Error: DWP index section is corrupt (too small)"
12266                    " [in module %s]"),
12267                  dwp_file->name);
12268         }
12269     }
12270
12271   return htab;
12272 }
12273
12274 /* Update SECTIONS with the data from SECTP.
12275
12276    This function is like the other "locate" section routines that are
12277    passed to bfd_map_over_sections, but in this context the sections to
12278    read comes from the DWP V1 hash table, not the full ELF section table.
12279
12280    The result is non-zero for success, or zero if an error was found.  */
12281
12282 static int
12283 locate_v1_virtual_dwo_sections (asection *sectp,
12284                                 struct virtual_v1_dwo_sections *sections)
12285 {
12286   const struct dwop_section_names *names = &dwop_section_names;
12287
12288   if (section_is_p (sectp->name, &names->abbrev_dwo))
12289     {
12290       /* There can be only one.  */
12291       if (sections->abbrev.s.section != NULL)
12292         return 0;
12293       sections->abbrev.s.section = sectp;
12294       sections->abbrev.size = bfd_get_section_size (sectp);
12295     }
12296   else if (section_is_p (sectp->name, &names->info_dwo)
12297            || section_is_p (sectp->name, &names->types_dwo))
12298     {
12299       /* There can be only one.  */
12300       if (sections->info_or_types.s.section != NULL)
12301         return 0;
12302       sections->info_or_types.s.section = sectp;
12303       sections->info_or_types.size = bfd_get_section_size (sectp);
12304     }
12305   else if (section_is_p (sectp->name, &names->line_dwo))
12306     {
12307       /* There can be only one.  */
12308       if (sections->line.s.section != NULL)
12309         return 0;
12310       sections->line.s.section = sectp;
12311       sections->line.size = bfd_get_section_size (sectp);
12312     }
12313   else if (section_is_p (sectp->name, &names->loc_dwo))
12314     {
12315       /* There can be only one.  */
12316       if (sections->loc.s.section != NULL)
12317         return 0;
12318       sections->loc.s.section = sectp;
12319       sections->loc.size = bfd_get_section_size (sectp);
12320     }
12321   else if (section_is_p (sectp->name, &names->macinfo_dwo))
12322     {
12323       /* There can be only one.  */
12324       if (sections->macinfo.s.section != NULL)
12325         return 0;
12326       sections->macinfo.s.section = sectp;
12327       sections->macinfo.size = bfd_get_section_size (sectp);
12328     }
12329   else if (section_is_p (sectp->name, &names->macro_dwo))
12330     {
12331       /* There can be only one.  */
12332       if (sections->macro.s.section != NULL)
12333         return 0;
12334       sections->macro.s.section = sectp;
12335       sections->macro.size = bfd_get_section_size (sectp);
12336     }
12337   else if (section_is_p (sectp->name, &names->str_offsets_dwo))
12338     {
12339       /* There can be only one.  */
12340       if (sections->str_offsets.s.section != NULL)
12341         return 0;
12342       sections->str_offsets.s.section = sectp;
12343       sections->str_offsets.size = bfd_get_section_size (sectp);
12344     }
12345   else
12346     {
12347       /* No other kind of section is valid.  */
12348       return 0;
12349     }
12350
12351   return 1;
12352 }
12353
12354 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12355    UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12356    COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12357    This is for DWP version 1 files.  */
12358
12359 static struct dwo_unit *
12360 create_dwo_unit_in_dwp_v1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
12361                            struct dwp_file *dwp_file,
12362                            uint32_t unit_index,
12363                            const char *comp_dir,
12364                            ULONGEST signature, int is_debug_types)
12365 {
12366   struct objfile *objfile = dwarf2_per_objfile->objfile;
12367   const struct dwp_hash_table *dwp_htab =
12368     is_debug_types ? dwp_file->tus : dwp_file->cus;
12369   bfd *dbfd = dwp_file->dbfd.get ();
12370   const char *kind = is_debug_types ? "TU" : "CU";
12371   struct dwo_file *dwo_file;
12372   struct dwo_unit *dwo_unit;
12373   struct virtual_v1_dwo_sections sections;
12374   void **dwo_file_slot;
12375   int i;
12376
12377   gdb_assert (dwp_file->version == 1);
12378
12379   if (dwarf_read_debug)
12380     {
12381       fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V1 file: %s\n",
12382                           kind,
12383                           pulongest (unit_index), hex_string (signature),
12384                           dwp_file->name);
12385     }
12386
12387   /* Fetch the sections of this DWO unit.
12388      Put a limit on the number of sections we look for so that bad data
12389      doesn't cause us to loop forever.  */
12390
12391 #define MAX_NR_V1_DWO_SECTIONS \
12392   (1 /* .debug_info or .debug_types */ \
12393    + 1 /* .debug_abbrev */ \
12394    + 1 /* .debug_line */ \
12395    + 1 /* .debug_loc */ \
12396    + 1 /* .debug_str_offsets */ \
12397    + 1 /* .debug_macro or .debug_macinfo */ \
12398    + 1 /* trailing zero */)
12399
12400   memset (&sections, 0, sizeof (sections));
12401
12402   for (i = 0; i < MAX_NR_V1_DWO_SECTIONS; ++i)
12403     {
12404       asection *sectp;
12405       uint32_t section_nr =
12406         read_4_bytes (dbfd,
12407                       dwp_htab->section_pool.v1.indices
12408                       + (unit_index + i) * sizeof (uint32_t));
12409
12410       if (section_nr == 0)
12411         break;
12412       if (section_nr >= dwp_file->num_sections)
12413         {
12414           error (_("Dwarf Error: bad DWP hash table, section number too large"
12415                    " [in module %s]"),
12416                  dwp_file->name);
12417         }
12418
12419       sectp = dwp_file->elf_sections[section_nr];
12420       if (! locate_v1_virtual_dwo_sections (sectp, &sections))
12421         {
12422           error (_("Dwarf Error: bad DWP hash table, invalid section found"
12423                    " [in module %s]"),
12424                  dwp_file->name);
12425         }
12426     }
12427
12428   if (i < 2
12429       || dwarf2_section_empty_p (&sections.info_or_types)
12430       || dwarf2_section_empty_p (&sections.abbrev))
12431     {
12432       error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
12433                " [in module %s]"),
12434              dwp_file->name);
12435     }
12436   if (i == MAX_NR_V1_DWO_SECTIONS)
12437     {
12438       error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
12439                " [in module %s]"),
12440              dwp_file->name);
12441     }
12442
12443   /* It's easier for the rest of the code if we fake a struct dwo_file and
12444      have dwo_unit "live" in that.  At least for now.
12445
12446      The DWP file can be made up of a random collection of CUs and TUs.
12447      However, for each CU + set of TUs that came from the same original DWO
12448      file, we can combine them back into a virtual DWO file to save space
12449      (fewer struct dwo_file objects to allocate).  Remember that for really
12450      large apps there can be on the order of 8K CUs and 200K TUs, or more.  */
12451
12452   std::string virtual_dwo_name =
12453     string_printf ("virtual-dwo/%d-%d-%d-%d",
12454                    get_section_id (&sections.abbrev),
12455                    get_section_id (&sections.line),
12456                    get_section_id (&sections.loc),
12457                    get_section_id (&sections.str_offsets));
12458   /* Can we use an existing virtual DWO file?  */
12459   dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
12460                                         virtual_dwo_name.c_str (),
12461                                         comp_dir);
12462   /* Create one if necessary.  */
12463   if (*dwo_file_slot == NULL)
12464     {
12465       if (dwarf_read_debug)
12466         {
12467           fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
12468                               virtual_dwo_name.c_str ());
12469         }
12470       dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
12471       dwo_file->dwo_name
12472         = (const char *) obstack_copy0 (&objfile->objfile_obstack,
12473                                         virtual_dwo_name.c_str (),
12474                                         virtual_dwo_name.size ());
12475       dwo_file->comp_dir = comp_dir;
12476       dwo_file->sections.abbrev = sections.abbrev;
12477       dwo_file->sections.line = sections.line;
12478       dwo_file->sections.loc = sections.loc;
12479       dwo_file->sections.macinfo = sections.macinfo;
12480       dwo_file->sections.macro = sections.macro;
12481       dwo_file->sections.str_offsets = sections.str_offsets;
12482       /* The "str" section is global to the entire DWP file.  */
12483       dwo_file->sections.str = dwp_file->sections.str;
12484       /* The info or types section is assigned below to dwo_unit,
12485          there's no need to record it in dwo_file.
12486          Also, we can't simply record type sections in dwo_file because
12487          we record a pointer into the vector in dwo_unit.  As we collect more
12488          types we'll grow the vector and eventually have to reallocate space
12489          for it, invalidating all copies of pointers into the previous
12490          contents.  */
12491       *dwo_file_slot = dwo_file;
12492     }
12493   else
12494     {
12495       if (dwarf_read_debug)
12496         {
12497           fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
12498                               virtual_dwo_name.c_str ());
12499         }
12500       dwo_file = (struct dwo_file *) *dwo_file_slot;
12501     }
12502
12503   dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
12504   dwo_unit->dwo_file = dwo_file;
12505   dwo_unit->signature = signature;
12506   dwo_unit->section =
12507     XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
12508   *dwo_unit->section = sections.info_or_types;
12509   /* dwo_unit->{offset,length,type_offset_in_tu} are set later.  */
12510
12511   return dwo_unit;
12512 }
12513
12514 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
12515    Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
12516    piece within that section used by a TU/CU, return a virtual section
12517    of just that piece.  */
12518
12519 static struct dwarf2_section_info
12520 create_dwp_v2_section (struct dwarf2_per_objfile *dwarf2_per_objfile,
12521                        struct dwarf2_section_info *section,
12522                        bfd_size_type offset, bfd_size_type size)
12523 {
12524   struct dwarf2_section_info result;
12525   asection *sectp;
12526
12527   gdb_assert (section != NULL);
12528   gdb_assert (!section->is_virtual);
12529
12530   memset (&result, 0, sizeof (result));
12531   result.s.containing_section = section;
12532   result.is_virtual = 1;
12533
12534   if (size == 0)
12535     return result;
12536
12537   sectp = get_section_bfd_section (section);
12538
12539   /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
12540      bounds of the real section.  This is a pretty-rare event, so just
12541      flag an error (easier) instead of a warning and trying to cope.  */
12542   if (sectp == NULL
12543       || offset + size > bfd_get_section_size (sectp))
12544     {
12545       error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
12546                " in section %s [in module %s]"),
12547              sectp ? bfd_section_name (abfd, sectp) : "<unknown>",
12548              objfile_name (dwarf2_per_objfile->objfile));
12549     }
12550
12551   result.virtual_offset = offset;
12552   result.size = size;
12553   return result;
12554 }
12555
12556 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12557    UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12558    COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12559    This is for DWP version 2 files.  */
12560
12561 static struct dwo_unit *
12562 create_dwo_unit_in_dwp_v2 (struct dwarf2_per_objfile *dwarf2_per_objfile,
12563                            struct dwp_file *dwp_file,
12564                            uint32_t unit_index,
12565                            const char *comp_dir,
12566                            ULONGEST signature, int is_debug_types)
12567 {
12568   struct objfile *objfile = dwarf2_per_objfile->objfile;
12569   const struct dwp_hash_table *dwp_htab =
12570     is_debug_types ? dwp_file->tus : dwp_file->cus;
12571   bfd *dbfd = dwp_file->dbfd.get ();
12572   const char *kind = is_debug_types ? "TU" : "CU";
12573   struct dwo_file *dwo_file;
12574   struct dwo_unit *dwo_unit;
12575   struct virtual_v2_dwo_sections sections;
12576   void **dwo_file_slot;
12577   int i;
12578
12579   gdb_assert (dwp_file->version == 2);
12580
12581   if (dwarf_read_debug)
12582     {
12583       fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V2 file: %s\n",
12584                           kind,
12585                           pulongest (unit_index), hex_string (signature),
12586                           dwp_file->name);
12587     }
12588
12589   /* Fetch the section offsets of this DWO unit.  */
12590
12591   memset (&sections, 0, sizeof (sections));
12592
12593   for (i = 0; i < dwp_htab->nr_columns; ++i)
12594     {
12595       uint32_t offset = read_4_bytes (dbfd,
12596                                       dwp_htab->section_pool.v2.offsets
12597                                       + (((unit_index - 1) * dwp_htab->nr_columns
12598                                           + i)
12599                                          * sizeof (uint32_t)));
12600       uint32_t size = read_4_bytes (dbfd,
12601                                     dwp_htab->section_pool.v2.sizes
12602                                     + (((unit_index - 1) * dwp_htab->nr_columns
12603                                         + i)
12604                                        * sizeof (uint32_t)));
12605
12606       switch (dwp_htab->section_pool.v2.section_ids[i])
12607         {
12608         case DW_SECT_INFO:
12609         case DW_SECT_TYPES:
12610           sections.info_or_types_offset = offset;
12611           sections.info_or_types_size = size;
12612           break;
12613         case DW_SECT_ABBREV:
12614           sections.abbrev_offset = offset;
12615           sections.abbrev_size = size;
12616           break;
12617         case DW_SECT_LINE:
12618           sections.line_offset = offset;
12619           sections.line_size = size;
12620           break;
12621         case DW_SECT_LOC:
12622           sections.loc_offset = offset;
12623           sections.loc_size = size;
12624           break;
12625         case DW_SECT_STR_OFFSETS:
12626           sections.str_offsets_offset = offset;
12627           sections.str_offsets_size = size;
12628           break;
12629         case DW_SECT_MACINFO:
12630           sections.macinfo_offset = offset;
12631           sections.macinfo_size = size;
12632           break;
12633         case DW_SECT_MACRO:
12634           sections.macro_offset = offset;
12635           sections.macro_size = size;
12636           break;
12637         }
12638     }
12639
12640   /* It's easier for the rest of the code if we fake a struct dwo_file and
12641      have dwo_unit "live" in that.  At least for now.
12642
12643      The DWP file can be made up of a random collection of CUs and TUs.
12644      However, for each CU + set of TUs that came from the same original DWO
12645      file, we can combine them back into a virtual DWO file to save space
12646      (fewer struct dwo_file objects to allocate).  Remember that for really
12647      large apps there can be on the order of 8K CUs and 200K TUs, or more.  */
12648
12649   std::string virtual_dwo_name =
12650     string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
12651                    (long) (sections.abbrev_size ? sections.abbrev_offset : 0),
12652                    (long) (sections.line_size ? sections.line_offset : 0),
12653                    (long) (sections.loc_size ? sections.loc_offset : 0),
12654                    (long) (sections.str_offsets_size
12655                            ? sections.str_offsets_offset : 0));
12656   /* Can we use an existing virtual DWO file?  */
12657   dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
12658                                         virtual_dwo_name.c_str (),
12659                                         comp_dir);
12660   /* Create one if necessary.  */
12661   if (*dwo_file_slot == NULL)
12662     {
12663       if (dwarf_read_debug)
12664         {
12665           fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
12666                               virtual_dwo_name.c_str ());
12667         }
12668       dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
12669       dwo_file->dwo_name
12670         = (const char *) obstack_copy0 (&objfile->objfile_obstack,
12671                                         virtual_dwo_name.c_str (),
12672                                         virtual_dwo_name.size ());
12673       dwo_file->comp_dir = comp_dir;
12674       dwo_file->sections.abbrev =
12675         create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.abbrev,
12676                                sections.abbrev_offset, sections.abbrev_size);
12677       dwo_file->sections.line =
12678         create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.line,
12679                                sections.line_offset, sections.line_size);
12680       dwo_file->sections.loc =
12681         create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.loc,
12682                                sections.loc_offset, sections.loc_size);
12683       dwo_file->sections.macinfo =
12684         create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.macinfo,
12685                                sections.macinfo_offset, sections.macinfo_size);
12686       dwo_file->sections.macro =
12687         create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.macro,
12688                                sections.macro_offset, sections.macro_size);
12689       dwo_file->sections.str_offsets =
12690         create_dwp_v2_section (dwarf2_per_objfile,
12691                                &dwp_file->sections.str_offsets,
12692                                sections.str_offsets_offset,
12693                                sections.str_offsets_size);
12694       /* The "str" section is global to the entire DWP file.  */
12695       dwo_file->sections.str = dwp_file->sections.str;
12696       /* The info or types section is assigned below to dwo_unit,
12697          there's no need to record it in dwo_file.
12698          Also, we can't simply record type sections in dwo_file because
12699          we record a pointer into the vector in dwo_unit.  As we collect more
12700          types we'll grow the vector and eventually have to reallocate space
12701          for it, invalidating all copies of pointers into the previous
12702          contents.  */
12703       *dwo_file_slot = dwo_file;
12704     }
12705   else
12706     {
12707       if (dwarf_read_debug)
12708         {
12709           fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
12710                               virtual_dwo_name.c_str ());
12711         }
12712       dwo_file = (struct dwo_file *) *dwo_file_slot;
12713     }
12714
12715   dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
12716   dwo_unit->dwo_file = dwo_file;
12717   dwo_unit->signature = signature;
12718   dwo_unit->section =
12719     XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
12720   *dwo_unit->section = create_dwp_v2_section (dwarf2_per_objfile,
12721                                               is_debug_types
12722                                               ? &dwp_file->sections.types
12723                                               : &dwp_file->sections.info,
12724                                               sections.info_or_types_offset,
12725                                               sections.info_or_types_size);
12726   /* dwo_unit->{offset,length,type_offset_in_tu} are set later.  */
12727
12728   return dwo_unit;
12729 }
12730
12731 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
12732    Returns NULL if the signature isn't found.  */
12733
12734 static struct dwo_unit *
12735 lookup_dwo_unit_in_dwp (struct dwarf2_per_objfile *dwarf2_per_objfile,
12736                         struct dwp_file *dwp_file, const char *comp_dir,
12737                         ULONGEST signature, int is_debug_types)
12738 {
12739   const struct dwp_hash_table *dwp_htab =
12740     is_debug_types ? dwp_file->tus : dwp_file->cus;
12741   bfd *dbfd = dwp_file->dbfd.get ();
12742   uint32_t mask = dwp_htab->nr_slots - 1;
12743   uint32_t hash = signature & mask;
12744   uint32_t hash2 = ((signature >> 32) & mask) | 1;
12745   unsigned int i;
12746   void **slot;
12747   struct dwo_unit find_dwo_cu;
12748
12749   memset (&find_dwo_cu, 0, sizeof (find_dwo_cu));
12750   find_dwo_cu.signature = signature;
12751   slot = htab_find_slot (is_debug_types
12752                          ? dwp_file->loaded_tus
12753                          : dwp_file->loaded_cus,
12754                          &find_dwo_cu, INSERT);
12755
12756   if (*slot != NULL)
12757     return (struct dwo_unit *) *slot;
12758
12759   /* Use a for loop so that we don't loop forever on bad debug info.  */
12760   for (i = 0; i < dwp_htab->nr_slots; ++i)
12761     {
12762       ULONGEST signature_in_table;
12763
12764       signature_in_table =
12765         read_8_bytes (dbfd, dwp_htab->hash_table + hash * sizeof (uint64_t));
12766       if (signature_in_table == signature)
12767         {
12768           uint32_t unit_index =
12769             read_4_bytes (dbfd,
12770                           dwp_htab->unit_table + hash * sizeof (uint32_t));
12771
12772           if (dwp_file->version == 1)
12773             {
12774               *slot = create_dwo_unit_in_dwp_v1 (dwarf2_per_objfile,
12775                                                  dwp_file, unit_index,
12776                                                  comp_dir, signature,
12777                                                  is_debug_types);
12778             }
12779           else
12780             {
12781               *slot = create_dwo_unit_in_dwp_v2 (dwarf2_per_objfile,
12782                                                  dwp_file, unit_index,
12783                                                  comp_dir, signature,
12784                                                  is_debug_types);
12785             }
12786           return (struct dwo_unit *) *slot;
12787         }
12788       if (signature_in_table == 0)
12789         return NULL;
12790       hash = (hash + hash2) & mask;
12791     }
12792
12793   error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
12794            " [in module %s]"),
12795          dwp_file->name);
12796 }
12797
12798 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
12799    Open the file specified by FILE_NAME and hand it off to BFD for
12800    preliminary analysis.  Return a newly initialized bfd *, which
12801    includes a canonicalized copy of FILE_NAME.
12802    If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
12803    SEARCH_CWD is true if the current directory is to be searched.
12804    It will be searched before debug-file-directory.
12805    If successful, the file is added to the bfd include table of the
12806    objfile's bfd (see gdb_bfd_record_inclusion).
12807    If unable to find/open the file, return NULL.
12808    NOTE: This function is derived from symfile_bfd_open.  */
12809
12810 static gdb_bfd_ref_ptr
12811 try_open_dwop_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
12812                     const char *file_name, int is_dwp, int search_cwd)
12813 {
12814   int desc;
12815   /* Blech.  OPF_TRY_CWD_FIRST also disables searching the path list if
12816      FILE_NAME contains a '/'.  So we can't use it.  Instead prepend "."
12817      to debug_file_directory.  */
12818   const char *search_path;
12819   static const char dirname_separator_string[] = { DIRNAME_SEPARATOR, '\0' };
12820
12821   gdb::unique_xmalloc_ptr<char> search_path_holder;
12822   if (search_cwd)
12823     {
12824       if (*debug_file_directory != '\0')
12825         {
12826           search_path_holder.reset (concat (".", dirname_separator_string,
12827                                             debug_file_directory,
12828                                             (char *) NULL));
12829           search_path = search_path_holder.get ();
12830         }
12831       else
12832         search_path = ".";
12833     }
12834   else
12835     search_path = debug_file_directory;
12836
12837   openp_flags flags = OPF_RETURN_REALPATH;
12838   if (is_dwp)
12839     flags |= OPF_SEARCH_IN_PATH;
12840
12841   gdb::unique_xmalloc_ptr<char> absolute_name;
12842   desc = openp (search_path, flags, file_name,
12843                 O_RDONLY | O_BINARY, &absolute_name);
12844   if (desc < 0)
12845     return NULL;
12846
12847   gdb_bfd_ref_ptr sym_bfd (gdb_bfd_open (absolute_name.get (),
12848                                          gnutarget, desc));
12849   if (sym_bfd == NULL)
12850     return NULL;
12851   bfd_set_cacheable (sym_bfd.get (), 1);
12852
12853   if (!bfd_check_format (sym_bfd.get (), bfd_object))
12854     return NULL;
12855
12856   /* Success.  Record the bfd as having been included by the objfile's bfd.
12857      This is important because things like demangled_names_hash lives in the
12858      objfile's per_bfd space and may have references to things like symbol
12859      names that live in the DWO/DWP file's per_bfd space.  PR 16426.  */
12860   gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd, sym_bfd.get ());
12861
12862   return sym_bfd;
12863 }
12864
12865 /* Try to open DWO file FILE_NAME.
12866    COMP_DIR is the DW_AT_comp_dir attribute.
12867    The result is the bfd handle of the file.
12868    If there is a problem finding or opening the file, return NULL.
12869    Upon success, the canonicalized path of the file is stored in the bfd,
12870    same as symfile_bfd_open.  */
12871
12872 static gdb_bfd_ref_ptr
12873 open_dwo_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
12874                const char *file_name, const char *comp_dir)
12875 {
12876   if (IS_ABSOLUTE_PATH (file_name))
12877     return try_open_dwop_file (dwarf2_per_objfile, file_name,
12878                                0 /*is_dwp*/, 0 /*search_cwd*/);
12879
12880   /* Before trying the search path, try DWO_NAME in COMP_DIR.  */
12881
12882   if (comp_dir != NULL)
12883     {
12884       char *path_to_try = concat (comp_dir, SLASH_STRING,
12885                                   file_name, (char *) NULL);
12886
12887       /* NOTE: If comp_dir is a relative path, this will also try the
12888          search path, which seems useful.  */
12889       gdb_bfd_ref_ptr abfd (try_open_dwop_file (dwarf2_per_objfile,
12890                                                 path_to_try,
12891                                                 0 /*is_dwp*/,
12892                                                 1 /*search_cwd*/));
12893       xfree (path_to_try);
12894       if (abfd != NULL)
12895         return abfd;
12896     }
12897
12898   /* That didn't work, try debug-file-directory, which, despite its name,
12899      is a list of paths.  */
12900
12901   if (*debug_file_directory == '\0')
12902     return NULL;
12903
12904   return try_open_dwop_file (dwarf2_per_objfile, file_name,
12905                              0 /*is_dwp*/, 1 /*search_cwd*/);
12906 }
12907
12908 /* This function is mapped across the sections and remembers the offset and
12909    size of each of the DWO debugging sections we are interested in.  */
12910
12911 static void
12912 dwarf2_locate_dwo_sections (bfd *abfd, asection *sectp, void *dwo_sections_ptr)
12913 {
12914   struct dwo_sections *dwo_sections = (struct dwo_sections *) dwo_sections_ptr;
12915   const struct dwop_section_names *names = &dwop_section_names;
12916
12917   if (section_is_p (sectp->name, &names->abbrev_dwo))
12918     {
12919       dwo_sections->abbrev.s.section = sectp;
12920       dwo_sections->abbrev.size = bfd_get_section_size (sectp);
12921     }
12922   else if (section_is_p (sectp->name, &names->info_dwo))
12923     {
12924       dwo_sections->info.s.section = sectp;
12925       dwo_sections->info.size = bfd_get_section_size (sectp);
12926     }
12927   else if (section_is_p (sectp->name, &names->line_dwo))
12928     {
12929       dwo_sections->line.s.section = sectp;
12930       dwo_sections->line.size = bfd_get_section_size (sectp);
12931     }
12932   else if (section_is_p (sectp->name, &names->loc_dwo))
12933     {
12934       dwo_sections->loc.s.section = sectp;
12935       dwo_sections->loc.size = bfd_get_section_size (sectp);
12936     }
12937   else if (section_is_p (sectp->name, &names->macinfo_dwo))
12938     {
12939       dwo_sections->macinfo.s.section = sectp;
12940       dwo_sections->macinfo.size = bfd_get_section_size (sectp);
12941     }
12942   else if (section_is_p (sectp->name, &names->macro_dwo))
12943     {
12944       dwo_sections->macro.s.section = sectp;
12945       dwo_sections->macro.size = bfd_get_section_size (sectp);
12946     }
12947   else if (section_is_p (sectp->name, &names->str_dwo))
12948     {
12949       dwo_sections->str.s.section = sectp;
12950       dwo_sections->str.size = bfd_get_section_size (sectp);
12951     }
12952   else if (section_is_p (sectp->name, &names->str_offsets_dwo))
12953     {
12954       dwo_sections->str_offsets.s.section = sectp;
12955       dwo_sections->str_offsets.size = bfd_get_section_size (sectp);
12956     }
12957   else if (section_is_p (sectp->name, &names->types_dwo))
12958     {
12959       struct dwarf2_section_info type_section;
12960
12961       memset (&type_section, 0, sizeof (type_section));
12962       type_section.s.section = sectp;
12963       type_section.size = bfd_get_section_size (sectp);
12964       VEC_safe_push (dwarf2_section_info_def, dwo_sections->types,
12965                      &type_section);
12966     }
12967 }
12968
12969 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
12970    by PER_CU.  This is for the non-DWP case.
12971    The result is NULL if DWO_NAME can't be found.  */
12972
12973 static struct dwo_file *
12974 open_and_init_dwo_file (struct dwarf2_per_cu_data *per_cu,
12975                         const char *dwo_name, const char *comp_dir)
12976 {
12977   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
12978   struct objfile *objfile = dwarf2_per_objfile->objfile;
12979
12980   gdb_bfd_ref_ptr dbfd (open_dwo_file (dwarf2_per_objfile, dwo_name, comp_dir));
12981   if (dbfd == NULL)
12982     {
12983       if (dwarf_read_debug)
12984         fprintf_unfiltered (gdb_stdlog, "DWO file not found: %s\n", dwo_name);
12985       return NULL;
12986     }
12987
12988   /* We use a unique pointer here, despite the obstack allocation,
12989      because a dwo_file needs some cleanup if it is abandoned.  */
12990   dwo_file_up dwo_file (OBSTACK_ZALLOC (&objfile->objfile_obstack,
12991                                         struct dwo_file));
12992   dwo_file->dwo_name = dwo_name;
12993   dwo_file->comp_dir = comp_dir;
12994   dwo_file->dbfd = dbfd.release ();
12995
12996   bfd_map_over_sections (dwo_file->dbfd, dwarf2_locate_dwo_sections,
12997                          &dwo_file->sections);
12998
12999   create_cus_hash_table (dwarf2_per_objfile, *dwo_file, dwo_file->sections.info,
13000                          dwo_file->cus);
13001
13002   create_debug_types_hash_table (dwarf2_per_objfile, dwo_file.get (),
13003                                  dwo_file->sections.types, dwo_file->tus);
13004
13005   if (dwarf_read_debug)
13006     fprintf_unfiltered (gdb_stdlog, "DWO file found: %s\n", dwo_name);
13007
13008   return dwo_file.release ();
13009 }
13010
13011 /* This function is mapped across the sections and remembers the offset and
13012    size of each of the DWP debugging sections common to version 1 and 2 that
13013    we are interested in.  */
13014
13015 static void
13016 dwarf2_locate_common_dwp_sections (bfd *abfd, asection *sectp,
13017                                    void *dwp_file_ptr)
13018 {
13019   struct dwp_file *dwp_file = (struct dwp_file *) dwp_file_ptr;
13020   const struct dwop_section_names *names = &dwop_section_names;
13021   unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
13022
13023   /* Record the ELF section number for later lookup: this is what the
13024      .debug_cu_index,.debug_tu_index tables use in DWP V1.  */
13025   gdb_assert (elf_section_nr < dwp_file->num_sections);
13026   dwp_file->elf_sections[elf_section_nr] = sectp;
13027
13028   /* Look for specific sections that we need.  */
13029   if (section_is_p (sectp->name, &names->str_dwo))
13030     {
13031       dwp_file->sections.str.s.section = sectp;
13032       dwp_file->sections.str.size = bfd_get_section_size (sectp);
13033     }
13034   else if (section_is_p (sectp->name, &names->cu_index))
13035     {
13036       dwp_file->sections.cu_index.s.section = sectp;
13037       dwp_file->sections.cu_index.size = bfd_get_section_size (sectp);
13038     }
13039   else if (section_is_p (sectp->name, &names->tu_index))
13040     {
13041       dwp_file->sections.tu_index.s.section = sectp;
13042       dwp_file->sections.tu_index.size = bfd_get_section_size (sectp);
13043     }
13044 }
13045
13046 /* This function is mapped across the sections and remembers the offset and
13047    size of each of the DWP version 2 debugging sections that we are interested
13048    in.  This is split into a separate function because we don't know if we
13049    have version 1 or 2 until we parse the cu_index/tu_index sections.  */
13050
13051 static void
13052 dwarf2_locate_v2_dwp_sections (bfd *abfd, asection *sectp, void *dwp_file_ptr)
13053 {
13054   struct dwp_file *dwp_file = (struct dwp_file *) dwp_file_ptr;
13055   const struct dwop_section_names *names = &dwop_section_names;
13056   unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
13057
13058   /* Record the ELF section number for later lookup: this is what the
13059      .debug_cu_index,.debug_tu_index tables use in DWP V1.  */
13060   gdb_assert (elf_section_nr < dwp_file->num_sections);
13061   dwp_file->elf_sections[elf_section_nr] = sectp;
13062
13063   /* Look for specific sections that we need.  */
13064   if (section_is_p (sectp->name, &names->abbrev_dwo))
13065     {
13066       dwp_file->sections.abbrev.s.section = sectp;
13067       dwp_file->sections.abbrev.size = bfd_get_section_size (sectp);
13068     }
13069   else if (section_is_p (sectp->name, &names->info_dwo))
13070     {
13071       dwp_file->sections.info.s.section = sectp;
13072       dwp_file->sections.info.size = bfd_get_section_size (sectp);
13073     }
13074   else if (section_is_p (sectp->name, &names->line_dwo))
13075     {
13076       dwp_file->sections.line.s.section = sectp;
13077       dwp_file->sections.line.size = bfd_get_section_size (sectp);
13078     }
13079   else if (section_is_p (sectp->name, &names->loc_dwo))
13080     {
13081       dwp_file->sections.loc.s.section = sectp;
13082       dwp_file->sections.loc.size = bfd_get_section_size (sectp);
13083     }
13084   else if (section_is_p (sectp->name, &names->macinfo_dwo))
13085     {
13086       dwp_file->sections.macinfo.s.section = sectp;
13087       dwp_file->sections.macinfo.size = bfd_get_section_size (sectp);
13088     }
13089   else if (section_is_p (sectp->name, &names->macro_dwo))
13090     {
13091       dwp_file->sections.macro.s.section = sectp;
13092       dwp_file->sections.macro.size = bfd_get_section_size (sectp);
13093     }
13094   else if (section_is_p (sectp->name, &names->str_offsets_dwo))
13095     {
13096       dwp_file->sections.str_offsets.s.section = sectp;
13097       dwp_file->sections.str_offsets.size = bfd_get_section_size (sectp);
13098     }
13099   else if (section_is_p (sectp->name, &names->types_dwo))
13100     {
13101       dwp_file->sections.types.s.section = sectp;
13102       dwp_file->sections.types.size = bfd_get_section_size (sectp);
13103     }
13104 }
13105
13106 /* Hash function for dwp_file loaded CUs/TUs.  */
13107
13108 static hashval_t
13109 hash_dwp_loaded_cutus (const void *item)
13110 {
13111   const struct dwo_unit *dwo_unit = (const struct dwo_unit *) item;
13112
13113   /* This drops the top 32 bits of the signature, but is ok for a hash.  */
13114   return dwo_unit->signature;
13115 }
13116
13117 /* Equality function for dwp_file loaded CUs/TUs.  */
13118
13119 static int
13120 eq_dwp_loaded_cutus (const void *a, const void *b)
13121 {
13122   const struct dwo_unit *dua = (const struct dwo_unit *) a;
13123   const struct dwo_unit *dub = (const struct dwo_unit *) b;
13124
13125   return dua->signature == dub->signature;
13126 }
13127
13128 /* Allocate a hash table for dwp_file loaded CUs/TUs.  */
13129
13130 static htab_t
13131 allocate_dwp_loaded_cutus_table (struct objfile *objfile)
13132 {
13133   return htab_create_alloc_ex (3,
13134                                hash_dwp_loaded_cutus,
13135                                eq_dwp_loaded_cutus,
13136                                NULL,
13137                                &objfile->objfile_obstack,
13138                                hashtab_obstack_allocate,
13139                                dummy_obstack_deallocate);
13140 }
13141
13142 /* Try to open DWP file FILE_NAME.
13143    The result is the bfd handle of the file.
13144    If there is a problem finding or opening the file, return NULL.
13145    Upon success, the canonicalized path of the file is stored in the bfd,
13146    same as symfile_bfd_open.  */
13147
13148 static gdb_bfd_ref_ptr
13149 open_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
13150                const char *file_name)
13151 {
13152   gdb_bfd_ref_ptr abfd (try_open_dwop_file (dwarf2_per_objfile, file_name,
13153                                             1 /*is_dwp*/,
13154                                             1 /*search_cwd*/));
13155   if (abfd != NULL)
13156     return abfd;
13157
13158   /* Work around upstream bug 15652.
13159      http://sourceware.org/bugzilla/show_bug.cgi?id=15652
13160      [Whether that's a "bug" is debatable, but it is getting in our way.]
13161      We have no real idea where the dwp file is, because gdb's realpath-ing
13162      of the executable's path may have discarded the needed info.
13163      [IWBN if the dwp file name was recorded in the executable, akin to
13164      .gnu_debuglink, but that doesn't exist yet.]
13165      Strip the directory from FILE_NAME and search again.  */
13166   if (*debug_file_directory != '\0')
13167     {
13168       /* Don't implicitly search the current directory here.
13169          If the user wants to search "." to handle this case,
13170          it must be added to debug-file-directory.  */
13171       return try_open_dwop_file (dwarf2_per_objfile,
13172                                  lbasename (file_name), 1 /*is_dwp*/,
13173                                  0 /*search_cwd*/);
13174     }
13175
13176   return NULL;
13177 }
13178
13179 /* Initialize the use of the DWP file for the current objfile.
13180    By convention the name of the DWP file is ${objfile}.dwp.
13181    The result is NULL if it can't be found.  */
13182
13183 static std::unique_ptr<struct dwp_file>
13184 open_and_init_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
13185 {
13186   struct objfile *objfile = dwarf2_per_objfile->objfile;
13187
13188   /* Try to find first .dwp for the binary file before any symbolic links
13189      resolving.  */
13190
13191   /* If the objfile is a debug file, find the name of the real binary
13192      file and get the name of dwp file from there.  */
13193   std::string dwp_name;
13194   if (objfile->separate_debug_objfile_backlink != NULL)
13195     {
13196       struct objfile *backlink = objfile->separate_debug_objfile_backlink;
13197       const char *backlink_basename = lbasename (backlink->original_name);
13198
13199       dwp_name = ldirname (objfile->original_name) + SLASH_STRING + backlink_basename;
13200     }
13201   else
13202     dwp_name = objfile->original_name;
13203
13204   dwp_name += ".dwp";
13205
13206   gdb_bfd_ref_ptr dbfd (open_dwp_file (dwarf2_per_objfile, dwp_name.c_str ()));
13207   if (dbfd == NULL
13208       && strcmp (objfile->original_name, objfile_name (objfile)) != 0)
13209     {
13210       /* Try to find .dwp for the binary file after gdb_realpath resolving.  */
13211       dwp_name = objfile_name (objfile);
13212       dwp_name += ".dwp";
13213       dbfd = open_dwp_file (dwarf2_per_objfile, dwp_name.c_str ());
13214     }
13215
13216   if (dbfd == NULL)
13217     {
13218       if (dwarf_read_debug)
13219         fprintf_unfiltered (gdb_stdlog, "DWP file not found: %s\n", dwp_name.c_str ());
13220       return std::unique_ptr<dwp_file> ();
13221     }
13222
13223   const char *name = bfd_get_filename (dbfd.get ());
13224   std::unique_ptr<struct dwp_file> dwp_file
13225     (new struct dwp_file (name, std::move (dbfd)));
13226
13227   dwp_file->num_sections = elf_numsections (dwp_file->dbfd);
13228   dwp_file->elf_sections =
13229     OBSTACK_CALLOC (&objfile->objfile_obstack,
13230                     dwp_file->num_sections, asection *);
13231
13232   bfd_map_over_sections (dwp_file->dbfd.get (),
13233                          dwarf2_locate_common_dwp_sections,
13234                          dwp_file.get ());
13235
13236   dwp_file->cus = create_dwp_hash_table (dwarf2_per_objfile, dwp_file.get (),
13237                                          0);
13238
13239   dwp_file->tus = create_dwp_hash_table (dwarf2_per_objfile, dwp_file.get (),
13240                                          1);
13241
13242   /* The DWP file version is stored in the hash table.  Oh well.  */
13243   if (dwp_file->cus && dwp_file->tus
13244       && dwp_file->cus->version != dwp_file->tus->version)
13245     {
13246       /* Technically speaking, we should try to limp along, but this is
13247          pretty bizarre.  We use pulongest here because that's the established
13248          portability solution (e.g, we cannot use %u for uint32_t).  */
13249       error (_("Dwarf Error: DWP file CU version %s doesn't match"
13250                " TU version %s [in DWP file %s]"),
13251              pulongest (dwp_file->cus->version),
13252              pulongest (dwp_file->tus->version), dwp_name.c_str ());
13253     }
13254
13255   if (dwp_file->cus)
13256     dwp_file->version = dwp_file->cus->version;
13257   else if (dwp_file->tus)
13258     dwp_file->version = dwp_file->tus->version;
13259   else
13260     dwp_file->version = 2;
13261
13262   if (dwp_file->version == 2)
13263     bfd_map_over_sections (dwp_file->dbfd.get (),
13264                            dwarf2_locate_v2_dwp_sections,
13265                            dwp_file.get ());
13266
13267   dwp_file->loaded_cus = allocate_dwp_loaded_cutus_table (objfile);
13268   dwp_file->loaded_tus = allocate_dwp_loaded_cutus_table (objfile);
13269
13270   if (dwarf_read_debug)
13271     {
13272       fprintf_unfiltered (gdb_stdlog, "DWP file found: %s\n", dwp_file->name);
13273       fprintf_unfiltered (gdb_stdlog,
13274                           "    %s CUs, %s TUs\n",
13275                           pulongest (dwp_file->cus ? dwp_file->cus->nr_units : 0),
13276                           pulongest (dwp_file->tus ? dwp_file->tus->nr_units : 0));
13277     }
13278
13279   return dwp_file;
13280 }
13281
13282 /* Wrapper around open_and_init_dwp_file, only open it once.  */
13283
13284 static struct dwp_file *
13285 get_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
13286 {
13287   if (! dwarf2_per_objfile->dwp_checked)
13288     {
13289       dwarf2_per_objfile->dwp_file
13290         = open_and_init_dwp_file (dwarf2_per_objfile);
13291       dwarf2_per_objfile->dwp_checked = 1;
13292     }
13293   return dwarf2_per_objfile->dwp_file.get ();
13294 }
13295
13296 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
13297    Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
13298    or in the DWP file for the objfile, referenced by THIS_UNIT.
13299    If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
13300    IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
13301
13302    This is called, for example, when wanting to read a variable with a
13303    complex location.  Therefore we don't want to do file i/o for every call.
13304    Therefore we don't want to look for a DWO file on every call.
13305    Therefore we first see if we've already seen SIGNATURE in a DWP file,
13306    then we check if we've already seen DWO_NAME, and only THEN do we check
13307    for a DWO file.
13308
13309    The result is a pointer to the dwo_unit object or NULL if we didn't find it
13310    (dwo_id mismatch or couldn't find the DWO/DWP file).  */
13311
13312 static struct dwo_unit *
13313 lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit,
13314                  const char *dwo_name, const char *comp_dir,
13315                  ULONGEST signature, int is_debug_types)
13316 {
13317   struct dwarf2_per_objfile *dwarf2_per_objfile = this_unit->dwarf2_per_objfile;
13318   struct objfile *objfile = dwarf2_per_objfile->objfile;
13319   const char *kind = is_debug_types ? "TU" : "CU";
13320   void **dwo_file_slot;
13321   struct dwo_file *dwo_file;
13322   struct dwp_file *dwp_file;
13323
13324   /* First see if there's a DWP file.
13325      If we have a DWP file but didn't find the DWO inside it, don't
13326      look for the original DWO file.  It makes gdb behave differently
13327      depending on whether one is debugging in the build tree.  */
13328
13329   dwp_file = get_dwp_file (dwarf2_per_objfile);
13330   if (dwp_file != NULL)
13331     {
13332       const struct dwp_hash_table *dwp_htab =
13333         is_debug_types ? dwp_file->tus : dwp_file->cus;
13334
13335       if (dwp_htab != NULL)
13336         {
13337           struct dwo_unit *dwo_cutu =
13338             lookup_dwo_unit_in_dwp (dwarf2_per_objfile, dwp_file, comp_dir,
13339                                     signature, is_debug_types);
13340
13341           if (dwo_cutu != NULL)
13342             {
13343               if (dwarf_read_debug)
13344                 {
13345                   fprintf_unfiltered (gdb_stdlog,
13346                                       "Virtual DWO %s %s found: @%s\n",
13347                                       kind, hex_string (signature),
13348                                       host_address_to_string (dwo_cutu));
13349                 }
13350               return dwo_cutu;
13351             }
13352         }
13353     }
13354   else
13355     {
13356       /* No DWP file, look for the DWO file.  */
13357
13358       dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
13359                                             dwo_name, comp_dir);
13360       if (*dwo_file_slot == NULL)
13361         {
13362           /* Read in the file and build a table of the CUs/TUs it contains.  */
13363           *dwo_file_slot = open_and_init_dwo_file (this_unit, dwo_name, comp_dir);
13364         }
13365       /* NOTE: This will be NULL if unable to open the file.  */
13366       dwo_file = (struct dwo_file *) *dwo_file_slot;
13367
13368       if (dwo_file != NULL)
13369         {
13370           struct dwo_unit *dwo_cutu = NULL;
13371
13372           if (is_debug_types && dwo_file->tus)
13373             {
13374               struct dwo_unit find_dwo_cutu;
13375
13376               memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
13377               find_dwo_cutu.signature = signature;
13378               dwo_cutu
13379                 = (struct dwo_unit *) htab_find (dwo_file->tus, &find_dwo_cutu);
13380             }
13381           else if (!is_debug_types && dwo_file->cus)
13382             {
13383               struct dwo_unit find_dwo_cutu;
13384
13385               memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
13386               find_dwo_cutu.signature = signature;
13387               dwo_cutu = (struct dwo_unit *)htab_find (dwo_file->cus,
13388                                                        &find_dwo_cutu);
13389             }
13390
13391           if (dwo_cutu != NULL)
13392             {
13393               if (dwarf_read_debug)
13394                 {
13395                   fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) found: @%s\n",
13396                                       kind, dwo_name, hex_string (signature),
13397                                       host_address_to_string (dwo_cutu));
13398                 }
13399               return dwo_cutu;
13400             }
13401         }
13402     }
13403
13404   /* We didn't find it.  This could mean a dwo_id mismatch, or
13405      someone deleted the DWO/DWP file, or the search path isn't set up
13406      correctly to find the file.  */
13407
13408   if (dwarf_read_debug)
13409     {
13410       fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) not found\n",
13411                           kind, dwo_name, hex_string (signature));
13412     }
13413
13414   /* This is a warning and not a complaint because it can be caused by
13415      pilot error (e.g., user accidentally deleting the DWO).  */
13416   {
13417     /* Print the name of the DWP file if we looked there, helps the user
13418        better diagnose the problem.  */
13419     std::string dwp_text;
13420
13421     if (dwp_file != NULL)
13422       dwp_text = string_printf (" [in DWP file %s]",
13423                                 lbasename (dwp_file->name));
13424
13425     warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset %s"
13426                " [in module %s]"),
13427              kind, dwo_name, hex_string (signature),
13428              dwp_text.c_str (),
13429              this_unit->is_debug_types ? "TU" : "CU",
13430              sect_offset_str (this_unit->sect_off), objfile_name (objfile));
13431   }
13432   return NULL;
13433 }
13434
13435 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
13436    See lookup_dwo_cutu_unit for details.  */
13437
13438 static struct dwo_unit *
13439 lookup_dwo_comp_unit (struct dwarf2_per_cu_data *this_cu,
13440                       const char *dwo_name, const char *comp_dir,
13441                       ULONGEST signature)
13442 {
13443   return lookup_dwo_cutu (this_cu, dwo_name, comp_dir, signature, 0);
13444 }
13445
13446 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
13447    See lookup_dwo_cutu_unit for details.  */
13448
13449 static struct dwo_unit *
13450 lookup_dwo_type_unit (struct signatured_type *this_tu,
13451                       const char *dwo_name, const char *comp_dir)
13452 {
13453   return lookup_dwo_cutu (&this_tu->per_cu, dwo_name, comp_dir, this_tu->signature, 1);
13454 }
13455
13456 /* Traversal function for queue_and_load_all_dwo_tus.  */
13457
13458 static int
13459 queue_and_load_dwo_tu (void **slot, void *info)
13460 {
13461   struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
13462   struct dwarf2_per_cu_data *per_cu = (struct dwarf2_per_cu_data *) info;
13463   ULONGEST signature = dwo_unit->signature;
13464   struct signatured_type *sig_type =
13465     lookup_dwo_signatured_type (per_cu->cu, signature);
13466
13467   if (sig_type != NULL)
13468     {
13469       struct dwarf2_per_cu_data *sig_cu = &sig_type->per_cu;
13470
13471       /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
13472          a real dependency of PER_CU on SIG_TYPE.  That is detected later
13473          while processing PER_CU.  */
13474       if (maybe_queue_comp_unit (NULL, sig_cu, per_cu->cu->language))
13475         load_full_type_unit (sig_cu);
13476       VEC_safe_push (dwarf2_per_cu_ptr, per_cu->imported_symtabs, sig_cu);
13477     }
13478
13479   return 1;
13480 }
13481
13482 /* Queue all TUs contained in the DWO of PER_CU to be read in.
13483    The DWO may have the only definition of the type, though it may not be
13484    referenced anywhere in PER_CU.  Thus we have to load *all* its TUs.
13485    http://sourceware.org/bugzilla/show_bug.cgi?id=15021  */
13486
13487 static void
13488 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *per_cu)
13489 {
13490   struct dwo_unit *dwo_unit;
13491   struct dwo_file *dwo_file;
13492
13493   gdb_assert (!per_cu->is_debug_types);
13494   gdb_assert (get_dwp_file (per_cu->dwarf2_per_objfile) == NULL);
13495   gdb_assert (per_cu->cu != NULL);
13496
13497   dwo_unit = per_cu->cu->dwo_unit;
13498   gdb_assert (dwo_unit != NULL);
13499
13500   dwo_file = dwo_unit->dwo_file;
13501   if (dwo_file->tus != NULL)
13502     htab_traverse_noresize (dwo_file->tus, queue_and_load_dwo_tu, per_cu);
13503 }
13504
13505 /* Free all resources associated with DWO_FILE.
13506    Close the DWO file and munmap the sections.  */
13507
13508 static void
13509 free_dwo_file (struct dwo_file *dwo_file)
13510 {
13511   /* Note: dbfd is NULL for virtual DWO files.  */
13512   gdb_bfd_unref (dwo_file->dbfd);
13513
13514   VEC_free (dwarf2_section_info_def, dwo_file->sections.types);
13515 }
13516
13517 /* Traversal function for free_dwo_files.  */
13518
13519 static int
13520 free_dwo_file_from_slot (void **slot, void *info)
13521 {
13522   struct dwo_file *dwo_file = (struct dwo_file *) *slot;
13523
13524   free_dwo_file (dwo_file);
13525
13526   return 1;
13527 }
13528
13529 /* Free all resources associated with DWO_FILES.  */
13530
13531 static void
13532 free_dwo_files (htab_t dwo_files, struct objfile *objfile)
13533 {
13534   htab_traverse_noresize (dwo_files, free_dwo_file_from_slot, objfile);
13535 }
13536 \f
13537 /* Read in various DIEs.  */
13538
13539 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
13540    Inherit only the children of the DW_AT_abstract_origin DIE not being
13541    already referenced by DW_AT_abstract_origin from the children of the
13542    current DIE.  */
13543
13544 static void
13545 inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu)
13546 {
13547   struct die_info *child_die;
13548   sect_offset *offsetp;
13549   /* Parent of DIE - referenced by DW_AT_abstract_origin.  */
13550   struct die_info *origin_die;
13551   /* Iterator of the ORIGIN_DIE children.  */
13552   struct die_info *origin_child_die;
13553   struct attribute *attr;
13554   struct dwarf2_cu *origin_cu;
13555   struct pending **origin_previous_list_in_scope;
13556
13557   attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
13558   if (!attr)
13559     return;
13560
13561   /* Note that following die references may follow to a die in a
13562      different cu.  */
13563
13564   origin_cu = cu;
13565   origin_die = follow_die_ref (die, attr, &origin_cu);
13566
13567   /* We're inheriting ORIGIN's children into the scope we'd put DIE's
13568      symbols in.  */
13569   origin_previous_list_in_scope = origin_cu->list_in_scope;
13570   origin_cu->list_in_scope = cu->list_in_scope;
13571
13572   if (die->tag != origin_die->tag
13573       && !(die->tag == DW_TAG_inlined_subroutine
13574            && origin_die->tag == DW_TAG_subprogram))
13575     complaint (_("DIE %s and its abstract origin %s have different tags"),
13576                sect_offset_str (die->sect_off),
13577                sect_offset_str (origin_die->sect_off));
13578
13579   std::vector<sect_offset> offsets;
13580
13581   for (child_die = die->child;
13582        child_die && child_die->tag;
13583        child_die = sibling_die (child_die))
13584     {
13585       struct die_info *child_origin_die;
13586       struct dwarf2_cu *child_origin_cu;
13587
13588       /* We are trying to process concrete instance entries:
13589          DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
13590          it's not relevant to our analysis here. i.e. detecting DIEs that are
13591          present in the abstract instance but not referenced in the concrete
13592          one.  */
13593       if (child_die->tag == DW_TAG_call_site
13594           || child_die->tag == DW_TAG_GNU_call_site)
13595         continue;
13596
13597       /* For each CHILD_DIE, find the corresponding child of
13598          ORIGIN_DIE.  If there is more than one layer of
13599          DW_AT_abstract_origin, follow them all; there shouldn't be,
13600          but GCC versions at least through 4.4 generate this (GCC PR
13601          40573).  */
13602       child_origin_die = child_die;
13603       child_origin_cu = cu;
13604       while (1)
13605         {
13606           attr = dwarf2_attr (child_origin_die, DW_AT_abstract_origin,
13607                               child_origin_cu);
13608           if (attr == NULL)
13609             break;
13610           child_origin_die = follow_die_ref (child_origin_die, attr,
13611                                              &child_origin_cu);
13612         }
13613
13614       /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
13615          counterpart may exist.  */
13616       if (child_origin_die != child_die)
13617         {
13618           if (child_die->tag != child_origin_die->tag
13619               && !(child_die->tag == DW_TAG_inlined_subroutine
13620                    && child_origin_die->tag == DW_TAG_subprogram))
13621             complaint (_("Child DIE %s and its abstract origin %s have "
13622                          "different tags"),
13623                        sect_offset_str (child_die->sect_off),
13624                        sect_offset_str (child_origin_die->sect_off));
13625           if (child_origin_die->parent != origin_die)
13626             complaint (_("Child DIE %s and its abstract origin %s have "
13627                          "different parents"),
13628                        sect_offset_str (child_die->sect_off),
13629                        sect_offset_str (child_origin_die->sect_off));
13630           else
13631             offsets.push_back (child_origin_die->sect_off);
13632         }
13633     }
13634   std::sort (offsets.begin (), offsets.end ());
13635   sect_offset *offsets_end = offsets.data () + offsets.size ();
13636   for (offsetp = offsets.data () + 1; offsetp < offsets_end; offsetp++)
13637     if (offsetp[-1] == *offsetp)
13638       complaint (_("Multiple children of DIE %s refer "
13639                    "to DIE %s as their abstract origin"),
13640                  sect_offset_str (die->sect_off), sect_offset_str (*offsetp));
13641
13642   offsetp = offsets.data ();
13643   origin_child_die = origin_die->child;
13644   while (origin_child_die && origin_child_die->tag)
13645     {
13646       /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children?  */
13647       while (offsetp < offsets_end
13648              && *offsetp < origin_child_die->sect_off)
13649         offsetp++;
13650       if (offsetp >= offsets_end
13651           || *offsetp > origin_child_die->sect_off)
13652         {
13653           /* Found that ORIGIN_CHILD_DIE is really not referenced.
13654              Check whether we're already processing ORIGIN_CHILD_DIE.
13655              This can happen with mutually referenced abstract_origins.
13656              PR 16581.  */
13657           if (!origin_child_die->in_process)
13658             process_die (origin_child_die, origin_cu);
13659         }
13660       origin_child_die = sibling_die (origin_child_die);
13661     }
13662   origin_cu->list_in_scope = origin_previous_list_in_scope;
13663 }
13664
13665 static void
13666 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
13667 {
13668   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13669   struct gdbarch *gdbarch = get_objfile_arch (objfile);
13670   struct context_stack *newobj;
13671   CORE_ADDR lowpc;
13672   CORE_ADDR highpc;
13673   struct die_info *child_die;
13674   struct attribute *attr, *call_line, *call_file;
13675   const char *name;
13676   CORE_ADDR baseaddr;
13677   struct block *block;
13678   int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
13679   std::vector<struct symbol *> template_args;
13680   struct template_symbol *templ_func = NULL;
13681
13682   if (inlined_func)
13683     {
13684       /* If we do not have call site information, we can't show the
13685          caller of this inlined function.  That's too confusing, so
13686          only use the scope for local variables.  */
13687       call_line = dwarf2_attr (die, DW_AT_call_line, cu);
13688       call_file = dwarf2_attr (die, DW_AT_call_file, cu);
13689       if (call_line == NULL || call_file == NULL)
13690         {
13691           read_lexical_block_scope (die, cu);
13692           return;
13693         }
13694     }
13695
13696   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13697
13698   name = dwarf2_name (die, cu);
13699
13700   /* Ignore functions with missing or empty names.  These are actually
13701      illegal according to the DWARF standard.  */
13702   if (name == NULL)
13703     {
13704       complaint (_("missing name for subprogram DIE at %s"),
13705                  sect_offset_str (die->sect_off));
13706       return;
13707     }
13708
13709   /* Ignore functions with missing or invalid low and high pc attributes.  */
13710   if (dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL)
13711       <= PC_BOUNDS_INVALID)
13712     {
13713       attr = dwarf2_attr (die, DW_AT_external, cu);
13714       if (!attr || !DW_UNSND (attr))
13715         complaint (_("cannot get low and high bounds "
13716                      "for subprogram DIE at %s"),
13717                    sect_offset_str (die->sect_off));
13718       return;
13719     }
13720
13721   lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
13722   highpc = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
13723
13724   /* If we have any template arguments, then we must allocate a
13725      different sort of symbol.  */
13726   for (child_die = die->child; child_die; child_die = sibling_die (child_die))
13727     {
13728       if (child_die->tag == DW_TAG_template_type_param
13729           || child_die->tag == DW_TAG_template_value_param)
13730         {
13731           templ_func = allocate_template_symbol (objfile);
13732           templ_func->subclass = SYMBOL_TEMPLATE;
13733           break;
13734         }
13735     }
13736
13737   newobj = cu->get_builder ()->push_context (0, lowpc);
13738   newobj->name = new_symbol (die, read_type_die (die, cu), cu,
13739                              (struct symbol *) templ_func);
13740
13741   /* If there is a location expression for DW_AT_frame_base, record
13742      it.  */
13743   attr = dwarf2_attr (die, DW_AT_frame_base, cu);
13744   if (attr)
13745     dwarf2_symbol_mark_computed (attr, newobj->name, cu, 1);
13746
13747   /* If there is a location for the static link, record it.  */
13748   newobj->static_link = NULL;
13749   attr = dwarf2_attr (die, DW_AT_static_link, cu);
13750   if (attr)
13751     {
13752       newobj->static_link
13753         = XOBNEW (&objfile->objfile_obstack, struct dynamic_prop);
13754       attr_to_dynamic_prop (attr, die, cu, newobj->static_link);
13755     }
13756
13757   cu->list_in_scope = cu->get_builder ()->get_local_symbols ();
13758
13759   if (die->child != NULL)
13760     {
13761       child_die = die->child;
13762       while (child_die && child_die->tag)
13763         {
13764           if (child_die->tag == DW_TAG_template_type_param
13765               || child_die->tag == DW_TAG_template_value_param)
13766             {
13767               struct symbol *arg = new_symbol (child_die, NULL, cu);
13768
13769               if (arg != NULL)
13770                 template_args.push_back (arg);
13771             }
13772           else
13773             process_die (child_die, cu);
13774           child_die = sibling_die (child_die);
13775         }
13776     }
13777
13778   inherit_abstract_dies (die, cu);
13779
13780   /* If we have a DW_AT_specification, we might need to import using
13781      directives from the context of the specification DIE.  See the
13782      comment in determine_prefix.  */
13783   if (cu->language == language_cplus
13784       && dwarf2_attr (die, DW_AT_specification, cu))
13785     {
13786       struct dwarf2_cu *spec_cu = cu;
13787       struct die_info *spec_die = die_specification (die, &spec_cu);
13788
13789       while (spec_die)
13790         {
13791           child_die = spec_die->child;
13792           while (child_die && child_die->tag)
13793             {
13794               if (child_die->tag == DW_TAG_imported_module)
13795                 process_die (child_die, spec_cu);
13796               child_die = sibling_die (child_die);
13797             }
13798
13799           /* In some cases, GCC generates specification DIEs that
13800              themselves contain DW_AT_specification attributes.  */
13801           spec_die = die_specification (spec_die, &spec_cu);
13802         }
13803     }
13804
13805   struct context_stack cstk = cu->get_builder ()->pop_context ();
13806   /* Make a block for the local symbols within.  */
13807   block = cu->get_builder ()->finish_block (cstk.name, cstk.old_blocks,
13808                                      cstk.static_link, lowpc, highpc);
13809
13810   /* For C++, set the block's scope.  */
13811   if ((cu->language == language_cplus
13812        || cu->language == language_fortran
13813        || cu->language == language_d
13814        || cu->language == language_rust)
13815       && cu->processing_has_namespace_info)
13816     block_set_scope (block, determine_prefix (die, cu),
13817                      &objfile->objfile_obstack);
13818
13819   /* If we have address ranges, record them.  */
13820   dwarf2_record_block_ranges (die, block, baseaddr, cu);
13821
13822   gdbarch_make_symbol_special (gdbarch, cstk.name, objfile);
13823
13824   /* Attach template arguments to function.  */
13825   if (!template_args.empty ())
13826     {
13827       gdb_assert (templ_func != NULL);
13828
13829       templ_func->n_template_arguments = template_args.size ();
13830       templ_func->template_arguments
13831         = XOBNEWVEC (&objfile->objfile_obstack, struct symbol *,
13832                      templ_func->n_template_arguments);
13833       memcpy (templ_func->template_arguments,
13834               template_args.data (),
13835               (templ_func->n_template_arguments * sizeof (struct symbol *)));
13836
13837       /* Make sure that the symtab is set on the new symbols.  Even
13838          though they don't appear in this symtab directly, other parts
13839          of gdb assume that symbols do, and this is reasonably
13840          true.  */
13841       for (symbol *sym : template_args)
13842         symbol_set_symtab (sym, symbol_symtab (templ_func));
13843     }
13844
13845   /* In C++, we can have functions nested inside functions (e.g., when
13846      a function declares a class that has methods).  This means that
13847      when we finish processing a function scope, we may need to go
13848      back to building a containing block's symbol lists.  */
13849   *cu->get_builder ()->get_local_symbols () = cstk.locals;
13850   cu->get_builder ()->set_local_using_directives (cstk.local_using_directives);
13851
13852   /* If we've finished processing a top-level function, subsequent
13853      symbols go in the file symbol list.  */
13854   if (cu->get_builder ()->outermost_context_p ())
13855     cu->list_in_scope = cu->get_builder ()->get_file_symbols ();
13856 }
13857
13858 /* Process all the DIES contained within a lexical block scope.  Start
13859    a new scope, process the dies, and then close the scope.  */
13860
13861 static void
13862 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
13863 {
13864   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13865   struct gdbarch *gdbarch = get_objfile_arch (objfile);
13866   CORE_ADDR lowpc, highpc;
13867   struct die_info *child_die;
13868   CORE_ADDR baseaddr;
13869
13870   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13871
13872   /* Ignore blocks with missing or invalid low and high pc attributes.  */
13873   /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
13874      as multiple lexical blocks?  Handling children in a sane way would
13875      be nasty.  Might be easier to properly extend generic blocks to
13876      describe ranges.  */
13877   switch (dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
13878     {
13879     case PC_BOUNDS_NOT_PRESENT:
13880       /* DW_TAG_lexical_block has no attributes, process its children as if
13881          there was no wrapping by that DW_TAG_lexical_block.
13882          GCC does no longer produces such DWARF since GCC r224161.  */
13883       for (child_die = die->child;
13884            child_die != NULL && child_die->tag;
13885            child_die = sibling_die (child_die))
13886         process_die (child_die, cu);
13887       return;
13888     case PC_BOUNDS_INVALID:
13889       return;
13890     }
13891   lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
13892   highpc = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
13893
13894   cu->get_builder ()->push_context (0, lowpc);
13895   if (die->child != NULL)
13896     {
13897       child_die = die->child;
13898       while (child_die && child_die->tag)
13899         {
13900           process_die (child_die, cu);
13901           child_die = sibling_die (child_die);
13902         }
13903     }
13904   inherit_abstract_dies (die, cu);
13905   struct context_stack cstk = cu->get_builder ()->pop_context ();
13906
13907   if (*cu->get_builder ()->get_local_symbols () != NULL
13908       || (*cu->get_builder ()->get_local_using_directives ()) != NULL)
13909     {
13910       struct block *block
13911         = cu->get_builder ()->finish_block (0, cstk.old_blocks, NULL,
13912                                      cstk.start_addr, highpc);
13913
13914       /* Note that recording ranges after traversing children, as we
13915          do here, means that recording a parent's ranges entails
13916          walking across all its children's ranges as they appear in
13917          the address map, which is quadratic behavior.
13918
13919          It would be nicer to record the parent's ranges before
13920          traversing its children, simply overriding whatever you find
13921          there.  But since we don't even decide whether to create a
13922          block until after we've traversed its children, that's hard
13923          to do.  */
13924       dwarf2_record_block_ranges (die, block, baseaddr, cu);
13925     }
13926   *cu->get_builder ()->get_local_symbols () = cstk.locals;
13927   cu->get_builder ()->set_local_using_directives (cstk.local_using_directives);
13928 }
13929
13930 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab.  */
13931
13932 static void
13933 read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
13934 {
13935   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13936   struct gdbarch *gdbarch = get_objfile_arch (objfile);
13937   CORE_ADDR pc, baseaddr;
13938   struct attribute *attr;
13939   struct call_site *call_site, call_site_local;
13940   void **slot;
13941   int nparams;
13942   struct die_info *child_die;
13943
13944   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13945
13946   attr = dwarf2_attr (die, DW_AT_call_return_pc, cu);
13947   if (attr == NULL)
13948     {
13949       /* This was a pre-DWARF-5 GNU extension alias
13950          for DW_AT_call_return_pc.  */
13951       attr = dwarf2_attr (die, DW_AT_low_pc, cu);
13952     }
13953   if (!attr)
13954     {
13955       complaint (_("missing DW_AT_call_return_pc for DW_TAG_call_site "
13956                    "DIE %s [in module %s]"),
13957                  sect_offset_str (die->sect_off), objfile_name (objfile));
13958       return;
13959     }
13960   pc = attr_value_as_address (attr) + baseaddr;
13961   pc = gdbarch_adjust_dwarf2_addr (gdbarch, pc);
13962
13963   if (cu->call_site_htab == NULL)
13964     cu->call_site_htab = htab_create_alloc_ex (16, core_addr_hash, core_addr_eq,
13965                                                NULL, &objfile->objfile_obstack,
13966                                                hashtab_obstack_allocate, NULL);
13967   call_site_local.pc = pc;
13968   slot = htab_find_slot (cu->call_site_htab, &call_site_local, INSERT);
13969   if (*slot != NULL)
13970     {
13971       complaint (_("Duplicate PC %s for DW_TAG_call_site "
13972                    "DIE %s [in module %s]"),
13973                  paddress (gdbarch, pc), sect_offset_str (die->sect_off),
13974                  objfile_name (objfile));
13975       return;
13976     }
13977
13978   /* Count parameters at the caller.  */
13979
13980   nparams = 0;
13981   for (child_die = die->child; child_die && child_die->tag;
13982        child_die = sibling_die (child_die))
13983     {
13984       if (child_die->tag != DW_TAG_call_site_parameter
13985           && child_die->tag != DW_TAG_GNU_call_site_parameter)
13986         {
13987           complaint (_("Tag %d is not DW_TAG_call_site_parameter in "
13988                        "DW_TAG_call_site child DIE %s [in module %s]"),
13989                      child_die->tag, sect_offset_str (child_die->sect_off),
13990                      objfile_name (objfile));
13991           continue;
13992         }
13993
13994       nparams++;
13995     }
13996
13997   call_site
13998     = ((struct call_site *)
13999        obstack_alloc (&objfile->objfile_obstack,
14000                       sizeof (*call_site)
14001                       + (sizeof (*call_site->parameter) * (nparams - 1))));
14002   *slot = call_site;
14003   memset (call_site, 0, sizeof (*call_site) - sizeof (*call_site->parameter));
14004   call_site->pc = pc;
14005
14006   if (dwarf2_flag_true_p (die, DW_AT_call_tail_call, cu)
14007       || dwarf2_flag_true_p (die, DW_AT_GNU_tail_call, cu))
14008     {
14009       struct die_info *func_die;
14010
14011       /* Skip also over DW_TAG_inlined_subroutine.  */
14012       for (func_die = die->parent;
14013            func_die && func_die->tag != DW_TAG_subprogram
14014            && func_die->tag != DW_TAG_subroutine_type;
14015            func_die = func_die->parent);
14016
14017       /* DW_AT_call_all_calls is a superset
14018          of DW_AT_call_all_tail_calls.  */
14019       if (func_die
14020           && !dwarf2_flag_true_p (func_die, DW_AT_call_all_calls, cu)
14021           && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_call_sites, cu)
14022           && !dwarf2_flag_true_p (func_die, DW_AT_call_all_tail_calls, cu)
14023           && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_tail_call_sites, cu))
14024         {
14025           /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
14026              not complete.  But keep CALL_SITE for look ups via call_site_htab,
14027              both the initial caller containing the real return address PC and
14028              the final callee containing the current PC of a chain of tail
14029              calls do not need to have the tail call list complete.  But any
14030              function candidate for a virtual tail call frame searched via
14031              TYPE_TAIL_CALL_LIST must have the tail call list complete to be
14032              determined unambiguously.  */
14033         }
14034       else
14035         {
14036           struct type *func_type = NULL;
14037
14038           if (func_die)
14039             func_type = get_die_type (func_die, cu);
14040           if (func_type != NULL)
14041             {
14042               gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC);
14043
14044               /* Enlist this call site to the function.  */
14045               call_site->tail_call_next = TYPE_TAIL_CALL_LIST (func_type);
14046               TYPE_TAIL_CALL_LIST (func_type) = call_site;
14047             }
14048           else
14049             complaint (_("Cannot find function owning DW_TAG_call_site "
14050                          "DIE %s [in module %s]"),
14051                        sect_offset_str (die->sect_off), objfile_name (objfile));
14052         }
14053     }
14054
14055   attr = dwarf2_attr (die, DW_AT_call_target, cu);
14056   if (attr == NULL)
14057     attr = dwarf2_attr (die, DW_AT_GNU_call_site_target, cu);
14058   if (attr == NULL)
14059     attr = dwarf2_attr (die, DW_AT_call_origin, cu);
14060   if (attr == NULL)
14061     {
14062       /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin.  */
14063       attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
14064     }
14065   SET_FIELD_DWARF_BLOCK (call_site->target, NULL);
14066   if (!attr || (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0))
14067     /* Keep NULL DWARF_BLOCK.  */;
14068   else if (attr_form_is_block (attr))
14069     {
14070       struct dwarf2_locexpr_baton *dlbaton;
14071
14072       dlbaton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
14073       dlbaton->data = DW_BLOCK (attr)->data;
14074       dlbaton->size = DW_BLOCK (attr)->size;
14075       dlbaton->per_cu = cu->per_cu;
14076
14077       SET_FIELD_DWARF_BLOCK (call_site->target, dlbaton);
14078     }
14079   else if (attr_form_is_ref (attr))
14080     {
14081       struct dwarf2_cu *target_cu = cu;
14082       struct die_info *target_die;
14083
14084       target_die = follow_die_ref (die, attr, &target_cu);
14085       gdb_assert (target_cu->per_cu->dwarf2_per_objfile->objfile == objfile);
14086       if (die_is_declaration (target_die, target_cu))
14087         {
14088           const char *target_physname;
14089
14090           /* Prefer the mangled name; otherwise compute the demangled one.  */
14091           target_physname = dw2_linkage_name (target_die, target_cu);
14092           if (target_physname == NULL)
14093             target_physname = dwarf2_physname (NULL, target_die, target_cu);
14094           if (target_physname == NULL)
14095             complaint (_("DW_AT_call_target target DIE has invalid "
14096                          "physname, for referencing DIE %s [in module %s]"),
14097                        sect_offset_str (die->sect_off), objfile_name (objfile));
14098           else
14099             SET_FIELD_PHYSNAME (call_site->target, target_physname);
14100         }
14101       else
14102         {
14103           CORE_ADDR lowpc;
14104
14105           /* DW_AT_entry_pc should be preferred.  */
14106           if (dwarf2_get_pc_bounds (target_die, &lowpc, NULL, target_cu, NULL)
14107               <= PC_BOUNDS_INVALID)
14108             complaint (_("DW_AT_call_target target DIE has invalid "
14109                          "low pc, for referencing DIE %s [in module %s]"),
14110                        sect_offset_str (die->sect_off), objfile_name (objfile));
14111           else
14112             {
14113               lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
14114               SET_FIELD_PHYSADDR (call_site->target, lowpc);
14115             }
14116         }
14117     }
14118   else
14119     complaint (_("DW_TAG_call_site DW_AT_call_target is neither "
14120                  "block nor reference, for DIE %s [in module %s]"),
14121                sect_offset_str (die->sect_off), objfile_name (objfile));
14122
14123   call_site->per_cu = cu->per_cu;
14124
14125   for (child_die = die->child;
14126        child_die && child_die->tag;
14127        child_die = sibling_die (child_die))
14128     {
14129       struct call_site_parameter *parameter;
14130       struct attribute *loc, *origin;
14131
14132       if (child_die->tag != DW_TAG_call_site_parameter
14133           && child_die->tag != DW_TAG_GNU_call_site_parameter)
14134         {
14135           /* Already printed the complaint above.  */
14136           continue;
14137         }
14138
14139       gdb_assert (call_site->parameter_count < nparams);
14140       parameter = &call_site->parameter[call_site->parameter_count];
14141
14142       /* DW_AT_location specifies the register number or DW_AT_abstract_origin
14143          specifies DW_TAG_formal_parameter.  Value of the data assumed for the
14144          register is contained in DW_AT_call_value.  */
14145
14146       loc = dwarf2_attr (child_die, DW_AT_location, cu);
14147       origin = dwarf2_attr (child_die, DW_AT_call_parameter, cu);
14148       if (origin == NULL)
14149         {
14150           /* This was a pre-DWARF-5 GNU extension alias
14151              for DW_AT_call_parameter.  */
14152           origin = dwarf2_attr (child_die, DW_AT_abstract_origin, cu);
14153         }
14154       if (loc == NULL && origin != NULL && attr_form_is_ref (origin))
14155         {
14156           parameter->kind = CALL_SITE_PARAMETER_PARAM_OFFSET;
14157
14158           sect_offset sect_off
14159             = (sect_offset) dwarf2_get_ref_die_offset (origin);
14160           if (!offset_in_cu_p (&cu->header, sect_off))
14161             {
14162               /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
14163                  binding can be done only inside one CU.  Such referenced DIE
14164                  therefore cannot be even moved to DW_TAG_partial_unit.  */
14165               complaint (_("DW_AT_call_parameter offset is not in CU for "
14166                            "DW_TAG_call_site child DIE %s [in module %s]"),
14167                          sect_offset_str (child_die->sect_off),
14168                          objfile_name (objfile));
14169               continue;
14170             }
14171           parameter->u.param_cu_off
14172             = (cu_offset) (sect_off - cu->header.sect_off);
14173         }
14174       else if (loc == NULL || origin != NULL || !attr_form_is_block (loc))
14175         {
14176           complaint (_("No DW_FORM_block* DW_AT_location for "
14177                        "DW_TAG_call_site child DIE %s [in module %s]"),
14178                      sect_offset_str (child_die->sect_off), objfile_name (objfile));
14179           continue;
14180         }
14181       else
14182         {
14183           parameter->u.dwarf_reg = dwarf_block_to_dwarf_reg
14184             (DW_BLOCK (loc)->data, &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size]);
14185           if (parameter->u.dwarf_reg != -1)
14186             parameter->kind = CALL_SITE_PARAMETER_DWARF_REG;
14187           else if (dwarf_block_to_sp_offset (gdbarch, DW_BLOCK (loc)->data,
14188                                     &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size],
14189                                              &parameter->u.fb_offset))
14190             parameter->kind = CALL_SITE_PARAMETER_FB_OFFSET;
14191           else
14192             {
14193               complaint (_("Only single DW_OP_reg or DW_OP_fbreg is supported "
14194                            "for DW_FORM_block* DW_AT_location is supported for "
14195                            "DW_TAG_call_site child DIE %s "
14196                            "[in module %s]"),
14197                          sect_offset_str (child_die->sect_off),
14198                          objfile_name (objfile));
14199               continue;
14200             }
14201         }
14202
14203       attr = dwarf2_attr (child_die, DW_AT_call_value, cu);
14204       if (attr == NULL)
14205         attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_value, cu);
14206       if (!attr_form_is_block (attr))
14207         {
14208           complaint (_("No DW_FORM_block* DW_AT_call_value for "
14209                        "DW_TAG_call_site child DIE %s [in module %s]"),
14210                      sect_offset_str (child_die->sect_off),
14211                      objfile_name (objfile));
14212           continue;
14213         }
14214       parameter->value = DW_BLOCK (attr)->data;
14215       parameter->value_size = DW_BLOCK (attr)->size;
14216
14217       /* Parameters are not pre-cleared by memset above.  */
14218       parameter->data_value = NULL;
14219       parameter->data_value_size = 0;
14220       call_site->parameter_count++;
14221
14222       attr = dwarf2_attr (child_die, DW_AT_call_data_value, cu);
14223       if (attr == NULL)
14224         attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_data_value, cu);
14225       if (attr)
14226         {
14227           if (!attr_form_is_block (attr))
14228             complaint (_("No DW_FORM_block* DW_AT_call_data_value for "
14229                          "DW_TAG_call_site child DIE %s [in module %s]"),
14230                        sect_offset_str (child_die->sect_off),
14231                        objfile_name (objfile));
14232           else
14233             {
14234               parameter->data_value = DW_BLOCK (attr)->data;
14235               parameter->data_value_size = DW_BLOCK (attr)->size;
14236             }
14237         }
14238     }
14239 }
14240
14241 /* Helper function for read_variable.  If DIE represents a virtual
14242    table, then return the type of the concrete object that is
14243    associated with the virtual table.  Otherwise, return NULL.  */
14244
14245 static struct type *
14246 rust_containing_type (struct die_info *die, struct dwarf2_cu *cu)
14247 {
14248   struct attribute *attr = dwarf2_attr (die, DW_AT_type, cu);
14249   if (attr == NULL)
14250     return NULL;
14251
14252   /* Find the type DIE.  */
14253   struct die_info *type_die = NULL;
14254   struct dwarf2_cu *type_cu = cu;
14255
14256   if (attr_form_is_ref (attr))
14257     type_die = follow_die_ref (die, attr, &type_cu);
14258   if (type_die == NULL)
14259     return NULL;
14260
14261   if (dwarf2_attr (type_die, DW_AT_containing_type, type_cu) == NULL)
14262     return NULL;
14263   return die_containing_type (type_die, type_cu);
14264 }
14265
14266 /* Read a variable (DW_TAG_variable) DIE and create a new symbol.  */
14267
14268 static void
14269 read_variable (struct die_info *die, struct dwarf2_cu *cu)
14270 {
14271   struct rust_vtable_symbol *storage = NULL;
14272
14273   if (cu->language == language_rust)
14274     {
14275       struct type *containing_type = rust_containing_type (die, cu);
14276
14277       if (containing_type != NULL)
14278         {
14279           struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14280
14281           storage = OBSTACK_ZALLOC (&objfile->objfile_obstack,
14282                                     struct rust_vtable_symbol);
14283           initialize_objfile_symbol (storage);
14284           storage->concrete_type = containing_type;
14285           storage->subclass = SYMBOL_RUST_VTABLE;
14286         }
14287     }
14288
14289   struct symbol *res = new_symbol (die, NULL, cu, storage);
14290   struct attribute *abstract_origin
14291     = dwarf2_attr (die, DW_AT_abstract_origin, cu);
14292   struct attribute *loc = dwarf2_attr (die, DW_AT_location, cu);
14293   if (res == NULL && loc && abstract_origin)
14294     {
14295       /* We have a variable without a name, but with a location and an abstract
14296          origin.  This may be a concrete instance of an abstract variable
14297          referenced from an DW_OP_GNU_variable_value, so save it to find it back
14298          later.  */
14299       struct dwarf2_cu *origin_cu = cu;
14300       struct die_info *origin_die
14301         = follow_die_ref (die, abstract_origin, &origin_cu);
14302       dwarf2_per_objfile *dpo = cu->per_cu->dwarf2_per_objfile;
14303       dpo->abstract_to_concrete[origin_die].push_back (die);
14304     }
14305 }
14306
14307 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
14308    reading .debug_rnglists.
14309    Callback's type should be:
14310     void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14311    Return true if the attributes are present and valid, otherwise,
14312    return false.  */
14313
14314 template <typename Callback>
14315 static bool
14316 dwarf2_rnglists_process (unsigned offset, struct dwarf2_cu *cu,
14317                          Callback &&callback)
14318 {
14319   struct dwarf2_per_objfile *dwarf2_per_objfile
14320     = cu->per_cu->dwarf2_per_objfile;
14321   struct objfile *objfile = dwarf2_per_objfile->objfile;
14322   bfd *obfd = objfile->obfd;
14323   /* Base address selection entry.  */
14324   CORE_ADDR base;
14325   int found_base;
14326   const gdb_byte *buffer;
14327   CORE_ADDR baseaddr;
14328   bool overflow = false;
14329
14330   found_base = cu->base_known;
14331   base = cu->base_address;
14332
14333   dwarf2_read_section (objfile, &dwarf2_per_objfile->rnglists);
14334   if (offset >= dwarf2_per_objfile->rnglists.size)
14335     {
14336       complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14337                  offset);
14338       return false;
14339     }
14340   buffer = dwarf2_per_objfile->rnglists.buffer + offset;
14341
14342   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
14343
14344   while (1)
14345     {
14346       /* Initialize it due to a false compiler warning.  */
14347       CORE_ADDR range_beginning = 0, range_end = 0;
14348       const gdb_byte *buf_end = (dwarf2_per_objfile->rnglists.buffer
14349                                  + dwarf2_per_objfile->rnglists.size);
14350       unsigned int bytes_read;
14351
14352       if (buffer == buf_end)
14353         {
14354           overflow = true;
14355           break;
14356         }
14357       const auto rlet = static_cast<enum dwarf_range_list_entry>(*buffer++);
14358       switch (rlet)
14359         {
14360         case DW_RLE_end_of_list:
14361           break;
14362         case DW_RLE_base_address:
14363           if (buffer + cu->header.addr_size > buf_end)
14364             {
14365               overflow = true;
14366               break;
14367             }
14368           base = read_address (obfd, buffer, cu, &bytes_read);
14369           found_base = 1;
14370           buffer += bytes_read;
14371           break;
14372         case DW_RLE_start_length:
14373           if (buffer + cu->header.addr_size > buf_end)
14374             {
14375               overflow = true;
14376               break;
14377             }
14378           range_beginning = read_address (obfd, buffer, cu, &bytes_read);
14379           buffer += bytes_read;
14380           range_end = (range_beginning
14381                        + read_unsigned_leb128 (obfd, buffer, &bytes_read));
14382           buffer += bytes_read;
14383           if (buffer > buf_end)
14384             {
14385               overflow = true;
14386               break;
14387             }
14388           break;
14389         case DW_RLE_offset_pair:
14390           range_beginning = read_unsigned_leb128 (obfd, buffer, &bytes_read);
14391           buffer += bytes_read;
14392           if (buffer > buf_end)
14393             {
14394               overflow = true;
14395               break;
14396             }
14397           range_end = read_unsigned_leb128 (obfd, buffer, &bytes_read);
14398           buffer += bytes_read;
14399           if (buffer > buf_end)
14400             {
14401               overflow = true;
14402               break;
14403             }
14404           break;
14405         case DW_RLE_start_end:
14406           if (buffer + 2 * cu->header.addr_size > buf_end)
14407             {
14408               overflow = true;
14409               break;
14410             }
14411           range_beginning = read_address (obfd, buffer, cu, &bytes_read);
14412           buffer += bytes_read;
14413           range_end = read_address (obfd, buffer, cu, &bytes_read);
14414           buffer += bytes_read;
14415           break;
14416         default:
14417           complaint (_("Invalid .debug_rnglists data (no base address)"));
14418           return false;
14419         }
14420       if (rlet == DW_RLE_end_of_list || overflow)
14421         break;
14422       if (rlet == DW_RLE_base_address)
14423         continue;
14424
14425       if (!found_base)
14426         {
14427           /* We have no valid base address for the ranges
14428              data.  */
14429           complaint (_("Invalid .debug_rnglists data (no base address)"));
14430           return false;
14431         }
14432
14433       if (range_beginning > range_end)
14434         {
14435           /* Inverted range entries are invalid.  */
14436           complaint (_("Invalid .debug_rnglists data (inverted range)"));
14437           return false;
14438         }
14439
14440       /* Empty range entries have no effect.  */
14441       if (range_beginning == range_end)
14442         continue;
14443
14444       range_beginning += base;
14445       range_end += base;
14446
14447       /* A not-uncommon case of bad debug info.
14448          Don't pollute the addrmap with bad data.  */
14449       if (range_beginning + baseaddr == 0
14450           && !dwarf2_per_objfile->has_section_at_zero)
14451         {
14452           complaint (_(".debug_rnglists entry has start address of zero"
14453                        " [in module %s]"), objfile_name (objfile));
14454           continue;
14455         }
14456
14457       callback (range_beginning, range_end);
14458     }
14459
14460   if (overflow)
14461     {
14462       complaint (_("Offset %d is not terminated "
14463                    "for DW_AT_ranges attribute"),
14464                  offset);
14465       return false;
14466     }
14467
14468   return true;
14469 }
14470
14471 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
14472    Callback's type should be:
14473     void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14474    Return 1 if the attributes are present and valid, otherwise, return 0.  */
14475
14476 template <typename Callback>
14477 static int
14478 dwarf2_ranges_process (unsigned offset, struct dwarf2_cu *cu,
14479                        Callback &&callback)
14480 {
14481   struct dwarf2_per_objfile *dwarf2_per_objfile
14482       = cu->per_cu->dwarf2_per_objfile;
14483   struct objfile *objfile = dwarf2_per_objfile->objfile;
14484   struct comp_unit_head *cu_header = &cu->header;
14485   bfd *obfd = objfile->obfd;
14486   unsigned int addr_size = cu_header->addr_size;
14487   CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
14488   /* Base address selection entry.  */
14489   CORE_ADDR base;
14490   int found_base;
14491   unsigned int dummy;
14492   const gdb_byte *buffer;
14493   CORE_ADDR baseaddr;
14494
14495   if (cu_header->version >= 5)
14496     return dwarf2_rnglists_process (offset, cu, callback);
14497
14498   found_base = cu->base_known;
14499   base = cu->base_address;
14500
14501   dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
14502   if (offset >= dwarf2_per_objfile->ranges.size)
14503     {
14504       complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14505                  offset);
14506       return 0;
14507     }
14508   buffer = dwarf2_per_objfile->ranges.buffer + offset;
14509
14510   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
14511
14512   while (1)
14513     {
14514       CORE_ADDR range_beginning, range_end;
14515
14516       range_beginning = read_address (obfd, buffer, cu, &dummy);
14517       buffer += addr_size;
14518       range_end = read_address (obfd, buffer, cu, &dummy);
14519       buffer += addr_size;
14520       offset += 2 * addr_size;
14521
14522       /* An end of list marker is a pair of zero addresses.  */
14523       if (range_beginning == 0 && range_end == 0)
14524         /* Found the end of list entry.  */
14525         break;
14526
14527       /* Each base address selection entry is a pair of 2 values.
14528          The first is the largest possible address, the second is
14529          the base address.  Check for a base address here.  */
14530       if ((range_beginning & mask) == mask)
14531         {
14532           /* If we found the largest possible address, then we already
14533              have the base address in range_end.  */
14534           base = range_end;
14535           found_base = 1;
14536           continue;
14537         }
14538
14539       if (!found_base)
14540         {
14541           /* We have no valid base address for the ranges
14542              data.  */
14543           complaint (_("Invalid .debug_ranges data (no base address)"));
14544           return 0;
14545         }
14546
14547       if (range_beginning > range_end)
14548         {
14549           /* Inverted range entries are invalid.  */
14550           complaint (_("Invalid .debug_ranges data (inverted range)"));
14551           return 0;
14552         }
14553
14554       /* Empty range entries have no effect.  */
14555       if (range_beginning == range_end)
14556         continue;
14557
14558       range_beginning += base;
14559       range_end += base;
14560
14561       /* A not-uncommon case of bad debug info.
14562          Don't pollute the addrmap with bad data.  */
14563       if (range_beginning + baseaddr == 0
14564           && !dwarf2_per_objfile->has_section_at_zero)
14565         {
14566           complaint (_(".debug_ranges entry has start address of zero"
14567                        " [in module %s]"), objfile_name (objfile));
14568           continue;
14569         }
14570
14571       callback (range_beginning, range_end);
14572     }
14573
14574   return 1;
14575 }
14576
14577 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
14578    Return 1 if the attributes are present and valid, otherwise, return 0.
14579    If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'.  */
14580
14581 static int
14582 dwarf2_ranges_read (unsigned offset, CORE_ADDR *low_return,
14583                     CORE_ADDR *high_return, struct dwarf2_cu *cu,
14584                     struct partial_symtab *ranges_pst)
14585 {
14586   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14587   struct gdbarch *gdbarch = get_objfile_arch (objfile);
14588   const CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
14589                                        SECT_OFF_TEXT (objfile));
14590   int low_set = 0;
14591   CORE_ADDR low = 0;
14592   CORE_ADDR high = 0;
14593   int retval;
14594
14595   retval = dwarf2_ranges_process (offset, cu,
14596     [&] (CORE_ADDR range_beginning, CORE_ADDR range_end)
14597     {
14598       if (ranges_pst != NULL)
14599         {
14600           CORE_ADDR lowpc;
14601           CORE_ADDR highpc;
14602
14603           lowpc = (gdbarch_adjust_dwarf2_addr (gdbarch,
14604                                                range_beginning + baseaddr)
14605                    - baseaddr);
14606           highpc = (gdbarch_adjust_dwarf2_addr (gdbarch,
14607                                                 range_end + baseaddr)
14608                     - baseaddr);
14609           addrmap_set_empty (objfile->partial_symtabs->psymtabs_addrmap,
14610                              lowpc, highpc - 1, ranges_pst);
14611         }
14612
14613       /* FIXME: This is recording everything as a low-high
14614          segment of consecutive addresses.  We should have a
14615          data structure for discontiguous block ranges
14616          instead.  */
14617       if (! low_set)
14618         {
14619           low = range_beginning;
14620           high = range_end;
14621           low_set = 1;
14622         }
14623       else
14624         {
14625           if (range_beginning < low)
14626             low = range_beginning;
14627           if (range_end > high)
14628             high = range_end;
14629         }
14630     });
14631   if (!retval)
14632     return 0;
14633
14634   if (! low_set)
14635     /* If the first entry is an end-of-list marker, the range
14636        describes an empty scope, i.e. no instructions.  */
14637     return 0;
14638
14639   if (low_return)
14640     *low_return = low;
14641   if (high_return)
14642     *high_return = high;
14643   return 1;
14644 }
14645
14646 /* Get low and high pc attributes from a die.  See enum pc_bounds_kind
14647    definition for the return value.  *LOWPC and *HIGHPC are set iff
14648    neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned.  */
14649
14650 static enum pc_bounds_kind
14651 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
14652                       CORE_ADDR *highpc, struct dwarf2_cu *cu,
14653                       struct partial_symtab *pst)
14654 {
14655   struct dwarf2_per_objfile *dwarf2_per_objfile
14656     = cu->per_cu->dwarf2_per_objfile;
14657   struct attribute *attr;
14658   struct attribute *attr_high;
14659   CORE_ADDR low = 0;
14660   CORE_ADDR high = 0;
14661   enum pc_bounds_kind ret;
14662
14663   attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
14664   if (attr_high)
14665     {
14666       attr = dwarf2_attr (die, DW_AT_low_pc, cu);
14667       if (attr)
14668         {
14669           low = attr_value_as_address (attr);
14670           high = attr_value_as_address (attr_high);
14671           if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
14672             high += low;
14673         }
14674       else
14675         /* Found high w/o low attribute.  */
14676         return PC_BOUNDS_INVALID;
14677
14678       /* Found consecutive range of addresses.  */
14679       ret = PC_BOUNDS_HIGH_LOW;
14680     }
14681   else
14682     {
14683       attr = dwarf2_attr (die, DW_AT_ranges, cu);
14684       if (attr != NULL)
14685         {
14686           /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14687              We take advantage of the fact that DW_AT_ranges does not appear
14688              in DW_TAG_compile_unit of DWO files.  */
14689           int need_ranges_base = die->tag != DW_TAG_compile_unit;
14690           unsigned int ranges_offset = (DW_UNSND (attr)
14691                                         + (need_ranges_base
14692                                            ? cu->ranges_base
14693                                            : 0));
14694
14695           /* Value of the DW_AT_ranges attribute is the offset in the
14696              .debug_ranges section.  */
14697           if (!dwarf2_ranges_read (ranges_offset, &low, &high, cu, pst))
14698             return PC_BOUNDS_INVALID;
14699           /* Found discontinuous range of addresses.  */
14700           ret = PC_BOUNDS_RANGES;
14701         }
14702       else
14703         return PC_BOUNDS_NOT_PRESENT;
14704     }
14705
14706   /* partial_die_info::read has also the strict LOW < HIGH requirement.  */
14707   if (high <= low)
14708     return PC_BOUNDS_INVALID;
14709
14710   /* When using the GNU linker, .gnu.linkonce. sections are used to
14711      eliminate duplicate copies of functions and vtables and such.
14712      The linker will arbitrarily choose one and discard the others.
14713      The AT_*_pc values for such functions refer to local labels in
14714      these sections.  If the section from that file was discarded, the
14715      labels are not in the output, so the relocs get a value of 0.
14716      If this is a discarded function, mark the pc bounds as invalid,
14717      so that GDB will ignore it.  */
14718   if (low == 0 && !dwarf2_per_objfile->has_section_at_zero)
14719     return PC_BOUNDS_INVALID;
14720
14721   *lowpc = low;
14722   if (highpc)
14723     *highpc = high;
14724   return ret;
14725 }
14726
14727 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
14728    its low and high PC addresses.  Do nothing if these addresses could not
14729    be determined.  Otherwise, set LOWPC to the low address if it is smaller,
14730    and HIGHPC to the high address if greater than HIGHPC.  */
14731
14732 static void
14733 dwarf2_get_subprogram_pc_bounds (struct die_info *die,
14734                                  CORE_ADDR *lowpc, CORE_ADDR *highpc,
14735                                  struct dwarf2_cu *cu)
14736 {
14737   CORE_ADDR low, high;
14738   struct die_info *child = die->child;
14739
14740   if (dwarf2_get_pc_bounds (die, &low, &high, cu, NULL) >= PC_BOUNDS_RANGES)
14741     {
14742       *lowpc = std::min (*lowpc, low);
14743       *highpc = std::max (*highpc, high);
14744     }
14745
14746   /* If the language does not allow nested subprograms (either inside
14747      subprograms or lexical blocks), we're done.  */
14748   if (cu->language != language_ada)
14749     return;
14750
14751   /* Check all the children of the given DIE.  If it contains nested
14752      subprograms, then check their pc bounds.  Likewise, we need to
14753      check lexical blocks as well, as they may also contain subprogram
14754      definitions.  */
14755   while (child && child->tag)
14756     {
14757       if (child->tag == DW_TAG_subprogram
14758           || child->tag == DW_TAG_lexical_block)
14759         dwarf2_get_subprogram_pc_bounds (child, lowpc, highpc, cu);
14760       child = sibling_die (child);
14761     }
14762 }
14763
14764 /* Get the low and high pc's represented by the scope DIE, and store
14765    them in *LOWPC and *HIGHPC.  If the correct values can't be
14766    determined, set *LOWPC to -1 and *HIGHPC to 0.  */
14767
14768 static void
14769 get_scope_pc_bounds (struct die_info *die,
14770                      CORE_ADDR *lowpc, CORE_ADDR *highpc,
14771                      struct dwarf2_cu *cu)
14772 {
14773   CORE_ADDR best_low = (CORE_ADDR) -1;
14774   CORE_ADDR best_high = (CORE_ADDR) 0;
14775   CORE_ADDR current_low, current_high;
14776
14777   if (dwarf2_get_pc_bounds (die, &current_low, &current_high, cu, NULL)
14778       >= PC_BOUNDS_RANGES)
14779     {
14780       best_low = current_low;
14781       best_high = current_high;
14782     }
14783   else
14784     {
14785       struct die_info *child = die->child;
14786
14787       while (child && child->tag)
14788         {
14789           switch (child->tag) {
14790           case DW_TAG_subprogram:
14791             dwarf2_get_subprogram_pc_bounds (child, &best_low, &best_high, cu);
14792             break;
14793           case DW_TAG_namespace:
14794           case DW_TAG_module:
14795             /* FIXME: carlton/2004-01-16: Should we do this for
14796                DW_TAG_class_type/DW_TAG_structure_type, too?  I think
14797                that current GCC's always emit the DIEs corresponding
14798                to definitions of methods of classes as children of a
14799                DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
14800                the DIEs giving the declarations, which could be
14801                anywhere).  But I don't see any reason why the
14802                standards says that they have to be there.  */
14803             get_scope_pc_bounds (child, &current_low, &current_high, cu);
14804
14805             if (current_low != ((CORE_ADDR) -1))
14806               {
14807                 best_low = std::min (best_low, current_low);
14808                 best_high = std::max (best_high, current_high);
14809               }
14810             break;
14811           default:
14812             /* Ignore.  */
14813             break;
14814           }
14815
14816           child = sibling_die (child);
14817         }
14818     }
14819
14820   *lowpc = best_low;
14821   *highpc = best_high;
14822 }
14823
14824 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
14825    in DIE.  */
14826
14827 static void
14828 dwarf2_record_block_ranges (struct die_info *die, struct block *block,
14829                             CORE_ADDR baseaddr, struct dwarf2_cu *cu)
14830 {
14831   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14832   struct gdbarch *gdbarch = get_objfile_arch (objfile);
14833   struct attribute *attr;
14834   struct attribute *attr_high;
14835
14836   attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
14837   if (attr_high)
14838     {
14839       attr = dwarf2_attr (die, DW_AT_low_pc, cu);
14840       if (attr)
14841         {
14842           CORE_ADDR low = attr_value_as_address (attr);
14843           CORE_ADDR high = attr_value_as_address (attr_high);
14844
14845           if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
14846             high += low;
14847
14848           low = gdbarch_adjust_dwarf2_addr (gdbarch, low + baseaddr);
14849           high = gdbarch_adjust_dwarf2_addr (gdbarch, high + baseaddr);
14850           cu->get_builder ()->record_block_range (block, low, high - 1);
14851         }
14852     }
14853
14854   attr = dwarf2_attr (die, DW_AT_ranges, cu);
14855   if (attr)
14856     {
14857       /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14858          We take advantage of the fact that DW_AT_ranges does not appear
14859          in DW_TAG_compile_unit of DWO files.  */
14860       int need_ranges_base = die->tag != DW_TAG_compile_unit;
14861
14862       /* The value of the DW_AT_ranges attribute is the offset of the
14863          address range list in the .debug_ranges section.  */
14864       unsigned long offset = (DW_UNSND (attr)
14865                               + (need_ranges_base ? cu->ranges_base : 0));
14866
14867       std::vector<blockrange> blockvec;
14868       dwarf2_ranges_process (offset, cu,
14869         [&] (CORE_ADDR start, CORE_ADDR end)
14870         {
14871           start += baseaddr;
14872           end += baseaddr;
14873           start = gdbarch_adjust_dwarf2_addr (gdbarch, start);
14874           end = gdbarch_adjust_dwarf2_addr (gdbarch, end);
14875           cu->get_builder ()->record_block_range (block, start, end - 1);
14876           blockvec.emplace_back (start, end);
14877         });
14878
14879       BLOCK_RANGES(block) = make_blockranges (objfile, blockvec);
14880     }
14881 }
14882
14883 /* Check whether the producer field indicates either of GCC < 4.6, or the
14884    Intel C/C++ compiler, and cache the result in CU.  */
14885
14886 static void
14887 check_producer (struct dwarf2_cu *cu)
14888 {
14889   int major, minor;
14890
14891   if (cu->producer == NULL)
14892     {
14893       /* For unknown compilers expect their behavior is DWARF version
14894          compliant.
14895
14896          GCC started to support .debug_types sections by -gdwarf-4 since
14897          gcc-4.5.x.  As the .debug_types sections are missing DW_AT_producer
14898          for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
14899          combination.  gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
14900          interpreted incorrectly by GDB now - GCC PR debug/48229.  */
14901     }
14902   else if (producer_is_gcc (cu->producer, &major, &minor))
14903     {
14904       cu->producer_is_gxx_lt_4_6 = major < 4 || (major == 4 && minor < 6);
14905       cu->producer_is_gcc_lt_4_3 = major < 4 || (major == 4 && minor < 3);
14906     }
14907   else if (producer_is_icc (cu->producer, &major, &minor))
14908     {
14909       cu->producer_is_icc = true;
14910       cu->producer_is_icc_lt_14 = major < 14;
14911     }
14912   else if (startswith (cu->producer, "CodeWarrior S12/L-ISA"))
14913     cu->producer_is_codewarrior = true;
14914   else
14915     {
14916       /* For other non-GCC compilers, expect their behavior is DWARF version
14917          compliant.  */
14918     }
14919
14920   cu->checked_producer = true;
14921 }
14922
14923 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
14924    to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
14925    during 4.6.0 experimental.  */
14926
14927 static bool
14928 producer_is_gxx_lt_4_6 (struct dwarf2_cu *cu)
14929 {
14930   if (!cu->checked_producer)
14931     check_producer (cu);
14932
14933   return cu->producer_is_gxx_lt_4_6;
14934 }
14935
14936
14937 /* Codewarrior (at least as of version 5.0.40) generates dwarf line information
14938    with incorrect is_stmt attributes.  */
14939
14940 static bool
14941 producer_is_codewarrior (struct dwarf2_cu *cu)
14942 {
14943   if (!cu->checked_producer)
14944     check_producer (cu);
14945
14946   return cu->producer_is_codewarrior;
14947 }
14948
14949 /* Return the default accessibility type if it is not overriden by
14950    DW_AT_accessibility.  */
14951
14952 static enum dwarf_access_attribute
14953 dwarf2_default_access_attribute (struct die_info *die, struct dwarf2_cu *cu)
14954 {
14955   if (cu->header.version < 3 || producer_is_gxx_lt_4_6 (cu))
14956     {
14957       /* The default DWARF 2 accessibility for members is public, the default
14958          accessibility for inheritance is private.  */
14959
14960       if (die->tag != DW_TAG_inheritance)
14961         return DW_ACCESS_public;
14962       else
14963         return DW_ACCESS_private;
14964     }
14965   else
14966     {
14967       /* DWARF 3+ defines the default accessibility a different way.  The same
14968          rules apply now for DW_TAG_inheritance as for the members and it only
14969          depends on the container kind.  */
14970
14971       if (die->parent->tag == DW_TAG_class_type)
14972         return DW_ACCESS_private;
14973       else
14974         return DW_ACCESS_public;
14975     }
14976 }
14977
14978 /* Look for DW_AT_data_member_location.  Set *OFFSET to the byte
14979    offset.  If the attribute was not found return 0, otherwise return
14980    1.  If it was found but could not properly be handled, set *OFFSET
14981    to 0.  */
14982
14983 static int
14984 handle_data_member_location (struct die_info *die, struct dwarf2_cu *cu,
14985                              LONGEST *offset)
14986 {
14987   struct attribute *attr;
14988
14989   attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
14990   if (attr != NULL)
14991     {
14992       *offset = 0;
14993
14994       /* Note that we do not check for a section offset first here.
14995          This is because DW_AT_data_member_location is new in DWARF 4,
14996          so if we see it, we can assume that a constant form is really
14997          a constant and not a section offset.  */
14998       if (attr_form_is_constant (attr))
14999         *offset = dwarf2_get_attr_constant_value (attr, 0);
15000       else if (attr_form_is_section_offset (attr))
15001         dwarf2_complex_location_expr_complaint ();
15002       else if (attr_form_is_block (attr))
15003         *offset = decode_locdesc (DW_BLOCK (attr), cu);
15004       else
15005         dwarf2_complex_location_expr_complaint ();
15006
15007       return 1;
15008     }
15009
15010   return 0;
15011 }
15012
15013 /* Add an aggregate field to the field list.  */
15014
15015 static void
15016 dwarf2_add_field (struct field_info *fip, struct die_info *die,
15017                   struct dwarf2_cu *cu)
15018 {
15019   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15020   struct gdbarch *gdbarch = get_objfile_arch (objfile);
15021   struct nextfield *new_field;
15022   struct attribute *attr;
15023   struct field *fp;
15024   const char *fieldname = "";
15025
15026   if (die->tag == DW_TAG_inheritance)
15027     {
15028       fip->baseclasses.emplace_back ();
15029       new_field = &fip->baseclasses.back ();
15030     }
15031   else
15032     {
15033       fip->fields.emplace_back ();
15034       new_field = &fip->fields.back ();
15035     }
15036
15037   fip->nfields++;
15038
15039   attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15040   if (attr)
15041     new_field->accessibility = DW_UNSND (attr);
15042   else
15043     new_field->accessibility = dwarf2_default_access_attribute (die, cu);
15044   if (new_field->accessibility != DW_ACCESS_public)
15045     fip->non_public_fields = 1;
15046
15047   attr = dwarf2_attr (die, DW_AT_virtuality, cu);
15048   if (attr)
15049     new_field->virtuality = DW_UNSND (attr);
15050   else
15051     new_field->virtuality = DW_VIRTUALITY_none;
15052
15053   fp = &new_field->field;
15054
15055   if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
15056     {
15057       LONGEST offset;
15058
15059       /* Data member other than a C++ static data member.  */
15060
15061       /* Get type of field.  */
15062       fp->type = die_type (die, cu);
15063
15064       SET_FIELD_BITPOS (*fp, 0);
15065
15066       /* Get bit size of field (zero if none).  */
15067       attr = dwarf2_attr (die, DW_AT_bit_size, cu);
15068       if (attr)
15069         {
15070           FIELD_BITSIZE (*fp) = DW_UNSND (attr);
15071         }
15072       else
15073         {
15074           FIELD_BITSIZE (*fp) = 0;
15075         }
15076
15077       /* Get bit offset of field.  */
15078       if (handle_data_member_location (die, cu, &offset))
15079         SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
15080       attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
15081       if (attr)
15082         {
15083           if (gdbarch_bits_big_endian (gdbarch))
15084             {
15085               /* For big endian bits, the DW_AT_bit_offset gives the
15086                  additional bit offset from the MSB of the containing
15087                  anonymous object to the MSB of the field.  We don't
15088                  have to do anything special since we don't need to
15089                  know the size of the anonymous object.  */
15090               SET_FIELD_BITPOS (*fp, FIELD_BITPOS (*fp) + DW_UNSND (attr));
15091             }
15092           else
15093             {
15094               /* For little endian bits, compute the bit offset to the
15095                  MSB of the anonymous object, subtract off the number of
15096                  bits from the MSB of the field to the MSB of the
15097                  object, and then subtract off the number of bits of
15098                  the field itself.  The result is the bit offset of
15099                  the LSB of the field.  */
15100               int anonymous_size;
15101               int bit_offset = DW_UNSND (attr);
15102
15103               attr = dwarf2_attr (die, DW_AT_byte_size, cu);
15104               if (attr)
15105                 {
15106                   /* The size of the anonymous object containing
15107                      the bit field is explicit, so use the
15108                      indicated size (in bytes).  */
15109                   anonymous_size = DW_UNSND (attr);
15110                 }
15111               else
15112                 {
15113                   /* The size of the anonymous object containing
15114                      the bit field must be inferred from the type
15115                      attribute of the data member containing the
15116                      bit field.  */
15117                   anonymous_size = TYPE_LENGTH (fp->type);
15118                 }
15119               SET_FIELD_BITPOS (*fp,
15120                                 (FIELD_BITPOS (*fp)
15121                                  + anonymous_size * bits_per_byte
15122                                  - bit_offset - FIELD_BITSIZE (*fp)));
15123             }
15124         }
15125       attr = dwarf2_attr (die, DW_AT_data_bit_offset, cu);
15126       if (attr != NULL)
15127         SET_FIELD_BITPOS (*fp, (FIELD_BITPOS (*fp)
15128                                 + dwarf2_get_attr_constant_value (attr, 0)));
15129
15130       /* Get name of field.  */
15131       fieldname = dwarf2_name (die, cu);
15132       if (fieldname == NULL)
15133         fieldname = "";
15134
15135       /* The name is already allocated along with this objfile, so we don't
15136          need to duplicate it for the type.  */
15137       fp->name = fieldname;
15138
15139       /* Change accessibility for artificial fields (e.g. virtual table
15140          pointer or virtual base class pointer) to private.  */
15141       if (dwarf2_attr (die, DW_AT_artificial, cu))
15142         {
15143           FIELD_ARTIFICIAL (*fp) = 1;
15144           new_field->accessibility = DW_ACCESS_private;
15145           fip->non_public_fields = 1;
15146         }
15147     }
15148   else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
15149     {
15150       /* C++ static member.  */
15151
15152       /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
15153          is a declaration, but all versions of G++ as of this writing
15154          (so through at least 3.2.1) incorrectly generate
15155          DW_TAG_variable tags.  */
15156
15157       const char *physname;
15158
15159       /* Get name of field.  */
15160       fieldname = dwarf2_name (die, cu);
15161       if (fieldname == NULL)
15162         return;
15163
15164       attr = dwarf2_attr (die, DW_AT_const_value, cu);
15165       if (attr
15166           /* Only create a symbol if this is an external value.
15167              new_symbol checks this and puts the value in the global symbol
15168              table, which we want.  If it is not external, new_symbol
15169              will try to put the value in cu->list_in_scope which is wrong.  */
15170           && dwarf2_flag_true_p (die, DW_AT_external, cu))
15171         {
15172           /* A static const member, not much different than an enum as far as
15173              we're concerned, except that we can support more types.  */
15174           new_symbol (die, NULL, cu);
15175         }
15176
15177       /* Get physical name.  */
15178       physname = dwarf2_physname (fieldname, die, cu);
15179
15180       /* The name is already allocated along with this objfile, so we don't
15181          need to duplicate it for the type.  */
15182       SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
15183       FIELD_TYPE (*fp) = die_type (die, cu);
15184       FIELD_NAME (*fp) = fieldname;
15185     }
15186   else if (die->tag == DW_TAG_inheritance)
15187     {
15188       LONGEST offset;
15189
15190       /* C++ base class field.  */
15191       if (handle_data_member_location (die, cu, &offset))
15192         SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
15193       FIELD_BITSIZE (*fp) = 0;
15194       FIELD_TYPE (*fp) = die_type (die, cu);
15195       FIELD_NAME (*fp) = TYPE_NAME (fp->type);
15196     }
15197   else if (die->tag == DW_TAG_variant_part)
15198     {
15199       /* process_structure_scope will treat this DIE as a union.  */
15200       process_structure_scope (die, cu);
15201
15202       /* The variant part is relative to the start of the enclosing
15203          structure.  */
15204       SET_FIELD_BITPOS (*fp, 0);
15205       fp->type = get_die_type (die, cu);
15206       fp->artificial = 1;
15207       fp->name = "<<variant>>";
15208
15209       /* Normally a DW_TAG_variant_part won't have a size, but our
15210          representation requires one, so set it to the maximum of the
15211          child sizes.  */
15212       if (TYPE_LENGTH (fp->type) == 0)
15213         {
15214           unsigned max = 0;
15215           for (int i = 0; i < TYPE_NFIELDS (fp->type); ++i)
15216             if (TYPE_LENGTH (TYPE_FIELD_TYPE (fp->type, i)) > max)
15217               max = TYPE_LENGTH (TYPE_FIELD_TYPE (fp->type, i));
15218           TYPE_LENGTH (fp->type) = max;
15219         }
15220     }
15221   else
15222     gdb_assert_not_reached ("missing case in dwarf2_add_field");
15223 }
15224
15225 /* Can the type given by DIE define another type?  */
15226
15227 static bool
15228 type_can_define_types (const struct die_info *die)
15229 {
15230   switch (die->tag)
15231     {
15232     case DW_TAG_typedef:
15233     case DW_TAG_class_type:
15234     case DW_TAG_structure_type:
15235     case DW_TAG_union_type:
15236     case DW_TAG_enumeration_type:
15237       return true;
15238
15239     default:
15240       return false;
15241     }
15242 }
15243
15244 /* Add a type definition defined in the scope of the FIP's class.  */
15245
15246 static void
15247 dwarf2_add_type_defn (struct field_info *fip, struct die_info *die,
15248                       struct dwarf2_cu *cu)
15249 {
15250   struct decl_field fp;
15251   memset (&fp, 0, sizeof (fp));
15252
15253   gdb_assert (type_can_define_types (die));
15254
15255   /* Get name of field.  NULL is okay here, meaning an anonymous type.  */
15256   fp.name = dwarf2_name (die, cu);
15257   fp.type = read_type_die (die, cu);
15258
15259   /* Save accessibility.  */
15260   enum dwarf_access_attribute accessibility;
15261   struct attribute *attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15262   if (attr != NULL)
15263     accessibility = (enum dwarf_access_attribute) DW_UNSND (attr);
15264   else
15265     accessibility = dwarf2_default_access_attribute (die, cu);
15266   switch (accessibility)
15267     {
15268     case DW_ACCESS_public:
15269       /* The assumed value if neither private nor protected.  */
15270       break;
15271     case DW_ACCESS_private:
15272       fp.is_private = 1;
15273       break;
15274     case DW_ACCESS_protected:
15275       fp.is_protected = 1;
15276       break;
15277     default:
15278       complaint (_("Unhandled DW_AT_accessibility value (%x)"), accessibility);
15279     }
15280
15281   if (die->tag == DW_TAG_typedef)
15282     fip->typedef_field_list.push_back (fp);
15283   else
15284     fip->nested_types_list.push_back (fp);
15285 }
15286
15287 /* Create the vector of fields, and attach it to the type.  */
15288
15289 static void
15290 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
15291                               struct dwarf2_cu *cu)
15292 {
15293   int nfields = fip->nfields;
15294
15295   /* Record the field count, allocate space for the array of fields,
15296      and create blank accessibility bitfields if necessary.  */
15297   TYPE_NFIELDS (type) = nfields;
15298   TYPE_FIELDS (type) = (struct field *)
15299     TYPE_ZALLOC (type, sizeof (struct field) * nfields);
15300
15301   if (fip->non_public_fields && cu->language != language_ada)
15302     {
15303       ALLOCATE_CPLUS_STRUCT_TYPE (type);
15304
15305       TYPE_FIELD_PRIVATE_BITS (type) =
15306         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15307       B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
15308
15309       TYPE_FIELD_PROTECTED_BITS (type) =
15310         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15311       B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
15312
15313       TYPE_FIELD_IGNORE_BITS (type) =
15314         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15315       B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
15316     }
15317
15318   /* If the type has baseclasses, allocate and clear a bit vector for
15319      TYPE_FIELD_VIRTUAL_BITS.  */
15320   if (!fip->baseclasses.empty () && cu->language != language_ada)
15321     {
15322       int num_bytes = B_BYTES (fip->baseclasses.size ());
15323       unsigned char *pointer;
15324
15325       ALLOCATE_CPLUS_STRUCT_TYPE (type);
15326       pointer = (unsigned char *) TYPE_ALLOC (type, num_bytes);
15327       TYPE_FIELD_VIRTUAL_BITS (type) = pointer;
15328       B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->baseclasses.size ());
15329       TYPE_N_BASECLASSES (type) = fip->baseclasses.size ();
15330     }
15331
15332   if (TYPE_FLAG_DISCRIMINATED_UNION (type))
15333     {
15334       struct discriminant_info *di = alloc_discriminant_info (type, -1, -1);
15335
15336       for (int index = 0; index < nfields; ++index)
15337         {
15338           struct nextfield &field = fip->fields[index];
15339
15340           if (field.variant.is_discriminant)
15341             di->discriminant_index = index;
15342           else if (field.variant.default_branch)
15343             di->default_index = index;
15344           else
15345             di->discriminants[index] = field.variant.discriminant_value;
15346         }
15347     }
15348
15349   /* Copy the saved-up fields into the field vector.  */
15350   for (int i = 0; i < nfields; ++i)
15351     {
15352       struct nextfield &field
15353         = ((i < fip->baseclasses.size ()) ? fip->baseclasses[i]
15354            : fip->fields[i - fip->baseclasses.size ()]);
15355
15356       TYPE_FIELD (type, i) = field.field;
15357       switch (field.accessibility)
15358         {
15359         case DW_ACCESS_private:
15360           if (cu->language != language_ada)
15361             SET_TYPE_FIELD_PRIVATE (type, i);
15362           break;
15363
15364         case DW_ACCESS_protected:
15365           if (cu->language != language_ada)
15366             SET_TYPE_FIELD_PROTECTED (type, i);
15367           break;
15368
15369         case DW_ACCESS_public:
15370           break;
15371
15372         default:
15373           /* Unknown accessibility.  Complain and treat it as public.  */
15374           {
15375             complaint (_("unsupported accessibility %d"),
15376                        field.accessibility);
15377           }
15378           break;
15379         }
15380       if (i < fip->baseclasses.size ())
15381         {
15382           switch (field.virtuality)
15383             {
15384             case DW_VIRTUALITY_virtual:
15385             case DW_VIRTUALITY_pure_virtual:
15386               if (cu->language == language_ada)
15387                 error (_("unexpected virtuality in component of Ada type"));
15388               SET_TYPE_FIELD_VIRTUAL (type, i);
15389               break;
15390             }
15391         }
15392     }
15393 }
15394
15395 /* Return true if this member function is a constructor, false
15396    otherwise.  */
15397
15398 static int
15399 dwarf2_is_constructor (struct die_info *die, struct dwarf2_cu *cu)
15400 {
15401   const char *fieldname;
15402   const char *type_name;
15403   int len;
15404
15405   if (die->parent == NULL)
15406     return 0;
15407
15408   if (die->parent->tag != DW_TAG_structure_type
15409       && die->parent->tag != DW_TAG_union_type
15410       && die->parent->tag != DW_TAG_class_type)
15411     return 0;
15412
15413   fieldname = dwarf2_name (die, cu);
15414   type_name = dwarf2_name (die->parent, cu);
15415   if (fieldname == NULL || type_name == NULL)
15416     return 0;
15417
15418   len = strlen (fieldname);
15419   return (strncmp (fieldname, type_name, len) == 0
15420           && (type_name[len] == '\0' || type_name[len] == '<'));
15421 }
15422
15423 /* Add a member function to the proper fieldlist.  */
15424
15425 static void
15426 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
15427                       struct type *type, struct dwarf2_cu *cu)
15428 {
15429   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15430   struct attribute *attr;
15431   int i;
15432   struct fnfieldlist *flp = nullptr;
15433   struct fn_field *fnp;
15434   const char *fieldname;
15435   struct type *this_type;
15436   enum dwarf_access_attribute accessibility;
15437
15438   if (cu->language == language_ada)
15439     error (_("unexpected member function in Ada type"));
15440
15441   /* Get name of member function.  */
15442   fieldname = dwarf2_name (die, cu);
15443   if (fieldname == NULL)
15444     return;
15445
15446   /* Look up member function name in fieldlist.  */
15447   for (i = 0; i < fip->fnfieldlists.size (); i++)
15448     {
15449       if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
15450         {
15451           flp = &fip->fnfieldlists[i];
15452           break;
15453         }
15454     }
15455
15456   /* Create a new fnfieldlist if necessary.  */
15457   if (flp == nullptr)
15458     {
15459       fip->fnfieldlists.emplace_back ();
15460       flp = &fip->fnfieldlists.back ();
15461       flp->name = fieldname;
15462       i = fip->fnfieldlists.size () - 1;
15463     }
15464
15465   /* Create a new member function field and add it to the vector of
15466      fnfieldlists.  */
15467   flp->fnfields.emplace_back ();
15468   fnp = &flp->fnfields.back ();
15469
15470   /* Delay processing of the physname until later.  */
15471   if (cu->language == language_cplus)
15472     add_to_method_list (type, i, flp->fnfields.size () - 1, fieldname,
15473                         die, cu);
15474   else
15475     {
15476       const char *physname = dwarf2_physname (fieldname, die, cu);
15477       fnp->physname = physname ? physname : "";
15478     }
15479
15480   fnp->type = alloc_type (objfile);
15481   this_type = read_type_die (die, cu);
15482   if (this_type && TYPE_CODE (this_type) == TYPE_CODE_FUNC)
15483     {
15484       int nparams = TYPE_NFIELDS (this_type);
15485
15486       /* TYPE is the domain of this method, and THIS_TYPE is the type
15487            of the method itself (TYPE_CODE_METHOD).  */
15488       smash_to_method_type (fnp->type, type,
15489                             TYPE_TARGET_TYPE (this_type),
15490                             TYPE_FIELDS (this_type),
15491                             TYPE_NFIELDS (this_type),
15492                             TYPE_VARARGS (this_type));
15493
15494       /* Handle static member functions.
15495          Dwarf2 has no clean way to discern C++ static and non-static
15496          member functions.  G++ helps GDB by marking the first
15497          parameter for non-static member functions (which is the this
15498          pointer) as artificial.  We obtain this information from
15499          read_subroutine_type via TYPE_FIELD_ARTIFICIAL.  */
15500       if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (this_type, 0) == 0)
15501         fnp->voffset = VOFFSET_STATIC;
15502     }
15503   else
15504     complaint (_("member function type missing for '%s'"),
15505                dwarf2_full_name (fieldname, die, cu));
15506
15507   /* Get fcontext from DW_AT_containing_type if present.  */
15508   if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
15509     fnp->fcontext = die_containing_type (die, cu);
15510
15511   /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
15512      is_volatile is irrelevant, as it is needed by gdb_mangle_name only.  */
15513
15514   /* Get accessibility.  */
15515   attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15516   if (attr)
15517     accessibility = (enum dwarf_access_attribute) DW_UNSND (attr);
15518   else
15519     accessibility = dwarf2_default_access_attribute (die, cu);
15520   switch (accessibility)
15521     {
15522     case DW_ACCESS_private:
15523       fnp->is_private = 1;
15524       break;
15525     case DW_ACCESS_protected:
15526       fnp->is_protected = 1;
15527       break;
15528     }
15529
15530   /* Check for artificial methods.  */
15531   attr = dwarf2_attr (die, DW_AT_artificial, cu);
15532   if (attr && DW_UNSND (attr) != 0)
15533     fnp->is_artificial = 1;
15534
15535   fnp->is_constructor = dwarf2_is_constructor (die, cu);
15536
15537   /* Get index in virtual function table if it is a virtual member
15538      function.  For older versions of GCC, this is an offset in the
15539      appropriate virtual table, as specified by DW_AT_containing_type.
15540      For everyone else, it is an expression to be evaluated relative
15541      to the object address.  */
15542
15543   attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
15544   if (attr)
15545     {
15546       if (attr_form_is_block (attr) && DW_BLOCK (attr)->size > 0)
15547         {
15548           if (DW_BLOCK (attr)->data[0] == DW_OP_constu)
15549             {
15550               /* Old-style GCC.  */
15551               fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
15552             }
15553           else if (DW_BLOCK (attr)->data[0] == DW_OP_deref
15554                    || (DW_BLOCK (attr)->size > 1
15555                        && DW_BLOCK (attr)->data[0] == DW_OP_deref_size
15556                        && DW_BLOCK (attr)->data[1] == cu->header.addr_size))
15557             {
15558               fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu);
15559               if ((fnp->voffset % cu->header.addr_size) != 0)
15560                 dwarf2_complex_location_expr_complaint ();
15561               else
15562                 fnp->voffset /= cu->header.addr_size;
15563               fnp->voffset += 2;
15564             }
15565           else
15566             dwarf2_complex_location_expr_complaint ();
15567
15568           if (!fnp->fcontext)
15569             {
15570               /* If there is no `this' field and no DW_AT_containing_type,
15571                  we cannot actually find a base class context for the
15572                  vtable!  */
15573               if (TYPE_NFIELDS (this_type) == 0
15574                   || !TYPE_FIELD_ARTIFICIAL (this_type, 0))
15575                 {
15576                   complaint (_("cannot determine context for virtual member "
15577                                "function \"%s\" (offset %s)"),
15578                              fieldname, sect_offset_str (die->sect_off));
15579                 }
15580               else
15581                 {
15582                   fnp->fcontext
15583                     = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type, 0));
15584                 }
15585             }
15586         }
15587       else if (attr_form_is_section_offset (attr))
15588         {
15589           dwarf2_complex_location_expr_complaint ();
15590         }
15591       else
15592         {
15593           dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
15594                                                  fieldname);
15595         }
15596     }
15597   else
15598     {
15599       attr = dwarf2_attr (die, DW_AT_virtuality, cu);
15600       if (attr && DW_UNSND (attr))
15601         {
15602           /* GCC does this, as of 2008-08-25; PR debug/37237.  */
15603           complaint (_("Member function \"%s\" (offset %s) is virtual "
15604                        "but the vtable offset is not specified"),
15605                      fieldname, sect_offset_str (die->sect_off));
15606           ALLOCATE_CPLUS_STRUCT_TYPE (type);
15607           TYPE_CPLUS_DYNAMIC (type) = 1;
15608         }
15609     }
15610 }
15611
15612 /* Create the vector of member function fields, and attach it to the type.  */
15613
15614 static void
15615 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
15616                                  struct dwarf2_cu *cu)
15617 {
15618   if (cu->language == language_ada)
15619     error (_("unexpected member functions in Ada type"));
15620
15621   ALLOCATE_CPLUS_STRUCT_TYPE (type);
15622   TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
15623     TYPE_ALLOC (type,
15624                 sizeof (struct fn_fieldlist) * fip->fnfieldlists.size ());
15625
15626   for (int i = 0; i < fip->fnfieldlists.size (); i++)
15627     {
15628       struct fnfieldlist &nf = fip->fnfieldlists[i];
15629       struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
15630
15631       TYPE_FN_FIELDLIST_NAME (type, i) = nf.name;
15632       TYPE_FN_FIELDLIST_LENGTH (type, i) = nf.fnfields.size ();
15633       fn_flp->fn_fields = (struct fn_field *)
15634         TYPE_ALLOC (type, sizeof (struct fn_field) * nf.fnfields.size ());
15635
15636       for (int k = 0; k < nf.fnfields.size (); ++k)
15637         fn_flp->fn_fields[k] = nf.fnfields[k];
15638     }
15639
15640   TYPE_NFN_FIELDS (type) = fip->fnfieldlists.size ();
15641 }
15642
15643 /* Returns non-zero if NAME is the name of a vtable member in CU's
15644    language, zero otherwise.  */
15645 static int
15646 is_vtable_name (const char *name, struct dwarf2_cu *cu)
15647 {
15648   static const char vptr[] = "_vptr";
15649
15650   /* Look for the C++ form of the vtable.  */
15651   if (startswith (name, vptr) && is_cplus_marker (name[sizeof (vptr) - 1]))
15652     return 1;
15653
15654   return 0;
15655 }
15656
15657 /* GCC outputs unnamed structures that are really pointers to member
15658    functions, with the ABI-specified layout.  If TYPE describes
15659    such a structure, smash it into a member function type.
15660
15661    GCC shouldn't do this; it should just output pointer to member DIEs.
15662    This is GCC PR debug/28767.  */
15663
15664 static void
15665 quirk_gcc_member_function_pointer (struct type *type, struct objfile *objfile)
15666 {
15667   struct type *pfn_type, *self_type, *new_type;
15668
15669   /* Check for a structure with no name and two children.  */
15670   if (TYPE_CODE (type) != TYPE_CODE_STRUCT || TYPE_NFIELDS (type) != 2)
15671     return;
15672
15673   /* Check for __pfn and __delta members.  */
15674   if (TYPE_FIELD_NAME (type, 0) == NULL
15675       || strcmp (TYPE_FIELD_NAME (type, 0), "__pfn") != 0
15676       || TYPE_FIELD_NAME (type, 1) == NULL
15677       || strcmp (TYPE_FIELD_NAME (type, 1), "__delta") != 0)
15678     return;
15679
15680   /* Find the type of the method.  */
15681   pfn_type = TYPE_FIELD_TYPE (type, 0);
15682   if (pfn_type == NULL
15683       || TYPE_CODE (pfn_type) != TYPE_CODE_PTR
15684       || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type)) != TYPE_CODE_FUNC)
15685     return;
15686
15687   /* Look for the "this" argument.  */
15688   pfn_type = TYPE_TARGET_TYPE (pfn_type);
15689   if (TYPE_NFIELDS (pfn_type) == 0
15690       /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
15691       || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type, 0)) != TYPE_CODE_PTR)
15692     return;
15693
15694   self_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0));
15695   new_type = alloc_type (objfile);
15696   smash_to_method_type (new_type, self_type, TYPE_TARGET_TYPE (pfn_type),
15697                         TYPE_FIELDS (pfn_type), TYPE_NFIELDS (pfn_type),
15698                         TYPE_VARARGS (pfn_type));
15699   smash_to_methodptr_type (type, new_type);
15700 }
15701
15702 /* If the DIE has a DW_AT_alignment attribute, return its value, doing
15703    appropriate error checking and issuing complaints if there is a
15704    problem.  */
15705
15706 static ULONGEST
15707 get_alignment (struct dwarf2_cu *cu, struct die_info *die)
15708 {
15709   struct attribute *attr = dwarf2_attr (die, DW_AT_alignment, cu);
15710
15711   if (attr == nullptr)
15712     return 0;
15713
15714   if (!attr_form_is_constant (attr))
15715     {
15716       complaint (_("DW_AT_alignment must have constant form"
15717                    " - DIE at %s [in module %s]"),
15718                  sect_offset_str (die->sect_off),
15719                  objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15720       return 0;
15721     }
15722
15723   ULONGEST align;
15724   if (attr->form == DW_FORM_sdata)
15725     {
15726       LONGEST val = DW_SND (attr);
15727       if (val < 0)
15728         {
15729           complaint (_("DW_AT_alignment value must not be negative"
15730                        " - DIE at %s [in module %s]"),
15731                      sect_offset_str (die->sect_off),
15732                      objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15733           return 0;
15734         }
15735       align = val;
15736     }
15737   else
15738     align = DW_UNSND (attr);
15739
15740   if (align == 0)
15741     {
15742       complaint (_("DW_AT_alignment value must not be zero"
15743                    " - DIE at %s [in module %s]"),
15744                  sect_offset_str (die->sect_off),
15745                  objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15746       return 0;
15747     }
15748   if ((align & (align - 1)) != 0)
15749     {
15750       complaint (_("DW_AT_alignment value must be a power of 2"
15751                    " - DIE at %s [in module %s]"),
15752                  sect_offset_str (die->sect_off),
15753                  objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15754       return 0;
15755     }
15756
15757   return align;
15758 }
15759
15760 /* If the DIE has a DW_AT_alignment attribute, use its value to set
15761    the alignment for TYPE.  */
15762
15763 static void
15764 maybe_set_alignment (struct dwarf2_cu *cu, struct die_info *die,
15765                      struct type *type)
15766 {
15767   if (!set_type_align (type, get_alignment (cu, die)))
15768     complaint (_("DW_AT_alignment value too large"
15769                  " - DIE at %s [in module %s]"),
15770                sect_offset_str (die->sect_off),
15771                objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15772 }
15773
15774 /* Called when we find the DIE that starts a structure or union scope
15775    (definition) to create a type for the structure or union.  Fill in
15776    the type's name and general properties; the members will not be
15777    processed until process_structure_scope.  A symbol table entry for
15778    the type will also not be done until process_structure_scope (assuming
15779    the type has a name).
15780
15781    NOTE: we need to call these functions regardless of whether or not the
15782    DIE has a DW_AT_name attribute, since it might be an anonymous
15783    structure or union.  This gets the type entered into our set of
15784    user defined types.  */
15785
15786 static struct type *
15787 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
15788 {
15789   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15790   struct type *type;
15791   struct attribute *attr;
15792   const char *name;
15793
15794   /* If the definition of this type lives in .debug_types, read that type.
15795      Don't follow DW_AT_specification though, that will take us back up
15796      the chain and we want to go down.  */
15797   attr = dwarf2_attr_no_follow (die, DW_AT_signature);
15798   if (attr)
15799     {
15800       type = get_DW_AT_signature_type (die, attr, cu);
15801
15802       /* The type's CU may not be the same as CU.
15803          Ensure TYPE is recorded with CU in die_type_hash.  */
15804       return set_die_type (die, type, cu);
15805     }
15806
15807   type = alloc_type (objfile);
15808   INIT_CPLUS_SPECIFIC (type);
15809
15810   name = dwarf2_name (die, cu);
15811   if (name != NULL)
15812     {
15813       if (cu->language == language_cplus
15814           || cu->language == language_d
15815           || cu->language == language_rust)
15816         {
15817           const char *full_name = dwarf2_full_name (name, die, cu);
15818
15819           /* dwarf2_full_name might have already finished building the DIE's
15820              type.  If so, there is no need to continue.  */
15821           if (get_die_type (die, cu) != NULL)
15822             return get_die_type (die, cu);
15823
15824           TYPE_NAME (type) = full_name;
15825         }
15826       else
15827         {
15828           /* The name is already allocated along with this objfile, so
15829              we don't need to duplicate it for the type.  */
15830           TYPE_NAME (type) = name;
15831         }
15832     }
15833
15834   if (die->tag == DW_TAG_structure_type)
15835     {
15836       TYPE_CODE (type) = TYPE_CODE_STRUCT;
15837     }
15838   else if (die->tag == DW_TAG_union_type)
15839     {
15840       TYPE_CODE (type) = TYPE_CODE_UNION;
15841     }
15842   else if (die->tag == DW_TAG_variant_part)
15843     {
15844       TYPE_CODE (type) = TYPE_CODE_UNION;
15845       TYPE_FLAG_DISCRIMINATED_UNION (type) = 1;
15846     }
15847   else
15848     {
15849       TYPE_CODE (type) = TYPE_CODE_STRUCT;
15850     }
15851
15852   if (cu->language == language_cplus && die->tag == DW_TAG_class_type)
15853     TYPE_DECLARED_CLASS (type) = 1;
15854
15855   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
15856   if (attr)
15857     {
15858       if (attr_form_is_constant (attr))
15859         TYPE_LENGTH (type) = DW_UNSND (attr);
15860       else
15861         {
15862           /* For the moment, dynamic type sizes are not supported
15863              by GDB's struct type.  The actual size is determined
15864              on-demand when resolving the type of a given object,
15865              so set the type's length to zero for now.  Otherwise,
15866              we record an expression as the length, and that expression
15867              could lead to a very large value, which could eventually
15868              lead to us trying to allocate that much memory when creating
15869              a value of that type.  */
15870           TYPE_LENGTH (type) = 0;
15871         }
15872     }
15873   else
15874     {
15875       TYPE_LENGTH (type) = 0;
15876     }
15877
15878   maybe_set_alignment (cu, die, type);
15879
15880   if (producer_is_icc_lt_14 (cu) && (TYPE_LENGTH (type) == 0))
15881     {
15882       /* ICC<14 does not output the required DW_AT_declaration on
15883          incomplete types, but gives them a size of zero.  */
15884       TYPE_STUB (type) = 1;
15885     }
15886   else
15887     TYPE_STUB_SUPPORTED (type) = 1;
15888
15889   if (die_is_declaration (die, cu))
15890     TYPE_STUB (type) = 1;
15891   else if (attr == NULL && die->child == NULL
15892            && producer_is_realview (cu->producer))
15893     /* RealView does not output the required DW_AT_declaration
15894        on incomplete types.  */
15895     TYPE_STUB (type) = 1;
15896
15897   /* We need to add the type field to the die immediately so we don't
15898      infinitely recurse when dealing with pointers to the structure
15899      type within the structure itself.  */
15900   set_die_type (die, type, cu);
15901
15902   /* set_die_type should be already done.  */
15903   set_descriptive_type (type, die, cu);
15904
15905   return type;
15906 }
15907
15908 /* A helper for process_structure_scope that handles a single member
15909    DIE.  */
15910
15911 static void
15912 handle_struct_member_die (struct die_info *child_die, struct type *type,
15913                           struct field_info *fi,
15914                           std::vector<struct symbol *> *template_args,
15915                           struct dwarf2_cu *cu)
15916 {
15917   if (child_die->tag == DW_TAG_member
15918       || child_die->tag == DW_TAG_variable
15919       || child_die->tag == DW_TAG_variant_part)
15920     {
15921       /* NOTE: carlton/2002-11-05: A C++ static data member
15922          should be a DW_TAG_member that is a declaration, but
15923          all versions of G++ as of this writing (so through at
15924          least 3.2.1) incorrectly generate DW_TAG_variable
15925          tags for them instead.  */
15926       dwarf2_add_field (fi, child_die, cu);
15927     }
15928   else if (child_die->tag == DW_TAG_subprogram)
15929     {
15930       /* Rust doesn't have member functions in the C++ sense.
15931          However, it does emit ordinary functions as children
15932          of a struct DIE.  */
15933       if (cu->language == language_rust)
15934         read_func_scope (child_die, cu);
15935       else
15936         {
15937           /* C++ member function.  */
15938           dwarf2_add_member_fn (fi, child_die, type, cu);
15939         }
15940     }
15941   else if (child_die->tag == DW_TAG_inheritance)
15942     {
15943       /* C++ base class field.  */
15944       dwarf2_add_field (fi, child_die, cu);
15945     }
15946   else if (type_can_define_types (child_die))
15947     dwarf2_add_type_defn (fi, child_die, cu);
15948   else if (child_die->tag == DW_TAG_template_type_param
15949            || child_die->tag == DW_TAG_template_value_param)
15950     {
15951       struct symbol *arg = new_symbol (child_die, NULL, cu);
15952
15953       if (arg != NULL)
15954         template_args->push_back (arg);
15955     }
15956   else if (child_die->tag == DW_TAG_variant)
15957     {
15958       /* In a variant we want to get the discriminant and also add a
15959          field for our sole member child.  */
15960       struct attribute *discr = dwarf2_attr (child_die, DW_AT_discr_value, cu);
15961
15962       for (struct die_info *variant_child = child_die->child;
15963            variant_child != NULL;
15964            variant_child = sibling_die (variant_child))
15965         {
15966           if (variant_child->tag == DW_TAG_member)
15967             {
15968               handle_struct_member_die (variant_child, type, fi,
15969                                         template_args, cu);
15970               /* Only handle the one.  */
15971               break;
15972             }
15973         }
15974
15975       /* We don't handle this but we might as well report it if we see
15976          it.  */
15977       if (dwarf2_attr (child_die, DW_AT_discr_list, cu) != nullptr)
15978           complaint (_("DW_AT_discr_list is not supported yet"
15979                        " - DIE at %s [in module %s]"),
15980                      sect_offset_str (child_die->sect_off),
15981                      objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15982
15983       /* The first field was just added, so we can stash the
15984          discriminant there.  */
15985       gdb_assert (!fi->fields.empty ());
15986       if (discr == NULL)
15987         fi->fields.back ().variant.default_branch = true;
15988       else
15989         fi->fields.back ().variant.discriminant_value = DW_UNSND (discr);
15990     }
15991 }
15992
15993 /* Finish creating a structure or union type, including filling in
15994    its members and creating a symbol for it.  */
15995
15996 static void
15997 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
15998 {
15999   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16000   struct die_info *child_die;
16001   struct type *type;
16002
16003   type = get_die_type (die, cu);
16004   if (type == NULL)
16005     type = read_structure_type (die, cu);
16006
16007   /* When reading a DW_TAG_variant_part, we need to notice when we
16008      read the discriminant member, so we can record it later in the
16009      discriminant_info.  */
16010   bool is_variant_part = TYPE_FLAG_DISCRIMINATED_UNION (type);
16011   sect_offset discr_offset;
16012   bool has_template_parameters = false;
16013
16014   if (is_variant_part)
16015     {
16016       struct attribute *discr = dwarf2_attr (die, DW_AT_discr, cu);
16017       if (discr == NULL)
16018         {
16019           /* Maybe it's a univariant form, an extension we support.
16020              In this case arrange not to check the offset.  */
16021           is_variant_part = false;
16022         }
16023       else if (attr_form_is_ref (discr))
16024         {
16025           struct dwarf2_cu *target_cu = cu;
16026           struct die_info *target_die = follow_die_ref (die, discr, &target_cu);
16027
16028           discr_offset = target_die->sect_off;
16029         }
16030       else
16031         {
16032           complaint (_("DW_AT_discr does not have DIE reference form"
16033                        " - DIE at %s [in module %s]"),
16034                      sect_offset_str (die->sect_off),
16035                      objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
16036           is_variant_part = false;
16037         }
16038     }
16039
16040   if (die->child != NULL && ! die_is_declaration (die, cu))
16041     {
16042       struct field_info fi;
16043       std::vector<struct symbol *> template_args;
16044
16045       child_die = die->child;
16046
16047       while (child_die && child_die->tag)
16048         {
16049           handle_struct_member_die (child_die, type, &fi, &template_args, cu);
16050
16051           if (is_variant_part && discr_offset == child_die->sect_off)
16052             fi.fields.back ().variant.is_discriminant = true;
16053
16054           child_die = sibling_die (child_die);
16055         }
16056
16057       /* Attach template arguments to type.  */
16058       if (!template_args.empty ())
16059         {
16060           has_template_parameters = true;
16061           ALLOCATE_CPLUS_STRUCT_TYPE (type);
16062           TYPE_N_TEMPLATE_ARGUMENTS (type) = template_args.size ();
16063           TYPE_TEMPLATE_ARGUMENTS (type)
16064             = XOBNEWVEC (&objfile->objfile_obstack,
16065                          struct symbol *,
16066                          TYPE_N_TEMPLATE_ARGUMENTS (type));
16067           memcpy (TYPE_TEMPLATE_ARGUMENTS (type),
16068                   template_args.data (),
16069                   (TYPE_N_TEMPLATE_ARGUMENTS (type)
16070                    * sizeof (struct symbol *)));
16071         }
16072
16073       /* Attach fields and member functions to the type.  */
16074       if (fi.nfields)
16075         dwarf2_attach_fields_to_type (&fi, type, cu);
16076       if (!fi.fnfieldlists.empty ())
16077         {
16078           dwarf2_attach_fn_fields_to_type (&fi, type, cu);
16079
16080           /* Get the type which refers to the base class (possibly this
16081              class itself) which contains the vtable pointer for the current
16082              class from the DW_AT_containing_type attribute.  This use of
16083              DW_AT_containing_type is a GNU extension.  */
16084
16085           if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
16086             {
16087               struct type *t = die_containing_type (die, cu);
16088
16089               set_type_vptr_basetype (type, t);
16090               if (type == t)
16091                 {
16092                   int i;
16093
16094                   /* Our own class provides vtbl ptr.  */
16095                   for (i = TYPE_NFIELDS (t) - 1;
16096                        i >= TYPE_N_BASECLASSES (t);
16097                        --i)
16098                     {
16099                       const char *fieldname = TYPE_FIELD_NAME (t, i);
16100
16101                       if (is_vtable_name (fieldname, cu))
16102                         {
16103                           set_type_vptr_fieldno (type, i);
16104                           break;
16105                         }
16106                     }
16107
16108                   /* Complain if virtual function table field not found.  */
16109                   if (i < TYPE_N_BASECLASSES (t))
16110                     complaint (_("virtual function table pointer "
16111                                  "not found when defining class '%s'"),
16112                                TYPE_NAME (type) ? TYPE_NAME (type) : "");
16113                 }
16114               else
16115                 {
16116                   set_type_vptr_fieldno (type, TYPE_VPTR_FIELDNO (t));
16117                 }
16118             }
16119           else if (cu->producer
16120                    && startswith (cu->producer, "IBM(R) XL C/C++ Advanced Edition"))
16121             {
16122               /* The IBM XLC compiler does not provide direct indication
16123                  of the containing type, but the vtable pointer is
16124                  always named __vfp.  */
16125
16126               int i;
16127
16128               for (i = TYPE_NFIELDS (type) - 1;
16129                    i >= TYPE_N_BASECLASSES (type);
16130                    --i)
16131                 {
16132                   if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
16133                     {
16134                       set_type_vptr_fieldno (type, i);
16135                       set_type_vptr_basetype (type, type);
16136                       break;
16137                     }
16138                 }
16139             }
16140         }
16141
16142       /* Copy fi.typedef_field_list linked list elements content into the
16143          allocated array TYPE_TYPEDEF_FIELD_ARRAY (type).  */
16144       if (!fi.typedef_field_list.empty ())
16145         {
16146           int count = fi.typedef_field_list.size ();
16147
16148           ALLOCATE_CPLUS_STRUCT_TYPE (type);
16149           TYPE_TYPEDEF_FIELD_ARRAY (type)
16150             = ((struct decl_field *)
16151                TYPE_ALLOC (type,
16152                            sizeof (TYPE_TYPEDEF_FIELD (type, 0)) * count));
16153           TYPE_TYPEDEF_FIELD_COUNT (type) = count;
16154
16155           for (int i = 0; i < fi.typedef_field_list.size (); ++i)
16156             TYPE_TYPEDEF_FIELD (type, i) = fi.typedef_field_list[i];
16157         }
16158
16159       /* Copy fi.nested_types_list linked list elements content into the
16160          allocated array TYPE_NESTED_TYPES_ARRAY (type).  */
16161       if (!fi.nested_types_list.empty () && cu->language != language_ada)
16162         {
16163           int count = fi.nested_types_list.size ();
16164
16165           ALLOCATE_CPLUS_STRUCT_TYPE (type);
16166           TYPE_NESTED_TYPES_ARRAY (type)
16167             = ((struct decl_field *)
16168                TYPE_ALLOC (type, sizeof (struct decl_field) * count));
16169           TYPE_NESTED_TYPES_COUNT (type) = count;
16170
16171           for (int i = 0; i < fi.nested_types_list.size (); ++i)
16172             TYPE_NESTED_TYPES_FIELD (type, i) = fi.nested_types_list[i];
16173         }
16174     }
16175
16176   quirk_gcc_member_function_pointer (type, objfile);
16177   if (cu->language == language_rust && die->tag == DW_TAG_union_type)
16178     cu->rust_unions.push_back (type);
16179
16180   /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
16181      snapshots) has been known to create a die giving a declaration
16182      for a class that has, as a child, a die giving a definition for a
16183      nested class.  So we have to process our children even if the
16184      current die is a declaration.  Normally, of course, a declaration
16185      won't have any children at all.  */
16186
16187   child_die = die->child;
16188
16189   while (child_die != NULL && child_die->tag)
16190     {
16191       if (child_die->tag == DW_TAG_member
16192           || child_die->tag == DW_TAG_variable
16193           || child_die->tag == DW_TAG_inheritance
16194           || child_die->tag == DW_TAG_template_value_param
16195           || child_die->tag == DW_TAG_template_type_param)
16196         {
16197           /* Do nothing.  */
16198         }
16199       else
16200         process_die (child_die, cu);
16201
16202       child_die = sibling_die (child_die);
16203     }
16204
16205   /* Do not consider external references.  According to the DWARF standard,
16206      these DIEs are identified by the fact that they have no byte_size
16207      attribute, and a declaration attribute.  */
16208   if (dwarf2_attr (die, DW_AT_byte_size, cu) != NULL
16209       || !die_is_declaration (die, cu))
16210     {
16211       struct symbol *sym = new_symbol (die, type, cu);
16212
16213       if (has_template_parameters)
16214         {
16215           struct symtab *symtab;
16216           if (sym != nullptr)
16217             symtab = symbol_symtab (sym);
16218           else if (cu->line_header != nullptr)
16219             {
16220               /* Any related symtab will do.  */
16221               symtab
16222                 = cu->line_header->file_name_at (file_name_index (1))->symtab;
16223             }
16224           else
16225             {
16226               symtab = nullptr;
16227               complaint (_("could not find suitable "
16228                            "symtab for template parameter"
16229                            " - DIE at %s [in module %s]"),
16230                          sect_offset_str (die->sect_off),
16231                          objfile_name (objfile));
16232             }
16233
16234           if (symtab != nullptr)
16235             {
16236               /* Make sure that the symtab is set on the new symbols.
16237                  Even though they don't appear in this symtab directly,
16238                  other parts of gdb assume that symbols do, and this is
16239                  reasonably true.  */
16240               for (int i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (type); ++i)
16241                 symbol_set_symtab (TYPE_TEMPLATE_ARGUMENT (type, i), symtab);
16242             }
16243         }
16244     }
16245 }
16246
16247 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
16248    update TYPE using some information only available in DIE's children.  */
16249
16250 static void
16251 update_enumeration_type_from_children (struct die_info *die,
16252                                        struct type *type,
16253                                        struct dwarf2_cu *cu)
16254 {
16255   struct die_info *child_die;
16256   int unsigned_enum = 1;
16257   int flag_enum = 1;
16258   ULONGEST mask = 0;
16259
16260   auto_obstack obstack;
16261
16262   for (child_die = die->child;
16263        child_die != NULL && child_die->tag;
16264        child_die = sibling_die (child_die))
16265     {
16266       struct attribute *attr;
16267       LONGEST value;
16268       const gdb_byte *bytes;
16269       struct dwarf2_locexpr_baton *baton;
16270       const char *name;
16271
16272       if (child_die->tag != DW_TAG_enumerator)
16273         continue;
16274
16275       attr = dwarf2_attr (child_die, DW_AT_const_value, cu);
16276       if (attr == NULL)
16277         continue;
16278
16279       name = dwarf2_name (child_die, cu);
16280       if (name == NULL)
16281         name = "<anonymous enumerator>";
16282
16283       dwarf2_const_value_attr (attr, type, name, &obstack, cu,
16284                                &value, &bytes, &baton);
16285       if (value < 0)
16286         {
16287           unsigned_enum = 0;
16288           flag_enum = 0;
16289         }
16290       else if ((mask & value) != 0)
16291         flag_enum = 0;
16292       else
16293         mask |= value;
16294
16295       /* If we already know that the enum type is neither unsigned, nor
16296          a flag type, no need to look at the rest of the enumerates.  */
16297       if (!unsigned_enum && !flag_enum)
16298         break;
16299     }
16300
16301   if (unsigned_enum)
16302     TYPE_UNSIGNED (type) = 1;
16303   if (flag_enum)
16304     TYPE_FLAG_ENUM (type) = 1;
16305 }
16306
16307 /* Given a DW_AT_enumeration_type die, set its type.  We do not
16308    complete the type's fields yet, or create any symbols.  */
16309
16310 static struct type *
16311 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
16312 {
16313   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16314   struct type *type;
16315   struct attribute *attr;
16316   const char *name;
16317
16318   /* If the definition of this type lives in .debug_types, read that type.
16319      Don't follow DW_AT_specification though, that will take us back up
16320      the chain and we want to go down.  */
16321   attr = dwarf2_attr_no_follow (die, DW_AT_signature);
16322   if (attr)
16323     {
16324       type = get_DW_AT_signature_type (die, attr, cu);
16325
16326       /* The type's CU may not be the same as CU.
16327          Ensure TYPE is recorded with CU in die_type_hash.  */
16328       return set_die_type (die, type, cu);
16329     }
16330
16331   type = alloc_type (objfile);
16332
16333   TYPE_CODE (type) = TYPE_CODE_ENUM;
16334   name = dwarf2_full_name (NULL, die, cu);
16335   if (name != NULL)
16336     TYPE_NAME (type) = name;
16337
16338   attr = dwarf2_attr (die, DW_AT_type, cu);
16339   if (attr != NULL)
16340     {
16341       struct type *underlying_type = die_type (die, cu);
16342
16343       TYPE_TARGET_TYPE (type) = underlying_type;
16344     }
16345
16346   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16347   if (attr)
16348     {
16349       TYPE_LENGTH (type) = DW_UNSND (attr);
16350     }
16351   else
16352     {
16353       TYPE_LENGTH (type) = 0;
16354     }
16355
16356   maybe_set_alignment (cu, die, type);
16357
16358   /* The enumeration DIE can be incomplete.  In Ada, any type can be
16359      declared as private in the package spec, and then defined only
16360      inside the package body.  Such types are known as Taft Amendment
16361      Types.  When another package uses such a type, an incomplete DIE
16362      may be generated by the compiler.  */
16363   if (die_is_declaration (die, cu))
16364     TYPE_STUB (type) = 1;
16365
16366   /* Finish the creation of this type by using the enum's children.
16367      We must call this even when the underlying type has been provided
16368      so that we can determine if we're looking at a "flag" enum.  */
16369   update_enumeration_type_from_children (die, type, cu);
16370
16371   /* If this type has an underlying type that is not a stub, then we
16372      may use its attributes.  We always use the "unsigned" attribute
16373      in this situation, because ordinarily we guess whether the type
16374      is unsigned -- but the guess can be wrong and the underlying type
16375      can tell us the reality.  However, we defer to a local size
16376      attribute if one exists, because this lets the compiler override
16377      the underlying type if needed.  */
16378   if (TYPE_TARGET_TYPE (type) != NULL && !TYPE_STUB (TYPE_TARGET_TYPE (type)))
16379     {
16380       TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type));
16381       if (TYPE_LENGTH (type) == 0)
16382         TYPE_LENGTH (type) = TYPE_LENGTH (TYPE_TARGET_TYPE (type));
16383       if (TYPE_RAW_ALIGN (type) == 0
16384           && TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type)) != 0)
16385         set_type_align (type, TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type)));
16386     }
16387
16388   TYPE_DECLARED_CLASS (type) = dwarf2_flag_true_p (die, DW_AT_enum_class, cu);
16389
16390   return set_die_type (die, type, cu);
16391 }
16392
16393 /* Given a pointer to a die which begins an enumeration, process all
16394    the dies that define the members of the enumeration, and create the
16395    symbol for the enumeration type.
16396
16397    NOTE: We reverse the order of the element list.  */
16398
16399 static void
16400 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
16401 {
16402   struct type *this_type;
16403
16404   this_type = get_die_type (die, cu);
16405   if (this_type == NULL)
16406     this_type = read_enumeration_type (die, cu);
16407
16408   if (die->child != NULL)
16409     {
16410       struct die_info *child_die;
16411       struct symbol *sym;
16412       struct field *fields = NULL;
16413       int num_fields = 0;
16414       const char *name;
16415
16416       child_die = die->child;
16417       while (child_die && child_die->tag)
16418         {
16419           if (child_die->tag != DW_TAG_enumerator)
16420             {
16421               process_die (child_die, cu);
16422             }
16423           else
16424             {
16425               name = dwarf2_name (child_die, cu);
16426               if (name)
16427                 {
16428                   sym = new_symbol (child_die, this_type, cu);
16429
16430                   if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
16431                     {
16432                       fields = (struct field *)
16433                         xrealloc (fields,
16434                                   (num_fields + DW_FIELD_ALLOC_CHUNK)
16435                                   * sizeof (struct field));
16436                     }
16437
16438                   FIELD_NAME (fields[num_fields]) = SYMBOL_LINKAGE_NAME (sym);
16439                   FIELD_TYPE (fields[num_fields]) = NULL;
16440                   SET_FIELD_ENUMVAL (fields[num_fields], SYMBOL_VALUE (sym));
16441                   FIELD_BITSIZE (fields[num_fields]) = 0;
16442
16443                   num_fields++;
16444                 }
16445             }
16446
16447           child_die = sibling_die (child_die);
16448         }
16449
16450       if (num_fields)
16451         {
16452           TYPE_NFIELDS (this_type) = num_fields;
16453           TYPE_FIELDS (this_type) = (struct field *)
16454             TYPE_ALLOC (this_type, sizeof (struct field) * num_fields);
16455           memcpy (TYPE_FIELDS (this_type), fields,
16456                   sizeof (struct field) * num_fields);
16457           xfree (fields);
16458         }
16459     }
16460
16461   /* If we are reading an enum from a .debug_types unit, and the enum
16462      is a declaration, and the enum is not the signatured type in the
16463      unit, then we do not want to add a symbol for it.  Adding a
16464      symbol would in some cases obscure the true definition of the
16465      enum, giving users an incomplete type when the definition is
16466      actually available.  Note that we do not want to do this for all
16467      enums which are just declarations, because C++0x allows forward
16468      enum declarations.  */
16469   if (cu->per_cu->is_debug_types
16470       && die_is_declaration (die, cu))
16471     {
16472       struct signatured_type *sig_type;
16473
16474       sig_type = (struct signatured_type *) cu->per_cu;
16475       gdb_assert (to_underlying (sig_type->type_offset_in_section) != 0);
16476       if (sig_type->type_offset_in_section != die->sect_off)
16477         return;
16478     }
16479
16480   new_symbol (die, this_type, cu);
16481 }
16482
16483 /* Extract all information from a DW_TAG_array_type DIE and put it in
16484    the DIE's type field.  For now, this only handles one dimensional
16485    arrays.  */
16486
16487 static struct type *
16488 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
16489 {
16490   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16491   struct die_info *child_die;
16492   struct type *type;
16493   struct type *element_type, *range_type, *index_type;
16494   struct attribute *attr;
16495   const char *name;
16496   struct dynamic_prop *byte_stride_prop = NULL;
16497   unsigned int bit_stride = 0;
16498
16499   element_type = die_type (die, cu);
16500
16501   /* The die_type call above may have already set the type for this DIE.  */
16502   type = get_die_type (die, cu);
16503   if (type)
16504     return type;
16505
16506   attr = dwarf2_attr (die, DW_AT_byte_stride, cu);
16507   if (attr != NULL)
16508     {
16509       int stride_ok;
16510
16511       byte_stride_prop
16512         = (struct dynamic_prop *) alloca (sizeof (struct dynamic_prop));
16513       stride_ok = attr_to_dynamic_prop (attr, die, cu, byte_stride_prop);
16514       if (!stride_ok)
16515         {
16516           complaint (_("unable to read array DW_AT_byte_stride "
16517                        " - DIE at %s [in module %s]"),
16518                      sect_offset_str (die->sect_off),
16519                      objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
16520           /* Ignore this attribute.  We will likely not be able to print
16521              arrays of this type correctly, but there is little we can do
16522              to help if we cannot read the attribute's value.  */
16523           byte_stride_prop = NULL;
16524         }
16525     }
16526
16527   attr = dwarf2_attr (die, DW_AT_bit_stride, cu);
16528   if (attr != NULL)
16529     bit_stride = DW_UNSND (attr);
16530
16531   /* Irix 6.2 native cc creates array types without children for
16532      arrays with unspecified length.  */
16533   if (die->child == NULL)
16534     {
16535       index_type = objfile_type (objfile)->builtin_int;
16536       range_type = create_static_range_type (NULL, index_type, 0, -1);
16537       type = create_array_type_with_stride (NULL, element_type, range_type,
16538                                             byte_stride_prop, bit_stride);
16539       return set_die_type (die, type, cu);
16540     }
16541
16542   std::vector<struct type *> range_types;
16543   child_die = die->child;
16544   while (child_die && child_die->tag)
16545     {
16546       if (child_die->tag == DW_TAG_subrange_type)
16547         {
16548           struct type *child_type = read_type_die (child_die, cu);
16549
16550           if (child_type != NULL)
16551             {
16552               /* The range type was succesfully read.  Save it for the
16553                  array type creation.  */
16554               range_types.push_back (child_type);
16555             }
16556         }
16557       child_die = sibling_die (child_die);
16558     }
16559
16560   /* Dwarf2 dimensions are output from left to right, create the
16561      necessary array types in backwards order.  */
16562
16563   type = element_type;
16564
16565   if (read_array_order (die, cu) == DW_ORD_col_major)
16566     {
16567       int i = 0;
16568
16569       while (i < range_types.size ())
16570         type = create_array_type_with_stride (NULL, type, range_types[i++],
16571                                               byte_stride_prop, bit_stride);
16572     }
16573   else
16574     {
16575       size_t ndim = range_types.size ();
16576       while (ndim-- > 0)
16577         type = create_array_type_with_stride (NULL, type, range_types[ndim],
16578                                               byte_stride_prop, bit_stride);
16579     }
16580
16581   /* Understand Dwarf2 support for vector types (like they occur on
16582      the PowerPC w/ AltiVec).  Gcc just adds another attribute to the
16583      array type.  This is not part of the Dwarf2/3 standard yet, but a
16584      custom vendor extension.  The main difference between a regular
16585      array and the vector variant is that vectors are passed by value
16586      to functions.  */
16587   attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
16588   if (attr)
16589     make_vector_type (type);
16590
16591   /* The DIE may have DW_AT_byte_size set.  For example an OpenCL
16592      implementation may choose to implement triple vectors using this
16593      attribute.  */
16594   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16595   if (attr)
16596     {
16597       if (DW_UNSND (attr) >= TYPE_LENGTH (type))
16598         TYPE_LENGTH (type) = DW_UNSND (attr);
16599       else
16600         complaint (_("DW_AT_byte_size for array type smaller "
16601                      "than the total size of elements"));
16602     }
16603
16604   name = dwarf2_name (die, cu);
16605   if (name)
16606     TYPE_NAME (type) = name;
16607
16608   maybe_set_alignment (cu, die, type);
16609
16610   /* Install the type in the die.  */
16611   set_die_type (die, type, cu);
16612
16613   /* set_die_type should be already done.  */
16614   set_descriptive_type (type, die, cu);
16615
16616   return type;
16617 }
16618
16619 static enum dwarf_array_dim_ordering
16620 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
16621 {
16622   struct attribute *attr;
16623
16624   attr = dwarf2_attr (die, DW_AT_ordering, cu);
16625
16626   if (attr)
16627     return (enum dwarf_array_dim_ordering) DW_SND (attr);
16628
16629   /* GNU F77 is a special case, as at 08/2004 array type info is the
16630      opposite order to the dwarf2 specification, but data is still
16631      laid out as per normal fortran.
16632
16633      FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
16634      version checking.  */
16635
16636   if (cu->language == language_fortran
16637       && cu->producer && strstr (cu->producer, "GNU F77"))
16638     {
16639       return DW_ORD_row_major;
16640     }
16641
16642   switch (cu->language_defn->la_array_ordering)
16643     {
16644     case array_column_major:
16645       return DW_ORD_col_major;
16646     case array_row_major:
16647     default:
16648       return DW_ORD_row_major;
16649     };
16650 }
16651
16652 /* Extract all information from a DW_TAG_set_type DIE and put it in
16653    the DIE's type field.  */
16654
16655 static struct type *
16656 read_set_type (struct die_info *die, struct dwarf2_cu *cu)
16657 {
16658   struct type *domain_type, *set_type;
16659   struct attribute *attr;
16660
16661   domain_type = die_type (die, cu);
16662
16663   /* The die_type call above may have already set the type for this DIE.  */
16664   set_type = get_die_type (die, cu);
16665   if (set_type)
16666     return set_type;
16667
16668   set_type = create_set_type (NULL, domain_type);
16669
16670   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16671   if (attr)
16672     TYPE_LENGTH (set_type) = DW_UNSND (attr);
16673
16674   maybe_set_alignment (cu, die, set_type);
16675
16676   return set_die_type (die, set_type, cu);
16677 }
16678
16679 /* A helper for read_common_block that creates a locexpr baton.
16680    SYM is the symbol which we are marking as computed.
16681    COMMON_DIE is the DIE for the common block.
16682    COMMON_LOC is the location expression attribute for the common
16683    block itself.
16684    MEMBER_LOC is the location expression attribute for the particular
16685    member of the common block that we are processing.
16686    CU is the CU from which the above come.  */
16687
16688 static void
16689 mark_common_block_symbol_computed (struct symbol *sym,
16690                                    struct die_info *common_die,
16691                                    struct attribute *common_loc,
16692                                    struct attribute *member_loc,
16693                                    struct dwarf2_cu *cu)
16694 {
16695   struct dwarf2_per_objfile *dwarf2_per_objfile
16696     = cu->per_cu->dwarf2_per_objfile;
16697   struct objfile *objfile = dwarf2_per_objfile->objfile;
16698   struct dwarf2_locexpr_baton *baton;
16699   gdb_byte *ptr;
16700   unsigned int cu_off;
16701   enum bfd_endian byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
16702   LONGEST offset = 0;
16703
16704   gdb_assert (common_loc && member_loc);
16705   gdb_assert (attr_form_is_block (common_loc));
16706   gdb_assert (attr_form_is_block (member_loc)
16707               || attr_form_is_constant (member_loc));
16708
16709   baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
16710   baton->per_cu = cu->per_cu;
16711   gdb_assert (baton->per_cu);
16712
16713   baton->size = 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
16714
16715   if (attr_form_is_constant (member_loc))
16716     {
16717       offset = dwarf2_get_attr_constant_value (member_loc, 0);
16718       baton->size += 1 /* DW_OP_addr */ + cu->header.addr_size;
16719     }
16720   else
16721     baton->size += DW_BLOCK (member_loc)->size;
16722
16723   ptr = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, baton->size);
16724   baton->data = ptr;
16725
16726   *ptr++ = DW_OP_call4;
16727   cu_off = common_die->sect_off - cu->per_cu->sect_off;
16728   store_unsigned_integer (ptr, 4, byte_order, cu_off);
16729   ptr += 4;
16730
16731   if (attr_form_is_constant (member_loc))
16732     {
16733       *ptr++ = DW_OP_addr;
16734       store_unsigned_integer (ptr, cu->header.addr_size, byte_order, offset);
16735       ptr += cu->header.addr_size;
16736     }
16737   else
16738     {
16739       /* We have to copy the data here, because DW_OP_call4 will only
16740          use a DW_AT_location attribute.  */
16741       memcpy (ptr, DW_BLOCK (member_loc)->data, DW_BLOCK (member_loc)->size);
16742       ptr += DW_BLOCK (member_loc)->size;
16743     }
16744
16745   *ptr++ = DW_OP_plus;
16746   gdb_assert (ptr - baton->data == baton->size);
16747
16748   SYMBOL_LOCATION_BATON (sym) = baton;
16749   SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
16750 }
16751
16752 /* Create appropriate locally-scoped variables for all the
16753    DW_TAG_common_block entries.  Also create a struct common_block
16754    listing all such variables for `info common'.  COMMON_BLOCK_DOMAIN
16755    is used to sepate the common blocks name namespace from regular
16756    variable names.  */
16757
16758 static void
16759 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
16760 {
16761   struct attribute *attr;
16762
16763   attr = dwarf2_attr (die, DW_AT_location, cu);
16764   if (attr)
16765     {
16766       /* Support the .debug_loc offsets.  */
16767       if (attr_form_is_block (attr))
16768         {
16769           /* Ok.  */
16770         }
16771       else if (attr_form_is_section_offset (attr))
16772         {
16773           dwarf2_complex_location_expr_complaint ();
16774           attr = NULL;
16775         }
16776       else
16777         {
16778           dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
16779                                                  "common block member");
16780           attr = NULL;
16781         }
16782     }
16783
16784   if (die->child != NULL)
16785     {
16786       struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16787       struct die_info *child_die;
16788       size_t n_entries = 0, size;
16789       struct common_block *common_block;
16790       struct symbol *sym;
16791
16792       for (child_die = die->child;
16793            child_die && child_die->tag;
16794            child_die = sibling_die (child_die))
16795         ++n_entries;
16796
16797       size = (sizeof (struct common_block)
16798               + (n_entries - 1) * sizeof (struct symbol *));
16799       common_block
16800         = (struct common_block *) obstack_alloc (&objfile->objfile_obstack,
16801                                                  size);
16802       memset (common_block->contents, 0, n_entries * sizeof (struct symbol *));
16803       common_block->n_entries = 0;
16804
16805       for (child_die = die->child;
16806            child_die && child_die->tag;
16807            child_die = sibling_die (child_die))
16808         {
16809           /* Create the symbol in the DW_TAG_common_block block in the current
16810              symbol scope.  */
16811           sym = new_symbol (child_die, NULL, cu);
16812           if (sym != NULL)
16813             {
16814               struct attribute *member_loc;
16815
16816               common_block->contents[common_block->n_entries++] = sym;
16817
16818               member_loc = dwarf2_attr (child_die, DW_AT_data_member_location,
16819                                         cu);
16820               if (member_loc)
16821                 {
16822                   /* GDB has handled this for a long time, but it is
16823                      not specified by DWARF.  It seems to have been
16824                      emitted by gfortran at least as recently as:
16825                      http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057.  */
16826                   complaint (_("Variable in common block has "
16827                                "DW_AT_data_member_location "
16828                                "- DIE at %s [in module %s]"),
16829                                sect_offset_str (child_die->sect_off),
16830                              objfile_name (objfile));
16831
16832                   if (attr_form_is_section_offset (member_loc))
16833                     dwarf2_complex_location_expr_complaint ();
16834                   else if (attr_form_is_constant (member_loc)
16835                            || attr_form_is_block (member_loc))
16836                     {
16837                       if (attr)
16838                         mark_common_block_symbol_computed (sym, die, attr,
16839                                                            member_loc, cu);
16840                     }
16841                   else
16842                     dwarf2_complex_location_expr_complaint ();
16843                 }
16844             }
16845         }
16846
16847       sym = new_symbol (die, objfile_type (objfile)->builtin_void, cu);
16848       SYMBOL_VALUE_COMMON_BLOCK (sym) = common_block;
16849     }
16850 }
16851
16852 /* Create a type for a C++ namespace.  */
16853
16854 static struct type *
16855 read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
16856 {
16857   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16858   const char *previous_prefix, *name;
16859   int is_anonymous;
16860   struct type *type;
16861
16862   /* For extensions, reuse the type of the original namespace.  */
16863   if (dwarf2_attr (die, DW_AT_extension, cu) != NULL)
16864     {
16865       struct die_info *ext_die;
16866       struct dwarf2_cu *ext_cu = cu;
16867
16868       ext_die = dwarf2_extension (die, &ext_cu);
16869       type = read_type_die (ext_die, ext_cu);
16870
16871       /* EXT_CU may not be the same as CU.
16872          Ensure TYPE is recorded with CU in die_type_hash.  */
16873       return set_die_type (die, type, cu);
16874     }
16875
16876   name = namespace_name (die, &is_anonymous, cu);
16877
16878   /* Now build the name of the current namespace.  */
16879
16880   previous_prefix = determine_prefix (die, cu);
16881   if (previous_prefix[0] != '\0')
16882     name = typename_concat (&objfile->objfile_obstack,
16883                             previous_prefix, name, 0, cu);
16884
16885   /* Create the type.  */
16886   type = init_type (objfile, TYPE_CODE_NAMESPACE, 0, name);
16887
16888   return set_die_type (die, type, cu);
16889 }
16890
16891 /* Read a namespace scope.  */
16892
16893 static void
16894 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
16895 {
16896   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16897   int is_anonymous;
16898
16899   /* Add a symbol associated to this if we haven't seen the namespace
16900      before.  Also, add a using directive if it's an anonymous
16901      namespace.  */
16902
16903   if (dwarf2_attr (die, DW_AT_extension, cu) == NULL)
16904     {
16905       struct type *type;
16906
16907       type = read_type_die (die, cu);
16908       new_symbol (die, type, cu);
16909
16910       namespace_name (die, &is_anonymous, cu);
16911       if (is_anonymous)
16912         {
16913           const char *previous_prefix = determine_prefix (die, cu);
16914
16915           std::vector<const char *> excludes;
16916           add_using_directive (using_directives (cu),
16917                                previous_prefix, TYPE_NAME (type), NULL,
16918                                NULL, excludes, 0, &objfile->objfile_obstack);
16919         }
16920     }
16921
16922   if (die->child != NULL)
16923     {
16924       struct die_info *child_die = die->child;
16925
16926       while (child_die && child_die->tag)
16927         {
16928           process_die (child_die, cu);
16929           child_die = sibling_die (child_die);
16930         }
16931     }
16932 }
16933
16934 /* Read a Fortran module as type.  This DIE can be only a declaration used for
16935    imported module.  Still we need that type as local Fortran "use ... only"
16936    declaration imports depend on the created type in determine_prefix.  */
16937
16938 static struct type *
16939 read_module_type (struct die_info *die, struct dwarf2_cu *cu)
16940 {
16941   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16942   const char *module_name;
16943   struct type *type;
16944
16945   module_name = dwarf2_name (die, cu);
16946   if (!module_name)
16947     complaint (_("DW_TAG_module has no name, offset %s"),
16948                sect_offset_str (die->sect_off));
16949   type = init_type (objfile, TYPE_CODE_MODULE, 0, module_name);
16950
16951   return set_die_type (die, type, cu);
16952 }
16953
16954 /* Read a Fortran module.  */
16955
16956 static void
16957 read_module (struct die_info *die, struct dwarf2_cu *cu)
16958 {
16959   struct die_info *child_die = die->child;
16960   struct type *type;
16961
16962   type = read_type_die (die, cu);
16963   new_symbol (die, type, cu);
16964
16965   while (child_die && child_die->tag)
16966     {
16967       process_die (child_die, cu);
16968       child_die = sibling_die (child_die);
16969     }
16970 }
16971
16972 /* Return the name of the namespace represented by DIE.  Set
16973    *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
16974    namespace.  */
16975
16976 static const char *
16977 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
16978 {
16979   struct die_info *current_die;
16980   const char *name = NULL;
16981
16982   /* Loop through the extensions until we find a name.  */
16983
16984   for (current_die = die;
16985        current_die != NULL;
16986        current_die = dwarf2_extension (die, &cu))
16987     {
16988       /* We don't use dwarf2_name here so that we can detect the absence
16989          of a name -> anonymous namespace.  */
16990       name = dwarf2_string_attr (die, DW_AT_name, cu);
16991
16992       if (name != NULL)
16993         break;
16994     }
16995
16996   /* Is it an anonymous namespace?  */
16997
16998   *is_anonymous = (name == NULL);
16999   if (*is_anonymous)
17000     name = CP_ANONYMOUS_NAMESPACE_STR;
17001
17002   return name;
17003 }
17004
17005 /* Extract all information from a DW_TAG_pointer_type DIE and add to
17006    the user defined type vector.  */
17007
17008 static struct type *
17009 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
17010 {
17011   struct gdbarch *gdbarch
17012     = get_objfile_arch (cu->per_cu->dwarf2_per_objfile->objfile);
17013   struct comp_unit_head *cu_header = &cu->header;
17014   struct type *type;
17015   struct attribute *attr_byte_size;
17016   struct attribute *attr_address_class;
17017   int byte_size, addr_class;
17018   struct type *target_type;
17019
17020   target_type = die_type (die, cu);
17021
17022   /* The die_type call above may have already set the type for this DIE.  */
17023   type = get_die_type (die, cu);
17024   if (type)
17025     return type;
17026
17027   type = lookup_pointer_type (target_type);
17028
17029   attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
17030   if (attr_byte_size)
17031     byte_size = DW_UNSND (attr_byte_size);
17032   else
17033     byte_size = cu_header->addr_size;
17034
17035   attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
17036   if (attr_address_class)
17037     addr_class = DW_UNSND (attr_address_class);
17038   else
17039     addr_class = DW_ADDR_none;
17040
17041   ULONGEST alignment = get_alignment (cu, die);
17042
17043   /* If the pointer size, alignment, or address class is different
17044      than the default, create a type variant marked as such and set
17045      the length accordingly.  */
17046   if (TYPE_LENGTH (type) != byte_size
17047       || (alignment != 0 && TYPE_RAW_ALIGN (type) != 0
17048           && alignment != TYPE_RAW_ALIGN (type))
17049       || addr_class != DW_ADDR_none)
17050     {
17051       if (gdbarch_address_class_type_flags_p (gdbarch))
17052         {
17053           int type_flags;
17054
17055           type_flags = gdbarch_address_class_type_flags
17056                          (gdbarch, byte_size, addr_class);
17057           gdb_assert ((type_flags & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
17058                       == 0);
17059           type = make_type_with_address_space (type, type_flags);
17060         }
17061       else if (TYPE_LENGTH (type) != byte_size)
17062         {
17063           complaint (_("invalid pointer size %d"), byte_size);
17064         }
17065       else if (TYPE_RAW_ALIGN (type) != alignment)
17066         {
17067           complaint (_("Invalid DW_AT_alignment"
17068                        " - DIE at %s [in module %s]"),
17069                      sect_offset_str (die->sect_off),
17070                      objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17071         }
17072       else
17073         {
17074           /* Should we also complain about unhandled address classes?  */
17075         }
17076     }
17077
17078   TYPE_LENGTH (type) = byte_size;
17079   set_type_align (type, alignment);
17080   return set_die_type (die, type, cu);
17081 }
17082
17083 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
17084    the user defined type vector.  */
17085
17086 static struct type *
17087 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
17088 {
17089   struct type *type;
17090   struct type *to_type;
17091   struct type *domain;
17092
17093   to_type = die_type (die, cu);
17094   domain = die_containing_type (die, cu);
17095
17096   /* The calls above may have already set the type for this DIE.  */
17097   type = get_die_type (die, cu);
17098   if (type)
17099     return type;
17100
17101   if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_METHOD)
17102     type = lookup_methodptr_type (to_type);
17103   else if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_FUNC)
17104     {
17105       struct type *new_type
17106         = alloc_type (cu->per_cu->dwarf2_per_objfile->objfile);
17107
17108       smash_to_method_type (new_type, domain, TYPE_TARGET_TYPE (to_type),
17109                             TYPE_FIELDS (to_type), TYPE_NFIELDS (to_type),
17110                             TYPE_VARARGS (to_type));
17111       type = lookup_methodptr_type (new_type);
17112     }
17113   else
17114     type = lookup_memberptr_type (to_type, domain);
17115
17116   return set_die_type (die, type, cu);
17117 }
17118
17119 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
17120    the user defined type vector.  */
17121
17122 static struct type *
17123 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu,
17124                           enum type_code refcode)
17125 {
17126   struct comp_unit_head *cu_header = &cu->header;
17127   struct type *type, *target_type;
17128   struct attribute *attr;
17129
17130   gdb_assert (refcode == TYPE_CODE_REF || refcode == TYPE_CODE_RVALUE_REF);
17131
17132   target_type = die_type (die, cu);
17133
17134   /* The die_type call above may have already set the type for this DIE.  */
17135   type = get_die_type (die, cu);
17136   if (type)
17137     return type;
17138
17139   type = lookup_reference_type (target_type, refcode);
17140   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17141   if (attr)
17142     {
17143       TYPE_LENGTH (type) = DW_UNSND (attr);
17144     }
17145   else
17146     {
17147       TYPE_LENGTH (type) = cu_header->addr_size;
17148     }
17149   maybe_set_alignment (cu, die, type);
17150   return set_die_type (die, type, cu);
17151 }
17152
17153 /* Add the given cv-qualifiers to the element type of the array.  GCC
17154    outputs DWARF type qualifiers that apply to an array, not the
17155    element type.  But GDB relies on the array element type to carry
17156    the cv-qualifiers.  This mimics section 6.7.3 of the C99
17157    specification.  */
17158
17159 static struct type *
17160 add_array_cv_type (struct die_info *die, struct dwarf2_cu *cu,
17161                    struct type *base_type, int cnst, int voltl)
17162 {
17163   struct type *el_type, *inner_array;
17164
17165   base_type = copy_type (base_type);
17166   inner_array = base_type;
17167
17168   while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
17169     {
17170       TYPE_TARGET_TYPE (inner_array) =
17171         copy_type (TYPE_TARGET_TYPE (inner_array));
17172       inner_array = TYPE_TARGET_TYPE (inner_array);
17173     }
17174
17175   el_type = TYPE_TARGET_TYPE (inner_array);
17176   cnst |= TYPE_CONST (el_type);
17177   voltl |= TYPE_VOLATILE (el_type);
17178   TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, NULL);
17179
17180   return set_die_type (die, base_type, cu);
17181 }
17182
17183 static struct type *
17184 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
17185 {
17186   struct type *base_type, *cv_type;
17187
17188   base_type = die_type (die, cu);
17189
17190   /* The die_type call above may have already set the type for this DIE.  */
17191   cv_type = get_die_type (die, cu);
17192   if (cv_type)
17193     return cv_type;
17194
17195   /* In case the const qualifier is applied to an array type, the element type
17196      is so qualified, not the array type (section 6.7.3 of C99).  */
17197   if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
17198     return add_array_cv_type (die, cu, base_type, 1, 0);
17199
17200   cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
17201   return set_die_type (die, cv_type, cu);
17202 }
17203
17204 static struct type *
17205 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
17206 {
17207   struct type *base_type, *cv_type;
17208
17209   base_type = die_type (die, cu);
17210
17211   /* The die_type call above may have already set the type for this DIE.  */
17212   cv_type = get_die_type (die, cu);
17213   if (cv_type)
17214     return cv_type;
17215
17216   /* In case the volatile qualifier is applied to an array type, the
17217      element type is so qualified, not the array type (section 6.7.3
17218      of C99).  */
17219   if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
17220     return add_array_cv_type (die, cu, base_type, 0, 1);
17221
17222   cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
17223   return set_die_type (die, cv_type, cu);
17224 }
17225
17226 /* Handle DW_TAG_restrict_type.  */
17227
17228 static struct type *
17229 read_tag_restrict_type (struct die_info *die, struct dwarf2_cu *cu)
17230 {
17231   struct type *base_type, *cv_type;
17232
17233   base_type = die_type (die, cu);
17234
17235   /* The die_type call above may have already set the type for this DIE.  */
17236   cv_type = get_die_type (die, cu);
17237   if (cv_type)
17238     return cv_type;
17239
17240   cv_type = make_restrict_type (base_type);
17241   return set_die_type (die, cv_type, cu);
17242 }
17243
17244 /* Handle DW_TAG_atomic_type.  */
17245
17246 static struct type *
17247 read_tag_atomic_type (struct die_info *die, struct dwarf2_cu *cu)
17248 {
17249   struct type *base_type, *cv_type;
17250
17251   base_type = die_type (die, cu);
17252
17253   /* The die_type call above may have already set the type for this DIE.  */
17254   cv_type = get_die_type (die, cu);
17255   if (cv_type)
17256     return cv_type;
17257
17258   cv_type = make_atomic_type (base_type);
17259   return set_die_type (die, cv_type, cu);
17260 }
17261
17262 /* Extract all information from a DW_TAG_string_type DIE and add to
17263    the user defined type vector.  It isn't really a user defined type,
17264    but it behaves like one, with other DIE's using an AT_user_def_type
17265    attribute to reference it.  */
17266
17267 static struct type *
17268 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
17269 {
17270   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17271   struct gdbarch *gdbarch = get_objfile_arch (objfile);
17272   struct type *type, *range_type, *index_type, *char_type;
17273   struct attribute *attr;
17274   unsigned int length;
17275
17276   attr = dwarf2_attr (die, DW_AT_string_length, cu);
17277   if (attr)
17278     {
17279       length = DW_UNSND (attr);
17280     }
17281   else
17282     {
17283       /* Check for the DW_AT_byte_size attribute.  */
17284       attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17285       if (attr)
17286         {
17287           length = DW_UNSND (attr);
17288         }
17289       else
17290         {
17291           length = 1;
17292         }
17293     }
17294
17295   index_type = objfile_type (objfile)->builtin_int;
17296   range_type = create_static_range_type (NULL, index_type, 1, length);
17297   char_type = language_string_char_type (cu->language_defn, gdbarch);
17298   type = create_string_type (NULL, char_type, range_type);
17299
17300   return set_die_type (die, type, cu);
17301 }
17302
17303 /* Assuming that DIE corresponds to a function, returns nonzero
17304    if the function is prototyped.  */
17305
17306 static int
17307 prototyped_function_p (struct die_info *die, struct dwarf2_cu *cu)
17308 {
17309   struct attribute *attr;
17310
17311   attr = dwarf2_attr (die, DW_AT_prototyped, cu);
17312   if (attr && (DW_UNSND (attr) != 0))
17313     return 1;
17314
17315   /* The DWARF standard implies that the DW_AT_prototyped attribute
17316      is only meaninful for C, but the concept also extends to other
17317      languages that allow unprototyped functions (Eg: Objective C).
17318      For all other languages, assume that functions are always
17319      prototyped.  */
17320   if (cu->language != language_c
17321       && cu->language != language_objc
17322       && cu->language != language_opencl)
17323     return 1;
17324
17325   /* RealView does not emit DW_AT_prototyped.  We can not distinguish
17326      prototyped and unprototyped functions; default to prototyped,
17327      since that is more common in modern code (and RealView warns
17328      about unprototyped functions).  */
17329   if (producer_is_realview (cu->producer))
17330     return 1;
17331
17332   return 0;
17333 }
17334
17335 /* Handle DIES due to C code like:
17336
17337    struct foo
17338    {
17339    int (*funcp)(int a, long l);
17340    int b;
17341    };
17342
17343    ('funcp' generates a DW_TAG_subroutine_type DIE).  */
17344
17345 static struct type *
17346 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
17347 {
17348   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17349   struct type *type;            /* Type that this function returns.  */
17350   struct type *ftype;           /* Function that returns above type.  */
17351   struct attribute *attr;
17352
17353   type = die_type (die, cu);
17354
17355   /* The die_type call above may have already set the type for this DIE.  */
17356   ftype = get_die_type (die, cu);
17357   if (ftype)
17358     return ftype;
17359
17360   ftype = lookup_function_type (type);
17361
17362   if (prototyped_function_p (die, cu))
17363     TYPE_PROTOTYPED (ftype) = 1;
17364
17365   /* Store the calling convention in the type if it's available in
17366      the subroutine die.  Otherwise set the calling convention to
17367      the default value DW_CC_normal.  */
17368   attr = dwarf2_attr (die, DW_AT_calling_convention, cu);
17369   if (attr)
17370     TYPE_CALLING_CONVENTION (ftype) = DW_UNSND (attr);
17371   else if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL"))
17372     TYPE_CALLING_CONVENTION (ftype) = DW_CC_GDB_IBM_OpenCL;
17373   else
17374     TYPE_CALLING_CONVENTION (ftype) = DW_CC_normal;
17375
17376   /* Record whether the function returns normally to its caller or not
17377      if the DWARF producer set that information.  */
17378   attr = dwarf2_attr (die, DW_AT_noreturn, cu);
17379   if (attr && (DW_UNSND (attr) != 0))
17380     TYPE_NO_RETURN (ftype) = 1;
17381
17382   /* We need to add the subroutine type to the die immediately so
17383      we don't infinitely recurse when dealing with parameters
17384      declared as the same subroutine type.  */
17385   set_die_type (die, ftype, cu);
17386
17387   if (die->child != NULL)
17388     {
17389       struct type *void_type = objfile_type (objfile)->builtin_void;
17390       struct die_info *child_die;
17391       int nparams, iparams;
17392
17393       /* Count the number of parameters.
17394          FIXME: GDB currently ignores vararg functions, but knows about
17395          vararg member functions.  */
17396       nparams = 0;
17397       child_die = die->child;
17398       while (child_die && child_die->tag)
17399         {
17400           if (child_die->tag == DW_TAG_formal_parameter)
17401             nparams++;
17402           else if (child_die->tag == DW_TAG_unspecified_parameters)
17403             TYPE_VARARGS (ftype) = 1;
17404           child_die = sibling_die (child_die);
17405         }
17406
17407       /* Allocate storage for parameters and fill them in.  */
17408       TYPE_NFIELDS (ftype) = nparams;
17409       TYPE_FIELDS (ftype) = (struct field *)
17410         TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
17411
17412       /* TYPE_FIELD_TYPE must never be NULL.  Pre-fill the array to ensure it
17413          even if we error out during the parameters reading below.  */
17414       for (iparams = 0; iparams < nparams; iparams++)
17415         TYPE_FIELD_TYPE (ftype, iparams) = void_type;
17416
17417       iparams = 0;
17418       child_die = die->child;
17419       while (child_die && child_die->tag)
17420         {
17421           if (child_die->tag == DW_TAG_formal_parameter)
17422             {
17423               struct type *arg_type;
17424
17425               /* DWARF version 2 has no clean way to discern C++
17426                  static and non-static member functions.  G++ helps
17427                  GDB by marking the first parameter for non-static
17428                  member functions (which is the this pointer) as
17429                  artificial.  We pass this information to
17430                  dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
17431
17432                  DWARF version 3 added DW_AT_object_pointer, which GCC
17433                  4.5 does not yet generate.  */
17434               attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
17435               if (attr)
17436                 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
17437               else
17438                 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
17439               arg_type = die_type (child_die, cu);
17440
17441               /* RealView does not mark THIS as const, which the testsuite
17442                  expects.  GCC marks THIS as const in method definitions,
17443                  but not in the class specifications (GCC PR 43053).  */
17444               if (cu->language == language_cplus && !TYPE_CONST (arg_type)
17445                   && TYPE_FIELD_ARTIFICIAL (ftype, iparams))
17446                 {
17447                   int is_this = 0;
17448                   struct dwarf2_cu *arg_cu = cu;
17449                   const char *name = dwarf2_name (child_die, cu);
17450
17451                   attr = dwarf2_attr (die, DW_AT_object_pointer, cu);
17452                   if (attr)
17453                     {
17454                       /* If the compiler emits this, use it.  */
17455                       if (follow_die_ref (die, attr, &arg_cu) == child_die)
17456                         is_this = 1;
17457                     }
17458                   else if (name && strcmp (name, "this") == 0)
17459                     /* Function definitions will have the argument names.  */
17460                     is_this = 1;
17461                   else if (name == NULL && iparams == 0)
17462                     /* Declarations may not have the names, so like
17463                        elsewhere in GDB, assume an artificial first
17464                        argument is "this".  */
17465                     is_this = 1;
17466
17467                   if (is_this)
17468                     arg_type = make_cv_type (1, TYPE_VOLATILE (arg_type),
17469                                              arg_type, 0);
17470                 }
17471
17472               TYPE_FIELD_TYPE (ftype, iparams) = arg_type;
17473               iparams++;
17474             }
17475           child_die = sibling_die (child_die);
17476         }
17477     }
17478
17479   return ftype;
17480 }
17481
17482 static struct type *
17483 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
17484 {
17485   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17486   const char *name = NULL;
17487   struct type *this_type, *target_type;
17488
17489   name = dwarf2_full_name (NULL, die, cu);
17490   this_type = init_type (objfile, TYPE_CODE_TYPEDEF, 0, name);
17491   TYPE_TARGET_STUB (this_type) = 1;
17492   set_die_type (die, this_type, cu);
17493   target_type = die_type (die, cu);
17494   if (target_type != this_type)
17495     TYPE_TARGET_TYPE (this_type) = target_type;
17496   else
17497     {
17498       /* Self-referential typedefs are, it seems, not allowed by the DWARF
17499          spec and cause infinite loops in GDB.  */
17500       complaint (_("Self-referential DW_TAG_typedef "
17501                    "- DIE at %s [in module %s]"),
17502                  sect_offset_str (die->sect_off), objfile_name (objfile));
17503       TYPE_TARGET_TYPE (this_type) = NULL;
17504     }
17505   return this_type;
17506 }
17507
17508 /* Allocate a floating-point type of size BITS and name NAME.  Pass NAME_HINT
17509    (which may be different from NAME) to the architecture back-end to allow
17510    it to guess the correct format if necessary.  */
17511
17512 static struct type *
17513 dwarf2_init_float_type (struct objfile *objfile, int bits, const char *name,
17514                         const char *name_hint)
17515 {
17516   struct gdbarch *gdbarch = get_objfile_arch (objfile);
17517   const struct floatformat **format;
17518   struct type *type;
17519
17520   format = gdbarch_floatformat_for_type (gdbarch, name_hint, bits);
17521   if (format)
17522     type = init_float_type (objfile, bits, name, format);
17523   else
17524     type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
17525
17526   return type;
17527 }
17528
17529 /* Allocate an integer type of size BITS and name NAME.  */
17530
17531 static struct type *
17532 dwarf2_init_integer_type (struct dwarf2_cu *cu, struct objfile *objfile,
17533                           int bits, int unsigned_p, const char *name)
17534 {
17535   struct type *type;
17536
17537   /* Versions of Intel's C Compiler generate an integer type called "void"
17538      instead of using DW_TAG_unspecified_type.  This has been seen on
17539      at least versions 14, 17, and 18.  */
17540   if (bits == 0 && producer_is_icc (cu) && name != nullptr
17541       && strcmp (name, "void") == 0)
17542     type = objfile_type (objfile)->builtin_void;
17543   else
17544     type = init_integer_type (objfile, bits, unsigned_p, name);
17545
17546   return type;
17547 }
17548
17549 /* Initialise and return a floating point type of size BITS suitable for
17550    use as a component of a complex number.  The NAME_HINT is passed through
17551    when initialising the floating point type and is the name of the complex
17552    type.
17553
17554    As DWARF doesn't currently provide an explicit name for the components
17555    of a complex number, but it can be helpful to have these components
17556    named, we try to select a suitable name based on the size of the
17557    component.  */
17558 static struct type *
17559 dwarf2_init_complex_target_type (struct dwarf2_cu *cu,
17560                                  struct objfile *objfile,
17561                                  int bits, const char *name_hint)
17562 {
17563   gdbarch *gdbarch = get_objfile_arch (objfile);
17564   struct type *tt = nullptr;
17565
17566   /* Try to find a suitable floating point builtin type of size BITS.
17567      We're going to use the name of this type as the name for the complex
17568      target type that we are about to create.  */
17569   switch (cu->language)
17570     {
17571     case language_fortran:
17572       switch (bits)
17573         {
17574         case 32:
17575           tt = builtin_f_type (gdbarch)->builtin_real;
17576           break;
17577         case 64:
17578           tt = builtin_f_type (gdbarch)->builtin_real_s8;
17579           break;
17580         case 96:        /* The x86-32 ABI specifies 96-bit long double.  */
17581         case 128:
17582           tt = builtin_f_type (gdbarch)->builtin_real_s16;
17583           break;
17584         }
17585       break;
17586     default:
17587       switch (bits)
17588         {
17589         case 32:
17590           tt = builtin_type (gdbarch)->builtin_float;
17591           break;
17592         case 64:
17593           tt = builtin_type (gdbarch)->builtin_double;
17594           break;
17595         case 96:        /* The x86-32 ABI specifies 96-bit long double.  */
17596         case 128:
17597           tt = builtin_type (gdbarch)->builtin_long_double;
17598           break;
17599         }
17600       break;
17601     }
17602
17603   /* If the type we found doesn't match the size we were looking for, then
17604      pretend we didn't find a type at all, the complex target type we
17605      create will then be nameless.  */
17606   if (tt != nullptr && TYPE_LENGTH (tt) * TARGET_CHAR_BIT != bits)
17607     tt = nullptr;
17608
17609   const char *name = (tt == nullptr) ? nullptr : TYPE_NAME (tt);
17610   return dwarf2_init_float_type (objfile, bits, name, name_hint);
17611 }
17612
17613 /* Find a representation of a given base type and install
17614    it in the TYPE field of the die.  */
17615
17616 static struct type *
17617 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
17618 {
17619   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17620   struct type *type;
17621   struct attribute *attr;
17622   int encoding = 0, bits = 0;
17623   const char *name;
17624
17625   attr = dwarf2_attr (die, DW_AT_encoding, cu);
17626   if (attr)
17627     {
17628       encoding = DW_UNSND (attr);
17629     }
17630   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17631   if (attr)
17632     {
17633       bits = DW_UNSND (attr) * TARGET_CHAR_BIT;
17634     }
17635   name = dwarf2_name (die, cu);
17636   if (!name)
17637     {
17638       complaint (_("DW_AT_name missing from DW_TAG_base_type"));
17639     }
17640
17641   switch (encoding)
17642     {
17643       case DW_ATE_address:
17644         /* Turn DW_ATE_address into a void * pointer.  */
17645         type = init_type (objfile, TYPE_CODE_VOID, TARGET_CHAR_BIT, NULL);
17646         type = init_pointer_type (objfile, bits, name, type);
17647         break;
17648       case DW_ATE_boolean:
17649         type = init_boolean_type (objfile, bits, 1, name);
17650         break;
17651       case DW_ATE_complex_float:
17652         type = dwarf2_init_complex_target_type (cu, objfile, bits / 2, name);
17653         type = init_complex_type (objfile, name, type);
17654         break;
17655       case DW_ATE_decimal_float:
17656         type = init_decfloat_type (objfile, bits, name);
17657         break;
17658       case DW_ATE_float:
17659         type = dwarf2_init_float_type (objfile, bits, name, name);
17660         break;
17661       case DW_ATE_signed:
17662         type = dwarf2_init_integer_type (cu, objfile, bits, 0, name);
17663         break;
17664       case DW_ATE_unsigned:
17665         if (cu->language == language_fortran
17666             && name
17667             && startswith (name, "character("))
17668           type = init_character_type (objfile, bits, 1, name);
17669         else
17670           type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17671         break;
17672       case DW_ATE_signed_char:
17673         if (cu->language == language_ada || cu->language == language_m2
17674             || cu->language == language_pascal
17675             || cu->language == language_fortran)
17676           type = init_character_type (objfile, bits, 0, name);
17677         else
17678           type = dwarf2_init_integer_type (cu, objfile, bits, 0, name);
17679         break;
17680       case DW_ATE_unsigned_char:
17681         if (cu->language == language_ada || cu->language == language_m2
17682             || cu->language == language_pascal
17683             || cu->language == language_fortran
17684             || cu->language == language_rust)
17685           type = init_character_type (objfile, bits, 1, name);
17686         else
17687           type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17688         break;
17689       case DW_ATE_UTF:
17690         {
17691           gdbarch *arch = get_objfile_arch (objfile);
17692
17693           if (bits == 16)
17694             type = builtin_type (arch)->builtin_char16;
17695           else if (bits == 32)
17696             type = builtin_type (arch)->builtin_char32;
17697           else
17698             {
17699               complaint (_("unsupported DW_ATE_UTF bit size: '%d'"),
17700                          bits);
17701               type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17702             }
17703           return set_die_type (die, type, cu);
17704         }
17705         break;
17706
17707       default:
17708         complaint (_("unsupported DW_AT_encoding: '%s'"),
17709                    dwarf_type_encoding_name (encoding));
17710         type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
17711         break;
17712     }
17713
17714   if (name && strcmp (name, "char") == 0)
17715     TYPE_NOSIGN (type) = 1;
17716
17717   maybe_set_alignment (cu, die, type);
17718
17719   return set_die_type (die, type, cu);
17720 }
17721
17722 /* Parse dwarf attribute if it's a block, reference or constant and put the
17723    resulting value of the attribute into struct bound_prop.
17724    Returns 1 if ATTR could be resolved into PROP, 0 otherwise.  */
17725
17726 static int
17727 attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die,
17728                       struct dwarf2_cu *cu, struct dynamic_prop *prop)
17729 {
17730   struct dwarf2_property_baton *baton;
17731   struct obstack *obstack
17732     = &cu->per_cu->dwarf2_per_objfile->objfile->objfile_obstack;
17733
17734   if (attr == NULL || prop == NULL)
17735     return 0;
17736
17737   if (attr_form_is_block (attr))
17738     {
17739       baton = XOBNEW (obstack, struct dwarf2_property_baton);
17740       baton->referenced_type = NULL;
17741       baton->locexpr.per_cu = cu->per_cu;
17742       baton->locexpr.size = DW_BLOCK (attr)->size;
17743       baton->locexpr.data = DW_BLOCK (attr)->data;
17744       prop->data.baton = baton;
17745       prop->kind = PROP_LOCEXPR;
17746       gdb_assert (prop->data.baton != NULL);
17747     }
17748   else if (attr_form_is_ref (attr))
17749     {
17750       struct dwarf2_cu *target_cu = cu;
17751       struct die_info *target_die;
17752       struct attribute *target_attr;
17753
17754       target_die = follow_die_ref (die, attr, &target_cu);
17755       target_attr = dwarf2_attr (target_die, DW_AT_location, target_cu);
17756       if (target_attr == NULL)
17757         target_attr = dwarf2_attr (target_die, DW_AT_data_member_location,
17758                                    target_cu);
17759       if (target_attr == NULL)
17760         return 0;
17761
17762       switch (target_attr->name)
17763         {
17764           case DW_AT_location:
17765             if (attr_form_is_section_offset (target_attr))
17766               {
17767                 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17768                 baton->referenced_type = die_type (target_die, target_cu);
17769                 fill_in_loclist_baton (cu, &baton->loclist, target_attr);
17770                 prop->data.baton = baton;
17771                 prop->kind = PROP_LOCLIST;
17772                 gdb_assert (prop->data.baton != NULL);
17773               }
17774             else if (attr_form_is_block (target_attr))
17775               {
17776                 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17777                 baton->referenced_type = die_type (target_die, target_cu);
17778                 baton->locexpr.per_cu = cu->per_cu;
17779                 baton->locexpr.size = DW_BLOCK (target_attr)->size;
17780                 baton->locexpr.data = DW_BLOCK (target_attr)->data;
17781                 prop->data.baton = baton;
17782                 prop->kind = PROP_LOCEXPR;
17783                 gdb_assert (prop->data.baton != NULL);
17784               }
17785             else
17786               {
17787                 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
17788                                                        "dynamic property");
17789                 return 0;
17790               }
17791             break;
17792           case DW_AT_data_member_location:
17793             {
17794               LONGEST offset;
17795
17796               if (!handle_data_member_location (target_die, target_cu,
17797                                                 &offset))
17798                 return 0;
17799
17800               baton = XOBNEW (obstack, struct dwarf2_property_baton);
17801               baton->referenced_type = read_type_die (target_die->parent,
17802                                                       target_cu);
17803               baton->offset_info.offset = offset;
17804               baton->offset_info.type = die_type (target_die, target_cu);
17805               prop->data.baton = baton;
17806               prop->kind = PROP_ADDR_OFFSET;
17807               break;
17808             }
17809         }
17810     }
17811   else if (attr_form_is_constant (attr))
17812     {
17813       prop->data.const_val = dwarf2_get_attr_constant_value (attr, 0);
17814       prop->kind = PROP_CONST;
17815     }
17816   else
17817     {
17818       dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr->form),
17819                                              dwarf2_name (die, cu));
17820       return 0;
17821     }
17822
17823   return 1;
17824 }
17825
17826 /* Read the given DW_AT_subrange DIE.  */
17827
17828 static struct type *
17829 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
17830 {
17831   struct type *base_type, *orig_base_type;
17832   struct type *range_type;
17833   struct attribute *attr;
17834   struct dynamic_prop low, high;
17835   int low_default_is_valid;
17836   int high_bound_is_count = 0;
17837   const char *name;
17838   ULONGEST negative_mask;
17839
17840   orig_base_type = die_type (die, cu);
17841   /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
17842      whereas the real type might be.  So, we use ORIG_BASE_TYPE when
17843      creating the range type, but we use the result of check_typedef
17844      when examining properties of the type.  */
17845   base_type = check_typedef (orig_base_type);
17846
17847   /* The die_type call above may have already set the type for this DIE.  */
17848   range_type = get_die_type (die, cu);
17849   if (range_type)
17850     return range_type;
17851
17852   low.kind = PROP_CONST;
17853   high.kind = PROP_CONST;
17854   high.data.const_val = 0;
17855
17856   /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
17857      omitting DW_AT_lower_bound.  */
17858   switch (cu->language)
17859     {
17860     case language_c:
17861     case language_cplus:
17862       low.data.const_val = 0;
17863       low_default_is_valid = 1;
17864       break;
17865     case language_fortran:
17866       low.data.const_val = 1;
17867       low_default_is_valid = 1;
17868       break;
17869     case language_d:
17870     case language_objc:
17871     case language_rust:
17872       low.data.const_val = 0;
17873       low_default_is_valid = (cu->header.version >= 4);
17874       break;
17875     case language_ada:
17876     case language_m2:
17877     case language_pascal:
17878       low.data.const_val = 1;
17879       low_default_is_valid = (cu->header.version >= 4);
17880       break;
17881     default:
17882       low.data.const_val = 0;
17883       low_default_is_valid = 0;
17884       break;
17885     }
17886
17887   attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
17888   if (attr)
17889     attr_to_dynamic_prop (attr, die, cu, &low);
17890   else if (!low_default_is_valid)
17891     complaint (_("Missing DW_AT_lower_bound "
17892                                       "- DIE at %s [in module %s]"),
17893                sect_offset_str (die->sect_off),
17894                objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17895
17896   struct attribute *attr_ub, *attr_count;
17897   attr = attr_ub = dwarf2_attr (die, DW_AT_upper_bound, cu);
17898   if (!attr_to_dynamic_prop (attr, die, cu, &high))
17899     {
17900       attr = attr_count = dwarf2_attr (die, DW_AT_count, cu);
17901       if (attr_to_dynamic_prop (attr, die, cu, &high))
17902         {
17903           /* If bounds are constant do the final calculation here.  */
17904           if (low.kind == PROP_CONST && high.kind == PROP_CONST)
17905             high.data.const_val = low.data.const_val + high.data.const_val - 1;
17906           else
17907             high_bound_is_count = 1;
17908         }
17909       else
17910         {
17911           if (attr_ub != NULL)
17912             complaint (_("Unresolved DW_AT_upper_bound "
17913                          "- DIE at %s [in module %s]"),
17914                        sect_offset_str (die->sect_off),
17915                        objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17916           if (attr_count != NULL)
17917             complaint (_("Unresolved DW_AT_count "
17918                          "- DIE at %s [in module %s]"),
17919                        sect_offset_str (die->sect_off),
17920                        objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17921         }
17922         
17923     }
17924
17925   /* Dwarf-2 specifications explicitly allows to create subrange types
17926      without specifying a base type.
17927      In that case, the base type must be set to the type of
17928      the lower bound, upper bound or count, in that order, if any of these
17929      three attributes references an object that has a type.
17930      If no base type is found, the Dwarf-2 specifications say that
17931      a signed integer type of size equal to the size of an address should
17932      be used.
17933      For the following C code: `extern char gdb_int [];'
17934      GCC produces an empty range DIE.
17935      FIXME: muller/2010-05-28: Possible references to object for low bound,
17936      high bound or count are not yet handled by this code.  */
17937   if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
17938     {
17939       struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17940       struct gdbarch *gdbarch = get_objfile_arch (objfile);
17941       int addr_size = gdbarch_addr_bit (gdbarch) /8;
17942       struct type *int_type = objfile_type (objfile)->builtin_int;
17943
17944       /* Test "int", "long int", and "long long int" objfile types,
17945          and select the first one having a size above or equal to the
17946          architecture address size.  */
17947       if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17948         base_type = int_type;
17949       else
17950         {
17951           int_type = objfile_type (objfile)->builtin_long;
17952           if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17953             base_type = int_type;
17954           else
17955             {
17956               int_type = objfile_type (objfile)->builtin_long_long;
17957               if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17958                 base_type = int_type;
17959             }
17960         }
17961     }
17962
17963   /* Normally, the DWARF producers are expected to use a signed
17964      constant form (Eg. DW_FORM_sdata) to express negative bounds.
17965      But this is unfortunately not always the case, as witnessed
17966      with GCC, for instance, where the ambiguous DW_FORM_dataN form
17967      is used instead.  To work around that ambiguity, we treat
17968      the bounds as signed, and thus sign-extend their values, when
17969      the base type is signed.  */
17970   negative_mask =
17971     -((ULONGEST) 1 << (TYPE_LENGTH (base_type) * TARGET_CHAR_BIT - 1));
17972   if (low.kind == PROP_CONST
17973       && !TYPE_UNSIGNED (base_type) && (low.data.const_val & negative_mask))
17974     low.data.const_val |= negative_mask;
17975   if (high.kind == PROP_CONST
17976       && !TYPE_UNSIGNED (base_type) && (high.data.const_val & negative_mask))
17977     high.data.const_val |= negative_mask;
17978
17979   range_type = create_range_type (NULL, orig_base_type, &low, &high);
17980
17981   if (high_bound_is_count)
17982     TYPE_RANGE_DATA (range_type)->flag_upper_bound_is_count = 1;
17983
17984   /* Ada expects an empty array on no boundary attributes.  */
17985   if (attr == NULL && cu->language != language_ada)
17986     TYPE_HIGH_BOUND_KIND (range_type) = PROP_UNDEFINED;
17987
17988   name = dwarf2_name (die, cu);
17989   if (name)
17990     TYPE_NAME (range_type) = name;
17991
17992   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17993   if (attr)
17994     TYPE_LENGTH (range_type) = DW_UNSND (attr);
17995
17996   maybe_set_alignment (cu, die, range_type);
17997
17998   set_die_type (die, range_type, cu);
17999
18000   /* set_die_type should be already done.  */
18001   set_descriptive_type (range_type, die, cu);
18002
18003   return range_type;
18004 }
18005
18006 static struct type *
18007 read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
18008 {
18009   struct type *type;
18010
18011   type = init_type (cu->per_cu->dwarf2_per_objfile->objfile, TYPE_CODE_VOID,0,
18012                     NULL);
18013   TYPE_NAME (type) = dwarf2_name (die, cu);
18014
18015   /* In Ada, an unspecified type is typically used when the description
18016      of the type is defered to a different unit.  When encountering
18017      such a type, we treat it as a stub, and try to resolve it later on,
18018      when needed.  */
18019   if (cu->language == language_ada)
18020     TYPE_STUB (type) = 1;
18021
18022   return set_die_type (die, type, cu);
18023 }
18024
18025 /* Read a single die and all its descendents.  Set the die's sibling
18026    field to NULL; set other fields in the die correctly, and set all
18027    of the descendents' fields correctly.  Set *NEW_INFO_PTR to the
18028    location of the info_ptr after reading all of those dies.  PARENT
18029    is the parent of the die in question.  */
18030
18031 static struct die_info *
18032 read_die_and_children (const struct die_reader_specs *reader,
18033                        const gdb_byte *info_ptr,
18034                        const gdb_byte **new_info_ptr,
18035                        struct die_info *parent)
18036 {
18037   struct die_info *die;
18038   const gdb_byte *cur_ptr;
18039   int has_children;
18040
18041   cur_ptr = read_full_die_1 (reader, &die, info_ptr, &has_children, 0);
18042   if (die == NULL)
18043     {
18044       *new_info_ptr = cur_ptr;
18045       return NULL;
18046     }
18047   store_in_ref_table (die, reader->cu);
18048
18049   if (has_children)
18050     die->child = read_die_and_siblings_1 (reader, cur_ptr, new_info_ptr, die);
18051   else
18052     {
18053       die->child = NULL;
18054       *new_info_ptr = cur_ptr;
18055     }
18056
18057   die->sibling = NULL;
18058   die->parent = parent;
18059   return die;
18060 }
18061
18062 /* Read a die, all of its descendents, and all of its siblings; set
18063    all of the fields of all of the dies correctly.  Arguments are as
18064    in read_die_and_children.  */
18065
18066 static struct die_info *
18067 read_die_and_siblings_1 (const struct die_reader_specs *reader,
18068                          const gdb_byte *info_ptr,
18069                          const gdb_byte **new_info_ptr,
18070                          struct die_info *parent)
18071 {
18072   struct die_info *first_die, *last_sibling;
18073   const gdb_byte *cur_ptr;
18074
18075   cur_ptr = info_ptr;
18076   first_die = last_sibling = NULL;
18077
18078   while (1)
18079     {
18080       struct die_info *die
18081         = read_die_and_children (reader, cur_ptr, &cur_ptr, parent);
18082
18083       if (die == NULL)
18084         {
18085           *new_info_ptr = cur_ptr;
18086           return first_die;
18087         }
18088
18089       if (!first_die)
18090         first_die = die;
18091       else
18092         last_sibling->sibling = die;
18093
18094       last_sibling = die;
18095     }
18096 }
18097
18098 /* Read a die, all of its descendents, and all of its siblings; set
18099    all of the fields of all of the dies correctly.  Arguments are as
18100    in read_die_and_children.
18101    This the main entry point for reading a DIE and all its children.  */
18102
18103 static struct die_info *
18104 read_die_and_siblings (const struct die_reader_specs *reader,
18105                        const gdb_byte *info_ptr,
18106                        const gdb_byte **new_info_ptr,
18107                        struct die_info *parent)
18108 {
18109   struct die_info *die = read_die_and_siblings_1 (reader, info_ptr,
18110                                                   new_info_ptr, parent);
18111
18112   if (dwarf_die_debug)
18113     {
18114       fprintf_unfiltered (gdb_stdlog,
18115                           "Read die from %s@0x%x of %s:\n",
18116                           get_section_name (reader->die_section),
18117                           (unsigned) (info_ptr - reader->die_section->buffer),
18118                           bfd_get_filename (reader->abfd));
18119       dump_die (die, dwarf_die_debug);
18120     }
18121
18122   return die;
18123 }
18124
18125 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
18126    attributes.
18127    The caller is responsible for filling in the extra attributes
18128    and updating (*DIEP)->num_attrs.
18129    Set DIEP to point to a newly allocated die with its information,
18130    except for its child, sibling, and parent fields.
18131    Set HAS_CHILDREN to tell whether the die has children or not.  */
18132
18133 static const gdb_byte *
18134 read_full_die_1 (const struct die_reader_specs *reader,
18135                  struct die_info **diep, const gdb_byte *info_ptr,
18136                  int *has_children, int num_extra_attrs)
18137 {
18138   unsigned int abbrev_number, bytes_read, i;
18139   struct abbrev_info *abbrev;
18140   struct die_info *die;
18141   struct dwarf2_cu *cu = reader->cu;
18142   bfd *abfd = reader->abfd;
18143
18144   sect_offset sect_off = (sect_offset) (info_ptr - reader->buffer);
18145   abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
18146   info_ptr += bytes_read;
18147   if (!abbrev_number)
18148     {
18149       *diep = NULL;
18150       *has_children = 0;
18151       return info_ptr;
18152     }
18153
18154   abbrev = reader->abbrev_table->lookup_abbrev (abbrev_number);
18155   if (!abbrev)
18156     error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
18157            abbrev_number,
18158            bfd_get_filename (abfd));
18159
18160   die = dwarf_alloc_die (cu, abbrev->num_attrs + num_extra_attrs);
18161   die->sect_off = sect_off;
18162   die->tag = abbrev->tag;
18163   die->abbrev = abbrev_number;
18164
18165   /* Make the result usable.
18166      The caller needs to update num_attrs after adding the extra
18167      attributes.  */
18168   die->num_attrs = abbrev->num_attrs;
18169
18170   for (i = 0; i < abbrev->num_attrs; ++i)
18171     info_ptr = read_attribute (reader, &die->attrs[i], &abbrev->attrs[i],
18172                                info_ptr);
18173
18174   *diep = die;
18175   *has_children = abbrev->has_children;
18176   return info_ptr;
18177 }
18178
18179 /* Read a die and all its attributes.
18180    Set DIEP to point to a newly allocated die with its information,
18181    except for its child, sibling, and parent fields.
18182    Set HAS_CHILDREN to tell whether the die has children or not.  */
18183
18184 static const gdb_byte *
18185 read_full_die (const struct die_reader_specs *reader,
18186                struct die_info **diep, const gdb_byte *info_ptr,
18187                int *has_children)
18188 {
18189   const gdb_byte *result;
18190
18191   result = read_full_die_1 (reader, diep, info_ptr, has_children, 0);
18192
18193   if (dwarf_die_debug)
18194     {
18195       fprintf_unfiltered (gdb_stdlog,
18196                           "Read die from %s@0x%x of %s:\n",
18197                           get_section_name (reader->die_section),
18198                           (unsigned) (info_ptr - reader->die_section->buffer),
18199                           bfd_get_filename (reader->abfd));
18200       dump_die (*diep, dwarf_die_debug);
18201     }
18202
18203   return result;
18204 }
18205 \f
18206 /* Abbreviation tables.
18207
18208    In DWARF version 2, the description of the debugging information is
18209    stored in a separate .debug_abbrev section.  Before we read any
18210    dies from a section we read in all abbreviations and install them
18211    in a hash table.  */
18212
18213 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE.  */
18214
18215 struct abbrev_info *
18216 abbrev_table::alloc_abbrev ()
18217 {
18218   struct abbrev_info *abbrev;
18219
18220   abbrev = XOBNEW (&abbrev_obstack, struct abbrev_info);
18221   memset (abbrev, 0, sizeof (struct abbrev_info));
18222
18223   return abbrev;
18224 }
18225
18226 /* Add an abbreviation to the table.  */
18227
18228 void
18229 abbrev_table::add_abbrev (unsigned int abbrev_number,
18230                           struct abbrev_info *abbrev)
18231 {
18232   unsigned int hash_number;
18233
18234   hash_number = abbrev_number % ABBREV_HASH_SIZE;
18235   abbrev->next = m_abbrevs[hash_number];
18236   m_abbrevs[hash_number] = abbrev;
18237 }
18238
18239 /* Look up an abbrev in the table.
18240    Returns NULL if the abbrev is not found.  */
18241
18242 struct abbrev_info *
18243 abbrev_table::lookup_abbrev (unsigned int abbrev_number)
18244 {
18245   unsigned int hash_number;
18246   struct abbrev_info *abbrev;
18247
18248   hash_number = abbrev_number % ABBREV_HASH_SIZE;
18249   abbrev = m_abbrevs[hash_number];
18250
18251   while (abbrev)
18252     {
18253       if (abbrev->number == abbrev_number)
18254         return abbrev;
18255       abbrev = abbrev->next;
18256     }
18257   return NULL;
18258 }
18259
18260 /* Read in an abbrev table.  */
18261
18262 static abbrev_table_up
18263 abbrev_table_read_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
18264                          struct dwarf2_section_info *section,
18265                          sect_offset sect_off)
18266 {
18267   struct objfile *objfile = dwarf2_per_objfile->objfile;
18268   bfd *abfd = get_section_bfd_owner (section);
18269   const gdb_byte *abbrev_ptr;
18270   struct abbrev_info *cur_abbrev;
18271   unsigned int abbrev_number, bytes_read, abbrev_name;
18272   unsigned int abbrev_form;
18273   struct attr_abbrev *cur_attrs;
18274   unsigned int allocated_attrs;
18275
18276   abbrev_table_up abbrev_table (new struct abbrev_table (sect_off));
18277
18278   dwarf2_read_section (objfile, section);
18279   abbrev_ptr = section->buffer + to_underlying (sect_off);
18280   abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18281   abbrev_ptr += bytes_read;
18282
18283   allocated_attrs = ATTR_ALLOC_CHUNK;
18284   cur_attrs = XNEWVEC (struct attr_abbrev, allocated_attrs);
18285
18286   /* Loop until we reach an abbrev number of 0.  */
18287   while (abbrev_number)
18288     {
18289       cur_abbrev = abbrev_table->alloc_abbrev ();
18290
18291       /* read in abbrev header */
18292       cur_abbrev->number = abbrev_number;
18293       cur_abbrev->tag
18294         = (enum dwarf_tag) read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18295       abbrev_ptr += bytes_read;
18296       cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
18297       abbrev_ptr += 1;
18298
18299       /* now read in declarations */
18300       for (;;)
18301         {
18302           LONGEST implicit_const;
18303
18304           abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18305           abbrev_ptr += bytes_read;
18306           abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18307           abbrev_ptr += bytes_read;
18308           if (abbrev_form == DW_FORM_implicit_const)
18309             {
18310               implicit_const = read_signed_leb128 (abfd, abbrev_ptr,
18311                                                    &bytes_read);
18312               abbrev_ptr += bytes_read;
18313             }
18314           else
18315             {
18316               /* Initialize it due to a false compiler warning.  */
18317               implicit_const = -1;
18318             }
18319
18320           if (abbrev_name == 0)
18321             break;
18322
18323           if (cur_abbrev->num_attrs == allocated_attrs)
18324             {
18325               allocated_attrs += ATTR_ALLOC_CHUNK;
18326               cur_attrs
18327                 = XRESIZEVEC (struct attr_abbrev, cur_attrs, allocated_attrs);
18328             }
18329
18330           cur_attrs[cur_abbrev->num_attrs].name
18331             = (enum dwarf_attribute) abbrev_name;
18332           cur_attrs[cur_abbrev->num_attrs].form
18333             = (enum dwarf_form) abbrev_form;
18334           cur_attrs[cur_abbrev->num_attrs].implicit_const = implicit_const;
18335           ++cur_abbrev->num_attrs;
18336         }
18337
18338       cur_abbrev->attrs =
18339         XOBNEWVEC (&abbrev_table->abbrev_obstack, struct attr_abbrev,
18340                    cur_abbrev->num_attrs);
18341       memcpy (cur_abbrev->attrs, cur_attrs,
18342               cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
18343
18344       abbrev_table->add_abbrev (abbrev_number, cur_abbrev);
18345
18346       /* Get next abbreviation.
18347          Under Irix6 the abbreviations for a compilation unit are not
18348          always properly terminated with an abbrev number of 0.
18349          Exit loop if we encounter an abbreviation which we have
18350          already read (which means we are about to read the abbreviations
18351          for the next compile unit) or if the end of the abbreviation
18352          table is reached.  */
18353       if ((unsigned int) (abbrev_ptr - section->buffer) >= section->size)
18354         break;
18355       abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18356       abbrev_ptr += bytes_read;
18357       if (abbrev_table->lookup_abbrev (abbrev_number) != NULL)
18358         break;
18359     }
18360
18361   xfree (cur_attrs);
18362   return abbrev_table;
18363 }
18364
18365 /* Returns nonzero if TAG represents a type that we might generate a partial
18366    symbol for.  */
18367
18368 static int
18369 is_type_tag_for_partial (int tag)
18370 {
18371   switch (tag)
18372     {
18373 #if 0
18374     /* Some types that would be reasonable to generate partial symbols for,
18375        that we don't at present.  */
18376     case DW_TAG_array_type:
18377     case DW_TAG_file_type:
18378     case DW_TAG_ptr_to_member_type:
18379     case DW_TAG_set_type:
18380     case DW_TAG_string_type:
18381     case DW_TAG_subroutine_type:
18382 #endif
18383     case DW_TAG_base_type:
18384     case DW_TAG_class_type:
18385     case DW_TAG_interface_type:
18386     case DW_TAG_enumeration_type:
18387     case DW_TAG_structure_type:
18388     case DW_TAG_subrange_type:
18389     case DW_TAG_typedef:
18390     case DW_TAG_union_type:
18391       return 1;
18392     default:
18393       return 0;
18394     }
18395 }
18396
18397 /* Load all DIEs that are interesting for partial symbols into memory.  */
18398
18399 static struct partial_die_info *
18400 load_partial_dies (const struct die_reader_specs *reader,
18401                    const gdb_byte *info_ptr, int building_psymtab)
18402 {
18403   struct dwarf2_cu *cu = reader->cu;
18404   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
18405   struct partial_die_info *parent_die, *last_die, *first_die = NULL;
18406   unsigned int bytes_read;
18407   unsigned int load_all = 0;
18408   int nesting_level = 1;
18409
18410   parent_die = NULL;
18411   last_die = NULL;
18412
18413   gdb_assert (cu->per_cu != NULL);
18414   if (cu->per_cu->load_all_dies)
18415     load_all = 1;
18416
18417   cu->partial_dies
18418     = htab_create_alloc_ex (cu->header.length / 12,
18419                             partial_die_hash,
18420                             partial_die_eq,
18421                             NULL,
18422                             &cu->comp_unit_obstack,
18423                             hashtab_obstack_allocate,
18424                             dummy_obstack_deallocate);
18425
18426   while (1)
18427     {
18428       abbrev_info *abbrev = peek_die_abbrev (*reader, info_ptr, &bytes_read);
18429
18430       /* A NULL abbrev means the end of a series of children.  */
18431       if (abbrev == NULL)
18432         {
18433           if (--nesting_level == 0)
18434             return first_die;
18435
18436           info_ptr += bytes_read;
18437           last_die = parent_die;
18438           parent_die = parent_die->die_parent;
18439           continue;
18440         }
18441
18442       /* Check for template arguments.  We never save these; if
18443          they're seen, we just mark the parent, and go on our way.  */
18444       if (parent_die != NULL
18445           && cu->language == language_cplus
18446           && (abbrev->tag == DW_TAG_template_type_param
18447               || abbrev->tag == DW_TAG_template_value_param))
18448         {
18449           parent_die->has_template_arguments = 1;
18450
18451           if (!load_all)
18452             {
18453               /* We don't need a partial DIE for the template argument.  */
18454               info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18455               continue;
18456             }
18457         }
18458
18459       /* We only recurse into c++ subprograms looking for template arguments.
18460          Skip their other children.  */
18461       if (!load_all
18462           && cu->language == language_cplus
18463           && parent_die != NULL
18464           && parent_die->tag == DW_TAG_subprogram)
18465         {
18466           info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18467           continue;
18468         }
18469
18470       /* Check whether this DIE is interesting enough to save.  Normally
18471          we would not be interested in members here, but there may be
18472          later variables referencing them via DW_AT_specification (for
18473          static members).  */
18474       if (!load_all
18475           && !is_type_tag_for_partial (abbrev->tag)
18476           && abbrev->tag != DW_TAG_constant
18477           && abbrev->tag != DW_TAG_enumerator
18478           && abbrev->tag != DW_TAG_subprogram
18479           && abbrev->tag != DW_TAG_inlined_subroutine
18480           && abbrev->tag != DW_TAG_lexical_block
18481           && abbrev->tag != DW_TAG_variable
18482           && abbrev->tag != DW_TAG_namespace
18483           && abbrev->tag != DW_TAG_module
18484           && abbrev->tag != DW_TAG_member
18485           && abbrev->tag != DW_TAG_imported_unit
18486           && abbrev->tag != DW_TAG_imported_declaration)
18487         {
18488           /* Otherwise we skip to the next sibling, if any.  */
18489           info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18490           continue;
18491         }
18492
18493       struct partial_die_info pdi ((sect_offset) (info_ptr - reader->buffer),
18494                                    abbrev);
18495
18496       info_ptr = pdi.read (reader, *abbrev, info_ptr + bytes_read);
18497
18498       /* This two-pass algorithm for processing partial symbols has a
18499          high cost in cache pressure.  Thus, handle some simple cases
18500          here which cover the majority of C partial symbols.  DIEs
18501          which neither have specification tags in them, nor could have
18502          specification tags elsewhere pointing at them, can simply be
18503          processed and discarded.
18504
18505          This segment is also optional; scan_partial_symbols and
18506          add_partial_symbol will handle these DIEs if we chain
18507          them in normally.  When compilers which do not emit large
18508          quantities of duplicate debug information are more common,
18509          this code can probably be removed.  */
18510
18511       /* Any complete simple types at the top level (pretty much all
18512          of them, for a language without namespaces), can be processed
18513          directly.  */
18514       if (parent_die == NULL
18515           && pdi.has_specification == 0
18516           && pdi.is_declaration == 0
18517           && ((pdi.tag == DW_TAG_typedef && !pdi.has_children)
18518               || pdi.tag == DW_TAG_base_type
18519               || pdi.tag == DW_TAG_subrange_type))
18520         {
18521           if (building_psymtab && pdi.name != NULL)
18522             add_psymbol_to_list (pdi.name, strlen (pdi.name), 0,
18523                                  VAR_DOMAIN, LOC_TYPEDEF, -1,
18524                                  psymbol_placement::STATIC,
18525                                  0, cu->language, objfile);
18526           info_ptr = locate_pdi_sibling (reader, &pdi, info_ptr);
18527           continue;
18528         }
18529
18530       /* The exception for DW_TAG_typedef with has_children above is
18531          a workaround of GCC PR debug/47510.  In the case of this complaint
18532          type_name_or_error will error on such types later.
18533
18534          GDB skipped children of DW_TAG_typedef by the shortcut above and then
18535          it could not find the child DIEs referenced later, this is checked
18536          above.  In correct DWARF DW_TAG_typedef should have no children.  */
18537
18538       if (pdi.tag == DW_TAG_typedef && pdi.has_children)
18539         complaint (_("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
18540                      "- DIE at %s [in module %s]"),
18541                    sect_offset_str (pdi.sect_off), objfile_name (objfile));
18542
18543       /* If we're at the second level, and we're an enumerator, and
18544          our parent has no specification (meaning possibly lives in a
18545          namespace elsewhere), then we can add the partial symbol now
18546          instead of queueing it.  */
18547       if (pdi.tag == DW_TAG_enumerator
18548           && parent_die != NULL
18549           && parent_die->die_parent == NULL
18550           && parent_die->tag == DW_TAG_enumeration_type
18551           && parent_die->has_specification == 0)
18552         {
18553           if (pdi.name == NULL)
18554             complaint (_("malformed enumerator DIE ignored"));
18555           else if (building_psymtab)
18556             add_psymbol_to_list (pdi.name, strlen (pdi.name), 0,
18557                                  VAR_DOMAIN, LOC_CONST, -1,
18558                                  cu->language == language_cplus
18559                                  ? psymbol_placement::GLOBAL
18560                                  : psymbol_placement::STATIC,
18561                                  0, cu->language, objfile);
18562
18563           info_ptr = locate_pdi_sibling (reader, &pdi, info_ptr);
18564           continue;
18565         }
18566
18567       struct partial_die_info *part_die
18568         = new (&cu->comp_unit_obstack) partial_die_info (pdi);
18569
18570       /* We'll save this DIE so link it in.  */
18571       part_die->die_parent = parent_die;
18572       part_die->die_sibling = NULL;
18573       part_die->die_child = NULL;
18574
18575       if (last_die && last_die == parent_die)
18576         last_die->die_child = part_die;
18577       else if (last_die)
18578         last_die->die_sibling = part_die;
18579
18580       last_die = part_die;
18581
18582       if (first_die == NULL)
18583         first_die = part_die;
18584
18585       /* Maybe add the DIE to the hash table.  Not all DIEs that we
18586          find interesting need to be in the hash table, because we
18587          also have the parent/sibling/child chains; only those that we
18588          might refer to by offset later during partial symbol reading.
18589
18590          For now this means things that might have be the target of a
18591          DW_AT_specification, DW_AT_abstract_origin, or
18592          DW_AT_extension.  DW_AT_extension will refer only to
18593          namespaces; DW_AT_abstract_origin refers to functions (and
18594          many things under the function DIE, but we do not recurse
18595          into function DIEs during partial symbol reading) and
18596          possibly variables as well; DW_AT_specification refers to
18597          declarations.  Declarations ought to have the DW_AT_declaration
18598          flag.  It happens that GCC forgets to put it in sometimes, but
18599          only for functions, not for types.
18600
18601          Adding more things than necessary to the hash table is harmless
18602          except for the performance cost.  Adding too few will result in
18603          wasted time in find_partial_die, when we reread the compilation
18604          unit with load_all_dies set.  */
18605
18606       if (load_all
18607           || abbrev->tag == DW_TAG_constant
18608           || abbrev->tag == DW_TAG_subprogram
18609           || abbrev->tag == DW_TAG_variable
18610           || abbrev->tag == DW_TAG_namespace
18611           || part_die->is_declaration)
18612         {
18613           void **slot;
18614
18615           slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
18616                                            to_underlying (part_die->sect_off),
18617                                            INSERT);
18618           *slot = part_die;
18619         }
18620
18621       /* For some DIEs we want to follow their children (if any).  For C
18622          we have no reason to follow the children of structures; for other
18623          languages we have to, so that we can get at method physnames
18624          to infer fully qualified class names, for DW_AT_specification,
18625          and for C++ template arguments.  For C++, we also look one level
18626          inside functions to find template arguments (if the name of the
18627          function does not already contain the template arguments).
18628
18629          For Ada, we need to scan the children of subprograms and lexical
18630          blocks as well because Ada allows the definition of nested
18631          entities that could be interesting for the debugger, such as
18632          nested subprograms for instance.  */
18633       if (last_die->has_children
18634           && (load_all
18635               || last_die->tag == DW_TAG_namespace
18636               || last_die->tag == DW_TAG_module
18637               || last_die->tag == DW_TAG_enumeration_type
18638               || (cu->language == language_cplus
18639                   && last_die->tag == DW_TAG_subprogram
18640                   && (last_die->name == NULL
18641                       || strchr (last_die->name, '<') == NULL))
18642               || (cu->language != language_c
18643                   && (last_die->tag == DW_TAG_class_type
18644                       || last_die->tag == DW_TAG_interface_type
18645                       || last_die->tag == DW_TAG_structure_type
18646                       || last_die->tag == DW_TAG_union_type))
18647               || (cu->language == language_ada
18648                   && (last_die->tag == DW_TAG_subprogram
18649                       || last_die->tag == DW_TAG_lexical_block))))
18650         {
18651           nesting_level++;
18652           parent_die = last_die;
18653           continue;
18654         }
18655
18656       /* Otherwise we skip to the next sibling, if any.  */
18657       info_ptr = locate_pdi_sibling (reader, last_die, info_ptr);
18658
18659       /* Back to the top, do it again.  */
18660     }
18661 }
18662
18663 partial_die_info::partial_die_info (sect_offset sect_off_,
18664                                     struct abbrev_info *abbrev)
18665   : partial_die_info (sect_off_, abbrev->tag, abbrev->has_children)
18666 {
18667 }
18668
18669 /* Read a minimal amount of information into the minimal die structure.
18670    INFO_PTR should point just after the initial uleb128 of a DIE.  */
18671
18672 const gdb_byte *
18673 partial_die_info::read (const struct die_reader_specs *reader,
18674                         const struct abbrev_info &abbrev, const gdb_byte *info_ptr)
18675 {
18676   struct dwarf2_cu *cu = reader->cu;
18677   struct dwarf2_per_objfile *dwarf2_per_objfile
18678     = cu->per_cu->dwarf2_per_objfile;
18679   unsigned int i;
18680   int has_low_pc_attr = 0;
18681   int has_high_pc_attr = 0;
18682   int high_pc_relative = 0;
18683
18684   for (i = 0; i < abbrev.num_attrs; ++i)
18685     {
18686       struct attribute attr;
18687
18688       info_ptr = read_attribute (reader, &attr, &abbrev.attrs[i], info_ptr);
18689
18690       /* Store the data if it is of an attribute we want to keep in a
18691          partial symbol table.  */
18692       switch (attr.name)
18693         {
18694         case DW_AT_name:
18695           switch (tag)
18696             {
18697             case DW_TAG_compile_unit:
18698             case DW_TAG_partial_unit:
18699             case DW_TAG_type_unit:
18700               /* Compilation units have a DW_AT_name that is a filename, not
18701                  a source language identifier.  */
18702             case DW_TAG_enumeration_type:
18703             case DW_TAG_enumerator:
18704               /* These tags always have simple identifiers already; no need
18705                  to canonicalize them.  */
18706               name = DW_STRING (&attr);
18707               break;
18708             default:
18709               {
18710                 struct objfile *objfile = dwarf2_per_objfile->objfile;
18711
18712                 name
18713                   = dwarf2_canonicalize_name (DW_STRING (&attr), cu,
18714                                               &objfile->per_bfd->storage_obstack);
18715               }
18716               break;
18717             }
18718           break;
18719         case DW_AT_linkage_name:
18720         case DW_AT_MIPS_linkage_name:
18721           /* Note that both forms of linkage name might appear.  We
18722              assume they will be the same, and we only store the last
18723              one we see.  */
18724           if (cu->language == language_ada)
18725             name = DW_STRING (&attr);
18726           linkage_name = DW_STRING (&attr);
18727           break;
18728         case DW_AT_low_pc:
18729           has_low_pc_attr = 1;
18730           lowpc = attr_value_as_address (&attr);
18731           break;
18732         case DW_AT_high_pc:
18733           has_high_pc_attr = 1;
18734           highpc = attr_value_as_address (&attr);
18735           if (cu->header.version >= 4 && attr_form_is_constant (&attr))
18736                 high_pc_relative = 1;
18737           break;
18738         case DW_AT_location:
18739           /* Support the .debug_loc offsets.  */
18740           if (attr_form_is_block (&attr))
18741             {
18742                d.locdesc = DW_BLOCK (&attr);
18743             }
18744           else if (attr_form_is_section_offset (&attr))
18745             {
18746               dwarf2_complex_location_expr_complaint ();
18747             }
18748           else
18749             {
18750               dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
18751                                                      "partial symbol information");
18752             }
18753           break;
18754         case DW_AT_external:
18755           is_external = DW_UNSND (&attr);
18756           break;
18757         case DW_AT_declaration:
18758           is_declaration = DW_UNSND (&attr);
18759           break;
18760         case DW_AT_type:
18761           has_type = 1;
18762           break;
18763         case DW_AT_abstract_origin:
18764         case DW_AT_specification:
18765         case DW_AT_extension:
18766           has_specification = 1;
18767           spec_offset = dwarf2_get_ref_die_offset (&attr);
18768           spec_is_dwz = (attr.form == DW_FORM_GNU_ref_alt
18769                                    || cu->per_cu->is_dwz);
18770           break;
18771         case DW_AT_sibling:
18772           /* Ignore absolute siblings, they might point outside of
18773              the current compile unit.  */
18774           if (attr.form == DW_FORM_ref_addr)
18775             complaint (_("ignoring absolute DW_AT_sibling"));
18776           else
18777             {
18778               const gdb_byte *buffer = reader->buffer;
18779               sect_offset off = dwarf2_get_ref_die_offset (&attr);
18780               const gdb_byte *sibling_ptr = buffer + to_underlying (off);
18781
18782               if (sibling_ptr < info_ptr)
18783                 complaint (_("DW_AT_sibling points backwards"));
18784               else if (sibling_ptr > reader->buffer_end)
18785                 dwarf2_section_buffer_overflow_complaint (reader->die_section);
18786               else
18787                 sibling = sibling_ptr;
18788             }
18789           break;
18790         case DW_AT_byte_size:
18791           has_byte_size = 1;
18792           break;
18793         case DW_AT_const_value:
18794           has_const_value = 1;
18795           break;
18796         case DW_AT_calling_convention:
18797           /* DWARF doesn't provide a way to identify a program's source-level
18798              entry point.  DW_AT_calling_convention attributes are only meant
18799              to describe functions' calling conventions.
18800
18801              However, because it's a necessary piece of information in
18802              Fortran, and before DWARF 4 DW_CC_program was the only
18803              piece of debugging information whose definition refers to
18804              a 'main program' at all, several compilers marked Fortran
18805              main programs with DW_CC_program --- even when those
18806              functions use the standard calling conventions.
18807
18808              Although DWARF now specifies a way to provide this
18809              information, we support this practice for backward
18810              compatibility.  */
18811           if (DW_UNSND (&attr) == DW_CC_program
18812               && cu->language == language_fortran)
18813             main_subprogram = 1;
18814           break;
18815         case DW_AT_inline:
18816           if (DW_UNSND (&attr) == DW_INL_inlined
18817               || DW_UNSND (&attr) == DW_INL_declared_inlined)
18818             may_be_inlined = 1;
18819           break;
18820
18821         case DW_AT_import:
18822           if (tag == DW_TAG_imported_unit)
18823             {
18824               d.sect_off = dwarf2_get_ref_die_offset (&attr);
18825               is_dwz = (attr.form == DW_FORM_GNU_ref_alt
18826                                   || cu->per_cu->is_dwz);
18827             }
18828           break;
18829
18830         case DW_AT_main_subprogram:
18831           main_subprogram = DW_UNSND (&attr);
18832           break;
18833
18834         case DW_AT_ranges:
18835           {
18836             /* It would be nice to reuse dwarf2_get_pc_bounds here,
18837                but that requires a full DIE, so instead we just
18838                reimplement it.  */
18839             int need_ranges_base = tag != DW_TAG_compile_unit;
18840             unsigned int ranges_offset = (DW_UNSND (&attr)
18841                                           + (need_ranges_base
18842                                              ? cu->ranges_base
18843                                              : 0));
18844
18845             /* Value of the DW_AT_ranges attribute is the offset in the
18846                .debug_ranges section.  */
18847             if (dwarf2_ranges_read (ranges_offset, &lowpc, &highpc, cu,
18848                                     nullptr))
18849               has_pc_info = 1;
18850           }
18851           break;
18852
18853         default:
18854           break;
18855         }
18856     }
18857
18858   if (high_pc_relative)
18859     highpc += lowpc;
18860
18861   if (has_low_pc_attr && has_high_pc_attr)
18862     {
18863       /* When using the GNU linker, .gnu.linkonce. sections are used to
18864          eliminate duplicate copies of functions and vtables and such.
18865          The linker will arbitrarily choose one and discard the others.
18866          The AT_*_pc values for such functions refer to local labels in
18867          these sections.  If the section from that file was discarded, the
18868          labels are not in the output, so the relocs get a value of 0.
18869          If this is a discarded function, mark the pc bounds as invalid,
18870          so that GDB will ignore it.  */
18871       if (lowpc == 0 && !dwarf2_per_objfile->has_section_at_zero)
18872         {
18873           struct objfile *objfile = dwarf2_per_objfile->objfile;
18874           struct gdbarch *gdbarch = get_objfile_arch (objfile);
18875
18876           complaint (_("DW_AT_low_pc %s is zero "
18877                        "for DIE at %s [in module %s]"),
18878                      paddress (gdbarch, lowpc),
18879                      sect_offset_str (sect_off),
18880                      objfile_name (objfile));
18881         }
18882       /* dwarf2_get_pc_bounds has also the strict low < high requirement.  */
18883       else if (lowpc >= highpc)
18884         {
18885           struct objfile *objfile = dwarf2_per_objfile->objfile;
18886           struct gdbarch *gdbarch = get_objfile_arch (objfile);
18887
18888           complaint (_("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
18889                        "for DIE at %s [in module %s]"),
18890                      paddress (gdbarch, lowpc),
18891                      paddress (gdbarch, highpc),
18892                      sect_offset_str (sect_off),
18893                      objfile_name (objfile));
18894         }
18895       else
18896         has_pc_info = 1;
18897     }
18898
18899   return info_ptr;
18900 }
18901
18902 /* Find a cached partial DIE at OFFSET in CU.  */
18903
18904 struct partial_die_info *
18905 dwarf2_cu::find_partial_die (sect_offset sect_off)
18906 {
18907   struct partial_die_info *lookup_die = NULL;
18908   struct partial_die_info part_die (sect_off);
18909
18910   lookup_die = ((struct partial_die_info *)
18911                 htab_find_with_hash (partial_dies, &part_die,
18912                                      to_underlying (sect_off)));
18913
18914   return lookup_die;
18915 }
18916
18917 /* Find a partial DIE at OFFSET, which may or may not be in CU,
18918    except in the case of .debug_types DIEs which do not reference
18919    outside their CU (they do however referencing other types via
18920    DW_FORM_ref_sig8).  */
18921
18922 static struct partial_die_info *
18923 find_partial_die (sect_offset sect_off, int offset_in_dwz, struct dwarf2_cu *cu)
18924 {
18925   struct dwarf2_per_objfile *dwarf2_per_objfile
18926     = cu->per_cu->dwarf2_per_objfile;
18927   struct objfile *objfile = dwarf2_per_objfile->objfile;
18928   struct dwarf2_per_cu_data *per_cu = NULL;
18929   struct partial_die_info *pd = NULL;
18930
18931   if (offset_in_dwz == cu->per_cu->is_dwz
18932       && offset_in_cu_p (&cu->header, sect_off))
18933     {
18934       pd = cu->find_partial_die (sect_off);
18935       if (pd != NULL)
18936         return pd;
18937       /* We missed recording what we needed.
18938          Load all dies and try again.  */
18939       per_cu = cu->per_cu;
18940     }
18941   else
18942     {
18943       /* TUs don't reference other CUs/TUs (except via type signatures).  */
18944       if (cu->per_cu->is_debug_types)
18945         {
18946           error (_("Dwarf Error: Type Unit at offset %s contains"
18947                    " external reference to offset %s [in module %s].\n"),
18948                  sect_offset_str (cu->header.sect_off), sect_offset_str (sect_off),
18949                  bfd_get_filename (objfile->obfd));
18950         }
18951       per_cu = dwarf2_find_containing_comp_unit (sect_off, offset_in_dwz,
18952                                                  dwarf2_per_objfile);
18953
18954       if (per_cu->cu == NULL || per_cu->cu->partial_dies == NULL)
18955         load_partial_comp_unit (per_cu);
18956
18957       per_cu->cu->last_used = 0;
18958       pd = per_cu->cu->find_partial_die (sect_off);
18959     }
18960
18961   /* If we didn't find it, and not all dies have been loaded,
18962      load them all and try again.  */
18963
18964   if (pd == NULL && per_cu->load_all_dies == 0)
18965     {
18966       per_cu->load_all_dies = 1;
18967
18968       /* This is nasty.  When we reread the DIEs, somewhere up the call chain
18969          THIS_CU->cu may already be in use.  So we can't just free it and
18970          replace its DIEs with the ones we read in.  Instead, we leave those
18971          DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
18972          and clobber THIS_CU->cu->partial_dies with the hash table for the new
18973          set.  */
18974       load_partial_comp_unit (per_cu);
18975
18976       pd = per_cu->cu->find_partial_die (sect_off);
18977     }
18978
18979   if (pd == NULL)
18980     internal_error (__FILE__, __LINE__,
18981                     _("could not find partial DIE %s "
18982                       "in cache [from module %s]\n"),
18983                     sect_offset_str (sect_off), bfd_get_filename (objfile->obfd));
18984   return pd;
18985 }
18986
18987 /* See if we can figure out if the class lives in a namespace.  We do
18988    this by looking for a member function; its demangled name will
18989    contain namespace info, if there is any.  */
18990
18991 static void
18992 guess_partial_die_structure_name (struct partial_die_info *struct_pdi,
18993                                   struct dwarf2_cu *cu)
18994 {
18995   /* NOTE: carlton/2003-10-07: Getting the info this way changes
18996      what template types look like, because the demangler
18997      frequently doesn't give the same name as the debug info.  We
18998      could fix this by only using the demangled name to get the
18999      prefix (but see comment in read_structure_type).  */
19000
19001   struct partial_die_info *real_pdi;
19002   struct partial_die_info *child_pdi;
19003
19004   /* If this DIE (this DIE's specification, if any) has a parent, then
19005      we should not do this.  We'll prepend the parent's fully qualified
19006      name when we create the partial symbol.  */
19007
19008   real_pdi = struct_pdi;
19009   while (real_pdi->has_specification)
19010     real_pdi = find_partial_die (real_pdi->spec_offset,
19011                                  real_pdi->spec_is_dwz, cu);
19012
19013   if (real_pdi->die_parent != NULL)
19014     return;
19015
19016   for (child_pdi = struct_pdi->die_child;
19017        child_pdi != NULL;
19018        child_pdi = child_pdi->die_sibling)
19019     {
19020       if (child_pdi->tag == DW_TAG_subprogram
19021           && child_pdi->linkage_name != NULL)
19022         {
19023           char *actual_class_name
19024             = language_class_name_from_physname (cu->language_defn,
19025                                                  child_pdi->linkage_name);
19026           if (actual_class_name != NULL)
19027             {
19028               struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
19029               struct_pdi->name
19030                 = ((const char *)
19031                    obstack_copy0 (&objfile->per_bfd->storage_obstack,
19032                                   actual_class_name,
19033                                   strlen (actual_class_name)));
19034               xfree (actual_class_name);
19035             }
19036           break;
19037         }
19038     }
19039 }
19040
19041 void
19042 partial_die_info::fixup (struct dwarf2_cu *cu)
19043 {
19044   /* Once we've fixed up a die, there's no point in doing so again.
19045      This also avoids a memory leak if we were to call
19046      guess_partial_die_structure_name multiple times.  */
19047   if (fixup_called)
19048     return;
19049
19050   /* If we found a reference attribute and the DIE has no name, try
19051      to find a name in the referred to DIE.  */
19052
19053   if (name == NULL && has_specification)
19054     {
19055       struct partial_die_info *spec_die;
19056
19057       spec_die = find_partial_die (spec_offset, spec_is_dwz, cu);
19058
19059       spec_die->fixup (cu);
19060
19061       if (spec_die->name)
19062         {
19063           name = spec_die->name;
19064
19065           /* Copy DW_AT_external attribute if it is set.  */
19066           if (spec_die->is_external)
19067             is_external = spec_die->is_external;
19068         }
19069     }
19070
19071   /* Set default names for some unnamed DIEs.  */
19072
19073   if (name == NULL && tag == DW_TAG_namespace)
19074     name = CP_ANONYMOUS_NAMESPACE_STR;
19075
19076   /* If there is no parent die to provide a namespace, and there are
19077      children, see if we can determine the namespace from their linkage
19078      name.  */
19079   if (cu->language == language_cplus
19080       && !VEC_empty (dwarf2_section_info_def,
19081                      cu->per_cu->dwarf2_per_objfile->types)
19082       && die_parent == NULL
19083       && has_children
19084       && (tag == DW_TAG_class_type
19085           || tag == DW_TAG_structure_type
19086           || tag == DW_TAG_union_type))
19087     guess_partial_die_structure_name (this, cu);
19088
19089   /* GCC might emit a nameless struct or union that has a linkage
19090      name.  See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510.  */
19091   if (name == NULL
19092       && (tag == DW_TAG_class_type
19093           || tag == DW_TAG_interface_type
19094           || tag == DW_TAG_structure_type
19095           || tag == DW_TAG_union_type)
19096       && linkage_name != NULL)
19097     {
19098       char *demangled;
19099
19100       demangled = gdb_demangle (linkage_name, DMGL_TYPES);
19101       if (demangled)
19102         {
19103           const char *base;
19104
19105           /* Strip any leading namespaces/classes, keep only the base name.
19106              DW_AT_name for named DIEs does not contain the prefixes.  */
19107           base = strrchr (demangled, ':');
19108           if (base && base > demangled && base[-1] == ':')
19109             base++;
19110           else
19111             base = demangled;
19112
19113           struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
19114           name
19115             = ((const char *)
19116                obstack_copy0 (&objfile->per_bfd->storage_obstack,
19117                               base, strlen (base)));
19118           xfree (demangled);
19119         }
19120     }
19121
19122   fixup_called = 1;
19123 }
19124
19125 /* Read an attribute value described by an attribute form.  */
19126
19127 static const gdb_byte *
19128 read_attribute_value (const struct die_reader_specs *reader,
19129                       struct attribute *attr, unsigned form,
19130                       LONGEST implicit_const, const gdb_byte *info_ptr)
19131 {
19132   struct dwarf2_cu *cu = reader->cu;
19133   struct dwarf2_per_objfile *dwarf2_per_objfile
19134     = cu->per_cu->dwarf2_per_objfile;
19135   struct objfile *objfile = dwarf2_per_objfile->objfile;
19136   struct gdbarch *gdbarch = get_objfile_arch (objfile);
19137   bfd *abfd = reader->abfd;
19138   struct comp_unit_head *cu_header = &cu->header;
19139   unsigned int bytes_read;
19140   struct dwarf_block *blk;
19141
19142   attr->form = (enum dwarf_form) form;
19143   switch (form)
19144     {
19145     case DW_FORM_ref_addr:
19146       if (cu->header.version == 2)
19147         DW_UNSND (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
19148       else
19149         DW_UNSND (attr) = read_offset (abfd, info_ptr,
19150                                        &cu->header, &bytes_read);
19151       info_ptr += bytes_read;
19152       break;
19153     case DW_FORM_GNU_ref_alt:
19154       DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
19155       info_ptr += bytes_read;
19156       break;
19157     case DW_FORM_addr:
19158       DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
19159       DW_ADDR (attr) = gdbarch_adjust_dwarf2_addr (gdbarch, DW_ADDR (attr));
19160       info_ptr += bytes_read;
19161       break;
19162     case DW_FORM_block2:
19163       blk = dwarf_alloc_block (cu);
19164       blk->size = read_2_bytes (abfd, info_ptr);
19165       info_ptr += 2;
19166       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19167       info_ptr += blk->size;
19168       DW_BLOCK (attr) = blk;
19169       break;
19170     case DW_FORM_block4:
19171       blk = dwarf_alloc_block (cu);
19172       blk->size = read_4_bytes (abfd, info_ptr);
19173       info_ptr += 4;
19174       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19175       info_ptr += blk->size;
19176       DW_BLOCK (attr) = blk;
19177       break;
19178     case DW_FORM_data2:
19179       DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
19180       info_ptr += 2;
19181       break;
19182     case DW_FORM_data4:
19183       DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
19184       info_ptr += 4;
19185       break;
19186     case DW_FORM_data8:
19187       DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
19188       info_ptr += 8;
19189       break;
19190     case DW_FORM_data16:
19191       blk = dwarf_alloc_block (cu);
19192       blk->size = 16;
19193       blk->data = read_n_bytes (abfd, info_ptr, 16);
19194       info_ptr += 16;
19195       DW_BLOCK (attr) = blk;
19196       break;
19197     case DW_FORM_sec_offset:
19198       DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
19199       info_ptr += bytes_read;
19200       break;
19201     case DW_FORM_string:
19202       DW_STRING (attr) = read_direct_string (abfd, info_ptr, &bytes_read);
19203       DW_STRING_IS_CANONICAL (attr) = 0;
19204       info_ptr += bytes_read;
19205       break;
19206     case DW_FORM_strp:
19207       if (!cu->per_cu->is_dwz)
19208         {
19209           DW_STRING (attr) = read_indirect_string (dwarf2_per_objfile,
19210                                                    abfd, info_ptr, cu_header,
19211                                                    &bytes_read);
19212           DW_STRING_IS_CANONICAL (attr) = 0;
19213           info_ptr += bytes_read;
19214           break;
19215         }
19216       /* FALLTHROUGH */
19217     case DW_FORM_line_strp:
19218       if (!cu->per_cu->is_dwz)
19219         {
19220           DW_STRING (attr) = read_indirect_line_string (dwarf2_per_objfile,
19221                                                         abfd, info_ptr,
19222                                                         cu_header, &bytes_read);
19223           DW_STRING_IS_CANONICAL (attr) = 0;
19224           info_ptr += bytes_read;
19225           break;
19226         }
19227       /* FALLTHROUGH */
19228     case DW_FORM_GNU_strp_alt:
19229       {
19230         struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
19231         LONGEST str_offset = read_offset (abfd, info_ptr, cu_header,
19232                                           &bytes_read);
19233
19234         DW_STRING (attr) = read_indirect_string_from_dwz (objfile,
19235                                                           dwz, str_offset);
19236         DW_STRING_IS_CANONICAL (attr) = 0;
19237         info_ptr += bytes_read;
19238       }
19239       break;
19240     case DW_FORM_exprloc:
19241     case DW_FORM_block:
19242       blk = dwarf_alloc_block (cu);
19243       blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19244       info_ptr += bytes_read;
19245       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19246       info_ptr += blk->size;
19247       DW_BLOCK (attr) = blk;
19248       break;
19249     case DW_FORM_block1:
19250       blk = dwarf_alloc_block (cu);
19251       blk->size = read_1_byte (abfd, info_ptr);
19252       info_ptr += 1;
19253       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19254       info_ptr += blk->size;
19255       DW_BLOCK (attr) = blk;
19256       break;
19257     case DW_FORM_data1:
19258       DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
19259       info_ptr += 1;
19260       break;
19261     case DW_FORM_flag:
19262       DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
19263       info_ptr += 1;
19264       break;
19265     case DW_FORM_flag_present:
19266       DW_UNSND (attr) = 1;
19267       break;
19268     case DW_FORM_sdata:
19269       DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
19270       info_ptr += bytes_read;
19271       break;
19272     case DW_FORM_udata:
19273       DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19274       info_ptr += bytes_read;
19275       break;
19276     case DW_FORM_ref1:
19277       DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19278                          + read_1_byte (abfd, info_ptr));
19279       info_ptr += 1;
19280       break;
19281     case DW_FORM_ref2:
19282       DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19283                          + read_2_bytes (abfd, info_ptr));
19284       info_ptr += 2;
19285       break;
19286     case DW_FORM_ref4:
19287       DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19288                          + read_4_bytes (abfd, info_ptr));
19289       info_ptr += 4;
19290       break;
19291     case DW_FORM_ref8:
19292       DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19293                          + read_8_bytes (abfd, info_ptr));
19294       info_ptr += 8;
19295       break;
19296     case DW_FORM_ref_sig8:
19297       DW_SIGNATURE (attr) = read_8_bytes (abfd, info_ptr);
19298       info_ptr += 8;
19299       break;
19300     case DW_FORM_ref_udata:
19301       DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19302                          + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
19303       info_ptr += bytes_read;
19304       break;
19305     case DW_FORM_indirect:
19306       form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19307       info_ptr += bytes_read;
19308       if (form == DW_FORM_implicit_const)
19309         {
19310           implicit_const = read_signed_leb128 (abfd, info_ptr, &bytes_read);
19311           info_ptr += bytes_read;
19312         }
19313       info_ptr = read_attribute_value (reader, attr, form, implicit_const,
19314                                        info_ptr);
19315       break;
19316     case DW_FORM_implicit_const:
19317       DW_SND (attr) = implicit_const;
19318       break;
19319     case DW_FORM_addrx:
19320     case DW_FORM_GNU_addr_index:
19321       if (reader->dwo_file == NULL)
19322         {
19323           /* For now flag a hard error.
19324              Later we can turn this into a complaint.  */
19325           error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19326                  dwarf_form_name (form),
19327                  bfd_get_filename (abfd));
19328         }
19329       DW_ADDR (attr) = read_addr_index_from_leb128 (cu, info_ptr, &bytes_read);
19330       info_ptr += bytes_read;
19331       break;
19332     case DW_FORM_strx:
19333     case DW_FORM_GNU_str_index:
19334       if (reader->dwo_file == NULL)
19335         {
19336           /* For now flag a hard error.
19337              Later we can turn this into a complaint if warranted.  */
19338           error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19339                  dwarf_form_name (form),
19340                  bfd_get_filename (abfd));
19341         }
19342       {
19343         ULONGEST str_index =
19344           read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19345
19346         DW_STRING (attr) = read_str_index (reader, str_index);
19347         DW_STRING_IS_CANONICAL (attr) = 0;
19348         info_ptr += bytes_read;
19349       }
19350       break;
19351     default:
19352       error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
19353              dwarf_form_name (form),
19354              bfd_get_filename (abfd));
19355     }
19356
19357   /* Super hack.  */
19358   if (cu->per_cu->is_dwz && attr_form_is_ref (attr))
19359     attr->form = DW_FORM_GNU_ref_alt;
19360
19361   /* We have seen instances where the compiler tried to emit a byte
19362      size attribute of -1 which ended up being encoded as an unsigned
19363      0xffffffff.  Although 0xffffffff is technically a valid size value,
19364      an object of this size seems pretty unlikely so we can relatively
19365      safely treat these cases as if the size attribute was invalid and
19366      treat them as zero by default.  */
19367   if (attr->name == DW_AT_byte_size
19368       && form == DW_FORM_data4
19369       && DW_UNSND (attr) >= 0xffffffff)
19370     {
19371       complaint
19372         (_("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
19373          hex_string (DW_UNSND (attr)));
19374       DW_UNSND (attr) = 0;
19375     }
19376
19377   return info_ptr;
19378 }
19379
19380 /* Read an attribute described by an abbreviated attribute.  */
19381
19382 static const gdb_byte *
19383 read_attribute (const struct die_reader_specs *reader,
19384                 struct attribute *attr, struct attr_abbrev *abbrev,
19385                 const gdb_byte *info_ptr)
19386 {
19387   attr->name = abbrev->name;
19388   return read_attribute_value (reader, attr, abbrev->form,
19389                                abbrev->implicit_const, info_ptr);
19390 }
19391
19392 /* Read dwarf information from a buffer.  */
19393
19394 static unsigned int
19395 read_1_byte (bfd *abfd, const gdb_byte *buf)
19396 {
19397   return bfd_get_8 (abfd, buf);
19398 }
19399
19400 static int
19401 read_1_signed_byte (bfd *abfd, const gdb_byte *buf)
19402 {
19403   return bfd_get_signed_8 (abfd, buf);
19404 }
19405
19406 static unsigned int
19407 read_2_bytes (bfd *abfd, const gdb_byte *buf)
19408 {
19409   return bfd_get_16 (abfd, buf);
19410 }
19411
19412 static int
19413 read_2_signed_bytes (bfd *abfd, const gdb_byte *buf)
19414 {
19415   return bfd_get_signed_16 (abfd, buf);
19416 }
19417
19418 static unsigned int
19419 read_4_bytes (bfd *abfd, const gdb_byte *buf)
19420 {
19421   return bfd_get_32 (abfd, buf);
19422 }
19423
19424 static int
19425 read_4_signed_bytes (bfd *abfd, const gdb_byte *buf)
19426 {
19427   return bfd_get_signed_32 (abfd, buf);
19428 }
19429
19430 static ULONGEST
19431 read_8_bytes (bfd *abfd, const gdb_byte *buf)
19432 {
19433   return bfd_get_64 (abfd, buf);
19434 }
19435
19436 static CORE_ADDR
19437 read_address (bfd *abfd, const gdb_byte *buf, struct dwarf2_cu *cu,
19438               unsigned int *bytes_read)
19439 {
19440   struct comp_unit_head *cu_header = &cu->header;
19441   CORE_ADDR retval = 0;
19442
19443   if (cu_header->signed_addr_p)
19444     {
19445       switch (cu_header->addr_size)
19446         {
19447         case 2:
19448           retval = bfd_get_signed_16 (abfd, buf);
19449           break;
19450         case 4:
19451           retval = bfd_get_signed_32 (abfd, buf);
19452           break;
19453         case 8:
19454           retval = bfd_get_signed_64 (abfd, buf);
19455           break;
19456         default:
19457           internal_error (__FILE__, __LINE__,
19458                           _("read_address: bad switch, signed [in module %s]"),
19459                           bfd_get_filename (abfd));
19460         }
19461     }
19462   else
19463     {
19464       switch (cu_header->addr_size)
19465         {
19466         case 2:
19467           retval = bfd_get_16 (abfd, buf);
19468           break;
19469         case 4:
19470           retval = bfd_get_32 (abfd, buf);
19471           break;
19472         case 8:
19473           retval = bfd_get_64 (abfd, buf);
19474           break;
19475         default:
19476           internal_error (__FILE__, __LINE__,
19477                           _("read_address: bad switch, "
19478                             "unsigned [in module %s]"),
19479                           bfd_get_filename (abfd));
19480         }
19481     }
19482
19483   *bytes_read = cu_header->addr_size;
19484   return retval;
19485 }
19486
19487 /* Read the initial length from a section.  The (draft) DWARF 3
19488    specification allows the initial length to take up either 4 bytes
19489    or 12 bytes.  If the first 4 bytes are 0xffffffff, then the next 8
19490    bytes describe the length and all offsets will be 8 bytes in length
19491    instead of 4.
19492
19493    An older, non-standard 64-bit format is also handled by this
19494    function.  The older format in question stores the initial length
19495    as an 8-byte quantity without an escape value.  Lengths greater
19496    than 2^32 aren't very common which means that the initial 4 bytes
19497    is almost always zero.  Since a length value of zero doesn't make
19498    sense for the 32-bit format, this initial zero can be considered to
19499    be an escape value which indicates the presence of the older 64-bit
19500    format.  As written, the code can't detect (old format) lengths
19501    greater than 4GB.  If it becomes necessary to handle lengths
19502    somewhat larger than 4GB, we could allow other small values (such
19503    as the non-sensical values of 1, 2, and 3) to also be used as
19504    escape values indicating the presence of the old format.
19505
19506    The value returned via bytes_read should be used to increment the
19507    relevant pointer after calling read_initial_length().
19508
19509    [ Note:  read_initial_length() and read_offset() are based on the
19510      document entitled "DWARF Debugging Information Format", revision
19511      3, draft 8, dated November 19, 2001.  This document was obtained
19512      from:
19513
19514         http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
19515
19516      This document is only a draft and is subject to change.  (So beware.)
19517
19518      Details regarding the older, non-standard 64-bit format were
19519      determined empirically by examining 64-bit ELF files produced by
19520      the SGI toolchain on an IRIX 6.5 machine.
19521
19522      - Kevin, July 16, 2002
19523    ] */
19524
19525 static LONGEST
19526 read_initial_length (bfd *abfd, const gdb_byte *buf, unsigned int *bytes_read)
19527 {
19528   LONGEST length = bfd_get_32 (abfd, buf);
19529
19530   if (length == 0xffffffff)
19531     {
19532       length = bfd_get_64 (abfd, buf + 4);
19533       *bytes_read = 12;
19534     }
19535   else if (length == 0)
19536     {
19537       /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX.  */
19538       length = bfd_get_64 (abfd, buf);
19539       *bytes_read = 8;
19540     }
19541   else
19542     {
19543       *bytes_read = 4;
19544     }
19545
19546   return length;
19547 }
19548
19549 /* Cover function for read_initial_length.
19550    Returns the length of the object at BUF, and stores the size of the
19551    initial length in *BYTES_READ and stores the size that offsets will be in
19552    *OFFSET_SIZE.
19553    If the initial length size is not equivalent to that specified in
19554    CU_HEADER then issue a complaint.
19555    This is useful when reading non-comp-unit headers.  */
19556
19557 static LONGEST
19558 read_checked_initial_length_and_offset (bfd *abfd, const gdb_byte *buf,
19559                                         const struct comp_unit_head *cu_header,
19560                                         unsigned int *bytes_read,
19561                                         unsigned int *offset_size)
19562 {
19563   LONGEST length = read_initial_length (abfd, buf, bytes_read);
19564
19565   gdb_assert (cu_header->initial_length_size == 4
19566               || cu_header->initial_length_size == 8
19567               || cu_header->initial_length_size == 12);
19568
19569   if (cu_header->initial_length_size != *bytes_read)
19570     complaint (_("intermixed 32-bit and 64-bit DWARF sections"));
19571
19572   *offset_size = (*bytes_read == 4) ? 4 : 8;
19573   return length;
19574 }
19575
19576 /* Read an offset from the data stream.  The size of the offset is
19577    given by cu_header->offset_size.  */
19578
19579 static LONGEST
19580 read_offset (bfd *abfd, const gdb_byte *buf,
19581              const struct comp_unit_head *cu_header,
19582              unsigned int *bytes_read)
19583 {
19584   LONGEST offset = read_offset_1 (abfd, buf, cu_header->offset_size);
19585
19586   *bytes_read = cu_header->offset_size;
19587   return offset;
19588 }
19589
19590 /* Read an offset from the data stream.  */
19591
19592 static LONGEST
19593 read_offset_1 (bfd *abfd, const gdb_byte *buf, unsigned int offset_size)
19594 {
19595   LONGEST retval = 0;
19596
19597   switch (offset_size)
19598     {
19599     case 4:
19600       retval = bfd_get_32 (abfd, buf);
19601       break;
19602     case 8:
19603       retval = bfd_get_64 (abfd, buf);
19604       break;
19605     default:
19606       internal_error (__FILE__, __LINE__,
19607                       _("read_offset_1: bad switch [in module %s]"),
19608                       bfd_get_filename (abfd));
19609     }
19610
19611   return retval;
19612 }
19613
19614 static const gdb_byte *
19615 read_n_bytes (bfd *abfd, const gdb_byte *buf, unsigned int size)
19616 {
19617   /* If the size of a host char is 8 bits, we can return a pointer
19618      to the buffer, otherwise we have to copy the data to a buffer
19619      allocated on the temporary obstack.  */
19620   gdb_assert (HOST_CHAR_BIT == 8);
19621   return buf;
19622 }
19623
19624 static const char *
19625 read_direct_string (bfd *abfd, const gdb_byte *buf,
19626                     unsigned int *bytes_read_ptr)
19627 {
19628   /* If the size of a host char is 8 bits, we can return a pointer
19629      to the string, otherwise we have to copy the string to a buffer
19630      allocated on the temporary obstack.  */
19631   gdb_assert (HOST_CHAR_BIT == 8);
19632   if (*buf == '\0')
19633     {
19634       *bytes_read_ptr = 1;
19635       return NULL;
19636     }
19637   *bytes_read_ptr = strlen ((const char *) buf) + 1;
19638   return (const char *) buf;
19639 }
19640
19641 /* Return pointer to string at section SECT offset STR_OFFSET with error
19642    reporting strings FORM_NAME and SECT_NAME.  */
19643
19644 static const char *
19645 read_indirect_string_at_offset_from (struct objfile *objfile,
19646                                      bfd *abfd, LONGEST str_offset,
19647                                      struct dwarf2_section_info *sect,
19648                                      const char *form_name,
19649                                      const char *sect_name)
19650 {
19651   dwarf2_read_section (objfile, sect);
19652   if (sect->buffer == NULL)
19653     error (_("%s used without %s section [in module %s]"),
19654            form_name, sect_name, bfd_get_filename (abfd));
19655   if (str_offset >= sect->size)
19656     error (_("%s pointing outside of %s section [in module %s]"),
19657            form_name, sect_name, bfd_get_filename (abfd));
19658   gdb_assert (HOST_CHAR_BIT == 8);
19659   if (sect->buffer[str_offset] == '\0')
19660     return NULL;
19661   return (const char *) (sect->buffer + str_offset);
19662 }
19663
19664 /* Return pointer to string at .debug_str offset STR_OFFSET.  */
19665
19666 static const char *
19667 read_indirect_string_at_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
19668                                 bfd *abfd, LONGEST str_offset)
19669 {
19670   return read_indirect_string_at_offset_from (dwarf2_per_objfile->objfile,
19671                                               abfd, str_offset,
19672                                               &dwarf2_per_objfile->str,
19673                                               "DW_FORM_strp", ".debug_str");
19674 }
19675
19676 /* Return pointer to string at .debug_line_str offset STR_OFFSET.  */
19677
19678 static const char *
19679 read_indirect_line_string_at_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
19680                                      bfd *abfd, LONGEST str_offset)
19681 {
19682   return read_indirect_string_at_offset_from (dwarf2_per_objfile->objfile,
19683                                               abfd, str_offset,
19684                                               &dwarf2_per_objfile->line_str,
19685                                               "DW_FORM_line_strp",
19686                                               ".debug_line_str");
19687 }
19688
19689 /* Read a string at offset STR_OFFSET in the .debug_str section from
19690    the .dwz file DWZ.  Throw an error if the offset is too large.  If
19691    the string consists of a single NUL byte, return NULL; otherwise
19692    return a pointer to the string.  */
19693
19694 static const char *
19695 read_indirect_string_from_dwz (struct objfile *objfile, struct dwz_file *dwz,
19696                                LONGEST str_offset)
19697 {
19698   dwarf2_read_section (objfile, &dwz->str);
19699
19700   if (dwz->str.buffer == NULL)
19701     error (_("DW_FORM_GNU_strp_alt used without .debug_str "
19702              "section [in module %s]"),
19703            bfd_get_filename (dwz->dwz_bfd));
19704   if (str_offset >= dwz->str.size)
19705     error (_("DW_FORM_GNU_strp_alt pointing outside of "
19706              ".debug_str section [in module %s]"),
19707            bfd_get_filename (dwz->dwz_bfd));
19708   gdb_assert (HOST_CHAR_BIT == 8);
19709   if (dwz->str.buffer[str_offset] == '\0')
19710     return NULL;
19711   return (const char *) (dwz->str.buffer + str_offset);
19712 }
19713
19714 /* Return pointer to string at .debug_str offset as read from BUF.
19715    BUF is assumed to be in a compilation unit described by CU_HEADER.
19716    Return *BYTES_READ_PTR count of bytes read from BUF.  */
19717
19718 static const char *
19719 read_indirect_string (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *abfd,
19720                       const gdb_byte *buf,
19721                       const struct comp_unit_head *cu_header,
19722                       unsigned int *bytes_read_ptr)
19723 {
19724   LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
19725
19726   return read_indirect_string_at_offset (dwarf2_per_objfile, abfd, str_offset);
19727 }
19728
19729 /* Return pointer to string at .debug_line_str offset as read from BUF.
19730    BUF is assumed to be in a compilation unit described by CU_HEADER.
19731    Return *BYTES_READ_PTR count of bytes read from BUF.  */
19732
19733 static const char *
19734 read_indirect_line_string (struct dwarf2_per_objfile *dwarf2_per_objfile,
19735                            bfd *abfd, const gdb_byte *buf,
19736                            const struct comp_unit_head *cu_header,
19737                            unsigned int *bytes_read_ptr)
19738 {
19739   LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
19740
19741   return read_indirect_line_string_at_offset (dwarf2_per_objfile, abfd,
19742                                               str_offset);
19743 }
19744
19745 ULONGEST
19746 read_unsigned_leb128 (bfd *abfd, const gdb_byte *buf,
19747                           unsigned int *bytes_read_ptr)
19748 {
19749   ULONGEST result;
19750   unsigned int num_read;
19751   int shift;
19752   unsigned char byte;
19753
19754   result = 0;
19755   shift = 0;
19756   num_read = 0;
19757   while (1)
19758     {
19759       byte = bfd_get_8 (abfd, buf);
19760       buf++;
19761       num_read++;
19762       result |= ((ULONGEST) (byte & 127) << shift);
19763       if ((byte & 128) == 0)
19764         {
19765           break;
19766         }
19767       shift += 7;
19768     }
19769   *bytes_read_ptr = num_read;
19770   return result;
19771 }
19772
19773 static LONGEST
19774 read_signed_leb128 (bfd *abfd, const gdb_byte *buf,
19775                     unsigned int *bytes_read_ptr)
19776 {
19777   ULONGEST result;
19778   int shift, num_read;
19779   unsigned char byte;
19780
19781   result = 0;
19782   shift = 0;
19783   num_read = 0;
19784   while (1)
19785     {
19786       byte = bfd_get_8 (abfd, buf);
19787       buf++;
19788       num_read++;
19789       result |= ((ULONGEST) (byte & 127) << shift);
19790       shift += 7;
19791       if ((byte & 128) == 0)
19792         {
19793           break;
19794         }
19795     }
19796   if ((shift < 8 * sizeof (result)) && (byte & 0x40))
19797     result |= -(((ULONGEST) 1) << shift);
19798   *bytes_read_ptr = num_read;
19799   return result;
19800 }
19801
19802 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
19803    ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
19804    ADDR_SIZE is the size of addresses from the CU header.  */
19805
19806 static CORE_ADDR
19807 read_addr_index_1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
19808                    unsigned int addr_index, ULONGEST addr_base, int addr_size)
19809 {
19810   struct objfile *objfile = dwarf2_per_objfile->objfile;
19811   bfd *abfd = objfile->obfd;
19812   const gdb_byte *info_ptr;
19813
19814   dwarf2_read_section (objfile, &dwarf2_per_objfile->addr);
19815   if (dwarf2_per_objfile->addr.buffer == NULL)
19816     error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
19817            objfile_name (objfile));
19818   if (addr_base + addr_index * addr_size >= dwarf2_per_objfile->addr.size)
19819     error (_("DW_FORM_addr_index pointing outside of "
19820              ".debug_addr section [in module %s]"),
19821            objfile_name (objfile));
19822   info_ptr = (dwarf2_per_objfile->addr.buffer
19823               + addr_base + addr_index * addr_size);
19824   if (addr_size == 4)
19825     return bfd_get_32 (abfd, info_ptr);
19826   else
19827     return bfd_get_64 (abfd, info_ptr);
19828 }
19829
19830 /* Given index ADDR_INDEX in .debug_addr, fetch the value.  */
19831
19832 static CORE_ADDR
19833 read_addr_index (struct dwarf2_cu *cu, unsigned int addr_index)
19834 {
19835   return read_addr_index_1 (cu->per_cu->dwarf2_per_objfile, addr_index,
19836                             cu->addr_base, cu->header.addr_size);
19837 }
19838
19839 /* Given a pointer to an leb128 value, fetch the value from .debug_addr.  */
19840
19841 static CORE_ADDR
19842 read_addr_index_from_leb128 (struct dwarf2_cu *cu, const gdb_byte *info_ptr,
19843                              unsigned int *bytes_read)
19844 {
19845   bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
19846   unsigned int addr_index = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
19847
19848   return read_addr_index (cu, addr_index);
19849 }
19850
19851 /* Data structure to pass results from dwarf2_read_addr_index_reader
19852    back to dwarf2_read_addr_index.  */
19853
19854 struct dwarf2_read_addr_index_data
19855 {
19856   ULONGEST addr_base;
19857   int addr_size;
19858 };
19859
19860 /* die_reader_func for dwarf2_read_addr_index.  */
19861
19862 static void
19863 dwarf2_read_addr_index_reader (const struct die_reader_specs *reader,
19864                                const gdb_byte *info_ptr,
19865                                struct die_info *comp_unit_die,
19866                                int has_children,
19867                                void *data)
19868 {
19869   struct dwarf2_cu *cu = reader->cu;
19870   struct dwarf2_read_addr_index_data *aidata =
19871     (struct dwarf2_read_addr_index_data *) data;
19872
19873   aidata->addr_base = cu->addr_base;
19874   aidata->addr_size = cu->header.addr_size;
19875 }
19876
19877 /* Given an index in .debug_addr, fetch the value.
19878    NOTE: This can be called during dwarf expression evaluation,
19879    long after the debug information has been read, and thus per_cu->cu
19880    may no longer exist.  */
19881
19882 CORE_ADDR
19883 dwarf2_read_addr_index (struct dwarf2_per_cu_data *per_cu,
19884                         unsigned int addr_index)
19885 {
19886   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
19887   struct dwarf2_cu *cu = per_cu->cu;
19888   ULONGEST addr_base;
19889   int addr_size;
19890
19891   /* We need addr_base and addr_size.
19892      If we don't have PER_CU->cu, we have to get it.
19893      Nasty, but the alternative is storing the needed info in PER_CU,
19894      which at this point doesn't seem justified: it's not clear how frequently
19895      it would get used and it would increase the size of every PER_CU.
19896      Entry points like dwarf2_per_cu_addr_size do a similar thing
19897      so we're not in uncharted territory here.
19898      Alas we need to be a bit more complicated as addr_base is contained
19899      in the DIE.
19900
19901      We don't need to read the entire CU(/TU).
19902      We just need the header and top level die.
19903
19904      IWBN to use the aging mechanism to let us lazily later discard the CU.
19905      For now we skip this optimization.  */
19906
19907   if (cu != NULL)
19908     {
19909       addr_base = cu->addr_base;
19910       addr_size = cu->header.addr_size;
19911     }
19912   else
19913     {
19914       struct dwarf2_read_addr_index_data aidata;
19915
19916       /* Note: We can't use init_cutu_and_read_dies_simple here,
19917          we need addr_base.  */
19918       init_cutu_and_read_dies (per_cu, NULL, 0, 0, false,
19919                                dwarf2_read_addr_index_reader, &aidata);
19920       addr_base = aidata.addr_base;
19921       addr_size = aidata.addr_size;
19922     }
19923
19924   return read_addr_index_1 (dwarf2_per_objfile, addr_index, addr_base,
19925                             addr_size);
19926 }
19927
19928 /* Given a DW_FORM_GNU_str_index or DW_FORM_strx, fetch the string.
19929    This is only used by the Fission support.  */
19930
19931 static const char *
19932 read_str_index (const struct die_reader_specs *reader, ULONGEST str_index)
19933 {
19934   struct dwarf2_cu *cu = reader->cu;
19935   struct dwarf2_per_objfile *dwarf2_per_objfile
19936     = cu->per_cu->dwarf2_per_objfile;
19937   struct objfile *objfile = dwarf2_per_objfile->objfile;
19938   const char *objf_name = objfile_name (objfile);
19939   bfd *abfd = objfile->obfd;
19940   struct dwarf2_section_info *str_section = &reader->dwo_file->sections.str;
19941   struct dwarf2_section_info *str_offsets_section =
19942     &reader->dwo_file->sections.str_offsets;
19943   const gdb_byte *info_ptr;
19944   ULONGEST str_offset;
19945   static const char form_name[] = "DW_FORM_GNU_str_index or DW_FORM_strx";
19946
19947   dwarf2_read_section (objfile, str_section);
19948   dwarf2_read_section (objfile, str_offsets_section);
19949   if (str_section->buffer == NULL)
19950     error (_("%s used without .debug_str.dwo section"
19951              " in CU at offset %s [in module %s]"),
19952            form_name, sect_offset_str (cu->header.sect_off), objf_name);
19953   if (str_offsets_section->buffer == NULL)
19954     error (_("%s used without .debug_str_offsets.dwo section"
19955              " in CU at offset %s [in module %s]"),
19956            form_name, sect_offset_str (cu->header.sect_off), objf_name);
19957   if (str_index * cu->header.offset_size >= str_offsets_section->size)
19958     error (_("%s pointing outside of .debug_str_offsets.dwo"
19959              " section in CU at offset %s [in module %s]"),
19960            form_name, sect_offset_str (cu->header.sect_off), objf_name);
19961   info_ptr = (str_offsets_section->buffer
19962               + str_index * cu->header.offset_size);
19963   if (cu->header.offset_size == 4)
19964     str_offset = bfd_get_32 (abfd, info_ptr);
19965   else
19966     str_offset = bfd_get_64 (abfd, info_ptr);
19967   if (str_offset >= str_section->size)
19968     error (_("Offset from %s pointing outside of"
19969              " .debug_str.dwo section in CU at offset %s [in module %s]"),
19970            form_name, sect_offset_str (cu->header.sect_off), objf_name);
19971   return (const char *) (str_section->buffer + str_offset);
19972 }
19973
19974 /* Return the length of an LEB128 number in BUF.  */
19975
19976 static int
19977 leb128_size (const gdb_byte *buf)
19978 {
19979   const gdb_byte *begin = buf;
19980   gdb_byte byte;
19981
19982   while (1)
19983     {
19984       byte = *buf++;
19985       if ((byte & 128) == 0)
19986         return buf - begin;
19987     }
19988 }
19989
19990 static void
19991 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
19992 {
19993   switch (lang)
19994     {
19995     case DW_LANG_C89:
19996     case DW_LANG_C99:
19997     case DW_LANG_C11:
19998     case DW_LANG_C:
19999     case DW_LANG_UPC:
20000       cu->language = language_c;
20001       break;
20002     case DW_LANG_Java:
20003     case DW_LANG_C_plus_plus:
20004     case DW_LANG_C_plus_plus_11:
20005     case DW_LANG_C_plus_plus_14:
20006       cu->language = language_cplus;
20007       break;
20008     case DW_LANG_D:
20009       cu->language = language_d;
20010       break;
20011     case DW_LANG_Fortran77:
20012     case DW_LANG_Fortran90:
20013     case DW_LANG_Fortran95:
20014     case DW_LANG_Fortran03:
20015     case DW_LANG_Fortran08:
20016       cu->language = language_fortran;
20017       break;
20018     case DW_LANG_Go:
20019       cu->language = language_go;
20020       break;
20021     case DW_LANG_Mips_Assembler:
20022       cu->language = language_asm;
20023       break;
20024     case DW_LANG_Ada83:
20025     case DW_LANG_Ada95:
20026       cu->language = language_ada;
20027       break;
20028     case DW_LANG_Modula2:
20029       cu->language = language_m2;
20030       break;
20031     case DW_LANG_Pascal83:
20032       cu->language = language_pascal;
20033       break;
20034     case DW_LANG_ObjC:
20035       cu->language = language_objc;
20036       break;
20037     case DW_LANG_Rust:
20038     case DW_LANG_Rust_old:
20039       cu->language = language_rust;
20040       break;
20041     case DW_LANG_Cobol74:
20042     case DW_LANG_Cobol85:
20043     default:
20044       cu->language = language_minimal;
20045       break;
20046     }
20047   cu->language_defn = language_def (cu->language);
20048 }
20049
20050 /* Return the named attribute or NULL if not there.  */
20051
20052 static struct attribute *
20053 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
20054 {
20055   for (;;)
20056     {
20057       unsigned int i;
20058       struct attribute *spec = NULL;
20059
20060       for (i = 0; i < die->num_attrs; ++i)
20061         {
20062           if (die->attrs[i].name == name)
20063             return &die->attrs[i];
20064           if (die->attrs[i].name == DW_AT_specification
20065               || die->attrs[i].name == DW_AT_abstract_origin)
20066             spec = &die->attrs[i];
20067         }
20068
20069       if (!spec)
20070         break;
20071
20072       die = follow_die_ref (die, spec, &cu);
20073     }
20074
20075   return NULL;
20076 }
20077
20078 /* Return the named attribute or NULL if not there,
20079    but do not follow DW_AT_specification, etc.
20080    This is for use in contexts where we're reading .debug_types dies.
20081    Following DW_AT_specification, DW_AT_abstract_origin will take us
20082    back up the chain, and we want to go down.  */
20083
20084 static struct attribute *
20085 dwarf2_attr_no_follow (struct die_info *die, unsigned int name)
20086 {
20087   unsigned int i;
20088
20089   for (i = 0; i < die->num_attrs; ++i)
20090     if (die->attrs[i].name == name)
20091       return &die->attrs[i];
20092
20093   return NULL;
20094 }
20095
20096 /* Return the string associated with a string-typed attribute, or NULL if it
20097    is either not found or is of an incorrect type.  */
20098
20099 static const char *
20100 dwarf2_string_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
20101 {
20102   struct attribute *attr;
20103   const char *str = NULL;
20104
20105   attr = dwarf2_attr (die, name, cu);
20106
20107   if (attr != NULL)
20108     {
20109       if (attr->form == DW_FORM_strp || attr->form == DW_FORM_line_strp
20110           || attr->form == DW_FORM_string
20111           || attr->form == DW_FORM_strx
20112           || attr->form == DW_FORM_GNU_str_index
20113           || attr->form == DW_FORM_GNU_strp_alt)
20114         str = DW_STRING (attr);
20115       else
20116         complaint (_("string type expected for attribute %s for "
20117                      "DIE at %s in module %s"),
20118                    dwarf_attr_name (name), sect_offset_str (die->sect_off),
20119                    objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
20120     }
20121
20122   return str;
20123 }
20124
20125 /* Return non-zero iff the attribute NAME is defined for the given DIE,
20126    and holds a non-zero value.  This function should only be used for
20127    DW_FORM_flag or DW_FORM_flag_present attributes.  */
20128
20129 static int
20130 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
20131 {
20132   struct attribute *attr = dwarf2_attr (die, name, cu);
20133
20134   return (attr && DW_UNSND (attr));
20135 }
20136
20137 static int
20138 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
20139 {
20140   /* A DIE is a declaration if it has a DW_AT_declaration attribute
20141      which value is non-zero.  However, we have to be careful with
20142      DIEs having a DW_AT_specification attribute, because dwarf2_attr()
20143      (via dwarf2_flag_true_p) follows this attribute.  So we may
20144      end up accidently finding a declaration attribute that belongs
20145      to a different DIE referenced by the specification attribute,
20146      even though the given DIE does not have a declaration attribute.  */
20147   return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
20148           && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
20149 }
20150
20151 /* Return the die giving the specification for DIE, if there is
20152    one.  *SPEC_CU is the CU containing DIE on input, and the CU
20153    containing the return value on output.  If there is no
20154    specification, but there is an abstract origin, that is
20155    returned.  */
20156
20157 static struct die_info *
20158 die_specification (struct die_info *die, struct dwarf2_cu **spec_cu)
20159 {
20160   struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification,
20161                                              *spec_cu);
20162
20163   if (spec_attr == NULL)
20164     spec_attr = dwarf2_attr (die, DW_AT_abstract_origin, *spec_cu);
20165
20166   if (spec_attr == NULL)
20167     return NULL;
20168   else
20169     return follow_die_ref (die, spec_attr, spec_cu);
20170 }
20171
20172 /* Stub for free_line_header to match void * callback types.  */
20173
20174 static void
20175 free_line_header_voidp (void *arg)
20176 {
20177   struct line_header *lh = (struct line_header *) arg;
20178
20179   delete lh;
20180 }
20181
20182 void
20183 line_header::add_include_dir (const char *include_dir)
20184 {
20185   if (dwarf_line_debug >= 2)
20186     fprintf_unfiltered (gdb_stdlog, "Adding dir %zu: %s\n",
20187                         include_dirs.size () + 1, include_dir);
20188
20189   include_dirs.push_back (include_dir);
20190 }
20191
20192 void
20193 line_header::add_file_name (const char *name,
20194                             dir_index d_index,
20195                             unsigned int mod_time,
20196                             unsigned int length)
20197 {
20198   if (dwarf_line_debug >= 2)
20199     fprintf_unfiltered (gdb_stdlog, "Adding file %u: %s\n",
20200                         (unsigned) file_names.size () + 1, name);
20201
20202   file_names.emplace_back (name, d_index, mod_time, length);
20203 }
20204
20205 /* A convenience function to find the proper .debug_line section for a CU.  */
20206
20207 static struct dwarf2_section_info *
20208 get_debug_line_section (struct dwarf2_cu *cu)
20209 {
20210   struct dwarf2_section_info *section;
20211   struct dwarf2_per_objfile *dwarf2_per_objfile
20212     = cu->per_cu->dwarf2_per_objfile;
20213
20214   /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
20215      DWO file.  */
20216   if (cu->dwo_unit && cu->per_cu->is_debug_types)
20217     section = &cu->dwo_unit->dwo_file->sections.line;
20218   else if (cu->per_cu->is_dwz)
20219     {
20220       struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
20221
20222       section = &dwz->line;
20223     }
20224   else
20225     section = &dwarf2_per_objfile->line;
20226
20227   return section;
20228 }
20229
20230 /* Read directory or file name entry format, starting with byte of
20231    format count entries, ULEB128 pairs of entry formats, ULEB128 of
20232    entries count and the entries themselves in the described entry
20233    format.  */
20234
20235 static void
20236 read_formatted_entries (struct dwarf2_per_objfile *dwarf2_per_objfile,
20237                         bfd *abfd, const gdb_byte **bufp,
20238                         struct line_header *lh,
20239                         const struct comp_unit_head *cu_header,
20240                         void (*callback) (struct line_header *lh,
20241                                           const char *name,
20242                                           dir_index d_index,
20243                                           unsigned int mod_time,
20244                                           unsigned int length))
20245 {
20246   gdb_byte format_count, formati;
20247   ULONGEST data_count, datai;
20248   const gdb_byte *buf = *bufp;
20249   const gdb_byte *format_header_data;
20250   unsigned int bytes_read;
20251
20252   format_count = read_1_byte (abfd, buf);
20253   buf += 1;
20254   format_header_data = buf;
20255   for (formati = 0; formati < format_count; formati++)
20256     {
20257       read_unsigned_leb128 (abfd, buf, &bytes_read);
20258       buf += bytes_read;
20259       read_unsigned_leb128 (abfd, buf, &bytes_read);
20260       buf += bytes_read;
20261     }
20262
20263   data_count = read_unsigned_leb128 (abfd, buf, &bytes_read);
20264   buf += bytes_read;
20265   for (datai = 0; datai < data_count; datai++)
20266     {
20267       const gdb_byte *format = format_header_data;
20268       struct file_entry fe;
20269
20270       for (formati = 0; formati < format_count; formati++)
20271         {
20272           ULONGEST content_type = read_unsigned_leb128 (abfd, format, &bytes_read);
20273           format += bytes_read;
20274
20275           ULONGEST form  = read_unsigned_leb128 (abfd, format, &bytes_read);
20276           format += bytes_read;
20277
20278           gdb::optional<const char *> string;
20279           gdb::optional<unsigned int> uint;
20280
20281           switch (form)
20282             {
20283             case DW_FORM_string:
20284               string.emplace (read_direct_string (abfd, buf, &bytes_read));
20285               buf += bytes_read;
20286               break;
20287
20288             case DW_FORM_line_strp:
20289               string.emplace (read_indirect_line_string (dwarf2_per_objfile,
20290                                                          abfd, buf,
20291                                                          cu_header,
20292                                                          &bytes_read));
20293               buf += bytes_read;
20294               break;
20295
20296             case DW_FORM_data1:
20297               uint.emplace (read_1_byte (abfd, buf));
20298               buf += 1;
20299               break;
20300
20301             case DW_FORM_data2:
20302               uint.emplace (read_2_bytes (abfd, buf));
20303               buf += 2;
20304               break;
20305
20306             case DW_FORM_data4:
20307               uint.emplace (read_4_bytes (abfd, buf));
20308               buf += 4;
20309               break;
20310
20311             case DW_FORM_data8:
20312               uint.emplace (read_8_bytes (abfd, buf));
20313               buf += 8;
20314               break;
20315
20316             case DW_FORM_udata:
20317               uint.emplace (read_unsigned_leb128 (abfd, buf, &bytes_read));
20318               buf += bytes_read;
20319               break;
20320
20321             case DW_FORM_block:
20322               /* It is valid only for DW_LNCT_timestamp which is ignored by
20323                  current GDB.  */
20324               break;
20325             }
20326
20327           switch (content_type)
20328             {
20329             case DW_LNCT_path:
20330               if (string.has_value ())
20331                 fe.name = *string;
20332               break;
20333             case DW_LNCT_directory_index:
20334               if (uint.has_value ())
20335                 fe.d_index = (dir_index) *uint;
20336               break;
20337             case DW_LNCT_timestamp:
20338               if (uint.has_value ())
20339                 fe.mod_time = *uint;
20340               break;
20341             case DW_LNCT_size:
20342               if (uint.has_value ())
20343                 fe.length = *uint;
20344               break;
20345             case DW_LNCT_MD5:
20346               break;
20347             default:
20348               complaint (_("Unknown format content type %s"),
20349                          pulongest (content_type));
20350             }
20351         }
20352
20353       callback (lh, fe.name, fe.d_index, fe.mod_time, fe.length);
20354     }
20355
20356   *bufp = buf;
20357 }
20358
20359 /* Read the statement program header starting at OFFSET in
20360    .debug_line, or .debug_line.dwo.  Return a pointer
20361    to a struct line_header, allocated using xmalloc.
20362    Returns NULL if there is a problem reading the header, e.g., if it
20363    has a version we don't understand.
20364
20365    NOTE: the strings in the include directory and file name tables of
20366    the returned object point into the dwarf line section buffer,
20367    and must not be freed.  */
20368
20369 static line_header_up
20370 dwarf_decode_line_header (sect_offset sect_off, struct dwarf2_cu *cu)
20371 {
20372   const gdb_byte *line_ptr;
20373   unsigned int bytes_read, offset_size;
20374   int i;
20375   const char *cur_dir, *cur_file;
20376   struct dwarf2_section_info *section;
20377   bfd *abfd;
20378   struct dwarf2_per_objfile *dwarf2_per_objfile
20379     = cu->per_cu->dwarf2_per_objfile;
20380
20381   section = get_debug_line_section (cu);
20382   dwarf2_read_section (dwarf2_per_objfile->objfile, section);
20383   if (section->buffer == NULL)
20384     {
20385       if (cu->dwo_unit && cu->per_cu->is_debug_types)
20386         complaint (_("missing .debug_line.dwo section"));
20387       else
20388         complaint (_("missing .debug_line section"));
20389       return 0;
20390     }
20391
20392   /* We can't do this until we know the section is non-empty.
20393      Only then do we know we have such a section.  */
20394   abfd = get_section_bfd_owner (section);
20395
20396   /* Make sure that at least there's room for the total_length field.
20397      That could be 12 bytes long, but we're just going to fudge that.  */
20398   if (to_underlying (sect_off) + 4 >= section->size)
20399     {
20400       dwarf2_statement_list_fits_in_line_number_section_complaint ();
20401       return 0;
20402     }
20403
20404   line_header_up lh (new line_header ());
20405
20406   lh->sect_off = sect_off;
20407   lh->offset_in_dwz = cu->per_cu->is_dwz;
20408
20409   line_ptr = section->buffer + to_underlying (sect_off);
20410
20411   /* Read in the header.  */
20412   lh->total_length =
20413     read_checked_initial_length_and_offset (abfd, line_ptr, &cu->header,
20414                                             &bytes_read, &offset_size);
20415   line_ptr += bytes_read;
20416   if (line_ptr + lh->total_length > (section->buffer + section->size))
20417     {
20418       dwarf2_statement_list_fits_in_line_number_section_complaint ();
20419       return 0;
20420     }
20421   lh->statement_program_end = line_ptr + lh->total_length;
20422   lh->version = read_2_bytes (abfd, line_ptr);
20423   line_ptr += 2;
20424   if (lh->version > 5)
20425     {
20426       /* This is a version we don't understand.  The format could have
20427          changed in ways we don't handle properly so just punt.  */
20428       complaint (_("unsupported version in .debug_line section"));
20429       return NULL;
20430     }
20431   if (lh->version >= 5)
20432     {
20433       gdb_byte segment_selector_size;
20434
20435       /* Skip address size.  */
20436       read_1_byte (abfd, line_ptr);
20437       line_ptr += 1;
20438
20439       segment_selector_size = read_1_byte (abfd, line_ptr);
20440       line_ptr += 1;
20441       if (segment_selector_size != 0)
20442         {
20443           complaint (_("unsupported segment selector size %u "
20444                        "in .debug_line section"),
20445                      segment_selector_size);
20446           return NULL;
20447         }
20448     }
20449   lh->header_length = read_offset_1 (abfd, line_ptr, offset_size);
20450   line_ptr += offset_size;
20451   lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
20452   line_ptr += 1;
20453   if (lh->version >= 4)
20454     {
20455       lh->maximum_ops_per_instruction = read_1_byte (abfd, line_ptr);
20456       line_ptr += 1;
20457     }
20458   else
20459     lh->maximum_ops_per_instruction = 1;
20460
20461   if (lh->maximum_ops_per_instruction == 0)
20462     {
20463       lh->maximum_ops_per_instruction = 1;
20464       complaint (_("invalid maximum_ops_per_instruction "
20465                    "in `.debug_line' section"));
20466     }
20467
20468   lh->default_is_stmt = read_1_byte (abfd, line_ptr);
20469   line_ptr += 1;
20470   lh->line_base = read_1_signed_byte (abfd, line_ptr);
20471   line_ptr += 1;
20472   lh->line_range = read_1_byte (abfd, line_ptr);
20473   line_ptr += 1;
20474   lh->opcode_base = read_1_byte (abfd, line_ptr);
20475   line_ptr += 1;
20476   lh->standard_opcode_lengths.reset (new unsigned char[lh->opcode_base]);
20477
20478   lh->standard_opcode_lengths[0] = 1;  /* This should never be used anyway.  */
20479   for (i = 1; i < lh->opcode_base; ++i)
20480     {
20481       lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
20482       line_ptr += 1;
20483     }
20484
20485   if (lh->version >= 5)
20486     {
20487       /* Read directory table.  */
20488       read_formatted_entries (dwarf2_per_objfile, abfd, &line_ptr, lh.get (),
20489                               &cu->header,
20490                               [] (struct line_header *header, const char *name,
20491                                   dir_index d_index, unsigned int mod_time,
20492                                   unsigned int length)
20493         {
20494           header->add_include_dir (name);
20495         });
20496
20497       /* Read file name table.  */
20498       read_formatted_entries (dwarf2_per_objfile, abfd, &line_ptr, lh.get (),
20499                               &cu->header,
20500                               [] (struct line_header *header, const char *name,
20501                                   dir_index d_index, unsigned int mod_time,
20502                                   unsigned int length)
20503         {
20504           header->add_file_name (name, d_index, mod_time, length);
20505         });
20506     }
20507   else
20508     {
20509       /* Read directory table.  */
20510       while ((cur_dir = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
20511         {
20512           line_ptr += bytes_read;
20513           lh->add_include_dir (cur_dir);
20514         }
20515       line_ptr += bytes_read;
20516
20517       /* Read file name table.  */
20518       while ((cur_file = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
20519         {
20520           unsigned int mod_time, length;
20521           dir_index d_index;
20522
20523           line_ptr += bytes_read;
20524           d_index = (dir_index) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20525           line_ptr += bytes_read;
20526           mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20527           line_ptr += bytes_read;
20528           length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20529           line_ptr += bytes_read;
20530
20531           lh->add_file_name (cur_file, d_index, mod_time, length);
20532         }
20533       line_ptr += bytes_read;
20534     }
20535   lh->statement_program_start = line_ptr;
20536
20537   if (line_ptr > (section->buffer + section->size))
20538     complaint (_("line number info header doesn't "
20539                  "fit in `.debug_line' section"));
20540
20541   return lh;
20542 }
20543
20544 /* Subroutine of dwarf_decode_lines to simplify it.
20545    Return the file name of the psymtab for included file FILE_INDEX
20546    in line header LH of PST.
20547    COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
20548    If space for the result is malloc'd, *NAME_HOLDER will be set.
20549    Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename.  */
20550
20551 static const char *
20552 psymtab_include_file_name (const struct line_header *lh, int file_index,
20553                            const struct partial_symtab *pst,
20554                            const char *comp_dir,
20555                            gdb::unique_xmalloc_ptr<char> *name_holder)
20556 {
20557   const file_entry &fe = lh->file_names[file_index];
20558   const char *include_name = fe.name;
20559   const char *include_name_to_compare = include_name;
20560   const char *pst_filename;
20561   int file_is_pst;
20562
20563   const char *dir_name = fe.include_dir (lh);
20564
20565   gdb::unique_xmalloc_ptr<char> hold_compare;
20566   if (!IS_ABSOLUTE_PATH (include_name)
20567       && (dir_name != NULL || comp_dir != NULL))
20568     {
20569       /* Avoid creating a duplicate psymtab for PST.
20570          We do this by comparing INCLUDE_NAME and PST_FILENAME.
20571          Before we do the comparison, however, we need to account
20572          for DIR_NAME and COMP_DIR.
20573          First prepend dir_name (if non-NULL).  If we still don't
20574          have an absolute path prepend comp_dir (if non-NULL).
20575          However, the directory we record in the include-file's
20576          psymtab does not contain COMP_DIR (to match the
20577          corresponding symtab(s)).
20578
20579          Example:
20580
20581          bash$ cd /tmp
20582          bash$ gcc -g ./hello.c
20583          include_name = "hello.c"
20584          dir_name = "."
20585          DW_AT_comp_dir = comp_dir = "/tmp"
20586          DW_AT_name = "./hello.c"
20587
20588       */
20589
20590       if (dir_name != NULL)
20591         {
20592           name_holder->reset (concat (dir_name, SLASH_STRING,
20593                                       include_name, (char *) NULL));
20594           include_name = name_holder->get ();
20595           include_name_to_compare = include_name;
20596         }
20597       if (!IS_ABSOLUTE_PATH (include_name) && comp_dir != NULL)
20598         {
20599           hold_compare.reset (concat (comp_dir, SLASH_STRING,
20600                                       include_name, (char *) NULL));
20601           include_name_to_compare = hold_compare.get ();
20602         }
20603     }
20604
20605   pst_filename = pst->filename;
20606   gdb::unique_xmalloc_ptr<char> copied_name;
20607   if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
20608     {
20609       copied_name.reset (concat (pst->dirname, SLASH_STRING,
20610                                  pst_filename, (char *) NULL));
20611       pst_filename = copied_name.get ();
20612     }
20613
20614   file_is_pst = FILENAME_CMP (include_name_to_compare, pst_filename) == 0;
20615
20616   if (file_is_pst)
20617     return NULL;
20618   return include_name;
20619 }
20620
20621 /* State machine to track the state of the line number program.  */
20622
20623 class lnp_state_machine
20624 {
20625 public:
20626   /* Initialize a machine state for the start of a line number
20627      program.  */
20628   lnp_state_machine (struct dwarf2_cu *cu, gdbarch *arch, line_header *lh,
20629                      bool record_lines_p);
20630
20631   file_entry *current_file ()
20632   {
20633     /* lh->file_names is 0-based, but the file name numbers in the
20634        statement program are 1-based.  */
20635     return m_line_header->file_name_at (m_file);
20636   }
20637
20638   /* Record the line in the state machine.  END_SEQUENCE is true if
20639      we're processing the end of a sequence.  */
20640   void record_line (bool end_sequence);
20641
20642   /* Check ADDRESS is zero and less than UNRELOCATED_LOWPC and if true
20643      nop-out rest of the lines in this sequence.  */
20644   void check_line_address (struct dwarf2_cu *cu,
20645                            const gdb_byte *line_ptr,
20646                            CORE_ADDR unrelocated_lowpc, CORE_ADDR address);
20647
20648   void handle_set_discriminator (unsigned int discriminator)
20649   {
20650     m_discriminator = discriminator;
20651     m_line_has_non_zero_discriminator |= discriminator != 0;
20652   }
20653
20654   /* Handle DW_LNE_set_address.  */
20655   void handle_set_address (CORE_ADDR baseaddr, CORE_ADDR address)
20656   {
20657     m_op_index = 0;
20658     address += baseaddr;
20659     m_address = gdbarch_adjust_dwarf2_line (m_gdbarch, address, false);
20660   }
20661
20662   /* Handle DW_LNS_advance_pc.  */
20663   void handle_advance_pc (CORE_ADDR adjust);
20664
20665   /* Handle a special opcode.  */
20666   void handle_special_opcode (unsigned char op_code);
20667
20668   /* Handle DW_LNS_advance_line.  */
20669   void handle_advance_line (int line_delta)
20670   {
20671     advance_line (line_delta);
20672   }
20673
20674   /* Handle DW_LNS_set_file.  */
20675   void handle_set_file (file_name_index file);
20676
20677   /* Handle DW_LNS_negate_stmt.  */
20678   void handle_negate_stmt ()
20679   {
20680     m_is_stmt = !m_is_stmt;
20681   }
20682
20683   /* Handle DW_LNS_const_add_pc.  */
20684   void handle_const_add_pc ();
20685
20686   /* Handle DW_LNS_fixed_advance_pc.  */
20687   void handle_fixed_advance_pc (CORE_ADDR addr_adj)
20688   {
20689     m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20690     m_op_index = 0;
20691   }
20692
20693   /* Handle DW_LNS_copy.  */
20694   void handle_copy ()
20695   {
20696     record_line (false);
20697     m_discriminator = 0;
20698   }
20699
20700   /* Handle DW_LNE_end_sequence.  */
20701   void handle_end_sequence ()
20702   {
20703     m_currently_recording_lines = true;
20704   }
20705
20706 private:
20707   /* Advance the line by LINE_DELTA.  */
20708   void advance_line (int line_delta)
20709   {
20710     m_line += line_delta;
20711
20712     if (line_delta != 0)
20713       m_line_has_non_zero_discriminator = m_discriminator != 0;
20714   }
20715
20716   struct dwarf2_cu *m_cu;
20717
20718   gdbarch *m_gdbarch;
20719
20720   /* True if we're recording lines.
20721      Otherwise we're building partial symtabs and are just interested in
20722      finding include files mentioned by the line number program.  */
20723   bool m_record_lines_p;
20724
20725   /* The line number header.  */
20726   line_header *m_line_header;
20727
20728   /* These are part of the standard DWARF line number state machine,
20729      and initialized according to the DWARF spec.  */
20730
20731   unsigned char m_op_index = 0;
20732   /* The line table index (1-based) of the current file.  */
20733   file_name_index m_file = (file_name_index) 1;
20734   unsigned int m_line = 1;
20735
20736   /* These are initialized in the constructor.  */
20737
20738   CORE_ADDR m_address;
20739   bool m_is_stmt;
20740   unsigned int m_discriminator;
20741
20742   /* Additional bits of state we need to track.  */
20743
20744   /* The last file that we called dwarf2_start_subfile for.
20745      This is only used for TLLs.  */
20746   unsigned int m_last_file = 0;
20747   /* The last file a line number was recorded for.  */
20748   struct subfile *m_last_subfile = NULL;
20749
20750   /* When true, record the lines we decode.  */
20751   bool m_currently_recording_lines = false;
20752
20753   /* The last line number that was recorded, used to coalesce
20754      consecutive entries for the same line.  This can happen, for
20755      example, when discriminators are present.  PR 17276.  */
20756   unsigned int m_last_line = 0;
20757   bool m_line_has_non_zero_discriminator = false;
20758 };
20759
20760 void
20761 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust)
20762 {
20763   CORE_ADDR addr_adj = (((m_op_index + adjust)
20764                          / m_line_header->maximum_ops_per_instruction)
20765                         * m_line_header->minimum_instruction_length);
20766   m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20767   m_op_index = ((m_op_index + adjust)
20768                 % m_line_header->maximum_ops_per_instruction);
20769 }
20770
20771 void
20772 lnp_state_machine::handle_special_opcode (unsigned char op_code)
20773 {
20774   unsigned char adj_opcode = op_code - m_line_header->opcode_base;
20775   CORE_ADDR addr_adj = (((m_op_index
20776                           + (adj_opcode / m_line_header->line_range))
20777                          / m_line_header->maximum_ops_per_instruction)
20778                         * m_line_header->minimum_instruction_length);
20779   m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20780   m_op_index = ((m_op_index + (adj_opcode / m_line_header->line_range))
20781                 % m_line_header->maximum_ops_per_instruction);
20782
20783   int line_delta = (m_line_header->line_base
20784                     + (adj_opcode % m_line_header->line_range));
20785   advance_line (line_delta);
20786   record_line (false);
20787   m_discriminator = 0;
20788 }
20789
20790 void
20791 lnp_state_machine::handle_set_file (file_name_index file)
20792 {
20793   m_file = file;
20794
20795   const file_entry *fe = current_file ();
20796   if (fe == NULL)
20797     dwarf2_debug_line_missing_file_complaint ();
20798   else if (m_record_lines_p)
20799     {
20800       const char *dir = fe->include_dir (m_line_header);
20801
20802       m_last_subfile = m_cu->get_builder ()->get_current_subfile ();
20803       m_line_has_non_zero_discriminator = m_discriminator != 0;
20804       dwarf2_start_subfile (m_cu, fe->name, dir);
20805     }
20806 }
20807
20808 void
20809 lnp_state_machine::handle_const_add_pc ()
20810 {
20811   CORE_ADDR adjust
20812     = (255 - m_line_header->opcode_base) / m_line_header->line_range;
20813
20814   CORE_ADDR addr_adj
20815     = (((m_op_index + adjust)
20816         / m_line_header->maximum_ops_per_instruction)
20817        * m_line_header->minimum_instruction_length);
20818
20819   m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20820   m_op_index = ((m_op_index + adjust)
20821                 % m_line_header->maximum_ops_per_instruction);
20822 }
20823
20824 /* Return non-zero if we should add LINE to the line number table.
20825    LINE is the line to add, LAST_LINE is the last line that was added,
20826    LAST_SUBFILE is the subfile for LAST_LINE.
20827    LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
20828    had a non-zero discriminator.
20829
20830    We have to be careful in the presence of discriminators.
20831    E.g., for this line:
20832
20833      for (i = 0; i < 100000; i++);
20834
20835    clang can emit four line number entries for that one line,
20836    each with a different discriminator.
20837    See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
20838
20839    However, we want gdb to coalesce all four entries into one.
20840    Otherwise the user could stepi into the middle of the line and
20841    gdb would get confused about whether the pc really was in the
20842    middle of the line.
20843
20844    Things are further complicated by the fact that two consecutive
20845    line number entries for the same line is a heuristic used by gcc
20846    to denote the end of the prologue.  So we can't just discard duplicate
20847    entries, we have to be selective about it.  The heuristic we use is
20848    that we only collapse consecutive entries for the same line if at least
20849    one of those entries has a non-zero discriminator.  PR 17276.
20850
20851    Note: Addresses in the line number state machine can never go backwards
20852    within one sequence, thus this coalescing is ok.  */
20853
20854 static int
20855 dwarf_record_line_p (struct dwarf2_cu *cu,
20856                      unsigned int line, unsigned int last_line,
20857                      int line_has_non_zero_discriminator,
20858                      struct subfile *last_subfile)
20859 {
20860   if (cu->get_builder ()->get_current_subfile () != last_subfile)
20861     return 1;
20862   if (line != last_line)
20863     return 1;
20864   /* Same line for the same file that we've seen already.
20865      As a last check, for pr 17276, only record the line if the line
20866      has never had a non-zero discriminator.  */
20867   if (!line_has_non_zero_discriminator)
20868     return 1;
20869   return 0;
20870 }
20871
20872 /* Use the CU's builder to record line number LINE beginning at
20873    address ADDRESS in the line table of subfile SUBFILE.  */
20874
20875 static void
20876 dwarf_record_line_1 (struct gdbarch *gdbarch, struct subfile *subfile,
20877                      unsigned int line, CORE_ADDR address,
20878                      struct dwarf2_cu *cu)
20879 {
20880   CORE_ADDR addr = gdbarch_addr_bits_remove (gdbarch, address);
20881
20882   if (dwarf_line_debug)
20883     {
20884       fprintf_unfiltered (gdb_stdlog,
20885                           "Recording line %u, file %s, address %s\n",
20886                           line, lbasename (subfile->name),
20887                           paddress (gdbarch, address));
20888     }
20889
20890   if (cu != nullptr)
20891     cu->get_builder ()->record_line (subfile, line, addr);
20892 }
20893
20894 /* Subroutine of dwarf_decode_lines_1 to simplify it.
20895    Mark the end of a set of line number records.
20896    The arguments are the same as for dwarf_record_line_1.
20897    If SUBFILE is NULL the request is ignored.  */
20898
20899 static void
20900 dwarf_finish_line (struct gdbarch *gdbarch, struct subfile *subfile,
20901                    CORE_ADDR address, struct dwarf2_cu *cu)
20902 {
20903   if (subfile == NULL)
20904     return;
20905
20906   if (dwarf_line_debug)
20907     {
20908       fprintf_unfiltered (gdb_stdlog,
20909                           "Finishing current line, file %s, address %s\n",
20910                           lbasename (subfile->name),
20911                           paddress (gdbarch, address));
20912     }
20913
20914   dwarf_record_line_1 (gdbarch, subfile, 0, address, cu);
20915 }
20916
20917 void
20918 lnp_state_machine::record_line (bool end_sequence)
20919 {
20920   if (dwarf_line_debug)
20921     {
20922       fprintf_unfiltered (gdb_stdlog,
20923                           "Processing actual line %u: file %u,"
20924                           " address %s, is_stmt %u, discrim %u\n",
20925                           m_line, to_underlying (m_file),
20926                           paddress (m_gdbarch, m_address),
20927                           m_is_stmt, m_discriminator);
20928     }
20929
20930   file_entry *fe = current_file ();
20931
20932   if (fe == NULL)
20933     dwarf2_debug_line_missing_file_complaint ();
20934   /* For now we ignore lines not starting on an instruction boundary.
20935      But not when processing end_sequence for compatibility with the
20936      previous version of the code.  */
20937   else if (m_op_index == 0 || end_sequence)
20938     {
20939       fe->included_p = 1;
20940       if (m_record_lines_p && (producer_is_codewarrior (m_cu) || m_is_stmt))
20941         {
20942           if (m_last_subfile != m_cu->get_builder ()->get_current_subfile ()
20943               || end_sequence)
20944             {
20945               dwarf_finish_line (m_gdbarch, m_last_subfile, m_address,
20946                                  m_currently_recording_lines ? m_cu : nullptr);
20947             }
20948
20949           if (!end_sequence)
20950             {
20951               if (dwarf_record_line_p (m_cu, m_line, m_last_line,
20952                                        m_line_has_non_zero_discriminator,
20953                                        m_last_subfile))
20954                 {
20955                   buildsym_compunit *builder = m_cu->get_builder ();
20956                   dwarf_record_line_1 (m_gdbarch,
20957                                        builder->get_current_subfile (),
20958                                        m_line, m_address,
20959                                        m_currently_recording_lines ? m_cu : nullptr);
20960                 }
20961               m_last_subfile = m_cu->get_builder ()->get_current_subfile ();
20962               m_last_line = m_line;
20963             }
20964         }
20965     }
20966 }
20967
20968 lnp_state_machine::lnp_state_machine (struct dwarf2_cu *cu, gdbarch *arch,
20969                                       line_header *lh, bool record_lines_p)
20970 {
20971   m_cu = cu;
20972   m_gdbarch = arch;
20973   m_record_lines_p = record_lines_p;
20974   m_line_header = lh;
20975
20976   m_currently_recording_lines = true;
20977
20978   /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
20979      was a line entry for it so that the backend has a chance to adjust it
20980      and also record it in case it needs it.  This is currently used by MIPS
20981      code, cf. `mips_adjust_dwarf2_line'.  */
20982   m_address = gdbarch_adjust_dwarf2_line (arch, 0, 0);
20983   m_is_stmt = lh->default_is_stmt;
20984   m_discriminator = 0;
20985 }
20986
20987 void
20988 lnp_state_machine::check_line_address (struct dwarf2_cu *cu,
20989                                        const gdb_byte *line_ptr,
20990                                        CORE_ADDR unrelocated_lowpc, CORE_ADDR address)
20991 {
20992   /* If ADDRESS < UNRELOCATED_LOWPC then it's not a usable value, it's outside
20993      the pc range of the CU.  However, we restrict the test to only ADDRESS
20994      values of zero to preserve GDB's previous behaviour which is to handle
20995      the specific case of a function being GC'd by the linker.  */
20996
20997   if (address == 0 && address < unrelocated_lowpc)
20998     {
20999       /* This line table is for a function which has been
21000          GCd by the linker.  Ignore it.  PR gdb/12528 */
21001
21002       struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21003       long line_offset = line_ptr - get_debug_line_section (cu)->buffer;
21004
21005       complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
21006                  line_offset, objfile_name (objfile));
21007       m_currently_recording_lines = false;
21008       /* Note: m_currently_recording_lines is left as false until we see
21009          DW_LNE_end_sequence.  */
21010     }
21011 }
21012
21013 /* Subroutine of dwarf_decode_lines to simplify it.
21014    Process the line number information in LH.
21015    If DECODE_FOR_PST_P is non-zero, all we do is process the line number
21016    program in order to set included_p for every referenced header.  */
21017
21018 static void
21019 dwarf_decode_lines_1 (struct line_header *lh, struct dwarf2_cu *cu,
21020                       const int decode_for_pst_p, CORE_ADDR lowpc)
21021 {
21022   const gdb_byte *line_ptr, *extended_end;
21023   const gdb_byte *line_end;
21024   unsigned int bytes_read, extended_len;
21025   unsigned char op_code, extended_op;
21026   CORE_ADDR baseaddr;
21027   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21028   bfd *abfd = objfile->obfd;
21029   struct gdbarch *gdbarch = get_objfile_arch (objfile);
21030   /* True if we're recording line info (as opposed to building partial
21031      symtabs and just interested in finding include files mentioned by
21032      the line number program).  */
21033   bool record_lines_p = !decode_for_pst_p;
21034
21035   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
21036
21037   line_ptr = lh->statement_program_start;
21038   line_end = lh->statement_program_end;
21039
21040   /* Read the statement sequences until there's nothing left.  */
21041   while (line_ptr < line_end)
21042     {
21043       /* The DWARF line number program state machine.  Reset the state
21044          machine at the start of each sequence.  */
21045       lnp_state_machine state_machine (cu, gdbarch, lh, record_lines_p);
21046       bool end_sequence = false;
21047
21048       if (record_lines_p)
21049         {
21050           /* Start a subfile for the current file of the state
21051              machine.  */
21052           const file_entry *fe = state_machine.current_file ();
21053
21054           if (fe != NULL)
21055             dwarf2_start_subfile (cu, fe->name, fe->include_dir (lh));
21056         }
21057
21058       /* Decode the table.  */
21059       while (line_ptr < line_end && !end_sequence)
21060         {
21061           op_code = read_1_byte (abfd, line_ptr);
21062           line_ptr += 1;
21063
21064           if (op_code >= lh->opcode_base)
21065             {
21066               /* Special opcode.  */
21067               state_machine.handle_special_opcode (op_code);
21068             }
21069           else switch (op_code)
21070             {
21071             case DW_LNS_extended_op:
21072               extended_len = read_unsigned_leb128 (abfd, line_ptr,
21073                                                    &bytes_read);
21074               line_ptr += bytes_read;
21075               extended_end = line_ptr + extended_len;
21076               extended_op = read_1_byte (abfd, line_ptr);
21077               line_ptr += 1;
21078               switch (extended_op)
21079                 {
21080                 case DW_LNE_end_sequence:
21081                   state_machine.handle_end_sequence ();
21082                   end_sequence = true;
21083                   break;
21084                 case DW_LNE_set_address:
21085                   {
21086                     CORE_ADDR address
21087                       = read_address (abfd, line_ptr, cu, &bytes_read);
21088                     line_ptr += bytes_read;
21089
21090                     state_machine.check_line_address (cu, line_ptr,
21091                                                       lowpc - baseaddr, address);
21092                     state_machine.handle_set_address (baseaddr, address);
21093                   }
21094                   break;
21095                 case DW_LNE_define_file:
21096                   {
21097                     const char *cur_file;
21098                     unsigned int mod_time, length;
21099                     dir_index dindex;
21100
21101                     cur_file = read_direct_string (abfd, line_ptr,
21102                                                    &bytes_read);
21103                     line_ptr += bytes_read;
21104                     dindex = (dir_index)
21105                       read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21106                     line_ptr += bytes_read;
21107                     mod_time =
21108                       read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21109                     line_ptr += bytes_read;
21110                     length =
21111                       read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21112                     line_ptr += bytes_read;
21113                     lh->add_file_name (cur_file, dindex, mod_time, length);
21114                   }
21115                   break;
21116                 case DW_LNE_set_discriminator:
21117                   {
21118                     /* The discriminator is not interesting to the
21119                        debugger; just ignore it.  We still need to
21120                        check its value though:
21121                        if there are consecutive entries for the same
21122                        (non-prologue) line we want to coalesce them.
21123                        PR 17276.  */
21124                     unsigned int discr
21125                       = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21126                     line_ptr += bytes_read;
21127
21128                     state_machine.handle_set_discriminator (discr);
21129                   }
21130                   break;
21131                 default:
21132                   complaint (_("mangled .debug_line section"));
21133                   return;
21134                 }
21135               /* Make sure that we parsed the extended op correctly.  If e.g.
21136                  we expected a different address size than the producer used,
21137                  we may have read the wrong number of bytes.  */
21138               if (line_ptr != extended_end)
21139                 {
21140                   complaint (_("mangled .debug_line section"));
21141                   return;
21142                 }
21143               break;
21144             case DW_LNS_copy:
21145               state_machine.handle_copy ();
21146               break;
21147             case DW_LNS_advance_pc:
21148               {
21149                 CORE_ADDR adjust
21150                   = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21151                 line_ptr += bytes_read;
21152
21153                 state_machine.handle_advance_pc (adjust);
21154               }
21155               break;
21156             case DW_LNS_advance_line:
21157               {
21158                 int line_delta
21159                   = read_signed_leb128 (abfd, line_ptr, &bytes_read);
21160                 line_ptr += bytes_read;
21161
21162                 state_machine.handle_advance_line (line_delta);
21163               }
21164               break;
21165             case DW_LNS_set_file:
21166               {
21167                 file_name_index file
21168                   = (file_name_index) read_unsigned_leb128 (abfd, line_ptr,
21169                                                             &bytes_read);
21170                 line_ptr += bytes_read;
21171
21172                 state_machine.handle_set_file (file);
21173               }
21174               break;
21175             case DW_LNS_set_column:
21176               (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21177               line_ptr += bytes_read;
21178               break;
21179             case DW_LNS_negate_stmt:
21180               state_machine.handle_negate_stmt ();
21181               break;
21182             case DW_LNS_set_basic_block:
21183               break;
21184             /* Add to the address register of the state machine the
21185                address increment value corresponding to special opcode
21186                255.  I.e., this value is scaled by the minimum
21187                instruction length since special opcode 255 would have
21188                scaled the increment.  */
21189             case DW_LNS_const_add_pc:
21190               state_machine.handle_const_add_pc ();
21191               break;
21192             case DW_LNS_fixed_advance_pc:
21193               {
21194                 CORE_ADDR addr_adj = read_2_bytes (abfd, line_ptr);
21195                 line_ptr += 2;
21196
21197                 state_machine.handle_fixed_advance_pc (addr_adj);
21198               }
21199               break;
21200             default:
21201               {
21202                 /* Unknown standard opcode, ignore it.  */
21203                 int i;
21204
21205                 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
21206                   {
21207                     (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21208                     line_ptr += bytes_read;
21209                   }
21210               }
21211             }
21212         }
21213
21214       if (!end_sequence)
21215         dwarf2_debug_line_missing_end_sequence_complaint ();
21216
21217       /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
21218          in which case we still finish recording the last line).  */
21219       state_machine.record_line (true);
21220     }
21221 }
21222
21223 /* Decode the Line Number Program (LNP) for the given line_header
21224    structure and CU.  The actual information extracted and the type
21225    of structures created from the LNP depends on the value of PST.
21226
21227    1. If PST is NULL, then this procedure uses the data from the program
21228       to create all necessary symbol tables, and their linetables.
21229
21230    2. If PST is not NULL, this procedure reads the program to determine
21231       the list of files included by the unit represented by PST, and
21232       builds all the associated partial symbol tables.
21233
21234    COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21235    It is used for relative paths in the line table.
21236    NOTE: When processing partial symtabs (pst != NULL),
21237    comp_dir == pst->dirname.
21238
21239    NOTE: It is important that psymtabs have the same file name (via strcmp)
21240    as the corresponding symtab.  Since COMP_DIR is not used in the name of the
21241    symtab we don't use it in the name of the psymtabs we create.
21242    E.g. expand_line_sal requires this when finding psymtabs to expand.
21243    A good testcase for this is mb-inline.exp.
21244
21245    LOWPC is the lowest address in CU (or 0 if not known).
21246
21247    Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
21248    for its PC<->lines mapping information.  Otherwise only the filename
21249    table is read in.  */
21250
21251 static void
21252 dwarf_decode_lines (struct line_header *lh, const char *comp_dir,
21253                     struct dwarf2_cu *cu, struct partial_symtab *pst,
21254                     CORE_ADDR lowpc, int decode_mapping)
21255 {
21256   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21257   const int decode_for_pst_p = (pst != NULL);
21258
21259   if (decode_mapping)
21260     dwarf_decode_lines_1 (lh, cu, decode_for_pst_p, lowpc);
21261
21262   if (decode_for_pst_p)
21263     {
21264       int file_index;
21265
21266       /* Now that we're done scanning the Line Header Program, we can
21267          create the psymtab of each included file.  */
21268       for (file_index = 0; file_index < lh->file_names.size (); file_index++)
21269         if (lh->file_names[file_index].included_p == 1)
21270           {
21271             gdb::unique_xmalloc_ptr<char> name_holder;
21272             const char *include_name =
21273               psymtab_include_file_name (lh, file_index, pst, comp_dir,
21274                                          &name_holder);
21275             if (include_name != NULL)
21276               dwarf2_create_include_psymtab (include_name, pst, objfile);
21277           }
21278     }
21279   else
21280     {
21281       /* Make sure a symtab is created for every file, even files
21282          which contain only variables (i.e. no code with associated
21283          line numbers).  */
21284       buildsym_compunit *builder = cu->get_builder ();
21285       struct compunit_symtab *cust = builder->get_compunit_symtab ();
21286       int i;
21287
21288       for (i = 0; i < lh->file_names.size (); i++)
21289         {
21290           file_entry &fe = lh->file_names[i];
21291
21292           dwarf2_start_subfile (cu, fe.name, fe.include_dir (lh));
21293
21294           if (builder->get_current_subfile ()->symtab == NULL)
21295             {
21296               builder->get_current_subfile ()->symtab
21297                 = allocate_symtab (cust,
21298                                    builder->get_current_subfile ()->name);
21299             }
21300           fe.symtab = builder->get_current_subfile ()->symtab;
21301         }
21302     }
21303 }
21304
21305 /* Start a subfile for DWARF.  FILENAME is the name of the file and
21306    DIRNAME the name of the source directory which contains FILENAME
21307    or NULL if not known.
21308    This routine tries to keep line numbers from identical absolute and
21309    relative file names in a common subfile.
21310
21311    Using the `list' example from the GDB testsuite, which resides in
21312    /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
21313    of /srcdir/list0.c yields the following debugging information for list0.c:
21314
21315    DW_AT_name:          /srcdir/list0.c
21316    DW_AT_comp_dir:      /compdir
21317    files.files[0].name: list0.h
21318    files.files[0].dir:  /srcdir
21319    files.files[1].name: list0.c
21320    files.files[1].dir:  /srcdir
21321
21322    The line number information for list0.c has to end up in a single
21323    subfile, so that `break /srcdir/list0.c:1' works as expected.
21324    start_subfile will ensure that this happens provided that we pass the
21325    concatenation of files.files[1].dir and files.files[1].name as the
21326    subfile's name.  */
21327
21328 static void
21329 dwarf2_start_subfile (struct dwarf2_cu *cu, const char *filename,
21330                       const char *dirname)
21331 {
21332   char *copy = NULL;
21333
21334   /* In order not to lose the line information directory,
21335      we concatenate it to the filename when it makes sense.
21336      Note that the Dwarf3 standard says (speaking of filenames in line
21337      information): ``The directory index is ignored for file names
21338      that represent full path names''.  Thus ignoring dirname in the
21339      `else' branch below isn't an issue.  */
21340
21341   if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
21342     {
21343       copy = concat (dirname, SLASH_STRING, filename, (char *)NULL);
21344       filename = copy;
21345     }
21346
21347   cu->get_builder ()->start_subfile (filename);
21348
21349   if (copy != NULL)
21350     xfree (copy);
21351 }
21352
21353 /* Start a symtab for DWARF.  NAME, COMP_DIR, LOW_PC are passed to the
21354    buildsym_compunit constructor.  */
21355
21356 struct compunit_symtab *
21357 dwarf2_cu::start_symtab (const char *name, const char *comp_dir,
21358                          CORE_ADDR low_pc)
21359 {
21360   gdb_assert (m_builder == nullptr);
21361
21362   m_builder.reset (new struct buildsym_compunit
21363                    (per_cu->dwarf2_per_objfile->objfile,
21364                     name, comp_dir, language, low_pc));
21365
21366   list_in_scope = get_builder ()->get_file_symbols ();
21367
21368   get_builder ()->record_debugformat ("DWARF 2");
21369   get_builder ()->record_producer (producer);
21370
21371   processing_has_namespace_info = false;
21372
21373   return get_builder ()->get_compunit_symtab ();
21374 }
21375
21376 static void
21377 var_decode_location (struct attribute *attr, struct symbol *sym,
21378                      struct dwarf2_cu *cu)
21379 {
21380   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21381   struct comp_unit_head *cu_header = &cu->header;
21382
21383   /* NOTE drow/2003-01-30: There used to be a comment and some special
21384      code here to turn a symbol with DW_AT_external and a
21385      SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol.  This was
21386      necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
21387      with some versions of binutils) where shared libraries could have
21388      relocations against symbols in their debug information - the
21389      minimal symbol would have the right address, but the debug info
21390      would not.  It's no longer necessary, because we will explicitly
21391      apply relocations when we read in the debug information now.  */
21392
21393   /* A DW_AT_location attribute with no contents indicates that a
21394      variable has been optimized away.  */
21395   if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
21396     {
21397       SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
21398       return;
21399     }
21400
21401   /* Handle one degenerate form of location expression specially, to
21402      preserve GDB's previous behavior when section offsets are
21403      specified.  If this is just a DW_OP_addr, DW_OP_addrx, or
21404      DW_OP_GNU_addr_index then mark this symbol as LOC_STATIC.  */
21405
21406   if (attr_form_is_block (attr)
21407       && ((DW_BLOCK (attr)->data[0] == DW_OP_addr
21408            && DW_BLOCK (attr)->size == 1 + cu_header->addr_size)
21409           || ((DW_BLOCK (attr)->data[0] == DW_OP_GNU_addr_index
21410                || DW_BLOCK (attr)->data[0] == DW_OP_addrx)
21411               && (DW_BLOCK (attr)->size
21412                   == 1 + leb128_size (&DW_BLOCK (attr)->data[1])))))
21413     {
21414       unsigned int dummy;
21415
21416       if (DW_BLOCK (attr)->data[0] == DW_OP_addr)
21417         SYMBOL_VALUE_ADDRESS (sym) =
21418           read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
21419       else
21420         SYMBOL_VALUE_ADDRESS (sym) =
21421           read_addr_index_from_leb128 (cu, DW_BLOCK (attr)->data + 1, &dummy);
21422       SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
21423       fixup_symbol_section (sym, objfile);
21424       SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
21425                                               SYMBOL_SECTION (sym));
21426       return;
21427     }
21428
21429   /* NOTE drow/2002-01-30: It might be worthwhile to have a static
21430      expression evaluator, and use LOC_COMPUTED only when necessary
21431      (i.e. when the value of a register or memory location is
21432      referenced, or a thread-local block, etc.).  Then again, it might
21433      not be worthwhile.  I'm assuming that it isn't unless performance
21434      or memory numbers show me otherwise.  */
21435
21436   dwarf2_symbol_mark_computed (attr, sym, cu, 0);
21437
21438   if (SYMBOL_COMPUTED_OPS (sym)->location_has_loclist)
21439     cu->has_loclist = true;
21440 }
21441
21442 /* Given a pointer to a DWARF information entry, figure out if we need
21443    to make a symbol table entry for it, and if so, create a new entry
21444    and return a pointer to it.
21445    If TYPE is NULL, determine symbol type from the die, otherwise
21446    used the passed type.
21447    If SPACE is not NULL, use it to hold the new symbol.  If it is
21448    NULL, allocate a new symbol on the objfile's obstack.  */
21449
21450 static struct symbol *
21451 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
21452             struct symbol *space)
21453 {
21454   struct dwarf2_per_objfile *dwarf2_per_objfile
21455     = cu->per_cu->dwarf2_per_objfile;
21456   struct objfile *objfile = dwarf2_per_objfile->objfile;
21457   struct gdbarch *gdbarch = get_objfile_arch (objfile);
21458   struct symbol *sym = NULL;
21459   const char *name;
21460   struct attribute *attr = NULL;
21461   struct attribute *attr2 = NULL;
21462   CORE_ADDR baseaddr;
21463   struct pending **list_to_add = NULL;
21464
21465   int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
21466
21467   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
21468
21469   name = dwarf2_name (die, cu);
21470   if (name)
21471     {
21472       const char *linkagename;
21473       int suppress_add = 0;
21474
21475       if (space)
21476         sym = space;
21477       else
21478         sym = allocate_symbol (objfile);
21479       OBJSTAT (objfile, n_syms++);
21480
21481       /* Cache this symbol's name and the name's demangled form (if any).  */
21482       SYMBOL_SET_LANGUAGE (sym, cu->language, &objfile->objfile_obstack);
21483       linkagename = dwarf2_physname (name, die, cu);
21484       SYMBOL_SET_NAMES (sym, linkagename, strlen (linkagename), 0, objfile);
21485
21486       /* Fortran does not have mangling standard and the mangling does differ
21487          between gfortran, iFort etc.  */
21488       if (cu->language == language_fortran
21489           && symbol_get_demangled_name (&(sym->ginfo)) == NULL)
21490         symbol_set_demangled_name (&(sym->ginfo),
21491                                    dwarf2_full_name (name, die, cu),
21492                                    NULL);
21493
21494       /* Default assumptions.
21495          Use the passed type or decode it from the die.  */
21496       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21497       SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
21498       if (type != NULL)
21499         SYMBOL_TYPE (sym) = type;
21500       else
21501         SYMBOL_TYPE (sym) = die_type (die, cu);
21502       attr = dwarf2_attr (die,
21503                           inlined_func ? DW_AT_call_line : DW_AT_decl_line,
21504                           cu);
21505       if (attr)
21506         {
21507           SYMBOL_LINE (sym) = DW_UNSND (attr);
21508         }
21509
21510       attr = dwarf2_attr (die,
21511                           inlined_func ? DW_AT_call_file : DW_AT_decl_file,
21512                           cu);
21513       if (attr)
21514         {
21515           file_name_index file_index = (file_name_index) DW_UNSND (attr);
21516           struct file_entry *fe;
21517
21518           if (cu->line_header != NULL)
21519             fe = cu->line_header->file_name_at (file_index);
21520           else
21521             fe = NULL;
21522
21523           if (fe == NULL)
21524             complaint (_("file index out of range"));
21525           else
21526             symbol_set_symtab (sym, fe->symtab);
21527         }
21528
21529       switch (die->tag)
21530         {
21531         case DW_TAG_label:
21532           attr = dwarf2_attr (die, DW_AT_low_pc, cu);
21533           if (attr)
21534             {
21535               CORE_ADDR addr;
21536
21537               addr = attr_value_as_address (attr);
21538               addr = gdbarch_adjust_dwarf2_addr (gdbarch, addr + baseaddr);
21539               SYMBOL_VALUE_ADDRESS (sym) = addr;
21540             }
21541           SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_core_addr;
21542           SYMBOL_DOMAIN (sym) = LABEL_DOMAIN;
21543           SYMBOL_ACLASS_INDEX (sym) = LOC_LABEL;
21544           add_symbol_to_list (sym, cu->list_in_scope);
21545           break;
21546         case DW_TAG_subprogram:
21547           /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21548              finish_block.  */
21549           SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
21550           attr2 = dwarf2_attr (die, DW_AT_external, cu);
21551           if ((attr2 && (DW_UNSND (attr2) != 0))
21552               || cu->language == language_ada)
21553             {
21554               /* Subprograms marked external are stored as a global symbol.
21555                  Ada subprograms, whether marked external or not, are always
21556                  stored as a global symbol, because we want to be able to
21557                  access them globally.  For instance, we want to be able
21558                  to break on a nested subprogram without having to
21559                  specify the context.  */
21560               list_to_add = cu->get_builder ()->get_global_symbols ();
21561             }
21562           else
21563             {
21564               list_to_add = cu->list_in_scope;
21565             }
21566           break;
21567         case DW_TAG_inlined_subroutine:
21568           /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21569              finish_block.  */
21570           SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
21571           SYMBOL_INLINED (sym) = 1;
21572           list_to_add = cu->list_in_scope;
21573           break;
21574         case DW_TAG_template_value_param:
21575           suppress_add = 1;
21576           /* Fall through.  */
21577         case DW_TAG_constant:
21578         case DW_TAG_variable:
21579         case DW_TAG_member:
21580           /* Compilation with minimal debug info may result in
21581              variables with missing type entries.  Change the
21582              misleading `void' type to something sensible.  */
21583           if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
21584             SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_int;
21585
21586           attr = dwarf2_attr (die, DW_AT_const_value, cu);
21587           /* In the case of DW_TAG_member, we should only be called for
21588              static const members.  */
21589           if (die->tag == DW_TAG_member)
21590             {
21591               /* dwarf2_add_field uses die_is_declaration,
21592                  so we do the same.  */
21593               gdb_assert (die_is_declaration (die, cu));
21594               gdb_assert (attr);
21595             }
21596           if (attr)
21597             {
21598               dwarf2_const_value (attr, sym, cu);
21599               attr2 = dwarf2_attr (die, DW_AT_external, cu);
21600               if (!suppress_add)
21601                 {
21602                   if (attr2 && (DW_UNSND (attr2) != 0))
21603                     list_to_add = cu->get_builder ()->get_global_symbols ();
21604                   else
21605                     list_to_add = cu->list_in_scope;
21606                 }
21607               break;
21608             }
21609           attr = dwarf2_attr (die, DW_AT_location, cu);
21610           if (attr)
21611             {
21612               var_decode_location (attr, sym, cu);
21613               attr2 = dwarf2_attr (die, DW_AT_external, cu);
21614
21615               /* Fortran explicitly imports any global symbols to the local
21616                  scope by DW_TAG_common_block.  */
21617               if (cu->language == language_fortran && die->parent
21618                   && die->parent->tag == DW_TAG_common_block)
21619                 attr2 = NULL;
21620
21621               if (SYMBOL_CLASS (sym) == LOC_STATIC
21622                   && SYMBOL_VALUE_ADDRESS (sym) == 0
21623                   && !dwarf2_per_objfile->has_section_at_zero)
21624                 {
21625                   /* When a static variable is eliminated by the linker,
21626                      the corresponding debug information is not stripped
21627                      out, but the variable address is set to null;
21628                      do not add such variables into symbol table.  */
21629                 }
21630               else if (attr2 && (DW_UNSND (attr2) != 0))
21631                 {
21632                   /* Workaround gfortran PR debug/40040 - it uses
21633                      DW_AT_location for variables in -fPIC libraries which may
21634                      get overriden by other libraries/executable and get
21635                      a different address.  Resolve it by the minimal symbol
21636                      which may come from inferior's executable using copy
21637                      relocation.  Make this workaround only for gfortran as for
21638                      other compilers GDB cannot guess the minimal symbol
21639                      Fortran mangling kind.  */
21640                   if (cu->language == language_fortran && die->parent
21641                       && die->parent->tag == DW_TAG_module
21642                       && cu->producer
21643                       && startswith (cu->producer, "GNU Fortran"))
21644                     SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
21645
21646                   /* A variable with DW_AT_external is never static,
21647                      but it may be block-scoped.  */
21648                   list_to_add
21649                     = ((cu->list_in_scope
21650                         == cu->get_builder ()->get_file_symbols ())
21651                        ? cu->get_builder ()->get_global_symbols ()
21652                        : cu->list_in_scope);
21653                 }
21654               else
21655                 list_to_add = cu->list_in_scope;
21656             }
21657           else
21658             {
21659               /* We do not know the address of this symbol.
21660                  If it is an external symbol and we have type information
21661                  for it, enter the symbol as a LOC_UNRESOLVED symbol.
21662                  The address of the variable will then be determined from
21663                  the minimal symbol table whenever the variable is
21664                  referenced.  */
21665               attr2 = dwarf2_attr (die, DW_AT_external, cu);
21666
21667               /* Fortran explicitly imports any global symbols to the local
21668                  scope by DW_TAG_common_block.  */
21669               if (cu->language == language_fortran && die->parent
21670                   && die->parent->tag == DW_TAG_common_block)
21671                 {
21672                   /* SYMBOL_CLASS doesn't matter here because
21673                      read_common_block is going to reset it.  */
21674                   if (!suppress_add)
21675                     list_to_add = cu->list_in_scope;
21676                 }
21677               else if (attr2 && (DW_UNSND (attr2) != 0)
21678                        && dwarf2_attr (die, DW_AT_type, cu) != NULL)
21679                 {
21680                   /* A variable with DW_AT_external is never static, but it
21681                      may be block-scoped.  */
21682                   list_to_add
21683                     = ((cu->list_in_scope
21684                         == cu->get_builder ()->get_file_symbols ())
21685                        ? cu->get_builder ()->get_global_symbols ()
21686                        : cu->list_in_scope);
21687
21688                   SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
21689                 }
21690               else if (!die_is_declaration (die, cu))
21691                 {
21692                   /* Use the default LOC_OPTIMIZED_OUT class.  */
21693                   gdb_assert (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT);
21694                   if (!suppress_add)
21695                     list_to_add = cu->list_in_scope;
21696                 }
21697             }
21698           break;
21699         case DW_TAG_formal_parameter:
21700           {
21701             /* If we are inside a function, mark this as an argument.  If
21702                not, we might be looking at an argument to an inlined function
21703                when we do not have enough information to show inlined frames;
21704                pretend it's a local variable in that case so that the user can
21705                still see it.  */
21706             struct context_stack *curr
21707               = cu->get_builder ()->get_current_context_stack ();
21708             if (curr != nullptr && curr->name != nullptr)
21709               SYMBOL_IS_ARGUMENT (sym) = 1;
21710             attr = dwarf2_attr (die, DW_AT_location, cu);
21711             if (attr)
21712               {
21713                 var_decode_location (attr, sym, cu);
21714               }
21715             attr = dwarf2_attr (die, DW_AT_const_value, cu);
21716             if (attr)
21717               {
21718                 dwarf2_const_value (attr, sym, cu);
21719               }
21720
21721             list_to_add = cu->list_in_scope;
21722           }
21723           break;
21724         case DW_TAG_unspecified_parameters:
21725           /* From varargs functions; gdb doesn't seem to have any
21726              interest in this information, so just ignore it for now.
21727              (FIXME?) */
21728           break;
21729         case DW_TAG_template_type_param:
21730           suppress_add = 1;
21731           /* Fall through.  */
21732         case DW_TAG_class_type:
21733         case DW_TAG_interface_type:
21734         case DW_TAG_structure_type:
21735         case DW_TAG_union_type:
21736         case DW_TAG_set_type:
21737         case DW_TAG_enumeration_type:
21738           SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21739           SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
21740
21741           {
21742             /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
21743                really ever be static objects: otherwise, if you try
21744                to, say, break of a class's method and you're in a file
21745                which doesn't mention that class, it won't work unless
21746                the check for all static symbols in lookup_symbol_aux
21747                saves you.  See the OtherFileClass tests in
21748                gdb.c++/namespace.exp.  */
21749
21750             if (!suppress_add)
21751               {
21752                 buildsym_compunit *builder = cu->get_builder ();
21753                 list_to_add
21754                   = (cu->list_in_scope == builder->get_file_symbols ()
21755                      && cu->language == language_cplus
21756                      ? builder->get_global_symbols ()
21757                      : cu->list_in_scope);
21758
21759                 /* The semantics of C++ state that "struct foo {
21760                    ... }" also defines a typedef for "foo".  */
21761                 if (cu->language == language_cplus
21762                     || cu->language == language_ada
21763                     || cu->language == language_d
21764                     || cu->language == language_rust)
21765                   {
21766                     /* The symbol's name is already allocated along
21767                        with this objfile, so we don't need to
21768                        duplicate it for the type.  */
21769                     if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
21770                       TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
21771                   }
21772               }
21773           }
21774           break;
21775         case DW_TAG_typedef:
21776           SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21777           SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21778           list_to_add = cu->list_in_scope;
21779           break;
21780         case DW_TAG_base_type:
21781         case DW_TAG_subrange_type:
21782           SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21783           SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21784           list_to_add = cu->list_in_scope;
21785           break;
21786         case DW_TAG_enumerator:
21787           attr = dwarf2_attr (die, DW_AT_const_value, cu);
21788           if (attr)
21789             {
21790               dwarf2_const_value (attr, sym, cu);
21791             }
21792           {
21793             /* NOTE: carlton/2003-11-10: See comment above in the
21794                DW_TAG_class_type, etc. block.  */
21795
21796             list_to_add
21797               = (cu->list_in_scope == cu->get_builder ()->get_file_symbols ()
21798                  && cu->language == language_cplus
21799                  ? cu->get_builder ()->get_global_symbols ()
21800                  : cu->list_in_scope);
21801           }
21802           break;
21803         case DW_TAG_imported_declaration:
21804         case DW_TAG_namespace:
21805           SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21806           list_to_add = cu->get_builder ()->get_global_symbols ();
21807           break;
21808         case DW_TAG_module:
21809           SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21810           SYMBOL_DOMAIN (sym) = MODULE_DOMAIN;
21811           list_to_add = cu->get_builder ()->get_global_symbols ();
21812           break;
21813         case DW_TAG_common_block:
21814           SYMBOL_ACLASS_INDEX (sym) = LOC_COMMON_BLOCK;
21815           SYMBOL_DOMAIN (sym) = COMMON_BLOCK_DOMAIN;
21816           add_symbol_to_list (sym, cu->list_in_scope);
21817           break;
21818         default:
21819           /* Not a tag we recognize.  Hopefully we aren't processing
21820              trash data, but since we must specifically ignore things
21821              we don't recognize, there is nothing else we should do at
21822              this point.  */
21823           complaint (_("unsupported tag: '%s'"),
21824                      dwarf_tag_name (die->tag));
21825           break;
21826         }
21827
21828       if (suppress_add)
21829         {
21830           sym->hash_next = objfile->template_symbols;
21831           objfile->template_symbols = sym;
21832           list_to_add = NULL;
21833         }
21834
21835       if (list_to_add != NULL)
21836         add_symbol_to_list (sym, list_to_add);
21837
21838       /* For the benefit of old versions of GCC, check for anonymous
21839          namespaces based on the demangled name.  */
21840       if (!cu->processing_has_namespace_info
21841           && cu->language == language_cplus)
21842         cp_scan_for_anonymous_namespaces (cu->get_builder (), sym, objfile);
21843     }
21844   return (sym);
21845 }
21846
21847 /* Given an attr with a DW_FORM_dataN value in host byte order,
21848    zero-extend it as appropriate for the symbol's type.  The DWARF
21849    standard (v4) is not entirely clear about the meaning of using
21850    DW_FORM_dataN for a constant with a signed type, where the type is
21851    wider than the data.  The conclusion of a discussion on the DWARF
21852    list was that this is unspecified.  We choose to always zero-extend
21853    because that is the interpretation long in use by GCC.  */
21854
21855 static gdb_byte *
21856 dwarf2_const_value_data (const struct attribute *attr, struct obstack *obstack,
21857                          struct dwarf2_cu *cu, LONGEST *value, int bits)
21858 {
21859   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21860   enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ?
21861                                 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
21862   LONGEST l = DW_UNSND (attr);
21863
21864   if (bits < sizeof (*value) * 8)
21865     {
21866       l &= ((LONGEST) 1 << bits) - 1;
21867       *value = l;
21868     }
21869   else if (bits == sizeof (*value) * 8)
21870     *value = l;
21871   else
21872     {
21873       gdb_byte *bytes = (gdb_byte *) obstack_alloc (obstack, bits / 8);
21874       store_unsigned_integer (bytes, bits / 8, byte_order, l);
21875       return bytes;
21876     }
21877
21878   return NULL;
21879 }
21880
21881 /* Read a constant value from an attribute.  Either set *VALUE, or if
21882    the value does not fit in *VALUE, set *BYTES - either already
21883    allocated on the objfile obstack, or newly allocated on OBSTACK,
21884    or, set *BATON, if we translated the constant to a location
21885    expression.  */
21886
21887 static void
21888 dwarf2_const_value_attr (const struct attribute *attr, struct type *type,
21889                          const char *name, struct obstack *obstack,
21890                          struct dwarf2_cu *cu,
21891                          LONGEST *value, const gdb_byte **bytes,
21892                          struct dwarf2_locexpr_baton **baton)
21893 {
21894   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21895   struct comp_unit_head *cu_header = &cu->header;
21896   struct dwarf_block *blk;
21897   enum bfd_endian byte_order = (bfd_big_endian (objfile->obfd) ?
21898                                 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
21899
21900   *value = 0;
21901   *bytes = NULL;
21902   *baton = NULL;
21903
21904   switch (attr->form)
21905     {
21906     case DW_FORM_addr:
21907     case DW_FORM_addrx:
21908     case DW_FORM_GNU_addr_index:
21909       {
21910         gdb_byte *data;
21911
21912         if (TYPE_LENGTH (type) != cu_header->addr_size)
21913           dwarf2_const_value_length_mismatch_complaint (name,
21914                                                         cu_header->addr_size,
21915                                                         TYPE_LENGTH (type));
21916         /* Symbols of this form are reasonably rare, so we just
21917            piggyback on the existing location code rather than writing
21918            a new implementation of symbol_computed_ops.  */
21919         *baton = XOBNEW (obstack, struct dwarf2_locexpr_baton);
21920         (*baton)->per_cu = cu->per_cu;
21921         gdb_assert ((*baton)->per_cu);
21922
21923         (*baton)->size = 2 + cu_header->addr_size;
21924         data = (gdb_byte *) obstack_alloc (obstack, (*baton)->size);
21925         (*baton)->data = data;
21926
21927         data[0] = DW_OP_addr;
21928         store_unsigned_integer (&data[1], cu_header->addr_size,
21929                                 byte_order, DW_ADDR (attr));
21930         data[cu_header->addr_size + 1] = DW_OP_stack_value;
21931       }
21932       break;
21933     case DW_FORM_string:
21934     case DW_FORM_strp:
21935     case DW_FORM_strx:
21936     case DW_FORM_GNU_str_index:
21937     case DW_FORM_GNU_strp_alt:
21938       /* DW_STRING is already allocated on the objfile obstack, point
21939          directly to it.  */
21940       *bytes = (const gdb_byte *) DW_STRING (attr);
21941       break;
21942     case DW_FORM_block1:
21943     case DW_FORM_block2:
21944     case DW_FORM_block4:
21945     case DW_FORM_block:
21946     case DW_FORM_exprloc:
21947     case DW_FORM_data16:
21948       blk = DW_BLOCK (attr);
21949       if (TYPE_LENGTH (type) != blk->size)
21950         dwarf2_const_value_length_mismatch_complaint (name, blk->size,
21951                                                       TYPE_LENGTH (type));
21952       *bytes = blk->data;
21953       break;
21954
21955       /* The DW_AT_const_value attributes are supposed to carry the
21956          symbol's value "represented as it would be on the target
21957          architecture."  By the time we get here, it's already been
21958          converted to host endianness, so we just need to sign- or
21959          zero-extend it as appropriate.  */
21960     case DW_FORM_data1:
21961       *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 8);
21962       break;
21963     case DW_FORM_data2:
21964       *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 16);
21965       break;
21966     case DW_FORM_data4:
21967       *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 32);
21968       break;
21969     case DW_FORM_data8:
21970       *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 64);
21971       break;
21972
21973     case DW_FORM_sdata:
21974     case DW_FORM_implicit_const:
21975       *value = DW_SND (attr);
21976       break;
21977
21978     case DW_FORM_udata:
21979       *value = DW_UNSND (attr);
21980       break;
21981
21982     default:
21983       complaint (_("unsupported const value attribute form: '%s'"),
21984                  dwarf_form_name (attr->form));
21985       *value = 0;
21986       break;
21987     }
21988 }
21989
21990
21991 /* Copy constant value from an attribute to a symbol.  */
21992
21993 static void
21994 dwarf2_const_value (const struct attribute *attr, struct symbol *sym,
21995                     struct dwarf2_cu *cu)
21996 {
21997   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21998   LONGEST value;
21999   const gdb_byte *bytes;
22000   struct dwarf2_locexpr_baton *baton;
22001
22002   dwarf2_const_value_attr (attr, SYMBOL_TYPE (sym),
22003                            SYMBOL_PRINT_NAME (sym),
22004                            &objfile->objfile_obstack, cu,
22005                            &value, &bytes, &baton);
22006
22007   if (baton != NULL)
22008     {
22009       SYMBOL_LOCATION_BATON (sym) = baton;
22010       SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
22011     }
22012   else if (bytes != NULL)
22013      {
22014       SYMBOL_VALUE_BYTES (sym) = bytes;
22015       SYMBOL_ACLASS_INDEX (sym) = LOC_CONST_BYTES;
22016     }
22017   else
22018     {
22019       SYMBOL_VALUE (sym) = value;
22020       SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
22021     }
22022 }
22023
22024 /* Return the type of the die in question using its DW_AT_type attribute.  */
22025
22026 static struct type *
22027 die_type (struct die_info *die, struct dwarf2_cu *cu)
22028 {
22029   struct attribute *type_attr;
22030
22031   type_attr = dwarf2_attr (die, DW_AT_type, cu);
22032   if (!type_attr)
22033     {
22034       struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22035       /* A missing DW_AT_type represents a void type.  */
22036       return objfile_type (objfile)->builtin_void;
22037     }
22038
22039   return lookup_die_type (die, type_attr, cu);
22040 }
22041
22042 /* True iff CU's producer generates GNAT Ada auxiliary information
22043    that allows to find parallel types through that information instead
22044    of having to do expensive parallel lookups by type name.  */
22045
22046 static int
22047 need_gnat_info (struct dwarf2_cu *cu)
22048 {
22049   /* Assume that the Ada compiler was GNAT, which always produces
22050      the auxiliary information.  */
22051   return (cu->language == language_ada);
22052 }
22053
22054 /* Return the auxiliary type of the die in question using its
22055    DW_AT_GNAT_descriptive_type attribute.  Returns NULL if the
22056    attribute is not present.  */
22057
22058 static struct type *
22059 die_descriptive_type (struct die_info *die, struct dwarf2_cu *cu)
22060 {
22061   struct attribute *type_attr;
22062
22063   type_attr = dwarf2_attr (die, DW_AT_GNAT_descriptive_type, cu);
22064   if (!type_attr)
22065     return NULL;
22066
22067   return lookup_die_type (die, type_attr, cu);
22068 }
22069
22070 /* If DIE has a descriptive_type attribute, then set the TYPE's
22071    descriptive type accordingly.  */
22072
22073 static void
22074 set_descriptive_type (struct type *type, struct die_info *die,
22075                       struct dwarf2_cu *cu)
22076 {
22077   struct type *descriptive_type = die_descriptive_type (die, cu);
22078
22079   if (descriptive_type)
22080     {
22081       ALLOCATE_GNAT_AUX_TYPE (type);
22082       TYPE_DESCRIPTIVE_TYPE (type) = descriptive_type;
22083     }
22084 }
22085
22086 /* Return the containing type of the die in question using its
22087    DW_AT_containing_type attribute.  */
22088
22089 static struct type *
22090 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
22091 {
22092   struct attribute *type_attr;
22093   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22094
22095   type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
22096   if (!type_attr)
22097     error (_("Dwarf Error: Problem turning containing type into gdb type "
22098              "[in module %s]"), objfile_name (objfile));
22099
22100   return lookup_die_type (die, type_attr, cu);
22101 }
22102
22103 /* Return an error marker type to use for the ill formed type in DIE/CU.  */
22104
22105 static struct type *
22106 build_error_marker_type (struct dwarf2_cu *cu, struct die_info *die)
22107 {
22108   struct dwarf2_per_objfile *dwarf2_per_objfile
22109     = cu->per_cu->dwarf2_per_objfile;
22110   struct objfile *objfile = dwarf2_per_objfile->objfile;
22111   char *saved;
22112
22113   std::string message
22114     = string_printf (_("<unknown type in %s, CU %s, DIE %s>"),
22115                      objfile_name (objfile),
22116                      sect_offset_str (cu->header.sect_off),
22117                      sect_offset_str (die->sect_off));
22118   saved = (char *) obstack_copy0 (&objfile->objfile_obstack,
22119                                   message.c_str (), message.length ());
22120
22121   return init_type (objfile, TYPE_CODE_ERROR, 0, saved);
22122 }
22123
22124 /* Look up the type of DIE in CU using its type attribute ATTR.
22125    ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
22126    DW_AT_containing_type.
22127    If there is no type substitute an error marker.  */
22128
22129 static struct type *
22130 lookup_die_type (struct die_info *die, const struct attribute *attr,
22131                  struct dwarf2_cu *cu)
22132 {
22133   struct dwarf2_per_objfile *dwarf2_per_objfile
22134     = cu->per_cu->dwarf2_per_objfile;
22135   struct objfile *objfile = dwarf2_per_objfile->objfile;
22136   struct type *this_type;
22137
22138   gdb_assert (attr->name == DW_AT_type
22139               || attr->name == DW_AT_GNAT_descriptive_type
22140               || attr->name == DW_AT_containing_type);
22141
22142   /* First see if we have it cached.  */
22143
22144   if (attr->form == DW_FORM_GNU_ref_alt)
22145     {
22146       struct dwarf2_per_cu_data *per_cu;
22147       sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
22148
22149       per_cu = dwarf2_find_containing_comp_unit (sect_off, 1,
22150                                                  dwarf2_per_objfile);
22151       this_type = get_die_type_at_offset (sect_off, per_cu);
22152     }
22153   else if (attr_form_is_ref (attr))
22154     {
22155       sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
22156
22157       this_type = get_die_type_at_offset (sect_off, cu->per_cu);
22158     }
22159   else if (attr->form == DW_FORM_ref_sig8)
22160     {
22161       ULONGEST signature = DW_SIGNATURE (attr);
22162
22163       return get_signatured_type (die, signature, cu);
22164     }
22165   else
22166     {
22167       complaint (_("Dwarf Error: Bad type attribute %s in DIE"
22168                    " at %s [in module %s]"),
22169                  dwarf_attr_name (attr->name), sect_offset_str (die->sect_off),
22170                  objfile_name (objfile));
22171       return build_error_marker_type (cu, die);
22172     }
22173
22174   /* If not cached we need to read it in.  */
22175
22176   if (this_type == NULL)
22177     {
22178       struct die_info *type_die = NULL;
22179       struct dwarf2_cu *type_cu = cu;
22180
22181       if (attr_form_is_ref (attr))
22182         type_die = follow_die_ref (die, attr, &type_cu);
22183       if (type_die == NULL)
22184         return build_error_marker_type (cu, die);
22185       /* If we find the type now, it's probably because the type came
22186          from an inter-CU reference and the type's CU got expanded before
22187          ours.  */
22188       this_type = read_type_die (type_die, type_cu);
22189     }
22190
22191   /* If we still don't have a type use an error marker.  */
22192
22193   if (this_type == NULL)
22194     return build_error_marker_type (cu, die);
22195
22196   return this_type;
22197 }
22198
22199 /* Return the type in DIE, CU.
22200    Returns NULL for invalid types.
22201
22202    This first does a lookup in die_type_hash,
22203    and only reads the die in if necessary.
22204
22205    NOTE: This can be called when reading in partial or full symbols.  */
22206
22207 static struct type *
22208 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
22209 {
22210   struct type *this_type;
22211
22212   this_type = get_die_type (die, cu);
22213   if (this_type)
22214     return this_type;
22215
22216   return read_type_die_1 (die, cu);
22217 }
22218
22219 /* Read the type in DIE, CU.
22220    Returns NULL for invalid types.  */
22221
22222 static struct type *
22223 read_type_die_1 (struct die_info *die, struct dwarf2_cu *cu)
22224 {
22225   struct type *this_type = NULL;
22226
22227   switch (die->tag)
22228     {
22229     case DW_TAG_class_type:
22230     case DW_TAG_interface_type:
22231     case DW_TAG_structure_type:
22232     case DW_TAG_union_type:
22233       this_type = read_structure_type (die, cu);
22234       break;
22235     case DW_TAG_enumeration_type:
22236       this_type = read_enumeration_type (die, cu);
22237       break;
22238     case DW_TAG_subprogram:
22239     case DW_TAG_subroutine_type:
22240     case DW_TAG_inlined_subroutine:
22241       this_type = read_subroutine_type (die, cu);
22242       break;
22243     case DW_TAG_array_type:
22244       this_type = read_array_type (die, cu);
22245       break;
22246     case DW_TAG_set_type:
22247       this_type = read_set_type (die, cu);
22248       break;
22249     case DW_TAG_pointer_type:
22250       this_type = read_tag_pointer_type (die, cu);
22251       break;
22252     case DW_TAG_ptr_to_member_type:
22253       this_type = read_tag_ptr_to_member_type (die, cu);
22254       break;
22255     case DW_TAG_reference_type:
22256       this_type = read_tag_reference_type (die, cu, TYPE_CODE_REF);
22257       break;
22258     case DW_TAG_rvalue_reference_type:
22259       this_type = read_tag_reference_type (die, cu, TYPE_CODE_RVALUE_REF);
22260       break;
22261     case DW_TAG_const_type:
22262       this_type = read_tag_const_type (die, cu);
22263       break;
22264     case DW_TAG_volatile_type:
22265       this_type = read_tag_volatile_type (die, cu);
22266       break;
22267     case DW_TAG_restrict_type:
22268       this_type = read_tag_restrict_type (die, cu);
22269       break;
22270     case DW_TAG_string_type:
22271       this_type = read_tag_string_type (die, cu);
22272       break;
22273     case DW_TAG_typedef:
22274       this_type = read_typedef (die, cu);
22275       break;
22276     case DW_TAG_subrange_type:
22277       this_type = read_subrange_type (die, cu);
22278       break;
22279     case DW_TAG_base_type:
22280       this_type = read_base_type (die, cu);
22281       break;
22282     case DW_TAG_unspecified_type:
22283       this_type = read_unspecified_type (die, cu);
22284       break;
22285     case DW_TAG_namespace:
22286       this_type = read_namespace_type (die, cu);
22287       break;
22288     case DW_TAG_module:
22289       this_type = read_module_type (die, cu);
22290       break;
22291     case DW_TAG_atomic_type:
22292       this_type = read_tag_atomic_type (die, cu);
22293       break;
22294     default:
22295       complaint (_("unexpected tag in read_type_die: '%s'"),
22296                  dwarf_tag_name (die->tag));
22297       break;
22298     }
22299
22300   return this_type;
22301 }
22302
22303 /* See if we can figure out if the class lives in a namespace.  We do
22304    this by looking for a member function; its demangled name will
22305    contain namespace info, if there is any.
22306    Return the computed name or NULL.
22307    Space for the result is allocated on the objfile's obstack.
22308    This is the full-die version of guess_partial_die_structure_name.
22309    In this case we know DIE has no useful parent.  */
22310
22311 static char *
22312 guess_full_die_structure_name (struct die_info *die, struct dwarf2_cu *cu)
22313 {
22314   struct die_info *spec_die;
22315   struct dwarf2_cu *spec_cu;
22316   struct die_info *child;
22317   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22318
22319   spec_cu = cu;
22320   spec_die = die_specification (die, &spec_cu);
22321   if (spec_die != NULL)
22322     {
22323       die = spec_die;
22324       cu = spec_cu;
22325     }
22326
22327   for (child = die->child;
22328        child != NULL;
22329        child = child->sibling)
22330     {
22331       if (child->tag == DW_TAG_subprogram)
22332         {
22333           const char *linkage_name = dw2_linkage_name (child, cu);
22334
22335           if (linkage_name != NULL)
22336             {
22337               char *actual_name
22338                 = language_class_name_from_physname (cu->language_defn,
22339                                                      linkage_name);
22340               char *name = NULL;
22341
22342               if (actual_name != NULL)
22343                 {
22344                   const char *die_name = dwarf2_name (die, cu);
22345
22346                   if (die_name != NULL
22347                       && strcmp (die_name, actual_name) != 0)
22348                     {
22349                       /* Strip off the class name from the full name.
22350                          We want the prefix.  */
22351                       int die_name_len = strlen (die_name);
22352                       int actual_name_len = strlen (actual_name);
22353
22354                       /* Test for '::' as a sanity check.  */
22355                       if (actual_name_len > die_name_len + 2
22356                           && actual_name[actual_name_len
22357                                          - die_name_len - 1] == ':')
22358                         name = (char *) obstack_copy0 (
22359                           &objfile->per_bfd->storage_obstack,
22360                           actual_name, actual_name_len - die_name_len - 2);
22361                     }
22362                 }
22363               xfree (actual_name);
22364               return name;
22365             }
22366         }
22367     }
22368
22369   return NULL;
22370 }
22371
22372 /* GCC might emit a nameless typedef that has a linkage name.  Determine the
22373    prefix part in such case.  See
22374    http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510.  */
22375
22376 static const char *
22377 anonymous_struct_prefix (struct die_info *die, struct dwarf2_cu *cu)
22378 {
22379   struct attribute *attr;
22380   const char *base;
22381
22382   if (die->tag != DW_TAG_class_type && die->tag != DW_TAG_interface_type
22383       && die->tag != DW_TAG_structure_type && die->tag != DW_TAG_union_type)
22384     return NULL;
22385
22386   if (dwarf2_string_attr (die, DW_AT_name, cu) != NULL)
22387     return NULL;
22388
22389   attr = dw2_linkage_name_attr (die, cu);
22390   if (attr == NULL || DW_STRING (attr) == NULL)
22391     return NULL;
22392
22393   /* dwarf2_name had to be already called.  */
22394   gdb_assert (DW_STRING_IS_CANONICAL (attr));
22395
22396   /* Strip the base name, keep any leading namespaces/classes.  */
22397   base = strrchr (DW_STRING (attr), ':');
22398   if (base == NULL || base == DW_STRING (attr) || base[-1] != ':')
22399     return "";
22400
22401   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22402   return (char *) obstack_copy0 (&objfile->per_bfd->storage_obstack,
22403                                  DW_STRING (attr),
22404                                  &base[-1] - DW_STRING (attr));
22405 }
22406
22407 /* Return the name of the namespace/class that DIE is defined within,
22408    or "" if we can't tell.  The caller should not xfree the result.
22409
22410    For example, if we're within the method foo() in the following
22411    code:
22412
22413    namespace N {
22414      class C {
22415        void foo () {
22416        }
22417      };
22418    }
22419
22420    then determine_prefix on foo's die will return "N::C".  */
22421
22422 static const char *
22423 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
22424 {
22425   struct dwarf2_per_objfile *dwarf2_per_objfile
22426     = cu->per_cu->dwarf2_per_objfile;
22427   struct die_info *parent, *spec_die;
22428   struct dwarf2_cu *spec_cu;
22429   struct type *parent_type;
22430   const char *retval;
22431
22432   if (cu->language != language_cplus
22433       && cu->language != language_fortran && cu->language != language_d
22434       && cu->language != language_rust)
22435     return "";
22436
22437   retval = anonymous_struct_prefix (die, cu);
22438   if (retval)
22439     return retval;
22440
22441   /* We have to be careful in the presence of DW_AT_specification.
22442      For example, with GCC 3.4, given the code
22443
22444      namespace N {
22445        void foo() {
22446          // Definition of N::foo.
22447        }
22448      }
22449
22450      then we'll have a tree of DIEs like this:
22451
22452      1: DW_TAG_compile_unit
22453        2: DW_TAG_namespace        // N
22454          3: DW_TAG_subprogram     // declaration of N::foo
22455        4: DW_TAG_subprogram       // definition of N::foo
22456             DW_AT_specification   // refers to die #3
22457
22458      Thus, when processing die #4, we have to pretend that we're in
22459      the context of its DW_AT_specification, namely the contex of die
22460      #3.  */
22461   spec_cu = cu;
22462   spec_die = die_specification (die, &spec_cu);
22463   if (spec_die == NULL)
22464     parent = die->parent;
22465   else
22466     {
22467       parent = spec_die->parent;
22468       cu = spec_cu;
22469     }
22470
22471   if (parent == NULL)
22472     return "";
22473   else if (parent->building_fullname)
22474     {
22475       const char *name;
22476       const char *parent_name;
22477
22478       /* It has been seen on RealView 2.2 built binaries,
22479          DW_TAG_template_type_param types actually _defined_ as
22480          children of the parent class:
22481
22482          enum E {};
22483          template class <class Enum> Class{};
22484          Class<enum E> class_e;
22485
22486          1: DW_TAG_class_type (Class)
22487            2: DW_TAG_enumeration_type (E)
22488              3: DW_TAG_enumerator (enum1:0)
22489              3: DW_TAG_enumerator (enum2:1)
22490              ...
22491            2: DW_TAG_template_type_param
22492               DW_AT_type  DW_FORM_ref_udata (E)
22493
22494          Besides being broken debug info, it can put GDB into an
22495          infinite loop.  Consider:
22496
22497          When we're building the full name for Class<E>, we'll start
22498          at Class, and go look over its template type parameters,
22499          finding E.  We'll then try to build the full name of E, and
22500          reach here.  We're now trying to build the full name of E,
22501          and look over the parent DIE for containing scope.  In the
22502          broken case, if we followed the parent DIE of E, we'd again
22503          find Class, and once again go look at its template type
22504          arguments, etc., etc.  Simply don't consider such parent die
22505          as source-level parent of this die (it can't be, the language
22506          doesn't allow it), and break the loop here.  */
22507       name = dwarf2_name (die, cu);
22508       parent_name = dwarf2_name (parent, cu);
22509       complaint (_("template param type '%s' defined within parent '%s'"),
22510                  name ? name : "<unknown>",
22511                  parent_name ? parent_name : "<unknown>");
22512       return "";
22513     }
22514   else
22515     switch (parent->tag)
22516       {
22517       case DW_TAG_namespace:
22518         parent_type = read_type_die (parent, cu);
22519         /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
22520            DW_TAG_namespace DIEs with a name of "::" for the global namespace.
22521            Work around this problem here.  */
22522         if (cu->language == language_cplus
22523             && strcmp (TYPE_NAME (parent_type), "::") == 0)
22524           return "";
22525         /* We give a name to even anonymous namespaces.  */
22526         return TYPE_NAME (parent_type);
22527       case DW_TAG_class_type:
22528       case DW_TAG_interface_type:
22529       case DW_TAG_structure_type:
22530       case DW_TAG_union_type:
22531       case DW_TAG_module:
22532         parent_type = read_type_die (parent, cu);
22533         if (TYPE_NAME (parent_type) != NULL)
22534           return TYPE_NAME (parent_type);
22535         else
22536           /* An anonymous structure is only allowed non-static data
22537              members; no typedefs, no member functions, et cetera.
22538              So it does not need a prefix.  */
22539           return "";
22540       case DW_TAG_compile_unit:
22541       case DW_TAG_partial_unit:
22542         /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace.  Cope.  */
22543         if (cu->language == language_cplus
22544             && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
22545             && die->child != NULL
22546             && (die->tag == DW_TAG_class_type
22547                 || die->tag == DW_TAG_structure_type
22548                 || die->tag == DW_TAG_union_type))
22549           {
22550             char *name = guess_full_die_structure_name (die, cu);
22551             if (name != NULL)
22552               return name;
22553           }
22554         return "";
22555       case DW_TAG_enumeration_type:
22556         parent_type = read_type_die (parent, cu);
22557         if (TYPE_DECLARED_CLASS (parent_type))
22558           {
22559             if (TYPE_NAME (parent_type) != NULL)
22560               return TYPE_NAME (parent_type);
22561             return "";
22562           }
22563         /* Fall through.  */
22564       default:
22565         return determine_prefix (parent, cu);
22566       }
22567 }
22568
22569 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
22570    with appropriate separator.  If PREFIX or SUFFIX is NULL or empty, then
22571    simply copy the SUFFIX or PREFIX, respectively.  If OBS is non-null, perform
22572    an obconcat, otherwise allocate storage for the result.  The CU argument is
22573    used to determine the language and hence, the appropriate separator.  */
22574
22575 #define MAX_SEP_LEN 7  /* strlen ("__") + strlen ("_MOD_")  */
22576
22577 static char *
22578 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
22579                  int physname, struct dwarf2_cu *cu)
22580 {
22581   const char *lead = "";
22582   const char *sep;
22583
22584   if (suffix == NULL || suffix[0] == '\0'
22585       || prefix == NULL || prefix[0] == '\0')
22586     sep = "";
22587   else if (cu->language == language_d)
22588     {
22589       /* For D, the 'main' function could be defined in any module, but it
22590          should never be prefixed.  */
22591       if (strcmp (suffix, "D main") == 0)
22592         {
22593           prefix = "";
22594           sep = "";
22595         }
22596       else
22597         sep = ".";
22598     }
22599   else if (cu->language == language_fortran && physname)
22600     {
22601       /* This is gfortran specific mangling.  Normally DW_AT_linkage_name or
22602          DW_AT_MIPS_linkage_name is preferred and used instead.  */
22603
22604       lead = "__";
22605       sep = "_MOD_";
22606     }
22607   else
22608     sep = "::";
22609
22610   if (prefix == NULL)
22611     prefix = "";
22612   if (suffix == NULL)
22613     suffix = "";
22614
22615   if (obs == NULL)
22616     {
22617       char *retval
22618         = ((char *)
22619            xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1));
22620
22621       strcpy (retval, lead);
22622       strcat (retval, prefix);
22623       strcat (retval, sep);
22624       strcat (retval, suffix);
22625       return retval;
22626     }
22627   else
22628     {
22629       /* We have an obstack.  */
22630       return obconcat (obs, lead, prefix, sep, suffix, (char *) NULL);
22631     }
22632 }
22633
22634 /* Return sibling of die, NULL if no sibling.  */
22635
22636 static struct die_info *
22637 sibling_die (struct die_info *die)
22638 {
22639   return die->sibling;
22640 }
22641
22642 /* Get name of a die, return NULL if not found.  */
22643
22644 static const char *
22645 dwarf2_canonicalize_name (const char *name, struct dwarf2_cu *cu,
22646                           struct obstack *obstack)
22647 {
22648   if (name && cu->language == language_cplus)
22649     {
22650       std::string canon_name = cp_canonicalize_string (name);
22651
22652       if (!canon_name.empty ())
22653         {
22654           if (canon_name != name)
22655             name = (const char *) obstack_copy0 (obstack,
22656                                                  canon_name.c_str (),
22657                                                  canon_name.length ());
22658         }
22659     }
22660
22661   return name;
22662 }
22663
22664 /* Get name of a die, return NULL if not found.
22665    Anonymous namespaces are converted to their magic string.  */
22666
22667 static const char *
22668 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
22669 {
22670   struct attribute *attr;
22671   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22672
22673   attr = dwarf2_attr (die, DW_AT_name, cu);
22674   if ((!attr || !DW_STRING (attr))
22675       && die->tag != DW_TAG_namespace
22676       && die->tag != DW_TAG_class_type
22677       && die->tag != DW_TAG_interface_type
22678       && die->tag != DW_TAG_structure_type
22679       && die->tag != DW_TAG_union_type)
22680     return NULL;
22681
22682   switch (die->tag)
22683     {
22684     case DW_TAG_compile_unit:
22685     case DW_TAG_partial_unit:
22686       /* Compilation units have a DW_AT_name that is a filename, not
22687          a source language identifier.  */
22688     case DW_TAG_enumeration_type:
22689     case DW_TAG_enumerator:
22690       /* These tags always have simple identifiers already; no need
22691          to canonicalize them.  */
22692       return DW_STRING (attr);
22693
22694     case DW_TAG_namespace:
22695       if (attr != NULL && DW_STRING (attr) != NULL)
22696         return DW_STRING (attr);
22697       return CP_ANONYMOUS_NAMESPACE_STR;
22698
22699     case DW_TAG_class_type:
22700     case DW_TAG_interface_type:
22701     case DW_TAG_structure_type:
22702     case DW_TAG_union_type:
22703       /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
22704          structures or unions.  These were of the form "._%d" in GCC 4.1,
22705          or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
22706          and GCC 4.4.  We work around this problem by ignoring these.  */
22707       if (attr && DW_STRING (attr)
22708           && (startswith (DW_STRING (attr), "._")
22709               || startswith (DW_STRING (attr), "<anonymous")))
22710         return NULL;
22711
22712       /* GCC might emit a nameless typedef that has a linkage name.  See
22713          http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510.  */
22714       if (!attr || DW_STRING (attr) == NULL)
22715         {
22716           char *demangled = NULL;
22717
22718           attr = dw2_linkage_name_attr (die, cu);
22719           if (attr == NULL || DW_STRING (attr) == NULL)
22720             return NULL;
22721
22722           /* Avoid demangling DW_STRING (attr) the second time on a second
22723              call for the same DIE.  */
22724           if (!DW_STRING_IS_CANONICAL (attr))
22725             demangled = gdb_demangle (DW_STRING (attr), DMGL_TYPES);
22726
22727           if (demangled)
22728             {
22729               const char *base;
22730
22731               /* FIXME: we already did this for the partial symbol... */
22732               DW_STRING (attr)
22733                 = ((const char *)
22734                    obstack_copy0 (&objfile->per_bfd->storage_obstack,
22735                                   demangled, strlen (demangled)));
22736               DW_STRING_IS_CANONICAL (attr) = 1;
22737               xfree (demangled);
22738
22739               /* Strip any leading namespaces/classes, keep only the base name.
22740                  DW_AT_name for named DIEs does not contain the prefixes.  */
22741               base = strrchr (DW_STRING (attr), ':');
22742               if (base && base > DW_STRING (attr) && base[-1] == ':')
22743                 return &base[1];
22744               else
22745                 return DW_STRING (attr);
22746             }
22747         }
22748       break;
22749
22750     default:
22751       break;
22752     }
22753
22754   if (!DW_STRING_IS_CANONICAL (attr))
22755     {
22756       DW_STRING (attr)
22757         = dwarf2_canonicalize_name (DW_STRING (attr), cu,
22758                                     &objfile->per_bfd->storage_obstack);
22759       DW_STRING_IS_CANONICAL (attr) = 1;
22760     }
22761   return DW_STRING (attr);
22762 }
22763
22764 /* Return the die that this die in an extension of, or NULL if there
22765    is none.  *EXT_CU is the CU containing DIE on input, and the CU
22766    containing the return value on output.  */
22767
22768 static struct die_info *
22769 dwarf2_extension (struct die_info *die, struct dwarf2_cu **ext_cu)
22770 {
22771   struct attribute *attr;
22772
22773   attr = dwarf2_attr (die, DW_AT_extension, *ext_cu);
22774   if (attr == NULL)
22775     return NULL;
22776
22777   return follow_die_ref (die, attr, ext_cu);
22778 }
22779
22780 /* Convert a DIE tag into its string name.  */
22781
22782 static const char *
22783 dwarf_tag_name (unsigned tag)
22784 {
22785   const char *name = get_DW_TAG_name (tag);
22786
22787   if (name == NULL)
22788     return "DW_TAG_<unknown>";
22789
22790   return name;
22791 }
22792
22793 /* Convert a DWARF attribute code into its string name.  */
22794
22795 static const char *
22796 dwarf_attr_name (unsigned attr)
22797 {
22798   const char *name;
22799
22800 #ifdef MIPS /* collides with DW_AT_HP_block_index */
22801   if (attr == DW_AT_MIPS_fde)
22802     return "DW_AT_MIPS_fde";
22803 #else
22804   if (attr == DW_AT_HP_block_index)
22805     return "DW_AT_HP_block_index";
22806 #endif
22807
22808   name = get_DW_AT_name (attr);
22809
22810   if (name == NULL)
22811     return "DW_AT_<unknown>";
22812
22813   return name;
22814 }
22815
22816 /* Convert a DWARF value form code into its string name.  */
22817
22818 static const char *
22819 dwarf_form_name (unsigned form)
22820 {
22821   const char *name = get_DW_FORM_name (form);
22822
22823   if (name == NULL)
22824     return "DW_FORM_<unknown>";
22825
22826   return name;
22827 }
22828
22829 static const char *
22830 dwarf_bool_name (unsigned mybool)
22831 {
22832   if (mybool)
22833     return "TRUE";
22834   else
22835     return "FALSE";
22836 }
22837
22838 /* Convert a DWARF type code into its string name.  */
22839
22840 static const char *
22841 dwarf_type_encoding_name (unsigned enc)
22842 {
22843   const char *name = get_DW_ATE_name (enc);
22844
22845   if (name == NULL)
22846     return "DW_ATE_<unknown>";
22847
22848   return name;
22849 }
22850
22851 static void
22852 dump_die_shallow (struct ui_file *f, int indent, struct die_info *die)
22853 {
22854   unsigned int i;
22855
22856   print_spaces (indent, f);
22857   fprintf_unfiltered (f, "Die: %s (abbrev %d, offset %s)\n",
22858                       dwarf_tag_name (die->tag), die->abbrev,
22859                       sect_offset_str (die->sect_off));
22860
22861   if (die->parent != NULL)
22862     {
22863       print_spaces (indent, f);
22864       fprintf_unfiltered (f, "  parent at offset: %s\n",
22865                           sect_offset_str (die->parent->sect_off));
22866     }
22867
22868   print_spaces (indent, f);
22869   fprintf_unfiltered (f, "  has children: %s\n",
22870            dwarf_bool_name (die->child != NULL));
22871
22872   print_spaces (indent, f);
22873   fprintf_unfiltered (f, "  attributes:\n");
22874
22875   for (i = 0; i < die->num_attrs; ++i)
22876     {
22877       print_spaces (indent, f);
22878       fprintf_unfiltered (f, "    %s (%s) ",
22879                dwarf_attr_name (die->attrs[i].name),
22880                dwarf_form_name (die->attrs[i].form));
22881
22882       switch (die->attrs[i].form)
22883         {
22884         case DW_FORM_addr:
22885         case DW_FORM_addrx:
22886         case DW_FORM_GNU_addr_index:
22887           fprintf_unfiltered (f, "address: ");
22888           fputs_filtered (hex_string (DW_ADDR (&die->attrs[i])), f);
22889           break;
22890         case DW_FORM_block2:
22891         case DW_FORM_block4:
22892         case DW_FORM_block:
22893         case DW_FORM_block1:
22894           fprintf_unfiltered (f, "block: size %s",
22895                               pulongest (DW_BLOCK (&die->attrs[i])->size));
22896           break;
22897         case DW_FORM_exprloc:
22898           fprintf_unfiltered (f, "expression: size %s",
22899                               pulongest (DW_BLOCK (&die->attrs[i])->size));
22900           break;
22901         case DW_FORM_data16:
22902           fprintf_unfiltered (f, "constant of 16 bytes");
22903           break;
22904         case DW_FORM_ref_addr:
22905           fprintf_unfiltered (f, "ref address: ");
22906           fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
22907           break;
22908         case DW_FORM_GNU_ref_alt:
22909           fprintf_unfiltered (f, "alt ref address: ");
22910           fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
22911           break;
22912         case DW_FORM_ref1:
22913         case DW_FORM_ref2:
22914         case DW_FORM_ref4:
22915         case DW_FORM_ref8:
22916         case DW_FORM_ref_udata:
22917           fprintf_unfiltered (f, "constant ref: 0x%lx (adjusted)",
22918                               (long) (DW_UNSND (&die->attrs[i])));
22919           break;
22920         case DW_FORM_data1:
22921         case DW_FORM_data2:
22922         case DW_FORM_data4:
22923         case DW_FORM_data8:
22924         case DW_FORM_udata:
22925         case DW_FORM_sdata:
22926           fprintf_unfiltered (f, "constant: %s",
22927                               pulongest (DW_UNSND (&die->attrs[i])));
22928           break;
22929         case DW_FORM_sec_offset:
22930           fprintf_unfiltered (f, "section offset: %s",
22931                               pulongest (DW_UNSND (&die->attrs[i])));
22932           break;
22933         case DW_FORM_ref_sig8:
22934           fprintf_unfiltered (f, "signature: %s",
22935                               hex_string (DW_SIGNATURE (&die->attrs[i])));
22936           break;
22937         case DW_FORM_string:
22938         case DW_FORM_strp:
22939         case DW_FORM_line_strp:
22940         case DW_FORM_strx:
22941         case DW_FORM_GNU_str_index:
22942         case DW_FORM_GNU_strp_alt:
22943           fprintf_unfiltered (f, "string: \"%s\" (%s canonicalized)",
22944                    DW_STRING (&die->attrs[i])
22945                    ? DW_STRING (&die->attrs[i]) : "",
22946                    DW_STRING_IS_CANONICAL (&die->attrs[i]) ? "is" : "not");
22947           break;
22948         case DW_FORM_flag:
22949           if (DW_UNSND (&die->attrs[i]))
22950             fprintf_unfiltered (f, "flag: TRUE");
22951           else
22952             fprintf_unfiltered (f, "flag: FALSE");
22953           break;
22954         case DW_FORM_flag_present:
22955           fprintf_unfiltered (f, "flag: TRUE");
22956           break;
22957         case DW_FORM_indirect:
22958           /* The reader will have reduced the indirect form to
22959              the "base form" so this form should not occur.  */
22960           fprintf_unfiltered (f, 
22961                               "unexpected attribute form: DW_FORM_indirect");
22962           break;
22963         case DW_FORM_implicit_const:
22964           fprintf_unfiltered (f, "constant: %s",
22965                               plongest (DW_SND (&die->attrs[i])));
22966           break;
22967         default:
22968           fprintf_unfiltered (f, "unsupported attribute form: %d.",
22969                    die->attrs[i].form);
22970           break;
22971         }
22972       fprintf_unfiltered (f, "\n");
22973     }
22974 }
22975
22976 static void
22977 dump_die_for_error (struct die_info *die)
22978 {
22979   dump_die_shallow (gdb_stderr, 0, die);
22980 }
22981
22982 static void
22983 dump_die_1 (struct ui_file *f, int level, int max_level, struct die_info *die)
22984 {
22985   int indent = level * 4;
22986
22987   gdb_assert (die != NULL);
22988
22989   if (level >= max_level)
22990     return;
22991
22992   dump_die_shallow (f, indent, die);
22993
22994   if (die->child != NULL)
22995     {
22996       print_spaces (indent, f);
22997       fprintf_unfiltered (f, "  Children:");
22998       if (level + 1 < max_level)
22999         {
23000           fprintf_unfiltered (f, "\n");
23001           dump_die_1 (f, level + 1, max_level, die->child);
23002         }
23003       else
23004         {
23005           fprintf_unfiltered (f,
23006                               " [not printed, max nesting level reached]\n");
23007         }
23008     }
23009
23010   if (die->sibling != NULL && level > 0)
23011     {
23012       dump_die_1 (f, level, max_level, die->sibling);
23013     }
23014 }
23015
23016 /* This is called from the pdie macro in gdbinit.in.
23017    It's not static so gcc will keep a copy callable from gdb.  */
23018
23019 void
23020 dump_die (struct die_info *die, int max_level)
23021 {
23022   dump_die_1 (gdb_stdlog, 0, max_level, die);
23023 }
23024
23025 static void
23026 store_in_ref_table (struct die_info *die, struct dwarf2_cu *cu)
23027 {
23028   void **slot;
23029
23030   slot = htab_find_slot_with_hash (cu->die_hash, die,
23031                                    to_underlying (die->sect_off),
23032                                    INSERT);
23033
23034   *slot = die;
23035 }
23036
23037 /* Return DIE offset of ATTR.  Return 0 with complaint if ATTR is not of the
23038    required kind.  */
23039
23040 static sect_offset
23041 dwarf2_get_ref_die_offset (const struct attribute *attr)
23042 {
23043   if (attr_form_is_ref (attr))
23044     return (sect_offset) DW_UNSND (attr);
23045
23046   complaint (_("unsupported die ref attribute form: '%s'"),
23047              dwarf_form_name (attr->form));
23048   return {};
23049 }
23050
23051 /* Return the constant value held by ATTR.  Return DEFAULT_VALUE if
23052  * the value held by the attribute is not constant.  */
23053
23054 static LONGEST
23055 dwarf2_get_attr_constant_value (const struct attribute *attr, int default_value)
23056 {
23057   if (attr->form == DW_FORM_sdata || attr->form == DW_FORM_implicit_const)
23058     return DW_SND (attr);
23059   else if (attr->form == DW_FORM_udata
23060            || attr->form == DW_FORM_data1
23061            || attr->form == DW_FORM_data2
23062            || attr->form == DW_FORM_data4
23063            || attr->form == DW_FORM_data8)
23064     return DW_UNSND (attr);
23065   else
23066     {
23067       /* For DW_FORM_data16 see attr_form_is_constant.  */
23068       complaint (_("Attribute value is not a constant (%s)"),
23069                  dwarf_form_name (attr->form));
23070       return default_value;
23071     }
23072 }
23073
23074 /* Follow reference or signature attribute ATTR of SRC_DIE.
23075    On entry *REF_CU is the CU of SRC_DIE.
23076    On exit *REF_CU is the CU of the result.  */
23077
23078 static struct die_info *
23079 follow_die_ref_or_sig (struct die_info *src_die, const struct attribute *attr,
23080                        struct dwarf2_cu **ref_cu)
23081 {
23082   struct die_info *die;
23083
23084   if (attr_form_is_ref (attr))
23085     die = follow_die_ref (src_die, attr, ref_cu);
23086   else if (attr->form == DW_FORM_ref_sig8)
23087     die = follow_die_sig (src_die, attr, ref_cu);
23088   else
23089     {
23090       dump_die_for_error (src_die);
23091       error (_("Dwarf Error: Expected reference attribute [in module %s]"),
23092              objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23093     }
23094
23095   return die;
23096 }
23097
23098 /* Follow reference OFFSET.
23099    On entry *REF_CU is the CU of the source die referencing OFFSET.
23100    On exit *REF_CU is the CU of the result.
23101    Returns NULL if OFFSET is invalid.  */
23102
23103 static struct die_info *
23104 follow_die_offset (sect_offset sect_off, int offset_in_dwz,
23105                    struct dwarf2_cu **ref_cu)
23106 {
23107   struct die_info temp_die;
23108   struct dwarf2_cu *target_cu, *cu = *ref_cu;
23109   struct dwarf2_per_objfile *dwarf2_per_objfile
23110     = cu->per_cu->dwarf2_per_objfile;
23111
23112   gdb_assert (cu->per_cu != NULL);
23113
23114   target_cu = cu;
23115
23116   if (cu->per_cu->is_debug_types)
23117     {
23118       /* .debug_types CUs cannot reference anything outside their CU.
23119          If they need to, they have to reference a signatured type via
23120          DW_FORM_ref_sig8.  */
23121       if (!offset_in_cu_p (&cu->header, sect_off))
23122         return NULL;
23123     }
23124   else if (offset_in_dwz != cu->per_cu->is_dwz
23125            || !offset_in_cu_p (&cu->header, sect_off))
23126     {
23127       struct dwarf2_per_cu_data *per_cu;
23128
23129       per_cu = dwarf2_find_containing_comp_unit (sect_off, offset_in_dwz,
23130                                                  dwarf2_per_objfile);
23131
23132       /* If necessary, add it to the queue and load its DIEs.  */
23133       if (maybe_queue_comp_unit (cu, per_cu, cu->language))
23134         load_full_comp_unit (per_cu, false, cu->language);
23135
23136       target_cu = per_cu->cu;
23137     }
23138   else if (cu->dies == NULL)
23139     {
23140       /* We're loading full DIEs during partial symbol reading.  */
23141       gdb_assert (dwarf2_per_objfile->reading_partial_symbols);
23142       load_full_comp_unit (cu->per_cu, false, language_minimal);
23143     }
23144
23145   *ref_cu = target_cu;
23146   temp_die.sect_off = sect_off;
23147
23148   if (target_cu != cu)
23149     target_cu->ancestor = cu;
23150
23151   return (struct die_info *) htab_find_with_hash (target_cu->die_hash,
23152                                                   &temp_die,
23153                                                   to_underlying (sect_off));
23154 }
23155
23156 /* Follow reference attribute ATTR of SRC_DIE.
23157    On entry *REF_CU is the CU of SRC_DIE.
23158    On exit *REF_CU is the CU of the result.  */
23159
23160 static struct die_info *
23161 follow_die_ref (struct die_info *src_die, const struct attribute *attr,
23162                 struct dwarf2_cu **ref_cu)
23163 {
23164   sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
23165   struct dwarf2_cu *cu = *ref_cu;
23166   struct die_info *die;
23167
23168   die = follow_die_offset (sect_off,
23169                            (attr->form == DW_FORM_GNU_ref_alt
23170                             || cu->per_cu->is_dwz),
23171                            ref_cu);
23172   if (!die)
23173     error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
23174            "at %s [in module %s]"),
23175            sect_offset_str (sect_off), sect_offset_str (src_die->sect_off),
23176            objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
23177
23178   return die;
23179 }
23180
23181 /* Return DWARF block referenced by DW_AT_location of DIE at SECT_OFF at PER_CU.
23182    Returned value is intended for DW_OP_call*.  Returned
23183    dwarf2_locexpr_baton->data has lifetime of
23184    PER_CU->DWARF2_PER_OBJFILE->OBJFILE.  */
23185
23186 struct dwarf2_locexpr_baton
23187 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off,
23188                                struct dwarf2_per_cu_data *per_cu,
23189                                CORE_ADDR (*get_frame_pc) (void *baton),
23190                                void *baton, bool resolve_abstract_p)
23191 {
23192   struct dwarf2_cu *cu;
23193   struct die_info *die;
23194   struct attribute *attr;
23195   struct dwarf2_locexpr_baton retval;
23196   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
23197   struct objfile *objfile = dwarf2_per_objfile->objfile;
23198
23199   if (per_cu->cu == NULL)
23200     load_cu (per_cu, false);
23201   cu = per_cu->cu;
23202   if (cu == NULL)
23203     {
23204       /* We shouldn't get here for a dummy CU, but don't crash on the user.
23205          Instead just throw an error, not much else we can do.  */
23206       error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23207              sect_offset_str (sect_off), objfile_name (objfile));
23208     }
23209
23210   die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23211   if (!die)
23212     error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23213            sect_offset_str (sect_off), objfile_name (objfile));
23214
23215   attr = dwarf2_attr (die, DW_AT_location, cu);
23216   if (!attr && resolve_abstract_p
23217       && (dwarf2_per_objfile->abstract_to_concrete.find (die)
23218           != dwarf2_per_objfile->abstract_to_concrete.end ()))
23219     {
23220       CORE_ADDR pc = (*get_frame_pc) (baton);
23221
23222       for (const auto &cand : dwarf2_per_objfile->abstract_to_concrete[die])
23223         {
23224           if (!cand->parent
23225               || cand->parent->tag != DW_TAG_subprogram)
23226             continue;
23227
23228           CORE_ADDR pc_low, pc_high;
23229           get_scope_pc_bounds (cand->parent, &pc_low, &pc_high, cu);
23230           if (pc_low == ((CORE_ADDR) -1)
23231               || !(pc_low <= pc && pc < pc_high))
23232             continue;
23233
23234           die = cand;
23235           attr = dwarf2_attr (die, DW_AT_location, cu);
23236           break;
23237         }
23238     }
23239
23240   if (!attr)
23241     {
23242       /* DWARF: "If there is no such attribute, then there is no effect.".
23243          DATA is ignored if SIZE is 0.  */
23244
23245       retval.data = NULL;
23246       retval.size = 0;
23247     }
23248   else if (attr_form_is_section_offset (attr))
23249     {
23250       struct dwarf2_loclist_baton loclist_baton;
23251       CORE_ADDR pc = (*get_frame_pc) (baton);
23252       size_t size;
23253
23254       fill_in_loclist_baton (cu, &loclist_baton, attr);
23255
23256       retval.data = dwarf2_find_location_expression (&loclist_baton,
23257                                                      &size, pc);
23258       retval.size = size;
23259     }
23260   else
23261     {
23262       if (!attr_form_is_block (attr))
23263         error (_("Dwarf Error: DIE at %s referenced in module %s "
23264                  "is neither DW_FORM_block* nor DW_FORM_exprloc"),
23265                sect_offset_str (sect_off), objfile_name (objfile));
23266
23267       retval.data = DW_BLOCK (attr)->data;
23268       retval.size = DW_BLOCK (attr)->size;
23269     }
23270   retval.per_cu = cu->per_cu;
23271
23272   age_cached_comp_units (dwarf2_per_objfile);
23273
23274   return retval;
23275 }
23276
23277 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
23278    offset.  */
23279
23280 struct dwarf2_locexpr_baton
23281 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu,
23282                              struct dwarf2_per_cu_data *per_cu,
23283                              CORE_ADDR (*get_frame_pc) (void *baton),
23284                              void *baton)
23285 {
23286   sect_offset sect_off = per_cu->sect_off + to_underlying (offset_in_cu);
23287
23288   return dwarf2_fetch_die_loc_sect_off (sect_off, per_cu, get_frame_pc, baton);
23289 }
23290
23291 /* Write a constant of a given type as target-ordered bytes into
23292    OBSTACK.  */
23293
23294 static const gdb_byte *
23295 write_constant_as_bytes (struct obstack *obstack,
23296                          enum bfd_endian byte_order,
23297                          struct type *type,
23298                          ULONGEST value,
23299                          LONGEST *len)
23300 {
23301   gdb_byte *result;
23302
23303   *len = TYPE_LENGTH (type);
23304   result = (gdb_byte *) obstack_alloc (obstack, *len);
23305   store_unsigned_integer (result, *len, byte_order, value);
23306
23307   return result;
23308 }
23309
23310 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
23311    pointer to the constant bytes and set LEN to the length of the
23312    data.  If memory is needed, allocate it on OBSTACK.  If the DIE
23313    does not have a DW_AT_const_value, return NULL.  */
23314
23315 const gdb_byte *
23316 dwarf2_fetch_constant_bytes (sect_offset sect_off,
23317                              struct dwarf2_per_cu_data *per_cu,
23318                              struct obstack *obstack,
23319                              LONGEST *len)
23320 {
23321   struct dwarf2_cu *cu;
23322   struct die_info *die;
23323   struct attribute *attr;
23324   const gdb_byte *result = NULL;
23325   struct type *type;
23326   LONGEST value;
23327   enum bfd_endian byte_order;
23328   struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
23329
23330   if (per_cu->cu == NULL)
23331     load_cu (per_cu, false);
23332   cu = per_cu->cu;
23333   if (cu == NULL)
23334     {
23335       /* We shouldn't get here for a dummy CU, but don't crash on the user.
23336          Instead just throw an error, not much else we can do.  */
23337       error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23338              sect_offset_str (sect_off), objfile_name (objfile));
23339     }
23340
23341   die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23342   if (!die)
23343     error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23344            sect_offset_str (sect_off), objfile_name (objfile));
23345
23346   attr = dwarf2_attr (die, DW_AT_const_value, cu);
23347   if (attr == NULL)
23348     return NULL;
23349
23350   byte_order = (bfd_big_endian (objfile->obfd)
23351                 ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
23352
23353   switch (attr->form)
23354     {
23355     case DW_FORM_addr:
23356     case DW_FORM_addrx:
23357     case DW_FORM_GNU_addr_index:
23358       {
23359         gdb_byte *tem;
23360
23361         *len = cu->header.addr_size;
23362         tem = (gdb_byte *) obstack_alloc (obstack, *len);
23363         store_unsigned_integer (tem, *len, byte_order, DW_ADDR (attr));
23364         result = tem;
23365       }
23366       break;
23367     case DW_FORM_string:
23368     case DW_FORM_strp:
23369     case DW_FORM_strx:
23370     case DW_FORM_GNU_str_index:
23371     case DW_FORM_GNU_strp_alt:
23372       /* DW_STRING is already allocated on the objfile obstack, point
23373          directly to it.  */
23374       result = (const gdb_byte *) DW_STRING (attr);
23375       *len = strlen (DW_STRING (attr));
23376       break;
23377     case DW_FORM_block1:
23378     case DW_FORM_block2:
23379     case DW_FORM_block4:
23380     case DW_FORM_block:
23381     case DW_FORM_exprloc:
23382     case DW_FORM_data16:
23383       result = DW_BLOCK (attr)->data;
23384       *len = DW_BLOCK (attr)->size;
23385       break;
23386
23387       /* The DW_AT_const_value attributes are supposed to carry the
23388          symbol's value "represented as it would be on the target
23389          architecture."  By the time we get here, it's already been
23390          converted to host endianness, so we just need to sign- or
23391          zero-extend it as appropriate.  */
23392     case DW_FORM_data1:
23393       type = die_type (die, cu);
23394       result = dwarf2_const_value_data (attr, obstack, cu, &value, 8);
23395       if (result == NULL)
23396         result = write_constant_as_bytes (obstack, byte_order,
23397                                           type, value, len);
23398       break;
23399     case DW_FORM_data2:
23400       type = die_type (die, cu);
23401       result = dwarf2_const_value_data (attr, obstack, cu, &value, 16);
23402       if (result == NULL)
23403         result = write_constant_as_bytes (obstack, byte_order,
23404                                           type, value, len);
23405       break;
23406     case DW_FORM_data4:
23407       type = die_type (die, cu);
23408       result = dwarf2_const_value_data (attr, obstack, cu, &value, 32);
23409       if (result == NULL)
23410         result = write_constant_as_bytes (obstack, byte_order,
23411                                           type, value, len);
23412       break;
23413     case DW_FORM_data8:
23414       type = die_type (die, cu);
23415       result = dwarf2_const_value_data (attr, obstack, cu, &value, 64);
23416       if (result == NULL)
23417         result = write_constant_as_bytes (obstack, byte_order,
23418                                           type, value, len);
23419       break;
23420
23421     case DW_FORM_sdata:
23422     case DW_FORM_implicit_const:
23423       type = die_type (die, cu);
23424       result = write_constant_as_bytes (obstack, byte_order,
23425                                         type, DW_SND (attr), len);
23426       break;
23427
23428     case DW_FORM_udata:
23429       type = die_type (die, cu);
23430       result = write_constant_as_bytes (obstack, byte_order,
23431                                         type, DW_UNSND (attr), len);
23432       break;
23433
23434     default:
23435       complaint (_("unsupported const value attribute form: '%s'"),
23436                  dwarf_form_name (attr->form));
23437       break;
23438     }
23439
23440   return result;
23441 }
23442
23443 /* Return the type of the die at OFFSET in PER_CU.  Return NULL if no
23444    valid type for this die is found.  */
23445
23446 struct type *
23447 dwarf2_fetch_die_type_sect_off (sect_offset sect_off,
23448                                 struct dwarf2_per_cu_data *per_cu)
23449 {
23450   struct dwarf2_cu *cu;
23451   struct die_info *die;
23452
23453   if (per_cu->cu == NULL)
23454     load_cu (per_cu, false);
23455   cu = per_cu->cu;
23456   if (!cu)
23457     return NULL;
23458
23459   die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23460   if (!die)
23461     return NULL;
23462
23463   return die_type (die, cu);
23464 }
23465
23466 /* Return the type of the DIE at DIE_OFFSET in the CU named by
23467    PER_CU.  */
23468
23469 struct type *
23470 dwarf2_get_die_type (cu_offset die_offset,
23471                      struct dwarf2_per_cu_data *per_cu)
23472 {
23473   sect_offset die_offset_sect = per_cu->sect_off + to_underlying (die_offset);
23474   return get_die_type_at_offset (die_offset_sect, per_cu);
23475 }
23476
23477 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
23478    On entry *REF_CU is the CU of SRC_DIE.
23479    On exit *REF_CU is the CU of the result.
23480    Returns NULL if the referenced DIE isn't found.  */
23481
23482 static struct die_info *
23483 follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type,
23484                   struct dwarf2_cu **ref_cu)
23485 {
23486   struct die_info temp_die;
23487   struct dwarf2_cu *sig_cu, *cu = *ref_cu;
23488   struct die_info *die;
23489
23490   /* While it might be nice to assert sig_type->type == NULL here,
23491      we can get here for DW_AT_imported_declaration where we need
23492      the DIE not the type.  */
23493
23494   /* If necessary, add it to the queue and load its DIEs.  */
23495
23496   if (maybe_queue_comp_unit (*ref_cu, &sig_type->per_cu, language_minimal))
23497     read_signatured_type (sig_type);
23498
23499   sig_cu = sig_type->per_cu.cu;
23500   gdb_assert (sig_cu != NULL);
23501   gdb_assert (to_underlying (sig_type->type_offset_in_section) != 0);
23502   temp_die.sect_off = sig_type->type_offset_in_section;
23503   die = (struct die_info *) htab_find_with_hash (sig_cu->die_hash, &temp_die,
23504                                                  to_underlying (temp_die.sect_off));
23505   if (die)
23506     {
23507       struct dwarf2_per_objfile *dwarf2_per_objfile
23508         = (*ref_cu)->per_cu->dwarf2_per_objfile;
23509
23510       /* For .gdb_index version 7 keep track of included TUs.
23511          http://sourceware.org/bugzilla/show_bug.cgi?id=15021.  */
23512       if (dwarf2_per_objfile->index_table != NULL
23513           && dwarf2_per_objfile->index_table->version <= 7)
23514         {
23515           VEC_safe_push (dwarf2_per_cu_ptr,
23516                          (*ref_cu)->per_cu->imported_symtabs,
23517                          sig_cu->per_cu);
23518         }
23519
23520       *ref_cu = sig_cu;
23521       if (sig_cu != cu)
23522         sig_cu->ancestor = cu;
23523
23524       return die;
23525     }
23526
23527   return NULL;
23528 }
23529
23530 /* Follow signatured type referenced by ATTR in SRC_DIE.
23531    On entry *REF_CU is the CU of SRC_DIE.
23532    On exit *REF_CU is the CU of the result.
23533    The result is the DIE of the type.
23534    If the referenced type cannot be found an error is thrown.  */
23535
23536 static struct die_info *
23537 follow_die_sig (struct die_info *src_die, const struct attribute *attr,
23538                 struct dwarf2_cu **ref_cu)
23539 {
23540   ULONGEST signature = DW_SIGNATURE (attr);
23541   struct signatured_type *sig_type;
23542   struct die_info *die;
23543
23544   gdb_assert (attr->form == DW_FORM_ref_sig8);
23545
23546   sig_type = lookup_signatured_type (*ref_cu, signature);
23547   /* sig_type will be NULL if the signatured type is missing from
23548      the debug info.  */
23549   if (sig_type == NULL)
23550     {
23551       error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23552                " from DIE at %s [in module %s]"),
23553              hex_string (signature), sect_offset_str (src_die->sect_off),
23554              objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23555     }
23556
23557   die = follow_die_sig_1 (src_die, sig_type, ref_cu);
23558   if (die == NULL)
23559     {
23560       dump_die_for_error (src_die);
23561       error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23562                " from DIE at %s [in module %s]"),
23563              hex_string (signature), sect_offset_str (src_die->sect_off),
23564              objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23565     }
23566
23567   return die;
23568 }
23569
23570 /* Get the type specified by SIGNATURE referenced in DIE/CU,
23571    reading in and processing the type unit if necessary.  */
23572
23573 static struct type *
23574 get_signatured_type (struct die_info *die, ULONGEST signature,
23575                      struct dwarf2_cu *cu)
23576 {
23577   struct dwarf2_per_objfile *dwarf2_per_objfile
23578     = cu->per_cu->dwarf2_per_objfile;
23579   struct signatured_type *sig_type;
23580   struct dwarf2_cu *type_cu;
23581   struct die_info *type_die;
23582   struct type *type;
23583
23584   sig_type = lookup_signatured_type (cu, signature);
23585   /* sig_type will be NULL if the signatured type is missing from
23586      the debug info.  */
23587   if (sig_type == NULL)
23588     {
23589       complaint (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23590                    " from DIE at %s [in module %s]"),
23591                  hex_string (signature), sect_offset_str (die->sect_off),
23592                  objfile_name (dwarf2_per_objfile->objfile));
23593       return build_error_marker_type (cu, die);
23594     }
23595
23596   /* If we already know the type we're done.  */
23597   if (sig_type->type != NULL)
23598     return sig_type->type;
23599
23600   type_cu = cu;
23601   type_die = follow_die_sig_1 (die, sig_type, &type_cu);
23602   if (type_die != NULL)
23603     {
23604       /* N.B. We need to call get_die_type to ensure only one type for this DIE
23605          is created.  This is important, for example, because for c++ classes
23606          we need TYPE_NAME set which is only done by new_symbol.  Blech.  */
23607       type = read_type_die (type_die, type_cu);
23608       if (type == NULL)
23609         {
23610           complaint (_("Dwarf Error: Cannot build signatured type %s"
23611                        " referenced from DIE at %s [in module %s]"),
23612                      hex_string (signature), sect_offset_str (die->sect_off),
23613                      objfile_name (dwarf2_per_objfile->objfile));
23614           type = build_error_marker_type (cu, die);
23615         }
23616     }
23617   else
23618     {
23619       complaint (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23620                    " from DIE at %s [in module %s]"),
23621                  hex_string (signature), sect_offset_str (die->sect_off),
23622                  objfile_name (dwarf2_per_objfile->objfile));
23623       type = build_error_marker_type (cu, die);
23624     }
23625   sig_type->type = type;
23626
23627   return type;
23628 }
23629
23630 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
23631    reading in and processing the type unit if necessary.  */
23632
23633 static struct type *
23634 get_DW_AT_signature_type (struct die_info *die, const struct attribute *attr,
23635                           struct dwarf2_cu *cu) /* ARI: editCase function */
23636 {
23637   /* Yes, DW_AT_signature can use a non-ref_sig8 reference.  */
23638   if (attr_form_is_ref (attr))
23639     {
23640       struct dwarf2_cu *type_cu = cu;
23641       struct die_info *type_die = follow_die_ref (die, attr, &type_cu);
23642
23643       return read_type_die (type_die, type_cu);
23644     }
23645   else if (attr->form == DW_FORM_ref_sig8)
23646     {
23647       return get_signatured_type (die, DW_SIGNATURE (attr), cu);
23648     }
23649   else
23650     {
23651       struct dwarf2_per_objfile *dwarf2_per_objfile
23652         = cu->per_cu->dwarf2_per_objfile;
23653
23654       complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
23655                    " at %s [in module %s]"),
23656                  dwarf_form_name (attr->form), sect_offset_str (die->sect_off),
23657                  objfile_name (dwarf2_per_objfile->objfile));
23658       return build_error_marker_type (cu, die);
23659     }
23660 }
23661
23662 /* Load the DIEs associated with type unit PER_CU into memory.  */
23663
23664 static void
23665 load_full_type_unit (struct dwarf2_per_cu_data *per_cu)
23666 {
23667   struct signatured_type *sig_type;
23668
23669   /* Caller is responsible for ensuring type_unit_groups don't get here.  */
23670   gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu));
23671
23672   /* We have the per_cu, but we need the signatured_type.
23673      Fortunately this is an easy translation.  */
23674   gdb_assert (per_cu->is_debug_types);
23675   sig_type = (struct signatured_type *) per_cu;
23676
23677   gdb_assert (per_cu->cu == NULL);
23678
23679   read_signatured_type (sig_type);
23680
23681   gdb_assert (per_cu->cu != NULL);
23682 }
23683
23684 /* die_reader_func for read_signatured_type.
23685    This is identical to load_full_comp_unit_reader,
23686    but is kept separate for now.  */
23687
23688 static void
23689 read_signatured_type_reader (const struct die_reader_specs *reader,
23690                              const gdb_byte *info_ptr,
23691                              struct die_info *comp_unit_die,
23692                              int has_children,
23693                              void *data)
23694 {
23695   struct dwarf2_cu *cu = reader->cu;
23696
23697   gdb_assert (cu->die_hash == NULL);
23698   cu->die_hash =
23699     htab_create_alloc_ex (cu->header.length / 12,
23700                           die_hash,
23701                           die_eq,
23702                           NULL,
23703                           &cu->comp_unit_obstack,
23704                           hashtab_obstack_allocate,
23705                           dummy_obstack_deallocate);
23706
23707   if (has_children)
23708     comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
23709                                                   &info_ptr, comp_unit_die);
23710   cu->dies = comp_unit_die;
23711   /* comp_unit_die is not stored in die_hash, no need.  */
23712
23713   /* We try not to read any attributes in this function, because not
23714      all CUs needed for references have been loaded yet, and symbol
23715      table processing isn't initialized.  But we have to set the CU language,
23716      or we won't be able to build types correctly.
23717      Similarly, if we do not read the producer, we can not apply
23718      producer-specific interpretation.  */
23719   prepare_one_comp_unit (cu, cu->dies, language_minimal);
23720 }
23721
23722 /* Read in a signatured type and build its CU and DIEs.
23723    If the type is a stub for the real type in a DWO file,
23724    read in the real type from the DWO file as well.  */
23725
23726 static void
23727 read_signatured_type (struct signatured_type *sig_type)
23728 {
23729   struct dwarf2_per_cu_data *per_cu = &sig_type->per_cu;
23730
23731   gdb_assert (per_cu->is_debug_types);
23732   gdb_assert (per_cu->cu == NULL);
23733
23734   init_cutu_and_read_dies (per_cu, NULL, 0, 1, false,
23735                            read_signatured_type_reader, NULL);
23736   sig_type->per_cu.tu_read = 1;
23737 }
23738
23739 /* Decode simple location descriptions.
23740    Given a pointer to a dwarf block that defines a location, compute
23741    the location and return the value.
23742
23743    NOTE drow/2003-11-18: This function is called in two situations
23744    now: for the address of static or global variables (partial symbols
23745    only) and for offsets into structures which are expected to be
23746    (more or less) constant.  The partial symbol case should go away,
23747    and only the constant case should remain.  That will let this
23748    function complain more accurately.  A few special modes are allowed
23749    without complaint for global variables (for instance, global
23750    register values and thread-local values).
23751
23752    A location description containing no operations indicates that the
23753    object is optimized out.  The return value is 0 for that case.
23754    FIXME drow/2003-11-16: No callers check for this case any more; soon all
23755    callers will only want a very basic result and this can become a
23756    complaint.
23757
23758    Note that stack[0] is unused except as a default error return.  */
23759
23760 static CORE_ADDR
23761 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
23762 {
23763   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
23764   size_t i;
23765   size_t size = blk->size;
23766   const gdb_byte *data = blk->data;
23767   CORE_ADDR stack[64];
23768   int stacki;
23769   unsigned int bytes_read, unsnd;
23770   gdb_byte op;
23771
23772   i = 0;
23773   stacki = 0;
23774   stack[stacki] = 0;
23775   stack[++stacki] = 0;
23776
23777   while (i < size)
23778     {
23779       op = data[i++];
23780       switch (op)
23781         {
23782         case DW_OP_lit0:
23783         case DW_OP_lit1:
23784         case DW_OP_lit2:
23785         case DW_OP_lit3:
23786         case DW_OP_lit4:
23787         case DW_OP_lit5:
23788         case DW_OP_lit6:
23789         case DW_OP_lit7:
23790         case DW_OP_lit8:
23791         case DW_OP_lit9:
23792         case DW_OP_lit10:
23793         case DW_OP_lit11:
23794         case DW_OP_lit12:
23795         case DW_OP_lit13:
23796         case DW_OP_lit14:
23797         case DW_OP_lit15:
23798         case DW_OP_lit16:
23799         case DW_OP_lit17:
23800         case DW_OP_lit18:
23801         case DW_OP_lit19:
23802         case DW_OP_lit20:
23803         case DW_OP_lit21:
23804         case DW_OP_lit22:
23805         case DW_OP_lit23:
23806         case DW_OP_lit24:
23807         case DW_OP_lit25:
23808         case DW_OP_lit26:
23809         case DW_OP_lit27:
23810         case DW_OP_lit28:
23811         case DW_OP_lit29:
23812         case DW_OP_lit30:
23813         case DW_OP_lit31:
23814           stack[++stacki] = op - DW_OP_lit0;
23815           break;
23816
23817         case DW_OP_reg0:
23818         case DW_OP_reg1:
23819         case DW_OP_reg2:
23820         case DW_OP_reg3:
23821         case DW_OP_reg4:
23822         case DW_OP_reg5:
23823         case DW_OP_reg6:
23824         case DW_OP_reg7:
23825         case DW_OP_reg8:
23826         case DW_OP_reg9:
23827         case DW_OP_reg10:
23828         case DW_OP_reg11:
23829         case DW_OP_reg12:
23830         case DW_OP_reg13:
23831         case DW_OP_reg14:
23832         case DW_OP_reg15:
23833         case DW_OP_reg16:
23834         case DW_OP_reg17:
23835         case DW_OP_reg18:
23836         case DW_OP_reg19:
23837         case DW_OP_reg20:
23838         case DW_OP_reg21:
23839         case DW_OP_reg22:
23840         case DW_OP_reg23:
23841         case DW_OP_reg24:
23842         case DW_OP_reg25:
23843         case DW_OP_reg26:
23844         case DW_OP_reg27:
23845         case DW_OP_reg28:
23846         case DW_OP_reg29:
23847         case DW_OP_reg30:
23848         case DW_OP_reg31:
23849           stack[++stacki] = op - DW_OP_reg0;
23850           if (i < size)
23851             dwarf2_complex_location_expr_complaint ();
23852           break;
23853
23854         case DW_OP_regx:
23855           unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
23856           i += bytes_read;
23857           stack[++stacki] = unsnd;
23858           if (i < size)
23859             dwarf2_complex_location_expr_complaint ();
23860           break;
23861
23862         case DW_OP_addr:
23863           stack[++stacki] = read_address (objfile->obfd, &data[i],
23864                                           cu, &bytes_read);
23865           i += bytes_read;
23866           break;
23867
23868         case DW_OP_const1u:
23869           stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
23870           i += 1;
23871           break;
23872
23873         case DW_OP_const1s:
23874           stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
23875           i += 1;
23876           break;
23877
23878         case DW_OP_const2u:
23879           stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
23880           i += 2;
23881           break;
23882
23883         case DW_OP_const2s:
23884           stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
23885           i += 2;
23886           break;
23887
23888         case DW_OP_const4u:
23889           stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
23890           i += 4;
23891           break;
23892
23893         case DW_OP_const4s:
23894           stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
23895           i += 4;
23896           break;
23897
23898         case DW_OP_const8u:
23899           stack[++stacki] = read_8_bytes (objfile->obfd, &data[i]);
23900           i += 8;
23901           break;
23902
23903         case DW_OP_constu:
23904           stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
23905                                                   &bytes_read);
23906           i += bytes_read;
23907           break;
23908
23909         case DW_OP_consts:
23910           stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
23911           i += bytes_read;
23912           break;
23913
23914         case DW_OP_dup:
23915           stack[stacki + 1] = stack[stacki];
23916           stacki++;
23917           break;
23918
23919         case DW_OP_plus:
23920           stack[stacki - 1] += stack[stacki];
23921           stacki--;
23922           break;
23923
23924         case DW_OP_plus_uconst:
23925           stack[stacki] += read_unsigned_leb128 (NULL, (data + i),
23926                                                  &bytes_read);
23927           i += bytes_read;
23928           break;
23929
23930         case DW_OP_minus:
23931           stack[stacki - 1] -= stack[stacki];
23932           stacki--;
23933           break;
23934
23935         case DW_OP_deref:
23936           /* If we're not the last op, then we definitely can't encode
23937              this using GDB's address_class enum.  This is valid for partial
23938              global symbols, although the variable's address will be bogus
23939              in the psymtab.  */
23940           if (i < size)
23941             dwarf2_complex_location_expr_complaint ();
23942           break;
23943
23944         case DW_OP_GNU_push_tls_address:
23945         case DW_OP_form_tls_address:
23946           /* The top of the stack has the offset from the beginning
23947              of the thread control block at which the variable is located.  */
23948           /* Nothing should follow this operator, so the top of stack would
23949              be returned.  */
23950           /* This is valid for partial global symbols, but the variable's
23951              address will be bogus in the psymtab.  Make it always at least
23952              non-zero to not look as a variable garbage collected by linker
23953              which have DW_OP_addr 0.  */
23954           if (i < size)
23955             dwarf2_complex_location_expr_complaint ();
23956           stack[stacki]++;
23957           break;
23958
23959         case DW_OP_GNU_uninit:
23960           break;
23961
23962         case DW_OP_addrx:
23963         case DW_OP_GNU_addr_index:
23964         case DW_OP_GNU_const_index:
23965           stack[++stacki] = read_addr_index_from_leb128 (cu, &data[i],
23966                                                          &bytes_read);
23967           i += bytes_read;
23968           break;
23969
23970         default:
23971           {
23972             const char *name = get_DW_OP_name (op);
23973
23974             if (name)
23975               complaint (_("unsupported stack op: '%s'"),
23976                          name);
23977             else
23978               complaint (_("unsupported stack op: '%02x'"),
23979                          op);
23980           }
23981
23982           return (stack[stacki]);
23983         }
23984
23985       /* Enforce maximum stack depth of SIZE-1 to avoid writing
23986          outside of the allocated space.  Also enforce minimum>0.  */
23987       if (stacki >= ARRAY_SIZE (stack) - 1)
23988         {
23989           complaint (_("location description stack overflow"));
23990           return 0;
23991         }
23992
23993       if (stacki <= 0)
23994         {
23995           complaint (_("location description stack underflow"));
23996           return 0;
23997         }
23998     }
23999   return (stack[stacki]);
24000 }
24001
24002 /* memory allocation interface */
24003
24004 static struct dwarf_block *
24005 dwarf_alloc_block (struct dwarf2_cu *cu)
24006 {
24007   return XOBNEW (&cu->comp_unit_obstack, struct dwarf_block);
24008 }
24009
24010 static struct die_info *
24011 dwarf_alloc_die (struct dwarf2_cu *cu, int num_attrs)
24012 {
24013   struct die_info *die;
24014   size_t size = sizeof (struct die_info);
24015
24016   if (num_attrs > 1)
24017     size += (num_attrs - 1) * sizeof (struct attribute);
24018
24019   die = (struct die_info *) obstack_alloc (&cu->comp_unit_obstack, size);
24020   memset (die, 0, sizeof (struct die_info));
24021   return (die);
24022 }
24023
24024 \f
24025 /* Macro support.  */
24026
24027 /* Return file name relative to the compilation directory of file number I in
24028    *LH's file name table.  The result is allocated using xmalloc; the caller is
24029    responsible for freeing it.  */
24030
24031 static char *
24032 file_file_name (int file, struct line_header *lh)
24033 {
24034   /* Is the file number a valid index into the line header's file name
24035      table?  Remember that file numbers start with one, not zero.  */
24036   if (1 <= file && file <= lh->file_names.size ())
24037     {
24038       const file_entry &fe = lh->file_names[file - 1];
24039
24040       if (!IS_ABSOLUTE_PATH (fe.name))
24041         {
24042           const char *dir = fe.include_dir (lh);
24043           if (dir != NULL)
24044             return concat (dir, SLASH_STRING, fe.name, (char *) NULL);
24045         }
24046       return xstrdup (fe.name);
24047     }
24048   else
24049     {
24050       /* The compiler produced a bogus file number.  We can at least
24051          record the macro definitions made in the file, even if we
24052          won't be able to find the file by name.  */
24053       char fake_name[80];
24054
24055       xsnprintf (fake_name, sizeof (fake_name),
24056                  "<bad macro file number %d>", file);
24057
24058       complaint (_("bad file number in macro information (%d)"),
24059                  file);
24060
24061       return xstrdup (fake_name);
24062     }
24063 }
24064
24065 /* Return the full name of file number I in *LH's file name table.
24066    Use COMP_DIR as the name of the current directory of the
24067    compilation.  The result is allocated using xmalloc; the caller is
24068    responsible for freeing it.  */
24069 static char *
24070 file_full_name (int file, struct line_header *lh, const char *comp_dir)
24071 {
24072   /* Is the file number a valid index into the line header's file name
24073      table?  Remember that file numbers start with one, not zero.  */
24074   if (1 <= file && file <= lh->file_names.size ())
24075     {
24076       char *relative = file_file_name (file, lh);
24077
24078       if (IS_ABSOLUTE_PATH (relative) || comp_dir == NULL)
24079         return relative;
24080       return reconcat (relative, comp_dir, SLASH_STRING,
24081                        relative, (char *) NULL);
24082     }
24083   else
24084     return file_file_name (file, lh);
24085 }
24086
24087
24088 static struct macro_source_file *
24089 macro_start_file (struct dwarf2_cu *cu,
24090                   int file, int line,
24091                   struct macro_source_file *current_file,
24092                   struct line_header *lh)
24093 {
24094   /* File name relative to the compilation directory of this source file.  */
24095   char *file_name = file_file_name (file, lh);
24096
24097   if (! current_file)
24098     {
24099       /* Note: We don't create a macro table for this compilation unit
24100          at all until we actually get a filename.  */
24101       struct macro_table *macro_table = cu->get_builder ()->get_macro_table ();
24102
24103       /* If we have no current file, then this must be the start_file
24104          directive for the compilation unit's main source file.  */
24105       current_file = macro_set_main (macro_table, file_name);
24106       macro_define_special (macro_table);
24107     }
24108   else
24109     current_file = macro_include (current_file, line, file_name);
24110
24111   xfree (file_name);
24112
24113   return current_file;
24114 }
24115
24116 static const char *
24117 consume_improper_spaces (const char *p, const char *body)
24118 {
24119   if (*p == ' ')
24120     {
24121       complaint (_("macro definition contains spaces "
24122                    "in formal argument list:\n`%s'"),
24123                  body);
24124
24125       while (*p == ' ')
24126         p++;
24127     }
24128
24129   return p;
24130 }
24131
24132
24133 static void
24134 parse_macro_definition (struct macro_source_file *file, int line,
24135                         const char *body)
24136 {
24137   const char *p;
24138
24139   /* The body string takes one of two forms.  For object-like macro
24140      definitions, it should be:
24141
24142         <macro name> " " <definition>
24143
24144      For function-like macro definitions, it should be:
24145
24146         <macro name> "() " <definition>
24147      or
24148         <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
24149
24150      Spaces may appear only where explicitly indicated, and in the
24151      <definition>.
24152
24153      The Dwarf 2 spec says that an object-like macro's name is always
24154      followed by a space, but versions of GCC around March 2002 omit
24155      the space when the macro's definition is the empty string.
24156
24157      The Dwarf 2 spec says that there should be no spaces between the
24158      formal arguments in a function-like macro's formal argument list,
24159      but versions of GCC around March 2002 include spaces after the
24160      commas.  */
24161
24162
24163   /* Find the extent of the macro name.  The macro name is terminated
24164      by either a space or null character (for an object-like macro) or
24165      an opening paren (for a function-like macro).  */
24166   for (p = body; *p; p++)
24167     if (*p == ' ' || *p == '(')
24168       break;
24169
24170   if (*p == ' ' || *p == '\0')
24171     {
24172       /* It's an object-like macro.  */
24173       int name_len = p - body;
24174       char *name = savestring (body, name_len);
24175       const char *replacement;
24176
24177       if (*p == ' ')
24178         replacement = body + name_len + 1;
24179       else
24180         {
24181           dwarf2_macro_malformed_definition_complaint (body);
24182           replacement = body + name_len;
24183         }
24184
24185       macro_define_object (file, line, name, replacement);
24186
24187       xfree (name);
24188     }
24189   else if (*p == '(')
24190     {
24191       /* It's a function-like macro.  */
24192       char *name = savestring (body, p - body);
24193       int argc = 0;
24194       int argv_size = 1;
24195       char **argv = XNEWVEC (char *, argv_size);
24196
24197       p++;
24198
24199       p = consume_improper_spaces (p, body);
24200
24201       /* Parse the formal argument list.  */
24202       while (*p && *p != ')')
24203         {
24204           /* Find the extent of the current argument name.  */
24205           const char *arg_start = p;
24206
24207           while (*p && *p != ',' && *p != ')' && *p != ' ')
24208             p++;
24209
24210           if (! *p || p == arg_start)
24211             dwarf2_macro_malformed_definition_complaint (body);
24212           else
24213             {
24214               /* Make sure argv has room for the new argument.  */
24215               if (argc >= argv_size)
24216                 {
24217                   argv_size *= 2;
24218                   argv = XRESIZEVEC (char *, argv, argv_size);
24219                 }
24220
24221               argv[argc++] = savestring (arg_start, p - arg_start);
24222             }
24223
24224           p = consume_improper_spaces (p, body);
24225
24226           /* Consume the comma, if present.  */
24227           if (*p == ',')
24228             {
24229               p++;
24230
24231               p = consume_improper_spaces (p, body);
24232             }
24233         }
24234
24235       if (*p == ')')
24236         {
24237           p++;
24238
24239           if (*p == ' ')
24240             /* Perfectly formed definition, no complaints.  */
24241             macro_define_function (file, line, name,
24242                                    argc, (const char **) argv,
24243                                    p + 1);
24244           else if (*p == '\0')
24245             {
24246               /* Complain, but do define it.  */
24247               dwarf2_macro_malformed_definition_complaint (body);
24248               macro_define_function (file, line, name,
24249                                      argc, (const char **) argv,
24250                                      p);
24251             }
24252           else
24253             /* Just complain.  */
24254             dwarf2_macro_malformed_definition_complaint (body);
24255         }
24256       else
24257         /* Just complain.  */
24258         dwarf2_macro_malformed_definition_complaint (body);
24259
24260       xfree (name);
24261       {
24262         int i;
24263
24264         for (i = 0; i < argc; i++)
24265           xfree (argv[i]);
24266       }
24267       xfree (argv);
24268     }
24269   else
24270     dwarf2_macro_malformed_definition_complaint (body);
24271 }
24272
24273 /* Skip some bytes from BYTES according to the form given in FORM.
24274    Returns the new pointer.  */
24275
24276 static const gdb_byte *
24277 skip_form_bytes (bfd *abfd, const gdb_byte *bytes, const gdb_byte *buffer_end,
24278                  enum dwarf_form form,
24279                  unsigned int offset_size,
24280                  struct dwarf2_section_info *section)
24281 {
24282   unsigned int bytes_read;
24283
24284   switch (form)
24285     {
24286     case DW_FORM_data1:
24287     case DW_FORM_flag:
24288       ++bytes;
24289       break;
24290
24291     case DW_FORM_data2:
24292       bytes += 2;
24293       break;
24294
24295     case DW_FORM_data4:
24296       bytes += 4;
24297       break;
24298
24299     case DW_FORM_data8:
24300       bytes += 8;
24301       break;
24302
24303     case DW_FORM_data16:
24304       bytes += 16;
24305       break;
24306
24307     case DW_FORM_string:
24308       read_direct_string (abfd, bytes, &bytes_read);
24309       bytes += bytes_read;
24310       break;
24311
24312     case DW_FORM_sec_offset:
24313     case DW_FORM_strp:
24314     case DW_FORM_GNU_strp_alt:
24315       bytes += offset_size;
24316       break;
24317
24318     case DW_FORM_block:
24319       bytes += read_unsigned_leb128 (abfd, bytes, &bytes_read);
24320       bytes += bytes_read;
24321       break;
24322
24323     case DW_FORM_block1:
24324       bytes += 1 + read_1_byte (abfd, bytes);
24325       break;
24326     case DW_FORM_block2:
24327       bytes += 2 + read_2_bytes (abfd, bytes);
24328       break;
24329     case DW_FORM_block4:
24330       bytes += 4 + read_4_bytes (abfd, bytes);
24331       break;
24332
24333     case DW_FORM_addrx:
24334     case DW_FORM_sdata:
24335     case DW_FORM_strx:
24336     case DW_FORM_udata:
24337     case DW_FORM_GNU_addr_index:
24338     case DW_FORM_GNU_str_index:
24339       bytes = gdb_skip_leb128 (bytes, buffer_end);
24340       if (bytes == NULL)
24341         {
24342           dwarf2_section_buffer_overflow_complaint (section);
24343           return NULL;
24344         }
24345       break;
24346
24347     case DW_FORM_implicit_const:
24348       break;
24349
24350     default:
24351       {
24352         complaint (_("invalid form 0x%x in `%s'"),
24353                    form, get_section_name (section));
24354         return NULL;
24355       }
24356     }
24357
24358   return bytes;
24359 }
24360
24361 /* A helper for dwarf_decode_macros that handles skipping an unknown
24362    opcode.  Returns an updated pointer to the macro data buffer; or,
24363    on error, issues a complaint and returns NULL.  */
24364
24365 static const gdb_byte *
24366 skip_unknown_opcode (unsigned int opcode,
24367                      const gdb_byte **opcode_definitions,
24368                      const gdb_byte *mac_ptr, const gdb_byte *mac_end,
24369                      bfd *abfd,
24370                      unsigned int offset_size,
24371                      struct dwarf2_section_info *section)
24372 {
24373   unsigned int bytes_read, i;
24374   unsigned long arg;
24375   const gdb_byte *defn;
24376
24377   if (opcode_definitions[opcode] == NULL)
24378     {
24379       complaint (_("unrecognized DW_MACFINO opcode 0x%x"),
24380                  opcode);
24381       return NULL;
24382     }
24383
24384   defn = opcode_definitions[opcode];
24385   arg = read_unsigned_leb128 (abfd, defn, &bytes_read);
24386   defn += bytes_read;
24387
24388   for (i = 0; i < arg; ++i)
24389     {
24390       mac_ptr = skip_form_bytes (abfd, mac_ptr, mac_end,
24391                                  (enum dwarf_form) defn[i], offset_size,
24392                                  section);
24393       if (mac_ptr == NULL)
24394         {
24395           /* skip_form_bytes already issued the complaint.  */
24396           return NULL;
24397         }
24398     }
24399
24400   return mac_ptr;
24401 }
24402
24403 /* A helper function which parses the header of a macro section.
24404    If the macro section is the extended (for now called "GNU") type,
24405    then this updates *OFFSET_SIZE.  Returns a pointer to just after
24406    the header, or issues a complaint and returns NULL on error.  */
24407
24408 static const gdb_byte *
24409 dwarf_parse_macro_header (const gdb_byte **opcode_definitions,
24410                           bfd *abfd,
24411                           const gdb_byte *mac_ptr,
24412                           unsigned int *offset_size,
24413                           int section_is_gnu)
24414 {
24415   memset (opcode_definitions, 0, 256 * sizeof (gdb_byte *));
24416
24417   if (section_is_gnu)
24418     {
24419       unsigned int version, flags;
24420
24421       version = read_2_bytes (abfd, mac_ptr);
24422       if (version != 4 && version != 5)
24423         {
24424           complaint (_("unrecognized version `%d' in .debug_macro section"),
24425                      version);
24426           return NULL;
24427         }
24428       mac_ptr += 2;
24429
24430       flags = read_1_byte (abfd, mac_ptr);
24431       ++mac_ptr;
24432       *offset_size = (flags & 1) ? 8 : 4;
24433
24434       if ((flags & 2) != 0)
24435         /* We don't need the line table offset.  */
24436         mac_ptr += *offset_size;
24437
24438       /* Vendor opcode descriptions.  */
24439       if ((flags & 4) != 0)
24440         {
24441           unsigned int i, count;
24442
24443           count = read_1_byte (abfd, mac_ptr);
24444           ++mac_ptr;
24445           for (i = 0; i < count; ++i)
24446             {
24447               unsigned int opcode, bytes_read;
24448               unsigned long arg;
24449
24450               opcode = read_1_byte (abfd, mac_ptr);
24451               ++mac_ptr;
24452               opcode_definitions[opcode] = mac_ptr;
24453               arg = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24454               mac_ptr += bytes_read;
24455               mac_ptr += arg;
24456             }
24457         }
24458     }
24459
24460   return mac_ptr;
24461 }
24462
24463 /* A helper for dwarf_decode_macros that handles the GNU extensions,
24464    including DW_MACRO_import.  */
24465
24466 static void
24467 dwarf_decode_macro_bytes (struct dwarf2_cu *cu,
24468                           bfd *abfd,
24469                           const gdb_byte *mac_ptr, const gdb_byte *mac_end,
24470                           struct macro_source_file *current_file,
24471                           struct line_header *lh,
24472                           struct dwarf2_section_info *section,
24473                           int section_is_gnu, int section_is_dwz,
24474                           unsigned int offset_size,
24475                           htab_t include_hash)
24476 {
24477   struct dwarf2_per_objfile *dwarf2_per_objfile
24478     = cu->per_cu->dwarf2_per_objfile;
24479   struct objfile *objfile = dwarf2_per_objfile->objfile;
24480   enum dwarf_macro_record_type macinfo_type;
24481   int at_commandline;
24482   const gdb_byte *opcode_definitions[256];
24483
24484   mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
24485                                       &offset_size, section_is_gnu);
24486   if (mac_ptr == NULL)
24487     {
24488       /* We already issued a complaint.  */
24489       return;
24490     }
24491
24492   /* Determines if GDB is still before first DW_MACINFO_start_file.  If true
24493      GDB is still reading the definitions from command line.  First
24494      DW_MACINFO_start_file will need to be ignored as it was already executed
24495      to create CURRENT_FILE for the main source holding also the command line
24496      definitions.  On first met DW_MACINFO_start_file this flag is reset to
24497      normally execute all the remaining DW_MACINFO_start_file macinfos.  */
24498
24499   at_commandline = 1;
24500
24501   do
24502     {
24503       /* Do we at least have room for a macinfo type byte?  */
24504       if (mac_ptr >= mac_end)
24505         {
24506           dwarf2_section_buffer_overflow_complaint (section);
24507           break;
24508         }
24509
24510       macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr);
24511       mac_ptr++;
24512
24513       /* Note that we rely on the fact that the corresponding GNU and
24514          DWARF constants are the same.  */
24515       DIAGNOSTIC_PUSH
24516       DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24517       switch (macinfo_type)
24518         {
24519           /* A zero macinfo type indicates the end of the macro
24520              information.  */
24521         case 0:
24522           break;
24523
24524         case DW_MACRO_define:
24525         case DW_MACRO_undef:
24526         case DW_MACRO_define_strp:
24527         case DW_MACRO_undef_strp:
24528         case DW_MACRO_define_sup:
24529         case DW_MACRO_undef_sup:
24530           {
24531             unsigned int bytes_read;
24532             int line;
24533             const char *body;
24534             int is_define;
24535
24536             line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24537             mac_ptr += bytes_read;
24538
24539             if (macinfo_type == DW_MACRO_define
24540                 || macinfo_type == DW_MACRO_undef)
24541               {
24542                 body = read_direct_string (abfd, mac_ptr, &bytes_read);
24543                 mac_ptr += bytes_read;
24544               }
24545             else
24546               {
24547                 LONGEST str_offset;
24548
24549                 str_offset = read_offset_1 (abfd, mac_ptr, offset_size);
24550                 mac_ptr += offset_size;
24551
24552                 if (macinfo_type == DW_MACRO_define_sup
24553                     || macinfo_type == DW_MACRO_undef_sup
24554                     || section_is_dwz)
24555                   {
24556                     struct dwz_file *dwz
24557                       = dwarf2_get_dwz_file (dwarf2_per_objfile);
24558
24559                     body = read_indirect_string_from_dwz (objfile,
24560                                                           dwz, str_offset);
24561                   }
24562                 else
24563                   body = read_indirect_string_at_offset (dwarf2_per_objfile,
24564                                                          abfd, str_offset);
24565               }
24566
24567             is_define = (macinfo_type == DW_MACRO_define
24568                          || macinfo_type == DW_MACRO_define_strp
24569                          || macinfo_type == DW_MACRO_define_sup);
24570             if (! current_file)
24571               {
24572                 /* DWARF violation as no main source is present.  */
24573                 complaint (_("debug info with no main source gives macro %s "
24574                              "on line %d: %s"),
24575                            is_define ? _("definition") : _("undefinition"),
24576                            line, body);
24577                 break;
24578               }
24579             if ((line == 0 && !at_commandline)
24580                 || (line != 0 && at_commandline))
24581               complaint (_("debug info gives %s macro %s with %s line %d: %s"),
24582                          at_commandline ? _("command-line") : _("in-file"),
24583                          is_define ? _("definition") : _("undefinition"),
24584                          line == 0 ? _("zero") : _("non-zero"), line, body);
24585
24586             if (is_define)
24587               parse_macro_definition (current_file, line, body);
24588             else
24589               {
24590                 gdb_assert (macinfo_type == DW_MACRO_undef
24591                             || macinfo_type == DW_MACRO_undef_strp
24592                             || macinfo_type == DW_MACRO_undef_sup);
24593                 macro_undef (current_file, line, body);
24594               }
24595           }
24596           break;
24597
24598         case DW_MACRO_start_file:
24599           {
24600             unsigned int bytes_read;
24601             int line, file;
24602
24603             line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24604             mac_ptr += bytes_read;
24605             file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24606             mac_ptr += bytes_read;
24607
24608             if ((line == 0 && !at_commandline)
24609                 || (line != 0 && at_commandline))
24610               complaint (_("debug info gives source %d included "
24611                            "from %s at %s line %d"),
24612                          file, at_commandline ? _("command-line") : _("file"),
24613                          line == 0 ? _("zero") : _("non-zero"), line);
24614
24615             if (at_commandline)
24616               {
24617                 /* This DW_MACRO_start_file was executed in the
24618                    pass one.  */
24619                 at_commandline = 0;
24620               }
24621             else
24622               current_file = macro_start_file (cu, file, line, current_file,
24623                                                lh);
24624           }
24625           break;
24626
24627         case DW_MACRO_end_file:
24628           if (! current_file)
24629             complaint (_("macro debug info has an unmatched "
24630                          "`close_file' directive"));
24631           else
24632             {
24633               current_file = current_file->included_by;
24634               if (! current_file)
24635                 {
24636                   enum dwarf_macro_record_type next_type;
24637
24638                   /* GCC circa March 2002 doesn't produce the zero
24639                      type byte marking the end of the compilation
24640                      unit.  Complain if it's not there, but exit no
24641                      matter what.  */
24642
24643                   /* Do we at least have room for a macinfo type byte?  */
24644                   if (mac_ptr >= mac_end)
24645                     {
24646                       dwarf2_section_buffer_overflow_complaint (section);
24647                       return;
24648                     }
24649
24650                   /* We don't increment mac_ptr here, so this is just
24651                      a look-ahead.  */
24652                   next_type
24653                     = (enum dwarf_macro_record_type) read_1_byte (abfd,
24654                                                                   mac_ptr);
24655                   if (next_type != 0)
24656                     complaint (_("no terminating 0-type entry for "
24657                                  "macros in `.debug_macinfo' section"));
24658
24659                   return;
24660                 }
24661             }
24662           break;
24663
24664         case DW_MACRO_import:
24665         case DW_MACRO_import_sup:
24666           {
24667             LONGEST offset;
24668             void **slot;
24669             bfd *include_bfd = abfd;
24670             struct dwarf2_section_info *include_section = section;
24671             const gdb_byte *include_mac_end = mac_end;
24672             int is_dwz = section_is_dwz;
24673             const gdb_byte *new_mac_ptr;
24674
24675             offset = read_offset_1 (abfd, mac_ptr, offset_size);
24676             mac_ptr += offset_size;
24677
24678             if (macinfo_type == DW_MACRO_import_sup)
24679               {
24680                 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
24681
24682                 dwarf2_read_section (objfile, &dwz->macro);
24683
24684                 include_section = &dwz->macro;
24685                 include_bfd = get_section_bfd_owner (include_section);
24686                 include_mac_end = dwz->macro.buffer + dwz->macro.size;
24687                 is_dwz = 1;
24688               }
24689
24690             new_mac_ptr = include_section->buffer + offset;
24691             slot = htab_find_slot (include_hash, new_mac_ptr, INSERT);
24692
24693             if (*slot != NULL)
24694               {
24695                 /* This has actually happened; see
24696                    http://sourceware.org/bugzilla/show_bug.cgi?id=13568.  */
24697                 complaint (_("recursive DW_MACRO_import in "
24698                              ".debug_macro section"));
24699               }
24700             else
24701               {
24702                 *slot = (void *) new_mac_ptr;
24703
24704                 dwarf_decode_macro_bytes (cu, include_bfd, new_mac_ptr,
24705                                           include_mac_end, current_file, lh,
24706                                           section, section_is_gnu, is_dwz,
24707                                           offset_size, include_hash);
24708
24709                 htab_remove_elt (include_hash, (void *) new_mac_ptr);
24710               }
24711           }
24712           break;
24713
24714         case DW_MACINFO_vendor_ext:
24715           if (!section_is_gnu)
24716             {
24717               unsigned int bytes_read;
24718
24719               /* This reads the constant, but since we don't recognize
24720                  any vendor extensions, we ignore it.  */
24721               read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24722               mac_ptr += bytes_read;
24723               read_direct_string (abfd, mac_ptr, &bytes_read);
24724               mac_ptr += bytes_read;
24725
24726               /* We don't recognize any vendor extensions.  */
24727               break;
24728             }
24729           /* FALLTHROUGH */
24730
24731         default:
24732           mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
24733                                          mac_ptr, mac_end, abfd, offset_size,
24734                                          section);
24735           if (mac_ptr == NULL)
24736             return;
24737           break;
24738         }
24739       DIAGNOSTIC_POP
24740     } while (macinfo_type != 0);
24741 }
24742
24743 static void
24744 dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset,
24745                      int section_is_gnu)
24746 {
24747   struct dwarf2_per_objfile *dwarf2_per_objfile
24748     = cu->per_cu->dwarf2_per_objfile;
24749   struct objfile *objfile = dwarf2_per_objfile->objfile;
24750   struct line_header *lh = cu->line_header;
24751   bfd *abfd;
24752   const gdb_byte *mac_ptr, *mac_end;
24753   struct macro_source_file *current_file = 0;
24754   enum dwarf_macro_record_type macinfo_type;
24755   unsigned int offset_size = cu->header.offset_size;
24756   const gdb_byte *opcode_definitions[256];
24757   void **slot;
24758   struct dwarf2_section_info *section;
24759   const char *section_name;
24760
24761   if (cu->dwo_unit != NULL)
24762     {
24763       if (section_is_gnu)
24764         {
24765           section = &cu->dwo_unit->dwo_file->sections.macro;
24766           section_name = ".debug_macro.dwo";
24767         }
24768       else
24769         {
24770           section = &cu->dwo_unit->dwo_file->sections.macinfo;
24771           section_name = ".debug_macinfo.dwo";
24772         }
24773     }
24774   else
24775     {
24776       if (section_is_gnu)
24777         {
24778           section = &dwarf2_per_objfile->macro;
24779           section_name = ".debug_macro";
24780         }
24781       else
24782         {
24783           section = &dwarf2_per_objfile->macinfo;
24784           section_name = ".debug_macinfo";
24785         }
24786     }
24787
24788   dwarf2_read_section (objfile, section);
24789   if (section->buffer == NULL)
24790     {
24791       complaint (_("missing %s section"), section_name);
24792       return;
24793     }
24794   abfd = get_section_bfd_owner (section);
24795
24796   /* First pass: Find the name of the base filename.
24797      This filename is needed in order to process all macros whose definition
24798      (or undefinition) comes from the command line.  These macros are defined
24799      before the first DW_MACINFO_start_file entry, and yet still need to be
24800      associated to the base file.
24801
24802      To determine the base file name, we scan the macro definitions until we
24803      reach the first DW_MACINFO_start_file entry.  We then initialize
24804      CURRENT_FILE accordingly so that any macro definition found before the
24805      first DW_MACINFO_start_file can still be associated to the base file.  */
24806
24807   mac_ptr = section->buffer + offset;
24808   mac_end = section->buffer + section->size;
24809
24810   mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
24811                                       &offset_size, section_is_gnu);
24812   if (mac_ptr == NULL)
24813     {
24814       /* We already issued a complaint.  */
24815       return;
24816     }
24817
24818   do
24819     {
24820       /* Do we at least have room for a macinfo type byte?  */
24821       if (mac_ptr >= mac_end)
24822         {
24823           /* Complaint is printed during the second pass as GDB will probably
24824              stop the first pass earlier upon finding
24825              DW_MACINFO_start_file.  */
24826           break;
24827         }
24828
24829       macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr);
24830       mac_ptr++;
24831
24832       /* Note that we rely on the fact that the corresponding GNU and
24833          DWARF constants are the same.  */
24834       DIAGNOSTIC_PUSH
24835       DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24836       switch (macinfo_type)
24837         {
24838           /* A zero macinfo type indicates the end of the macro
24839              information.  */
24840         case 0:
24841           break;
24842
24843         case DW_MACRO_define:
24844         case DW_MACRO_undef:
24845           /* Only skip the data by MAC_PTR.  */
24846           {
24847             unsigned int bytes_read;
24848
24849             read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24850             mac_ptr += bytes_read;
24851             read_direct_string (abfd, mac_ptr, &bytes_read);
24852             mac_ptr += bytes_read;
24853           }
24854           break;
24855
24856         case DW_MACRO_start_file:
24857           {
24858             unsigned int bytes_read;
24859             int line, file;
24860
24861             line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24862             mac_ptr += bytes_read;
24863             file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24864             mac_ptr += bytes_read;
24865
24866             current_file = macro_start_file (cu, file, line, current_file, lh);
24867           }
24868           break;
24869
24870         case DW_MACRO_end_file:
24871           /* No data to skip by MAC_PTR.  */
24872           break;
24873
24874         case DW_MACRO_define_strp:
24875         case DW_MACRO_undef_strp:
24876         case DW_MACRO_define_sup:
24877         case DW_MACRO_undef_sup:
24878           {
24879             unsigned int bytes_read;
24880
24881             read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24882             mac_ptr += bytes_read;
24883             mac_ptr += offset_size;
24884           }
24885           break;
24886
24887         case DW_MACRO_import:
24888         case DW_MACRO_import_sup:
24889           /* Note that, according to the spec, a transparent include
24890              chain cannot call DW_MACRO_start_file.  So, we can just
24891              skip this opcode.  */
24892           mac_ptr += offset_size;
24893           break;
24894
24895         case DW_MACINFO_vendor_ext:
24896           /* Only skip the data by MAC_PTR.  */
24897           if (!section_is_gnu)
24898             {
24899               unsigned int bytes_read;
24900
24901               read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24902               mac_ptr += bytes_read;
24903               read_direct_string (abfd, mac_ptr, &bytes_read);
24904               mac_ptr += bytes_read;
24905             }
24906           /* FALLTHROUGH */
24907
24908         default:
24909           mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
24910                                          mac_ptr, mac_end, abfd, offset_size,
24911                                          section);
24912           if (mac_ptr == NULL)
24913             return;
24914           break;
24915         }
24916       DIAGNOSTIC_POP
24917     } while (macinfo_type != 0 && current_file == NULL);
24918
24919   /* Second pass: Process all entries.
24920
24921      Use the AT_COMMAND_LINE flag to determine whether we are still processing
24922      command-line macro definitions/undefinitions.  This flag is unset when we
24923      reach the first DW_MACINFO_start_file entry.  */
24924
24925   htab_up include_hash (htab_create_alloc (1, htab_hash_pointer,
24926                                            htab_eq_pointer,
24927                                            NULL, xcalloc, xfree));
24928   mac_ptr = section->buffer + offset;
24929   slot = htab_find_slot (include_hash.get (), mac_ptr, INSERT);
24930   *slot = (void *) mac_ptr;
24931   dwarf_decode_macro_bytes (cu, abfd, mac_ptr, mac_end,
24932                             current_file, lh, section,
24933                             section_is_gnu, 0, offset_size,
24934                             include_hash.get ());
24935 }
24936
24937 /* Check if the attribute's form is a DW_FORM_block*
24938    if so return true else false.  */
24939
24940 static int
24941 attr_form_is_block (const struct attribute *attr)
24942 {
24943   return (attr == NULL ? 0 :
24944       attr->form == DW_FORM_block1
24945       || attr->form == DW_FORM_block2
24946       || attr->form == DW_FORM_block4
24947       || attr->form == DW_FORM_block
24948       || attr->form == DW_FORM_exprloc);
24949 }
24950
24951 /* Return non-zero if ATTR's value is a section offset --- classes
24952    lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
24953    You may use DW_UNSND (attr) to retrieve such offsets.
24954
24955    Section 7.5.4, "Attribute Encodings", explains that no attribute
24956    may have a value that belongs to more than one of these classes; it
24957    would be ambiguous if we did, because we use the same forms for all
24958    of them.  */
24959
24960 static int
24961 attr_form_is_section_offset (const struct attribute *attr)
24962 {
24963   return (attr->form == DW_FORM_data4
24964           || attr->form == DW_FORM_data8
24965           || attr->form == DW_FORM_sec_offset);
24966 }
24967
24968 /* Return non-zero if ATTR's value falls in the 'constant' class, or
24969    zero otherwise.  When this function returns true, you can apply
24970    dwarf2_get_attr_constant_value to it.
24971
24972    However, note that for some attributes you must check
24973    attr_form_is_section_offset before using this test.  DW_FORM_data4
24974    and DW_FORM_data8 are members of both the constant class, and of
24975    the classes that contain offsets into other debug sections
24976    (lineptr, loclistptr, macptr or rangelistptr).  The DWARF spec says
24977    that, if an attribute's can be either a constant or one of the
24978    section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
24979    taken as section offsets, not constants.
24980
24981    DW_FORM_data16 is not considered as dwarf2_get_attr_constant_value
24982    cannot handle that.  */
24983
24984 static int
24985 attr_form_is_constant (const struct attribute *attr)
24986 {
24987   switch (attr->form)
24988     {
24989     case DW_FORM_sdata:
24990     case DW_FORM_udata:
24991     case DW_FORM_data1:
24992     case DW_FORM_data2:
24993     case DW_FORM_data4:
24994     case DW_FORM_data8:
24995     case DW_FORM_implicit_const:
24996       return 1;
24997     default:
24998       return 0;
24999     }
25000 }
25001
25002
25003 /* DW_ADDR is always stored already as sect_offset; despite for the forms
25004    besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file.  */
25005
25006 static int
25007 attr_form_is_ref (const struct attribute *attr)
25008 {
25009   switch (attr->form)
25010     {
25011     case DW_FORM_ref_addr:
25012     case DW_FORM_ref1:
25013     case DW_FORM_ref2:
25014     case DW_FORM_ref4:
25015     case DW_FORM_ref8:
25016     case DW_FORM_ref_udata:
25017     case DW_FORM_GNU_ref_alt:
25018       return 1;
25019     default:
25020       return 0;
25021     }
25022 }
25023
25024 /* Return the .debug_loc section to use for CU.
25025    For DWO files use .debug_loc.dwo.  */
25026
25027 static struct dwarf2_section_info *
25028 cu_debug_loc_section (struct dwarf2_cu *cu)
25029 {
25030   struct dwarf2_per_objfile *dwarf2_per_objfile
25031     = cu->per_cu->dwarf2_per_objfile;
25032
25033   if (cu->dwo_unit)
25034     {
25035       struct dwo_sections *sections = &cu->dwo_unit->dwo_file->sections;
25036       
25037       return cu->header.version >= 5 ? &sections->loclists : &sections->loc;
25038     }
25039   return (cu->header.version >= 5 ? &dwarf2_per_objfile->loclists
25040                                   : &dwarf2_per_objfile->loc);
25041 }
25042
25043 /* A helper function that fills in a dwarf2_loclist_baton.  */
25044
25045 static void
25046 fill_in_loclist_baton (struct dwarf2_cu *cu,
25047                        struct dwarf2_loclist_baton *baton,
25048                        const struct attribute *attr)
25049 {
25050   struct dwarf2_per_objfile *dwarf2_per_objfile
25051     = cu->per_cu->dwarf2_per_objfile;
25052   struct dwarf2_section_info *section = cu_debug_loc_section (cu);
25053
25054   dwarf2_read_section (dwarf2_per_objfile->objfile, section);
25055
25056   baton->per_cu = cu->per_cu;
25057   gdb_assert (baton->per_cu);
25058   /* We don't know how long the location list is, but make sure we
25059      don't run off the edge of the section.  */
25060   baton->size = section->size - DW_UNSND (attr);
25061   baton->data = section->buffer + DW_UNSND (attr);
25062   baton->base_address = cu->base_address;
25063   baton->from_dwo = cu->dwo_unit != NULL;
25064 }
25065
25066 static void
25067 dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym,
25068                              struct dwarf2_cu *cu, int is_block)
25069 {
25070   struct dwarf2_per_objfile *dwarf2_per_objfile
25071     = cu->per_cu->dwarf2_per_objfile;
25072   struct objfile *objfile = dwarf2_per_objfile->objfile;
25073   struct dwarf2_section_info *section = cu_debug_loc_section (cu);
25074
25075   if (attr_form_is_section_offset (attr)
25076       /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
25077          the section.  If so, fall through to the complaint in the
25078          other branch.  */
25079       && DW_UNSND (attr) < dwarf2_section_size (objfile, section))
25080     {
25081       struct dwarf2_loclist_baton *baton;
25082
25083       baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_loclist_baton);
25084
25085       fill_in_loclist_baton (cu, baton, attr);
25086
25087       if (cu->base_known == 0)
25088         complaint (_("Location list used without "
25089                      "specifying the CU base address."));
25090
25091       SYMBOL_ACLASS_INDEX (sym) = (is_block
25092                                    ? dwarf2_loclist_block_index
25093                                    : dwarf2_loclist_index);
25094       SYMBOL_LOCATION_BATON (sym) = baton;
25095     }
25096   else
25097     {
25098       struct dwarf2_locexpr_baton *baton;
25099
25100       baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
25101       baton->per_cu = cu->per_cu;
25102       gdb_assert (baton->per_cu);
25103
25104       if (attr_form_is_block (attr))
25105         {
25106           /* Note that we're just copying the block's data pointer
25107              here, not the actual data.  We're still pointing into the
25108              info_buffer for SYM's objfile; right now we never release
25109              that buffer, but when we do clean up properly this may
25110              need to change.  */
25111           baton->size = DW_BLOCK (attr)->size;
25112           baton->data = DW_BLOCK (attr)->data;
25113         }
25114       else
25115         {
25116           dwarf2_invalid_attrib_class_complaint ("location description",
25117                                                  SYMBOL_NATURAL_NAME (sym));
25118           baton->size = 0;
25119         }
25120
25121       SYMBOL_ACLASS_INDEX (sym) = (is_block
25122                                    ? dwarf2_locexpr_block_index
25123                                    : dwarf2_locexpr_index);
25124       SYMBOL_LOCATION_BATON (sym) = baton;
25125     }
25126 }
25127
25128 /* Return the OBJFILE associated with the compilation unit CU.  If CU
25129    came from a separate debuginfo file, then the master objfile is
25130    returned.  */
25131
25132 struct objfile *
25133 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data *per_cu)
25134 {
25135   struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
25136
25137   /* Return the master objfile, so that we can report and look up the
25138      correct file containing this variable.  */
25139   if (objfile->separate_debug_objfile_backlink)
25140     objfile = objfile->separate_debug_objfile_backlink;
25141
25142   return objfile;
25143 }
25144
25145 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
25146    (CU_HEADERP is unused in such case) or prepare a temporary copy at
25147    CU_HEADERP first.  */
25148
25149 static const struct comp_unit_head *
25150 per_cu_header_read_in (struct comp_unit_head *cu_headerp,
25151                        struct dwarf2_per_cu_data *per_cu)
25152 {
25153   const gdb_byte *info_ptr;
25154
25155   if (per_cu->cu)
25156     return &per_cu->cu->header;
25157
25158   info_ptr = per_cu->section->buffer + to_underlying (per_cu->sect_off);
25159
25160   memset (cu_headerp, 0, sizeof (*cu_headerp));
25161   read_comp_unit_head (cu_headerp, info_ptr, per_cu->section,
25162                        rcuh_kind::COMPILE);
25163
25164   return cu_headerp;
25165 }
25166
25167 /* Return the address size given in the compilation unit header for CU.  */
25168
25169 int
25170 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data *per_cu)
25171 {
25172   struct comp_unit_head cu_header_local;
25173   const struct comp_unit_head *cu_headerp;
25174
25175   cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25176
25177   return cu_headerp->addr_size;
25178 }
25179
25180 /* Return the offset size given in the compilation unit header for CU.  */
25181
25182 int
25183 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data *per_cu)
25184 {
25185   struct comp_unit_head cu_header_local;
25186   const struct comp_unit_head *cu_headerp;
25187
25188   cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25189
25190   return cu_headerp->offset_size;
25191 }
25192
25193 /* See its dwarf2loc.h declaration.  */
25194
25195 int
25196 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data *per_cu)
25197 {
25198   struct comp_unit_head cu_header_local;
25199   const struct comp_unit_head *cu_headerp;
25200
25201   cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25202
25203   if (cu_headerp->version == 2)
25204     return cu_headerp->addr_size;
25205   else
25206     return cu_headerp->offset_size;
25207 }
25208
25209 /* Return the text offset of the CU.  The returned offset comes from
25210    this CU's objfile.  If this objfile came from a separate debuginfo
25211    file, then the offset may be different from the corresponding
25212    offset in the parent objfile.  */
25213
25214 CORE_ADDR
25215 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data *per_cu)
25216 {
25217   struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
25218
25219   return ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
25220 }
25221
25222 /* Return DWARF version number of PER_CU.  */
25223
25224 short
25225 dwarf2_version (struct dwarf2_per_cu_data *per_cu)
25226 {
25227   return per_cu->dwarf_version;
25228 }
25229
25230 /* Locate the .debug_info compilation unit from CU's objfile which contains
25231    the DIE at OFFSET.  Raises an error on failure.  */
25232
25233 static struct dwarf2_per_cu_data *
25234 dwarf2_find_containing_comp_unit (sect_offset sect_off,
25235                                   unsigned int offset_in_dwz,
25236                                   struct dwarf2_per_objfile *dwarf2_per_objfile)
25237 {
25238   struct dwarf2_per_cu_data *this_cu;
25239   int low, high;
25240
25241   low = 0;
25242   high = dwarf2_per_objfile->all_comp_units.size () - 1;
25243   while (high > low)
25244     {
25245       struct dwarf2_per_cu_data *mid_cu;
25246       int mid = low + (high - low) / 2;
25247
25248       mid_cu = dwarf2_per_objfile->all_comp_units[mid];
25249       if (mid_cu->is_dwz > offset_in_dwz
25250           || (mid_cu->is_dwz == offset_in_dwz
25251               && mid_cu->sect_off + mid_cu->length >= sect_off))
25252         high = mid;
25253       else
25254         low = mid + 1;
25255     }
25256   gdb_assert (low == high);
25257   this_cu = dwarf2_per_objfile->all_comp_units[low];
25258   if (this_cu->is_dwz != offset_in_dwz || this_cu->sect_off > sect_off)
25259     {
25260       if (low == 0 || this_cu->is_dwz != offset_in_dwz)
25261         error (_("Dwarf Error: could not find partial DIE containing "
25262                "offset %s [in module %s]"),
25263                sect_offset_str (sect_off),
25264                bfd_get_filename (dwarf2_per_objfile->objfile->obfd));
25265
25266       gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->sect_off
25267                   <= sect_off);
25268       return dwarf2_per_objfile->all_comp_units[low-1];
25269     }
25270   else
25271     {
25272       if (low == dwarf2_per_objfile->all_comp_units.size () - 1
25273           && sect_off >= this_cu->sect_off + this_cu->length)
25274         error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off));
25275       gdb_assert (sect_off < this_cu->sect_off + this_cu->length);
25276       return this_cu;
25277     }
25278 }
25279
25280 /* Initialize dwarf2_cu CU, owned by PER_CU.  */
25281
25282 dwarf2_cu::dwarf2_cu (struct dwarf2_per_cu_data *per_cu_)
25283   : per_cu (per_cu_),
25284     mark (false),
25285     has_loclist (false),
25286     checked_producer (false),
25287     producer_is_gxx_lt_4_6 (false),
25288     producer_is_gcc_lt_4_3 (false),
25289     producer_is_icc (false),
25290     producer_is_icc_lt_14 (false),
25291     producer_is_codewarrior (false),
25292     processing_has_namespace_info (false)
25293 {
25294   per_cu->cu = this;
25295 }
25296
25297 /* Destroy a dwarf2_cu.  */
25298
25299 dwarf2_cu::~dwarf2_cu ()
25300 {
25301   per_cu->cu = NULL;
25302 }
25303
25304 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE.  */
25305
25306 static void
25307 prepare_one_comp_unit (struct dwarf2_cu *cu, struct die_info *comp_unit_die,
25308                        enum language pretend_language)
25309 {
25310   struct attribute *attr;
25311
25312   /* Set the language we're debugging.  */
25313   attr = dwarf2_attr (comp_unit_die, DW_AT_language, cu);
25314   if (attr)
25315     set_cu_language (DW_UNSND (attr), cu);
25316   else
25317     {
25318       cu->language = pretend_language;
25319       cu->language_defn = language_def (cu->language);
25320     }
25321
25322   cu->producer = dwarf2_string_attr (comp_unit_die, DW_AT_producer, cu);
25323 }
25324
25325 /* Increase the age counter on each cached compilation unit, and free
25326    any that are too old.  */
25327
25328 static void
25329 age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
25330 {
25331   struct dwarf2_per_cu_data *per_cu, **last_chain;
25332
25333   dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
25334   per_cu = dwarf2_per_objfile->read_in_chain;
25335   while (per_cu != NULL)
25336     {
25337       per_cu->cu->last_used ++;
25338       if (per_cu->cu->last_used <= dwarf_max_cache_age)
25339         dwarf2_mark (per_cu->cu);
25340       per_cu = per_cu->cu->read_in_chain;
25341     }
25342
25343   per_cu = dwarf2_per_objfile->read_in_chain;
25344   last_chain = &dwarf2_per_objfile->read_in_chain;
25345   while (per_cu != NULL)
25346     {
25347       struct dwarf2_per_cu_data *next_cu;
25348
25349       next_cu = per_cu->cu->read_in_chain;
25350
25351       if (!per_cu->cu->mark)
25352         {
25353           delete per_cu->cu;
25354           *last_chain = next_cu;
25355         }
25356       else
25357         last_chain = &per_cu->cu->read_in_chain;
25358
25359       per_cu = next_cu;
25360     }
25361 }
25362
25363 /* Remove a single compilation unit from the cache.  */
25364
25365 static void
25366 free_one_cached_comp_unit (struct dwarf2_per_cu_data *target_per_cu)
25367 {
25368   struct dwarf2_per_cu_data *per_cu, **last_chain;
25369   struct dwarf2_per_objfile *dwarf2_per_objfile
25370     = target_per_cu->dwarf2_per_objfile;
25371
25372   per_cu = dwarf2_per_objfile->read_in_chain;
25373   last_chain = &dwarf2_per_objfile->read_in_chain;
25374   while (per_cu != NULL)
25375     {
25376       struct dwarf2_per_cu_data *next_cu;
25377
25378       next_cu = per_cu->cu->read_in_chain;
25379
25380       if (per_cu == target_per_cu)
25381         {
25382           delete per_cu->cu;
25383           per_cu->cu = NULL;
25384           *last_chain = next_cu;
25385           break;
25386         }
25387       else
25388         last_chain = &per_cu->cu->read_in_chain;
25389
25390       per_cu = next_cu;
25391     }
25392 }
25393
25394 /* Cleanup function for the dwarf2_per_objfile data.  */
25395
25396 static void
25397 dwarf2_free_objfile (struct objfile *objfile, void *datum)
25398 {
25399   struct dwarf2_per_objfile *dwarf2_per_objfile
25400     = static_cast<struct dwarf2_per_objfile *> (datum);
25401
25402   delete dwarf2_per_objfile;
25403 }
25404
25405 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
25406    We store these in a hash table separate from the DIEs, and preserve them
25407    when the DIEs are flushed out of cache.
25408
25409    The CU "per_cu" pointer is needed because offset alone is not enough to
25410    uniquely identify the type.  A file may have multiple .debug_types sections,
25411    or the type may come from a DWO file.  Furthermore, while it's more logical
25412    to use per_cu->section+offset, with Fission the section with the data is in
25413    the DWO file but we don't know that section at the point we need it.
25414    We have to use something in dwarf2_per_cu_data (or the pointer to it)
25415    because we can enter the lookup routine, get_die_type_at_offset, from
25416    outside this file, and thus won't necessarily have PER_CU->cu.
25417    Fortunately, PER_CU is stable for the life of the objfile.  */
25418
25419 struct dwarf2_per_cu_offset_and_type
25420 {
25421   const struct dwarf2_per_cu_data *per_cu;
25422   sect_offset sect_off;
25423   struct type *type;
25424 };
25425
25426 /* Hash function for a dwarf2_per_cu_offset_and_type.  */
25427
25428 static hashval_t
25429 per_cu_offset_and_type_hash (const void *item)
25430 {
25431   const struct dwarf2_per_cu_offset_and_type *ofs
25432     = (const struct dwarf2_per_cu_offset_and_type *) item;
25433
25434   return (uintptr_t) ofs->per_cu + to_underlying (ofs->sect_off);
25435 }
25436
25437 /* Equality function for a dwarf2_per_cu_offset_and_type.  */
25438
25439 static int
25440 per_cu_offset_and_type_eq (const void *item_lhs, const void *item_rhs)
25441 {
25442   const struct dwarf2_per_cu_offset_and_type *ofs_lhs
25443     = (const struct dwarf2_per_cu_offset_and_type *) item_lhs;
25444   const struct dwarf2_per_cu_offset_and_type *ofs_rhs
25445     = (const struct dwarf2_per_cu_offset_and_type *) item_rhs;
25446
25447   return (ofs_lhs->per_cu == ofs_rhs->per_cu
25448           && ofs_lhs->sect_off == ofs_rhs->sect_off);
25449 }
25450
25451 /* Set the type associated with DIE to TYPE.  Save it in CU's hash
25452    table if necessary.  For convenience, return TYPE.
25453
25454    The DIEs reading must have careful ordering to:
25455     * Not cause infite loops trying to read in DIEs as a prerequisite for
25456       reading current DIE.
25457     * Not trying to dereference contents of still incompletely read in types
25458       while reading in other DIEs.
25459     * Enable referencing still incompletely read in types just by a pointer to
25460       the type without accessing its fields.
25461
25462    Therefore caller should follow these rules:
25463      * Try to fetch any prerequisite types we may need to build this DIE type
25464        before building the type and calling set_die_type.
25465      * After building type call set_die_type for current DIE as soon as
25466        possible before fetching more types to complete the current type.
25467      * Make the type as complete as possible before fetching more types.  */
25468
25469 static struct type *
25470 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
25471 {
25472   struct dwarf2_per_objfile *dwarf2_per_objfile
25473     = cu->per_cu->dwarf2_per_objfile;
25474   struct dwarf2_per_cu_offset_and_type **slot, ofs;
25475   struct objfile *objfile = dwarf2_per_objfile->objfile;
25476   struct attribute *attr;
25477   struct dynamic_prop prop;
25478
25479   /* For Ada types, make sure that the gnat-specific data is always
25480      initialized (if not already set).  There are a few types where
25481      we should not be doing so, because the type-specific area is
25482      already used to hold some other piece of info (eg: TYPE_CODE_FLT
25483      where the type-specific area is used to store the floatformat).
25484      But this is not a problem, because the gnat-specific information
25485      is actually not needed for these types.  */
25486   if (need_gnat_info (cu)
25487       && TYPE_CODE (type) != TYPE_CODE_FUNC
25488       && TYPE_CODE (type) != TYPE_CODE_FLT
25489       && TYPE_CODE (type) != TYPE_CODE_METHODPTR
25490       && TYPE_CODE (type) != TYPE_CODE_MEMBERPTR
25491       && TYPE_CODE (type) != TYPE_CODE_METHOD
25492       && !HAVE_GNAT_AUX_INFO (type))
25493     INIT_GNAT_SPECIFIC (type);
25494
25495   /* Read DW_AT_allocated and set in type.  */
25496   attr = dwarf2_attr (die, DW_AT_allocated, cu);
25497   if (attr_form_is_block (attr))
25498     {
25499       if (attr_to_dynamic_prop (attr, die, cu, &prop))
25500         add_dyn_prop (DYN_PROP_ALLOCATED, prop, type);
25501     }
25502   else if (attr != NULL)
25503     {
25504       complaint (_("DW_AT_allocated has the wrong form (%s) at DIE %s"),
25505                  (attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
25506                  sect_offset_str (die->sect_off));
25507     }
25508
25509   /* Read DW_AT_associated and set in type.  */
25510   attr = dwarf2_attr (die, DW_AT_associated, cu);
25511   if (attr_form_is_block (attr))
25512     {
25513       if (attr_to_dynamic_prop (attr, die, cu, &prop))
25514         add_dyn_prop (DYN_PROP_ASSOCIATED, prop, type);
25515     }
25516   else if (attr != NULL)
25517     {
25518       complaint (_("DW_AT_associated has the wrong form (%s) at DIE %s"),
25519                  (attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
25520                  sect_offset_str (die->sect_off));
25521     }
25522
25523   /* Read DW_AT_data_location and set in type.  */
25524   attr = dwarf2_attr (die, DW_AT_data_location, cu);
25525   if (attr_to_dynamic_prop (attr, die, cu, &prop))
25526     add_dyn_prop (DYN_PROP_DATA_LOCATION, prop, type);
25527
25528   if (dwarf2_per_objfile->die_type_hash == NULL)
25529     {
25530       dwarf2_per_objfile->die_type_hash =
25531         htab_create_alloc_ex (127,
25532                               per_cu_offset_and_type_hash,
25533                               per_cu_offset_and_type_eq,
25534                               NULL,
25535                               &objfile->objfile_obstack,
25536                               hashtab_obstack_allocate,
25537                               dummy_obstack_deallocate);
25538     }
25539
25540   ofs.per_cu = cu->per_cu;
25541   ofs.sect_off = die->sect_off;
25542   ofs.type = type;
25543   slot = (struct dwarf2_per_cu_offset_and_type **)
25544     htab_find_slot (dwarf2_per_objfile->die_type_hash, &ofs, INSERT);
25545   if (*slot)
25546     complaint (_("A problem internal to GDB: DIE %s has type already set"),
25547                sect_offset_str (die->sect_off));
25548   *slot = XOBNEW (&objfile->objfile_obstack,
25549                   struct dwarf2_per_cu_offset_and_type);
25550   **slot = ofs;
25551   return type;
25552 }
25553
25554 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
25555    or return NULL if the die does not have a saved type.  */
25556
25557 static struct type *
25558 get_die_type_at_offset (sect_offset sect_off,
25559                         struct dwarf2_per_cu_data *per_cu)
25560 {
25561   struct dwarf2_per_cu_offset_and_type *slot, ofs;
25562   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
25563
25564   if (dwarf2_per_objfile->die_type_hash == NULL)
25565     return NULL;
25566
25567   ofs.per_cu = per_cu;
25568   ofs.sect_off = sect_off;
25569   slot = ((struct dwarf2_per_cu_offset_and_type *)
25570           htab_find (dwarf2_per_objfile->die_type_hash, &ofs));
25571   if (slot)
25572     return slot->type;
25573   else
25574     return NULL;
25575 }
25576
25577 /* Look up the type for DIE in CU in die_type_hash,
25578    or return NULL if DIE does not have a saved type.  */
25579
25580 static struct type *
25581 get_die_type (struct die_info *die, struct dwarf2_cu *cu)
25582 {
25583   return get_die_type_at_offset (die->sect_off, cu->per_cu);
25584 }
25585
25586 /* Add a dependence relationship from CU to REF_PER_CU.  */
25587
25588 static void
25589 dwarf2_add_dependence (struct dwarf2_cu *cu,
25590                        struct dwarf2_per_cu_data *ref_per_cu)
25591 {
25592   void **slot;
25593
25594   if (cu->dependencies == NULL)
25595     cu->dependencies
25596       = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
25597                               NULL, &cu->comp_unit_obstack,
25598                               hashtab_obstack_allocate,
25599                               dummy_obstack_deallocate);
25600
25601   slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
25602   if (*slot == NULL)
25603     *slot = ref_per_cu;
25604 }
25605
25606 /* Subroutine of dwarf2_mark to pass to htab_traverse.
25607    Set the mark field in every compilation unit in the
25608    cache that we must keep because we are keeping CU.  */
25609
25610 static int
25611 dwarf2_mark_helper (void **slot, void *data)
25612 {
25613   struct dwarf2_per_cu_data *per_cu;
25614
25615   per_cu = (struct dwarf2_per_cu_data *) *slot;
25616
25617   /* cu->dependencies references may not yet have been ever read if QUIT aborts
25618      reading of the chain.  As such dependencies remain valid it is not much
25619      useful to track and undo them during QUIT cleanups.  */
25620   if (per_cu->cu == NULL)
25621     return 1;
25622
25623   if (per_cu->cu->mark)
25624     return 1;
25625   per_cu->cu->mark = true;
25626
25627   if (per_cu->cu->dependencies != NULL)
25628     htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
25629
25630   return 1;
25631 }
25632
25633 /* Set the mark field in CU and in every other compilation unit in the
25634    cache that we must keep because we are keeping CU.  */
25635
25636 static void
25637 dwarf2_mark (struct dwarf2_cu *cu)
25638 {
25639   if (cu->mark)
25640     return;
25641   cu->mark = true;
25642   if (cu->dependencies != NULL)
25643     htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
25644 }
25645
25646 static void
25647 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
25648 {
25649   while (per_cu)
25650     {
25651       per_cu->cu->mark = false;
25652       per_cu = per_cu->cu->read_in_chain;
25653     }
25654 }
25655
25656 /* Trivial hash function for partial_die_info: the hash value of a DIE
25657    is its offset in .debug_info for this objfile.  */
25658
25659 static hashval_t
25660 partial_die_hash (const void *item)
25661 {
25662   const struct partial_die_info *part_die
25663     = (const struct partial_die_info *) item;
25664
25665   return to_underlying (part_die->sect_off);
25666 }
25667
25668 /* Trivial comparison function for partial_die_info structures: two DIEs
25669    are equal if they have the same offset.  */
25670
25671 static int
25672 partial_die_eq (const void *item_lhs, const void *item_rhs)
25673 {
25674   const struct partial_die_info *part_die_lhs
25675     = (const struct partial_die_info *) item_lhs;
25676   const struct partial_die_info *part_die_rhs
25677     = (const struct partial_die_info *) item_rhs;
25678
25679   return part_die_lhs->sect_off == part_die_rhs->sect_off;
25680 }
25681
25682 struct cmd_list_element *set_dwarf_cmdlist;
25683 struct cmd_list_element *show_dwarf_cmdlist;
25684
25685 static void
25686 set_dwarf_cmd (const char *args, int from_tty)
25687 {
25688   help_list (set_dwarf_cmdlist, "maintenance set dwarf ", all_commands,
25689              gdb_stdout);
25690 }
25691
25692 static void
25693 show_dwarf_cmd (const char *args, int from_tty)
25694 {
25695   cmd_show_list (show_dwarf_cmdlist, from_tty, "");
25696 }
25697
25698 int dwarf_always_disassemble;
25699
25700 static void
25701 show_dwarf_always_disassemble (struct ui_file *file, int from_tty,
25702                                struct cmd_list_element *c, const char *value)
25703 {
25704   fprintf_filtered (file,
25705                     _("Whether to always disassemble "
25706                       "DWARF expressions is %s.\n"),
25707                     value);
25708 }
25709
25710 static void
25711 show_check_physname (struct ui_file *file, int from_tty,
25712                      struct cmd_list_element *c, const char *value)
25713 {
25714   fprintf_filtered (file,
25715                     _("Whether to check \"physname\" is %s.\n"),
25716                     value);
25717 }
25718
25719 void
25720 _initialize_dwarf2_read (void)
25721 {
25722   dwarf2_objfile_data_key
25723     = register_objfile_data_with_cleanup (nullptr, dwarf2_free_objfile);
25724
25725   add_prefix_cmd ("dwarf", class_maintenance, set_dwarf_cmd, _("\
25726 Set DWARF specific variables.\n\
25727 Configure DWARF variables such as the cache size"),
25728                   &set_dwarf_cmdlist, "maintenance set dwarf ",
25729                   0/*allow-unknown*/, &maintenance_set_cmdlist);
25730
25731   add_prefix_cmd ("dwarf", class_maintenance, show_dwarf_cmd, _("\
25732 Show DWARF specific variables\n\
25733 Show DWARF variables such as the cache size"),
25734                   &show_dwarf_cmdlist, "maintenance show dwarf ",
25735                   0/*allow-unknown*/, &maintenance_show_cmdlist);
25736
25737   add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
25738                             &dwarf_max_cache_age, _("\
25739 Set the upper bound on the age of cached DWARF compilation units."), _("\
25740 Show the upper bound on the age of cached DWARF compilation units."), _("\
25741 A higher limit means that cached compilation units will be stored\n\
25742 in memory longer, and more total memory will be used.  Zero disables\n\
25743 caching, which can slow down startup."),
25744                             NULL,
25745                             show_dwarf_max_cache_age,
25746                             &set_dwarf_cmdlist,
25747                             &show_dwarf_cmdlist);
25748
25749   add_setshow_boolean_cmd ("always-disassemble", class_obscure,
25750                            &dwarf_always_disassemble, _("\
25751 Set whether `info address' always disassembles DWARF expressions."), _("\
25752 Show whether `info address' always disassembles DWARF expressions."), _("\
25753 When enabled, DWARF expressions are always printed in an assembly-like\n\
25754 syntax.  When disabled, expressions will be printed in a more\n\
25755 conversational style, when possible."),
25756                            NULL,
25757                            show_dwarf_always_disassemble,
25758                            &set_dwarf_cmdlist,
25759                            &show_dwarf_cmdlist);
25760
25761   add_setshow_zuinteger_cmd ("dwarf-read", no_class, &dwarf_read_debug, _("\
25762 Set debugging of the DWARF reader."), _("\
25763 Show debugging of the DWARF reader."), _("\
25764 When enabled (non-zero), debugging messages are printed during DWARF\n\
25765 reading and symtab expansion.  A value of 1 (one) provides basic\n\
25766 information.  A value greater than 1 provides more verbose information."),
25767                             NULL,
25768                             NULL,
25769                             &setdebuglist, &showdebuglist);
25770
25771   add_setshow_zuinteger_cmd ("dwarf-die", no_class, &dwarf_die_debug, _("\
25772 Set debugging of the DWARF DIE reader."), _("\
25773 Show debugging of the DWARF DIE reader."), _("\
25774 When enabled (non-zero), DIEs are dumped after they are read in.\n\
25775 The value is the maximum depth to print."),
25776                              NULL,
25777                              NULL,
25778                              &setdebuglist, &showdebuglist);
25779
25780   add_setshow_zuinteger_cmd ("dwarf-line", no_class, &dwarf_line_debug, _("\
25781 Set debugging of the dwarf line reader."), _("\
25782 Show debugging of the dwarf line reader."), _("\
25783 When enabled (non-zero), line number entries are dumped as they are read in.\n\
25784 A value of 1 (one) provides basic information.\n\
25785 A value greater than 1 provides more verbose information."),
25786                              NULL,
25787                              NULL,
25788                              &setdebuglist, &showdebuglist);
25789
25790   add_setshow_boolean_cmd ("check-physname", no_class, &check_physname, _("\
25791 Set cross-checking of \"physname\" code against demangler."), _("\
25792 Show cross-checking of \"physname\" code against demangler."), _("\
25793 When enabled, GDB's internal \"physname\" code is checked against\n\
25794 the demangler."),
25795                            NULL, show_check_physname,
25796                            &setdebuglist, &showdebuglist);
25797
25798   add_setshow_boolean_cmd ("use-deprecated-index-sections",
25799                            no_class, &use_deprecated_index_sections, _("\
25800 Set whether to use deprecated gdb_index sections."), _("\
25801 Show whether to use deprecated gdb_index sections."), _("\
25802 When enabled, deprecated .gdb_index sections are used anyway.\n\
25803 Normally they are ignored either because of a missing feature or\n\
25804 performance issue.\n\
25805 Warning: This option must be enabled before gdb reads the file."),
25806                            NULL,
25807                            NULL,
25808                            &setlist, &showlist);
25809
25810   dwarf2_locexpr_index = register_symbol_computed_impl (LOC_COMPUTED,
25811                                                         &dwarf2_locexpr_funcs);
25812   dwarf2_loclist_index = register_symbol_computed_impl (LOC_COMPUTED,
25813                                                         &dwarf2_loclist_funcs);
25814
25815   dwarf2_locexpr_block_index = register_symbol_block_impl (LOC_BLOCK,
25816                                         &dwarf2_block_frame_base_locexpr_funcs);
25817   dwarf2_loclist_block_index = register_symbol_block_impl (LOC_BLOCK,
25818                                         &dwarf2_block_frame_base_loclist_funcs);
25819
25820 #if GDB_SELF_TEST
25821   selftests::register_test ("dw2_expand_symtabs_matching",
25822                             selftests::dw2_expand_symtabs_matching::run_test);
25823 #endif
25824 }