Rename gdb exception types
[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   /* Const version of the above.  */
1040   const file_entry *file_name_at (unsigned int index) const
1041   {
1042     if (index >= file_names.size ())
1043       return NULL;
1044     return &file_names[index];
1045   }
1046
1047   /* Offset of line number information in .debug_line section.  */
1048   sect_offset sect_off {};
1049
1050   /* OFFSET is for struct dwz_file associated with dwarf2_per_objfile.  */
1051   unsigned offset_in_dwz : 1; /* Can't initialize bitfields in-class.  */
1052
1053   unsigned int total_length {};
1054   unsigned short version {};
1055   unsigned int header_length {};
1056   unsigned char minimum_instruction_length {};
1057   unsigned char maximum_ops_per_instruction {};
1058   unsigned char default_is_stmt {};
1059   int line_base {};
1060   unsigned char line_range {};
1061   unsigned char opcode_base {};
1062
1063   /* standard_opcode_lengths[i] is the number of operands for the
1064      standard opcode whose value is i.  This means that
1065      standard_opcode_lengths[0] is unused, and the last meaningful
1066      element is standard_opcode_lengths[opcode_base - 1].  */
1067   std::unique_ptr<unsigned char[]> standard_opcode_lengths;
1068
1069   /* The include_directories table.  Note these are observing
1070      pointers.  The memory is owned by debug_line_buffer.  */
1071   std::vector<const char *> include_dirs;
1072
1073   /* The file_names table.  */
1074   std::vector<file_entry> file_names;
1075
1076   /* The start and end of the statement program following this
1077      header.  These point into dwarf2_per_objfile->line_buffer.  */
1078   const gdb_byte *statement_program_start {}, *statement_program_end {};
1079 };
1080
1081 typedef std::unique_ptr<line_header> line_header_up;
1082
1083 const char *
1084 file_entry::include_dir (const line_header *lh) const
1085 {
1086   return lh->include_dir_at (d_index);
1087 }
1088
1089 /* When we construct a partial symbol table entry we only
1090    need this much information.  */
1091 struct partial_die_info : public allocate_on_obstack
1092   {
1093     partial_die_info (sect_offset sect_off, struct abbrev_info *abbrev);
1094
1095     /* Disable assign but still keep copy ctor, which is needed
1096        load_partial_dies.   */
1097     partial_die_info& operator=(const partial_die_info& rhs) = delete;
1098
1099     /* Adjust the partial die before generating a symbol for it.  This
1100        function may set the is_external flag or change the DIE's
1101        name.  */
1102     void fixup (struct dwarf2_cu *cu);
1103
1104     /* Read a minimal amount of information into the minimal die
1105        structure.  */
1106     const gdb_byte *read (const struct die_reader_specs *reader,
1107                           const struct abbrev_info &abbrev,
1108                           const gdb_byte *info_ptr);
1109
1110     /* Offset of this DIE.  */
1111     const sect_offset sect_off;
1112
1113     /* DWARF-2 tag for this DIE.  */
1114     const ENUM_BITFIELD(dwarf_tag) tag : 16;
1115
1116     /* Assorted flags describing the data found in this DIE.  */
1117     const unsigned int has_children : 1;
1118
1119     unsigned int is_external : 1;
1120     unsigned int is_declaration : 1;
1121     unsigned int has_type : 1;
1122     unsigned int has_specification : 1;
1123     unsigned int has_pc_info : 1;
1124     unsigned int may_be_inlined : 1;
1125
1126     /* This DIE has been marked DW_AT_main_subprogram.  */
1127     unsigned int main_subprogram : 1;
1128
1129     /* Flag set if the SCOPE field of this structure has been
1130        computed.  */
1131     unsigned int scope_set : 1;
1132
1133     /* Flag set if the DIE has a byte_size attribute.  */
1134     unsigned int has_byte_size : 1;
1135
1136     /* Flag set if the DIE has a DW_AT_const_value attribute.  */
1137     unsigned int has_const_value : 1;
1138
1139     /* Flag set if any of the DIE's children are template arguments.  */
1140     unsigned int has_template_arguments : 1;
1141
1142     /* Flag set if fixup has been called on this die.  */
1143     unsigned int fixup_called : 1;
1144
1145     /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt.  */
1146     unsigned int is_dwz : 1;
1147
1148     /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt.  */
1149     unsigned int spec_is_dwz : 1;
1150
1151     /* The name of this DIE.  Normally the value of DW_AT_name, but
1152        sometimes a default name for unnamed DIEs.  */
1153     const char *name = nullptr;
1154
1155     /* The linkage name, if present.  */
1156     const char *linkage_name = nullptr;
1157
1158     /* The scope to prepend to our children.  This is generally
1159        allocated on the comp_unit_obstack, so will disappear
1160        when this compilation unit leaves the cache.  */
1161     const char *scope = nullptr;
1162
1163     /* Some data associated with the partial DIE.  The tag determines
1164        which field is live.  */
1165     union
1166     {
1167       /* The location description associated with this DIE, if any.  */
1168       struct dwarf_block *locdesc;
1169       /* The offset of an import, for DW_TAG_imported_unit.  */
1170       sect_offset sect_off;
1171     } d {};
1172
1173     /* If HAS_PC_INFO, the PC range associated with this DIE.  */
1174     CORE_ADDR lowpc = 0;
1175     CORE_ADDR highpc = 0;
1176
1177     /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1178        DW_AT_sibling, if any.  */
1179     /* NOTE: This member isn't strictly necessary, partial_die_info::read
1180        could return DW_AT_sibling values to its caller load_partial_dies.  */
1181     const gdb_byte *sibling = nullptr;
1182
1183     /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1184        DW_AT_specification (or DW_AT_abstract_origin or
1185        DW_AT_extension).  */
1186     sect_offset spec_offset {};
1187
1188     /* Pointers to this DIE's parent, first child, and next sibling,
1189        if any.  */
1190     struct partial_die_info *die_parent = nullptr;
1191     struct partial_die_info *die_child = nullptr;
1192     struct partial_die_info *die_sibling = nullptr;
1193
1194     friend struct partial_die_info *
1195     dwarf2_cu::find_partial_die (sect_offset sect_off);
1196
1197   private:
1198     /* Only need to do look up in dwarf2_cu::find_partial_die.  */
1199     partial_die_info (sect_offset sect_off)
1200       : partial_die_info (sect_off, DW_TAG_padding, 0)
1201     {
1202     }
1203
1204     partial_die_info (sect_offset sect_off_, enum dwarf_tag tag_,
1205                       int has_children_)
1206       : sect_off (sect_off_), tag (tag_), has_children (has_children_)
1207     {
1208       is_external = 0;
1209       is_declaration = 0;
1210       has_type = 0;
1211       has_specification = 0;
1212       has_pc_info = 0;
1213       may_be_inlined = 0;
1214       main_subprogram = 0;
1215       scope_set = 0;
1216       has_byte_size = 0;
1217       has_const_value = 0;
1218       has_template_arguments = 0;
1219       fixup_called = 0;
1220       is_dwz = 0;
1221       spec_is_dwz = 0;
1222     }
1223   };
1224
1225 /* This data structure holds the information of an abbrev.  */
1226 struct abbrev_info
1227   {
1228     unsigned int number;        /* number identifying abbrev */
1229     enum dwarf_tag tag;         /* dwarf tag */
1230     unsigned short has_children;                /* boolean */
1231     unsigned short num_attrs;   /* number of attributes */
1232     struct attr_abbrev *attrs;  /* an array of attribute descriptions */
1233     struct abbrev_info *next;   /* next in chain */
1234   };
1235
1236 struct attr_abbrev
1237   {
1238     ENUM_BITFIELD(dwarf_attribute) name : 16;
1239     ENUM_BITFIELD(dwarf_form) form : 16;
1240
1241     /* It is valid only if FORM is DW_FORM_implicit_const.  */
1242     LONGEST implicit_const;
1243   };
1244
1245 /* Size of abbrev_table.abbrev_hash_table.  */
1246 #define ABBREV_HASH_SIZE 121
1247
1248 /* Top level data structure to contain an abbreviation table.  */
1249
1250 struct abbrev_table
1251 {
1252   explicit abbrev_table (sect_offset off)
1253     : sect_off (off)
1254   {
1255     m_abbrevs =
1256       XOBNEWVEC (&abbrev_obstack, struct abbrev_info *, ABBREV_HASH_SIZE);
1257     memset (m_abbrevs, 0, ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
1258   }
1259
1260   DISABLE_COPY_AND_ASSIGN (abbrev_table);
1261
1262   /* Allocate space for a struct abbrev_info object in
1263      ABBREV_TABLE.  */
1264   struct abbrev_info *alloc_abbrev ();
1265
1266   /* Add an abbreviation to the table.  */
1267   void add_abbrev (unsigned int abbrev_number, struct abbrev_info *abbrev);
1268
1269   /* Look up an abbrev in the table.
1270      Returns NULL if the abbrev is not found.  */
1271
1272   struct abbrev_info *lookup_abbrev (unsigned int abbrev_number);
1273
1274
1275   /* Where the abbrev table came from.
1276      This is used as a sanity check when the table is used.  */
1277   const sect_offset sect_off;
1278
1279   /* Storage for the abbrev table.  */
1280   auto_obstack abbrev_obstack;
1281
1282 private:
1283
1284   /* Hash table of abbrevs.
1285      This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1286      It could be statically allocated, but the previous code didn't so we
1287      don't either.  */
1288   struct abbrev_info **m_abbrevs;
1289 };
1290
1291 typedef std::unique_ptr<struct abbrev_table> abbrev_table_up;
1292
1293 /* Attributes have a name and a value.  */
1294 struct attribute
1295   {
1296     ENUM_BITFIELD(dwarf_attribute) name : 16;
1297     ENUM_BITFIELD(dwarf_form) form : 15;
1298
1299     /* Has DW_STRING already been updated by dwarf2_canonicalize_name?  This
1300        field should be in u.str (existing only for DW_STRING) but it is kept
1301        here for better struct attribute alignment.  */
1302     unsigned int string_is_canonical : 1;
1303
1304     union
1305       {
1306         const char *str;
1307         struct dwarf_block *blk;
1308         ULONGEST unsnd;
1309         LONGEST snd;
1310         CORE_ADDR addr;
1311         ULONGEST signature;
1312       }
1313     u;
1314   };
1315
1316 /* This data structure holds a complete die structure.  */
1317 struct die_info
1318   {
1319     /* DWARF-2 tag for this DIE.  */
1320     ENUM_BITFIELD(dwarf_tag) tag : 16;
1321
1322     /* Number of attributes */
1323     unsigned char num_attrs;
1324
1325     /* True if we're presently building the full type name for the
1326        type derived from this DIE.  */
1327     unsigned char building_fullname : 1;
1328
1329     /* True if this die is in process.  PR 16581.  */
1330     unsigned char in_process : 1;
1331
1332     /* Abbrev number */
1333     unsigned int abbrev;
1334
1335     /* Offset in .debug_info or .debug_types section.  */
1336     sect_offset sect_off;
1337
1338     /* The dies in a compilation unit form an n-ary tree.  PARENT
1339        points to this die's parent; CHILD points to the first child of
1340        this node; and all the children of a given node are chained
1341        together via their SIBLING fields.  */
1342     struct die_info *child;     /* Its first child, if any.  */
1343     struct die_info *sibling;   /* Its next sibling, if any.  */
1344     struct die_info *parent;    /* Its parent, if any.  */
1345
1346     /* An array of attributes, with NUM_ATTRS elements.  There may be
1347        zero, but it's not common and zero-sized arrays are not
1348        sufficiently portable C.  */
1349     struct attribute attrs[1];
1350   };
1351
1352 /* Get at parts of an attribute structure.  */
1353
1354 #define DW_STRING(attr)    ((attr)->u.str)
1355 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1356 #define DW_UNSND(attr)     ((attr)->u.unsnd)
1357 #define DW_BLOCK(attr)     ((attr)->u.blk)
1358 #define DW_SND(attr)       ((attr)->u.snd)
1359 #define DW_ADDR(attr)      ((attr)->u.addr)
1360 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1361
1362 /* Blocks are a bunch of untyped bytes.  */
1363 struct dwarf_block
1364   {
1365     size_t size;
1366
1367     /* Valid only if SIZE is not zero.  */
1368     const gdb_byte *data;
1369   };
1370
1371 #ifndef ATTR_ALLOC_CHUNK
1372 #define ATTR_ALLOC_CHUNK 4
1373 #endif
1374
1375 /* Allocate fields for structs, unions and enums in this size.  */
1376 #ifndef DW_FIELD_ALLOC_CHUNK
1377 #define DW_FIELD_ALLOC_CHUNK 4
1378 #endif
1379
1380 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1381    but this would require a corresponding change in unpack_field_as_long
1382    and friends.  */
1383 static int bits_per_byte = 8;
1384
1385 /* When reading a variant or variant part, we track a bit more
1386    information about the field, and store it in an object of this
1387    type.  */
1388
1389 struct variant_field
1390 {
1391   /* If we see a DW_TAG_variant, then this will be the discriminant
1392      value.  */
1393   ULONGEST discriminant_value;
1394   /* If we see a DW_TAG_variant, then this will be set if this is the
1395      default branch.  */
1396   bool default_branch;
1397   /* While reading a DW_TAG_variant_part, this will be set if this
1398      field is the discriminant.  */
1399   bool is_discriminant;
1400 };
1401
1402 struct nextfield
1403 {
1404   int accessibility = 0;
1405   int virtuality = 0;
1406   /* Extra information to describe a variant or variant part.  */
1407   struct variant_field variant {};
1408   struct field field {};
1409 };
1410
1411 struct fnfieldlist
1412 {
1413   const char *name = nullptr;
1414   std::vector<struct fn_field> fnfields;
1415 };
1416
1417 /* The routines that read and process dies for a C struct or C++ class
1418    pass lists of data member fields and lists of member function fields
1419    in an instance of a field_info structure, as defined below.  */
1420 struct field_info
1421   {
1422     /* List of data member and baseclasses fields.  */
1423     std::vector<struct nextfield> fields;
1424     std::vector<struct nextfield> baseclasses;
1425
1426     /* Number of fields (including baseclasses).  */
1427     int nfields = 0;
1428
1429     /* Set if the accesibility of one of the fields is not public.  */
1430     int non_public_fields = 0;
1431
1432     /* Member function fieldlist array, contains name of possibly overloaded
1433        member function, number of overloaded member functions and a pointer
1434        to the head of the member function field chain.  */
1435     std::vector<struct fnfieldlist> fnfieldlists;
1436
1437     /* typedefs defined inside this class.  TYPEDEF_FIELD_LIST contains head of
1438        a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements.  */
1439     std::vector<struct decl_field> typedef_field_list;
1440
1441     /* Nested types defined by this class and the number of elements in this
1442        list.  */
1443     std::vector<struct decl_field> nested_types_list;
1444   };
1445
1446 /* One item on the queue of compilation units to read in full symbols
1447    for.  */
1448 struct dwarf2_queue_item
1449 {
1450   struct dwarf2_per_cu_data *per_cu;
1451   enum language pretend_language;
1452   struct dwarf2_queue_item *next;
1453 };
1454
1455 /* The current queue.  */
1456 static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail;
1457
1458 /* Loaded secondary compilation units are kept in memory until they
1459    have not been referenced for the processing of this many
1460    compilation units.  Set this to zero to disable caching.  Cache
1461    sizes of up to at least twenty will improve startup time for
1462    typical inter-CU-reference binaries, at an obvious memory cost.  */
1463 static int dwarf_max_cache_age = 5;
1464 static void
1465 show_dwarf_max_cache_age (struct ui_file *file, int from_tty,
1466                           struct cmd_list_element *c, const char *value)
1467 {
1468   fprintf_filtered (file, _("The upper bound on the age of cached "
1469                             "DWARF compilation units is %s.\n"),
1470                     value);
1471 }
1472 \f
1473 /* local function prototypes */
1474
1475 static const char *get_section_name (const struct dwarf2_section_info *);
1476
1477 static const char *get_section_file_name (const struct dwarf2_section_info *);
1478
1479 static void dwarf2_find_base_address (struct die_info *die,
1480                                       struct dwarf2_cu *cu);
1481
1482 static struct partial_symtab *create_partial_symtab
1483   (struct dwarf2_per_cu_data *per_cu, const char *name);
1484
1485 static void build_type_psymtabs_reader (const struct die_reader_specs *reader,
1486                                         const gdb_byte *info_ptr,
1487                                         struct die_info *type_unit_die,
1488                                         int has_children, void *data);
1489
1490 static void dwarf2_build_psymtabs_hard
1491   (struct dwarf2_per_objfile *dwarf2_per_objfile);
1492
1493 static void scan_partial_symbols (struct partial_die_info *,
1494                                   CORE_ADDR *, CORE_ADDR *,
1495                                   int, struct dwarf2_cu *);
1496
1497 static void add_partial_symbol (struct partial_die_info *,
1498                                 struct dwarf2_cu *);
1499
1500 static void add_partial_namespace (struct partial_die_info *pdi,
1501                                    CORE_ADDR *lowpc, CORE_ADDR *highpc,
1502                                    int set_addrmap, struct dwarf2_cu *cu);
1503
1504 static void add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
1505                                 CORE_ADDR *highpc, int set_addrmap,
1506                                 struct dwarf2_cu *cu);
1507
1508 static void add_partial_enumeration (struct partial_die_info *enum_pdi,
1509                                      struct dwarf2_cu *cu);
1510
1511 static void add_partial_subprogram (struct partial_die_info *pdi,
1512                                     CORE_ADDR *lowpc, CORE_ADDR *highpc,
1513                                     int need_pc, struct dwarf2_cu *cu);
1514
1515 static void dwarf2_read_symtab (struct partial_symtab *,
1516                                 struct objfile *);
1517
1518 static void psymtab_to_symtab_1 (struct partial_symtab *);
1519
1520 static abbrev_table_up abbrev_table_read_table
1521   (struct dwarf2_per_objfile *dwarf2_per_objfile, struct dwarf2_section_info *,
1522    sect_offset);
1523
1524 static unsigned int peek_abbrev_code (bfd *, const gdb_byte *);
1525
1526 static struct partial_die_info *load_partial_dies
1527   (const struct die_reader_specs *, const gdb_byte *, int);
1528
1529 static struct partial_die_info *find_partial_die (sect_offset, int,
1530                                                   struct dwarf2_cu *);
1531
1532 static const gdb_byte *read_attribute (const struct die_reader_specs *,
1533                                        struct attribute *, struct attr_abbrev *,
1534                                        const gdb_byte *);
1535
1536 static unsigned int read_1_byte (bfd *, const gdb_byte *);
1537
1538 static int read_1_signed_byte (bfd *, const gdb_byte *);
1539
1540 static unsigned int read_2_bytes (bfd *, const gdb_byte *);
1541
1542 static unsigned int read_4_bytes (bfd *, const gdb_byte *);
1543
1544 static ULONGEST read_8_bytes (bfd *, const gdb_byte *);
1545
1546 static CORE_ADDR read_address (bfd *, const gdb_byte *ptr, struct dwarf2_cu *,
1547                                unsigned int *);
1548
1549 static LONGEST read_initial_length (bfd *, const gdb_byte *, unsigned int *);
1550
1551 static LONGEST read_checked_initial_length_and_offset
1552   (bfd *, const gdb_byte *, const struct comp_unit_head *,
1553    unsigned int *, unsigned int *);
1554
1555 static LONGEST read_offset (bfd *, const gdb_byte *,
1556                             const struct comp_unit_head *,
1557                             unsigned int *);
1558
1559 static LONGEST read_offset_1 (bfd *, const gdb_byte *, unsigned int);
1560
1561 static sect_offset read_abbrev_offset
1562   (struct dwarf2_per_objfile *dwarf2_per_objfile,
1563    struct dwarf2_section_info *, sect_offset);
1564
1565 static const gdb_byte *read_n_bytes (bfd *, const gdb_byte *, unsigned int);
1566
1567 static const char *read_direct_string (bfd *, const gdb_byte *, unsigned int *);
1568
1569 static const char *read_indirect_string
1570   (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *, const gdb_byte *,
1571    const struct comp_unit_head *, unsigned int *);
1572
1573 static const char *read_indirect_line_string
1574   (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *, const gdb_byte *,
1575    const struct comp_unit_head *, unsigned int *);
1576
1577 static const char *read_indirect_string_at_offset
1578   (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *abfd,
1579    LONGEST str_offset);
1580
1581 static const char *read_indirect_string_from_dwz
1582   (struct objfile *objfile, struct dwz_file *, LONGEST);
1583
1584 static LONGEST read_signed_leb128 (bfd *, const gdb_byte *, unsigned int *);
1585
1586 static CORE_ADDR read_addr_index_from_leb128 (struct dwarf2_cu *,
1587                                               const gdb_byte *,
1588                                               unsigned int *);
1589
1590 static const char *read_str_index (const struct die_reader_specs *reader,
1591                                    ULONGEST str_index);
1592
1593 static void set_cu_language (unsigned int, struct dwarf2_cu *);
1594
1595 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
1596                                       struct dwarf2_cu *);
1597
1598 static struct attribute *dwarf2_attr_no_follow (struct die_info *,
1599                                                 unsigned int);
1600
1601 static const char *dwarf2_string_attr (struct die_info *die, unsigned int name,
1602                                        struct dwarf2_cu *cu);
1603
1604 static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
1605                                struct dwarf2_cu *cu);
1606
1607 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
1608
1609 static struct die_info *die_specification (struct die_info *die,
1610                                            struct dwarf2_cu **);
1611
1612 static line_header_up dwarf_decode_line_header (sect_offset sect_off,
1613                                                 struct dwarf2_cu *cu);
1614
1615 static void dwarf_decode_lines (struct line_header *, const char *,
1616                                 struct dwarf2_cu *, struct partial_symtab *,
1617                                 CORE_ADDR, int decode_mapping);
1618
1619 static void dwarf2_start_subfile (struct dwarf2_cu *, const char *,
1620                                   const char *);
1621
1622 static struct symbol *new_symbol (struct die_info *, struct type *,
1623                                   struct dwarf2_cu *, struct symbol * = NULL);
1624
1625 static void dwarf2_const_value (const struct attribute *, struct symbol *,
1626                                 struct dwarf2_cu *);
1627
1628 static void dwarf2_const_value_attr (const struct attribute *attr,
1629                                      struct type *type,
1630                                      const char *name,
1631                                      struct obstack *obstack,
1632                                      struct dwarf2_cu *cu, LONGEST *value,
1633                                      const gdb_byte **bytes,
1634                                      struct dwarf2_locexpr_baton **baton);
1635
1636 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
1637
1638 static int need_gnat_info (struct dwarf2_cu *);
1639
1640 static struct type *die_descriptive_type (struct die_info *,
1641                                           struct dwarf2_cu *);
1642
1643 static void set_descriptive_type (struct type *, struct die_info *,
1644                                   struct dwarf2_cu *);
1645
1646 static struct type *die_containing_type (struct die_info *,
1647                                          struct dwarf2_cu *);
1648
1649 static struct type *lookup_die_type (struct die_info *, const struct attribute *,
1650                                      struct dwarf2_cu *);
1651
1652 static struct type *read_type_die (struct die_info *, struct dwarf2_cu *);
1653
1654 static struct type *read_type_die_1 (struct die_info *, struct dwarf2_cu *);
1655
1656 static const char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
1657
1658 static char *typename_concat (struct obstack *obs, const char *prefix,
1659                               const char *suffix, int physname,
1660                               struct dwarf2_cu *cu);
1661
1662 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
1663
1664 static void read_type_unit_scope (struct die_info *, struct dwarf2_cu *);
1665
1666 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
1667
1668 static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
1669
1670 static void read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu);
1671
1672 static void read_variable (struct die_info *die, struct dwarf2_cu *cu);
1673
1674 static int dwarf2_ranges_read (unsigned, CORE_ADDR *, CORE_ADDR *,
1675                                struct dwarf2_cu *, struct partial_symtab *);
1676
1677 /* How dwarf2_get_pc_bounds constructed its *LOWPC and *HIGHPC return
1678    values.  Keep the items ordered with increasing constraints compliance.  */
1679 enum pc_bounds_kind
1680 {
1681   /* No attribute DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges was found.  */
1682   PC_BOUNDS_NOT_PRESENT,
1683
1684   /* Some of the attributes DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges
1685      were present but they do not form a valid range of PC addresses.  */
1686   PC_BOUNDS_INVALID,
1687
1688   /* Discontiguous range was found - that is DW_AT_ranges was found.  */
1689   PC_BOUNDS_RANGES,
1690
1691   /* Contiguous range was found - DW_AT_low_pc and DW_AT_high_pc were found.  */
1692   PC_BOUNDS_HIGH_LOW,
1693 };
1694
1695 static enum pc_bounds_kind dwarf2_get_pc_bounds (struct die_info *,
1696                                                  CORE_ADDR *, CORE_ADDR *,
1697                                                  struct dwarf2_cu *,
1698                                                  struct partial_symtab *);
1699
1700 static void get_scope_pc_bounds (struct die_info *,
1701                                  CORE_ADDR *, CORE_ADDR *,
1702                                  struct dwarf2_cu *);
1703
1704 static void dwarf2_record_block_ranges (struct die_info *, struct block *,
1705                                         CORE_ADDR, struct dwarf2_cu *);
1706
1707 static void dwarf2_add_field (struct field_info *, struct die_info *,
1708                               struct dwarf2_cu *);
1709
1710 static void dwarf2_attach_fields_to_type (struct field_info *,
1711                                           struct type *, struct dwarf2_cu *);
1712
1713 static void dwarf2_add_member_fn (struct field_info *,
1714                                   struct die_info *, struct type *,
1715                                   struct dwarf2_cu *);
1716
1717 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
1718                                              struct type *,
1719                                              struct dwarf2_cu *);
1720
1721 static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
1722
1723 static void read_common_block (struct die_info *, struct dwarf2_cu *);
1724
1725 static void read_namespace (struct die_info *die, struct dwarf2_cu *);
1726
1727 static void read_module (struct die_info *die, struct dwarf2_cu *cu);
1728
1729 static struct using_direct **using_directives (struct dwarf2_cu *cu);
1730
1731 static void read_import_statement (struct die_info *die, struct dwarf2_cu *);
1732
1733 static int read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu);
1734
1735 static struct type *read_module_type (struct die_info *die,
1736                                       struct dwarf2_cu *cu);
1737
1738 static const char *namespace_name (struct die_info *die,
1739                                    int *is_anonymous, struct dwarf2_cu *);
1740
1741 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
1742
1743 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
1744
1745 static enum dwarf_array_dim_ordering read_array_order (struct die_info *,
1746                                                        struct dwarf2_cu *);
1747
1748 static struct die_info *read_die_and_siblings_1
1749   (const struct die_reader_specs *, const gdb_byte *, const gdb_byte **,
1750    struct die_info *);
1751
1752 static struct die_info *read_die_and_siblings (const struct die_reader_specs *,
1753                                                const gdb_byte *info_ptr,
1754                                                const gdb_byte **new_info_ptr,
1755                                                struct die_info *parent);
1756
1757 static const gdb_byte *read_full_die_1 (const struct die_reader_specs *,
1758                                         struct die_info **, const gdb_byte *,
1759                                         int *, int);
1760
1761 static const gdb_byte *read_full_die (const struct die_reader_specs *,
1762                                       struct die_info **, const gdb_byte *,
1763                                       int *);
1764
1765 static void process_die (struct die_info *, struct dwarf2_cu *);
1766
1767 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu *,
1768                                              struct obstack *);
1769
1770 static const char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
1771
1772 static const char *dwarf2_full_name (const char *name,
1773                                      struct die_info *die,
1774                                      struct dwarf2_cu *cu);
1775
1776 static const char *dwarf2_physname (const char *name, struct die_info *die,
1777                                     struct dwarf2_cu *cu);
1778
1779 static struct die_info *dwarf2_extension (struct die_info *die,
1780                                           struct dwarf2_cu **);
1781
1782 static const char *dwarf_tag_name (unsigned int);
1783
1784 static const char *dwarf_attr_name (unsigned int);
1785
1786 static const char *dwarf_form_name (unsigned int);
1787
1788 static const char *dwarf_bool_name (unsigned int);
1789
1790 static const char *dwarf_type_encoding_name (unsigned int);
1791
1792 static struct die_info *sibling_die (struct die_info *);
1793
1794 static void dump_die_shallow (struct ui_file *, int indent, struct die_info *);
1795
1796 static void dump_die_for_error (struct die_info *);
1797
1798 static void dump_die_1 (struct ui_file *, int level, int max_level,
1799                         struct die_info *);
1800
1801 /*static*/ void dump_die (struct die_info *, int max_level);
1802
1803 static void store_in_ref_table (struct die_info *,
1804                                 struct dwarf2_cu *);
1805
1806 static sect_offset dwarf2_get_ref_die_offset (const struct attribute *);
1807
1808 static LONGEST dwarf2_get_attr_constant_value (const struct attribute *, int);
1809
1810 static struct die_info *follow_die_ref_or_sig (struct die_info *,
1811                                                const struct attribute *,
1812                                                struct dwarf2_cu **);
1813
1814 static struct die_info *follow_die_ref (struct die_info *,
1815                                         const struct attribute *,
1816                                         struct dwarf2_cu **);
1817
1818 static struct die_info *follow_die_sig (struct die_info *,
1819                                         const struct attribute *,
1820                                         struct dwarf2_cu **);
1821
1822 static struct type *get_signatured_type (struct die_info *, ULONGEST,
1823                                          struct dwarf2_cu *);
1824
1825 static struct type *get_DW_AT_signature_type (struct die_info *,
1826                                               const struct attribute *,
1827                                               struct dwarf2_cu *);
1828
1829 static void load_full_type_unit (struct dwarf2_per_cu_data *per_cu);
1830
1831 static void read_signatured_type (struct signatured_type *);
1832
1833 static int attr_to_dynamic_prop (const struct attribute *attr,
1834                                  struct die_info *die, struct dwarf2_cu *cu,
1835                                  struct dynamic_prop *prop);
1836
1837 /* memory allocation interface */
1838
1839 static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
1840
1841 static struct die_info *dwarf_alloc_die (struct dwarf2_cu *, int);
1842
1843 static void dwarf_decode_macros (struct dwarf2_cu *, unsigned int, int);
1844
1845 static int attr_form_is_block (const struct attribute *);
1846
1847 static int attr_form_is_section_offset (const struct attribute *);
1848
1849 static int attr_form_is_constant (const struct attribute *);
1850
1851 static int attr_form_is_ref (const struct attribute *);
1852
1853 static void fill_in_loclist_baton (struct dwarf2_cu *cu,
1854                                    struct dwarf2_loclist_baton *baton,
1855                                    const struct attribute *attr);
1856
1857 static void dwarf2_symbol_mark_computed (const struct attribute *attr,
1858                                          struct symbol *sym,
1859                                          struct dwarf2_cu *cu,
1860                                          int is_block);
1861
1862 static const gdb_byte *skip_one_die (const struct die_reader_specs *reader,
1863                                      const gdb_byte *info_ptr,
1864                                      struct abbrev_info *abbrev);
1865
1866 static hashval_t partial_die_hash (const void *item);
1867
1868 static int partial_die_eq (const void *item_lhs, const void *item_rhs);
1869
1870 static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit
1871   (sect_offset sect_off, unsigned int offset_in_dwz,
1872    struct dwarf2_per_objfile *dwarf2_per_objfile);
1873
1874 static void prepare_one_comp_unit (struct dwarf2_cu *cu,
1875                                    struct die_info *comp_unit_die,
1876                                    enum language pretend_language);
1877
1878 static void age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
1879
1880 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data *);
1881
1882 static struct type *set_die_type (struct die_info *, struct type *,
1883                                   struct dwarf2_cu *);
1884
1885 static void create_all_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
1886
1887 static int create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
1888
1889 static void load_full_comp_unit (struct dwarf2_per_cu_data *, bool,
1890                                  enum language);
1891
1892 static void process_full_comp_unit (struct dwarf2_per_cu_data *,
1893                                     enum language);
1894
1895 static void process_full_type_unit (struct dwarf2_per_cu_data *,
1896                                     enum language);
1897
1898 static void dwarf2_add_dependence (struct dwarf2_cu *,
1899                                    struct dwarf2_per_cu_data *);
1900
1901 static void dwarf2_mark (struct dwarf2_cu *);
1902
1903 static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
1904
1905 static struct type *get_die_type_at_offset (sect_offset,
1906                                             struct dwarf2_per_cu_data *);
1907
1908 static struct type *get_die_type (struct die_info *die, struct dwarf2_cu *cu);
1909
1910 static void queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
1911                              enum language pretend_language);
1912
1913 static void process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile);
1914
1915 /* Class, the destructor of which frees all allocated queue entries.  This
1916    will only have work to do if an error was thrown while processing the
1917    dwarf.  If no error was thrown then the queue entries should have all
1918    been processed, and freed, as we went along.  */
1919
1920 class dwarf2_queue_guard
1921 {
1922 public:
1923   dwarf2_queue_guard () = default;
1924
1925   /* Free any entries remaining on the queue.  There should only be
1926      entries left if we hit an error while processing the dwarf.  */
1927   ~dwarf2_queue_guard ()
1928   {
1929     struct dwarf2_queue_item *item, *last;
1930
1931     item = dwarf2_queue;
1932     while (item)
1933       {
1934         /* Anything still marked queued is likely to be in an
1935            inconsistent state, so discard it.  */
1936         if (item->per_cu->queued)
1937           {
1938             if (item->per_cu->cu != NULL)
1939               free_one_cached_comp_unit (item->per_cu);
1940             item->per_cu->queued = 0;
1941           }
1942
1943         last = item;
1944         item = item->next;
1945         xfree (last);
1946       }
1947
1948     dwarf2_queue = dwarf2_queue_tail = NULL;
1949   }
1950 };
1951
1952 /* The return type of find_file_and_directory.  Note, the enclosed
1953    string pointers are only valid while this object is valid.  */
1954
1955 struct file_and_directory
1956 {
1957   /* The filename.  This is never NULL.  */
1958   const char *name;
1959
1960   /* The compilation directory.  NULL if not known.  If we needed to
1961      compute a new string, this points to COMP_DIR_STORAGE, otherwise,
1962      points directly to the DW_AT_comp_dir string attribute owned by
1963      the obstack that owns the DIE.  */
1964   const char *comp_dir;
1965
1966   /* If we needed to build a new string for comp_dir, this is what
1967      owns the storage.  */
1968   std::string comp_dir_storage;
1969 };
1970
1971 static file_and_directory find_file_and_directory (struct die_info *die,
1972                                                    struct dwarf2_cu *cu);
1973
1974 static char *file_full_name (int file, struct line_header *lh,
1975                              const char *comp_dir);
1976
1977 /* Expected enum dwarf_unit_type for read_comp_unit_head.  */
1978 enum class rcuh_kind { COMPILE, TYPE };
1979
1980 static const gdb_byte *read_and_check_comp_unit_head
1981   (struct dwarf2_per_objfile* dwarf2_per_objfile,
1982    struct comp_unit_head *header,
1983    struct dwarf2_section_info *section,
1984    struct dwarf2_section_info *abbrev_section, const gdb_byte *info_ptr,
1985    rcuh_kind section_kind);
1986
1987 static void init_cutu_and_read_dies
1988   (struct dwarf2_per_cu_data *this_cu, struct abbrev_table *abbrev_table,
1989    int use_existing_cu, int keep, bool skip_partial,
1990    die_reader_func_ftype *die_reader_func, void *data);
1991
1992 static void init_cutu_and_read_dies_simple
1993   (struct dwarf2_per_cu_data *this_cu,
1994    die_reader_func_ftype *die_reader_func, void *data);
1995
1996 static htab_t allocate_signatured_type_table (struct objfile *objfile);
1997
1998 static htab_t allocate_dwo_unit_table (struct objfile *objfile);
1999
2000 static struct dwo_unit *lookup_dwo_unit_in_dwp
2001   (struct dwarf2_per_objfile *dwarf2_per_objfile,
2002    struct dwp_file *dwp_file, const char *comp_dir,
2003    ULONGEST signature, int is_debug_types);
2004
2005 static struct dwp_file *get_dwp_file
2006   (struct dwarf2_per_objfile *dwarf2_per_objfile);
2007
2008 static struct dwo_unit *lookup_dwo_comp_unit
2009   (struct dwarf2_per_cu_data *, const char *, const char *, ULONGEST);
2010
2011 static struct dwo_unit *lookup_dwo_type_unit
2012   (struct signatured_type *, const char *, const char *);
2013
2014 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *);
2015
2016 static void free_dwo_file (struct dwo_file *);
2017
2018 /* A unique_ptr helper to free a dwo_file.  */
2019
2020 struct dwo_file_deleter
2021 {
2022   void operator() (struct dwo_file *df) const
2023   {
2024     free_dwo_file (df);
2025   }
2026 };
2027
2028 /* A unique pointer to a dwo_file.  */
2029
2030 typedef std::unique_ptr<struct dwo_file, dwo_file_deleter> dwo_file_up;
2031
2032 static void process_cu_includes (struct dwarf2_per_objfile *dwarf2_per_objfile);
2033
2034 static void check_producer (struct dwarf2_cu *cu);
2035
2036 static void free_line_header_voidp (void *arg);
2037 \f
2038 /* Various complaints about symbol reading that don't abort the process.  */
2039
2040 static void
2041 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
2042 {
2043   complaint (_("statement list doesn't fit in .debug_line section"));
2044 }
2045
2046 static void
2047 dwarf2_debug_line_missing_file_complaint (void)
2048 {
2049   complaint (_(".debug_line section has line data without a file"));
2050 }
2051
2052 static void
2053 dwarf2_debug_line_missing_end_sequence_complaint (void)
2054 {
2055   complaint (_(".debug_line section has line "
2056                "program sequence without an end"));
2057 }
2058
2059 static void
2060 dwarf2_complex_location_expr_complaint (void)
2061 {
2062   complaint (_("location expression too complex"));
2063 }
2064
2065 static void
2066 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
2067                                               int arg3)
2068 {
2069   complaint (_("const value length mismatch for '%s', got %d, expected %d"),
2070              arg1, arg2, arg3);
2071 }
2072
2073 static void
2074 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info *section)
2075 {
2076   complaint (_("debug info runs off end of %s section"
2077                " [in module %s]"),
2078              get_section_name (section),
2079              get_section_file_name (section));
2080 }
2081
2082 static void
2083 dwarf2_macro_malformed_definition_complaint (const char *arg1)
2084 {
2085   complaint (_("macro debug info contains a "
2086                "malformed macro definition:\n`%s'"),
2087              arg1);
2088 }
2089
2090 static void
2091 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
2092 {
2093   complaint (_("invalid attribute class or form for '%s' in '%s'"),
2094              arg1, arg2);
2095 }
2096
2097 /* Hash function for line_header_hash.  */
2098
2099 static hashval_t
2100 line_header_hash (const struct line_header *ofs)
2101 {
2102   return to_underlying (ofs->sect_off) ^ ofs->offset_in_dwz;
2103 }
2104
2105 /* Hash function for htab_create_alloc_ex for line_header_hash.  */
2106
2107 static hashval_t
2108 line_header_hash_voidp (const void *item)
2109 {
2110   const struct line_header *ofs = (const struct line_header *) item;
2111
2112   return line_header_hash (ofs);
2113 }
2114
2115 /* Equality function for line_header_hash.  */
2116
2117 static int
2118 line_header_eq_voidp (const void *item_lhs, const void *item_rhs)
2119 {
2120   const struct line_header *ofs_lhs = (const struct line_header *) item_lhs;
2121   const struct line_header *ofs_rhs = (const struct line_header *) item_rhs;
2122
2123   return (ofs_lhs->sect_off == ofs_rhs->sect_off
2124           && ofs_lhs->offset_in_dwz == ofs_rhs->offset_in_dwz);
2125 }
2126
2127 \f
2128
2129 /* Read the given attribute value as an address, taking the attribute's
2130    form into account.  */
2131
2132 static CORE_ADDR
2133 attr_value_as_address (struct attribute *attr)
2134 {
2135   CORE_ADDR addr;
2136
2137   if (attr->form != DW_FORM_addr && attr->form != DW_FORM_GNU_addr_index)
2138     {
2139       /* Aside from a few clearly defined exceptions, attributes that
2140          contain an address must always be in DW_FORM_addr form.
2141          Unfortunately, some compilers happen to be violating this
2142          requirement by encoding addresses using other forms, such
2143          as DW_FORM_data4 for example.  For those broken compilers,
2144          we try to do our best, without any guarantee of success,
2145          to interpret the address correctly.  It would also be nice
2146          to generate a complaint, but that would require us to maintain
2147          a list of legitimate cases where a non-address form is allowed,
2148          as well as update callers to pass in at least the CU's DWARF
2149          version.  This is more overhead than what we're willing to
2150          expand for a pretty rare case.  */
2151       addr = DW_UNSND (attr);
2152     }
2153   else
2154     addr = DW_ADDR (attr);
2155
2156   return addr;
2157 }
2158
2159 /* See declaration.  */
2160
2161 dwarf2_per_objfile::dwarf2_per_objfile (struct objfile *objfile_,
2162                                         const dwarf2_debug_sections *names)
2163   : objfile (objfile_)
2164 {
2165   if (names == NULL)
2166     names = &dwarf2_elf_names;
2167
2168   bfd *obfd = objfile->obfd;
2169
2170   for (asection *sec = obfd->sections; sec != NULL; sec = sec->next)
2171     locate_sections (obfd, sec, *names);
2172 }
2173
2174 static void free_dwo_files (htab_t dwo_files, struct objfile *objfile);
2175
2176 dwarf2_per_objfile::~dwarf2_per_objfile ()
2177 {
2178   /* Cached DIE trees use xmalloc and the comp_unit_obstack.  */
2179   free_cached_comp_units ();
2180
2181   if (quick_file_names_table)
2182     htab_delete (quick_file_names_table);
2183
2184   if (line_header_hash)
2185     htab_delete (line_header_hash);
2186
2187   for (dwarf2_per_cu_data *per_cu : all_comp_units)
2188     VEC_free (dwarf2_per_cu_ptr, per_cu->imported_symtabs);
2189
2190   for (signatured_type *sig_type : all_type_units)
2191     VEC_free (dwarf2_per_cu_ptr, sig_type->per_cu.imported_symtabs);
2192
2193   VEC_free (dwarf2_section_info_def, types);
2194
2195   if (dwo_files != NULL)
2196     free_dwo_files (dwo_files, objfile);
2197
2198   /* Everything else should be on the objfile obstack.  */
2199 }
2200
2201 /* See declaration.  */
2202
2203 void
2204 dwarf2_per_objfile::free_cached_comp_units ()
2205 {
2206   dwarf2_per_cu_data *per_cu = read_in_chain;
2207   dwarf2_per_cu_data **last_chain = &read_in_chain;
2208   while (per_cu != NULL)
2209     {
2210       dwarf2_per_cu_data *next_cu = per_cu->cu->read_in_chain;
2211
2212       delete per_cu->cu;
2213       *last_chain = next_cu;
2214       per_cu = next_cu;
2215     }
2216 }
2217
2218 /* A helper class that calls free_cached_comp_units on
2219    destruction.  */
2220
2221 class free_cached_comp_units
2222 {
2223 public:
2224
2225   explicit free_cached_comp_units (dwarf2_per_objfile *per_objfile)
2226     : m_per_objfile (per_objfile)
2227   {
2228   }
2229
2230   ~free_cached_comp_units ()
2231   {
2232     m_per_objfile->free_cached_comp_units ();
2233   }
2234
2235   DISABLE_COPY_AND_ASSIGN (free_cached_comp_units);
2236
2237 private:
2238
2239   dwarf2_per_objfile *m_per_objfile;
2240 };
2241
2242 /* Try to locate the sections we need for DWARF 2 debugging
2243    information and return true if we have enough to do something.
2244    NAMES points to the dwarf2 section names, or is NULL if the standard
2245    ELF names are used.  */
2246
2247 int
2248 dwarf2_has_info (struct objfile *objfile,
2249                  const struct dwarf2_debug_sections *names)
2250 {
2251   if (objfile->flags & OBJF_READNEVER)
2252     return 0;
2253
2254   struct dwarf2_per_objfile *dwarf2_per_objfile
2255     = get_dwarf2_per_objfile (objfile);
2256
2257   if (dwarf2_per_objfile == NULL)
2258     {
2259       /* Initialize per-objfile state.  */
2260       dwarf2_per_objfile
2261         = new (&objfile->objfile_obstack) struct dwarf2_per_objfile (objfile,
2262                                                                      names);
2263       set_dwarf2_per_objfile (objfile, dwarf2_per_objfile);
2264     }
2265   return (!dwarf2_per_objfile->info.is_virtual
2266           && dwarf2_per_objfile->info.s.section != NULL
2267           && !dwarf2_per_objfile->abbrev.is_virtual
2268           && dwarf2_per_objfile->abbrev.s.section != NULL);
2269 }
2270
2271 /* Return the containing section of virtual section SECTION.  */
2272
2273 static struct dwarf2_section_info *
2274 get_containing_section (const struct dwarf2_section_info *section)
2275 {
2276   gdb_assert (section->is_virtual);
2277   return section->s.containing_section;
2278 }
2279
2280 /* Return the bfd owner of SECTION.  */
2281
2282 static struct bfd *
2283 get_section_bfd_owner (const struct dwarf2_section_info *section)
2284 {
2285   if (section->is_virtual)
2286     {
2287       section = get_containing_section (section);
2288       gdb_assert (!section->is_virtual);
2289     }
2290   return section->s.section->owner;
2291 }
2292
2293 /* Return the bfd section of SECTION.
2294    Returns NULL if the section is not present.  */
2295
2296 static asection *
2297 get_section_bfd_section (const struct dwarf2_section_info *section)
2298 {
2299   if (section->is_virtual)
2300     {
2301       section = get_containing_section (section);
2302       gdb_assert (!section->is_virtual);
2303     }
2304   return section->s.section;
2305 }
2306
2307 /* Return the name of SECTION.  */
2308
2309 static const char *
2310 get_section_name (const struct dwarf2_section_info *section)
2311 {
2312   asection *sectp = get_section_bfd_section (section);
2313
2314   gdb_assert (sectp != NULL);
2315   return bfd_section_name (get_section_bfd_owner (section), sectp);
2316 }
2317
2318 /* Return the name of the file SECTION is in.  */
2319
2320 static const char *
2321 get_section_file_name (const struct dwarf2_section_info *section)
2322 {
2323   bfd *abfd = get_section_bfd_owner (section);
2324
2325   return bfd_get_filename (abfd);
2326 }
2327
2328 /* Return the id of SECTION.
2329    Returns 0 if SECTION doesn't exist.  */
2330
2331 static int
2332 get_section_id (const struct dwarf2_section_info *section)
2333 {
2334   asection *sectp = get_section_bfd_section (section);
2335
2336   if (sectp == NULL)
2337     return 0;
2338   return sectp->id;
2339 }
2340
2341 /* Return the flags of SECTION.
2342    SECTION (or containing section if this is a virtual section) must exist.  */
2343
2344 static int
2345 get_section_flags (const struct dwarf2_section_info *section)
2346 {
2347   asection *sectp = get_section_bfd_section (section);
2348
2349   gdb_assert (sectp != NULL);
2350   return bfd_get_section_flags (sectp->owner, sectp);
2351 }
2352
2353 /* When loading sections, we look either for uncompressed section or for
2354    compressed section names.  */
2355
2356 static int
2357 section_is_p (const char *section_name,
2358               const struct dwarf2_section_names *names)
2359 {
2360   if (names->normal != NULL
2361       && strcmp (section_name, names->normal) == 0)
2362     return 1;
2363   if (names->compressed != NULL
2364       && strcmp (section_name, names->compressed) == 0)
2365     return 1;
2366   return 0;
2367 }
2368
2369 /* See declaration.  */
2370
2371 void
2372 dwarf2_per_objfile::locate_sections (bfd *abfd, asection *sectp,
2373                                      const dwarf2_debug_sections &names)
2374 {
2375   flagword aflag = bfd_get_section_flags (abfd, sectp);
2376
2377   if ((aflag & SEC_HAS_CONTENTS) == 0)
2378     {
2379     }
2380   else if (section_is_p (sectp->name, &names.info))
2381     {
2382       this->info.s.section = sectp;
2383       this->info.size = bfd_get_section_size (sectp);
2384     }
2385   else if (section_is_p (sectp->name, &names.abbrev))
2386     {
2387       this->abbrev.s.section = sectp;
2388       this->abbrev.size = bfd_get_section_size (sectp);
2389     }
2390   else if (section_is_p (sectp->name, &names.line))
2391     {
2392       this->line.s.section = sectp;
2393       this->line.size = bfd_get_section_size (sectp);
2394     }
2395   else if (section_is_p (sectp->name, &names.loc))
2396     {
2397       this->loc.s.section = sectp;
2398       this->loc.size = bfd_get_section_size (sectp);
2399     }
2400   else if (section_is_p (sectp->name, &names.loclists))
2401     {
2402       this->loclists.s.section = sectp;
2403       this->loclists.size = bfd_get_section_size (sectp);
2404     }
2405   else if (section_is_p (sectp->name, &names.macinfo))
2406     {
2407       this->macinfo.s.section = sectp;
2408       this->macinfo.size = bfd_get_section_size (sectp);
2409     }
2410   else if (section_is_p (sectp->name, &names.macro))
2411     {
2412       this->macro.s.section = sectp;
2413       this->macro.size = bfd_get_section_size (sectp);
2414     }
2415   else if (section_is_p (sectp->name, &names.str))
2416     {
2417       this->str.s.section = sectp;
2418       this->str.size = bfd_get_section_size (sectp);
2419     }
2420   else if (section_is_p (sectp->name, &names.line_str))
2421     {
2422       this->line_str.s.section = sectp;
2423       this->line_str.size = bfd_get_section_size (sectp);
2424     }
2425   else if (section_is_p (sectp->name, &names.addr))
2426     {
2427       this->addr.s.section = sectp;
2428       this->addr.size = bfd_get_section_size (sectp);
2429     }
2430   else if (section_is_p (sectp->name, &names.frame))
2431     {
2432       this->frame.s.section = sectp;
2433       this->frame.size = bfd_get_section_size (sectp);
2434     }
2435   else if (section_is_p (sectp->name, &names.eh_frame))
2436     {
2437       this->eh_frame.s.section = sectp;
2438       this->eh_frame.size = bfd_get_section_size (sectp);
2439     }
2440   else if (section_is_p (sectp->name, &names.ranges))
2441     {
2442       this->ranges.s.section = sectp;
2443       this->ranges.size = bfd_get_section_size (sectp);
2444     }
2445   else if (section_is_p (sectp->name, &names.rnglists))
2446     {
2447       this->rnglists.s.section = sectp;
2448       this->rnglists.size = bfd_get_section_size (sectp);
2449     }
2450   else if (section_is_p (sectp->name, &names.types))
2451     {
2452       struct dwarf2_section_info type_section;
2453
2454       memset (&type_section, 0, sizeof (type_section));
2455       type_section.s.section = sectp;
2456       type_section.size = bfd_get_section_size (sectp);
2457
2458       VEC_safe_push (dwarf2_section_info_def, this->types,
2459                      &type_section);
2460     }
2461   else if (section_is_p (sectp->name, &names.gdb_index))
2462     {
2463       this->gdb_index.s.section = sectp;
2464       this->gdb_index.size = bfd_get_section_size (sectp);
2465     }
2466   else if (section_is_p (sectp->name, &names.debug_names))
2467     {
2468       this->debug_names.s.section = sectp;
2469       this->debug_names.size = bfd_get_section_size (sectp);
2470     }
2471   else if (section_is_p (sectp->name, &names.debug_aranges))
2472     {
2473       this->debug_aranges.s.section = sectp;
2474       this->debug_aranges.size = bfd_get_section_size (sectp);
2475     }
2476
2477   if ((bfd_get_section_flags (abfd, sectp) & (SEC_LOAD | SEC_ALLOC))
2478       && bfd_section_vma (abfd, sectp) == 0)
2479     this->has_section_at_zero = true;
2480 }
2481
2482 /* A helper function that decides whether a section is empty,
2483    or not present.  */
2484
2485 static int
2486 dwarf2_section_empty_p (const struct dwarf2_section_info *section)
2487 {
2488   if (section->is_virtual)
2489     return section->size == 0;
2490   return section->s.section == NULL || section->size == 0;
2491 }
2492
2493 /* See dwarf2read.h.  */
2494
2495 void
2496 dwarf2_read_section (struct objfile *objfile, dwarf2_section_info *info)
2497 {
2498   asection *sectp;
2499   bfd *abfd;
2500   gdb_byte *buf, *retbuf;
2501
2502   if (info->readin)
2503     return;
2504   info->buffer = NULL;
2505   info->readin = 1;
2506
2507   if (dwarf2_section_empty_p (info))
2508     return;
2509
2510   sectp = get_section_bfd_section (info);
2511
2512   /* If this is a virtual section we need to read in the real one first.  */
2513   if (info->is_virtual)
2514     {
2515       struct dwarf2_section_info *containing_section =
2516         get_containing_section (info);
2517
2518       gdb_assert (sectp != NULL);
2519       if ((sectp->flags & SEC_RELOC) != 0)
2520         {
2521           error (_("Dwarf Error: DWP format V2 with relocations is not"
2522                    " supported in section %s [in module %s]"),
2523                  get_section_name (info), get_section_file_name (info));
2524         }
2525       dwarf2_read_section (objfile, containing_section);
2526       /* Other code should have already caught virtual sections that don't
2527          fit.  */
2528       gdb_assert (info->virtual_offset + info->size
2529                   <= containing_section->size);
2530       /* If the real section is empty or there was a problem reading the
2531          section we shouldn't get here.  */
2532       gdb_assert (containing_section->buffer != NULL);
2533       info->buffer = containing_section->buffer + info->virtual_offset;
2534       return;
2535     }
2536
2537   /* If the section has relocations, we must read it ourselves.
2538      Otherwise we attach it to the BFD.  */
2539   if ((sectp->flags & SEC_RELOC) == 0)
2540     {
2541       info->buffer = gdb_bfd_map_section (sectp, &info->size);
2542       return;
2543     }
2544
2545   buf = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, info->size);
2546   info->buffer = buf;
2547
2548   /* When debugging .o files, we may need to apply relocations; see
2549      http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2550      We never compress sections in .o files, so we only need to
2551      try this when the section is not compressed.  */
2552   retbuf = symfile_relocate_debug_section (objfile, sectp, buf);
2553   if (retbuf != NULL)
2554     {
2555       info->buffer = retbuf;
2556       return;
2557     }
2558
2559   abfd = get_section_bfd_owner (info);
2560   gdb_assert (abfd != NULL);
2561
2562   if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
2563       || bfd_bread (buf, info->size, abfd) != info->size)
2564     {
2565       error (_("Dwarf Error: Can't read DWARF data"
2566                " in section %s [in module %s]"),
2567              bfd_section_name (abfd, sectp), bfd_get_filename (abfd));
2568     }
2569 }
2570
2571 /* A helper function that returns the size of a section in a safe way.
2572    If you are positive that the section has been read before using the
2573    size, then it is safe to refer to the dwarf2_section_info object's
2574    "size" field directly.  In other cases, you must call this
2575    function, because for compressed sections the size field is not set
2576    correctly until the section has been read.  */
2577
2578 static bfd_size_type
2579 dwarf2_section_size (struct objfile *objfile,
2580                      struct dwarf2_section_info *info)
2581 {
2582   if (!info->readin)
2583     dwarf2_read_section (objfile, info);
2584   return info->size;
2585 }
2586
2587 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2588    SECTION_NAME.  */
2589
2590 void
2591 dwarf2_get_section_info (struct objfile *objfile,
2592                          enum dwarf2_section_enum sect,
2593                          asection **sectp, const gdb_byte **bufp,
2594                          bfd_size_type *sizep)
2595 {
2596   struct dwarf2_per_objfile *data
2597     = (struct dwarf2_per_objfile *) objfile_data (objfile,
2598                                                   dwarf2_objfile_data_key);
2599   struct dwarf2_section_info *info;
2600
2601   /* We may see an objfile without any DWARF, in which case we just
2602      return nothing.  */
2603   if (data == NULL)
2604     {
2605       *sectp = NULL;
2606       *bufp = NULL;
2607       *sizep = 0;
2608       return;
2609     }
2610   switch (sect)
2611     {
2612     case DWARF2_DEBUG_FRAME:
2613       info = &data->frame;
2614       break;
2615     case DWARF2_EH_FRAME:
2616       info = &data->eh_frame;
2617       break;
2618     default:
2619       gdb_assert_not_reached ("unexpected section");
2620     }
2621
2622   dwarf2_read_section (objfile, info);
2623
2624   *sectp = get_section_bfd_section (info);
2625   *bufp = info->buffer;
2626   *sizep = info->size;
2627 }
2628
2629 /* A helper function to find the sections for a .dwz file.  */
2630
2631 static void
2632 locate_dwz_sections (bfd *abfd, asection *sectp, void *arg)
2633 {
2634   struct dwz_file *dwz_file = (struct dwz_file *) arg;
2635
2636   /* Note that we only support the standard ELF names, because .dwz
2637      is ELF-only (at the time of writing).  */
2638   if (section_is_p (sectp->name, &dwarf2_elf_names.abbrev))
2639     {
2640       dwz_file->abbrev.s.section = sectp;
2641       dwz_file->abbrev.size = bfd_get_section_size (sectp);
2642     }
2643   else if (section_is_p (sectp->name, &dwarf2_elf_names.info))
2644     {
2645       dwz_file->info.s.section = sectp;
2646       dwz_file->info.size = bfd_get_section_size (sectp);
2647     }
2648   else if (section_is_p (sectp->name, &dwarf2_elf_names.str))
2649     {
2650       dwz_file->str.s.section = sectp;
2651       dwz_file->str.size = bfd_get_section_size (sectp);
2652     }
2653   else if (section_is_p (sectp->name, &dwarf2_elf_names.line))
2654     {
2655       dwz_file->line.s.section = sectp;
2656       dwz_file->line.size = bfd_get_section_size (sectp);
2657     }
2658   else if (section_is_p (sectp->name, &dwarf2_elf_names.macro))
2659     {
2660       dwz_file->macro.s.section = sectp;
2661       dwz_file->macro.size = bfd_get_section_size (sectp);
2662     }
2663   else if (section_is_p (sectp->name, &dwarf2_elf_names.gdb_index))
2664     {
2665       dwz_file->gdb_index.s.section = sectp;
2666       dwz_file->gdb_index.size = bfd_get_section_size (sectp);
2667     }
2668   else if (section_is_p (sectp->name, &dwarf2_elf_names.debug_names))
2669     {
2670       dwz_file->debug_names.s.section = sectp;
2671       dwz_file->debug_names.size = bfd_get_section_size (sectp);
2672     }
2673 }
2674
2675 /* Open the separate '.dwz' debug file, if needed.  Return NULL if
2676    there is no .gnu_debugaltlink section in the file.  Error if there
2677    is such a section but the file cannot be found.  */
2678
2679 static struct dwz_file *
2680 dwarf2_get_dwz_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
2681 {
2682   const char *filename;
2683   bfd_size_type buildid_len_arg;
2684   size_t buildid_len;
2685   bfd_byte *buildid;
2686
2687   if (dwarf2_per_objfile->dwz_file != NULL)
2688     return dwarf2_per_objfile->dwz_file.get ();
2689
2690   bfd_set_error (bfd_error_no_error);
2691   gdb::unique_xmalloc_ptr<char> data
2692     (bfd_get_alt_debug_link_info (dwarf2_per_objfile->objfile->obfd,
2693                                   &buildid_len_arg, &buildid));
2694   if (data == NULL)
2695     {
2696       if (bfd_get_error () == bfd_error_no_error)
2697         return NULL;
2698       error (_("could not read '.gnu_debugaltlink' section: %s"),
2699              bfd_errmsg (bfd_get_error ()));
2700     }
2701
2702   gdb::unique_xmalloc_ptr<bfd_byte> buildid_holder (buildid);
2703
2704   buildid_len = (size_t) buildid_len_arg;
2705
2706   filename = data.get ();
2707
2708   std::string abs_storage;
2709   if (!IS_ABSOLUTE_PATH (filename))
2710     {
2711       gdb::unique_xmalloc_ptr<char> abs
2712         = gdb_realpath (objfile_name (dwarf2_per_objfile->objfile));
2713
2714       abs_storage = ldirname (abs.get ()) + SLASH_STRING + filename;
2715       filename = abs_storage.c_str ();
2716     }
2717
2718   /* First try the file name given in the section.  If that doesn't
2719      work, try to use the build-id instead.  */
2720   gdb_bfd_ref_ptr dwz_bfd (gdb_bfd_open (filename, gnutarget, -1));
2721   if (dwz_bfd != NULL)
2722     {
2723       if (!build_id_verify (dwz_bfd.get (), buildid_len, buildid))
2724         dwz_bfd.reset (nullptr);
2725     }
2726
2727   if (dwz_bfd == NULL)
2728     dwz_bfd = build_id_to_debug_bfd (buildid_len, buildid);
2729
2730   if (dwz_bfd == NULL)
2731     error (_("could not find '.gnu_debugaltlink' file for %s"),
2732            objfile_name (dwarf2_per_objfile->objfile));
2733
2734   std::unique_ptr<struct dwz_file> result
2735     (new struct dwz_file (std::move (dwz_bfd)));
2736
2737   bfd_map_over_sections (result->dwz_bfd.get (), locate_dwz_sections,
2738                          result.get ());
2739
2740   gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd,
2741                             result->dwz_bfd.get ());
2742   dwarf2_per_objfile->dwz_file = std::move (result);
2743   return dwarf2_per_objfile->dwz_file.get ();
2744 }
2745 \f
2746 /* DWARF quick_symbols_functions support.  */
2747
2748 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2749    unique line tables, so we maintain a separate table of all .debug_line
2750    derived entries to support the sharing.
2751    All the quick functions need is the list of file names.  We discard the
2752    line_header when we're done and don't need to record it here.  */
2753 struct quick_file_names
2754 {
2755   /* The data used to construct the hash key.  */
2756   struct stmt_list_hash hash;
2757
2758   /* The number of entries in file_names, real_names.  */
2759   unsigned int num_file_names;
2760
2761   /* The file names from the line table, after being run through
2762      file_full_name.  */
2763   const char **file_names;
2764
2765   /* The file names from the line table after being run through
2766      gdb_realpath.  These are computed lazily.  */
2767   const char **real_names;
2768 };
2769
2770 /* When using the index (and thus not using psymtabs), each CU has an
2771    object of this type.  This is used to hold information needed by
2772    the various "quick" methods.  */
2773 struct dwarf2_per_cu_quick_data
2774 {
2775   /* The file table.  This can be NULL if there was no file table
2776      or it's currently not read in.
2777      NOTE: This points into dwarf2_per_objfile->quick_file_names_table.  */
2778   struct quick_file_names *file_names;
2779
2780   /* The corresponding symbol table.  This is NULL if symbols for this
2781      CU have not yet been read.  */
2782   struct compunit_symtab *compunit_symtab;
2783
2784   /* A temporary mark bit used when iterating over all CUs in
2785      expand_symtabs_matching.  */
2786   unsigned int mark : 1;
2787
2788   /* True if we've tried to read the file table and found there isn't one.
2789      There will be no point in trying to read it again next time.  */
2790   unsigned int no_file_data : 1;
2791 };
2792
2793 /* Utility hash function for a stmt_list_hash.  */
2794
2795 static hashval_t
2796 hash_stmt_list_entry (const struct stmt_list_hash *stmt_list_hash)
2797 {
2798   hashval_t v = 0;
2799
2800   if (stmt_list_hash->dwo_unit != NULL)
2801     v += (uintptr_t) stmt_list_hash->dwo_unit->dwo_file;
2802   v += to_underlying (stmt_list_hash->line_sect_off);
2803   return v;
2804 }
2805
2806 /* Utility equality function for a stmt_list_hash.  */
2807
2808 static int
2809 eq_stmt_list_entry (const struct stmt_list_hash *lhs,
2810                     const struct stmt_list_hash *rhs)
2811 {
2812   if ((lhs->dwo_unit != NULL) != (rhs->dwo_unit != NULL))
2813     return 0;
2814   if (lhs->dwo_unit != NULL
2815       && lhs->dwo_unit->dwo_file != rhs->dwo_unit->dwo_file)
2816     return 0;
2817
2818   return lhs->line_sect_off == rhs->line_sect_off;
2819 }
2820
2821 /* Hash function for a quick_file_names.  */
2822
2823 static hashval_t
2824 hash_file_name_entry (const void *e)
2825 {
2826   const struct quick_file_names *file_data
2827     = (const struct quick_file_names *) e;
2828
2829   return hash_stmt_list_entry (&file_data->hash);
2830 }
2831
2832 /* Equality function for a quick_file_names.  */
2833
2834 static int
2835 eq_file_name_entry (const void *a, const void *b)
2836 {
2837   const struct quick_file_names *ea = (const struct quick_file_names *) a;
2838   const struct quick_file_names *eb = (const struct quick_file_names *) b;
2839
2840   return eq_stmt_list_entry (&ea->hash, &eb->hash);
2841 }
2842
2843 /* Delete function for a quick_file_names.  */
2844
2845 static void
2846 delete_file_name_entry (void *e)
2847 {
2848   struct quick_file_names *file_data = (struct quick_file_names *) e;
2849   int i;
2850
2851   for (i = 0; i < file_data->num_file_names; ++i)
2852     {
2853       xfree ((void*) file_data->file_names[i]);
2854       if (file_data->real_names)
2855         xfree ((void*) file_data->real_names[i]);
2856     }
2857
2858   /* The space for the struct itself lives on objfile_obstack,
2859      so we don't free it here.  */
2860 }
2861
2862 /* Create a quick_file_names hash table.  */
2863
2864 static htab_t
2865 create_quick_file_names_table (unsigned int nr_initial_entries)
2866 {
2867   return htab_create_alloc (nr_initial_entries,
2868                             hash_file_name_entry, eq_file_name_entry,
2869                             delete_file_name_entry, xcalloc, xfree);
2870 }
2871
2872 /* Read in PER_CU->CU.  This function is unrelated to symtabs, symtab would
2873    have to be created afterwards.  You should call age_cached_comp_units after
2874    processing PER_CU->CU.  dw2_setup must have been already called.  */
2875
2876 static void
2877 load_cu (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
2878 {
2879   if (per_cu->is_debug_types)
2880     load_full_type_unit (per_cu);
2881   else
2882     load_full_comp_unit (per_cu, skip_partial, language_minimal);
2883
2884   if (per_cu->cu == NULL)
2885     return;  /* Dummy CU.  */
2886
2887   dwarf2_find_base_address (per_cu->cu->dies, per_cu->cu);
2888 }
2889
2890 /* Read in the symbols for PER_CU.  */
2891
2892 static void
2893 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
2894 {
2895   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
2896
2897   /* Skip type_unit_groups, reading the type units they contain
2898      is handled elsewhere.  */
2899   if (IS_TYPE_UNIT_GROUP (per_cu))
2900     return;
2901
2902   /* The destructor of dwarf2_queue_guard frees any entries left on
2903      the queue.  After this point we're guaranteed to leave this function
2904      with the dwarf queue empty.  */
2905   dwarf2_queue_guard q_guard;
2906
2907   if (dwarf2_per_objfile->using_index
2908       ? per_cu->v.quick->compunit_symtab == NULL
2909       : (per_cu->v.psymtab == NULL || !per_cu->v.psymtab->readin))
2910     {
2911       queue_comp_unit (per_cu, language_minimal);
2912       load_cu (per_cu, skip_partial);
2913
2914       /* If we just loaded a CU from a DWO, and we're working with an index
2915          that may badly handle TUs, load all the TUs in that DWO as well.
2916          http://sourceware.org/bugzilla/show_bug.cgi?id=15021  */
2917       if (!per_cu->is_debug_types
2918           && per_cu->cu != NULL
2919           && per_cu->cu->dwo_unit != NULL
2920           && dwarf2_per_objfile->index_table != NULL
2921           && dwarf2_per_objfile->index_table->version <= 7
2922           /* DWP files aren't supported yet.  */
2923           && get_dwp_file (dwarf2_per_objfile) == NULL)
2924         queue_and_load_all_dwo_tus (per_cu);
2925     }
2926
2927   process_queue (dwarf2_per_objfile);
2928
2929   /* Age the cache, releasing compilation units that have not
2930      been used recently.  */
2931   age_cached_comp_units (dwarf2_per_objfile);
2932 }
2933
2934 /* Ensure that the symbols for PER_CU have been read in.  OBJFILE is
2935    the objfile from which this CU came.  Returns the resulting symbol
2936    table.  */
2937
2938 static struct compunit_symtab *
2939 dw2_instantiate_symtab (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
2940 {
2941   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
2942
2943   gdb_assert (dwarf2_per_objfile->using_index);
2944   if (!per_cu->v.quick->compunit_symtab)
2945     {
2946       free_cached_comp_units freer (dwarf2_per_objfile);
2947       scoped_restore decrementer = increment_reading_symtab ();
2948       dw2_do_instantiate_symtab (per_cu, skip_partial);
2949       process_cu_includes (dwarf2_per_objfile);
2950     }
2951
2952   return per_cu->v.quick->compunit_symtab;
2953 }
2954
2955 /* See declaration.  */
2956
2957 dwarf2_per_cu_data *
2958 dwarf2_per_objfile::get_cutu (int index)
2959 {
2960   if (index >= this->all_comp_units.size ())
2961     {
2962       index -= this->all_comp_units.size ();
2963       gdb_assert (index < this->all_type_units.size ());
2964       return &this->all_type_units[index]->per_cu;
2965     }
2966
2967   return this->all_comp_units[index];
2968 }
2969
2970 /* See declaration.  */
2971
2972 dwarf2_per_cu_data *
2973 dwarf2_per_objfile::get_cu (int index)
2974 {
2975   gdb_assert (index >= 0 && index < this->all_comp_units.size ());
2976
2977   return this->all_comp_units[index];
2978 }
2979
2980 /* See declaration.  */
2981
2982 signatured_type *
2983 dwarf2_per_objfile::get_tu (int index)
2984 {
2985   gdb_assert (index >= 0 && index < this->all_type_units.size ());
2986
2987   return this->all_type_units[index];
2988 }
2989
2990 /* Return a new dwarf2_per_cu_data allocated on OBJFILE's
2991    objfile_obstack, and constructed with the specified field
2992    values.  */
2993
2994 static dwarf2_per_cu_data *
2995 create_cu_from_index_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
2996                           struct dwarf2_section_info *section,
2997                           int is_dwz,
2998                           sect_offset sect_off, ULONGEST length)
2999 {
3000   struct objfile *objfile = dwarf2_per_objfile->objfile;
3001   dwarf2_per_cu_data *the_cu
3002     = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3003                      struct dwarf2_per_cu_data);
3004   the_cu->sect_off = sect_off;
3005   the_cu->length = length;
3006   the_cu->dwarf2_per_objfile = dwarf2_per_objfile;
3007   the_cu->section = section;
3008   the_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3009                                    struct dwarf2_per_cu_quick_data);
3010   the_cu->is_dwz = is_dwz;
3011   return the_cu;
3012 }
3013
3014 /* A helper for create_cus_from_index that handles a given list of
3015    CUs.  */
3016
3017 static void
3018 create_cus_from_index_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
3019                             const gdb_byte *cu_list, offset_type n_elements,
3020                             struct dwarf2_section_info *section,
3021                             int is_dwz)
3022 {
3023   for (offset_type i = 0; i < n_elements; i += 2)
3024     {
3025       gdb_static_assert (sizeof (ULONGEST) >= 8);
3026
3027       sect_offset sect_off
3028         = (sect_offset) extract_unsigned_integer (cu_list, 8, BFD_ENDIAN_LITTLE);
3029       ULONGEST length = extract_unsigned_integer (cu_list + 8, 8, BFD_ENDIAN_LITTLE);
3030       cu_list += 2 * 8;
3031
3032       dwarf2_per_cu_data *per_cu
3033         = create_cu_from_index_list (dwarf2_per_objfile, section, is_dwz,
3034                                      sect_off, length);
3035       dwarf2_per_objfile->all_comp_units.push_back (per_cu);
3036     }
3037 }
3038
3039 /* Read the CU list from the mapped index, and use it to create all
3040    the CU objects for this objfile.  */
3041
3042 static void
3043 create_cus_from_index (struct dwarf2_per_objfile *dwarf2_per_objfile,
3044                        const gdb_byte *cu_list, offset_type cu_list_elements,
3045                        const gdb_byte *dwz_list, offset_type dwz_elements)
3046 {
3047   gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
3048   dwarf2_per_objfile->all_comp_units.reserve
3049     ((cu_list_elements + dwz_elements) / 2);
3050
3051   create_cus_from_index_list (dwarf2_per_objfile, cu_list, cu_list_elements,
3052                               &dwarf2_per_objfile->info, 0);
3053
3054   if (dwz_elements == 0)
3055     return;
3056
3057   dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
3058   create_cus_from_index_list (dwarf2_per_objfile, dwz_list, dwz_elements,
3059                               &dwz->info, 1);
3060 }
3061
3062 /* Create the signatured type hash table from the index.  */
3063
3064 static void
3065 create_signatured_type_table_from_index
3066   (struct dwarf2_per_objfile *dwarf2_per_objfile,
3067    struct dwarf2_section_info *section,
3068    const gdb_byte *bytes,
3069    offset_type elements)
3070 {
3071   struct objfile *objfile = dwarf2_per_objfile->objfile;
3072
3073   gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
3074   dwarf2_per_objfile->all_type_units.reserve (elements / 3);
3075
3076   htab_t sig_types_hash = allocate_signatured_type_table (objfile);
3077
3078   for (offset_type i = 0; i < elements; i += 3)
3079     {
3080       struct signatured_type *sig_type;
3081       ULONGEST signature;
3082       void **slot;
3083       cu_offset type_offset_in_tu;
3084
3085       gdb_static_assert (sizeof (ULONGEST) >= 8);
3086       sect_offset sect_off
3087         = (sect_offset) extract_unsigned_integer (bytes, 8, BFD_ENDIAN_LITTLE);
3088       type_offset_in_tu
3089         = (cu_offset) extract_unsigned_integer (bytes + 8, 8,
3090                                                 BFD_ENDIAN_LITTLE);
3091       signature = extract_unsigned_integer (bytes + 16, 8, BFD_ENDIAN_LITTLE);
3092       bytes += 3 * 8;
3093
3094       sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3095                                  struct signatured_type);
3096       sig_type->signature = signature;
3097       sig_type->type_offset_in_tu = type_offset_in_tu;
3098       sig_type->per_cu.is_debug_types = 1;
3099       sig_type->per_cu.section = section;
3100       sig_type->per_cu.sect_off = sect_off;
3101       sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
3102       sig_type->per_cu.v.quick
3103         = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3104                           struct dwarf2_per_cu_quick_data);
3105
3106       slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
3107       *slot = sig_type;
3108
3109       dwarf2_per_objfile->all_type_units.push_back (sig_type);
3110     }
3111
3112   dwarf2_per_objfile->signatured_types = sig_types_hash;
3113 }
3114
3115 /* Create the signatured type hash table from .debug_names.  */
3116
3117 static void
3118 create_signatured_type_table_from_debug_names
3119   (struct dwarf2_per_objfile *dwarf2_per_objfile,
3120    const mapped_debug_names &map,
3121    struct dwarf2_section_info *section,
3122    struct dwarf2_section_info *abbrev_section)
3123 {
3124   struct objfile *objfile = dwarf2_per_objfile->objfile;
3125
3126   dwarf2_read_section (objfile, section);
3127   dwarf2_read_section (objfile, abbrev_section);
3128
3129   gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
3130   dwarf2_per_objfile->all_type_units.reserve (map.tu_count);
3131
3132   htab_t sig_types_hash = allocate_signatured_type_table (objfile);
3133
3134   for (uint32_t i = 0; i < map.tu_count; ++i)
3135     {
3136       struct signatured_type *sig_type;
3137       void **slot;
3138
3139       sect_offset sect_off
3140         = (sect_offset) (extract_unsigned_integer
3141                          (map.tu_table_reordered + i * map.offset_size,
3142                           map.offset_size,
3143                           map.dwarf5_byte_order));
3144
3145       comp_unit_head cu_header;
3146       read_and_check_comp_unit_head (dwarf2_per_objfile, &cu_header, section,
3147                                      abbrev_section,
3148                                      section->buffer + to_underlying (sect_off),
3149                                      rcuh_kind::TYPE);
3150
3151       sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3152                                  struct signatured_type);
3153       sig_type->signature = cu_header.signature;
3154       sig_type->type_offset_in_tu = cu_header.type_cu_offset_in_tu;
3155       sig_type->per_cu.is_debug_types = 1;
3156       sig_type->per_cu.section = section;
3157       sig_type->per_cu.sect_off = sect_off;
3158       sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
3159       sig_type->per_cu.v.quick
3160         = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3161                           struct dwarf2_per_cu_quick_data);
3162
3163       slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
3164       *slot = sig_type;
3165
3166       dwarf2_per_objfile->all_type_units.push_back (sig_type);
3167     }
3168
3169   dwarf2_per_objfile->signatured_types = sig_types_hash;
3170 }
3171
3172 /* Read the address map data from the mapped index, and use it to
3173    populate the objfile's psymtabs_addrmap.  */
3174
3175 static void
3176 create_addrmap_from_index (struct dwarf2_per_objfile *dwarf2_per_objfile,
3177                            struct mapped_index *index)
3178 {
3179   struct objfile *objfile = dwarf2_per_objfile->objfile;
3180   struct gdbarch *gdbarch = get_objfile_arch (objfile);
3181   const gdb_byte *iter, *end;
3182   struct addrmap *mutable_map;
3183   CORE_ADDR baseaddr;
3184
3185   auto_obstack temp_obstack;
3186
3187   mutable_map = addrmap_create_mutable (&temp_obstack);
3188
3189   iter = index->address_table.data ();
3190   end = iter + index->address_table.size ();
3191
3192   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
3193
3194   while (iter < end)
3195     {
3196       ULONGEST hi, lo, cu_index;
3197       lo = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
3198       iter += 8;
3199       hi = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
3200       iter += 8;
3201       cu_index = extract_unsigned_integer (iter, 4, BFD_ENDIAN_LITTLE);
3202       iter += 4;
3203
3204       if (lo > hi)
3205         {
3206           complaint (_(".gdb_index address table has invalid range (%s - %s)"),
3207                      hex_string (lo), hex_string (hi));
3208           continue;
3209         }
3210
3211       if (cu_index >= dwarf2_per_objfile->all_comp_units.size ())
3212         {
3213           complaint (_(".gdb_index address table has invalid CU number %u"),
3214                      (unsigned) cu_index);
3215           continue;
3216         }
3217
3218       lo = gdbarch_adjust_dwarf2_addr (gdbarch, lo + baseaddr) - baseaddr;
3219       hi = gdbarch_adjust_dwarf2_addr (gdbarch, hi + baseaddr) - baseaddr;
3220       addrmap_set_empty (mutable_map, lo, hi - 1,
3221                          dwarf2_per_objfile->get_cu (cu_index));
3222     }
3223
3224   objfile->partial_symtabs->psymtabs_addrmap
3225     = addrmap_create_fixed (mutable_map, objfile->partial_symtabs->obstack ());
3226 }
3227
3228 /* Read the address map data from DWARF-5 .debug_aranges, and use it to
3229    populate the objfile's psymtabs_addrmap.  */
3230
3231 static void
3232 create_addrmap_from_aranges (struct dwarf2_per_objfile *dwarf2_per_objfile,
3233                              struct dwarf2_section_info *section)
3234 {
3235   struct objfile *objfile = dwarf2_per_objfile->objfile;
3236   bfd *abfd = objfile->obfd;
3237   struct gdbarch *gdbarch = get_objfile_arch (objfile);
3238   const CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
3239                                        SECT_OFF_TEXT (objfile));
3240
3241   auto_obstack temp_obstack;
3242   addrmap *mutable_map = addrmap_create_mutable (&temp_obstack);
3243
3244   std::unordered_map<sect_offset,
3245                      dwarf2_per_cu_data *,
3246                      gdb::hash_enum<sect_offset>>
3247     debug_info_offset_to_per_cu;
3248   for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
3249     {
3250       const auto insertpair
3251         = debug_info_offset_to_per_cu.emplace (per_cu->sect_off, per_cu);
3252       if (!insertpair.second)
3253         {
3254           warning (_("Section .debug_aranges in %s has duplicate "
3255                      "debug_info_offset %s, ignoring .debug_aranges."),
3256                    objfile_name (objfile), sect_offset_str (per_cu->sect_off));
3257           return;
3258         }
3259     }
3260
3261   dwarf2_read_section (objfile, section);
3262
3263   const bfd_endian dwarf5_byte_order = gdbarch_byte_order (gdbarch);
3264
3265   const gdb_byte *addr = section->buffer;
3266
3267   while (addr < section->buffer + section->size)
3268     {
3269       const gdb_byte *const entry_addr = addr;
3270       unsigned int bytes_read;
3271
3272       const LONGEST entry_length = read_initial_length (abfd, addr,
3273                                                         &bytes_read);
3274       addr += bytes_read;
3275
3276       const gdb_byte *const entry_end = addr + entry_length;
3277       const bool dwarf5_is_dwarf64 = bytes_read != 4;
3278       const uint8_t offset_size = dwarf5_is_dwarf64 ? 8 : 4;
3279       if (addr + entry_length > section->buffer + section->size)
3280         {
3281           warning (_("Section .debug_aranges in %s entry at offset %zu "
3282                      "length %s exceeds section length %s, "
3283                      "ignoring .debug_aranges."),
3284                    objfile_name (objfile), entry_addr - section->buffer,
3285                    plongest (bytes_read + entry_length),
3286                    pulongest (section->size));
3287           return;
3288         }
3289
3290       /* The version number.  */
3291       const uint16_t version = read_2_bytes (abfd, addr);
3292       addr += 2;
3293       if (version != 2)
3294         {
3295           warning (_("Section .debug_aranges in %s entry at offset %zu "
3296                      "has unsupported version %d, ignoring .debug_aranges."),
3297                    objfile_name (objfile), entry_addr - section->buffer,
3298                    version);
3299           return;
3300         }
3301
3302       const uint64_t debug_info_offset
3303         = extract_unsigned_integer (addr, offset_size, dwarf5_byte_order);
3304       addr += offset_size;
3305       const auto per_cu_it
3306         = debug_info_offset_to_per_cu.find (sect_offset (debug_info_offset));
3307       if (per_cu_it == debug_info_offset_to_per_cu.cend ())
3308         {
3309           warning (_("Section .debug_aranges in %s entry at offset %zu "
3310                      "debug_info_offset %s does not exists, "
3311                      "ignoring .debug_aranges."),
3312                    objfile_name (objfile), entry_addr - section->buffer,
3313                    pulongest (debug_info_offset));
3314           return;
3315         }
3316       dwarf2_per_cu_data *const per_cu = per_cu_it->second;
3317
3318       const uint8_t address_size = *addr++;
3319       if (address_size < 1 || address_size > 8)
3320         {
3321           warning (_("Section .debug_aranges in %s entry at offset %zu "
3322                      "address_size %u is invalid, ignoring .debug_aranges."),
3323                    objfile_name (objfile), entry_addr - section->buffer,
3324                    address_size);
3325           return;
3326         }
3327
3328       const uint8_t segment_selector_size = *addr++;
3329       if (segment_selector_size != 0)
3330         {
3331           warning (_("Section .debug_aranges in %s entry at offset %zu "
3332                      "segment_selector_size %u is not supported, "
3333                      "ignoring .debug_aranges."),
3334                    objfile_name (objfile), entry_addr - section->buffer,
3335                    segment_selector_size);
3336           return;
3337         }
3338
3339       /* Must pad to an alignment boundary that is twice the address
3340          size.  It is undocumented by the DWARF standard but GCC does
3341          use it.  */
3342       for (size_t padding = ((-(addr - section->buffer))
3343                              & (2 * address_size - 1));
3344            padding > 0; padding--)
3345         if (*addr++ != 0)
3346           {
3347             warning (_("Section .debug_aranges in %s entry at offset %zu "
3348                        "padding is not zero, ignoring .debug_aranges."),
3349                      objfile_name (objfile), entry_addr - section->buffer);
3350             return;
3351           }
3352
3353       for (;;)
3354         {
3355           if (addr + 2 * address_size > entry_end)
3356             {
3357               warning (_("Section .debug_aranges in %s entry at offset %zu "
3358                          "address list is not properly terminated, "
3359                          "ignoring .debug_aranges."),
3360                        objfile_name (objfile), entry_addr - section->buffer);
3361               return;
3362             }
3363           ULONGEST start = extract_unsigned_integer (addr, address_size,
3364                                                      dwarf5_byte_order);
3365           addr += address_size;
3366           ULONGEST length = extract_unsigned_integer (addr, address_size,
3367                                                       dwarf5_byte_order);
3368           addr += address_size;
3369           if (start == 0 && length == 0)
3370             break;
3371           if (start == 0 && !dwarf2_per_objfile->has_section_at_zero)
3372             {
3373               /* Symbol was eliminated due to a COMDAT group.  */
3374               continue;
3375             }
3376           ULONGEST end = start + length;
3377           start = (gdbarch_adjust_dwarf2_addr (gdbarch, start + baseaddr)
3378                    - baseaddr);
3379           end = (gdbarch_adjust_dwarf2_addr (gdbarch, end + baseaddr)
3380                  - baseaddr);
3381           addrmap_set_empty (mutable_map, start, end - 1, per_cu);
3382         }
3383     }
3384
3385   objfile->partial_symtabs->psymtabs_addrmap
3386     = addrmap_create_fixed (mutable_map, objfile->partial_symtabs->obstack ());
3387 }
3388
3389 /* Find a slot in the mapped index INDEX for the object named NAME.
3390    If NAME is found, set *VEC_OUT to point to the CU vector in the
3391    constant pool and return true.  If NAME cannot be found, return
3392    false.  */
3393
3394 static bool
3395 find_slot_in_mapped_hash (struct mapped_index *index, const char *name,
3396                           offset_type **vec_out)
3397 {
3398   offset_type hash;
3399   offset_type slot, step;
3400   int (*cmp) (const char *, const char *);
3401
3402   gdb::unique_xmalloc_ptr<char> without_params;
3403   if (current_language->la_language == language_cplus
3404       || current_language->la_language == language_fortran
3405       || current_language->la_language == language_d)
3406     {
3407       /* NAME is already canonical.  Drop any qualifiers as .gdb_index does
3408          not contain any.  */
3409
3410       if (strchr (name, '(') != NULL)
3411         {
3412           without_params = cp_remove_params (name);
3413
3414           if (without_params != NULL)
3415             name = without_params.get ();
3416         }
3417     }
3418
3419   /* Index version 4 did not support case insensitive searches.  But the
3420      indices for case insensitive languages are built in lowercase, therefore
3421      simulate our NAME being searched is also lowercased.  */
3422   hash = mapped_index_string_hash ((index->version == 4
3423                                     && case_sensitivity == case_sensitive_off
3424                                     ? 5 : index->version),
3425                                    name);
3426
3427   slot = hash & (index->symbol_table.size () - 1);
3428   step = ((hash * 17) & (index->symbol_table.size () - 1)) | 1;
3429   cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
3430
3431   for (;;)
3432     {
3433       const char *str;
3434
3435       const auto &bucket = index->symbol_table[slot];
3436       if (bucket.name == 0 && bucket.vec == 0)
3437         return false;
3438
3439       str = index->constant_pool + MAYBE_SWAP (bucket.name);
3440       if (!cmp (name, str))
3441         {
3442           *vec_out = (offset_type *) (index->constant_pool
3443                                       + MAYBE_SWAP (bucket.vec));
3444           return true;
3445         }
3446
3447       slot = (slot + step) & (index->symbol_table.size () - 1);
3448     }
3449 }
3450
3451 /* A helper function that reads the .gdb_index from BUFFER and fills
3452    in MAP.  FILENAME is the name of the file containing the data;
3453    it is used for error reporting.  DEPRECATED_OK is true if it is
3454    ok to use deprecated sections.
3455
3456    CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
3457    out parameters that are filled in with information about the CU and
3458    TU lists in the section.
3459
3460    Returns true if all went well, false otherwise.  */
3461
3462 static bool
3463 read_gdb_index_from_buffer (struct objfile *objfile,
3464                             const char *filename,
3465                             bool deprecated_ok,
3466                             gdb::array_view<const gdb_byte> buffer,
3467                             struct mapped_index *map,
3468                             const gdb_byte **cu_list,
3469                             offset_type *cu_list_elements,
3470                             const gdb_byte **types_list,
3471                             offset_type *types_list_elements)
3472 {
3473   const gdb_byte *addr = &buffer[0];
3474
3475   /* Version check.  */
3476   offset_type version = MAYBE_SWAP (*(offset_type *) addr);
3477   /* Versions earlier than 3 emitted every copy of a psymbol.  This
3478      causes the index to behave very poorly for certain requests.  Version 3
3479      contained incomplete addrmap.  So, it seems better to just ignore such
3480      indices.  */
3481   if (version < 4)
3482     {
3483       static int warning_printed = 0;
3484       if (!warning_printed)
3485         {
3486           warning (_("Skipping obsolete .gdb_index section in %s."),
3487                    filename);
3488           warning_printed = 1;
3489         }
3490       return 0;
3491     }
3492   /* Index version 4 uses a different hash function than index version
3493      5 and later.
3494
3495      Versions earlier than 6 did not emit psymbols for inlined
3496      functions.  Using these files will cause GDB not to be able to
3497      set breakpoints on inlined functions by name, so we ignore these
3498      indices unless the user has done
3499      "set use-deprecated-index-sections on".  */
3500   if (version < 6 && !deprecated_ok)
3501     {
3502       static int warning_printed = 0;
3503       if (!warning_printed)
3504         {
3505           warning (_("\
3506 Skipping deprecated .gdb_index section in %s.\n\
3507 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3508 to use the section anyway."),
3509                    filename);
3510           warning_printed = 1;
3511         }
3512       return 0;
3513     }
3514   /* Version 7 indices generated by gold refer to the CU for a symbol instead
3515      of the TU (for symbols coming from TUs),
3516      http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3517      Plus gold-generated indices can have duplicate entries for global symbols,
3518      http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3519      These are just performance bugs, and we can't distinguish gdb-generated
3520      indices from gold-generated ones, so issue no warning here.  */
3521
3522   /* Indexes with higher version than the one supported by GDB may be no
3523      longer backward compatible.  */
3524   if (version > 8)
3525     return 0;
3526
3527   map->version = version;
3528
3529   offset_type *metadata = (offset_type *) (addr + sizeof (offset_type));
3530
3531   int i = 0;
3532   *cu_list = addr + MAYBE_SWAP (metadata[i]);
3533   *cu_list_elements = ((MAYBE_SWAP (metadata[i + 1]) - MAYBE_SWAP (metadata[i]))
3534                        / 8);
3535   ++i;
3536
3537   *types_list = addr + MAYBE_SWAP (metadata[i]);
3538   *types_list_elements = ((MAYBE_SWAP (metadata[i + 1])
3539                            - MAYBE_SWAP (metadata[i]))
3540                           / 8);
3541   ++i;
3542
3543   const gdb_byte *address_table = addr + MAYBE_SWAP (metadata[i]);
3544   const gdb_byte *address_table_end = addr + MAYBE_SWAP (metadata[i + 1]);
3545   map->address_table
3546     = gdb::array_view<const gdb_byte> (address_table, address_table_end);
3547   ++i;
3548
3549   const gdb_byte *symbol_table = addr + MAYBE_SWAP (metadata[i]);
3550   const gdb_byte *symbol_table_end = addr + MAYBE_SWAP (metadata[i + 1]);
3551   map->symbol_table
3552     = gdb::array_view<mapped_index::symbol_table_slot>
3553        ((mapped_index::symbol_table_slot *) symbol_table,
3554         (mapped_index::symbol_table_slot *) symbol_table_end);
3555
3556   ++i;
3557   map->constant_pool = (char *) (addr + MAYBE_SWAP (metadata[i]));
3558
3559   return 1;
3560 }
3561
3562 /* Callback types for dwarf2_read_gdb_index.  */
3563
3564 typedef gdb::function_view
3565     <gdb::array_view<const gdb_byte>(objfile *, dwarf2_per_objfile *)>
3566     get_gdb_index_contents_ftype;
3567 typedef gdb::function_view
3568     <gdb::array_view<const gdb_byte>(objfile *, dwz_file *)>
3569     get_gdb_index_contents_dwz_ftype;
3570
3571 /* Read .gdb_index.  If everything went ok, initialize the "quick"
3572    elements of all the CUs and return 1.  Otherwise, return 0.  */
3573
3574 static int
3575 dwarf2_read_gdb_index
3576   (struct dwarf2_per_objfile *dwarf2_per_objfile,
3577    get_gdb_index_contents_ftype get_gdb_index_contents,
3578    get_gdb_index_contents_dwz_ftype get_gdb_index_contents_dwz)
3579 {
3580   const gdb_byte *cu_list, *types_list, *dwz_list = NULL;
3581   offset_type cu_list_elements, types_list_elements, dwz_list_elements = 0;
3582   struct dwz_file *dwz;
3583   struct objfile *objfile = dwarf2_per_objfile->objfile;
3584
3585   gdb::array_view<const gdb_byte> main_index_contents
3586     = get_gdb_index_contents (objfile, dwarf2_per_objfile);
3587
3588   if (main_index_contents.empty ())
3589     return 0;
3590
3591   std::unique_ptr<struct mapped_index> map (new struct mapped_index);
3592   if (!read_gdb_index_from_buffer (objfile, objfile_name (objfile),
3593                                    use_deprecated_index_sections,
3594                                    main_index_contents, map.get (), &cu_list,
3595                                    &cu_list_elements, &types_list,
3596                                    &types_list_elements))
3597     return 0;
3598
3599   /* Don't use the index if it's empty.  */
3600   if (map->symbol_table.empty ())
3601     return 0;
3602
3603   /* If there is a .dwz file, read it so we can get its CU list as
3604      well.  */
3605   dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
3606   if (dwz != NULL)
3607     {
3608       struct mapped_index dwz_map;
3609       const gdb_byte *dwz_types_ignore;
3610       offset_type dwz_types_elements_ignore;
3611
3612       gdb::array_view<const gdb_byte> dwz_index_content
3613         = get_gdb_index_contents_dwz (objfile, dwz);
3614
3615       if (dwz_index_content.empty ())
3616         return 0;
3617
3618       if (!read_gdb_index_from_buffer (objfile,
3619                                        bfd_get_filename (dwz->dwz_bfd), 1,
3620                                        dwz_index_content, &dwz_map,
3621                                        &dwz_list, &dwz_list_elements,
3622                                        &dwz_types_ignore,
3623                                        &dwz_types_elements_ignore))
3624         {
3625           warning (_("could not read '.gdb_index' section from %s; skipping"),
3626                    bfd_get_filename (dwz->dwz_bfd));
3627           return 0;
3628         }
3629     }
3630
3631   create_cus_from_index (dwarf2_per_objfile, cu_list, cu_list_elements,
3632                          dwz_list, dwz_list_elements);
3633
3634   if (types_list_elements)
3635     {
3636       struct dwarf2_section_info *section;
3637
3638       /* We can only handle a single .debug_types when we have an
3639          index.  */
3640       if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) != 1)
3641         return 0;
3642
3643       section = VEC_index (dwarf2_section_info_def,
3644                            dwarf2_per_objfile->types, 0);
3645
3646       create_signatured_type_table_from_index (dwarf2_per_objfile, section,
3647                                                types_list, types_list_elements);
3648     }
3649
3650   create_addrmap_from_index (dwarf2_per_objfile, map.get ());
3651
3652   dwarf2_per_objfile->index_table = std::move (map);
3653   dwarf2_per_objfile->using_index = 1;
3654   dwarf2_per_objfile->quick_file_names_table =
3655     create_quick_file_names_table (dwarf2_per_objfile->all_comp_units.size ());
3656
3657   return 1;
3658 }
3659
3660 /* die_reader_func for dw2_get_file_names.  */
3661
3662 static void
3663 dw2_get_file_names_reader (const struct die_reader_specs *reader,
3664                            const gdb_byte *info_ptr,
3665                            struct die_info *comp_unit_die,
3666                            int has_children,
3667                            void *data)
3668 {
3669   struct dwarf2_cu *cu = reader->cu;
3670   struct dwarf2_per_cu_data *this_cu = cu->per_cu;
3671   struct dwarf2_per_objfile *dwarf2_per_objfile
3672     = cu->per_cu->dwarf2_per_objfile;
3673   struct objfile *objfile = dwarf2_per_objfile->objfile;
3674   struct dwarf2_per_cu_data *lh_cu;
3675   struct attribute *attr;
3676   int i;
3677   void **slot;
3678   struct quick_file_names *qfn;
3679
3680   gdb_assert (! this_cu->is_debug_types);
3681
3682   /* Our callers never want to match partial units -- instead they
3683      will match the enclosing full CU.  */
3684   if (comp_unit_die->tag == DW_TAG_partial_unit)
3685     {
3686       this_cu->v.quick->no_file_data = 1;
3687       return;
3688     }
3689
3690   lh_cu = this_cu;
3691   slot = NULL;
3692
3693   line_header_up lh;
3694   sect_offset line_offset {};
3695
3696   attr = dwarf2_attr (comp_unit_die, DW_AT_stmt_list, cu);
3697   if (attr)
3698     {
3699       struct quick_file_names find_entry;
3700
3701       line_offset = (sect_offset) DW_UNSND (attr);
3702
3703       /* We may have already read in this line header (TU line header sharing).
3704          If we have we're done.  */
3705       find_entry.hash.dwo_unit = cu->dwo_unit;
3706       find_entry.hash.line_sect_off = line_offset;
3707       slot = htab_find_slot (dwarf2_per_objfile->quick_file_names_table,
3708                              &find_entry, INSERT);
3709       if (*slot != NULL)
3710         {
3711           lh_cu->v.quick->file_names = (struct quick_file_names *) *slot;
3712           return;
3713         }
3714
3715       lh = dwarf_decode_line_header (line_offset, cu);
3716     }
3717   if (lh == NULL)
3718     {
3719       lh_cu->v.quick->no_file_data = 1;
3720       return;
3721     }
3722
3723   qfn = XOBNEW (&objfile->objfile_obstack, struct quick_file_names);
3724   qfn->hash.dwo_unit = cu->dwo_unit;
3725   qfn->hash.line_sect_off = line_offset;
3726   gdb_assert (slot != NULL);
3727   *slot = qfn;
3728
3729   file_and_directory fnd = find_file_and_directory (comp_unit_die, cu);
3730
3731   qfn->num_file_names = lh->file_names.size ();
3732   qfn->file_names =
3733     XOBNEWVEC (&objfile->objfile_obstack, const char *, lh->file_names.size ());
3734   for (i = 0; i < lh->file_names.size (); ++i)
3735     qfn->file_names[i] = file_full_name (i + 1, lh.get (), fnd.comp_dir);
3736   qfn->real_names = NULL;
3737
3738   lh_cu->v.quick->file_names = qfn;
3739 }
3740
3741 /* A helper for the "quick" functions which attempts to read the line
3742    table for THIS_CU.  */
3743
3744 static struct quick_file_names *
3745 dw2_get_file_names (struct dwarf2_per_cu_data *this_cu)
3746 {
3747   /* This should never be called for TUs.  */
3748   gdb_assert (! this_cu->is_debug_types);
3749   /* Nor type unit groups.  */
3750   gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu));
3751
3752   if (this_cu->v.quick->file_names != NULL)
3753     return this_cu->v.quick->file_names;
3754   /* If we know there is no line data, no point in looking again.  */
3755   if (this_cu->v.quick->no_file_data)
3756     return NULL;
3757
3758   init_cutu_and_read_dies_simple (this_cu, dw2_get_file_names_reader, NULL);
3759
3760   if (this_cu->v.quick->no_file_data)
3761     return NULL;
3762   return this_cu->v.quick->file_names;
3763 }
3764
3765 /* A helper for the "quick" functions which computes and caches the
3766    real path for a given file name from the line table.  */
3767
3768 static const char *
3769 dw2_get_real_path (struct objfile *objfile,
3770                    struct quick_file_names *qfn, int index)
3771 {
3772   if (qfn->real_names == NULL)
3773     qfn->real_names = OBSTACK_CALLOC (&objfile->objfile_obstack,
3774                                       qfn->num_file_names, const char *);
3775
3776   if (qfn->real_names[index] == NULL)
3777     qfn->real_names[index] = gdb_realpath (qfn->file_names[index]).release ();
3778
3779   return qfn->real_names[index];
3780 }
3781
3782 static struct symtab *
3783 dw2_find_last_source_symtab (struct objfile *objfile)
3784 {
3785   struct dwarf2_per_objfile *dwarf2_per_objfile
3786     = get_dwarf2_per_objfile (objfile);
3787   dwarf2_per_cu_data *dwarf_cu = dwarf2_per_objfile->all_comp_units.back ();
3788   compunit_symtab *cust = dw2_instantiate_symtab (dwarf_cu, false);
3789
3790   if (cust == NULL)
3791     return NULL;
3792
3793   return compunit_primary_filetab (cust);
3794 }
3795
3796 /* Traversal function for dw2_forget_cached_source_info.  */
3797
3798 static int
3799 dw2_free_cached_file_names (void **slot, void *info)
3800 {
3801   struct quick_file_names *file_data = (struct quick_file_names *) *slot;
3802
3803   if (file_data->real_names)
3804     {
3805       int i;
3806
3807       for (i = 0; i < file_data->num_file_names; ++i)
3808         {
3809           xfree ((void*) file_data->real_names[i]);
3810           file_data->real_names[i] = NULL;
3811         }
3812     }
3813
3814   return 1;
3815 }
3816
3817 static void
3818 dw2_forget_cached_source_info (struct objfile *objfile)
3819 {
3820   struct dwarf2_per_objfile *dwarf2_per_objfile
3821     = get_dwarf2_per_objfile (objfile);
3822
3823   htab_traverse_noresize (dwarf2_per_objfile->quick_file_names_table,
3824                           dw2_free_cached_file_names, NULL);
3825 }
3826
3827 /* Helper function for dw2_map_symtabs_matching_filename that expands
3828    the symtabs and calls the iterator.  */
3829
3830 static int
3831 dw2_map_expand_apply (struct objfile *objfile,
3832                       struct dwarf2_per_cu_data *per_cu,
3833                       const char *name, const char *real_path,
3834                       gdb::function_view<bool (symtab *)> callback)
3835 {
3836   struct compunit_symtab *last_made = objfile->compunit_symtabs;
3837
3838   /* Don't visit already-expanded CUs.  */
3839   if (per_cu->v.quick->compunit_symtab)
3840     return 0;
3841
3842   /* This may expand more than one symtab, and we want to iterate over
3843      all of them.  */
3844   dw2_instantiate_symtab (per_cu, false);
3845
3846   return iterate_over_some_symtabs (name, real_path, objfile->compunit_symtabs,
3847                                     last_made, callback);
3848 }
3849
3850 /* Implementation of the map_symtabs_matching_filename method.  */
3851
3852 static bool
3853 dw2_map_symtabs_matching_filename
3854   (struct objfile *objfile, const char *name, const char *real_path,
3855    gdb::function_view<bool (symtab *)> callback)
3856 {
3857   const char *name_basename = lbasename (name);
3858   struct dwarf2_per_objfile *dwarf2_per_objfile
3859     = get_dwarf2_per_objfile (objfile);
3860
3861   /* The rule is CUs specify all the files, including those used by
3862      any TU, so there's no need to scan TUs here.  */
3863
3864   for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
3865     {
3866       /* We only need to look at symtabs not already expanded.  */
3867       if (per_cu->v.quick->compunit_symtab)
3868         continue;
3869
3870       quick_file_names *file_data = dw2_get_file_names (per_cu);
3871       if (file_data == NULL)
3872         continue;
3873
3874       for (int j = 0; j < file_data->num_file_names; ++j)
3875         {
3876           const char *this_name = file_data->file_names[j];
3877           const char *this_real_name;
3878
3879           if (compare_filenames_for_search (this_name, name))
3880             {
3881               if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3882                                         callback))
3883                 return true;
3884               continue;
3885             }
3886
3887           /* Before we invoke realpath, which can get expensive when many
3888              files are involved, do a quick comparison of the basenames.  */
3889           if (! basenames_may_differ
3890               && FILENAME_CMP (lbasename (this_name), name_basename) != 0)
3891             continue;
3892
3893           this_real_name = dw2_get_real_path (objfile, file_data, j);
3894           if (compare_filenames_for_search (this_real_name, name))
3895             {
3896               if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3897                                         callback))
3898                 return true;
3899               continue;
3900             }
3901
3902           if (real_path != NULL)
3903             {
3904               gdb_assert (IS_ABSOLUTE_PATH (real_path));
3905               gdb_assert (IS_ABSOLUTE_PATH (name));
3906               if (this_real_name != NULL
3907                   && FILENAME_CMP (real_path, this_real_name) == 0)
3908                 {
3909                   if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3910                                             callback))
3911                     return true;
3912                   continue;
3913                 }
3914             }
3915         }
3916     }
3917
3918   return false;
3919 }
3920
3921 /* Struct used to manage iterating over all CUs looking for a symbol.  */
3922
3923 struct dw2_symtab_iterator
3924 {
3925   /* The dwarf2_per_objfile owning the CUs we are iterating on.  */
3926   struct dwarf2_per_objfile *dwarf2_per_objfile;
3927   /* If non-zero, only look for symbols that match BLOCK_INDEX.  */
3928   int want_specific_block;
3929   /* One of GLOBAL_BLOCK or STATIC_BLOCK.
3930      Unused if !WANT_SPECIFIC_BLOCK.  */
3931   int block_index;
3932   /* The kind of symbol we're looking for.  */
3933   domain_enum domain;
3934   /* The list of CUs from the index entry of the symbol,
3935      or NULL if not found.  */
3936   offset_type *vec;
3937   /* The next element in VEC to look at.  */
3938   int next;
3939   /* The number of elements in VEC, or zero if there is no match.  */
3940   int length;
3941   /* Have we seen a global version of the symbol?
3942      If so we can ignore all further global instances.
3943      This is to work around gold/15646, inefficient gold-generated
3944      indices.  */
3945   int global_seen;
3946 };
3947
3948 /* Initialize the index symtab iterator ITER.
3949    If WANT_SPECIFIC_BLOCK is non-zero, only look for symbols
3950    in block BLOCK_INDEX.  Otherwise BLOCK_INDEX is ignored.  */
3951
3952 static void
3953 dw2_symtab_iter_init (struct dw2_symtab_iterator *iter,
3954                       struct dwarf2_per_objfile *dwarf2_per_objfile,
3955                       int want_specific_block,
3956                       int block_index,
3957                       domain_enum domain,
3958                       const char *name)
3959 {
3960   iter->dwarf2_per_objfile = dwarf2_per_objfile;
3961   iter->want_specific_block = want_specific_block;
3962   iter->block_index = block_index;
3963   iter->domain = domain;
3964   iter->next = 0;
3965   iter->global_seen = 0;
3966
3967   mapped_index *index = dwarf2_per_objfile->index_table.get ();
3968
3969   /* index is NULL if OBJF_READNOW.  */
3970   if (index != NULL && find_slot_in_mapped_hash (index, name, &iter->vec))
3971     iter->length = MAYBE_SWAP (*iter->vec);
3972   else
3973     {
3974       iter->vec = NULL;
3975       iter->length = 0;
3976     }
3977 }
3978
3979 /* Return the next matching CU or NULL if there are no more.  */
3980
3981 static struct dwarf2_per_cu_data *
3982 dw2_symtab_iter_next (struct dw2_symtab_iterator *iter)
3983 {
3984   struct dwarf2_per_objfile *dwarf2_per_objfile = iter->dwarf2_per_objfile;
3985
3986   for ( ; iter->next < iter->length; ++iter->next)
3987     {
3988       offset_type cu_index_and_attrs =
3989         MAYBE_SWAP (iter->vec[iter->next + 1]);
3990       offset_type cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
3991       int want_static = iter->block_index != GLOBAL_BLOCK;
3992       /* This value is only valid for index versions >= 7.  */
3993       int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
3994       gdb_index_symbol_kind symbol_kind =
3995         GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
3996       /* Only check the symbol attributes if they're present.
3997          Indices prior to version 7 don't record them,
3998          and indices >= 7 may elide them for certain symbols
3999          (gold does this).  */
4000       int attrs_valid =
4001         (dwarf2_per_objfile->index_table->version >= 7
4002          && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
4003
4004       /* Don't crash on bad data.  */
4005       if (cu_index >= (dwarf2_per_objfile->all_comp_units.size ()
4006                        + dwarf2_per_objfile->all_type_units.size ()))
4007         {
4008           complaint (_(".gdb_index entry has bad CU index"
4009                        " [in module %s]"),
4010                      objfile_name (dwarf2_per_objfile->objfile));
4011           continue;
4012         }
4013
4014       dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (cu_index);
4015
4016       /* Skip if already read in.  */
4017       if (per_cu->v.quick->compunit_symtab)
4018         continue;
4019
4020       /* Check static vs global.  */
4021       if (attrs_valid)
4022         {
4023           if (iter->want_specific_block
4024               && want_static != is_static)
4025             continue;
4026           /* Work around gold/15646.  */
4027           if (!is_static && iter->global_seen)
4028             continue;
4029           if (!is_static)
4030             iter->global_seen = 1;
4031         }
4032
4033       /* Only check the symbol's kind if it has one.  */
4034       if (attrs_valid)
4035         {
4036           switch (iter->domain)
4037             {
4038             case VAR_DOMAIN:
4039               if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE
4040                   && symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION
4041                   /* Some types are also in VAR_DOMAIN.  */
4042                   && symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
4043                 continue;
4044               break;
4045             case STRUCT_DOMAIN:
4046               if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
4047                 continue;
4048               break;
4049             case LABEL_DOMAIN:
4050               if (symbol_kind != GDB_INDEX_SYMBOL_KIND_OTHER)
4051                 continue;
4052               break;
4053             default:
4054               break;
4055             }
4056         }
4057
4058       ++iter->next;
4059       return per_cu;
4060     }
4061
4062   return NULL;
4063 }
4064
4065 static struct compunit_symtab *
4066 dw2_lookup_symbol (struct objfile *objfile, int block_index,
4067                    const char *name, domain_enum domain)
4068 {
4069   struct compunit_symtab *stab_best = NULL;
4070   struct dwarf2_per_objfile *dwarf2_per_objfile
4071     = get_dwarf2_per_objfile (objfile);
4072
4073   lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
4074
4075   struct dw2_symtab_iterator iter;
4076   struct dwarf2_per_cu_data *per_cu;
4077
4078   dw2_symtab_iter_init (&iter, dwarf2_per_objfile, 1, block_index, domain, name);
4079
4080   while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
4081     {
4082       struct symbol *sym, *with_opaque = NULL;
4083       struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu, false);
4084       const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
4085       const struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
4086
4087       sym = block_find_symbol (block, name, domain,
4088                                block_find_non_opaque_type_preferred,
4089                                &with_opaque);
4090
4091       /* Some caution must be observed with overloaded functions
4092          and methods, since the index will not contain any overload
4093          information (but NAME might contain it).  */
4094
4095       if (sym != NULL
4096           && SYMBOL_MATCHES_SEARCH_NAME (sym, lookup_name))
4097         return stab;
4098       if (with_opaque != NULL
4099           && SYMBOL_MATCHES_SEARCH_NAME (with_opaque, lookup_name))
4100         stab_best = stab;
4101
4102       /* Keep looking through other CUs.  */
4103     }
4104
4105   return stab_best;
4106 }
4107
4108 static void
4109 dw2_print_stats (struct objfile *objfile)
4110 {
4111   struct dwarf2_per_objfile *dwarf2_per_objfile
4112     = get_dwarf2_per_objfile (objfile);
4113   int total = (dwarf2_per_objfile->all_comp_units.size ()
4114                + dwarf2_per_objfile->all_type_units.size ());
4115   int count = 0;
4116
4117   for (int i = 0; i < total; ++i)
4118     {
4119       dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
4120
4121       if (!per_cu->v.quick->compunit_symtab)
4122         ++count;
4123     }
4124   printf_filtered (_("  Number of read CUs: %d\n"), total - count);
4125   printf_filtered (_("  Number of unread CUs: %d\n"), count);
4126 }
4127
4128 /* This dumps minimal information about the index.
4129    It is called via "mt print objfiles".
4130    One use is to verify .gdb_index has been loaded by the
4131    gdb.dwarf2/gdb-index.exp testcase.  */
4132
4133 static void
4134 dw2_dump (struct objfile *objfile)
4135 {
4136   struct dwarf2_per_objfile *dwarf2_per_objfile
4137     = get_dwarf2_per_objfile (objfile);
4138
4139   gdb_assert (dwarf2_per_objfile->using_index);
4140   printf_filtered (".gdb_index:");
4141   if (dwarf2_per_objfile->index_table != NULL)
4142     {
4143       printf_filtered (" version %d\n",
4144                        dwarf2_per_objfile->index_table->version);
4145     }
4146   else
4147     printf_filtered (" faked for \"readnow\"\n");
4148   printf_filtered ("\n");
4149 }
4150
4151 static void
4152 dw2_expand_symtabs_for_function (struct objfile *objfile,
4153                                  const char *func_name)
4154 {
4155   struct dwarf2_per_objfile *dwarf2_per_objfile
4156     = get_dwarf2_per_objfile (objfile);
4157
4158   struct dw2_symtab_iterator iter;
4159   struct dwarf2_per_cu_data *per_cu;
4160
4161   /* Note: It doesn't matter what we pass for block_index here.  */
4162   dw2_symtab_iter_init (&iter, dwarf2_per_objfile, 0, GLOBAL_BLOCK, VAR_DOMAIN,
4163                         func_name);
4164
4165   while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
4166     dw2_instantiate_symtab (per_cu, false);
4167
4168 }
4169
4170 static void
4171 dw2_expand_all_symtabs (struct objfile *objfile)
4172 {
4173   struct dwarf2_per_objfile *dwarf2_per_objfile
4174     = get_dwarf2_per_objfile (objfile);
4175   int total_units = (dwarf2_per_objfile->all_comp_units.size ()
4176                      + dwarf2_per_objfile->all_type_units.size ());
4177
4178   for (int i = 0; i < total_units; ++i)
4179     {
4180       dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
4181
4182       /* We don't want to directly expand a partial CU, because if we
4183          read it with the wrong language, then assertion failures can
4184          be triggered later on.  See PR symtab/23010.  So, tell
4185          dw2_instantiate_symtab to skip partial CUs -- any important
4186          partial CU will be read via DW_TAG_imported_unit anyway.  */
4187       dw2_instantiate_symtab (per_cu, true);
4188     }
4189 }
4190
4191 static void
4192 dw2_expand_symtabs_with_fullname (struct objfile *objfile,
4193                                   const char *fullname)
4194 {
4195   struct dwarf2_per_objfile *dwarf2_per_objfile
4196     = get_dwarf2_per_objfile (objfile);
4197
4198   /* We don't need to consider type units here.
4199      This is only called for examining code, e.g. expand_line_sal.
4200      There can be an order of magnitude (or more) more type units
4201      than comp units, and we avoid them if we can.  */
4202
4203   for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
4204     {
4205       /* We only need to look at symtabs not already expanded.  */
4206       if (per_cu->v.quick->compunit_symtab)
4207         continue;
4208
4209       quick_file_names *file_data = dw2_get_file_names (per_cu);
4210       if (file_data == NULL)
4211         continue;
4212
4213       for (int j = 0; j < file_data->num_file_names; ++j)
4214         {
4215           const char *this_fullname = file_data->file_names[j];
4216
4217           if (filename_cmp (this_fullname, fullname) == 0)
4218             {
4219               dw2_instantiate_symtab (per_cu, false);
4220               break;
4221             }
4222         }
4223     }
4224 }
4225
4226 static void
4227 dw2_map_matching_symbols (struct objfile *objfile,
4228                           const char * name, domain_enum domain,
4229                           int global,
4230                           int (*callback) (const struct block *,
4231                                            struct symbol *, void *),
4232                           void *data, symbol_name_match_type match,
4233                           symbol_compare_ftype *ordered_compare)
4234 {
4235   /* Currently unimplemented; used for Ada.  The function can be called if the
4236      current language is Ada for a non-Ada objfile using GNU index.  As Ada
4237      does not look for non-Ada symbols this function should just return.  */
4238 }
4239
4240 /* Symbol name matcher for .gdb_index names.
4241
4242    Symbol names in .gdb_index have a few particularities:
4243
4244    - There's no indication of which is the language of each symbol.
4245
4246      Since each language has its own symbol name matching algorithm,
4247      and we don't know which language is the right one, we must match
4248      each symbol against all languages.  This would be a potential
4249      performance problem if it were not mitigated by the
4250      mapped_index::name_components lookup table, which significantly
4251      reduces the number of times we need to call into this matcher,
4252      making it a non-issue.
4253
4254    - Symbol names in the index have no overload (parameter)
4255      information.  I.e., in C++, "foo(int)" and "foo(long)" both
4256      appear as "foo" in the index, for example.
4257
4258      This means that the lookup names passed to the symbol name
4259      matcher functions must have no parameter information either
4260      because (e.g.) symbol search name "foo" does not match
4261      lookup-name "foo(int)" [while swapping search name for lookup
4262      name would match].
4263 */
4264 class gdb_index_symbol_name_matcher
4265 {
4266 public:
4267   /* Prepares the vector of comparison functions for LOOKUP_NAME.  */
4268   gdb_index_symbol_name_matcher (const lookup_name_info &lookup_name);
4269
4270   /* Walk all the matcher routines and match SYMBOL_NAME against them.
4271      Returns true if any matcher matches.  */
4272   bool matches (const char *symbol_name);
4273
4274 private:
4275   /* A reference to the lookup name we're matching against.  */
4276   const lookup_name_info &m_lookup_name;
4277
4278   /* A vector holding all the different symbol name matchers, for all
4279      languages.  */
4280   std::vector<symbol_name_matcher_ftype *> m_symbol_name_matcher_funcs;
4281 };
4282
4283 gdb_index_symbol_name_matcher::gdb_index_symbol_name_matcher
4284   (const lookup_name_info &lookup_name)
4285     : m_lookup_name (lookup_name)
4286 {
4287   /* Prepare the vector of comparison functions upfront, to avoid
4288      doing the same work for each symbol.  Care is taken to avoid
4289      matching with the same matcher more than once if/when multiple
4290      languages use the same matcher function.  */
4291   auto &matchers = m_symbol_name_matcher_funcs;
4292   matchers.reserve (nr_languages);
4293
4294   matchers.push_back (default_symbol_name_matcher);
4295
4296   for (int i = 0; i < nr_languages; i++)
4297     {
4298       const language_defn *lang = language_def ((enum language) i);
4299       symbol_name_matcher_ftype *name_matcher
4300         = get_symbol_name_matcher (lang, m_lookup_name);
4301
4302       /* Don't insert the same comparison routine more than once.
4303          Note that we do this linear walk instead of a seemingly
4304          cheaper sorted insert, or use a std::set or something like
4305          that, because relative order of function addresses is not
4306          stable.  This is not a problem in practice because the number
4307          of supported languages is low, and the cost here is tiny
4308          compared to the number of searches we'll do afterwards using
4309          this object.  */
4310       if (name_matcher != default_symbol_name_matcher
4311           && (std::find (matchers.begin (), matchers.end (), name_matcher)
4312               == matchers.end ()))
4313         matchers.push_back (name_matcher);
4314     }
4315 }
4316
4317 bool
4318 gdb_index_symbol_name_matcher::matches (const char *symbol_name)
4319 {
4320   for (auto matches_name : m_symbol_name_matcher_funcs)
4321     if (matches_name (symbol_name, m_lookup_name, NULL))
4322       return true;
4323
4324   return false;
4325 }
4326
4327 /* Starting from a search name, return the string that finds the upper
4328    bound of all strings that start with SEARCH_NAME in a sorted name
4329    list.  Returns the empty string to indicate that the upper bound is
4330    the end of the list.  */
4331
4332 static std::string
4333 make_sort_after_prefix_name (const char *search_name)
4334 {
4335   /* When looking to complete "func", we find the upper bound of all
4336      symbols that start with "func" by looking for where we'd insert
4337      the closest string that would follow "func" in lexicographical
4338      order.  Usually, that's "func"-with-last-character-incremented,
4339      i.e. "fund".  Mind non-ASCII characters, though.  Usually those
4340      will be UTF-8 multi-byte sequences, but we can't be certain.
4341      Especially mind the 0xff character, which is a valid character in
4342      non-UTF-8 source character sets (e.g. Latin1 'ÿ'), and we can't
4343      rule out compilers allowing it in identifiers.  Note that
4344      conveniently, strcmp/strcasecmp are specified to compare
4345      characters interpreted as unsigned char.  So what we do is treat
4346      the whole string as a base 256 number composed of a sequence of
4347      base 256 "digits" and add 1 to it.  I.e., adding 1 to 0xff wraps
4348      to 0, and carries 1 to the following more-significant position.
4349      If the very first character in SEARCH_NAME ends up incremented
4350      and carries/overflows, then the upper bound is the end of the
4351      list.  The string after the empty string is also the empty
4352      string.
4353
4354      Some examples of this operation:
4355
4356        SEARCH_NAME  => "+1" RESULT
4357
4358        "abc"              => "abd"
4359        "ab\xff"           => "ac"
4360        "\xff" "a" "\xff"  => "\xff" "b"
4361        "\xff"             => ""
4362        "\xff\xff"         => ""
4363        ""                 => ""
4364
4365      Then, with these symbols for example:
4366
4367       func
4368       func1
4369       fund
4370
4371      completing "func" looks for symbols between "func" and
4372      "func"-with-last-character-incremented, i.e. "fund" (exclusive),
4373      which finds "func" and "func1", but not "fund".
4374
4375      And with:
4376
4377       funcÿ     (Latin1 'ÿ' [0xff])
4378       funcÿ1
4379       fund
4380
4381      completing "funcÿ" looks for symbols between "funcÿ" and "fund"
4382      (exclusive), which finds "funcÿ" and "funcÿ1", but not "fund".
4383
4384      And with:
4385
4386       ÿÿ        (Latin1 'ÿ' [0xff])
4387       ÿÿ1
4388
4389      completing "ÿ" or "ÿÿ" looks for symbols between between "ÿÿ" and
4390      the end of the list.
4391   */
4392   std::string after = search_name;
4393   while (!after.empty () && (unsigned char) after.back () == 0xff)
4394     after.pop_back ();
4395   if (!after.empty ())
4396     after.back () = (unsigned char) after.back () + 1;
4397   return after;
4398 }
4399
4400 /* See declaration.  */
4401
4402 std::pair<std::vector<name_component>::const_iterator,
4403           std::vector<name_component>::const_iterator>
4404 mapped_index_base::find_name_components_bounds
4405   (const lookup_name_info &lookup_name_without_params) const
4406 {
4407   auto *name_cmp
4408     = this->name_components_casing == case_sensitive_on ? strcmp : strcasecmp;
4409
4410   const char *cplus
4411     = lookup_name_without_params.cplus ().lookup_name ().c_str ();
4412
4413   /* Comparison function object for lower_bound that matches against a
4414      given symbol name.  */
4415   auto lookup_compare_lower = [&] (const name_component &elem,
4416                                    const char *name)
4417     {
4418       const char *elem_qualified = this->symbol_name_at (elem.idx);
4419       const char *elem_name = elem_qualified + elem.name_offset;
4420       return name_cmp (elem_name, name) < 0;
4421     };
4422
4423   /* Comparison function object for upper_bound that matches against a
4424      given symbol name.  */
4425   auto lookup_compare_upper = [&] (const char *name,
4426                                    const name_component &elem)
4427     {
4428       const char *elem_qualified = this->symbol_name_at (elem.idx);
4429       const char *elem_name = elem_qualified + elem.name_offset;
4430       return name_cmp (name, elem_name) < 0;
4431     };
4432
4433   auto begin = this->name_components.begin ();
4434   auto end = this->name_components.end ();
4435
4436   /* Find the lower bound.  */
4437   auto lower = [&] ()
4438     {
4439       if (lookup_name_without_params.completion_mode () && cplus[0] == '\0')
4440         return begin;
4441       else
4442         return std::lower_bound (begin, end, cplus, lookup_compare_lower);
4443     } ();
4444
4445   /* Find the upper bound.  */
4446   auto upper = [&] ()
4447     {
4448       if (lookup_name_without_params.completion_mode ())
4449         {
4450           /* In completion mode, we want UPPER to point past all
4451              symbols names that have the same prefix.  I.e., with
4452              these symbols, and completing "func":
4453
4454               function        << lower bound
4455               function1
4456               other_function  << upper bound
4457
4458              We find the upper bound by looking for the insertion
4459              point of "func"-with-last-character-incremented,
4460              i.e. "fund".  */
4461           std::string after = make_sort_after_prefix_name (cplus);
4462           if (after.empty ())
4463             return end;
4464           return std::lower_bound (lower, end, after.c_str (),
4465                                    lookup_compare_lower);
4466         }
4467       else
4468         return std::upper_bound (lower, end, cplus, lookup_compare_upper);
4469     } ();
4470
4471   return {lower, upper};
4472 }
4473
4474 /* See declaration.  */
4475
4476 void
4477 mapped_index_base::build_name_components ()
4478 {
4479   if (!this->name_components.empty ())
4480     return;
4481
4482   this->name_components_casing = case_sensitivity;
4483   auto *name_cmp
4484     = this->name_components_casing == case_sensitive_on ? strcmp : strcasecmp;
4485
4486   /* The code below only knows how to break apart components of C++
4487      symbol names (and other languages that use '::' as
4488      namespace/module separator).  If we add support for wild matching
4489      to some language that uses some other operator (E.g., Ada, Go and
4490      D use '.'), then we'll need to try splitting the symbol name
4491      according to that language too.  Note that Ada does support wild
4492      matching, but doesn't currently support .gdb_index.  */
4493   auto count = this->symbol_name_count ();
4494   for (offset_type idx = 0; idx < count; idx++)
4495     {
4496       if (this->symbol_name_slot_invalid (idx))
4497         continue;
4498
4499       const char *name = this->symbol_name_at (idx);
4500
4501       /* Add each name component to the name component table.  */
4502       unsigned int previous_len = 0;
4503       for (unsigned int current_len = cp_find_first_component (name);
4504            name[current_len] != '\0';
4505            current_len += cp_find_first_component (name + current_len))
4506         {
4507           gdb_assert (name[current_len] == ':');
4508           this->name_components.push_back ({previous_len, idx});
4509           /* Skip the '::'.  */
4510           current_len += 2;
4511           previous_len = current_len;
4512         }
4513       this->name_components.push_back ({previous_len, idx});
4514     }
4515
4516   /* Sort name_components elements by name.  */
4517   auto name_comp_compare = [&] (const name_component &left,
4518                                 const name_component &right)
4519     {
4520       const char *left_qualified = this->symbol_name_at (left.idx);
4521       const char *right_qualified = this->symbol_name_at (right.idx);
4522
4523       const char *left_name = left_qualified + left.name_offset;
4524       const char *right_name = right_qualified + right.name_offset;
4525
4526       return name_cmp (left_name, right_name) < 0;
4527     };
4528
4529   std::sort (this->name_components.begin (),
4530              this->name_components.end (),
4531              name_comp_compare);
4532 }
4533
4534 /* Helper for dw2_expand_symtabs_matching that works with a
4535    mapped_index_base instead of the containing objfile.  This is split
4536    to a separate function in order to be able to unit test the
4537    name_components matching using a mock mapped_index_base.  For each
4538    symbol name that matches, calls MATCH_CALLBACK, passing it the
4539    symbol's index in the mapped_index_base symbol table.  */
4540
4541 static void
4542 dw2_expand_symtabs_matching_symbol
4543   (mapped_index_base &index,
4544    const lookup_name_info &lookup_name_in,
4545    gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
4546    enum search_domain kind,
4547    gdb::function_view<void (offset_type)> match_callback)
4548 {
4549   lookup_name_info lookup_name_without_params
4550     = lookup_name_in.make_ignore_params ();
4551   gdb_index_symbol_name_matcher lookup_name_matcher
4552     (lookup_name_without_params);
4553
4554   /* Build the symbol name component sorted vector, if we haven't
4555      yet.  */
4556   index.build_name_components ();
4557
4558   auto bounds = index.find_name_components_bounds (lookup_name_without_params);
4559
4560   /* Now for each symbol name in range, check to see if we have a name
4561      match, and if so, call the MATCH_CALLBACK callback.  */
4562
4563   /* The same symbol may appear more than once in the range though.
4564      E.g., if we're looking for symbols that complete "w", and we have
4565      a symbol named "w1::w2", we'll find the two name components for
4566      that same symbol in the range.  To be sure we only call the
4567      callback once per symbol, we first collect the symbol name
4568      indexes that matched in a temporary vector and ignore
4569      duplicates.  */
4570   std::vector<offset_type> matches;
4571   matches.reserve (std::distance (bounds.first, bounds.second));
4572
4573   for (; bounds.first != bounds.second; ++bounds.first)
4574     {
4575       const char *qualified = index.symbol_name_at (bounds.first->idx);
4576
4577       if (!lookup_name_matcher.matches (qualified)
4578           || (symbol_matcher != NULL && !symbol_matcher (qualified)))
4579         continue;
4580
4581       matches.push_back (bounds.first->idx);
4582     }
4583
4584   std::sort (matches.begin (), matches.end ());
4585
4586   /* Finally call the callback, once per match.  */
4587   ULONGEST prev = -1;
4588   for (offset_type idx : matches)
4589     {
4590       if (prev != idx)
4591         {
4592           match_callback (idx);
4593           prev = idx;
4594         }
4595     }
4596
4597   /* Above we use a type wider than idx's for 'prev', since 0 and
4598      (offset_type)-1 are both possible values.  */
4599   static_assert (sizeof (prev) > sizeof (offset_type), "");
4600 }
4601
4602 #if GDB_SELF_TEST
4603
4604 namespace selftests { namespace dw2_expand_symtabs_matching {
4605
4606 /* A mock .gdb_index/.debug_names-like name index table, enough to
4607    exercise dw2_expand_symtabs_matching_symbol, which works with the
4608    mapped_index_base interface.  Builds an index from the symbol list
4609    passed as parameter to the constructor.  */
4610 class mock_mapped_index : public mapped_index_base
4611 {
4612 public:
4613   mock_mapped_index (gdb::array_view<const char *> symbols)
4614     : m_symbol_table (symbols)
4615   {}
4616
4617   DISABLE_COPY_AND_ASSIGN (mock_mapped_index);
4618
4619   /* Return the number of names in the symbol table.  */
4620   size_t symbol_name_count () const override
4621   {
4622     return m_symbol_table.size ();
4623   }
4624
4625   /* Get the name of the symbol at IDX in the symbol table.  */
4626   const char *symbol_name_at (offset_type idx) const override
4627   {
4628     return m_symbol_table[idx];
4629   }
4630
4631 private:
4632   gdb::array_view<const char *> m_symbol_table;
4633 };
4634
4635 /* Convenience function that converts a NULL pointer to a "<null>"
4636    string, to pass to print routines.  */
4637
4638 static const char *
4639 string_or_null (const char *str)
4640 {
4641   return str != NULL ? str : "<null>";
4642 }
4643
4644 /* Check if a lookup_name_info built from
4645    NAME/MATCH_TYPE/COMPLETION_MODE matches the symbols in the mock
4646    index.  EXPECTED_LIST is the list of expected matches, in expected
4647    matching order.  If no match expected, then an empty list is
4648    specified.  Returns true on success.  On failure prints a warning
4649    indicating the file:line that failed, and returns false.  */
4650
4651 static bool
4652 check_match (const char *file, int line,
4653              mock_mapped_index &mock_index,
4654              const char *name, symbol_name_match_type match_type,
4655              bool completion_mode,
4656              std::initializer_list<const char *> expected_list)
4657 {
4658   lookup_name_info lookup_name (name, match_type, completion_mode);
4659
4660   bool matched = true;
4661
4662   auto mismatch = [&] (const char *expected_str,
4663                        const char *got)
4664   {
4665     warning (_("%s:%d: match_type=%s, looking-for=\"%s\", "
4666                "expected=\"%s\", got=\"%s\"\n"),
4667              file, line,
4668              (match_type == symbol_name_match_type::FULL
4669               ? "FULL" : "WILD"),
4670              name, string_or_null (expected_str), string_or_null (got));
4671     matched = false;
4672   };
4673
4674   auto expected_it = expected_list.begin ();
4675   auto expected_end = expected_list.end ();
4676
4677   dw2_expand_symtabs_matching_symbol (mock_index, lookup_name,
4678                                       NULL, ALL_DOMAIN,
4679                                       [&] (offset_type idx)
4680   {
4681     const char *matched_name = mock_index.symbol_name_at (idx);
4682     const char *expected_str
4683       = expected_it == expected_end ? NULL : *expected_it++;
4684
4685     if (expected_str == NULL || strcmp (expected_str, matched_name) != 0)
4686       mismatch (expected_str, matched_name);
4687   });
4688
4689   const char *expected_str
4690   = expected_it == expected_end ? NULL : *expected_it++;
4691   if (expected_str != NULL)
4692     mismatch (expected_str, NULL);
4693
4694   return matched;
4695 }
4696
4697 /* The symbols added to the mock mapped_index for testing (in
4698    canonical form).  */
4699 static const char *test_symbols[] = {
4700   "function",
4701   "std::bar",
4702   "std::zfunction",
4703   "std::zfunction2",
4704   "w1::w2",
4705   "ns::foo<char*>",
4706   "ns::foo<int>",
4707   "ns::foo<long>",
4708   "ns2::tmpl<int>::foo2",
4709   "(anonymous namespace)::A::B::C",
4710
4711   /* These are used to check that the increment-last-char in the
4712      matching algorithm for completion doesn't match "t1_fund" when
4713      completing "t1_func".  */
4714   "t1_func",
4715   "t1_func1",
4716   "t1_fund",
4717   "t1_fund1",
4718
4719   /* A UTF-8 name with multi-byte sequences to make sure that
4720      cp-name-parser understands this as a single identifier ("função"
4721      is "function" in PT).  */
4722   u8"u8função",
4723
4724   /* \377 (0xff) is Latin1 'ÿ'.  */
4725   "yfunc\377",
4726
4727   /* \377 (0xff) is Latin1 'ÿ'.  */
4728   "\377",
4729   "\377\377123",
4730
4731   /* A name with all sorts of complications.  Starts with "z" to make
4732      it easier for the completion tests below.  */
4733 #define Z_SYM_NAME \
4734   "z::std::tuple<(anonymous namespace)::ui*, std::bar<(anonymous namespace)::ui> >" \
4735     "::tuple<(anonymous namespace)::ui*, " \
4736     "std::default_delete<(anonymous namespace)::ui>, void>"
4737
4738   Z_SYM_NAME
4739 };
4740
4741 /* Returns true if the mapped_index_base::find_name_component_bounds
4742    method finds EXPECTED_SYMS in INDEX when looking for SEARCH_NAME,
4743    in completion mode.  */
4744
4745 static bool
4746 check_find_bounds_finds (mapped_index_base &index,
4747                          const char *search_name,
4748                          gdb::array_view<const char *> expected_syms)
4749 {
4750   lookup_name_info lookup_name (search_name,
4751                                 symbol_name_match_type::FULL, true);
4752
4753   auto bounds = index.find_name_components_bounds (lookup_name);
4754
4755   size_t distance = std::distance (bounds.first, bounds.second);
4756   if (distance != expected_syms.size ())
4757     return false;
4758
4759   for (size_t exp_elem = 0; exp_elem < distance; exp_elem++)
4760     {
4761       auto nc_elem = bounds.first + exp_elem;
4762       const char *qualified = index.symbol_name_at (nc_elem->idx);
4763       if (strcmp (qualified, expected_syms[exp_elem]) != 0)
4764         return false;
4765     }
4766
4767   return true;
4768 }
4769
4770 /* Test the lower-level mapped_index::find_name_component_bounds
4771    method.  */
4772
4773 static void
4774 test_mapped_index_find_name_component_bounds ()
4775 {
4776   mock_mapped_index mock_index (test_symbols);
4777
4778   mock_index.build_name_components ();
4779
4780   /* Test the lower-level mapped_index::find_name_component_bounds
4781      method in completion mode.  */
4782   {
4783     static const char *expected_syms[] = {
4784       "t1_func",
4785       "t1_func1",
4786     };
4787
4788     SELF_CHECK (check_find_bounds_finds (mock_index,
4789                                          "t1_func", expected_syms));
4790   }
4791
4792   /* Check that the increment-last-char in the name matching algorithm
4793      for completion doesn't get confused with Ansi1 'ÿ' / 0xff.  */
4794   {
4795     static const char *expected_syms1[] = {
4796       "\377",
4797       "\377\377123",
4798     };
4799     SELF_CHECK (check_find_bounds_finds (mock_index,
4800                                          "\377", expected_syms1));
4801
4802     static const char *expected_syms2[] = {
4803       "\377\377123",
4804     };
4805     SELF_CHECK (check_find_bounds_finds (mock_index,
4806                                          "\377\377", expected_syms2));
4807   }
4808 }
4809
4810 /* Test dw2_expand_symtabs_matching_symbol.  */
4811
4812 static void
4813 test_dw2_expand_symtabs_matching_symbol ()
4814 {
4815   mock_mapped_index mock_index (test_symbols);
4816
4817   /* We let all tests run until the end even if some fails, for debug
4818      convenience.  */
4819   bool any_mismatch = false;
4820
4821   /* Create the expected symbols list (an initializer_list).  Needed
4822      because lists have commas, and we need to pass them to CHECK,
4823      which is a macro.  */
4824 #define EXPECT(...) { __VA_ARGS__ }
4825
4826   /* Wrapper for check_match that passes down the current
4827      __FILE__/__LINE__.  */
4828 #define CHECK_MATCH(NAME, MATCH_TYPE, COMPLETION_MODE, EXPECTED_LIST)   \
4829   any_mismatch |= !check_match (__FILE__, __LINE__,                     \
4830                                 mock_index,                             \
4831                                 NAME, MATCH_TYPE, COMPLETION_MODE,      \
4832                                 EXPECTED_LIST)
4833
4834   /* Identity checks.  */
4835   for (const char *sym : test_symbols)
4836     {
4837       /* Should be able to match all existing symbols.  */
4838       CHECK_MATCH (sym, symbol_name_match_type::FULL, false,
4839                    EXPECT (sym));
4840
4841       /* Should be able to match all existing symbols with
4842          parameters.  */
4843       std::string with_params = std::string (sym) + "(int)";
4844       CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
4845                    EXPECT (sym));
4846
4847       /* Should be able to match all existing symbols with
4848          parameters and qualifiers.  */
4849       with_params = std::string (sym) + " ( int ) const";
4850       CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
4851                    EXPECT (sym));
4852
4853       /* This should really find sym, but cp-name-parser.y doesn't
4854          know about lvalue/rvalue qualifiers yet.  */
4855       with_params = std::string (sym) + " ( int ) &&";
4856       CHECK_MATCH (with_params.c_str (), symbol_name_match_type::FULL, false,
4857                    {});
4858     }
4859
4860   /* Check that the name matching algorithm for completion doesn't get
4861      confused with Latin1 'ÿ' / 0xff.  */
4862   {
4863     static const char str[] = "\377";
4864     CHECK_MATCH (str, symbol_name_match_type::FULL, true,
4865                  EXPECT ("\377", "\377\377123"));
4866   }
4867
4868   /* Check that the increment-last-char in the matching algorithm for
4869      completion doesn't match "t1_fund" when completing "t1_func".  */
4870   {
4871     static const char str[] = "t1_func";
4872     CHECK_MATCH (str, symbol_name_match_type::FULL, true,
4873                  EXPECT ("t1_func", "t1_func1"));
4874   }
4875
4876   /* Check that completion mode works at each prefix of the expected
4877      symbol name.  */
4878   {
4879     static const char str[] = "function(int)";
4880     size_t len = strlen (str);
4881     std::string lookup;
4882
4883     for (size_t i = 1; i < len; i++)
4884       {
4885         lookup.assign (str, i);
4886         CHECK_MATCH (lookup.c_str (), symbol_name_match_type::FULL, true,
4887                      EXPECT ("function"));
4888       }
4889   }
4890
4891   /* While "w" is a prefix of both components, the match function
4892      should still only be called once.  */
4893   {
4894     CHECK_MATCH ("w", symbol_name_match_type::FULL, true,
4895                  EXPECT ("w1::w2"));
4896     CHECK_MATCH ("w", symbol_name_match_type::WILD, true,
4897                  EXPECT ("w1::w2"));
4898   }
4899
4900   /* Same, with a "complicated" symbol.  */
4901   {
4902     static const char str[] = Z_SYM_NAME;
4903     size_t len = strlen (str);
4904     std::string lookup;
4905
4906     for (size_t i = 1; i < len; i++)
4907       {
4908         lookup.assign (str, i);
4909         CHECK_MATCH (lookup.c_str (), symbol_name_match_type::FULL, true,
4910                      EXPECT (Z_SYM_NAME));
4911       }
4912   }
4913
4914   /* In FULL mode, an incomplete symbol doesn't match.  */
4915   {
4916     CHECK_MATCH ("std::zfunction(int", symbol_name_match_type::FULL, false,
4917                  {});
4918   }
4919
4920   /* A complete symbol with parameters matches any overload, since the
4921      index has no overload info.  */
4922   {
4923     CHECK_MATCH ("std::zfunction(int)", symbol_name_match_type::FULL, true,
4924                  EXPECT ("std::zfunction", "std::zfunction2"));
4925     CHECK_MATCH ("zfunction(int)", symbol_name_match_type::WILD, true,
4926                  EXPECT ("std::zfunction", "std::zfunction2"));
4927     CHECK_MATCH ("zfunc", symbol_name_match_type::WILD, true,
4928                  EXPECT ("std::zfunction", "std::zfunction2"));
4929   }
4930
4931   /* Check that whitespace is ignored appropriately.  A symbol with a
4932      template argument list. */
4933   {
4934     static const char expected[] = "ns::foo<int>";
4935     CHECK_MATCH ("ns :: foo < int > ", symbol_name_match_type::FULL, false,
4936                  EXPECT (expected));
4937     CHECK_MATCH ("foo < int > ", symbol_name_match_type::WILD, false,
4938                  EXPECT (expected));
4939   }
4940
4941   /* Check that whitespace is ignored appropriately.  A symbol with a
4942      template argument list that includes a pointer.  */
4943   {
4944     static const char expected[] = "ns::foo<char*>";
4945     /* Try both completion and non-completion modes.  */
4946     static const bool completion_mode[2] = {false, true};
4947     for (size_t i = 0; i < 2; i++)
4948       {
4949         CHECK_MATCH ("ns :: foo < char * >", symbol_name_match_type::FULL,
4950                      completion_mode[i], EXPECT (expected));
4951         CHECK_MATCH ("foo < char * >", symbol_name_match_type::WILD,
4952                      completion_mode[i], EXPECT (expected));
4953
4954         CHECK_MATCH ("ns :: foo < char * > (int)", symbol_name_match_type::FULL,
4955                      completion_mode[i], EXPECT (expected));
4956         CHECK_MATCH ("foo < char * > (int)", symbol_name_match_type::WILD,
4957                      completion_mode[i], EXPECT (expected));
4958       }
4959   }
4960
4961   {
4962     /* Check method qualifiers are ignored.  */
4963     static const char expected[] = "ns::foo<char*>";
4964     CHECK_MATCH ("ns :: foo < char * >  ( int ) const",
4965                  symbol_name_match_type::FULL, true, EXPECT (expected));
4966     CHECK_MATCH ("ns :: foo < char * >  ( int ) &&",
4967                  symbol_name_match_type::FULL, true, EXPECT (expected));
4968     CHECK_MATCH ("foo < char * >  ( int ) const",
4969                  symbol_name_match_type::WILD, true, EXPECT (expected));
4970     CHECK_MATCH ("foo < char * >  ( int ) &&",
4971                  symbol_name_match_type::WILD, true, EXPECT (expected));
4972   }
4973
4974   /* Test lookup names that don't match anything.  */
4975   {
4976     CHECK_MATCH ("bar2", symbol_name_match_type::WILD, false,
4977                  {});
4978
4979     CHECK_MATCH ("doesntexist", symbol_name_match_type::FULL, false,
4980                  {});
4981   }
4982
4983   /* Some wild matching tests, exercising "(anonymous namespace)",
4984      which should not be confused with a parameter list.  */
4985   {
4986     static const char *syms[] = {
4987       "A::B::C",
4988       "B::C",
4989       "C",
4990       "A :: B :: C ( int )",
4991       "B :: C ( int )",
4992       "C ( int )",
4993     };
4994
4995     for (const char *s : syms)
4996       {
4997         CHECK_MATCH (s, symbol_name_match_type::WILD, false,
4998                      EXPECT ("(anonymous namespace)::A::B::C"));
4999       }
5000   }
5001
5002   {
5003     static const char expected[] = "ns2::tmpl<int>::foo2";
5004     CHECK_MATCH ("tmp", symbol_name_match_type::WILD, true,
5005                  EXPECT (expected));
5006     CHECK_MATCH ("tmpl<", symbol_name_match_type::WILD, true,
5007                  EXPECT (expected));
5008   }
5009
5010   SELF_CHECK (!any_mismatch);
5011
5012 #undef EXPECT
5013 #undef CHECK_MATCH
5014 }
5015
5016 static void
5017 run_test ()
5018 {
5019   test_mapped_index_find_name_component_bounds ();
5020   test_dw2_expand_symtabs_matching_symbol ();
5021 }
5022
5023 }} // namespace selftests::dw2_expand_symtabs_matching
5024
5025 #endif /* GDB_SELF_TEST */
5026
5027 /* If FILE_MATCHER is NULL or if PER_CU has
5028    dwarf2_per_cu_quick_data::MARK set (see
5029    dw_expand_symtabs_matching_file_matcher), expand the CU and call
5030    EXPANSION_NOTIFY on it.  */
5031
5032 static void
5033 dw2_expand_symtabs_matching_one
5034   (struct dwarf2_per_cu_data *per_cu,
5035    gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5036    gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify)
5037 {
5038   if (file_matcher == NULL || per_cu->v.quick->mark)
5039     {
5040       bool symtab_was_null
5041         = (per_cu->v.quick->compunit_symtab == NULL);
5042
5043       dw2_instantiate_symtab (per_cu, false);
5044
5045       if (expansion_notify != NULL
5046           && symtab_was_null
5047           && per_cu->v.quick->compunit_symtab != NULL)
5048         expansion_notify (per_cu->v.quick->compunit_symtab);
5049     }
5050 }
5051
5052 /* Helper for dw2_expand_matching symtabs.  Called on each symbol
5053    matched, to expand corresponding CUs that were marked.  IDX is the
5054    index of the symbol name that matched.  */
5055
5056 static void
5057 dw2_expand_marked_cus
5058   (struct dwarf2_per_objfile *dwarf2_per_objfile, offset_type idx,
5059    gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5060    gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
5061    search_domain kind)
5062 {
5063   offset_type *vec, vec_len, vec_idx;
5064   bool global_seen = false;
5065   mapped_index &index = *dwarf2_per_objfile->index_table;
5066
5067   vec = (offset_type *) (index.constant_pool
5068                          + MAYBE_SWAP (index.symbol_table[idx].vec));
5069   vec_len = MAYBE_SWAP (vec[0]);
5070   for (vec_idx = 0; vec_idx < vec_len; ++vec_idx)
5071     {
5072       offset_type cu_index_and_attrs = MAYBE_SWAP (vec[vec_idx + 1]);
5073       /* This value is only valid for index versions >= 7.  */
5074       int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
5075       gdb_index_symbol_kind symbol_kind =
5076         GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
5077       int cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
5078       /* Only check the symbol attributes if they're present.
5079          Indices prior to version 7 don't record them,
5080          and indices >= 7 may elide them for certain symbols
5081          (gold does this).  */
5082       int attrs_valid =
5083         (index.version >= 7
5084          && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
5085
5086       /* Work around gold/15646.  */
5087       if (attrs_valid)
5088         {
5089           if (!is_static && global_seen)
5090             continue;
5091           if (!is_static)
5092             global_seen = true;
5093         }
5094
5095       /* Only check the symbol's kind if it has one.  */
5096       if (attrs_valid)
5097         {
5098           switch (kind)
5099             {
5100             case VARIABLES_DOMAIN:
5101               if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE)
5102                 continue;
5103               break;
5104             case FUNCTIONS_DOMAIN:
5105               if (symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION)
5106                 continue;
5107               break;
5108             case TYPES_DOMAIN:
5109               if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
5110                 continue;
5111               break;
5112             default:
5113               break;
5114             }
5115         }
5116
5117       /* Don't crash on bad data.  */
5118       if (cu_index >= (dwarf2_per_objfile->all_comp_units.size ()
5119                        + dwarf2_per_objfile->all_type_units.size ()))
5120         {
5121           complaint (_(".gdb_index entry has bad CU index"
5122                        " [in module %s]"),
5123                        objfile_name (dwarf2_per_objfile->objfile));
5124           continue;
5125         }
5126
5127       dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (cu_index);
5128       dw2_expand_symtabs_matching_one (per_cu, file_matcher,
5129                                        expansion_notify);
5130     }
5131 }
5132
5133 /* If FILE_MATCHER is non-NULL, set all the
5134    dwarf2_per_cu_quick_data::MARK of the current DWARF2_PER_OBJFILE
5135    that match FILE_MATCHER.  */
5136
5137 static void
5138 dw_expand_symtabs_matching_file_matcher
5139   (struct dwarf2_per_objfile *dwarf2_per_objfile,
5140    gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher)
5141 {
5142   if (file_matcher == NULL)
5143     return;
5144
5145   objfile *const objfile = dwarf2_per_objfile->objfile;
5146
5147   htab_up visited_found (htab_create_alloc (10, htab_hash_pointer,
5148                                             htab_eq_pointer,
5149                                             NULL, xcalloc, xfree));
5150   htab_up visited_not_found (htab_create_alloc (10, htab_hash_pointer,
5151                                                 htab_eq_pointer,
5152                                                 NULL, xcalloc, xfree));
5153
5154   /* The rule is CUs specify all the files, including those used by
5155      any TU, so there's no need to scan TUs here.  */
5156
5157   for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
5158     {
5159       QUIT;
5160
5161       per_cu->v.quick->mark = 0;
5162
5163       /* We only need to look at symtabs not already expanded.  */
5164       if (per_cu->v.quick->compunit_symtab)
5165         continue;
5166
5167       quick_file_names *file_data = dw2_get_file_names (per_cu);
5168       if (file_data == NULL)
5169         continue;
5170
5171       if (htab_find (visited_not_found.get (), file_data) != NULL)
5172         continue;
5173       else if (htab_find (visited_found.get (), file_data) != NULL)
5174         {
5175           per_cu->v.quick->mark = 1;
5176           continue;
5177         }
5178
5179       for (int j = 0; j < file_data->num_file_names; ++j)
5180         {
5181           const char *this_real_name;
5182
5183           if (file_matcher (file_data->file_names[j], false))
5184             {
5185               per_cu->v.quick->mark = 1;
5186               break;
5187             }
5188
5189           /* Before we invoke realpath, which can get expensive when many
5190              files are involved, do a quick comparison of the basenames.  */
5191           if (!basenames_may_differ
5192               && !file_matcher (lbasename (file_data->file_names[j]),
5193                                 true))
5194             continue;
5195
5196           this_real_name = dw2_get_real_path (objfile, file_data, j);
5197           if (file_matcher (this_real_name, false))
5198             {
5199               per_cu->v.quick->mark = 1;
5200               break;
5201             }
5202         }
5203
5204       void **slot = htab_find_slot (per_cu->v.quick->mark
5205                                     ? visited_found.get ()
5206                                     : visited_not_found.get (),
5207                                     file_data, INSERT);
5208       *slot = file_data;
5209     }
5210 }
5211
5212 static void
5213 dw2_expand_symtabs_matching
5214   (struct objfile *objfile,
5215    gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
5216    const lookup_name_info &lookup_name,
5217    gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
5218    gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
5219    enum search_domain kind)
5220 {
5221   struct dwarf2_per_objfile *dwarf2_per_objfile
5222     = get_dwarf2_per_objfile (objfile);
5223
5224   /* index_table is NULL if OBJF_READNOW.  */
5225   if (!dwarf2_per_objfile->index_table)
5226     return;
5227
5228   dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile, file_matcher);
5229
5230   mapped_index &index = *dwarf2_per_objfile->index_table;
5231
5232   dw2_expand_symtabs_matching_symbol (index, lookup_name,
5233                                       symbol_matcher,
5234                                       kind, [&] (offset_type idx)
5235     {
5236       dw2_expand_marked_cus (dwarf2_per_objfile, idx, file_matcher,
5237                              expansion_notify, kind);
5238     });
5239 }
5240
5241 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
5242    symtab.  */
5243
5244 static struct compunit_symtab *
5245 recursively_find_pc_sect_compunit_symtab (struct compunit_symtab *cust,
5246                                           CORE_ADDR pc)
5247 {
5248   int i;
5249
5250   if (COMPUNIT_BLOCKVECTOR (cust) != NULL
5251       && blockvector_contains_pc (COMPUNIT_BLOCKVECTOR (cust), pc))
5252     return cust;
5253
5254   if (cust->includes == NULL)
5255     return NULL;
5256
5257   for (i = 0; cust->includes[i]; ++i)
5258     {
5259       struct compunit_symtab *s = cust->includes[i];
5260
5261       s = recursively_find_pc_sect_compunit_symtab (s, pc);
5262       if (s != NULL)
5263         return s;
5264     }
5265
5266   return NULL;
5267 }
5268
5269 static struct compunit_symtab *
5270 dw2_find_pc_sect_compunit_symtab (struct objfile *objfile,
5271                                   struct bound_minimal_symbol msymbol,
5272                                   CORE_ADDR pc,
5273                                   struct obj_section *section,
5274                                   int warn_if_readin)
5275 {
5276   struct dwarf2_per_cu_data *data;
5277   struct compunit_symtab *result;
5278
5279   if (!objfile->partial_symtabs->psymtabs_addrmap)
5280     return NULL;
5281
5282   CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
5283                                  SECT_OFF_TEXT (objfile));
5284   data = (struct dwarf2_per_cu_data *) addrmap_find
5285     (objfile->partial_symtabs->psymtabs_addrmap, pc - baseaddr);
5286   if (!data)
5287     return NULL;
5288
5289   if (warn_if_readin && data->v.quick->compunit_symtab)
5290     warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
5291              paddress (get_objfile_arch (objfile), pc));
5292
5293   result
5294     = recursively_find_pc_sect_compunit_symtab (dw2_instantiate_symtab (data,
5295                                                                         false),
5296                                                 pc);
5297   gdb_assert (result != NULL);
5298   return result;
5299 }
5300
5301 static void
5302 dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun,
5303                           void *data, int need_fullname)
5304 {
5305   struct dwarf2_per_objfile *dwarf2_per_objfile
5306     = get_dwarf2_per_objfile (objfile);
5307
5308   if (!dwarf2_per_objfile->filenames_cache)
5309     {
5310       dwarf2_per_objfile->filenames_cache.emplace ();
5311
5312       htab_up visited (htab_create_alloc (10,
5313                                           htab_hash_pointer, htab_eq_pointer,
5314                                           NULL, xcalloc, xfree));
5315
5316       /* The rule is CUs specify all the files, including those used
5317          by any TU, so there's no need to scan TUs here.  We can
5318          ignore file names coming from already-expanded CUs.  */
5319
5320       for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
5321         {
5322           if (per_cu->v.quick->compunit_symtab)
5323             {
5324               void **slot = htab_find_slot (visited.get (),
5325                                             per_cu->v.quick->file_names,
5326                                             INSERT);
5327
5328               *slot = per_cu->v.quick->file_names;
5329             }
5330         }
5331
5332       for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
5333         {
5334           /* We only need to look at symtabs not already expanded.  */
5335           if (per_cu->v.quick->compunit_symtab)
5336             continue;
5337
5338           quick_file_names *file_data = dw2_get_file_names (per_cu);
5339           if (file_data == NULL)
5340             continue;
5341
5342           void **slot = htab_find_slot (visited.get (), file_data, INSERT);
5343           if (*slot)
5344             {
5345               /* Already visited.  */
5346               continue;
5347             }
5348           *slot = file_data;
5349
5350           for (int j = 0; j < file_data->num_file_names; ++j)
5351             {
5352               const char *filename = file_data->file_names[j];
5353               dwarf2_per_objfile->filenames_cache->seen (filename);
5354             }
5355         }
5356     }
5357
5358   dwarf2_per_objfile->filenames_cache->traverse ([&] (const char *filename)
5359     {
5360       gdb::unique_xmalloc_ptr<char> this_real_name;
5361
5362       if (need_fullname)
5363         this_real_name = gdb_realpath (filename);
5364       (*fun) (filename, this_real_name.get (), data);
5365     });
5366 }
5367
5368 static int
5369 dw2_has_symbols (struct objfile *objfile)
5370 {
5371   return 1;
5372 }
5373
5374 const struct quick_symbol_functions dwarf2_gdb_index_functions =
5375 {
5376   dw2_has_symbols,
5377   dw2_find_last_source_symtab,
5378   dw2_forget_cached_source_info,
5379   dw2_map_symtabs_matching_filename,
5380   dw2_lookup_symbol,
5381   dw2_print_stats,
5382   dw2_dump,
5383   dw2_expand_symtabs_for_function,
5384   dw2_expand_all_symtabs,
5385   dw2_expand_symtabs_with_fullname,
5386   dw2_map_matching_symbols,
5387   dw2_expand_symtabs_matching,
5388   dw2_find_pc_sect_compunit_symtab,
5389   NULL,
5390   dw2_map_symbol_filenames
5391 };
5392
5393 /* DWARF-5 debug_names reader.  */
5394
5395 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension.  */
5396 static const gdb_byte dwarf5_augmentation[] = { 'G', 'D', 'B', 0 };
5397
5398 /* A helper function that reads the .debug_names section in SECTION
5399    and fills in MAP.  FILENAME is the name of the file containing the
5400    section; it is used for error reporting.
5401
5402    Returns true if all went well, false otherwise.  */
5403
5404 static bool
5405 read_debug_names_from_section (struct objfile *objfile,
5406                                const char *filename,
5407                                struct dwarf2_section_info *section,
5408                                mapped_debug_names &map)
5409 {
5410   if (dwarf2_section_empty_p (section))
5411     return false;
5412
5413   /* Older elfutils strip versions could keep the section in the main
5414      executable while splitting it for the separate debug info file.  */
5415   if ((get_section_flags (section) & SEC_HAS_CONTENTS) == 0)
5416     return false;
5417
5418   dwarf2_read_section (objfile, section);
5419
5420   map.dwarf5_byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
5421
5422   const gdb_byte *addr = section->buffer;
5423
5424   bfd *const abfd = get_section_bfd_owner (section);
5425
5426   unsigned int bytes_read;
5427   LONGEST length = read_initial_length (abfd, addr, &bytes_read);
5428   addr += bytes_read;
5429
5430   map.dwarf5_is_dwarf64 = bytes_read != 4;
5431   map.offset_size = map.dwarf5_is_dwarf64 ? 8 : 4;
5432   if (bytes_read + length != section->size)
5433     {
5434       /* There may be multiple per-CU indices.  */
5435       warning (_("Section .debug_names in %s length %s does not match "
5436                  "section length %s, ignoring .debug_names."),
5437                filename, plongest (bytes_read + length),
5438                pulongest (section->size));
5439       return false;
5440     }
5441
5442   /* The version number.  */
5443   uint16_t version = read_2_bytes (abfd, addr);
5444   addr += 2;
5445   if (version != 5)
5446     {
5447       warning (_("Section .debug_names in %s has unsupported version %d, "
5448                  "ignoring .debug_names."),
5449                filename, version);
5450       return false;
5451     }
5452
5453   /* Padding.  */
5454   uint16_t padding = read_2_bytes (abfd, addr);
5455   addr += 2;
5456   if (padding != 0)
5457     {
5458       warning (_("Section .debug_names in %s has unsupported padding %d, "
5459                  "ignoring .debug_names."),
5460                filename, padding);
5461       return false;
5462     }
5463
5464   /* comp_unit_count - The number of CUs in the CU list.  */
5465   map.cu_count = read_4_bytes (abfd, addr);
5466   addr += 4;
5467
5468   /* local_type_unit_count - The number of TUs in the local TU
5469      list.  */
5470   map.tu_count = read_4_bytes (abfd, addr);
5471   addr += 4;
5472
5473   /* foreign_type_unit_count - The number of TUs in the foreign TU
5474      list.  */
5475   uint32_t foreign_tu_count = read_4_bytes (abfd, addr);
5476   addr += 4;
5477   if (foreign_tu_count != 0)
5478     {
5479       warning (_("Section .debug_names in %s has unsupported %lu foreign TUs, "
5480                  "ignoring .debug_names."),
5481                filename, static_cast<unsigned long> (foreign_tu_count));
5482       return false;
5483     }
5484
5485   /* bucket_count - The number of hash buckets in the hash lookup
5486      table.  */
5487   map.bucket_count = read_4_bytes (abfd, addr);
5488   addr += 4;
5489
5490   /* name_count - The number of unique names in the index.  */
5491   map.name_count = read_4_bytes (abfd, addr);
5492   addr += 4;
5493
5494   /* abbrev_table_size - The size in bytes of the abbreviations
5495      table.  */
5496   uint32_t abbrev_table_size = read_4_bytes (abfd, addr);
5497   addr += 4;
5498
5499   /* augmentation_string_size - The size in bytes of the augmentation
5500      string.  This value is rounded up to a multiple of 4.  */
5501   uint32_t augmentation_string_size = read_4_bytes (abfd, addr);
5502   addr += 4;
5503   map.augmentation_is_gdb = ((augmentation_string_size
5504                               == sizeof (dwarf5_augmentation))
5505                              && memcmp (addr, dwarf5_augmentation,
5506                                         sizeof (dwarf5_augmentation)) == 0);
5507   augmentation_string_size += (-augmentation_string_size) & 3;
5508   addr += augmentation_string_size;
5509
5510   /* List of CUs */
5511   map.cu_table_reordered = addr;
5512   addr += map.cu_count * map.offset_size;
5513
5514   /* List of Local TUs */
5515   map.tu_table_reordered = addr;
5516   addr += map.tu_count * map.offset_size;
5517
5518   /* Hash Lookup Table */
5519   map.bucket_table_reordered = reinterpret_cast<const uint32_t *> (addr);
5520   addr += map.bucket_count * 4;
5521   map.hash_table_reordered = reinterpret_cast<const uint32_t *> (addr);
5522   addr += map.name_count * 4;
5523
5524   /* Name Table */
5525   map.name_table_string_offs_reordered = addr;
5526   addr += map.name_count * map.offset_size;
5527   map.name_table_entry_offs_reordered = addr;
5528   addr += map.name_count * map.offset_size;
5529
5530   const gdb_byte *abbrev_table_start = addr;
5531   for (;;)
5532     {
5533       const ULONGEST index_num = read_unsigned_leb128 (abfd, addr, &bytes_read);
5534       addr += bytes_read;
5535       if (index_num == 0)
5536         break;
5537
5538       const auto insertpair
5539         = map.abbrev_map.emplace (index_num, mapped_debug_names::index_val ());
5540       if (!insertpair.second)
5541         {
5542           warning (_("Section .debug_names in %s has duplicate index %s, "
5543                      "ignoring .debug_names."),
5544                    filename, pulongest (index_num));
5545           return false;
5546         }
5547       mapped_debug_names::index_val &indexval = insertpair.first->second;
5548       indexval.dwarf_tag = read_unsigned_leb128 (abfd, addr, &bytes_read);
5549       addr += bytes_read;
5550
5551       for (;;)
5552         {
5553           mapped_debug_names::index_val::attr attr;
5554           attr.dw_idx = read_unsigned_leb128 (abfd, addr, &bytes_read);
5555           addr += bytes_read;
5556           attr.form = read_unsigned_leb128 (abfd, addr, &bytes_read);
5557           addr += bytes_read;
5558           if (attr.form == DW_FORM_implicit_const)
5559             {
5560               attr.implicit_const = read_signed_leb128 (abfd, addr,
5561                                                         &bytes_read);
5562               addr += bytes_read;
5563             }
5564           if (attr.dw_idx == 0 && attr.form == 0)
5565             break;
5566           indexval.attr_vec.push_back (std::move (attr));
5567         }
5568     }
5569   if (addr != abbrev_table_start + abbrev_table_size)
5570     {
5571       warning (_("Section .debug_names in %s has abbreviation_table "
5572                  "of size %zu vs. written as %u, ignoring .debug_names."),
5573                filename, addr - abbrev_table_start, abbrev_table_size);
5574       return false;
5575     }
5576   map.entry_pool = addr;
5577
5578   return true;
5579 }
5580
5581 /* A helper for create_cus_from_debug_names that handles the MAP's CU
5582    list.  */
5583
5584 static void
5585 create_cus_from_debug_names_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
5586                                   const mapped_debug_names &map,
5587                                   dwarf2_section_info &section,
5588                                   bool is_dwz)
5589 {
5590   sect_offset sect_off_prev;
5591   for (uint32_t i = 0; i <= map.cu_count; ++i)
5592     {
5593       sect_offset sect_off_next;
5594       if (i < map.cu_count)
5595         {
5596           sect_off_next
5597             = (sect_offset) (extract_unsigned_integer
5598                              (map.cu_table_reordered + i * map.offset_size,
5599                               map.offset_size,
5600                               map.dwarf5_byte_order));
5601         }
5602       else
5603         sect_off_next = (sect_offset) section.size;
5604       if (i >= 1)
5605         {
5606           const ULONGEST length = sect_off_next - sect_off_prev;
5607           dwarf2_per_cu_data *per_cu
5608             = create_cu_from_index_list (dwarf2_per_objfile, &section, is_dwz,
5609                                          sect_off_prev, length);
5610           dwarf2_per_objfile->all_comp_units.push_back (per_cu);
5611         }
5612       sect_off_prev = sect_off_next;
5613     }
5614 }
5615
5616 /* Read the CU list from the mapped index, and use it to create all
5617    the CU objects for this dwarf2_per_objfile.  */
5618
5619 static void
5620 create_cus_from_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile,
5621                              const mapped_debug_names &map,
5622                              const mapped_debug_names &dwz_map)
5623 {
5624   gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
5625   dwarf2_per_objfile->all_comp_units.reserve (map.cu_count + dwz_map.cu_count);
5626
5627   create_cus_from_debug_names_list (dwarf2_per_objfile, map,
5628                                     dwarf2_per_objfile->info,
5629                                     false /* is_dwz */);
5630
5631   if (dwz_map.cu_count == 0)
5632     return;
5633
5634   dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
5635   create_cus_from_debug_names_list (dwarf2_per_objfile, dwz_map, dwz->info,
5636                                     true /* is_dwz */);
5637 }
5638
5639 /* Read .debug_names.  If everything went ok, initialize the "quick"
5640    elements of all the CUs and return true.  Otherwise, return false.  */
5641
5642 static bool
5643 dwarf2_read_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile)
5644 {
5645   std::unique_ptr<mapped_debug_names> map
5646     (new mapped_debug_names (dwarf2_per_objfile));
5647   mapped_debug_names dwz_map (dwarf2_per_objfile);
5648   struct objfile *objfile = dwarf2_per_objfile->objfile;
5649
5650   if (!read_debug_names_from_section (objfile, objfile_name (objfile),
5651                                       &dwarf2_per_objfile->debug_names,
5652                                       *map))
5653     return false;
5654
5655   /* Don't use the index if it's empty.  */
5656   if (map->name_count == 0)
5657     return false;
5658
5659   /* If there is a .dwz file, read it so we can get its CU list as
5660      well.  */
5661   dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
5662   if (dwz != NULL)
5663     {
5664       if (!read_debug_names_from_section (objfile,
5665                                           bfd_get_filename (dwz->dwz_bfd),
5666                                           &dwz->debug_names, dwz_map))
5667         {
5668           warning (_("could not read '.debug_names' section from %s; skipping"),
5669                    bfd_get_filename (dwz->dwz_bfd));
5670           return false;
5671         }
5672     }
5673
5674   create_cus_from_debug_names (dwarf2_per_objfile, *map, dwz_map);
5675
5676   if (map->tu_count != 0)
5677     {
5678       /* We can only handle a single .debug_types when we have an
5679          index.  */
5680       if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) != 1)
5681         return false;
5682
5683       dwarf2_section_info *section = VEC_index (dwarf2_section_info_def,
5684                                                 dwarf2_per_objfile->types, 0);
5685
5686       create_signatured_type_table_from_debug_names
5687         (dwarf2_per_objfile, *map, section, &dwarf2_per_objfile->abbrev);
5688     }
5689
5690   create_addrmap_from_aranges (dwarf2_per_objfile,
5691                                &dwarf2_per_objfile->debug_aranges);
5692
5693   dwarf2_per_objfile->debug_names_table = std::move (map);
5694   dwarf2_per_objfile->using_index = 1;
5695   dwarf2_per_objfile->quick_file_names_table =
5696     create_quick_file_names_table (dwarf2_per_objfile->all_comp_units.size ());
5697
5698   return true;
5699 }
5700
5701 /* Type used to manage iterating over all CUs looking for a symbol for
5702    .debug_names.  */
5703
5704 class dw2_debug_names_iterator
5705 {
5706 public:
5707   /* If WANT_SPECIFIC_BLOCK is true, only look for symbols in block
5708      BLOCK_INDEX.  Otherwise BLOCK_INDEX is ignored.  */
5709   dw2_debug_names_iterator (const mapped_debug_names &map,
5710                             bool want_specific_block,
5711                             block_enum block_index, domain_enum domain,
5712                             const char *name)
5713     : m_map (map), m_want_specific_block (want_specific_block),
5714       m_block_index (block_index), m_domain (domain),
5715       m_addr (find_vec_in_debug_names (map, name))
5716   {}
5717
5718   dw2_debug_names_iterator (const mapped_debug_names &map,
5719                             search_domain search, uint32_t namei)
5720     : m_map (map),
5721       m_search (search),
5722       m_addr (find_vec_in_debug_names (map, namei))
5723   {}
5724
5725   /* Return the next matching CU or NULL if there are no more.  */
5726   dwarf2_per_cu_data *next ();
5727
5728 private:
5729   static const gdb_byte *find_vec_in_debug_names (const mapped_debug_names &map,
5730                                                   const char *name);
5731   static const gdb_byte *find_vec_in_debug_names (const mapped_debug_names &map,
5732                                                   uint32_t namei);
5733
5734   /* The internalized form of .debug_names.  */
5735   const mapped_debug_names &m_map;
5736
5737   /* If true, only look for symbols that match BLOCK_INDEX.  */
5738   const bool m_want_specific_block = false;
5739
5740   /* One of GLOBAL_BLOCK or STATIC_BLOCK.
5741      Unused if !WANT_SPECIFIC_BLOCK - FIRST_LOCAL_BLOCK is an invalid
5742      value.  */
5743   const block_enum m_block_index = FIRST_LOCAL_BLOCK;
5744
5745   /* The kind of symbol we're looking for.  */
5746   const domain_enum m_domain = UNDEF_DOMAIN;
5747   const search_domain m_search = ALL_DOMAIN;
5748
5749   /* The list of CUs from the index entry of the symbol, or NULL if
5750      not found.  */
5751   const gdb_byte *m_addr;
5752 };
5753
5754 const char *
5755 mapped_debug_names::namei_to_name (uint32_t namei) const
5756 {
5757   const ULONGEST namei_string_offs
5758     = extract_unsigned_integer ((name_table_string_offs_reordered
5759                                  + namei * offset_size),
5760                                 offset_size,
5761                                 dwarf5_byte_order);
5762   return read_indirect_string_at_offset
5763     (dwarf2_per_objfile, dwarf2_per_objfile->objfile->obfd, namei_string_offs);
5764 }
5765
5766 /* Find a slot in .debug_names for the object named NAME.  If NAME is
5767    found, return pointer to its pool data.  If NAME cannot be found,
5768    return NULL.  */
5769
5770 const gdb_byte *
5771 dw2_debug_names_iterator::find_vec_in_debug_names
5772   (const mapped_debug_names &map, const char *name)
5773 {
5774   int (*cmp) (const char *, const char *);
5775
5776   if (current_language->la_language == language_cplus
5777       || current_language->la_language == language_fortran
5778       || current_language->la_language == language_d)
5779     {
5780       /* NAME is already canonical.  Drop any qualifiers as
5781          .debug_names does not contain any.  */
5782
5783       if (strchr (name, '(') != NULL)
5784         {
5785           gdb::unique_xmalloc_ptr<char> without_params
5786             = cp_remove_params (name);
5787
5788           if (without_params != NULL)
5789             {
5790               name = without_params.get();
5791             }
5792         }
5793     }
5794
5795   cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
5796
5797   const uint32_t full_hash = dwarf5_djb_hash (name);
5798   uint32_t namei
5799     = extract_unsigned_integer (reinterpret_cast<const gdb_byte *>
5800                                 (map.bucket_table_reordered
5801                                  + (full_hash % map.bucket_count)), 4,
5802                                 map.dwarf5_byte_order);
5803   if (namei == 0)
5804     return NULL;
5805   --namei;
5806   if (namei >= map.name_count)
5807     {
5808       complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5809                    "[in module %s]"),
5810                  namei, map.name_count,
5811                  objfile_name (map.dwarf2_per_objfile->objfile));
5812       return NULL;
5813     }
5814
5815   for (;;)
5816     {
5817       const uint32_t namei_full_hash
5818         = extract_unsigned_integer (reinterpret_cast<const gdb_byte *>
5819                                     (map.hash_table_reordered + namei), 4,
5820                                     map.dwarf5_byte_order);
5821       if (full_hash % map.bucket_count != namei_full_hash % map.bucket_count)
5822         return NULL;
5823
5824       if (full_hash == namei_full_hash)
5825         {
5826           const char *const namei_string = map.namei_to_name (namei);
5827
5828 #if 0 /* An expensive sanity check.  */
5829           if (namei_full_hash != dwarf5_djb_hash (namei_string))
5830             {
5831               complaint (_("Wrong .debug_names hash for string at index %u "
5832                            "[in module %s]"),
5833                          namei, objfile_name (dwarf2_per_objfile->objfile));
5834               return NULL;
5835             }
5836 #endif
5837
5838           if (cmp (namei_string, name) == 0)
5839             {
5840               const ULONGEST namei_entry_offs
5841                 = extract_unsigned_integer ((map.name_table_entry_offs_reordered
5842                                              + namei * map.offset_size),
5843                                             map.offset_size, map.dwarf5_byte_order);
5844               return map.entry_pool + namei_entry_offs;
5845             }
5846         }
5847
5848       ++namei;
5849       if (namei >= map.name_count)
5850         return NULL;
5851     }
5852 }
5853
5854 const gdb_byte *
5855 dw2_debug_names_iterator::find_vec_in_debug_names
5856   (const mapped_debug_names &map, uint32_t namei)
5857 {
5858   if (namei >= map.name_count)
5859     {
5860       complaint (_("Wrong .debug_names with name index %u but name_count=%u "
5861                    "[in module %s]"),
5862                  namei, map.name_count,
5863                  objfile_name (map.dwarf2_per_objfile->objfile));
5864       return NULL;
5865     }
5866
5867   const ULONGEST namei_entry_offs
5868     = extract_unsigned_integer ((map.name_table_entry_offs_reordered
5869                                  + namei * map.offset_size),
5870                                 map.offset_size, map.dwarf5_byte_order);
5871   return map.entry_pool + namei_entry_offs;
5872 }
5873
5874 /* See dw2_debug_names_iterator.  */
5875
5876 dwarf2_per_cu_data *
5877 dw2_debug_names_iterator::next ()
5878 {
5879   if (m_addr == NULL)
5880     return NULL;
5881
5882   struct dwarf2_per_objfile *dwarf2_per_objfile = m_map.dwarf2_per_objfile;
5883   struct objfile *objfile = dwarf2_per_objfile->objfile;
5884   bfd *const abfd = objfile->obfd;
5885
5886  again:
5887
5888   unsigned int bytes_read;
5889   const ULONGEST abbrev = read_unsigned_leb128 (abfd, m_addr, &bytes_read);
5890   m_addr += bytes_read;
5891   if (abbrev == 0)
5892     return NULL;
5893
5894   const auto indexval_it = m_map.abbrev_map.find (abbrev);
5895   if (indexval_it == m_map.abbrev_map.cend ())
5896     {
5897       complaint (_("Wrong .debug_names undefined abbrev code %s "
5898                    "[in module %s]"),
5899                  pulongest (abbrev), objfile_name (objfile));
5900       return NULL;
5901     }
5902   const mapped_debug_names::index_val &indexval = indexval_it->second;
5903   bool have_is_static = false;
5904   bool is_static;
5905   dwarf2_per_cu_data *per_cu = NULL;
5906   for (const mapped_debug_names::index_val::attr &attr : indexval.attr_vec)
5907     {
5908       ULONGEST ull;
5909       switch (attr.form)
5910         {
5911         case DW_FORM_implicit_const:
5912           ull = attr.implicit_const;
5913           break;
5914         case DW_FORM_flag_present:
5915           ull = 1;
5916           break;
5917         case DW_FORM_udata:
5918           ull = read_unsigned_leb128 (abfd, m_addr, &bytes_read);
5919           m_addr += bytes_read;
5920           break;
5921         default:
5922           complaint (_("Unsupported .debug_names form %s [in module %s]"),
5923                      dwarf_form_name (attr.form),
5924                      objfile_name (objfile));
5925           return NULL;
5926         }
5927       switch (attr.dw_idx)
5928         {
5929         case DW_IDX_compile_unit:
5930           /* Don't crash on bad data.  */
5931           if (ull >= dwarf2_per_objfile->all_comp_units.size ())
5932             {
5933               complaint (_(".debug_names entry has bad CU index %s"
5934                            " [in module %s]"),
5935                          pulongest (ull),
5936                          objfile_name (dwarf2_per_objfile->objfile));
5937               continue;
5938             }
5939           per_cu = dwarf2_per_objfile->get_cutu (ull);
5940           break;
5941         case DW_IDX_type_unit:
5942           /* Don't crash on bad data.  */
5943           if (ull >= dwarf2_per_objfile->all_type_units.size ())
5944             {
5945               complaint (_(".debug_names entry has bad TU index %s"
5946                            " [in module %s]"),
5947                          pulongest (ull),
5948                          objfile_name (dwarf2_per_objfile->objfile));
5949               continue;
5950             }
5951           per_cu = &dwarf2_per_objfile->get_tu (ull)->per_cu;
5952           break;
5953         case DW_IDX_GNU_internal:
5954           if (!m_map.augmentation_is_gdb)
5955             break;
5956           have_is_static = true;
5957           is_static = true;
5958           break;
5959         case DW_IDX_GNU_external:
5960           if (!m_map.augmentation_is_gdb)
5961             break;
5962           have_is_static = true;
5963           is_static = false;
5964           break;
5965         }
5966     }
5967
5968   /* Skip if already read in.  */
5969   if (per_cu->v.quick->compunit_symtab)
5970     goto again;
5971
5972   /* Check static vs global.  */
5973   if (have_is_static)
5974     {
5975       const bool want_static = m_block_index != GLOBAL_BLOCK;
5976       if (m_want_specific_block && want_static != is_static)
5977         goto again;
5978     }
5979
5980   /* Match dw2_symtab_iter_next, symbol_kind
5981      and debug_names::psymbol_tag.  */
5982   switch (m_domain)
5983     {
5984     case VAR_DOMAIN:
5985       switch (indexval.dwarf_tag)
5986         {
5987         case DW_TAG_variable:
5988         case DW_TAG_subprogram:
5989         /* Some types are also in VAR_DOMAIN.  */
5990         case DW_TAG_typedef:
5991         case DW_TAG_structure_type:
5992           break;
5993         default:
5994           goto again;
5995         }
5996       break;
5997     case STRUCT_DOMAIN:
5998       switch (indexval.dwarf_tag)
5999         {
6000         case DW_TAG_typedef:
6001         case DW_TAG_structure_type:
6002           break;
6003         default:
6004           goto again;
6005         }
6006       break;
6007     case LABEL_DOMAIN:
6008       switch (indexval.dwarf_tag)
6009         {
6010         case 0:
6011         case DW_TAG_variable:
6012           break;
6013         default:
6014           goto again;
6015         }
6016       break;
6017     default:
6018       break;
6019     }
6020
6021   /* Match dw2_expand_symtabs_matching, symbol_kind and
6022      debug_names::psymbol_tag.  */
6023   switch (m_search)
6024     {
6025     case VARIABLES_DOMAIN:
6026       switch (indexval.dwarf_tag)
6027         {
6028         case DW_TAG_variable:
6029           break;
6030         default:
6031           goto again;
6032         }
6033       break;
6034     case FUNCTIONS_DOMAIN:
6035       switch (indexval.dwarf_tag)
6036         {
6037         case DW_TAG_subprogram:
6038           break;
6039         default:
6040           goto again;
6041         }
6042       break;
6043     case TYPES_DOMAIN:
6044       switch (indexval.dwarf_tag)
6045         {
6046         case DW_TAG_typedef:
6047         case DW_TAG_structure_type:
6048           break;
6049         default:
6050           goto again;
6051         }
6052       break;
6053     default:
6054       break;
6055     }
6056
6057   return per_cu;
6058 }
6059
6060 static struct compunit_symtab *
6061 dw2_debug_names_lookup_symbol (struct objfile *objfile, int block_index_int,
6062                                const char *name, domain_enum domain)
6063 {
6064   const block_enum block_index = static_cast<block_enum> (block_index_int);
6065   struct dwarf2_per_objfile *dwarf2_per_objfile
6066     = get_dwarf2_per_objfile (objfile);
6067
6068   const auto &mapp = dwarf2_per_objfile->debug_names_table;
6069   if (!mapp)
6070     {
6071       /* index is NULL if OBJF_READNOW.  */
6072       return NULL;
6073     }
6074   const auto &map = *mapp;
6075
6076   dw2_debug_names_iterator iter (map, true /* want_specific_block */,
6077                                  block_index, domain, name);
6078
6079   struct compunit_symtab *stab_best = NULL;
6080   struct dwarf2_per_cu_data *per_cu;
6081   while ((per_cu = iter.next ()) != NULL)
6082     {
6083       struct symbol *sym, *with_opaque = NULL;
6084       struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu, false);
6085       const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
6086       const struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
6087
6088       sym = block_find_symbol (block, name, domain,
6089                                block_find_non_opaque_type_preferred,
6090                                &with_opaque);
6091
6092       /* Some caution must be observed with overloaded functions and
6093          methods, since the index will not contain any overload
6094          information (but NAME might contain it).  */
6095
6096       if (sym != NULL
6097           && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
6098         return stab;
6099       if (with_opaque != NULL
6100           && strcmp_iw (SYMBOL_SEARCH_NAME (with_opaque), name) == 0)
6101         stab_best = stab;
6102
6103       /* Keep looking through other CUs.  */
6104     }
6105
6106   return stab_best;
6107 }
6108
6109 /* This dumps minimal information about .debug_names.  It is called
6110    via "mt print objfiles".  The gdb.dwarf2/gdb-index.exp testcase
6111    uses this to verify that .debug_names has been loaded.  */
6112
6113 static void
6114 dw2_debug_names_dump (struct objfile *objfile)
6115 {
6116   struct dwarf2_per_objfile *dwarf2_per_objfile
6117     = get_dwarf2_per_objfile (objfile);
6118
6119   gdb_assert (dwarf2_per_objfile->using_index);
6120   printf_filtered (".debug_names:");
6121   if (dwarf2_per_objfile->debug_names_table)
6122     printf_filtered (" exists\n");
6123   else
6124     printf_filtered (" faked for \"readnow\"\n");
6125   printf_filtered ("\n");
6126 }
6127
6128 static void
6129 dw2_debug_names_expand_symtabs_for_function (struct objfile *objfile,
6130                                              const char *func_name)
6131 {
6132   struct dwarf2_per_objfile *dwarf2_per_objfile
6133     = get_dwarf2_per_objfile (objfile);
6134
6135   /* dwarf2_per_objfile->debug_names_table is NULL if OBJF_READNOW.  */
6136   if (dwarf2_per_objfile->debug_names_table)
6137     {
6138       const mapped_debug_names &map = *dwarf2_per_objfile->debug_names_table;
6139
6140       /* Note: It doesn't matter what we pass for block_index here.  */
6141       dw2_debug_names_iterator iter (map, false /* want_specific_block */,
6142                                      GLOBAL_BLOCK, VAR_DOMAIN, func_name);
6143
6144       struct dwarf2_per_cu_data *per_cu;
6145       while ((per_cu = iter.next ()) != NULL)
6146         dw2_instantiate_symtab (per_cu, false);
6147     }
6148 }
6149
6150 static void
6151 dw2_debug_names_expand_symtabs_matching
6152   (struct objfile *objfile,
6153    gdb::function_view<expand_symtabs_file_matcher_ftype> file_matcher,
6154    const lookup_name_info &lookup_name,
6155    gdb::function_view<expand_symtabs_symbol_matcher_ftype> symbol_matcher,
6156    gdb::function_view<expand_symtabs_exp_notify_ftype> expansion_notify,
6157    enum search_domain kind)
6158 {
6159   struct dwarf2_per_objfile *dwarf2_per_objfile
6160     = get_dwarf2_per_objfile (objfile);
6161
6162   /* debug_names_table is NULL if OBJF_READNOW.  */
6163   if (!dwarf2_per_objfile->debug_names_table)
6164     return;
6165
6166   dw_expand_symtabs_matching_file_matcher (dwarf2_per_objfile, file_matcher);
6167
6168   mapped_debug_names &map = *dwarf2_per_objfile->debug_names_table;
6169
6170   dw2_expand_symtabs_matching_symbol (map, lookup_name,
6171                                       symbol_matcher,
6172                                       kind, [&] (offset_type namei)
6173     {
6174       /* The name was matched, now expand corresponding CUs that were
6175          marked.  */
6176       dw2_debug_names_iterator iter (map, kind, namei);
6177
6178       struct dwarf2_per_cu_data *per_cu;
6179       while ((per_cu = iter.next ()) != NULL)
6180         dw2_expand_symtabs_matching_one (per_cu, file_matcher,
6181                                          expansion_notify);
6182     });
6183 }
6184
6185 const struct quick_symbol_functions dwarf2_debug_names_functions =
6186 {
6187   dw2_has_symbols,
6188   dw2_find_last_source_symtab,
6189   dw2_forget_cached_source_info,
6190   dw2_map_symtabs_matching_filename,
6191   dw2_debug_names_lookup_symbol,
6192   dw2_print_stats,
6193   dw2_debug_names_dump,
6194   dw2_debug_names_expand_symtabs_for_function,
6195   dw2_expand_all_symtabs,
6196   dw2_expand_symtabs_with_fullname,
6197   dw2_map_matching_symbols,
6198   dw2_debug_names_expand_symtabs_matching,
6199   dw2_find_pc_sect_compunit_symtab,
6200   NULL,
6201   dw2_map_symbol_filenames
6202 };
6203
6204 /* Get the content of the .gdb_index section of OBJ.  SECTION_OWNER should point
6205    to either a dwarf2_per_objfile or dwz_file object.  */
6206
6207 template <typename T>
6208 static gdb::array_view<const gdb_byte>
6209 get_gdb_index_contents_from_section (objfile *obj, T *section_owner)
6210 {
6211   dwarf2_section_info *section = &section_owner->gdb_index;
6212
6213   if (dwarf2_section_empty_p (section))
6214     return {};
6215
6216   /* Older elfutils strip versions could keep the section in the main
6217      executable while splitting it for the separate debug info file.  */
6218   if ((get_section_flags (section) & SEC_HAS_CONTENTS) == 0)
6219     return {};
6220
6221   dwarf2_read_section (obj, section);
6222
6223   /* dwarf2_section_info::size is a bfd_size_type, while
6224      gdb::array_view works with size_t.  On 32-bit hosts, with
6225      --enable-64-bit-bfd, bfd_size_type is a 64-bit type, while size_t
6226      is 32-bit.  So we need an explicit narrowing conversion here.
6227      This is fine, because it's impossible to allocate or mmap an
6228      array/buffer larger than what size_t can represent.  */
6229   return gdb::make_array_view (section->buffer, section->size);
6230 }
6231
6232 /* Lookup the index cache for the contents of the index associated to
6233    DWARF2_OBJ.  */
6234
6235 static gdb::array_view<const gdb_byte>
6236 get_gdb_index_contents_from_cache (objfile *obj, dwarf2_per_objfile *dwarf2_obj)
6237 {
6238   const bfd_build_id *build_id = build_id_bfd_get (obj->obfd);
6239   if (build_id == nullptr)
6240     return {};
6241
6242   return global_index_cache.lookup_gdb_index (build_id,
6243                                               &dwarf2_obj->index_cache_res);
6244 }
6245
6246 /* Same as the above, but for DWZ.  */
6247
6248 static gdb::array_view<const gdb_byte>
6249 get_gdb_index_contents_from_cache_dwz (objfile *obj, dwz_file *dwz)
6250 {
6251   const bfd_build_id *build_id = build_id_bfd_get (dwz->dwz_bfd.get ());
6252   if (build_id == nullptr)
6253     return {};
6254
6255   return global_index_cache.lookup_gdb_index (build_id, &dwz->index_cache_res);
6256 }
6257
6258 /* See symfile.h.  */
6259
6260 bool
6261 dwarf2_initialize_objfile (struct objfile *objfile, dw_index_kind *index_kind)
6262 {
6263   struct dwarf2_per_objfile *dwarf2_per_objfile
6264     = get_dwarf2_per_objfile (objfile);
6265
6266   /* If we're about to read full symbols, don't bother with the
6267      indices.  In this case we also don't care if some other debug
6268      format is making psymtabs, because they are all about to be
6269      expanded anyway.  */
6270   if ((objfile->flags & OBJF_READNOW))
6271     {
6272       dwarf2_per_objfile->using_index = 1;
6273       create_all_comp_units (dwarf2_per_objfile);
6274       create_all_type_units (dwarf2_per_objfile);
6275       dwarf2_per_objfile->quick_file_names_table
6276         = create_quick_file_names_table
6277             (dwarf2_per_objfile->all_comp_units.size ());
6278
6279       for (int i = 0; i < (dwarf2_per_objfile->all_comp_units.size ()
6280                            + dwarf2_per_objfile->all_type_units.size ()); ++i)
6281         {
6282           dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
6283
6284           per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6285                                             struct dwarf2_per_cu_quick_data);
6286         }
6287
6288       /* Return 1 so that gdb sees the "quick" functions.  However,
6289          these functions will be no-ops because we will have expanded
6290          all symtabs.  */
6291       *index_kind = dw_index_kind::GDB_INDEX;
6292       return true;
6293     }
6294
6295   if (dwarf2_read_debug_names (dwarf2_per_objfile))
6296     {
6297       *index_kind = dw_index_kind::DEBUG_NAMES;
6298       return true;
6299     }
6300
6301   if (dwarf2_read_gdb_index (dwarf2_per_objfile,
6302                              get_gdb_index_contents_from_section<struct dwarf2_per_objfile>,
6303                              get_gdb_index_contents_from_section<dwz_file>))
6304     {
6305       *index_kind = dw_index_kind::GDB_INDEX;
6306       return true;
6307     }
6308
6309   /* ... otherwise, try to find the index in the index cache.  */
6310   if (dwarf2_read_gdb_index (dwarf2_per_objfile,
6311                              get_gdb_index_contents_from_cache,
6312                              get_gdb_index_contents_from_cache_dwz))
6313     {
6314       global_index_cache.hit ();
6315       *index_kind = dw_index_kind::GDB_INDEX;
6316       return true;
6317     }
6318
6319   global_index_cache.miss ();
6320   return false;
6321 }
6322
6323 \f
6324
6325 /* Build a partial symbol table.  */
6326
6327 void
6328 dwarf2_build_psymtabs (struct objfile *objfile)
6329 {
6330   struct dwarf2_per_objfile *dwarf2_per_objfile
6331     = get_dwarf2_per_objfile (objfile);
6332
6333   init_psymbol_list (objfile, 1024);
6334
6335   try
6336     {
6337       /* This isn't really ideal: all the data we allocate on the
6338          objfile's obstack is still uselessly kept around.  However,
6339          freeing it seems unsafe.  */
6340       psymtab_discarder psymtabs (objfile);
6341       dwarf2_build_psymtabs_hard (dwarf2_per_objfile);
6342       psymtabs.keep ();
6343
6344       /* (maybe) store an index in the cache.  */
6345       global_index_cache.store (dwarf2_per_objfile);
6346     }
6347   catch (const gdb_exception_error &except)
6348     {
6349       exception_print (gdb_stderr, except);
6350     }
6351 }
6352
6353 /* Return the total length of the CU described by HEADER.  */
6354
6355 static unsigned int
6356 get_cu_length (const struct comp_unit_head *header)
6357 {
6358   return header->initial_length_size + header->length;
6359 }
6360
6361 /* Return TRUE if SECT_OFF is within CU_HEADER.  */
6362
6363 static inline bool
6364 offset_in_cu_p (const comp_unit_head *cu_header, sect_offset sect_off)
6365 {
6366   sect_offset bottom = cu_header->sect_off;
6367   sect_offset top = cu_header->sect_off + get_cu_length (cu_header);
6368
6369   return sect_off >= bottom && sect_off < top;
6370 }
6371
6372 /* Find the base address of the compilation unit for range lists and
6373    location lists.  It will normally be specified by DW_AT_low_pc.
6374    In DWARF-3 draft 4, the base address could be overridden by
6375    DW_AT_entry_pc.  It's been removed, but GCC still uses this for
6376    compilation units with discontinuous ranges.  */
6377
6378 static void
6379 dwarf2_find_base_address (struct die_info *die, struct dwarf2_cu *cu)
6380 {
6381   struct attribute *attr;
6382
6383   cu->base_known = 0;
6384   cu->base_address = 0;
6385
6386   attr = dwarf2_attr (die, DW_AT_entry_pc, cu);
6387   if (attr)
6388     {
6389       cu->base_address = attr_value_as_address (attr);
6390       cu->base_known = 1;
6391     }
6392   else
6393     {
6394       attr = dwarf2_attr (die, DW_AT_low_pc, cu);
6395       if (attr)
6396         {
6397           cu->base_address = attr_value_as_address (attr);
6398           cu->base_known = 1;
6399         }
6400     }
6401 }
6402
6403 /* Read in the comp unit header information from the debug_info at info_ptr.
6404    Use rcuh_kind::COMPILE as the default type if not known by the caller.
6405    NOTE: This leaves members offset, first_die_offset to be filled in
6406    by the caller.  */
6407
6408 static const gdb_byte *
6409 read_comp_unit_head (struct comp_unit_head *cu_header,
6410                      const gdb_byte *info_ptr,
6411                      struct dwarf2_section_info *section,
6412                      rcuh_kind section_kind)
6413 {
6414   int signed_addr;
6415   unsigned int bytes_read;
6416   const char *filename = get_section_file_name (section);
6417   bfd *abfd = get_section_bfd_owner (section);
6418
6419   cu_header->length = read_initial_length (abfd, info_ptr, &bytes_read);
6420   cu_header->initial_length_size = bytes_read;
6421   cu_header->offset_size = (bytes_read == 4) ? 4 : 8;
6422   info_ptr += bytes_read;
6423   cu_header->version = read_2_bytes (abfd, info_ptr);
6424   if (cu_header->version < 2 || cu_header->version > 5)
6425     error (_("Dwarf Error: wrong version in compilation unit header "
6426            "(is %d, should be 2, 3, 4 or 5) [in module %s]"),
6427            cu_header->version, filename);
6428   info_ptr += 2;
6429   if (cu_header->version < 5)
6430     switch (section_kind)
6431       {
6432       case rcuh_kind::COMPILE:
6433         cu_header->unit_type = DW_UT_compile;
6434         break;
6435       case rcuh_kind::TYPE:
6436         cu_header->unit_type = DW_UT_type;
6437         break;
6438       default:
6439         internal_error (__FILE__, __LINE__,
6440                         _("read_comp_unit_head: invalid section_kind"));
6441       }
6442   else
6443     {
6444       cu_header->unit_type = static_cast<enum dwarf_unit_type>
6445                                                  (read_1_byte (abfd, info_ptr));
6446       info_ptr += 1;
6447       switch (cu_header->unit_type)
6448         {
6449         case DW_UT_compile:
6450           if (section_kind != rcuh_kind::COMPILE)
6451             error (_("Dwarf Error: wrong unit_type in compilation unit header "
6452                    "(is DW_UT_compile, should be DW_UT_type) [in module %s]"),
6453                    filename);
6454           break;
6455         case DW_UT_type:
6456           section_kind = rcuh_kind::TYPE;
6457           break;
6458         default:
6459           error (_("Dwarf Error: wrong unit_type in compilation unit header "
6460                  "(is %d, should be %d or %d) [in module %s]"),
6461                  cu_header->unit_type, DW_UT_compile, DW_UT_type, filename);
6462         }
6463
6464       cu_header->addr_size = read_1_byte (abfd, info_ptr);
6465       info_ptr += 1;
6466     }
6467   cu_header->abbrev_sect_off = (sect_offset) read_offset (abfd, info_ptr,
6468                                                           cu_header,
6469                                                           &bytes_read);
6470   info_ptr += bytes_read;
6471   if (cu_header->version < 5)
6472     {
6473       cu_header->addr_size = read_1_byte (abfd, info_ptr);
6474       info_ptr += 1;
6475     }
6476   signed_addr = bfd_get_sign_extend_vma (abfd);
6477   if (signed_addr < 0)
6478     internal_error (__FILE__, __LINE__,
6479                     _("read_comp_unit_head: dwarf from non elf file"));
6480   cu_header->signed_addr_p = signed_addr;
6481
6482   if (section_kind == rcuh_kind::TYPE)
6483     {
6484       LONGEST type_offset;
6485
6486       cu_header->signature = read_8_bytes (abfd, info_ptr);
6487       info_ptr += 8;
6488
6489       type_offset = read_offset (abfd, info_ptr, cu_header, &bytes_read);
6490       info_ptr += bytes_read;
6491       cu_header->type_cu_offset_in_tu = (cu_offset) type_offset;
6492       if (to_underlying (cu_header->type_cu_offset_in_tu) != type_offset)
6493         error (_("Dwarf Error: Too big type_offset in compilation unit "
6494                "header (is %s) [in module %s]"), plongest (type_offset),
6495                filename);
6496     }
6497
6498   return info_ptr;
6499 }
6500
6501 /* Helper function that returns the proper abbrev section for
6502    THIS_CU.  */
6503
6504 static struct dwarf2_section_info *
6505 get_abbrev_section_for_cu (struct dwarf2_per_cu_data *this_cu)
6506 {
6507   struct dwarf2_section_info *abbrev;
6508   struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
6509
6510   if (this_cu->is_dwz)
6511     abbrev = &dwarf2_get_dwz_file (dwarf2_per_objfile)->abbrev;
6512   else
6513     abbrev = &dwarf2_per_objfile->abbrev;
6514
6515   return abbrev;
6516 }
6517
6518 /* Subroutine of read_and_check_comp_unit_head and
6519    read_and_check_type_unit_head to simplify them.
6520    Perform various error checking on the header.  */
6521
6522 static void
6523 error_check_comp_unit_head (struct dwarf2_per_objfile *dwarf2_per_objfile,
6524                             struct comp_unit_head *header,
6525                             struct dwarf2_section_info *section,
6526                             struct dwarf2_section_info *abbrev_section)
6527 {
6528   const char *filename = get_section_file_name (section);
6529
6530   if (to_underlying (header->abbrev_sect_off)
6531       >= dwarf2_section_size (dwarf2_per_objfile->objfile, abbrev_section))
6532     error (_("Dwarf Error: bad offset (%s) in compilation unit header "
6533            "(offset %s + 6) [in module %s]"),
6534            sect_offset_str (header->abbrev_sect_off),
6535            sect_offset_str (header->sect_off),
6536            filename);
6537
6538   /* Cast to ULONGEST to use 64-bit arithmetic when possible to
6539      avoid potential 32-bit overflow.  */
6540   if (((ULONGEST) header->sect_off + get_cu_length (header))
6541       > section->size)
6542     error (_("Dwarf Error: bad length (0x%x) in compilation unit header "
6543            "(offset %s + 0) [in module %s]"),
6544            header->length, sect_offset_str (header->sect_off),
6545            filename);
6546 }
6547
6548 /* Read in a CU/TU header and perform some basic error checking.
6549    The contents of the header are stored in HEADER.
6550    The result is a pointer to the start of the first DIE.  */
6551
6552 static const gdb_byte *
6553 read_and_check_comp_unit_head (struct dwarf2_per_objfile *dwarf2_per_objfile,
6554                                struct comp_unit_head *header,
6555                                struct dwarf2_section_info *section,
6556                                struct dwarf2_section_info *abbrev_section,
6557                                const gdb_byte *info_ptr,
6558                                rcuh_kind section_kind)
6559 {
6560   const gdb_byte *beg_of_comp_unit = info_ptr;
6561
6562   header->sect_off = (sect_offset) (beg_of_comp_unit - section->buffer);
6563
6564   info_ptr = read_comp_unit_head (header, info_ptr, section, section_kind);
6565
6566   header->first_die_cu_offset = (cu_offset) (info_ptr - beg_of_comp_unit);
6567
6568   error_check_comp_unit_head (dwarf2_per_objfile, header, section,
6569                               abbrev_section);
6570
6571   return info_ptr;
6572 }
6573
6574 /* Fetch the abbreviation table offset from a comp or type unit header.  */
6575
6576 static sect_offset
6577 read_abbrev_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
6578                     struct dwarf2_section_info *section,
6579                     sect_offset sect_off)
6580 {
6581   bfd *abfd = get_section_bfd_owner (section);
6582   const gdb_byte *info_ptr;
6583   unsigned int initial_length_size, offset_size;
6584   uint16_t version;
6585
6586   dwarf2_read_section (dwarf2_per_objfile->objfile, section);
6587   info_ptr = section->buffer + to_underlying (sect_off);
6588   read_initial_length (abfd, info_ptr, &initial_length_size);
6589   offset_size = initial_length_size == 4 ? 4 : 8;
6590   info_ptr += initial_length_size;
6591
6592   version = read_2_bytes (abfd, info_ptr);
6593   info_ptr += 2;
6594   if (version >= 5)
6595     {
6596       /* Skip unit type and address size.  */
6597       info_ptr += 2;
6598     }
6599
6600   return (sect_offset) read_offset_1 (abfd, info_ptr, offset_size);
6601 }
6602
6603 /* Allocate a new partial symtab for file named NAME and mark this new
6604    partial symtab as being an include of PST.  */
6605
6606 static void
6607 dwarf2_create_include_psymtab (const char *name, struct partial_symtab *pst,
6608                                struct objfile *objfile)
6609 {
6610   struct partial_symtab *subpst = allocate_psymtab (name, objfile);
6611
6612   if (!IS_ABSOLUTE_PATH (subpst->filename))
6613     {
6614       /* It shares objfile->objfile_obstack.  */
6615       subpst->dirname = pst->dirname;
6616     }
6617
6618   subpst->dependencies = objfile->partial_symtabs->allocate_dependencies (1);
6619   subpst->dependencies[0] = pst;
6620   subpst->number_of_dependencies = 1;
6621
6622   subpst->read_symtab = pst->read_symtab;
6623
6624   /* No private part is necessary for include psymtabs.  This property
6625      can be used to differentiate between such include psymtabs and
6626      the regular ones.  */
6627   subpst->read_symtab_private = NULL;
6628 }
6629
6630 /* Read the Line Number Program data and extract the list of files
6631    included by the source file represented by PST.  Build an include
6632    partial symtab for each of these included files.  */
6633
6634 static void
6635 dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
6636                                struct die_info *die,
6637                                struct partial_symtab *pst)
6638 {
6639   line_header_up lh;
6640   struct attribute *attr;
6641
6642   attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
6643   if (attr)
6644     lh = dwarf_decode_line_header ((sect_offset) DW_UNSND (attr), cu);
6645   if (lh == NULL)
6646     return;  /* No linetable, so no includes.  */
6647
6648   /* NOTE: pst->dirname is DW_AT_comp_dir (if present).  Also note
6649      that we pass in the raw text_low here; that is ok because we're
6650      only decoding the line table to make include partial symtabs, and
6651      so the addresses aren't really used.  */
6652   dwarf_decode_lines (lh.get (), pst->dirname, cu, pst,
6653                       pst->raw_text_low (), 1);
6654 }
6655
6656 static hashval_t
6657 hash_signatured_type (const void *item)
6658 {
6659   const struct signatured_type *sig_type
6660     = (const struct signatured_type *) item;
6661
6662   /* This drops the top 32 bits of the signature, but is ok for a hash.  */
6663   return sig_type->signature;
6664 }
6665
6666 static int
6667 eq_signatured_type (const void *item_lhs, const void *item_rhs)
6668 {
6669   const struct signatured_type *lhs = (const struct signatured_type *) item_lhs;
6670   const struct signatured_type *rhs = (const struct signatured_type *) item_rhs;
6671
6672   return lhs->signature == rhs->signature;
6673 }
6674
6675 /* Allocate a hash table for signatured types.  */
6676
6677 static htab_t
6678 allocate_signatured_type_table (struct objfile *objfile)
6679 {
6680   return htab_create_alloc_ex (41,
6681                                hash_signatured_type,
6682                                eq_signatured_type,
6683                                NULL,
6684                                &objfile->objfile_obstack,
6685                                hashtab_obstack_allocate,
6686                                dummy_obstack_deallocate);
6687 }
6688
6689 /* A helper function to add a signatured type CU to a table.  */
6690
6691 static int
6692 add_signatured_type_cu_to_table (void **slot, void *datum)
6693 {
6694   struct signatured_type *sigt = (struct signatured_type *) *slot;
6695   std::vector<signatured_type *> *all_type_units
6696     = (std::vector<signatured_type *> *) datum;
6697
6698   all_type_units->push_back (sigt);
6699
6700   return 1;
6701 }
6702
6703 /* A helper for create_debug_types_hash_table.  Read types from SECTION
6704    and fill them into TYPES_HTAB.  It will process only type units,
6705    therefore DW_UT_type.  */
6706
6707 static void
6708 create_debug_type_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
6709                               struct dwo_file *dwo_file,
6710                               dwarf2_section_info *section, htab_t &types_htab,
6711                               rcuh_kind section_kind)
6712 {
6713   struct objfile *objfile = dwarf2_per_objfile->objfile;
6714   struct dwarf2_section_info *abbrev_section;
6715   bfd *abfd;
6716   const gdb_byte *info_ptr, *end_ptr;
6717
6718   abbrev_section = (dwo_file != NULL
6719                     ? &dwo_file->sections.abbrev
6720                     : &dwarf2_per_objfile->abbrev);
6721
6722   if (dwarf_read_debug)
6723     fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
6724                         get_section_name (section),
6725                         get_section_file_name (abbrev_section));
6726
6727   dwarf2_read_section (objfile, section);
6728   info_ptr = section->buffer;
6729
6730   if (info_ptr == NULL)
6731     return;
6732
6733   /* We can't set abfd until now because the section may be empty or
6734      not present, in which case the bfd is unknown.  */
6735   abfd = get_section_bfd_owner (section);
6736
6737   /* We don't use init_cutu_and_read_dies_simple, or some such, here
6738      because we don't need to read any dies: the signature is in the
6739      header.  */
6740
6741   end_ptr = info_ptr + section->size;
6742   while (info_ptr < end_ptr)
6743     {
6744       struct signatured_type *sig_type;
6745       struct dwo_unit *dwo_tu;
6746       void **slot;
6747       const gdb_byte *ptr = info_ptr;
6748       struct comp_unit_head header;
6749       unsigned int length;
6750
6751       sect_offset sect_off = (sect_offset) (ptr - section->buffer);
6752
6753       /* Initialize it due to a false compiler warning.  */
6754       header.signature = -1;
6755       header.type_cu_offset_in_tu = (cu_offset) -1;
6756
6757       /* We need to read the type's signature in order to build the hash
6758          table, but we don't need anything else just yet.  */
6759
6760       ptr = read_and_check_comp_unit_head (dwarf2_per_objfile, &header, section,
6761                                            abbrev_section, ptr, section_kind);
6762
6763       length = get_cu_length (&header);
6764
6765       /* Skip dummy type units.  */
6766       if (ptr >= info_ptr + length
6767           || peek_abbrev_code (abfd, ptr) == 0
6768           || header.unit_type != DW_UT_type)
6769         {
6770           info_ptr += length;
6771           continue;
6772         }
6773
6774       if (types_htab == NULL)
6775         {
6776           if (dwo_file)
6777             types_htab = allocate_dwo_unit_table (objfile);
6778           else
6779             types_htab = allocate_signatured_type_table (objfile);
6780         }
6781
6782       if (dwo_file)
6783         {
6784           sig_type = NULL;
6785           dwo_tu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6786                                    struct dwo_unit);
6787           dwo_tu->dwo_file = dwo_file;
6788           dwo_tu->signature = header.signature;
6789           dwo_tu->type_offset_in_tu = header.type_cu_offset_in_tu;
6790           dwo_tu->section = section;
6791           dwo_tu->sect_off = sect_off;
6792           dwo_tu->length = length;
6793         }
6794       else
6795         {
6796           /* N.B.: type_offset is not usable if this type uses a DWO file.
6797              The real type_offset is in the DWO file.  */
6798           dwo_tu = NULL;
6799           sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6800                                      struct signatured_type);
6801           sig_type->signature = header.signature;
6802           sig_type->type_offset_in_tu = header.type_cu_offset_in_tu;
6803           sig_type->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
6804           sig_type->per_cu.is_debug_types = 1;
6805           sig_type->per_cu.section = section;
6806           sig_type->per_cu.sect_off = sect_off;
6807           sig_type->per_cu.length = length;
6808         }
6809
6810       slot = htab_find_slot (types_htab,
6811                              dwo_file ? (void*) dwo_tu : (void *) sig_type,
6812                              INSERT);
6813       gdb_assert (slot != NULL);
6814       if (*slot != NULL)
6815         {
6816           sect_offset dup_sect_off;
6817
6818           if (dwo_file)
6819             {
6820               const struct dwo_unit *dup_tu
6821                 = (const struct dwo_unit *) *slot;
6822
6823               dup_sect_off = dup_tu->sect_off;
6824             }
6825           else
6826             {
6827               const struct signatured_type *dup_tu
6828                 = (const struct signatured_type *) *slot;
6829
6830               dup_sect_off = dup_tu->per_cu.sect_off;
6831             }
6832
6833           complaint (_("debug type entry at offset %s is duplicate to"
6834                        " the entry at offset %s, signature %s"),
6835                      sect_offset_str (sect_off), sect_offset_str (dup_sect_off),
6836                      hex_string (header.signature));
6837         }
6838       *slot = dwo_file ? (void *) dwo_tu : (void *) sig_type;
6839
6840       if (dwarf_read_debug > 1)
6841         fprintf_unfiltered (gdb_stdlog, "  offset %s, signature %s\n",
6842                             sect_offset_str (sect_off),
6843                             hex_string (header.signature));
6844
6845       info_ptr += length;
6846     }
6847 }
6848
6849 /* Create the hash table of all entries in the .debug_types
6850    (or .debug_types.dwo) section(s).
6851    If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
6852    otherwise it is NULL.
6853
6854    The result is a pointer to the hash table or NULL if there are no types.
6855
6856    Note: This function processes DWO files only, not DWP files.  */
6857
6858 static void
6859 create_debug_types_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
6860                                struct dwo_file *dwo_file,
6861                                VEC (dwarf2_section_info_def) *types,
6862                                htab_t &types_htab)
6863 {
6864   int ix;
6865   struct dwarf2_section_info *section;
6866
6867   if (VEC_empty (dwarf2_section_info_def, types))
6868     return;
6869
6870   for (ix = 0;
6871        VEC_iterate (dwarf2_section_info_def, types, ix, section);
6872        ++ix)
6873     create_debug_type_hash_table (dwarf2_per_objfile, dwo_file, section,
6874                                   types_htab, rcuh_kind::TYPE);
6875 }
6876
6877 /* Create the hash table of all entries in the .debug_types section,
6878    and initialize all_type_units.
6879    The result is zero if there is an error (e.g. missing .debug_types section),
6880    otherwise non-zero.  */
6881
6882 static int
6883 create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
6884 {
6885   htab_t types_htab = NULL;
6886
6887   create_debug_type_hash_table (dwarf2_per_objfile, NULL,
6888                                 &dwarf2_per_objfile->info, types_htab,
6889                                 rcuh_kind::COMPILE);
6890   create_debug_types_hash_table (dwarf2_per_objfile, NULL,
6891                                  dwarf2_per_objfile->types, types_htab);
6892   if (types_htab == NULL)
6893     {
6894       dwarf2_per_objfile->signatured_types = NULL;
6895       return 0;
6896     }
6897
6898   dwarf2_per_objfile->signatured_types = types_htab;
6899
6900   gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
6901   dwarf2_per_objfile->all_type_units.reserve (htab_elements (types_htab));
6902
6903   htab_traverse_noresize (types_htab, add_signatured_type_cu_to_table,
6904                           &dwarf2_per_objfile->all_type_units);
6905
6906   return 1;
6907 }
6908
6909 /* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
6910    If SLOT is non-NULL, it is the entry to use in the hash table.
6911    Otherwise we find one.  */
6912
6913 static struct signatured_type *
6914 add_type_unit (struct dwarf2_per_objfile *dwarf2_per_objfile, ULONGEST sig,
6915                void **slot)
6916 {
6917   struct objfile *objfile = dwarf2_per_objfile->objfile;
6918
6919   if (dwarf2_per_objfile->all_type_units.size ()
6920       == dwarf2_per_objfile->all_type_units.capacity ())
6921     ++dwarf2_per_objfile->tu_stats.nr_all_type_units_reallocs;
6922
6923   signatured_type *sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
6924                                               struct signatured_type);
6925
6926   dwarf2_per_objfile->all_type_units.push_back (sig_type);
6927   sig_type->signature = sig;
6928   sig_type->per_cu.is_debug_types = 1;
6929   if (dwarf2_per_objfile->using_index)
6930     {
6931       sig_type->per_cu.v.quick =
6932         OBSTACK_ZALLOC (&objfile->objfile_obstack,
6933                         struct dwarf2_per_cu_quick_data);
6934     }
6935
6936   if (slot == NULL)
6937     {
6938       slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
6939                              sig_type, INSERT);
6940     }
6941   gdb_assert (*slot == NULL);
6942   *slot = sig_type;
6943   /* The rest of sig_type must be filled in by the caller.  */
6944   return sig_type;
6945 }
6946
6947 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
6948    Fill in SIG_ENTRY with DWO_ENTRY.  */
6949
6950 static void
6951 fill_in_sig_entry_from_dwo_entry (struct dwarf2_per_objfile *dwarf2_per_objfile,
6952                                   struct signatured_type *sig_entry,
6953                                   struct dwo_unit *dwo_entry)
6954 {
6955   /* Make sure we're not clobbering something we don't expect to.  */
6956   gdb_assert (! sig_entry->per_cu.queued);
6957   gdb_assert (sig_entry->per_cu.cu == NULL);
6958   if (dwarf2_per_objfile->using_index)
6959     {
6960       gdb_assert (sig_entry->per_cu.v.quick != NULL);
6961       gdb_assert (sig_entry->per_cu.v.quick->compunit_symtab == NULL);
6962     }
6963   else
6964       gdb_assert (sig_entry->per_cu.v.psymtab == NULL);
6965   gdb_assert (sig_entry->signature == dwo_entry->signature);
6966   gdb_assert (to_underlying (sig_entry->type_offset_in_section) == 0);
6967   gdb_assert (sig_entry->type_unit_group == NULL);
6968   gdb_assert (sig_entry->dwo_unit == NULL);
6969
6970   sig_entry->per_cu.section = dwo_entry->section;
6971   sig_entry->per_cu.sect_off = dwo_entry->sect_off;
6972   sig_entry->per_cu.length = dwo_entry->length;
6973   sig_entry->per_cu.reading_dwo_directly = 1;
6974   sig_entry->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
6975   sig_entry->type_offset_in_tu = dwo_entry->type_offset_in_tu;
6976   sig_entry->dwo_unit = dwo_entry;
6977 }
6978
6979 /* Subroutine of lookup_signatured_type.
6980    If we haven't read the TU yet, create the signatured_type data structure
6981    for a TU to be read in directly from a DWO file, bypassing the stub.
6982    This is the "Stay in DWO Optimization": When there is no DWP file and we're
6983    using .gdb_index, then when reading a CU we want to stay in the DWO file
6984    containing that CU.  Otherwise we could end up reading several other DWO
6985    files (due to comdat folding) to process the transitive closure of all the
6986    mentioned TUs, and that can be slow.  The current DWO file will have every
6987    type signature that it needs.
6988    We only do this for .gdb_index because in the psymtab case we already have
6989    to read all the DWOs to build the type unit groups.  */
6990
6991 static struct signatured_type *
6992 lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
6993 {
6994   struct dwarf2_per_objfile *dwarf2_per_objfile
6995     = cu->per_cu->dwarf2_per_objfile;
6996   struct objfile *objfile = dwarf2_per_objfile->objfile;
6997   struct dwo_file *dwo_file;
6998   struct dwo_unit find_dwo_entry, *dwo_entry;
6999   struct signatured_type find_sig_entry, *sig_entry;
7000   void **slot;
7001
7002   gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
7003
7004   /* If TU skeletons have been removed then we may not have read in any
7005      TUs yet.  */
7006   if (dwarf2_per_objfile->signatured_types == NULL)
7007     {
7008       dwarf2_per_objfile->signatured_types
7009         = allocate_signatured_type_table (objfile);
7010     }
7011
7012   /* We only ever need to read in one copy of a signatured type.
7013      Use the global signatured_types array to do our own comdat-folding
7014      of types.  If this is the first time we're reading this TU, and
7015      the TU has an entry in .gdb_index, replace the recorded data from
7016      .gdb_index with this TU.  */
7017
7018   find_sig_entry.signature = sig;
7019   slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
7020                          &find_sig_entry, INSERT);
7021   sig_entry = (struct signatured_type *) *slot;
7022
7023   /* We can get here with the TU already read, *or* in the process of being
7024      read.  Don't reassign the global entry to point to this DWO if that's
7025      the case.  Also note that if the TU is already being read, it may not
7026      have come from a DWO, the program may be a mix of Fission-compiled
7027      code and non-Fission-compiled code.  */
7028
7029   /* Have we already tried to read this TU?
7030      Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7031      needn't exist in the global table yet).  */
7032   if (sig_entry != NULL && sig_entry->per_cu.tu_read)
7033     return sig_entry;
7034
7035   /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
7036      dwo_unit of the TU itself.  */
7037   dwo_file = cu->dwo_unit->dwo_file;
7038
7039   /* Ok, this is the first time we're reading this TU.  */
7040   if (dwo_file->tus == NULL)
7041     return NULL;
7042   find_dwo_entry.signature = sig;
7043   dwo_entry = (struct dwo_unit *) htab_find (dwo_file->tus, &find_dwo_entry);
7044   if (dwo_entry == NULL)
7045     return NULL;
7046
7047   /* If the global table doesn't have an entry for this TU, add one.  */
7048   if (sig_entry == NULL)
7049     sig_entry = add_type_unit (dwarf2_per_objfile, sig, slot);
7050
7051   fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, sig_entry, dwo_entry);
7052   sig_entry->per_cu.tu_read = 1;
7053   return sig_entry;
7054 }
7055
7056 /* Subroutine of lookup_signatured_type.
7057    Look up the type for signature SIG, and if we can't find SIG in .gdb_index
7058    then try the DWP file.  If the TU stub (skeleton) has been removed then
7059    it won't be in .gdb_index.  */
7060
7061 static struct signatured_type *
7062 lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
7063 {
7064   struct dwarf2_per_objfile *dwarf2_per_objfile
7065     = cu->per_cu->dwarf2_per_objfile;
7066   struct objfile *objfile = dwarf2_per_objfile->objfile;
7067   struct dwp_file *dwp_file = get_dwp_file (dwarf2_per_objfile);
7068   struct dwo_unit *dwo_entry;
7069   struct signatured_type find_sig_entry, *sig_entry;
7070   void **slot;
7071
7072   gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
7073   gdb_assert (dwp_file != NULL);
7074
7075   /* If TU skeletons have been removed then we may not have read in any
7076      TUs yet.  */
7077   if (dwarf2_per_objfile->signatured_types == NULL)
7078     {
7079       dwarf2_per_objfile->signatured_types
7080         = allocate_signatured_type_table (objfile);
7081     }
7082
7083   find_sig_entry.signature = sig;
7084   slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
7085                          &find_sig_entry, INSERT);
7086   sig_entry = (struct signatured_type *) *slot;
7087
7088   /* Have we already tried to read this TU?
7089      Note: sig_entry can be NULL if the skeleton TU was removed (thus it
7090      needn't exist in the global table yet).  */
7091   if (sig_entry != NULL)
7092     return sig_entry;
7093
7094   if (dwp_file->tus == NULL)
7095     return NULL;
7096   dwo_entry = lookup_dwo_unit_in_dwp (dwarf2_per_objfile, dwp_file, NULL,
7097                                       sig, 1 /* is_debug_types */);
7098   if (dwo_entry == NULL)
7099     return NULL;
7100
7101   sig_entry = add_type_unit (dwarf2_per_objfile, sig, slot);
7102   fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, sig_entry, dwo_entry);
7103
7104   return sig_entry;
7105 }
7106
7107 /* Lookup a signature based type for DW_FORM_ref_sig8.
7108    Returns NULL if signature SIG is not present in the table.
7109    It is up to the caller to complain about this.  */
7110
7111 static struct signatured_type *
7112 lookup_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
7113 {
7114   struct dwarf2_per_objfile *dwarf2_per_objfile
7115     = cu->per_cu->dwarf2_per_objfile;
7116
7117   if (cu->dwo_unit
7118       && dwarf2_per_objfile->using_index)
7119     {
7120       /* We're in a DWO/DWP file, and we're using .gdb_index.
7121          These cases require special processing.  */
7122       if (get_dwp_file (dwarf2_per_objfile) == NULL)
7123         return lookup_dwo_signatured_type (cu, sig);
7124       else
7125         return lookup_dwp_signatured_type (cu, sig);
7126     }
7127   else
7128     {
7129       struct signatured_type find_entry, *entry;
7130
7131       if (dwarf2_per_objfile->signatured_types == NULL)
7132         return NULL;
7133       find_entry.signature = sig;
7134       entry = ((struct signatured_type *)
7135                htab_find (dwarf2_per_objfile->signatured_types, &find_entry));
7136       return entry;
7137     }
7138 }
7139 \f
7140 /* Low level DIE reading support.  */
7141
7142 /* Initialize a die_reader_specs struct from a dwarf2_cu struct.  */
7143
7144 static void
7145 init_cu_die_reader (struct die_reader_specs *reader,
7146                     struct dwarf2_cu *cu,
7147                     struct dwarf2_section_info *section,
7148                     struct dwo_file *dwo_file,
7149                     struct abbrev_table *abbrev_table)
7150 {
7151   gdb_assert (section->readin && section->buffer != NULL);
7152   reader->abfd = get_section_bfd_owner (section);
7153   reader->cu = cu;
7154   reader->dwo_file = dwo_file;
7155   reader->die_section = section;
7156   reader->buffer = section->buffer;
7157   reader->buffer_end = section->buffer + section->size;
7158   reader->comp_dir = NULL;
7159   reader->abbrev_table = abbrev_table;
7160 }
7161
7162 /* Subroutine of init_cutu_and_read_dies to simplify it.
7163    Read in the rest of a CU/TU top level DIE from DWO_UNIT.
7164    There's just a lot of work to do, and init_cutu_and_read_dies is big enough
7165    already.
7166
7167    STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
7168    from it to the DIE in the DWO.  If NULL we are skipping the stub.
7169    STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
7170    from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
7171    attribute of the referencing CU.  At most one of STUB_COMP_UNIT_DIE and
7172    STUB_COMP_DIR may be non-NULL.
7173    *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
7174    are filled in with the info of the DIE from the DWO file.
7175    *RESULT_DWO_ABBREV_TABLE will be filled in with the abbrev table allocated
7176    from the dwo.  Since *RESULT_READER references this abbrev table, it must be
7177    kept around for at least as long as *RESULT_READER.
7178
7179    The result is non-zero if a valid (non-dummy) DIE was found.  */
7180
7181 static int
7182 read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu,
7183                         struct dwo_unit *dwo_unit,
7184                         struct die_info *stub_comp_unit_die,
7185                         const char *stub_comp_dir,
7186                         struct die_reader_specs *result_reader,
7187                         const gdb_byte **result_info_ptr,
7188                         struct die_info **result_comp_unit_die,
7189                         int *result_has_children,
7190                         abbrev_table_up *result_dwo_abbrev_table)
7191 {
7192   struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7193   struct objfile *objfile = dwarf2_per_objfile->objfile;
7194   struct dwarf2_cu *cu = this_cu->cu;
7195   bfd *abfd;
7196   const gdb_byte *begin_info_ptr, *info_ptr;
7197   struct attribute *comp_dir, *stmt_list, *low_pc, *high_pc, *ranges;
7198   int i,num_extra_attrs;
7199   struct dwarf2_section_info *dwo_abbrev_section;
7200   struct attribute *attr;
7201   struct die_info *comp_unit_die;
7202
7203   /* At most one of these may be provided.  */
7204   gdb_assert ((stub_comp_unit_die != NULL) + (stub_comp_dir != NULL) <= 1);
7205
7206   /* These attributes aren't processed until later:
7207      DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
7208      DW_AT_comp_dir is used now, to find the DWO file, but it is also
7209      referenced later.  However, these attributes are found in the stub
7210      which we won't have later.  In order to not impose this complication
7211      on the rest of the code, we read them here and copy them to the
7212      DWO CU/TU die.  */
7213
7214   stmt_list = NULL;
7215   low_pc = NULL;
7216   high_pc = NULL;
7217   ranges = NULL;
7218   comp_dir = NULL;
7219
7220   if (stub_comp_unit_die != NULL)
7221     {
7222       /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
7223          DWO file.  */
7224       if (! this_cu->is_debug_types)
7225         stmt_list = dwarf2_attr (stub_comp_unit_die, DW_AT_stmt_list, cu);
7226       low_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_low_pc, cu);
7227       high_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_high_pc, cu);
7228       ranges = dwarf2_attr (stub_comp_unit_die, DW_AT_ranges, cu);
7229       comp_dir = dwarf2_attr (stub_comp_unit_die, DW_AT_comp_dir, cu);
7230
7231       /* There should be a DW_AT_addr_base attribute here (if needed).
7232          We need the value before we can process DW_FORM_GNU_addr_index.  */
7233       cu->addr_base = 0;
7234       attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_addr_base, cu);
7235       if (attr)
7236         cu->addr_base = DW_UNSND (attr);
7237
7238       /* There should be a DW_AT_ranges_base attribute here (if needed).
7239          We need the value before we can process DW_AT_ranges.  */
7240       cu->ranges_base = 0;
7241       attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_ranges_base, cu);
7242       if (attr)
7243         cu->ranges_base = DW_UNSND (attr);
7244     }
7245   else if (stub_comp_dir != NULL)
7246     {
7247       /* Reconstruct the comp_dir attribute to simplify the code below.  */
7248       comp_dir = XOBNEW (&cu->comp_unit_obstack, struct attribute);
7249       comp_dir->name = DW_AT_comp_dir;
7250       comp_dir->form = DW_FORM_string;
7251       DW_STRING_IS_CANONICAL (comp_dir) = 0;
7252       DW_STRING (comp_dir) = stub_comp_dir;
7253     }
7254
7255   /* Set up for reading the DWO CU/TU.  */
7256   cu->dwo_unit = dwo_unit;
7257   dwarf2_section_info *section = dwo_unit->section;
7258   dwarf2_read_section (objfile, section);
7259   abfd = get_section_bfd_owner (section);
7260   begin_info_ptr = info_ptr = (section->buffer
7261                                + to_underlying (dwo_unit->sect_off));
7262   dwo_abbrev_section = &dwo_unit->dwo_file->sections.abbrev;
7263
7264   if (this_cu->is_debug_types)
7265     {
7266       struct signatured_type *sig_type = (struct signatured_type *) this_cu;
7267
7268       info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7269                                                 &cu->header, section,
7270                                                 dwo_abbrev_section,
7271                                                 info_ptr, rcuh_kind::TYPE);
7272       /* This is not an assert because it can be caused by bad debug info.  */
7273       if (sig_type->signature != cu->header.signature)
7274         {
7275           error (_("Dwarf Error: signature mismatch %s vs %s while reading"
7276                    " TU at offset %s [in module %s]"),
7277                  hex_string (sig_type->signature),
7278                  hex_string (cu->header.signature),
7279                  sect_offset_str (dwo_unit->sect_off),
7280                  bfd_get_filename (abfd));
7281         }
7282       gdb_assert (dwo_unit->sect_off == cu->header.sect_off);
7283       /* For DWOs coming from DWP files, we don't know the CU length
7284          nor the type's offset in the TU until now.  */
7285       dwo_unit->length = get_cu_length (&cu->header);
7286       dwo_unit->type_offset_in_tu = cu->header.type_cu_offset_in_tu;
7287
7288       /* Establish the type offset that can be used to lookup the type.
7289          For DWO files, we don't know it until now.  */
7290       sig_type->type_offset_in_section
7291         = dwo_unit->sect_off + to_underlying (dwo_unit->type_offset_in_tu);
7292     }
7293   else
7294     {
7295       info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7296                                                 &cu->header, section,
7297                                                 dwo_abbrev_section,
7298                                                 info_ptr, rcuh_kind::COMPILE);
7299       gdb_assert (dwo_unit->sect_off == cu->header.sect_off);
7300       /* For DWOs coming from DWP files, we don't know the CU length
7301          until now.  */
7302       dwo_unit->length = get_cu_length (&cu->header);
7303     }
7304
7305   *result_dwo_abbrev_table
7306     = abbrev_table_read_table (dwarf2_per_objfile, dwo_abbrev_section,
7307                                cu->header.abbrev_sect_off);
7308   init_cu_die_reader (result_reader, cu, section, dwo_unit->dwo_file,
7309                       result_dwo_abbrev_table->get ());
7310
7311   /* Read in the die, but leave space to copy over the attributes
7312      from the stub.  This has the benefit of simplifying the rest of
7313      the code - all the work to maintain the illusion of a single
7314      DW_TAG_{compile,type}_unit DIE is done here.  */
7315   num_extra_attrs = ((stmt_list != NULL)
7316                      + (low_pc != NULL)
7317                      + (high_pc != NULL)
7318                      + (ranges != NULL)
7319                      + (comp_dir != NULL));
7320   info_ptr = read_full_die_1 (result_reader, result_comp_unit_die, info_ptr,
7321                               result_has_children, num_extra_attrs);
7322
7323   /* Copy over the attributes from the stub to the DIE we just read in.  */
7324   comp_unit_die = *result_comp_unit_die;
7325   i = comp_unit_die->num_attrs;
7326   if (stmt_list != NULL)
7327     comp_unit_die->attrs[i++] = *stmt_list;
7328   if (low_pc != NULL)
7329     comp_unit_die->attrs[i++] = *low_pc;
7330   if (high_pc != NULL)
7331     comp_unit_die->attrs[i++] = *high_pc;
7332   if (ranges != NULL)
7333     comp_unit_die->attrs[i++] = *ranges;
7334   if (comp_dir != NULL)
7335     comp_unit_die->attrs[i++] = *comp_dir;
7336   comp_unit_die->num_attrs += num_extra_attrs;
7337
7338   if (dwarf_die_debug)
7339     {
7340       fprintf_unfiltered (gdb_stdlog,
7341                           "Read die from %s@0x%x of %s:\n",
7342                           get_section_name (section),
7343                           (unsigned) (begin_info_ptr - section->buffer),
7344                           bfd_get_filename (abfd));
7345       dump_die (comp_unit_die, dwarf_die_debug);
7346     }
7347
7348   /* Save the comp_dir attribute.  If there is no DWP file then we'll read
7349      TUs by skipping the stub and going directly to the entry in the DWO file.
7350      However, skipping the stub means we won't get DW_AT_comp_dir, so we have
7351      to get it via circuitous means.  Blech.  */
7352   if (comp_dir != NULL)
7353     result_reader->comp_dir = DW_STRING (comp_dir);
7354
7355   /* Skip dummy compilation units.  */
7356   if (info_ptr >= begin_info_ptr + dwo_unit->length
7357       || peek_abbrev_code (abfd, info_ptr) == 0)
7358     return 0;
7359
7360   *result_info_ptr = info_ptr;
7361   return 1;
7362 }
7363
7364 /* Subroutine of init_cutu_and_read_dies to simplify it.
7365    Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
7366    Returns NULL if the specified DWO unit cannot be found.  */
7367
7368 static struct dwo_unit *
7369 lookup_dwo_unit (struct dwarf2_per_cu_data *this_cu,
7370                  struct die_info *comp_unit_die)
7371 {
7372   struct dwarf2_cu *cu = this_cu->cu;
7373   ULONGEST signature;
7374   struct dwo_unit *dwo_unit;
7375   const char *comp_dir, *dwo_name;
7376
7377   gdb_assert (cu != NULL);
7378
7379   /* Yeah, we look dwo_name up again, but it simplifies the code.  */
7380   dwo_name = dwarf2_string_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
7381   comp_dir = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
7382
7383   if (this_cu->is_debug_types)
7384     {
7385       struct signatured_type *sig_type;
7386
7387       /* Since this_cu is the first member of struct signatured_type,
7388          we can go from a pointer to one to a pointer to the other.  */
7389       sig_type = (struct signatured_type *) this_cu;
7390       signature = sig_type->signature;
7391       dwo_unit = lookup_dwo_type_unit (sig_type, dwo_name, comp_dir);
7392     }
7393   else
7394     {
7395       struct attribute *attr;
7396
7397       attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
7398       if (! attr)
7399         error (_("Dwarf Error: missing dwo_id for dwo_name %s"
7400                  " [in module %s]"),
7401                dwo_name, objfile_name (this_cu->dwarf2_per_objfile->objfile));
7402       signature = DW_UNSND (attr);
7403       dwo_unit = lookup_dwo_comp_unit (this_cu, dwo_name, comp_dir,
7404                                        signature);
7405     }
7406
7407   return dwo_unit;
7408 }
7409
7410 /* Subroutine of init_cutu_and_read_dies to simplify it.
7411    See it for a description of the parameters.
7412    Read a TU directly from a DWO file, bypassing the stub.  */
7413
7414 static void
7415 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data *this_cu,
7416                            int use_existing_cu, int keep,
7417                            die_reader_func_ftype *die_reader_func,
7418                            void *data)
7419 {
7420   std::unique_ptr<dwarf2_cu> new_cu;
7421   struct signatured_type *sig_type;
7422   struct die_reader_specs reader;
7423   const gdb_byte *info_ptr;
7424   struct die_info *comp_unit_die;
7425   int has_children;
7426   struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7427
7428   /* Verify we can do the following downcast, and that we have the
7429      data we need.  */
7430   gdb_assert (this_cu->is_debug_types && this_cu->reading_dwo_directly);
7431   sig_type = (struct signatured_type *) this_cu;
7432   gdb_assert (sig_type->dwo_unit != NULL);
7433
7434   if (use_existing_cu && this_cu->cu != NULL)
7435     {
7436       gdb_assert (this_cu->cu->dwo_unit == sig_type->dwo_unit);
7437       /* There's no need to do the rereading_dwo_cu handling that
7438          init_cutu_and_read_dies does since we don't read the stub.  */
7439     }
7440   else
7441     {
7442       /* If !use_existing_cu, this_cu->cu must be NULL.  */
7443       gdb_assert (this_cu->cu == NULL);
7444       new_cu.reset (new dwarf2_cu (this_cu));
7445     }
7446
7447   /* A future optimization, if needed, would be to use an existing
7448      abbrev table.  When reading DWOs with skeletonless TUs, all the TUs
7449      could share abbrev tables.  */
7450
7451   /* The abbreviation table used by READER, this must live at least as long as
7452      READER.  */
7453   abbrev_table_up dwo_abbrev_table;
7454
7455   if (read_cutu_die_from_dwo (this_cu, sig_type->dwo_unit,
7456                               NULL /* stub_comp_unit_die */,
7457                               sig_type->dwo_unit->dwo_file->comp_dir,
7458                               &reader, &info_ptr,
7459                               &comp_unit_die, &has_children,
7460                               &dwo_abbrev_table) == 0)
7461     {
7462       /* Dummy die.  */
7463       return;
7464     }
7465
7466   /* All the "real" work is done here.  */
7467   die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7468
7469   /* This duplicates the code in init_cutu_and_read_dies,
7470      but the alternative is making the latter more complex.
7471      This function is only for the special case of using DWO files directly:
7472      no point in overly complicating the general case just to handle this.  */
7473   if (new_cu != NULL && keep)
7474     {
7475       /* Link this CU into read_in_chain.  */
7476       this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
7477       dwarf2_per_objfile->read_in_chain = this_cu;
7478       /* The chain owns it now.  */
7479       new_cu.release ();
7480     }
7481 }
7482
7483 /* Initialize a CU (or TU) and read its DIEs.
7484    If the CU defers to a DWO file, read the DWO file as well.
7485
7486    ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
7487    Otherwise the table specified in the comp unit header is read in and used.
7488    This is an optimization for when we already have the abbrev table.
7489
7490    If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
7491    Otherwise, a new CU is allocated with xmalloc.
7492
7493    If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
7494    read_in_chain.  Otherwise the dwarf2_cu data is freed at the end.
7495
7496    WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7497    linker) then DIE_READER_FUNC will not get called.  */
7498
7499 static void
7500 init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu,
7501                          struct abbrev_table *abbrev_table,
7502                          int use_existing_cu, int keep,
7503                          bool skip_partial,
7504                          die_reader_func_ftype *die_reader_func,
7505                          void *data)
7506 {
7507   struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7508   struct objfile *objfile = dwarf2_per_objfile->objfile;
7509   struct dwarf2_section_info *section = this_cu->section;
7510   bfd *abfd = get_section_bfd_owner (section);
7511   struct dwarf2_cu *cu;
7512   const gdb_byte *begin_info_ptr, *info_ptr;
7513   struct die_reader_specs reader;
7514   struct die_info *comp_unit_die;
7515   int has_children;
7516   struct attribute *attr;
7517   struct signatured_type *sig_type = NULL;
7518   struct dwarf2_section_info *abbrev_section;
7519   /* Non-zero if CU currently points to a DWO file and we need to
7520      reread it.  When this happens we need to reread the skeleton die
7521      before we can reread the DWO file (this only applies to CUs, not TUs).  */
7522   int rereading_dwo_cu = 0;
7523
7524   if (dwarf_die_debug)
7525     fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset %s\n",
7526                         this_cu->is_debug_types ? "type" : "comp",
7527                         sect_offset_str (this_cu->sect_off));
7528
7529   if (use_existing_cu)
7530     gdb_assert (keep);
7531
7532   /* If we're reading a TU directly from a DWO file, including a virtual DWO
7533      file (instead of going through the stub), short-circuit all of this.  */
7534   if (this_cu->reading_dwo_directly)
7535     {
7536       /* Narrow down the scope of possibilities to have to understand.  */
7537       gdb_assert (this_cu->is_debug_types);
7538       gdb_assert (abbrev_table == NULL);
7539       init_tu_and_read_dwo_dies (this_cu, use_existing_cu, keep,
7540                                  die_reader_func, data);
7541       return;
7542     }
7543
7544   /* This is cheap if the section is already read in.  */
7545   dwarf2_read_section (objfile, section);
7546
7547   begin_info_ptr = info_ptr = section->buffer + to_underlying (this_cu->sect_off);
7548
7549   abbrev_section = get_abbrev_section_for_cu (this_cu);
7550
7551   std::unique_ptr<dwarf2_cu> new_cu;
7552   if (use_existing_cu && this_cu->cu != NULL)
7553     {
7554       cu = this_cu->cu;
7555       /* If this CU is from a DWO file we need to start over, we need to
7556          refetch the attributes from the skeleton CU.
7557          This could be optimized by retrieving those attributes from when we
7558          were here the first time: the previous comp_unit_die was stored in
7559          comp_unit_obstack.  But there's no data yet that we need this
7560          optimization.  */
7561       if (cu->dwo_unit != NULL)
7562         rereading_dwo_cu = 1;
7563     }
7564   else
7565     {
7566       /* If !use_existing_cu, this_cu->cu must be NULL.  */
7567       gdb_assert (this_cu->cu == NULL);
7568       new_cu.reset (new dwarf2_cu (this_cu));
7569       cu = new_cu.get ();
7570     }
7571
7572   /* Get the header.  */
7573   if (to_underlying (cu->header.first_die_cu_offset) != 0 && !rereading_dwo_cu)
7574     {
7575       /* We already have the header, there's no need to read it in again.  */
7576       info_ptr += to_underlying (cu->header.first_die_cu_offset);
7577     }
7578   else
7579     {
7580       if (this_cu->is_debug_types)
7581         {
7582           info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7583                                                     &cu->header, section,
7584                                                     abbrev_section, info_ptr,
7585                                                     rcuh_kind::TYPE);
7586
7587           /* Since per_cu is the first member of struct signatured_type,
7588              we can go from a pointer to one to a pointer to the other.  */
7589           sig_type = (struct signatured_type *) this_cu;
7590           gdb_assert (sig_type->signature == cu->header.signature);
7591           gdb_assert (sig_type->type_offset_in_tu
7592                       == cu->header.type_cu_offset_in_tu);
7593           gdb_assert (this_cu->sect_off == cu->header.sect_off);
7594
7595           /* LENGTH has not been set yet for type units if we're
7596              using .gdb_index.  */
7597           this_cu->length = get_cu_length (&cu->header);
7598
7599           /* Establish the type offset that can be used to lookup the type.  */
7600           sig_type->type_offset_in_section =
7601             this_cu->sect_off + to_underlying (sig_type->type_offset_in_tu);
7602
7603           this_cu->dwarf_version = cu->header.version;
7604         }
7605       else
7606         {
7607           info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7608                                                     &cu->header, section,
7609                                                     abbrev_section,
7610                                                     info_ptr,
7611                                                     rcuh_kind::COMPILE);
7612
7613           gdb_assert (this_cu->sect_off == cu->header.sect_off);
7614           gdb_assert (this_cu->length == get_cu_length (&cu->header));
7615           this_cu->dwarf_version = cu->header.version;
7616         }
7617     }
7618
7619   /* Skip dummy compilation units.  */
7620   if (info_ptr >= begin_info_ptr + this_cu->length
7621       || peek_abbrev_code (abfd, info_ptr) == 0)
7622     return;
7623
7624   /* If we don't have them yet, read the abbrevs for this compilation unit.
7625      And if we need to read them now, make sure they're freed when we're
7626      done (own the table through ABBREV_TABLE_HOLDER).  */
7627   abbrev_table_up abbrev_table_holder;
7628   if (abbrev_table != NULL)
7629     gdb_assert (cu->header.abbrev_sect_off == abbrev_table->sect_off);
7630   else
7631     {
7632       abbrev_table_holder
7633         = abbrev_table_read_table (dwarf2_per_objfile, abbrev_section,
7634                                    cu->header.abbrev_sect_off);
7635       abbrev_table = abbrev_table_holder.get ();
7636     }
7637
7638   /* Read the top level CU/TU die.  */
7639   init_cu_die_reader (&reader, cu, section, NULL, abbrev_table);
7640   info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
7641
7642   if (skip_partial && comp_unit_die->tag == DW_TAG_partial_unit)
7643     return;
7644
7645   /* If we are in a DWO stub, process it and then read in the "real" CU/TU
7646      from the DWO file.  read_cutu_die_from_dwo will allocate the abbreviation
7647      table from the DWO file and pass the ownership over to us.  It will be
7648      referenced from READER, so we must make sure to free it after we're done
7649      with READER.
7650
7651      Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
7652      DWO CU, that this test will fail (the attribute will not be present).  */
7653   attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
7654   abbrev_table_up dwo_abbrev_table;
7655   if (attr)
7656     {
7657       struct dwo_unit *dwo_unit;
7658       struct die_info *dwo_comp_unit_die;
7659
7660       if (has_children)
7661         {
7662           complaint (_("compilation unit with DW_AT_GNU_dwo_name"
7663                        " has children (offset %s) [in module %s]"),
7664                      sect_offset_str (this_cu->sect_off),
7665                      bfd_get_filename (abfd));
7666         }
7667       dwo_unit = lookup_dwo_unit (this_cu, comp_unit_die);
7668       if (dwo_unit != NULL)
7669         {
7670           if (read_cutu_die_from_dwo (this_cu, dwo_unit,
7671                                       comp_unit_die, NULL,
7672                                       &reader, &info_ptr,
7673                                       &dwo_comp_unit_die, &has_children,
7674                                       &dwo_abbrev_table) == 0)
7675             {
7676               /* Dummy die.  */
7677               return;
7678             }
7679           comp_unit_die = dwo_comp_unit_die;
7680         }
7681       else
7682         {
7683           /* Yikes, we couldn't find the rest of the DIE, we only have
7684              the stub.  A complaint has already been logged.  There's
7685              not much more we can do except pass on the stub DIE to
7686              die_reader_func.  We don't want to throw an error on bad
7687              debug info.  */
7688         }
7689     }
7690
7691   /* All of the above is setup for this call.  Yikes.  */
7692   die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7693
7694   /* Done, clean up.  */
7695   if (new_cu != NULL && keep)
7696     {
7697       /* Link this CU into read_in_chain.  */
7698       this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
7699       dwarf2_per_objfile->read_in_chain = this_cu;
7700       /* The chain owns it now.  */
7701       new_cu.release ();
7702     }
7703 }
7704
7705 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
7706    DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
7707    to have already done the lookup to find the DWO file).
7708
7709    The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
7710    THIS_CU->is_debug_types, but nothing else.
7711
7712    We fill in THIS_CU->length.
7713
7714    WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
7715    linker) then DIE_READER_FUNC will not get called.
7716
7717    THIS_CU->cu is always freed when done.
7718    This is done in order to not leave THIS_CU->cu in a state where we have
7719    to care whether it refers to the "main" CU or the DWO CU.  */
7720
7721 static void
7722 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data *this_cu,
7723                                    struct dwo_file *dwo_file,
7724                                    die_reader_func_ftype *die_reader_func,
7725                                    void *data)
7726 {
7727   struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
7728   struct objfile *objfile = dwarf2_per_objfile->objfile;
7729   struct dwarf2_section_info *section = this_cu->section;
7730   bfd *abfd = get_section_bfd_owner (section);
7731   struct dwarf2_section_info *abbrev_section;
7732   const gdb_byte *begin_info_ptr, *info_ptr;
7733   struct die_reader_specs reader;
7734   struct die_info *comp_unit_die;
7735   int has_children;
7736
7737   if (dwarf_die_debug)
7738     fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset %s\n",
7739                         this_cu->is_debug_types ? "type" : "comp",
7740                         sect_offset_str (this_cu->sect_off));
7741
7742   gdb_assert (this_cu->cu == NULL);
7743
7744   abbrev_section = (dwo_file != NULL
7745                     ? &dwo_file->sections.abbrev
7746                     : get_abbrev_section_for_cu (this_cu));
7747
7748   /* This is cheap if the section is already read in.  */
7749   dwarf2_read_section (objfile, section);
7750
7751   struct dwarf2_cu cu (this_cu);
7752
7753   begin_info_ptr = info_ptr = section->buffer + to_underlying (this_cu->sect_off);
7754   info_ptr = read_and_check_comp_unit_head (dwarf2_per_objfile,
7755                                             &cu.header, section,
7756                                             abbrev_section, info_ptr,
7757                                             (this_cu->is_debug_types
7758                                              ? rcuh_kind::TYPE
7759                                              : rcuh_kind::COMPILE));
7760
7761   this_cu->length = get_cu_length (&cu.header);
7762
7763   /* Skip dummy compilation units.  */
7764   if (info_ptr >= begin_info_ptr + this_cu->length
7765       || peek_abbrev_code (abfd, info_ptr) == 0)
7766     return;
7767
7768   abbrev_table_up abbrev_table
7769     = abbrev_table_read_table (dwarf2_per_objfile, abbrev_section,
7770                                cu.header.abbrev_sect_off);
7771
7772   init_cu_die_reader (&reader, &cu, section, dwo_file, abbrev_table.get ());
7773   info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
7774
7775   die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
7776 }
7777
7778 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
7779    does not lookup the specified DWO file.
7780    This cannot be used to read DWO files.
7781
7782    THIS_CU->cu is always freed when done.
7783    This is done in order to not leave THIS_CU->cu in a state where we have
7784    to care whether it refers to the "main" CU or the DWO CU.
7785    We can revisit this if the data shows there's a performance issue.  */
7786
7787 static void
7788 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data *this_cu,
7789                                 die_reader_func_ftype *die_reader_func,
7790                                 void *data)
7791 {
7792   init_cutu_and_read_dies_no_follow (this_cu, NULL, die_reader_func, data);
7793 }
7794 \f
7795 /* Type Unit Groups.
7796
7797    Type Unit Groups are a way to collapse the set of all TUs (type units) into
7798    a more manageable set.  The grouping is done by DW_AT_stmt_list entry
7799    so that all types coming from the same compilation (.o file) are grouped
7800    together.  A future step could be to put the types in the same symtab as
7801    the CU the types ultimately came from.  */
7802
7803 static hashval_t
7804 hash_type_unit_group (const void *item)
7805 {
7806   const struct type_unit_group *tu_group
7807     = (const struct type_unit_group *) item;
7808
7809   return hash_stmt_list_entry (&tu_group->hash);
7810 }
7811
7812 static int
7813 eq_type_unit_group (const void *item_lhs, const void *item_rhs)
7814 {
7815   const struct type_unit_group *lhs = (const struct type_unit_group *) item_lhs;
7816   const struct type_unit_group *rhs = (const struct type_unit_group *) item_rhs;
7817
7818   return eq_stmt_list_entry (&lhs->hash, &rhs->hash);
7819 }
7820
7821 /* Allocate a hash table for type unit groups.  */
7822
7823 static htab_t
7824 allocate_type_unit_groups_table (struct objfile *objfile)
7825 {
7826   return htab_create_alloc_ex (3,
7827                                hash_type_unit_group,
7828                                eq_type_unit_group,
7829                                NULL,
7830                                &objfile->objfile_obstack,
7831                                hashtab_obstack_allocate,
7832                                dummy_obstack_deallocate);
7833 }
7834
7835 /* Type units that don't have DW_AT_stmt_list are grouped into their own
7836    partial symtabs.  We combine several TUs per psymtab to not let the size
7837    of any one psymtab grow too big.  */
7838 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
7839 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
7840
7841 /* Helper routine for get_type_unit_group.
7842    Create the type_unit_group object used to hold one or more TUs.  */
7843
7844 static struct type_unit_group *
7845 create_type_unit_group (struct dwarf2_cu *cu, sect_offset line_offset_struct)
7846 {
7847   struct dwarf2_per_objfile *dwarf2_per_objfile
7848     = cu->per_cu->dwarf2_per_objfile;
7849   struct objfile *objfile = dwarf2_per_objfile->objfile;
7850   struct dwarf2_per_cu_data *per_cu;
7851   struct type_unit_group *tu_group;
7852
7853   tu_group = OBSTACK_ZALLOC (&objfile->objfile_obstack,
7854                              struct type_unit_group);
7855   per_cu = &tu_group->per_cu;
7856   per_cu->dwarf2_per_objfile = dwarf2_per_objfile;
7857
7858   if (dwarf2_per_objfile->using_index)
7859     {
7860       per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
7861                                         struct dwarf2_per_cu_quick_data);
7862     }
7863   else
7864     {
7865       unsigned int line_offset = to_underlying (line_offset_struct);
7866       struct partial_symtab *pst;
7867       std::string name;
7868
7869       /* Give the symtab a useful name for debug purposes.  */
7870       if ((line_offset & NO_STMT_LIST_TYPE_UNIT_PSYMTAB) != 0)
7871         name = string_printf ("<type_units_%d>",
7872                               (line_offset & ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB));
7873       else
7874         name = string_printf ("<type_units_at_0x%x>", line_offset);
7875
7876       pst = create_partial_symtab (per_cu, name.c_str ());
7877       pst->anonymous = 1;
7878     }
7879
7880   tu_group->hash.dwo_unit = cu->dwo_unit;
7881   tu_group->hash.line_sect_off = line_offset_struct;
7882
7883   return tu_group;
7884 }
7885
7886 /* Look up the type_unit_group for type unit CU, and create it if necessary.
7887    STMT_LIST is a DW_AT_stmt_list attribute.  */
7888
7889 static struct type_unit_group *
7890 get_type_unit_group (struct dwarf2_cu *cu, const struct attribute *stmt_list)
7891 {
7892   struct dwarf2_per_objfile *dwarf2_per_objfile
7893     = cu->per_cu->dwarf2_per_objfile;
7894   struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
7895   struct type_unit_group *tu_group;
7896   void **slot;
7897   unsigned int line_offset;
7898   struct type_unit_group type_unit_group_for_lookup;
7899
7900   if (dwarf2_per_objfile->type_unit_groups == NULL)
7901     {
7902       dwarf2_per_objfile->type_unit_groups =
7903         allocate_type_unit_groups_table (dwarf2_per_objfile->objfile);
7904     }
7905
7906   /* Do we need to create a new group, or can we use an existing one?  */
7907
7908   if (stmt_list)
7909     {
7910       line_offset = DW_UNSND (stmt_list);
7911       ++tu_stats->nr_symtab_sharers;
7912     }
7913   else
7914     {
7915       /* Ugh, no stmt_list.  Rare, but we have to handle it.
7916          We can do various things here like create one group per TU or
7917          spread them over multiple groups to split up the expansion work.
7918          To avoid worst case scenarios (too many groups or too large groups)
7919          we, umm, group them in bunches.  */
7920       line_offset = (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
7921                      | (tu_stats->nr_stmt_less_type_units
7922                         / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE));
7923       ++tu_stats->nr_stmt_less_type_units;
7924     }
7925
7926   type_unit_group_for_lookup.hash.dwo_unit = cu->dwo_unit;
7927   type_unit_group_for_lookup.hash.line_sect_off = (sect_offset) line_offset;
7928   slot = htab_find_slot (dwarf2_per_objfile->type_unit_groups,
7929                          &type_unit_group_for_lookup, INSERT);
7930   if (*slot != NULL)
7931     {
7932       tu_group = (struct type_unit_group *) *slot;
7933       gdb_assert (tu_group != NULL);
7934     }
7935   else
7936     {
7937       sect_offset line_offset_struct = (sect_offset) line_offset;
7938       tu_group = create_type_unit_group (cu, line_offset_struct);
7939       *slot = tu_group;
7940       ++tu_stats->nr_symtabs;
7941     }
7942
7943   return tu_group;
7944 }
7945 \f
7946 /* Partial symbol tables.  */
7947
7948 /* Create a psymtab named NAME and assign it to PER_CU.
7949
7950    The caller must fill in the following details:
7951    dirname, textlow, texthigh.  */
7952
7953 static struct partial_symtab *
7954 create_partial_symtab (struct dwarf2_per_cu_data *per_cu, const char *name)
7955 {
7956   struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
7957   struct partial_symtab *pst;
7958
7959   pst = start_psymtab_common (objfile, name, 0);
7960
7961   pst->psymtabs_addrmap_supported = 1;
7962
7963   /* This is the glue that links PST into GDB's symbol API.  */
7964   pst->read_symtab_private = per_cu;
7965   pst->read_symtab = dwarf2_read_symtab;
7966   per_cu->v.psymtab = pst;
7967
7968   return pst;
7969 }
7970
7971 /* The DATA object passed to process_psymtab_comp_unit_reader has this
7972    type.  */
7973
7974 struct process_psymtab_comp_unit_data
7975 {
7976   /* True if we are reading a DW_TAG_partial_unit.  */
7977
7978   int want_partial_unit;
7979
7980   /* The "pretend" language that is used if the CU doesn't declare a
7981      language.  */
7982
7983   enum language pretend_language;
7984 };
7985
7986 /* die_reader_func for process_psymtab_comp_unit.  */
7987
7988 static void
7989 process_psymtab_comp_unit_reader (const struct die_reader_specs *reader,
7990                                   const gdb_byte *info_ptr,
7991                                   struct die_info *comp_unit_die,
7992                                   int has_children,
7993                                   void *data)
7994 {
7995   struct dwarf2_cu *cu = reader->cu;
7996   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
7997   struct gdbarch *gdbarch = get_objfile_arch (objfile);
7998   struct dwarf2_per_cu_data *per_cu = cu->per_cu;
7999   CORE_ADDR baseaddr;
8000   CORE_ADDR best_lowpc = 0, best_highpc = 0;
8001   struct partial_symtab *pst;
8002   enum pc_bounds_kind cu_bounds_kind;
8003   const char *filename;
8004   struct process_psymtab_comp_unit_data *info
8005     = (struct process_psymtab_comp_unit_data *) data;
8006
8007   if (comp_unit_die->tag == DW_TAG_partial_unit && !info->want_partial_unit)
8008     return;
8009
8010   gdb_assert (! per_cu->is_debug_types);
8011
8012   prepare_one_comp_unit (cu, comp_unit_die, info->pretend_language);
8013
8014   /* Allocate a new partial symbol table structure.  */
8015   filename = dwarf2_string_attr (comp_unit_die, DW_AT_name, cu);
8016   if (filename == NULL)
8017     filename = "";
8018
8019   pst = create_partial_symtab (per_cu, filename);
8020
8021   /* This must be done before calling dwarf2_build_include_psymtabs.  */
8022   pst->dirname = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
8023
8024   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
8025
8026   dwarf2_find_base_address (comp_unit_die, cu);
8027
8028   /* Possibly set the default values of LOWPC and HIGHPC from
8029      `DW_AT_ranges'.  */
8030   cu_bounds_kind = dwarf2_get_pc_bounds (comp_unit_die, &best_lowpc,
8031                                          &best_highpc, cu, pst);
8032   if (cu_bounds_kind == PC_BOUNDS_HIGH_LOW && best_lowpc < best_highpc)
8033     {
8034       CORE_ADDR low
8035         = (gdbarch_adjust_dwarf2_addr (gdbarch, best_lowpc + baseaddr)
8036            - baseaddr);
8037       CORE_ADDR high
8038         = (gdbarch_adjust_dwarf2_addr (gdbarch, best_highpc + baseaddr)
8039            - baseaddr - 1);
8040       /* Store the contiguous range if it is not empty; it can be
8041          empty for CUs with no code.  */
8042       addrmap_set_empty (objfile->partial_symtabs->psymtabs_addrmap,
8043                          low, high, pst);
8044     }
8045
8046   /* Check if comp unit has_children.
8047      If so, read the rest of the partial symbols from this comp unit.
8048      If not, there's no more debug_info for this comp unit.  */
8049   if (has_children)
8050     {
8051       struct partial_die_info *first_die;
8052       CORE_ADDR lowpc, highpc;
8053
8054       lowpc = ((CORE_ADDR) -1);
8055       highpc = ((CORE_ADDR) 0);
8056
8057       first_die = load_partial_dies (reader, info_ptr, 1);
8058
8059       scan_partial_symbols (first_die, &lowpc, &highpc,
8060                             cu_bounds_kind <= PC_BOUNDS_INVALID, cu);
8061
8062       /* If we didn't find a lowpc, set it to highpc to avoid
8063          complaints from `maint check'.  */
8064       if (lowpc == ((CORE_ADDR) -1))
8065         lowpc = highpc;
8066
8067       /* If the compilation unit didn't have an explicit address range,
8068          then use the information extracted from its child dies.  */
8069       if (cu_bounds_kind <= PC_BOUNDS_INVALID)
8070         {
8071           best_lowpc = lowpc;
8072           best_highpc = highpc;
8073         }
8074     }
8075   pst->set_text_low (gdbarch_adjust_dwarf2_addr (gdbarch,
8076                                                  best_lowpc + baseaddr)
8077                      - baseaddr);
8078   pst->set_text_high (gdbarch_adjust_dwarf2_addr (gdbarch,
8079                                                   best_highpc + baseaddr)
8080                       - baseaddr);
8081
8082   end_psymtab_common (objfile, pst);
8083
8084   if (!VEC_empty (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs))
8085     {
8086       int i;
8087       int len = VEC_length (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
8088       struct dwarf2_per_cu_data *iter;
8089
8090       /* Fill in 'dependencies' here; we fill in 'users' in a
8091          post-pass.  */
8092       pst->number_of_dependencies = len;
8093       pst->dependencies
8094         = objfile->partial_symtabs->allocate_dependencies (len);
8095       for (i = 0;
8096            VEC_iterate (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
8097                         i, iter);
8098            ++i)
8099         pst->dependencies[i] = iter->v.psymtab;
8100
8101       VEC_free (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
8102     }
8103
8104   /* Get the list of files included in the current compilation unit,
8105      and build a psymtab for each of them.  */
8106   dwarf2_build_include_psymtabs (cu, comp_unit_die, pst);
8107
8108   if (dwarf_read_debug)
8109     fprintf_unfiltered (gdb_stdlog,
8110                         "Psymtab for %s unit @%s: %s - %s"
8111                         ", %d global, %d static syms\n",
8112                         per_cu->is_debug_types ? "type" : "comp",
8113                         sect_offset_str (per_cu->sect_off),
8114                         paddress (gdbarch, pst->text_low (objfile)),
8115                         paddress (gdbarch, pst->text_high (objfile)),
8116                         pst->n_global_syms, pst->n_static_syms);
8117 }
8118
8119 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8120    Process compilation unit THIS_CU for a psymtab.  */
8121
8122 static void
8123 process_psymtab_comp_unit (struct dwarf2_per_cu_data *this_cu,
8124                            int want_partial_unit,
8125                            enum language pretend_language)
8126 {
8127   /* If this compilation unit was already read in, free the
8128      cached copy in order to read it in again.  This is
8129      necessary because we skipped some symbols when we first
8130      read in the compilation unit (see load_partial_dies).
8131      This problem could be avoided, but the benefit is unclear.  */
8132   if (this_cu->cu != NULL)
8133     free_one_cached_comp_unit (this_cu);
8134
8135   if (this_cu->is_debug_types)
8136     init_cutu_and_read_dies (this_cu, NULL, 0, 0, false,
8137                              build_type_psymtabs_reader, NULL);
8138   else
8139     {
8140       process_psymtab_comp_unit_data info;
8141       info.want_partial_unit = want_partial_unit;
8142       info.pretend_language = pretend_language;
8143       init_cutu_and_read_dies (this_cu, NULL, 0, 0, false,
8144                                process_psymtab_comp_unit_reader, &info);
8145     }
8146
8147   /* Age out any secondary CUs.  */
8148   age_cached_comp_units (this_cu->dwarf2_per_objfile);
8149 }
8150
8151 /* Reader function for build_type_psymtabs.  */
8152
8153 static void
8154 build_type_psymtabs_reader (const struct die_reader_specs *reader,
8155                             const gdb_byte *info_ptr,
8156                             struct die_info *type_unit_die,
8157                             int has_children,
8158                             void *data)
8159 {
8160   struct dwarf2_per_objfile *dwarf2_per_objfile
8161     = reader->cu->per_cu->dwarf2_per_objfile;
8162   struct objfile *objfile = dwarf2_per_objfile->objfile;
8163   struct dwarf2_cu *cu = reader->cu;
8164   struct dwarf2_per_cu_data *per_cu = cu->per_cu;
8165   struct signatured_type *sig_type;
8166   struct type_unit_group *tu_group;
8167   struct attribute *attr;
8168   struct partial_die_info *first_die;
8169   CORE_ADDR lowpc, highpc;
8170   struct partial_symtab *pst;
8171
8172   gdb_assert (data == NULL);
8173   gdb_assert (per_cu->is_debug_types);
8174   sig_type = (struct signatured_type *) per_cu;
8175
8176   if (! has_children)
8177     return;
8178
8179   attr = dwarf2_attr_no_follow (type_unit_die, DW_AT_stmt_list);
8180   tu_group = get_type_unit_group (cu, attr);
8181
8182   VEC_safe_push (sig_type_ptr, tu_group->tus, sig_type);
8183
8184   prepare_one_comp_unit (cu, type_unit_die, language_minimal);
8185   pst = create_partial_symtab (per_cu, "");
8186   pst->anonymous = 1;
8187
8188   first_die = load_partial_dies (reader, info_ptr, 1);
8189
8190   lowpc = (CORE_ADDR) -1;
8191   highpc = (CORE_ADDR) 0;
8192   scan_partial_symbols (first_die, &lowpc, &highpc, 0, cu);
8193
8194   end_psymtab_common (objfile, pst);
8195 }
8196
8197 /* Struct used to sort TUs by their abbreviation table offset.  */
8198
8199 struct tu_abbrev_offset
8200 {
8201   tu_abbrev_offset (signatured_type *sig_type_, sect_offset abbrev_offset_)
8202   : sig_type (sig_type_), abbrev_offset (abbrev_offset_)
8203   {}
8204
8205   signatured_type *sig_type;
8206   sect_offset abbrev_offset;
8207 };
8208
8209 /* Helper routine for build_type_psymtabs_1, passed to std::sort.  */
8210
8211 static bool
8212 sort_tu_by_abbrev_offset (const struct tu_abbrev_offset &a,
8213                           const struct tu_abbrev_offset &b)
8214 {
8215   return a.abbrev_offset < b.abbrev_offset;
8216 }
8217
8218 /* Efficiently read all the type units.
8219    This does the bulk of the work for build_type_psymtabs.
8220
8221    The efficiency is because we sort TUs by the abbrev table they use and
8222    only read each abbrev table once.  In one program there are 200K TUs
8223    sharing 8K abbrev tables.
8224
8225    The main purpose of this function is to support building the
8226    dwarf2_per_objfile->type_unit_groups table.
8227    TUs typically share the DW_AT_stmt_list of the CU they came from, so we
8228    can collapse the search space by grouping them by stmt_list.
8229    The savings can be significant, in the same program from above the 200K TUs
8230    share 8K stmt_list tables.
8231
8232    FUNC is expected to call get_type_unit_group, which will create the
8233    struct type_unit_group if necessary and add it to
8234    dwarf2_per_objfile->type_unit_groups.  */
8235
8236 static void
8237 build_type_psymtabs_1 (struct dwarf2_per_objfile *dwarf2_per_objfile)
8238 {
8239   struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
8240   abbrev_table_up abbrev_table;
8241   sect_offset abbrev_offset;
8242
8243   /* It's up to the caller to not call us multiple times.  */
8244   gdb_assert (dwarf2_per_objfile->type_unit_groups == NULL);
8245
8246   if (dwarf2_per_objfile->all_type_units.empty ())
8247     return;
8248
8249   /* TUs typically share abbrev tables, and there can be way more TUs than
8250      abbrev tables.  Sort by abbrev table to reduce the number of times we
8251      read each abbrev table in.
8252      Alternatives are to punt or to maintain a cache of abbrev tables.
8253      This is simpler and efficient enough for now.
8254
8255      Later we group TUs by their DW_AT_stmt_list value (as this defines the
8256      symtab to use).  Typically TUs with the same abbrev offset have the same
8257      stmt_list value too so in practice this should work well.
8258
8259      The basic algorithm here is:
8260
8261       sort TUs by abbrev table
8262       for each TU with same abbrev table:
8263         read abbrev table if first user
8264         read TU top level DIE
8265           [IWBN if DWO skeletons had DW_AT_stmt_list]
8266         call FUNC  */
8267
8268   if (dwarf_read_debug)
8269     fprintf_unfiltered (gdb_stdlog, "Building type unit groups ...\n");
8270
8271   /* Sort in a separate table to maintain the order of all_type_units
8272      for .gdb_index: TU indices directly index all_type_units.  */
8273   std::vector<tu_abbrev_offset> sorted_by_abbrev;
8274   sorted_by_abbrev.reserve (dwarf2_per_objfile->all_type_units.size ());
8275
8276   for (signatured_type *sig_type : dwarf2_per_objfile->all_type_units)
8277     sorted_by_abbrev.emplace_back
8278       (sig_type, read_abbrev_offset (dwarf2_per_objfile,
8279                                      sig_type->per_cu.section,
8280                                      sig_type->per_cu.sect_off));
8281
8282   std::sort (sorted_by_abbrev.begin (), sorted_by_abbrev.end (),
8283              sort_tu_by_abbrev_offset);
8284
8285   abbrev_offset = (sect_offset) ~(unsigned) 0;
8286
8287   for (const tu_abbrev_offset &tu : sorted_by_abbrev)
8288     {
8289       /* Switch to the next abbrev table if necessary.  */
8290       if (abbrev_table == NULL
8291           || tu.abbrev_offset != abbrev_offset)
8292         {
8293           abbrev_offset = tu.abbrev_offset;
8294           abbrev_table =
8295             abbrev_table_read_table (dwarf2_per_objfile,
8296                                      &dwarf2_per_objfile->abbrev,
8297                                      abbrev_offset);
8298           ++tu_stats->nr_uniq_abbrev_tables;
8299         }
8300
8301       init_cutu_and_read_dies (&tu.sig_type->per_cu, abbrev_table.get (),
8302                                0, 0, false, build_type_psymtabs_reader, NULL);
8303     }
8304 }
8305
8306 /* Print collected type unit statistics.  */
8307
8308 static void
8309 print_tu_stats (struct dwarf2_per_objfile *dwarf2_per_objfile)
8310 {
8311   struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
8312
8313   fprintf_unfiltered (gdb_stdlog, "Type unit statistics:\n");
8314   fprintf_unfiltered (gdb_stdlog, "  %zu TUs\n",
8315                       dwarf2_per_objfile->all_type_units.size ());
8316   fprintf_unfiltered (gdb_stdlog, "  %d uniq abbrev tables\n",
8317                       tu_stats->nr_uniq_abbrev_tables);
8318   fprintf_unfiltered (gdb_stdlog, "  %d symtabs from stmt_list entries\n",
8319                       tu_stats->nr_symtabs);
8320   fprintf_unfiltered (gdb_stdlog, "  %d symtab sharers\n",
8321                       tu_stats->nr_symtab_sharers);
8322   fprintf_unfiltered (gdb_stdlog, "  %d type units without a stmt_list\n",
8323                       tu_stats->nr_stmt_less_type_units);
8324   fprintf_unfiltered (gdb_stdlog, "  %d all_type_units reallocs\n",
8325                       tu_stats->nr_all_type_units_reallocs);
8326 }
8327
8328 /* Traversal function for build_type_psymtabs.  */
8329
8330 static int
8331 build_type_psymtab_dependencies (void **slot, void *info)
8332 {
8333   struct dwarf2_per_objfile *dwarf2_per_objfile
8334     = (struct dwarf2_per_objfile *) info;
8335   struct objfile *objfile = dwarf2_per_objfile->objfile;
8336   struct type_unit_group *tu_group = (struct type_unit_group *) *slot;
8337   struct dwarf2_per_cu_data *per_cu = &tu_group->per_cu;
8338   struct partial_symtab *pst = per_cu->v.psymtab;
8339   int len = VEC_length (sig_type_ptr, tu_group->tus);
8340   struct signatured_type *iter;
8341   int i;
8342
8343   gdb_assert (len > 0);
8344   gdb_assert (IS_TYPE_UNIT_GROUP (per_cu));
8345
8346   pst->number_of_dependencies = len;
8347   pst->dependencies = objfile->partial_symtabs->allocate_dependencies (len);
8348   for (i = 0;
8349        VEC_iterate (sig_type_ptr, tu_group->tus, i, iter);
8350        ++i)
8351     {
8352       gdb_assert (iter->per_cu.is_debug_types);
8353       pst->dependencies[i] = iter->per_cu.v.psymtab;
8354       iter->type_unit_group = tu_group;
8355     }
8356
8357   VEC_free (sig_type_ptr, tu_group->tus);
8358
8359   return 1;
8360 }
8361
8362 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
8363    Build partial symbol tables for the .debug_types comp-units.  */
8364
8365 static void
8366 build_type_psymtabs (struct dwarf2_per_objfile *dwarf2_per_objfile)
8367 {
8368   if (! create_all_type_units (dwarf2_per_objfile))
8369     return;
8370
8371   build_type_psymtabs_1 (dwarf2_per_objfile);
8372 }
8373
8374 /* Traversal function for process_skeletonless_type_unit.
8375    Read a TU in a DWO file and build partial symbols for it.  */
8376
8377 static int
8378 process_skeletonless_type_unit (void **slot, void *info)
8379 {
8380   struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
8381   struct dwarf2_per_objfile *dwarf2_per_objfile
8382     = (struct dwarf2_per_objfile *) info;
8383   struct signatured_type find_entry, *entry;
8384
8385   /* If this TU doesn't exist in the global table, add it and read it in.  */
8386
8387   if (dwarf2_per_objfile->signatured_types == NULL)
8388     {
8389       dwarf2_per_objfile->signatured_types
8390         = allocate_signatured_type_table (dwarf2_per_objfile->objfile);
8391     }
8392
8393   find_entry.signature = dwo_unit->signature;
8394   slot = htab_find_slot (dwarf2_per_objfile->signatured_types, &find_entry,
8395                          INSERT);
8396   /* If we've already seen this type there's nothing to do.  What's happening
8397      is we're doing our own version of comdat-folding here.  */
8398   if (*slot != NULL)
8399     return 1;
8400
8401   /* This does the job that create_all_type_units would have done for
8402      this TU.  */
8403   entry = add_type_unit (dwarf2_per_objfile, dwo_unit->signature, slot);
8404   fill_in_sig_entry_from_dwo_entry (dwarf2_per_objfile, entry, dwo_unit);
8405   *slot = entry;
8406
8407   /* This does the job that build_type_psymtabs_1 would have done.  */
8408   init_cutu_and_read_dies (&entry->per_cu, NULL, 0, 0, false,
8409                            build_type_psymtabs_reader, NULL);
8410
8411   return 1;
8412 }
8413
8414 /* Traversal function for process_skeletonless_type_units.  */
8415
8416 static int
8417 process_dwo_file_for_skeletonless_type_units (void **slot, void *info)
8418 {
8419   struct dwo_file *dwo_file = (struct dwo_file *) *slot;
8420
8421   if (dwo_file->tus != NULL)
8422     {
8423       htab_traverse_noresize (dwo_file->tus,
8424                               process_skeletonless_type_unit, info);
8425     }
8426
8427   return 1;
8428 }
8429
8430 /* Scan all TUs of DWO files, verifying we've processed them.
8431    This is needed in case a TU was emitted without its skeleton.
8432    Note: This can't be done until we know what all the DWO files are.  */
8433
8434 static void
8435 process_skeletonless_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
8436 {
8437   /* Skeletonless TUs in DWP files without .gdb_index is not supported yet.  */
8438   if (get_dwp_file (dwarf2_per_objfile) == NULL
8439       && dwarf2_per_objfile->dwo_files != NULL)
8440     {
8441       htab_traverse_noresize (dwarf2_per_objfile->dwo_files,
8442                               process_dwo_file_for_skeletonless_type_units,
8443                               dwarf2_per_objfile);
8444     }
8445 }
8446
8447 /* Compute the 'user' field for each psymtab in DWARF2_PER_OBJFILE.  */
8448
8449 static void
8450 set_partial_user (struct dwarf2_per_objfile *dwarf2_per_objfile)
8451 {
8452   for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
8453     {
8454       struct partial_symtab *pst = per_cu->v.psymtab;
8455
8456       if (pst == NULL)
8457         continue;
8458
8459       for (int j = 0; j < pst->number_of_dependencies; ++j)
8460         {
8461           /* Set the 'user' field only if it is not already set.  */
8462           if (pst->dependencies[j]->user == NULL)
8463             pst->dependencies[j]->user = pst;
8464         }
8465     }
8466 }
8467
8468 /* Build the partial symbol table by doing a quick pass through the
8469    .debug_info and .debug_abbrev sections.  */
8470
8471 static void
8472 dwarf2_build_psymtabs_hard (struct dwarf2_per_objfile *dwarf2_per_objfile)
8473 {
8474   struct objfile *objfile = dwarf2_per_objfile->objfile;
8475
8476   if (dwarf_read_debug)
8477     {
8478       fprintf_unfiltered (gdb_stdlog, "Building psymtabs of objfile %s ...\n",
8479                           objfile_name (objfile));
8480     }
8481
8482   dwarf2_per_objfile->reading_partial_symbols = 1;
8483
8484   dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
8485
8486   /* Any cached compilation units will be linked by the per-objfile
8487      read_in_chain.  Make sure to free them when we're done.  */
8488   free_cached_comp_units freer (dwarf2_per_objfile);
8489
8490   build_type_psymtabs (dwarf2_per_objfile);
8491
8492   create_all_comp_units (dwarf2_per_objfile);
8493
8494   /* Create a temporary address map on a temporary obstack.  We later
8495      copy this to the final obstack.  */
8496   auto_obstack temp_obstack;
8497
8498   scoped_restore save_psymtabs_addrmap
8499     = make_scoped_restore (&objfile->partial_symtabs->psymtabs_addrmap,
8500                            addrmap_create_mutable (&temp_obstack));
8501
8502   for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
8503     process_psymtab_comp_unit (per_cu, 0, language_minimal);
8504
8505   /* This has to wait until we read the CUs, we need the list of DWOs.  */
8506   process_skeletonless_type_units (dwarf2_per_objfile);
8507
8508   /* Now that all TUs have been processed we can fill in the dependencies.  */
8509   if (dwarf2_per_objfile->type_unit_groups != NULL)
8510     {
8511       htab_traverse_noresize (dwarf2_per_objfile->type_unit_groups,
8512                               build_type_psymtab_dependencies, dwarf2_per_objfile);
8513     }
8514
8515   if (dwarf_read_debug)
8516     print_tu_stats (dwarf2_per_objfile);
8517
8518   set_partial_user (dwarf2_per_objfile);
8519
8520   objfile->partial_symtabs->psymtabs_addrmap
8521     = addrmap_create_fixed (objfile->partial_symtabs->psymtabs_addrmap,
8522                             objfile->partial_symtabs->obstack ());
8523   /* At this point we want to keep the address map.  */
8524   save_psymtabs_addrmap.release ();
8525
8526   if (dwarf_read_debug)
8527     fprintf_unfiltered (gdb_stdlog, "Done building psymtabs of %s\n",
8528                         objfile_name (objfile));
8529 }
8530
8531 /* die_reader_func for load_partial_comp_unit.  */
8532
8533 static void
8534 load_partial_comp_unit_reader (const struct die_reader_specs *reader,
8535                                const gdb_byte *info_ptr,
8536                                struct die_info *comp_unit_die,
8537                                int has_children,
8538                                void *data)
8539 {
8540   struct dwarf2_cu *cu = reader->cu;
8541
8542   prepare_one_comp_unit (cu, comp_unit_die, language_minimal);
8543
8544   /* Check if comp unit has_children.
8545      If so, read the rest of the partial symbols from this comp unit.
8546      If not, there's no more debug_info for this comp unit.  */
8547   if (has_children)
8548     load_partial_dies (reader, info_ptr, 0);
8549 }
8550
8551 /* Load the partial DIEs for a secondary CU into memory.
8552    This is also used when rereading a primary CU with load_all_dies.  */
8553
8554 static void
8555 load_partial_comp_unit (struct dwarf2_per_cu_data *this_cu)
8556 {
8557   init_cutu_and_read_dies (this_cu, NULL, 1, 1, false,
8558                            load_partial_comp_unit_reader, NULL);
8559 }
8560
8561 static void
8562 read_comp_units_from_section (struct dwarf2_per_objfile *dwarf2_per_objfile,
8563                               struct dwarf2_section_info *section,
8564                               struct dwarf2_section_info *abbrev_section,
8565                               unsigned int is_dwz)
8566 {
8567   const gdb_byte *info_ptr;
8568   struct objfile *objfile = dwarf2_per_objfile->objfile;
8569
8570   if (dwarf_read_debug)
8571     fprintf_unfiltered (gdb_stdlog, "Reading %s for %s\n",
8572                         get_section_name (section),
8573                         get_section_file_name (section));
8574
8575   dwarf2_read_section (objfile, section);
8576
8577   info_ptr = section->buffer;
8578
8579   while (info_ptr < section->buffer + section->size)
8580     {
8581       struct dwarf2_per_cu_data *this_cu;
8582
8583       sect_offset sect_off = (sect_offset) (info_ptr - section->buffer);
8584
8585       comp_unit_head cu_header;
8586       read_and_check_comp_unit_head (dwarf2_per_objfile, &cu_header, section,
8587                                      abbrev_section, info_ptr,
8588                                      rcuh_kind::COMPILE);
8589
8590       /* Save the compilation unit for later lookup.  */
8591       if (cu_header.unit_type != DW_UT_type)
8592         {
8593           this_cu = XOBNEW (&objfile->objfile_obstack,
8594                             struct dwarf2_per_cu_data);
8595           memset (this_cu, 0, sizeof (*this_cu));
8596         }
8597       else
8598         {
8599           auto sig_type = XOBNEW (&objfile->objfile_obstack,
8600                                   struct signatured_type);
8601           memset (sig_type, 0, sizeof (*sig_type));
8602           sig_type->signature = cu_header.signature;
8603           sig_type->type_offset_in_tu = cu_header.type_cu_offset_in_tu;
8604           this_cu = &sig_type->per_cu;
8605         }
8606       this_cu->is_debug_types = (cu_header.unit_type == DW_UT_type);
8607       this_cu->sect_off = sect_off;
8608       this_cu->length = cu_header.length + cu_header.initial_length_size;
8609       this_cu->is_dwz = is_dwz;
8610       this_cu->dwarf2_per_objfile = dwarf2_per_objfile;
8611       this_cu->section = section;
8612
8613       dwarf2_per_objfile->all_comp_units.push_back (this_cu);
8614
8615       info_ptr = info_ptr + this_cu->length;
8616     }
8617 }
8618
8619 /* Create a list of all compilation units in OBJFILE.
8620    This is only done for -readnow and building partial symtabs.  */
8621
8622 static void
8623 create_all_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
8624 {
8625   gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
8626   read_comp_units_from_section (dwarf2_per_objfile, &dwarf2_per_objfile->info,
8627                                 &dwarf2_per_objfile->abbrev, 0);
8628
8629   dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
8630   if (dwz != NULL)
8631     read_comp_units_from_section (dwarf2_per_objfile, &dwz->info, &dwz->abbrev,
8632                                   1);
8633 }
8634
8635 /* Process all loaded DIEs for compilation unit CU, starting at
8636    FIRST_DIE.  The caller should pass SET_ADDRMAP == 1 if the compilation
8637    unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
8638    DW_AT_ranges).  See the comments of add_partial_subprogram on how
8639    SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated.  */
8640
8641 static void
8642 scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
8643                       CORE_ADDR *highpc, int set_addrmap,
8644                       struct dwarf2_cu *cu)
8645 {
8646   struct partial_die_info *pdi;
8647
8648   /* Now, march along the PDI's, descending into ones which have
8649      interesting children but skipping the children of the other ones,
8650      until we reach the end of the compilation unit.  */
8651
8652   pdi = first_die;
8653
8654   while (pdi != NULL)
8655     {
8656       pdi->fixup (cu);
8657
8658       /* Anonymous namespaces or modules have no name but have interesting
8659          children, so we need to look at them.  Ditto for anonymous
8660          enums.  */
8661
8662       if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
8663           || pdi->tag == DW_TAG_module || pdi->tag == DW_TAG_enumeration_type
8664           || pdi->tag == DW_TAG_imported_unit
8665           || pdi->tag == DW_TAG_inlined_subroutine)
8666         {
8667           switch (pdi->tag)
8668             {
8669             case DW_TAG_subprogram:
8670             case DW_TAG_inlined_subroutine:
8671               add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
8672               break;
8673             case DW_TAG_constant:
8674             case DW_TAG_variable:
8675             case DW_TAG_typedef:
8676             case DW_TAG_union_type:
8677               if (!pdi->is_declaration)
8678                 {
8679                   add_partial_symbol (pdi, cu);
8680                 }
8681               break;
8682             case DW_TAG_class_type:
8683             case DW_TAG_interface_type:
8684             case DW_TAG_structure_type:
8685               if (!pdi->is_declaration)
8686                 {
8687                   add_partial_symbol (pdi, cu);
8688                 }
8689               if ((cu->language == language_rust
8690                    || cu->language == language_cplus) && pdi->has_children)
8691                 scan_partial_symbols (pdi->die_child, lowpc, highpc,
8692                                       set_addrmap, cu);
8693               break;
8694             case DW_TAG_enumeration_type:
8695               if (!pdi->is_declaration)
8696                 add_partial_enumeration (pdi, cu);
8697               break;
8698             case DW_TAG_base_type:
8699             case DW_TAG_subrange_type:
8700               /* File scope base type definitions are added to the partial
8701                  symbol table.  */
8702               add_partial_symbol (pdi, cu);
8703               break;
8704             case DW_TAG_namespace:
8705               add_partial_namespace (pdi, lowpc, highpc, set_addrmap, cu);
8706               break;
8707             case DW_TAG_module:
8708               add_partial_module (pdi, lowpc, highpc, set_addrmap, cu);
8709               break;
8710             case DW_TAG_imported_unit:
8711               {
8712                 struct dwarf2_per_cu_data *per_cu;
8713
8714                 /* For now we don't handle imported units in type units.  */
8715                 if (cu->per_cu->is_debug_types)
8716                   {
8717                     error (_("Dwarf Error: DW_TAG_imported_unit is not"
8718                              " supported in type units [in module %s]"),
8719                            objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
8720                   }
8721
8722                 per_cu = dwarf2_find_containing_comp_unit
8723                            (pdi->d.sect_off, pdi->is_dwz,
8724                             cu->per_cu->dwarf2_per_objfile);
8725
8726                 /* Go read the partial unit, if needed.  */
8727                 if (per_cu->v.psymtab == NULL)
8728                   process_psymtab_comp_unit (per_cu, 1, cu->language);
8729
8730                 VEC_safe_push (dwarf2_per_cu_ptr,
8731                                cu->per_cu->imported_symtabs, per_cu);
8732               }
8733               break;
8734             case DW_TAG_imported_declaration:
8735               add_partial_symbol (pdi, cu);
8736               break;
8737             default:
8738               break;
8739             }
8740         }
8741
8742       /* If the die has a sibling, skip to the sibling.  */
8743
8744       pdi = pdi->die_sibling;
8745     }
8746 }
8747
8748 /* Functions used to compute the fully scoped name of a partial DIE.
8749
8750    Normally, this is simple.  For C++, the parent DIE's fully scoped
8751    name is concatenated with "::" and the partial DIE's name.
8752    Enumerators are an exception; they use the scope of their parent
8753    enumeration type, i.e. the name of the enumeration type is not
8754    prepended to the enumerator.
8755
8756    There are two complexities.  One is DW_AT_specification; in this
8757    case "parent" means the parent of the target of the specification,
8758    instead of the direct parent of the DIE.  The other is compilers
8759    which do not emit DW_TAG_namespace; in this case we try to guess
8760    the fully qualified name of structure types from their members'
8761    linkage names.  This must be done using the DIE's children rather
8762    than the children of any DW_AT_specification target.  We only need
8763    to do this for structures at the top level, i.e. if the target of
8764    any DW_AT_specification (if any; otherwise the DIE itself) does not
8765    have a parent.  */
8766
8767 /* Compute the scope prefix associated with PDI's parent, in
8768    compilation unit CU.  The result will be allocated on CU's
8769    comp_unit_obstack, or a copy of the already allocated PDI->NAME
8770    field.  NULL is returned if no prefix is necessary.  */
8771 static const char *
8772 partial_die_parent_scope (struct partial_die_info *pdi,
8773                           struct dwarf2_cu *cu)
8774 {
8775   const char *grandparent_scope;
8776   struct partial_die_info *parent, *real_pdi;
8777
8778   /* We need to look at our parent DIE; if we have a DW_AT_specification,
8779      then this means the parent of the specification DIE.  */
8780
8781   real_pdi = pdi;
8782   while (real_pdi->has_specification)
8783     real_pdi = find_partial_die (real_pdi->spec_offset,
8784                                  real_pdi->spec_is_dwz, cu);
8785
8786   parent = real_pdi->die_parent;
8787   if (parent == NULL)
8788     return NULL;
8789
8790   if (parent->scope_set)
8791     return parent->scope;
8792
8793   parent->fixup (cu);
8794
8795   grandparent_scope = partial_die_parent_scope (parent, cu);
8796
8797   /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
8798      DW_TAG_namespace DIEs with a name of "::" for the global namespace.
8799      Work around this problem here.  */
8800   if (cu->language == language_cplus
8801       && parent->tag == DW_TAG_namespace
8802       && strcmp (parent->name, "::") == 0
8803       && grandparent_scope == NULL)
8804     {
8805       parent->scope = NULL;
8806       parent->scope_set = 1;
8807       return NULL;
8808     }
8809
8810   if (pdi->tag == DW_TAG_enumerator)
8811     /* Enumerators should not get the name of the enumeration as a prefix.  */
8812     parent->scope = grandparent_scope;
8813   else if (parent->tag == DW_TAG_namespace
8814       || parent->tag == DW_TAG_module
8815       || parent->tag == DW_TAG_structure_type
8816       || parent->tag == DW_TAG_class_type
8817       || parent->tag == DW_TAG_interface_type
8818       || parent->tag == DW_TAG_union_type
8819       || parent->tag == DW_TAG_enumeration_type)
8820     {
8821       if (grandparent_scope == NULL)
8822         parent->scope = parent->name;
8823       else
8824         parent->scope = typename_concat (&cu->comp_unit_obstack,
8825                                          grandparent_scope,
8826                                          parent->name, 0, cu);
8827     }
8828   else
8829     {
8830       /* FIXME drow/2004-04-01: What should we be doing with
8831          function-local names?  For partial symbols, we should probably be
8832          ignoring them.  */
8833       complaint (_("unhandled containing DIE tag %d for DIE at %s"),
8834                  parent->tag, sect_offset_str (pdi->sect_off));
8835       parent->scope = grandparent_scope;
8836     }
8837
8838   parent->scope_set = 1;
8839   return parent->scope;
8840 }
8841
8842 /* Return the fully scoped name associated with PDI, from compilation unit
8843    CU.  The result will be allocated with malloc.  */
8844
8845 static char *
8846 partial_die_full_name (struct partial_die_info *pdi,
8847                        struct dwarf2_cu *cu)
8848 {
8849   const char *parent_scope;
8850
8851   /* If this is a template instantiation, we can not work out the
8852      template arguments from partial DIEs.  So, unfortunately, we have
8853      to go through the full DIEs.  At least any work we do building
8854      types here will be reused if full symbols are loaded later.  */
8855   if (pdi->has_template_arguments)
8856     {
8857       pdi->fixup (cu);
8858
8859       if (pdi->name != NULL && strchr (pdi->name, '<') == NULL)
8860         {
8861           struct die_info *die;
8862           struct attribute attr;
8863           struct dwarf2_cu *ref_cu = cu;
8864
8865           /* DW_FORM_ref_addr is using section offset.  */
8866           attr.name = (enum dwarf_attribute) 0;
8867           attr.form = DW_FORM_ref_addr;
8868           attr.u.unsnd = to_underlying (pdi->sect_off);
8869           die = follow_die_ref (NULL, &attr, &ref_cu);
8870
8871           return xstrdup (dwarf2_full_name (NULL, die, ref_cu));
8872         }
8873     }
8874
8875   parent_scope = partial_die_parent_scope (pdi, cu);
8876   if (parent_scope == NULL)
8877     return NULL;
8878   else
8879     return typename_concat (NULL, parent_scope, pdi->name, 0, cu);
8880 }
8881
8882 static void
8883 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
8884 {
8885   struct dwarf2_per_objfile *dwarf2_per_objfile
8886     = cu->per_cu->dwarf2_per_objfile;
8887   struct objfile *objfile = dwarf2_per_objfile->objfile;
8888   struct gdbarch *gdbarch = get_objfile_arch (objfile);
8889   CORE_ADDR addr = 0;
8890   const char *actual_name = NULL;
8891   CORE_ADDR baseaddr;
8892   char *built_actual_name;
8893
8894   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
8895
8896   built_actual_name = partial_die_full_name (pdi, cu);
8897   if (built_actual_name != NULL)
8898     actual_name = built_actual_name;
8899
8900   if (actual_name == NULL)
8901     actual_name = pdi->name;
8902
8903   switch (pdi->tag)
8904     {
8905     case DW_TAG_inlined_subroutine:
8906     case DW_TAG_subprogram:
8907       addr = (gdbarch_adjust_dwarf2_addr (gdbarch, pdi->lowpc + baseaddr)
8908               - baseaddr);
8909       if (pdi->is_external || cu->language == language_ada)
8910         {
8911           /* brobecker/2007-12-26: Normally, only "external" DIEs are part
8912              of the global scope.  But in Ada, we want to be able to access
8913              nested procedures globally.  So all Ada subprograms are stored
8914              in the global scope.  */
8915           add_psymbol_to_list (actual_name, strlen (actual_name),
8916                                built_actual_name != NULL,
8917                                VAR_DOMAIN, LOC_BLOCK,
8918                                SECT_OFF_TEXT (objfile),
8919                                psymbol_placement::GLOBAL,
8920                                addr,
8921                                cu->language, objfile);
8922         }
8923       else
8924         {
8925           add_psymbol_to_list (actual_name, strlen (actual_name),
8926                                built_actual_name != NULL,
8927                                VAR_DOMAIN, LOC_BLOCK,
8928                                SECT_OFF_TEXT (objfile),
8929                                psymbol_placement::STATIC,
8930                                addr, cu->language, objfile);
8931         }
8932
8933       if (pdi->main_subprogram && actual_name != NULL)
8934         set_objfile_main_name (objfile, actual_name, cu->language);
8935       break;
8936     case DW_TAG_constant:
8937       add_psymbol_to_list (actual_name, strlen (actual_name),
8938                            built_actual_name != NULL, VAR_DOMAIN, LOC_STATIC,
8939                            -1, (pdi->is_external
8940                                 ? psymbol_placement::GLOBAL
8941                                 : psymbol_placement::STATIC),
8942                            0, cu->language, objfile);
8943       break;
8944     case DW_TAG_variable:
8945       if (pdi->d.locdesc)
8946         addr = decode_locdesc (pdi->d.locdesc, cu);
8947
8948       if (pdi->d.locdesc
8949           && addr == 0
8950           && !dwarf2_per_objfile->has_section_at_zero)
8951         {
8952           /* A global or static variable may also have been stripped
8953              out by the linker if unused, in which case its address
8954              will be nullified; do not add such variables into partial
8955              symbol table then.  */
8956         }
8957       else if (pdi->is_external)
8958         {
8959           /* Global Variable.
8960              Don't enter into the minimal symbol tables as there is
8961              a minimal symbol table entry from the ELF symbols already.
8962              Enter into partial symbol table if it has a location
8963              descriptor or a type.
8964              If the location descriptor is missing, new_symbol will create
8965              a LOC_UNRESOLVED symbol, the address of the variable will then
8966              be determined from the minimal symbol table whenever the variable
8967              is referenced.
8968              The address for the partial symbol table entry is not
8969              used by GDB, but it comes in handy for debugging partial symbol
8970              table building.  */
8971
8972           if (pdi->d.locdesc || pdi->has_type)
8973             add_psymbol_to_list (actual_name, strlen (actual_name),
8974                                  built_actual_name != NULL,
8975                                  VAR_DOMAIN, LOC_STATIC,
8976                                  SECT_OFF_TEXT (objfile),
8977                                  psymbol_placement::GLOBAL,
8978                                  addr, cu->language, objfile);
8979         }
8980       else
8981         {
8982           int has_loc = pdi->d.locdesc != NULL;
8983
8984           /* Static Variable.  Skip symbols whose value we cannot know (those
8985              without location descriptors or constant values).  */
8986           if (!has_loc && !pdi->has_const_value)
8987             {
8988               xfree (built_actual_name);
8989               return;
8990             }
8991
8992           add_psymbol_to_list (actual_name, strlen (actual_name),
8993                                built_actual_name != NULL,
8994                                VAR_DOMAIN, LOC_STATIC,
8995                                SECT_OFF_TEXT (objfile),
8996                                psymbol_placement::STATIC,
8997                                has_loc ? addr : 0,
8998                                cu->language, objfile);
8999         }
9000       break;
9001     case DW_TAG_typedef:
9002     case DW_TAG_base_type:
9003     case DW_TAG_subrange_type:
9004       add_psymbol_to_list (actual_name, strlen (actual_name),
9005                            built_actual_name != NULL,
9006                            VAR_DOMAIN, LOC_TYPEDEF, -1,
9007                            psymbol_placement::STATIC,
9008                            0, cu->language, objfile);
9009       break;
9010     case DW_TAG_imported_declaration:
9011     case DW_TAG_namespace:
9012       add_psymbol_to_list (actual_name, strlen (actual_name),
9013                            built_actual_name != NULL,
9014                            VAR_DOMAIN, LOC_TYPEDEF, -1,
9015                            psymbol_placement::GLOBAL,
9016                            0, cu->language, objfile);
9017       break;
9018     case DW_TAG_module:
9019       add_psymbol_to_list (actual_name, strlen (actual_name),
9020                            built_actual_name != NULL,
9021                            MODULE_DOMAIN, LOC_TYPEDEF, -1,
9022                            psymbol_placement::GLOBAL,
9023                            0, cu->language, objfile);
9024       break;
9025     case DW_TAG_class_type:
9026     case DW_TAG_interface_type:
9027     case DW_TAG_structure_type:
9028     case DW_TAG_union_type:
9029     case DW_TAG_enumeration_type:
9030       /* Skip external references.  The DWARF standard says in the section
9031          about "Structure, Union, and Class Type Entries": "An incomplete
9032          structure, union or class type is represented by a structure,
9033          union or class entry that does not have a byte size attribute
9034          and that has a DW_AT_declaration attribute."  */
9035       if (!pdi->has_byte_size && pdi->is_declaration)
9036         {
9037           xfree (built_actual_name);
9038           return;
9039         }
9040
9041       /* NOTE: carlton/2003-10-07: See comment in new_symbol about
9042          static vs. global.  */
9043       add_psymbol_to_list (actual_name, strlen (actual_name),
9044                            built_actual_name != NULL,
9045                            STRUCT_DOMAIN, LOC_TYPEDEF, -1,
9046                            cu->language == language_cplus
9047                            ? psymbol_placement::GLOBAL
9048                            : psymbol_placement::STATIC,
9049                            0, cu->language, objfile);
9050
9051       break;
9052     case DW_TAG_enumerator:
9053       add_psymbol_to_list (actual_name, strlen (actual_name),
9054                            built_actual_name != NULL,
9055                            VAR_DOMAIN, LOC_CONST, -1,
9056                            cu->language == language_cplus
9057                            ? psymbol_placement::GLOBAL
9058                            : psymbol_placement::STATIC,
9059                            0, cu->language, objfile);
9060       break;
9061     default:
9062       break;
9063     }
9064
9065   xfree (built_actual_name);
9066 }
9067
9068 /* Read a partial die corresponding to a namespace; also, add a symbol
9069    corresponding to that namespace to the symbol table.  NAMESPACE is
9070    the name of the enclosing namespace.  */
9071
9072 static void
9073 add_partial_namespace (struct partial_die_info *pdi,
9074                        CORE_ADDR *lowpc, CORE_ADDR *highpc,
9075                        int set_addrmap, struct dwarf2_cu *cu)
9076 {
9077   /* Add a symbol for the namespace.  */
9078
9079   add_partial_symbol (pdi, cu);
9080
9081   /* Now scan partial symbols in that namespace.  */
9082
9083   if (pdi->has_children)
9084     scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
9085 }
9086
9087 /* Read a partial die corresponding to a Fortran module.  */
9088
9089 static void
9090 add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
9091                     CORE_ADDR *highpc, int set_addrmap, struct dwarf2_cu *cu)
9092 {
9093   /* Add a symbol for the namespace.  */
9094
9095   add_partial_symbol (pdi, cu);
9096
9097   /* Now scan partial symbols in that module.  */
9098
9099   if (pdi->has_children)
9100     scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
9101 }
9102
9103 /* Read a partial die corresponding to a subprogram or an inlined
9104    subprogram and create a partial symbol for that subprogram.
9105    When the CU language allows it, this routine also defines a partial
9106    symbol for each nested subprogram that this subprogram contains.
9107    If SET_ADDRMAP is true, record the covered ranges in the addrmap.
9108    Set *LOWPC and *HIGHPC to the lowest and highest PC values found in PDI.
9109
9110    PDI may also be a lexical block, in which case we simply search
9111    recursively for subprograms defined inside that lexical block.
9112    Again, this is only performed when the CU language allows this
9113    type of definitions.  */
9114
9115 static void
9116 add_partial_subprogram (struct partial_die_info *pdi,
9117                         CORE_ADDR *lowpc, CORE_ADDR *highpc,
9118                         int set_addrmap, struct dwarf2_cu *cu)
9119 {
9120   if (pdi->tag == DW_TAG_subprogram || pdi->tag == DW_TAG_inlined_subroutine)
9121     {
9122       if (pdi->has_pc_info)
9123         {
9124           if (pdi->lowpc < *lowpc)
9125             *lowpc = pdi->lowpc;
9126           if (pdi->highpc > *highpc)
9127             *highpc = pdi->highpc;
9128           if (set_addrmap)
9129             {
9130               struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
9131               struct gdbarch *gdbarch = get_objfile_arch (objfile);
9132               CORE_ADDR baseaddr;
9133               CORE_ADDR this_highpc;
9134               CORE_ADDR this_lowpc;
9135
9136               baseaddr = ANOFFSET (objfile->section_offsets,
9137                                    SECT_OFF_TEXT (objfile));
9138               this_lowpc
9139                 = (gdbarch_adjust_dwarf2_addr (gdbarch,
9140                                                pdi->lowpc + baseaddr)
9141                    - baseaddr);
9142               this_highpc
9143                 = (gdbarch_adjust_dwarf2_addr (gdbarch,
9144                                                pdi->highpc + baseaddr)
9145                    - baseaddr);
9146               addrmap_set_empty (objfile->partial_symtabs->psymtabs_addrmap,
9147                                  this_lowpc, this_highpc - 1,
9148                                  cu->per_cu->v.psymtab);
9149             }
9150         }
9151
9152       if (pdi->has_pc_info || (!pdi->is_external && pdi->may_be_inlined))
9153         {
9154           if (!pdi->is_declaration)
9155             /* Ignore subprogram DIEs that do not have a name, they are
9156                illegal.  Do not emit a complaint at this point, we will
9157                do so when we convert this psymtab into a symtab.  */
9158             if (pdi->name)
9159               add_partial_symbol (pdi, cu);
9160         }
9161     }
9162
9163   if (! pdi->has_children)
9164     return;
9165
9166   if (cu->language == language_ada)
9167     {
9168       pdi = pdi->die_child;
9169       while (pdi != NULL)
9170         {
9171           pdi->fixup (cu);
9172           if (pdi->tag == DW_TAG_subprogram
9173               || pdi->tag == DW_TAG_inlined_subroutine
9174               || pdi->tag == DW_TAG_lexical_block)
9175             add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
9176           pdi = pdi->die_sibling;
9177         }
9178     }
9179 }
9180
9181 /* Read a partial die corresponding to an enumeration type.  */
9182
9183 static void
9184 add_partial_enumeration (struct partial_die_info *enum_pdi,
9185                          struct dwarf2_cu *cu)
9186 {
9187   struct partial_die_info *pdi;
9188
9189   if (enum_pdi->name != NULL)
9190     add_partial_symbol (enum_pdi, cu);
9191
9192   pdi = enum_pdi->die_child;
9193   while (pdi)
9194     {
9195       if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
9196         complaint (_("malformed enumerator DIE ignored"));
9197       else
9198         add_partial_symbol (pdi, cu);
9199       pdi = pdi->die_sibling;
9200     }
9201 }
9202
9203 /* Return the initial uleb128 in the die at INFO_PTR.  */
9204
9205 static unsigned int
9206 peek_abbrev_code (bfd *abfd, const gdb_byte *info_ptr)
9207 {
9208   unsigned int bytes_read;
9209
9210   return read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9211 }
9212
9213 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit
9214    READER::CU.  Use READER::ABBREV_TABLE to lookup any abbreviation.
9215
9216    Return the corresponding abbrev, or NULL if the number is zero (indicating
9217    an empty DIE).  In either case *BYTES_READ will be set to the length of
9218    the initial number.  */
9219
9220 static struct abbrev_info *
9221 peek_die_abbrev (const die_reader_specs &reader,
9222                  const gdb_byte *info_ptr, unsigned int *bytes_read)
9223 {
9224   dwarf2_cu *cu = reader.cu;
9225   bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
9226   unsigned int abbrev_number
9227     = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
9228
9229   if (abbrev_number == 0)
9230     return NULL;
9231
9232   abbrev_info *abbrev = reader.abbrev_table->lookup_abbrev (abbrev_number);
9233   if (!abbrev)
9234     {
9235       error (_("Dwarf Error: Could not find abbrev number %d in %s"
9236                " at offset %s [in module %s]"),
9237              abbrev_number, cu->per_cu->is_debug_types ? "TU" : "CU",
9238              sect_offset_str (cu->header.sect_off), bfd_get_filename (abfd));
9239     }
9240
9241   return abbrev;
9242 }
9243
9244 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9245    Returns a pointer to the end of a series of DIEs, terminated by an empty
9246    DIE.  Any children of the skipped DIEs will also be skipped.  */
9247
9248 static const gdb_byte *
9249 skip_children (const struct die_reader_specs *reader, const gdb_byte *info_ptr)
9250 {
9251   while (1)
9252     {
9253       unsigned int bytes_read;
9254       abbrev_info *abbrev = peek_die_abbrev (*reader, info_ptr, &bytes_read);
9255
9256       if (abbrev == NULL)
9257         return info_ptr + bytes_read;
9258       else
9259         info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
9260     }
9261 }
9262
9263 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
9264    INFO_PTR should point just after the initial uleb128 of a DIE, and the
9265    abbrev corresponding to that skipped uleb128 should be passed in
9266    ABBREV.  Returns a pointer to this DIE's sibling, skipping any
9267    children.  */
9268
9269 static const gdb_byte *
9270 skip_one_die (const struct die_reader_specs *reader, const gdb_byte *info_ptr,
9271               struct abbrev_info *abbrev)
9272 {
9273   unsigned int bytes_read;
9274   struct attribute attr;
9275   bfd *abfd = reader->abfd;
9276   struct dwarf2_cu *cu = reader->cu;
9277   const gdb_byte *buffer = reader->buffer;
9278   const gdb_byte *buffer_end = reader->buffer_end;
9279   unsigned int form, i;
9280
9281   for (i = 0; i < abbrev->num_attrs; i++)
9282     {
9283       /* The only abbrev we care about is DW_AT_sibling.  */
9284       if (abbrev->attrs[i].name == DW_AT_sibling)
9285         {
9286           read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
9287           if (attr.form == DW_FORM_ref_addr)
9288             complaint (_("ignoring absolute DW_AT_sibling"));
9289           else
9290             {
9291               sect_offset off = dwarf2_get_ref_die_offset (&attr);
9292               const gdb_byte *sibling_ptr = buffer + to_underlying (off);
9293
9294               if (sibling_ptr < info_ptr)
9295                 complaint (_("DW_AT_sibling points backwards"));
9296               else if (sibling_ptr > reader->buffer_end)
9297                 dwarf2_section_buffer_overflow_complaint (reader->die_section);
9298               else
9299                 return sibling_ptr;
9300             }
9301         }
9302
9303       /* If it isn't DW_AT_sibling, skip this attribute.  */
9304       form = abbrev->attrs[i].form;
9305     skip_attribute:
9306       switch (form)
9307         {
9308         case DW_FORM_ref_addr:
9309           /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
9310              and later it is offset sized.  */
9311           if (cu->header.version == 2)
9312             info_ptr += cu->header.addr_size;
9313           else
9314             info_ptr += cu->header.offset_size;
9315           break;
9316         case DW_FORM_GNU_ref_alt:
9317           info_ptr += cu->header.offset_size;
9318           break;
9319         case DW_FORM_addr:
9320           info_ptr += cu->header.addr_size;
9321           break;
9322         case DW_FORM_data1:
9323         case DW_FORM_ref1:
9324         case DW_FORM_flag:
9325           info_ptr += 1;
9326           break;
9327         case DW_FORM_flag_present:
9328         case DW_FORM_implicit_const:
9329           break;
9330         case DW_FORM_data2:
9331         case DW_FORM_ref2:
9332           info_ptr += 2;
9333           break;
9334         case DW_FORM_data4:
9335         case DW_FORM_ref4:
9336           info_ptr += 4;
9337           break;
9338         case DW_FORM_data8:
9339         case DW_FORM_ref8:
9340         case DW_FORM_ref_sig8:
9341           info_ptr += 8;
9342           break;
9343         case DW_FORM_data16:
9344           info_ptr += 16;
9345           break;
9346         case DW_FORM_string:
9347           read_direct_string (abfd, info_ptr, &bytes_read);
9348           info_ptr += bytes_read;
9349           break;
9350         case DW_FORM_sec_offset:
9351         case DW_FORM_strp:
9352         case DW_FORM_GNU_strp_alt:
9353           info_ptr += cu->header.offset_size;
9354           break;
9355         case DW_FORM_exprloc:
9356         case DW_FORM_block:
9357           info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9358           info_ptr += bytes_read;
9359           break;
9360         case DW_FORM_block1:
9361           info_ptr += 1 + read_1_byte (abfd, info_ptr);
9362           break;
9363         case DW_FORM_block2:
9364           info_ptr += 2 + read_2_bytes (abfd, info_ptr);
9365           break;
9366         case DW_FORM_block4:
9367           info_ptr += 4 + read_4_bytes (abfd, info_ptr);
9368           break;
9369         case DW_FORM_sdata:
9370         case DW_FORM_udata:
9371         case DW_FORM_ref_udata:
9372         case DW_FORM_GNU_addr_index:
9373         case DW_FORM_GNU_str_index:
9374           info_ptr = safe_skip_leb128 (info_ptr, buffer_end);
9375           break;
9376         case DW_FORM_indirect:
9377           form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
9378           info_ptr += bytes_read;
9379           /* We need to continue parsing from here, so just go back to
9380              the top.  */
9381           goto skip_attribute;
9382
9383         default:
9384           error (_("Dwarf Error: Cannot handle %s "
9385                    "in DWARF reader [in module %s]"),
9386                  dwarf_form_name (form),
9387                  bfd_get_filename (abfd));
9388         }
9389     }
9390
9391   if (abbrev->has_children)
9392     return skip_children (reader, info_ptr);
9393   else
9394     return info_ptr;
9395 }
9396
9397 /* Locate ORIG_PDI's sibling.
9398    INFO_PTR should point to the start of the next DIE after ORIG_PDI.  */
9399
9400 static const gdb_byte *
9401 locate_pdi_sibling (const struct die_reader_specs *reader,
9402                     struct partial_die_info *orig_pdi,
9403                     const gdb_byte *info_ptr)
9404 {
9405   /* Do we know the sibling already?  */
9406
9407   if (orig_pdi->sibling)
9408     return orig_pdi->sibling;
9409
9410   /* Are there any children to deal with?  */
9411
9412   if (!orig_pdi->has_children)
9413     return info_ptr;
9414
9415   /* Skip the children the long way.  */
9416
9417   return skip_children (reader, info_ptr);
9418 }
9419
9420 /* Expand this partial symbol table into a full symbol table.  SELF is
9421    not NULL.  */
9422
9423 static void
9424 dwarf2_read_symtab (struct partial_symtab *self,
9425                     struct objfile *objfile)
9426 {
9427   struct dwarf2_per_objfile *dwarf2_per_objfile
9428     = get_dwarf2_per_objfile (objfile);
9429
9430   if (self->readin)
9431     {
9432       warning (_("bug: psymtab for %s is already read in."),
9433                self->filename);
9434     }
9435   else
9436     {
9437       if (info_verbose)
9438         {
9439           printf_filtered (_("Reading in symbols for %s..."),
9440                            self->filename);
9441           gdb_flush (gdb_stdout);
9442         }
9443
9444       /* If this psymtab is constructed from a debug-only objfile, the
9445          has_section_at_zero flag will not necessarily be correct.  We
9446          can get the correct value for this flag by looking at the data
9447          associated with the (presumably stripped) associated objfile.  */
9448       if (objfile->separate_debug_objfile_backlink)
9449         {
9450           struct dwarf2_per_objfile *dpo_backlink
9451             = get_dwarf2_per_objfile (objfile->separate_debug_objfile_backlink);
9452
9453           dwarf2_per_objfile->has_section_at_zero
9454             = dpo_backlink->has_section_at_zero;
9455         }
9456
9457       dwarf2_per_objfile->reading_partial_symbols = 0;
9458
9459       psymtab_to_symtab_1 (self);
9460
9461       /* Finish up the debug error message.  */
9462       if (info_verbose)
9463         printf_filtered (_("done.\n"));
9464     }
9465
9466   process_cu_includes (dwarf2_per_objfile);
9467 }
9468 \f
9469 /* Reading in full CUs.  */
9470
9471 /* Add PER_CU to the queue.  */
9472
9473 static void
9474 queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
9475                  enum language pretend_language)
9476 {
9477   struct dwarf2_queue_item *item;
9478
9479   per_cu->queued = 1;
9480   item = XNEW (struct dwarf2_queue_item);
9481   item->per_cu = per_cu;
9482   item->pretend_language = pretend_language;
9483   item->next = NULL;
9484
9485   if (dwarf2_queue == NULL)
9486     dwarf2_queue = item;
9487   else
9488     dwarf2_queue_tail->next = item;
9489
9490   dwarf2_queue_tail = item;
9491 }
9492
9493 /* If PER_CU is not yet queued, add it to the queue.
9494    If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
9495    dependency.
9496    The result is non-zero if PER_CU was queued, otherwise the result is zero
9497    meaning either PER_CU is already queued or it is already loaded.
9498
9499    N.B. There is an invariant here that if a CU is queued then it is loaded.
9500    The caller is required to load PER_CU if we return non-zero.  */
9501
9502 static int
9503 maybe_queue_comp_unit (struct dwarf2_cu *dependent_cu,
9504                        struct dwarf2_per_cu_data *per_cu,
9505                        enum language pretend_language)
9506 {
9507   /* We may arrive here during partial symbol reading, if we need full
9508      DIEs to process an unusual case (e.g. template arguments).  Do
9509      not queue PER_CU, just tell our caller to load its DIEs.  */
9510   if (per_cu->dwarf2_per_objfile->reading_partial_symbols)
9511     {
9512       if (per_cu->cu == NULL || per_cu->cu->dies == NULL)
9513         return 1;
9514       return 0;
9515     }
9516
9517   /* Mark the dependence relation so that we don't flush PER_CU
9518      too early.  */
9519   if (dependent_cu != NULL)
9520     dwarf2_add_dependence (dependent_cu, per_cu);
9521
9522   /* If it's already on the queue, we have nothing to do.  */
9523   if (per_cu->queued)
9524     return 0;
9525
9526   /* If the compilation unit is already loaded, just mark it as
9527      used.  */
9528   if (per_cu->cu != NULL)
9529     {
9530       per_cu->cu->last_used = 0;
9531       return 0;
9532     }
9533
9534   /* Add it to the queue.  */
9535   queue_comp_unit (per_cu, pretend_language);
9536
9537   return 1;
9538 }
9539
9540 /* Process the queue.  */
9541
9542 static void
9543 process_queue (struct dwarf2_per_objfile *dwarf2_per_objfile)
9544 {
9545   struct dwarf2_queue_item *item, *next_item;
9546
9547   if (dwarf_read_debug)
9548     {
9549       fprintf_unfiltered (gdb_stdlog,
9550                           "Expanding one or more symtabs of objfile %s ...\n",
9551                           objfile_name (dwarf2_per_objfile->objfile));
9552     }
9553
9554   /* The queue starts out with one item, but following a DIE reference
9555      may load a new CU, adding it to the end of the queue.  */
9556   for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
9557     {
9558       if ((dwarf2_per_objfile->using_index
9559            ? !item->per_cu->v.quick->compunit_symtab
9560            : (item->per_cu->v.psymtab && !item->per_cu->v.psymtab->readin))
9561           /* Skip dummy CUs.  */
9562           && item->per_cu->cu != NULL)
9563         {
9564           struct dwarf2_per_cu_data *per_cu = item->per_cu;
9565           unsigned int debug_print_threshold;
9566           char buf[100];
9567
9568           if (per_cu->is_debug_types)
9569             {
9570               struct signatured_type *sig_type =
9571                 (struct signatured_type *) per_cu;
9572
9573               sprintf (buf, "TU %s at offset %s",
9574                        hex_string (sig_type->signature),
9575                        sect_offset_str (per_cu->sect_off));
9576               /* There can be 100s of TUs.
9577                  Only print them in verbose mode.  */
9578               debug_print_threshold = 2;
9579             }
9580           else
9581             {
9582               sprintf (buf, "CU at offset %s",
9583                        sect_offset_str (per_cu->sect_off));
9584               debug_print_threshold = 1;
9585             }
9586
9587           if (dwarf_read_debug >= debug_print_threshold)
9588             fprintf_unfiltered (gdb_stdlog, "Expanding symtab of %s\n", buf);
9589
9590           if (per_cu->is_debug_types)
9591             process_full_type_unit (per_cu, item->pretend_language);
9592           else
9593             process_full_comp_unit (per_cu, item->pretend_language);
9594
9595           if (dwarf_read_debug >= debug_print_threshold)
9596             fprintf_unfiltered (gdb_stdlog, "Done expanding %s\n", buf);
9597         }
9598
9599       item->per_cu->queued = 0;
9600       next_item = item->next;
9601       xfree (item);
9602     }
9603
9604   dwarf2_queue_tail = NULL;
9605
9606   if (dwarf_read_debug)
9607     {
9608       fprintf_unfiltered (gdb_stdlog, "Done expanding symtabs of %s.\n",
9609                           objfile_name (dwarf2_per_objfile->objfile));
9610     }
9611 }
9612
9613 /* Read in full symbols for PST, and anything it depends on.  */
9614
9615 static void
9616 psymtab_to_symtab_1 (struct partial_symtab *pst)
9617 {
9618   struct dwarf2_per_cu_data *per_cu;
9619   int i;
9620
9621   if (pst->readin)
9622     return;
9623
9624   for (i = 0; i < pst->number_of_dependencies; i++)
9625     if (!pst->dependencies[i]->readin
9626         && pst->dependencies[i]->user == NULL)
9627       {
9628         /* Inform about additional files that need to be read in.  */
9629         if (info_verbose)
9630           {
9631             /* FIXME: i18n: Need to make this a single string.  */
9632             fputs_filtered (" ", gdb_stdout);
9633             wrap_here ("");
9634             fputs_filtered ("and ", gdb_stdout);
9635             wrap_here ("");
9636             printf_filtered ("%s...", pst->dependencies[i]->filename);
9637             wrap_here ("");     /* Flush output.  */
9638             gdb_flush (gdb_stdout);
9639           }
9640         psymtab_to_symtab_1 (pst->dependencies[i]);
9641       }
9642
9643   per_cu = (struct dwarf2_per_cu_data *) pst->read_symtab_private;
9644
9645   if (per_cu == NULL)
9646     {
9647       /* It's an include file, no symbols to read for it.
9648          Everything is in the parent symtab.  */
9649       pst->readin = 1;
9650       return;
9651     }
9652
9653   dw2_do_instantiate_symtab (per_cu, false);
9654 }
9655
9656 /* Trivial hash function for die_info: the hash value of a DIE
9657    is its offset in .debug_info for this objfile.  */
9658
9659 static hashval_t
9660 die_hash (const void *item)
9661 {
9662   const struct die_info *die = (const struct die_info *) item;
9663
9664   return to_underlying (die->sect_off);
9665 }
9666
9667 /* Trivial comparison function for die_info structures: two DIEs
9668    are equal if they have the same offset.  */
9669
9670 static int
9671 die_eq (const void *item_lhs, const void *item_rhs)
9672 {
9673   const struct die_info *die_lhs = (const struct die_info *) item_lhs;
9674   const struct die_info *die_rhs = (const struct die_info *) item_rhs;
9675
9676   return die_lhs->sect_off == die_rhs->sect_off;
9677 }
9678
9679 /* die_reader_func for load_full_comp_unit.
9680    This is identical to read_signatured_type_reader,
9681    but is kept separate for now.  */
9682
9683 static void
9684 load_full_comp_unit_reader (const struct die_reader_specs *reader,
9685                             const gdb_byte *info_ptr,
9686                             struct die_info *comp_unit_die,
9687                             int has_children,
9688                             void *data)
9689 {
9690   struct dwarf2_cu *cu = reader->cu;
9691   enum language *language_ptr = (enum language *) data;
9692
9693   gdb_assert (cu->die_hash == NULL);
9694   cu->die_hash =
9695     htab_create_alloc_ex (cu->header.length / 12,
9696                           die_hash,
9697                           die_eq,
9698                           NULL,
9699                           &cu->comp_unit_obstack,
9700                           hashtab_obstack_allocate,
9701                           dummy_obstack_deallocate);
9702
9703   if (has_children)
9704     comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
9705                                                   &info_ptr, comp_unit_die);
9706   cu->dies = comp_unit_die;
9707   /* comp_unit_die is not stored in die_hash, no need.  */
9708
9709   /* We try not to read any attributes in this function, because not
9710      all CUs needed for references have been loaded yet, and symbol
9711      table processing isn't initialized.  But we have to set the CU language,
9712      or we won't be able to build types correctly.
9713      Similarly, if we do not read the producer, we can not apply
9714      producer-specific interpretation.  */
9715   prepare_one_comp_unit (cu, cu->dies, *language_ptr);
9716 }
9717
9718 /* Load the DIEs associated with PER_CU into memory.  */
9719
9720 static void
9721 load_full_comp_unit (struct dwarf2_per_cu_data *this_cu,
9722                      bool skip_partial,
9723                      enum language pretend_language)
9724 {
9725   gdb_assert (! this_cu->is_debug_types);
9726
9727   init_cutu_and_read_dies (this_cu, NULL, 1, 1, skip_partial,
9728                            load_full_comp_unit_reader, &pretend_language);
9729 }
9730
9731 /* Add a DIE to the delayed physname list.  */
9732
9733 static void
9734 add_to_method_list (struct type *type, int fnfield_index, int index,
9735                     const char *name, struct die_info *die,
9736                     struct dwarf2_cu *cu)
9737 {
9738   struct delayed_method_info mi;
9739   mi.type = type;
9740   mi.fnfield_index = fnfield_index;
9741   mi.index = index;
9742   mi.name = name;
9743   mi.die = die;
9744   cu->method_list.push_back (mi);
9745 }
9746
9747 /* Check whether [PHYSNAME, PHYSNAME+LEN) ends with a modifier like
9748    "const" / "volatile".  If so, decrements LEN by the length of the
9749    modifier and return true.  Otherwise return false.  */
9750
9751 template<size_t N>
9752 static bool
9753 check_modifier (const char *physname, size_t &len, const char (&mod)[N])
9754 {
9755   size_t mod_len = sizeof (mod) - 1;
9756   if (len > mod_len && startswith (physname + (len - mod_len), mod))
9757     {
9758       len -= mod_len;
9759       return true;
9760     }
9761   return false;
9762 }
9763
9764 /* Compute the physnames of any methods on the CU's method list.
9765
9766    The computation of method physnames is delayed in order to avoid the
9767    (bad) condition that one of the method's formal parameters is of an as yet
9768    incomplete type.  */
9769
9770 static void
9771 compute_delayed_physnames (struct dwarf2_cu *cu)
9772 {
9773   /* Only C++ delays computing physnames.  */
9774   if (cu->method_list.empty ())
9775     return;
9776   gdb_assert (cu->language == language_cplus);
9777
9778   for (const delayed_method_info &mi : cu->method_list)
9779     {
9780       const char *physname;
9781       struct fn_fieldlist *fn_flp
9782         = &TYPE_FN_FIELDLIST (mi.type, mi.fnfield_index);
9783       physname = dwarf2_physname (mi.name, mi.die, cu);
9784       TYPE_FN_FIELD_PHYSNAME (fn_flp->fn_fields, mi.index)
9785         = physname ? physname : "";
9786
9787       /* Since there's no tag to indicate whether a method is a
9788          const/volatile overload, extract that information out of the
9789          demangled name.  */
9790       if (physname != NULL)
9791         {
9792           size_t len = strlen (physname);
9793
9794           while (1)
9795             {
9796               if (physname[len] == ')') /* shortcut */
9797                 break;
9798               else if (check_modifier (physname, len, " const"))
9799                 TYPE_FN_FIELD_CONST (fn_flp->fn_fields, mi.index) = 1;
9800               else if (check_modifier (physname, len, " volatile"))
9801                 TYPE_FN_FIELD_VOLATILE (fn_flp->fn_fields, mi.index) = 1;
9802               else
9803                 break;
9804             }
9805         }
9806     }
9807
9808   /* The list is no longer needed.  */
9809   cu->method_list.clear ();
9810 }
9811
9812 /* Go objects should be embedded in a DW_TAG_module DIE,
9813    and it's not clear if/how imported objects will appear.
9814    To keep Go support simple until that's worked out,
9815    go back through what we've read and create something usable.
9816    We could do this while processing each DIE, and feels kinda cleaner,
9817    but that way is more invasive.
9818    This is to, for example, allow the user to type "p var" or "b main"
9819    without having to specify the package name, and allow lookups
9820    of module.object to work in contexts that use the expression
9821    parser.  */
9822
9823 static void
9824 fixup_go_packaging (struct dwarf2_cu *cu)
9825 {
9826   char *package_name = NULL;
9827   struct pending *list;
9828   int i;
9829
9830   for (list = *cu->get_builder ()->get_global_symbols ();
9831        list != NULL;
9832        list = list->next)
9833     {
9834       for (i = 0; i < list->nsyms; ++i)
9835         {
9836           struct symbol *sym = list->symbol[i];
9837
9838           if (SYMBOL_LANGUAGE (sym) == language_go
9839               && SYMBOL_CLASS (sym) == LOC_BLOCK)
9840             {
9841               char *this_package_name = go_symbol_package_name (sym);
9842
9843               if (this_package_name == NULL)
9844                 continue;
9845               if (package_name == NULL)
9846                 package_name = this_package_name;
9847               else
9848                 {
9849                   struct objfile *objfile
9850                     = cu->per_cu->dwarf2_per_objfile->objfile;
9851                   if (strcmp (package_name, this_package_name) != 0)
9852                     complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
9853                                (symbol_symtab (sym) != NULL
9854                                 ? symtab_to_filename_for_display
9855                                     (symbol_symtab (sym))
9856                                 : objfile_name (objfile)),
9857                                this_package_name, package_name);
9858                   xfree (this_package_name);
9859                 }
9860             }
9861         }
9862     }
9863
9864   if (package_name != NULL)
9865     {
9866       struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
9867       const char *saved_package_name
9868         = (const char *) obstack_copy0 (&objfile->per_bfd->storage_obstack,
9869                                         package_name,
9870                                         strlen (package_name));
9871       struct type *type = init_type (objfile, TYPE_CODE_MODULE, 0,
9872                                      saved_package_name);
9873       struct symbol *sym;
9874
9875       sym = allocate_symbol (objfile);
9876       SYMBOL_SET_LANGUAGE (sym, language_go, &objfile->objfile_obstack);
9877       SYMBOL_SET_NAMES (sym, saved_package_name,
9878                         strlen (saved_package_name), 0, objfile);
9879       /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
9880          e.g., "main" finds the "main" module and not C's main().  */
9881       SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
9882       SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
9883       SYMBOL_TYPE (sym) = type;
9884
9885       add_symbol_to_list (sym, cu->get_builder ()->get_global_symbols ());
9886
9887       xfree (package_name);
9888     }
9889 }
9890
9891 /* Allocate a fully-qualified name consisting of the two parts on the
9892    obstack.  */
9893
9894 static const char *
9895 rust_fully_qualify (struct obstack *obstack, const char *p1, const char *p2)
9896 {
9897   return obconcat (obstack, p1, "::", p2, (char *) NULL);
9898 }
9899
9900 /* A helper that allocates a struct discriminant_info to attach to a
9901    union type.  */
9902
9903 static struct discriminant_info *
9904 alloc_discriminant_info (struct type *type, int discriminant_index,
9905                          int default_index)
9906 {
9907   gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
9908   gdb_assert (discriminant_index == -1
9909               || (discriminant_index >= 0
9910                   && discriminant_index < TYPE_NFIELDS (type)));
9911   gdb_assert (default_index == -1
9912               || (default_index >= 0 && default_index < TYPE_NFIELDS (type)));
9913
9914   TYPE_FLAG_DISCRIMINATED_UNION (type) = 1;
9915
9916   struct discriminant_info *disc
9917     = ((struct discriminant_info *)
9918        TYPE_ZALLOC (type,
9919                     offsetof (struct discriminant_info, discriminants)
9920                     + TYPE_NFIELDS (type) * sizeof (disc->discriminants[0])));
9921   disc->default_index = default_index;
9922   disc->discriminant_index = discriminant_index;
9923
9924   struct dynamic_prop prop;
9925   prop.kind = PROP_UNDEFINED;
9926   prop.data.baton = disc;
9927
9928   add_dyn_prop (DYN_PROP_DISCRIMINATED, prop, type);
9929
9930   return disc;
9931 }
9932
9933 /* Some versions of rustc emitted enums in an unusual way.
9934
9935    Ordinary enums were emitted as unions.  The first element of each
9936    structure in the union was named "RUST$ENUM$DISR".  This element
9937    held the discriminant.
9938
9939    These versions of Rust also implemented the "non-zero"
9940    optimization.  When the enum had two values, and one is empty and
9941    the other holds a pointer that cannot be zero, the pointer is used
9942    as the discriminant, with a zero value meaning the empty variant.
9943    Here, the union's first member is of the form
9944    RUST$ENCODED$ENUM$<fieldno>$<fieldno>$...$<variantname>
9945    where the fieldnos are the indices of the fields that should be
9946    traversed in order to find the field (which may be several fields deep)
9947    and the variantname is the name of the variant of the case when the
9948    field is zero.
9949
9950    This function recognizes whether TYPE is of one of these forms,
9951    and, if so, smashes it to be a variant type.  */
9952
9953 static void
9954 quirk_rust_enum (struct type *type, struct objfile *objfile)
9955 {
9956   gdb_assert (TYPE_CODE (type) == TYPE_CODE_UNION);
9957
9958   /* We don't need to deal with empty enums.  */
9959   if (TYPE_NFIELDS (type) == 0)
9960     return;
9961
9962 #define RUST_ENUM_PREFIX "RUST$ENCODED$ENUM$"
9963   if (TYPE_NFIELDS (type) == 1
9964       && startswith (TYPE_FIELD_NAME (type, 0), RUST_ENUM_PREFIX))
9965     {
9966       const char *name = TYPE_FIELD_NAME (type, 0) + strlen (RUST_ENUM_PREFIX);
9967
9968       /* Decode the field name to find the offset of the
9969          discriminant.  */
9970       ULONGEST bit_offset = 0;
9971       struct type *field_type = TYPE_FIELD_TYPE (type, 0);
9972       while (name[0] >= '0' && name[0] <= '9')
9973         {
9974           char *tail;
9975           unsigned long index = strtoul (name, &tail, 10);
9976           name = tail;
9977           if (*name != '$'
9978               || index >= TYPE_NFIELDS (field_type)
9979               || (TYPE_FIELD_LOC_KIND (field_type, index)
9980                   != FIELD_LOC_KIND_BITPOS))
9981             {
9982               complaint (_("Could not parse Rust enum encoding string \"%s\""
9983                            "[in module %s]"),
9984                          TYPE_FIELD_NAME (type, 0),
9985                          objfile_name (objfile));
9986               return;
9987             }
9988           ++name;
9989
9990           bit_offset += TYPE_FIELD_BITPOS (field_type, index);
9991           field_type = TYPE_FIELD_TYPE (field_type, index);
9992         }
9993
9994       /* Make a union to hold the variants.  */
9995       struct type *union_type = alloc_type (objfile);
9996       TYPE_CODE (union_type) = TYPE_CODE_UNION;
9997       TYPE_NFIELDS (union_type) = 3;
9998       TYPE_FIELDS (union_type)
9999         = (struct field *) TYPE_ZALLOC (type, 3 * sizeof (struct field));
10000       TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
10001       set_type_align (union_type, TYPE_RAW_ALIGN (type));
10002
10003       /* Put the discriminant must at index 0.  */
10004       TYPE_FIELD_TYPE (union_type, 0) = field_type;
10005       TYPE_FIELD_ARTIFICIAL (union_type, 0) = 1;
10006       TYPE_FIELD_NAME (union_type, 0) = "<<discriminant>>";
10007       SET_FIELD_BITPOS (TYPE_FIELD (union_type, 0), bit_offset);
10008
10009       /* The order of fields doesn't really matter, so put the real
10010          field at index 1 and the data-less field at index 2.  */
10011       struct discriminant_info *disc
10012         = alloc_discriminant_info (union_type, 0, 1);
10013       TYPE_FIELD (union_type, 1) = TYPE_FIELD (type, 0);
10014       TYPE_FIELD_NAME (union_type, 1)
10015         = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type, 1)));
10016       TYPE_NAME (TYPE_FIELD_TYPE (union_type, 1))
10017         = rust_fully_qualify (&objfile->objfile_obstack, TYPE_NAME (type),
10018                               TYPE_FIELD_NAME (union_type, 1));
10019
10020       const char *dataless_name
10021         = rust_fully_qualify (&objfile->objfile_obstack, TYPE_NAME (type),
10022                               name);
10023       struct type *dataless_type = init_type (objfile, TYPE_CODE_VOID, 0,
10024                                               dataless_name);
10025       TYPE_FIELD_TYPE (union_type, 2) = dataless_type;
10026       /* NAME points into the original discriminant name, which
10027          already has the correct lifetime.  */
10028       TYPE_FIELD_NAME (union_type, 2) = name;
10029       SET_FIELD_BITPOS (TYPE_FIELD (union_type, 2), 0);
10030       disc->discriminants[2] = 0;
10031
10032       /* Smash this type to be a structure type.  We have to do this
10033          because the type has already been recorded.  */
10034       TYPE_CODE (type) = TYPE_CODE_STRUCT;
10035       TYPE_NFIELDS (type) = 1;
10036       TYPE_FIELDS (type)
10037         = (struct field *) TYPE_ZALLOC (type, sizeof (struct field));
10038
10039       /* Install the variant part.  */
10040       TYPE_FIELD_TYPE (type, 0) = union_type;
10041       SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
10042       TYPE_FIELD_NAME (type, 0) = "<<variants>>";
10043     }
10044   else if (TYPE_NFIELDS (type) == 1)
10045     {
10046       /* We assume that a union with a single field is a univariant
10047          enum.  */
10048       /* Smash this type to be a structure type.  We have to do this
10049          because the type has already been recorded.  */
10050       TYPE_CODE (type) = TYPE_CODE_STRUCT;
10051
10052       /* Make a union to hold the variants.  */
10053       struct type *union_type = alloc_type (objfile);
10054       TYPE_CODE (union_type) = TYPE_CODE_UNION;
10055       TYPE_NFIELDS (union_type) = TYPE_NFIELDS (type);
10056       TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
10057       set_type_align (union_type, TYPE_RAW_ALIGN (type));
10058       TYPE_FIELDS (union_type) = TYPE_FIELDS (type);
10059
10060       struct type *field_type = TYPE_FIELD_TYPE (union_type, 0);
10061       const char *variant_name
10062         = rust_last_path_segment (TYPE_NAME (field_type));
10063       TYPE_FIELD_NAME (union_type, 0) = variant_name;
10064       TYPE_NAME (field_type)
10065         = rust_fully_qualify (&objfile->objfile_obstack,
10066                               TYPE_NAME (type), variant_name);
10067
10068       /* Install the union in the outer struct type.  */
10069       TYPE_NFIELDS (type) = 1;
10070       TYPE_FIELDS (type)
10071         = (struct field *) TYPE_ZALLOC (union_type, sizeof (struct field));
10072       TYPE_FIELD_TYPE (type, 0) = union_type;
10073       TYPE_FIELD_NAME (type, 0) = "<<variants>>";
10074       SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
10075
10076       alloc_discriminant_info (union_type, -1, 0);
10077     }
10078   else
10079     {
10080       struct type *disr_type = nullptr;
10081       for (int i = 0; i < TYPE_NFIELDS (type); ++i)
10082         {
10083           disr_type = TYPE_FIELD_TYPE (type, i);
10084
10085           if (TYPE_CODE (disr_type) != TYPE_CODE_STRUCT)
10086             {
10087               /* All fields of a true enum will be structs.  */
10088               return;
10089             }
10090           else if (TYPE_NFIELDS (disr_type) == 0)
10091             {
10092               /* Could be data-less variant, so keep going.  */
10093               disr_type = nullptr;
10094             }
10095           else if (strcmp (TYPE_FIELD_NAME (disr_type, 0),
10096                            "RUST$ENUM$DISR") != 0)
10097             {
10098               /* Not a Rust enum.  */
10099               return;
10100             }
10101           else
10102             {
10103               /* Found one.  */
10104               break;
10105             }
10106         }
10107
10108       /* If we got here without a discriminant, then it's probably
10109          just a union.  */
10110       if (disr_type == nullptr)
10111         return;
10112
10113       /* Smash this type to be a structure type.  We have to do this
10114          because the type has already been recorded.  */
10115       TYPE_CODE (type) = TYPE_CODE_STRUCT;
10116
10117       /* Make a union to hold the variants.  */
10118       struct field *disr_field = &TYPE_FIELD (disr_type, 0);
10119       struct type *union_type = alloc_type (objfile);
10120       TYPE_CODE (union_type) = TYPE_CODE_UNION;
10121       TYPE_NFIELDS (union_type) = 1 + TYPE_NFIELDS (type);
10122       TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
10123       set_type_align (union_type, TYPE_RAW_ALIGN (type));
10124       TYPE_FIELDS (union_type)
10125         = (struct field *) TYPE_ZALLOC (union_type,
10126                                         (TYPE_NFIELDS (union_type)
10127                                          * sizeof (struct field)));
10128
10129       memcpy (TYPE_FIELDS (union_type) + 1, TYPE_FIELDS (type),
10130               TYPE_NFIELDS (type) * sizeof (struct field));
10131
10132       /* Install the discriminant at index 0 in the union.  */
10133       TYPE_FIELD (union_type, 0) = *disr_field;
10134       TYPE_FIELD_ARTIFICIAL (union_type, 0) = 1;
10135       TYPE_FIELD_NAME (union_type, 0) = "<<discriminant>>";
10136
10137       /* Install the union in the outer struct type.  */
10138       TYPE_FIELD_TYPE (type, 0) = union_type;
10139       TYPE_FIELD_NAME (type, 0) = "<<variants>>";
10140       TYPE_NFIELDS (type) = 1;
10141
10142       /* Set the size and offset of the union type.  */
10143       SET_FIELD_BITPOS (TYPE_FIELD (type, 0), 0);
10144
10145       /* We need a way to find the correct discriminant given a
10146          variant name.  For convenience we build a map here.  */
10147       struct type *enum_type = FIELD_TYPE (*disr_field);
10148       std::unordered_map<std::string, ULONGEST> discriminant_map;
10149       for (int i = 0; i < TYPE_NFIELDS (enum_type); ++i)
10150         {
10151           if (TYPE_FIELD_LOC_KIND (enum_type, i) == FIELD_LOC_KIND_ENUMVAL)
10152             {
10153               const char *name
10154                 = rust_last_path_segment (TYPE_FIELD_NAME (enum_type, i));
10155               discriminant_map[name] = TYPE_FIELD_ENUMVAL (enum_type, i);
10156             }
10157         }
10158
10159       int n_fields = TYPE_NFIELDS (union_type);
10160       struct discriminant_info *disc
10161         = alloc_discriminant_info (union_type, 0, -1);
10162       /* Skip the discriminant here.  */
10163       for (int i = 1; i < n_fields; ++i)
10164         {
10165           /* Find the final word in the name of this variant's type.
10166              That name can be used to look up the correct
10167              discriminant.  */
10168           const char *variant_name
10169             = rust_last_path_segment (TYPE_NAME (TYPE_FIELD_TYPE (union_type,
10170                                                                   i)));
10171
10172           auto iter = discriminant_map.find (variant_name);
10173           if (iter != discriminant_map.end ())
10174             disc->discriminants[i] = iter->second;
10175
10176           /* Remove the discriminant field, if it exists.  */
10177           struct type *sub_type = TYPE_FIELD_TYPE (union_type, i);
10178           if (TYPE_NFIELDS (sub_type) > 0)
10179             {
10180               --TYPE_NFIELDS (sub_type);
10181               ++TYPE_FIELDS (sub_type);
10182             }
10183           TYPE_FIELD_NAME (union_type, i) = variant_name;
10184           TYPE_NAME (sub_type)
10185             = rust_fully_qualify (&objfile->objfile_obstack,
10186                                   TYPE_NAME (type), variant_name);
10187         }
10188     }
10189 }
10190
10191 /* Rewrite some Rust unions to be structures with variants parts.  */
10192
10193 static void
10194 rust_union_quirks (struct dwarf2_cu *cu)
10195 {
10196   gdb_assert (cu->language == language_rust);
10197   for (type *type_ : cu->rust_unions)
10198     quirk_rust_enum (type_, cu->per_cu->dwarf2_per_objfile->objfile);
10199   /* We don't need this any more.  */
10200   cu->rust_unions.clear ();
10201 }
10202
10203 /* Return the symtab for PER_CU.  This works properly regardless of
10204    whether we're using the index or psymtabs.  */
10205
10206 static struct compunit_symtab *
10207 get_compunit_symtab (struct dwarf2_per_cu_data *per_cu)
10208 {
10209   return (per_cu->dwarf2_per_objfile->using_index
10210           ? per_cu->v.quick->compunit_symtab
10211           : per_cu->v.psymtab->compunit_symtab);
10212 }
10213
10214 /* A helper function for computing the list of all symbol tables
10215    included by PER_CU.  */
10216
10217 static void
10218 recursively_compute_inclusions (std::vector<compunit_symtab *> *result,
10219                                 htab_t all_children, htab_t all_type_symtabs,
10220                                 struct dwarf2_per_cu_data *per_cu,
10221                                 struct compunit_symtab *immediate_parent)
10222 {
10223   void **slot;
10224   int ix;
10225   struct compunit_symtab *cust;
10226   struct dwarf2_per_cu_data *iter;
10227
10228   slot = htab_find_slot (all_children, per_cu, INSERT);
10229   if (*slot != NULL)
10230     {
10231       /* This inclusion and its children have been processed.  */
10232       return;
10233     }
10234
10235   *slot = per_cu;
10236   /* Only add a CU if it has a symbol table.  */
10237   cust = get_compunit_symtab (per_cu);
10238   if (cust != NULL)
10239     {
10240       /* If this is a type unit only add its symbol table if we haven't
10241          seen it yet (type unit per_cu's can share symtabs).  */
10242       if (per_cu->is_debug_types)
10243         {
10244           slot = htab_find_slot (all_type_symtabs, cust, INSERT);
10245           if (*slot == NULL)
10246             {
10247               *slot = cust;
10248               result->push_back (cust);
10249               if (cust->user == NULL)
10250                 cust->user = immediate_parent;
10251             }
10252         }
10253       else
10254         {
10255           result->push_back (cust);
10256           if (cust->user == NULL)
10257             cust->user = immediate_parent;
10258         }
10259     }
10260
10261   for (ix = 0;
10262        VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs, ix, iter);
10263        ++ix)
10264     {
10265       recursively_compute_inclusions (result, all_children,
10266                                       all_type_symtabs, iter, cust);
10267     }
10268 }
10269
10270 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
10271    PER_CU.  */
10272
10273 static void
10274 compute_compunit_symtab_includes (struct dwarf2_per_cu_data *per_cu)
10275 {
10276   gdb_assert (! per_cu->is_debug_types);
10277
10278   if (!VEC_empty (dwarf2_per_cu_ptr, per_cu->imported_symtabs))
10279     {
10280       int ix, len;
10281       struct dwarf2_per_cu_data *per_cu_iter;
10282       std::vector<compunit_symtab *> result_symtabs;
10283       htab_t all_children, all_type_symtabs;
10284       struct compunit_symtab *cust = get_compunit_symtab (per_cu);
10285
10286       /* If we don't have a symtab, we can just skip this case.  */
10287       if (cust == NULL)
10288         return;
10289
10290       all_children = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
10291                                         NULL, xcalloc, xfree);
10292       all_type_symtabs = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
10293                                             NULL, xcalloc, xfree);
10294
10295       for (ix = 0;
10296            VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs,
10297                         ix, per_cu_iter);
10298            ++ix)
10299         {
10300           recursively_compute_inclusions (&result_symtabs, all_children,
10301                                           all_type_symtabs, per_cu_iter,
10302                                           cust);
10303         }
10304
10305       /* Now we have a transitive closure of all the included symtabs.  */
10306       len = result_symtabs.size ();
10307       cust->includes
10308         = XOBNEWVEC (&per_cu->dwarf2_per_objfile->objfile->objfile_obstack,
10309                      struct compunit_symtab *, len + 1);
10310       memcpy (cust->includes, result_symtabs.data (),
10311               len * sizeof (compunit_symtab *));
10312       cust->includes[len] = NULL;
10313
10314       htab_delete (all_children);
10315       htab_delete (all_type_symtabs);
10316     }
10317 }
10318
10319 /* Compute the 'includes' field for the symtabs of all the CUs we just
10320    read.  */
10321
10322 static void
10323 process_cu_includes (struct dwarf2_per_objfile *dwarf2_per_objfile)
10324 {
10325   for (dwarf2_per_cu_data *iter : dwarf2_per_objfile->just_read_cus)
10326     {
10327       if (! iter->is_debug_types)
10328         compute_compunit_symtab_includes (iter);
10329     }
10330
10331   dwarf2_per_objfile->just_read_cus.clear ();
10332 }
10333
10334 /* Generate full symbol information for PER_CU, whose DIEs have
10335    already been loaded into memory.  */
10336
10337 static void
10338 process_full_comp_unit (struct dwarf2_per_cu_data *per_cu,
10339                         enum language pretend_language)
10340 {
10341   struct dwarf2_cu *cu = per_cu->cu;
10342   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
10343   struct objfile *objfile = dwarf2_per_objfile->objfile;
10344   struct gdbarch *gdbarch = get_objfile_arch (objfile);
10345   CORE_ADDR lowpc, highpc;
10346   struct compunit_symtab *cust;
10347   CORE_ADDR baseaddr;
10348   struct block *static_block;
10349   CORE_ADDR addr;
10350
10351   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
10352
10353   /* Clear the list here in case something was left over.  */
10354   cu->method_list.clear ();
10355
10356   cu->language = pretend_language;
10357   cu->language_defn = language_def (cu->language);
10358
10359   /* Do line number decoding in read_file_scope () */
10360   process_die (cu->dies, cu);
10361
10362   /* For now fudge the Go package.  */
10363   if (cu->language == language_go)
10364     fixup_go_packaging (cu);
10365
10366   /* Now that we have processed all the DIEs in the CU, all the types 
10367      should be complete, and it should now be safe to compute all of the
10368      physnames.  */
10369   compute_delayed_physnames (cu);
10370
10371   if (cu->language == language_rust)
10372     rust_union_quirks (cu);
10373
10374   /* Some compilers don't define a DW_AT_high_pc attribute for the
10375      compilation unit.  If the DW_AT_high_pc is missing, synthesize
10376      it, by scanning the DIE's below the compilation unit.  */
10377   get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
10378
10379   addr = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
10380   static_block = cu->get_builder ()->end_symtab_get_static_block (addr, 0, 1);
10381
10382   /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
10383      Also, DW_AT_ranges may record ranges not belonging to any child DIEs
10384      (such as virtual method tables).  Record the ranges in STATIC_BLOCK's
10385      addrmap to help ensure it has an accurate map of pc values belonging to
10386      this comp unit.  */
10387   dwarf2_record_block_ranges (cu->dies, static_block, baseaddr, cu);
10388
10389   cust = cu->get_builder ()->end_symtab_from_static_block (static_block,
10390                                                     SECT_OFF_TEXT (objfile),
10391                                                     0);
10392
10393   if (cust != NULL)
10394     {
10395       int gcc_4_minor = producer_is_gcc_ge_4 (cu->producer);
10396
10397       /* Set symtab language to language from DW_AT_language.  If the
10398          compilation is from a C file generated by language preprocessors, do
10399          not set the language if it was already deduced by start_subfile.  */
10400       if (!(cu->language == language_c
10401             && COMPUNIT_FILETABS (cust)->language != language_unknown))
10402         COMPUNIT_FILETABS (cust)->language = cu->language;
10403
10404       /* GCC-4.0 has started to support -fvar-tracking.  GCC-3.x still can
10405          produce DW_AT_location with location lists but it can be possibly
10406          invalid without -fvar-tracking.  Still up to GCC-4.4.x incl. 4.4.0
10407          there were bugs in prologue debug info, fixed later in GCC-4.5
10408          by "unwind info for epilogues" patch (which is not directly related).
10409
10410          For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
10411          needed, it would be wrong due to missing DW_AT_producer there.
10412
10413          Still one can confuse GDB by using non-standard GCC compilation
10414          options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
10415          */ 
10416       if (cu->has_loclist && gcc_4_minor >= 5)
10417         cust->locations_valid = 1;
10418
10419       if (gcc_4_minor >= 5)
10420         cust->epilogue_unwind_valid = 1;
10421
10422       cust->call_site_htab = cu->call_site_htab;
10423     }
10424
10425   if (dwarf2_per_objfile->using_index)
10426     per_cu->v.quick->compunit_symtab = cust;
10427   else
10428     {
10429       struct partial_symtab *pst = per_cu->v.psymtab;
10430       pst->compunit_symtab = cust;
10431       pst->readin = 1;
10432     }
10433
10434   /* Push it for inclusion processing later.  */
10435   dwarf2_per_objfile->just_read_cus.push_back (per_cu);
10436
10437   /* Not needed any more.  */
10438   cu->reset_builder ();
10439 }
10440
10441 /* Generate full symbol information for type unit PER_CU, whose DIEs have
10442    already been loaded into memory.  */
10443
10444 static void
10445 process_full_type_unit (struct dwarf2_per_cu_data *per_cu,
10446                         enum language pretend_language)
10447 {
10448   struct dwarf2_cu *cu = per_cu->cu;
10449   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
10450   struct objfile *objfile = dwarf2_per_objfile->objfile;
10451   struct compunit_symtab *cust;
10452   struct signatured_type *sig_type;
10453
10454   gdb_assert (per_cu->is_debug_types);
10455   sig_type = (struct signatured_type *) per_cu;
10456
10457   /* Clear the list here in case something was left over.  */
10458   cu->method_list.clear ();
10459
10460   cu->language = pretend_language;
10461   cu->language_defn = language_def (cu->language);
10462
10463   /* The symbol tables are set up in read_type_unit_scope.  */
10464   process_die (cu->dies, cu);
10465
10466   /* For now fudge the Go package.  */
10467   if (cu->language == language_go)
10468     fixup_go_packaging (cu);
10469
10470   /* Now that we have processed all the DIEs in the CU, all the types 
10471      should be complete, and it should now be safe to compute all of the
10472      physnames.  */
10473   compute_delayed_physnames (cu);
10474
10475   if (cu->language == language_rust)
10476     rust_union_quirks (cu);
10477
10478   /* TUs share symbol tables.
10479      If this is the first TU to use this symtab, complete the construction
10480      of it with end_expandable_symtab.  Otherwise, complete the addition of
10481      this TU's symbols to the existing symtab.  */
10482   if (sig_type->type_unit_group->compunit_symtab == NULL)
10483     {
10484       buildsym_compunit *builder = cu->get_builder ();
10485       cust = builder->end_expandable_symtab (0, SECT_OFF_TEXT (objfile));
10486       sig_type->type_unit_group->compunit_symtab = cust;
10487
10488       if (cust != NULL)
10489         {
10490           /* Set symtab language to language from DW_AT_language.  If the
10491              compilation is from a C file generated by language preprocessors,
10492              do not set the language if it was already deduced by
10493              start_subfile.  */
10494           if (!(cu->language == language_c
10495                 && COMPUNIT_FILETABS (cust)->language != language_c))
10496             COMPUNIT_FILETABS (cust)->language = cu->language;
10497         }
10498     }
10499   else
10500     {
10501       cu->get_builder ()->augment_type_symtab ();
10502       cust = sig_type->type_unit_group->compunit_symtab;
10503     }
10504
10505   if (dwarf2_per_objfile->using_index)
10506     per_cu->v.quick->compunit_symtab = cust;
10507   else
10508     {
10509       struct partial_symtab *pst = per_cu->v.psymtab;
10510       pst->compunit_symtab = cust;
10511       pst->readin = 1;
10512     }
10513
10514   /* Not needed any more.  */
10515   cu->reset_builder ();
10516 }
10517
10518 /* Process an imported unit DIE.  */
10519
10520 static void
10521 process_imported_unit_die (struct die_info *die, struct dwarf2_cu *cu)
10522 {
10523   struct attribute *attr;
10524
10525   /* For now we don't handle imported units in type units.  */
10526   if (cu->per_cu->is_debug_types)
10527     {
10528       error (_("Dwarf Error: DW_TAG_imported_unit is not"
10529                " supported in type units [in module %s]"),
10530              objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
10531     }
10532
10533   attr = dwarf2_attr (die, DW_AT_import, cu);
10534   if (attr != NULL)
10535     {
10536       sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
10537       bool is_dwz = (attr->form == DW_FORM_GNU_ref_alt || cu->per_cu->is_dwz);
10538       dwarf2_per_cu_data *per_cu
10539         = dwarf2_find_containing_comp_unit (sect_off, is_dwz,
10540                                             cu->per_cu->dwarf2_per_objfile);
10541
10542       /* If necessary, add it to the queue and load its DIEs.  */
10543       if (maybe_queue_comp_unit (cu, per_cu, cu->language))
10544         load_full_comp_unit (per_cu, false, cu->language);
10545
10546       VEC_safe_push (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
10547                      per_cu);
10548     }
10549 }
10550
10551 /* RAII object that represents a process_die scope: i.e.,
10552    starts/finishes processing a DIE.  */
10553 class process_die_scope
10554 {
10555 public:
10556   process_die_scope (die_info *die, dwarf2_cu *cu)
10557     : m_die (die), m_cu (cu)
10558   {
10559     /* We should only be processing DIEs not already in process.  */
10560     gdb_assert (!m_die->in_process);
10561     m_die->in_process = true;
10562   }
10563
10564   ~process_die_scope ()
10565   {
10566     m_die->in_process = false;
10567
10568     /* If we're done processing the DIE for the CU that owns the line
10569        header, we don't need the line header anymore.  */
10570     if (m_cu->line_header_die_owner == m_die)
10571       {
10572         delete m_cu->line_header;
10573         m_cu->line_header = NULL;
10574         m_cu->line_header_die_owner = NULL;
10575       }
10576   }
10577
10578 private:
10579   die_info *m_die;
10580   dwarf2_cu *m_cu;
10581 };
10582
10583 /* Process a die and its children.  */
10584
10585 static void
10586 process_die (struct die_info *die, struct dwarf2_cu *cu)
10587 {
10588   process_die_scope scope (die, cu);
10589
10590   switch (die->tag)
10591     {
10592     case DW_TAG_padding:
10593       break;
10594     case DW_TAG_compile_unit:
10595     case DW_TAG_partial_unit:
10596       read_file_scope (die, cu);
10597       break;
10598     case DW_TAG_type_unit:
10599       read_type_unit_scope (die, cu);
10600       break;
10601     case DW_TAG_subprogram:
10602     case DW_TAG_inlined_subroutine:
10603       read_func_scope (die, cu);
10604       break;
10605     case DW_TAG_lexical_block:
10606     case DW_TAG_try_block:
10607     case DW_TAG_catch_block:
10608       read_lexical_block_scope (die, cu);
10609       break;
10610     case DW_TAG_call_site:
10611     case DW_TAG_GNU_call_site:
10612       read_call_site_scope (die, cu);
10613       break;
10614     case DW_TAG_class_type:
10615     case DW_TAG_interface_type:
10616     case DW_TAG_structure_type:
10617     case DW_TAG_union_type:
10618       process_structure_scope (die, cu);
10619       break;
10620     case DW_TAG_enumeration_type:
10621       process_enumeration_scope (die, cu);
10622       break;
10623
10624     /* These dies have a type, but processing them does not create
10625        a symbol or recurse to process the children.  Therefore we can
10626        read them on-demand through read_type_die.  */
10627     case DW_TAG_subroutine_type:
10628     case DW_TAG_set_type:
10629     case DW_TAG_array_type:
10630     case DW_TAG_pointer_type:
10631     case DW_TAG_ptr_to_member_type:
10632     case DW_TAG_reference_type:
10633     case DW_TAG_rvalue_reference_type:
10634     case DW_TAG_string_type:
10635       break;
10636
10637     case DW_TAG_base_type:
10638     case DW_TAG_subrange_type:
10639     case DW_TAG_typedef:
10640       /* Add a typedef symbol for the type definition, if it has a
10641          DW_AT_name.  */
10642       new_symbol (die, read_type_die (die, cu), cu);
10643       break;
10644     case DW_TAG_common_block:
10645       read_common_block (die, cu);
10646       break;
10647     case DW_TAG_common_inclusion:
10648       break;
10649     case DW_TAG_namespace:
10650       cu->processing_has_namespace_info = true;
10651       read_namespace (die, cu);
10652       break;
10653     case DW_TAG_module:
10654       cu->processing_has_namespace_info = true;
10655       read_module (die, cu);
10656       break;
10657     case DW_TAG_imported_declaration:
10658       cu->processing_has_namespace_info = true;
10659       if (read_namespace_alias (die, cu))
10660         break;
10661       /* The declaration is not a global namespace alias.  */
10662       /* Fall through.  */
10663     case DW_TAG_imported_module:
10664       cu->processing_has_namespace_info = true;
10665       if (die->child != NULL && (die->tag == DW_TAG_imported_declaration
10666                                  || cu->language != language_fortran))
10667         complaint (_("Tag '%s' has unexpected children"),
10668                    dwarf_tag_name (die->tag));
10669       read_import_statement (die, cu);
10670       break;
10671
10672     case DW_TAG_imported_unit:
10673       process_imported_unit_die (die, cu);
10674       break;
10675
10676     case DW_TAG_variable:
10677       read_variable (die, cu);
10678       break;
10679
10680     default:
10681       new_symbol (die, NULL, cu);
10682       break;
10683     }
10684 }
10685 \f
10686 /* DWARF name computation.  */
10687
10688 /* A helper function for dwarf2_compute_name which determines whether DIE
10689    needs to have the name of the scope prepended to the name listed in the
10690    die.  */
10691
10692 static int
10693 die_needs_namespace (struct die_info *die, struct dwarf2_cu *cu)
10694 {
10695   struct attribute *attr;
10696
10697   switch (die->tag)
10698     {
10699     case DW_TAG_namespace:
10700     case DW_TAG_typedef:
10701     case DW_TAG_class_type:
10702     case DW_TAG_interface_type:
10703     case DW_TAG_structure_type:
10704     case DW_TAG_union_type:
10705     case DW_TAG_enumeration_type:
10706     case DW_TAG_enumerator:
10707     case DW_TAG_subprogram:
10708     case DW_TAG_inlined_subroutine:
10709     case DW_TAG_member:
10710     case DW_TAG_imported_declaration:
10711       return 1;
10712
10713     case DW_TAG_variable:
10714     case DW_TAG_constant:
10715       /* We only need to prefix "globally" visible variables.  These include
10716          any variable marked with DW_AT_external or any variable that
10717          lives in a namespace.  [Variables in anonymous namespaces
10718          require prefixing, but they are not DW_AT_external.]  */
10719
10720       if (dwarf2_attr (die, DW_AT_specification, cu))
10721         {
10722           struct dwarf2_cu *spec_cu = cu;
10723
10724           return die_needs_namespace (die_specification (die, &spec_cu),
10725                                       spec_cu);
10726         }
10727
10728       attr = dwarf2_attr (die, DW_AT_external, cu);
10729       if (attr == NULL && die->parent->tag != DW_TAG_namespace
10730           && die->parent->tag != DW_TAG_module)
10731         return 0;
10732       /* A variable in a lexical block of some kind does not need a
10733          namespace, even though in C++ such variables may be external
10734          and have a mangled name.  */
10735       if (die->parent->tag ==  DW_TAG_lexical_block
10736           || die->parent->tag ==  DW_TAG_try_block
10737           || die->parent->tag ==  DW_TAG_catch_block
10738           || die->parent->tag == DW_TAG_subprogram)
10739         return 0;
10740       return 1;
10741
10742     default:
10743       return 0;
10744     }
10745 }
10746
10747 /* Return the DIE's linkage name attribute, either DW_AT_linkage_name
10748    or DW_AT_MIPS_linkage_name.  Returns NULL if the attribute is not
10749    defined for the given DIE.  */
10750
10751 static struct attribute *
10752 dw2_linkage_name_attr (struct die_info *die, struct dwarf2_cu *cu)
10753 {
10754   struct attribute *attr;
10755
10756   attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
10757   if (attr == NULL)
10758     attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
10759
10760   return attr;
10761 }
10762
10763 /* Return the DIE's linkage name as a string, either DW_AT_linkage_name
10764    or DW_AT_MIPS_linkage_name.  Returns NULL if the attribute is not
10765    defined for the given DIE.  */
10766
10767 static const char *
10768 dw2_linkage_name (struct die_info *die, struct dwarf2_cu *cu)
10769 {
10770   const char *linkage_name;
10771
10772   linkage_name = dwarf2_string_attr (die, DW_AT_linkage_name, cu);
10773   if (linkage_name == NULL)
10774     linkage_name = dwarf2_string_attr (die, DW_AT_MIPS_linkage_name, cu);
10775
10776   return linkage_name;
10777 }
10778
10779 /* Compute the fully qualified name of DIE in CU.  If PHYSNAME is nonzero,
10780    compute the physname for the object, which include a method's:
10781    - formal parameters (C++),
10782    - receiver type (Go),
10783
10784    The term "physname" is a bit confusing.
10785    For C++, for example, it is the demangled name.
10786    For Go, for example, it's the mangled name.
10787
10788    For Ada, return the DIE's linkage name rather than the fully qualified
10789    name.  PHYSNAME is ignored..
10790
10791    The result is allocated on the objfile_obstack and canonicalized.  */
10792
10793 static const char *
10794 dwarf2_compute_name (const char *name,
10795                      struct die_info *die, struct dwarf2_cu *cu,
10796                      int physname)
10797 {
10798   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
10799
10800   if (name == NULL)
10801     name = dwarf2_name (die, cu);
10802
10803   /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
10804      but otherwise compute it by typename_concat inside GDB.
10805      FIXME: Actually this is not really true, or at least not always true.
10806      It's all very confusing.  SYMBOL_SET_NAMES doesn't try to demangle
10807      Fortran names because there is no mangling standard.  So new_symbol
10808      will set the demangled name to the result of dwarf2_full_name, and it is
10809      the demangled name that GDB uses if it exists.  */
10810   if (cu->language == language_ada
10811       || (cu->language == language_fortran && physname))
10812     {
10813       /* For Ada unit, we prefer the linkage name over the name, as
10814          the former contains the exported name, which the user expects
10815          to be able to reference.  Ideally, we want the user to be able
10816          to reference this entity using either natural or linkage name,
10817          but we haven't started looking at this enhancement yet.  */
10818       const char *linkage_name = dw2_linkage_name (die, cu);
10819
10820       if (linkage_name != NULL)
10821         return linkage_name;
10822     }
10823
10824   /* These are the only languages we know how to qualify names in.  */
10825   if (name != NULL
10826       && (cu->language == language_cplus
10827           || cu->language == language_fortran || cu->language == language_d
10828           || cu->language == language_rust))
10829     {
10830       if (die_needs_namespace (die, cu))
10831         {
10832           const char *prefix;
10833           const char *canonical_name = NULL;
10834
10835           string_file buf;
10836
10837           prefix = determine_prefix (die, cu);
10838           if (*prefix != '\0')
10839             {
10840               char *prefixed_name = typename_concat (NULL, prefix, name,
10841                                                      physname, cu);
10842
10843               buf.puts (prefixed_name);
10844               xfree (prefixed_name);
10845             }
10846           else
10847             buf.puts (name);
10848
10849           /* Template parameters may be specified in the DIE's DW_AT_name, or
10850              as children with DW_TAG_template_type_param or
10851              DW_TAG_value_type_param.  If the latter, add them to the name
10852              here.  If the name already has template parameters, then
10853              skip this step; some versions of GCC emit both, and
10854              it is more efficient to use the pre-computed name.
10855
10856              Something to keep in mind about this process: it is very
10857              unlikely, or in some cases downright impossible, to produce
10858              something that will match the mangled name of a function.
10859              If the definition of the function has the same debug info,
10860              we should be able to match up with it anyway.  But fallbacks
10861              using the minimal symbol, for instance to find a method
10862              implemented in a stripped copy of libstdc++, will not work.
10863              If we do not have debug info for the definition, we will have to
10864              match them up some other way.
10865
10866              When we do name matching there is a related problem with function
10867              templates; two instantiated function templates are allowed to
10868              differ only by their return types, which we do not add here.  */
10869
10870           if (cu->language == language_cplus && strchr (name, '<') == NULL)
10871             {
10872               struct attribute *attr;
10873               struct die_info *child;
10874               int first = 1;
10875
10876               die->building_fullname = 1;
10877
10878               for (child = die->child; child != NULL; child = child->sibling)
10879                 {
10880                   struct type *type;
10881                   LONGEST value;
10882                   const gdb_byte *bytes;
10883                   struct dwarf2_locexpr_baton *baton;
10884                   struct value *v;
10885
10886                   if (child->tag != DW_TAG_template_type_param
10887                       && child->tag != DW_TAG_template_value_param)
10888                     continue;
10889
10890                   if (first)
10891                     {
10892                       buf.puts ("<");
10893                       first = 0;
10894                     }
10895                   else
10896                     buf.puts (", ");
10897
10898                   attr = dwarf2_attr (child, DW_AT_type, cu);
10899                   if (attr == NULL)
10900                     {
10901                       complaint (_("template parameter missing DW_AT_type"));
10902                       buf.puts ("UNKNOWN_TYPE");
10903                       continue;
10904                     }
10905                   type = die_type (child, cu);
10906
10907                   if (child->tag == DW_TAG_template_type_param)
10908                     {
10909                       c_print_type (type, "", &buf, -1, 0, cu->language,
10910                                     &type_print_raw_options);
10911                       continue;
10912                     }
10913
10914                   attr = dwarf2_attr (child, DW_AT_const_value, cu);
10915                   if (attr == NULL)
10916                     {
10917                       complaint (_("template parameter missing "
10918                                    "DW_AT_const_value"));
10919                       buf.puts ("UNKNOWN_VALUE");
10920                       continue;
10921                     }
10922
10923                   dwarf2_const_value_attr (attr, type, name,
10924                                            &cu->comp_unit_obstack, cu,
10925                                            &value, &bytes, &baton);
10926
10927                   if (TYPE_NOSIGN (type))
10928                     /* GDB prints characters as NUMBER 'CHAR'.  If that's
10929                        changed, this can use value_print instead.  */
10930                     c_printchar (value, type, &buf);
10931                   else
10932                     {
10933                       struct value_print_options opts;
10934
10935                       if (baton != NULL)
10936                         v = dwarf2_evaluate_loc_desc (type, NULL,
10937                                                       baton->data,
10938                                                       baton->size,
10939                                                       baton->per_cu);
10940                       else if (bytes != NULL)
10941                         {
10942                           v = allocate_value (type);
10943                           memcpy (value_contents_writeable (v), bytes,
10944                                   TYPE_LENGTH (type));
10945                         }
10946                       else
10947                         v = value_from_longest (type, value);
10948
10949                       /* Specify decimal so that we do not depend on
10950                          the radix.  */
10951                       get_formatted_print_options (&opts, 'd');
10952                       opts.raw = 1;
10953                       value_print (v, &buf, &opts);
10954                       release_value (v);
10955                     }
10956                 }
10957
10958               die->building_fullname = 0;
10959
10960               if (!first)
10961                 {
10962                   /* Close the argument list, with a space if necessary
10963                      (nested templates).  */
10964                   if (!buf.empty () && buf.string ().back () == '>')
10965                     buf.puts (" >");
10966                   else
10967                     buf.puts (">");
10968                 }
10969             }
10970
10971           /* For C++ methods, append formal parameter type
10972              information, if PHYSNAME.  */
10973
10974           if (physname && die->tag == DW_TAG_subprogram
10975               && cu->language == language_cplus)
10976             {
10977               struct type *type = read_type_die (die, cu);
10978
10979               c_type_print_args (type, &buf, 1, cu->language,
10980                                  &type_print_raw_options);
10981
10982               if (cu->language == language_cplus)
10983                 {
10984                   /* Assume that an artificial first parameter is
10985                      "this", but do not crash if it is not.  RealView
10986                      marks unnamed (and thus unused) parameters as
10987                      artificial; there is no way to differentiate
10988                      the two cases.  */
10989                   if (TYPE_NFIELDS (type) > 0
10990                       && TYPE_FIELD_ARTIFICIAL (type, 0)
10991                       && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_PTR
10992                       && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type,
10993                                                                         0))))
10994                     buf.puts (" const");
10995                 }
10996             }
10997
10998           const std::string &intermediate_name = buf.string ();
10999
11000           if (cu->language == language_cplus)
11001             canonical_name
11002               = dwarf2_canonicalize_name (intermediate_name.c_str (), cu,
11003                                           &objfile->per_bfd->storage_obstack);
11004
11005           /* If we only computed INTERMEDIATE_NAME, or if
11006              INTERMEDIATE_NAME is already canonical, then we need to
11007              copy it to the appropriate obstack.  */
11008           if (canonical_name == NULL || canonical_name == intermediate_name.c_str ())
11009             name = ((const char *)
11010                     obstack_copy0 (&objfile->per_bfd->storage_obstack,
11011                                    intermediate_name.c_str (),
11012                                    intermediate_name.length ()));
11013           else
11014             name = canonical_name;
11015         }
11016     }
11017
11018   return name;
11019 }
11020
11021 /* Return the fully qualified name of DIE, based on its DW_AT_name.
11022    If scope qualifiers are appropriate they will be added.  The result
11023    will be allocated on the storage_obstack, or NULL if the DIE does
11024    not have a name.  NAME may either be from a previous call to
11025    dwarf2_name or NULL.
11026
11027    The output string will be canonicalized (if C++).  */
11028
11029 static const char *
11030 dwarf2_full_name (const char *name, struct die_info *die, struct dwarf2_cu *cu)
11031 {
11032   return dwarf2_compute_name (name, die, cu, 0);
11033 }
11034
11035 /* Construct a physname for the given DIE in CU.  NAME may either be
11036    from a previous call to dwarf2_name or NULL.  The result will be
11037    allocated on the objfile_objstack or NULL if the DIE does not have a
11038    name.
11039
11040    The output string will be canonicalized (if C++).  */
11041
11042 static const char *
11043 dwarf2_physname (const char *name, struct die_info *die, struct dwarf2_cu *cu)
11044 {
11045   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
11046   const char *retval, *mangled = NULL, *canon = NULL;
11047   int need_copy = 1;
11048
11049   /* In this case dwarf2_compute_name is just a shortcut not building anything
11050      on its own.  */
11051   if (!die_needs_namespace (die, cu))
11052     return dwarf2_compute_name (name, die, cu, 1);
11053
11054   mangled = dw2_linkage_name (die, cu);
11055
11056   /* rustc emits invalid values for DW_AT_linkage_name.  Ignore these.
11057      See https://github.com/rust-lang/rust/issues/32925.  */
11058   if (cu->language == language_rust && mangled != NULL
11059       && strchr (mangled, '{') != NULL)
11060     mangled = NULL;
11061
11062   /* DW_AT_linkage_name is missing in some cases - depend on what GDB
11063      has computed.  */
11064   gdb::unique_xmalloc_ptr<char> demangled;
11065   if (mangled != NULL)
11066     {
11067
11068       if (language_def (cu->language)->la_store_sym_names_in_linkage_form_p)
11069         {
11070           /* Do nothing (do not demangle the symbol name).  */
11071         }
11072       else if (cu->language == language_go)
11073         {
11074           /* This is a lie, but we already lie to the caller new_symbol.
11075              new_symbol assumes we return the mangled name.
11076              This just undoes that lie until things are cleaned up.  */
11077         }
11078       else
11079         {
11080           /* Use DMGL_RET_DROP for C++ template functions to suppress
11081              their return type.  It is easier for GDB users to search
11082              for such functions as `name(params)' than `long name(params)'.
11083              In such case the minimal symbol names do not match the full
11084              symbol names but for template functions there is never a need
11085              to look up their definition from their declaration so
11086              the only disadvantage remains the minimal symbol variant
11087              `long name(params)' does not have the proper inferior type.  */
11088           demangled.reset (gdb_demangle (mangled,
11089                                          (DMGL_PARAMS | DMGL_ANSI
11090                                           | DMGL_RET_DROP)));
11091         }
11092       if (demangled)
11093         canon = demangled.get ();
11094       else
11095         {
11096           canon = mangled;
11097           need_copy = 0;
11098         }
11099     }
11100
11101   if (canon == NULL || check_physname)
11102     {
11103       const char *physname = dwarf2_compute_name (name, die, cu, 1);
11104
11105       if (canon != NULL && strcmp (physname, canon) != 0)
11106         {
11107           /* It may not mean a bug in GDB.  The compiler could also
11108              compute DW_AT_linkage_name incorrectly.  But in such case
11109              GDB would need to be bug-to-bug compatible.  */
11110
11111           complaint (_("Computed physname <%s> does not match demangled <%s> "
11112                        "(from linkage <%s>) - DIE at %s [in module %s]"),
11113                      physname, canon, mangled, sect_offset_str (die->sect_off),
11114                      objfile_name (objfile));
11115
11116           /* Prefer DW_AT_linkage_name (in the CANON form) - when it
11117              is available here - over computed PHYSNAME.  It is safer
11118              against both buggy GDB and buggy compilers.  */
11119
11120           retval = canon;
11121         }
11122       else
11123         {
11124           retval = physname;
11125           need_copy = 0;
11126         }
11127     }
11128   else
11129     retval = canon;
11130
11131   if (need_copy)
11132     retval = ((const char *)
11133               obstack_copy0 (&objfile->per_bfd->storage_obstack,
11134                              retval, strlen (retval)));
11135
11136   return retval;
11137 }
11138
11139 /* Inspect DIE in CU for a namespace alias.  If one exists, record
11140    a new symbol for it.
11141
11142    Returns 1 if a namespace alias was recorded, 0 otherwise.  */
11143
11144 static int
11145 read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu)
11146 {
11147   struct attribute *attr;
11148
11149   /* If the die does not have a name, this is not a namespace
11150      alias.  */
11151   attr = dwarf2_attr (die, DW_AT_name, cu);
11152   if (attr != NULL)
11153     {
11154       int num;
11155       struct die_info *d = die;
11156       struct dwarf2_cu *imported_cu = cu;
11157
11158       /* If the compiler has nested DW_AT_imported_declaration DIEs,
11159          keep inspecting DIEs until we hit the underlying import.  */
11160 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
11161       for (num = 0; num  < MAX_NESTED_IMPORTED_DECLARATIONS; ++num)
11162         {
11163           attr = dwarf2_attr (d, DW_AT_import, cu);
11164           if (attr == NULL)
11165             break;
11166
11167           d = follow_die_ref (d, attr, &imported_cu);
11168           if (d->tag != DW_TAG_imported_declaration)
11169             break;
11170         }
11171
11172       if (num == MAX_NESTED_IMPORTED_DECLARATIONS)
11173         {
11174           complaint (_("DIE at %s has too many recursively imported "
11175                        "declarations"), sect_offset_str (d->sect_off));
11176           return 0;
11177         }
11178
11179       if (attr != NULL)
11180         {
11181           struct type *type;
11182           sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
11183
11184           type = get_die_type_at_offset (sect_off, cu->per_cu);
11185           if (type != NULL && TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
11186             {
11187               /* This declaration is a global namespace alias.  Add
11188                  a symbol for it whose type is the aliased namespace.  */
11189               new_symbol (die, type, cu);
11190               return 1;
11191             }
11192         }
11193     }
11194
11195   return 0;
11196 }
11197
11198 /* Return the using directives repository (global or local?) to use in the
11199    current context for CU.
11200
11201    For Ada, imported declarations can materialize renamings, which *may* be
11202    global.  However it is impossible (for now?) in DWARF to distinguish
11203    "external" imported declarations and "static" ones.  As all imported
11204    declarations seem to be static in all other languages, make them all CU-wide
11205    global only in Ada.  */
11206
11207 static struct using_direct **
11208 using_directives (struct dwarf2_cu *cu)
11209 {
11210   if (cu->language == language_ada
11211       && cu->get_builder ()->outermost_context_p ())
11212     return cu->get_builder ()->get_global_using_directives ();
11213   else
11214     return cu->get_builder ()->get_local_using_directives ();
11215 }
11216
11217 /* Read the import statement specified by the given die and record it.  */
11218
11219 static void
11220 read_import_statement (struct die_info *die, struct dwarf2_cu *cu)
11221 {
11222   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
11223   struct attribute *import_attr;
11224   struct die_info *imported_die, *child_die;
11225   struct dwarf2_cu *imported_cu;
11226   const char *imported_name;
11227   const char *imported_name_prefix;
11228   const char *canonical_name;
11229   const char *import_alias;
11230   const char *imported_declaration = NULL;
11231   const char *import_prefix;
11232   std::vector<const char *> excludes;
11233
11234   import_attr = dwarf2_attr (die, DW_AT_import, cu);
11235   if (import_attr == NULL)
11236     {
11237       complaint (_("Tag '%s' has no DW_AT_import"),
11238                  dwarf_tag_name (die->tag));
11239       return;
11240     }
11241
11242   imported_cu = cu;
11243   imported_die = follow_die_ref_or_sig (die, import_attr, &imported_cu);
11244   imported_name = dwarf2_name (imported_die, imported_cu);
11245   if (imported_name == NULL)
11246     {
11247       /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
11248
11249         The import in the following code:
11250         namespace A
11251           {
11252             typedef int B;
11253           }
11254
11255         int main ()
11256           {
11257             using A::B;
11258             B b;
11259             return b;
11260           }
11261
11262         ...
11263          <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
11264             <52>   DW_AT_decl_file   : 1
11265             <53>   DW_AT_decl_line   : 6
11266             <54>   DW_AT_import      : <0x75>
11267          <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
11268             <59>   DW_AT_name        : B
11269             <5b>   DW_AT_decl_file   : 1
11270             <5c>   DW_AT_decl_line   : 2
11271             <5d>   DW_AT_type        : <0x6e>
11272         ...
11273          <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
11274             <76>   DW_AT_byte_size   : 4
11275             <77>   DW_AT_encoding    : 5        (signed)
11276
11277         imports the wrong die ( 0x75 instead of 0x58 ).
11278         This case will be ignored until the gcc bug is fixed.  */
11279       return;
11280     }
11281
11282   /* Figure out the local name after import.  */
11283   import_alias = dwarf2_name (die, cu);
11284
11285   /* Figure out where the statement is being imported to.  */
11286   import_prefix = determine_prefix (die, cu);
11287
11288   /* Figure out what the scope of the imported die is and prepend it
11289      to the name of the imported die.  */
11290   imported_name_prefix = determine_prefix (imported_die, imported_cu);
11291
11292   if (imported_die->tag != DW_TAG_namespace
11293       && imported_die->tag != DW_TAG_module)
11294     {
11295       imported_declaration = imported_name;
11296       canonical_name = imported_name_prefix;
11297     }
11298   else if (strlen (imported_name_prefix) > 0)
11299     canonical_name = obconcat (&objfile->objfile_obstack,
11300                                imported_name_prefix,
11301                                (cu->language == language_d ? "." : "::"),
11302                                imported_name, (char *) NULL);
11303   else
11304     canonical_name = imported_name;
11305
11306   if (die->tag == DW_TAG_imported_module && cu->language == language_fortran)
11307     for (child_die = die->child; child_die && child_die->tag;
11308          child_die = sibling_die (child_die))
11309       {
11310         /* DWARF-4: A Fortran use statement with a “rename list” may be
11311            represented by an imported module entry with an import attribute
11312            referring to the module and owned entries corresponding to those
11313            entities that are renamed as part of being imported.  */
11314
11315         if (child_die->tag != DW_TAG_imported_declaration)
11316           {
11317             complaint (_("child DW_TAG_imported_declaration expected "
11318                          "- DIE at %s [in module %s]"),
11319                        sect_offset_str (child_die->sect_off),
11320                        objfile_name (objfile));
11321             continue;
11322           }
11323
11324         import_attr = dwarf2_attr (child_die, DW_AT_import, cu);
11325         if (import_attr == NULL)
11326           {
11327             complaint (_("Tag '%s' has no DW_AT_import"),
11328                        dwarf_tag_name (child_die->tag));
11329             continue;
11330           }
11331
11332         imported_cu = cu;
11333         imported_die = follow_die_ref_or_sig (child_die, import_attr,
11334                                               &imported_cu);
11335         imported_name = dwarf2_name (imported_die, imported_cu);
11336         if (imported_name == NULL)
11337           {
11338             complaint (_("child DW_TAG_imported_declaration has unknown "
11339                          "imported name - DIE at %s [in module %s]"),
11340                        sect_offset_str (child_die->sect_off),
11341                        objfile_name (objfile));
11342             continue;
11343           }
11344
11345         excludes.push_back (imported_name);
11346
11347         process_die (child_die, cu);
11348       }
11349
11350   add_using_directive (using_directives (cu),
11351                        import_prefix,
11352                        canonical_name,
11353                        import_alias,
11354                        imported_declaration,
11355                        excludes,
11356                        0,
11357                        &objfile->objfile_obstack);
11358 }
11359
11360 /* ICC<14 does not output the required DW_AT_declaration on incomplete
11361    types, but gives them a size of zero.  Starting with version 14,
11362    ICC is compatible with GCC.  */
11363
11364 static bool
11365 producer_is_icc_lt_14 (struct dwarf2_cu *cu)
11366 {
11367   if (!cu->checked_producer)
11368     check_producer (cu);
11369
11370   return cu->producer_is_icc_lt_14;
11371 }
11372
11373 /* ICC generates a DW_AT_type for C void functions.  This was observed on
11374    ICC 14.0.5.212, and appears to be against the DWARF spec (V5 3.3.2)
11375    which says that void functions should not have a DW_AT_type.  */
11376
11377 static bool
11378 producer_is_icc (struct dwarf2_cu *cu)
11379 {
11380   if (!cu->checked_producer)
11381     check_producer (cu);
11382
11383   return cu->producer_is_icc;
11384 }
11385
11386 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
11387    directory paths.  GCC SVN r127613 (new option -fdebug-prefix-map) fixed
11388    this, it was first present in GCC release 4.3.0.  */
11389
11390 static bool
11391 producer_is_gcc_lt_4_3 (struct dwarf2_cu *cu)
11392 {
11393   if (!cu->checked_producer)
11394     check_producer (cu);
11395
11396   return cu->producer_is_gcc_lt_4_3;
11397 }
11398
11399 static file_and_directory
11400 find_file_and_directory (struct die_info *die, struct dwarf2_cu *cu)
11401 {
11402   file_and_directory res;
11403
11404   /* Find the filename.  Do not use dwarf2_name here, since the filename
11405      is not a source language identifier.  */
11406   res.name = dwarf2_string_attr (die, DW_AT_name, cu);
11407   res.comp_dir = dwarf2_string_attr (die, DW_AT_comp_dir, cu);
11408
11409   if (res.comp_dir == NULL
11410       && producer_is_gcc_lt_4_3 (cu) && res.name != NULL
11411       && IS_ABSOLUTE_PATH (res.name))
11412     {
11413       res.comp_dir_storage = ldirname (res.name);
11414       if (!res.comp_dir_storage.empty ())
11415         res.comp_dir = res.comp_dir_storage.c_str ();
11416     }
11417   if (res.comp_dir != NULL)
11418     {
11419       /* Irix 6.2 native cc prepends <machine>.: to the compilation
11420          directory, get rid of it.  */
11421       const char *cp = strchr (res.comp_dir, ':');
11422
11423       if (cp && cp != res.comp_dir && cp[-1] == '.' && cp[1] == '/')
11424         res.comp_dir = cp + 1;
11425     }
11426
11427   if (res.name == NULL)
11428     res.name = "<unknown>";
11429
11430   return res;
11431 }
11432
11433 /* Handle DW_AT_stmt_list for a compilation unit.
11434    DIE is the DW_TAG_compile_unit die for CU.
11435    COMP_DIR is the compilation directory.  LOWPC is passed to
11436    dwarf_decode_lines.  See dwarf_decode_lines comments about it.  */
11437
11438 static void
11439 handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
11440                         const char *comp_dir, CORE_ADDR lowpc) /* ARI: editCase function */
11441 {
11442   struct dwarf2_per_objfile *dwarf2_per_objfile
11443     = cu->per_cu->dwarf2_per_objfile;
11444   struct objfile *objfile = dwarf2_per_objfile->objfile;
11445   struct attribute *attr;
11446   struct line_header line_header_local;
11447   hashval_t line_header_local_hash;
11448   void **slot;
11449   int decode_mapping;
11450
11451   gdb_assert (! cu->per_cu->is_debug_types);
11452
11453   attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
11454   if (attr == NULL)
11455     return;
11456
11457   sect_offset line_offset = (sect_offset) DW_UNSND (attr);
11458
11459   /* The line header hash table is only created if needed (it exists to
11460      prevent redundant reading of the line table for partial_units).
11461      If we're given a partial_unit, we'll need it.  If we're given a
11462      compile_unit, then use the line header hash table if it's already
11463      created, but don't create one just yet.  */
11464
11465   if (dwarf2_per_objfile->line_header_hash == NULL
11466       && die->tag == DW_TAG_partial_unit)
11467     {
11468       dwarf2_per_objfile->line_header_hash
11469         = htab_create_alloc_ex (127, line_header_hash_voidp,
11470                                 line_header_eq_voidp,
11471                                 free_line_header_voidp,
11472                                 &objfile->objfile_obstack,
11473                                 hashtab_obstack_allocate,
11474                                 dummy_obstack_deallocate);
11475     }
11476
11477   line_header_local.sect_off = line_offset;
11478   line_header_local.offset_in_dwz = cu->per_cu->is_dwz;
11479   line_header_local_hash = line_header_hash (&line_header_local);
11480   if (dwarf2_per_objfile->line_header_hash != NULL)
11481     {
11482       slot = htab_find_slot_with_hash (dwarf2_per_objfile->line_header_hash,
11483                                        &line_header_local,
11484                                        line_header_local_hash, NO_INSERT);
11485
11486       /* For DW_TAG_compile_unit we need info like symtab::linetable which
11487          is not present in *SLOT (since if there is something in *SLOT then
11488          it will be for a partial_unit).  */
11489       if (die->tag == DW_TAG_partial_unit && slot != NULL)
11490         {
11491           gdb_assert (*slot != NULL);
11492           cu->line_header = (struct line_header *) *slot;
11493           return;
11494         }
11495     }
11496
11497   /* dwarf_decode_line_header does not yet provide sufficient information.
11498      We always have to call also dwarf_decode_lines for it.  */
11499   line_header_up lh = dwarf_decode_line_header (line_offset, cu);
11500   if (lh == NULL)
11501     return;
11502
11503   cu->line_header = lh.release ();
11504   cu->line_header_die_owner = die;
11505
11506   if (dwarf2_per_objfile->line_header_hash == NULL)
11507     slot = NULL;
11508   else
11509     {
11510       slot = htab_find_slot_with_hash (dwarf2_per_objfile->line_header_hash,
11511                                        &line_header_local,
11512                                        line_header_local_hash, INSERT);
11513       gdb_assert (slot != NULL);
11514     }
11515   if (slot != NULL && *slot == NULL)
11516     {
11517       /* This newly decoded line number information unit will be owned
11518          by line_header_hash hash table.  */
11519       *slot = cu->line_header;
11520       cu->line_header_die_owner = NULL;
11521     }
11522   else
11523     {
11524       /* We cannot free any current entry in (*slot) as that struct line_header
11525          may be already used by multiple CUs.  Create only temporary decoded
11526          line_header for this CU - it may happen at most once for each line
11527          number information unit.  And if we're not using line_header_hash
11528          then this is what we want as well.  */
11529       gdb_assert (die->tag != DW_TAG_partial_unit);
11530     }
11531   decode_mapping = (die->tag != DW_TAG_partial_unit);
11532   dwarf_decode_lines (cu->line_header, comp_dir, cu, NULL, lowpc,
11533                       decode_mapping);
11534
11535 }
11536
11537 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit.  */
11538
11539 static void
11540 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
11541 {
11542   struct dwarf2_per_objfile *dwarf2_per_objfile
11543     = cu->per_cu->dwarf2_per_objfile;
11544   struct objfile *objfile = dwarf2_per_objfile->objfile;
11545   struct gdbarch *gdbarch = get_objfile_arch (objfile);
11546   CORE_ADDR lowpc = ((CORE_ADDR) -1);
11547   CORE_ADDR highpc = ((CORE_ADDR) 0);
11548   struct attribute *attr;
11549   struct die_info *child_die;
11550   CORE_ADDR baseaddr;
11551
11552   prepare_one_comp_unit (cu, die, cu->language);
11553   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11554
11555   get_scope_pc_bounds (die, &lowpc, &highpc, cu);
11556
11557   /* If we didn't find a lowpc, set it to highpc to avoid complaints
11558      from finish_block.  */
11559   if (lowpc == ((CORE_ADDR) -1))
11560     lowpc = highpc;
11561   lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
11562
11563   file_and_directory fnd = find_file_and_directory (die, cu);
11564
11565   /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
11566      standardised yet.  As a workaround for the language detection we fall
11567      back to the DW_AT_producer string.  */
11568   if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL") != NULL)
11569     cu->language = language_opencl;
11570
11571   /* Similar hack for Go.  */
11572   if (cu->producer && strstr (cu->producer, "GNU Go ") != NULL)
11573     set_cu_language (DW_LANG_Go, cu);
11574
11575   cu->start_symtab (fnd.name, fnd.comp_dir, lowpc);
11576
11577   /* Decode line number information if present.  We do this before
11578      processing child DIEs, so that the line header table is available
11579      for DW_AT_decl_file.  */
11580   handle_DW_AT_stmt_list (die, cu, fnd.comp_dir, lowpc);
11581
11582   /* Process all dies in compilation unit.  */
11583   if (die->child != NULL)
11584     {
11585       child_die = die->child;
11586       while (child_die && child_die->tag)
11587         {
11588           process_die (child_die, cu);
11589           child_die = sibling_die (child_die);
11590         }
11591     }
11592
11593   /* Decode macro information, if present.  Dwarf 2 macro information
11594      refers to information in the line number info statement program
11595      header, so we can only read it if we've read the header
11596      successfully.  */
11597   attr = dwarf2_attr (die, DW_AT_macros, cu);
11598   if (attr == NULL)
11599     attr = dwarf2_attr (die, DW_AT_GNU_macros, cu);
11600   if (attr && cu->line_header)
11601     {
11602       if (dwarf2_attr (die, DW_AT_macro_info, cu))
11603         complaint (_("CU refers to both DW_AT_macros and DW_AT_macro_info"));
11604
11605       dwarf_decode_macros (cu, DW_UNSND (attr), 1);
11606     }
11607   else
11608     {
11609       attr = dwarf2_attr (die, DW_AT_macro_info, cu);
11610       if (attr && cu->line_header)
11611         {
11612           unsigned int macro_offset = DW_UNSND (attr);
11613
11614           dwarf_decode_macros (cu, macro_offset, 0);
11615         }
11616     }
11617 }
11618
11619 void
11620 dwarf2_cu::setup_type_unit_groups (struct die_info *die)
11621 {
11622   struct type_unit_group *tu_group;
11623   int first_time;
11624   struct attribute *attr;
11625   unsigned int i;
11626   struct signatured_type *sig_type;
11627
11628   gdb_assert (per_cu->is_debug_types);
11629   sig_type = (struct signatured_type *) per_cu;
11630
11631   attr = dwarf2_attr (die, DW_AT_stmt_list, this);
11632
11633   /* If we're using .gdb_index (includes -readnow) then
11634      per_cu->type_unit_group may not have been set up yet.  */
11635   if (sig_type->type_unit_group == NULL)
11636     sig_type->type_unit_group = get_type_unit_group (this, attr);
11637   tu_group = sig_type->type_unit_group;
11638
11639   /* If we've already processed this stmt_list there's no real need to
11640      do it again, we could fake it and just recreate the part we need
11641      (file name,index -> symtab mapping).  If data shows this optimization
11642      is useful we can do it then.  */
11643   first_time = tu_group->compunit_symtab == NULL;
11644
11645   /* We have to handle the case of both a missing DW_AT_stmt_list or bad
11646      debug info.  */
11647   line_header_up lh;
11648   if (attr != NULL)
11649     {
11650       sect_offset line_offset = (sect_offset) DW_UNSND (attr);
11651       lh = dwarf_decode_line_header (line_offset, this);
11652     }
11653   if (lh == NULL)
11654     {
11655       if (first_time)
11656         start_symtab ("", NULL, 0);
11657       else
11658         {
11659           gdb_assert (tu_group->symtabs == NULL);
11660           gdb_assert (m_builder == nullptr);
11661           struct compunit_symtab *cust = tu_group->compunit_symtab;
11662           m_builder.reset (new struct buildsym_compunit
11663                            (COMPUNIT_OBJFILE (cust), "",
11664                             COMPUNIT_DIRNAME (cust),
11665                             compunit_language (cust),
11666                             0, cust));
11667         }
11668       return;
11669     }
11670
11671   line_header = lh.release ();
11672   line_header_die_owner = die;
11673
11674   if (first_time)
11675     {
11676       struct compunit_symtab *cust = start_symtab ("", NULL, 0);
11677
11678       /* Note: We don't assign tu_group->compunit_symtab yet because we're
11679          still initializing it, and our caller (a few levels up)
11680          process_full_type_unit still needs to know if this is the first
11681          time.  */
11682
11683       tu_group->num_symtabs = line_header->file_names.size ();
11684       tu_group->symtabs = XNEWVEC (struct symtab *,
11685                                    line_header->file_names.size ());
11686
11687       for (i = 0; i < line_header->file_names.size (); ++i)
11688         {
11689           file_entry &fe = line_header->file_names[i];
11690
11691           dwarf2_start_subfile (this, fe.name,
11692                                 fe.include_dir (line_header));
11693           buildsym_compunit *b = get_builder ();
11694           if (b->get_current_subfile ()->symtab == NULL)
11695             {
11696               /* NOTE: start_subfile will recognize when it's been
11697                  passed a file it has already seen.  So we can't
11698                  assume there's a simple mapping from
11699                  cu->line_header->file_names to subfiles, plus
11700                  cu->line_header->file_names may contain dups.  */
11701               b->get_current_subfile ()->symtab
11702                 = allocate_symtab (cust, b->get_current_subfile ()->name);
11703             }
11704
11705           fe.symtab = b->get_current_subfile ()->symtab;
11706           tu_group->symtabs[i] = fe.symtab;
11707         }
11708     }
11709   else
11710     {
11711       gdb_assert (m_builder == nullptr);
11712       struct compunit_symtab *cust = tu_group->compunit_symtab;
11713       m_builder.reset (new struct buildsym_compunit
11714                        (COMPUNIT_OBJFILE (cust), "",
11715                         COMPUNIT_DIRNAME (cust),
11716                         compunit_language (cust),
11717                         0, cust));
11718
11719       for (i = 0; i < line_header->file_names.size (); ++i)
11720         {
11721           file_entry &fe = line_header->file_names[i];
11722
11723           fe.symtab = tu_group->symtabs[i];
11724         }
11725     }
11726
11727   /* The main symtab is allocated last.  Type units don't have DW_AT_name
11728      so they don't have a "real" (so to speak) symtab anyway.
11729      There is later code that will assign the main symtab to all symbols
11730      that don't have one.  We need to handle the case of a symbol with a
11731      missing symtab (DW_AT_decl_file) anyway.  */
11732 }
11733
11734 /* Process DW_TAG_type_unit.
11735    For TUs we want to skip the first top level sibling if it's not the
11736    actual type being defined by this TU.  In this case the first top
11737    level sibling is there to provide context only.  */
11738
11739 static void
11740 read_type_unit_scope (struct die_info *die, struct dwarf2_cu *cu)
11741 {
11742   struct die_info *child_die;
11743
11744   prepare_one_comp_unit (cu, die, language_minimal);
11745
11746   /* Initialize (or reinitialize) the machinery for building symtabs.
11747      We do this before processing child DIEs, so that the line header table
11748      is available for DW_AT_decl_file.  */
11749   cu->setup_type_unit_groups (die);
11750
11751   if (die->child != NULL)
11752     {
11753       child_die = die->child;
11754       while (child_die && child_die->tag)
11755         {
11756           process_die (child_die, cu);
11757           child_die = sibling_die (child_die);
11758         }
11759     }
11760 }
11761 \f
11762 /* DWO/DWP files.
11763
11764    http://gcc.gnu.org/wiki/DebugFission
11765    http://gcc.gnu.org/wiki/DebugFissionDWP
11766
11767    To simplify handling of both DWO files ("object" files with the DWARF info)
11768    and DWP files (a file with the DWOs packaged up into one file), we treat
11769    DWP files as having a collection of virtual DWO files.  */
11770
11771 static hashval_t
11772 hash_dwo_file (const void *item)
11773 {
11774   const struct dwo_file *dwo_file = (const struct dwo_file *) item;
11775   hashval_t hash;
11776
11777   hash = htab_hash_string (dwo_file->dwo_name);
11778   if (dwo_file->comp_dir != NULL)
11779     hash += htab_hash_string (dwo_file->comp_dir);
11780   return hash;
11781 }
11782
11783 static int
11784 eq_dwo_file (const void *item_lhs, const void *item_rhs)
11785 {
11786   const struct dwo_file *lhs = (const struct dwo_file *) item_lhs;
11787   const struct dwo_file *rhs = (const struct dwo_file *) item_rhs;
11788
11789   if (strcmp (lhs->dwo_name, rhs->dwo_name) != 0)
11790     return 0;
11791   if (lhs->comp_dir == NULL || rhs->comp_dir == NULL)
11792     return lhs->comp_dir == rhs->comp_dir;
11793   return strcmp (lhs->comp_dir, rhs->comp_dir) == 0;
11794 }
11795
11796 /* Allocate a hash table for DWO files.  */
11797
11798 static htab_t
11799 allocate_dwo_file_hash_table (struct objfile *objfile)
11800 {
11801   return htab_create_alloc_ex (41,
11802                                hash_dwo_file,
11803                                eq_dwo_file,
11804                                NULL,
11805                                &objfile->objfile_obstack,
11806                                hashtab_obstack_allocate,
11807                                dummy_obstack_deallocate);
11808 }
11809
11810 /* Lookup DWO file DWO_NAME.  */
11811
11812 static void **
11813 lookup_dwo_file_slot (struct dwarf2_per_objfile *dwarf2_per_objfile,
11814                       const char *dwo_name,
11815                       const char *comp_dir)
11816 {
11817   struct dwo_file find_entry;
11818   void **slot;
11819
11820   if (dwarf2_per_objfile->dwo_files == NULL)
11821     dwarf2_per_objfile->dwo_files
11822       = allocate_dwo_file_hash_table (dwarf2_per_objfile->objfile);
11823
11824   memset (&find_entry, 0, sizeof (find_entry));
11825   find_entry.dwo_name = dwo_name;
11826   find_entry.comp_dir = comp_dir;
11827   slot = htab_find_slot (dwarf2_per_objfile->dwo_files, &find_entry, INSERT);
11828
11829   return slot;
11830 }
11831
11832 static hashval_t
11833 hash_dwo_unit (const void *item)
11834 {
11835   const struct dwo_unit *dwo_unit = (const struct dwo_unit *) item;
11836
11837   /* This drops the top 32 bits of the id, but is ok for a hash.  */
11838   return dwo_unit->signature;
11839 }
11840
11841 static int
11842 eq_dwo_unit (const void *item_lhs, const void *item_rhs)
11843 {
11844   const struct dwo_unit *lhs = (const struct dwo_unit *) item_lhs;
11845   const struct dwo_unit *rhs = (const struct dwo_unit *) item_rhs;
11846
11847   /* The signature is assumed to be unique within the DWO file.
11848      So while object file CU dwo_id's always have the value zero,
11849      that's OK, assuming each object file DWO file has only one CU,
11850      and that's the rule for now.  */
11851   return lhs->signature == rhs->signature;
11852 }
11853
11854 /* Allocate a hash table for DWO CUs,TUs.
11855    There is one of these tables for each of CUs,TUs for each DWO file.  */
11856
11857 static htab_t
11858 allocate_dwo_unit_table (struct objfile *objfile)
11859 {
11860   /* Start out with a pretty small number.
11861      Generally DWO files contain only one CU and maybe some TUs.  */
11862   return htab_create_alloc_ex (3,
11863                                hash_dwo_unit,
11864                                eq_dwo_unit,
11865                                NULL,
11866                                &objfile->objfile_obstack,
11867                                hashtab_obstack_allocate,
11868                                dummy_obstack_deallocate);
11869 }
11870
11871 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader.  */
11872
11873 struct create_dwo_cu_data
11874 {
11875   struct dwo_file *dwo_file;
11876   struct dwo_unit dwo_unit;
11877 };
11878
11879 /* die_reader_func for create_dwo_cu.  */
11880
11881 static void
11882 create_dwo_cu_reader (const struct die_reader_specs *reader,
11883                       const gdb_byte *info_ptr,
11884                       struct die_info *comp_unit_die,
11885                       int has_children,
11886                       void *datap)
11887 {
11888   struct dwarf2_cu *cu = reader->cu;
11889   sect_offset sect_off = cu->per_cu->sect_off;
11890   struct dwarf2_section_info *section = cu->per_cu->section;
11891   struct create_dwo_cu_data *data = (struct create_dwo_cu_data *) datap;
11892   struct dwo_file *dwo_file = data->dwo_file;
11893   struct dwo_unit *dwo_unit = &data->dwo_unit;
11894   struct attribute *attr;
11895
11896   attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
11897   if (attr == NULL)
11898     {
11899       complaint (_("Dwarf Error: debug entry at offset %s is missing"
11900                    " its dwo_id [in module %s]"),
11901                  sect_offset_str (sect_off), dwo_file->dwo_name);
11902       return;
11903     }
11904
11905   dwo_unit->dwo_file = dwo_file;
11906   dwo_unit->signature = DW_UNSND (attr);
11907   dwo_unit->section = section;
11908   dwo_unit->sect_off = sect_off;
11909   dwo_unit->length = cu->per_cu->length;
11910
11911   if (dwarf_read_debug)
11912     fprintf_unfiltered (gdb_stdlog, "  offset %s, dwo_id %s\n",
11913                         sect_offset_str (sect_off),
11914                         hex_string (dwo_unit->signature));
11915 }
11916
11917 /* Create the dwo_units for the CUs in a DWO_FILE.
11918    Note: This function processes DWO files only, not DWP files.  */
11919
11920 static void
11921 create_cus_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
11922                        struct dwo_file &dwo_file, dwarf2_section_info &section,
11923                        htab_t &cus_htab)
11924 {
11925   struct objfile *objfile = dwarf2_per_objfile->objfile;
11926   const gdb_byte *info_ptr, *end_ptr;
11927
11928   dwarf2_read_section (objfile, &section);
11929   info_ptr = section.buffer;
11930
11931   if (info_ptr == NULL)
11932     return;
11933
11934   if (dwarf_read_debug)
11935     {
11936       fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
11937                           get_section_name (&section),
11938                           get_section_file_name (&section));
11939     }
11940
11941   end_ptr = info_ptr + section.size;
11942   while (info_ptr < end_ptr)
11943     {
11944       struct dwarf2_per_cu_data per_cu;
11945       struct create_dwo_cu_data create_dwo_cu_data;
11946       struct dwo_unit *dwo_unit;
11947       void **slot;
11948       sect_offset sect_off = (sect_offset) (info_ptr - section.buffer);
11949
11950       memset (&create_dwo_cu_data.dwo_unit, 0,
11951               sizeof (create_dwo_cu_data.dwo_unit));
11952       memset (&per_cu, 0, sizeof (per_cu));
11953       per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
11954       per_cu.is_debug_types = 0;
11955       per_cu.sect_off = sect_offset (info_ptr - section.buffer);
11956       per_cu.section = &section;
11957       create_dwo_cu_data.dwo_file = &dwo_file;
11958
11959       init_cutu_and_read_dies_no_follow (
11960           &per_cu, &dwo_file, create_dwo_cu_reader, &create_dwo_cu_data);
11961       info_ptr += per_cu.length;
11962
11963       // If the unit could not be parsed, skip it.
11964       if (create_dwo_cu_data.dwo_unit.dwo_file == NULL)
11965         continue;
11966
11967       if (cus_htab == NULL)
11968         cus_htab = allocate_dwo_unit_table (objfile);
11969
11970       dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
11971       *dwo_unit = create_dwo_cu_data.dwo_unit;
11972       slot = htab_find_slot (cus_htab, dwo_unit, INSERT);
11973       gdb_assert (slot != NULL);
11974       if (*slot != NULL)
11975         {
11976           const struct dwo_unit *dup_cu = (const struct dwo_unit *)*slot;
11977           sect_offset dup_sect_off = dup_cu->sect_off;
11978
11979           complaint (_("debug cu entry at offset %s is duplicate to"
11980                        " the entry at offset %s, signature %s"),
11981                      sect_offset_str (sect_off), sect_offset_str (dup_sect_off),
11982                      hex_string (dwo_unit->signature));
11983         }
11984       *slot = (void *)dwo_unit;
11985     }
11986 }
11987
11988 /* DWP file .debug_{cu,tu}_index section format:
11989    [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
11990
11991    DWP Version 1:
11992
11993    Both index sections have the same format, and serve to map a 64-bit
11994    signature to a set of section numbers.  Each section begins with a header,
11995    followed by a hash table of 64-bit signatures, a parallel table of 32-bit
11996    indexes, and a pool of 32-bit section numbers.  The index sections will be
11997    aligned at 8-byte boundaries in the file.
11998
11999    The index section header consists of:
12000
12001     V, 32 bit version number
12002     -, 32 bits unused
12003     N, 32 bit number of compilation units or type units in the index
12004     M, 32 bit number of slots in the hash table
12005
12006    Numbers are recorded using the byte order of the application binary.
12007
12008    The hash table begins at offset 16 in the section, and consists of an array
12009    of M 64-bit slots.  Each slot contains a 64-bit signature (using the byte
12010    order of the application binary).  Unused slots in the hash table are 0.
12011    (We rely on the extreme unlikeliness of a signature being exactly 0.)
12012
12013    The parallel table begins immediately after the hash table
12014    (at offset 16 + 8 * M from the beginning of the section), and consists of an
12015    array of 32-bit indexes (using the byte order of the application binary),
12016    corresponding 1-1 with slots in the hash table.  Each entry in the parallel
12017    table contains a 32-bit index into the pool of section numbers.  For unused
12018    hash table slots, the corresponding entry in the parallel table will be 0.
12019
12020    The pool of section numbers begins immediately following the hash table
12021    (at offset 16 + 12 * M from the beginning of the section).  The pool of
12022    section numbers consists of an array of 32-bit words (using the byte order
12023    of the application binary).  Each item in the array is indexed starting
12024    from 0.  The hash table entry provides the index of the first section
12025    number in the set.  Additional section numbers in the set follow, and the
12026    set is terminated by a 0 entry (section number 0 is not used in ELF).
12027
12028    In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
12029    section must be the first entry in the set, and the .debug_abbrev.dwo must
12030    be the second entry. Other members of the set may follow in any order.
12031
12032    ---
12033
12034    DWP Version 2:
12035
12036    DWP Version 2 combines all the .debug_info, etc. sections into one,
12037    and the entries in the index tables are now offsets into these sections.
12038    CU offsets begin at 0.  TU offsets begin at the size of the .debug_info
12039    section.
12040
12041    Index Section Contents:
12042     Header
12043     Hash Table of Signatures   dwp_hash_table.hash_table
12044     Parallel Table of Indices  dwp_hash_table.unit_table
12045     Table of Section Offsets   dwp_hash_table.v2.{section_ids,offsets}
12046     Table of Section Sizes     dwp_hash_table.v2.sizes
12047
12048    The index section header consists of:
12049
12050     V, 32 bit version number
12051     L, 32 bit number of columns in the table of section offsets
12052     N, 32 bit number of compilation units or type units in the index
12053     M, 32 bit number of slots in the hash table
12054
12055    Numbers are recorded using the byte order of the application binary.
12056
12057    The hash table has the same format as version 1.
12058    The parallel table of indices has the same format as version 1,
12059    except that the entries are origin-1 indices into the table of sections
12060    offsets and the table of section sizes.
12061
12062    The table of offsets begins immediately following the parallel table
12063    (at offset 16 + 12 * M from the beginning of the section).  The table is
12064    a two-dimensional array of 32-bit words (using the byte order of the
12065    application binary), with L columns and N+1 rows, in row-major order.
12066    Each row in the array is indexed starting from 0.  The first row provides
12067    a key to the remaining rows: each column in this row provides an identifier
12068    for a debug section, and the offsets in the same column of subsequent rows
12069    refer to that section.  The section identifiers are:
12070
12071     DW_SECT_INFO         1  .debug_info.dwo
12072     DW_SECT_TYPES        2  .debug_types.dwo
12073     DW_SECT_ABBREV       3  .debug_abbrev.dwo
12074     DW_SECT_LINE         4  .debug_line.dwo
12075     DW_SECT_LOC          5  .debug_loc.dwo
12076     DW_SECT_STR_OFFSETS  6  .debug_str_offsets.dwo
12077     DW_SECT_MACINFO      7  .debug_macinfo.dwo
12078     DW_SECT_MACRO        8  .debug_macro.dwo
12079
12080    The offsets provided by the CU and TU index sections are the base offsets
12081    for the contributions made by each CU or TU to the corresponding section
12082    in the package file.  Each CU and TU header contains an abbrev_offset
12083    field, used to find the abbreviations table for that CU or TU within the
12084    contribution to the .debug_abbrev.dwo section for that CU or TU, and should
12085    be interpreted as relative to the base offset given in the index section.
12086    Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
12087    should be interpreted as relative to the base offset for .debug_line.dwo,
12088    and offsets into other debug sections obtained from DWARF attributes should
12089    also be interpreted as relative to the corresponding base offset.
12090
12091    The table of sizes begins immediately following the table of offsets.
12092    Like the table of offsets, it is a two-dimensional array of 32-bit words,
12093    with L columns and N rows, in row-major order.  Each row in the array is
12094    indexed starting from 1 (row 0 is shared by the two tables).
12095
12096    ---
12097
12098    Hash table lookup is handled the same in version 1 and 2:
12099
12100    We assume that N and M will not exceed 2^32 - 1.
12101    The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
12102
12103    Given a 64-bit compilation unit signature or a type signature S, an entry
12104    in the hash table is located as follows:
12105
12106    1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
12107       the low-order k bits all set to 1.
12108
12109    2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
12110
12111    3) If the hash table entry at index H matches the signature, use that
12112       entry.  If the hash table entry at index H is unused (all zeroes),
12113       terminate the search: the signature is not present in the table.
12114
12115    4) Let H = (H + H') modulo M. Repeat at Step 3.
12116
12117    Because M > N and H' and M are relatively prime, the search is guaranteed
12118    to stop at an unused slot or find the match.  */
12119
12120 /* Create a hash table to map DWO IDs to their CU/TU entry in
12121    .debug_{info,types}.dwo in DWP_FILE.
12122    Returns NULL if there isn't one.
12123    Note: This function processes DWP files only, not DWO files.  */
12124
12125 static struct dwp_hash_table *
12126 create_dwp_hash_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
12127                        struct dwp_file *dwp_file, int is_debug_types)
12128 {
12129   struct objfile *objfile = dwarf2_per_objfile->objfile;
12130   bfd *dbfd = dwp_file->dbfd.get ();
12131   const gdb_byte *index_ptr, *index_end;
12132   struct dwarf2_section_info *index;
12133   uint32_t version, nr_columns, nr_units, nr_slots;
12134   struct dwp_hash_table *htab;
12135
12136   if (is_debug_types)
12137     index = &dwp_file->sections.tu_index;
12138   else
12139     index = &dwp_file->sections.cu_index;
12140
12141   if (dwarf2_section_empty_p (index))
12142     return NULL;
12143   dwarf2_read_section (objfile, index);
12144
12145   index_ptr = index->buffer;
12146   index_end = index_ptr + index->size;
12147
12148   version = read_4_bytes (dbfd, index_ptr);
12149   index_ptr += 4;
12150   if (version == 2)
12151     nr_columns = read_4_bytes (dbfd, index_ptr);
12152   else
12153     nr_columns = 0;
12154   index_ptr += 4;
12155   nr_units = read_4_bytes (dbfd, index_ptr);
12156   index_ptr += 4;
12157   nr_slots = read_4_bytes (dbfd, index_ptr);
12158   index_ptr += 4;
12159
12160   if (version != 1 && version != 2)
12161     {
12162       error (_("Dwarf Error: unsupported DWP file version (%s)"
12163                " [in module %s]"),
12164              pulongest (version), dwp_file->name);
12165     }
12166   if (nr_slots != (nr_slots & -nr_slots))
12167     {
12168       error (_("Dwarf Error: number of slots in DWP hash table (%s)"
12169                " is not power of 2 [in module %s]"),
12170              pulongest (nr_slots), dwp_file->name);
12171     }
12172
12173   htab = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_hash_table);
12174   htab->version = version;
12175   htab->nr_columns = nr_columns;
12176   htab->nr_units = nr_units;
12177   htab->nr_slots = nr_slots;
12178   htab->hash_table = index_ptr;
12179   htab->unit_table = htab->hash_table + sizeof (uint64_t) * nr_slots;
12180
12181   /* Exit early if the table is empty.  */
12182   if (nr_slots == 0 || nr_units == 0
12183       || (version == 2 && nr_columns == 0))
12184     {
12185       /* All must be zero.  */
12186       if (nr_slots != 0 || nr_units != 0
12187           || (version == 2 && nr_columns != 0))
12188         {
12189           complaint (_("Empty DWP but nr_slots,nr_units,nr_columns not"
12190                        " all zero [in modules %s]"),
12191                      dwp_file->name);
12192         }
12193       return htab;
12194     }
12195
12196   if (version == 1)
12197     {
12198       htab->section_pool.v1.indices =
12199         htab->unit_table + sizeof (uint32_t) * nr_slots;
12200       /* It's harder to decide whether the section is too small in v1.
12201          V1 is deprecated anyway so we punt.  */
12202     }
12203   else
12204     {
12205       const gdb_byte *ids_ptr = htab->unit_table + sizeof (uint32_t) * nr_slots;
12206       int *ids = htab->section_pool.v2.section_ids;
12207       size_t sizeof_ids = sizeof (htab->section_pool.v2.section_ids);
12208       /* Reverse map for error checking.  */
12209       int ids_seen[DW_SECT_MAX + 1];
12210       int i;
12211
12212       if (nr_columns < 2)
12213         {
12214           error (_("Dwarf Error: bad DWP hash table, too few columns"
12215                    " in section table [in module %s]"),
12216                  dwp_file->name);
12217         }
12218       if (nr_columns > MAX_NR_V2_DWO_SECTIONS)
12219         {
12220           error (_("Dwarf Error: bad DWP hash table, too many columns"
12221                    " in section table [in module %s]"),
12222                  dwp_file->name);
12223         }
12224       memset (ids, 255, sizeof_ids);
12225       memset (ids_seen, 255, sizeof (ids_seen));
12226       for (i = 0; i < nr_columns; ++i)
12227         {
12228           int id = read_4_bytes (dbfd, ids_ptr + i * sizeof (uint32_t));
12229
12230           if (id < DW_SECT_MIN || id > DW_SECT_MAX)
12231             {
12232               error (_("Dwarf Error: bad DWP hash table, bad section id %d"
12233                        " in section table [in module %s]"),
12234                      id, dwp_file->name);
12235             }
12236           if (ids_seen[id] != -1)
12237             {
12238               error (_("Dwarf Error: bad DWP hash table, duplicate section"
12239                        " id %d in section table [in module %s]"),
12240                      id, dwp_file->name);
12241             }
12242           ids_seen[id] = i;
12243           ids[i] = id;
12244         }
12245       /* Must have exactly one info or types section.  */
12246       if (((ids_seen[DW_SECT_INFO] != -1)
12247            + (ids_seen[DW_SECT_TYPES] != -1))
12248           != 1)
12249         {
12250           error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
12251                    " DWO info/types section [in module %s]"),
12252                  dwp_file->name);
12253         }
12254       /* Must have an abbrev section.  */
12255       if (ids_seen[DW_SECT_ABBREV] == -1)
12256         {
12257           error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
12258                    " section [in module %s]"),
12259                  dwp_file->name);
12260         }
12261       htab->section_pool.v2.offsets = ids_ptr + sizeof (uint32_t) * nr_columns;
12262       htab->section_pool.v2.sizes =
12263         htab->section_pool.v2.offsets + (sizeof (uint32_t)
12264                                          * nr_units * nr_columns);
12265       if ((htab->section_pool.v2.sizes + (sizeof (uint32_t)
12266                                           * nr_units * nr_columns))
12267           > index_end)
12268         {
12269           error (_("Dwarf Error: DWP index section is corrupt (too small)"
12270                    " [in module %s]"),
12271                  dwp_file->name);
12272         }
12273     }
12274
12275   return htab;
12276 }
12277
12278 /* Update SECTIONS with the data from SECTP.
12279
12280    This function is like the other "locate" section routines that are
12281    passed to bfd_map_over_sections, but in this context the sections to
12282    read comes from the DWP V1 hash table, not the full ELF section table.
12283
12284    The result is non-zero for success, or zero if an error was found.  */
12285
12286 static int
12287 locate_v1_virtual_dwo_sections (asection *sectp,
12288                                 struct virtual_v1_dwo_sections *sections)
12289 {
12290   const struct dwop_section_names *names = &dwop_section_names;
12291
12292   if (section_is_p (sectp->name, &names->abbrev_dwo))
12293     {
12294       /* There can be only one.  */
12295       if (sections->abbrev.s.section != NULL)
12296         return 0;
12297       sections->abbrev.s.section = sectp;
12298       sections->abbrev.size = bfd_get_section_size (sectp);
12299     }
12300   else if (section_is_p (sectp->name, &names->info_dwo)
12301            || section_is_p (sectp->name, &names->types_dwo))
12302     {
12303       /* There can be only one.  */
12304       if (sections->info_or_types.s.section != NULL)
12305         return 0;
12306       sections->info_or_types.s.section = sectp;
12307       sections->info_or_types.size = bfd_get_section_size (sectp);
12308     }
12309   else if (section_is_p (sectp->name, &names->line_dwo))
12310     {
12311       /* There can be only one.  */
12312       if (sections->line.s.section != NULL)
12313         return 0;
12314       sections->line.s.section = sectp;
12315       sections->line.size = bfd_get_section_size (sectp);
12316     }
12317   else if (section_is_p (sectp->name, &names->loc_dwo))
12318     {
12319       /* There can be only one.  */
12320       if (sections->loc.s.section != NULL)
12321         return 0;
12322       sections->loc.s.section = sectp;
12323       sections->loc.size = bfd_get_section_size (sectp);
12324     }
12325   else if (section_is_p (sectp->name, &names->macinfo_dwo))
12326     {
12327       /* There can be only one.  */
12328       if (sections->macinfo.s.section != NULL)
12329         return 0;
12330       sections->macinfo.s.section = sectp;
12331       sections->macinfo.size = bfd_get_section_size (sectp);
12332     }
12333   else if (section_is_p (sectp->name, &names->macro_dwo))
12334     {
12335       /* There can be only one.  */
12336       if (sections->macro.s.section != NULL)
12337         return 0;
12338       sections->macro.s.section = sectp;
12339       sections->macro.size = bfd_get_section_size (sectp);
12340     }
12341   else if (section_is_p (sectp->name, &names->str_offsets_dwo))
12342     {
12343       /* There can be only one.  */
12344       if (sections->str_offsets.s.section != NULL)
12345         return 0;
12346       sections->str_offsets.s.section = sectp;
12347       sections->str_offsets.size = bfd_get_section_size (sectp);
12348     }
12349   else
12350     {
12351       /* No other kind of section is valid.  */
12352       return 0;
12353     }
12354
12355   return 1;
12356 }
12357
12358 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12359    UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12360    COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12361    This is for DWP version 1 files.  */
12362
12363 static struct dwo_unit *
12364 create_dwo_unit_in_dwp_v1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
12365                            struct dwp_file *dwp_file,
12366                            uint32_t unit_index,
12367                            const char *comp_dir,
12368                            ULONGEST signature, int is_debug_types)
12369 {
12370   struct objfile *objfile = dwarf2_per_objfile->objfile;
12371   const struct dwp_hash_table *dwp_htab =
12372     is_debug_types ? dwp_file->tus : dwp_file->cus;
12373   bfd *dbfd = dwp_file->dbfd.get ();
12374   const char *kind = is_debug_types ? "TU" : "CU";
12375   struct dwo_file *dwo_file;
12376   struct dwo_unit *dwo_unit;
12377   struct virtual_v1_dwo_sections sections;
12378   void **dwo_file_slot;
12379   int i;
12380
12381   gdb_assert (dwp_file->version == 1);
12382
12383   if (dwarf_read_debug)
12384     {
12385       fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V1 file: %s\n",
12386                           kind,
12387                           pulongest (unit_index), hex_string (signature),
12388                           dwp_file->name);
12389     }
12390
12391   /* Fetch the sections of this DWO unit.
12392      Put a limit on the number of sections we look for so that bad data
12393      doesn't cause us to loop forever.  */
12394
12395 #define MAX_NR_V1_DWO_SECTIONS \
12396   (1 /* .debug_info or .debug_types */ \
12397    + 1 /* .debug_abbrev */ \
12398    + 1 /* .debug_line */ \
12399    + 1 /* .debug_loc */ \
12400    + 1 /* .debug_str_offsets */ \
12401    + 1 /* .debug_macro or .debug_macinfo */ \
12402    + 1 /* trailing zero */)
12403
12404   memset (&sections, 0, sizeof (sections));
12405
12406   for (i = 0; i < MAX_NR_V1_DWO_SECTIONS; ++i)
12407     {
12408       asection *sectp;
12409       uint32_t section_nr =
12410         read_4_bytes (dbfd,
12411                       dwp_htab->section_pool.v1.indices
12412                       + (unit_index + i) * sizeof (uint32_t));
12413
12414       if (section_nr == 0)
12415         break;
12416       if (section_nr >= dwp_file->num_sections)
12417         {
12418           error (_("Dwarf Error: bad DWP hash table, section number too large"
12419                    " [in module %s]"),
12420                  dwp_file->name);
12421         }
12422
12423       sectp = dwp_file->elf_sections[section_nr];
12424       if (! locate_v1_virtual_dwo_sections (sectp, &sections))
12425         {
12426           error (_("Dwarf Error: bad DWP hash table, invalid section found"
12427                    " [in module %s]"),
12428                  dwp_file->name);
12429         }
12430     }
12431
12432   if (i < 2
12433       || dwarf2_section_empty_p (&sections.info_or_types)
12434       || dwarf2_section_empty_p (&sections.abbrev))
12435     {
12436       error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
12437                " [in module %s]"),
12438              dwp_file->name);
12439     }
12440   if (i == MAX_NR_V1_DWO_SECTIONS)
12441     {
12442       error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
12443                " [in module %s]"),
12444              dwp_file->name);
12445     }
12446
12447   /* It's easier for the rest of the code if we fake a struct dwo_file and
12448      have dwo_unit "live" in that.  At least for now.
12449
12450      The DWP file can be made up of a random collection of CUs and TUs.
12451      However, for each CU + set of TUs that came from the same original DWO
12452      file, we can combine them back into a virtual DWO file to save space
12453      (fewer struct dwo_file objects to allocate).  Remember that for really
12454      large apps there can be on the order of 8K CUs and 200K TUs, or more.  */
12455
12456   std::string virtual_dwo_name =
12457     string_printf ("virtual-dwo/%d-%d-%d-%d",
12458                    get_section_id (&sections.abbrev),
12459                    get_section_id (&sections.line),
12460                    get_section_id (&sections.loc),
12461                    get_section_id (&sections.str_offsets));
12462   /* Can we use an existing virtual DWO file?  */
12463   dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
12464                                         virtual_dwo_name.c_str (),
12465                                         comp_dir);
12466   /* Create one if necessary.  */
12467   if (*dwo_file_slot == NULL)
12468     {
12469       if (dwarf_read_debug)
12470         {
12471           fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
12472                               virtual_dwo_name.c_str ());
12473         }
12474       dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
12475       dwo_file->dwo_name
12476         = (const char *) obstack_copy0 (&objfile->objfile_obstack,
12477                                         virtual_dwo_name.c_str (),
12478                                         virtual_dwo_name.size ());
12479       dwo_file->comp_dir = comp_dir;
12480       dwo_file->sections.abbrev = sections.abbrev;
12481       dwo_file->sections.line = sections.line;
12482       dwo_file->sections.loc = sections.loc;
12483       dwo_file->sections.macinfo = sections.macinfo;
12484       dwo_file->sections.macro = sections.macro;
12485       dwo_file->sections.str_offsets = sections.str_offsets;
12486       /* The "str" section is global to the entire DWP file.  */
12487       dwo_file->sections.str = dwp_file->sections.str;
12488       /* The info or types section is assigned below to dwo_unit,
12489          there's no need to record it in dwo_file.
12490          Also, we can't simply record type sections in dwo_file because
12491          we record a pointer into the vector in dwo_unit.  As we collect more
12492          types we'll grow the vector and eventually have to reallocate space
12493          for it, invalidating all copies of pointers into the previous
12494          contents.  */
12495       *dwo_file_slot = dwo_file;
12496     }
12497   else
12498     {
12499       if (dwarf_read_debug)
12500         {
12501           fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
12502                               virtual_dwo_name.c_str ());
12503         }
12504       dwo_file = (struct dwo_file *) *dwo_file_slot;
12505     }
12506
12507   dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
12508   dwo_unit->dwo_file = dwo_file;
12509   dwo_unit->signature = signature;
12510   dwo_unit->section =
12511     XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
12512   *dwo_unit->section = sections.info_or_types;
12513   /* dwo_unit->{offset,length,type_offset_in_tu} are set later.  */
12514
12515   return dwo_unit;
12516 }
12517
12518 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
12519    Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
12520    piece within that section used by a TU/CU, return a virtual section
12521    of just that piece.  */
12522
12523 static struct dwarf2_section_info
12524 create_dwp_v2_section (struct dwarf2_per_objfile *dwarf2_per_objfile,
12525                        struct dwarf2_section_info *section,
12526                        bfd_size_type offset, bfd_size_type size)
12527 {
12528   struct dwarf2_section_info result;
12529   asection *sectp;
12530
12531   gdb_assert (section != NULL);
12532   gdb_assert (!section->is_virtual);
12533
12534   memset (&result, 0, sizeof (result));
12535   result.s.containing_section = section;
12536   result.is_virtual = 1;
12537
12538   if (size == 0)
12539     return result;
12540
12541   sectp = get_section_bfd_section (section);
12542
12543   /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
12544      bounds of the real section.  This is a pretty-rare event, so just
12545      flag an error (easier) instead of a warning and trying to cope.  */
12546   if (sectp == NULL
12547       || offset + size > bfd_get_section_size (sectp))
12548     {
12549       error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
12550                " in section %s [in module %s]"),
12551              sectp ? bfd_section_name (abfd, sectp) : "<unknown>",
12552              objfile_name (dwarf2_per_objfile->objfile));
12553     }
12554
12555   result.virtual_offset = offset;
12556   result.size = size;
12557   return result;
12558 }
12559
12560 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
12561    UNIT_INDEX is the index of the DWO unit in the DWP hash table.
12562    COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
12563    This is for DWP version 2 files.  */
12564
12565 static struct dwo_unit *
12566 create_dwo_unit_in_dwp_v2 (struct dwarf2_per_objfile *dwarf2_per_objfile,
12567                            struct dwp_file *dwp_file,
12568                            uint32_t unit_index,
12569                            const char *comp_dir,
12570                            ULONGEST signature, int is_debug_types)
12571 {
12572   struct objfile *objfile = dwarf2_per_objfile->objfile;
12573   const struct dwp_hash_table *dwp_htab =
12574     is_debug_types ? dwp_file->tus : dwp_file->cus;
12575   bfd *dbfd = dwp_file->dbfd.get ();
12576   const char *kind = is_debug_types ? "TU" : "CU";
12577   struct dwo_file *dwo_file;
12578   struct dwo_unit *dwo_unit;
12579   struct virtual_v2_dwo_sections sections;
12580   void **dwo_file_slot;
12581   int i;
12582
12583   gdb_assert (dwp_file->version == 2);
12584
12585   if (dwarf_read_debug)
12586     {
12587       fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V2 file: %s\n",
12588                           kind,
12589                           pulongest (unit_index), hex_string (signature),
12590                           dwp_file->name);
12591     }
12592
12593   /* Fetch the section offsets of this DWO unit.  */
12594
12595   memset (&sections, 0, sizeof (sections));
12596
12597   for (i = 0; i < dwp_htab->nr_columns; ++i)
12598     {
12599       uint32_t offset = read_4_bytes (dbfd,
12600                                       dwp_htab->section_pool.v2.offsets
12601                                       + (((unit_index - 1) * dwp_htab->nr_columns
12602                                           + i)
12603                                          * sizeof (uint32_t)));
12604       uint32_t size = read_4_bytes (dbfd,
12605                                     dwp_htab->section_pool.v2.sizes
12606                                     + (((unit_index - 1) * dwp_htab->nr_columns
12607                                         + i)
12608                                        * sizeof (uint32_t)));
12609
12610       switch (dwp_htab->section_pool.v2.section_ids[i])
12611         {
12612         case DW_SECT_INFO:
12613         case DW_SECT_TYPES:
12614           sections.info_or_types_offset = offset;
12615           sections.info_or_types_size = size;
12616           break;
12617         case DW_SECT_ABBREV:
12618           sections.abbrev_offset = offset;
12619           sections.abbrev_size = size;
12620           break;
12621         case DW_SECT_LINE:
12622           sections.line_offset = offset;
12623           sections.line_size = size;
12624           break;
12625         case DW_SECT_LOC:
12626           sections.loc_offset = offset;
12627           sections.loc_size = size;
12628           break;
12629         case DW_SECT_STR_OFFSETS:
12630           sections.str_offsets_offset = offset;
12631           sections.str_offsets_size = size;
12632           break;
12633         case DW_SECT_MACINFO:
12634           sections.macinfo_offset = offset;
12635           sections.macinfo_size = size;
12636           break;
12637         case DW_SECT_MACRO:
12638           sections.macro_offset = offset;
12639           sections.macro_size = size;
12640           break;
12641         }
12642     }
12643
12644   /* It's easier for the rest of the code if we fake a struct dwo_file and
12645      have dwo_unit "live" in that.  At least for now.
12646
12647      The DWP file can be made up of a random collection of CUs and TUs.
12648      However, for each CU + set of TUs that came from the same original DWO
12649      file, we can combine them back into a virtual DWO file to save space
12650      (fewer struct dwo_file objects to allocate).  Remember that for really
12651      large apps there can be on the order of 8K CUs and 200K TUs, or more.  */
12652
12653   std::string virtual_dwo_name =
12654     string_printf ("virtual-dwo/%ld-%ld-%ld-%ld",
12655                    (long) (sections.abbrev_size ? sections.abbrev_offset : 0),
12656                    (long) (sections.line_size ? sections.line_offset : 0),
12657                    (long) (sections.loc_size ? sections.loc_offset : 0),
12658                    (long) (sections.str_offsets_size
12659                            ? sections.str_offsets_offset : 0));
12660   /* Can we use an existing virtual DWO file?  */
12661   dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
12662                                         virtual_dwo_name.c_str (),
12663                                         comp_dir);
12664   /* Create one if necessary.  */
12665   if (*dwo_file_slot == NULL)
12666     {
12667       if (dwarf_read_debug)
12668         {
12669           fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
12670                               virtual_dwo_name.c_str ());
12671         }
12672       dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
12673       dwo_file->dwo_name
12674         = (const char *) obstack_copy0 (&objfile->objfile_obstack,
12675                                         virtual_dwo_name.c_str (),
12676                                         virtual_dwo_name.size ());
12677       dwo_file->comp_dir = comp_dir;
12678       dwo_file->sections.abbrev =
12679         create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.abbrev,
12680                                sections.abbrev_offset, sections.abbrev_size);
12681       dwo_file->sections.line =
12682         create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.line,
12683                                sections.line_offset, sections.line_size);
12684       dwo_file->sections.loc =
12685         create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.loc,
12686                                sections.loc_offset, sections.loc_size);
12687       dwo_file->sections.macinfo =
12688         create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.macinfo,
12689                                sections.macinfo_offset, sections.macinfo_size);
12690       dwo_file->sections.macro =
12691         create_dwp_v2_section (dwarf2_per_objfile, &dwp_file->sections.macro,
12692                                sections.macro_offset, sections.macro_size);
12693       dwo_file->sections.str_offsets =
12694         create_dwp_v2_section (dwarf2_per_objfile,
12695                                &dwp_file->sections.str_offsets,
12696                                sections.str_offsets_offset,
12697                                sections.str_offsets_size);
12698       /* The "str" section is global to the entire DWP file.  */
12699       dwo_file->sections.str = dwp_file->sections.str;
12700       /* The info or types section is assigned below to dwo_unit,
12701          there's no need to record it in dwo_file.
12702          Also, we can't simply record type sections in dwo_file because
12703          we record a pointer into the vector in dwo_unit.  As we collect more
12704          types we'll grow the vector and eventually have to reallocate space
12705          for it, invalidating all copies of pointers into the previous
12706          contents.  */
12707       *dwo_file_slot = dwo_file;
12708     }
12709   else
12710     {
12711       if (dwarf_read_debug)
12712         {
12713           fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
12714                               virtual_dwo_name.c_str ());
12715         }
12716       dwo_file = (struct dwo_file *) *dwo_file_slot;
12717     }
12718
12719   dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
12720   dwo_unit->dwo_file = dwo_file;
12721   dwo_unit->signature = signature;
12722   dwo_unit->section =
12723     XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
12724   *dwo_unit->section = create_dwp_v2_section (dwarf2_per_objfile,
12725                                               is_debug_types
12726                                               ? &dwp_file->sections.types
12727                                               : &dwp_file->sections.info,
12728                                               sections.info_or_types_offset,
12729                                               sections.info_or_types_size);
12730   /* dwo_unit->{offset,length,type_offset_in_tu} are set later.  */
12731
12732   return dwo_unit;
12733 }
12734
12735 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
12736    Returns NULL if the signature isn't found.  */
12737
12738 static struct dwo_unit *
12739 lookup_dwo_unit_in_dwp (struct dwarf2_per_objfile *dwarf2_per_objfile,
12740                         struct dwp_file *dwp_file, const char *comp_dir,
12741                         ULONGEST signature, int is_debug_types)
12742 {
12743   const struct dwp_hash_table *dwp_htab =
12744     is_debug_types ? dwp_file->tus : dwp_file->cus;
12745   bfd *dbfd = dwp_file->dbfd.get ();
12746   uint32_t mask = dwp_htab->nr_slots - 1;
12747   uint32_t hash = signature & mask;
12748   uint32_t hash2 = ((signature >> 32) & mask) | 1;
12749   unsigned int i;
12750   void **slot;
12751   struct dwo_unit find_dwo_cu;
12752
12753   memset (&find_dwo_cu, 0, sizeof (find_dwo_cu));
12754   find_dwo_cu.signature = signature;
12755   slot = htab_find_slot (is_debug_types
12756                          ? dwp_file->loaded_tus
12757                          : dwp_file->loaded_cus,
12758                          &find_dwo_cu, INSERT);
12759
12760   if (*slot != NULL)
12761     return (struct dwo_unit *) *slot;
12762
12763   /* Use a for loop so that we don't loop forever on bad debug info.  */
12764   for (i = 0; i < dwp_htab->nr_slots; ++i)
12765     {
12766       ULONGEST signature_in_table;
12767
12768       signature_in_table =
12769         read_8_bytes (dbfd, dwp_htab->hash_table + hash * sizeof (uint64_t));
12770       if (signature_in_table == signature)
12771         {
12772           uint32_t unit_index =
12773             read_4_bytes (dbfd,
12774                           dwp_htab->unit_table + hash * sizeof (uint32_t));
12775
12776           if (dwp_file->version == 1)
12777             {
12778               *slot = create_dwo_unit_in_dwp_v1 (dwarf2_per_objfile,
12779                                                  dwp_file, unit_index,
12780                                                  comp_dir, signature,
12781                                                  is_debug_types);
12782             }
12783           else
12784             {
12785               *slot = create_dwo_unit_in_dwp_v2 (dwarf2_per_objfile,
12786                                                  dwp_file, unit_index,
12787                                                  comp_dir, signature,
12788                                                  is_debug_types);
12789             }
12790           return (struct dwo_unit *) *slot;
12791         }
12792       if (signature_in_table == 0)
12793         return NULL;
12794       hash = (hash + hash2) & mask;
12795     }
12796
12797   error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
12798            " [in module %s]"),
12799          dwp_file->name);
12800 }
12801
12802 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
12803    Open the file specified by FILE_NAME and hand it off to BFD for
12804    preliminary analysis.  Return a newly initialized bfd *, which
12805    includes a canonicalized copy of FILE_NAME.
12806    If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
12807    SEARCH_CWD is true if the current directory is to be searched.
12808    It will be searched before debug-file-directory.
12809    If successful, the file is added to the bfd include table of the
12810    objfile's bfd (see gdb_bfd_record_inclusion).
12811    If unable to find/open the file, return NULL.
12812    NOTE: This function is derived from symfile_bfd_open.  */
12813
12814 static gdb_bfd_ref_ptr
12815 try_open_dwop_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
12816                     const char *file_name, int is_dwp, int search_cwd)
12817 {
12818   int desc;
12819   /* Blech.  OPF_TRY_CWD_FIRST also disables searching the path list if
12820      FILE_NAME contains a '/'.  So we can't use it.  Instead prepend "."
12821      to debug_file_directory.  */
12822   const char *search_path;
12823   static const char dirname_separator_string[] = { DIRNAME_SEPARATOR, '\0' };
12824
12825   gdb::unique_xmalloc_ptr<char> search_path_holder;
12826   if (search_cwd)
12827     {
12828       if (*debug_file_directory != '\0')
12829         {
12830           search_path_holder.reset (concat (".", dirname_separator_string,
12831                                             debug_file_directory,
12832                                             (char *) NULL));
12833           search_path = search_path_holder.get ();
12834         }
12835       else
12836         search_path = ".";
12837     }
12838   else
12839     search_path = debug_file_directory;
12840
12841   openp_flags flags = OPF_RETURN_REALPATH;
12842   if (is_dwp)
12843     flags |= OPF_SEARCH_IN_PATH;
12844
12845   gdb::unique_xmalloc_ptr<char> absolute_name;
12846   desc = openp (search_path, flags, file_name,
12847                 O_RDONLY | O_BINARY, &absolute_name);
12848   if (desc < 0)
12849     return NULL;
12850
12851   gdb_bfd_ref_ptr sym_bfd (gdb_bfd_open (absolute_name.get (),
12852                                          gnutarget, desc));
12853   if (sym_bfd == NULL)
12854     return NULL;
12855   bfd_set_cacheable (sym_bfd.get (), 1);
12856
12857   if (!bfd_check_format (sym_bfd.get (), bfd_object))
12858     return NULL;
12859
12860   /* Success.  Record the bfd as having been included by the objfile's bfd.
12861      This is important because things like demangled_names_hash lives in the
12862      objfile's per_bfd space and may have references to things like symbol
12863      names that live in the DWO/DWP file's per_bfd space.  PR 16426.  */
12864   gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd, sym_bfd.get ());
12865
12866   return sym_bfd;
12867 }
12868
12869 /* Try to open DWO file FILE_NAME.
12870    COMP_DIR is the DW_AT_comp_dir attribute.
12871    The result is the bfd handle of the file.
12872    If there is a problem finding or opening the file, return NULL.
12873    Upon success, the canonicalized path of the file is stored in the bfd,
12874    same as symfile_bfd_open.  */
12875
12876 static gdb_bfd_ref_ptr
12877 open_dwo_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
12878                const char *file_name, const char *comp_dir)
12879 {
12880   if (IS_ABSOLUTE_PATH (file_name))
12881     return try_open_dwop_file (dwarf2_per_objfile, file_name,
12882                                0 /*is_dwp*/, 0 /*search_cwd*/);
12883
12884   /* Before trying the search path, try DWO_NAME in COMP_DIR.  */
12885
12886   if (comp_dir != NULL)
12887     {
12888       char *path_to_try = concat (comp_dir, SLASH_STRING,
12889                                   file_name, (char *) NULL);
12890
12891       /* NOTE: If comp_dir is a relative path, this will also try the
12892          search path, which seems useful.  */
12893       gdb_bfd_ref_ptr abfd (try_open_dwop_file (dwarf2_per_objfile,
12894                                                 path_to_try,
12895                                                 0 /*is_dwp*/,
12896                                                 1 /*search_cwd*/));
12897       xfree (path_to_try);
12898       if (abfd != NULL)
12899         return abfd;
12900     }
12901
12902   /* That didn't work, try debug-file-directory, which, despite its name,
12903      is a list of paths.  */
12904
12905   if (*debug_file_directory == '\0')
12906     return NULL;
12907
12908   return try_open_dwop_file (dwarf2_per_objfile, file_name,
12909                              0 /*is_dwp*/, 1 /*search_cwd*/);
12910 }
12911
12912 /* This function is mapped across the sections and remembers the offset and
12913    size of each of the DWO debugging sections we are interested in.  */
12914
12915 static void
12916 dwarf2_locate_dwo_sections (bfd *abfd, asection *sectp, void *dwo_sections_ptr)
12917 {
12918   struct dwo_sections *dwo_sections = (struct dwo_sections *) dwo_sections_ptr;
12919   const struct dwop_section_names *names = &dwop_section_names;
12920
12921   if (section_is_p (sectp->name, &names->abbrev_dwo))
12922     {
12923       dwo_sections->abbrev.s.section = sectp;
12924       dwo_sections->abbrev.size = bfd_get_section_size (sectp);
12925     }
12926   else if (section_is_p (sectp->name, &names->info_dwo))
12927     {
12928       dwo_sections->info.s.section = sectp;
12929       dwo_sections->info.size = bfd_get_section_size (sectp);
12930     }
12931   else if (section_is_p (sectp->name, &names->line_dwo))
12932     {
12933       dwo_sections->line.s.section = sectp;
12934       dwo_sections->line.size = bfd_get_section_size (sectp);
12935     }
12936   else if (section_is_p (sectp->name, &names->loc_dwo))
12937     {
12938       dwo_sections->loc.s.section = sectp;
12939       dwo_sections->loc.size = bfd_get_section_size (sectp);
12940     }
12941   else if (section_is_p (sectp->name, &names->macinfo_dwo))
12942     {
12943       dwo_sections->macinfo.s.section = sectp;
12944       dwo_sections->macinfo.size = bfd_get_section_size (sectp);
12945     }
12946   else if (section_is_p (sectp->name, &names->macro_dwo))
12947     {
12948       dwo_sections->macro.s.section = sectp;
12949       dwo_sections->macro.size = bfd_get_section_size (sectp);
12950     }
12951   else if (section_is_p (sectp->name, &names->str_dwo))
12952     {
12953       dwo_sections->str.s.section = sectp;
12954       dwo_sections->str.size = bfd_get_section_size (sectp);
12955     }
12956   else if (section_is_p (sectp->name, &names->str_offsets_dwo))
12957     {
12958       dwo_sections->str_offsets.s.section = sectp;
12959       dwo_sections->str_offsets.size = bfd_get_section_size (sectp);
12960     }
12961   else if (section_is_p (sectp->name, &names->types_dwo))
12962     {
12963       struct dwarf2_section_info type_section;
12964
12965       memset (&type_section, 0, sizeof (type_section));
12966       type_section.s.section = sectp;
12967       type_section.size = bfd_get_section_size (sectp);
12968       VEC_safe_push (dwarf2_section_info_def, dwo_sections->types,
12969                      &type_section);
12970     }
12971 }
12972
12973 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
12974    by PER_CU.  This is for the non-DWP case.
12975    The result is NULL if DWO_NAME can't be found.  */
12976
12977 static struct dwo_file *
12978 open_and_init_dwo_file (struct dwarf2_per_cu_data *per_cu,
12979                         const char *dwo_name, const char *comp_dir)
12980 {
12981   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
12982   struct objfile *objfile = dwarf2_per_objfile->objfile;
12983
12984   gdb_bfd_ref_ptr dbfd (open_dwo_file (dwarf2_per_objfile, dwo_name, comp_dir));
12985   if (dbfd == NULL)
12986     {
12987       if (dwarf_read_debug)
12988         fprintf_unfiltered (gdb_stdlog, "DWO file not found: %s\n", dwo_name);
12989       return NULL;
12990     }
12991
12992   /* We use a unique pointer here, despite the obstack allocation,
12993      because a dwo_file needs some cleanup if it is abandoned.  */
12994   dwo_file_up dwo_file (OBSTACK_ZALLOC (&objfile->objfile_obstack,
12995                                         struct dwo_file));
12996   dwo_file->dwo_name = dwo_name;
12997   dwo_file->comp_dir = comp_dir;
12998   dwo_file->dbfd = dbfd.release ();
12999
13000   bfd_map_over_sections (dwo_file->dbfd, dwarf2_locate_dwo_sections,
13001                          &dwo_file->sections);
13002
13003   create_cus_hash_table (dwarf2_per_objfile, *dwo_file, dwo_file->sections.info,
13004                          dwo_file->cus);
13005
13006   create_debug_types_hash_table (dwarf2_per_objfile, dwo_file.get (),
13007                                  dwo_file->sections.types, dwo_file->tus);
13008
13009   if (dwarf_read_debug)
13010     fprintf_unfiltered (gdb_stdlog, "DWO file found: %s\n", dwo_name);
13011
13012   return dwo_file.release ();
13013 }
13014
13015 /* This function is mapped across the sections and remembers the offset and
13016    size of each of the DWP debugging sections common to version 1 and 2 that
13017    we are interested in.  */
13018
13019 static void
13020 dwarf2_locate_common_dwp_sections (bfd *abfd, asection *sectp,
13021                                    void *dwp_file_ptr)
13022 {
13023   struct dwp_file *dwp_file = (struct dwp_file *) dwp_file_ptr;
13024   const struct dwop_section_names *names = &dwop_section_names;
13025   unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
13026
13027   /* Record the ELF section number for later lookup: this is what the
13028      .debug_cu_index,.debug_tu_index tables use in DWP V1.  */
13029   gdb_assert (elf_section_nr < dwp_file->num_sections);
13030   dwp_file->elf_sections[elf_section_nr] = sectp;
13031
13032   /* Look for specific sections that we need.  */
13033   if (section_is_p (sectp->name, &names->str_dwo))
13034     {
13035       dwp_file->sections.str.s.section = sectp;
13036       dwp_file->sections.str.size = bfd_get_section_size (sectp);
13037     }
13038   else if (section_is_p (sectp->name, &names->cu_index))
13039     {
13040       dwp_file->sections.cu_index.s.section = sectp;
13041       dwp_file->sections.cu_index.size = bfd_get_section_size (sectp);
13042     }
13043   else if (section_is_p (sectp->name, &names->tu_index))
13044     {
13045       dwp_file->sections.tu_index.s.section = sectp;
13046       dwp_file->sections.tu_index.size = bfd_get_section_size (sectp);
13047     }
13048 }
13049
13050 /* This function is mapped across the sections and remembers the offset and
13051    size of each of the DWP version 2 debugging sections that we are interested
13052    in.  This is split into a separate function because we don't know if we
13053    have version 1 or 2 until we parse the cu_index/tu_index sections.  */
13054
13055 static void
13056 dwarf2_locate_v2_dwp_sections (bfd *abfd, asection *sectp, void *dwp_file_ptr)
13057 {
13058   struct dwp_file *dwp_file = (struct dwp_file *) dwp_file_ptr;
13059   const struct dwop_section_names *names = &dwop_section_names;
13060   unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
13061
13062   /* Record the ELF section number for later lookup: this is what the
13063      .debug_cu_index,.debug_tu_index tables use in DWP V1.  */
13064   gdb_assert (elf_section_nr < dwp_file->num_sections);
13065   dwp_file->elf_sections[elf_section_nr] = sectp;
13066
13067   /* Look for specific sections that we need.  */
13068   if (section_is_p (sectp->name, &names->abbrev_dwo))
13069     {
13070       dwp_file->sections.abbrev.s.section = sectp;
13071       dwp_file->sections.abbrev.size = bfd_get_section_size (sectp);
13072     }
13073   else if (section_is_p (sectp->name, &names->info_dwo))
13074     {
13075       dwp_file->sections.info.s.section = sectp;
13076       dwp_file->sections.info.size = bfd_get_section_size (sectp);
13077     }
13078   else if (section_is_p (sectp->name, &names->line_dwo))
13079     {
13080       dwp_file->sections.line.s.section = sectp;
13081       dwp_file->sections.line.size = bfd_get_section_size (sectp);
13082     }
13083   else if (section_is_p (sectp->name, &names->loc_dwo))
13084     {
13085       dwp_file->sections.loc.s.section = sectp;
13086       dwp_file->sections.loc.size = bfd_get_section_size (sectp);
13087     }
13088   else if (section_is_p (sectp->name, &names->macinfo_dwo))
13089     {
13090       dwp_file->sections.macinfo.s.section = sectp;
13091       dwp_file->sections.macinfo.size = bfd_get_section_size (sectp);
13092     }
13093   else if (section_is_p (sectp->name, &names->macro_dwo))
13094     {
13095       dwp_file->sections.macro.s.section = sectp;
13096       dwp_file->sections.macro.size = bfd_get_section_size (sectp);
13097     }
13098   else if (section_is_p (sectp->name, &names->str_offsets_dwo))
13099     {
13100       dwp_file->sections.str_offsets.s.section = sectp;
13101       dwp_file->sections.str_offsets.size = bfd_get_section_size (sectp);
13102     }
13103   else if (section_is_p (sectp->name, &names->types_dwo))
13104     {
13105       dwp_file->sections.types.s.section = sectp;
13106       dwp_file->sections.types.size = bfd_get_section_size (sectp);
13107     }
13108 }
13109
13110 /* Hash function for dwp_file loaded CUs/TUs.  */
13111
13112 static hashval_t
13113 hash_dwp_loaded_cutus (const void *item)
13114 {
13115   const struct dwo_unit *dwo_unit = (const struct dwo_unit *) item;
13116
13117   /* This drops the top 32 bits of the signature, but is ok for a hash.  */
13118   return dwo_unit->signature;
13119 }
13120
13121 /* Equality function for dwp_file loaded CUs/TUs.  */
13122
13123 static int
13124 eq_dwp_loaded_cutus (const void *a, const void *b)
13125 {
13126   const struct dwo_unit *dua = (const struct dwo_unit *) a;
13127   const struct dwo_unit *dub = (const struct dwo_unit *) b;
13128
13129   return dua->signature == dub->signature;
13130 }
13131
13132 /* Allocate a hash table for dwp_file loaded CUs/TUs.  */
13133
13134 static htab_t
13135 allocate_dwp_loaded_cutus_table (struct objfile *objfile)
13136 {
13137   return htab_create_alloc_ex (3,
13138                                hash_dwp_loaded_cutus,
13139                                eq_dwp_loaded_cutus,
13140                                NULL,
13141                                &objfile->objfile_obstack,
13142                                hashtab_obstack_allocate,
13143                                dummy_obstack_deallocate);
13144 }
13145
13146 /* Try to open DWP file FILE_NAME.
13147    The result is the bfd handle of the file.
13148    If there is a problem finding or opening the file, return NULL.
13149    Upon success, the canonicalized path of the file is stored in the bfd,
13150    same as symfile_bfd_open.  */
13151
13152 static gdb_bfd_ref_ptr
13153 open_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile,
13154                const char *file_name)
13155 {
13156   gdb_bfd_ref_ptr abfd (try_open_dwop_file (dwarf2_per_objfile, file_name,
13157                                             1 /*is_dwp*/,
13158                                             1 /*search_cwd*/));
13159   if (abfd != NULL)
13160     return abfd;
13161
13162   /* Work around upstream bug 15652.
13163      http://sourceware.org/bugzilla/show_bug.cgi?id=15652
13164      [Whether that's a "bug" is debatable, but it is getting in our way.]
13165      We have no real idea where the dwp file is, because gdb's realpath-ing
13166      of the executable's path may have discarded the needed info.
13167      [IWBN if the dwp file name was recorded in the executable, akin to
13168      .gnu_debuglink, but that doesn't exist yet.]
13169      Strip the directory from FILE_NAME and search again.  */
13170   if (*debug_file_directory != '\0')
13171     {
13172       /* Don't implicitly search the current directory here.
13173          If the user wants to search "." to handle this case,
13174          it must be added to debug-file-directory.  */
13175       return try_open_dwop_file (dwarf2_per_objfile,
13176                                  lbasename (file_name), 1 /*is_dwp*/,
13177                                  0 /*search_cwd*/);
13178     }
13179
13180   return NULL;
13181 }
13182
13183 /* Initialize the use of the DWP file for the current objfile.
13184    By convention the name of the DWP file is ${objfile}.dwp.
13185    The result is NULL if it can't be found.  */
13186
13187 static std::unique_ptr<struct dwp_file>
13188 open_and_init_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
13189 {
13190   struct objfile *objfile = dwarf2_per_objfile->objfile;
13191
13192   /* Try to find first .dwp for the binary file before any symbolic links
13193      resolving.  */
13194
13195   /* If the objfile is a debug file, find the name of the real binary
13196      file and get the name of dwp file from there.  */
13197   std::string dwp_name;
13198   if (objfile->separate_debug_objfile_backlink != NULL)
13199     {
13200       struct objfile *backlink = objfile->separate_debug_objfile_backlink;
13201       const char *backlink_basename = lbasename (backlink->original_name);
13202
13203       dwp_name = ldirname (objfile->original_name) + SLASH_STRING + backlink_basename;
13204     }
13205   else
13206     dwp_name = objfile->original_name;
13207
13208   dwp_name += ".dwp";
13209
13210   gdb_bfd_ref_ptr dbfd (open_dwp_file (dwarf2_per_objfile, dwp_name.c_str ()));
13211   if (dbfd == NULL
13212       && strcmp (objfile->original_name, objfile_name (objfile)) != 0)
13213     {
13214       /* Try to find .dwp for the binary file after gdb_realpath resolving.  */
13215       dwp_name = objfile_name (objfile);
13216       dwp_name += ".dwp";
13217       dbfd = open_dwp_file (dwarf2_per_objfile, dwp_name.c_str ());
13218     }
13219
13220   if (dbfd == NULL)
13221     {
13222       if (dwarf_read_debug)
13223         fprintf_unfiltered (gdb_stdlog, "DWP file not found: %s\n", dwp_name.c_str ());
13224       return std::unique_ptr<dwp_file> ();
13225     }
13226
13227   const char *name = bfd_get_filename (dbfd.get ());
13228   std::unique_ptr<struct dwp_file> dwp_file
13229     (new struct dwp_file (name, std::move (dbfd)));
13230
13231   dwp_file->num_sections = elf_numsections (dwp_file->dbfd);
13232   dwp_file->elf_sections =
13233     OBSTACK_CALLOC (&objfile->objfile_obstack,
13234                     dwp_file->num_sections, asection *);
13235
13236   bfd_map_over_sections (dwp_file->dbfd.get (),
13237                          dwarf2_locate_common_dwp_sections,
13238                          dwp_file.get ());
13239
13240   dwp_file->cus = create_dwp_hash_table (dwarf2_per_objfile, dwp_file.get (),
13241                                          0);
13242
13243   dwp_file->tus = create_dwp_hash_table (dwarf2_per_objfile, dwp_file.get (),
13244                                          1);
13245
13246   /* The DWP file version is stored in the hash table.  Oh well.  */
13247   if (dwp_file->cus && dwp_file->tus
13248       && dwp_file->cus->version != dwp_file->tus->version)
13249     {
13250       /* Technically speaking, we should try to limp along, but this is
13251          pretty bizarre.  We use pulongest here because that's the established
13252          portability solution (e.g, we cannot use %u for uint32_t).  */
13253       error (_("Dwarf Error: DWP file CU version %s doesn't match"
13254                " TU version %s [in DWP file %s]"),
13255              pulongest (dwp_file->cus->version),
13256              pulongest (dwp_file->tus->version), dwp_name.c_str ());
13257     }
13258
13259   if (dwp_file->cus)
13260     dwp_file->version = dwp_file->cus->version;
13261   else if (dwp_file->tus)
13262     dwp_file->version = dwp_file->tus->version;
13263   else
13264     dwp_file->version = 2;
13265
13266   if (dwp_file->version == 2)
13267     bfd_map_over_sections (dwp_file->dbfd.get (),
13268                            dwarf2_locate_v2_dwp_sections,
13269                            dwp_file.get ());
13270
13271   dwp_file->loaded_cus = allocate_dwp_loaded_cutus_table (objfile);
13272   dwp_file->loaded_tus = allocate_dwp_loaded_cutus_table (objfile);
13273
13274   if (dwarf_read_debug)
13275     {
13276       fprintf_unfiltered (gdb_stdlog, "DWP file found: %s\n", dwp_file->name);
13277       fprintf_unfiltered (gdb_stdlog,
13278                           "    %s CUs, %s TUs\n",
13279                           pulongest (dwp_file->cus ? dwp_file->cus->nr_units : 0),
13280                           pulongest (dwp_file->tus ? dwp_file->tus->nr_units : 0));
13281     }
13282
13283   return dwp_file;
13284 }
13285
13286 /* Wrapper around open_and_init_dwp_file, only open it once.  */
13287
13288 static struct dwp_file *
13289 get_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
13290 {
13291   if (! dwarf2_per_objfile->dwp_checked)
13292     {
13293       dwarf2_per_objfile->dwp_file
13294         = open_and_init_dwp_file (dwarf2_per_objfile);
13295       dwarf2_per_objfile->dwp_checked = 1;
13296     }
13297   return dwarf2_per_objfile->dwp_file.get ();
13298 }
13299
13300 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
13301    Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
13302    or in the DWP file for the objfile, referenced by THIS_UNIT.
13303    If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
13304    IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
13305
13306    This is called, for example, when wanting to read a variable with a
13307    complex location.  Therefore we don't want to do file i/o for every call.
13308    Therefore we don't want to look for a DWO file on every call.
13309    Therefore we first see if we've already seen SIGNATURE in a DWP file,
13310    then we check if we've already seen DWO_NAME, and only THEN do we check
13311    for a DWO file.
13312
13313    The result is a pointer to the dwo_unit object or NULL if we didn't find it
13314    (dwo_id mismatch or couldn't find the DWO/DWP file).  */
13315
13316 static struct dwo_unit *
13317 lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit,
13318                  const char *dwo_name, const char *comp_dir,
13319                  ULONGEST signature, int is_debug_types)
13320 {
13321   struct dwarf2_per_objfile *dwarf2_per_objfile = this_unit->dwarf2_per_objfile;
13322   struct objfile *objfile = dwarf2_per_objfile->objfile;
13323   const char *kind = is_debug_types ? "TU" : "CU";
13324   void **dwo_file_slot;
13325   struct dwo_file *dwo_file;
13326   struct dwp_file *dwp_file;
13327
13328   /* First see if there's a DWP file.
13329      If we have a DWP file but didn't find the DWO inside it, don't
13330      look for the original DWO file.  It makes gdb behave differently
13331      depending on whether one is debugging in the build tree.  */
13332
13333   dwp_file = get_dwp_file (dwarf2_per_objfile);
13334   if (dwp_file != NULL)
13335     {
13336       const struct dwp_hash_table *dwp_htab =
13337         is_debug_types ? dwp_file->tus : dwp_file->cus;
13338
13339       if (dwp_htab != NULL)
13340         {
13341           struct dwo_unit *dwo_cutu =
13342             lookup_dwo_unit_in_dwp (dwarf2_per_objfile, dwp_file, comp_dir,
13343                                     signature, is_debug_types);
13344
13345           if (dwo_cutu != NULL)
13346             {
13347               if (dwarf_read_debug)
13348                 {
13349                   fprintf_unfiltered (gdb_stdlog,
13350                                       "Virtual DWO %s %s found: @%s\n",
13351                                       kind, hex_string (signature),
13352                                       host_address_to_string (dwo_cutu));
13353                 }
13354               return dwo_cutu;
13355             }
13356         }
13357     }
13358   else
13359     {
13360       /* No DWP file, look for the DWO file.  */
13361
13362       dwo_file_slot = lookup_dwo_file_slot (dwarf2_per_objfile,
13363                                             dwo_name, comp_dir);
13364       if (*dwo_file_slot == NULL)
13365         {
13366           /* Read in the file and build a table of the CUs/TUs it contains.  */
13367           *dwo_file_slot = open_and_init_dwo_file (this_unit, dwo_name, comp_dir);
13368         }
13369       /* NOTE: This will be NULL if unable to open the file.  */
13370       dwo_file = (struct dwo_file *) *dwo_file_slot;
13371
13372       if (dwo_file != NULL)
13373         {
13374           struct dwo_unit *dwo_cutu = NULL;
13375
13376           if (is_debug_types && dwo_file->tus)
13377             {
13378               struct dwo_unit find_dwo_cutu;
13379
13380               memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
13381               find_dwo_cutu.signature = signature;
13382               dwo_cutu
13383                 = (struct dwo_unit *) htab_find (dwo_file->tus, &find_dwo_cutu);
13384             }
13385           else if (!is_debug_types && dwo_file->cus)
13386             {
13387               struct dwo_unit find_dwo_cutu;
13388
13389               memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
13390               find_dwo_cutu.signature = signature;
13391               dwo_cutu = (struct dwo_unit *)htab_find (dwo_file->cus,
13392                                                        &find_dwo_cutu);
13393             }
13394
13395           if (dwo_cutu != NULL)
13396             {
13397               if (dwarf_read_debug)
13398                 {
13399                   fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) found: @%s\n",
13400                                       kind, dwo_name, hex_string (signature),
13401                                       host_address_to_string (dwo_cutu));
13402                 }
13403               return dwo_cutu;
13404             }
13405         }
13406     }
13407
13408   /* We didn't find it.  This could mean a dwo_id mismatch, or
13409      someone deleted the DWO/DWP file, or the search path isn't set up
13410      correctly to find the file.  */
13411
13412   if (dwarf_read_debug)
13413     {
13414       fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) not found\n",
13415                           kind, dwo_name, hex_string (signature));
13416     }
13417
13418   /* This is a warning and not a complaint because it can be caused by
13419      pilot error (e.g., user accidentally deleting the DWO).  */
13420   {
13421     /* Print the name of the DWP file if we looked there, helps the user
13422        better diagnose the problem.  */
13423     std::string dwp_text;
13424
13425     if (dwp_file != NULL)
13426       dwp_text = string_printf (" [in DWP file %s]",
13427                                 lbasename (dwp_file->name));
13428
13429     warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset %s"
13430                " [in module %s]"),
13431              kind, dwo_name, hex_string (signature),
13432              dwp_text.c_str (),
13433              this_unit->is_debug_types ? "TU" : "CU",
13434              sect_offset_str (this_unit->sect_off), objfile_name (objfile));
13435   }
13436   return NULL;
13437 }
13438
13439 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
13440    See lookup_dwo_cutu_unit for details.  */
13441
13442 static struct dwo_unit *
13443 lookup_dwo_comp_unit (struct dwarf2_per_cu_data *this_cu,
13444                       const char *dwo_name, const char *comp_dir,
13445                       ULONGEST signature)
13446 {
13447   return lookup_dwo_cutu (this_cu, dwo_name, comp_dir, signature, 0);
13448 }
13449
13450 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
13451    See lookup_dwo_cutu_unit for details.  */
13452
13453 static struct dwo_unit *
13454 lookup_dwo_type_unit (struct signatured_type *this_tu,
13455                       const char *dwo_name, const char *comp_dir)
13456 {
13457   return lookup_dwo_cutu (&this_tu->per_cu, dwo_name, comp_dir, this_tu->signature, 1);
13458 }
13459
13460 /* Traversal function for queue_and_load_all_dwo_tus.  */
13461
13462 static int
13463 queue_and_load_dwo_tu (void **slot, void *info)
13464 {
13465   struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
13466   struct dwarf2_per_cu_data *per_cu = (struct dwarf2_per_cu_data *) info;
13467   ULONGEST signature = dwo_unit->signature;
13468   struct signatured_type *sig_type =
13469     lookup_dwo_signatured_type (per_cu->cu, signature);
13470
13471   if (sig_type != NULL)
13472     {
13473       struct dwarf2_per_cu_data *sig_cu = &sig_type->per_cu;
13474
13475       /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
13476          a real dependency of PER_CU on SIG_TYPE.  That is detected later
13477          while processing PER_CU.  */
13478       if (maybe_queue_comp_unit (NULL, sig_cu, per_cu->cu->language))
13479         load_full_type_unit (sig_cu);
13480       VEC_safe_push (dwarf2_per_cu_ptr, per_cu->imported_symtabs, sig_cu);
13481     }
13482
13483   return 1;
13484 }
13485
13486 /* Queue all TUs contained in the DWO of PER_CU to be read in.
13487    The DWO may have the only definition of the type, though it may not be
13488    referenced anywhere in PER_CU.  Thus we have to load *all* its TUs.
13489    http://sourceware.org/bugzilla/show_bug.cgi?id=15021  */
13490
13491 static void
13492 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *per_cu)
13493 {
13494   struct dwo_unit *dwo_unit;
13495   struct dwo_file *dwo_file;
13496
13497   gdb_assert (!per_cu->is_debug_types);
13498   gdb_assert (get_dwp_file (per_cu->dwarf2_per_objfile) == NULL);
13499   gdb_assert (per_cu->cu != NULL);
13500
13501   dwo_unit = per_cu->cu->dwo_unit;
13502   gdb_assert (dwo_unit != NULL);
13503
13504   dwo_file = dwo_unit->dwo_file;
13505   if (dwo_file->tus != NULL)
13506     htab_traverse_noresize (dwo_file->tus, queue_and_load_dwo_tu, per_cu);
13507 }
13508
13509 /* Free all resources associated with DWO_FILE.
13510    Close the DWO file and munmap the sections.  */
13511
13512 static void
13513 free_dwo_file (struct dwo_file *dwo_file)
13514 {
13515   /* Note: dbfd is NULL for virtual DWO files.  */
13516   gdb_bfd_unref (dwo_file->dbfd);
13517
13518   VEC_free (dwarf2_section_info_def, dwo_file->sections.types);
13519 }
13520
13521 /* Traversal function for free_dwo_files.  */
13522
13523 static int
13524 free_dwo_file_from_slot (void **slot, void *info)
13525 {
13526   struct dwo_file *dwo_file = (struct dwo_file *) *slot;
13527
13528   free_dwo_file (dwo_file);
13529
13530   return 1;
13531 }
13532
13533 /* Free all resources associated with DWO_FILES.  */
13534
13535 static void
13536 free_dwo_files (htab_t dwo_files, struct objfile *objfile)
13537 {
13538   htab_traverse_noresize (dwo_files, free_dwo_file_from_slot, objfile);
13539 }
13540 \f
13541 /* Read in various DIEs.  */
13542
13543 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
13544    Inherit only the children of the DW_AT_abstract_origin DIE not being
13545    already referenced by DW_AT_abstract_origin from the children of the
13546    current DIE.  */
13547
13548 static void
13549 inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu)
13550 {
13551   struct die_info *child_die;
13552   sect_offset *offsetp;
13553   /* Parent of DIE - referenced by DW_AT_abstract_origin.  */
13554   struct die_info *origin_die;
13555   /* Iterator of the ORIGIN_DIE children.  */
13556   struct die_info *origin_child_die;
13557   struct attribute *attr;
13558   struct dwarf2_cu *origin_cu;
13559   struct pending **origin_previous_list_in_scope;
13560
13561   attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
13562   if (!attr)
13563     return;
13564
13565   /* Note that following die references may follow to a die in a
13566      different cu.  */
13567
13568   origin_cu = cu;
13569   origin_die = follow_die_ref (die, attr, &origin_cu);
13570
13571   /* We're inheriting ORIGIN's children into the scope we'd put DIE's
13572      symbols in.  */
13573   origin_previous_list_in_scope = origin_cu->list_in_scope;
13574   origin_cu->list_in_scope = cu->list_in_scope;
13575
13576   if (die->tag != origin_die->tag
13577       && !(die->tag == DW_TAG_inlined_subroutine
13578            && origin_die->tag == DW_TAG_subprogram))
13579     complaint (_("DIE %s and its abstract origin %s have different tags"),
13580                sect_offset_str (die->sect_off),
13581                sect_offset_str (origin_die->sect_off));
13582
13583   std::vector<sect_offset> offsets;
13584
13585   for (child_die = die->child;
13586        child_die && child_die->tag;
13587        child_die = sibling_die (child_die))
13588     {
13589       struct die_info *child_origin_die;
13590       struct dwarf2_cu *child_origin_cu;
13591
13592       /* We are trying to process concrete instance entries:
13593          DW_TAG_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
13594          it's not relevant to our analysis here. i.e. detecting DIEs that are
13595          present in the abstract instance but not referenced in the concrete
13596          one.  */
13597       if (child_die->tag == DW_TAG_call_site
13598           || child_die->tag == DW_TAG_GNU_call_site)
13599         continue;
13600
13601       /* For each CHILD_DIE, find the corresponding child of
13602          ORIGIN_DIE.  If there is more than one layer of
13603          DW_AT_abstract_origin, follow them all; there shouldn't be,
13604          but GCC versions at least through 4.4 generate this (GCC PR
13605          40573).  */
13606       child_origin_die = child_die;
13607       child_origin_cu = cu;
13608       while (1)
13609         {
13610           attr = dwarf2_attr (child_origin_die, DW_AT_abstract_origin,
13611                               child_origin_cu);
13612           if (attr == NULL)
13613             break;
13614           child_origin_die = follow_die_ref (child_origin_die, attr,
13615                                              &child_origin_cu);
13616         }
13617
13618       /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
13619          counterpart may exist.  */
13620       if (child_origin_die != child_die)
13621         {
13622           if (child_die->tag != child_origin_die->tag
13623               && !(child_die->tag == DW_TAG_inlined_subroutine
13624                    && child_origin_die->tag == DW_TAG_subprogram))
13625             complaint (_("Child DIE %s and its abstract origin %s have "
13626                          "different tags"),
13627                        sect_offset_str (child_die->sect_off),
13628                        sect_offset_str (child_origin_die->sect_off));
13629           if (child_origin_die->parent != origin_die)
13630             complaint (_("Child DIE %s and its abstract origin %s have "
13631                          "different parents"),
13632                        sect_offset_str (child_die->sect_off),
13633                        sect_offset_str (child_origin_die->sect_off));
13634           else
13635             offsets.push_back (child_origin_die->sect_off);
13636         }
13637     }
13638   std::sort (offsets.begin (), offsets.end ());
13639   sect_offset *offsets_end = offsets.data () + offsets.size ();
13640   for (offsetp = offsets.data () + 1; offsetp < offsets_end; offsetp++)
13641     if (offsetp[-1] == *offsetp)
13642       complaint (_("Multiple children of DIE %s refer "
13643                    "to DIE %s as their abstract origin"),
13644                  sect_offset_str (die->sect_off), sect_offset_str (*offsetp));
13645
13646   offsetp = offsets.data ();
13647   origin_child_die = origin_die->child;
13648   while (origin_child_die && origin_child_die->tag)
13649     {
13650       /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children?  */
13651       while (offsetp < offsets_end
13652              && *offsetp < origin_child_die->sect_off)
13653         offsetp++;
13654       if (offsetp >= offsets_end
13655           || *offsetp > origin_child_die->sect_off)
13656         {
13657           /* Found that ORIGIN_CHILD_DIE is really not referenced.
13658              Check whether we're already processing ORIGIN_CHILD_DIE.
13659              This can happen with mutually referenced abstract_origins.
13660              PR 16581.  */
13661           if (!origin_child_die->in_process)
13662             process_die (origin_child_die, origin_cu);
13663         }
13664       origin_child_die = sibling_die (origin_child_die);
13665     }
13666   origin_cu->list_in_scope = origin_previous_list_in_scope;
13667 }
13668
13669 static void
13670 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
13671 {
13672   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13673   struct gdbarch *gdbarch = get_objfile_arch (objfile);
13674   struct context_stack *newobj;
13675   CORE_ADDR lowpc;
13676   CORE_ADDR highpc;
13677   struct die_info *child_die;
13678   struct attribute *attr, *call_line, *call_file;
13679   const char *name;
13680   CORE_ADDR baseaddr;
13681   struct block *block;
13682   int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
13683   std::vector<struct symbol *> template_args;
13684   struct template_symbol *templ_func = NULL;
13685
13686   if (inlined_func)
13687     {
13688       /* If we do not have call site information, we can't show the
13689          caller of this inlined function.  That's too confusing, so
13690          only use the scope for local variables.  */
13691       call_line = dwarf2_attr (die, DW_AT_call_line, cu);
13692       call_file = dwarf2_attr (die, DW_AT_call_file, cu);
13693       if (call_line == NULL || call_file == NULL)
13694         {
13695           read_lexical_block_scope (die, cu);
13696           return;
13697         }
13698     }
13699
13700   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13701
13702   name = dwarf2_name (die, cu);
13703
13704   /* Ignore functions with missing or empty names.  These are actually
13705      illegal according to the DWARF standard.  */
13706   if (name == NULL)
13707     {
13708       complaint (_("missing name for subprogram DIE at %s"),
13709                  sect_offset_str (die->sect_off));
13710       return;
13711     }
13712
13713   /* Ignore functions with missing or invalid low and high pc attributes.  */
13714   if (dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL)
13715       <= PC_BOUNDS_INVALID)
13716     {
13717       attr = dwarf2_attr (die, DW_AT_external, cu);
13718       if (!attr || !DW_UNSND (attr))
13719         complaint (_("cannot get low and high bounds "
13720                      "for subprogram DIE at %s"),
13721                    sect_offset_str (die->sect_off));
13722       return;
13723     }
13724
13725   lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
13726   highpc = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
13727
13728   /* If we have any template arguments, then we must allocate a
13729      different sort of symbol.  */
13730   for (child_die = die->child; child_die; child_die = sibling_die (child_die))
13731     {
13732       if (child_die->tag == DW_TAG_template_type_param
13733           || child_die->tag == DW_TAG_template_value_param)
13734         {
13735           templ_func = allocate_template_symbol (objfile);
13736           templ_func->subclass = SYMBOL_TEMPLATE;
13737           break;
13738         }
13739     }
13740
13741   newobj = cu->get_builder ()->push_context (0, lowpc);
13742   newobj->name = new_symbol (die, read_type_die (die, cu), cu,
13743                              (struct symbol *) templ_func);
13744
13745   /* If there is a location expression for DW_AT_frame_base, record
13746      it.  */
13747   attr = dwarf2_attr (die, DW_AT_frame_base, cu);
13748   if (attr)
13749     dwarf2_symbol_mark_computed (attr, newobj->name, cu, 1);
13750
13751   /* If there is a location for the static link, record it.  */
13752   newobj->static_link = NULL;
13753   attr = dwarf2_attr (die, DW_AT_static_link, cu);
13754   if (attr)
13755     {
13756       newobj->static_link
13757         = XOBNEW (&objfile->objfile_obstack, struct dynamic_prop);
13758       attr_to_dynamic_prop (attr, die, cu, newobj->static_link);
13759     }
13760
13761   cu->list_in_scope = cu->get_builder ()->get_local_symbols ();
13762
13763   if (die->child != NULL)
13764     {
13765       child_die = die->child;
13766       while (child_die && child_die->tag)
13767         {
13768           if (child_die->tag == DW_TAG_template_type_param
13769               || child_die->tag == DW_TAG_template_value_param)
13770             {
13771               struct symbol *arg = new_symbol (child_die, NULL, cu);
13772
13773               if (arg != NULL)
13774                 template_args.push_back (arg);
13775             }
13776           else
13777             process_die (child_die, cu);
13778           child_die = sibling_die (child_die);
13779         }
13780     }
13781
13782   inherit_abstract_dies (die, cu);
13783
13784   /* If we have a DW_AT_specification, we might need to import using
13785      directives from the context of the specification DIE.  See the
13786      comment in determine_prefix.  */
13787   if (cu->language == language_cplus
13788       && dwarf2_attr (die, DW_AT_specification, cu))
13789     {
13790       struct dwarf2_cu *spec_cu = cu;
13791       struct die_info *spec_die = die_specification (die, &spec_cu);
13792
13793       while (spec_die)
13794         {
13795           child_die = spec_die->child;
13796           while (child_die && child_die->tag)
13797             {
13798               if (child_die->tag == DW_TAG_imported_module)
13799                 process_die (child_die, spec_cu);
13800               child_die = sibling_die (child_die);
13801             }
13802
13803           /* In some cases, GCC generates specification DIEs that
13804              themselves contain DW_AT_specification attributes.  */
13805           spec_die = die_specification (spec_die, &spec_cu);
13806         }
13807     }
13808
13809   struct context_stack cstk = cu->get_builder ()->pop_context ();
13810   /* Make a block for the local symbols within.  */
13811   block = cu->get_builder ()->finish_block (cstk.name, cstk.old_blocks,
13812                                      cstk.static_link, lowpc, highpc);
13813
13814   /* For C++, set the block's scope.  */
13815   if ((cu->language == language_cplus
13816        || cu->language == language_fortran
13817        || cu->language == language_d
13818        || cu->language == language_rust)
13819       && cu->processing_has_namespace_info)
13820     block_set_scope (block, determine_prefix (die, cu),
13821                      &objfile->objfile_obstack);
13822
13823   /* If we have address ranges, record them.  */
13824   dwarf2_record_block_ranges (die, block, baseaddr, cu);
13825
13826   gdbarch_make_symbol_special (gdbarch, cstk.name, objfile);
13827
13828   /* Attach template arguments to function.  */
13829   if (!template_args.empty ())
13830     {
13831       gdb_assert (templ_func != NULL);
13832
13833       templ_func->n_template_arguments = template_args.size ();
13834       templ_func->template_arguments
13835         = XOBNEWVEC (&objfile->objfile_obstack, struct symbol *,
13836                      templ_func->n_template_arguments);
13837       memcpy (templ_func->template_arguments,
13838               template_args.data (),
13839               (templ_func->n_template_arguments * sizeof (struct symbol *)));
13840
13841       /* Make sure that the symtab is set on the new symbols.  Even
13842          though they don't appear in this symtab directly, other parts
13843          of gdb assume that symbols do, and this is reasonably
13844          true.  */
13845       for (symbol *sym : template_args)
13846         symbol_set_symtab (sym, symbol_symtab (templ_func));
13847     }
13848
13849   /* In C++, we can have functions nested inside functions (e.g., when
13850      a function declares a class that has methods).  This means that
13851      when we finish processing a function scope, we may need to go
13852      back to building a containing block's symbol lists.  */
13853   *cu->get_builder ()->get_local_symbols () = cstk.locals;
13854   cu->get_builder ()->set_local_using_directives (cstk.local_using_directives);
13855
13856   /* If we've finished processing a top-level function, subsequent
13857      symbols go in the file symbol list.  */
13858   if (cu->get_builder ()->outermost_context_p ())
13859     cu->list_in_scope = cu->get_builder ()->get_file_symbols ();
13860 }
13861
13862 /* Process all the DIES contained within a lexical block scope.  Start
13863    a new scope, process the dies, and then close the scope.  */
13864
13865 static void
13866 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
13867 {
13868   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13869   struct gdbarch *gdbarch = get_objfile_arch (objfile);
13870   CORE_ADDR lowpc, highpc;
13871   struct die_info *child_die;
13872   CORE_ADDR baseaddr;
13873
13874   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13875
13876   /* Ignore blocks with missing or invalid low and high pc attributes.  */
13877   /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
13878      as multiple lexical blocks?  Handling children in a sane way would
13879      be nasty.  Might be easier to properly extend generic blocks to
13880      describe ranges.  */
13881   switch (dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
13882     {
13883     case PC_BOUNDS_NOT_PRESENT:
13884       /* DW_TAG_lexical_block has no attributes, process its children as if
13885          there was no wrapping by that DW_TAG_lexical_block.
13886          GCC does no longer produces such DWARF since GCC r224161.  */
13887       for (child_die = die->child;
13888            child_die != NULL && child_die->tag;
13889            child_die = sibling_die (child_die))
13890         process_die (child_die, cu);
13891       return;
13892     case PC_BOUNDS_INVALID:
13893       return;
13894     }
13895   lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
13896   highpc = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
13897
13898   cu->get_builder ()->push_context (0, lowpc);
13899   if (die->child != NULL)
13900     {
13901       child_die = die->child;
13902       while (child_die && child_die->tag)
13903         {
13904           process_die (child_die, cu);
13905           child_die = sibling_die (child_die);
13906         }
13907     }
13908   inherit_abstract_dies (die, cu);
13909   struct context_stack cstk = cu->get_builder ()->pop_context ();
13910
13911   if (*cu->get_builder ()->get_local_symbols () != NULL
13912       || (*cu->get_builder ()->get_local_using_directives ()) != NULL)
13913     {
13914       struct block *block
13915         = cu->get_builder ()->finish_block (0, cstk.old_blocks, NULL,
13916                                      cstk.start_addr, highpc);
13917
13918       /* Note that recording ranges after traversing children, as we
13919          do here, means that recording a parent's ranges entails
13920          walking across all its children's ranges as they appear in
13921          the address map, which is quadratic behavior.
13922
13923          It would be nicer to record the parent's ranges before
13924          traversing its children, simply overriding whatever you find
13925          there.  But since we don't even decide whether to create a
13926          block until after we've traversed its children, that's hard
13927          to do.  */
13928       dwarf2_record_block_ranges (die, block, baseaddr, cu);
13929     }
13930   *cu->get_builder ()->get_local_symbols () = cstk.locals;
13931   cu->get_builder ()->set_local_using_directives (cstk.local_using_directives);
13932 }
13933
13934 /* Read in DW_TAG_call_site and insert it to CU->call_site_htab.  */
13935
13936 static void
13937 read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
13938 {
13939   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
13940   struct gdbarch *gdbarch = get_objfile_arch (objfile);
13941   CORE_ADDR pc, baseaddr;
13942   struct attribute *attr;
13943   struct call_site *call_site, call_site_local;
13944   void **slot;
13945   int nparams;
13946   struct die_info *child_die;
13947
13948   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13949
13950   attr = dwarf2_attr (die, DW_AT_call_return_pc, cu);
13951   if (attr == NULL)
13952     {
13953       /* This was a pre-DWARF-5 GNU extension alias
13954          for DW_AT_call_return_pc.  */
13955       attr = dwarf2_attr (die, DW_AT_low_pc, cu);
13956     }
13957   if (!attr)
13958     {
13959       complaint (_("missing DW_AT_call_return_pc for DW_TAG_call_site "
13960                    "DIE %s [in module %s]"),
13961                  sect_offset_str (die->sect_off), objfile_name (objfile));
13962       return;
13963     }
13964   pc = attr_value_as_address (attr) + baseaddr;
13965   pc = gdbarch_adjust_dwarf2_addr (gdbarch, pc);
13966
13967   if (cu->call_site_htab == NULL)
13968     cu->call_site_htab = htab_create_alloc_ex (16, core_addr_hash, core_addr_eq,
13969                                                NULL, &objfile->objfile_obstack,
13970                                                hashtab_obstack_allocate, NULL);
13971   call_site_local.pc = pc;
13972   slot = htab_find_slot (cu->call_site_htab, &call_site_local, INSERT);
13973   if (*slot != NULL)
13974     {
13975       complaint (_("Duplicate PC %s for DW_TAG_call_site "
13976                    "DIE %s [in module %s]"),
13977                  paddress (gdbarch, pc), sect_offset_str (die->sect_off),
13978                  objfile_name (objfile));
13979       return;
13980     }
13981
13982   /* Count parameters at the caller.  */
13983
13984   nparams = 0;
13985   for (child_die = die->child; child_die && child_die->tag;
13986        child_die = sibling_die (child_die))
13987     {
13988       if (child_die->tag != DW_TAG_call_site_parameter
13989           && child_die->tag != DW_TAG_GNU_call_site_parameter)
13990         {
13991           complaint (_("Tag %d is not DW_TAG_call_site_parameter in "
13992                        "DW_TAG_call_site child DIE %s [in module %s]"),
13993                      child_die->tag, sect_offset_str (child_die->sect_off),
13994                      objfile_name (objfile));
13995           continue;
13996         }
13997
13998       nparams++;
13999     }
14000
14001   call_site
14002     = ((struct call_site *)
14003        obstack_alloc (&objfile->objfile_obstack,
14004                       sizeof (*call_site)
14005                       + (sizeof (*call_site->parameter) * (nparams - 1))));
14006   *slot = call_site;
14007   memset (call_site, 0, sizeof (*call_site) - sizeof (*call_site->parameter));
14008   call_site->pc = pc;
14009
14010   if (dwarf2_flag_true_p (die, DW_AT_call_tail_call, cu)
14011       || dwarf2_flag_true_p (die, DW_AT_GNU_tail_call, cu))
14012     {
14013       struct die_info *func_die;
14014
14015       /* Skip also over DW_TAG_inlined_subroutine.  */
14016       for (func_die = die->parent;
14017            func_die && func_die->tag != DW_TAG_subprogram
14018            && func_die->tag != DW_TAG_subroutine_type;
14019            func_die = func_die->parent);
14020
14021       /* DW_AT_call_all_calls is a superset
14022          of DW_AT_call_all_tail_calls.  */
14023       if (func_die
14024           && !dwarf2_flag_true_p (func_die, DW_AT_call_all_calls, cu)
14025           && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_call_sites, cu)
14026           && !dwarf2_flag_true_p (func_die, DW_AT_call_all_tail_calls, cu)
14027           && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_tail_call_sites, cu))
14028         {
14029           /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
14030              not complete.  But keep CALL_SITE for look ups via call_site_htab,
14031              both the initial caller containing the real return address PC and
14032              the final callee containing the current PC of a chain of tail
14033              calls do not need to have the tail call list complete.  But any
14034              function candidate for a virtual tail call frame searched via
14035              TYPE_TAIL_CALL_LIST must have the tail call list complete to be
14036              determined unambiguously.  */
14037         }
14038       else
14039         {
14040           struct type *func_type = NULL;
14041
14042           if (func_die)
14043             func_type = get_die_type (func_die, cu);
14044           if (func_type != NULL)
14045             {
14046               gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC);
14047
14048               /* Enlist this call site to the function.  */
14049               call_site->tail_call_next = TYPE_TAIL_CALL_LIST (func_type);
14050               TYPE_TAIL_CALL_LIST (func_type) = call_site;
14051             }
14052           else
14053             complaint (_("Cannot find function owning DW_TAG_call_site "
14054                          "DIE %s [in module %s]"),
14055                        sect_offset_str (die->sect_off), objfile_name (objfile));
14056         }
14057     }
14058
14059   attr = dwarf2_attr (die, DW_AT_call_target, cu);
14060   if (attr == NULL)
14061     attr = dwarf2_attr (die, DW_AT_GNU_call_site_target, cu);
14062   if (attr == NULL)
14063     attr = dwarf2_attr (die, DW_AT_call_origin, cu);
14064   if (attr == NULL)
14065     {
14066       /* This was a pre-DWARF-5 GNU extension alias for DW_AT_call_origin.  */
14067       attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
14068     }
14069   SET_FIELD_DWARF_BLOCK (call_site->target, NULL);
14070   if (!attr || (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0))
14071     /* Keep NULL DWARF_BLOCK.  */;
14072   else if (attr_form_is_block (attr))
14073     {
14074       struct dwarf2_locexpr_baton *dlbaton;
14075
14076       dlbaton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
14077       dlbaton->data = DW_BLOCK (attr)->data;
14078       dlbaton->size = DW_BLOCK (attr)->size;
14079       dlbaton->per_cu = cu->per_cu;
14080
14081       SET_FIELD_DWARF_BLOCK (call_site->target, dlbaton);
14082     }
14083   else if (attr_form_is_ref (attr))
14084     {
14085       struct dwarf2_cu *target_cu = cu;
14086       struct die_info *target_die;
14087
14088       target_die = follow_die_ref (die, attr, &target_cu);
14089       gdb_assert (target_cu->per_cu->dwarf2_per_objfile->objfile == objfile);
14090       if (die_is_declaration (target_die, target_cu))
14091         {
14092           const char *target_physname;
14093
14094           /* Prefer the mangled name; otherwise compute the demangled one.  */
14095           target_physname = dw2_linkage_name (target_die, target_cu);
14096           if (target_physname == NULL)
14097             target_physname = dwarf2_physname (NULL, target_die, target_cu);
14098           if (target_physname == NULL)
14099             complaint (_("DW_AT_call_target target DIE has invalid "
14100                          "physname, for referencing DIE %s [in module %s]"),
14101                        sect_offset_str (die->sect_off), objfile_name (objfile));
14102           else
14103             SET_FIELD_PHYSNAME (call_site->target, target_physname);
14104         }
14105       else
14106         {
14107           CORE_ADDR lowpc;
14108
14109           /* DW_AT_entry_pc should be preferred.  */
14110           if (dwarf2_get_pc_bounds (target_die, &lowpc, NULL, target_cu, NULL)
14111               <= PC_BOUNDS_INVALID)
14112             complaint (_("DW_AT_call_target target DIE has invalid "
14113                          "low pc, for referencing DIE %s [in module %s]"),
14114                        sect_offset_str (die->sect_off), objfile_name (objfile));
14115           else
14116             {
14117               lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
14118               SET_FIELD_PHYSADDR (call_site->target, lowpc);
14119             }
14120         }
14121     }
14122   else
14123     complaint (_("DW_TAG_call_site DW_AT_call_target is neither "
14124                  "block nor reference, for DIE %s [in module %s]"),
14125                sect_offset_str (die->sect_off), objfile_name (objfile));
14126
14127   call_site->per_cu = cu->per_cu;
14128
14129   for (child_die = die->child;
14130        child_die && child_die->tag;
14131        child_die = sibling_die (child_die))
14132     {
14133       struct call_site_parameter *parameter;
14134       struct attribute *loc, *origin;
14135
14136       if (child_die->tag != DW_TAG_call_site_parameter
14137           && child_die->tag != DW_TAG_GNU_call_site_parameter)
14138         {
14139           /* Already printed the complaint above.  */
14140           continue;
14141         }
14142
14143       gdb_assert (call_site->parameter_count < nparams);
14144       parameter = &call_site->parameter[call_site->parameter_count];
14145
14146       /* DW_AT_location specifies the register number or DW_AT_abstract_origin
14147          specifies DW_TAG_formal_parameter.  Value of the data assumed for the
14148          register is contained in DW_AT_call_value.  */
14149
14150       loc = dwarf2_attr (child_die, DW_AT_location, cu);
14151       origin = dwarf2_attr (child_die, DW_AT_call_parameter, cu);
14152       if (origin == NULL)
14153         {
14154           /* This was a pre-DWARF-5 GNU extension alias
14155              for DW_AT_call_parameter.  */
14156           origin = dwarf2_attr (child_die, DW_AT_abstract_origin, cu);
14157         }
14158       if (loc == NULL && origin != NULL && attr_form_is_ref (origin))
14159         {
14160           parameter->kind = CALL_SITE_PARAMETER_PARAM_OFFSET;
14161
14162           sect_offset sect_off
14163             = (sect_offset) dwarf2_get_ref_die_offset (origin);
14164           if (!offset_in_cu_p (&cu->header, sect_off))
14165             {
14166               /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
14167                  binding can be done only inside one CU.  Such referenced DIE
14168                  therefore cannot be even moved to DW_TAG_partial_unit.  */
14169               complaint (_("DW_AT_call_parameter offset is not in CU for "
14170                            "DW_TAG_call_site child DIE %s [in module %s]"),
14171                          sect_offset_str (child_die->sect_off),
14172                          objfile_name (objfile));
14173               continue;
14174             }
14175           parameter->u.param_cu_off
14176             = (cu_offset) (sect_off - cu->header.sect_off);
14177         }
14178       else if (loc == NULL || origin != NULL || !attr_form_is_block (loc))
14179         {
14180           complaint (_("No DW_FORM_block* DW_AT_location for "
14181                        "DW_TAG_call_site child DIE %s [in module %s]"),
14182                      sect_offset_str (child_die->sect_off), objfile_name (objfile));
14183           continue;
14184         }
14185       else
14186         {
14187           parameter->u.dwarf_reg = dwarf_block_to_dwarf_reg
14188             (DW_BLOCK (loc)->data, &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size]);
14189           if (parameter->u.dwarf_reg != -1)
14190             parameter->kind = CALL_SITE_PARAMETER_DWARF_REG;
14191           else if (dwarf_block_to_sp_offset (gdbarch, DW_BLOCK (loc)->data,
14192                                     &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size],
14193                                              &parameter->u.fb_offset))
14194             parameter->kind = CALL_SITE_PARAMETER_FB_OFFSET;
14195           else
14196             {
14197               complaint (_("Only single DW_OP_reg or DW_OP_fbreg is supported "
14198                            "for DW_FORM_block* DW_AT_location is supported for "
14199                            "DW_TAG_call_site child DIE %s "
14200                            "[in module %s]"),
14201                          sect_offset_str (child_die->sect_off),
14202                          objfile_name (objfile));
14203               continue;
14204             }
14205         }
14206
14207       attr = dwarf2_attr (child_die, DW_AT_call_value, cu);
14208       if (attr == NULL)
14209         attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_value, cu);
14210       if (!attr_form_is_block (attr))
14211         {
14212           complaint (_("No DW_FORM_block* DW_AT_call_value for "
14213                        "DW_TAG_call_site child DIE %s [in module %s]"),
14214                      sect_offset_str (child_die->sect_off),
14215                      objfile_name (objfile));
14216           continue;
14217         }
14218       parameter->value = DW_BLOCK (attr)->data;
14219       parameter->value_size = DW_BLOCK (attr)->size;
14220
14221       /* Parameters are not pre-cleared by memset above.  */
14222       parameter->data_value = NULL;
14223       parameter->data_value_size = 0;
14224       call_site->parameter_count++;
14225
14226       attr = dwarf2_attr (child_die, DW_AT_call_data_value, cu);
14227       if (attr == NULL)
14228         attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_data_value, cu);
14229       if (attr)
14230         {
14231           if (!attr_form_is_block (attr))
14232             complaint (_("No DW_FORM_block* DW_AT_call_data_value for "
14233                          "DW_TAG_call_site child DIE %s [in module %s]"),
14234                        sect_offset_str (child_die->sect_off),
14235                        objfile_name (objfile));
14236           else
14237             {
14238               parameter->data_value = DW_BLOCK (attr)->data;
14239               parameter->data_value_size = DW_BLOCK (attr)->size;
14240             }
14241         }
14242     }
14243 }
14244
14245 /* Helper function for read_variable.  If DIE represents a virtual
14246    table, then return the type of the concrete object that is
14247    associated with the virtual table.  Otherwise, return NULL.  */
14248
14249 static struct type *
14250 rust_containing_type (struct die_info *die, struct dwarf2_cu *cu)
14251 {
14252   struct attribute *attr = dwarf2_attr (die, DW_AT_type, cu);
14253   if (attr == NULL)
14254     return NULL;
14255
14256   /* Find the type DIE.  */
14257   struct die_info *type_die = NULL;
14258   struct dwarf2_cu *type_cu = cu;
14259
14260   if (attr_form_is_ref (attr))
14261     type_die = follow_die_ref (die, attr, &type_cu);
14262   if (type_die == NULL)
14263     return NULL;
14264
14265   if (dwarf2_attr (type_die, DW_AT_containing_type, type_cu) == NULL)
14266     return NULL;
14267   return die_containing_type (type_die, type_cu);
14268 }
14269
14270 /* Read a variable (DW_TAG_variable) DIE and create a new symbol.  */
14271
14272 static void
14273 read_variable (struct die_info *die, struct dwarf2_cu *cu)
14274 {
14275   struct rust_vtable_symbol *storage = NULL;
14276
14277   if (cu->language == language_rust)
14278     {
14279       struct type *containing_type = rust_containing_type (die, cu);
14280
14281       if (containing_type != NULL)
14282         {
14283           struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14284
14285           storage = OBSTACK_ZALLOC (&objfile->objfile_obstack,
14286                                     struct rust_vtable_symbol);
14287           initialize_objfile_symbol (storage);
14288           storage->concrete_type = containing_type;
14289           storage->subclass = SYMBOL_RUST_VTABLE;
14290         }
14291     }
14292
14293   struct symbol *res = new_symbol (die, NULL, cu, storage);
14294   struct attribute *abstract_origin
14295     = dwarf2_attr (die, DW_AT_abstract_origin, cu);
14296   struct attribute *loc = dwarf2_attr (die, DW_AT_location, cu);
14297   if (res == NULL && loc && abstract_origin)
14298     {
14299       /* We have a variable without a name, but with a location and an abstract
14300          origin.  This may be a concrete instance of an abstract variable
14301          referenced from an DW_OP_GNU_variable_value, so save it to find it back
14302          later.  */
14303       struct dwarf2_cu *origin_cu = cu;
14304       struct die_info *origin_die
14305         = follow_die_ref (die, abstract_origin, &origin_cu);
14306       dwarf2_per_objfile *dpo = cu->per_cu->dwarf2_per_objfile;
14307       dpo->abstract_to_concrete[origin_die].push_back (die);
14308     }
14309 }
14310
14311 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET
14312    reading .debug_rnglists.
14313    Callback's type should be:
14314     void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14315    Return true if the attributes are present and valid, otherwise,
14316    return false.  */
14317
14318 template <typename Callback>
14319 static bool
14320 dwarf2_rnglists_process (unsigned offset, struct dwarf2_cu *cu,
14321                          Callback &&callback)
14322 {
14323   struct dwarf2_per_objfile *dwarf2_per_objfile
14324     = cu->per_cu->dwarf2_per_objfile;
14325   struct objfile *objfile = dwarf2_per_objfile->objfile;
14326   bfd *obfd = objfile->obfd;
14327   /* Base address selection entry.  */
14328   CORE_ADDR base;
14329   int found_base;
14330   const gdb_byte *buffer;
14331   CORE_ADDR baseaddr;
14332   bool overflow = false;
14333
14334   found_base = cu->base_known;
14335   base = cu->base_address;
14336
14337   dwarf2_read_section (objfile, &dwarf2_per_objfile->rnglists);
14338   if (offset >= dwarf2_per_objfile->rnglists.size)
14339     {
14340       complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14341                  offset);
14342       return false;
14343     }
14344   buffer = dwarf2_per_objfile->rnglists.buffer + offset;
14345
14346   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
14347
14348   while (1)
14349     {
14350       /* Initialize it due to a false compiler warning.  */
14351       CORE_ADDR range_beginning = 0, range_end = 0;
14352       const gdb_byte *buf_end = (dwarf2_per_objfile->rnglists.buffer
14353                                  + dwarf2_per_objfile->rnglists.size);
14354       unsigned int bytes_read;
14355
14356       if (buffer == buf_end)
14357         {
14358           overflow = true;
14359           break;
14360         }
14361       const auto rlet = static_cast<enum dwarf_range_list_entry>(*buffer++);
14362       switch (rlet)
14363         {
14364         case DW_RLE_end_of_list:
14365           break;
14366         case DW_RLE_base_address:
14367           if (buffer + cu->header.addr_size > buf_end)
14368             {
14369               overflow = true;
14370               break;
14371             }
14372           base = read_address (obfd, buffer, cu, &bytes_read);
14373           found_base = 1;
14374           buffer += bytes_read;
14375           break;
14376         case DW_RLE_start_length:
14377           if (buffer + cu->header.addr_size > buf_end)
14378             {
14379               overflow = true;
14380               break;
14381             }
14382           range_beginning = read_address (obfd, buffer, cu, &bytes_read);
14383           buffer += bytes_read;
14384           range_end = (range_beginning
14385                        + read_unsigned_leb128 (obfd, buffer, &bytes_read));
14386           buffer += bytes_read;
14387           if (buffer > buf_end)
14388             {
14389               overflow = true;
14390               break;
14391             }
14392           break;
14393         case DW_RLE_offset_pair:
14394           range_beginning = read_unsigned_leb128 (obfd, buffer, &bytes_read);
14395           buffer += bytes_read;
14396           if (buffer > buf_end)
14397             {
14398               overflow = true;
14399               break;
14400             }
14401           range_end = read_unsigned_leb128 (obfd, buffer, &bytes_read);
14402           buffer += bytes_read;
14403           if (buffer > buf_end)
14404             {
14405               overflow = true;
14406               break;
14407             }
14408           break;
14409         case DW_RLE_start_end:
14410           if (buffer + 2 * cu->header.addr_size > buf_end)
14411             {
14412               overflow = true;
14413               break;
14414             }
14415           range_beginning = read_address (obfd, buffer, cu, &bytes_read);
14416           buffer += bytes_read;
14417           range_end = read_address (obfd, buffer, cu, &bytes_read);
14418           buffer += bytes_read;
14419           break;
14420         default:
14421           complaint (_("Invalid .debug_rnglists data (no base address)"));
14422           return false;
14423         }
14424       if (rlet == DW_RLE_end_of_list || overflow)
14425         break;
14426       if (rlet == DW_RLE_base_address)
14427         continue;
14428
14429       if (!found_base)
14430         {
14431           /* We have no valid base address for the ranges
14432              data.  */
14433           complaint (_("Invalid .debug_rnglists data (no base address)"));
14434           return false;
14435         }
14436
14437       if (range_beginning > range_end)
14438         {
14439           /* Inverted range entries are invalid.  */
14440           complaint (_("Invalid .debug_rnglists data (inverted range)"));
14441           return false;
14442         }
14443
14444       /* Empty range entries have no effect.  */
14445       if (range_beginning == range_end)
14446         continue;
14447
14448       range_beginning += base;
14449       range_end += base;
14450
14451       /* A not-uncommon case of bad debug info.
14452          Don't pollute the addrmap with bad data.  */
14453       if (range_beginning + baseaddr == 0
14454           && !dwarf2_per_objfile->has_section_at_zero)
14455         {
14456           complaint (_(".debug_rnglists entry has start address of zero"
14457                        " [in module %s]"), objfile_name (objfile));
14458           continue;
14459         }
14460
14461       callback (range_beginning, range_end);
14462     }
14463
14464   if (overflow)
14465     {
14466       complaint (_("Offset %d is not terminated "
14467                    "for DW_AT_ranges attribute"),
14468                  offset);
14469       return false;
14470     }
14471
14472   return true;
14473 }
14474
14475 /* Call CALLBACK from DW_AT_ranges attribute value OFFSET reading .debug_ranges.
14476    Callback's type should be:
14477     void (CORE_ADDR range_beginning, CORE_ADDR range_end)
14478    Return 1 if the attributes are present and valid, otherwise, return 0.  */
14479
14480 template <typename Callback>
14481 static int
14482 dwarf2_ranges_process (unsigned offset, struct dwarf2_cu *cu,
14483                        Callback &&callback)
14484 {
14485   struct dwarf2_per_objfile *dwarf2_per_objfile
14486       = cu->per_cu->dwarf2_per_objfile;
14487   struct objfile *objfile = dwarf2_per_objfile->objfile;
14488   struct comp_unit_head *cu_header = &cu->header;
14489   bfd *obfd = objfile->obfd;
14490   unsigned int addr_size = cu_header->addr_size;
14491   CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
14492   /* Base address selection entry.  */
14493   CORE_ADDR base;
14494   int found_base;
14495   unsigned int dummy;
14496   const gdb_byte *buffer;
14497   CORE_ADDR baseaddr;
14498
14499   if (cu_header->version >= 5)
14500     return dwarf2_rnglists_process (offset, cu, callback);
14501
14502   found_base = cu->base_known;
14503   base = cu->base_address;
14504
14505   dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
14506   if (offset >= dwarf2_per_objfile->ranges.size)
14507     {
14508       complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
14509                  offset);
14510       return 0;
14511     }
14512   buffer = dwarf2_per_objfile->ranges.buffer + offset;
14513
14514   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
14515
14516   while (1)
14517     {
14518       CORE_ADDR range_beginning, range_end;
14519
14520       range_beginning = read_address (obfd, buffer, cu, &dummy);
14521       buffer += addr_size;
14522       range_end = read_address (obfd, buffer, cu, &dummy);
14523       buffer += addr_size;
14524       offset += 2 * addr_size;
14525
14526       /* An end of list marker is a pair of zero addresses.  */
14527       if (range_beginning == 0 && range_end == 0)
14528         /* Found the end of list entry.  */
14529         break;
14530
14531       /* Each base address selection entry is a pair of 2 values.
14532          The first is the largest possible address, the second is
14533          the base address.  Check for a base address here.  */
14534       if ((range_beginning & mask) == mask)
14535         {
14536           /* If we found the largest possible address, then we already
14537              have the base address in range_end.  */
14538           base = range_end;
14539           found_base = 1;
14540           continue;
14541         }
14542
14543       if (!found_base)
14544         {
14545           /* We have no valid base address for the ranges
14546              data.  */
14547           complaint (_("Invalid .debug_ranges data (no base address)"));
14548           return 0;
14549         }
14550
14551       if (range_beginning > range_end)
14552         {
14553           /* Inverted range entries are invalid.  */
14554           complaint (_("Invalid .debug_ranges data (inverted range)"));
14555           return 0;
14556         }
14557
14558       /* Empty range entries have no effect.  */
14559       if (range_beginning == range_end)
14560         continue;
14561
14562       range_beginning += base;
14563       range_end += base;
14564
14565       /* A not-uncommon case of bad debug info.
14566          Don't pollute the addrmap with bad data.  */
14567       if (range_beginning + baseaddr == 0
14568           && !dwarf2_per_objfile->has_section_at_zero)
14569         {
14570           complaint (_(".debug_ranges entry has start address of zero"
14571                        " [in module %s]"), objfile_name (objfile));
14572           continue;
14573         }
14574
14575       callback (range_beginning, range_end);
14576     }
14577
14578   return 1;
14579 }
14580
14581 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
14582    Return 1 if the attributes are present and valid, otherwise, return 0.
14583    If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'.  */
14584
14585 static int
14586 dwarf2_ranges_read (unsigned offset, CORE_ADDR *low_return,
14587                     CORE_ADDR *high_return, struct dwarf2_cu *cu,
14588                     struct partial_symtab *ranges_pst)
14589 {
14590   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14591   struct gdbarch *gdbarch = get_objfile_arch (objfile);
14592   const CORE_ADDR baseaddr = ANOFFSET (objfile->section_offsets,
14593                                        SECT_OFF_TEXT (objfile));
14594   int low_set = 0;
14595   CORE_ADDR low = 0;
14596   CORE_ADDR high = 0;
14597   int retval;
14598
14599   retval = dwarf2_ranges_process (offset, cu,
14600     [&] (CORE_ADDR range_beginning, CORE_ADDR range_end)
14601     {
14602       if (ranges_pst != NULL)
14603         {
14604           CORE_ADDR lowpc;
14605           CORE_ADDR highpc;
14606
14607           lowpc = (gdbarch_adjust_dwarf2_addr (gdbarch,
14608                                                range_beginning + baseaddr)
14609                    - baseaddr);
14610           highpc = (gdbarch_adjust_dwarf2_addr (gdbarch,
14611                                                 range_end + baseaddr)
14612                     - baseaddr);
14613           addrmap_set_empty (objfile->partial_symtabs->psymtabs_addrmap,
14614                              lowpc, highpc - 1, ranges_pst);
14615         }
14616
14617       /* FIXME: This is recording everything as a low-high
14618          segment of consecutive addresses.  We should have a
14619          data structure for discontiguous block ranges
14620          instead.  */
14621       if (! low_set)
14622         {
14623           low = range_beginning;
14624           high = range_end;
14625           low_set = 1;
14626         }
14627       else
14628         {
14629           if (range_beginning < low)
14630             low = range_beginning;
14631           if (range_end > high)
14632             high = range_end;
14633         }
14634     });
14635   if (!retval)
14636     return 0;
14637
14638   if (! low_set)
14639     /* If the first entry is an end-of-list marker, the range
14640        describes an empty scope, i.e. no instructions.  */
14641     return 0;
14642
14643   if (low_return)
14644     *low_return = low;
14645   if (high_return)
14646     *high_return = high;
14647   return 1;
14648 }
14649
14650 /* Get low and high pc attributes from a die.  See enum pc_bounds_kind
14651    definition for the return value.  *LOWPC and *HIGHPC are set iff
14652    neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned.  */
14653
14654 static enum pc_bounds_kind
14655 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
14656                       CORE_ADDR *highpc, struct dwarf2_cu *cu,
14657                       struct partial_symtab *pst)
14658 {
14659   struct dwarf2_per_objfile *dwarf2_per_objfile
14660     = cu->per_cu->dwarf2_per_objfile;
14661   struct attribute *attr;
14662   struct attribute *attr_high;
14663   CORE_ADDR low = 0;
14664   CORE_ADDR high = 0;
14665   enum pc_bounds_kind ret;
14666
14667   attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
14668   if (attr_high)
14669     {
14670       attr = dwarf2_attr (die, DW_AT_low_pc, cu);
14671       if (attr)
14672         {
14673           low = attr_value_as_address (attr);
14674           high = attr_value_as_address (attr_high);
14675           if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
14676             high += low;
14677         }
14678       else
14679         /* Found high w/o low attribute.  */
14680         return PC_BOUNDS_INVALID;
14681
14682       /* Found consecutive range of addresses.  */
14683       ret = PC_BOUNDS_HIGH_LOW;
14684     }
14685   else
14686     {
14687       attr = dwarf2_attr (die, DW_AT_ranges, cu);
14688       if (attr != NULL)
14689         {
14690           /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14691              We take advantage of the fact that DW_AT_ranges does not appear
14692              in DW_TAG_compile_unit of DWO files.  */
14693           int need_ranges_base = die->tag != DW_TAG_compile_unit;
14694           unsigned int ranges_offset = (DW_UNSND (attr)
14695                                         + (need_ranges_base
14696                                            ? cu->ranges_base
14697                                            : 0));
14698
14699           /* Value of the DW_AT_ranges attribute is the offset in the
14700              .debug_ranges section.  */
14701           if (!dwarf2_ranges_read (ranges_offset, &low, &high, cu, pst))
14702             return PC_BOUNDS_INVALID;
14703           /* Found discontinuous range of addresses.  */
14704           ret = PC_BOUNDS_RANGES;
14705         }
14706       else
14707         return PC_BOUNDS_NOT_PRESENT;
14708     }
14709
14710   /* partial_die_info::read has also the strict LOW < HIGH requirement.  */
14711   if (high <= low)
14712     return PC_BOUNDS_INVALID;
14713
14714   /* When using the GNU linker, .gnu.linkonce. sections are used to
14715      eliminate duplicate copies of functions and vtables and such.
14716      The linker will arbitrarily choose one and discard the others.
14717      The AT_*_pc values for such functions refer to local labels in
14718      these sections.  If the section from that file was discarded, the
14719      labels are not in the output, so the relocs get a value of 0.
14720      If this is a discarded function, mark the pc bounds as invalid,
14721      so that GDB will ignore it.  */
14722   if (low == 0 && !dwarf2_per_objfile->has_section_at_zero)
14723     return PC_BOUNDS_INVALID;
14724
14725   *lowpc = low;
14726   if (highpc)
14727     *highpc = high;
14728   return ret;
14729 }
14730
14731 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
14732    its low and high PC addresses.  Do nothing if these addresses could not
14733    be determined.  Otherwise, set LOWPC to the low address if it is smaller,
14734    and HIGHPC to the high address if greater than HIGHPC.  */
14735
14736 static void
14737 dwarf2_get_subprogram_pc_bounds (struct die_info *die,
14738                                  CORE_ADDR *lowpc, CORE_ADDR *highpc,
14739                                  struct dwarf2_cu *cu)
14740 {
14741   CORE_ADDR low, high;
14742   struct die_info *child = die->child;
14743
14744   if (dwarf2_get_pc_bounds (die, &low, &high, cu, NULL) >= PC_BOUNDS_RANGES)
14745     {
14746       *lowpc = std::min (*lowpc, low);
14747       *highpc = std::max (*highpc, high);
14748     }
14749
14750   /* If the language does not allow nested subprograms (either inside
14751      subprograms or lexical blocks), we're done.  */
14752   if (cu->language != language_ada)
14753     return;
14754
14755   /* Check all the children of the given DIE.  If it contains nested
14756      subprograms, then check their pc bounds.  Likewise, we need to
14757      check lexical blocks as well, as they may also contain subprogram
14758      definitions.  */
14759   while (child && child->tag)
14760     {
14761       if (child->tag == DW_TAG_subprogram
14762           || child->tag == DW_TAG_lexical_block)
14763         dwarf2_get_subprogram_pc_bounds (child, lowpc, highpc, cu);
14764       child = sibling_die (child);
14765     }
14766 }
14767
14768 /* Get the low and high pc's represented by the scope DIE, and store
14769    them in *LOWPC and *HIGHPC.  If the correct values can't be
14770    determined, set *LOWPC to -1 and *HIGHPC to 0.  */
14771
14772 static void
14773 get_scope_pc_bounds (struct die_info *die,
14774                      CORE_ADDR *lowpc, CORE_ADDR *highpc,
14775                      struct dwarf2_cu *cu)
14776 {
14777   CORE_ADDR best_low = (CORE_ADDR) -1;
14778   CORE_ADDR best_high = (CORE_ADDR) 0;
14779   CORE_ADDR current_low, current_high;
14780
14781   if (dwarf2_get_pc_bounds (die, &current_low, &current_high, cu, NULL)
14782       >= PC_BOUNDS_RANGES)
14783     {
14784       best_low = current_low;
14785       best_high = current_high;
14786     }
14787   else
14788     {
14789       struct die_info *child = die->child;
14790
14791       while (child && child->tag)
14792         {
14793           switch (child->tag) {
14794           case DW_TAG_subprogram:
14795             dwarf2_get_subprogram_pc_bounds (child, &best_low, &best_high, cu);
14796             break;
14797           case DW_TAG_namespace:
14798           case DW_TAG_module:
14799             /* FIXME: carlton/2004-01-16: Should we do this for
14800                DW_TAG_class_type/DW_TAG_structure_type, too?  I think
14801                that current GCC's always emit the DIEs corresponding
14802                to definitions of methods of classes as children of a
14803                DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
14804                the DIEs giving the declarations, which could be
14805                anywhere).  But I don't see any reason why the
14806                standards says that they have to be there.  */
14807             get_scope_pc_bounds (child, &current_low, &current_high, cu);
14808
14809             if (current_low != ((CORE_ADDR) -1))
14810               {
14811                 best_low = std::min (best_low, current_low);
14812                 best_high = std::max (best_high, current_high);
14813               }
14814             break;
14815           default:
14816             /* Ignore.  */
14817             break;
14818           }
14819
14820           child = sibling_die (child);
14821         }
14822     }
14823
14824   *lowpc = best_low;
14825   *highpc = best_high;
14826 }
14827
14828 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
14829    in DIE.  */
14830
14831 static void
14832 dwarf2_record_block_ranges (struct die_info *die, struct block *block,
14833                             CORE_ADDR baseaddr, struct dwarf2_cu *cu)
14834 {
14835   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
14836   struct gdbarch *gdbarch = get_objfile_arch (objfile);
14837   struct attribute *attr;
14838   struct attribute *attr_high;
14839
14840   attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
14841   if (attr_high)
14842     {
14843       attr = dwarf2_attr (die, DW_AT_low_pc, cu);
14844       if (attr)
14845         {
14846           CORE_ADDR low = attr_value_as_address (attr);
14847           CORE_ADDR high = attr_value_as_address (attr_high);
14848
14849           if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
14850             high += low;
14851
14852           low = gdbarch_adjust_dwarf2_addr (gdbarch, low + baseaddr);
14853           high = gdbarch_adjust_dwarf2_addr (gdbarch, high + baseaddr);
14854           cu->get_builder ()->record_block_range (block, low, high - 1);
14855         }
14856     }
14857
14858   attr = dwarf2_attr (die, DW_AT_ranges, cu);
14859   if (attr)
14860     {
14861       /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
14862          We take advantage of the fact that DW_AT_ranges does not appear
14863          in DW_TAG_compile_unit of DWO files.  */
14864       int need_ranges_base = die->tag != DW_TAG_compile_unit;
14865
14866       /* The value of the DW_AT_ranges attribute is the offset of the
14867          address range list in the .debug_ranges section.  */
14868       unsigned long offset = (DW_UNSND (attr)
14869                               + (need_ranges_base ? cu->ranges_base : 0));
14870
14871       std::vector<blockrange> blockvec;
14872       dwarf2_ranges_process (offset, cu,
14873         [&] (CORE_ADDR start, CORE_ADDR end)
14874         {
14875           start += baseaddr;
14876           end += baseaddr;
14877           start = gdbarch_adjust_dwarf2_addr (gdbarch, start);
14878           end = gdbarch_adjust_dwarf2_addr (gdbarch, end);
14879           cu->get_builder ()->record_block_range (block, start, end - 1);
14880           blockvec.emplace_back (start, end);
14881         });
14882
14883       BLOCK_RANGES(block) = make_blockranges (objfile, blockvec);
14884     }
14885 }
14886
14887 /* Check whether the producer field indicates either of GCC < 4.6, or the
14888    Intel C/C++ compiler, and cache the result in CU.  */
14889
14890 static void
14891 check_producer (struct dwarf2_cu *cu)
14892 {
14893   int major, minor;
14894
14895   if (cu->producer == NULL)
14896     {
14897       /* For unknown compilers expect their behavior is DWARF version
14898          compliant.
14899
14900          GCC started to support .debug_types sections by -gdwarf-4 since
14901          gcc-4.5.x.  As the .debug_types sections are missing DW_AT_producer
14902          for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
14903          combination.  gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
14904          interpreted incorrectly by GDB now - GCC PR debug/48229.  */
14905     }
14906   else if (producer_is_gcc (cu->producer, &major, &minor))
14907     {
14908       cu->producer_is_gxx_lt_4_6 = major < 4 || (major == 4 && minor < 6);
14909       cu->producer_is_gcc_lt_4_3 = major < 4 || (major == 4 && minor < 3);
14910     }
14911   else if (producer_is_icc (cu->producer, &major, &minor))
14912     {
14913       cu->producer_is_icc = true;
14914       cu->producer_is_icc_lt_14 = major < 14;
14915     }
14916   else if (startswith (cu->producer, "CodeWarrior S12/L-ISA"))
14917     cu->producer_is_codewarrior = true;
14918   else
14919     {
14920       /* For other non-GCC compilers, expect their behavior is DWARF version
14921          compliant.  */
14922     }
14923
14924   cu->checked_producer = true;
14925 }
14926
14927 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
14928    to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
14929    during 4.6.0 experimental.  */
14930
14931 static bool
14932 producer_is_gxx_lt_4_6 (struct dwarf2_cu *cu)
14933 {
14934   if (!cu->checked_producer)
14935     check_producer (cu);
14936
14937   return cu->producer_is_gxx_lt_4_6;
14938 }
14939
14940
14941 /* Codewarrior (at least as of version 5.0.40) generates dwarf line information
14942    with incorrect is_stmt attributes.  */
14943
14944 static bool
14945 producer_is_codewarrior (struct dwarf2_cu *cu)
14946 {
14947   if (!cu->checked_producer)
14948     check_producer (cu);
14949
14950   return cu->producer_is_codewarrior;
14951 }
14952
14953 /* Return the default accessibility type if it is not overriden by
14954    DW_AT_accessibility.  */
14955
14956 static enum dwarf_access_attribute
14957 dwarf2_default_access_attribute (struct die_info *die, struct dwarf2_cu *cu)
14958 {
14959   if (cu->header.version < 3 || producer_is_gxx_lt_4_6 (cu))
14960     {
14961       /* The default DWARF 2 accessibility for members is public, the default
14962          accessibility for inheritance is private.  */
14963
14964       if (die->tag != DW_TAG_inheritance)
14965         return DW_ACCESS_public;
14966       else
14967         return DW_ACCESS_private;
14968     }
14969   else
14970     {
14971       /* DWARF 3+ defines the default accessibility a different way.  The same
14972          rules apply now for DW_TAG_inheritance as for the members and it only
14973          depends on the container kind.  */
14974
14975       if (die->parent->tag == DW_TAG_class_type)
14976         return DW_ACCESS_private;
14977       else
14978         return DW_ACCESS_public;
14979     }
14980 }
14981
14982 /* Look for DW_AT_data_member_location.  Set *OFFSET to the byte
14983    offset.  If the attribute was not found return 0, otherwise return
14984    1.  If it was found but could not properly be handled, set *OFFSET
14985    to 0.  */
14986
14987 static int
14988 handle_data_member_location (struct die_info *die, struct dwarf2_cu *cu,
14989                              LONGEST *offset)
14990 {
14991   struct attribute *attr;
14992
14993   attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
14994   if (attr != NULL)
14995     {
14996       *offset = 0;
14997
14998       /* Note that we do not check for a section offset first here.
14999          This is because DW_AT_data_member_location is new in DWARF 4,
15000          so if we see it, we can assume that a constant form is really
15001          a constant and not a section offset.  */
15002       if (attr_form_is_constant (attr))
15003         *offset = dwarf2_get_attr_constant_value (attr, 0);
15004       else if (attr_form_is_section_offset (attr))
15005         dwarf2_complex_location_expr_complaint ();
15006       else if (attr_form_is_block (attr))
15007         *offset = decode_locdesc (DW_BLOCK (attr), cu);
15008       else
15009         dwarf2_complex_location_expr_complaint ();
15010
15011       return 1;
15012     }
15013
15014   return 0;
15015 }
15016
15017 /* Add an aggregate field to the field list.  */
15018
15019 static void
15020 dwarf2_add_field (struct field_info *fip, struct die_info *die,
15021                   struct dwarf2_cu *cu)
15022 {
15023   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15024   struct gdbarch *gdbarch = get_objfile_arch (objfile);
15025   struct nextfield *new_field;
15026   struct attribute *attr;
15027   struct field *fp;
15028   const char *fieldname = "";
15029
15030   if (die->tag == DW_TAG_inheritance)
15031     {
15032       fip->baseclasses.emplace_back ();
15033       new_field = &fip->baseclasses.back ();
15034     }
15035   else
15036     {
15037       fip->fields.emplace_back ();
15038       new_field = &fip->fields.back ();
15039     }
15040
15041   fip->nfields++;
15042
15043   attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15044   if (attr)
15045     new_field->accessibility = DW_UNSND (attr);
15046   else
15047     new_field->accessibility = dwarf2_default_access_attribute (die, cu);
15048   if (new_field->accessibility != DW_ACCESS_public)
15049     fip->non_public_fields = 1;
15050
15051   attr = dwarf2_attr (die, DW_AT_virtuality, cu);
15052   if (attr)
15053     new_field->virtuality = DW_UNSND (attr);
15054   else
15055     new_field->virtuality = DW_VIRTUALITY_none;
15056
15057   fp = &new_field->field;
15058
15059   if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
15060     {
15061       LONGEST offset;
15062
15063       /* Data member other than a C++ static data member.  */
15064
15065       /* Get type of field.  */
15066       fp->type = die_type (die, cu);
15067
15068       SET_FIELD_BITPOS (*fp, 0);
15069
15070       /* Get bit size of field (zero if none).  */
15071       attr = dwarf2_attr (die, DW_AT_bit_size, cu);
15072       if (attr)
15073         {
15074           FIELD_BITSIZE (*fp) = DW_UNSND (attr);
15075         }
15076       else
15077         {
15078           FIELD_BITSIZE (*fp) = 0;
15079         }
15080
15081       /* Get bit offset of field.  */
15082       if (handle_data_member_location (die, cu, &offset))
15083         SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
15084       attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
15085       if (attr)
15086         {
15087           if (gdbarch_bits_big_endian (gdbarch))
15088             {
15089               /* For big endian bits, the DW_AT_bit_offset gives the
15090                  additional bit offset from the MSB of the containing
15091                  anonymous object to the MSB of the field.  We don't
15092                  have to do anything special since we don't need to
15093                  know the size of the anonymous object.  */
15094               SET_FIELD_BITPOS (*fp, FIELD_BITPOS (*fp) + DW_UNSND (attr));
15095             }
15096           else
15097             {
15098               /* For little endian bits, compute the bit offset to the
15099                  MSB of the anonymous object, subtract off the number of
15100                  bits from the MSB of the field to the MSB of the
15101                  object, and then subtract off the number of bits of
15102                  the field itself.  The result is the bit offset of
15103                  the LSB of the field.  */
15104               int anonymous_size;
15105               int bit_offset = DW_UNSND (attr);
15106
15107               attr = dwarf2_attr (die, DW_AT_byte_size, cu);
15108               if (attr)
15109                 {
15110                   /* The size of the anonymous object containing
15111                      the bit field is explicit, so use the
15112                      indicated size (in bytes).  */
15113                   anonymous_size = DW_UNSND (attr);
15114                 }
15115               else
15116                 {
15117                   /* The size of the anonymous object containing
15118                      the bit field must be inferred from the type
15119                      attribute of the data member containing the
15120                      bit field.  */
15121                   anonymous_size = TYPE_LENGTH (fp->type);
15122                 }
15123               SET_FIELD_BITPOS (*fp,
15124                                 (FIELD_BITPOS (*fp)
15125                                  + anonymous_size * bits_per_byte
15126                                  - bit_offset - FIELD_BITSIZE (*fp)));
15127             }
15128         }
15129       attr = dwarf2_attr (die, DW_AT_data_bit_offset, cu);
15130       if (attr != NULL)
15131         SET_FIELD_BITPOS (*fp, (FIELD_BITPOS (*fp)
15132                                 + dwarf2_get_attr_constant_value (attr, 0)));
15133
15134       /* Get name of field.  */
15135       fieldname = dwarf2_name (die, cu);
15136       if (fieldname == NULL)
15137         fieldname = "";
15138
15139       /* The name is already allocated along with this objfile, so we don't
15140          need to duplicate it for the type.  */
15141       fp->name = fieldname;
15142
15143       /* Change accessibility for artificial fields (e.g. virtual table
15144          pointer or virtual base class pointer) to private.  */
15145       if (dwarf2_attr (die, DW_AT_artificial, cu))
15146         {
15147           FIELD_ARTIFICIAL (*fp) = 1;
15148           new_field->accessibility = DW_ACCESS_private;
15149           fip->non_public_fields = 1;
15150         }
15151     }
15152   else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
15153     {
15154       /* C++ static member.  */
15155
15156       /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
15157          is a declaration, but all versions of G++ as of this writing
15158          (so through at least 3.2.1) incorrectly generate
15159          DW_TAG_variable tags.  */
15160
15161       const char *physname;
15162
15163       /* Get name of field.  */
15164       fieldname = dwarf2_name (die, cu);
15165       if (fieldname == NULL)
15166         return;
15167
15168       attr = dwarf2_attr (die, DW_AT_const_value, cu);
15169       if (attr
15170           /* Only create a symbol if this is an external value.
15171              new_symbol checks this and puts the value in the global symbol
15172              table, which we want.  If it is not external, new_symbol
15173              will try to put the value in cu->list_in_scope which is wrong.  */
15174           && dwarf2_flag_true_p (die, DW_AT_external, cu))
15175         {
15176           /* A static const member, not much different than an enum as far as
15177              we're concerned, except that we can support more types.  */
15178           new_symbol (die, NULL, cu);
15179         }
15180
15181       /* Get physical name.  */
15182       physname = dwarf2_physname (fieldname, die, cu);
15183
15184       /* The name is already allocated along with this objfile, so we don't
15185          need to duplicate it for the type.  */
15186       SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
15187       FIELD_TYPE (*fp) = die_type (die, cu);
15188       FIELD_NAME (*fp) = fieldname;
15189     }
15190   else if (die->tag == DW_TAG_inheritance)
15191     {
15192       LONGEST offset;
15193
15194       /* C++ base class field.  */
15195       if (handle_data_member_location (die, cu, &offset))
15196         SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
15197       FIELD_BITSIZE (*fp) = 0;
15198       FIELD_TYPE (*fp) = die_type (die, cu);
15199       FIELD_NAME (*fp) = TYPE_NAME (fp->type);
15200     }
15201   else if (die->tag == DW_TAG_variant_part)
15202     {
15203       /* process_structure_scope will treat this DIE as a union.  */
15204       process_structure_scope (die, cu);
15205
15206       /* The variant part is relative to the start of the enclosing
15207          structure.  */
15208       SET_FIELD_BITPOS (*fp, 0);
15209       fp->type = get_die_type (die, cu);
15210       fp->artificial = 1;
15211       fp->name = "<<variant>>";
15212
15213       /* Normally a DW_TAG_variant_part won't have a size, but our
15214          representation requires one, so set it to the maximum of the
15215          child sizes.  */
15216       if (TYPE_LENGTH (fp->type) == 0)
15217         {
15218           unsigned max = 0;
15219           for (int i = 0; i < TYPE_NFIELDS (fp->type); ++i)
15220             if (TYPE_LENGTH (TYPE_FIELD_TYPE (fp->type, i)) > max)
15221               max = TYPE_LENGTH (TYPE_FIELD_TYPE (fp->type, i));
15222           TYPE_LENGTH (fp->type) = max;
15223         }
15224     }
15225   else
15226     gdb_assert_not_reached ("missing case in dwarf2_add_field");
15227 }
15228
15229 /* Can the type given by DIE define another type?  */
15230
15231 static bool
15232 type_can_define_types (const struct die_info *die)
15233 {
15234   switch (die->tag)
15235     {
15236     case DW_TAG_typedef:
15237     case DW_TAG_class_type:
15238     case DW_TAG_structure_type:
15239     case DW_TAG_union_type:
15240     case DW_TAG_enumeration_type:
15241       return true;
15242
15243     default:
15244       return false;
15245     }
15246 }
15247
15248 /* Add a type definition defined in the scope of the FIP's class.  */
15249
15250 static void
15251 dwarf2_add_type_defn (struct field_info *fip, struct die_info *die,
15252                       struct dwarf2_cu *cu)
15253 {
15254   struct decl_field fp;
15255   memset (&fp, 0, sizeof (fp));
15256
15257   gdb_assert (type_can_define_types (die));
15258
15259   /* Get name of field.  NULL is okay here, meaning an anonymous type.  */
15260   fp.name = dwarf2_name (die, cu);
15261   fp.type = read_type_die (die, cu);
15262
15263   /* Save accessibility.  */
15264   enum dwarf_access_attribute accessibility;
15265   struct attribute *attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15266   if (attr != NULL)
15267     accessibility = (enum dwarf_access_attribute) DW_UNSND (attr);
15268   else
15269     accessibility = dwarf2_default_access_attribute (die, cu);
15270   switch (accessibility)
15271     {
15272     case DW_ACCESS_public:
15273       /* The assumed value if neither private nor protected.  */
15274       break;
15275     case DW_ACCESS_private:
15276       fp.is_private = 1;
15277       break;
15278     case DW_ACCESS_protected:
15279       fp.is_protected = 1;
15280       break;
15281     default:
15282       complaint (_("Unhandled DW_AT_accessibility value (%x)"), accessibility);
15283     }
15284
15285   if (die->tag == DW_TAG_typedef)
15286     fip->typedef_field_list.push_back (fp);
15287   else
15288     fip->nested_types_list.push_back (fp);
15289 }
15290
15291 /* Create the vector of fields, and attach it to the type.  */
15292
15293 static void
15294 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
15295                               struct dwarf2_cu *cu)
15296 {
15297   int nfields = fip->nfields;
15298
15299   /* Record the field count, allocate space for the array of fields,
15300      and create blank accessibility bitfields if necessary.  */
15301   TYPE_NFIELDS (type) = nfields;
15302   TYPE_FIELDS (type) = (struct field *)
15303     TYPE_ZALLOC (type, sizeof (struct field) * nfields);
15304
15305   if (fip->non_public_fields && cu->language != language_ada)
15306     {
15307       ALLOCATE_CPLUS_STRUCT_TYPE (type);
15308
15309       TYPE_FIELD_PRIVATE_BITS (type) =
15310         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15311       B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
15312
15313       TYPE_FIELD_PROTECTED_BITS (type) =
15314         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15315       B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
15316
15317       TYPE_FIELD_IGNORE_BITS (type) =
15318         (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
15319       B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
15320     }
15321
15322   /* If the type has baseclasses, allocate and clear a bit vector for
15323      TYPE_FIELD_VIRTUAL_BITS.  */
15324   if (!fip->baseclasses.empty () && cu->language != language_ada)
15325     {
15326       int num_bytes = B_BYTES (fip->baseclasses.size ());
15327       unsigned char *pointer;
15328
15329       ALLOCATE_CPLUS_STRUCT_TYPE (type);
15330       pointer = (unsigned char *) TYPE_ALLOC (type, num_bytes);
15331       TYPE_FIELD_VIRTUAL_BITS (type) = pointer;
15332       B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->baseclasses.size ());
15333       TYPE_N_BASECLASSES (type) = fip->baseclasses.size ();
15334     }
15335
15336   if (TYPE_FLAG_DISCRIMINATED_UNION (type))
15337     {
15338       struct discriminant_info *di = alloc_discriminant_info (type, -1, -1);
15339
15340       for (int index = 0; index < nfields; ++index)
15341         {
15342           struct nextfield &field = fip->fields[index];
15343
15344           if (field.variant.is_discriminant)
15345             di->discriminant_index = index;
15346           else if (field.variant.default_branch)
15347             di->default_index = index;
15348           else
15349             di->discriminants[index] = field.variant.discriminant_value;
15350         }
15351     }
15352
15353   /* Copy the saved-up fields into the field vector.  */
15354   for (int i = 0; i < nfields; ++i)
15355     {
15356       struct nextfield &field
15357         = ((i < fip->baseclasses.size ()) ? fip->baseclasses[i]
15358            : fip->fields[i - fip->baseclasses.size ()]);
15359
15360       TYPE_FIELD (type, i) = field.field;
15361       switch (field.accessibility)
15362         {
15363         case DW_ACCESS_private:
15364           if (cu->language != language_ada)
15365             SET_TYPE_FIELD_PRIVATE (type, i);
15366           break;
15367
15368         case DW_ACCESS_protected:
15369           if (cu->language != language_ada)
15370             SET_TYPE_FIELD_PROTECTED (type, i);
15371           break;
15372
15373         case DW_ACCESS_public:
15374           break;
15375
15376         default:
15377           /* Unknown accessibility.  Complain and treat it as public.  */
15378           {
15379             complaint (_("unsupported accessibility %d"),
15380                        field.accessibility);
15381           }
15382           break;
15383         }
15384       if (i < fip->baseclasses.size ())
15385         {
15386           switch (field.virtuality)
15387             {
15388             case DW_VIRTUALITY_virtual:
15389             case DW_VIRTUALITY_pure_virtual:
15390               if (cu->language == language_ada)
15391                 error (_("unexpected virtuality in component of Ada type"));
15392               SET_TYPE_FIELD_VIRTUAL (type, i);
15393               break;
15394             }
15395         }
15396     }
15397 }
15398
15399 /* Return true if this member function is a constructor, false
15400    otherwise.  */
15401
15402 static int
15403 dwarf2_is_constructor (struct die_info *die, struct dwarf2_cu *cu)
15404 {
15405   const char *fieldname;
15406   const char *type_name;
15407   int len;
15408
15409   if (die->parent == NULL)
15410     return 0;
15411
15412   if (die->parent->tag != DW_TAG_structure_type
15413       && die->parent->tag != DW_TAG_union_type
15414       && die->parent->tag != DW_TAG_class_type)
15415     return 0;
15416
15417   fieldname = dwarf2_name (die, cu);
15418   type_name = dwarf2_name (die->parent, cu);
15419   if (fieldname == NULL || type_name == NULL)
15420     return 0;
15421
15422   len = strlen (fieldname);
15423   return (strncmp (fieldname, type_name, len) == 0
15424           && (type_name[len] == '\0' || type_name[len] == '<'));
15425 }
15426
15427 /* Add a member function to the proper fieldlist.  */
15428
15429 static void
15430 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
15431                       struct type *type, struct dwarf2_cu *cu)
15432 {
15433   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15434   struct attribute *attr;
15435   int i;
15436   struct fnfieldlist *flp = nullptr;
15437   struct fn_field *fnp;
15438   const char *fieldname;
15439   struct type *this_type;
15440   enum dwarf_access_attribute accessibility;
15441
15442   if (cu->language == language_ada)
15443     error (_("unexpected member function in Ada type"));
15444
15445   /* Get name of member function.  */
15446   fieldname = dwarf2_name (die, cu);
15447   if (fieldname == NULL)
15448     return;
15449
15450   /* Look up member function name in fieldlist.  */
15451   for (i = 0; i < fip->fnfieldlists.size (); i++)
15452     {
15453       if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
15454         {
15455           flp = &fip->fnfieldlists[i];
15456           break;
15457         }
15458     }
15459
15460   /* Create a new fnfieldlist if necessary.  */
15461   if (flp == nullptr)
15462     {
15463       fip->fnfieldlists.emplace_back ();
15464       flp = &fip->fnfieldlists.back ();
15465       flp->name = fieldname;
15466       i = fip->fnfieldlists.size () - 1;
15467     }
15468
15469   /* Create a new member function field and add it to the vector of
15470      fnfieldlists.  */
15471   flp->fnfields.emplace_back ();
15472   fnp = &flp->fnfields.back ();
15473
15474   /* Delay processing of the physname until later.  */
15475   if (cu->language == language_cplus)
15476     add_to_method_list (type, i, flp->fnfields.size () - 1, fieldname,
15477                         die, cu);
15478   else
15479     {
15480       const char *physname = dwarf2_physname (fieldname, die, cu);
15481       fnp->physname = physname ? physname : "";
15482     }
15483
15484   fnp->type = alloc_type (objfile);
15485   this_type = read_type_die (die, cu);
15486   if (this_type && TYPE_CODE (this_type) == TYPE_CODE_FUNC)
15487     {
15488       int nparams = TYPE_NFIELDS (this_type);
15489
15490       /* TYPE is the domain of this method, and THIS_TYPE is the type
15491            of the method itself (TYPE_CODE_METHOD).  */
15492       smash_to_method_type (fnp->type, type,
15493                             TYPE_TARGET_TYPE (this_type),
15494                             TYPE_FIELDS (this_type),
15495                             TYPE_NFIELDS (this_type),
15496                             TYPE_VARARGS (this_type));
15497
15498       /* Handle static member functions.
15499          Dwarf2 has no clean way to discern C++ static and non-static
15500          member functions.  G++ helps GDB by marking the first
15501          parameter for non-static member functions (which is the this
15502          pointer) as artificial.  We obtain this information from
15503          read_subroutine_type via TYPE_FIELD_ARTIFICIAL.  */
15504       if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (this_type, 0) == 0)
15505         fnp->voffset = VOFFSET_STATIC;
15506     }
15507   else
15508     complaint (_("member function type missing for '%s'"),
15509                dwarf2_full_name (fieldname, die, cu));
15510
15511   /* Get fcontext from DW_AT_containing_type if present.  */
15512   if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
15513     fnp->fcontext = die_containing_type (die, cu);
15514
15515   /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
15516      is_volatile is irrelevant, as it is needed by gdb_mangle_name only.  */
15517
15518   /* Get accessibility.  */
15519   attr = dwarf2_attr (die, DW_AT_accessibility, cu);
15520   if (attr)
15521     accessibility = (enum dwarf_access_attribute) DW_UNSND (attr);
15522   else
15523     accessibility = dwarf2_default_access_attribute (die, cu);
15524   switch (accessibility)
15525     {
15526     case DW_ACCESS_private:
15527       fnp->is_private = 1;
15528       break;
15529     case DW_ACCESS_protected:
15530       fnp->is_protected = 1;
15531       break;
15532     }
15533
15534   /* Check for artificial methods.  */
15535   attr = dwarf2_attr (die, DW_AT_artificial, cu);
15536   if (attr && DW_UNSND (attr) != 0)
15537     fnp->is_artificial = 1;
15538
15539   fnp->is_constructor = dwarf2_is_constructor (die, cu);
15540
15541   /* Get index in virtual function table if it is a virtual member
15542      function.  For older versions of GCC, this is an offset in the
15543      appropriate virtual table, as specified by DW_AT_containing_type.
15544      For everyone else, it is an expression to be evaluated relative
15545      to the object address.  */
15546
15547   attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
15548   if (attr)
15549     {
15550       if (attr_form_is_block (attr) && DW_BLOCK (attr)->size > 0)
15551         {
15552           if (DW_BLOCK (attr)->data[0] == DW_OP_constu)
15553             {
15554               /* Old-style GCC.  */
15555               fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
15556             }
15557           else if (DW_BLOCK (attr)->data[0] == DW_OP_deref
15558                    || (DW_BLOCK (attr)->size > 1
15559                        && DW_BLOCK (attr)->data[0] == DW_OP_deref_size
15560                        && DW_BLOCK (attr)->data[1] == cu->header.addr_size))
15561             {
15562               fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu);
15563               if ((fnp->voffset % cu->header.addr_size) != 0)
15564                 dwarf2_complex_location_expr_complaint ();
15565               else
15566                 fnp->voffset /= cu->header.addr_size;
15567               fnp->voffset += 2;
15568             }
15569           else
15570             dwarf2_complex_location_expr_complaint ();
15571
15572           if (!fnp->fcontext)
15573             {
15574               /* If there is no `this' field and no DW_AT_containing_type,
15575                  we cannot actually find a base class context for the
15576                  vtable!  */
15577               if (TYPE_NFIELDS (this_type) == 0
15578                   || !TYPE_FIELD_ARTIFICIAL (this_type, 0))
15579                 {
15580                   complaint (_("cannot determine context for virtual member "
15581                                "function \"%s\" (offset %s)"),
15582                              fieldname, sect_offset_str (die->sect_off));
15583                 }
15584               else
15585                 {
15586                   fnp->fcontext
15587                     = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type, 0));
15588                 }
15589             }
15590         }
15591       else if (attr_form_is_section_offset (attr))
15592         {
15593           dwarf2_complex_location_expr_complaint ();
15594         }
15595       else
15596         {
15597           dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
15598                                                  fieldname);
15599         }
15600     }
15601   else
15602     {
15603       attr = dwarf2_attr (die, DW_AT_virtuality, cu);
15604       if (attr && DW_UNSND (attr))
15605         {
15606           /* GCC does this, as of 2008-08-25; PR debug/37237.  */
15607           complaint (_("Member function \"%s\" (offset %s) is virtual "
15608                        "but the vtable offset is not specified"),
15609                      fieldname, sect_offset_str (die->sect_off));
15610           ALLOCATE_CPLUS_STRUCT_TYPE (type);
15611           TYPE_CPLUS_DYNAMIC (type) = 1;
15612         }
15613     }
15614 }
15615
15616 /* Create the vector of member function fields, and attach it to the type.  */
15617
15618 static void
15619 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
15620                                  struct dwarf2_cu *cu)
15621 {
15622   if (cu->language == language_ada)
15623     error (_("unexpected member functions in Ada type"));
15624
15625   ALLOCATE_CPLUS_STRUCT_TYPE (type);
15626   TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
15627     TYPE_ALLOC (type,
15628                 sizeof (struct fn_fieldlist) * fip->fnfieldlists.size ());
15629
15630   for (int i = 0; i < fip->fnfieldlists.size (); i++)
15631     {
15632       struct fnfieldlist &nf = fip->fnfieldlists[i];
15633       struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
15634
15635       TYPE_FN_FIELDLIST_NAME (type, i) = nf.name;
15636       TYPE_FN_FIELDLIST_LENGTH (type, i) = nf.fnfields.size ();
15637       fn_flp->fn_fields = (struct fn_field *)
15638         TYPE_ALLOC (type, sizeof (struct fn_field) * nf.fnfields.size ());
15639
15640       for (int k = 0; k < nf.fnfields.size (); ++k)
15641         fn_flp->fn_fields[k] = nf.fnfields[k];
15642     }
15643
15644   TYPE_NFN_FIELDS (type) = fip->fnfieldlists.size ();
15645 }
15646
15647 /* Returns non-zero if NAME is the name of a vtable member in CU's
15648    language, zero otherwise.  */
15649 static int
15650 is_vtable_name (const char *name, struct dwarf2_cu *cu)
15651 {
15652   static const char vptr[] = "_vptr";
15653
15654   /* Look for the C++ form of the vtable.  */
15655   if (startswith (name, vptr) && is_cplus_marker (name[sizeof (vptr) - 1]))
15656     return 1;
15657
15658   return 0;
15659 }
15660
15661 /* GCC outputs unnamed structures that are really pointers to member
15662    functions, with the ABI-specified layout.  If TYPE describes
15663    such a structure, smash it into a member function type.
15664
15665    GCC shouldn't do this; it should just output pointer to member DIEs.
15666    This is GCC PR debug/28767.  */
15667
15668 static void
15669 quirk_gcc_member_function_pointer (struct type *type, struct objfile *objfile)
15670 {
15671   struct type *pfn_type, *self_type, *new_type;
15672
15673   /* Check for a structure with no name and two children.  */
15674   if (TYPE_CODE (type) != TYPE_CODE_STRUCT || TYPE_NFIELDS (type) != 2)
15675     return;
15676
15677   /* Check for __pfn and __delta members.  */
15678   if (TYPE_FIELD_NAME (type, 0) == NULL
15679       || strcmp (TYPE_FIELD_NAME (type, 0), "__pfn") != 0
15680       || TYPE_FIELD_NAME (type, 1) == NULL
15681       || strcmp (TYPE_FIELD_NAME (type, 1), "__delta") != 0)
15682     return;
15683
15684   /* Find the type of the method.  */
15685   pfn_type = TYPE_FIELD_TYPE (type, 0);
15686   if (pfn_type == NULL
15687       || TYPE_CODE (pfn_type) != TYPE_CODE_PTR
15688       || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type)) != TYPE_CODE_FUNC)
15689     return;
15690
15691   /* Look for the "this" argument.  */
15692   pfn_type = TYPE_TARGET_TYPE (pfn_type);
15693   if (TYPE_NFIELDS (pfn_type) == 0
15694       /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
15695       || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type, 0)) != TYPE_CODE_PTR)
15696     return;
15697
15698   self_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0));
15699   new_type = alloc_type (objfile);
15700   smash_to_method_type (new_type, self_type, TYPE_TARGET_TYPE (pfn_type),
15701                         TYPE_FIELDS (pfn_type), TYPE_NFIELDS (pfn_type),
15702                         TYPE_VARARGS (pfn_type));
15703   smash_to_methodptr_type (type, new_type);
15704 }
15705
15706 /* If the DIE has a DW_AT_alignment attribute, return its value, doing
15707    appropriate error checking and issuing complaints if there is a
15708    problem.  */
15709
15710 static ULONGEST
15711 get_alignment (struct dwarf2_cu *cu, struct die_info *die)
15712 {
15713   struct attribute *attr = dwarf2_attr (die, DW_AT_alignment, cu);
15714
15715   if (attr == nullptr)
15716     return 0;
15717
15718   if (!attr_form_is_constant (attr))
15719     {
15720       complaint (_("DW_AT_alignment must have constant form"
15721                    " - DIE at %s [in module %s]"),
15722                  sect_offset_str (die->sect_off),
15723                  objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15724       return 0;
15725     }
15726
15727   ULONGEST align;
15728   if (attr->form == DW_FORM_sdata)
15729     {
15730       LONGEST val = DW_SND (attr);
15731       if (val < 0)
15732         {
15733           complaint (_("DW_AT_alignment value must not be negative"
15734                        " - DIE at %s [in module %s]"),
15735                      sect_offset_str (die->sect_off),
15736                      objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15737           return 0;
15738         }
15739       align = val;
15740     }
15741   else
15742     align = DW_UNSND (attr);
15743
15744   if (align == 0)
15745     {
15746       complaint (_("DW_AT_alignment value must not be zero"
15747                    " - DIE at %s [in module %s]"),
15748                  sect_offset_str (die->sect_off),
15749                  objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15750       return 0;
15751     }
15752   if ((align & (align - 1)) != 0)
15753     {
15754       complaint (_("DW_AT_alignment value must be a power of 2"
15755                    " - DIE at %s [in module %s]"),
15756                  sect_offset_str (die->sect_off),
15757                  objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15758       return 0;
15759     }
15760
15761   return align;
15762 }
15763
15764 /* If the DIE has a DW_AT_alignment attribute, use its value to set
15765    the alignment for TYPE.  */
15766
15767 static void
15768 maybe_set_alignment (struct dwarf2_cu *cu, struct die_info *die,
15769                      struct type *type)
15770 {
15771   if (!set_type_align (type, get_alignment (cu, die)))
15772     complaint (_("DW_AT_alignment value too large"
15773                  " - DIE at %s [in module %s]"),
15774                sect_offset_str (die->sect_off),
15775                objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15776 }
15777
15778 /* Called when we find the DIE that starts a structure or union scope
15779    (definition) to create a type for the structure or union.  Fill in
15780    the type's name and general properties; the members will not be
15781    processed until process_structure_scope.  A symbol table entry for
15782    the type will also not be done until process_structure_scope (assuming
15783    the type has a name).
15784
15785    NOTE: we need to call these functions regardless of whether or not the
15786    DIE has a DW_AT_name attribute, since it might be an anonymous
15787    structure or union.  This gets the type entered into our set of
15788    user defined types.  */
15789
15790 static struct type *
15791 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
15792 {
15793   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
15794   struct type *type;
15795   struct attribute *attr;
15796   const char *name;
15797
15798   /* If the definition of this type lives in .debug_types, read that type.
15799      Don't follow DW_AT_specification though, that will take us back up
15800      the chain and we want to go down.  */
15801   attr = dwarf2_attr_no_follow (die, DW_AT_signature);
15802   if (attr)
15803     {
15804       type = get_DW_AT_signature_type (die, attr, cu);
15805
15806       /* The type's CU may not be the same as CU.
15807          Ensure TYPE is recorded with CU in die_type_hash.  */
15808       return set_die_type (die, type, cu);
15809     }
15810
15811   type = alloc_type (objfile);
15812   INIT_CPLUS_SPECIFIC (type);
15813
15814   name = dwarf2_name (die, cu);
15815   if (name != NULL)
15816     {
15817       if (cu->language == language_cplus
15818           || cu->language == language_d
15819           || cu->language == language_rust)
15820         {
15821           const char *full_name = dwarf2_full_name (name, die, cu);
15822
15823           /* dwarf2_full_name might have already finished building the DIE's
15824              type.  If so, there is no need to continue.  */
15825           if (get_die_type (die, cu) != NULL)
15826             return get_die_type (die, cu);
15827
15828           TYPE_NAME (type) = full_name;
15829         }
15830       else
15831         {
15832           /* The name is already allocated along with this objfile, so
15833              we don't need to duplicate it for the type.  */
15834           TYPE_NAME (type) = name;
15835         }
15836     }
15837
15838   if (die->tag == DW_TAG_structure_type)
15839     {
15840       TYPE_CODE (type) = TYPE_CODE_STRUCT;
15841     }
15842   else if (die->tag == DW_TAG_union_type)
15843     {
15844       TYPE_CODE (type) = TYPE_CODE_UNION;
15845     }
15846   else if (die->tag == DW_TAG_variant_part)
15847     {
15848       TYPE_CODE (type) = TYPE_CODE_UNION;
15849       TYPE_FLAG_DISCRIMINATED_UNION (type) = 1;
15850     }
15851   else
15852     {
15853       TYPE_CODE (type) = TYPE_CODE_STRUCT;
15854     }
15855
15856   if (cu->language == language_cplus && die->tag == DW_TAG_class_type)
15857     TYPE_DECLARED_CLASS (type) = 1;
15858
15859   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
15860   if (attr)
15861     {
15862       if (attr_form_is_constant (attr))
15863         TYPE_LENGTH (type) = DW_UNSND (attr);
15864       else
15865         {
15866           /* For the moment, dynamic type sizes are not supported
15867              by GDB's struct type.  The actual size is determined
15868              on-demand when resolving the type of a given object,
15869              so set the type's length to zero for now.  Otherwise,
15870              we record an expression as the length, and that expression
15871              could lead to a very large value, which could eventually
15872              lead to us trying to allocate that much memory when creating
15873              a value of that type.  */
15874           TYPE_LENGTH (type) = 0;
15875         }
15876     }
15877   else
15878     {
15879       TYPE_LENGTH (type) = 0;
15880     }
15881
15882   maybe_set_alignment (cu, die, type);
15883
15884   if (producer_is_icc_lt_14 (cu) && (TYPE_LENGTH (type) == 0))
15885     {
15886       /* ICC<14 does not output the required DW_AT_declaration on
15887          incomplete types, but gives them a size of zero.  */
15888       TYPE_STUB (type) = 1;
15889     }
15890   else
15891     TYPE_STUB_SUPPORTED (type) = 1;
15892
15893   if (die_is_declaration (die, cu))
15894     TYPE_STUB (type) = 1;
15895   else if (attr == NULL && die->child == NULL
15896            && producer_is_realview (cu->producer))
15897     /* RealView does not output the required DW_AT_declaration
15898        on incomplete types.  */
15899     TYPE_STUB (type) = 1;
15900
15901   /* We need to add the type field to the die immediately so we don't
15902      infinitely recurse when dealing with pointers to the structure
15903      type within the structure itself.  */
15904   set_die_type (die, type, cu);
15905
15906   /* set_die_type should be already done.  */
15907   set_descriptive_type (type, die, cu);
15908
15909   return type;
15910 }
15911
15912 /* A helper for process_structure_scope that handles a single member
15913    DIE.  */
15914
15915 static void
15916 handle_struct_member_die (struct die_info *child_die, struct type *type,
15917                           struct field_info *fi,
15918                           std::vector<struct symbol *> *template_args,
15919                           struct dwarf2_cu *cu)
15920 {
15921   if (child_die->tag == DW_TAG_member
15922       || child_die->tag == DW_TAG_variable
15923       || child_die->tag == DW_TAG_variant_part)
15924     {
15925       /* NOTE: carlton/2002-11-05: A C++ static data member
15926          should be a DW_TAG_member that is a declaration, but
15927          all versions of G++ as of this writing (so through at
15928          least 3.2.1) incorrectly generate DW_TAG_variable
15929          tags for them instead.  */
15930       dwarf2_add_field (fi, child_die, cu);
15931     }
15932   else if (child_die->tag == DW_TAG_subprogram)
15933     {
15934       /* Rust doesn't have member functions in the C++ sense.
15935          However, it does emit ordinary functions as children
15936          of a struct DIE.  */
15937       if (cu->language == language_rust)
15938         read_func_scope (child_die, cu);
15939       else
15940         {
15941           /* C++ member function.  */
15942           dwarf2_add_member_fn (fi, child_die, type, cu);
15943         }
15944     }
15945   else if (child_die->tag == DW_TAG_inheritance)
15946     {
15947       /* C++ base class field.  */
15948       dwarf2_add_field (fi, child_die, cu);
15949     }
15950   else if (type_can_define_types (child_die))
15951     dwarf2_add_type_defn (fi, child_die, cu);
15952   else if (child_die->tag == DW_TAG_template_type_param
15953            || child_die->tag == DW_TAG_template_value_param)
15954     {
15955       struct symbol *arg = new_symbol (child_die, NULL, cu);
15956
15957       if (arg != NULL)
15958         template_args->push_back (arg);
15959     }
15960   else if (child_die->tag == DW_TAG_variant)
15961     {
15962       /* In a variant we want to get the discriminant and also add a
15963          field for our sole member child.  */
15964       struct attribute *discr = dwarf2_attr (child_die, DW_AT_discr_value, cu);
15965
15966       for (struct die_info *variant_child = child_die->child;
15967            variant_child != NULL;
15968            variant_child = sibling_die (variant_child))
15969         {
15970           if (variant_child->tag == DW_TAG_member)
15971             {
15972               handle_struct_member_die (variant_child, type, fi,
15973                                         template_args, cu);
15974               /* Only handle the one.  */
15975               break;
15976             }
15977         }
15978
15979       /* We don't handle this but we might as well report it if we see
15980          it.  */
15981       if (dwarf2_attr (child_die, DW_AT_discr_list, cu) != nullptr)
15982           complaint (_("DW_AT_discr_list is not supported yet"
15983                        " - DIE at %s [in module %s]"),
15984                      sect_offset_str (child_die->sect_off),
15985                      objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
15986
15987       /* The first field was just added, so we can stash the
15988          discriminant there.  */
15989       gdb_assert (!fi->fields.empty ());
15990       if (discr == NULL)
15991         fi->fields.back ().variant.default_branch = true;
15992       else
15993         fi->fields.back ().variant.discriminant_value = DW_UNSND (discr);
15994     }
15995 }
15996
15997 /* Finish creating a structure or union type, including filling in
15998    its members and creating a symbol for it.  */
15999
16000 static void
16001 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
16002 {
16003   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16004   struct die_info *child_die;
16005   struct type *type;
16006
16007   type = get_die_type (die, cu);
16008   if (type == NULL)
16009     type = read_structure_type (die, cu);
16010
16011   /* When reading a DW_TAG_variant_part, we need to notice when we
16012      read the discriminant member, so we can record it later in the
16013      discriminant_info.  */
16014   bool is_variant_part = TYPE_FLAG_DISCRIMINATED_UNION (type);
16015   sect_offset discr_offset;
16016   bool has_template_parameters = false;
16017
16018   if (is_variant_part)
16019     {
16020       struct attribute *discr = dwarf2_attr (die, DW_AT_discr, cu);
16021       if (discr == NULL)
16022         {
16023           /* Maybe it's a univariant form, an extension we support.
16024              In this case arrange not to check the offset.  */
16025           is_variant_part = false;
16026         }
16027       else if (attr_form_is_ref (discr))
16028         {
16029           struct dwarf2_cu *target_cu = cu;
16030           struct die_info *target_die = follow_die_ref (die, discr, &target_cu);
16031
16032           discr_offset = target_die->sect_off;
16033         }
16034       else
16035         {
16036           complaint (_("DW_AT_discr does not have DIE reference form"
16037                        " - DIE at %s [in module %s]"),
16038                      sect_offset_str (die->sect_off),
16039                      objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
16040           is_variant_part = false;
16041         }
16042     }
16043
16044   if (die->child != NULL && ! die_is_declaration (die, cu))
16045     {
16046       struct field_info fi;
16047       std::vector<struct symbol *> template_args;
16048
16049       child_die = die->child;
16050
16051       while (child_die && child_die->tag)
16052         {
16053           handle_struct_member_die (child_die, type, &fi, &template_args, cu);
16054
16055           if (is_variant_part && discr_offset == child_die->sect_off)
16056             fi.fields.back ().variant.is_discriminant = true;
16057
16058           child_die = sibling_die (child_die);
16059         }
16060
16061       /* Attach template arguments to type.  */
16062       if (!template_args.empty ())
16063         {
16064           has_template_parameters = true;
16065           ALLOCATE_CPLUS_STRUCT_TYPE (type);
16066           TYPE_N_TEMPLATE_ARGUMENTS (type) = template_args.size ();
16067           TYPE_TEMPLATE_ARGUMENTS (type)
16068             = XOBNEWVEC (&objfile->objfile_obstack,
16069                          struct symbol *,
16070                          TYPE_N_TEMPLATE_ARGUMENTS (type));
16071           memcpy (TYPE_TEMPLATE_ARGUMENTS (type),
16072                   template_args.data (),
16073                   (TYPE_N_TEMPLATE_ARGUMENTS (type)
16074                    * sizeof (struct symbol *)));
16075         }
16076
16077       /* Attach fields and member functions to the type.  */
16078       if (fi.nfields)
16079         dwarf2_attach_fields_to_type (&fi, type, cu);
16080       if (!fi.fnfieldlists.empty ())
16081         {
16082           dwarf2_attach_fn_fields_to_type (&fi, type, cu);
16083
16084           /* Get the type which refers to the base class (possibly this
16085              class itself) which contains the vtable pointer for the current
16086              class from the DW_AT_containing_type attribute.  This use of
16087              DW_AT_containing_type is a GNU extension.  */
16088
16089           if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
16090             {
16091               struct type *t = die_containing_type (die, cu);
16092
16093               set_type_vptr_basetype (type, t);
16094               if (type == t)
16095                 {
16096                   int i;
16097
16098                   /* Our own class provides vtbl ptr.  */
16099                   for (i = TYPE_NFIELDS (t) - 1;
16100                        i >= TYPE_N_BASECLASSES (t);
16101                        --i)
16102                     {
16103                       const char *fieldname = TYPE_FIELD_NAME (t, i);
16104
16105                       if (is_vtable_name (fieldname, cu))
16106                         {
16107                           set_type_vptr_fieldno (type, i);
16108                           break;
16109                         }
16110                     }
16111
16112                   /* Complain if virtual function table field not found.  */
16113                   if (i < TYPE_N_BASECLASSES (t))
16114                     complaint (_("virtual function table pointer "
16115                                  "not found when defining class '%s'"),
16116                                TYPE_NAME (type) ? TYPE_NAME (type) : "");
16117                 }
16118               else
16119                 {
16120                   set_type_vptr_fieldno (type, TYPE_VPTR_FIELDNO (t));
16121                 }
16122             }
16123           else if (cu->producer
16124                    && startswith (cu->producer, "IBM(R) XL C/C++ Advanced Edition"))
16125             {
16126               /* The IBM XLC compiler does not provide direct indication
16127                  of the containing type, but the vtable pointer is
16128                  always named __vfp.  */
16129
16130               int i;
16131
16132               for (i = TYPE_NFIELDS (type) - 1;
16133                    i >= TYPE_N_BASECLASSES (type);
16134                    --i)
16135                 {
16136                   if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
16137                     {
16138                       set_type_vptr_fieldno (type, i);
16139                       set_type_vptr_basetype (type, type);
16140                       break;
16141                     }
16142                 }
16143             }
16144         }
16145
16146       /* Copy fi.typedef_field_list linked list elements content into the
16147          allocated array TYPE_TYPEDEF_FIELD_ARRAY (type).  */
16148       if (!fi.typedef_field_list.empty ())
16149         {
16150           int count = fi.typedef_field_list.size ();
16151
16152           ALLOCATE_CPLUS_STRUCT_TYPE (type);
16153           TYPE_TYPEDEF_FIELD_ARRAY (type)
16154             = ((struct decl_field *)
16155                TYPE_ALLOC (type,
16156                            sizeof (TYPE_TYPEDEF_FIELD (type, 0)) * count));
16157           TYPE_TYPEDEF_FIELD_COUNT (type) = count;
16158
16159           for (int i = 0; i < fi.typedef_field_list.size (); ++i)
16160             TYPE_TYPEDEF_FIELD (type, i) = fi.typedef_field_list[i];
16161         }
16162
16163       /* Copy fi.nested_types_list linked list elements content into the
16164          allocated array TYPE_NESTED_TYPES_ARRAY (type).  */
16165       if (!fi.nested_types_list.empty () && cu->language != language_ada)
16166         {
16167           int count = fi.nested_types_list.size ();
16168
16169           ALLOCATE_CPLUS_STRUCT_TYPE (type);
16170           TYPE_NESTED_TYPES_ARRAY (type)
16171             = ((struct decl_field *)
16172                TYPE_ALLOC (type, sizeof (struct decl_field) * count));
16173           TYPE_NESTED_TYPES_COUNT (type) = count;
16174
16175           for (int i = 0; i < fi.nested_types_list.size (); ++i)
16176             TYPE_NESTED_TYPES_FIELD (type, i) = fi.nested_types_list[i];
16177         }
16178     }
16179
16180   quirk_gcc_member_function_pointer (type, objfile);
16181   if (cu->language == language_rust && die->tag == DW_TAG_union_type)
16182     cu->rust_unions.push_back (type);
16183
16184   /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
16185      snapshots) has been known to create a die giving a declaration
16186      for a class that has, as a child, a die giving a definition for a
16187      nested class.  So we have to process our children even if the
16188      current die is a declaration.  Normally, of course, a declaration
16189      won't have any children at all.  */
16190
16191   child_die = die->child;
16192
16193   while (child_die != NULL && child_die->tag)
16194     {
16195       if (child_die->tag == DW_TAG_member
16196           || child_die->tag == DW_TAG_variable
16197           || child_die->tag == DW_TAG_inheritance
16198           || child_die->tag == DW_TAG_template_value_param
16199           || child_die->tag == DW_TAG_template_type_param)
16200         {
16201           /* Do nothing.  */
16202         }
16203       else
16204         process_die (child_die, cu);
16205
16206       child_die = sibling_die (child_die);
16207     }
16208
16209   /* Do not consider external references.  According to the DWARF standard,
16210      these DIEs are identified by the fact that they have no byte_size
16211      attribute, and a declaration attribute.  */
16212   if (dwarf2_attr (die, DW_AT_byte_size, cu) != NULL
16213       || !die_is_declaration (die, cu))
16214     {
16215       struct symbol *sym = new_symbol (die, type, cu);
16216
16217       if (has_template_parameters)
16218         {
16219           /* Make sure that the symtab is set on the new symbols.
16220              Even though they don't appear in this symtab directly,
16221              other parts of gdb assume that symbols do, and this is
16222              reasonably true.  */
16223           for (int i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (type); ++i)
16224             symbol_set_symtab (TYPE_TEMPLATE_ARGUMENT (type, i),
16225                                symbol_symtab (sym));
16226         }
16227     }
16228 }
16229
16230 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
16231    update TYPE using some information only available in DIE's children.  */
16232
16233 static void
16234 update_enumeration_type_from_children (struct die_info *die,
16235                                        struct type *type,
16236                                        struct dwarf2_cu *cu)
16237 {
16238   struct die_info *child_die;
16239   int unsigned_enum = 1;
16240   int flag_enum = 1;
16241   ULONGEST mask = 0;
16242
16243   auto_obstack obstack;
16244
16245   for (child_die = die->child;
16246        child_die != NULL && child_die->tag;
16247        child_die = sibling_die (child_die))
16248     {
16249       struct attribute *attr;
16250       LONGEST value;
16251       const gdb_byte *bytes;
16252       struct dwarf2_locexpr_baton *baton;
16253       const char *name;
16254
16255       if (child_die->tag != DW_TAG_enumerator)
16256         continue;
16257
16258       attr = dwarf2_attr (child_die, DW_AT_const_value, cu);
16259       if (attr == NULL)
16260         continue;
16261
16262       name = dwarf2_name (child_die, cu);
16263       if (name == NULL)
16264         name = "<anonymous enumerator>";
16265
16266       dwarf2_const_value_attr (attr, type, name, &obstack, cu,
16267                                &value, &bytes, &baton);
16268       if (value < 0)
16269         {
16270           unsigned_enum = 0;
16271           flag_enum = 0;
16272         }
16273       else if ((mask & value) != 0)
16274         flag_enum = 0;
16275       else
16276         mask |= value;
16277
16278       /* If we already know that the enum type is neither unsigned, nor
16279          a flag type, no need to look at the rest of the enumerates.  */
16280       if (!unsigned_enum && !flag_enum)
16281         break;
16282     }
16283
16284   if (unsigned_enum)
16285     TYPE_UNSIGNED (type) = 1;
16286   if (flag_enum)
16287     TYPE_FLAG_ENUM (type) = 1;
16288 }
16289
16290 /* Given a DW_AT_enumeration_type die, set its type.  We do not
16291    complete the type's fields yet, or create any symbols.  */
16292
16293 static struct type *
16294 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
16295 {
16296   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16297   struct type *type;
16298   struct attribute *attr;
16299   const char *name;
16300
16301   /* If the definition of this type lives in .debug_types, read that type.
16302      Don't follow DW_AT_specification though, that will take us back up
16303      the chain and we want to go down.  */
16304   attr = dwarf2_attr_no_follow (die, DW_AT_signature);
16305   if (attr)
16306     {
16307       type = get_DW_AT_signature_type (die, attr, cu);
16308
16309       /* The type's CU may not be the same as CU.
16310          Ensure TYPE is recorded with CU in die_type_hash.  */
16311       return set_die_type (die, type, cu);
16312     }
16313
16314   type = alloc_type (objfile);
16315
16316   TYPE_CODE (type) = TYPE_CODE_ENUM;
16317   name = dwarf2_full_name (NULL, die, cu);
16318   if (name != NULL)
16319     TYPE_NAME (type) = name;
16320
16321   attr = dwarf2_attr (die, DW_AT_type, cu);
16322   if (attr != NULL)
16323     {
16324       struct type *underlying_type = die_type (die, cu);
16325
16326       TYPE_TARGET_TYPE (type) = underlying_type;
16327     }
16328
16329   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16330   if (attr)
16331     {
16332       TYPE_LENGTH (type) = DW_UNSND (attr);
16333     }
16334   else
16335     {
16336       TYPE_LENGTH (type) = 0;
16337     }
16338
16339   maybe_set_alignment (cu, die, type);
16340
16341   /* The enumeration DIE can be incomplete.  In Ada, any type can be
16342      declared as private in the package spec, and then defined only
16343      inside the package body.  Such types are known as Taft Amendment
16344      Types.  When another package uses such a type, an incomplete DIE
16345      may be generated by the compiler.  */
16346   if (die_is_declaration (die, cu))
16347     TYPE_STUB (type) = 1;
16348
16349   /* Finish the creation of this type by using the enum's children.
16350      We must call this even when the underlying type has been provided
16351      so that we can determine if we're looking at a "flag" enum.  */
16352   update_enumeration_type_from_children (die, type, cu);
16353
16354   /* If this type has an underlying type that is not a stub, then we
16355      may use its attributes.  We always use the "unsigned" attribute
16356      in this situation, because ordinarily we guess whether the type
16357      is unsigned -- but the guess can be wrong and the underlying type
16358      can tell us the reality.  However, we defer to a local size
16359      attribute if one exists, because this lets the compiler override
16360      the underlying type if needed.  */
16361   if (TYPE_TARGET_TYPE (type) != NULL && !TYPE_STUB (TYPE_TARGET_TYPE (type)))
16362     {
16363       TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type));
16364       if (TYPE_LENGTH (type) == 0)
16365         TYPE_LENGTH (type) = TYPE_LENGTH (TYPE_TARGET_TYPE (type));
16366       if (TYPE_RAW_ALIGN (type) == 0
16367           && TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type)) != 0)
16368         set_type_align (type, TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type)));
16369     }
16370
16371   TYPE_DECLARED_CLASS (type) = dwarf2_flag_true_p (die, DW_AT_enum_class, cu);
16372
16373   return set_die_type (die, type, cu);
16374 }
16375
16376 /* Given a pointer to a die which begins an enumeration, process all
16377    the dies that define the members of the enumeration, and create the
16378    symbol for the enumeration type.
16379
16380    NOTE: We reverse the order of the element list.  */
16381
16382 static void
16383 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
16384 {
16385   struct type *this_type;
16386
16387   this_type = get_die_type (die, cu);
16388   if (this_type == NULL)
16389     this_type = read_enumeration_type (die, cu);
16390
16391   if (die->child != NULL)
16392     {
16393       struct die_info *child_die;
16394       struct symbol *sym;
16395       struct field *fields = NULL;
16396       int num_fields = 0;
16397       const char *name;
16398
16399       child_die = die->child;
16400       while (child_die && child_die->tag)
16401         {
16402           if (child_die->tag != DW_TAG_enumerator)
16403             {
16404               process_die (child_die, cu);
16405             }
16406           else
16407             {
16408               name = dwarf2_name (child_die, cu);
16409               if (name)
16410                 {
16411                   sym = new_symbol (child_die, this_type, cu);
16412
16413                   if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
16414                     {
16415                       fields = (struct field *)
16416                         xrealloc (fields,
16417                                   (num_fields + DW_FIELD_ALLOC_CHUNK)
16418                                   * sizeof (struct field));
16419                     }
16420
16421                   FIELD_NAME (fields[num_fields]) = SYMBOL_LINKAGE_NAME (sym);
16422                   FIELD_TYPE (fields[num_fields]) = NULL;
16423                   SET_FIELD_ENUMVAL (fields[num_fields], SYMBOL_VALUE (sym));
16424                   FIELD_BITSIZE (fields[num_fields]) = 0;
16425
16426                   num_fields++;
16427                 }
16428             }
16429
16430           child_die = sibling_die (child_die);
16431         }
16432
16433       if (num_fields)
16434         {
16435           TYPE_NFIELDS (this_type) = num_fields;
16436           TYPE_FIELDS (this_type) = (struct field *)
16437             TYPE_ALLOC (this_type, sizeof (struct field) * num_fields);
16438           memcpy (TYPE_FIELDS (this_type), fields,
16439                   sizeof (struct field) * num_fields);
16440           xfree (fields);
16441         }
16442     }
16443
16444   /* If we are reading an enum from a .debug_types unit, and the enum
16445      is a declaration, and the enum is not the signatured type in the
16446      unit, then we do not want to add a symbol for it.  Adding a
16447      symbol would in some cases obscure the true definition of the
16448      enum, giving users an incomplete type when the definition is
16449      actually available.  Note that we do not want to do this for all
16450      enums which are just declarations, because C++0x allows forward
16451      enum declarations.  */
16452   if (cu->per_cu->is_debug_types
16453       && die_is_declaration (die, cu))
16454     {
16455       struct signatured_type *sig_type;
16456
16457       sig_type = (struct signatured_type *) cu->per_cu;
16458       gdb_assert (to_underlying (sig_type->type_offset_in_section) != 0);
16459       if (sig_type->type_offset_in_section != die->sect_off)
16460         return;
16461     }
16462
16463   new_symbol (die, this_type, cu);
16464 }
16465
16466 /* Extract all information from a DW_TAG_array_type DIE and put it in
16467    the DIE's type field.  For now, this only handles one dimensional
16468    arrays.  */
16469
16470 static struct type *
16471 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
16472 {
16473   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16474   struct die_info *child_die;
16475   struct type *type;
16476   struct type *element_type, *range_type, *index_type;
16477   struct attribute *attr;
16478   const char *name;
16479   struct dynamic_prop *byte_stride_prop = NULL;
16480   unsigned int bit_stride = 0;
16481
16482   element_type = die_type (die, cu);
16483
16484   /* The die_type call above may have already set the type for this DIE.  */
16485   type = get_die_type (die, cu);
16486   if (type)
16487     return type;
16488
16489   attr = dwarf2_attr (die, DW_AT_byte_stride, cu);
16490   if (attr != NULL)
16491     {
16492       int stride_ok;
16493
16494       byte_stride_prop
16495         = (struct dynamic_prop *) alloca (sizeof (struct dynamic_prop));
16496       stride_ok = attr_to_dynamic_prop (attr, die, cu, byte_stride_prop);
16497       if (!stride_ok)
16498         {
16499           complaint (_("unable to read array DW_AT_byte_stride "
16500                        " - DIE at %s [in module %s]"),
16501                      sect_offset_str (die->sect_off),
16502                      objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
16503           /* Ignore this attribute.  We will likely not be able to print
16504              arrays of this type correctly, but there is little we can do
16505              to help if we cannot read the attribute's value.  */
16506           byte_stride_prop = NULL;
16507         }
16508     }
16509
16510   attr = dwarf2_attr (die, DW_AT_bit_stride, cu);
16511   if (attr != NULL)
16512     bit_stride = DW_UNSND (attr);
16513
16514   /* Irix 6.2 native cc creates array types without children for
16515      arrays with unspecified length.  */
16516   if (die->child == NULL)
16517     {
16518       index_type = objfile_type (objfile)->builtin_int;
16519       range_type = create_static_range_type (NULL, index_type, 0, -1);
16520       type = create_array_type_with_stride (NULL, element_type, range_type,
16521                                             byte_stride_prop, bit_stride);
16522       return set_die_type (die, type, cu);
16523     }
16524
16525   std::vector<struct type *> range_types;
16526   child_die = die->child;
16527   while (child_die && child_die->tag)
16528     {
16529       if (child_die->tag == DW_TAG_subrange_type)
16530         {
16531           struct type *child_type = read_type_die (child_die, cu);
16532
16533           if (child_type != NULL)
16534             {
16535               /* The range type was succesfully read.  Save it for the
16536                  array type creation.  */
16537               range_types.push_back (child_type);
16538             }
16539         }
16540       child_die = sibling_die (child_die);
16541     }
16542
16543   /* Dwarf2 dimensions are output from left to right, create the
16544      necessary array types in backwards order.  */
16545
16546   type = element_type;
16547
16548   if (read_array_order (die, cu) == DW_ORD_col_major)
16549     {
16550       int i = 0;
16551
16552       while (i < range_types.size ())
16553         type = create_array_type_with_stride (NULL, type, range_types[i++],
16554                                               byte_stride_prop, bit_stride);
16555     }
16556   else
16557     {
16558       size_t ndim = range_types.size ();
16559       while (ndim-- > 0)
16560         type = create_array_type_with_stride (NULL, type, range_types[ndim],
16561                                               byte_stride_prop, bit_stride);
16562     }
16563
16564   /* Understand Dwarf2 support for vector types (like they occur on
16565      the PowerPC w/ AltiVec).  Gcc just adds another attribute to the
16566      array type.  This is not part of the Dwarf2/3 standard yet, but a
16567      custom vendor extension.  The main difference between a regular
16568      array and the vector variant is that vectors are passed by value
16569      to functions.  */
16570   attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
16571   if (attr)
16572     make_vector_type (type);
16573
16574   /* The DIE may have DW_AT_byte_size set.  For example an OpenCL
16575      implementation may choose to implement triple vectors using this
16576      attribute.  */
16577   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16578   if (attr)
16579     {
16580       if (DW_UNSND (attr) >= TYPE_LENGTH (type))
16581         TYPE_LENGTH (type) = DW_UNSND (attr);
16582       else
16583         complaint (_("DW_AT_byte_size for array type smaller "
16584                      "than the total size of elements"));
16585     }
16586
16587   name = dwarf2_name (die, cu);
16588   if (name)
16589     TYPE_NAME (type) = name;
16590
16591   maybe_set_alignment (cu, die, type);
16592
16593   /* Install the type in the die.  */
16594   set_die_type (die, type, cu);
16595
16596   /* set_die_type should be already done.  */
16597   set_descriptive_type (type, die, cu);
16598
16599   return type;
16600 }
16601
16602 static enum dwarf_array_dim_ordering
16603 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
16604 {
16605   struct attribute *attr;
16606
16607   attr = dwarf2_attr (die, DW_AT_ordering, cu);
16608
16609   if (attr)
16610     return (enum dwarf_array_dim_ordering) DW_SND (attr);
16611
16612   /* GNU F77 is a special case, as at 08/2004 array type info is the
16613      opposite order to the dwarf2 specification, but data is still
16614      laid out as per normal fortran.
16615
16616      FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
16617      version checking.  */
16618
16619   if (cu->language == language_fortran
16620       && cu->producer && strstr (cu->producer, "GNU F77"))
16621     {
16622       return DW_ORD_row_major;
16623     }
16624
16625   switch (cu->language_defn->la_array_ordering)
16626     {
16627     case array_column_major:
16628       return DW_ORD_col_major;
16629     case array_row_major:
16630     default:
16631       return DW_ORD_row_major;
16632     };
16633 }
16634
16635 /* Extract all information from a DW_TAG_set_type DIE and put it in
16636    the DIE's type field.  */
16637
16638 static struct type *
16639 read_set_type (struct die_info *die, struct dwarf2_cu *cu)
16640 {
16641   struct type *domain_type, *set_type;
16642   struct attribute *attr;
16643
16644   domain_type = die_type (die, cu);
16645
16646   /* The die_type call above may have already set the type for this DIE.  */
16647   set_type = get_die_type (die, cu);
16648   if (set_type)
16649     return set_type;
16650
16651   set_type = create_set_type (NULL, domain_type);
16652
16653   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
16654   if (attr)
16655     TYPE_LENGTH (set_type) = DW_UNSND (attr);
16656
16657   maybe_set_alignment (cu, die, set_type);
16658
16659   return set_die_type (die, set_type, cu);
16660 }
16661
16662 /* A helper for read_common_block that creates a locexpr baton.
16663    SYM is the symbol which we are marking as computed.
16664    COMMON_DIE is the DIE for the common block.
16665    COMMON_LOC is the location expression attribute for the common
16666    block itself.
16667    MEMBER_LOC is the location expression attribute for the particular
16668    member of the common block that we are processing.
16669    CU is the CU from which the above come.  */
16670
16671 static void
16672 mark_common_block_symbol_computed (struct symbol *sym,
16673                                    struct die_info *common_die,
16674                                    struct attribute *common_loc,
16675                                    struct attribute *member_loc,
16676                                    struct dwarf2_cu *cu)
16677 {
16678   struct dwarf2_per_objfile *dwarf2_per_objfile
16679     = cu->per_cu->dwarf2_per_objfile;
16680   struct objfile *objfile = dwarf2_per_objfile->objfile;
16681   struct dwarf2_locexpr_baton *baton;
16682   gdb_byte *ptr;
16683   unsigned int cu_off;
16684   enum bfd_endian byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
16685   LONGEST offset = 0;
16686
16687   gdb_assert (common_loc && member_loc);
16688   gdb_assert (attr_form_is_block (common_loc));
16689   gdb_assert (attr_form_is_block (member_loc)
16690               || attr_form_is_constant (member_loc));
16691
16692   baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
16693   baton->per_cu = cu->per_cu;
16694   gdb_assert (baton->per_cu);
16695
16696   baton->size = 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
16697
16698   if (attr_form_is_constant (member_loc))
16699     {
16700       offset = dwarf2_get_attr_constant_value (member_loc, 0);
16701       baton->size += 1 /* DW_OP_addr */ + cu->header.addr_size;
16702     }
16703   else
16704     baton->size += DW_BLOCK (member_loc)->size;
16705
16706   ptr = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, baton->size);
16707   baton->data = ptr;
16708
16709   *ptr++ = DW_OP_call4;
16710   cu_off = common_die->sect_off - cu->per_cu->sect_off;
16711   store_unsigned_integer (ptr, 4, byte_order, cu_off);
16712   ptr += 4;
16713
16714   if (attr_form_is_constant (member_loc))
16715     {
16716       *ptr++ = DW_OP_addr;
16717       store_unsigned_integer (ptr, cu->header.addr_size, byte_order, offset);
16718       ptr += cu->header.addr_size;
16719     }
16720   else
16721     {
16722       /* We have to copy the data here, because DW_OP_call4 will only
16723          use a DW_AT_location attribute.  */
16724       memcpy (ptr, DW_BLOCK (member_loc)->data, DW_BLOCK (member_loc)->size);
16725       ptr += DW_BLOCK (member_loc)->size;
16726     }
16727
16728   *ptr++ = DW_OP_plus;
16729   gdb_assert (ptr - baton->data == baton->size);
16730
16731   SYMBOL_LOCATION_BATON (sym) = baton;
16732   SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
16733 }
16734
16735 /* Create appropriate locally-scoped variables for all the
16736    DW_TAG_common_block entries.  Also create a struct common_block
16737    listing all such variables for `info common'.  COMMON_BLOCK_DOMAIN
16738    is used to sepate the common blocks name namespace from regular
16739    variable names.  */
16740
16741 static void
16742 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
16743 {
16744   struct attribute *attr;
16745
16746   attr = dwarf2_attr (die, DW_AT_location, cu);
16747   if (attr)
16748     {
16749       /* Support the .debug_loc offsets.  */
16750       if (attr_form_is_block (attr))
16751         {
16752           /* Ok.  */
16753         }
16754       else if (attr_form_is_section_offset (attr))
16755         {
16756           dwarf2_complex_location_expr_complaint ();
16757           attr = NULL;
16758         }
16759       else
16760         {
16761           dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
16762                                                  "common block member");
16763           attr = NULL;
16764         }
16765     }
16766
16767   if (die->child != NULL)
16768     {
16769       struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16770       struct die_info *child_die;
16771       size_t n_entries = 0, size;
16772       struct common_block *common_block;
16773       struct symbol *sym;
16774
16775       for (child_die = die->child;
16776            child_die && child_die->tag;
16777            child_die = sibling_die (child_die))
16778         ++n_entries;
16779
16780       size = (sizeof (struct common_block)
16781               + (n_entries - 1) * sizeof (struct symbol *));
16782       common_block
16783         = (struct common_block *) obstack_alloc (&objfile->objfile_obstack,
16784                                                  size);
16785       memset (common_block->contents, 0, n_entries * sizeof (struct symbol *));
16786       common_block->n_entries = 0;
16787
16788       for (child_die = die->child;
16789            child_die && child_die->tag;
16790            child_die = sibling_die (child_die))
16791         {
16792           /* Create the symbol in the DW_TAG_common_block block in the current
16793              symbol scope.  */
16794           sym = new_symbol (child_die, NULL, cu);
16795           if (sym != NULL)
16796             {
16797               struct attribute *member_loc;
16798
16799               common_block->contents[common_block->n_entries++] = sym;
16800
16801               member_loc = dwarf2_attr (child_die, DW_AT_data_member_location,
16802                                         cu);
16803               if (member_loc)
16804                 {
16805                   /* GDB has handled this for a long time, but it is
16806                      not specified by DWARF.  It seems to have been
16807                      emitted by gfortran at least as recently as:
16808                      http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057.  */
16809                   complaint (_("Variable in common block has "
16810                                "DW_AT_data_member_location "
16811                                "- DIE at %s [in module %s]"),
16812                                sect_offset_str (child_die->sect_off),
16813                              objfile_name (objfile));
16814
16815                   if (attr_form_is_section_offset (member_loc))
16816                     dwarf2_complex_location_expr_complaint ();
16817                   else if (attr_form_is_constant (member_loc)
16818                            || attr_form_is_block (member_loc))
16819                     {
16820                       if (attr)
16821                         mark_common_block_symbol_computed (sym, die, attr,
16822                                                            member_loc, cu);
16823                     }
16824                   else
16825                     dwarf2_complex_location_expr_complaint ();
16826                 }
16827             }
16828         }
16829
16830       sym = new_symbol (die, objfile_type (objfile)->builtin_void, cu);
16831       SYMBOL_VALUE_COMMON_BLOCK (sym) = common_block;
16832     }
16833 }
16834
16835 /* Create a type for a C++ namespace.  */
16836
16837 static struct type *
16838 read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
16839 {
16840   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16841   const char *previous_prefix, *name;
16842   int is_anonymous;
16843   struct type *type;
16844
16845   /* For extensions, reuse the type of the original namespace.  */
16846   if (dwarf2_attr (die, DW_AT_extension, cu) != NULL)
16847     {
16848       struct die_info *ext_die;
16849       struct dwarf2_cu *ext_cu = cu;
16850
16851       ext_die = dwarf2_extension (die, &ext_cu);
16852       type = read_type_die (ext_die, ext_cu);
16853
16854       /* EXT_CU may not be the same as CU.
16855          Ensure TYPE is recorded with CU in die_type_hash.  */
16856       return set_die_type (die, type, cu);
16857     }
16858
16859   name = namespace_name (die, &is_anonymous, cu);
16860
16861   /* Now build the name of the current namespace.  */
16862
16863   previous_prefix = determine_prefix (die, cu);
16864   if (previous_prefix[0] != '\0')
16865     name = typename_concat (&objfile->objfile_obstack,
16866                             previous_prefix, name, 0, cu);
16867
16868   /* Create the type.  */
16869   type = init_type (objfile, TYPE_CODE_NAMESPACE, 0, name);
16870
16871   return set_die_type (die, type, cu);
16872 }
16873
16874 /* Read a namespace scope.  */
16875
16876 static void
16877 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
16878 {
16879   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16880   int is_anonymous;
16881
16882   /* Add a symbol associated to this if we haven't seen the namespace
16883      before.  Also, add a using directive if it's an anonymous
16884      namespace.  */
16885
16886   if (dwarf2_attr (die, DW_AT_extension, cu) == NULL)
16887     {
16888       struct type *type;
16889
16890       type = read_type_die (die, cu);
16891       new_symbol (die, type, cu);
16892
16893       namespace_name (die, &is_anonymous, cu);
16894       if (is_anonymous)
16895         {
16896           const char *previous_prefix = determine_prefix (die, cu);
16897
16898           std::vector<const char *> excludes;
16899           add_using_directive (using_directives (cu),
16900                                previous_prefix, TYPE_NAME (type), NULL,
16901                                NULL, excludes, 0, &objfile->objfile_obstack);
16902         }
16903     }
16904
16905   if (die->child != NULL)
16906     {
16907       struct die_info *child_die = die->child;
16908
16909       while (child_die && child_die->tag)
16910         {
16911           process_die (child_die, cu);
16912           child_die = sibling_die (child_die);
16913         }
16914     }
16915 }
16916
16917 /* Read a Fortran module as type.  This DIE can be only a declaration used for
16918    imported module.  Still we need that type as local Fortran "use ... only"
16919    declaration imports depend on the created type in determine_prefix.  */
16920
16921 static struct type *
16922 read_module_type (struct die_info *die, struct dwarf2_cu *cu)
16923 {
16924   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
16925   const char *module_name;
16926   struct type *type;
16927
16928   module_name = dwarf2_name (die, cu);
16929   if (!module_name)
16930     complaint (_("DW_TAG_module has no name, offset %s"),
16931                sect_offset_str (die->sect_off));
16932   type = init_type (objfile, TYPE_CODE_MODULE, 0, module_name);
16933
16934   return set_die_type (die, type, cu);
16935 }
16936
16937 /* Read a Fortran module.  */
16938
16939 static void
16940 read_module (struct die_info *die, struct dwarf2_cu *cu)
16941 {
16942   struct die_info *child_die = die->child;
16943   struct type *type;
16944
16945   type = read_type_die (die, cu);
16946   new_symbol (die, type, cu);
16947
16948   while (child_die && child_die->tag)
16949     {
16950       process_die (child_die, cu);
16951       child_die = sibling_die (child_die);
16952     }
16953 }
16954
16955 /* Return the name of the namespace represented by DIE.  Set
16956    *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
16957    namespace.  */
16958
16959 static const char *
16960 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
16961 {
16962   struct die_info *current_die;
16963   const char *name = NULL;
16964
16965   /* Loop through the extensions until we find a name.  */
16966
16967   for (current_die = die;
16968        current_die != NULL;
16969        current_die = dwarf2_extension (die, &cu))
16970     {
16971       /* We don't use dwarf2_name here so that we can detect the absence
16972          of a name -> anonymous namespace.  */
16973       name = dwarf2_string_attr (die, DW_AT_name, cu);
16974
16975       if (name != NULL)
16976         break;
16977     }
16978
16979   /* Is it an anonymous namespace?  */
16980
16981   *is_anonymous = (name == NULL);
16982   if (*is_anonymous)
16983     name = CP_ANONYMOUS_NAMESPACE_STR;
16984
16985   return name;
16986 }
16987
16988 /* Extract all information from a DW_TAG_pointer_type DIE and add to
16989    the user defined type vector.  */
16990
16991 static struct type *
16992 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
16993 {
16994   struct gdbarch *gdbarch
16995     = get_objfile_arch (cu->per_cu->dwarf2_per_objfile->objfile);
16996   struct comp_unit_head *cu_header = &cu->header;
16997   struct type *type;
16998   struct attribute *attr_byte_size;
16999   struct attribute *attr_address_class;
17000   int byte_size, addr_class;
17001   struct type *target_type;
17002
17003   target_type = die_type (die, cu);
17004
17005   /* The die_type call above may have already set the type for this DIE.  */
17006   type = get_die_type (die, cu);
17007   if (type)
17008     return type;
17009
17010   type = lookup_pointer_type (target_type);
17011
17012   attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
17013   if (attr_byte_size)
17014     byte_size = DW_UNSND (attr_byte_size);
17015   else
17016     byte_size = cu_header->addr_size;
17017
17018   attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
17019   if (attr_address_class)
17020     addr_class = DW_UNSND (attr_address_class);
17021   else
17022     addr_class = DW_ADDR_none;
17023
17024   ULONGEST alignment = get_alignment (cu, die);
17025
17026   /* If the pointer size, alignment, or address class is different
17027      than the default, create a type variant marked as such and set
17028      the length accordingly.  */
17029   if (TYPE_LENGTH (type) != byte_size
17030       || (alignment != 0 && TYPE_RAW_ALIGN (type) != 0
17031           && alignment != TYPE_RAW_ALIGN (type))
17032       || addr_class != DW_ADDR_none)
17033     {
17034       if (gdbarch_address_class_type_flags_p (gdbarch))
17035         {
17036           int type_flags;
17037
17038           type_flags = gdbarch_address_class_type_flags
17039                          (gdbarch, byte_size, addr_class);
17040           gdb_assert ((type_flags & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
17041                       == 0);
17042           type = make_type_with_address_space (type, type_flags);
17043         }
17044       else if (TYPE_LENGTH (type) != byte_size)
17045         {
17046           complaint (_("invalid pointer size %d"), byte_size);
17047         }
17048       else if (TYPE_RAW_ALIGN (type) != alignment)
17049         {
17050           complaint (_("Invalid DW_AT_alignment"
17051                        " - DIE at %s [in module %s]"),
17052                      sect_offset_str (die->sect_off),
17053                      objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17054         }
17055       else
17056         {
17057           /* Should we also complain about unhandled address classes?  */
17058         }
17059     }
17060
17061   TYPE_LENGTH (type) = byte_size;
17062   set_type_align (type, alignment);
17063   return set_die_type (die, type, cu);
17064 }
17065
17066 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
17067    the user defined type vector.  */
17068
17069 static struct type *
17070 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
17071 {
17072   struct type *type;
17073   struct type *to_type;
17074   struct type *domain;
17075
17076   to_type = die_type (die, cu);
17077   domain = die_containing_type (die, cu);
17078
17079   /* The calls above may have already set the type for this DIE.  */
17080   type = get_die_type (die, cu);
17081   if (type)
17082     return type;
17083
17084   if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_METHOD)
17085     type = lookup_methodptr_type (to_type);
17086   else if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_FUNC)
17087     {
17088       struct type *new_type
17089         = alloc_type (cu->per_cu->dwarf2_per_objfile->objfile);
17090
17091       smash_to_method_type (new_type, domain, TYPE_TARGET_TYPE (to_type),
17092                             TYPE_FIELDS (to_type), TYPE_NFIELDS (to_type),
17093                             TYPE_VARARGS (to_type));
17094       type = lookup_methodptr_type (new_type);
17095     }
17096   else
17097     type = lookup_memberptr_type (to_type, domain);
17098
17099   return set_die_type (die, type, cu);
17100 }
17101
17102 /* Extract all information from a DW_TAG_{rvalue_,}reference_type DIE and add to
17103    the user defined type vector.  */
17104
17105 static struct type *
17106 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu,
17107                           enum type_code refcode)
17108 {
17109   struct comp_unit_head *cu_header = &cu->header;
17110   struct type *type, *target_type;
17111   struct attribute *attr;
17112
17113   gdb_assert (refcode == TYPE_CODE_REF || refcode == TYPE_CODE_RVALUE_REF);
17114
17115   target_type = die_type (die, cu);
17116
17117   /* The die_type call above may have already set the type for this DIE.  */
17118   type = get_die_type (die, cu);
17119   if (type)
17120     return type;
17121
17122   type = lookup_reference_type (target_type, refcode);
17123   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17124   if (attr)
17125     {
17126       TYPE_LENGTH (type) = DW_UNSND (attr);
17127     }
17128   else
17129     {
17130       TYPE_LENGTH (type) = cu_header->addr_size;
17131     }
17132   maybe_set_alignment (cu, die, type);
17133   return set_die_type (die, type, cu);
17134 }
17135
17136 /* Add the given cv-qualifiers to the element type of the array.  GCC
17137    outputs DWARF type qualifiers that apply to an array, not the
17138    element type.  But GDB relies on the array element type to carry
17139    the cv-qualifiers.  This mimics section 6.7.3 of the C99
17140    specification.  */
17141
17142 static struct type *
17143 add_array_cv_type (struct die_info *die, struct dwarf2_cu *cu,
17144                    struct type *base_type, int cnst, int voltl)
17145 {
17146   struct type *el_type, *inner_array;
17147
17148   base_type = copy_type (base_type);
17149   inner_array = base_type;
17150
17151   while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
17152     {
17153       TYPE_TARGET_TYPE (inner_array) =
17154         copy_type (TYPE_TARGET_TYPE (inner_array));
17155       inner_array = TYPE_TARGET_TYPE (inner_array);
17156     }
17157
17158   el_type = TYPE_TARGET_TYPE (inner_array);
17159   cnst |= TYPE_CONST (el_type);
17160   voltl |= TYPE_VOLATILE (el_type);
17161   TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, NULL);
17162
17163   return set_die_type (die, base_type, cu);
17164 }
17165
17166 static struct type *
17167 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
17168 {
17169   struct type *base_type, *cv_type;
17170
17171   base_type = die_type (die, cu);
17172
17173   /* The die_type call above may have already set the type for this DIE.  */
17174   cv_type = get_die_type (die, cu);
17175   if (cv_type)
17176     return cv_type;
17177
17178   /* In case the const qualifier is applied to an array type, the element type
17179      is so qualified, not the array type (section 6.7.3 of C99).  */
17180   if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
17181     return add_array_cv_type (die, cu, base_type, 1, 0);
17182
17183   cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
17184   return set_die_type (die, cv_type, cu);
17185 }
17186
17187 static struct type *
17188 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
17189 {
17190   struct type *base_type, *cv_type;
17191
17192   base_type = die_type (die, cu);
17193
17194   /* The die_type call above may have already set the type for this DIE.  */
17195   cv_type = get_die_type (die, cu);
17196   if (cv_type)
17197     return cv_type;
17198
17199   /* In case the volatile qualifier is applied to an array type, the
17200      element type is so qualified, not the array type (section 6.7.3
17201      of C99).  */
17202   if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
17203     return add_array_cv_type (die, cu, base_type, 0, 1);
17204
17205   cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
17206   return set_die_type (die, cv_type, cu);
17207 }
17208
17209 /* Handle DW_TAG_restrict_type.  */
17210
17211 static struct type *
17212 read_tag_restrict_type (struct die_info *die, struct dwarf2_cu *cu)
17213 {
17214   struct type *base_type, *cv_type;
17215
17216   base_type = die_type (die, cu);
17217
17218   /* The die_type call above may have already set the type for this DIE.  */
17219   cv_type = get_die_type (die, cu);
17220   if (cv_type)
17221     return cv_type;
17222
17223   cv_type = make_restrict_type (base_type);
17224   return set_die_type (die, cv_type, cu);
17225 }
17226
17227 /* Handle DW_TAG_atomic_type.  */
17228
17229 static struct type *
17230 read_tag_atomic_type (struct die_info *die, struct dwarf2_cu *cu)
17231 {
17232   struct type *base_type, *cv_type;
17233
17234   base_type = die_type (die, cu);
17235
17236   /* The die_type call above may have already set the type for this DIE.  */
17237   cv_type = get_die_type (die, cu);
17238   if (cv_type)
17239     return cv_type;
17240
17241   cv_type = make_atomic_type (base_type);
17242   return set_die_type (die, cv_type, cu);
17243 }
17244
17245 /* Extract all information from a DW_TAG_string_type DIE and add to
17246    the user defined type vector.  It isn't really a user defined type,
17247    but it behaves like one, with other DIE's using an AT_user_def_type
17248    attribute to reference it.  */
17249
17250 static struct type *
17251 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
17252 {
17253   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17254   struct gdbarch *gdbarch = get_objfile_arch (objfile);
17255   struct type *type, *range_type, *index_type, *char_type;
17256   struct attribute *attr;
17257   unsigned int length;
17258
17259   attr = dwarf2_attr (die, DW_AT_string_length, cu);
17260   if (attr)
17261     {
17262       length = DW_UNSND (attr);
17263     }
17264   else
17265     {
17266       /* Check for the DW_AT_byte_size attribute.  */
17267       attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17268       if (attr)
17269         {
17270           length = DW_UNSND (attr);
17271         }
17272       else
17273         {
17274           length = 1;
17275         }
17276     }
17277
17278   index_type = objfile_type (objfile)->builtin_int;
17279   range_type = create_static_range_type (NULL, index_type, 1, length);
17280   char_type = language_string_char_type (cu->language_defn, gdbarch);
17281   type = create_string_type (NULL, char_type, range_type);
17282
17283   return set_die_type (die, type, cu);
17284 }
17285
17286 /* Assuming that DIE corresponds to a function, returns nonzero
17287    if the function is prototyped.  */
17288
17289 static int
17290 prototyped_function_p (struct die_info *die, struct dwarf2_cu *cu)
17291 {
17292   struct attribute *attr;
17293
17294   attr = dwarf2_attr (die, DW_AT_prototyped, cu);
17295   if (attr && (DW_UNSND (attr) != 0))
17296     return 1;
17297
17298   /* The DWARF standard implies that the DW_AT_prototyped attribute
17299      is only meaninful for C, but the concept also extends to other
17300      languages that allow unprototyped functions (Eg: Objective C).
17301      For all other languages, assume that functions are always
17302      prototyped.  */
17303   if (cu->language != language_c
17304       && cu->language != language_objc
17305       && cu->language != language_opencl)
17306     return 1;
17307
17308   /* RealView does not emit DW_AT_prototyped.  We can not distinguish
17309      prototyped and unprototyped functions; default to prototyped,
17310      since that is more common in modern code (and RealView warns
17311      about unprototyped functions).  */
17312   if (producer_is_realview (cu->producer))
17313     return 1;
17314
17315   return 0;
17316 }
17317
17318 /* Handle DIES due to C code like:
17319
17320    struct foo
17321    {
17322    int (*funcp)(int a, long l);
17323    int b;
17324    };
17325
17326    ('funcp' generates a DW_TAG_subroutine_type DIE).  */
17327
17328 static struct type *
17329 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
17330 {
17331   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17332   struct type *type;            /* Type that this function returns.  */
17333   struct type *ftype;           /* Function that returns above type.  */
17334   struct attribute *attr;
17335
17336   type = die_type (die, cu);
17337
17338   /* The die_type call above may have already set the type for this DIE.  */
17339   ftype = get_die_type (die, cu);
17340   if (ftype)
17341     return ftype;
17342
17343   ftype = lookup_function_type (type);
17344
17345   if (prototyped_function_p (die, cu))
17346     TYPE_PROTOTYPED (ftype) = 1;
17347
17348   /* Store the calling convention in the type if it's available in
17349      the subroutine die.  Otherwise set the calling convention to
17350      the default value DW_CC_normal.  */
17351   attr = dwarf2_attr (die, DW_AT_calling_convention, cu);
17352   if (attr)
17353     TYPE_CALLING_CONVENTION (ftype) = DW_UNSND (attr);
17354   else if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL"))
17355     TYPE_CALLING_CONVENTION (ftype) = DW_CC_GDB_IBM_OpenCL;
17356   else
17357     TYPE_CALLING_CONVENTION (ftype) = DW_CC_normal;
17358
17359   /* Record whether the function returns normally to its caller or not
17360      if the DWARF producer set that information.  */
17361   attr = dwarf2_attr (die, DW_AT_noreturn, cu);
17362   if (attr && (DW_UNSND (attr) != 0))
17363     TYPE_NO_RETURN (ftype) = 1;
17364
17365   /* We need to add the subroutine type to the die immediately so
17366      we don't infinitely recurse when dealing with parameters
17367      declared as the same subroutine type.  */
17368   set_die_type (die, ftype, cu);
17369
17370   if (die->child != NULL)
17371     {
17372       struct type *void_type = objfile_type (objfile)->builtin_void;
17373       struct die_info *child_die;
17374       int nparams, iparams;
17375
17376       /* Count the number of parameters.
17377          FIXME: GDB currently ignores vararg functions, but knows about
17378          vararg member functions.  */
17379       nparams = 0;
17380       child_die = die->child;
17381       while (child_die && child_die->tag)
17382         {
17383           if (child_die->tag == DW_TAG_formal_parameter)
17384             nparams++;
17385           else if (child_die->tag == DW_TAG_unspecified_parameters)
17386             TYPE_VARARGS (ftype) = 1;
17387           child_die = sibling_die (child_die);
17388         }
17389
17390       /* Allocate storage for parameters and fill them in.  */
17391       TYPE_NFIELDS (ftype) = nparams;
17392       TYPE_FIELDS (ftype) = (struct field *)
17393         TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
17394
17395       /* TYPE_FIELD_TYPE must never be NULL.  Pre-fill the array to ensure it
17396          even if we error out during the parameters reading below.  */
17397       for (iparams = 0; iparams < nparams; iparams++)
17398         TYPE_FIELD_TYPE (ftype, iparams) = void_type;
17399
17400       iparams = 0;
17401       child_die = die->child;
17402       while (child_die && child_die->tag)
17403         {
17404           if (child_die->tag == DW_TAG_formal_parameter)
17405             {
17406               struct type *arg_type;
17407
17408               /* DWARF version 2 has no clean way to discern C++
17409                  static and non-static member functions.  G++ helps
17410                  GDB by marking the first parameter for non-static
17411                  member functions (which is the this pointer) as
17412                  artificial.  We pass this information to
17413                  dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
17414
17415                  DWARF version 3 added DW_AT_object_pointer, which GCC
17416                  4.5 does not yet generate.  */
17417               attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
17418               if (attr)
17419                 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
17420               else
17421                 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
17422               arg_type = die_type (child_die, cu);
17423
17424               /* RealView does not mark THIS as const, which the testsuite
17425                  expects.  GCC marks THIS as const in method definitions,
17426                  but not in the class specifications (GCC PR 43053).  */
17427               if (cu->language == language_cplus && !TYPE_CONST (arg_type)
17428                   && TYPE_FIELD_ARTIFICIAL (ftype, iparams))
17429                 {
17430                   int is_this = 0;
17431                   struct dwarf2_cu *arg_cu = cu;
17432                   const char *name = dwarf2_name (child_die, cu);
17433
17434                   attr = dwarf2_attr (die, DW_AT_object_pointer, cu);
17435                   if (attr)
17436                     {
17437                       /* If the compiler emits this, use it.  */
17438                       if (follow_die_ref (die, attr, &arg_cu) == child_die)
17439                         is_this = 1;
17440                     }
17441                   else if (name && strcmp (name, "this") == 0)
17442                     /* Function definitions will have the argument names.  */
17443                     is_this = 1;
17444                   else if (name == NULL && iparams == 0)
17445                     /* Declarations may not have the names, so like
17446                        elsewhere in GDB, assume an artificial first
17447                        argument is "this".  */
17448                     is_this = 1;
17449
17450                   if (is_this)
17451                     arg_type = make_cv_type (1, TYPE_VOLATILE (arg_type),
17452                                              arg_type, 0);
17453                 }
17454
17455               TYPE_FIELD_TYPE (ftype, iparams) = arg_type;
17456               iparams++;
17457             }
17458           child_die = sibling_die (child_die);
17459         }
17460     }
17461
17462   return ftype;
17463 }
17464
17465 static struct type *
17466 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
17467 {
17468   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17469   const char *name = NULL;
17470   struct type *this_type, *target_type;
17471
17472   name = dwarf2_full_name (NULL, die, cu);
17473   this_type = init_type (objfile, TYPE_CODE_TYPEDEF, 0, name);
17474   TYPE_TARGET_STUB (this_type) = 1;
17475   set_die_type (die, this_type, cu);
17476   target_type = die_type (die, cu);
17477   if (target_type != this_type)
17478     TYPE_TARGET_TYPE (this_type) = target_type;
17479   else
17480     {
17481       /* Self-referential typedefs are, it seems, not allowed by the DWARF
17482          spec and cause infinite loops in GDB.  */
17483       complaint (_("Self-referential DW_TAG_typedef "
17484                    "- DIE at %s [in module %s]"),
17485                  sect_offset_str (die->sect_off), objfile_name (objfile));
17486       TYPE_TARGET_TYPE (this_type) = NULL;
17487     }
17488   return this_type;
17489 }
17490
17491 /* Allocate a floating-point type of size BITS and name NAME.  Pass NAME_HINT
17492    (which may be different from NAME) to the architecture back-end to allow
17493    it to guess the correct format if necessary.  */
17494
17495 static struct type *
17496 dwarf2_init_float_type (struct objfile *objfile, int bits, const char *name,
17497                         const char *name_hint)
17498 {
17499   struct gdbarch *gdbarch = get_objfile_arch (objfile);
17500   const struct floatformat **format;
17501   struct type *type;
17502
17503   format = gdbarch_floatformat_for_type (gdbarch, name_hint, bits);
17504   if (format)
17505     type = init_float_type (objfile, bits, name, format);
17506   else
17507     type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
17508
17509   return type;
17510 }
17511
17512 /* Allocate an integer type of size BITS and name NAME.  */
17513
17514 static struct type *
17515 dwarf2_init_integer_type (struct dwarf2_cu *cu, struct objfile *objfile,
17516                           int bits, int unsigned_p, const char *name)
17517 {
17518   struct type *type;
17519
17520   /* Versions of Intel's C Compiler generate an integer type called "void"
17521      instead of using DW_TAG_unspecified_type.  This has been seen on
17522      at least versions 14, 17, and 18.  */
17523   if (bits == 0 && producer_is_icc (cu) && name != nullptr
17524       && strcmp (name, "void") == 0)
17525     type = objfile_type (objfile)->builtin_void;
17526   else
17527     type = init_integer_type (objfile, bits, unsigned_p, name);
17528
17529   return type;
17530 }
17531
17532 /* Initialise and return a floating point type of size BITS suitable for
17533    use as a component of a complex number.  The NAME_HINT is passed through
17534    when initialising the floating point type and is the name of the complex
17535    type.
17536
17537    As DWARF doesn't currently provide an explicit name for the components
17538    of a complex number, but it can be helpful to have these components
17539    named, we try to select a suitable name based on the size of the
17540    component.  */
17541 static struct type *
17542 dwarf2_init_complex_target_type (struct dwarf2_cu *cu,
17543                                  struct objfile *objfile,
17544                                  int bits, const char *name_hint)
17545 {
17546   gdbarch *gdbarch = get_objfile_arch (objfile);
17547   struct type *tt = nullptr;
17548
17549   switch (bits)
17550     {
17551     case 32:
17552       tt = builtin_type (gdbarch)->builtin_float;
17553       break;
17554     case 64:
17555       tt = builtin_type (gdbarch)->builtin_double;
17556       break;
17557     case 128:
17558       tt = builtin_type (gdbarch)->builtin_long_double;
17559       break;
17560     }
17561
17562   const char *name = (tt == nullptr) ? nullptr : TYPE_NAME (tt);
17563   return dwarf2_init_float_type (objfile, bits, name, name_hint);
17564 }
17565
17566 /* Find a representation of a given base type and install
17567    it in the TYPE field of the die.  */
17568
17569 static struct type *
17570 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
17571 {
17572   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17573   struct type *type;
17574   struct attribute *attr;
17575   int encoding = 0, bits = 0;
17576   const char *name;
17577
17578   attr = dwarf2_attr (die, DW_AT_encoding, cu);
17579   if (attr)
17580     {
17581       encoding = DW_UNSND (attr);
17582     }
17583   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17584   if (attr)
17585     {
17586       bits = DW_UNSND (attr) * TARGET_CHAR_BIT;
17587     }
17588   name = dwarf2_name (die, cu);
17589   if (!name)
17590     {
17591       complaint (_("DW_AT_name missing from DW_TAG_base_type"));
17592     }
17593
17594   switch (encoding)
17595     {
17596       case DW_ATE_address:
17597         /* Turn DW_ATE_address into a void * pointer.  */
17598         type = init_type (objfile, TYPE_CODE_VOID, TARGET_CHAR_BIT, NULL);
17599         type = init_pointer_type (objfile, bits, name, type);
17600         break;
17601       case DW_ATE_boolean:
17602         type = init_boolean_type (objfile, bits, 1, name);
17603         break;
17604       case DW_ATE_complex_float:
17605         type = dwarf2_init_complex_target_type (cu, objfile, bits / 2, name);
17606         type = init_complex_type (objfile, name, type);
17607         break;
17608       case DW_ATE_decimal_float:
17609         type = init_decfloat_type (objfile, bits, name);
17610         break;
17611       case DW_ATE_float:
17612         type = dwarf2_init_float_type (objfile, bits, name, name);
17613         break;
17614       case DW_ATE_signed:
17615         type = dwarf2_init_integer_type (cu, objfile, bits, 0, name);
17616         break;
17617       case DW_ATE_unsigned:
17618         if (cu->language == language_fortran
17619             && name
17620             && startswith (name, "character("))
17621           type = init_character_type (objfile, bits, 1, name);
17622         else
17623           type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17624         break;
17625       case DW_ATE_signed_char:
17626         if (cu->language == language_ada || cu->language == language_m2
17627             || cu->language == language_pascal
17628             || cu->language == language_fortran)
17629           type = init_character_type (objfile, bits, 0, name);
17630         else
17631           type = dwarf2_init_integer_type (cu, objfile, bits, 0, name);
17632         break;
17633       case DW_ATE_unsigned_char:
17634         if (cu->language == language_ada || cu->language == language_m2
17635             || cu->language == language_pascal
17636             || cu->language == language_fortran
17637             || cu->language == language_rust)
17638           type = init_character_type (objfile, bits, 1, name);
17639         else
17640           type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17641         break;
17642       case DW_ATE_UTF:
17643         {
17644           gdbarch *arch = get_objfile_arch (objfile);
17645
17646           if (bits == 16)
17647             type = builtin_type (arch)->builtin_char16;
17648           else if (bits == 32)
17649             type = builtin_type (arch)->builtin_char32;
17650           else
17651             {
17652               complaint (_("unsupported DW_ATE_UTF bit size: '%d'"),
17653                          bits);
17654               type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
17655             }
17656           return set_die_type (die, type, cu);
17657         }
17658         break;
17659
17660       default:
17661         complaint (_("unsupported DW_AT_encoding: '%s'"),
17662                    dwarf_type_encoding_name (encoding));
17663         type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
17664         break;
17665     }
17666
17667   if (name && strcmp (name, "char") == 0)
17668     TYPE_NOSIGN (type) = 1;
17669
17670   maybe_set_alignment (cu, die, type);
17671
17672   return set_die_type (die, type, cu);
17673 }
17674
17675 /* Parse dwarf attribute if it's a block, reference or constant and put the
17676    resulting value of the attribute into struct bound_prop.
17677    Returns 1 if ATTR could be resolved into PROP, 0 otherwise.  */
17678
17679 static int
17680 attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die,
17681                       struct dwarf2_cu *cu, struct dynamic_prop *prop)
17682 {
17683   struct dwarf2_property_baton *baton;
17684   struct obstack *obstack
17685     = &cu->per_cu->dwarf2_per_objfile->objfile->objfile_obstack;
17686
17687   if (attr == NULL || prop == NULL)
17688     return 0;
17689
17690   if (attr_form_is_block (attr))
17691     {
17692       baton = XOBNEW (obstack, struct dwarf2_property_baton);
17693       baton->referenced_type = NULL;
17694       baton->locexpr.per_cu = cu->per_cu;
17695       baton->locexpr.size = DW_BLOCK (attr)->size;
17696       baton->locexpr.data = DW_BLOCK (attr)->data;
17697       prop->data.baton = baton;
17698       prop->kind = PROP_LOCEXPR;
17699       gdb_assert (prop->data.baton != NULL);
17700     }
17701   else if (attr_form_is_ref (attr))
17702     {
17703       struct dwarf2_cu *target_cu = cu;
17704       struct die_info *target_die;
17705       struct attribute *target_attr;
17706
17707       target_die = follow_die_ref (die, attr, &target_cu);
17708       target_attr = dwarf2_attr (target_die, DW_AT_location, target_cu);
17709       if (target_attr == NULL)
17710         target_attr = dwarf2_attr (target_die, DW_AT_data_member_location,
17711                                    target_cu);
17712       if (target_attr == NULL)
17713         return 0;
17714
17715       switch (target_attr->name)
17716         {
17717           case DW_AT_location:
17718             if (attr_form_is_section_offset (target_attr))
17719               {
17720                 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17721                 baton->referenced_type = die_type (target_die, target_cu);
17722                 fill_in_loclist_baton (cu, &baton->loclist, target_attr);
17723                 prop->data.baton = baton;
17724                 prop->kind = PROP_LOCLIST;
17725                 gdb_assert (prop->data.baton != NULL);
17726               }
17727             else if (attr_form_is_block (target_attr))
17728               {
17729                 baton = XOBNEW (obstack, struct dwarf2_property_baton);
17730                 baton->referenced_type = die_type (target_die, target_cu);
17731                 baton->locexpr.per_cu = cu->per_cu;
17732                 baton->locexpr.size = DW_BLOCK (target_attr)->size;
17733                 baton->locexpr.data = DW_BLOCK (target_attr)->data;
17734                 prop->data.baton = baton;
17735                 prop->kind = PROP_LOCEXPR;
17736                 gdb_assert (prop->data.baton != NULL);
17737               }
17738             else
17739               {
17740                 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
17741                                                        "dynamic property");
17742                 return 0;
17743               }
17744             break;
17745           case DW_AT_data_member_location:
17746             {
17747               LONGEST offset;
17748
17749               if (!handle_data_member_location (target_die, target_cu,
17750                                                 &offset))
17751                 return 0;
17752
17753               baton = XOBNEW (obstack, struct dwarf2_property_baton);
17754               baton->referenced_type = read_type_die (target_die->parent,
17755                                                       target_cu);
17756               baton->offset_info.offset = offset;
17757               baton->offset_info.type = die_type (target_die, target_cu);
17758               prop->data.baton = baton;
17759               prop->kind = PROP_ADDR_OFFSET;
17760               break;
17761             }
17762         }
17763     }
17764   else if (attr_form_is_constant (attr))
17765     {
17766       prop->data.const_val = dwarf2_get_attr_constant_value (attr, 0);
17767       prop->kind = PROP_CONST;
17768     }
17769   else
17770     {
17771       dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr->form),
17772                                              dwarf2_name (die, cu));
17773       return 0;
17774     }
17775
17776   return 1;
17777 }
17778
17779 /* Read the given DW_AT_subrange DIE.  */
17780
17781 static struct type *
17782 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
17783 {
17784   struct type *base_type, *orig_base_type;
17785   struct type *range_type;
17786   struct attribute *attr;
17787   struct dynamic_prop low, high;
17788   int low_default_is_valid;
17789   int high_bound_is_count = 0;
17790   const char *name;
17791   ULONGEST negative_mask;
17792
17793   orig_base_type = die_type (die, cu);
17794   /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
17795      whereas the real type might be.  So, we use ORIG_BASE_TYPE when
17796      creating the range type, but we use the result of check_typedef
17797      when examining properties of the type.  */
17798   base_type = check_typedef (orig_base_type);
17799
17800   /* The die_type call above may have already set the type for this DIE.  */
17801   range_type = get_die_type (die, cu);
17802   if (range_type)
17803     return range_type;
17804
17805   low.kind = PROP_CONST;
17806   high.kind = PROP_CONST;
17807   high.data.const_val = 0;
17808
17809   /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
17810      omitting DW_AT_lower_bound.  */
17811   switch (cu->language)
17812     {
17813     case language_c:
17814     case language_cplus:
17815       low.data.const_val = 0;
17816       low_default_is_valid = 1;
17817       break;
17818     case language_fortran:
17819       low.data.const_val = 1;
17820       low_default_is_valid = 1;
17821       break;
17822     case language_d:
17823     case language_objc:
17824     case language_rust:
17825       low.data.const_val = 0;
17826       low_default_is_valid = (cu->header.version >= 4);
17827       break;
17828     case language_ada:
17829     case language_m2:
17830     case language_pascal:
17831       low.data.const_val = 1;
17832       low_default_is_valid = (cu->header.version >= 4);
17833       break;
17834     default:
17835       low.data.const_val = 0;
17836       low_default_is_valid = 0;
17837       break;
17838     }
17839
17840   attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
17841   if (attr)
17842     attr_to_dynamic_prop (attr, die, cu, &low);
17843   else if (!low_default_is_valid)
17844     complaint (_("Missing DW_AT_lower_bound "
17845                                       "- DIE at %s [in module %s]"),
17846                sect_offset_str (die->sect_off),
17847                objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17848
17849   struct attribute *attr_ub, *attr_count;
17850   attr = attr_ub = dwarf2_attr (die, DW_AT_upper_bound, cu);
17851   if (!attr_to_dynamic_prop (attr, die, cu, &high))
17852     {
17853       attr = attr_count = dwarf2_attr (die, DW_AT_count, cu);
17854       if (attr_to_dynamic_prop (attr, die, cu, &high))
17855         {
17856           /* If bounds are constant do the final calculation here.  */
17857           if (low.kind == PROP_CONST && high.kind == PROP_CONST)
17858             high.data.const_val = low.data.const_val + high.data.const_val - 1;
17859           else
17860             high_bound_is_count = 1;
17861         }
17862       else
17863         {
17864           if (attr_ub != NULL)
17865             complaint (_("Unresolved DW_AT_upper_bound "
17866                          "- DIE at %s [in module %s]"),
17867                        sect_offset_str (die->sect_off),
17868                        objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17869           if (attr_count != NULL)
17870             complaint (_("Unresolved DW_AT_count "
17871                          "- DIE at %s [in module %s]"),
17872                        sect_offset_str (die->sect_off),
17873                        objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
17874         }
17875         
17876     }
17877
17878   /* Dwarf-2 specifications explicitly allows to create subrange types
17879      without specifying a base type.
17880      In that case, the base type must be set to the type of
17881      the lower bound, upper bound or count, in that order, if any of these
17882      three attributes references an object that has a type.
17883      If no base type is found, the Dwarf-2 specifications say that
17884      a signed integer type of size equal to the size of an address should
17885      be used.
17886      For the following C code: `extern char gdb_int [];'
17887      GCC produces an empty range DIE.
17888      FIXME: muller/2010-05-28: Possible references to object for low bound,
17889      high bound or count are not yet handled by this code.  */
17890   if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
17891     {
17892       struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
17893       struct gdbarch *gdbarch = get_objfile_arch (objfile);
17894       int addr_size = gdbarch_addr_bit (gdbarch) /8;
17895       struct type *int_type = objfile_type (objfile)->builtin_int;
17896
17897       /* Test "int", "long int", and "long long int" objfile types,
17898          and select the first one having a size above or equal to the
17899          architecture address size.  */
17900       if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17901         base_type = int_type;
17902       else
17903         {
17904           int_type = objfile_type (objfile)->builtin_long;
17905           if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17906             base_type = int_type;
17907           else
17908             {
17909               int_type = objfile_type (objfile)->builtin_long_long;
17910               if (int_type && TYPE_LENGTH (int_type) >= addr_size)
17911                 base_type = int_type;
17912             }
17913         }
17914     }
17915
17916   /* Normally, the DWARF producers are expected to use a signed
17917      constant form (Eg. DW_FORM_sdata) to express negative bounds.
17918      But this is unfortunately not always the case, as witnessed
17919      with GCC, for instance, where the ambiguous DW_FORM_dataN form
17920      is used instead.  To work around that ambiguity, we treat
17921      the bounds as signed, and thus sign-extend their values, when
17922      the base type is signed.  */
17923   negative_mask =
17924     -((ULONGEST) 1 << (TYPE_LENGTH (base_type) * TARGET_CHAR_BIT - 1));
17925   if (low.kind == PROP_CONST
17926       && !TYPE_UNSIGNED (base_type) && (low.data.const_val & negative_mask))
17927     low.data.const_val |= negative_mask;
17928   if (high.kind == PROP_CONST
17929       && !TYPE_UNSIGNED (base_type) && (high.data.const_val & negative_mask))
17930     high.data.const_val |= negative_mask;
17931
17932   range_type = create_range_type (NULL, orig_base_type, &low, &high);
17933
17934   if (high_bound_is_count)
17935     TYPE_RANGE_DATA (range_type)->flag_upper_bound_is_count = 1;
17936
17937   /* Ada expects an empty array on no boundary attributes.  */
17938   if (attr == NULL && cu->language != language_ada)
17939     TYPE_HIGH_BOUND_KIND (range_type) = PROP_UNDEFINED;
17940
17941   name = dwarf2_name (die, cu);
17942   if (name)
17943     TYPE_NAME (range_type) = name;
17944
17945   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
17946   if (attr)
17947     TYPE_LENGTH (range_type) = DW_UNSND (attr);
17948
17949   maybe_set_alignment (cu, die, range_type);
17950
17951   set_die_type (die, range_type, cu);
17952
17953   /* set_die_type should be already done.  */
17954   set_descriptive_type (range_type, die, cu);
17955
17956   return range_type;
17957 }
17958
17959 static struct type *
17960 read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
17961 {
17962   struct type *type;
17963
17964   type = init_type (cu->per_cu->dwarf2_per_objfile->objfile, TYPE_CODE_VOID,0,
17965                     NULL);
17966   TYPE_NAME (type) = dwarf2_name (die, cu);
17967
17968   /* In Ada, an unspecified type is typically used when the description
17969      of the type is defered to a different unit.  When encountering
17970      such a type, we treat it as a stub, and try to resolve it later on,
17971      when needed.  */
17972   if (cu->language == language_ada)
17973     TYPE_STUB (type) = 1;
17974
17975   return set_die_type (die, type, cu);
17976 }
17977
17978 /* Read a single die and all its descendents.  Set the die's sibling
17979    field to NULL; set other fields in the die correctly, and set all
17980    of the descendents' fields correctly.  Set *NEW_INFO_PTR to the
17981    location of the info_ptr after reading all of those dies.  PARENT
17982    is the parent of the die in question.  */
17983
17984 static struct die_info *
17985 read_die_and_children (const struct die_reader_specs *reader,
17986                        const gdb_byte *info_ptr,
17987                        const gdb_byte **new_info_ptr,
17988                        struct die_info *parent)
17989 {
17990   struct die_info *die;
17991   const gdb_byte *cur_ptr;
17992   int has_children;
17993
17994   cur_ptr = read_full_die_1 (reader, &die, info_ptr, &has_children, 0);
17995   if (die == NULL)
17996     {
17997       *new_info_ptr = cur_ptr;
17998       return NULL;
17999     }
18000   store_in_ref_table (die, reader->cu);
18001
18002   if (has_children)
18003     die->child = read_die_and_siblings_1 (reader, cur_ptr, new_info_ptr, die);
18004   else
18005     {
18006       die->child = NULL;
18007       *new_info_ptr = cur_ptr;
18008     }
18009
18010   die->sibling = NULL;
18011   die->parent = parent;
18012   return die;
18013 }
18014
18015 /* Read a die, all of its descendents, and all of its siblings; set
18016    all of the fields of all of the dies correctly.  Arguments are as
18017    in read_die_and_children.  */
18018
18019 static struct die_info *
18020 read_die_and_siblings_1 (const struct die_reader_specs *reader,
18021                          const gdb_byte *info_ptr,
18022                          const gdb_byte **new_info_ptr,
18023                          struct die_info *parent)
18024 {
18025   struct die_info *first_die, *last_sibling;
18026   const gdb_byte *cur_ptr;
18027
18028   cur_ptr = info_ptr;
18029   first_die = last_sibling = NULL;
18030
18031   while (1)
18032     {
18033       struct die_info *die
18034         = read_die_and_children (reader, cur_ptr, &cur_ptr, parent);
18035
18036       if (die == NULL)
18037         {
18038           *new_info_ptr = cur_ptr;
18039           return first_die;
18040         }
18041
18042       if (!first_die)
18043         first_die = die;
18044       else
18045         last_sibling->sibling = die;
18046
18047       last_sibling = die;
18048     }
18049 }
18050
18051 /* Read a die, all of its descendents, and all of its siblings; set
18052    all of the fields of all of the dies correctly.  Arguments are as
18053    in read_die_and_children.
18054    This the main entry point for reading a DIE and all its children.  */
18055
18056 static struct die_info *
18057 read_die_and_siblings (const struct die_reader_specs *reader,
18058                        const gdb_byte *info_ptr,
18059                        const gdb_byte **new_info_ptr,
18060                        struct die_info *parent)
18061 {
18062   struct die_info *die = read_die_and_siblings_1 (reader, info_ptr,
18063                                                   new_info_ptr, parent);
18064
18065   if (dwarf_die_debug)
18066     {
18067       fprintf_unfiltered (gdb_stdlog,
18068                           "Read die from %s@0x%x of %s:\n",
18069                           get_section_name (reader->die_section),
18070                           (unsigned) (info_ptr - reader->die_section->buffer),
18071                           bfd_get_filename (reader->abfd));
18072       dump_die (die, dwarf_die_debug);
18073     }
18074
18075   return die;
18076 }
18077
18078 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
18079    attributes.
18080    The caller is responsible for filling in the extra attributes
18081    and updating (*DIEP)->num_attrs.
18082    Set DIEP to point to a newly allocated die with its information,
18083    except for its child, sibling, and parent fields.
18084    Set HAS_CHILDREN to tell whether the die has children or not.  */
18085
18086 static const gdb_byte *
18087 read_full_die_1 (const struct die_reader_specs *reader,
18088                  struct die_info **diep, const gdb_byte *info_ptr,
18089                  int *has_children, int num_extra_attrs)
18090 {
18091   unsigned int abbrev_number, bytes_read, i;
18092   struct abbrev_info *abbrev;
18093   struct die_info *die;
18094   struct dwarf2_cu *cu = reader->cu;
18095   bfd *abfd = reader->abfd;
18096
18097   sect_offset sect_off = (sect_offset) (info_ptr - reader->buffer);
18098   abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
18099   info_ptr += bytes_read;
18100   if (!abbrev_number)
18101     {
18102       *diep = NULL;
18103       *has_children = 0;
18104       return info_ptr;
18105     }
18106
18107   abbrev = reader->abbrev_table->lookup_abbrev (abbrev_number);
18108   if (!abbrev)
18109     error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
18110            abbrev_number,
18111            bfd_get_filename (abfd));
18112
18113   die = dwarf_alloc_die (cu, abbrev->num_attrs + num_extra_attrs);
18114   die->sect_off = sect_off;
18115   die->tag = abbrev->tag;
18116   die->abbrev = abbrev_number;
18117
18118   /* Make the result usable.
18119      The caller needs to update num_attrs after adding the extra
18120      attributes.  */
18121   die->num_attrs = abbrev->num_attrs;
18122
18123   for (i = 0; i < abbrev->num_attrs; ++i)
18124     info_ptr = read_attribute (reader, &die->attrs[i], &abbrev->attrs[i],
18125                                info_ptr);
18126
18127   *diep = die;
18128   *has_children = abbrev->has_children;
18129   return info_ptr;
18130 }
18131
18132 /* Read a die and all its attributes.
18133    Set DIEP to point to a newly allocated die with its information,
18134    except for its child, sibling, and parent fields.
18135    Set HAS_CHILDREN to tell whether the die has children or not.  */
18136
18137 static const gdb_byte *
18138 read_full_die (const struct die_reader_specs *reader,
18139                struct die_info **diep, const gdb_byte *info_ptr,
18140                int *has_children)
18141 {
18142   const gdb_byte *result;
18143
18144   result = read_full_die_1 (reader, diep, info_ptr, has_children, 0);
18145
18146   if (dwarf_die_debug)
18147     {
18148       fprintf_unfiltered (gdb_stdlog,
18149                           "Read die from %s@0x%x of %s:\n",
18150                           get_section_name (reader->die_section),
18151                           (unsigned) (info_ptr - reader->die_section->buffer),
18152                           bfd_get_filename (reader->abfd));
18153       dump_die (*diep, dwarf_die_debug);
18154     }
18155
18156   return result;
18157 }
18158 \f
18159 /* Abbreviation tables.
18160
18161    In DWARF version 2, the description of the debugging information is
18162    stored in a separate .debug_abbrev section.  Before we read any
18163    dies from a section we read in all abbreviations and install them
18164    in a hash table.  */
18165
18166 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE.  */
18167
18168 struct abbrev_info *
18169 abbrev_table::alloc_abbrev ()
18170 {
18171   struct abbrev_info *abbrev;
18172
18173   abbrev = XOBNEW (&abbrev_obstack, struct abbrev_info);
18174   memset (abbrev, 0, sizeof (struct abbrev_info));
18175
18176   return abbrev;
18177 }
18178
18179 /* Add an abbreviation to the table.  */
18180
18181 void
18182 abbrev_table::add_abbrev (unsigned int abbrev_number,
18183                           struct abbrev_info *abbrev)
18184 {
18185   unsigned int hash_number;
18186
18187   hash_number = abbrev_number % ABBREV_HASH_SIZE;
18188   abbrev->next = m_abbrevs[hash_number];
18189   m_abbrevs[hash_number] = abbrev;
18190 }
18191
18192 /* Look up an abbrev in the table.
18193    Returns NULL if the abbrev is not found.  */
18194
18195 struct abbrev_info *
18196 abbrev_table::lookup_abbrev (unsigned int abbrev_number)
18197 {
18198   unsigned int hash_number;
18199   struct abbrev_info *abbrev;
18200
18201   hash_number = abbrev_number % ABBREV_HASH_SIZE;
18202   abbrev = m_abbrevs[hash_number];
18203
18204   while (abbrev)
18205     {
18206       if (abbrev->number == abbrev_number)
18207         return abbrev;
18208       abbrev = abbrev->next;
18209     }
18210   return NULL;
18211 }
18212
18213 /* Read in an abbrev table.  */
18214
18215 static abbrev_table_up
18216 abbrev_table_read_table (struct dwarf2_per_objfile *dwarf2_per_objfile,
18217                          struct dwarf2_section_info *section,
18218                          sect_offset sect_off)
18219 {
18220   struct objfile *objfile = dwarf2_per_objfile->objfile;
18221   bfd *abfd = get_section_bfd_owner (section);
18222   const gdb_byte *abbrev_ptr;
18223   struct abbrev_info *cur_abbrev;
18224   unsigned int abbrev_number, bytes_read, abbrev_name;
18225   unsigned int abbrev_form;
18226   struct attr_abbrev *cur_attrs;
18227   unsigned int allocated_attrs;
18228
18229   abbrev_table_up abbrev_table (new struct abbrev_table (sect_off));
18230
18231   dwarf2_read_section (objfile, section);
18232   abbrev_ptr = section->buffer + to_underlying (sect_off);
18233   abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18234   abbrev_ptr += bytes_read;
18235
18236   allocated_attrs = ATTR_ALLOC_CHUNK;
18237   cur_attrs = XNEWVEC (struct attr_abbrev, allocated_attrs);
18238
18239   /* Loop until we reach an abbrev number of 0.  */
18240   while (abbrev_number)
18241     {
18242       cur_abbrev = abbrev_table->alloc_abbrev ();
18243
18244       /* read in abbrev header */
18245       cur_abbrev->number = abbrev_number;
18246       cur_abbrev->tag
18247         = (enum dwarf_tag) read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18248       abbrev_ptr += bytes_read;
18249       cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
18250       abbrev_ptr += 1;
18251
18252       /* now read in declarations */
18253       for (;;)
18254         {
18255           LONGEST implicit_const;
18256
18257           abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18258           abbrev_ptr += bytes_read;
18259           abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18260           abbrev_ptr += bytes_read;
18261           if (abbrev_form == DW_FORM_implicit_const)
18262             {
18263               implicit_const = read_signed_leb128 (abfd, abbrev_ptr,
18264                                                    &bytes_read);
18265               abbrev_ptr += bytes_read;
18266             }
18267           else
18268             {
18269               /* Initialize it due to a false compiler warning.  */
18270               implicit_const = -1;
18271             }
18272
18273           if (abbrev_name == 0)
18274             break;
18275
18276           if (cur_abbrev->num_attrs == allocated_attrs)
18277             {
18278               allocated_attrs += ATTR_ALLOC_CHUNK;
18279               cur_attrs
18280                 = XRESIZEVEC (struct attr_abbrev, cur_attrs, allocated_attrs);
18281             }
18282
18283           cur_attrs[cur_abbrev->num_attrs].name
18284             = (enum dwarf_attribute) abbrev_name;
18285           cur_attrs[cur_abbrev->num_attrs].form
18286             = (enum dwarf_form) abbrev_form;
18287           cur_attrs[cur_abbrev->num_attrs].implicit_const = implicit_const;
18288           ++cur_abbrev->num_attrs;
18289         }
18290
18291       cur_abbrev->attrs =
18292         XOBNEWVEC (&abbrev_table->abbrev_obstack, struct attr_abbrev,
18293                    cur_abbrev->num_attrs);
18294       memcpy (cur_abbrev->attrs, cur_attrs,
18295               cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
18296
18297       abbrev_table->add_abbrev (abbrev_number, cur_abbrev);
18298
18299       /* Get next abbreviation.
18300          Under Irix6 the abbreviations for a compilation unit are not
18301          always properly terminated with an abbrev number of 0.
18302          Exit loop if we encounter an abbreviation which we have
18303          already read (which means we are about to read the abbreviations
18304          for the next compile unit) or if the end of the abbreviation
18305          table is reached.  */
18306       if ((unsigned int) (abbrev_ptr - section->buffer) >= section->size)
18307         break;
18308       abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
18309       abbrev_ptr += bytes_read;
18310       if (abbrev_table->lookup_abbrev (abbrev_number) != NULL)
18311         break;
18312     }
18313
18314   xfree (cur_attrs);
18315   return abbrev_table;
18316 }
18317
18318 /* Returns nonzero if TAG represents a type that we might generate a partial
18319    symbol for.  */
18320
18321 static int
18322 is_type_tag_for_partial (int tag)
18323 {
18324   switch (tag)
18325     {
18326 #if 0
18327     /* Some types that would be reasonable to generate partial symbols for,
18328        that we don't at present.  */
18329     case DW_TAG_array_type:
18330     case DW_TAG_file_type:
18331     case DW_TAG_ptr_to_member_type:
18332     case DW_TAG_set_type:
18333     case DW_TAG_string_type:
18334     case DW_TAG_subroutine_type:
18335 #endif
18336     case DW_TAG_base_type:
18337     case DW_TAG_class_type:
18338     case DW_TAG_interface_type:
18339     case DW_TAG_enumeration_type:
18340     case DW_TAG_structure_type:
18341     case DW_TAG_subrange_type:
18342     case DW_TAG_typedef:
18343     case DW_TAG_union_type:
18344       return 1;
18345     default:
18346       return 0;
18347     }
18348 }
18349
18350 /* Load all DIEs that are interesting for partial symbols into memory.  */
18351
18352 static struct partial_die_info *
18353 load_partial_dies (const struct die_reader_specs *reader,
18354                    const gdb_byte *info_ptr, int building_psymtab)
18355 {
18356   struct dwarf2_cu *cu = reader->cu;
18357   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
18358   struct partial_die_info *parent_die, *last_die, *first_die = NULL;
18359   unsigned int bytes_read;
18360   unsigned int load_all = 0;
18361   int nesting_level = 1;
18362
18363   parent_die = NULL;
18364   last_die = NULL;
18365
18366   gdb_assert (cu->per_cu != NULL);
18367   if (cu->per_cu->load_all_dies)
18368     load_all = 1;
18369
18370   cu->partial_dies
18371     = htab_create_alloc_ex (cu->header.length / 12,
18372                             partial_die_hash,
18373                             partial_die_eq,
18374                             NULL,
18375                             &cu->comp_unit_obstack,
18376                             hashtab_obstack_allocate,
18377                             dummy_obstack_deallocate);
18378
18379   while (1)
18380     {
18381       abbrev_info *abbrev = peek_die_abbrev (*reader, info_ptr, &bytes_read);
18382
18383       /* A NULL abbrev means the end of a series of children.  */
18384       if (abbrev == NULL)
18385         {
18386           if (--nesting_level == 0)
18387             return first_die;
18388
18389           info_ptr += bytes_read;
18390           last_die = parent_die;
18391           parent_die = parent_die->die_parent;
18392           continue;
18393         }
18394
18395       /* Check for template arguments.  We never save these; if
18396          they're seen, we just mark the parent, and go on our way.  */
18397       if (parent_die != NULL
18398           && cu->language == language_cplus
18399           && (abbrev->tag == DW_TAG_template_type_param
18400               || abbrev->tag == DW_TAG_template_value_param))
18401         {
18402           parent_die->has_template_arguments = 1;
18403
18404           if (!load_all)
18405             {
18406               /* We don't need a partial DIE for the template argument.  */
18407               info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18408               continue;
18409             }
18410         }
18411
18412       /* We only recurse into c++ subprograms looking for template arguments.
18413          Skip their other children.  */
18414       if (!load_all
18415           && cu->language == language_cplus
18416           && parent_die != NULL
18417           && parent_die->tag == DW_TAG_subprogram)
18418         {
18419           info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18420           continue;
18421         }
18422
18423       /* Check whether this DIE is interesting enough to save.  Normally
18424          we would not be interested in members here, but there may be
18425          later variables referencing them via DW_AT_specification (for
18426          static members).  */
18427       if (!load_all
18428           && !is_type_tag_for_partial (abbrev->tag)
18429           && abbrev->tag != DW_TAG_constant
18430           && abbrev->tag != DW_TAG_enumerator
18431           && abbrev->tag != DW_TAG_subprogram
18432           && abbrev->tag != DW_TAG_inlined_subroutine
18433           && abbrev->tag != DW_TAG_lexical_block
18434           && abbrev->tag != DW_TAG_variable
18435           && abbrev->tag != DW_TAG_namespace
18436           && abbrev->tag != DW_TAG_module
18437           && abbrev->tag != DW_TAG_member
18438           && abbrev->tag != DW_TAG_imported_unit
18439           && abbrev->tag != DW_TAG_imported_declaration)
18440         {
18441           /* Otherwise we skip to the next sibling, if any.  */
18442           info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
18443           continue;
18444         }
18445
18446       struct partial_die_info pdi ((sect_offset) (info_ptr - reader->buffer),
18447                                    abbrev);
18448
18449       info_ptr = pdi.read (reader, *abbrev, info_ptr + bytes_read);
18450
18451       /* This two-pass algorithm for processing partial symbols has a
18452          high cost in cache pressure.  Thus, handle some simple cases
18453          here which cover the majority of C partial symbols.  DIEs
18454          which neither have specification tags in them, nor could have
18455          specification tags elsewhere pointing at them, can simply be
18456          processed and discarded.
18457
18458          This segment is also optional; scan_partial_symbols and
18459          add_partial_symbol will handle these DIEs if we chain
18460          them in normally.  When compilers which do not emit large
18461          quantities of duplicate debug information are more common,
18462          this code can probably be removed.  */
18463
18464       /* Any complete simple types at the top level (pretty much all
18465          of them, for a language without namespaces), can be processed
18466          directly.  */
18467       if (parent_die == NULL
18468           && pdi.has_specification == 0
18469           && pdi.is_declaration == 0
18470           && ((pdi.tag == DW_TAG_typedef && !pdi.has_children)
18471               || pdi.tag == DW_TAG_base_type
18472               || pdi.tag == DW_TAG_subrange_type))
18473         {
18474           if (building_psymtab && pdi.name != NULL)
18475             add_psymbol_to_list (pdi.name, strlen (pdi.name), 0,
18476                                  VAR_DOMAIN, LOC_TYPEDEF, -1,
18477                                  psymbol_placement::STATIC,
18478                                  0, cu->language, objfile);
18479           info_ptr = locate_pdi_sibling (reader, &pdi, info_ptr);
18480           continue;
18481         }
18482
18483       /* The exception for DW_TAG_typedef with has_children above is
18484          a workaround of GCC PR debug/47510.  In the case of this complaint
18485          type_name_or_error will error on such types later.
18486
18487          GDB skipped children of DW_TAG_typedef by the shortcut above and then
18488          it could not find the child DIEs referenced later, this is checked
18489          above.  In correct DWARF DW_TAG_typedef should have no children.  */
18490
18491       if (pdi.tag == DW_TAG_typedef && pdi.has_children)
18492         complaint (_("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
18493                      "- DIE at %s [in module %s]"),
18494                    sect_offset_str (pdi.sect_off), objfile_name (objfile));
18495
18496       /* If we're at the second level, and we're an enumerator, and
18497          our parent has no specification (meaning possibly lives in a
18498          namespace elsewhere), then we can add the partial symbol now
18499          instead of queueing it.  */
18500       if (pdi.tag == DW_TAG_enumerator
18501           && parent_die != NULL
18502           && parent_die->die_parent == NULL
18503           && parent_die->tag == DW_TAG_enumeration_type
18504           && parent_die->has_specification == 0)
18505         {
18506           if (pdi.name == NULL)
18507             complaint (_("malformed enumerator DIE ignored"));
18508           else if (building_psymtab)
18509             add_psymbol_to_list (pdi.name, strlen (pdi.name), 0,
18510                                  VAR_DOMAIN, LOC_CONST, -1,
18511                                  cu->language == language_cplus
18512                                  ? psymbol_placement::GLOBAL
18513                                  : psymbol_placement::STATIC,
18514                                  0, cu->language, objfile);
18515
18516           info_ptr = locate_pdi_sibling (reader, &pdi, info_ptr);
18517           continue;
18518         }
18519
18520       struct partial_die_info *part_die
18521         = new (&cu->comp_unit_obstack) partial_die_info (pdi);
18522
18523       /* We'll save this DIE so link it in.  */
18524       part_die->die_parent = parent_die;
18525       part_die->die_sibling = NULL;
18526       part_die->die_child = NULL;
18527
18528       if (last_die && last_die == parent_die)
18529         last_die->die_child = part_die;
18530       else if (last_die)
18531         last_die->die_sibling = part_die;
18532
18533       last_die = part_die;
18534
18535       if (first_die == NULL)
18536         first_die = part_die;
18537
18538       /* Maybe add the DIE to the hash table.  Not all DIEs that we
18539          find interesting need to be in the hash table, because we
18540          also have the parent/sibling/child chains; only those that we
18541          might refer to by offset later during partial symbol reading.
18542
18543          For now this means things that might have be the target of a
18544          DW_AT_specification, DW_AT_abstract_origin, or
18545          DW_AT_extension.  DW_AT_extension will refer only to
18546          namespaces; DW_AT_abstract_origin refers to functions (and
18547          many things under the function DIE, but we do not recurse
18548          into function DIEs during partial symbol reading) and
18549          possibly variables as well; DW_AT_specification refers to
18550          declarations.  Declarations ought to have the DW_AT_declaration
18551          flag.  It happens that GCC forgets to put it in sometimes, but
18552          only for functions, not for types.
18553
18554          Adding more things than necessary to the hash table is harmless
18555          except for the performance cost.  Adding too few will result in
18556          wasted time in find_partial_die, when we reread the compilation
18557          unit with load_all_dies set.  */
18558
18559       if (load_all
18560           || abbrev->tag == DW_TAG_constant
18561           || abbrev->tag == DW_TAG_subprogram
18562           || abbrev->tag == DW_TAG_variable
18563           || abbrev->tag == DW_TAG_namespace
18564           || part_die->is_declaration)
18565         {
18566           void **slot;
18567
18568           slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
18569                                            to_underlying (part_die->sect_off),
18570                                            INSERT);
18571           *slot = part_die;
18572         }
18573
18574       /* For some DIEs we want to follow their children (if any).  For C
18575          we have no reason to follow the children of structures; for other
18576          languages we have to, so that we can get at method physnames
18577          to infer fully qualified class names, for DW_AT_specification,
18578          and for C++ template arguments.  For C++, we also look one level
18579          inside functions to find template arguments (if the name of the
18580          function does not already contain the template arguments).
18581
18582          For Ada, we need to scan the children of subprograms and lexical
18583          blocks as well because Ada allows the definition of nested
18584          entities that could be interesting for the debugger, such as
18585          nested subprograms for instance.  */
18586       if (last_die->has_children
18587           && (load_all
18588               || last_die->tag == DW_TAG_namespace
18589               || last_die->tag == DW_TAG_module
18590               || last_die->tag == DW_TAG_enumeration_type
18591               || (cu->language == language_cplus
18592                   && last_die->tag == DW_TAG_subprogram
18593                   && (last_die->name == NULL
18594                       || strchr (last_die->name, '<') == NULL))
18595               || (cu->language != language_c
18596                   && (last_die->tag == DW_TAG_class_type
18597                       || last_die->tag == DW_TAG_interface_type
18598                       || last_die->tag == DW_TAG_structure_type
18599                       || last_die->tag == DW_TAG_union_type))
18600               || (cu->language == language_ada
18601                   && (last_die->tag == DW_TAG_subprogram
18602                       || last_die->tag == DW_TAG_lexical_block))))
18603         {
18604           nesting_level++;
18605           parent_die = last_die;
18606           continue;
18607         }
18608
18609       /* Otherwise we skip to the next sibling, if any.  */
18610       info_ptr = locate_pdi_sibling (reader, last_die, info_ptr);
18611
18612       /* Back to the top, do it again.  */
18613     }
18614 }
18615
18616 partial_die_info::partial_die_info (sect_offset sect_off_,
18617                                     struct abbrev_info *abbrev)
18618   : partial_die_info (sect_off_, abbrev->tag, abbrev->has_children)
18619 {
18620 }
18621
18622 /* Read a minimal amount of information into the minimal die structure.
18623    INFO_PTR should point just after the initial uleb128 of a DIE.  */
18624
18625 const gdb_byte *
18626 partial_die_info::read (const struct die_reader_specs *reader,
18627                         const struct abbrev_info &abbrev, const gdb_byte *info_ptr)
18628 {
18629   struct dwarf2_cu *cu = reader->cu;
18630   struct dwarf2_per_objfile *dwarf2_per_objfile
18631     = cu->per_cu->dwarf2_per_objfile;
18632   unsigned int i;
18633   int has_low_pc_attr = 0;
18634   int has_high_pc_attr = 0;
18635   int high_pc_relative = 0;
18636
18637   for (i = 0; i < abbrev.num_attrs; ++i)
18638     {
18639       struct attribute attr;
18640
18641       info_ptr = read_attribute (reader, &attr, &abbrev.attrs[i], info_ptr);
18642
18643       /* Store the data if it is of an attribute we want to keep in a
18644          partial symbol table.  */
18645       switch (attr.name)
18646         {
18647         case DW_AT_name:
18648           switch (tag)
18649             {
18650             case DW_TAG_compile_unit:
18651             case DW_TAG_partial_unit:
18652             case DW_TAG_type_unit:
18653               /* Compilation units have a DW_AT_name that is a filename, not
18654                  a source language identifier.  */
18655             case DW_TAG_enumeration_type:
18656             case DW_TAG_enumerator:
18657               /* These tags always have simple identifiers already; no need
18658                  to canonicalize them.  */
18659               name = DW_STRING (&attr);
18660               break;
18661             default:
18662               {
18663                 struct objfile *objfile = dwarf2_per_objfile->objfile;
18664
18665                 name
18666                   = dwarf2_canonicalize_name (DW_STRING (&attr), cu,
18667                                               &objfile->per_bfd->storage_obstack);
18668               }
18669               break;
18670             }
18671           break;
18672         case DW_AT_linkage_name:
18673         case DW_AT_MIPS_linkage_name:
18674           /* Note that both forms of linkage name might appear.  We
18675              assume they will be the same, and we only store the last
18676              one we see.  */
18677           if (cu->language == language_ada)
18678             name = DW_STRING (&attr);
18679           linkage_name = DW_STRING (&attr);
18680           break;
18681         case DW_AT_low_pc:
18682           has_low_pc_attr = 1;
18683           lowpc = attr_value_as_address (&attr);
18684           break;
18685         case DW_AT_high_pc:
18686           has_high_pc_attr = 1;
18687           highpc = attr_value_as_address (&attr);
18688           if (cu->header.version >= 4 && attr_form_is_constant (&attr))
18689                 high_pc_relative = 1;
18690           break;
18691         case DW_AT_location:
18692           /* Support the .debug_loc offsets.  */
18693           if (attr_form_is_block (&attr))
18694             {
18695                d.locdesc = DW_BLOCK (&attr);
18696             }
18697           else if (attr_form_is_section_offset (&attr))
18698             {
18699               dwarf2_complex_location_expr_complaint ();
18700             }
18701           else
18702             {
18703               dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
18704                                                      "partial symbol information");
18705             }
18706           break;
18707         case DW_AT_external:
18708           is_external = DW_UNSND (&attr);
18709           break;
18710         case DW_AT_declaration:
18711           is_declaration = DW_UNSND (&attr);
18712           break;
18713         case DW_AT_type:
18714           has_type = 1;
18715           break;
18716         case DW_AT_abstract_origin:
18717         case DW_AT_specification:
18718         case DW_AT_extension:
18719           has_specification = 1;
18720           spec_offset = dwarf2_get_ref_die_offset (&attr);
18721           spec_is_dwz = (attr.form == DW_FORM_GNU_ref_alt
18722                                    || cu->per_cu->is_dwz);
18723           break;
18724         case DW_AT_sibling:
18725           /* Ignore absolute siblings, they might point outside of
18726              the current compile unit.  */
18727           if (attr.form == DW_FORM_ref_addr)
18728             complaint (_("ignoring absolute DW_AT_sibling"));
18729           else
18730             {
18731               const gdb_byte *buffer = reader->buffer;
18732               sect_offset off = dwarf2_get_ref_die_offset (&attr);
18733               const gdb_byte *sibling_ptr = buffer + to_underlying (off);
18734
18735               if (sibling_ptr < info_ptr)
18736                 complaint (_("DW_AT_sibling points backwards"));
18737               else if (sibling_ptr > reader->buffer_end)
18738                 dwarf2_section_buffer_overflow_complaint (reader->die_section);
18739               else
18740                 sibling = sibling_ptr;
18741             }
18742           break;
18743         case DW_AT_byte_size:
18744           has_byte_size = 1;
18745           break;
18746         case DW_AT_const_value:
18747           has_const_value = 1;
18748           break;
18749         case DW_AT_calling_convention:
18750           /* DWARF doesn't provide a way to identify a program's source-level
18751              entry point.  DW_AT_calling_convention attributes are only meant
18752              to describe functions' calling conventions.
18753
18754              However, because it's a necessary piece of information in
18755              Fortran, and before DWARF 4 DW_CC_program was the only
18756              piece of debugging information whose definition refers to
18757              a 'main program' at all, several compilers marked Fortran
18758              main programs with DW_CC_program --- even when those
18759              functions use the standard calling conventions.
18760
18761              Although DWARF now specifies a way to provide this
18762              information, we support this practice for backward
18763              compatibility.  */
18764           if (DW_UNSND (&attr) == DW_CC_program
18765               && cu->language == language_fortran)
18766             main_subprogram = 1;
18767           break;
18768         case DW_AT_inline:
18769           if (DW_UNSND (&attr) == DW_INL_inlined
18770               || DW_UNSND (&attr) == DW_INL_declared_inlined)
18771             may_be_inlined = 1;
18772           break;
18773
18774         case DW_AT_import:
18775           if (tag == DW_TAG_imported_unit)
18776             {
18777               d.sect_off = dwarf2_get_ref_die_offset (&attr);
18778               is_dwz = (attr.form == DW_FORM_GNU_ref_alt
18779                                   || cu->per_cu->is_dwz);
18780             }
18781           break;
18782
18783         case DW_AT_main_subprogram:
18784           main_subprogram = DW_UNSND (&attr);
18785           break;
18786
18787         case DW_AT_ranges:
18788           {
18789             /* It would be nice to reuse dwarf2_get_pc_bounds here,
18790                but that requires a full DIE, so instead we just
18791                reimplement it.  */
18792             int need_ranges_base = tag != DW_TAG_compile_unit;
18793             unsigned int ranges_offset = (DW_UNSND (&attr)
18794                                           + (need_ranges_base
18795                                              ? cu->ranges_base
18796                                              : 0));
18797
18798             /* Value of the DW_AT_ranges attribute is the offset in the
18799                .debug_ranges section.  */
18800             if (dwarf2_ranges_read (ranges_offset, &lowpc, &highpc, cu,
18801                                     nullptr))
18802               has_pc_info = 1;
18803           }
18804           break;
18805
18806         default:
18807           break;
18808         }
18809     }
18810
18811   if (high_pc_relative)
18812     highpc += lowpc;
18813
18814   if (has_low_pc_attr && has_high_pc_attr)
18815     {
18816       /* When using the GNU linker, .gnu.linkonce. sections are used to
18817          eliminate duplicate copies of functions and vtables and such.
18818          The linker will arbitrarily choose one and discard the others.
18819          The AT_*_pc values for such functions refer to local labels in
18820          these sections.  If the section from that file was discarded, the
18821          labels are not in the output, so the relocs get a value of 0.
18822          If this is a discarded function, mark the pc bounds as invalid,
18823          so that GDB will ignore it.  */
18824       if (lowpc == 0 && !dwarf2_per_objfile->has_section_at_zero)
18825         {
18826           struct objfile *objfile = dwarf2_per_objfile->objfile;
18827           struct gdbarch *gdbarch = get_objfile_arch (objfile);
18828
18829           complaint (_("DW_AT_low_pc %s is zero "
18830                        "for DIE at %s [in module %s]"),
18831                      paddress (gdbarch, lowpc),
18832                      sect_offset_str (sect_off),
18833                      objfile_name (objfile));
18834         }
18835       /* dwarf2_get_pc_bounds has also the strict low < high requirement.  */
18836       else if (lowpc >= highpc)
18837         {
18838           struct objfile *objfile = dwarf2_per_objfile->objfile;
18839           struct gdbarch *gdbarch = get_objfile_arch (objfile);
18840
18841           complaint (_("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
18842                        "for DIE at %s [in module %s]"),
18843                      paddress (gdbarch, lowpc),
18844                      paddress (gdbarch, highpc),
18845                      sect_offset_str (sect_off),
18846                      objfile_name (objfile));
18847         }
18848       else
18849         has_pc_info = 1;
18850     }
18851
18852   return info_ptr;
18853 }
18854
18855 /* Find a cached partial DIE at OFFSET in CU.  */
18856
18857 struct partial_die_info *
18858 dwarf2_cu::find_partial_die (sect_offset sect_off)
18859 {
18860   struct partial_die_info *lookup_die = NULL;
18861   struct partial_die_info part_die (sect_off);
18862
18863   lookup_die = ((struct partial_die_info *)
18864                 htab_find_with_hash (partial_dies, &part_die,
18865                                      to_underlying (sect_off)));
18866
18867   return lookup_die;
18868 }
18869
18870 /* Find a partial DIE at OFFSET, which may or may not be in CU,
18871    except in the case of .debug_types DIEs which do not reference
18872    outside their CU (they do however referencing other types via
18873    DW_FORM_ref_sig8).  */
18874
18875 static struct partial_die_info *
18876 find_partial_die (sect_offset sect_off, int offset_in_dwz, struct dwarf2_cu *cu)
18877 {
18878   struct dwarf2_per_objfile *dwarf2_per_objfile
18879     = cu->per_cu->dwarf2_per_objfile;
18880   struct objfile *objfile = dwarf2_per_objfile->objfile;
18881   struct dwarf2_per_cu_data *per_cu = NULL;
18882   struct partial_die_info *pd = NULL;
18883
18884   if (offset_in_dwz == cu->per_cu->is_dwz
18885       && offset_in_cu_p (&cu->header, sect_off))
18886     {
18887       pd = cu->find_partial_die (sect_off);
18888       if (pd != NULL)
18889         return pd;
18890       /* We missed recording what we needed.
18891          Load all dies and try again.  */
18892       per_cu = cu->per_cu;
18893     }
18894   else
18895     {
18896       /* TUs don't reference other CUs/TUs (except via type signatures).  */
18897       if (cu->per_cu->is_debug_types)
18898         {
18899           error (_("Dwarf Error: Type Unit at offset %s contains"
18900                    " external reference to offset %s [in module %s].\n"),
18901                  sect_offset_str (cu->header.sect_off), sect_offset_str (sect_off),
18902                  bfd_get_filename (objfile->obfd));
18903         }
18904       per_cu = dwarf2_find_containing_comp_unit (sect_off, offset_in_dwz,
18905                                                  dwarf2_per_objfile);
18906
18907       if (per_cu->cu == NULL || per_cu->cu->partial_dies == NULL)
18908         load_partial_comp_unit (per_cu);
18909
18910       per_cu->cu->last_used = 0;
18911       pd = per_cu->cu->find_partial_die (sect_off);
18912     }
18913
18914   /* If we didn't find it, and not all dies have been loaded,
18915      load them all and try again.  */
18916
18917   if (pd == NULL && per_cu->load_all_dies == 0)
18918     {
18919       per_cu->load_all_dies = 1;
18920
18921       /* This is nasty.  When we reread the DIEs, somewhere up the call chain
18922          THIS_CU->cu may already be in use.  So we can't just free it and
18923          replace its DIEs with the ones we read in.  Instead, we leave those
18924          DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
18925          and clobber THIS_CU->cu->partial_dies with the hash table for the new
18926          set.  */
18927       load_partial_comp_unit (per_cu);
18928
18929       pd = per_cu->cu->find_partial_die (sect_off);
18930     }
18931
18932   if (pd == NULL)
18933     internal_error (__FILE__, __LINE__,
18934                     _("could not find partial DIE %s "
18935                       "in cache [from module %s]\n"),
18936                     sect_offset_str (sect_off), bfd_get_filename (objfile->obfd));
18937   return pd;
18938 }
18939
18940 /* See if we can figure out if the class lives in a namespace.  We do
18941    this by looking for a member function; its demangled name will
18942    contain namespace info, if there is any.  */
18943
18944 static void
18945 guess_partial_die_structure_name (struct partial_die_info *struct_pdi,
18946                                   struct dwarf2_cu *cu)
18947 {
18948   /* NOTE: carlton/2003-10-07: Getting the info this way changes
18949      what template types look like, because the demangler
18950      frequently doesn't give the same name as the debug info.  We
18951      could fix this by only using the demangled name to get the
18952      prefix (but see comment in read_structure_type).  */
18953
18954   struct partial_die_info *real_pdi;
18955   struct partial_die_info *child_pdi;
18956
18957   /* If this DIE (this DIE's specification, if any) has a parent, then
18958      we should not do this.  We'll prepend the parent's fully qualified
18959      name when we create the partial symbol.  */
18960
18961   real_pdi = struct_pdi;
18962   while (real_pdi->has_specification)
18963     real_pdi = find_partial_die (real_pdi->spec_offset,
18964                                  real_pdi->spec_is_dwz, cu);
18965
18966   if (real_pdi->die_parent != NULL)
18967     return;
18968
18969   for (child_pdi = struct_pdi->die_child;
18970        child_pdi != NULL;
18971        child_pdi = child_pdi->die_sibling)
18972     {
18973       if (child_pdi->tag == DW_TAG_subprogram
18974           && child_pdi->linkage_name != NULL)
18975         {
18976           char *actual_class_name
18977             = language_class_name_from_physname (cu->language_defn,
18978                                                  child_pdi->linkage_name);
18979           if (actual_class_name != NULL)
18980             {
18981               struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
18982               struct_pdi->name
18983                 = ((const char *)
18984                    obstack_copy0 (&objfile->per_bfd->storage_obstack,
18985                                   actual_class_name,
18986                                   strlen (actual_class_name)));
18987               xfree (actual_class_name);
18988             }
18989           break;
18990         }
18991     }
18992 }
18993
18994 void
18995 partial_die_info::fixup (struct dwarf2_cu *cu)
18996 {
18997   /* Once we've fixed up a die, there's no point in doing so again.
18998      This also avoids a memory leak if we were to call
18999      guess_partial_die_structure_name multiple times.  */
19000   if (fixup_called)
19001     return;
19002
19003   /* If we found a reference attribute and the DIE has no name, try
19004      to find a name in the referred to DIE.  */
19005
19006   if (name == NULL && has_specification)
19007     {
19008       struct partial_die_info *spec_die;
19009
19010       spec_die = find_partial_die (spec_offset, spec_is_dwz, cu);
19011
19012       spec_die->fixup (cu);
19013
19014       if (spec_die->name)
19015         {
19016           name = spec_die->name;
19017
19018           /* Copy DW_AT_external attribute if it is set.  */
19019           if (spec_die->is_external)
19020             is_external = spec_die->is_external;
19021         }
19022     }
19023
19024   /* Set default names for some unnamed DIEs.  */
19025
19026   if (name == NULL && tag == DW_TAG_namespace)
19027     name = CP_ANONYMOUS_NAMESPACE_STR;
19028
19029   /* If there is no parent die to provide a namespace, and there are
19030      children, see if we can determine the namespace from their linkage
19031      name.  */
19032   if (cu->language == language_cplus
19033       && !VEC_empty (dwarf2_section_info_def,
19034                      cu->per_cu->dwarf2_per_objfile->types)
19035       && die_parent == NULL
19036       && has_children
19037       && (tag == DW_TAG_class_type
19038           || tag == DW_TAG_structure_type
19039           || tag == DW_TAG_union_type))
19040     guess_partial_die_structure_name (this, cu);
19041
19042   /* GCC might emit a nameless struct or union that has a linkage
19043      name.  See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510.  */
19044   if (name == NULL
19045       && (tag == DW_TAG_class_type
19046           || tag == DW_TAG_interface_type
19047           || tag == DW_TAG_structure_type
19048           || tag == DW_TAG_union_type)
19049       && linkage_name != NULL)
19050     {
19051       char *demangled;
19052
19053       demangled = gdb_demangle (linkage_name, DMGL_TYPES);
19054       if (demangled)
19055         {
19056           const char *base;
19057
19058           /* Strip any leading namespaces/classes, keep only the base name.
19059              DW_AT_name for named DIEs does not contain the prefixes.  */
19060           base = strrchr (demangled, ':');
19061           if (base && base > demangled && base[-1] == ':')
19062             base++;
19063           else
19064             base = demangled;
19065
19066           struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
19067           name
19068             = ((const char *)
19069                obstack_copy0 (&objfile->per_bfd->storage_obstack,
19070                               base, strlen (base)));
19071           xfree (demangled);
19072         }
19073     }
19074
19075   fixup_called = 1;
19076 }
19077
19078 /* Read an attribute value described by an attribute form.  */
19079
19080 static const gdb_byte *
19081 read_attribute_value (const struct die_reader_specs *reader,
19082                       struct attribute *attr, unsigned form,
19083                       LONGEST implicit_const, const gdb_byte *info_ptr)
19084 {
19085   struct dwarf2_cu *cu = reader->cu;
19086   struct dwarf2_per_objfile *dwarf2_per_objfile
19087     = cu->per_cu->dwarf2_per_objfile;
19088   struct objfile *objfile = dwarf2_per_objfile->objfile;
19089   struct gdbarch *gdbarch = get_objfile_arch (objfile);
19090   bfd *abfd = reader->abfd;
19091   struct comp_unit_head *cu_header = &cu->header;
19092   unsigned int bytes_read;
19093   struct dwarf_block *blk;
19094
19095   attr->form = (enum dwarf_form) form;
19096   switch (form)
19097     {
19098     case DW_FORM_ref_addr:
19099       if (cu->header.version == 2)
19100         DW_UNSND (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
19101       else
19102         DW_UNSND (attr) = read_offset (abfd, info_ptr,
19103                                        &cu->header, &bytes_read);
19104       info_ptr += bytes_read;
19105       break;
19106     case DW_FORM_GNU_ref_alt:
19107       DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
19108       info_ptr += bytes_read;
19109       break;
19110     case DW_FORM_addr:
19111       DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
19112       DW_ADDR (attr) = gdbarch_adjust_dwarf2_addr (gdbarch, DW_ADDR (attr));
19113       info_ptr += bytes_read;
19114       break;
19115     case DW_FORM_block2:
19116       blk = dwarf_alloc_block (cu);
19117       blk->size = read_2_bytes (abfd, info_ptr);
19118       info_ptr += 2;
19119       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19120       info_ptr += blk->size;
19121       DW_BLOCK (attr) = blk;
19122       break;
19123     case DW_FORM_block4:
19124       blk = dwarf_alloc_block (cu);
19125       blk->size = read_4_bytes (abfd, info_ptr);
19126       info_ptr += 4;
19127       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19128       info_ptr += blk->size;
19129       DW_BLOCK (attr) = blk;
19130       break;
19131     case DW_FORM_data2:
19132       DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
19133       info_ptr += 2;
19134       break;
19135     case DW_FORM_data4:
19136       DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
19137       info_ptr += 4;
19138       break;
19139     case DW_FORM_data8:
19140       DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
19141       info_ptr += 8;
19142       break;
19143     case DW_FORM_data16:
19144       blk = dwarf_alloc_block (cu);
19145       blk->size = 16;
19146       blk->data = read_n_bytes (abfd, info_ptr, 16);
19147       info_ptr += 16;
19148       DW_BLOCK (attr) = blk;
19149       break;
19150     case DW_FORM_sec_offset:
19151       DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
19152       info_ptr += bytes_read;
19153       break;
19154     case DW_FORM_string:
19155       DW_STRING (attr) = read_direct_string (abfd, info_ptr, &bytes_read);
19156       DW_STRING_IS_CANONICAL (attr) = 0;
19157       info_ptr += bytes_read;
19158       break;
19159     case DW_FORM_strp:
19160       if (!cu->per_cu->is_dwz)
19161         {
19162           DW_STRING (attr) = read_indirect_string (dwarf2_per_objfile,
19163                                                    abfd, info_ptr, cu_header,
19164                                                    &bytes_read);
19165           DW_STRING_IS_CANONICAL (attr) = 0;
19166           info_ptr += bytes_read;
19167           break;
19168         }
19169       /* FALLTHROUGH */
19170     case DW_FORM_line_strp:
19171       if (!cu->per_cu->is_dwz)
19172         {
19173           DW_STRING (attr) = read_indirect_line_string (dwarf2_per_objfile,
19174                                                         abfd, info_ptr,
19175                                                         cu_header, &bytes_read);
19176           DW_STRING_IS_CANONICAL (attr) = 0;
19177           info_ptr += bytes_read;
19178           break;
19179         }
19180       /* FALLTHROUGH */
19181     case DW_FORM_GNU_strp_alt:
19182       {
19183         struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
19184         LONGEST str_offset = read_offset (abfd, info_ptr, cu_header,
19185                                           &bytes_read);
19186
19187         DW_STRING (attr) = read_indirect_string_from_dwz (objfile,
19188                                                           dwz, str_offset);
19189         DW_STRING_IS_CANONICAL (attr) = 0;
19190         info_ptr += bytes_read;
19191       }
19192       break;
19193     case DW_FORM_exprloc:
19194     case DW_FORM_block:
19195       blk = dwarf_alloc_block (cu);
19196       blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19197       info_ptr += bytes_read;
19198       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19199       info_ptr += blk->size;
19200       DW_BLOCK (attr) = blk;
19201       break;
19202     case DW_FORM_block1:
19203       blk = dwarf_alloc_block (cu);
19204       blk->size = read_1_byte (abfd, info_ptr);
19205       info_ptr += 1;
19206       blk->data = read_n_bytes (abfd, info_ptr, blk->size);
19207       info_ptr += blk->size;
19208       DW_BLOCK (attr) = blk;
19209       break;
19210     case DW_FORM_data1:
19211       DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
19212       info_ptr += 1;
19213       break;
19214     case DW_FORM_flag:
19215       DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
19216       info_ptr += 1;
19217       break;
19218     case DW_FORM_flag_present:
19219       DW_UNSND (attr) = 1;
19220       break;
19221     case DW_FORM_sdata:
19222       DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
19223       info_ptr += bytes_read;
19224       break;
19225     case DW_FORM_udata:
19226       DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19227       info_ptr += bytes_read;
19228       break;
19229     case DW_FORM_ref1:
19230       DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19231                          + read_1_byte (abfd, info_ptr));
19232       info_ptr += 1;
19233       break;
19234     case DW_FORM_ref2:
19235       DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19236                          + read_2_bytes (abfd, info_ptr));
19237       info_ptr += 2;
19238       break;
19239     case DW_FORM_ref4:
19240       DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19241                          + read_4_bytes (abfd, info_ptr));
19242       info_ptr += 4;
19243       break;
19244     case DW_FORM_ref8:
19245       DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19246                          + read_8_bytes (abfd, info_ptr));
19247       info_ptr += 8;
19248       break;
19249     case DW_FORM_ref_sig8:
19250       DW_SIGNATURE (attr) = read_8_bytes (abfd, info_ptr);
19251       info_ptr += 8;
19252       break;
19253     case DW_FORM_ref_udata:
19254       DW_UNSND (attr) = (to_underlying (cu->header.sect_off)
19255                          + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
19256       info_ptr += bytes_read;
19257       break;
19258     case DW_FORM_indirect:
19259       form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19260       info_ptr += bytes_read;
19261       if (form == DW_FORM_implicit_const)
19262         {
19263           implicit_const = read_signed_leb128 (abfd, info_ptr, &bytes_read);
19264           info_ptr += bytes_read;
19265         }
19266       info_ptr = read_attribute_value (reader, attr, form, implicit_const,
19267                                        info_ptr);
19268       break;
19269     case DW_FORM_implicit_const:
19270       DW_SND (attr) = implicit_const;
19271       break;
19272     case DW_FORM_GNU_addr_index:
19273       if (reader->dwo_file == NULL)
19274         {
19275           /* For now flag a hard error.
19276              Later we can turn this into a complaint.  */
19277           error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19278                  dwarf_form_name (form),
19279                  bfd_get_filename (abfd));
19280         }
19281       DW_ADDR (attr) = read_addr_index_from_leb128 (cu, info_ptr, &bytes_read);
19282       info_ptr += bytes_read;
19283       break;
19284     case DW_FORM_GNU_str_index:
19285       if (reader->dwo_file == NULL)
19286         {
19287           /* For now flag a hard error.
19288              Later we can turn this into a complaint if warranted.  */
19289           error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
19290                  dwarf_form_name (form),
19291                  bfd_get_filename (abfd));
19292         }
19293       {
19294         ULONGEST str_index =
19295           read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
19296
19297         DW_STRING (attr) = read_str_index (reader, str_index);
19298         DW_STRING_IS_CANONICAL (attr) = 0;
19299         info_ptr += bytes_read;
19300       }
19301       break;
19302     default:
19303       error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
19304              dwarf_form_name (form),
19305              bfd_get_filename (abfd));
19306     }
19307
19308   /* Super hack.  */
19309   if (cu->per_cu->is_dwz && attr_form_is_ref (attr))
19310     attr->form = DW_FORM_GNU_ref_alt;
19311
19312   /* We have seen instances where the compiler tried to emit a byte
19313      size attribute of -1 which ended up being encoded as an unsigned
19314      0xffffffff.  Although 0xffffffff is technically a valid size value,
19315      an object of this size seems pretty unlikely so we can relatively
19316      safely treat these cases as if the size attribute was invalid and
19317      treat them as zero by default.  */
19318   if (attr->name == DW_AT_byte_size
19319       && form == DW_FORM_data4
19320       && DW_UNSND (attr) >= 0xffffffff)
19321     {
19322       complaint
19323         (_("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
19324          hex_string (DW_UNSND (attr)));
19325       DW_UNSND (attr) = 0;
19326     }
19327
19328   return info_ptr;
19329 }
19330
19331 /* Read an attribute described by an abbreviated attribute.  */
19332
19333 static const gdb_byte *
19334 read_attribute (const struct die_reader_specs *reader,
19335                 struct attribute *attr, struct attr_abbrev *abbrev,
19336                 const gdb_byte *info_ptr)
19337 {
19338   attr->name = abbrev->name;
19339   return read_attribute_value (reader, attr, abbrev->form,
19340                                abbrev->implicit_const, info_ptr);
19341 }
19342
19343 /* Read dwarf information from a buffer.  */
19344
19345 static unsigned int
19346 read_1_byte (bfd *abfd, const gdb_byte *buf)
19347 {
19348   return bfd_get_8 (abfd, buf);
19349 }
19350
19351 static int
19352 read_1_signed_byte (bfd *abfd, const gdb_byte *buf)
19353 {
19354   return bfd_get_signed_8 (abfd, buf);
19355 }
19356
19357 static unsigned int
19358 read_2_bytes (bfd *abfd, const gdb_byte *buf)
19359 {
19360   return bfd_get_16 (abfd, buf);
19361 }
19362
19363 static int
19364 read_2_signed_bytes (bfd *abfd, const gdb_byte *buf)
19365 {
19366   return bfd_get_signed_16 (abfd, buf);
19367 }
19368
19369 static unsigned int
19370 read_4_bytes (bfd *abfd, const gdb_byte *buf)
19371 {
19372   return bfd_get_32 (abfd, buf);
19373 }
19374
19375 static int
19376 read_4_signed_bytes (bfd *abfd, const gdb_byte *buf)
19377 {
19378   return bfd_get_signed_32 (abfd, buf);
19379 }
19380
19381 static ULONGEST
19382 read_8_bytes (bfd *abfd, const gdb_byte *buf)
19383 {
19384   return bfd_get_64 (abfd, buf);
19385 }
19386
19387 static CORE_ADDR
19388 read_address (bfd *abfd, const gdb_byte *buf, struct dwarf2_cu *cu,
19389               unsigned int *bytes_read)
19390 {
19391   struct comp_unit_head *cu_header = &cu->header;
19392   CORE_ADDR retval = 0;
19393
19394   if (cu_header->signed_addr_p)
19395     {
19396       switch (cu_header->addr_size)
19397         {
19398         case 2:
19399           retval = bfd_get_signed_16 (abfd, buf);
19400           break;
19401         case 4:
19402           retval = bfd_get_signed_32 (abfd, buf);
19403           break;
19404         case 8:
19405           retval = bfd_get_signed_64 (abfd, buf);
19406           break;
19407         default:
19408           internal_error (__FILE__, __LINE__,
19409                           _("read_address: bad switch, signed [in module %s]"),
19410                           bfd_get_filename (abfd));
19411         }
19412     }
19413   else
19414     {
19415       switch (cu_header->addr_size)
19416         {
19417         case 2:
19418           retval = bfd_get_16 (abfd, buf);
19419           break;
19420         case 4:
19421           retval = bfd_get_32 (abfd, buf);
19422           break;
19423         case 8:
19424           retval = bfd_get_64 (abfd, buf);
19425           break;
19426         default:
19427           internal_error (__FILE__, __LINE__,
19428                           _("read_address: bad switch, "
19429                             "unsigned [in module %s]"),
19430                           bfd_get_filename (abfd));
19431         }
19432     }
19433
19434   *bytes_read = cu_header->addr_size;
19435   return retval;
19436 }
19437
19438 /* Read the initial length from a section.  The (draft) DWARF 3
19439    specification allows the initial length to take up either 4 bytes
19440    or 12 bytes.  If the first 4 bytes are 0xffffffff, then the next 8
19441    bytes describe the length and all offsets will be 8 bytes in length
19442    instead of 4.
19443
19444    An older, non-standard 64-bit format is also handled by this
19445    function.  The older format in question stores the initial length
19446    as an 8-byte quantity without an escape value.  Lengths greater
19447    than 2^32 aren't very common which means that the initial 4 bytes
19448    is almost always zero.  Since a length value of zero doesn't make
19449    sense for the 32-bit format, this initial zero can be considered to
19450    be an escape value which indicates the presence of the older 64-bit
19451    format.  As written, the code can't detect (old format) lengths
19452    greater than 4GB.  If it becomes necessary to handle lengths
19453    somewhat larger than 4GB, we could allow other small values (such
19454    as the non-sensical values of 1, 2, and 3) to also be used as
19455    escape values indicating the presence of the old format.
19456
19457    The value returned via bytes_read should be used to increment the
19458    relevant pointer after calling read_initial_length().
19459
19460    [ Note:  read_initial_length() and read_offset() are based on the
19461      document entitled "DWARF Debugging Information Format", revision
19462      3, draft 8, dated November 19, 2001.  This document was obtained
19463      from:
19464
19465         http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
19466
19467      This document is only a draft and is subject to change.  (So beware.)
19468
19469      Details regarding the older, non-standard 64-bit format were
19470      determined empirically by examining 64-bit ELF files produced by
19471      the SGI toolchain on an IRIX 6.5 machine.
19472
19473      - Kevin, July 16, 2002
19474    ] */
19475
19476 static LONGEST
19477 read_initial_length (bfd *abfd, const gdb_byte *buf, unsigned int *bytes_read)
19478 {
19479   LONGEST length = bfd_get_32 (abfd, buf);
19480
19481   if (length == 0xffffffff)
19482     {
19483       length = bfd_get_64 (abfd, buf + 4);
19484       *bytes_read = 12;
19485     }
19486   else if (length == 0)
19487     {
19488       /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX.  */
19489       length = bfd_get_64 (abfd, buf);
19490       *bytes_read = 8;
19491     }
19492   else
19493     {
19494       *bytes_read = 4;
19495     }
19496
19497   return length;
19498 }
19499
19500 /* Cover function for read_initial_length.
19501    Returns the length of the object at BUF, and stores the size of the
19502    initial length in *BYTES_READ and stores the size that offsets will be in
19503    *OFFSET_SIZE.
19504    If the initial length size is not equivalent to that specified in
19505    CU_HEADER then issue a complaint.
19506    This is useful when reading non-comp-unit headers.  */
19507
19508 static LONGEST
19509 read_checked_initial_length_and_offset (bfd *abfd, const gdb_byte *buf,
19510                                         const struct comp_unit_head *cu_header,
19511                                         unsigned int *bytes_read,
19512                                         unsigned int *offset_size)
19513 {
19514   LONGEST length = read_initial_length (abfd, buf, bytes_read);
19515
19516   gdb_assert (cu_header->initial_length_size == 4
19517               || cu_header->initial_length_size == 8
19518               || cu_header->initial_length_size == 12);
19519
19520   if (cu_header->initial_length_size != *bytes_read)
19521     complaint (_("intermixed 32-bit and 64-bit DWARF sections"));
19522
19523   *offset_size = (*bytes_read == 4) ? 4 : 8;
19524   return length;
19525 }
19526
19527 /* Read an offset from the data stream.  The size of the offset is
19528    given by cu_header->offset_size.  */
19529
19530 static LONGEST
19531 read_offset (bfd *abfd, const gdb_byte *buf,
19532              const struct comp_unit_head *cu_header,
19533              unsigned int *bytes_read)
19534 {
19535   LONGEST offset = read_offset_1 (abfd, buf, cu_header->offset_size);
19536
19537   *bytes_read = cu_header->offset_size;
19538   return offset;
19539 }
19540
19541 /* Read an offset from the data stream.  */
19542
19543 static LONGEST
19544 read_offset_1 (bfd *abfd, const gdb_byte *buf, unsigned int offset_size)
19545 {
19546   LONGEST retval = 0;
19547
19548   switch (offset_size)
19549     {
19550     case 4:
19551       retval = bfd_get_32 (abfd, buf);
19552       break;
19553     case 8:
19554       retval = bfd_get_64 (abfd, buf);
19555       break;
19556     default:
19557       internal_error (__FILE__, __LINE__,
19558                       _("read_offset_1: bad switch [in module %s]"),
19559                       bfd_get_filename (abfd));
19560     }
19561
19562   return retval;
19563 }
19564
19565 static const gdb_byte *
19566 read_n_bytes (bfd *abfd, const gdb_byte *buf, unsigned int size)
19567 {
19568   /* If the size of a host char is 8 bits, we can return a pointer
19569      to the buffer, otherwise we have to copy the data to a buffer
19570      allocated on the temporary obstack.  */
19571   gdb_assert (HOST_CHAR_BIT == 8);
19572   return buf;
19573 }
19574
19575 static const char *
19576 read_direct_string (bfd *abfd, const gdb_byte *buf,
19577                     unsigned int *bytes_read_ptr)
19578 {
19579   /* If the size of a host char is 8 bits, we can return a pointer
19580      to the string, otherwise we have to copy the string to a buffer
19581      allocated on the temporary obstack.  */
19582   gdb_assert (HOST_CHAR_BIT == 8);
19583   if (*buf == '\0')
19584     {
19585       *bytes_read_ptr = 1;
19586       return NULL;
19587     }
19588   *bytes_read_ptr = strlen ((const char *) buf) + 1;
19589   return (const char *) buf;
19590 }
19591
19592 /* Return pointer to string at section SECT offset STR_OFFSET with error
19593    reporting strings FORM_NAME and SECT_NAME.  */
19594
19595 static const char *
19596 read_indirect_string_at_offset_from (struct objfile *objfile,
19597                                      bfd *abfd, LONGEST str_offset,
19598                                      struct dwarf2_section_info *sect,
19599                                      const char *form_name,
19600                                      const char *sect_name)
19601 {
19602   dwarf2_read_section (objfile, sect);
19603   if (sect->buffer == NULL)
19604     error (_("%s used without %s section [in module %s]"),
19605            form_name, sect_name, bfd_get_filename (abfd));
19606   if (str_offset >= sect->size)
19607     error (_("%s pointing outside of %s section [in module %s]"),
19608            form_name, sect_name, bfd_get_filename (abfd));
19609   gdb_assert (HOST_CHAR_BIT == 8);
19610   if (sect->buffer[str_offset] == '\0')
19611     return NULL;
19612   return (const char *) (sect->buffer + str_offset);
19613 }
19614
19615 /* Return pointer to string at .debug_str offset STR_OFFSET.  */
19616
19617 static const char *
19618 read_indirect_string_at_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
19619                                 bfd *abfd, LONGEST str_offset)
19620 {
19621   return read_indirect_string_at_offset_from (dwarf2_per_objfile->objfile,
19622                                               abfd, str_offset,
19623                                               &dwarf2_per_objfile->str,
19624                                               "DW_FORM_strp", ".debug_str");
19625 }
19626
19627 /* Return pointer to string at .debug_line_str offset STR_OFFSET.  */
19628
19629 static const char *
19630 read_indirect_line_string_at_offset (struct dwarf2_per_objfile *dwarf2_per_objfile,
19631                                      bfd *abfd, LONGEST str_offset)
19632 {
19633   return read_indirect_string_at_offset_from (dwarf2_per_objfile->objfile,
19634                                               abfd, str_offset,
19635                                               &dwarf2_per_objfile->line_str,
19636                                               "DW_FORM_line_strp",
19637                                               ".debug_line_str");
19638 }
19639
19640 /* Read a string at offset STR_OFFSET in the .debug_str section from
19641    the .dwz file DWZ.  Throw an error if the offset is too large.  If
19642    the string consists of a single NUL byte, return NULL; otherwise
19643    return a pointer to the string.  */
19644
19645 static const char *
19646 read_indirect_string_from_dwz (struct objfile *objfile, struct dwz_file *dwz,
19647                                LONGEST str_offset)
19648 {
19649   dwarf2_read_section (objfile, &dwz->str);
19650
19651   if (dwz->str.buffer == NULL)
19652     error (_("DW_FORM_GNU_strp_alt used without .debug_str "
19653              "section [in module %s]"),
19654            bfd_get_filename (dwz->dwz_bfd));
19655   if (str_offset >= dwz->str.size)
19656     error (_("DW_FORM_GNU_strp_alt pointing outside of "
19657              ".debug_str section [in module %s]"),
19658            bfd_get_filename (dwz->dwz_bfd));
19659   gdb_assert (HOST_CHAR_BIT == 8);
19660   if (dwz->str.buffer[str_offset] == '\0')
19661     return NULL;
19662   return (const char *) (dwz->str.buffer + str_offset);
19663 }
19664
19665 /* Return pointer to string at .debug_str offset as read from BUF.
19666    BUF is assumed to be in a compilation unit described by CU_HEADER.
19667    Return *BYTES_READ_PTR count of bytes read from BUF.  */
19668
19669 static const char *
19670 read_indirect_string (struct dwarf2_per_objfile *dwarf2_per_objfile, bfd *abfd,
19671                       const gdb_byte *buf,
19672                       const struct comp_unit_head *cu_header,
19673                       unsigned int *bytes_read_ptr)
19674 {
19675   LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
19676
19677   return read_indirect_string_at_offset (dwarf2_per_objfile, abfd, str_offset);
19678 }
19679
19680 /* Return pointer to string at .debug_line_str offset as read from BUF.
19681    BUF is assumed to be in a compilation unit described by CU_HEADER.
19682    Return *BYTES_READ_PTR count of bytes read from BUF.  */
19683
19684 static const char *
19685 read_indirect_line_string (struct dwarf2_per_objfile *dwarf2_per_objfile,
19686                            bfd *abfd, const gdb_byte *buf,
19687                            const struct comp_unit_head *cu_header,
19688                            unsigned int *bytes_read_ptr)
19689 {
19690   LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
19691
19692   return read_indirect_line_string_at_offset (dwarf2_per_objfile, abfd,
19693                                               str_offset);
19694 }
19695
19696 ULONGEST
19697 read_unsigned_leb128 (bfd *abfd, const gdb_byte *buf,
19698                           unsigned int *bytes_read_ptr)
19699 {
19700   ULONGEST result;
19701   unsigned int num_read;
19702   int shift;
19703   unsigned char byte;
19704
19705   result = 0;
19706   shift = 0;
19707   num_read = 0;
19708   while (1)
19709     {
19710       byte = bfd_get_8 (abfd, buf);
19711       buf++;
19712       num_read++;
19713       result |= ((ULONGEST) (byte & 127) << shift);
19714       if ((byte & 128) == 0)
19715         {
19716           break;
19717         }
19718       shift += 7;
19719     }
19720   *bytes_read_ptr = num_read;
19721   return result;
19722 }
19723
19724 static LONGEST
19725 read_signed_leb128 (bfd *abfd, const gdb_byte *buf,
19726                     unsigned int *bytes_read_ptr)
19727 {
19728   ULONGEST result;
19729   int shift, num_read;
19730   unsigned char byte;
19731
19732   result = 0;
19733   shift = 0;
19734   num_read = 0;
19735   while (1)
19736     {
19737       byte = bfd_get_8 (abfd, buf);
19738       buf++;
19739       num_read++;
19740       result |= ((ULONGEST) (byte & 127) << shift);
19741       shift += 7;
19742       if ((byte & 128) == 0)
19743         {
19744           break;
19745         }
19746     }
19747   if ((shift < 8 * sizeof (result)) && (byte & 0x40))
19748     result |= -(((ULONGEST) 1) << shift);
19749   *bytes_read_ptr = num_read;
19750   return result;
19751 }
19752
19753 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
19754    ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
19755    ADDR_SIZE is the size of addresses from the CU header.  */
19756
19757 static CORE_ADDR
19758 read_addr_index_1 (struct dwarf2_per_objfile *dwarf2_per_objfile,
19759                    unsigned int addr_index, ULONGEST addr_base, int addr_size)
19760 {
19761   struct objfile *objfile = dwarf2_per_objfile->objfile;
19762   bfd *abfd = objfile->obfd;
19763   const gdb_byte *info_ptr;
19764
19765   dwarf2_read_section (objfile, &dwarf2_per_objfile->addr);
19766   if (dwarf2_per_objfile->addr.buffer == NULL)
19767     error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
19768            objfile_name (objfile));
19769   if (addr_base + addr_index * addr_size >= dwarf2_per_objfile->addr.size)
19770     error (_("DW_FORM_addr_index pointing outside of "
19771              ".debug_addr section [in module %s]"),
19772            objfile_name (objfile));
19773   info_ptr = (dwarf2_per_objfile->addr.buffer
19774               + addr_base + addr_index * addr_size);
19775   if (addr_size == 4)
19776     return bfd_get_32 (abfd, info_ptr);
19777   else
19778     return bfd_get_64 (abfd, info_ptr);
19779 }
19780
19781 /* Given index ADDR_INDEX in .debug_addr, fetch the value.  */
19782
19783 static CORE_ADDR
19784 read_addr_index (struct dwarf2_cu *cu, unsigned int addr_index)
19785 {
19786   return read_addr_index_1 (cu->per_cu->dwarf2_per_objfile, addr_index,
19787                             cu->addr_base, cu->header.addr_size);
19788 }
19789
19790 /* Given a pointer to an leb128 value, fetch the value from .debug_addr.  */
19791
19792 static CORE_ADDR
19793 read_addr_index_from_leb128 (struct dwarf2_cu *cu, const gdb_byte *info_ptr,
19794                              unsigned int *bytes_read)
19795 {
19796   bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
19797   unsigned int addr_index = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
19798
19799   return read_addr_index (cu, addr_index);
19800 }
19801
19802 /* Data structure to pass results from dwarf2_read_addr_index_reader
19803    back to dwarf2_read_addr_index.  */
19804
19805 struct dwarf2_read_addr_index_data
19806 {
19807   ULONGEST addr_base;
19808   int addr_size;
19809 };
19810
19811 /* die_reader_func for dwarf2_read_addr_index.  */
19812
19813 static void
19814 dwarf2_read_addr_index_reader (const struct die_reader_specs *reader,
19815                                const gdb_byte *info_ptr,
19816                                struct die_info *comp_unit_die,
19817                                int has_children,
19818                                void *data)
19819 {
19820   struct dwarf2_cu *cu = reader->cu;
19821   struct dwarf2_read_addr_index_data *aidata =
19822     (struct dwarf2_read_addr_index_data *) data;
19823
19824   aidata->addr_base = cu->addr_base;
19825   aidata->addr_size = cu->header.addr_size;
19826 }
19827
19828 /* Given an index in .debug_addr, fetch the value.
19829    NOTE: This can be called during dwarf expression evaluation,
19830    long after the debug information has been read, and thus per_cu->cu
19831    may no longer exist.  */
19832
19833 CORE_ADDR
19834 dwarf2_read_addr_index (struct dwarf2_per_cu_data *per_cu,
19835                         unsigned int addr_index)
19836 {
19837   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
19838   struct dwarf2_cu *cu = per_cu->cu;
19839   ULONGEST addr_base;
19840   int addr_size;
19841
19842   /* We need addr_base and addr_size.
19843      If we don't have PER_CU->cu, we have to get it.
19844      Nasty, but the alternative is storing the needed info in PER_CU,
19845      which at this point doesn't seem justified: it's not clear how frequently
19846      it would get used and it would increase the size of every PER_CU.
19847      Entry points like dwarf2_per_cu_addr_size do a similar thing
19848      so we're not in uncharted territory here.
19849      Alas we need to be a bit more complicated as addr_base is contained
19850      in the DIE.
19851
19852      We don't need to read the entire CU(/TU).
19853      We just need the header and top level die.
19854
19855      IWBN to use the aging mechanism to let us lazily later discard the CU.
19856      For now we skip this optimization.  */
19857
19858   if (cu != NULL)
19859     {
19860       addr_base = cu->addr_base;
19861       addr_size = cu->header.addr_size;
19862     }
19863   else
19864     {
19865       struct dwarf2_read_addr_index_data aidata;
19866
19867       /* Note: We can't use init_cutu_and_read_dies_simple here,
19868          we need addr_base.  */
19869       init_cutu_and_read_dies (per_cu, NULL, 0, 0, false,
19870                                dwarf2_read_addr_index_reader, &aidata);
19871       addr_base = aidata.addr_base;
19872       addr_size = aidata.addr_size;
19873     }
19874
19875   return read_addr_index_1 (dwarf2_per_objfile, addr_index, addr_base,
19876                             addr_size);
19877 }
19878
19879 /* Given a DW_FORM_GNU_str_index, fetch the string.
19880    This is only used by the Fission support.  */
19881
19882 static const char *
19883 read_str_index (const struct die_reader_specs *reader, ULONGEST str_index)
19884 {
19885   struct dwarf2_cu *cu = reader->cu;
19886   struct dwarf2_per_objfile *dwarf2_per_objfile
19887     = cu->per_cu->dwarf2_per_objfile;
19888   struct objfile *objfile = dwarf2_per_objfile->objfile;
19889   const char *objf_name = objfile_name (objfile);
19890   bfd *abfd = objfile->obfd;
19891   struct dwarf2_section_info *str_section = &reader->dwo_file->sections.str;
19892   struct dwarf2_section_info *str_offsets_section =
19893     &reader->dwo_file->sections.str_offsets;
19894   const gdb_byte *info_ptr;
19895   ULONGEST str_offset;
19896   static const char form_name[] = "DW_FORM_GNU_str_index";
19897
19898   dwarf2_read_section (objfile, str_section);
19899   dwarf2_read_section (objfile, str_offsets_section);
19900   if (str_section->buffer == NULL)
19901     error (_("%s used without .debug_str.dwo section"
19902              " in CU at offset %s [in module %s]"),
19903            form_name, sect_offset_str (cu->header.sect_off), objf_name);
19904   if (str_offsets_section->buffer == NULL)
19905     error (_("%s used without .debug_str_offsets.dwo section"
19906              " in CU at offset %s [in module %s]"),
19907            form_name, sect_offset_str (cu->header.sect_off), objf_name);
19908   if (str_index * cu->header.offset_size >= str_offsets_section->size)
19909     error (_("%s pointing outside of .debug_str_offsets.dwo"
19910              " section in CU at offset %s [in module %s]"),
19911            form_name, sect_offset_str (cu->header.sect_off), objf_name);
19912   info_ptr = (str_offsets_section->buffer
19913               + str_index * cu->header.offset_size);
19914   if (cu->header.offset_size == 4)
19915     str_offset = bfd_get_32 (abfd, info_ptr);
19916   else
19917     str_offset = bfd_get_64 (abfd, info_ptr);
19918   if (str_offset >= str_section->size)
19919     error (_("Offset from %s pointing outside of"
19920              " .debug_str.dwo section in CU at offset %s [in module %s]"),
19921            form_name, sect_offset_str (cu->header.sect_off), objf_name);
19922   return (const char *) (str_section->buffer + str_offset);
19923 }
19924
19925 /* Return the length of an LEB128 number in BUF.  */
19926
19927 static int
19928 leb128_size (const gdb_byte *buf)
19929 {
19930   const gdb_byte *begin = buf;
19931   gdb_byte byte;
19932
19933   while (1)
19934     {
19935       byte = *buf++;
19936       if ((byte & 128) == 0)
19937         return buf - begin;
19938     }
19939 }
19940
19941 static void
19942 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
19943 {
19944   switch (lang)
19945     {
19946     case DW_LANG_C89:
19947     case DW_LANG_C99:
19948     case DW_LANG_C11:
19949     case DW_LANG_C:
19950     case DW_LANG_UPC:
19951       cu->language = language_c;
19952       break;
19953     case DW_LANG_Java:
19954     case DW_LANG_C_plus_plus:
19955     case DW_LANG_C_plus_plus_11:
19956     case DW_LANG_C_plus_plus_14:
19957       cu->language = language_cplus;
19958       break;
19959     case DW_LANG_D:
19960       cu->language = language_d;
19961       break;
19962     case DW_LANG_Fortran77:
19963     case DW_LANG_Fortran90:
19964     case DW_LANG_Fortran95:
19965     case DW_LANG_Fortran03:
19966     case DW_LANG_Fortran08:
19967       cu->language = language_fortran;
19968       break;
19969     case DW_LANG_Go:
19970       cu->language = language_go;
19971       break;
19972     case DW_LANG_Mips_Assembler:
19973       cu->language = language_asm;
19974       break;
19975     case DW_LANG_Ada83:
19976     case DW_LANG_Ada95:
19977       cu->language = language_ada;
19978       break;
19979     case DW_LANG_Modula2:
19980       cu->language = language_m2;
19981       break;
19982     case DW_LANG_Pascal83:
19983       cu->language = language_pascal;
19984       break;
19985     case DW_LANG_ObjC:
19986       cu->language = language_objc;
19987       break;
19988     case DW_LANG_Rust:
19989     case DW_LANG_Rust_old:
19990       cu->language = language_rust;
19991       break;
19992     case DW_LANG_Cobol74:
19993     case DW_LANG_Cobol85:
19994     default:
19995       cu->language = language_minimal;
19996       break;
19997     }
19998   cu->language_defn = language_def (cu->language);
19999 }
20000
20001 /* Return the named attribute or NULL if not there.  */
20002
20003 static struct attribute *
20004 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
20005 {
20006   for (;;)
20007     {
20008       unsigned int i;
20009       struct attribute *spec = NULL;
20010
20011       for (i = 0; i < die->num_attrs; ++i)
20012         {
20013           if (die->attrs[i].name == name)
20014             return &die->attrs[i];
20015           if (die->attrs[i].name == DW_AT_specification
20016               || die->attrs[i].name == DW_AT_abstract_origin)
20017             spec = &die->attrs[i];
20018         }
20019
20020       if (!spec)
20021         break;
20022
20023       die = follow_die_ref (die, spec, &cu);
20024     }
20025
20026   return NULL;
20027 }
20028
20029 /* Return the named attribute or NULL if not there,
20030    but do not follow DW_AT_specification, etc.
20031    This is for use in contexts where we're reading .debug_types dies.
20032    Following DW_AT_specification, DW_AT_abstract_origin will take us
20033    back up the chain, and we want to go down.  */
20034
20035 static struct attribute *
20036 dwarf2_attr_no_follow (struct die_info *die, unsigned int name)
20037 {
20038   unsigned int i;
20039
20040   for (i = 0; i < die->num_attrs; ++i)
20041     if (die->attrs[i].name == name)
20042       return &die->attrs[i];
20043
20044   return NULL;
20045 }
20046
20047 /* Return the string associated with a string-typed attribute, or NULL if it
20048    is either not found or is of an incorrect type.  */
20049
20050 static const char *
20051 dwarf2_string_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
20052 {
20053   struct attribute *attr;
20054   const char *str = NULL;
20055
20056   attr = dwarf2_attr (die, name, cu);
20057
20058   if (attr != NULL)
20059     {
20060       if (attr->form == DW_FORM_strp || attr->form == DW_FORM_line_strp
20061           || attr->form == DW_FORM_string
20062           || attr->form == DW_FORM_GNU_str_index
20063           || attr->form == DW_FORM_GNU_strp_alt)
20064         str = DW_STRING (attr);
20065       else
20066         complaint (_("string type expected for attribute %s for "
20067                      "DIE at %s in module %s"),
20068                    dwarf_attr_name (name), sect_offset_str (die->sect_off),
20069                    objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
20070     }
20071
20072   return str;
20073 }
20074
20075 /* Return non-zero iff the attribute NAME is defined for the given DIE,
20076    and holds a non-zero value.  This function should only be used for
20077    DW_FORM_flag or DW_FORM_flag_present attributes.  */
20078
20079 static int
20080 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
20081 {
20082   struct attribute *attr = dwarf2_attr (die, name, cu);
20083
20084   return (attr && DW_UNSND (attr));
20085 }
20086
20087 static int
20088 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
20089 {
20090   /* A DIE is a declaration if it has a DW_AT_declaration attribute
20091      which value is non-zero.  However, we have to be careful with
20092      DIEs having a DW_AT_specification attribute, because dwarf2_attr()
20093      (via dwarf2_flag_true_p) follows this attribute.  So we may
20094      end up accidently finding a declaration attribute that belongs
20095      to a different DIE referenced by the specification attribute,
20096      even though the given DIE does not have a declaration attribute.  */
20097   return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
20098           && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
20099 }
20100
20101 /* Return the die giving the specification for DIE, if there is
20102    one.  *SPEC_CU is the CU containing DIE on input, and the CU
20103    containing the return value on output.  If there is no
20104    specification, but there is an abstract origin, that is
20105    returned.  */
20106
20107 static struct die_info *
20108 die_specification (struct die_info *die, struct dwarf2_cu **spec_cu)
20109 {
20110   struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification,
20111                                              *spec_cu);
20112
20113   if (spec_attr == NULL)
20114     spec_attr = dwarf2_attr (die, DW_AT_abstract_origin, *spec_cu);
20115
20116   if (spec_attr == NULL)
20117     return NULL;
20118   else
20119     return follow_die_ref (die, spec_attr, spec_cu);
20120 }
20121
20122 /* Stub for free_line_header to match void * callback types.  */
20123
20124 static void
20125 free_line_header_voidp (void *arg)
20126 {
20127   struct line_header *lh = (struct line_header *) arg;
20128
20129   delete lh;
20130 }
20131
20132 void
20133 line_header::add_include_dir (const char *include_dir)
20134 {
20135   if (dwarf_line_debug >= 2)
20136     fprintf_unfiltered (gdb_stdlog, "Adding dir %zu: %s\n",
20137                         include_dirs.size () + 1, include_dir);
20138
20139   include_dirs.push_back (include_dir);
20140 }
20141
20142 void
20143 line_header::add_file_name (const char *name,
20144                             dir_index d_index,
20145                             unsigned int mod_time,
20146                             unsigned int length)
20147 {
20148   if (dwarf_line_debug >= 2)
20149     fprintf_unfiltered (gdb_stdlog, "Adding file %u: %s\n",
20150                         (unsigned) file_names.size () + 1, name);
20151
20152   file_names.emplace_back (name, d_index, mod_time, length);
20153 }
20154
20155 /* A convenience function to find the proper .debug_line section for a CU.  */
20156
20157 static struct dwarf2_section_info *
20158 get_debug_line_section (struct dwarf2_cu *cu)
20159 {
20160   struct dwarf2_section_info *section;
20161   struct dwarf2_per_objfile *dwarf2_per_objfile
20162     = cu->per_cu->dwarf2_per_objfile;
20163
20164   /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
20165      DWO file.  */
20166   if (cu->dwo_unit && cu->per_cu->is_debug_types)
20167     section = &cu->dwo_unit->dwo_file->sections.line;
20168   else if (cu->per_cu->is_dwz)
20169     {
20170       struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
20171
20172       section = &dwz->line;
20173     }
20174   else
20175     section = &dwarf2_per_objfile->line;
20176
20177   return section;
20178 }
20179
20180 /* Read directory or file name entry format, starting with byte of
20181    format count entries, ULEB128 pairs of entry formats, ULEB128 of
20182    entries count and the entries themselves in the described entry
20183    format.  */
20184
20185 static void
20186 read_formatted_entries (struct dwarf2_per_objfile *dwarf2_per_objfile,
20187                         bfd *abfd, const gdb_byte **bufp,
20188                         struct line_header *lh,
20189                         const struct comp_unit_head *cu_header,
20190                         void (*callback) (struct line_header *lh,
20191                                           const char *name,
20192                                           dir_index d_index,
20193                                           unsigned int mod_time,
20194                                           unsigned int length))
20195 {
20196   gdb_byte format_count, formati;
20197   ULONGEST data_count, datai;
20198   const gdb_byte *buf = *bufp;
20199   const gdb_byte *format_header_data;
20200   unsigned int bytes_read;
20201
20202   format_count = read_1_byte (abfd, buf);
20203   buf += 1;
20204   format_header_data = buf;
20205   for (formati = 0; formati < format_count; formati++)
20206     {
20207       read_unsigned_leb128 (abfd, buf, &bytes_read);
20208       buf += bytes_read;
20209       read_unsigned_leb128 (abfd, buf, &bytes_read);
20210       buf += bytes_read;
20211     }
20212
20213   data_count = read_unsigned_leb128 (abfd, buf, &bytes_read);
20214   buf += bytes_read;
20215   for (datai = 0; datai < data_count; datai++)
20216     {
20217       const gdb_byte *format = format_header_data;
20218       struct file_entry fe;
20219
20220       for (formati = 0; formati < format_count; formati++)
20221         {
20222           ULONGEST content_type = read_unsigned_leb128 (abfd, format, &bytes_read);
20223           format += bytes_read;
20224
20225           ULONGEST form  = read_unsigned_leb128 (abfd, format, &bytes_read);
20226           format += bytes_read;
20227
20228           gdb::optional<const char *> string;
20229           gdb::optional<unsigned int> uint;
20230
20231           switch (form)
20232             {
20233             case DW_FORM_string:
20234               string.emplace (read_direct_string (abfd, buf, &bytes_read));
20235               buf += bytes_read;
20236               break;
20237
20238             case DW_FORM_line_strp:
20239               string.emplace (read_indirect_line_string (dwarf2_per_objfile,
20240                                                          abfd, buf,
20241                                                          cu_header,
20242                                                          &bytes_read));
20243               buf += bytes_read;
20244               break;
20245
20246             case DW_FORM_data1:
20247               uint.emplace (read_1_byte (abfd, buf));
20248               buf += 1;
20249               break;
20250
20251             case DW_FORM_data2:
20252               uint.emplace (read_2_bytes (abfd, buf));
20253               buf += 2;
20254               break;
20255
20256             case DW_FORM_data4:
20257               uint.emplace (read_4_bytes (abfd, buf));
20258               buf += 4;
20259               break;
20260
20261             case DW_FORM_data8:
20262               uint.emplace (read_8_bytes (abfd, buf));
20263               buf += 8;
20264               break;
20265
20266             case DW_FORM_udata:
20267               uint.emplace (read_unsigned_leb128 (abfd, buf, &bytes_read));
20268               buf += bytes_read;
20269               break;
20270
20271             case DW_FORM_block:
20272               /* It is valid only for DW_LNCT_timestamp which is ignored by
20273                  current GDB.  */
20274               break;
20275             }
20276
20277           switch (content_type)
20278             {
20279             case DW_LNCT_path:
20280               if (string.has_value ())
20281                 fe.name = *string;
20282               break;
20283             case DW_LNCT_directory_index:
20284               if (uint.has_value ())
20285                 fe.d_index = (dir_index) *uint;
20286               break;
20287             case DW_LNCT_timestamp:
20288               if (uint.has_value ())
20289                 fe.mod_time = *uint;
20290               break;
20291             case DW_LNCT_size:
20292               if (uint.has_value ())
20293                 fe.length = *uint;
20294               break;
20295             case DW_LNCT_MD5:
20296               break;
20297             default:
20298               complaint (_("Unknown format content type %s"),
20299                          pulongest (content_type));
20300             }
20301         }
20302
20303       callback (lh, fe.name, fe.d_index, fe.mod_time, fe.length);
20304     }
20305
20306   *bufp = buf;
20307 }
20308
20309 /* Read the statement program header starting at OFFSET in
20310    .debug_line, or .debug_line.dwo.  Return a pointer
20311    to a struct line_header, allocated using xmalloc.
20312    Returns NULL if there is a problem reading the header, e.g., if it
20313    has a version we don't understand.
20314
20315    NOTE: the strings in the include directory and file name tables of
20316    the returned object point into the dwarf line section buffer,
20317    and must not be freed.  */
20318
20319 static line_header_up
20320 dwarf_decode_line_header (sect_offset sect_off, struct dwarf2_cu *cu)
20321 {
20322   const gdb_byte *line_ptr;
20323   unsigned int bytes_read, offset_size;
20324   int i;
20325   const char *cur_dir, *cur_file;
20326   struct dwarf2_section_info *section;
20327   bfd *abfd;
20328   struct dwarf2_per_objfile *dwarf2_per_objfile
20329     = cu->per_cu->dwarf2_per_objfile;
20330
20331   section = get_debug_line_section (cu);
20332   dwarf2_read_section (dwarf2_per_objfile->objfile, section);
20333   if (section->buffer == NULL)
20334     {
20335       if (cu->dwo_unit && cu->per_cu->is_debug_types)
20336         complaint (_("missing .debug_line.dwo section"));
20337       else
20338         complaint (_("missing .debug_line section"));
20339       return 0;
20340     }
20341
20342   /* We can't do this until we know the section is non-empty.
20343      Only then do we know we have such a section.  */
20344   abfd = get_section_bfd_owner (section);
20345
20346   /* Make sure that at least there's room for the total_length field.
20347      That could be 12 bytes long, but we're just going to fudge that.  */
20348   if (to_underlying (sect_off) + 4 >= section->size)
20349     {
20350       dwarf2_statement_list_fits_in_line_number_section_complaint ();
20351       return 0;
20352     }
20353
20354   line_header_up lh (new line_header ());
20355
20356   lh->sect_off = sect_off;
20357   lh->offset_in_dwz = cu->per_cu->is_dwz;
20358
20359   line_ptr = section->buffer + to_underlying (sect_off);
20360
20361   /* Read in the header.  */
20362   lh->total_length =
20363     read_checked_initial_length_and_offset (abfd, line_ptr, &cu->header,
20364                                             &bytes_read, &offset_size);
20365   line_ptr += bytes_read;
20366   if (line_ptr + lh->total_length > (section->buffer + section->size))
20367     {
20368       dwarf2_statement_list_fits_in_line_number_section_complaint ();
20369       return 0;
20370     }
20371   lh->statement_program_end = line_ptr + lh->total_length;
20372   lh->version = read_2_bytes (abfd, line_ptr);
20373   line_ptr += 2;
20374   if (lh->version > 5)
20375     {
20376       /* This is a version we don't understand.  The format could have
20377          changed in ways we don't handle properly so just punt.  */
20378       complaint (_("unsupported version in .debug_line section"));
20379       return NULL;
20380     }
20381   if (lh->version >= 5)
20382     {
20383       gdb_byte segment_selector_size;
20384
20385       /* Skip address size.  */
20386       read_1_byte (abfd, line_ptr);
20387       line_ptr += 1;
20388
20389       segment_selector_size = read_1_byte (abfd, line_ptr);
20390       line_ptr += 1;
20391       if (segment_selector_size != 0)
20392         {
20393           complaint (_("unsupported segment selector size %u "
20394                        "in .debug_line section"),
20395                      segment_selector_size);
20396           return NULL;
20397         }
20398     }
20399   lh->header_length = read_offset_1 (abfd, line_ptr, offset_size);
20400   line_ptr += offset_size;
20401   lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
20402   line_ptr += 1;
20403   if (lh->version >= 4)
20404     {
20405       lh->maximum_ops_per_instruction = read_1_byte (abfd, line_ptr);
20406       line_ptr += 1;
20407     }
20408   else
20409     lh->maximum_ops_per_instruction = 1;
20410
20411   if (lh->maximum_ops_per_instruction == 0)
20412     {
20413       lh->maximum_ops_per_instruction = 1;
20414       complaint (_("invalid maximum_ops_per_instruction "
20415                    "in `.debug_line' section"));
20416     }
20417
20418   lh->default_is_stmt = read_1_byte (abfd, line_ptr);
20419   line_ptr += 1;
20420   lh->line_base = read_1_signed_byte (abfd, line_ptr);
20421   line_ptr += 1;
20422   lh->line_range = read_1_byte (abfd, line_ptr);
20423   line_ptr += 1;
20424   lh->opcode_base = read_1_byte (abfd, line_ptr);
20425   line_ptr += 1;
20426   lh->standard_opcode_lengths.reset (new unsigned char[lh->opcode_base]);
20427
20428   lh->standard_opcode_lengths[0] = 1;  /* This should never be used anyway.  */
20429   for (i = 1; i < lh->opcode_base; ++i)
20430     {
20431       lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
20432       line_ptr += 1;
20433     }
20434
20435   if (lh->version >= 5)
20436     {
20437       /* Read directory table.  */
20438       read_formatted_entries (dwarf2_per_objfile, abfd, &line_ptr, lh.get (),
20439                               &cu->header,
20440                               [] (struct line_header *header, const char *name,
20441                                   dir_index d_index, unsigned int mod_time,
20442                                   unsigned int length)
20443         {
20444           header->add_include_dir (name);
20445         });
20446
20447       /* Read file name table.  */
20448       read_formatted_entries (dwarf2_per_objfile, abfd, &line_ptr, lh.get (),
20449                               &cu->header,
20450                               [] (struct line_header *header, const char *name,
20451                                   dir_index d_index, unsigned int mod_time,
20452                                   unsigned int length)
20453         {
20454           header->add_file_name (name, d_index, mod_time, length);
20455         });
20456     }
20457   else
20458     {
20459       /* Read directory table.  */
20460       while ((cur_dir = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
20461         {
20462           line_ptr += bytes_read;
20463           lh->add_include_dir (cur_dir);
20464         }
20465       line_ptr += bytes_read;
20466
20467       /* Read file name table.  */
20468       while ((cur_file = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
20469         {
20470           unsigned int mod_time, length;
20471           dir_index d_index;
20472
20473           line_ptr += bytes_read;
20474           d_index = (dir_index) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20475           line_ptr += bytes_read;
20476           mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20477           line_ptr += bytes_read;
20478           length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
20479           line_ptr += bytes_read;
20480
20481           lh->add_file_name (cur_file, d_index, mod_time, length);
20482         }
20483       line_ptr += bytes_read;
20484     }
20485   lh->statement_program_start = line_ptr;
20486
20487   if (line_ptr > (section->buffer + section->size))
20488     complaint (_("line number info header doesn't "
20489                  "fit in `.debug_line' section"));
20490
20491   return lh;
20492 }
20493
20494 /* Subroutine of dwarf_decode_lines to simplify it.
20495    Return the file name of the psymtab for included file FILE_INDEX
20496    in line header LH of PST.
20497    COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
20498    If space for the result is malloc'd, *NAME_HOLDER will be set.
20499    Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename.  */
20500
20501 static const char *
20502 psymtab_include_file_name (const struct line_header *lh, int file_index,
20503                            const struct partial_symtab *pst,
20504                            const char *comp_dir,
20505                            gdb::unique_xmalloc_ptr<char> *name_holder)
20506 {
20507   const file_entry &fe = lh->file_names[file_index];
20508   const char *include_name = fe.name;
20509   const char *include_name_to_compare = include_name;
20510   const char *pst_filename;
20511   int file_is_pst;
20512
20513   const char *dir_name = fe.include_dir (lh);
20514
20515   gdb::unique_xmalloc_ptr<char> hold_compare;
20516   if (!IS_ABSOLUTE_PATH (include_name)
20517       && (dir_name != NULL || comp_dir != NULL))
20518     {
20519       /* Avoid creating a duplicate psymtab for PST.
20520          We do this by comparing INCLUDE_NAME and PST_FILENAME.
20521          Before we do the comparison, however, we need to account
20522          for DIR_NAME and COMP_DIR.
20523          First prepend dir_name (if non-NULL).  If we still don't
20524          have an absolute path prepend comp_dir (if non-NULL).
20525          However, the directory we record in the include-file's
20526          psymtab does not contain COMP_DIR (to match the
20527          corresponding symtab(s)).
20528
20529          Example:
20530
20531          bash$ cd /tmp
20532          bash$ gcc -g ./hello.c
20533          include_name = "hello.c"
20534          dir_name = "."
20535          DW_AT_comp_dir = comp_dir = "/tmp"
20536          DW_AT_name = "./hello.c"
20537
20538       */
20539
20540       if (dir_name != NULL)
20541         {
20542           name_holder->reset (concat (dir_name, SLASH_STRING,
20543                                       include_name, (char *) NULL));
20544           include_name = name_holder->get ();
20545           include_name_to_compare = include_name;
20546         }
20547       if (!IS_ABSOLUTE_PATH (include_name) && comp_dir != NULL)
20548         {
20549           hold_compare.reset (concat (comp_dir, SLASH_STRING,
20550                                       include_name, (char *) NULL));
20551           include_name_to_compare = hold_compare.get ();
20552         }
20553     }
20554
20555   pst_filename = pst->filename;
20556   gdb::unique_xmalloc_ptr<char> copied_name;
20557   if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
20558     {
20559       copied_name.reset (concat (pst->dirname, SLASH_STRING,
20560                                  pst_filename, (char *) NULL));
20561       pst_filename = copied_name.get ();
20562     }
20563
20564   file_is_pst = FILENAME_CMP (include_name_to_compare, pst_filename) == 0;
20565
20566   if (file_is_pst)
20567     return NULL;
20568   return include_name;
20569 }
20570
20571 /* State machine to track the state of the line number program.  */
20572
20573 class lnp_state_machine
20574 {
20575 public:
20576   /* Initialize a machine state for the start of a line number
20577      program.  */
20578   lnp_state_machine (struct dwarf2_cu *cu, gdbarch *arch, line_header *lh,
20579                      bool record_lines_p);
20580
20581   file_entry *current_file ()
20582   {
20583     /* lh->file_names is 0-based, but the file name numbers in the
20584        statement program are 1-based.  */
20585     return m_line_header->file_name_at (m_file);
20586   }
20587
20588   /* Record the line in the state machine.  END_SEQUENCE is true if
20589      we're processing the end of a sequence.  */
20590   void record_line (bool end_sequence);
20591
20592   /* Check ADDRESS is zero and less than UNRELOCATED_LOWPC and if true
20593      nop-out rest of the lines in this sequence.  */
20594   void check_line_address (struct dwarf2_cu *cu,
20595                            const gdb_byte *line_ptr,
20596                            CORE_ADDR unrelocated_lowpc, CORE_ADDR address);
20597
20598   void handle_set_discriminator (unsigned int discriminator)
20599   {
20600     m_discriminator = discriminator;
20601     m_line_has_non_zero_discriminator |= discriminator != 0;
20602   }
20603
20604   /* Handle DW_LNE_set_address.  */
20605   void handle_set_address (CORE_ADDR baseaddr, CORE_ADDR address)
20606   {
20607     m_op_index = 0;
20608     address += baseaddr;
20609     m_address = gdbarch_adjust_dwarf2_line (m_gdbarch, address, false);
20610   }
20611
20612   /* Handle DW_LNS_advance_pc.  */
20613   void handle_advance_pc (CORE_ADDR adjust);
20614
20615   /* Handle a special opcode.  */
20616   void handle_special_opcode (unsigned char op_code);
20617
20618   /* Handle DW_LNS_advance_line.  */
20619   void handle_advance_line (int line_delta)
20620   {
20621     advance_line (line_delta);
20622   }
20623
20624   /* Handle DW_LNS_set_file.  */
20625   void handle_set_file (file_name_index file);
20626
20627   /* Handle DW_LNS_negate_stmt.  */
20628   void handle_negate_stmt ()
20629   {
20630     m_is_stmt = !m_is_stmt;
20631   }
20632
20633   /* Handle DW_LNS_const_add_pc.  */
20634   void handle_const_add_pc ();
20635
20636   /* Handle DW_LNS_fixed_advance_pc.  */
20637   void handle_fixed_advance_pc (CORE_ADDR addr_adj)
20638   {
20639     m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20640     m_op_index = 0;
20641   }
20642
20643   /* Handle DW_LNS_copy.  */
20644   void handle_copy ()
20645   {
20646     record_line (false);
20647     m_discriminator = 0;
20648   }
20649
20650   /* Handle DW_LNE_end_sequence.  */
20651   void handle_end_sequence ()
20652   {
20653     m_currently_recording_lines = true;
20654   }
20655
20656 private:
20657   /* Advance the line by LINE_DELTA.  */
20658   void advance_line (int line_delta)
20659   {
20660     m_line += line_delta;
20661
20662     if (line_delta != 0)
20663       m_line_has_non_zero_discriminator = m_discriminator != 0;
20664   }
20665
20666   struct dwarf2_cu *m_cu;
20667
20668   gdbarch *m_gdbarch;
20669
20670   /* True if we're recording lines.
20671      Otherwise we're building partial symtabs and are just interested in
20672      finding include files mentioned by the line number program.  */
20673   bool m_record_lines_p;
20674
20675   /* The line number header.  */
20676   line_header *m_line_header;
20677
20678   /* These are part of the standard DWARF line number state machine,
20679      and initialized according to the DWARF spec.  */
20680
20681   unsigned char m_op_index = 0;
20682   /* The line table index (1-based) of the current file.  */
20683   file_name_index m_file = (file_name_index) 1;
20684   unsigned int m_line = 1;
20685
20686   /* These are initialized in the constructor.  */
20687
20688   CORE_ADDR m_address;
20689   bool m_is_stmt;
20690   unsigned int m_discriminator;
20691
20692   /* Additional bits of state we need to track.  */
20693
20694   /* The last file that we called dwarf2_start_subfile for.
20695      This is only used for TLLs.  */
20696   unsigned int m_last_file = 0;
20697   /* The last file a line number was recorded for.  */
20698   struct subfile *m_last_subfile = NULL;
20699
20700   /* When true, record the lines we decode.  */
20701   bool m_currently_recording_lines = false;
20702
20703   /* The last line number that was recorded, used to coalesce
20704      consecutive entries for the same line.  This can happen, for
20705      example, when discriminators are present.  PR 17276.  */
20706   unsigned int m_last_line = 0;
20707   bool m_line_has_non_zero_discriminator = false;
20708 };
20709
20710 void
20711 lnp_state_machine::handle_advance_pc (CORE_ADDR adjust)
20712 {
20713   CORE_ADDR addr_adj = (((m_op_index + adjust)
20714                          / m_line_header->maximum_ops_per_instruction)
20715                         * m_line_header->minimum_instruction_length);
20716   m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20717   m_op_index = ((m_op_index + adjust)
20718                 % m_line_header->maximum_ops_per_instruction);
20719 }
20720
20721 void
20722 lnp_state_machine::handle_special_opcode (unsigned char op_code)
20723 {
20724   unsigned char adj_opcode = op_code - m_line_header->opcode_base;
20725   CORE_ADDR addr_adj = (((m_op_index
20726                           + (adj_opcode / m_line_header->line_range))
20727                          / m_line_header->maximum_ops_per_instruction)
20728                         * m_line_header->minimum_instruction_length);
20729   m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20730   m_op_index = ((m_op_index + (adj_opcode / m_line_header->line_range))
20731                 % m_line_header->maximum_ops_per_instruction);
20732
20733   int line_delta = (m_line_header->line_base
20734                     + (adj_opcode % m_line_header->line_range));
20735   advance_line (line_delta);
20736   record_line (false);
20737   m_discriminator = 0;
20738 }
20739
20740 void
20741 lnp_state_machine::handle_set_file (file_name_index file)
20742 {
20743   m_file = file;
20744
20745   const file_entry *fe = current_file ();
20746   if (fe == NULL)
20747     dwarf2_debug_line_missing_file_complaint ();
20748   else if (m_record_lines_p)
20749     {
20750       const char *dir = fe->include_dir (m_line_header);
20751
20752       m_last_subfile = m_cu->get_builder ()->get_current_subfile ();
20753       m_line_has_non_zero_discriminator = m_discriminator != 0;
20754       dwarf2_start_subfile (m_cu, fe->name, dir);
20755     }
20756 }
20757
20758 void
20759 lnp_state_machine::handle_const_add_pc ()
20760 {
20761   CORE_ADDR adjust
20762     = (255 - m_line_header->opcode_base) / m_line_header->line_range;
20763
20764   CORE_ADDR addr_adj
20765     = (((m_op_index + adjust)
20766         / m_line_header->maximum_ops_per_instruction)
20767        * m_line_header->minimum_instruction_length);
20768
20769   m_address += gdbarch_adjust_dwarf2_line (m_gdbarch, addr_adj, true);
20770   m_op_index = ((m_op_index + adjust)
20771                 % m_line_header->maximum_ops_per_instruction);
20772 }
20773
20774 /* Return non-zero if we should add LINE to the line number table.
20775    LINE is the line to add, LAST_LINE is the last line that was added,
20776    LAST_SUBFILE is the subfile for LAST_LINE.
20777    LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
20778    had a non-zero discriminator.
20779
20780    We have to be careful in the presence of discriminators.
20781    E.g., for this line:
20782
20783      for (i = 0; i < 100000; i++);
20784
20785    clang can emit four line number entries for that one line,
20786    each with a different discriminator.
20787    See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
20788
20789    However, we want gdb to coalesce all four entries into one.
20790    Otherwise the user could stepi into the middle of the line and
20791    gdb would get confused about whether the pc really was in the
20792    middle of the line.
20793
20794    Things are further complicated by the fact that two consecutive
20795    line number entries for the same line is a heuristic used by gcc
20796    to denote the end of the prologue.  So we can't just discard duplicate
20797    entries, we have to be selective about it.  The heuristic we use is
20798    that we only collapse consecutive entries for the same line if at least
20799    one of those entries has a non-zero discriminator.  PR 17276.
20800
20801    Note: Addresses in the line number state machine can never go backwards
20802    within one sequence, thus this coalescing is ok.  */
20803
20804 static int
20805 dwarf_record_line_p (struct dwarf2_cu *cu,
20806                      unsigned int line, unsigned int last_line,
20807                      int line_has_non_zero_discriminator,
20808                      struct subfile *last_subfile)
20809 {
20810   if (cu->get_builder ()->get_current_subfile () != last_subfile)
20811     return 1;
20812   if (line != last_line)
20813     return 1;
20814   /* Same line for the same file that we've seen already.
20815      As a last check, for pr 17276, only record the line if the line
20816      has never had a non-zero discriminator.  */
20817   if (!line_has_non_zero_discriminator)
20818     return 1;
20819   return 0;
20820 }
20821
20822 /* Use the CU's builder to record line number LINE beginning at
20823    address ADDRESS in the line table of subfile SUBFILE.  */
20824
20825 static void
20826 dwarf_record_line_1 (struct gdbarch *gdbarch, struct subfile *subfile,
20827                      unsigned int line, CORE_ADDR address,
20828                      struct dwarf2_cu *cu)
20829 {
20830   CORE_ADDR addr = gdbarch_addr_bits_remove (gdbarch, address);
20831
20832   if (dwarf_line_debug)
20833     {
20834       fprintf_unfiltered (gdb_stdlog,
20835                           "Recording line %u, file %s, address %s\n",
20836                           line, lbasename (subfile->name),
20837                           paddress (gdbarch, address));
20838     }
20839
20840   if (cu != nullptr)
20841     cu->get_builder ()->record_line (subfile, line, addr);
20842 }
20843
20844 /* Subroutine of dwarf_decode_lines_1 to simplify it.
20845    Mark the end of a set of line number records.
20846    The arguments are the same as for dwarf_record_line_1.
20847    If SUBFILE is NULL the request is ignored.  */
20848
20849 static void
20850 dwarf_finish_line (struct gdbarch *gdbarch, struct subfile *subfile,
20851                    CORE_ADDR address, struct dwarf2_cu *cu)
20852 {
20853   if (subfile == NULL)
20854     return;
20855
20856   if (dwarf_line_debug)
20857     {
20858       fprintf_unfiltered (gdb_stdlog,
20859                           "Finishing current line, file %s, address %s\n",
20860                           lbasename (subfile->name),
20861                           paddress (gdbarch, address));
20862     }
20863
20864   dwarf_record_line_1 (gdbarch, subfile, 0, address, cu);
20865 }
20866
20867 void
20868 lnp_state_machine::record_line (bool end_sequence)
20869 {
20870   if (dwarf_line_debug)
20871     {
20872       fprintf_unfiltered (gdb_stdlog,
20873                           "Processing actual line %u: file %u,"
20874                           " address %s, is_stmt %u, discrim %u\n",
20875                           m_line, to_underlying (m_file),
20876                           paddress (m_gdbarch, m_address),
20877                           m_is_stmt, m_discriminator);
20878     }
20879
20880   file_entry *fe = current_file ();
20881
20882   if (fe == NULL)
20883     dwarf2_debug_line_missing_file_complaint ();
20884   /* For now we ignore lines not starting on an instruction boundary.
20885      But not when processing end_sequence for compatibility with the
20886      previous version of the code.  */
20887   else if (m_op_index == 0 || end_sequence)
20888     {
20889       fe->included_p = 1;
20890       if (m_record_lines_p && (producer_is_codewarrior (m_cu) || m_is_stmt))
20891         {
20892           if (m_last_subfile != m_cu->get_builder ()->get_current_subfile ()
20893               || end_sequence)
20894             {
20895               dwarf_finish_line (m_gdbarch, m_last_subfile, m_address,
20896                                  m_currently_recording_lines ? m_cu : nullptr);
20897             }
20898
20899           if (!end_sequence)
20900             {
20901               if (dwarf_record_line_p (m_cu, m_line, m_last_line,
20902                                        m_line_has_non_zero_discriminator,
20903                                        m_last_subfile))
20904                 {
20905                   buildsym_compunit *builder = m_cu->get_builder ();
20906                   dwarf_record_line_1 (m_gdbarch,
20907                                        builder->get_current_subfile (),
20908                                        m_line, m_address,
20909                                        m_currently_recording_lines ? m_cu : nullptr);
20910                 }
20911               m_last_subfile = m_cu->get_builder ()->get_current_subfile ();
20912               m_last_line = m_line;
20913             }
20914         }
20915     }
20916 }
20917
20918 lnp_state_machine::lnp_state_machine (struct dwarf2_cu *cu, gdbarch *arch,
20919                                       line_header *lh, bool record_lines_p)
20920 {
20921   m_cu = cu;
20922   m_gdbarch = arch;
20923   m_record_lines_p = record_lines_p;
20924   m_line_header = lh;
20925
20926   m_currently_recording_lines = true;
20927
20928   /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
20929      was a line entry for it so that the backend has a chance to adjust it
20930      and also record it in case it needs it.  This is currently used by MIPS
20931      code, cf. `mips_adjust_dwarf2_line'.  */
20932   m_address = gdbarch_adjust_dwarf2_line (arch, 0, 0);
20933   m_is_stmt = lh->default_is_stmt;
20934   m_discriminator = 0;
20935 }
20936
20937 void
20938 lnp_state_machine::check_line_address (struct dwarf2_cu *cu,
20939                                        const gdb_byte *line_ptr,
20940                                        CORE_ADDR unrelocated_lowpc, CORE_ADDR address)
20941 {
20942   /* If ADDRESS < UNRELOCATED_LOWPC then it's not a usable value, it's outside
20943      the pc range of the CU.  However, we restrict the test to only ADDRESS
20944      values of zero to preserve GDB's previous behaviour which is to handle
20945      the specific case of a function being GC'd by the linker.  */
20946
20947   if (address == 0 && address < unrelocated_lowpc)
20948     {
20949       /* This line table is for a function which has been
20950          GCd by the linker.  Ignore it.  PR gdb/12528 */
20951
20952       struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
20953       long line_offset = line_ptr - get_debug_line_section (cu)->buffer;
20954
20955       complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
20956                  line_offset, objfile_name (objfile));
20957       m_currently_recording_lines = false;
20958       /* Note: m_currently_recording_lines is left as false until we see
20959          DW_LNE_end_sequence.  */
20960     }
20961 }
20962
20963 /* Subroutine of dwarf_decode_lines to simplify it.
20964    Process the line number information in LH.
20965    If DECODE_FOR_PST_P is non-zero, all we do is process the line number
20966    program in order to set included_p for every referenced header.  */
20967
20968 static void
20969 dwarf_decode_lines_1 (struct line_header *lh, struct dwarf2_cu *cu,
20970                       const int decode_for_pst_p, CORE_ADDR lowpc)
20971 {
20972   const gdb_byte *line_ptr, *extended_end;
20973   const gdb_byte *line_end;
20974   unsigned int bytes_read, extended_len;
20975   unsigned char op_code, extended_op;
20976   CORE_ADDR baseaddr;
20977   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
20978   bfd *abfd = objfile->obfd;
20979   struct gdbarch *gdbarch = get_objfile_arch (objfile);
20980   /* True if we're recording line info (as opposed to building partial
20981      symtabs and just interested in finding include files mentioned by
20982      the line number program).  */
20983   bool record_lines_p = !decode_for_pst_p;
20984
20985   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
20986
20987   line_ptr = lh->statement_program_start;
20988   line_end = lh->statement_program_end;
20989
20990   /* Read the statement sequences until there's nothing left.  */
20991   while (line_ptr < line_end)
20992     {
20993       /* The DWARF line number program state machine.  Reset the state
20994          machine at the start of each sequence.  */
20995       lnp_state_machine state_machine (cu, gdbarch, lh, record_lines_p);
20996       bool end_sequence = false;
20997
20998       if (record_lines_p)
20999         {
21000           /* Start a subfile for the current file of the state
21001              machine.  */
21002           const file_entry *fe = state_machine.current_file ();
21003
21004           if (fe != NULL)
21005             dwarf2_start_subfile (cu, fe->name, fe->include_dir (lh));
21006         }
21007
21008       /* Decode the table.  */
21009       while (line_ptr < line_end && !end_sequence)
21010         {
21011           op_code = read_1_byte (abfd, line_ptr);
21012           line_ptr += 1;
21013
21014           if (op_code >= lh->opcode_base)
21015             {
21016               /* Special opcode.  */
21017               state_machine.handle_special_opcode (op_code);
21018             }
21019           else switch (op_code)
21020             {
21021             case DW_LNS_extended_op:
21022               extended_len = read_unsigned_leb128 (abfd, line_ptr,
21023                                                    &bytes_read);
21024               line_ptr += bytes_read;
21025               extended_end = line_ptr + extended_len;
21026               extended_op = read_1_byte (abfd, line_ptr);
21027               line_ptr += 1;
21028               switch (extended_op)
21029                 {
21030                 case DW_LNE_end_sequence:
21031                   state_machine.handle_end_sequence ();
21032                   end_sequence = true;
21033                   break;
21034                 case DW_LNE_set_address:
21035                   {
21036                     CORE_ADDR address
21037                       = read_address (abfd, line_ptr, cu, &bytes_read);
21038                     line_ptr += bytes_read;
21039
21040                     state_machine.check_line_address (cu, line_ptr,
21041                                                       lowpc - baseaddr, address);
21042                     state_machine.handle_set_address (baseaddr, address);
21043                   }
21044                   break;
21045                 case DW_LNE_define_file:
21046                   {
21047                     const char *cur_file;
21048                     unsigned int mod_time, length;
21049                     dir_index dindex;
21050
21051                     cur_file = read_direct_string (abfd, line_ptr,
21052                                                    &bytes_read);
21053                     line_ptr += bytes_read;
21054                     dindex = (dir_index)
21055                       read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21056                     line_ptr += bytes_read;
21057                     mod_time =
21058                       read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21059                     line_ptr += bytes_read;
21060                     length =
21061                       read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21062                     line_ptr += bytes_read;
21063                     lh->add_file_name (cur_file, dindex, mod_time, length);
21064                   }
21065                   break;
21066                 case DW_LNE_set_discriminator:
21067                   {
21068                     /* The discriminator is not interesting to the
21069                        debugger; just ignore it.  We still need to
21070                        check its value though:
21071                        if there are consecutive entries for the same
21072                        (non-prologue) line we want to coalesce them.
21073                        PR 17276.  */
21074                     unsigned int discr
21075                       = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21076                     line_ptr += bytes_read;
21077
21078                     state_machine.handle_set_discriminator (discr);
21079                   }
21080                   break;
21081                 default:
21082                   complaint (_("mangled .debug_line section"));
21083                   return;
21084                 }
21085               /* Make sure that we parsed the extended op correctly.  If e.g.
21086                  we expected a different address size than the producer used,
21087                  we may have read the wrong number of bytes.  */
21088               if (line_ptr != extended_end)
21089                 {
21090                   complaint (_("mangled .debug_line section"));
21091                   return;
21092                 }
21093               break;
21094             case DW_LNS_copy:
21095               state_machine.handle_copy ();
21096               break;
21097             case DW_LNS_advance_pc:
21098               {
21099                 CORE_ADDR adjust
21100                   = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21101                 line_ptr += bytes_read;
21102
21103                 state_machine.handle_advance_pc (adjust);
21104               }
21105               break;
21106             case DW_LNS_advance_line:
21107               {
21108                 int line_delta
21109                   = read_signed_leb128 (abfd, line_ptr, &bytes_read);
21110                 line_ptr += bytes_read;
21111
21112                 state_machine.handle_advance_line (line_delta);
21113               }
21114               break;
21115             case DW_LNS_set_file:
21116               {
21117                 file_name_index file
21118                   = (file_name_index) read_unsigned_leb128 (abfd, line_ptr,
21119                                                             &bytes_read);
21120                 line_ptr += bytes_read;
21121
21122                 state_machine.handle_set_file (file);
21123               }
21124               break;
21125             case DW_LNS_set_column:
21126               (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21127               line_ptr += bytes_read;
21128               break;
21129             case DW_LNS_negate_stmt:
21130               state_machine.handle_negate_stmt ();
21131               break;
21132             case DW_LNS_set_basic_block:
21133               break;
21134             /* Add to the address register of the state machine the
21135                address increment value corresponding to special opcode
21136                255.  I.e., this value is scaled by the minimum
21137                instruction length since special opcode 255 would have
21138                scaled the increment.  */
21139             case DW_LNS_const_add_pc:
21140               state_machine.handle_const_add_pc ();
21141               break;
21142             case DW_LNS_fixed_advance_pc:
21143               {
21144                 CORE_ADDR addr_adj = read_2_bytes (abfd, line_ptr);
21145                 line_ptr += 2;
21146
21147                 state_machine.handle_fixed_advance_pc (addr_adj);
21148               }
21149               break;
21150             default:
21151               {
21152                 /* Unknown standard opcode, ignore it.  */
21153                 int i;
21154
21155                 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
21156                   {
21157                     (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
21158                     line_ptr += bytes_read;
21159                   }
21160               }
21161             }
21162         }
21163
21164       if (!end_sequence)
21165         dwarf2_debug_line_missing_end_sequence_complaint ();
21166
21167       /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
21168          in which case we still finish recording the last line).  */
21169       state_machine.record_line (true);
21170     }
21171 }
21172
21173 /* Decode the Line Number Program (LNP) for the given line_header
21174    structure and CU.  The actual information extracted and the type
21175    of structures created from the LNP depends on the value of PST.
21176
21177    1. If PST is NULL, then this procedure uses the data from the program
21178       to create all necessary symbol tables, and their linetables.
21179
21180    2. If PST is not NULL, this procedure reads the program to determine
21181       the list of files included by the unit represented by PST, and
21182       builds all the associated partial symbol tables.
21183
21184    COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
21185    It is used for relative paths in the line table.
21186    NOTE: When processing partial symtabs (pst != NULL),
21187    comp_dir == pst->dirname.
21188
21189    NOTE: It is important that psymtabs have the same file name (via strcmp)
21190    as the corresponding symtab.  Since COMP_DIR is not used in the name of the
21191    symtab we don't use it in the name of the psymtabs we create.
21192    E.g. expand_line_sal requires this when finding psymtabs to expand.
21193    A good testcase for this is mb-inline.exp.
21194
21195    LOWPC is the lowest address in CU (or 0 if not known).
21196
21197    Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
21198    for its PC<->lines mapping information.  Otherwise only the filename
21199    table is read in.  */
21200
21201 static void
21202 dwarf_decode_lines (struct line_header *lh, const char *comp_dir,
21203                     struct dwarf2_cu *cu, struct partial_symtab *pst,
21204                     CORE_ADDR lowpc, int decode_mapping)
21205 {
21206   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21207   const int decode_for_pst_p = (pst != NULL);
21208
21209   if (decode_mapping)
21210     dwarf_decode_lines_1 (lh, cu, decode_for_pst_p, lowpc);
21211
21212   if (decode_for_pst_p)
21213     {
21214       int file_index;
21215
21216       /* Now that we're done scanning the Line Header Program, we can
21217          create the psymtab of each included file.  */
21218       for (file_index = 0; file_index < lh->file_names.size (); file_index++)
21219         if (lh->file_names[file_index].included_p == 1)
21220           {
21221             gdb::unique_xmalloc_ptr<char> name_holder;
21222             const char *include_name =
21223               psymtab_include_file_name (lh, file_index, pst, comp_dir,
21224                                          &name_holder);
21225             if (include_name != NULL)
21226               dwarf2_create_include_psymtab (include_name, pst, objfile);
21227           }
21228     }
21229   else
21230     {
21231       /* Make sure a symtab is created for every file, even files
21232          which contain only variables (i.e. no code with associated
21233          line numbers).  */
21234       buildsym_compunit *builder = cu->get_builder ();
21235       struct compunit_symtab *cust = builder->get_compunit_symtab ();
21236       int i;
21237
21238       for (i = 0; i < lh->file_names.size (); i++)
21239         {
21240           file_entry &fe = lh->file_names[i];
21241
21242           dwarf2_start_subfile (cu, fe.name, fe.include_dir (lh));
21243
21244           if (builder->get_current_subfile ()->symtab == NULL)
21245             {
21246               builder->get_current_subfile ()->symtab
21247                 = allocate_symtab (cust,
21248                                    builder->get_current_subfile ()->name);
21249             }
21250           fe.symtab = builder->get_current_subfile ()->symtab;
21251         }
21252     }
21253 }
21254
21255 /* Start a subfile for DWARF.  FILENAME is the name of the file and
21256    DIRNAME the name of the source directory which contains FILENAME
21257    or NULL if not known.
21258    This routine tries to keep line numbers from identical absolute and
21259    relative file names in a common subfile.
21260
21261    Using the `list' example from the GDB testsuite, which resides in
21262    /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
21263    of /srcdir/list0.c yields the following debugging information for list0.c:
21264
21265    DW_AT_name:          /srcdir/list0.c
21266    DW_AT_comp_dir:      /compdir
21267    files.files[0].name: list0.h
21268    files.files[0].dir:  /srcdir
21269    files.files[1].name: list0.c
21270    files.files[1].dir:  /srcdir
21271
21272    The line number information for list0.c has to end up in a single
21273    subfile, so that `break /srcdir/list0.c:1' works as expected.
21274    start_subfile will ensure that this happens provided that we pass the
21275    concatenation of files.files[1].dir and files.files[1].name as the
21276    subfile's name.  */
21277
21278 static void
21279 dwarf2_start_subfile (struct dwarf2_cu *cu, const char *filename,
21280                       const char *dirname)
21281 {
21282   char *copy = NULL;
21283
21284   /* In order not to lose the line information directory,
21285      we concatenate it to the filename when it makes sense.
21286      Note that the Dwarf3 standard says (speaking of filenames in line
21287      information): ``The directory index is ignored for file names
21288      that represent full path names''.  Thus ignoring dirname in the
21289      `else' branch below isn't an issue.  */
21290
21291   if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
21292     {
21293       copy = concat (dirname, SLASH_STRING, filename, (char *)NULL);
21294       filename = copy;
21295     }
21296
21297   cu->get_builder ()->start_subfile (filename);
21298
21299   if (copy != NULL)
21300     xfree (copy);
21301 }
21302
21303 /* Start a symtab for DWARF.  NAME, COMP_DIR, LOW_PC are passed to the
21304    buildsym_compunit constructor.  */
21305
21306 struct compunit_symtab *
21307 dwarf2_cu::start_symtab (const char *name, const char *comp_dir,
21308                          CORE_ADDR low_pc)
21309 {
21310   gdb_assert (m_builder == nullptr);
21311
21312   m_builder.reset (new struct buildsym_compunit
21313                    (per_cu->dwarf2_per_objfile->objfile,
21314                     name, comp_dir, language, low_pc));
21315
21316   list_in_scope = get_builder ()->get_file_symbols ();
21317
21318   get_builder ()->record_debugformat ("DWARF 2");
21319   get_builder ()->record_producer (producer);
21320
21321   processing_has_namespace_info = false;
21322
21323   return get_builder ()->get_compunit_symtab ();
21324 }
21325
21326 static void
21327 var_decode_location (struct attribute *attr, struct symbol *sym,
21328                      struct dwarf2_cu *cu)
21329 {
21330   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21331   struct comp_unit_head *cu_header = &cu->header;
21332
21333   /* NOTE drow/2003-01-30: There used to be a comment and some special
21334      code here to turn a symbol with DW_AT_external and a
21335      SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol.  This was
21336      necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
21337      with some versions of binutils) where shared libraries could have
21338      relocations against symbols in their debug information - the
21339      minimal symbol would have the right address, but the debug info
21340      would not.  It's no longer necessary, because we will explicitly
21341      apply relocations when we read in the debug information now.  */
21342
21343   /* A DW_AT_location attribute with no contents indicates that a
21344      variable has been optimized away.  */
21345   if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
21346     {
21347       SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
21348       return;
21349     }
21350
21351   /* Handle one degenerate form of location expression specially, to
21352      preserve GDB's previous behavior when section offsets are
21353      specified.  If this is just a DW_OP_addr or DW_OP_GNU_addr_index
21354      then mark this symbol as LOC_STATIC.  */
21355
21356   if (attr_form_is_block (attr)
21357       && ((DW_BLOCK (attr)->data[0] == DW_OP_addr
21358            && DW_BLOCK (attr)->size == 1 + cu_header->addr_size)
21359           || (DW_BLOCK (attr)->data[0] == DW_OP_GNU_addr_index
21360               && (DW_BLOCK (attr)->size
21361                   == 1 + leb128_size (&DW_BLOCK (attr)->data[1])))))
21362     {
21363       unsigned int dummy;
21364
21365       if (DW_BLOCK (attr)->data[0] == DW_OP_addr)
21366         SYMBOL_VALUE_ADDRESS (sym) =
21367           read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
21368       else
21369         SYMBOL_VALUE_ADDRESS (sym) =
21370           read_addr_index_from_leb128 (cu, DW_BLOCK (attr)->data + 1, &dummy);
21371       SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
21372       fixup_symbol_section (sym, objfile);
21373       SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
21374                                               SYMBOL_SECTION (sym));
21375       return;
21376     }
21377
21378   /* NOTE drow/2002-01-30: It might be worthwhile to have a static
21379      expression evaluator, and use LOC_COMPUTED only when necessary
21380      (i.e. when the value of a register or memory location is
21381      referenced, or a thread-local block, etc.).  Then again, it might
21382      not be worthwhile.  I'm assuming that it isn't unless performance
21383      or memory numbers show me otherwise.  */
21384
21385   dwarf2_symbol_mark_computed (attr, sym, cu, 0);
21386
21387   if (SYMBOL_COMPUTED_OPS (sym)->location_has_loclist)
21388     cu->has_loclist = true;
21389 }
21390
21391 /* Given a pointer to a DWARF information entry, figure out if we need
21392    to make a symbol table entry for it, and if so, create a new entry
21393    and return a pointer to it.
21394    If TYPE is NULL, determine symbol type from the die, otherwise
21395    used the passed type.
21396    If SPACE is not NULL, use it to hold the new symbol.  If it is
21397    NULL, allocate a new symbol on the objfile's obstack.  */
21398
21399 static struct symbol *
21400 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
21401             struct symbol *space)
21402 {
21403   struct dwarf2_per_objfile *dwarf2_per_objfile
21404     = cu->per_cu->dwarf2_per_objfile;
21405   struct objfile *objfile = dwarf2_per_objfile->objfile;
21406   struct gdbarch *gdbarch = get_objfile_arch (objfile);
21407   struct symbol *sym = NULL;
21408   const char *name;
21409   struct attribute *attr = NULL;
21410   struct attribute *attr2 = NULL;
21411   CORE_ADDR baseaddr;
21412   struct pending **list_to_add = NULL;
21413
21414   int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
21415
21416   baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
21417
21418   name = dwarf2_name (die, cu);
21419   if (name)
21420     {
21421       const char *linkagename;
21422       int suppress_add = 0;
21423
21424       if (space)
21425         sym = space;
21426       else
21427         sym = allocate_symbol (objfile);
21428       OBJSTAT (objfile, n_syms++);
21429
21430       /* Cache this symbol's name and the name's demangled form (if any).  */
21431       SYMBOL_SET_LANGUAGE (sym, cu->language, &objfile->objfile_obstack);
21432       linkagename = dwarf2_physname (name, die, cu);
21433       SYMBOL_SET_NAMES (sym, linkagename, strlen (linkagename), 0, objfile);
21434
21435       /* Fortran does not have mangling standard and the mangling does differ
21436          between gfortran, iFort etc.  */
21437       if (cu->language == language_fortran
21438           && symbol_get_demangled_name (&(sym->ginfo)) == NULL)
21439         symbol_set_demangled_name (&(sym->ginfo),
21440                                    dwarf2_full_name (name, die, cu),
21441                                    NULL);
21442
21443       /* Default assumptions.
21444          Use the passed type or decode it from the die.  */
21445       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21446       SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
21447       if (type != NULL)
21448         SYMBOL_TYPE (sym) = type;
21449       else
21450         SYMBOL_TYPE (sym) = die_type (die, cu);
21451       attr = dwarf2_attr (die,
21452                           inlined_func ? DW_AT_call_line : DW_AT_decl_line,
21453                           cu);
21454       if (attr)
21455         {
21456           SYMBOL_LINE (sym) = DW_UNSND (attr);
21457         }
21458
21459       attr = dwarf2_attr (die,
21460                           inlined_func ? DW_AT_call_file : DW_AT_decl_file,
21461                           cu);
21462       if (attr)
21463         {
21464           file_name_index file_index = (file_name_index) DW_UNSND (attr);
21465           struct file_entry *fe;
21466
21467           if (cu->line_header != NULL)
21468             fe = cu->line_header->file_name_at (file_index);
21469           else
21470             fe = NULL;
21471
21472           if (fe == NULL)
21473             complaint (_("file index out of range"));
21474           else
21475             symbol_set_symtab (sym, fe->symtab);
21476         }
21477
21478       switch (die->tag)
21479         {
21480         case DW_TAG_label:
21481           attr = dwarf2_attr (die, DW_AT_low_pc, cu);
21482           if (attr)
21483             {
21484               CORE_ADDR addr;
21485
21486               addr = attr_value_as_address (attr);
21487               addr = gdbarch_adjust_dwarf2_addr (gdbarch, addr + baseaddr);
21488               SYMBOL_VALUE_ADDRESS (sym) = addr;
21489             }
21490           SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_core_addr;
21491           SYMBOL_DOMAIN (sym) = LABEL_DOMAIN;
21492           SYMBOL_ACLASS_INDEX (sym) = LOC_LABEL;
21493           add_symbol_to_list (sym, cu->list_in_scope);
21494           break;
21495         case DW_TAG_subprogram:
21496           /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21497              finish_block.  */
21498           SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
21499           attr2 = dwarf2_attr (die, DW_AT_external, cu);
21500           if ((attr2 && (DW_UNSND (attr2) != 0))
21501               || cu->language == language_ada)
21502             {
21503               /* Subprograms marked external are stored as a global symbol.
21504                  Ada subprograms, whether marked external or not, are always
21505                  stored as a global symbol, because we want to be able to
21506                  access them globally.  For instance, we want to be able
21507                  to break on a nested subprogram without having to
21508                  specify the context.  */
21509               list_to_add = cu->get_builder ()->get_global_symbols ();
21510             }
21511           else
21512             {
21513               list_to_add = cu->list_in_scope;
21514             }
21515           break;
21516         case DW_TAG_inlined_subroutine:
21517           /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
21518              finish_block.  */
21519           SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
21520           SYMBOL_INLINED (sym) = 1;
21521           list_to_add = cu->list_in_scope;
21522           break;
21523         case DW_TAG_template_value_param:
21524           suppress_add = 1;
21525           /* Fall through.  */
21526         case DW_TAG_constant:
21527         case DW_TAG_variable:
21528         case DW_TAG_member:
21529           /* Compilation with minimal debug info may result in
21530              variables with missing type entries.  Change the
21531              misleading `void' type to something sensible.  */
21532           if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
21533             SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_int;
21534
21535           attr = dwarf2_attr (die, DW_AT_const_value, cu);
21536           /* In the case of DW_TAG_member, we should only be called for
21537              static const members.  */
21538           if (die->tag == DW_TAG_member)
21539             {
21540               /* dwarf2_add_field uses die_is_declaration,
21541                  so we do the same.  */
21542               gdb_assert (die_is_declaration (die, cu));
21543               gdb_assert (attr);
21544             }
21545           if (attr)
21546             {
21547               dwarf2_const_value (attr, sym, cu);
21548               attr2 = dwarf2_attr (die, DW_AT_external, cu);
21549               if (!suppress_add)
21550                 {
21551                   if (attr2 && (DW_UNSND (attr2) != 0))
21552                     list_to_add = cu->get_builder ()->get_global_symbols ();
21553                   else
21554                     list_to_add = cu->list_in_scope;
21555                 }
21556               break;
21557             }
21558           attr = dwarf2_attr (die, DW_AT_location, cu);
21559           if (attr)
21560             {
21561               var_decode_location (attr, sym, cu);
21562               attr2 = dwarf2_attr (die, DW_AT_external, cu);
21563
21564               /* Fortran explicitly imports any global symbols to the local
21565                  scope by DW_TAG_common_block.  */
21566               if (cu->language == language_fortran && die->parent
21567                   && die->parent->tag == DW_TAG_common_block)
21568                 attr2 = NULL;
21569
21570               if (SYMBOL_CLASS (sym) == LOC_STATIC
21571                   && SYMBOL_VALUE_ADDRESS (sym) == 0
21572                   && !dwarf2_per_objfile->has_section_at_zero)
21573                 {
21574                   /* When a static variable is eliminated by the linker,
21575                      the corresponding debug information is not stripped
21576                      out, but the variable address is set to null;
21577                      do not add such variables into symbol table.  */
21578                 }
21579               else if (attr2 && (DW_UNSND (attr2) != 0))
21580                 {
21581                   /* Workaround gfortran PR debug/40040 - it uses
21582                      DW_AT_location for variables in -fPIC libraries which may
21583                      get overriden by other libraries/executable and get
21584                      a different address.  Resolve it by the minimal symbol
21585                      which may come from inferior's executable using copy
21586                      relocation.  Make this workaround only for gfortran as for
21587                      other compilers GDB cannot guess the minimal symbol
21588                      Fortran mangling kind.  */
21589                   if (cu->language == language_fortran && die->parent
21590                       && die->parent->tag == DW_TAG_module
21591                       && cu->producer
21592                       && startswith (cu->producer, "GNU Fortran"))
21593                     SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
21594
21595                   /* A variable with DW_AT_external is never static,
21596                      but it may be block-scoped.  */
21597                   list_to_add
21598                     = ((cu->list_in_scope
21599                         == cu->get_builder ()->get_file_symbols ())
21600                        ? cu->get_builder ()->get_global_symbols ()
21601                        : cu->list_in_scope);
21602                 }
21603               else
21604                 list_to_add = cu->list_in_scope;
21605             }
21606           else
21607             {
21608               /* We do not know the address of this symbol.
21609                  If it is an external symbol and we have type information
21610                  for it, enter the symbol as a LOC_UNRESOLVED symbol.
21611                  The address of the variable will then be determined from
21612                  the minimal symbol table whenever the variable is
21613                  referenced.  */
21614               attr2 = dwarf2_attr (die, DW_AT_external, cu);
21615
21616               /* Fortran explicitly imports any global symbols to the local
21617                  scope by DW_TAG_common_block.  */
21618               if (cu->language == language_fortran && die->parent
21619                   && die->parent->tag == DW_TAG_common_block)
21620                 {
21621                   /* SYMBOL_CLASS doesn't matter here because
21622                      read_common_block is going to reset it.  */
21623                   if (!suppress_add)
21624                     list_to_add = cu->list_in_scope;
21625                 }
21626               else if (attr2 && (DW_UNSND (attr2) != 0)
21627                        && dwarf2_attr (die, DW_AT_type, cu) != NULL)
21628                 {
21629                   /* A variable with DW_AT_external is never static, but it
21630                      may be block-scoped.  */
21631                   list_to_add
21632                     = ((cu->list_in_scope
21633                         == cu->get_builder ()->get_file_symbols ())
21634                        ? cu->get_builder ()->get_global_symbols ()
21635                        : cu->list_in_scope);
21636
21637                   SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
21638                 }
21639               else if (!die_is_declaration (die, cu))
21640                 {
21641                   /* Use the default LOC_OPTIMIZED_OUT class.  */
21642                   gdb_assert (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT);
21643                   if (!suppress_add)
21644                     list_to_add = cu->list_in_scope;
21645                 }
21646             }
21647           break;
21648         case DW_TAG_formal_parameter:
21649           {
21650             /* If we are inside a function, mark this as an argument.  If
21651                not, we might be looking at an argument to an inlined function
21652                when we do not have enough information to show inlined frames;
21653                pretend it's a local variable in that case so that the user can
21654                still see it.  */
21655             struct context_stack *curr
21656               = cu->get_builder ()->get_current_context_stack ();
21657             if (curr != nullptr && curr->name != nullptr)
21658               SYMBOL_IS_ARGUMENT (sym) = 1;
21659             attr = dwarf2_attr (die, DW_AT_location, cu);
21660             if (attr)
21661               {
21662                 var_decode_location (attr, sym, cu);
21663               }
21664             attr = dwarf2_attr (die, DW_AT_const_value, cu);
21665             if (attr)
21666               {
21667                 dwarf2_const_value (attr, sym, cu);
21668               }
21669
21670             list_to_add = cu->list_in_scope;
21671           }
21672           break;
21673         case DW_TAG_unspecified_parameters:
21674           /* From varargs functions; gdb doesn't seem to have any
21675              interest in this information, so just ignore it for now.
21676              (FIXME?) */
21677           break;
21678         case DW_TAG_template_type_param:
21679           suppress_add = 1;
21680           /* Fall through.  */
21681         case DW_TAG_class_type:
21682         case DW_TAG_interface_type:
21683         case DW_TAG_structure_type:
21684         case DW_TAG_union_type:
21685         case DW_TAG_set_type:
21686         case DW_TAG_enumeration_type:
21687           SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21688           SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
21689
21690           {
21691             /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
21692                really ever be static objects: otherwise, if you try
21693                to, say, break of a class's method and you're in a file
21694                which doesn't mention that class, it won't work unless
21695                the check for all static symbols in lookup_symbol_aux
21696                saves you.  See the OtherFileClass tests in
21697                gdb.c++/namespace.exp.  */
21698
21699             if (!suppress_add)
21700               {
21701                 buildsym_compunit *builder = cu->get_builder ();
21702                 list_to_add
21703                   = (cu->list_in_scope == builder->get_file_symbols ()
21704                      && cu->language == language_cplus
21705                      ? builder->get_global_symbols ()
21706                      : cu->list_in_scope);
21707
21708                 /* The semantics of C++ state that "struct foo {
21709                    ... }" also defines a typedef for "foo".  */
21710                 if (cu->language == language_cplus
21711                     || cu->language == language_ada
21712                     || cu->language == language_d
21713                     || cu->language == language_rust)
21714                   {
21715                     /* The symbol's name is already allocated along
21716                        with this objfile, so we don't need to
21717                        duplicate it for the type.  */
21718                     if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
21719                       TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
21720                   }
21721               }
21722           }
21723           break;
21724         case DW_TAG_typedef:
21725           SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21726           SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21727           list_to_add = cu->list_in_scope;
21728           break;
21729         case DW_TAG_base_type:
21730         case DW_TAG_subrange_type:
21731           SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21732           SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
21733           list_to_add = cu->list_in_scope;
21734           break;
21735         case DW_TAG_enumerator:
21736           attr = dwarf2_attr (die, DW_AT_const_value, cu);
21737           if (attr)
21738             {
21739               dwarf2_const_value (attr, sym, cu);
21740             }
21741           {
21742             /* NOTE: carlton/2003-11-10: See comment above in the
21743                DW_TAG_class_type, etc. block.  */
21744
21745             list_to_add
21746               = (cu->list_in_scope == cu->get_builder ()->get_file_symbols ()
21747                  && cu->language == language_cplus
21748                  ? cu->get_builder ()->get_global_symbols ()
21749                  : cu->list_in_scope);
21750           }
21751           break;
21752         case DW_TAG_imported_declaration:
21753         case DW_TAG_namespace:
21754           SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21755           list_to_add = cu->get_builder ()->get_global_symbols ();
21756           break;
21757         case DW_TAG_module:
21758           SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
21759           SYMBOL_DOMAIN (sym) = MODULE_DOMAIN;
21760           list_to_add = cu->get_builder ()->get_global_symbols ();
21761           break;
21762         case DW_TAG_common_block:
21763           SYMBOL_ACLASS_INDEX (sym) = LOC_COMMON_BLOCK;
21764           SYMBOL_DOMAIN (sym) = COMMON_BLOCK_DOMAIN;
21765           add_symbol_to_list (sym, cu->list_in_scope);
21766           break;
21767         default:
21768           /* Not a tag we recognize.  Hopefully we aren't processing
21769              trash data, but since we must specifically ignore things
21770              we don't recognize, there is nothing else we should do at
21771              this point.  */
21772           complaint (_("unsupported tag: '%s'"),
21773                      dwarf_tag_name (die->tag));
21774           break;
21775         }
21776
21777       if (suppress_add)
21778         {
21779           sym->hash_next = objfile->template_symbols;
21780           objfile->template_symbols = sym;
21781           list_to_add = NULL;
21782         }
21783
21784       if (list_to_add != NULL)
21785         add_symbol_to_list (sym, list_to_add);
21786
21787       /* For the benefit of old versions of GCC, check for anonymous
21788          namespaces based on the demangled name.  */
21789       if (!cu->processing_has_namespace_info
21790           && cu->language == language_cplus)
21791         cp_scan_for_anonymous_namespaces (cu->get_builder (), sym, objfile);
21792     }
21793   return (sym);
21794 }
21795
21796 /* Given an attr with a DW_FORM_dataN value in host byte order,
21797    zero-extend it as appropriate for the symbol's type.  The DWARF
21798    standard (v4) is not entirely clear about the meaning of using
21799    DW_FORM_dataN for a constant with a signed type, where the type is
21800    wider than the data.  The conclusion of a discussion on the DWARF
21801    list was that this is unspecified.  We choose to always zero-extend
21802    because that is the interpretation long in use by GCC.  */
21803
21804 static gdb_byte *
21805 dwarf2_const_value_data (const struct attribute *attr, struct obstack *obstack,
21806                          struct dwarf2_cu *cu, LONGEST *value, int bits)
21807 {
21808   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21809   enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ?
21810                                 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
21811   LONGEST l = DW_UNSND (attr);
21812
21813   if (bits < sizeof (*value) * 8)
21814     {
21815       l &= ((LONGEST) 1 << bits) - 1;
21816       *value = l;
21817     }
21818   else if (bits == sizeof (*value) * 8)
21819     *value = l;
21820   else
21821     {
21822       gdb_byte *bytes = (gdb_byte *) obstack_alloc (obstack, bits / 8);
21823       store_unsigned_integer (bytes, bits / 8, byte_order, l);
21824       return bytes;
21825     }
21826
21827   return NULL;
21828 }
21829
21830 /* Read a constant value from an attribute.  Either set *VALUE, or if
21831    the value does not fit in *VALUE, set *BYTES - either already
21832    allocated on the objfile obstack, or newly allocated on OBSTACK,
21833    or, set *BATON, if we translated the constant to a location
21834    expression.  */
21835
21836 static void
21837 dwarf2_const_value_attr (const struct attribute *attr, struct type *type,
21838                          const char *name, struct obstack *obstack,
21839                          struct dwarf2_cu *cu,
21840                          LONGEST *value, const gdb_byte **bytes,
21841                          struct dwarf2_locexpr_baton **baton)
21842 {
21843   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21844   struct comp_unit_head *cu_header = &cu->header;
21845   struct dwarf_block *blk;
21846   enum bfd_endian byte_order = (bfd_big_endian (objfile->obfd) ?
21847                                 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
21848
21849   *value = 0;
21850   *bytes = NULL;
21851   *baton = NULL;
21852
21853   switch (attr->form)
21854     {
21855     case DW_FORM_addr:
21856     case DW_FORM_GNU_addr_index:
21857       {
21858         gdb_byte *data;
21859
21860         if (TYPE_LENGTH (type) != cu_header->addr_size)
21861           dwarf2_const_value_length_mismatch_complaint (name,
21862                                                         cu_header->addr_size,
21863                                                         TYPE_LENGTH (type));
21864         /* Symbols of this form are reasonably rare, so we just
21865            piggyback on the existing location code rather than writing
21866            a new implementation of symbol_computed_ops.  */
21867         *baton = XOBNEW (obstack, struct dwarf2_locexpr_baton);
21868         (*baton)->per_cu = cu->per_cu;
21869         gdb_assert ((*baton)->per_cu);
21870
21871         (*baton)->size = 2 + cu_header->addr_size;
21872         data = (gdb_byte *) obstack_alloc (obstack, (*baton)->size);
21873         (*baton)->data = data;
21874
21875         data[0] = DW_OP_addr;
21876         store_unsigned_integer (&data[1], cu_header->addr_size,
21877                                 byte_order, DW_ADDR (attr));
21878         data[cu_header->addr_size + 1] = DW_OP_stack_value;
21879       }
21880       break;
21881     case DW_FORM_string:
21882     case DW_FORM_strp:
21883     case DW_FORM_GNU_str_index:
21884     case DW_FORM_GNU_strp_alt:
21885       /* DW_STRING is already allocated on the objfile obstack, point
21886          directly to it.  */
21887       *bytes = (const gdb_byte *) DW_STRING (attr);
21888       break;
21889     case DW_FORM_block1:
21890     case DW_FORM_block2:
21891     case DW_FORM_block4:
21892     case DW_FORM_block:
21893     case DW_FORM_exprloc:
21894     case DW_FORM_data16:
21895       blk = DW_BLOCK (attr);
21896       if (TYPE_LENGTH (type) != blk->size)
21897         dwarf2_const_value_length_mismatch_complaint (name, blk->size,
21898                                                       TYPE_LENGTH (type));
21899       *bytes = blk->data;
21900       break;
21901
21902       /* The DW_AT_const_value attributes are supposed to carry the
21903          symbol's value "represented as it would be on the target
21904          architecture."  By the time we get here, it's already been
21905          converted to host endianness, so we just need to sign- or
21906          zero-extend it as appropriate.  */
21907     case DW_FORM_data1:
21908       *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 8);
21909       break;
21910     case DW_FORM_data2:
21911       *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 16);
21912       break;
21913     case DW_FORM_data4:
21914       *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 32);
21915       break;
21916     case DW_FORM_data8:
21917       *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 64);
21918       break;
21919
21920     case DW_FORM_sdata:
21921     case DW_FORM_implicit_const:
21922       *value = DW_SND (attr);
21923       break;
21924
21925     case DW_FORM_udata:
21926       *value = DW_UNSND (attr);
21927       break;
21928
21929     default:
21930       complaint (_("unsupported const value attribute form: '%s'"),
21931                  dwarf_form_name (attr->form));
21932       *value = 0;
21933       break;
21934     }
21935 }
21936
21937
21938 /* Copy constant value from an attribute to a symbol.  */
21939
21940 static void
21941 dwarf2_const_value (const struct attribute *attr, struct symbol *sym,
21942                     struct dwarf2_cu *cu)
21943 {
21944   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21945   LONGEST value;
21946   const gdb_byte *bytes;
21947   struct dwarf2_locexpr_baton *baton;
21948
21949   dwarf2_const_value_attr (attr, SYMBOL_TYPE (sym),
21950                            SYMBOL_PRINT_NAME (sym),
21951                            &objfile->objfile_obstack, cu,
21952                            &value, &bytes, &baton);
21953
21954   if (baton != NULL)
21955     {
21956       SYMBOL_LOCATION_BATON (sym) = baton;
21957       SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
21958     }
21959   else if (bytes != NULL)
21960      {
21961       SYMBOL_VALUE_BYTES (sym) = bytes;
21962       SYMBOL_ACLASS_INDEX (sym) = LOC_CONST_BYTES;
21963     }
21964   else
21965     {
21966       SYMBOL_VALUE (sym) = value;
21967       SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
21968     }
21969 }
21970
21971 /* Return the type of the die in question using its DW_AT_type attribute.  */
21972
21973 static struct type *
21974 die_type (struct die_info *die, struct dwarf2_cu *cu)
21975 {
21976   struct attribute *type_attr;
21977
21978   type_attr = dwarf2_attr (die, DW_AT_type, cu);
21979   if (!type_attr)
21980     {
21981       struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
21982       /* A missing DW_AT_type represents a void type.  */
21983       return objfile_type (objfile)->builtin_void;
21984     }
21985
21986   return lookup_die_type (die, type_attr, cu);
21987 }
21988
21989 /* True iff CU's producer generates GNAT Ada auxiliary information
21990    that allows to find parallel types through that information instead
21991    of having to do expensive parallel lookups by type name.  */
21992
21993 static int
21994 need_gnat_info (struct dwarf2_cu *cu)
21995 {
21996   /* Assume that the Ada compiler was GNAT, which always produces
21997      the auxiliary information.  */
21998   return (cu->language == language_ada);
21999 }
22000
22001 /* Return the auxiliary type of the die in question using its
22002    DW_AT_GNAT_descriptive_type attribute.  Returns NULL if the
22003    attribute is not present.  */
22004
22005 static struct type *
22006 die_descriptive_type (struct die_info *die, struct dwarf2_cu *cu)
22007 {
22008   struct attribute *type_attr;
22009
22010   type_attr = dwarf2_attr (die, DW_AT_GNAT_descriptive_type, cu);
22011   if (!type_attr)
22012     return NULL;
22013
22014   return lookup_die_type (die, type_attr, cu);
22015 }
22016
22017 /* If DIE has a descriptive_type attribute, then set the TYPE's
22018    descriptive type accordingly.  */
22019
22020 static void
22021 set_descriptive_type (struct type *type, struct die_info *die,
22022                       struct dwarf2_cu *cu)
22023 {
22024   struct type *descriptive_type = die_descriptive_type (die, cu);
22025
22026   if (descriptive_type)
22027     {
22028       ALLOCATE_GNAT_AUX_TYPE (type);
22029       TYPE_DESCRIPTIVE_TYPE (type) = descriptive_type;
22030     }
22031 }
22032
22033 /* Return the containing type of the die in question using its
22034    DW_AT_containing_type attribute.  */
22035
22036 static struct type *
22037 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
22038 {
22039   struct attribute *type_attr;
22040   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22041
22042   type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
22043   if (!type_attr)
22044     error (_("Dwarf Error: Problem turning containing type into gdb type "
22045              "[in module %s]"), objfile_name (objfile));
22046
22047   return lookup_die_type (die, type_attr, cu);
22048 }
22049
22050 /* Return an error marker type to use for the ill formed type in DIE/CU.  */
22051
22052 static struct type *
22053 build_error_marker_type (struct dwarf2_cu *cu, struct die_info *die)
22054 {
22055   struct dwarf2_per_objfile *dwarf2_per_objfile
22056     = cu->per_cu->dwarf2_per_objfile;
22057   struct objfile *objfile = dwarf2_per_objfile->objfile;
22058   char *saved;
22059
22060   std::string message
22061     = string_printf (_("<unknown type in %s, CU %s, DIE %s>"),
22062                      objfile_name (objfile),
22063                      sect_offset_str (cu->header.sect_off),
22064                      sect_offset_str (die->sect_off));
22065   saved = (char *) obstack_copy0 (&objfile->objfile_obstack,
22066                                   message.c_str (), message.length ());
22067
22068   return init_type (objfile, TYPE_CODE_ERROR, 0, saved);
22069 }
22070
22071 /* Look up the type of DIE in CU using its type attribute ATTR.
22072    ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
22073    DW_AT_containing_type.
22074    If there is no type substitute an error marker.  */
22075
22076 static struct type *
22077 lookup_die_type (struct die_info *die, const struct attribute *attr,
22078                  struct dwarf2_cu *cu)
22079 {
22080   struct dwarf2_per_objfile *dwarf2_per_objfile
22081     = cu->per_cu->dwarf2_per_objfile;
22082   struct objfile *objfile = dwarf2_per_objfile->objfile;
22083   struct type *this_type;
22084
22085   gdb_assert (attr->name == DW_AT_type
22086               || attr->name == DW_AT_GNAT_descriptive_type
22087               || attr->name == DW_AT_containing_type);
22088
22089   /* First see if we have it cached.  */
22090
22091   if (attr->form == DW_FORM_GNU_ref_alt)
22092     {
22093       struct dwarf2_per_cu_data *per_cu;
22094       sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
22095
22096       per_cu = dwarf2_find_containing_comp_unit (sect_off, 1,
22097                                                  dwarf2_per_objfile);
22098       this_type = get_die_type_at_offset (sect_off, per_cu);
22099     }
22100   else if (attr_form_is_ref (attr))
22101     {
22102       sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
22103
22104       this_type = get_die_type_at_offset (sect_off, cu->per_cu);
22105     }
22106   else if (attr->form == DW_FORM_ref_sig8)
22107     {
22108       ULONGEST signature = DW_SIGNATURE (attr);
22109
22110       return get_signatured_type (die, signature, cu);
22111     }
22112   else
22113     {
22114       complaint (_("Dwarf Error: Bad type attribute %s in DIE"
22115                    " at %s [in module %s]"),
22116                  dwarf_attr_name (attr->name), sect_offset_str (die->sect_off),
22117                  objfile_name (objfile));
22118       return build_error_marker_type (cu, die);
22119     }
22120
22121   /* If not cached we need to read it in.  */
22122
22123   if (this_type == NULL)
22124     {
22125       struct die_info *type_die = NULL;
22126       struct dwarf2_cu *type_cu = cu;
22127
22128       if (attr_form_is_ref (attr))
22129         type_die = follow_die_ref (die, attr, &type_cu);
22130       if (type_die == NULL)
22131         return build_error_marker_type (cu, die);
22132       /* If we find the type now, it's probably because the type came
22133          from an inter-CU reference and the type's CU got expanded before
22134          ours.  */
22135       this_type = read_type_die (type_die, type_cu);
22136     }
22137
22138   /* If we still don't have a type use an error marker.  */
22139
22140   if (this_type == NULL)
22141     return build_error_marker_type (cu, die);
22142
22143   return this_type;
22144 }
22145
22146 /* Return the type in DIE, CU.
22147    Returns NULL for invalid types.
22148
22149    This first does a lookup in die_type_hash,
22150    and only reads the die in if necessary.
22151
22152    NOTE: This can be called when reading in partial or full symbols.  */
22153
22154 static struct type *
22155 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
22156 {
22157   struct type *this_type;
22158
22159   this_type = get_die_type (die, cu);
22160   if (this_type)
22161     return this_type;
22162
22163   return read_type_die_1 (die, cu);
22164 }
22165
22166 /* Read the type in DIE, CU.
22167    Returns NULL for invalid types.  */
22168
22169 static struct type *
22170 read_type_die_1 (struct die_info *die, struct dwarf2_cu *cu)
22171 {
22172   struct type *this_type = NULL;
22173
22174   switch (die->tag)
22175     {
22176     case DW_TAG_class_type:
22177     case DW_TAG_interface_type:
22178     case DW_TAG_structure_type:
22179     case DW_TAG_union_type:
22180       this_type = read_structure_type (die, cu);
22181       break;
22182     case DW_TAG_enumeration_type:
22183       this_type = read_enumeration_type (die, cu);
22184       break;
22185     case DW_TAG_subprogram:
22186     case DW_TAG_subroutine_type:
22187     case DW_TAG_inlined_subroutine:
22188       this_type = read_subroutine_type (die, cu);
22189       break;
22190     case DW_TAG_array_type:
22191       this_type = read_array_type (die, cu);
22192       break;
22193     case DW_TAG_set_type:
22194       this_type = read_set_type (die, cu);
22195       break;
22196     case DW_TAG_pointer_type:
22197       this_type = read_tag_pointer_type (die, cu);
22198       break;
22199     case DW_TAG_ptr_to_member_type:
22200       this_type = read_tag_ptr_to_member_type (die, cu);
22201       break;
22202     case DW_TAG_reference_type:
22203       this_type = read_tag_reference_type (die, cu, TYPE_CODE_REF);
22204       break;
22205     case DW_TAG_rvalue_reference_type:
22206       this_type = read_tag_reference_type (die, cu, TYPE_CODE_RVALUE_REF);
22207       break;
22208     case DW_TAG_const_type:
22209       this_type = read_tag_const_type (die, cu);
22210       break;
22211     case DW_TAG_volatile_type:
22212       this_type = read_tag_volatile_type (die, cu);
22213       break;
22214     case DW_TAG_restrict_type:
22215       this_type = read_tag_restrict_type (die, cu);
22216       break;
22217     case DW_TAG_string_type:
22218       this_type = read_tag_string_type (die, cu);
22219       break;
22220     case DW_TAG_typedef:
22221       this_type = read_typedef (die, cu);
22222       break;
22223     case DW_TAG_subrange_type:
22224       this_type = read_subrange_type (die, cu);
22225       break;
22226     case DW_TAG_base_type:
22227       this_type = read_base_type (die, cu);
22228       break;
22229     case DW_TAG_unspecified_type:
22230       this_type = read_unspecified_type (die, cu);
22231       break;
22232     case DW_TAG_namespace:
22233       this_type = read_namespace_type (die, cu);
22234       break;
22235     case DW_TAG_module:
22236       this_type = read_module_type (die, cu);
22237       break;
22238     case DW_TAG_atomic_type:
22239       this_type = read_tag_atomic_type (die, cu);
22240       break;
22241     default:
22242       complaint (_("unexpected tag in read_type_die: '%s'"),
22243                  dwarf_tag_name (die->tag));
22244       break;
22245     }
22246
22247   return this_type;
22248 }
22249
22250 /* See if we can figure out if the class lives in a namespace.  We do
22251    this by looking for a member function; its demangled name will
22252    contain namespace info, if there is any.
22253    Return the computed name or NULL.
22254    Space for the result is allocated on the objfile's obstack.
22255    This is the full-die version of guess_partial_die_structure_name.
22256    In this case we know DIE has no useful parent.  */
22257
22258 static char *
22259 guess_full_die_structure_name (struct die_info *die, struct dwarf2_cu *cu)
22260 {
22261   struct die_info *spec_die;
22262   struct dwarf2_cu *spec_cu;
22263   struct die_info *child;
22264   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22265
22266   spec_cu = cu;
22267   spec_die = die_specification (die, &spec_cu);
22268   if (spec_die != NULL)
22269     {
22270       die = spec_die;
22271       cu = spec_cu;
22272     }
22273
22274   for (child = die->child;
22275        child != NULL;
22276        child = child->sibling)
22277     {
22278       if (child->tag == DW_TAG_subprogram)
22279         {
22280           const char *linkage_name = dw2_linkage_name (child, cu);
22281
22282           if (linkage_name != NULL)
22283             {
22284               char *actual_name
22285                 = language_class_name_from_physname (cu->language_defn,
22286                                                      linkage_name);
22287               char *name = NULL;
22288
22289               if (actual_name != NULL)
22290                 {
22291                   const char *die_name = dwarf2_name (die, cu);
22292
22293                   if (die_name != NULL
22294                       && strcmp (die_name, actual_name) != 0)
22295                     {
22296                       /* Strip off the class name from the full name.
22297                          We want the prefix.  */
22298                       int die_name_len = strlen (die_name);
22299                       int actual_name_len = strlen (actual_name);
22300
22301                       /* Test for '::' as a sanity check.  */
22302                       if (actual_name_len > die_name_len + 2
22303                           && actual_name[actual_name_len
22304                                          - die_name_len - 1] == ':')
22305                         name = (char *) obstack_copy0 (
22306                           &objfile->per_bfd->storage_obstack,
22307                           actual_name, actual_name_len - die_name_len - 2);
22308                     }
22309                 }
22310               xfree (actual_name);
22311               return name;
22312             }
22313         }
22314     }
22315
22316   return NULL;
22317 }
22318
22319 /* GCC might emit a nameless typedef that has a linkage name.  Determine the
22320    prefix part in such case.  See
22321    http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510.  */
22322
22323 static const char *
22324 anonymous_struct_prefix (struct die_info *die, struct dwarf2_cu *cu)
22325 {
22326   struct attribute *attr;
22327   const char *base;
22328
22329   if (die->tag != DW_TAG_class_type && die->tag != DW_TAG_interface_type
22330       && die->tag != DW_TAG_structure_type && die->tag != DW_TAG_union_type)
22331     return NULL;
22332
22333   if (dwarf2_string_attr (die, DW_AT_name, cu) != NULL)
22334     return NULL;
22335
22336   attr = dw2_linkage_name_attr (die, cu);
22337   if (attr == NULL || DW_STRING (attr) == NULL)
22338     return NULL;
22339
22340   /* dwarf2_name had to be already called.  */
22341   gdb_assert (DW_STRING_IS_CANONICAL (attr));
22342
22343   /* Strip the base name, keep any leading namespaces/classes.  */
22344   base = strrchr (DW_STRING (attr), ':');
22345   if (base == NULL || base == DW_STRING (attr) || base[-1] != ':')
22346     return "";
22347
22348   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22349   return (char *) obstack_copy0 (&objfile->per_bfd->storage_obstack,
22350                                  DW_STRING (attr),
22351                                  &base[-1] - DW_STRING (attr));
22352 }
22353
22354 /* Return the name of the namespace/class that DIE is defined within,
22355    or "" if we can't tell.  The caller should not xfree the result.
22356
22357    For example, if we're within the method foo() in the following
22358    code:
22359
22360    namespace N {
22361      class C {
22362        void foo () {
22363        }
22364      };
22365    }
22366
22367    then determine_prefix on foo's die will return "N::C".  */
22368
22369 static const char *
22370 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
22371 {
22372   struct dwarf2_per_objfile *dwarf2_per_objfile
22373     = cu->per_cu->dwarf2_per_objfile;
22374   struct die_info *parent, *spec_die;
22375   struct dwarf2_cu *spec_cu;
22376   struct type *parent_type;
22377   const char *retval;
22378
22379   if (cu->language != language_cplus
22380       && cu->language != language_fortran && cu->language != language_d
22381       && cu->language != language_rust)
22382     return "";
22383
22384   retval = anonymous_struct_prefix (die, cu);
22385   if (retval)
22386     return retval;
22387
22388   /* We have to be careful in the presence of DW_AT_specification.
22389      For example, with GCC 3.4, given the code
22390
22391      namespace N {
22392        void foo() {
22393          // Definition of N::foo.
22394        }
22395      }
22396
22397      then we'll have a tree of DIEs like this:
22398
22399      1: DW_TAG_compile_unit
22400        2: DW_TAG_namespace        // N
22401          3: DW_TAG_subprogram     // declaration of N::foo
22402        4: DW_TAG_subprogram       // definition of N::foo
22403             DW_AT_specification   // refers to die #3
22404
22405      Thus, when processing die #4, we have to pretend that we're in
22406      the context of its DW_AT_specification, namely the contex of die
22407      #3.  */
22408   spec_cu = cu;
22409   spec_die = die_specification (die, &spec_cu);
22410   if (spec_die == NULL)
22411     parent = die->parent;
22412   else
22413     {
22414       parent = spec_die->parent;
22415       cu = spec_cu;
22416     }
22417
22418   if (parent == NULL)
22419     return "";
22420   else if (parent->building_fullname)
22421     {
22422       const char *name;
22423       const char *parent_name;
22424
22425       /* It has been seen on RealView 2.2 built binaries,
22426          DW_TAG_template_type_param types actually _defined_ as
22427          children of the parent class:
22428
22429          enum E {};
22430          template class <class Enum> Class{};
22431          Class<enum E> class_e;
22432
22433          1: DW_TAG_class_type (Class)
22434            2: DW_TAG_enumeration_type (E)
22435              3: DW_TAG_enumerator (enum1:0)
22436              3: DW_TAG_enumerator (enum2:1)
22437              ...
22438            2: DW_TAG_template_type_param
22439               DW_AT_type  DW_FORM_ref_udata (E)
22440
22441          Besides being broken debug info, it can put GDB into an
22442          infinite loop.  Consider:
22443
22444          When we're building the full name for Class<E>, we'll start
22445          at Class, and go look over its template type parameters,
22446          finding E.  We'll then try to build the full name of E, and
22447          reach here.  We're now trying to build the full name of E,
22448          and look over the parent DIE for containing scope.  In the
22449          broken case, if we followed the parent DIE of E, we'd again
22450          find Class, and once again go look at its template type
22451          arguments, etc., etc.  Simply don't consider such parent die
22452          as source-level parent of this die (it can't be, the language
22453          doesn't allow it), and break the loop here.  */
22454       name = dwarf2_name (die, cu);
22455       parent_name = dwarf2_name (parent, cu);
22456       complaint (_("template param type '%s' defined within parent '%s'"),
22457                  name ? name : "<unknown>",
22458                  parent_name ? parent_name : "<unknown>");
22459       return "";
22460     }
22461   else
22462     switch (parent->tag)
22463       {
22464       case DW_TAG_namespace:
22465         parent_type = read_type_die (parent, cu);
22466         /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
22467            DW_TAG_namespace DIEs with a name of "::" for the global namespace.
22468            Work around this problem here.  */
22469         if (cu->language == language_cplus
22470             && strcmp (TYPE_NAME (parent_type), "::") == 0)
22471           return "";
22472         /* We give a name to even anonymous namespaces.  */
22473         return TYPE_NAME (parent_type);
22474       case DW_TAG_class_type:
22475       case DW_TAG_interface_type:
22476       case DW_TAG_structure_type:
22477       case DW_TAG_union_type:
22478       case DW_TAG_module:
22479         parent_type = read_type_die (parent, cu);
22480         if (TYPE_NAME (parent_type) != NULL)
22481           return TYPE_NAME (parent_type);
22482         else
22483           /* An anonymous structure is only allowed non-static data
22484              members; no typedefs, no member functions, et cetera.
22485              So it does not need a prefix.  */
22486           return "";
22487       case DW_TAG_compile_unit:
22488       case DW_TAG_partial_unit:
22489         /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace.  Cope.  */
22490         if (cu->language == language_cplus
22491             && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
22492             && die->child != NULL
22493             && (die->tag == DW_TAG_class_type
22494                 || die->tag == DW_TAG_structure_type
22495                 || die->tag == DW_TAG_union_type))
22496           {
22497             char *name = guess_full_die_structure_name (die, cu);
22498             if (name != NULL)
22499               return name;
22500           }
22501         return "";
22502       case DW_TAG_enumeration_type:
22503         parent_type = read_type_die (parent, cu);
22504         if (TYPE_DECLARED_CLASS (parent_type))
22505           {
22506             if (TYPE_NAME (parent_type) != NULL)
22507               return TYPE_NAME (parent_type);
22508             return "";
22509           }
22510         /* Fall through.  */
22511       default:
22512         return determine_prefix (parent, cu);
22513       }
22514 }
22515
22516 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
22517    with appropriate separator.  If PREFIX or SUFFIX is NULL or empty, then
22518    simply copy the SUFFIX or PREFIX, respectively.  If OBS is non-null, perform
22519    an obconcat, otherwise allocate storage for the result.  The CU argument is
22520    used to determine the language and hence, the appropriate separator.  */
22521
22522 #define MAX_SEP_LEN 7  /* strlen ("__") + strlen ("_MOD_")  */
22523
22524 static char *
22525 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
22526                  int physname, struct dwarf2_cu *cu)
22527 {
22528   const char *lead = "";
22529   const char *sep;
22530
22531   if (suffix == NULL || suffix[0] == '\0'
22532       || prefix == NULL || prefix[0] == '\0')
22533     sep = "";
22534   else if (cu->language == language_d)
22535     {
22536       /* For D, the 'main' function could be defined in any module, but it
22537          should never be prefixed.  */
22538       if (strcmp (suffix, "D main") == 0)
22539         {
22540           prefix = "";
22541           sep = "";
22542         }
22543       else
22544         sep = ".";
22545     }
22546   else if (cu->language == language_fortran && physname)
22547     {
22548       /* This is gfortran specific mangling.  Normally DW_AT_linkage_name or
22549          DW_AT_MIPS_linkage_name is preferred and used instead.  */
22550
22551       lead = "__";
22552       sep = "_MOD_";
22553     }
22554   else
22555     sep = "::";
22556
22557   if (prefix == NULL)
22558     prefix = "";
22559   if (suffix == NULL)
22560     suffix = "";
22561
22562   if (obs == NULL)
22563     {
22564       char *retval
22565         = ((char *)
22566            xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1));
22567
22568       strcpy (retval, lead);
22569       strcat (retval, prefix);
22570       strcat (retval, sep);
22571       strcat (retval, suffix);
22572       return retval;
22573     }
22574   else
22575     {
22576       /* We have an obstack.  */
22577       return obconcat (obs, lead, prefix, sep, suffix, (char *) NULL);
22578     }
22579 }
22580
22581 /* Return sibling of die, NULL if no sibling.  */
22582
22583 static struct die_info *
22584 sibling_die (struct die_info *die)
22585 {
22586   return die->sibling;
22587 }
22588
22589 /* Get name of a die, return NULL if not found.  */
22590
22591 static const char *
22592 dwarf2_canonicalize_name (const char *name, struct dwarf2_cu *cu,
22593                           struct obstack *obstack)
22594 {
22595   if (name && cu->language == language_cplus)
22596     {
22597       std::string canon_name = cp_canonicalize_string (name);
22598
22599       if (!canon_name.empty ())
22600         {
22601           if (canon_name != name)
22602             name = (const char *) obstack_copy0 (obstack,
22603                                                  canon_name.c_str (),
22604                                                  canon_name.length ());
22605         }
22606     }
22607
22608   return name;
22609 }
22610
22611 /* Get name of a die, return NULL if not found.
22612    Anonymous namespaces are converted to their magic string.  */
22613
22614 static const char *
22615 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
22616 {
22617   struct attribute *attr;
22618   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
22619
22620   attr = dwarf2_attr (die, DW_AT_name, cu);
22621   if ((!attr || !DW_STRING (attr))
22622       && die->tag != DW_TAG_namespace
22623       && die->tag != DW_TAG_class_type
22624       && die->tag != DW_TAG_interface_type
22625       && die->tag != DW_TAG_structure_type
22626       && die->tag != DW_TAG_union_type)
22627     return NULL;
22628
22629   switch (die->tag)
22630     {
22631     case DW_TAG_compile_unit:
22632     case DW_TAG_partial_unit:
22633       /* Compilation units have a DW_AT_name that is a filename, not
22634          a source language identifier.  */
22635     case DW_TAG_enumeration_type:
22636     case DW_TAG_enumerator:
22637       /* These tags always have simple identifiers already; no need
22638          to canonicalize them.  */
22639       return DW_STRING (attr);
22640
22641     case DW_TAG_namespace:
22642       if (attr != NULL && DW_STRING (attr) != NULL)
22643         return DW_STRING (attr);
22644       return CP_ANONYMOUS_NAMESPACE_STR;
22645
22646     case DW_TAG_class_type:
22647     case DW_TAG_interface_type:
22648     case DW_TAG_structure_type:
22649     case DW_TAG_union_type:
22650       /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
22651          structures or unions.  These were of the form "._%d" in GCC 4.1,
22652          or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
22653          and GCC 4.4.  We work around this problem by ignoring these.  */
22654       if (attr && DW_STRING (attr)
22655           && (startswith (DW_STRING (attr), "._")
22656               || startswith (DW_STRING (attr), "<anonymous")))
22657         return NULL;
22658
22659       /* GCC might emit a nameless typedef that has a linkage name.  See
22660          http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510.  */
22661       if (!attr || DW_STRING (attr) == NULL)
22662         {
22663           char *demangled = NULL;
22664
22665           attr = dw2_linkage_name_attr (die, cu);
22666           if (attr == NULL || DW_STRING (attr) == NULL)
22667             return NULL;
22668
22669           /* Avoid demangling DW_STRING (attr) the second time on a second
22670              call for the same DIE.  */
22671           if (!DW_STRING_IS_CANONICAL (attr))
22672             demangled = gdb_demangle (DW_STRING (attr), DMGL_TYPES);
22673
22674           if (demangled)
22675             {
22676               const char *base;
22677
22678               /* FIXME: we already did this for the partial symbol... */
22679               DW_STRING (attr)
22680                 = ((const char *)
22681                    obstack_copy0 (&objfile->per_bfd->storage_obstack,
22682                                   demangled, strlen (demangled)));
22683               DW_STRING_IS_CANONICAL (attr) = 1;
22684               xfree (demangled);
22685
22686               /* Strip any leading namespaces/classes, keep only the base name.
22687                  DW_AT_name for named DIEs does not contain the prefixes.  */
22688               base = strrchr (DW_STRING (attr), ':');
22689               if (base && base > DW_STRING (attr) && base[-1] == ':')
22690                 return &base[1];
22691               else
22692                 return DW_STRING (attr);
22693             }
22694         }
22695       break;
22696
22697     default:
22698       break;
22699     }
22700
22701   if (!DW_STRING_IS_CANONICAL (attr))
22702     {
22703       DW_STRING (attr)
22704         = dwarf2_canonicalize_name (DW_STRING (attr), cu,
22705                                     &objfile->per_bfd->storage_obstack);
22706       DW_STRING_IS_CANONICAL (attr) = 1;
22707     }
22708   return DW_STRING (attr);
22709 }
22710
22711 /* Return the die that this die in an extension of, or NULL if there
22712    is none.  *EXT_CU is the CU containing DIE on input, and the CU
22713    containing the return value on output.  */
22714
22715 static struct die_info *
22716 dwarf2_extension (struct die_info *die, struct dwarf2_cu **ext_cu)
22717 {
22718   struct attribute *attr;
22719
22720   attr = dwarf2_attr (die, DW_AT_extension, *ext_cu);
22721   if (attr == NULL)
22722     return NULL;
22723
22724   return follow_die_ref (die, attr, ext_cu);
22725 }
22726
22727 /* Convert a DIE tag into its string name.  */
22728
22729 static const char *
22730 dwarf_tag_name (unsigned tag)
22731 {
22732   const char *name = get_DW_TAG_name (tag);
22733
22734   if (name == NULL)
22735     return "DW_TAG_<unknown>";
22736
22737   return name;
22738 }
22739
22740 /* Convert a DWARF attribute code into its string name.  */
22741
22742 static const char *
22743 dwarf_attr_name (unsigned attr)
22744 {
22745   const char *name;
22746
22747 #ifdef MIPS /* collides with DW_AT_HP_block_index */
22748   if (attr == DW_AT_MIPS_fde)
22749     return "DW_AT_MIPS_fde";
22750 #else
22751   if (attr == DW_AT_HP_block_index)
22752     return "DW_AT_HP_block_index";
22753 #endif
22754
22755   name = get_DW_AT_name (attr);
22756
22757   if (name == NULL)
22758     return "DW_AT_<unknown>";
22759
22760   return name;
22761 }
22762
22763 /* Convert a DWARF value form code into its string name.  */
22764
22765 static const char *
22766 dwarf_form_name (unsigned form)
22767 {
22768   const char *name = get_DW_FORM_name (form);
22769
22770   if (name == NULL)
22771     return "DW_FORM_<unknown>";
22772
22773   return name;
22774 }
22775
22776 static const char *
22777 dwarf_bool_name (unsigned mybool)
22778 {
22779   if (mybool)
22780     return "TRUE";
22781   else
22782     return "FALSE";
22783 }
22784
22785 /* Convert a DWARF type code into its string name.  */
22786
22787 static const char *
22788 dwarf_type_encoding_name (unsigned enc)
22789 {
22790   const char *name = get_DW_ATE_name (enc);
22791
22792   if (name == NULL)
22793     return "DW_ATE_<unknown>";
22794
22795   return name;
22796 }
22797
22798 static void
22799 dump_die_shallow (struct ui_file *f, int indent, struct die_info *die)
22800 {
22801   unsigned int i;
22802
22803   print_spaces (indent, f);
22804   fprintf_unfiltered (f, "Die: %s (abbrev %d, offset %s)\n",
22805                       dwarf_tag_name (die->tag), die->abbrev,
22806                       sect_offset_str (die->sect_off));
22807
22808   if (die->parent != NULL)
22809     {
22810       print_spaces (indent, f);
22811       fprintf_unfiltered (f, "  parent at offset: %s\n",
22812                           sect_offset_str (die->parent->sect_off));
22813     }
22814
22815   print_spaces (indent, f);
22816   fprintf_unfiltered (f, "  has children: %s\n",
22817            dwarf_bool_name (die->child != NULL));
22818
22819   print_spaces (indent, f);
22820   fprintf_unfiltered (f, "  attributes:\n");
22821
22822   for (i = 0; i < die->num_attrs; ++i)
22823     {
22824       print_spaces (indent, f);
22825       fprintf_unfiltered (f, "    %s (%s) ",
22826                dwarf_attr_name (die->attrs[i].name),
22827                dwarf_form_name (die->attrs[i].form));
22828
22829       switch (die->attrs[i].form)
22830         {
22831         case DW_FORM_addr:
22832         case DW_FORM_GNU_addr_index:
22833           fprintf_unfiltered (f, "address: ");
22834           fputs_filtered (hex_string (DW_ADDR (&die->attrs[i])), f);
22835           break;
22836         case DW_FORM_block2:
22837         case DW_FORM_block4:
22838         case DW_FORM_block:
22839         case DW_FORM_block1:
22840           fprintf_unfiltered (f, "block: size %s",
22841                               pulongest (DW_BLOCK (&die->attrs[i])->size));
22842           break;
22843         case DW_FORM_exprloc:
22844           fprintf_unfiltered (f, "expression: size %s",
22845                               pulongest (DW_BLOCK (&die->attrs[i])->size));
22846           break;
22847         case DW_FORM_data16:
22848           fprintf_unfiltered (f, "constant of 16 bytes");
22849           break;
22850         case DW_FORM_ref_addr:
22851           fprintf_unfiltered (f, "ref address: ");
22852           fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
22853           break;
22854         case DW_FORM_GNU_ref_alt:
22855           fprintf_unfiltered (f, "alt ref address: ");
22856           fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
22857           break;
22858         case DW_FORM_ref1:
22859         case DW_FORM_ref2:
22860         case DW_FORM_ref4:
22861         case DW_FORM_ref8:
22862         case DW_FORM_ref_udata:
22863           fprintf_unfiltered (f, "constant ref: 0x%lx (adjusted)",
22864                               (long) (DW_UNSND (&die->attrs[i])));
22865           break;
22866         case DW_FORM_data1:
22867         case DW_FORM_data2:
22868         case DW_FORM_data4:
22869         case DW_FORM_data8:
22870         case DW_FORM_udata:
22871         case DW_FORM_sdata:
22872           fprintf_unfiltered (f, "constant: %s",
22873                               pulongest (DW_UNSND (&die->attrs[i])));
22874           break;
22875         case DW_FORM_sec_offset:
22876           fprintf_unfiltered (f, "section offset: %s",
22877                               pulongest (DW_UNSND (&die->attrs[i])));
22878           break;
22879         case DW_FORM_ref_sig8:
22880           fprintf_unfiltered (f, "signature: %s",
22881                               hex_string (DW_SIGNATURE (&die->attrs[i])));
22882           break;
22883         case DW_FORM_string:
22884         case DW_FORM_strp:
22885         case DW_FORM_line_strp:
22886         case DW_FORM_GNU_str_index:
22887         case DW_FORM_GNU_strp_alt:
22888           fprintf_unfiltered (f, "string: \"%s\" (%s canonicalized)",
22889                    DW_STRING (&die->attrs[i])
22890                    ? DW_STRING (&die->attrs[i]) : "",
22891                    DW_STRING_IS_CANONICAL (&die->attrs[i]) ? "is" : "not");
22892           break;
22893         case DW_FORM_flag:
22894           if (DW_UNSND (&die->attrs[i]))
22895             fprintf_unfiltered (f, "flag: TRUE");
22896           else
22897             fprintf_unfiltered (f, "flag: FALSE");
22898           break;
22899         case DW_FORM_flag_present:
22900           fprintf_unfiltered (f, "flag: TRUE");
22901           break;
22902         case DW_FORM_indirect:
22903           /* The reader will have reduced the indirect form to
22904              the "base form" so this form should not occur.  */
22905           fprintf_unfiltered (f, 
22906                               "unexpected attribute form: DW_FORM_indirect");
22907           break;
22908         case DW_FORM_implicit_const:
22909           fprintf_unfiltered (f, "constant: %s",
22910                               plongest (DW_SND (&die->attrs[i])));
22911           break;
22912         default:
22913           fprintf_unfiltered (f, "unsupported attribute form: %d.",
22914                    die->attrs[i].form);
22915           break;
22916         }
22917       fprintf_unfiltered (f, "\n");
22918     }
22919 }
22920
22921 static void
22922 dump_die_for_error (struct die_info *die)
22923 {
22924   dump_die_shallow (gdb_stderr, 0, die);
22925 }
22926
22927 static void
22928 dump_die_1 (struct ui_file *f, int level, int max_level, struct die_info *die)
22929 {
22930   int indent = level * 4;
22931
22932   gdb_assert (die != NULL);
22933
22934   if (level >= max_level)
22935     return;
22936
22937   dump_die_shallow (f, indent, die);
22938
22939   if (die->child != NULL)
22940     {
22941       print_spaces (indent, f);
22942       fprintf_unfiltered (f, "  Children:");
22943       if (level + 1 < max_level)
22944         {
22945           fprintf_unfiltered (f, "\n");
22946           dump_die_1 (f, level + 1, max_level, die->child);
22947         }
22948       else
22949         {
22950           fprintf_unfiltered (f,
22951                               " [not printed, max nesting level reached]\n");
22952         }
22953     }
22954
22955   if (die->sibling != NULL && level > 0)
22956     {
22957       dump_die_1 (f, level, max_level, die->sibling);
22958     }
22959 }
22960
22961 /* This is called from the pdie macro in gdbinit.in.
22962    It's not static so gcc will keep a copy callable from gdb.  */
22963
22964 void
22965 dump_die (struct die_info *die, int max_level)
22966 {
22967   dump_die_1 (gdb_stdlog, 0, max_level, die);
22968 }
22969
22970 static void
22971 store_in_ref_table (struct die_info *die, struct dwarf2_cu *cu)
22972 {
22973   void **slot;
22974
22975   slot = htab_find_slot_with_hash (cu->die_hash, die,
22976                                    to_underlying (die->sect_off),
22977                                    INSERT);
22978
22979   *slot = die;
22980 }
22981
22982 /* Return DIE offset of ATTR.  Return 0 with complaint if ATTR is not of the
22983    required kind.  */
22984
22985 static sect_offset
22986 dwarf2_get_ref_die_offset (const struct attribute *attr)
22987 {
22988   if (attr_form_is_ref (attr))
22989     return (sect_offset) DW_UNSND (attr);
22990
22991   complaint (_("unsupported die ref attribute form: '%s'"),
22992              dwarf_form_name (attr->form));
22993   return {};
22994 }
22995
22996 /* Return the constant value held by ATTR.  Return DEFAULT_VALUE if
22997  * the value held by the attribute is not constant.  */
22998
22999 static LONGEST
23000 dwarf2_get_attr_constant_value (const struct attribute *attr, int default_value)
23001 {
23002   if (attr->form == DW_FORM_sdata || attr->form == DW_FORM_implicit_const)
23003     return DW_SND (attr);
23004   else if (attr->form == DW_FORM_udata
23005            || attr->form == DW_FORM_data1
23006            || attr->form == DW_FORM_data2
23007            || attr->form == DW_FORM_data4
23008            || attr->form == DW_FORM_data8)
23009     return DW_UNSND (attr);
23010   else
23011     {
23012       /* For DW_FORM_data16 see attr_form_is_constant.  */
23013       complaint (_("Attribute value is not a constant (%s)"),
23014                  dwarf_form_name (attr->form));
23015       return default_value;
23016     }
23017 }
23018
23019 /* Follow reference or signature attribute ATTR of SRC_DIE.
23020    On entry *REF_CU is the CU of SRC_DIE.
23021    On exit *REF_CU is the CU of the result.  */
23022
23023 static struct die_info *
23024 follow_die_ref_or_sig (struct die_info *src_die, const struct attribute *attr,
23025                        struct dwarf2_cu **ref_cu)
23026 {
23027   struct die_info *die;
23028
23029   if (attr_form_is_ref (attr))
23030     die = follow_die_ref (src_die, attr, ref_cu);
23031   else if (attr->form == DW_FORM_ref_sig8)
23032     die = follow_die_sig (src_die, attr, ref_cu);
23033   else
23034     {
23035       dump_die_for_error (src_die);
23036       error (_("Dwarf Error: Expected reference attribute [in module %s]"),
23037              objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23038     }
23039
23040   return die;
23041 }
23042
23043 /* Follow reference OFFSET.
23044    On entry *REF_CU is the CU of the source die referencing OFFSET.
23045    On exit *REF_CU is the CU of the result.
23046    Returns NULL if OFFSET is invalid.  */
23047
23048 static struct die_info *
23049 follow_die_offset (sect_offset sect_off, int offset_in_dwz,
23050                    struct dwarf2_cu **ref_cu)
23051 {
23052   struct die_info temp_die;
23053   struct dwarf2_cu *target_cu, *cu = *ref_cu;
23054   struct dwarf2_per_objfile *dwarf2_per_objfile
23055     = cu->per_cu->dwarf2_per_objfile;
23056
23057   gdb_assert (cu->per_cu != NULL);
23058
23059   target_cu = cu;
23060
23061   if (cu->per_cu->is_debug_types)
23062     {
23063       /* .debug_types CUs cannot reference anything outside their CU.
23064          If they need to, they have to reference a signatured type via
23065          DW_FORM_ref_sig8.  */
23066       if (!offset_in_cu_p (&cu->header, sect_off))
23067         return NULL;
23068     }
23069   else if (offset_in_dwz != cu->per_cu->is_dwz
23070            || !offset_in_cu_p (&cu->header, sect_off))
23071     {
23072       struct dwarf2_per_cu_data *per_cu;
23073
23074       per_cu = dwarf2_find_containing_comp_unit (sect_off, offset_in_dwz,
23075                                                  dwarf2_per_objfile);
23076
23077       /* If necessary, add it to the queue and load its DIEs.  */
23078       if (maybe_queue_comp_unit (cu, per_cu, cu->language))
23079         load_full_comp_unit (per_cu, false, cu->language);
23080
23081       target_cu = per_cu->cu;
23082     }
23083   else if (cu->dies == NULL)
23084     {
23085       /* We're loading full DIEs during partial symbol reading.  */
23086       gdb_assert (dwarf2_per_objfile->reading_partial_symbols);
23087       load_full_comp_unit (cu->per_cu, false, language_minimal);
23088     }
23089
23090   *ref_cu = target_cu;
23091   temp_die.sect_off = sect_off;
23092
23093   if (target_cu != cu)
23094     target_cu->ancestor = cu;
23095
23096   return (struct die_info *) htab_find_with_hash (target_cu->die_hash,
23097                                                   &temp_die,
23098                                                   to_underlying (sect_off));
23099 }
23100
23101 /* Follow reference attribute ATTR of SRC_DIE.
23102    On entry *REF_CU is the CU of SRC_DIE.
23103    On exit *REF_CU is the CU of the result.  */
23104
23105 static struct die_info *
23106 follow_die_ref (struct die_info *src_die, const struct attribute *attr,
23107                 struct dwarf2_cu **ref_cu)
23108 {
23109   sect_offset sect_off = dwarf2_get_ref_die_offset (attr);
23110   struct dwarf2_cu *cu = *ref_cu;
23111   struct die_info *die;
23112
23113   die = follow_die_offset (sect_off,
23114                            (attr->form == DW_FORM_GNU_ref_alt
23115                             || cu->per_cu->is_dwz),
23116                            ref_cu);
23117   if (!die)
23118     error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
23119            "at %s [in module %s]"),
23120            sect_offset_str (sect_off), sect_offset_str (src_die->sect_off),
23121            objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
23122
23123   return die;
23124 }
23125
23126 /* Return DWARF block referenced by DW_AT_location of DIE at SECT_OFF at PER_CU.
23127    Returned value is intended for DW_OP_call*.  Returned
23128    dwarf2_locexpr_baton->data has lifetime of
23129    PER_CU->DWARF2_PER_OBJFILE->OBJFILE.  */
23130
23131 struct dwarf2_locexpr_baton
23132 dwarf2_fetch_die_loc_sect_off (sect_offset sect_off,
23133                                struct dwarf2_per_cu_data *per_cu,
23134                                CORE_ADDR (*get_frame_pc) (void *baton),
23135                                void *baton, bool resolve_abstract_p)
23136 {
23137   struct dwarf2_cu *cu;
23138   struct die_info *die;
23139   struct attribute *attr;
23140   struct dwarf2_locexpr_baton retval;
23141   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
23142   struct objfile *objfile = dwarf2_per_objfile->objfile;
23143
23144   if (per_cu->cu == NULL)
23145     load_cu (per_cu, false);
23146   cu = per_cu->cu;
23147   if (cu == NULL)
23148     {
23149       /* We shouldn't get here for a dummy CU, but don't crash on the user.
23150          Instead just throw an error, not much else we can do.  */
23151       error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23152              sect_offset_str (sect_off), objfile_name (objfile));
23153     }
23154
23155   die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23156   if (!die)
23157     error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23158            sect_offset_str (sect_off), objfile_name (objfile));
23159
23160   attr = dwarf2_attr (die, DW_AT_location, cu);
23161   if (!attr && resolve_abstract_p
23162       && (dwarf2_per_objfile->abstract_to_concrete.find (die)
23163           != dwarf2_per_objfile->abstract_to_concrete.end ()))
23164     {
23165       CORE_ADDR pc = (*get_frame_pc) (baton);
23166
23167       for (const auto &cand : dwarf2_per_objfile->abstract_to_concrete[die])
23168         {
23169           if (!cand->parent
23170               || cand->parent->tag != DW_TAG_subprogram)
23171             continue;
23172
23173           CORE_ADDR pc_low, pc_high;
23174           get_scope_pc_bounds (cand->parent, &pc_low, &pc_high, cu);
23175           if (pc_low == ((CORE_ADDR) -1)
23176               || !(pc_low <= pc && pc < pc_high))
23177             continue;
23178
23179           die = cand;
23180           attr = dwarf2_attr (die, DW_AT_location, cu);
23181           break;
23182         }
23183     }
23184
23185   if (!attr)
23186     {
23187       /* DWARF: "If there is no such attribute, then there is no effect.".
23188          DATA is ignored if SIZE is 0.  */
23189
23190       retval.data = NULL;
23191       retval.size = 0;
23192     }
23193   else if (attr_form_is_section_offset (attr))
23194     {
23195       struct dwarf2_loclist_baton loclist_baton;
23196       CORE_ADDR pc = (*get_frame_pc) (baton);
23197       size_t size;
23198
23199       fill_in_loclist_baton (cu, &loclist_baton, attr);
23200
23201       retval.data = dwarf2_find_location_expression (&loclist_baton,
23202                                                      &size, pc);
23203       retval.size = size;
23204     }
23205   else
23206     {
23207       if (!attr_form_is_block (attr))
23208         error (_("Dwarf Error: DIE at %s referenced in module %s "
23209                  "is neither DW_FORM_block* nor DW_FORM_exprloc"),
23210                sect_offset_str (sect_off), objfile_name (objfile));
23211
23212       retval.data = DW_BLOCK (attr)->data;
23213       retval.size = DW_BLOCK (attr)->size;
23214     }
23215   retval.per_cu = cu->per_cu;
23216
23217   age_cached_comp_units (dwarf2_per_objfile);
23218
23219   return retval;
23220 }
23221
23222 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
23223    offset.  */
23224
23225 struct dwarf2_locexpr_baton
23226 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu,
23227                              struct dwarf2_per_cu_data *per_cu,
23228                              CORE_ADDR (*get_frame_pc) (void *baton),
23229                              void *baton)
23230 {
23231   sect_offset sect_off = per_cu->sect_off + to_underlying (offset_in_cu);
23232
23233   return dwarf2_fetch_die_loc_sect_off (sect_off, per_cu, get_frame_pc, baton);
23234 }
23235
23236 /* Write a constant of a given type as target-ordered bytes into
23237    OBSTACK.  */
23238
23239 static const gdb_byte *
23240 write_constant_as_bytes (struct obstack *obstack,
23241                          enum bfd_endian byte_order,
23242                          struct type *type,
23243                          ULONGEST value,
23244                          LONGEST *len)
23245 {
23246   gdb_byte *result;
23247
23248   *len = TYPE_LENGTH (type);
23249   result = (gdb_byte *) obstack_alloc (obstack, *len);
23250   store_unsigned_integer (result, *len, byte_order, value);
23251
23252   return result;
23253 }
23254
23255 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
23256    pointer to the constant bytes and set LEN to the length of the
23257    data.  If memory is needed, allocate it on OBSTACK.  If the DIE
23258    does not have a DW_AT_const_value, return NULL.  */
23259
23260 const gdb_byte *
23261 dwarf2_fetch_constant_bytes (sect_offset sect_off,
23262                              struct dwarf2_per_cu_data *per_cu,
23263                              struct obstack *obstack,
23264                              LONGEST *len)
23265 {
23266   struct dwarf2_cu *cu;
23267   struct die_info *die;
23268   struct attribute *attr;
23269   const gdb_byte *result = NULL;
23270   struct type *type;
23271   LONGEST value;
23272   enum bfd_endian byte_order;
23273   struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
23274
23275   if (per_cu->cu == NULL)
23276     load_cu (per_cu, false);
23277   cu = per_cu->cu;
23278   if (cu == NULL)
23279     {
23280       /* We shouldn't get here for a dummy CU, but don't crash on the user.
23281          Instead just throw an error, not much else we can do.  */
23282       error (_("Dwarf Error: Dummy CU at %s referenced in module %s"),
23283              sect_offset_str (sect_off), objfile_name (objfile));
23284     }
23285
23286   die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23287   if (!die)
23288     error (_("Dwarf Error: Cannot find DIE at %s referenced in module %s"),
23289            sect_offset_str (sect_off), objfile_name (objfile));
23290
23291   attr = dwarf2_attr (die, DW_AT_const_value, cu);
23292   if (attr == NULL)
23293     return NULL;
23294
23295   byte_order = (bfd_big_endian (objfile->obfd)
23296                 ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
23297
23298   switch (attr->form)
23299     {
23300     case DW_FORM_addr:
23301     case DW_FORM_GNU_addr_index:
23302       {
23303         gdb_byte *tem;
23304
23305         *len = cu->header.addr_size;
23306         tem = (gdb_byte *) obstack_alloc (obstack, *len);
23307         store_unsigned_integer (tem, *len, byte_order, DW_ADDR (attr));
23308         result = tem;
23309       }
23310       break;
23311     case DW_FORM_string:
23312     case DW_FORM_strp:
23313     case DW_FORM_GNU_str_index:
23314     case DW_FORM_GNU_strp_alt:
23315       /* DW_STRING is already allocated on the objfile obstack, point
23316          directly to it.  */
23317       result = (const gdb_byte *) DW_STRING (attr);
23318       *len = strlen (DW_STRING (attr));
23319       break;
23320     case DW_FORM_block1:
23321     case DW_FORM_block2:
23322     case DW_FORM_block4:
23323     case DW_FORM_block:
23324     case DW_FORM_exprloc:
23325     case DW_FORM_data16:
23326       result = DW_BLOCK (attr)->data;
23327       *len = DW_BLOCK (attr)->size;
23328       break;
23329
23330       /* The DW_AT_const_value attributes are supposed to carry the
23331          symbol's value "represented as it would be on the target
23332          architecture."  By the time we get here, it's already been
23333          converted to host endianness, so we just need to sign- or
23334          zero-extend it as appropriate.  */
23335     case DW_FORM_data1:
23336       type = die_type (die, cu);
23337       result = dwarf2_const_value_data (attr, obstack, cu, &value, 8);
23338       if (result == NULL)
23339         result = write_constant_as_bytes (obstack, byte_order,
23340                                           type, value, len);
23341       break;
23342     case DW_FORM_data2:
23343       type = die_type (die, cu);
23344       result = dwarf2_const_value_data (attr, obstack, cu, &value, 16);
23345       if (result == NULL)
23346         result = write_constant_as_bytes (obstack, byte_order,
23347                                           type, value, len);
23348       break;
23349     case DW_FORM_data4:
23350       type = die_type (die, cu);
23351       result = dwarf2_const_value_data (attr, obstack, cu, &value, 32);
23352       if (result == NULL)
23353         result = write_constant_as_bytes (obstack, byte_order,
23354                                           type, value, len);
23355       break;
23356     case DW_FORM_data8:
23357       type = die_type (die, cu);
23358       result = dwarf2_const_value_data (attr, obstack, cu, &value, 64);
23359       if (result == NULL)
23360         result = write_constant_as_bytes (obstack, byte_order,
23361                                           type, value, len);
23362       break;
23363
23364     case DW_FORM_sdata:
23365     case DW_FORM_implicit_const:
23366       type = die_type (die, cu);
23367       result = write_constant_as_bytes (obstack, byte_order,
23368                                         type, DW_SND (attr), len);
23369       break;
23370
23371     case DW_FORM_udata:
23372       type = die_type (die, cu);
23373       result = write_constant_as_bytes (obstack, byte_order,
23374                                         type, DW_UNSND (attr), len);
23375       break;
23376
23377     default:
23378       complaint (_("unsupported const value attribute form: '%s'"),
23379                  dwarf_form_name (attr->form));
23380       break;
23381     }
23382
23383   return result;
23384 }
23385
23386 /* Return the type of the die at OFFSET in PER_CU.  Return NULL if no
23387    valid type for this die is found.  */
23388
23389 struct type *
23390 dwarf2_fetch_die_type_sect_off (sect_offset sect_off,
23391                                 struct dwarf2_per_cu_data *per_cu)
23392 {
23393   struct dwarf2_cu *cu;
23394   struct die_info *die;
23395
23396   if (per_cu->cu == NULL)
23397     load_cu (per_cu, false);
23398   cu = per_cu->cu;
23399   if (!cu)
23400     return NULL;
23401
23402   die = follow_die_offset (sect_off, per_cu->is_dwz, &cu);
23403   if (!die)
23404     return NULL;
23405
23406   return die_type (die, cu);
23407 }
23408
23409 /* Return the type of the DIE at DIE_OFFSET in the CU named by
23410    PER_CU.  */
23411
23412 struct type *
23413 dwarf2_get_die_type (cu_offset die_offset,
23414                      struct dwarf2_per_cu_data *per_cu)
23415 {
23416   sect_offset die_offset_sect = per_cu->sect_off + to_underlying (die_offset);
23417   return get_die_type_at_offset (die_offset_sect, per_cu);
23418 }
23419
23420 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
23421    On entry *REF_CU is the CU of SRC_DIE.
23422    On exit *REF_CU is the CU of the result.
23423    Returns NULL if the referenced DIE isn't found.  */
23424
23425 static struct die_info *
23426 follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type,
23427                   struct dwarf2_cu **ref_cu)
23428 {
23429   struct die_info temp_die;
23430   struct dwarf2_cu *sig_cu, *cu = *ref_cu;
23431   struct die_info *die;
23432
23433   /* While it might be nice to assert sig_type->type == NULL here,
23434      we can get here for DW_AT_imported_declaration where we need
23435      the DIE not the type.  */
23436
23437   /* If necessary, add it to the queue and load its DIEs.  */
23438
23439   if (maybe_queue_comp_unit (*ref_cu, &sig_type->per_cu, language_minimal))
23440     read_signatured_type (sig_type);
23441
23442   sig_cu = sig_type->per_cu.cu;
23443   gdb_assert (sig_cu != NULL);
23444   gdb_assert (to_underlying (sig_type->type_offset_in_section) != 0);
23445   temp_die.sect_off = sig_type->type_offset_in_section;
23446   die = (struct die_info *) htab_find_with_hash (sig_cu->die_hash, &temp_die,
23447                                                  to_underlying (temp_die.sect_off));
23448   if (die)
23449     {
23450       struct dwarf2_per_objfile *dwarf2_per_objfile
23451         = (*ref_cu)->per_cu->dwarf2_per_objfile;
23452
23453       /* For .gdb_index version 7 keep track of included TUs.
23454          http://sourceware.org/bugzilla/show_bug.cgi?id=15021.  */
23455       if (dwarf2_per_objfile->index_table != NULL
23456           && dwarf2_per_objfile->index_table->version <= 7)
23457         {
23458           VEC_safe_push (dwarf2_per_cu_ptr,
23459                          (*ref_cu)->per_cu->imported_symtabs,
23460                          sig_cu->per_cu);
23461         }
23462
23463       *ref_cu = sig_cu;
23464       if (sig_cu != cu)
23465         sig_cu->ancestor = cu;
23466
23467       return die;
23468     }
23469
23470   return NULL;
23471 }
23472
23473 /* Follow signatured type referenced by ATTR in SRC_DIE.
23474    On entry *REF_CU is the CU of SRC_DIE.
23475    On exit *REF_CU is the CU of the result.
23476    The result is the DIE of the type.
23477    If the referenced type cannot be found an error is thrown.  */
23478
23479 static struct die_info *
23480 follow_die_sig (struct die_info *src_die, const struct attribute *attr,
23481                 struct dwarf2_cu **ref_cu)
23482 {
23483   ULONGEST signature = DW_SIGNATURE (attr);
23484   struct signatured_type *sig_type;
23485   struct die_info *die;
23486
23487   gdb_assert (attr->form == DW_FORM_ref_sig8);
23488
23489   sig_type = lookup_signatured_type (*ref_cu, signature);
23490   /* sig_type will be NULL if the signatured type is missing from
23491      the debug info.  */
23492   if (sig_type == NULL)
23493     {
23494       error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23495                " from DIE at %s [in module %s]"),
23496              hex_string (signature), sect_offset_str (src_die->sect_off),
23497              objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23498     }
23499
23500   die = follow_die_sig_1 (src_die, sig_type, ref_cu);
23501   if (die == NULL)
23502     {
23503       dump_die_for_error (src_die);
23504       error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23505                " from DIE at %s [in module %s]"),
23506              hex_string (signature), sect_offset_str (src_die->sect_off),
23507              objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
23508     }
23509
23510   return die;
23511 }
23512
23513 /* Get the type specified by SIGNATURE referenced in DIE/CU,
23514    reading in and processing the type unit if necessary.  */
23515
23516 static struct type *
23517 get_signatured_type (struct die_info *die, ULONGEST signature,
23518                      struct dwarf2_cu *cu)
23519 {
23520   struct dwarf2_per_objfile *dwarf2_per_objfile
23521     = cu->per_cu->dwarf2_per_objfile;
23522   struct signatured_type *sig_type;
23523   struct dwarf2_cu *type_cu;
23524   struct die_info *type_die;
23525   struct type *type;
23526
23527   sig_type = lookup_signatured_type (cu, signature);
23528   /* sig_type will be NULL if the signatured type is missing from
23529      the debug info.  */
23530   if (sig_type == NULL)
23531     {
23532       complaint (_("Dwarf Error: Cannot find signatured DIE %s referenced"
23533                    " from DIE at %s [in module %s]"),
23534                  hex_string (signature), sect_offset_str (die->sect_off),
23535                  objfile_name (dwarf2_per_objfile->objfile));
23536       return build_error_marker_type (cu, die);
23537     }
23538
23539   /* If we already know the type we're done.  */
23540   if (sig_type->type != NULL)
23541     return sig_type->type;
23542
23543   type_cu = cu;
23544   type_die = follow_die_sig_1 (die, sig_type, &type_cu);
23545   if (type_die != NULL)
23546     {
23547       /* N.B. We need to call get_die_type to ensure only one type for this DIE
23548          is created.  This is important, for example, because for c++ classes
23549          we need TYPE_NAME set which is only done by new_symbol.  Blech.  */
23550       type = read_type_die (type_die, type_cu);
23551       if (type == NULL)
23552         {
23553           complaint (_("Dwarf Error: Cannot build signatured type %s"
23554                        " referenced from DIE at %s [in module %s]"),
23555                      hex_string (signature), sect_offset_str (die->sect_off),
23556                      objfile_name (dwarf2_per_objfile->objfile));
23557           type = build_error_marker_type (cu, die);
23558         }
23559     }
23560   else
23561     {
23562       complaint (_("Dwarf Error: Problem reading signatured DIE %s referenced"
23563                    " from DIE at %s [in module %s]"),
23564                  hex_string (signature), sect_offset_str (die->sect_off),
23565                  objfile_name (dwarf2_per_objfile->objfile));
23566       type = build_error_marker_type (cu, die);
23567     }
23568   sig_type->type = type;
23569
23570   return type;
23571 }
23572
23573 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
23574    reading in and processing the type unit if necessary.  */
23575
23576 static struct type *
23577 get_DW_AT_signature_type (struct die_info *die, const struct attribute *attr,
23578                           struct dwarf2_cu *cu) /* ARI: editCase function */
23579 {
23580   /* Yes, DW_AT_signature can use a non-ref_sig8 reference.  */
23581   if (attr_form_is_ref (attr))
23582     {
23583       struct dwarf2_cu *type_cu = cu;
23584       struct die_info *type_die = follow_die_ref (die, attr, &type_cu);
23585
23586       return read_type_die (type_die, type_cu);
23587     }
23588   else if (attr->form == DW_FORM_ref_sig8)
23589     {
23590       return get_signatured_type (die, DW_SIGNATURE (attr), cu);
23591     }
23592   else
23593     {
23594       struct dwarf2_per_objfile *dwarf2_per_objfile
23595         = cu->per_cu->dwarf2_per_objfile;
23596
23597       complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
23598                    " at %s [in module %s]"),
23599                  dwarf_form_name (attr->form), sect_offset_str (die->sect_off),
23600                  objfile_name (dwarf2_per_objfile->objfile));
23601       return build_error_marker_type (cu, die);
23602     }
23603 }
23604
23605 /* Load the DIEs associated with type unit PER_CU into memory.  */
23606
23607 static void
23608 load_full_type_unit (struct dwarf2_per_cu_data *per_cu)
23609 {
23610   struct signatured_type *sig_type;
23611
23612   /* Caller is responsible for ensuring type_unit_groups don't get here.  */
23613   gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu));
23614
23615   /* We have the per_cu, but we need the signatured_type.
23616      Fortunately this is an easy translation.  */
23617   gdb_assert (per_cu->is_debug_types);
23618   sig_type = (struct signatured_type *) per_cu;
23619
23620   gdb_assert (per_cu->cu == NULL);
23621
23622   read_signatured_type (sig_type);
23623
23624   gdb_assert (per_cu->cu != NULL);
23625 }
23626
23627 /* die_reader_func for read_signatured_type.
23628    This is identical to load_full_comp_unit_reader,
23629    but is kept separate for now.  */
23630
23631 static void
23632 read_signatured_type_reader (const struct die_reader_specs *reader,
23633                              const gdb_byte *info_ptr,
23634                              struct die_info *comp_unit_die,
23635                              int has_children,
23636                              void *data)
23637 {
23638   struct dwarf2_cu *cu = reader->cu;
23639
23640   gdb_assert (cu->die_hash == NULL);
23641   cu->die_hash =
23642     htab_create_alloc_ex (cu->header.length / 12,
23643                           die_hash,
23644                           die_eq,
23645                           NULL,
23646                           &cu->comp_unit_obstack,
23647                           hashtab_obstack_allocate,
23648                           dummy_obstack_deallocate);
23649
23650   if (has_children)
23651     comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
23652                                                   &info_ptr, comp_unit_die);
23653   cu->dies = comp_unit_die;
23654   /* comp_unit_die is not stored in die_hash, no need.  */
23655
23656   /* We try not to read any attributes in this function, because not
23657      all CUs needed for references have been loaded yet, and symbol
23658      table processing isn't initialized.  But we have to set the CU language,
23659      or we won't be able to build types correctly.
23660      Similarly, if we do not read the producer, we can not apply
23661      producer-specific interpretation.  */
23662   prepare_one_comp_unit (cu, cu->dies, language_minimal);
23663 }
23664
23665 /* Read in a signatured type and build its CU and DIEs.
23666    If the type is a stub for the real type in a DWO file,
23667    read in the real type from the DWO file as well.  */
23668
23669 static void
23670 read_signatured_type (struct signatured_type *sig_type)
23671 {
23672   struct dwarf2_per_cu_data *per_cu = &sig_type->per_cu;
23673
23674   gdb_assert (per_cu->is_debug_types);
23675   gdb_assert (per_cu->cu == NULL);
23676
23677   init_cutu_and_read_dies (per_cu, NULL, 0, 1, false,
23678                            read_signatured_type_reader, NULL);
23679   sig_type->per_cu.tu_read = 1;
23680 }
23681
23682 /* Decode simple location descriptions.
23683    Given a pointer to a dwarf block that defines a location, compute
23684    the location and return the value.
23685
23686    NOTE drow/2003-11-18: This function is called in two situations
23687    now: for the address of static or global variables (partial symbols
23688    only) and for offsets into structures which are expected to be
23689    (more or less) constant.  The partial symbol case should go away,
23690    and only the constant case should remain.  That will let this
23691    function complain more accurately.  A few special modes are allowed
23692    without complaint for global variables (for instance, global
23693    register values and thread-local values).
23694
23695    A location description containing no operations indicates that the
23696    object is optimized out.  The return value is 0 for that case.
23697    FIXME drow/2003-11-16: No callers check for this case any more; soon all
23698    callers will only want a very basic result and this can become a
23699    complaint.
23700
23701    Note that stack[0] is unused except as a default error return.  */
23702
23703 static CORE_ADDR
23704 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
23705 {
23706   struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
23707   size_t i;
23708   size_t size = blk->size;
23709   const gdb_byte *data = blk->data;
23710   CORE_ADDR stack[64];
23711   int stacki;
23712   unsigned int bytes_read, unsnd;
23713   gdb_byte op;
23714
23715   i = 0;
23716   stacki = 0;
23717   stack[stacki] = 0;
23718   stack[++stacki] = 0;
23719
23720   while (i < size)
23721     {
23722       op = data[i++];
23723       switch (op)
23724         {
23725         case DW_OP_lit0:
23726         case DW_OP_lit1:
23727         case DW_OP_lit2:
23728         case DW_OP_lit3:
23729         case DW_OP_lit4:
23730         case DW_OP_lit5:
23731         case DW_OP_lit6:
23732         case DW_OP_lit7:
23733         case DW_OP_lit8:
23734         case DW_OP_lit9:
23735         case DW_OP_lit10:
23736         case DW_OP_lit11:
23737         case DW_OP_lit12:
23738         case DW_OP_lit13:
23739         case DW_OP_lit14:
23740         case DW_OP_lit15:
23741         case DW_OP_lit16:
23742         case DW_OP_lit17:
23743         case DW_OP_lit18:
23744         case DW_OP_lit19:
23745         case DW_OP_lit20:
23746         case DW_OP_lit21:
23747         case DW_OP_lit22:
23748         case DW_OP_lit23:
23749         case DW_OP_lit24:
23750         case DW_OP_lit25:
23751         case DW_OP_lit26:
23752         case DW_OP_lit27:
23753         case DW_OP_lit28:
23754         case DW_OP_lit29:
23755         case DW_OP_lit30:
23756         case DW_OP_lit31:
23757           stack[++stacki] = op - DW_OP_lit0;
23758           break;
23759
23760         case DW_OP_reg0:
23761         case DW_OP_reg1:
23762         case DW_OP_reg2:
23763         case DW_OP_reg3:
23764         case DW_OP_reg4:
23765         case DW_OP_reg5:
23766         case DW_OP_reg6:
23767         case DW_OP_reg7:
23768         case DW_OP_reg8:
23769         case DW_OP_reg9:
23770         case DW_OP_reg10:
23771         case DW_OP_reg11:
23772         case DW_OP_reg12:
23773         case DW_OP_reg13:
23774         case DW_OP_reg14:
23775         case DW_OP_reg15:
23776         case DW_OP_reg16:
23777         case DW_OP_reg17:
23778         case DW_OP_reg18:
23779         case DW_OP_reg19:
23780         case DW_OP_reg20:
23781         case DW_OP_reg21:
23782         case DW_OP_reg22:
23783         case DW_OP_reg23:
23784         case DW_OP_reg24:
23785         case DW_OP_reg25:
23786         case DW_OP_reg26:
23787         case DW_OP_reg27:
23788         case DW_OP_reg28:
23789         case DW_OP_reg29:
23790         case DW_OP_reg30:
23791         case DW_OP_reg31:
23792           stack[++stacki] = op - DW_OP_reg0;
23793           if (i < size)
23794             dwarf2_complex_location_expr_complaint ();
23795           break;
23796
23797         case DW_OP_regx:
23798           unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
23799           i += bytes_read;
23800           stack[++stacki] = unsnd;
23801           if (i < size)
23802             dwarf2_complex_location_expr_complaint ();
23803           break;
23804
23805         case DW_OP_addr:
23806           stack[++stacki] = read_address (objfile->obfd, &data[i],
23807                                           cu, &bytes_read);
23808           i += bytes_read;
23809           break;
23810
23811         case DW_OP_const1u:
23812           stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
23813           i += 1;
23814           break;
23815
23816         case DW_OP_const1s:
23817           stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
23818           i += 1;
23819           break;
23820
23821         case DW_OP_const2u:
23822           stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
23823           i += 2;
23824           break;
23825
23826         case DW_OP_const2s:
23827           stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
23828           i += 2;
23829           break;
23830
23831         case DW_OP_const4u:
23832           stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
23833           i += 4;
23834           break;
23835
23836         case DW_OP_const4s:
23837           stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
23838           i += 4;
23839           break;
23840
23841         case DW_OP_const8u:
23842           stack[++stacki] = read_8_bytes (objfile->obfd, &data[i]);
23843           i += 8;
23844           break;
23845
23846         case DW_OP_constu:
23847           stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
23848                                                   &bytes_read);
23849           i += bytes_read;
23850           break;
23851
23852         case DW_OP_consts:
23853           stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
23854           i += bytes_read;
23855           break;
23856
23857         case DW_OP_dup:
23858           stack[stacki + 1] = stack[stacki];
23859           stacki++;
23860           break;
23861
23862         case DW_OP_plus:
23863           stack[stacki - 1] += stack[stacki];
23864           stacki--;
23865           break;
23866
23867         case DW_OP_plus_uconst:
23868           stack[stacki] += read_unsigned_leb128 (NULL, (data + i),
23869                                                  &bytes_read);
23870           i += bytes_read;
23871           break;
23872
23873         case DW_OP_minus:
23874           stack[stacki - 1] -= stack[stacki];
23875           stacki--;
23876           break;
23877
23878         case DW_OP_deref:
23879           /* If we're not the last op, then we definitely can't encode
23880              this using GDB's address_class enum.  This is valid for partial
23881              global symbols, although the variable's address will be bogus
23882              in the psymtab.  */
23883           if (i < size)
23884             dwarf2_complex_location_expr_complaint ();
23885           break;
23886
23887         case DW_OP_GNU_push_tls_address:
23888         case DW_OP_form_tls_address:
23889           /* The top of the stack has the offset from the beginning
23890              of the thread control block at which the variable is located.  */
23891           /* Nothing should follow this operator, so the top of stack would
23892              be returned.  */
23893           /* This is valid for partial global symbols, but the variable's
23894              address will be bogus in the psymtab.  Make it always at least
23895              non-zero to not look as a variable garbage collected by linker
23896              which have DW_OP_addr 0.  */
23897           if (i < size)
23898             dwarf2_complex_location_expr_complaint ();
23899           stack[stacki]++;
23900           break;
23901
23902         case DW_OP_GNU_uninit:
23903           break;
23904
23905         case DW_OP_GNU_addr_index:
23906         case DW_OP_GNU_const_index:
23907           stack[++stacki] = read_addr_index_from_leb128 (cu, &data[i],
23908                                                          &bytes_read);
23909           i += bytes_read;
23910           break;
23911
23912         default:
23913           {
23914             const char *name = get_DW_OP_name (op);
23915
23916             if (name)
23917               complaint (_("unsupported stack op: '%s'"),
23918                          name);
23919             else
23920               complaint (_("unsupported stack op: '%02x'"),
23921                          op);
23922           }
23923
23924           return (stack[stacki]);
23925         }
23926
23927       /* Enforce maximum stack depth of SIZE-1 to avoid writing
23928          outside of the allocated space.  Also enforce minimum>0.  */
23929       if (stacki >= ARRAY_SIZE (stack) - 1)
23930         {
23931           complaint (_("location description stack overflow"));
23932           return 0;
23933         }
23934
23935       if (stacki <= 0)
23936         {
23937           complaint (_("location description stack underflow"));
23938           return 0;
23939         }
23940     }
23941   return (stack[stacki]);
23942 }
23943
23944 /* memory allocation interface */
23945
23946 static struct dwarf_block *
23947 dwarf_alloc_block (struct dwarf2_cu *cu)
23948 {
23949   return XOBNEW (&cu->comp_unit_obstack, struct dwarf_block);
23950 }
23951
23952 static struct die_info *
23953 dwarf_alloc_die (struct dwarf2_cu *cu, int num_attrs)
23954 {
23955   struct die_info *die;
23956   size_t size = sizeof (struct die_info);
23957
23958   if (num_attrs > 1)
23959     size += (num_attrs - 1) * sizeof (struct attribute);
23960
23961   die = (struct die_info *) obstack_alloc (&cu->comp_unit_obstack, size);
23962   memset (die, 0, sizeof (struct die_info));
23963   return (die);
23964 }
23965
23966 \f
23967 /* Macro support.  */
23968
23969 /* Return file name relative to the compilation directory of file number I in
23970    *LH's file name table.  The result is allocated using xmalloc; the caller is
23971    responsible for freeing it.  */
23972
23973 static char *
23974 file_file_name (int file, struct line_header *lh)
23975 {
23976   /* Is the file number a valid index into the line header's file name
23977      table?  Remember that file numbers start with one, not zero.  */
23978   if (1 <= file && file <= lh->file_names.size ())
23979     {
23980       const file_entry &fe = lh->file_names[file - 1];
23981
23982       if (!IS_ABSOLUTE_PATH (fe.name))
23983         {
23984           const char *dir = fe.include_dir (lh);
23985           if (dir != NULL)
23986             return concat (dir, SLASH_STRING, fe.name, (char *) NULL);
23987         }
23988       return xstrdup (fe.name);
23989     }
23990   else
23991     {
23992       /* The compiler produced a bogus file number.  We can at least
23993          record the macro definitions made in the file, even if we
23994          won't be able to find the file by name.  */
23995       char fake_name[80];
23996
23997       xsnprintf (fake_name, sizeof (fake_name),
23998                  "<bad macro file number %d>", file);
23999
24000       complaint (_("bad file number in macro information (%d)"),
24001                  file);
24002
24003       return xstrdup (fake_name);
24004     }
24005 }
24006
24007 /* Return the full name of file number I in *LH's file name table.
24008    Use COMP_DIR as the name of the current directory of the
24009    compilation.  The result is allocated using xmalloc; the caller is
24010    responsible for freeing it.  */
24011 static char *
24012 file_full_name (int file, struct line_header *lh, const char *comp_dir)
24013 {
24014   /* Is the file number a valid index into the line header's file name
24015      table?  Remember that file numbers start with one, not zero.  */
24016   if (1 <= file && file <= lh->file_names.size ())
24017     {
24018       char *relative = file_file_name (file, lh);
24019
24020       if (IS_ABSOLUTE_PATH (relative) || comp_dir == NULL)
24021         return relative;
24022       return reconcat (relative, comp_dir, SLASH_STRING,
24023                        relative, (char *) NULL);
24024     }
24025   else
24026     return file_file_name (file, lh);
24027 }
24028
24029
24030 static struct macro_source_file *
24031 macro_start_file (struct dwarf2_cu *cu,
24032                   int file, int line,
24033                   struct macro_source_file *current_file,
24034                   struct line_header *lh)
24035 {
24036   /* File name relative to the compilation directory of this source file.  */
24037   char *file_name = file_file_name (file, lh);
24038
24039   if (! current_file)
24040     {
24041       /* Note: We don't create a macro table for this compilation unit
24042          at all until we actually get a filename.  */
24043       struct macro_table *macro_table = cu->get_builder ()->get_macro_table ();
24044
24045       /* If we have no current file, then this must be the start_file
24046          directive for the compilation unit's main source file.  */
24047       current_file = macro_set_main (macro_table, file_name);
24048       macro_define_special (macro_table);
24049     }
24050   else
24051     current_file = macro_include (current_file, line, file_name);
24052
24053   xfree (file_name);
24054
24055   return current_file;
24056 }
24057
24058 static const char *
24059 consume_improper_spaces (const char *p, const char *body)
24060 {
24061   if (*p == ' ')
24062     {
24063       complaint (_("macro definition contains spaces "
24064                    "in formal argument list:\n`%s'"),
24065                  body);
24066
24067       while (*p == ' ')
24068         p++;
24069     }
24070
24071   return p;
24072 }
24073
24074
24075 static void
24076 parse_macro_definition (struct macro_source_file *file, int line,
24077                         const char *body)
24078 {
24079   const char *p;
24080
24081   /* The body string takes one of two forms.  For object-like macro
24082      definitions, it should be:
24083
24084         <macro name> " " <definition>
24085
24086      For function-like macro definitions, it should be:
24087
24088         <macro name> "() " <definition>
24089      or
24090         <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
24091
24092      Spaces may appear only where explicitly indicated, and in the
24093      <definition>.
24094
24095      The Dwarf 2 spec says that an object-like macro's name is always
24096      followed by a space, but versions of GCC around March 2002 omit
24097      the space when the macro's definition is the empty string.
24098
24099      The Dwarf 2 spec says that there should be no spaces between the
24100      formal arguments in a function-like macro's formal argument list,
24101      but versions of GCC around March 2002 include spaces after the
24102      commas.  */
24103
24104
24105   /* Find the extent of the macro name.  The macro name is terminated
24106      by either a space or null character (for an object-like macro) or
24107      an opening paren (for a function-like macro).  */
24108   for (p = body; *p; p++)
24109     if (*p == ' ' || *p == '(')
24110       break;
24111
24112   if (*p == ' ' || *p == '\0')
24113     {
24114       /* It's an object-like macro.  */
24115       int name_len = p - body;
24116       char *name = savestring (body, name_len);
24117       const char *replacement;
24118
24119       if (*p == ' ')
24120         replacement = body + name_len + 1;
24121       else
24122         {
24123           dwarf2_macro_malformed_definition_complaint (body);
24124           replacement = body + name_len;
24125         }
24126
24127       macro_define_object (file, line, name, replacement);
24128
24129       xfree (name);
24130     }
24131   else if (*p == '(')
24132     {
24133       /* It's a function-like macro.  */
24134       char *name = savestring (body, p - body);
24135       int argc = 0;
24136       int argv_size = 1;
24137       char **argv = XNEWVEC (char *, argv_size);
24138
24139       p++;
24140
24141       p = consume_improper_spaces (p, body);
24142
24143       /* Parse the formal argument list.  */
24144       while (*p && *p != ')')
24145         {
24146           /* Find the extent of the current argument name.  */
24147           const char *arg_start = p;
24148
24149           while (*p && *p != ',' && *p != ')' && *p != ' ')
24150             p++;
24151
24152           if (! *p || p == arg_start)
24153             dwarf2_macro_malformed_definition_complaint (body);
24154           else
24155             {
24156               /* Make sure argv has room for the new argument.  */
24157               if (argc >= argv_size)
24158                 {
24159                   argv_size *= 2;
24160                   argv = XRESIZEVEC (char *, argv, argv_size);
24161                 }
24162
24163               argv[argc++] = savestring (arg_start, p - arg_start);
24164             }
24165
24166           p = consume_improper_spaces (p, body);
24167
24168           /* Consume the comma, if present.  */
24169           if (*p == ',')
24170             {
24171               p++;
24172
24173               p = consume_improper_spaces (p, body);
24174             }
24175         }
24176
24177       if (*p == ')')
24178         {
24179           p++;
24180
24181           if (*p == ' ')
24182             /* Perfectly formed definition, no complaints.  */
24183             macro_define_function (file, line, name,
24184                                    argc, (const char **) argv,
24185                                    p + 1);
24186           else if (*p == '\0')
24187             {
24188               /* Complain, but do define it.  */
24189               dwarf2_macro_malformed_definition_complaint (body);
24190               macro_define_function (file, line, name,
24191                                      argc, (const char **) argv,
24192                                      p);
24193             }
24194           else
24195             /* Just complain.  */
24196             dwarf2_macro_malformed_definition_complaint (body);
24197         }
24198       else
24199         /* Just complain.  */
24200         dwarf2_macro_malformed_definition_complaint (body);
24201
24202       xfree (name);
24203       {
24204         int i;
24205
24206         for (i = 0; i < argc; i++)
24207           xfree (argv[i]);
24208       }
24209       xfree (argv);
24210     }
24211   else
24212     dwarf2_macro_malformed_definition_complaint (body);
24213 }
24214
24215 /* Skip some bytes from BYTES according to the form given in FORM.
24216    Returns the new pointer.  */
24217
24218 static const gdb_byte *
24219 skip_form_bytes (bfd *abfd, const gdb_byte *bytes, const gdb_byte *buffer_end,
24220                  enum dwarf_form form,
24221                  unsigned int offset_size,
24222                  struct dwarf2_section_info *section)
24223 {
24224   unsigned int bytes_read;
24225
24226   switch (form)
24227     {
24228     case DW_FORM_data1:
24229     case DW_FORM_flag:
24230       ++bytes;
24231       break;
24232
24233     case DW_FORM_data2:
24234       bytes += 2;
24235       break;
24236
24237     case DW_FORM_data4:
24238       bytes += 4;
24239       break;
24240
24241     case DW_FORM_data8:
24242       bytes += 8;
24243       break;
24244
24245     case DW_FORM_data16:
24246       bytes += 16;
24247       break;
24248
24249     case DW_FORM_string:
24250       read_direct_string (abfd, bytes, &bytes_read);
24251       bytes += bytes_read;
24252       break;
24253
24254     case DW_FORM_sec_offset:
24255     case DW_FORM_strp:
24256     case DW_FORM_GNU_strp_alt:
24257       bytes += offset_size;
24258       break;
24259
24260     case DW_FORM_block:
24261       bytes += read_unsigned_leb128 (abfd, bytes, &bytes_read);
24262       bytes += bytes_read;
24263       break;
24264
24265     case DW_FORM_block1:
24266       bytes += 1 + read_1_byte (abfd, bytes);
24267       break;
24268     case DW_FORM_block2:
24269       bytes += 2 + read_2_bytes (abfd, bytes);
24270       break;
24271     case DW_FORM_block4:
24272       bytes += 4 + read_4_bytes (abfd, bytes);
24273       break;
24274
24275     case DW_FORM_sdata:
24276     case DW_FORM_udata:
24277     case DW_FORM_GNU_addr_index:
24278     case DW_FORM_GNU_str_index:
24279       bytes = gdb_skip_leb128 (bytes, buffer_end);
24280       if (bytes == NULL)
24281         {
24282           dwarf2_section_buffer_overflow_complaint (section);
24283           return NULL;
24284         }
24285       break;
24286
24287     case DW_FORM_implicit_const:
24288       break;
24289
24290     default:
24291       {
24292         complaint (_("invalid form 0x%x in `%s'"),
24293                    form, get_section_name (section));
24294         return NULL;
24295       }
24296     }
24297
24298   return bytes;
24299 }
24300
24301 /* A helper for dwarf_decode_macros that handles skipping an unknown
24302    opcode.  Returns an updated pointer to the macro data buffer; or,
24303    on error, issues a complaint and returns NULL.  */
24304
24305 static const gdb_byte *
24306 skip_unknown_opcode (unsigned int opcode,
24307                      const gdb_byte **opcode_definitions,
24308                      const gdb_byte *mac_ptr, const gdb_byte *mac_end,
24309                      bfd *abfd,
24310                      unsigned int offset_size,
24311                      struct dwarf2_section_info *section)
24312 {
24313   unsigned int bytes_read, i;
24314   unsigned long arg;
24315   const gdb_byte *defn;
24316
24317   if (opcode_definitions[opcode] == NULL)
24318     {
24319       complaint (_("unrecognized DW_MACFINO opcode 0x%x"),
24320                  opcode);
24321       return NULL;
24322     }
24323
24324   defn = opcode_definitions[opcode];
24325   arg = read_unsigned_leb128 (abfd, defn, &bytes_read);
24326   defn += bytes_read;
24327
24328   for (i = 0; i < arg; ++i)
24329     {
24330       mac_ptr = skip_form_bytes (abfd, mac_ptr, mac_end,
24331                                  (enum dwarf_form) defn[i], offset_size,
24332                                  section);
24333       if (mac_ptr == NULL)
24334         {
24335           /* skip_form_bytes already issued the complaint.  */
24336           return NULL;
24337         }
24338     }
24339
24340   return mac_ptr;
24341 }
24342
24343 /* A helper function which parses the header of a macro section.
24344    If the macro section is the extended (for now called "GNU") type,
24345    then this updates *OFFSET_SIZE.  Returns a pointer to just after
24346    the header, or issues a complaint and returns NULL on error.  */
24347
24348 static const gdb_byte *
24349 dwarf_parse_macro_header (const gdb_byte **opcode_definitions,
24350                           bfd *abfd,
24351                           const gdb_byte *mac_ptr,
24352                           unsigned int *offset_size,
24353                           int section_is_gnu)
24354 {
24355   memset (opcode_definitions, 0, 256 * sizeof (gdb_byte *));
24356
24357   if (section_is_gnu)
24358     {
24359       unsigned int version, flags;
24360
24361       version = read_2_bytes (abfd, mac_ptr);
24362       if (version != 4 && version != 5)
24363         {
24364           complaint (_("unrecognized version `%d' in .debug_macro section"),
24365                      version);
24366           return NULL;
24367         }
24368       mac_ptr += 2;
24369
24370       flags = read_1_byte (abfd, mac_ptr);
24371       ++mac_ptr;
24372       *offset_size = (flags & 1) ? 8 : 4;
24373
24374       if ((flags & 2) != 0)
24375         /* We don't need the line table offset.  */
24376         mac_ptr += *offset_size;
24377
24378       /* Vendor opcode descriptions.  */
24379       if ((flags & 4) != 0)
24380         {
24381           unsigned int i, count;
24382
24383           count = read_1_byte (abfd, mac_ptr);
24384           ++mac_ptr;
24385           for (i = 0; i < count; ++i)
24386             {
24387               unsigned int opcode, bytes_read;
24388               unsigned long arg;
24389
24390               opcode = read_1_byte (abfd, mac_ptr);
24391               ++mac_ptr;
24392               opcode_definitions[opcode] = mac_ptr;
24393               arg = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24394               mac_ptr += bytes_read;
24395               mac_ptr += arg;
24396             }
24397         }
24398     }
24399
24400   return mac_ptr;
24401 }
24402
24403 /* A helper for dwarf_decode_macros that handles the GNU extensions,
24404    including DW_MACRO_import.  */
24405
24406 static void
24407 dwarf_decode_macro_bytes (struct dwarf2_cu *cu,
24408                           bfd *abfd,
24409                           const gdb_byte *mac_ptr, const gdb_byte *mac_end,
24410                           struct macro_source_file *current_file,
24411                           struct line_header *lh,
24412                           struct dwarf2_section_info *section,
24413                           int section_is_gnu, int section_is_dwz,
24414                           unsigned int offset_size,
24415                           htab_t include_hash)
24416 {
24417   struct dwarf2_per_objfile *dwarf2_per_objfile
24418     = cu->per_cu->dwarf2_per_objfile;
24419   struct objfile *objfile = dwarf2_per_objfile->objfile;
24420   enum dwarf_macro_record_type macinfo_type;
24421   int at_commandline;
24422   const gdb_byte *opcode_definitions[256];
24423
24424   mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
24425                                       &offset_size, section_is_gnu);
24426   if (mac_ptr == NULL)
24427     {
24428       /* We already issued a complaint.  */
24429       return;
24430     }
24431
24432   /* Determines if GDB is still before first DW_MACINFO_start_file.  If true
24433      GDB is still reading the definitions from command line.  First
24434      DW_MACINFO_start_file will need to be ignored as it was already executed
24435      to create CURRENT_FILE for the main source holding also the command line
24436      definitions.  On first met DW_MACINFO_start_file this flag is reset to
24437      normally execute all the remaining DW_MACINFO_start_file macinfos.  */
24438
24439   at_commandline = 1;
24440
24441   do
24442     {
24443       /* Do we at least have room for a macinfo type byte?  */
24444       if (mac_ptr >= mac_end)
24445         {
24446           dwarf2_section_buffer_overflow_complaint (section);
24447           break;
24448         }
24449
24450       macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr);
24451       mac_ptr++;
24452
24453       /* Note that we rely on the fact that the corresponding GNU and
24454          DWARF constants are the same.  */
24455       DIAGNOSTIC_PUSH
24456       DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24457       switch (macinfo_type)
24458         {
24459           /* A zero macinfo type indicates the end of the macro
24460              information.  */
24461         case 0:
24462           break;
24463
24464         case DW_MACRO_define:
24465         case DW_MACRO_undef:
24466         case DW_MACRO_define_strp:
24467         case DW_MACRO_undef_strp:
24468         case DW_MACRO_define_sup:
24469         case DW_MACRO_undef_sup:
24470           {
24471             unsigned int bytes_read;
24472             int line;
24473             const char *body;
24474             int is_define;
24475
24476             line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24477             mac_ptr += bytes_read;
24478
24479             if (macinfo_type == DW_MACRO_define
24480                 || macinfo_type == DW_MACRO_undef)
24481               {
24482                 body = read_direct_string (abfd, mac_ptr, &bytes_read);
24483                 mac_ptr += bytes_read;
24484               }
24485             else
24486               {
24487                 LONGEST str_offset;
24488
24489                 str_offset = read_offset_1 (abfd, mac_ptr, offset_size);
24490                 mac_ptr += offset_size;
24491
24492                 if (macinfo_type == DW_MACRO_define_sup
24493                     || macinfo_type == DW_MACRO_undef_sup
24494                     || section_is_dwz)
24495                   {
24496                     struct dwz_file *dwz
24497                       = dwarf2_get_dwz_file (dwarf2_per_objfile);
24498
24499                     body = read_indirect_string_from_dwz (objfile,
24500                                                           dwz, str_offset);
24501                   }
24502                 else
24503                   body = read_indirect_string_at_offset (dwarf2_per_objfile,
24504                                                          abfd, str_offset);
24505               }
24506
24507             is_define = (macinfo_type == DW_MACRO_define
24508                          || macinfo_type == DW_MACRO_define_strp
24509                          || macinfo_type == DW_MACRO_define_sup);
24510             if (! current_file)
24511               {
24512                 /* DWARF violation as no main source is present.  */
24513                 complaint (_("debug info with no main source gives macro %s "
24514                              "on line %d: %s"),
24515                            is_define ? _("definition") : _("undefinition"),
24516                            line, body);
24517                 break;
24518               }
24519             if ((line == 0 && !at_commandline)
24520                 || (line != 0 && at_commandline))
24521               complaint (_("debug info gives %s macro %s with %s line %d: %s"),
24522                          at_commandline ? _("command-line") : _("in-file"),
24523                          is_define ? _("definition") : _("undefinition"),
24524                          line == 0 ? _("zero") : _("non-zero"), line, body);
24525
24526             if (is_define)
24527               parse_macro_definition (current_file, line, body);
24528             else
24529               {
24530                 gdb_assert (macinfo_type == DW_MACRO_undef
24531                             || macinfo_type == DW_MACRO_undef_strp
24532                             || macinfo_type == DW_MACRO_undef_sup);
24533                 macro_undef (current_file, line, body);
24534               }
24535           }
24536           break;
24537
24538         case DW_MACRO_start_file:
24539           {
24540             unsigned int bytes_read;
24541             int line, file;
24542
24543             line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24544             mac_ptr += bytes_read;
24545             file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24546             mac_ptr += bytes_read;
24547
24548             if ((line == 0 && !at_commandline)
24549                 || (line != 0 && at_commandline))
24550               complaint (_("debug info gives source %d included "
24551                            "from %s at %s line %d"),
24552                          file, at_commandline ? _("command-line") : _("file"),
24553                          line == 0 ? _("zero") : _("non-zero"), line);
24554
24555             if (at_commandline)
24556               {
24557                 /* This DW_MACRO_start_file was executed in the
24558                    pass one.  */
24559                 at_commandline = 0;
24560               }
24561             else
24562               current_file = macro_start_file (cu, file, line, current_file,
24563                                                lh);
24564           }
24565           break;
24566
24567         case DW_MACRO_end_file:
24568           if (! current_file)
24569             complaint (_("macro debug info has an unmatched "
24570                          "`close_file' directive"));
24571           else
24572             {
24573               current_file = current_file->included_by;
24574               if (! current_file)
24575                 {
24576                   enum dwarf_macro_record_type next_type;
24577
24578                   /* GCC circa March 2002 doesn't produce the zero
24579                      type byte marking the end of the compilation
24580                      unit.  Complain if it's not there, but exit no
24581                      matter what.  */
24582
24583                   /* Do we at least have room for a macinfo type byte?  */
24584                   if (mac_ptr >= mac_end)
24585                     {
24586                       dwarf2_section_buffer_overflow_complaint (section);
24587                       return;
24588                     }
24589
24590                   /* We don't increment mac_ptr here, so this is just
24591                      a look-ahead.  */
24592                   next_type
24593                     = (enum dwarf_macro_record_type) read_1_byte (abfd,
24594                                                                   mac_ptr);
24595                   if (next_type != 0)
24596                     complaint (_("no terminating 0-type entry for "
24597                                  "macros in `.debug_macinfo' section"));
24598
24599                   return;
24600                 }
24601             }
24602           break;
24603
24604         case DW_MACRO_import:
24605         case DW_MACRO_import_sup:
24606           {
24607             LONGEST offset;
24608             void **slot;
24609             bfd *include_bfd = abfd;
24610             struct dwarf2_section_info *include_section = section;
24611             const gdb_byte *include_mac_end = mac_end;
24612             int is_dwz = section_is_dwz;
24613             const gdb_byte *new_mac_ptr;
24614
24615             offset = read_offset_1 (abfd, mac_ptr, offset_size);
24616             mac_ptr += offset_size;
24617
24618             if (macinfo_type == DW_MACRO_import_sup)
24619               {
24620                 struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
24621
24622                 dwarf2_read_section (objfile, &dwz->macro);
24623
24624                 include_section = &dwz->macro;
24625                 include_bfd = get_section_bfd_owner (include_section);
24626                 include_mac_end = dwz->macro.buffer + dwz->macro.size;
24627                 is_dwz = 1;
24628               }
24629
24630             new_mac_ptr = include_section->buffer + offset;
24631             slot = htab_find_slot (include_hash, new_mac_ptr, INSERT);
24632
24633             if (*slot != NULL)
24634               {
24635                 /* This has actually happened; see
24636                    http://sourceware.org/bugzilla/show_bug.cgi?id=13568.  */
24637                 complaint (_("recursive DW_MACRO_import in "
24638                              ".debug_macro section"));
24639               }
24640             else
24641               {
24642                 *slot = (void *) new_mac_ptr;
24643
24644                 dwarf_decode_macro_bytes (cu, include_bfd, new_mac_ptr,
24645                                           include_mac_end, current_file, lh,
24646                                           section, section_is_gnu, is_dwz,
24647                                           offset_size, include_hash);
24648
24649                 htab_remove_elt (include_hash, (void *) new_mac_ptr);
24650               }
24651           }
24652           break;
24653
24654         case DW_MACINFO_vendor_ext:
24655           if (!section_is_gnu)
24656             {
24657               unsigned int bytes_read;
24658
24659               /* This reads the constant, but since we don't recognize
24660                  any vendor extensions, we ignore it.  */
24661               read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24662               mac_ptr += bytes_read;
24663               read_direct_string (abfd, mac_ptr, &bytes_read);
24664               mac_ptr += bytes_read;
24665
24666               /* We don't recognize any vendor extensions.  */
24667               break;
24668             }
24669           /* FALLTHROUGH */
24670
24671         default:
24672           mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
24673                                          mac_ptr, mac_end, abfd, offset_size,
24674                                          section);
24675           if (mac_ptr == NULL)
24676             return;
24677           break;
24678         }
24679       DIAGNOSTIC_POP
24680     } while (macinfo_type != 0);
24681 }
24682
24683 static void
24684 dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset,
24685                      int section_is_gnu)
24686 {
24687   struct dwarf2_per_objfile *dwarf2_per_objfile
24688     = cu->per_cu->dwarf2_per_objfile;
24689   struct objfile *objfile = dwarf2_per_objfile->objfile;
24690   struct line_header *lh = cu->line_header;
24691   bfd *abfd;
24692   const gdb_byte *mac_ptr, *mac_end;
24693   struct macro_source_file *current_file = 0;
24694   enum dwarf_macro_record_type macinfo_type;
24695   unsigned int offset_size = cu->header.offset_size;
24696   const gdb_byte *opcode_definitions[256];
24697   void **slot;
24698   struct dwarf2_section_info *section;
24699   const char *section_name;
24700
24701   if (cu->dwo_unit != NULL)
24702     {
24703       if (section_is_gnu)
24704         {
24705           section = &cu->dwo_unit->dwo_file->sections.macro;
24706           section_name = ".debug_macro.dwo";
24707         }
24708       else
24709         {
24710           section = &cu->dwo_unit->dwo_file->sections.macinfo;
24711           section_name = ".debug_macinfo.dwo";
24712         }
24713     }
24714   else
24715     {
24716       if (section_is_gnu)
24717         {
24718           section = &dwarf2_per_objfile->macro;
24719           section_name = ".debug_macro";
24720         }
24721       else
24722         {
24723           section = &dwarf2_per_objfile->macinfo;
24724           section_name = ".debug_macinfo";
24725         }
24726     }
24727
24728   dwarf2_read_section (objfile, section);
24729   if (section->buffer == NULL)
24730     {
24731       complaint (_("missing %s section"), section_name);
24732       return;
24733     }
24734   abfd = get_section_bfd_owner (section);
24735
24736   /* First pass: Find the name of the base filename.
24737      This filename is needed in order to process all macros whose definition
24738      (or undefinition) comes from the command line.  These macros are defined
24739      before the first DW_MACINFO_start_file entry, and yet still need to be
24740      associated to the base file.
24741
24742      To determine the base file name, we scan the macro definitions until we
24743      reach the first DW_MACINFO_start_file entry.  We then initialize
24744      CURRENT_FILE accordingly so that any macro definition found before the
24745      first DW_MACINFO_start_file can still be associated to the base file.  */
24746
24747   mac_ptr = section->buffer + offset;
24748   mac_end = section->buffer + section->size;
24749
24750   mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
24751                                       &offset_size, section_is_gnu);
24752   if (mac_ptr == NULL)
24753     {
24754       /* We already issued a complaint.  */
24755       return;
24756     }
24757
24758   do
24759     {
24760       /* Do we at least have room for a macinfo type byte?  */
24761       if (mac_ptr >= mac_end)
24762         {
24763           /* Complaint is printed during the second pass as GDB will probably
24764              stop the first pass earlier upon finding
24765              DW_MACINFO_start_file.  */
24766           break;
24767         }
24768
24769       macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr);
24770       mac_ptr++;
24771
24772       /* Note that we rely on the fact that the corresponding GNU and
24773          DWARF constants are the same.  */
24774       DIAGNOSTIC_PUSH
24775       DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
24776       switch (macinfo_type)
24777         {
24778           /* A zero macinfo type indicates the end of the macro
24779              information.  */
24780         case 0:
24781           break;
24782
24783         case DW_MACRO_define:
24784         case DW_MACRO_undef:
24785           /* Only skip the data by MAC_PTR.  */
24786           {
24787             unsigned int bytes_read;
24788
24789             read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24790             mac_ptr += bytes_read;
24791             read_direct_string (abfd, mac_ptr, &bytes_read);
24792             mac_ptr += bytes_read;
24793           }
24794           break;
24795
24796         case DW_MACRO_start_file:
24797           {
24798             unsigned int bytes_read;
24799             int line, file;
24800
24801             line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24802             mac_ptr += bytes_read;
24803             file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24804             mac_ptr += bytes_read;
24805
24806             current_file = macro_start_file (cu, file, line, current_file, lh);
24807           }
24808           break;
24809
24810         case DW_MACRO_end_file:
24811           /* No data to skip by MAC_PTR.  */
24812           break;
24813
24814         case DW_MACRO_define_strp:
24815         case DW_MACRO_undef_strp:
24816         case DW_MACRO_define_sup:
24817         case DW_MACRO_undef_sup:
24818           {
24819             unsigned int bytes_read;
24820
24821             read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24822             mac_ptr += bytes_read;
24823             mac_ptr += offset_size;
24824           }
24825           break;
24826
24827         case DW_MACRO_import:
24828         case DW_MACRO_import_sup:
24829           /* Note that, according to the spec, a transparent include
24830              chain cannot call DW_MACRO_start_file.  So, we can just
24831              skip this opcode.  */
24832           mac_ptr += offset_size;
24833           break;
24834
24835         case DW_MACINFO_vendor_ext:
24836           /* Only skip the data by MAC_PTR.  */
24837           if (!section_is_gnu)
24838             {
24839               unsigned int bytes_read;
24840
24841               read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
24842               mac_ptr += bytes_read;
24843               read_direct_string (abfd, mac_ptr, &bytes_read);
24844               mac_ptr += bytes_read;
24845             }
24846           /* FALLTHROUGH */
24847
24848         default:
24849           mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
24850                                          mac_ptr, mac_end, abfd, offset_size,
24851                                          section);
24852           if (mac_ptr == NULL)
24853             return;
24854           break;
24855         }
24856       DIAGNOSTIC_POP
24857     } while (macinfo_type != 0 && current_file == NULL);
24858
24859   /* Second pass: Process all entries.
24860
24861      Use the AT_COMMAND_LINE flag to determine whether we are still processing
24862      command-line macro definitions/undefinitions.  This flag is unset when we
24863      reach the first DW_MACINFO_start_file entry.  */
24864
24865   htab_up include_hash (htab_create_alloc (1, htab_hash_pointer,
24866                                            htab_eq_pointer,
24867                                            NULL, xcalloc, xfree));
24868   mac_ptr = section->buffer + offset;
24869   slot = htab_find_slot (include_hash.get (), mac_ptr, INSERT);
24870   *slot = (void *) mac_ptr;
24871   dwarf_decode_macro_bytes (cu, abfd, mac_ptr, mac_end,
24872                             current_file, lh, section,
24873                             section_is_gnu, 0, offset_size,
24874                             include_hash.get ());
24875 }
24876
24877 /* Check if the attribute's form is a DW_FORM_block*
24878    if so return true else false.  */
24879
24880 static int
24881 attr_form_is_block (const struct attribute *attr)
24882 {
24883   return (attr == NULL ? 0 :
24884       attr->form == DW_FORM_block1
24885       || attr->form == DW_FORM_block2
24886       || attr->form == DW_FORM_block4
24887       || attr->form == DW_FORM_block
24888       || attr->form == DW_FORM_exprloc);
24889 }
24890
24891 /* Return non-zero if ATTR's value is a section offset --- classes
24892    lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
24893    You may use DW_UNSND (attr) to retrieve such offsets.
24894
24895    Section 7.5.4, "Attribute Encodings", explains that no attribute
24896    may have a value that belongs to more than one of these classes; it
24897    would be ambiguous if we did, because we use the same forms for all
24898    of them.  */
24899
24900 static int
24901 attr_form_is_section_offset (const struct attribute *attr)
24902 {
24903   return (attr->form == DW_FORM_data4
24904           || attr->form == DW_FORM_data8
24905           || attr->form == DW_FORM_sec_offset);
24906 }
24907
24908 /* Return non-zero if ATTR's value falls in the 'constant' class, or
24909    zero otherwise.  When this function returns true, you can apply
24910    dwarf2_get_attr_constant_value to it.
24911
24912    However, note that for some attributes you must check
24913    attr_form_is_section_offset before using this test.  DW_FORM_data4
24914    and DW_FORM_data8 are members of both the constant class, and of
24915    the classes that contain offsets into other debug sections
24916    (lineptr, loclistptr, macptr or rangelistptr).  The DWARF spec says
24917    that, if an attribute's can be either a constant or one of the
24918    section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
24919    taken as section offsets, not constants.
24920
24921    DW_FORM_data16 is not considered as dwarf2_get_attr_constant_value
24922    cannot handle that.  */
24923
24924 static int
24925 attr_form_is_constant (const struct attribute *attr)
24926 {
24927   switch (attr->form)
24928     {
24929     case DW_FORM_sdata:
24930     case DW_FORM_udata:
24931     case DW_FORM_data1:
24932     case DW_FORM_data2:
24933     case DW_FORM_data4:
24934     case DW_FORM_data8:
24935     case DW_FORM_implicit_const:
24936       return 1;
24937     default:
24938       return 0;
24939     }
24940 }
24941
24942
24943 /* DW_ADDR is always stored already as sect_offset; despite for the forms
24944    besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file.  */
24945
24946 static int
24947 attr_form_is_ref (const struct attribute *attr)
24948 {
24949   switch (attr->form)
24950     {
24951     case DW_FORM_ref_addr:
24952     case DW_FORM_ref1:
24953     case DW_FORM_ref2:
24954     case DW_FORM_ref4:
24955     case DW_FORM_ref8:
24956     case DW_FORM_ref_udata:
24957     case DW_FORM_GNU_ref_alt:
24958       return 1;
24959     default:
24960       return 0;
24961     }
24962 }
24963
24964 /* Return the .debug_loc section to use for CU.
24965    For DWO files use .debug_loc.dwo.  */
24966
24967 static struct dwarf2_section_info *
24968 cu_debug_loc_section (struct dwarf2_cu *cu)
24969 {
24970   struct dwarf2_per_objfile *dwarf2_per_objfile
24971     = cu->per_cu->dwarf2_per_objfile;
24972
24973   if (cu->dwo_unit)
24974     {
24975       struct dwo_sections *sections = &cu->dwo_unit->dwo_file->sections;
24976       
24977       return cu->header.version >= 5 ? &sections->loclists : &sections->loc;
24978     }
24979   return (cu->header.version >= 5 ? &dwarf2_per_objfile->loclists
24980                                   : &dwarf2_per_objfile->loc);
24981 }
24982
24983 /* A helper function that fills in a dwarf2_loclist_baton.  */
24984
24985 static void
24986 fill_in_loclist_baton (struct dwarf2_cu *cu,
24987                        struct dwarf2_loclist_baton *baton,
24988                        const struct attribute *attr)
24989 {
24990   struct dwarf2_per_objfile *dwarf2_per_objfile
24991     = cu->per_cu->dwarf2_per_objfile;
24992   struct dwarf2_section_info *section = cu_debug_loc_section (cu);
24993
24994   dwarf2_read_section (dwarf2_per_objfile->objfile, section);
24995
24996   baton->per_cu = cu->per_cu;
24997   gdb_assert (baton->per_cu);
24998   /* We don't know how long the location list is, but make sure we
24999      don't run off the edge of the section.  */
25000   baton->size = section->size - DW_UNSND (attr);
25001   baton->data = section->buffer + DW_UNSND (attr);
25002   baton->base_address = cu->base_address;
25003   baton->from_dwo = cu->dwo_unit != NULL;
25004 }
25005
25006 static void
25007 dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym,
25008                              struct dwarf2_cu *cu, int is_block)
25009 {
25010   struct dwarf2_per_objfile *dwarf2_per_objfile
25011     = cu->per_cu->dwarf2_per_objfile;
25012   struct objfile *objfile = dwarf2_per_objfile->objfile;
25013   struct dwarf2_section_info *section = cu_debug_loc_section (cu);
25014
25015   if (attr_form_is_section_offset (attr)
25016       /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
25017          the section.  If so, fall through to the complaint in the
25018          other branch.  */
25019       && DW_UNSND (attr) < dwarf2_section_size (objfile, section))
25020     {
25021       struct dwarf2_loclist_baton *baton;
25022
25023       baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_loclist_baton);
25024
25025       fill_in_loclist_baton (cu, baton, attr);
25026
25027       if (cu->base_known == 0)
25028         complaint (_("Location list used without "
25029                      "specifying the CU base address."));
25030
25031       SYMBOL_ACLASS_INDEX (sym) = (is_block
25032                                    ? dwarf2_loclist_block_index
25033                                    : dwarf2_loclist_index);
25034       SYMBOL_LOCATION_BATON (sym) = baton;
25035     }
25036   else
25037     {
25038       struct dwarf2_locexpr_baton *baton;
25039
25040       baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
25041       baton->per_cu = cu->per_cu;
25042       gdb_assert (baton->per_cu);
25043
25044       if (attr_form_is_block (attr))
25045         {
25046           /* Note that we're just copying the block's data pointer
25047              here, not the actual data.  We're still pointing into the
25048              info_buffer for SYM's objfile; right now we never release
25049              that buffer, but when we do clean up properly this may
25050              need to change.  */
25051           baton->size = DW_BLOCK (attr)->size;
25052           baton->data = DW_BLOCK (attr)->data;
25053         }
25054       else
25055         {
25056           dwarf2_invalid_attrib_class_complaint ("location description",
25057                                                  SYMBOL_NATURAL_NAME (sym));
25058           baton->size = 0;
25059         }
25060
25061       SYMBOL_ACLASS_INDEX (sym) = (is_block
25062                                    ? dwarf2_locexpr_block_index
25063                                    : dwarf2_locexpr_index);
25064       SYMBOL_LOCATION_BATON (sym) = baton;
25065     }
25066 }
25067
25068 /* Return the OBJFILE associated with the compilation unit CU.  If CU
25069    came from a separate debuginfo file, then the master objfile is
25070    returned.  */
25071
25072 struct objfile *
25073 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data *per_cu)
25074 {
25075   struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
25076
25077   /* Return the master objfile, so that we can report and look up the
25078      correct file containing this variable.  */
25079   if (objfile->separate_debug_objfile_backlink)
25080     objfile = objfile->separate_debug_objfile_backlink;
25081
25082   return objfile;
25083 }
25084
25085 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
25086    (CU_HEADERP is unused in such case) or prepare a temporary copy at
25087    CU_HEADERP first.  */
25088
25089 static const struct comp_unit_head *
25090 per_cu_header_read_in (struct comp_unit_head *cu_headerp,
25091                        struct dwarf2_per_cu_data *per_cu)
25092 {
25093   const gdb_byte *info_ptr;
25094
25095   if (per_cu->cu)
25096     return &per_cu->cu->header;
25097
25098   info_ptr = per_cu->section->buffer + to_underlying (per_cu->sect_off);
25099
25100   memset (cu_headerp, 0, sizeof (*cu_headerp));
25101   read_comp_unit_head (cu_headerp, info_ptr, per_cu->section,
25102                        rcuh_kind::COMPILE);
25103
25104   return cu_headerp;
25105 }
25106
25107 /* Return the address size given in the compilation unit header for CU.  */
25108
25109 int
25110 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data *per_cu)
25111 {
25112   struct comp_unit_head cu_header_local;
25113   const struct comp_unit_head *cu_headerp;
25114
25115   cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25116
25117   return cu_headerp->addr_size;
25118 }
25119
25120 /* Return the offset size given in the compilation unit header for CU.  */
25121
25122 int
25123 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data *per_cu)
25124 {
25125   struct comp_unit_head cu_header_local;
25126   const struct comp_unit_head *cu_headerp;
25127
25128   cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25129
25130   return cu_headerp->offset_size;
25131 }
25132
25133 /* See its dwarf2loc.h declaration.  */
25134
25135 int
25136 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data *per_cu)
25137 {
25138   struct comp_unit_head cu_header_local;
25139   const struct comp_unit_head *cu_headerp;
25140
25141   cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
25142
25143   if (cu_headerp->version == 2)
25144     return cu_headerp->addr_size;
25145   else
25146     return cu_headerp->offset_size;
25147 }
25148
25149 /* Return the text offset of the CU.  The returned offset comes from
25150    this CU's objfile.  If this objfile came from a separate debuginfo
25151    file, then the offset may be different from the corresponding
25152    offset in the parent objfile.  */
25153
25154 CORE_ADDR
25155 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data *per_cu)
25156 {
25157   struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
25158
25159   return ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
25160 }
25161
25162 /* Return DWARF version number of PER_CU.  */
25163
25164 short
25165 dwarf2_version (struct dwarf2_per_cu_data *per_cu)
25166 {
25167   return per_cu->dwarf_version;
25168 }
25169
25170 /* Locate the .debug_info compilation unit from CU's objfile which contains
25171    the DIE at OFFSET.  Raises an error on failure.  */
25172
25173 static struct dwarf2_per_cu_data *
25174 dwarf2_find_containing_comp_unit (sect_offset sect_off,
25175                                   unsigned int offset_in_dwz,
25176                                   struct dwarf2_per_objfile *dwarf2_per_objfile)
25177 {
25178   struct dwarf2_per_cu_data *this_cu;
25179   int low, high;
25180
25181   low = 0;
25182   high = dwarf2_per_objfile->all_comp_units.size () - 1;
25183   while (high > low)
25184     {
25185       struct dwarf2_per_cu_data *mid_cu;
25186       int mid = low + (high - low) / 2;
25187
25188       mid_cu = dwarf2_per_objfile->all_comp_units[mid];
25189       if (mid_cu->is_dwz > offset_in_dwz
25190           || (mid_cu->is_dwz == offset_in_dwz
25191               && mid_cu->sect_off + mid_cu->length >= sect_off))
25192         high = mid;
25193       else
25194         low = mid + 1;
25195     }
25196   gdb_assert (low == high);
25197   this_cu = dwarf2_per_objfile->all_comp_units[low];
25198   if (this_cu->is_dwz != offset_in_dwz || this_cu->sect_off > sect_off)
25199     {
25200       if (low == 0 || this_cu->is_dwz != offset_in_dwz)
25201         error (_("Dwarf Error: could not find partial DIE containing "
25202                "offset %s [in module %s]"),
25203                sect_offset_str (sect_off),
25204                bfd_get_filename (dwarf2_per_objfile->objfile->obfd));
25205
25206       gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->sect_off
25207                   <= sect_off);
25208       return dwarf2_per_objfile->all_comp_units[low-1];
25209     }
25210   else
25211     {
25212       if (low == dwarf2_per_objfile->all_comp_units.size () - 1
25213           && sect_off >= this_cu->sect_off + this_cu->length)
25214         error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off));
25215       gdb_assert (sect_off < this_cu->sect_off + this_cu->length);
25216       return this_cu;
25217     }
25218 }
25219
25220 /* Initialize dwarf2_cu CU, owned by PER_CU.  */
25221
25222 dwarf2_cu::dwarf2_cu (struct dwarf2_per_cu_data *per_cu_)
25223   : per_cu (per_cu_),
25224     mark (false),
25225     has_loclist (false),
25226     checked_producer (false),
25227     producer_is_gxx_lt_4_6 (false),
25228     producer_is_gcc_lt_4_3 (false),
25229     producer_is_icc (false),
25230     producer_is_icc_lt_14 (false),
25231     producer_is_codewarrior (false),
25232     processing_has_namespace_info (false)
25233 {
25234   per_cu->cu = this;
25235 }
25236
25237 /* Destroy a dwarf2_cu.  */
25238
25239 dwarf2_cu::~dwarf2_cu ()
25240 {
25241   per_cu->cu = NULL;
25242 }
25243
25244 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE.  */
25245
25246 static void
25247 prepare_one_comp_unit (struct dwarf2_cu *cu, struct die_info *comp_unit_die,
25248                        enum language pretend_language)
25249 {
25250   struct attribute *attr;
25251
25252   /* Set the language we're debugging.  */
25253   attr = dwarf2_attr (comp_unit_die, DW_AT_language, cu);
25254   if (attr)
25255     set_cu_language (DW_UNSND (attr), cu);
25256   else
25257     {
25258       cu->language = pretend_language;
25259       cu->language_defn = language_def (cu->language);
25260     }
25261
25262   cu->producer = dwarf2_string_attr (comp_unit_die, DW_AT_producer, cu);
25263 }
25264
25265 /* Increase the age counter on each cached compilation unit, and free
25266    any that are too old.  */
25267
25268 static void
25269 age_cached_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
25270 {
25271   struct dwarf2_per_cu_data *per_cu, **last_chain;
25272
25273   dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
25274   per_cu = dwarf2_per_objfile->read_in_chain;
25275   while (per_cu != NULL)
25276     {
25277       per_cu->cu->last_used ++;
25278       if (per_cu->cu->last_used <= dwarf_max_cache_age)
25279         dwarf2_mark (per_cu->cu);
25280       per_cu = per_cu->cu->read_in_chain;
25281     }
25282
25283   per_cu = dwarf2_per_objfile->read_in_chain;
25284   last_chain = &dwarf2_per_objfile->read_in_chain;
25285   while (per_cu != NULL)
25286     {
25287       struct dwarf2_per_cu_data *next_cu;
25288
25289       next_cu = per_cu->cu->read_in_chain;
25290
25291       if (!per_cu->cu->mark)
25292         {
25293           delete per_cu->cu;
25294           *last_chain = next_cu;
25295         }
25296       else
25297         last_chain = &per_cu->cu->read_in_chain;
25298
25299       per_cu = next_cu;
25300     }
25301 }
25302
25303 /* Remove a single compilation unit from the cache.  */
25304
25305 static void
25306 free_one_cached_comp_unit (struct dwarf2_per_cu_data *target_per_cu)
25307 {
25308   struct dwarf2_per_cu_data *per_cu, **last_chain;
25309   struct dwarf2_per_objfile *dwarf2_per_objfile
25310     = target_per_cu->dwarf2_per_objfile;
25311
25312   per_cu = dwarf2_per_objfile->read_in_chain;
25313   last_chain = &dwarf2_per_objfile->read_in_chain;
25314   while (per_cu != NULL)
25315     {
25316       struct dwarf2_per_cu_data *next_cu;
25317
25318       next_cu = per_cu->cu->read_in_chain;
25319
25320       if (per_cu == target_per_cu)
25321         {
25322           delete per_cu->cu;
25323           per_cu->cu = NULL;
25324           *last_chain = next_cu;
25325           break;
25326         }
25327       else
25328         last_chain = &per_cu->cu->read_in_chain;
25329
25330       per_cu = next_cu;
25331     }
25332 }
25333
25334 /* Cleanup function for the dwarf2_per_objfile data.  */
25335
25336 static void
25337 dwarf2_free_objfile (struct objfile *objfile, void *datum)
25338 {
25339   struct dwarf2_per_objfile *dwarf2_per_objfile
25340     = static_cast<struct dwarf2_per_objfile *> (datum);
25341
25342   delete dwarf2_per_objfile;
25343 }
25344
25345 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
25346    We store these in a hash table separate from the DIEs, and preserve them
25347    when the DIEs are flushed out of cache.
25348
25349    The CU "per_cu" pointer is needed because offset alone is not enough to
25350    uniquely identify the type.  A file may have multiple .debug_types sections,
25351    or the type may come from a DWO file.  Furthermore, while it's more logical
25352    to use per_cu->section+offset, with Fission the section with the data is in
25353    the DWO file but we don't know that section at the point we need it.
25354    We have to use something in dwarf2_per_cu_data (or the pointer to it)
25355    because we can enter the lookup routine, get_die_type_at_offset, from
25356    outside this file, and thus won't necessarily have PER_CU->cu.
25357    Fortunately, PER_CU is stable for the life of the objfile.  */
25358
25359 struct dwarf2_per_cu_offset_and_type
25360 {
25361   const struct dwarf2_per_cu_data *per_cu;
25362   sect_offset sect_off;
25363   struct type *type;
25364 };
25365
25366 /* Hash function for a dwarf2_per_cu_offset_and_type.  */
25367
25368 static hashval_t
25369 per_cu_offset_and_type_hash (const void *item)
25370 {
25371   const struct dwarf2_per_cu_offset_and_type *ofs
25372     = (const struct dwarf2_per_cu_offset_and_type *) item;
25373
25374   return (uintptr_t) ofs->per_cu + to_underlying (ofs->sect_off);
25375 }
25376
25377 /* Equality function for a dwarf2_per_cu_offset_and_type.  */
25378
25379 static int
25380 per_cu_offset_and_type_eq (const void *item_lhs, const void *item_rhs)
25381 {
25382   const struct dwarf2_per_cu_offset_and_type *ofs_lhs
25383     = (const struct dwarf2_per_cu_offset_and_type *) item_lhs;
25384   const struct dwarf2_per_cu_offset_and_type *ofs_rhs
25385     = (const struct dwarf2_per_cu_offset_and_type *) item_rhs;
25386
25387   return (ofs_lhs->per_cu == ofs_rhs->per_cu
25388           && ofs_lhs->sect_off == ofs_rhs->sect_off);
25389 }
25390
25391 /* Set the type associated with DIE to TYPE.  Save it in CU's hash
25392    table if necessary.  For convenience, return TYPE.
25393
25394    The DIEs reading must have careful ordering to:
25395     * Not cause infite loops trying to read in DIEs as a prerequisite for
25396       reading current DIE.
25397     * Not trying to dereference contents of still incompletely read in types
25398       while reading in other DIEs.
25399     * Enable referencing still incompletely read in types just by a pointer to
25400       the type without accessing its fields.
25401
25402    Therefore caller should follow these rules:
25403      * Try to fetch any prerequisite types we may need to build this DIE type
25404        before building the type and calling set_die_type.
25405      * After building type call set_die_type for current DIE as soon as
25406        possible before fetching more types to complete the current type.
25407      * Make the type as complete as possible before fetching more types.  */
25408
25409 static struct type *
25410 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
25411 {
25412   struct dwarf2_per_objfile *dwarf2_per_objfile
25413     = cu->per_cu->dwarf2_per_objfile;
25414   struct dwarf2_per_cu_offset_and_type **slot, ofs;
25415   struct objfile *objfile = dwarf2_per_objfile->objfile;
25416   struct attribute *attr;
25417   struct dynamic_prop prop;
25418
25419   /* For Ada types, make sure that the gnat-specific data is always
25420      initialized (if not already set).  There are a few types where
25421      we should not be doing so, because the type-specific area is
25422      already used to hold some other piece of info (eg: TYPE_CODE_FLT
25423      where the type-specific area is used to store the floatformat).
25424      But this is not a problem, because the gnat-specific information
25425      is actually not needed for these types.  */
25426   if (need_gnat_info (cu)
25427       && TYPE_CODE (type) != TYPE_CODE_FUNC
25428       && TYPE_CODE (type) != TYPE_CODE_FLT
25429       && TYPE_CODE (type) != TYPE_CODE_METHODPTR
25430       && TYPE_CODE (type) != TYPE_CODE_MEMBERPTR
25431       && TYPE_CODE (type) != TYPE_CODE_METHOD
25432       && !HAVE_GNAT_AUX_INFO (type))
25433     INIT_GNAT_SPECIFIC (type);
25434
25435   /* Read DW_AT_allocated and set in type.  */
25436   attr = dwarf2_attr (die, DW_AT_allocated, cu);
25437   if (attr_form_is_block (attr))
25438     {
25439       if (attr_to_dynamic_prop (attr, die, cu, &prop))
25440         add_dyn_prop (DYN_PROP_ALLOCATED, prop, type);
25441     }
25442   else if (attr != NULL)
25443     {
25444       complaint (_("DW_AT_allocated has the wrong form (%s) at DIE %s"),
25445                  (attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
25446                  sect_offset_str (die->sect_off));
25447     }
25448
25449   /* Read DW_AT_associated and set in type.  */
25450   attr = dwarf2_attr (die, DW_AT_associated, cu);
25451   if (attr_form_is_block (attr))
25452     {
25453       if (attr_to_dynamic_prop (attr, die, cu, &prop))
25454         add_dyn_prop (DYN_PROP_ASSOCIATED, prop, type);
25455     }
25456   else if (attr != NULL)
25457     {
25458       complaint (_("DW_AT_associated has the wrong form (%s) at DIE %s"),
25459                  (attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
25460                  sect_offset_str (die->sect_off));
25461     }
25462
25463   /* Read DW_AT_data_location and set in type.  */
25464   attr = dwarf2_attr (die, DW_AT_data_location, cu);
25465   if (attr_to_dynamic_prop (attr, die, cu, &prop))
25466     add_dyn_prop (DYN_PROP_DATA_LOCATION, prop, type);
25467
25468   if (dwarf2_per_objfile->die_type_hash == NULL)
25469     {
25470       dwarf2_per_objfile->die_type_hash =
25471         htab_create_alloc_ex (127,
25472                               per_cu_offset_and_type_hash,
25473                               per_cu_offset_and_type_eq,
25474                               NULL,
25475                               &objfile->objfile_obstack,
25476                               hashtab_obstack_allocate,
25477                               dummy_obstack_deallocate);
25478     }
25479
25480   ofs.per_cu = cu->per_cu;
25481   ofs.sect_off = die->sect_off;
25482   ofs.type = type;
25483   slot = (struct dwarf2_per_cu_offset_and_type **)
25484     htab_find_slot (dwarf2_per_objfile->die_type_hash, &ofs, INSERT);
25485   if (*slot)
25486     complaint (_("A problem internal to GDB: DIE %s has type already set"),
25487                sect_offset_str (die->sect_off));
25488   *slot = XOBNEW (&objfile->objfile_obstack,
25489                   struct dwarf2_per_cu_offset_and_type);
25490   **slot = ofs;
25491   return type;
25492 }
25493
25494 /* Look up the type for the die at SECT_OFF in PER_CU in die_type_hash,
25495    or return NULL if the die does not have a saved type.  */
25496
25497 static struct type *
25498 get_die_type_at_offset (sect_offset sect_off,
25499                         struct dwarf2_per_cu_data *per_cu)
25500 {
25501   struct dwarf2_per_cu_offset_and_type *slot, ofs;
25502   struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
25503
25504   if (dwarf2_per_objfile->die_type_hash == NULL)
25505     return NULL;
25506
25507   ofs.per_cu = per_cu;
25508   ofs.sect_off = sect_off;
25509   slot = ((struct dwarf2_per_cu_offset_and_type *)
25510           htab_find (dwarf2_per_objfile->die_type_hash, &ofs));
25511   if (slot)
25512     return slot->type;
25513   else
25514     return NULL;
25515 }
25516
25517 /* Look up the type for DIE in CU in die_type_hash,
25518    or return NULL if DIE does not have a saved type.  */
25519
25520 static struct type *
25521 get_die_type (struct die_info *die, struct dwarf2_cu *cu)
25522 {
25523   return get_die_type_at_offset (die->sect_off, cu->per_cu);
25524 }
25525
25526 /* Add a dependence relationship from CU to REF_PER_CU.  */
25527
25528 static void
25529 dwarf2_add_dependence (struct dwarf2_cu *cu,
25530                        struct dwarf2_per_cu_data *ref_per_cu)
25531 {
25532   void **slot;
25533
25534   if (cu->dependencies == NULL)
25535     cu->dependencies
25536       = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
25537                               NULL, &cu->comp_unit_obstack,
25538                               hashtab_obstack_allocate,
25539                               dummy_obstack_deallocate);
25540
25541   slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
25542   if (*slot == NULL)
25543     *slot = ref_per_cu;
25544 }
25545
25546 /* Subroutine of dwarf2_mark to pass to htab_traverse.
25547    Set the mark field in every compilation unit in the
25548    cache that we must keep because we are keeping CU.  */
25549
25550 static int
25551 dwarf2_mark_helper (void **slot, void *data)
25552 {
25553   struct dwarf2_per_cu_data *per_cu;
25554
25555   per_cu = (struct dwarf2_per_cu_data *) *slot;
25556
25557   /* cu->dependencies references may not yet have been ever read if QUIT aborts
25558      reading of the chain.  As such dependencies remain valid it is not much
25559      useful to track and undo them during QUIT cleanups.  */
25560   if (per_cu->cu == NULL)
25561     return 1;
25562
25563   if (per_cu->cu->mark)
25564     return 1;
25565   per_cu->cu->mark = true;
25566
25567   if (per_cu->cu->dependencies != NULL)
25568     htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
25569
25570   return 1;
25571 }
25572
25573 /* Set the mark field in CU and in every other compilation unit in the
25574    cache that we must keep because we are keeping CU.  */
25575
25576 static void
25577 dwarf2_mark (struct dwarf2_cu *cu)
25578 {
25579   if (cu->mark)
25580     return;
25581   cu->mark = true;
25582   if (cu->dependencies != NULL)
25583     htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
25584 }
25585
25586 static void
25587 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
25588 {
25589   while (per_cu)
25590     {
25591       per_cu->cu->mark = false;
25592       per_cu = per_cu->cu->read_in_chain;
25593     }
25594 }
25595
25596 /* Trivial hash function for partial_die_info: the hash value of a DIE
25597    is its offset in .debug_info for this objfile.  */
25598
25599 static hashval_t
25600 partial_die_hash (const void *item)
25601 {
25602   const struct partial_die_info *part_die
25603     = (const struct partial_die_info *) item;
25604
25605   return to_underlying (part_die->sect_off);
25606 }
25607
25608 /* Trivial comparison function for partial_die_info structures: two DIEs
25609    are equal if they have the same offset.  */
25610
25611 static int
25612 partial_die_eq (const void *item_lhs, const void *item_rhs)
25613 {
25614   const struct partial_die_info *part_die_lhs
25615     = (const struct partial_die_info *) item_lhs;
25616   const struct partial_die_info *part_die_rhs
25617     = (const struct partial_die_info *) item_rhs;
25618
25619   return part_die_lhs->sect_off == part_die_rhs->sect_off;
25620 }
25621
25622 struct cmd_list_element *set_dwarf_cmdlist;
25623 struct cmd_list_element *show_dwarf_cmdlist;
25624
25625 static void
25626 set_dwarf_cmd (const char *args, int from_tty)
25627 {
25628   help_list (set_dwarf_cmdlist, "maintenance set dwarf ", all_commands,
25629              gdb_stdout);
25630 }
25631
25632 static void
25633 show_dwarf_cmd (const char *args, int from_tty)
25634 {
25635   cmd_show_list (show_dwarf_cmdlist, from_tty, "");
25636 }
25637
25638 int dwarf_always_disassemble;
25639
25640 static void
25641 show_dwarf_always_disassemble (struct ui_file *file, int from_tty,
25642                                struct cmd_list_element *c, const char *value)
25643 {
25644   fprintf_filtered (file,
25645                     _("Whether to always disassemble "
25646                       "DWARF expressions is %s.\n"),
25647                     value);
25648 }
25649
25650 static void
25651 show_check_physname (struct ui_file *file, int from_tty,
25652                      struct cmd_list_element *c, const char *value)
25653 {
25654   fprintf_filtered (file,
25655                     _("Whether to check \"physname\" is %s.\n"),
25656                     value);
25657 }
25658
25659 void
25660 _initialize_dwarf2_read (void)
25661 {
25662   dwarf2_objfile_data_key
25663     = register_objfile_data_with_cleanup (nullptr, dwarf2_free_objfile);
25664
25665   add_prefix_cmd ("dwarf", class_maintenance, set_dwarf_cmd, _("\
25666 Set DWARF specific variables.\n\
25667 Configure DWARF variables such as the cache size"),
25668                   &set_dwarf_cmdlist, "maintenance set dwarf ",
25669                   0/*allow-unknown*/, &maintenance_set_cmdlist);
25670
25671   add_prefix_cmd ("dwarf", class_maintenance, show_dwarf_cmd, _("\
25672 Show DWARF specific variables\n\
25673 Show DWARF variables such as the cache size"),
25674                   &show_dwarf_cmdlist, "maintenance show dwarf ",
25675                   0/*allow-unknown*/, &maintenance_show_cmdlist);
25676
25677   add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
25678                             &dwarf_max_cache_age, _("\
25679 Set the upper bound on the age of cached DWARF compilation units."), _("\
25680 Show the upper bound on the age of cached DWARF compilation units."), _("\
25681 A higher limit means that cached compilation units will be stored\n\
25682 in memory longer, and more total memory will be used.  Zero disables\n\
25683 caching, which can slow down startup."),
25684                             NULL,
25685                             show_dwarf_max_cache_age,
25686                             &set_dwarf_cmdlist,
25687                             &show_dwarf_cmdlist);
25688
25689   add_setshow_boolean_cmd ("always-disassemble", class_obscure,
25690                            &dwarf_always_disassemble, _("\
25691 Set whether `info address' always disassembles DWARF expressions."), _("\
25692 Show whether `info address' always disassembles DWARF expressions."), _("\
25693 When enabled, DWARF expressions are always printed in an assembly-like\n\
25694 syntax.  When disabled, expressions will be printed in a more\n\
25695 conversational style, when possible."),
25696                            NULL,
25697                            show_dwarf_always_disassemble,
25698                            &set_dwarf_cmdlist,
25699                            &show_dwarf_cmdlist);
25700
25701   add_setshow_zuinteger_cmd ("dwarf-read", no_class, &dwarf_read_debug, _("\
25702 Set debugging of the DWARF reader."), _("\
25703 Show debugging of the DWARF reader."), _("\
25704 When enabled (non-zero), debugging messages are printed during DWARF\n\
25705 reading and symtab expansion.  A value of 1 (one) provides basic\n\
25706 information.  A value greater than 1 provides more verbose information."),
25707                             NULL,
25708                             NULL,
25709                             &setdebuglist, &showdebuglist);
25710
25711   add_setshow_zuinteger_cmd ("dwarf-die", no_class, &dwarf_die_debug, _("\
25712 Set debugging of the DWARF DIE reader."), _("\
25713 Show debugging of the DWARF DIE reader."), _("\
25714 When enabled (non-zero), DIEs are dumped after they are read in.\n\
25715 The value is the maximum depth to print."),
25716                              NULL,
25717                              NULL,
25718                              &setdebuglist, &showdebuglist);
25719
25720   add_setshow_zuinteger_cmd ("dwarf-line", no_class, &dwarf_line_debug, _("\
25721 Set debugging of the dwarf line reader."), _("\
25722 Show debugging of the dwarf line reader."), _("\
25723 When enabled (non-zero), line number entries are dumped as they are read in.\n\
25724 A value of 1 (one) provides basic information.\n\
25725 A value greater than 1 provides more verbose information."),
25726                              NULL,
25727                              NULL,
25728                              &setdebuglist, &showdebuglist);
25729
25730   add_setshow_boolean_cmd ("check-physname", no_class, &check_physname, _("\
25731 Set cross-checking of \"physname\" code against demangler."), _("\
25732 Show cross-checking of \"physname\" code against demangler."), _("\
25733 When enabled, GDB's internal \"physname\" code is checked against\n\
25734 the demangler."),
25735                            NULL, show_check_physname,
25736                            &setdebuglist, &showdebuglist);
25737
25738   add_setshow_boolean_cmd ("use-deprecated-index-sections",
25739                            no_class, &use_deprecated_index_sections, _("\
25740 Set whether to use deprecated gdb_index sections."), _("\
25741 Show whether to use deprecated gdb_index sections."), _("\
25742 When enabled, deprecated .gdb_index sections are used anyway.\n\
25743 Normally they are ignored either because of a missing feature or\n\
25744 performance issue.\n\
25745 Warning: This option must be enabled before gdb reads the file."),
25746                            NULL,
25747                            NULL,
25748                            &setlist, &showlist);
25749
25750   dwarf2_locexpr_index = register_symbol_computed_impl (LOC_COMPUTED,
25751                                                         &dwarf2_locexpr_funcs);
25752   dwarf2_loclist_index = register_symbol_computed_impl (LOC_COMPUTED,
25753                                                         &dwarf2_loclist_funcs);
25754
25755   dwarf2_locexpr_block_index = register_symbol_block_impl (LOC_BLOCK,
25756                                         &dwarf2_block_frame_base_locexpr_funcs);
25757   dwarf2_loclist_block_index = register_symbol_block_impl (LOC_BLOCK,
25758                                         &dwarf2_block_frame_base_loclist_funcs);
25759
25760 #if GDB_SELF_TEST
25761   selftests::register_test ("dw2_expand_symtabs_matching",
25762                             selftests::dw2_expand_symtabs_matching::run_test);
25763 #endif
25764 }