GDB (xrefs)
/tmp/gdb-7.10/gdb/dwarf2read.c
Go to the documentation of this file.
1 /* DWARF 2 debugging format support for GDB.
2 
3  Copyright (C) 1994-2015 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 "bfd.h"
33 #include "elf-bfd.h"
34 #include "symtab.h"
35 #include "gdbtypes.h"
36 #include "objfiles.h"
37 #include "dwarf2.h"
38 #include "buildsym.h"
39 #include "demangle.h"
40 #include "gdb-demangle.h"
41 #include "expression.h"
42 #include "filenames.h" /* for DOSish file names */
43 #include "macrotab.h"
44 #include "language.h"
45 #include "complaints.h"
46 #include "bcache.h"
47 #include "dwarf2expr.h"
48 #include "dwarf2loc.h"
49 #include "cp-support.h"
50 #include "hashtab.h"
51 #include "command.h"
52 #include "gdbcmd.h"
53 #include "block.h"
54 #include "addrmap.h"
55 #include "typeprint.h"
56 #include "jv-lang.h"
57 #include "psympriv.h"
58 #include <sys/stat.h>
59 #include "completer.h"
60 #include "vec.h"
61 #include "c-lang.h"
62 #include "go-lang.h"
63 #include "valprint.h"
64 #include "gdbcore.h" /* for gnutarget */
65 #include "gdb/gdb-index.h"
66 #include <ctype.h>
67 #include "gdb_bfd.h"
68 #include "f-lang.h"
69 #include "source.h"
70 #include "filestuff.h"
71 #include "build-id.h"
72 
73 #include <fcntl.h>
74 #include <sys/types.h>
75 
76 typedef struct symbol *symbolp;
77 DEF_VEC_P (symbolp);
78 
79 /* When == 1, print basic high level tracing messages.
80  When > 1, be more verbose.
81  This is in contrast to the low level DIE reading of dwarf_die_debug. */
82 static unsigned int dwarf_read_debug = 0;
83 
84 /* When non-zero, dump DIEs after they are read in. */
85 static unsigned int dwarf_die_debug = 0;
86 
87 /* When non-zero, dump line number entries as they are read in. */
88 static unsigned int dwarf_line_debug = 0;
89 
90 /* When non-zero, cross-check physname against demangler. */
91 static int check_physname = 0;
92 
93 /* When non-zero, do not reject deprecated .gdb_index sections. */
95 
96 static const struct objfile_data *dwarf2_objfile_data_key;
97 
98 /* The "aclass" indices for various kinds of computed DWARF symbols. */
99 
104 
105 /* A descriptor for dwarf sections.
106 
107  S.ASECTION, SIZE are typically initialized when the objfile is first
108  scanned. BUFFER, READIN are filled in later when the section is read.
109  If the section contained compressed data then SIZE is updated to record
110  the uncompressed size of the section.
111 
112  DWP file format V2 introduces a wrinkle that is easiest to handle by
113  creating the concept of virtual sections contained within a real section.
114  In DWP V2 the sections of the input DWO files are concatenated together
115  into one section, but section offsets are kept relative to the original
116  input section.
117  If this is a virtual dwp-v2 section, S.CONTAINING_SECTION is a backlink to
118  the real section this "virtual" section is contained in, and BUFFER,SIZE
119  describe the virtual section. */
120 
122 {
123  union
124  {
125  /* If this is a real section, the bfd section. */
127  /* If this is a virtual section, pointer to the containing ("real")
128  section. */
130  } s;
131  /* Pointer to section data, only valid if readin. */
132  const gdb_byte *buffer;
133  /* The size of the section, real or virtual. */
134  bfd_size_type size;
135  /* If this is a virtual section, the offset in the real section.
136  Only valid if is_virtual. */
137  bfd_size_type virtual_offset;
138  /* True if we have tried to read this section. */
139  char readin;
140  /* True if this is a virtual section, False otherwise.
141  This specifies which of s.asection and s.containing_section to use. */
143 };
144 
147 
148 /* All offsets in the index are of this type. It must be
149  architecture-independent. */
150 typedef uint32_t offset_type;
151 
152 DEF_VEC_I (offset_type);
153 
154 /* Ensure only legit values are used. */
155 #define DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE(cu_index, value) \
156  do { \
157  gdb_assert ((unsigned int) (value) <= 1); \
158  GDB_INDEX_SYMBOL_STATIC_SET_VALUE((cu_index), (value)); \
159  } while (0)
160 
161 /* Ensure only legit values are used. */
162 #define DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE(cu_index, value) \
163  do { \
164  gdb_assert ((value) >= GDB_INDEX_SYMBOL_KIND_TYPE \
165  && (value) <= GDB_INDEX_SYMBOL_KIND_OTHER); \
166  GDB_INDEX_SYMBOL_KIND_SET_VALUE((cu_index), (value)); \
167  } while (0)
168 
169 /* Ensure we don't use more than the alloted nuber of bits for the CU. */
170 #define DW2_GDB_INDEX_CU_SET_VALUE(cu_index, value) \
171  do { \
172  gdb_assert (((value) & ~GDB_INDEX_CU_MASK) == 0); \
173  GDB_INDEX_CU_SET_VALUE((cu_index), (value)); \
174  } while (0)
175 
176 /* A description of the mapped index. The file format is described in
177  a comment by the code that writes the index. */
179 {
180  /* Index data format version. */
181  int version;
182 
183  /* The total length of the buffer. */
184  off_t total_size;
185 
186  /* A pointer to the address table data. */
188 
189  /* Size of the address table data in bytes. */
190  offset_type address_table_size;
191 
192  /* The symbol table, implemented as a hash table. */
193  const offset_type *symbol_table;
194 
195  /* Size in slots, each slot is 2 offset_types. */
196  offset_type symbol_table_slots;
197 
198  /* A pointer to the constant pool. */
199  const char *constant_pool;
200 };
201 
203 DEF_VEC_P (dwarf2_per_cu_ptr);
204 
205 struct tu_stats
206 {
212 };
213 
214 /* Collection of data recorded per objfile.
215  This hangs off of dwarf2_objfile_data_key. */
216 
217 struct dwarf2_per_objfile
218 {
231 
232  VEC (dwarf2_section_info_def) *types;
233 
234  /* Back link. */
235  struct objfile *objfile;
236 
237  /* Table of all the compilation units. This is used to locate
238  the target compilation unit of a particular reference. */
239  struct dwarf2_per_cu_data **all_comp_units;
240 
241  /* The number of compilation units in ALL_COMP_UNITS. */
242  int n_comp_units;
243 
244  /* The number of .debug_types-related CUs. */
245  int n_type_units;
246 
247  /* The number of elements allocated in all_type_units.
248  If there are skeleton-less TUs, we add them to all_type_units lazily. */
249  int n_allocated_type_units;
250 
251  /* The .debug_types-related CUs (TUs).
252  This is stored in malloc space because we may realloc it. */
253  struct signatured_type **all_type_units;
254 
255  /* Table of struct type_unit_group objects.
256  The hash key is the DW_AT_stmt_list value. */
257  htab_t type_unit_groups;
258 
259  /* A table mapping .debug_types signatures to its signatured_type entry.
260  This is NULL if the .debug_types section hasn't been read in yet. */
261  htab_t signatured_types;
262 
263  /* Type unit statistics, to see how well the scaling improvements
264  are doing. */
265  struct tu_stats tu_stats;
266 
267  /* A chain of compilation units that are currently read in, so that
268  they can be freed later. */
269  struct dwarf2_per_cu_data *read_in_chain;
270 
271  /* A table mapping DW_AT_dwo_name values to struct dwo_file objects.
272  This is NULL if the table hasn't been allocated yet. */
273  htab_t dwo_files;
274 
275  /* Non-zero if we've check for whether there is a DWP file. */
276  int dwp_checked;
277 
278  /* The DWP file if there is one, or NULL. */
279  struct dwp_file *dwp_file;
280 
281  /* The shared '.dwz' file, if one exists. This is used when the
282  original data was compressed using 'dwz -m'. */
283  struct dwz_file *dwz_file;
284 
285  /* A flag indicating wether this objfile has a section loaded at a
286  VMA of 0. */
287  int has_section_at_zero;
288 
289  /* True if we are using the mapped index,
290  or we are faking it for OBJF_READNOW's sake. */
291  unsigned char using_index;
292 
293  /* The mapped index, or NULL if .gdb_index is missing or not being used. */
294  struct mapped_index *index_table;
295 
296  /* When using index_table, this keeps track of all quick_file_names entries.
297  TUs typically share line table entries with a CU, so we maintain a
298  separate table of all line table entries to support the sharing.
299  Note that while there can be way more TUs than CUs, we've already
300  sorted all the TUs into "type unit groups", grouped by their
301  DW_AT_stmt_list value. Therefore the only sharing done here is with a
302  CU and its associated TU group if there is one. */
303  htab_t quick_file_names_table;
304 
305  /* Set during partial symbol reading, to prevent queueing of full
306  symbols. */
307  int reading_partial_symbols;
308 
309  /* Table mapping type DIEs to their struct type *.
310  This is NULL if not allocated yet.
311  The mapping is done via (CU/TU + DIE offset) -> type. */
312  htab_t die_type_hash;
313 
314  /* The CUs we recently read. */
315  VEC (dwarf2_per_cu_ptr) *just_read_cus;
316 
317  /* Table containing line_header indexed by offset and offset_in_dwz. */
318  htab_t line_header_hash;
319 };
320 
321 static struct dwarf2_per_objfile *dwarf2_per_objfile;
322 
323 /* Default names of the debugging sections. */
324 
325 /* Note that if the debugging section has been compressed, it might
326  have a name like .zdebug_info. */
327 
328 static const struct dwarf2_debug_sections dwarf2_elf_names =
329 {
330  { ".debug_info", ".zdebug_info" },
331  { ".debug_abbrev", ".zdebug_abbrev" },
332  { ".debug_line", ".zdebug_line" },
333  { ".debug_loc", ".zdebug_loc" },
334  { ".debug_macinfo", ".zdebug_macinfo" },
335  { ".debug_macro", ".zdebug_macro" },
336  { ".debug_str", ".zdebug_str" },
337  { ".debug_ranges", ".zdebug_ranges" },
338  { ".debug_types", ".zdebug_types" },
339  { ".debug_addr", ".zdebug_addr" },
340  { ".debug_frame", ".zdebug_frame" },
341  { ".eh_frame", NULL },
342  { ".gdb_index", ".zgdb_index" },
343  23
344 };
345 
346 /* List of DWO/DWP sections. */
347 
348 static const struct dwop_section_names
349 {
361 }
363 {
364  { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
365  { ".debug_info.dwo", ".zdebug_info.dwo" },
366  { ".debug_line.dwo", ".zdebug_line.dwo" },
367  { ".debug_loc.dwo", ".zdebug_loc.dwo" },
368  { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
369  { ".debug_macro.dwo", ".zdebug_macro.dwo" },
370  { ".debug_str.dwo", ".zdebug_str.dwo" },
371  { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
372  { ".debug_types.dwo", ".zdebug_types.dwo" },
373  { ".debug_cu_index", ".zdebug_cu_index" },
374  { ".debug_tu_index", ".zdebug_tu_index" },
375 };
376 
377 /* local data types */
378 
379 /* The data in a compilation unit header, after target2host
380  translation, looks like this. */
382 {
383  unsigned int length;
384  short version;
385  unsigned char addr_size;
386  unsigned char signed_addr_p;
388 
389  /* Size of file offsets; either 4 or 8. */
390  unsigned int offset_size;
391 
392  /* Size of the length field; either 4 or 12. */
393  unsigned int initial_length_size;
394 
395  /* Offset to the first byte of this compilation unit header in the
396  .debug_info section, for resolving relative reference dies. */
398 
399  /* Offset to first die in this cu from the start of the cu.
400  This will be the first byte following the compilation unit header. */
402 };
403 
404 /* Type used for delaying computation of method physnames.
405  See comments for compute_delayed_physnames. */
407 {
408  /* The type to which the method is attached, i.e., its parent class. */
409  struct type *type;
410 
411  /* The index of the method in the type's function fieldlists. */
413 
414  /* The index of the method in the fieldlist. */
415  int index;
416 
417  /* The name of the DIE. */
418  const char *name;
419 
420  /* The DIE associated with this method. */
421  struct die_info *die;
422 };
423 
426 
427 /* Internal state when decoding a particular compilation unit. */
428 struct dwarf2_cu
429 {
430  /* The objfile containing this compilation unit. */
431  struct objfile *objfile;
432 
433  /* The header of the compilation unit. */
435 
436  /* Base address of this compilation unit. */
438 
439  /* Non-zero if base_address has been set. */
441 
442  /* The language we are debugging. */
445 
446  const char *producer;
447 
448  /* The generic symbol table building routines have separate lists for
449  file scope symbols and all all other scopes (local scopes). So
450  we need to select the right one to pass to add_symbol_to_list().
451  We do it by keeping a pointer to the correct list in list_in_scope.
452 
453  FIXME: The original dwarf code just treated the file scope as the
454  first local scope, and all other local scopes as nested local
455  scopes, and worked fine. Check to see if we really need to
456  distinguish these in buildsym.c. */
458 
459  /* The abbrev table for this CU.
460  Normally this points to the abbrev table in the objfile.
461  But if DWO_UNIT is non-NULL this is the abbrev table in the DWO file. */
463 
464  /* Hash table holding all the loaded partial DIEs
465  with partial_die->offset.SECT_OFF as hash. */
466  htab_t partial_dies;
467 
468  /* Storage for things with the same lifetime as this read-in compilation
469  unit, including partial DIEs. */
470  struct obstack comp_unit_obstack;
471 
472  /* When multiple dwarf2_cu structures are living in memory, this field
473  chains them all together, so that they can be released efficiently.
474  We will probably also want a generation counter so that most-recently-used
475  compilation units are cached... */
477 
478  /* Backlink to our per_cu entry. */
480 
481  /* How many compilation units ago was this CU last referenced? */
483 
484  /* A hash table of DIE cu_offset for following references with
485  die_info->offset.sect_off as hash. */
486  htab_t die_hash;
487 
488  /* Full DIEs if read in. */
489  struct die_info *dies;
490 
491  /* A set of pointers to dwarf2_per_cu_data objects for compilation
492  units referenced by this one. Only set during full symbol processing;
493  partial symbol tables do not have dependencies. */
494  htab_t dependencies;
495 
496  /* Header data from the line table, during full symbol processing. */
498 
499  /* A list of methods which need to have physnames computed
500  after all type information has been read. */
501  VEC (delayed_method_info) *method_list;
502 
503  /* To be copied to symtab->call_site_htab. */
504  htab_t call_site_htab;
505 
506  /* Non-NULL if this CU came from a DWO file.
507  There is an invariant here that is important to remember:
508  Except for attributes copied from the top level DIE in the "main"
509  (or "stub") file in preparation for reading the DWO file
510  (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
511  Either there isn't a DWO file (in which case this is NULL and the point
512  is moot), or there is and either we're not going to read it (in which
513  case this is NULL) or there is and we are reading it (in which case this
514  is non-NULL). */
515  struct dwo_unit *dwo_unit;
516 
517  /* The DW_AT_addr_base attribute if present, zero otherwise
518  (zero is a valid value though).
519  Note this value comes from the Fission stub CU/TU's DIE. */
520  ULONGEST addr_base;
521 
522  /* The DW_AT_ranges_base attribute if present, zero otherwise
523  (zero is a valid value though).
524  Note this value comes from the Fission stub CU/TU's DIE.
525  Also note that the value is zero in the non-DWO case so this value can
526  be used without needing to know whether DWO files are in use or not.
527  N.B. This does not apply to DW_AT_ranges appearing in
528  DW_TAG_compile_unit dies. This is a bit of a wart, consider if ever
529  DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
530  DW_AT_ranges_base *would* have to be applied, and we'd have to care
531  whether the DW_AT_ranges attribute came from the skeleton or DWO. */
532  ULONGEST ranges_base;
533 
534  /* Mark used when releasing cached dies. */
535  unsigned int mark : 1;
536 
537  /* This CU references .debug_loc. See the symtab->locations_valid field.
538  This test is imperfect as there may exist optimized debug code not using
539  any location list and still facing inlining issues if handled as
540  unoptimized code. For a future better test see GCC PR other/32998. */
541  unsigned int has_loclist : 1;
542 
543  /* These cache the results for producer_is_* fields. CHECKED_PRODUCER is set
544  if all the producer_is_* fields are valid. This information is cached
545  because profiling CU expansion showed excessive time spent in
546  producer_is_gxx_lt_4_6. */
547  unsigned int checked_producer : 1;
548  unsigned int producer_is_gxx_lt_4_6 : 1;
549  unsigned int producer_is_gcc_lt_4_3 : 1;
550  unsigned int producer_is_icc : 1;
551 
552  /* When set, the file that we're processing is known to have
553  debugging info for C++ namespaces. GCC 3.3.x did not produce
554  this information, but later versions do. */
555 
556  unsigned int processing_has_namespace_info : 1;
557 };
558 
559 /* Persistent data held for a compilation unit, even when not
560  processing it. We put a pointer to this structure in the
561  read_symtab_private field of the psymtab. */
562 
564 {
565  /* The start offset and length of this compilation unit.
566  NOTE: Unlike comp_unit_head.length, this length includes
567  initial_length_size.
568  If the DIE refers to a DWO file, this is always of the original die,
569  not the DWO file. */
571  unsigned int length;
572 
573  /* Flag indicating this compilation unit will be read in before
574  any of the current compilation units are processed. */
575  unsigned int queued : 1;
576 
577  /* This flag will be set when reading partial DIEs if we need to load
578  absolutely all DIEs for this compilation unit, instead of just the ones
579  we think are interesting. It gets set if we look for a DIE in the
580  hash table and don't find it. */
581  unsigned int load_all_dies : 1;
582 
583  /* Non-zero if this CU is from .debug_types.
584  Struct dwarf2_per_cu_data is contained in struct signatured_type iff
585  this is non-zero. */
586  unsigned int is_debug_types : 1;
587 
588  /* Non-zero if this CU is from the .dwz file. */
589  unsigned int is_dwz : 1;
590 
591  /* Non-zero if reading a TU directly from a DWO file, bypassing the stub.
592  This flag is only valid if is_debug_types is true.
593  We can't read a CU directly from a DWO file: There are required
594  attributes in the stub. */
595  unsigned int reading_dwo_directly : 1;
596 
597  /* Non-zero if the TU has been read.
598  This is used to assist the "Stay in DWO Optimization" for Fission:
599  When reading a DWO, it's faster to read TUs from the DWO instead of
600  fetching them from random other DWOs (due to comdat folding).
601  If the TU has already been read, the optimization is unnecessary
602  (and unwise - we don't want to change where gdb thinks the TU lives
603  "midflight").
604  This flag is only valid if is_debug_types is true. */
605  unsigned int tu_read : 1;
606 
607  /* The section this CU/TU lives in.
608  If the DIE refers to a DWO file, this is always the original die,
609  not the DWO file. */
611 
612  /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
613  of the CU cache it gets reset to NULL again. */
614  struct dwarf2_cu *cu;
615 
616  /* The corresponding objfile.
617  Normally we can get the objfile from dwarf2_per_objfile.
618  However we can enter this file with just a "per_cu" handle. */
619  struct objfile *objfile;
620 
621  /* When dwarf2_per_objfile->using_index is true, the 'quick' field
622  is active. Otherwise, the 'psymtab' field is active. */
623  union
624  {
625  /* The partial symbol table associated with this compilation unit,
626  or NULL for unread partial units. */
628 
629  /* Data needed by the "quick" functions. */
631  } v;
632 
633  /* The CUs we import using DW_TAG_imported_unit. This is filled in
634  while reading psymtabs, used to compute the psymtab dependencies,
635  and then cleared. Then it is filled in again while reading full
636  symbols, and only deleted when the objfile is destroyed.
637 
638  This is also used to work around a difference between the way gold
639  generates .gdb_index version <=7 and the way gdb does. Arguably this
640  is a gold bug. For symbols coming from TUs, gold records in the index
641  the CU that includes the TU instead of the TU itself. This breaks
642  dw2_lookup_symbol: It assumes that if the index says symbol X lives
643  in CU/TU Y, then one need only expand Y and a subsequent lookup in Y
644  will find X. Alas TUs live in their own symtab, so after expanding CU Y
645  we need to look in TU Z to find X. Fortunately, this is akin to
646  DW_TAG_imported_unit, so we just use the same mechanism: For
647  .gdb_index version <=7 this also records the TUs that the CU referred
648  to. Concurrently with this change gdb was modified to emit version 8
649  indices so we only pay a price for gold generated indices.
650  http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
651  VEC (dwarf2_per_cu_ptr) *imported_symtabs;
652 };
653 
654 /* Entry in the signatured_types hash table. */
655 
657 {
658  /* The "per_cu" object of this type.
659  This struct is used iff per_cu.is_debug_types.
660  N.B.: This is the first member so that it's easy to convert pointers
661  between them. */
662  struct dwarf2_per_cu_data per_cu;
663 
664  /* The type's signature. */
666 
667  /* Offset in the TU of the type's DIE, as read from the TU header.
668  If this TU is a DWO stub and the definition lives in a DWO file
669  (specified by DW_AT_GNU_dwo_name), this value is unusable. */
671 
672  /* Offset in the section of the type's DIE.
673  If the definition lives in a DWO file, this is the offset in the
674  .debug_types.dwo section.
675  The value is zero until the actual value is known.
676  Zero is otherwise not a valid section offset. */
678 
679  /* Type units are grouped by their DW_AT_stmt_list entry so that they
680  can share them. This points to the containing symtab. */
682 
683  /* The type.
684  The first time we encounter this type we fully read it in and install it
685  in the symbol tables. Subsequent times we only need the type. */
686  struct type *type;
687 
688  /* Containing DWO unit.
689  This field is valid iff per_cu.reading_dwo_directly. */
691 };
692 
694 DEF_VEC_P (sig_type_ptr);
695 
696 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
697  This includes type_unit_group and quick_file_names. */
698 
700 {
701  /* The DWO unit this table is from or NULL if there is none. */
703 
704  /* Offset in .debug_line or .debug_line.dwo. */
706 };
707 
708 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
709  an object of this type. */
710 
712 {
713  /* dwarf2read.c's main "handle" on a TU symtab.
714  To simplify things we create an artificial CU that "includes" all the
715  type units using this stmt_list so that the rest of the code still has
716  a "per_cu" handle on the symtab.
717  This PER_CU is recognized by having no section. */
718 #define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->section == NULL)
719  struct dwarf2_per_cu_data per_cu;
720 
721  /* The TUs that share this DW_AT_stmt_list entry.
722  This is added to while parsing type units to build partial symtabs,
723  and is deleted afterwards and not used again. */
724  VEC (sig_type_ptr) *tus;
725 
726  /* The compunit symtab.
727  Type units in a group needn't all be defined in the same source file,
728  so we create an essentially anonymous symtab as the compunit symtab. */
730 
731  /* The data used to construct the hash key. */
732  struct stmt_list_hash hash;
733 
734  /* The number of symtabs from the line header.
735  The value here must match line_header.num_file_names. */
736  unsigned int num_symtabs;
737 
738  /* The symbol tables for this TU (obtained from the files listed in
739  DW_AT_stmt_list).
740  WARNING: The order of entries here must match the order of entries
741  in the line header. After the first TU using this type_unit_group, the
742  line header for the subsequent TUs is recreated from this. This is done
743  because we need to use the same symtabs for each TU using the same
744  DW_AT_stmt_list value. Also note that symtabs may be repeated here,
745  there's no guarantee the line header doesn't have duplicate entries. */
746  struct symtab **symtabs;
747 };
748 
749 /* These sections are what may appear in a (real or virtual) DWO file. */
750 
752 {
760  /* In the case of a virtual DWO file, these two are unused. */
762  VEC (dwarf2_section_info_def) *types;
763 };
764 
765 /* CUs/TUs in DWP/DWO files. */
766 
767 struct dwo_unit
768 {
769  /* Backlink to the containing struct dwo_file. */
771 
772  /* The "id" that distinguishes this CU/TU.
773  .debug_info calls this "dwo_id", .debug_types calls this "signature".
774  Since signatures came first, we stick with it for consistency. */
776 
777  /* The section this CU/TU lives in, in the DWO file. */
779 
780  /* Same as dwarf2_per_cu_data:{offset,length} but in the DWO section. */
782  unsigned int length;
783 
784  /* For types, offset in the type's DIE of the type defined by this TU. */
786 };
787 
788 /* include/dwarf2.h defines the DWP section codes.
789  It defines a max value but it doesn't define a min value, which we
790  use for error checking, so provide one. */
791 
793 {
795 };
796 
797 /* Data for one DWO file.
798 
799  This includes virtual DWO files (a virtual DWO file is a DWO file as it
800  appears in a DWP file). DWP files don't really have DWO files per se -
801  comdat folding of types "loses" the DWO file they came from, and from
802  a high level view DWP files appear to contain a mass of random types.
803  However, to maintain consistency with the non-DWP case we pretend DWP
804  files contain virtual DWO files, and we assign each TU with one virtual
805  DWO file (generally based on the line and abbrev section offsets -
806  a heuristic that seems to work in practice). */
807 
808 struct dwo_file
809 {
810  /* The DW_AT_GNU_dwo_name attribute.
811  For virtual DWO files the name is constructed from the section offsets
812  of abbrev,line,loc,str_offsets so that we combine virtual DWO files
813  from related CU+TUs. */
814  const char *dwo_name;
815 
816  /* The DW_AT_comp_dir attribute. */
817  const char *comp_dir;
818 
819  /* The bfd, when the file is open. Otherwise this is NULL.
820  This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
821  bfd *dbfd;
822 
823  /* The sections that make up this DWO file.
824  Remember that for virtual DWO files in DWP V2, these are virtual
825  sections (for lack of a better name). */
827 
828  /* The CU in the file.
829  We only support one because having more than one requires hacking the
830  dwo_name of each to match, which is highly unlikely to happen.
831  Doing this means all TUs can share comp_dir: We also assume that
832  DW_AT_comp_dir across all TUs in a DWO file will be identical. */
833  struct dwo_unit *cu;
834 
835  /* Table of TUs in the file.
836  Each element is a struct dwo_unit. */
837  htab_t tus;
838 };
839 
840 /* These sections are what may appear in a DWP file. */
841 
843 {
844  /* These are used by both DWP version 1 and 2. */
848 
849  /* These are only used by DWP version 2 files.
850  In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
851  sections are referenced by section number, and are not recorded here.
852  In DWP version 2 there is at most one copy of all these sections, each
853  section being (effectively) comprised of the concatenation of all of the
854  individual sections that exist in the version 1 format.
855  To keep the code simple we treat each of these concatenated pieces as a
856  section itself (a virtual section?). */
865 };
866 
867 /* These sections are what may appear in a virtual DWO file in DWP version 1.
868  A virtual DWO file is a DWO file as it appears in a DWP file. */
869 
871 {
878  /* Each DWP hash table entry records one CU or one TU.
879  That is recorded here, and copied to dwo_unit.section. */
881 };
882 
883 /* Similar to virtual_v1_dwo_sections, but for DWP version 2.
884  In version 2, the sections of the DWO files are concatenated together
885  and stored in one section of that name. Thus each ELF section contains
886  several "virtual" sections. */
887 
889 {
890  bfd_size_type abbrev_offset;
891  bfd_size_type abbrev_size;
892 
893  bfd_size_type line_offset;
894  bfd_size_type line_size;
895 
896  bfd_size_type loc_offset;
897  bfd_size_type loc_size;
898 
899  bfd_size_type macinfo_offset;
900  bfd_size_type macinfo_size;
901 
902  bfd_size_type macro_offset;
903  bfd_size_type macro_size;
904 
905  bfd_size_type str_offsets_offset;
906  bfd_size_type str_offsets_size;
907 
908  /* Each DWP hash table entry records one CU or one TU.
909  That is recorded here, and copied to dwo_unit.section. */
910  bfd_size_type info_or_types_offset;
911  bfd_size_type info_or_types_size;
912 };
913 
914 /* Contents of DWP hash tables. */
915 
917 {
918  uint32_t version, nr_columns;
919  uint32_t nr_units, nr_slots;
921  union
922  {
923  struct
924  {
926  } v1;
927  struct
928  {
929  /* This is indexed by column number and gives the id of the section
930  in that column. */
931 #define MAX_NR_V2_DWO_SECTIONS \
932  (1 /* .debug_info or .debug_types */ \
933  + 1 /* .debug_abbrev */ \
934  + 1 /* .debug_line */ \
935  + 1 /* .debug_loc */ \
936  + 1 /* .debug_str_offsets */ \
937  + 1 /* .debug_macro or .debug_macinfo */)
940  const gdb_byte *sizes;
941  } v2;
942  } section_pool;
943 };
944 
945 /* Data for one DWP file. */
946 
947 struct dwp_file
948 {
949  /* Name of the file. */
950  const char *name;
951 
952  /* File format version. */
953  int version;
954 
955  /* The bfd. */
956  bfd *dbfd;
957 
958  /* Section info for this file. */
960 
961  /* Table of CUs in the file. */
962  const struct dwp_hash_table *cus;
963 
964  /* Table of TUs in the file. */
965  const struct dwp_hash_table *tus;
966 
967  /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
968  htab_t loaded_cus;
969  htab_t loaded_tus;
970 
971  /* Table to map ELF section numbers to their sections.
972  This is only needed for the DWP V1 file format. */
973  unsigned int num_sections;
974  asection **elf_sections;
975 };
976 
977 /* This represents a '.dwz' file. */
978 
979 struct dwz_file
980 {
981  /* A dwz file can only contain a few sections. */
988 
989  /* The dwz's BFD. */
990  bfd *dwz_bfd;
991 };
992 
993 /* Struct used to pass misc. parameters to read_die_and_children, et
994  al. which are used for both .debug_info and .debug_types dies.
995  All parameters here are unchanging for the life of the call. This
996  struct exists to abstract away the constant parameters of die reading. */
997 
999 {
1000  /* The bfd of die_section. */
1001  bfd* abfd;
1002 
1003  /* The CU of the DIE we are parsing. */
1004  struct dwarf2_cu *cu;
1005 
1006  /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
1008 
1009  /* The section the die comes from.
1010  This is either .debug_info or .debug_types, or the .dwo variants. */
1012 
1013  /* die_section->buffer. */
1015 
1016  /* The end of the buffer. */
1018 
1019  /* The value of the DW_AT_comp_dir attribute. */
1020  const char *comp_dir;
1021 };
1022 
1023 /* Type of function passed to init_cutu_and_read_dies, et.al. */
1024 typedef void (die_reader_func_ftype) (const struct die_reader_specs *reader,
1025  const gdb_byte *info_ptr,
1026  struct die_info *comp_unit_die,
1027  int has_children,
1028  void *data);
1029 
1031 {
1032  const char *name;
1033  unsigned int dir_index;
1034  unsigned int mod_time;
1035  unsigned int length;
1036  /* Non-zero if referenced by the Line Number Program. */
1038  /* The associated symbol table, if any. */
1039  struct symtab *symtab;
1040 };
1041 
1042 /* The line number information for a compilation unit (found in the
1043  .debug_line section) begins with a "statement program header",
1044  which contains the following information. */
1046 {
1047  /* Offset of line number information in .debug_line section. */
1049 
1050  /* OFFSET is for struct dwz_file associated with dwarf2_per_objfile. */
1051  unsigned offset_in_dwz : 1;
1052 
1053  unsigned int total_length;
1054  unsigned short version;
1055  unsigned int header_length;
1058  unsigned char default_is_stmt;
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  unsigned char *standard_opcode_lengths;
1068 
1069  /* The include_directories table. NOTE! These strings are not
1070  allocated with xmalloc; instead, they are pointers into
1071  debug_line_buffer. If you try to free them, `free' will get
1072  indigestion. */
1074  const char **include_dirs;
1075 
1076  /* The file_names table. NOTE! These strings are not allocated
1077  with xmalloc; instead, they are pointers into debug_line_buffer.
1078  Don't try to free them directly. */
1081 
1082  /* The start and end of the statement program following this
1083  header. These point into dwarf2_per_objfile->line_buffer. */
1085 };
1086 
1087 /* When we construct a partial symbol table entry we only
1088  need this much information. */
1090  {
1091  /* Offset of this DIE. */
1093 
1094  /* DWARF-2 tag for this DIE. */
1095  ENUM_BITFIELD(dwarf_tag) tag : 16;
1096 
1097  /* Assorted flags describing the data found in this DIE. */
1098  unsigned int has_children : 1;
1099  unsigned int is_external : 1;
1100  unsigned int is_declaration : 1;
1101  unsigned int has_type : 1;
1102  unsigned int has_specification : 1;
1103  unsigned int has_pc_info : 1;
1104  unsigned int may_be_inlined : 1;
1105 
1106  /* Flag set if the SCOPE field of this structure has been
1107  computed. */
1108  unsigned int scope_set : 1;
1109 
1110  /* Flag set if the DIE has a byte_size attribute. */
1111  unsigned int has_byte_size : 1;
1112 
1113  /* Flag set if the DIE has a DW_AT_const_value attribute. */
1114  unsigned int has_const_value : 1;
1115 
1116  /* Flag set if any of the DIE's children are template arguments. */
1117  unsigned int has_template_arguments : 1;
1118 
1119  /* Flag set if fixup_partial_die has been called on this die. */
1120  unsigned int fixup_called : 1;
1121 
1122  /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1123  unsigned int is_dwz : 1;
1124 
1125  /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1126  unsigned int spec_is_dwz : 1;
1127 
1128  /* The name of this DIE. Normally the value of DW_AT_name, but
1129  sometimes a default name for unnamed DIEs. */
1130  const char *name;
1131 
1132  /* The linkage name, if present. */
1134 
1135  /* The scope to prepend to our children. This is generally
1136  allocated on the comp_unit_obstack, so will disappear
1137  when this compilation unit leaves the cache. */
1138  const char *scope;
1139 
1140  /* Some data associated with the partial DIE. The tag determines
1141  which field is live. */
1142  union
1143  {
1144  /* The location description associated with this DIE, if any. */
1146  /* The offset of an import, for DW_TAG_imported_unit. */
1148  } d;
1149 
1150  /* If HAS_PC_INFO, the PC range associated with this DIE. */
1153 
1154  /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1155  DW_AT_sibling, if any. */
1156  /* NOTE: This member isn't strictly necessary, read_partial_die could
1157  return DW_AT_sibling values to its caller load_partial_dies. */
1159 
1160  /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1161  DW_AT_specification (or DW_AT_abstract_origin or
1162  DW_AT_extension). */
1164 
1165  /* Pointers to this DIE's parent, first child, and next sibling,
1166  if any. */
1168  };
1169 
1170 /* This data structure holds the information of an abbrev. */
1172  {
1173  unsigned int number; /* number identifying abbrev */
1174  enum dwarf_tag tag; /* dwarf tag */
1175  unsigned short has_children; /* boolean */
1176  unsigned short num_attrs; /* number of attributes */
1177  struct attr_abbrev *attrs; /* an array of attribute descriptions */
1178  struct abbrev_info *next; /* next in chain */
1179  };
1180 
1182  {
1183  ENUM_BITFIELD(dwarf_attribute) name : 16;
1184  ENUM_BITFIELD(dwarf_form) form : 16;
1185  };
1186 
1187 /* Size of abbrev_table.abbrev_hash_table. */
1188 #define ABBREV_HASH_SIZE 121
1189 
1190 /* Top level data structure to contain an abbreviation table. */
1191 
1193 {
1194  /* Where the abbrev table came from.
1195  This is used as a sanity check when the table is used. */
1197 
1198  /* Storage for the abbrev table. */
1199  struct obstack abbrev_obstack;
1200 
1201  /* Hash table of abbrevs.
1202  This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1203  It could be statically allocated, but the previous code didn't so we
1204  don't either. */
1206 };
1207 
1208 /* Attributes have a name and a value. */
1210  {
1211  ENUM_BITFIELD(dwarf_attribute) name : 16;
1212  ENUM_BITFIELD(dwarf_form) form : 15;
1213 
1214  /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
1215  field should be in u.str (existing only for DW_STRING) but it is kept
1216  here for better struct attribute alignment. */
1217  unsigned int string_is_canonical : 1;
1218 
1219  union
1220  {
1221  const char *str;
1222  struct dwarf_block *blk;
1227  }
1228  u;
1229  };
1230 
1231 /* This data structure holds a complete die structure. */
1232 struct die_info
1233  {
1234  /* DWARF-2 tag for this DIE. */
1235  ENUM_BITFIELD(dwarf_tag) tag : 16;
1236 
1237  /* Number of attributes */
1238  unsigned char num_attrs;
1239 
1240  /* True if we're presently building the full type name for the
1241  type derived from this DIE. */
1242  unsigned char building_fullname : 1;
1243 
1244  /* True if this die is in process. PR 16581. */
1245  unsigned char in_process : 1;
1246 
1247  /* Abbrev number */
1248  unsigned int abbrev;
1249 
1250  /* Offset in .debug_info or .debug_types section. */
1252 
1253  /* The dies in a compilation unit form an n-ary tree. PARENT
1254  points to this die's parent; CHILD points to the first child of
1255  this node; and all the children of a given node are chained
1256  together via their SIBLING fields. */
1257  struct die_info *child; /* Its first child, if any. */
1258  struct die_info *sibling; /* Its next sibling, if any. */
1259  struct die_info *parent; /* Its parent, if any. */
1260 
1261  /* An array of attributes, with NUM_ATTRS elements. There may be
1262  zero, but it's not common and zero-sized arrays are not
1263  sufficiently portable C. */
1264  struct attribute attrs[1];
1265  };
1266 
1267 /* Get at parts of an attribute structure. */
1268 
1269 #define DW_STRING(attr) ((attr)->u.str)
1270 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1271 #define DW_UNSND(attr) ((attr)->u.unsnd)
1272 #define DW_BLOCK(attr) ((attr)->u.blk)
1273 #define DW_SND(attr) ((attr)->u.snd)
1274 #define DW_ADDR(attr) ((attr)->u.addr)
1275 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1276 
1277 /* Blocks are a bunch of untyped bytes. */
1279  {
1280  size_t size;
1281 
1282  /* Valid only if SIZE is not zero. */
1283  const gdb_byte *data;
1284  };
1285 
1286 #ifndef ATTR_ALLOC_CHUNK
1287 #define ATTR_ALLOC_CHUNK 4
1288 #endif
1289 
1290 /* Allocate fields for structs, unions and enums in this size. */
1291 #ifndef DW_FIELD_ALLOC_CHUNK
1292 #define DW_FIELD_ALLOC_CHUNK 4
1293 #endif
1294 
1295 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1296  but this would require a corresponding change in unpack_field_as_long
1297  and friends. */
1298 static int bits_per_byte = 8;
1299 
1301 {
1302  struct nextfield *next;
1305  struct field field;
1306 };
1307 
1309 {
1311  struct fn_field fnfield;
1312 };
1313 
1315 {
1316  const char *name;
1317  int length;
1319 };
1320 
1322 {
1325 };
1326 
1327 /* The routines that read and process dies for a C struct or C++ class
1328  pass lists of data member fields and lists of member function fields
1329  in an instance of a field_info structure, as defined below. */
1331  {
1332  /* List of data member and baseclasses fields. */
1333  struct nextfield *fields, *baseclasses;
1334 
1335  /* Number of fields (including baseclasses). */
1336  int nfields;
1337 
1338  /* Number of baseclasses. */
1340 
1341  /* Set if the accesibility of one of the fields is not public. */
1343 
1344  /* Member function fields array, entries are allocated in the order they
1345  are encountered in the object file. */
1347 
1348  /* Member function fieldlist array, contains name of possibly overloaded
1349  member function, number of overloaded member functions and a pointer
1350  to the head of the member function field chain. */
1352 
1353  /* Number of entries in the fnfieldlists array. */
1355 
1356  /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1357  a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1360  };
1361 
1362 /* One item on the queue of compilation units to read in full symbols
1363  for. */
1365 {
1367  enum language pretend_language;
1369 };
1370 
1371 /* The current queue. */
1373 
1374 /* Loaded secondary compilation units are kept in memory until they
1375  have not been referenced for the processing of this many
1376  compilation units. Set this to zero to disable caching. Cache
1377  sizes of up to at least twenty will improve startup time for
1378  typical inter-CU-reference binaries, at an obvious memory cost. */
1379 static int dwarf_max_cache_age = 5;
1380 static void
1381 show_dwarf_max_cache_age (struct ui_file *file, int from_tty,
1382  struct cmd_list_element *c, const char *value)
1383 {
1384  fprintf_filtered (file, _("The upper bound on the age of cached "
1385  "DWARF compilation units is %s.\n"),
1386  value);
1387 }
1388 
1389 /* local function prototypes */
1390 
1391 static const char *get_section_name (const struct dwarf2_section_info *);
1392 
1393 static const char *get_section_file_name (const struct dwarf2_section_info *);
1394 
1395 static void dwarf2_locate_sections (bfd *, asection *, void *);
1396 
1397 static void dwarf2_find_base_address (struct die_info *die,
1398  struct dwarf2_cu *cu);
1399 
1401  (struct dwarf2_per_cu_data *per_cu, const char *name);
1402 
1403 static void dwarf2_build_psymtabs_hard (struct objfile *);
1404 
1405 static void scan_partial_symbols (struct partial_die_info *,
1406  CORE_ADDR *, CORE_ADDR *,
1407  int, struct dwarf2_cu *);
1408 
1409 static void add_partial_symbol (struct partial_die_info *,
1410  struct dwarf2_cu *);
1411 
1412 static void add_partial_namespace (struct partial_die_info *pdi,
1413  CORE_ADDR *lowpc, CORE_ADDR *highpc,
1414  int set_addrmap, struct dwarf2_cu *cu);
1415 
1416 static void add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
1417  CORE_ADDR *highpc, int set_addrmap,
1418  struct dwarf2_cu *cu);
1419 
1420 static void add_partial_enumeration (struct partial_die_info *enum_pdi,
1421  struct dwarf2_cu *cu);
1422 
1423 static void add_partial_subprogram (struct partial_die_info *pdi,
1424  CORE_ADDR *lowpc, CORE_ADDR *highpc,
1425  int need_pc, struct dwarf2_cu *cu);
1426 
1427 static void dwarf2_read_symtab (struct partial_symtab *,
1428  struct objfile *);
1429 
1430 static void psymtab_to_symtab_1 (struct partial_symtab *);
1431 
1433  (const struct abbrev_table *, unsigned int);
1434 
1436  (struct dwarf2_section_info *, sect_offset);
1437 
1438 static void abbrev_table_free (struct abbrev_table *);
1439 
1440 static void abbrev_table_free_cleanup (void *);
1441 
1442 static void dwarf2_read_abbrevs (struct dwarf2_cu *,
1443  struct dwarf2_section_info *);
1444 
1445 static void dwarf2_free_abbrev_table (void *);
1446 
1447 static unsigned int peek_abbrev_code (bfd *, const gdb_byte *);
1448 
1449 static struct partial_die_info *load_partial_dies
1450  (const struct die_reader_specs *, const gdb_byte *, int);
1451 
1452 static const gdb_byte *read_partial_die (const struct die_reader_specs *,
1453  struct partial_die_info *,
1454  struct abbrev_info *,
1455  unsigned int,
1456  const gdb_byte *);
1457 
1458 static struct partial_die_info *find_partial_die (sect_offset, int,
1459  struct dwarf2_cu *);
1460 
1461 static void fixup_partial_die (struct partial_die_info *,
1462  struct dwarf2_cu *);
1463 
1464 static const gdb_byte *read_attribute (const struct die_reader_specs *,
1465  struct attribute *, struct attr_abbrev *,
1466  const gdb_byte *);
1467 
1468 static unsigned int read_1_byte (bfd *, const gdb_byte *);
1469 
1470 static int read_1_signed_byte (bfd *, const gdb_byte *);
1471 
1472 static unsigned int read_2_bytes (bfd *, const gdb_byte *);
1473 
1474 static unsigned int read_4_bytes (bfd *, const gdb_byte *);
1475 
1476 static ULONGEST read_8_bytes (bfd *, const gdb_byte *);
1477 
1478 static CORE_ADDR read_address (bfd *, const gdb_byte *ptr, struct dwarf2_cu *,
1479  unsigned int *);
1480 
1481 static LONGEST read_initial_length (bfd *, const gdb_byte *, unsigned int *);
1482 
1484  (bfd *, const gdb_byte *, const struct comp_unit_head *,
1485  unsigned int *, unsigned int *);
1486 
1487 static LONGEST read_offset (bfd *, const gdb_byte *,
1488  const struct comp_unit_head *,
1489  unsigned int *);
1490 
1491 static LONGEST read_offset_1 (bfd *, const gdb_byte *, unsigned int);
1492 
1494  sect_offset);
1495 
1496 static const gdb_byte *read_n_bytes (bfd *, const gdb_byte *, unsigned int);
1497 
1498 static const char *read_direct_string (bfd *, const gdb_byte *, unsigned int *);
1499 
1500 static const char *read_indirect_string (bfd *, const gdb_byte *,
1501  const struct comp_unit_head *,
1502  unsigned int *);
1503 
1504 static const char *read_indirect_string_from_dwz (struct dwz_file *, LONGEST);
1505 
1506 static ULONGEST read_unsigned_leb128 (bfd *, const gdb_byte *, unsigned int *);
1507 
1508 static LONGEST read_signed_leb128 (bfd *, const gdb_byte *, unsigned int *);
1509 
1511  const gdb_byte *,
1512  unsigned int *);
1513 
1514 static const char *read_str_index (const struct die_reader_specs *reader,
1515  ULONGEST str_index);
1516 
1517 static void set_cu_language (unsigned int, struct dwarf2_cu *);
1518 
1519 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
1520  struct dwarf2_cu *);
1521 
1522 static struct attribute *dwarf2_attr_no_follow (struct die_info *,
1523  unsigned int);
1524 
1525 static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
1526  struct dwarf2_cu *cu);
1527 
1528 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
1529 
1530 static struct die_info *die_specification (struct die_info *die,
1531  struct dwarf2_cu **);
1532 
1533 static void free_line_header (struct line_header *lh);
1534 
1535 static struct line_header *dwarf_decode_line_header (unsigned int offset,
1536  struct dwarf2_cu *cu);
1537 
1538 static void dwarf_decode_lines (struct line_header *, const char *,
1539  struct dwarf2_cu *, struct partial_symtab *,
1540  CORE_ADDR, int decode_mapping);
1541 
1542 static void dwarf2_start_subfile (const char *, const char *);
1543 
1544 static struct compunit_symtab *dwarf2_start_symtab (struct dwarf2_cu *,
1545  const char *, const char *,
1546  CORE_ADDR);
1547 
1548 static struct symbol *new_symbol (struct die_info *, struct type *,
1549  struct dwarf2_cu *);
1550 
1551 static struct symbol *new_symbol_full (struct die_info *, struct type *,
1552  struct dwarf2_cu *, struct symbol *);
1553 
1554 static void dwarf2_const_value (const struct attribute *, struct symbol *,
1555  struct dwarf2_cu *);
1556 
1557 static void dwarf2_const_value_attr (const struct attribute *attr,
1558  struct type *type,
1559  const char *name,
1560  struct obstack *obstack,
1561  struct dwarf2_cu *cu, LONGEST *value,
1562  const gdb_byte **bytes,
1563  struct dwarf2_locexpr_baton **baton);
1564 
1565 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
1566 
1567 static int need_gnat_info (struct dwarf2_cu *);
1568 
1569 static struct type *die_descriptive_type (struct die_info *,
1570  struct dwarf2_cu *);
1571 
1572 static void set_descriptive_type (struct type *, struct die_info *,
1573  struct dwarf2_cu *);
1574 
1575 static struct type *die_containing_type (struct die_info *,
1576  struct dwarf2_cu *);
1577 
1578 static struct type *lookup_die_type (struct die_info *, const struct attribute *,
1579  struct dwarf2_cu *);
1580 
1581 static struct type *read_type_die (struct die_info *, struct dwarf2_cu *);
1582 
1583 static struct type *read_type_die_1 (struct die_info *, struct dwarf2_cu *);
1584 
1585 static const char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
1586 
1587 static char *typename_concat (struct obstack *obs, const char *prefix,
1588  const char *suffix, int physname,
1589  struct dwarf2_cu *cu);
1590 
1591 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
1592 
1593 static void read_type_unit_scope (struct die_info *, struct dwarf2_cu *);
1594 
1595 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
1596 
1597 static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
1598 
1599 static void read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu);
1600 
1601 static int dwarf2_ranges_read (unsigned, CORE_ADDR *, CORE_ADDR *,
1602  struct dwarf2_cu *, struct partial_symtab *);
1603 
1604 static int dwarf2_get_pc_bounds (struct die_info *,
1605  CORE_ADDR *, CORE_ADDR *, struct dwarf2_cu *,
1606  struct partial_symtab *);
1607 
1608 static void get_scope_pc_bounds (struct die_info *,
1609  CORE_ADDR *, CORE_ADDR *,
1610  struct dwarf2_cu *);
1611 
1612 static void dwarf2_record_block_ranges (struct die_info *, struct block *,
1613  CORE_ADDR, struct dwarf2_cu *);
1614 
1615 static void dwarf2_add_field (struct field_info *, struct die_info *,
1616  struct dwarf2_cu *);
1617 
1618 static void dwarf2_attach_fields_to_type (struct field_info *,
1619  struct type *, struct dwarf2_cu *);
1620 
1621 static void dwarf2_add_member_fn (struct field_info *,
1622  struct die_info *, struct type *,
1623  struct dwarf2_cu *);
1624 
1625 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
1626  struct type *,
1627  struct dwarf2_cu *);
1628 
1629 static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
1630 
1631 static void read_common_block (struct die_info *, struct dwarf2_cu *);
1632 
1633 static void read_namespace (struct die_info *die, struct dwarf2_cu *);
1634 
1635 static void read_module (struct die_info *die, struct dwarf2_cu *cu);
1636 
1637 static void read_import_statement (struct die_info *die, struct dwarf2_cu *);
1638 
1639 static int read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu);
1640 
1641 static struct type *read_module_type (struct die_info *die,
1642  struct dwarf2_cu *cu);
1643 
1644 static const char *namespace_name (struct die_info *die,
1645  int *is_anonymous, struct dwarf2_cu *);
1646 
1647 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
1648 
1649 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
1650 
1651 static enum dwarf_array_dim_ordering read_array_order (struct die_info *,
1652  struct dwarf2_cu *);
1653 
1654 static struct die_info *read_die_and_siblings_1
1655  (const struct die_reader_specs *, const gdb_byte *, const gdb_byte **,
1656  struct die_info *);
1657 
1658 static struct die_info *read_die_and_siblings (const struct die_reader_specs *,
1659  const gdb_byte *info_ptr,
1660  const gdb_byte **new_info_ptr,
1661  struct die_info *parent);
1662 
1663 static const gdb_byte *read_full_die_1 (const struct die_reader_specs *,
1664  struct die_info **, const gdb_byte *,
1665  int *, int);
1666 
1667 static const gdb_byte *read_full_die (const struct die_reader_specs *,
1668  struct die_info **, const gdb_byte *,
1669  int *);
1670 
1671 static void process_die (struct die_info *, struct dwarf2_cu *);
1672 
1673 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu *,
1674  struct obstack *);
1675 
1676 static const char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
1677 
1678 static const char *dwarf2_full_name (const char *name,
1679  struct die_info *die,
1680  struct dwarf2_cu *cu);
1681 
1682 static const char *dwarf2_physname (const char *name, struct die_info *die,
1683  struct dwarf2_cu *cu);
1684 
1685 static struct die_info *dwarf2_extension (struct die_info *die,
1686  struct dwarf2_cu **);
1687 
1688 static const char *dwarf_tag_name (unsigned int);
1689 
1690 static const char *dwarf_attr_name (unsigned int);
1691 
1692 static const char *dwarf_form_name (unsigned int);
1693 
1694 static char *dwarf_bool_name (unsigned int);
1695 
1696 static const char *dwarf_type_encoding_name (unsigned int);
1697 
1698 static struct die_info *sibling_die (struct die_info *);
1699 
1700 static void dump_die_shallow (struct ui_file *, int indent, struct die_info *);
1701 
1702 static void dump_die_for_error (struct die_info *);
1703 
1704 static void dump_die_1 (struct ui_file *, int level, int max_level,
1705  struct die_info *);
1706 
1707 /*static*/ void dump_die (struct die_info *, int max_level);
1708 
1709 static void store_in_ref_table (struct die_info *,
1710  struct dwarf2_cu *);
1711 
1712 static sect_offset dwarf2_get_ref_die_offset (const struct attribute *);
1713 
1714 static LONGEST dwarf2_get_attr_constant_value (const struct attribute *, int);
1715 
1716 static struct die_info *follow_die_ref_or_sig (struct die_info *,
1717  const struct attribute *,
1718  struct dwarf2_cu **);
1719 
1720 static struct die_info *follow_die_ref (struct die_info *,
1721  const struct attribute *,
1722  struct dwarf2_cu **);
1723 
1724 static struct die_info *follow_die_sig (struct die_info *,
1725  const struct attribute *,
1726  struct dwarf2_cu **);
1727 
1728 static struct type *get_signatured_type (struct die_info *, ULONGEST,
1729  struct dwarf2_cu *);
1730 
1731 static struct type *get_DW_AT_signature_type (struct die_info *,
1732  const struct attribute *,
1733  struct dwarf2_cu *);
1734 
1735 static void load_full_type_unit (struct dwarf2_per_cu_data *per_cu);
1736 
1737 static void read_signatured_type (struct signatured_type *);
1738 
1739 /* memory allocation interface */
1740 
1741 static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
1742 
1743 static struct die_info *dwarf_alloc_die (struct dwarf2_cu *, int);
1744 
1745 static void dwarf_decode_macros (struct dwarf2_cu *, unsigned int, int);
1746 
1747 static int attr_form_is_block (const struct attribute *);
1748 
1749 static int attr_form_is_section_offset (const struct attribute *);
1750 
1751 static int attr_form_is_constant (const struct attribute *);
1752 
1753 static int attr_form_is_ref (const struct attribute *);
1754 
1755 static void fill_in_loclist_baton (struct dwarf2_cu *cu,
1756  struct dwarf2_loclist_baton *baton,
1757  const struct attribute *attr);
1758 
1759 static void dwarf2_symbol_mark_computed (const struct attribute *attr,
1760  struct symbol *sym,
1761  struct dwarf2_cu *cu,
1762  int is_block);
1763 
1764 static const gdb_byte *skip_one_die (const struct die_reader_specs *reader,
1765  const gdb_byte *info_ptr,
1766  struct abbrev_info *abbrev);
1767 
1768 static void free_stack_comp_unit (void *);
1769 
1770 static hashval_t partial_die_hash (const void *item);
1771 
1772 static int partial_die_eq (const void *item_lhs, const void *item_rhs);
1773 
1775  (sect_offset offset, unsigned int offset_in_dwz, struct objfile *objfile);
1776 
1777 static void init_one_comp_unit (struct dwarf2_cu *cu,
1778  struct dwarf2_per_cu_data *per_cu);
1779 
1780 static void prepare_one_comp_unit (struct dwarf2_cu *cu,
1781  struct die_info *comp_unit_die,
1782  enum language pretend_language);
1783 
1784 static void free_heap_comp_unit (void *);
1785 
1786 static void free_cached_comp_units (void *);
1787 
1788 static void age_cached_comp_units (void);
1789 
1790 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data *);
1791 
1792 static struct type *set_die_type (struct die_info *, struct type *,
1793  struct dwarf2_cu *);
1794 
1795 static void create_all_comp_units (struct objfile *);
1796 
1797 static int create_all_type_units (struct objfile *);
1798 
1799 static void load_full_comp_unit (struct dwarf2_per_cu_data *,
1800  enum language);
1801 
1802 static void process_full_comp_unit (struct dwarf2_per_cu_data *,
1803  enum language);
1804 
1805 static void process_full_type_unit (struct dwarf2_per_cu_data *,
1806  enum language);
1807 
1808 static void dwarf2_add_dependence (struct dwarf2_cu *,
1809  struct dwarf2_per_cu_data *);
1810 
1811 static void dwarf2_mark (struct dwarf2_cu *);
1812 
1813 static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
1814 
1815 static struct type *get_die_type_at_offset (sect_offset,
1816  struct dwarf2_per_cu_data *);
1817 
1818 static struct type *get_die_type (struct die_info *die, struct dwarf2_cu *cu);
1819 
1820 static void dwarf2_release_queue (void *dummy);
1821 
1822 static void queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
1823  enum language pretend_language);
1824 
1825 static void process_queue (void);
1826 
1827 static void find_file_and_directory (struct die_info *die,
1828  struct dwarf2_cu *cu,
1829  const char **name, const char **comp_dir);
1830 
1831 static char *file_full_name (int file, struct line_header *lh,
1832  const char *comp_dir);
1833 
1835  (struct comp_unit_head *header,
1836  struct dwarf2_section_info *section,
1837  struct dwarf2_section_info *abbrev_section, const gdb_byte *info_ptr,
1838  int is_debug_types_section);
1839 
1840 static void init_cutu_and_read_dies
1841  (struct dwarf2_per_cu_data *this_cu, struct abbrev_table *abbrev_table,
1842  int use_existing_cu, int keep,
1843  die_reader_func_ftype *die_reader_func, void *data);
1844 
1846  (struct dwarf2_per_cu_data *this_cu,
1847  die_reader_func_ftype *die_reader_func, void *data);
1848 
1849 static htab_t allocate_signatured_type_table (struct objfile *objfile);
1850 
1851 static htab_t allocate_dwo_unit_table (struct objfile *objfile);
1852 
1853 static struct dwo_unit *lookup_dwo_unit_in_dwp
1854  (struct dwp_file *dwp_file, const char *comp_dir,
1855  ULONGEST signature, int is_debug_types);
1856 
1857 static struct dwp_file *get_dwp_file (void);
1858 
1859 static struct dwo_unit *lookup_dwo_comp_unit
1860  (struct dwarf2_per_cu_data *, const char *, const char *, ULONGEST);
1861 
1862 static struct dwo_unit *lookup_dwo_type_unit
1863  (struct signatured_type *, const char *, const char *);
1864 
1865 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *);
1866 
1867 static void free_dwo_file_cleanup (void *);
1868 
1869 static void process_cu_includes (void);
1870 
1871 static void check_producer (struct dwarf2_cu *cu);
1872 
1873 static void free_line_header_voidp (void *arg);
1874 
1875 /* Various complaints about symbol reading that don't abort the process. */
1876 
1877 static void
1879 {
1881  _("statement list doesn't fit in .debug_line section"));
1882 }
1883 
1884 static void
1886 {
1888  _(".debug_line section has line data without a file"));
1889 }
1890 
1891 static void
1893 {
1895  _(".debug_line section has line "
1896  "program sequence without an end"));
1897 }
1898 
1899 static void
1901 {
1902  complaint (&symfile_complaints, _("location expression too complex"));
1903 }
1904 
1905 static void
1907  int arg3)
1908 {
1910  _("const value length mismatch for '%s', got %d, expected %d"),
1911  arg1, arg2, arg3);
1912 }
1913 
1914 static void
1916 {
1918  _("debug info runs off end of %s section"
1919  " [in module %s]"),
1920  get_section_name (section),
1921  get_section_file_name (section));
1922 }
1923 
1924 static void
1926 {
1928  _("macro debug info contains a "
1929  "malformed macro definition:\n`%s'"),
1930  arg1);
1931 }
1932 
1933 static void
1934 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
1935 {
1937  _("invalid attribute class or form for '%s' in '%s'"),
1938  arg1, arg2);
1939 }
1940 
1941 /* Hash function for line_header_hash. */
1942 
1943 static hashval_t
1944 line_header_hash (const struct line_header *ofs)
1945 {
1946  return ofs->offset.sect_off ^ ofs->offset_in_dwz;
1947 }
1948 
1949 /* Hash function for htab_create_alloc_ex for line_header_hash. */
1950 
1951 static hashval_t
1952 line_header_hash_voidp (const void *item)
1953 {
1954  const struct line_header *ofs = item;
1955 
1956  return line_header_hash (ofs);
1957 }
1958 
1959 /* Equality function for line_header_hash. */
1960 
1961 static int
1962 line_header_eq_voidp (const void *item_lhs, const void *item_rhs)
1963 {
1964  const struct line_header *ofs_lhs = item_lhs;
1965  const struct line_header *ofs_rhs = item_rhs;
1966 
1967  return (ofs_lhs->offset.sect_off == ofs_rhs->offset.sect_off
1968  && ofs_lhs->offset_in_dwz == ofs_rhs->offset_in_dwz);
1969 }
1970 
1971 
1972 #if WORDS_BIGENDIAN
1973 
1974 /* Convert VALUE between big- and little-endian. */
1975 static offset_type
1976 byte_swap (offset_type value)
1977 {
1978  offset_type result;
1979 
1980  result = (value & 0xff) << 24;
1981  result |= (value & 0xff00) << 8;
1982  result |= (value & 0xff0000) >> 8;
1983  result |= (value & 0xff000000) >> 24;
1984  return result;
1985 }
1986 
1987 #define MAYBE_SWAP(V) byte_swap (V)
1988 
1989 #else
1990 #define MAYBE_SWAP(V) (V)
1991 #endif /* WORDS_BIGENDIAN */
1992 
1993 /* Read the given attribute value as an address, taking the attribute's
1994  form into account. */
1995 
1996 static CORE_ADDR
1998 {
1999  CORE_ADDR addr;
2000 
2001  if (attr->form != DW_FORM_addr && attr->form != DW_FORM_GNU_addr_index)
2002  {
2003  /* Aside from a few clearly defined exceptions, attributes that
2004  contain an address must always be in DW_FORM_addr form.
2005  Unfortunately, some compilers happen to be violating this
2006  requirement by encoding addresses using other forms, such
2007  as DW_FORM_data4 for example. For those broken compilers,
2008  we try to do our best, without any guarantee of success,
2009  to interpret the address correctly. It would also be nice
2010  to generate a complaint, but that would require us to maintain
2011  a list of legitimate cases where a non-address form is allowed,
2012  as well as update callers to pass in at least the CU's DWARF
2013  version. This is more overhead than what we're willing to
2014  expand for a pretty rare case. */
2015  addr = DW_UNSND (attr);
2016  }
2017  else
2018  addr = DW_ADDR (attr);
2019 
2020  return addr;
2021 }
2022 
2023 /* The suffix for an index file. */
2024 #define INDEX_SUFFIX ".gdb-index"
2025 
2026 /* Try to locate the sections we need for DWARF 2 debugging
2027  information and return true if we have enough to do something.
2028  NAMES points to the dwarf2 section names, or is NULL if the standard
2029  ELF names are used. */
2030 
2031 int
2032 dwarf2_has_info (struct objfile *objfile,
2033  const struct dwarf2_debug_sections *names)
2034 {
2035  dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
2036  if (!dwarf2_per_objfile)
2037  {
2038  /* Initialize per-objfile state. */
2039  struct dwarf2_per_objfile *data
2040  = obstack_alloc (&objfile->objfile_obstack, sizeof (*data));
2041 
2042  memset (data, 0, sizeof (*data));
2043  set_objfile_data (objfile, dwarf2_objfile_data_key, data);
2044  dwarf2_per_objfile = data;
2045 
2046  bfd_map_over_sections (objfile->obfd, dwarf2_locate_sections,
2047  (void *) names);
2048  dwarf2_per_objfile->objfile = objfile;
2049  }
2050  return (!dwarf2_per_objfile->info.is_virtual
2051  && dwarf2_per_objfile->info.s.asection != NULL
2052  && !dwarf2_per_objfile->abbrev.is_virtual
2053  && dwarf2_per_objfile->abbrev.s.asection != NULL);
2054 }
2055 
2056 /* Return the containing section of virtual section SECTION. */
2057 
2058 static struct dwarf2_section_info *
2060 {
2061  gdb_assert (section->is_virtual);
2062  return section->s.containing_section;
2063 }
2064 
2065 /* Return the bfd owner of SECTION. */
2066 
2067 static struct bfd *
2069 {
2070  if (section->is_virtual)
2071  {
2072  section = get_containing_section (section);
2073  gdb_assert (!section->is_virtual);
2074  }
2075  return section->s.asection->owner;
2076 }
2077 
2078 /* Return the bfd section of SECTION.
2079  Returns NULL if the section is not present. */
2080 
2081 static asection *
2083 {
2084  if (section->is_virtual)
2085  {
2086  section = get_containing_section (section);
2087  gdb_assert (!section->is_virtual);
2088  }
2089  return section->s.asection;
2090 }
2091 
2092 /* Return the name of SECTION. */
2093 
2094 static const char *
2095 get_section_name (const struct dwarf2_section_info *section)
2096 {
2097  asection *sectp = get_section_bfd_section (section);
2098 
2099  gdb_assert (sectp != NULL);
2100  return bfd_section_name (get_section_bfd_owner (section), sectp);
2101 }
2102 
2103 /* Return the name of the file SECTION is in. */
2104 
2105 static const char *
2107 {
2108  bfd *abfd = get_section_bfd_owner (section);
2109 
2110  return bfd_get_filename (abfd);
2111 }
2112 
2113 /* Return the id of SECTION.
2114  Returns 0 if SECTION doesn't exist. */
2115 
2116 static int
2117 get_section_id (const struct dwarf2_section_info *section)
2118 {
2119  asection *sectp = get_section_bfd_section (section);
2120 
2121  if (sectp == NULL)
2122  return 0;
2123  return sectp->id;
2124 }
2125 
2126 /* Return the flags of SECTION.
2127  SECTION (or containing section if this is a virtual section) must exist. */
2128 
2129 static int
2131 {
2132  asection *sectp = get_section_bfd_section (section);
2133 
2134  gdb_assert (sectp != NULL);
2135  return bfd_get_section_flags (sectp->owner, sectp);
2136 }
2137 
2138 /* When loading sections, we look either for uncompressed section or for
2139  compressed section names. */
2140 
2141 static int
2142 section_is_p (const char *section_name,
2143  const struct dwarf2_section_names *names)
2144 {
2145  if (names->normal != NULL
2146  && strcmp (section_name, names->normal) == 0)
2147  return 1;
2148  if (names->compressed != NULL
2149  && strcmp (section_name, names->compressed) == 0)
2150  return 1;
2151  return 0;
2152 }
2153 
2154 /* This function is mapped across the sections and remembers the
2155  offset and size of each of the debugging sections we are interested
2156  in. */
2157 
2158 static void
2159 dwarf2_locate_sections (bfd *abfd, asection *sectp, void *vnames)
2160 {
2161  const struct dwarf2_debug_sections *names;
2162  flagword aflag = bfd_get_section_flags (abfd, sectp);
2163 
2164  if (vnames == NULL)
2165  names = &dwarf2_elf_names;
2166  else
2167  names = (const struct dwarf2_debug_sections *) vnames;
2168 
2169  if ((aflag & SEC_HAS_CONTENTS) == 0)
2170  {
2171  }
2172  else if (section_is_p (sectp->name, &names->info))
2173  {
2174  dwarf2_per_objfile->info.s.asection = sectp;
2175  dwarf2_per_objfile->info.size = bfd_get_section_size (sectp);
2176  }
2177  else if (section_is_p (sectp->name, &names->abbrev))
2178  {
2179  dwarf2_per_objfile->abbrev.s.asection = sectp;
2180  dwarf2_per_objfile->abbrev.size = bfd_get_section_size (sectp);
2181  }
2182  else if (section_is_p (sectp->name, &names->line))
2183  {
2184  dwarf2_per_objfile->line.s.asection = sectp;
2185  dwarf2_per_objfile->line.size = bfd_get_section_size (sectp);
2186  }
2187  else if (section_is_p (sectp->name, &names->loc))
2188  {
2189  dwarf2_per_objfile->loc.s.asection = sectp;
2190  dwarf2_per_objfile->loc.size = bfd_get_section_size (sectp);
2191  }
2192  else if (section_is_p (sectp->name, &names->macinfo))
2193  {
2194  dwarf2_per_objfile->macinfo.s.asection = sectp;
2195  dwarf2_per_objfile->macinfo.size = bfd_get_section_size (sectp);
2196  }
2197  else if (section_is_p (sectp->name, &names->macro))
2198  {
2199  dwarf2_per_objfile->macro.s.asection = sectp;
2200  dwarf2_per_objfile->macro.size = bfd_get_section_size (sectp);
2201  }
2202  else if (section_is_p (sectp->name, &names->str))
2203  {
2204  dwarf2_per_objfile->str.s.asection = sectp;
2205  dwarf2_per_objfile->str.size = bfd_get_section_size (sectp);
2206  }
2207  else if (section_is_p (sectp->name, &names->addr))
2208  {
2209  dwarf2_per_objfile->addr.s.asection = sectp;
2210  dwarf2_per_objfile->addr.size = bfd_get_section_size (sectp);
2211  }
2212  else if (section_is_p (sectp->name, &names->frame))
2213  {
2214  dwarf2_per_objfile->frame.s.asection = sectp;
2215  dwarf2_per_objfile->frame.size = bfd_get_section_size (sectp);
2216  }
2217  else if (section_is_p (sectp->name, &names->eh_frame))
2218  {
2219  dwarf2_per_objfile->eh_frame.s.asection = sectp;
2220  dwarf2_per_objfile->eh_frame.size = bfd_get_section_size (sectp);
2221  }
2222  else if (section_is_p (sectp->name, &names->ranges))
2223  {
2224  dwarf2_per_objfile->ranges.s.asection = sectp;
2225  dwarf2_per_objfile->ranges.size = bfd_get_section_size (sectp);
2226  }
2227  else if (section_is_p (sectp->name, &names->types))
2228  {
2229  struct dwarf2_section_info type_section;
2230 
2231  memset (&type_section, 0, sizeof (type_section));
2232  type_section.s.asection = sectp;
2233  type_section.size = bfd_get_section_size (sectp);
2234 
2235  VEC_safe_push (dwarf2_section_info_def, dwarf2_per_objfile->types,
2236  &type_section);
2237  }
2238  else if (section_is_p (sectp->name, &names->gdb_index))
2239  {
2240  dwarf2_per_objfile->gdb_index.s.asection = sectp;
2241  dwarf2_per_objfile->gdb_index.size = bfd_get_section_size (sectp);
2242  }
2243 
2244  if ((bfd_get_section_flags (abfd, sectp) & SEC_LOAD)
2245  && bfd_section_vma (abfd, sectp) == 0)
2246  dwarf2_per_objfile->has_section_at_zero = 1;
2247 }
2248 
2249 /* A helper function that decides whether a section is empty,
2250  or not present. */
2251 
2252 static int
2254 {
2255  if (section->is_virtual)
2256  return section->size == 0;
2257  return section->s.asection == NULL || section->size == 0;
2258 }
2259 
2260 /* Read the contents of the section INFO.
2261  OBJFILE is the main object file, but not necessarily the file where
2262  the section comes from. E.g., for DWO files the bfd of INFO is the bfd
2263  of the DWO file.
2264  If the section is compressed, uncompress it before returning. */
2265 
2266 static void
2267 dwarf2_read_section (struct objfile *objfile, struct dwarf2_section_info *info)
2268 {
2269  asection *sectp;
2270  bfd *abfd;
2271  gdb_byte *buf, *retbuf;
2272 
2273  if (info->readin)
2274  return;
2275  info->buffer = NULL;
2276  info->readin = 1;
2277 
2278  if (dwarf2_section_empty_p (info))
2279  return;
2280 
2281  sectp = get_section_bfd_section (info);
2282 
2283  /* If this is a virtual section we need to read in the real one first. */
2284  if (info->is_virtual)
2285  {
2287  get_containing_section (info);
2288 
2289  gdb_assert (sectp != NULL);
2290  if ((sectp->flags & SEC_RELOC) != 0)
2291  {
2292  error (_("Dwarf Error: DWP format V2 with relocations is not"
2293  " supported in section %s [in module %s]"),
2294  get_section_name (info), get_section_file_name (info));
2295  }
2296  dwarf2_read_section (objfile, containing_section);
2297  /* Other code should have already caught virtual sections that don't
2298  fit. */
2299  gdb_assert (info->virtual_offset + info->size
2300  <= containing_section->size);
2301  /* If the real section is empty or there was a problem reading the
2302  section we shouldn't get here. */
2303  gdb_assert (containing_section->buffer != NULL);
2304  info->buffer = containing_section->buffer + info->virtual_offset;
2305  return;
2306  }
2307 
2308  /* If the section has relocations, we must read it ourselves.
2309  Otherwise we attach it to the BFD. */
2310  if ((sectp->flags & SEC_RELOC) == 0)
2311  {
2312  info->buffer = gdb_bfd_map_section (sectp, &info->size);
2313  return;
2314  }
2315 
2316  buf = obstack_alloc (&objfile->objfile_obstack, info->size);
2317  info->buffer = buf;
2318 
2319  /* When debugging .o files, we may need to apply relocations; see
2320  http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2321  We never compress sections in .o files, so we only need to
2322  try this when the section is not compressed. */
2323  retbuf = symfile_relocate_debug_section (objfile, sectp, buf);
2324  if (retbuf != NULL)
2325  {
2326  info->buffer = retbuf;
2327  return;
2328  }
2329 
2330  abfd = get_section_bfd_owner (info);
2331  gdb_assert (abfd != NULL);
2332 
2333  if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
2334  || bfd_bread (buf, info->size, abfd) != info->size)
2335  {
2336  error (_("Dwarf Error: Can't read DWARF data"
2337  " in section %s [in module %s]"),
2338  bfd_section_name (abfd, sectp), bfd_get_filename (abfd));
2339  }
2340 }
2341 
2342 /* A helper function that returns the size of a section in a safe way.
2343  If you are positive that the section has been read before using the
2344  size, then it is safe to refer to the dwarf2_section_info object's
2345  "size" field directly. In other cases, you must call this
2346  function, because for compressed sections the size field is not set
2347  correctly until the section has been read. */
2348 
2349 static bfd_size_type
2350 dwarf2_section_size (struct objfile *objfile,
2351  struct dwarf2_section_info *info)
2352 {
2353  if (!info->readin)
2354  dwarf2_read_section (objfile, info);
2355  return info->size;
2356 }
2357 
2358 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2359  SECTION_NAME. */
2360 
2361 void
2362 dwarf2_get_section_info (struct objfile *objfile,
2363  enum dwarf2_section_enum sect,
2364  asection **sectp, const gdb_byte **bufp,
2365  bfd_size_type *sizep)
2366 {
2367  struct dwarf2_per_objfile *data
2368  = objfile_data (objfile, dwarf2_objfile_data_key);
2369  struct dwarf2_section_info *info;
2370 
2371  /* We may see an objfile without any DWARF, in which case we just
2372  return nothing. */
2373  if (data == NULL)
2374  {
2375  *sectp = NULL;
2376  *bufp = NULL;
2377  *sizep = 0;
2378  return;
2379  }
2380  switch (sect)
2381  {
2382  case DWARF2_DEBUG_FRAME:
2383  info = &data->frame;
2384  break;
2385  case DWARF2_EH_FRAME:
2386  info = &data->eh_frame;
2387  break;
2388  default:
2389  gdb_assert_not_reached ("unexpected section");
2390  }
2391 
2392  dwarf2_read_section (objfile, info);
2393 
2394  *sectp = get_section_bfd_section (info);
2395  *bufp = info->buffer;
2396  *sizep = info->size;
2397 }
2398 
2399 /* A helper function to find the sections for a .dwz file. */
2400 
2401 static void
2402 locate_dwz_sections (bfd *abfd, asection *sectp, void *arg)
2403 {
2404  struct dwz_file *dwz_file = arg;
2405 
2406  /* Note that we only support the standard ELF names, because .dwz
2407  is ELF-only (at the time of writing). */
2408  if (section_is_p (sectp->name, &dwarf2_elf_names.abbrev))
2409  {
2410  dwz_file->abbrev.s.asection = sectp;
2411  dwz_file->abbrev.size = bfd_get_section_size (sectp);
2412  }
2413  else if (section_is_p (sectp->name, &dwarf2_elf_names.info))
2414  {
2415  dwz_file->info.s.asection = sectp;
2416  dwz_file->info.size = bfd_get_section_size (sectp);
2417  }
2418  else if (section_is_p (sectp->name, &dwarf2_elf_names.str))
2419  {
2420  dwz_file->str.s.asection = sectp;
2421  dwz_file->str.size = bfd_get_section_size (sectp);
2422  }
2423  else if (section_is_p (sectp->name, &dwarf2_elf_names.line))
2424  {
2425  dwz_file->line.s.asection = sectp;
2426  dwz_file->line.size = bfd_get_section_size (sectp);
2427  }
2428  else if (section_is_p (sectp->name, &dwarf2_elf_names.macro))
2429  {
2430  dwz_file->macro.s.asection = sectp;
2431  dwz_file->macro.size = bfd_get_section_size (sectp);
2432  }
2433  else if (section_is_p (sectp->name, &dwarf2_elf_names.gdb_index))
2434  {
2435  dwz_file->gdb_index.s.asection = sectp;
2436  dwz_file->gdb_index.size = bfd_get_section_size (sectp);
2437  }
2438 }
2439 
2440 /* Open the separate '.dwz' debug file, if needed. Return NULL if
2441  there is no .gnu_debugaltlink section in the file. Error if there
2442  is such a section but the file cannot be found. */
2443 
2444 static struct dwz_file *
2446 {
2447  bfd *dwz_bfd;
2448  char *data;
2449  struct cleanup *cleanup;
2450  const char *filename;
2451  struct dwz_file *result;
2452  bfd_size_type buildid_len_arg;
2453  size_t buildid_len;
2454  bfd_byte *buildid;
2455 
2456  if (dwarf2_per_objfile->dwz_file != NULL)
2457  return dwarf2_per_objfile->dwz_file;
2458 
2459  bfd_set_error (bfd_error_no_error);
2460  data = bfd_get_alt_debug_link_info (dwarf2_per_objfile->objfile->obfd,
2461  &buildid_len_arg, &buildid);
2462  if (data == NULL)
2463  {
2464  if (bfd_get_error () == bfd_error_no_error)
2465  return NULL;
2466  error (_("could not read '.gnu_debugaltlink' section: %s"),
2467  bfd_errmsg (bfd_get_error ()));
2468  }
2469  cleanup = make_cleanup (xfree, data);
2470  make_cleanup (xfree, buildid);
2471 
2472  buildid_len = (size_t) buildid_len_arg;
2473 
2474  filename = (const char *) data;
2475  if (!IS_ABSOLUTE_PATH (filename))
2476  {
2477  char *abs = gdb_realpath (objfile_name (dwarf2_per_objfile->objfile));
2478  char *rel;
2479 
2480  make_cleanup (xfree, abs);
2481  abs = ldirname (abs);
2482  make_cleanup (xfree, abs);
2483 
2484  rel = concat (abs, SLASH_STRING, filename, (char *) NULL);
2485  make_cleanup (xfree, rel);
2486  filename = rel;
2487  }
2488 
2489  /* First try the file name given in the section. If that doesn't
2490  work, try to use the build-id instead. */
2491  dwz_bfd = gdb_bfd_open (filename, gnutarget, -1);
2492  if (dwz_bfd != NULL)
2493  {
2494  if (!build_id_verify (dwz_bfd, buildid_len, buildid))
2495  {
2496  gdb_bfd_unref (dwz_bfd);
2497  dwz_bfd = NULL;
2498  }
2499  }
2500 
2501  if (dwz_bfd == NULL)
2502  dwz_bfd = build_id_to_debug_bfd (buildid_len, buildid);
2503 
2504  if (dwz_bfd == NULL)
2505  error (_("could not find '.gnu_debugaltlink' file for %s"),
2506  objfile_name (dwarf2_per_objfile->objfile));
2507 
2508  result = OBSTACK_ZALLOC (&dwarf2_per_objfile->objfile->objfile_obstack,
2509  struct dwz_file);
2510  result->dwz_bfd = dwz_bfd;
2511 
2512  bfd_map_over_sections (dwz_bfd, locate_dwz_sections, result);
2513 
2514  do_cleanups (cleanup);
2515 
2516  gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd, dwz_bfd);
2517  dwarf2_per_objfile->dwz_file = result;
2518  return result;
2519 }
2520 
2521 /* DWARF quick_symbols_functions support. */
2522 
2523 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2524  unique line tables, so we maintain a separate table of all .debug_line
2525  derived entries to support the sharing.
2526  All the quick functions need is the list of file names. We discard the
2527  line_header when we're done and don't need to record it here. */
2529 {
2530  /* The data used to construct the hash key. */
2532 
2533  /* The number of entries in file_names, real_names. */
2534  unsigned int num_file_names;
2535 
2536  /* The file names from the line table, after being run through
2537  file_full_name. */
2538  const char **file_names;
2539 
2540  /* The file names from the line table after being run through
2541  gdb_realpath. These are computed lazily. */
2542  const char **real_names;
2543 };
2544 
2545 /* When using the index (and thus not using psymtabs), each CU has an
2546  object of this type. This is used to hold information needed by
2547  the various "quick" methods. */
2549 {
2550  /* The file table. This can be NULL if there was no file table
2551  or it's currently not read in.
2552  NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2554 
2555  /* The corresponding symbol table. This is NULL if symbols for this
2556  CU have not yet been read. */
2558 
2559  /* A temporary mark bit used when iterating over all CUs in
2560  expand_symtabs_matching. */
2561  unsigned int mark : 1;
2562 
2563  /* True if we've tried to read the file table and found there isn't one.
2564  There will be no point in trying to read it again next time. */
2565  unsigned int no_file_data : 1;
2566 };
2567 
2568 /* Utility hash function for a stmt_list_hash. */
2569 
2570 static hashval_t
2572 {
2573  hashval_t v = 0;
2574 
2575  if (stmt_list_hash->dwo_unit != NULL)
2576  v += (uintptr_t) stmt_list_hash->dwo_unit->dwo_file;
2577  v += stmt_list_hash->line_offset.sect_off;
2578  return v;
2579 }
2580 
2581 /* Utility equality function for a stmt_list_hash. */
2582 
2583 static int
2585  const struct stmt_list_hash *rhs)
2586 {
2587  if ((lhs->dwo_unit != NULL) != (rhs->dwo_unit != NULL))
2588  return 0;
2589  if (lhs->dwo_unit != NULL
2590  && lhs->dwo_unit->dwo_file != rhs->dwo_unit->dwo_file)
2591  return 0;
2592 
2593  return lhs->line_offset.sect_off == rhs->line_offset.sect_off;
2594 }
2595 
2596 /* Hash function for a quick_file_names. */
2597 
2598 static hashval_t
2599 hash_file_name_entry (const void *e)
2600 {
2601  const struct quick_file_names *file_data = e;
2602 
2603  return hash_stmt_list_entry (&file_data->hash);
2604 }
2605 
2606 /* Equality function for a quick_file_names. */
2607 
2608 static int
2609 eq_file_name_entry (const void *a, const void *b)
2610 {
2611  const struct quick_file_names *ea = a;
2612  const struct quick_file_names *eb = b;
2613 
2614  return eq_stmt_list_entry (&ea->hash, &eb->hash);
2615 }
2616 
2617 /* Delete function for a quick_file_names. */
2618 
2619 static void
2621 {
2622  struct quick_file_names *file_data = e;
2623  int i;
2624 
2625  for (i = 0; i < file_data->num_file_names; ++i)
2626  {
2627  xfree ((void*) file_data->file_names[i]);
2628  if (file_data->real_names)
2629  xfree ((void*) file_data->real_names[i]);
2630  }
2631 
2632  /* The space for the struct itself lives on objfile_obstack,
2633  so we don't free it here. */
2634 }
2635 
2636 /* Create a quick_file_names hash table. */
2637 
2638 static htab_t
2639 create_quick_file_names_table (unsigned int nr_initial_entries)
2640 {
2641  return htab_create_alloc (nr_initial_entries,
2644 }
2645 
2646 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
2647  have to be created afterwards. You should call age_cached_comp_units after
2648  processing PER_CU->CU. dw2_setup must have been already called. */
2649 
2650 static void
2651 load_cu (struct dwarf2_per_cu_data *per_cu)
2652 {
2653  if (per_cu->is_debug_types)
2654  load_full_type_unit (per_cu);
2655  else
2657 
2658  gdb_assert (per_cu->cu != NULL);
2659 
2660  dwarf2_find_base_address (per_cu->cu->dies, per_cu->cu);
2661 }
2662 
2663 /* Read in the symbols for PER_CU. */
2664 
2665 static void
2667 {
2668  struct cleanup *back_to;
2669 
2670  /* Skip type_unit_groups, reading the type units they contain
2671  is handled elsewhere. */
2672  if (IS_TYPE_UNIT_GROUP (per_cu))
2673  return;
2674 
2675  back_to = make_cleanup (dwarf2_release_queue, NULL);
2676 
2677  if (dwarf2_per_objfile->using_index
2678  ? per_cu->v.quick->compunit_symtab == NULL
2679  : (per_cu->v.psymtab == NULL || !per_cu->v.psymtab->readin))
2680  {
2682  load_cu (per_cu);
2683 
2684  /* If we just loaded a CU from a DWO, and we're working with an index
2685  that may badly handle TUs, load all the TUs in that DWO as well.
2686  http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2687  if (!per_cu->is_debug_types
2688  && per_cu->cu->dwo_unit != NULL
2689  && dwarf2_per_objfile->index_table != NULL
2690  && dwarf2_per_objfile->index_table->version <= 7
2691  /* DWP files aren't supported yet. */
2692  && get_dwp_file () == NULL)
2693  queue_and_load_all_dwo_tus (per_cu);
2694  }
2695 
2696  process_queue ();
2697 
2698  /* Age the cache, releasing compilation units that have not
2699  been used recently. */
2701 
2702  do_cleanups (back_to);
2703 }
2704 
2705 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2706  the objfile from which this CU came. Returns the resulting symbol
2707  table. */
2708 
2709 static struct compunit_symtab *
2711 {
2712  gdb_assert (dwarf2_per_objfile->using_index);
2713  if (!per_cu->v.quick->compunit_symtab)
2714  {
2715  struct cleanup *back_to = make_cleanup (free_cached_comp_units, NULL);
2717  dw2_do_instantiate_symtab (per_cu);
2719  do_cleanups (back_to);
2720  }
2721 
2722  return per_cu->v.quick->compunit_symtab;
2723 }
2724 
2725 /* Return the CU/TU given its index.
2726 
2727  This is intended for loops like:
2728 
2729  for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2730  + dwarf2_per_objfile->n_type_units); ++i)
2731  {
2732  struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
2733 
2734  ...;
2735  }
2736 */
2737 
2738 static struct dwarf2_per_cu_data *
2739 dw2_get_cutu (int index)
2740 {
2741  if (index >= dwarf2_per_objfile->n_comp_units)
2742  {
2743  index -= dwarf2_per_objfile->n_comp_units;
2744  gdb_assert (index < dwarf2_per_objfile->n_type_units);
2745  return &dwarf2_per_objfile->all_type_units[index]->per_cu;
2746  }
2747 
2748  return dwarf2_per_objfile->all_comp_units[index];
2749 }
2750 
2751 /* Return the CU given its index.
2752  This differs from dw2_get_cutu in that it's for when you know INDEX
2753  refers to a CU. */
2754 
2755 static struct dwarf2_per_cu_data *
2756 dw2_get_cu (int index)
2757 {
2758  gdb_assert (index >= 0 && index < dwarf2_per_objfile->n_comp_units);
2759 
2760  return dwarf2_per_objfile->all_comp_units[index];
2761 }
2762 
2763 /* A helper for create_cus_from_index that handles a given list of
2764  CUs. */
2765 
2766 static void
2767 create_cus_from_index_list (struct objfile *objfile,
2768  const gdb_byte *cu_list, offset_type n_elements,
2769  struct dwarf2_section_info *section,
2770  int is_dwz,
2771  int base_offset)
2772 {
2773  offset_type i;
2774 
2775  for (i = 0; i < n_elements; i += 2)
2776  {
2777  struct dwarf2_per_cu_data *the_cu;
2779 
2780  gdb_static_assert (sizeof (ULONGEST) >= 8);
2781  offset = extract_unsigned_integer (cu_list, 8, BFD_ENDIAN_LITTLE);
2782  length = extract_unsigned_integer (cu_list + 8, 8, BFD_ENDIAN_LITTLE);
2783  cu_list += 2 * 8;
2784 
2785  the_cu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2786  struct dwarf2_per_cu_data);
2787  the_cu->offset.sect_off = offset;
2788  the_cu->length = length;
2789  the_cu->objfile = objfile;
2790  the_cu->section = section;
2791  the_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2792  struct dwarf2_per_cu_quick_data);
2793  the_cu->is_dwz = is_dwz;
2794  dwarf2_per_objfile->all_comp_units[base_offset + i / 2] = the_cu;
2795  }
2796 }
2797 
2798 /* Read the CU list from the mapped index, and use it to create all
2799  the CU objects for this objfile. */
2800 
2801 static void
2802 create_cus_from_index (struct objfile *objfile,
2803  const gdb_byte *cu_list, offset_type cu_list_elements,
2804  const gdb_byte *dwz_list, offset_type dwz_elements)
2805 {
2806  struct dwz_file *dwz;
2807 
2808  dwarf2_per_objfile->n_comp_units = (cu_list_elements + dwz_elements) / 2;
2809  dwarf2_per_objfile->all_comp_units
2810  = obstack_alloc (&objfile->objfile_obstack,
2811  dwarf2_per_objfile->n_comp_units
2812  * sizeof (struct dwarf2_per_cu_data *));
2813 
2814  create_cus_from_index_list (objfile, cu_list, cu_list_elements,
2815  &dwarf2_per_objfile->info, 0, 0);
2816 
2817  if (dwz_elements == 0)
2818  return;
2819 
2820  dwz = dwarf2_get_dwz_file ();
2821  create_cus_from_index_list (objfile, dwz_list, dwz_elements, &dwz->info, 1,
2822  cu_list_elements / 2);
2823 }
2824 
2825 /* Create the signatured type hash table from the index. */
2826 
2827 static void
2829  struct dwarf2_section_info *section,
2830  const gdb_byte *bytes,
2831  offset_type elements)
2832 {
2833  offset_type i;
2834  htab_t sig_types_hash;
2835 
2836  dwarf2_per_objfile->n_type_units
2837  = dwarf2_per_objfile->n_allocated_type_units
2838  = elements / 3;
2839  dwarf2_per_objfile->all_type_units
2840  = xmalloc (dwarf2_per_objfile->n_type_units
2841  * sizeof (struct signatured_type *));
2842 
2843  sig_types_hash = allocate_signatured_type_table (objfile);
2844 
2845  for (i = 0; i < elements; i += 3)
2846  {
2847  struct signatured_type *sig_type;
2849  void **slot;
2850 
2851  gdb_static_assert (sizeof (ULONGEST) >= 8);
2852  offset = extract_unsigned_integer (bytes, 8, BFD_ENDIAN_LITTLE);
2853  type_offset_in_tu = extract_unsigned_integer (bytes + 8, 8,
2854  BFD_ENDIAN_LITTLE);
2855  signature = extract_unsigned_integer (bytes + 16, 8, BFD_ENDIAN_LITTLE);
2856  bytes += 3 * 8;
2857 
2858  sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2859  struct signatured_type);
2860  sig_type->signature = signature;
2862  sig_type->per_cu.is_debug_types = 1;
2863  sig_type->per_cu.section = section;
2864  sig_type->per_cu.offset.sect_off = offset;
2865  sig_type->per_cu.objfile = objfile;
2866  sig_type->per_cu.v.quick
2867  = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2868  struct dwarf2_per_cu_quick_data);
2869 
2870  slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
2871  *slot = sig_type;
2872 
2873  dwarf2_per_objfile->all_type_units[i / 3] = sig_type;
2874  }
2875 
2876  dwarf2_per_objfile->signatured_types = sig_types_hash;
2877 }
2878 
2879 /* Read the address map data from the mapped index, and use it to
2880  populate the objfile's psymtabs_addrmap. */
2881 
2882 static void
2883 create_addrmap_from_index (struct objfile *objfile, struct mapped_index *index)
2884 {
2885  struct gdbarch *gdbarch = get_objfile_arch (objfile);
2886  const gdb_byte *iter, *end;
2887  struct obstack temp_obstack;
2888  struct addrmap *mutable_map;
2889  struct cleanup *cleanup;
2890  CORE_ADDR baseaddr;
2891 
2892  obstack_init (&temp_obstack);
2893  cleanup = make_cleanup_obstack_free (&temp_obstack);
2894  mutable_map = addrmap_create_mutable (&temp_obstack);
2895 
2896  iter = index->address_table;
2897  end = iter + index->address_table_size;
2898 
2899  baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2900 
2901  while (iter < end)
2902  {
2903  ULONGEST hi, lo, cu_index;
2904  lo = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
2905  iter += 8;
2906  hi = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
2907  iter += 8;
2908  cu_index = extract_unsigned_integer (iter, 4, BFD_ENDIAN_LITTLE);
2909  iter += 4;
2910 
2911  if (lo > hi)
2912  {
2914  _(".gdb_index address table has invalid range (%s - %s)"),
2915  hex_string (lo), hex_string (hi));
2916  continue;
2917  }
2918 
2919  if (cu_index >= dwarf2_per_objfile->n_comp_units)
2920  {
2922  _(".gdb_index address table has invalid CU number %u"),
2923  (unsigned) cu_index);
2924  continue;
2925  }
2926 
2927  lo = gdbarch_adjust_dwarf2_addr (gdbarch, lo + baseaddr);
2928  hi = gdbarch_adjust_dwarf2_addr (gdbarch, hi + baseaddr);
2929  addrmap_set_empty (mutable_map, lo, hi - 1, dw2_get_cutu (cu_index));
2930  }
2931 
2932  objfile->psymtabs_addrmap = addrmap_create_fixed (mutable_map,
2933  &objfile->objfile_obstack);
2934  do_cleanups (cleanup);
2935 }
2936 
2937 /* The hash function for strings in the mapped index. This is the same as
2938  SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
2939  implementation. This is necessary because the hash function is tied to the
2940  format of the mapped index file. The hash values do not have to match with
2941  SYMBOL_HASH_NEXT.
2942 
2943  Use INT_MAX for INDEX_VERSION if you generate the current index format. */
2944 
2945 static hashval_t
2946 mapped_index_string_hash (int index_version, const void *p)
2947 {
2948  const unsigned char *str = (const unsigned char *) p;
2949  hashval_t r = 0;
2950  unsigned char c;
2951 
2952  while ((c = *str++) != 0)
2953  {
2954  if (index_version >= 5)
2955  c = tolower (c);
2956  r = r * 67 + c - 113;
2957  }
2958 
2959  return r;
2960 }
2961 
2962 /* Find a slot in the mapped index INDEX for the object named NAME.
2963  If NAME is found, set *VEC_OUT to point to the CU vector in the
2964  constant pool and return 1. If NAME cannot be found, return 0. */
2965 
2966 static int
2967 find_slot_in_mapped_hash (struct mapped_index *index, const char *name,
2968  offset_type **vec_out)
2969 {
2970  struct cleanup *back_to = make_cleanup (null_cleanup, 0);
2971  offset_type hash;
2972  offset_type slot, step;
2973  int (*cmp) (const char *, const char *);
2974 
2978  {
2979  /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2980  not contain any. */
2981 
2982  if (strchr (name, '(') != NULL)
2983  {
2984  char *without_params = cp_remove_params (name);
2985 
2986  if (without_params != NULL)
2987  {
2988  make_cleanup (xfree, without_params);
2989  name = without_params;
2990  }
2991  }
2992  }
2993 
2994  /* Index version 4 did not support case insensitive searches. But the
2995  indices for case insensitive languages are built in lowercase, therefore
2996  simulate our NAME being searched is also lowercased. */
2997  hash = mapped_index_string_hash ((index->version == 4
2999  ? 5 : index->version),
3000  name);
3001 
3002  slot = hash & (index->symbol_table_slots - 1);
3003  step = ((hash * 17) & (index->symbol_table_slots - 1)) | 1;
3004  cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
3005 
3006  for (;;)
3007  {
3008  /* Convert a slot number to an offset into the table. */
3009  offset_type i = 2 * slot;
3010  const char *str;
3011  if (index->symbol_table[i] == 0 && index->symbol_table[i + 1] == 0)
3012  {
3013  do_cleanups (back_to);
3014  return 0;
3015  }
3016 
3017  str = index->constant_pool + MAYBE_SWAP (index->symbol_table[i]);
3018  if (!cmp (name, str))
3019  {
3020  *vec_out = (offset_type *) (index->constant_pool
3021  + MAYBE_SWAP (index->symbol_table[i + 1]));
3022  do_cleanups (back_to);
3023  return 1;
3024  }
3025 
3026  slot = (slot + step) & (index->symbol_table_slots - 1);
3027  }
3028 }
3029 
3030 /* A helper function that reads the .gdb_index from SECTION and fills
3031  in MAP. FILENAME is the name of the file containing the section;
3032  it is used for error reporting. DEPRECATED_OK is nonzero if it is
3033  ok to use deprecated sections.
3034 
3035  CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
3036  out parameters that are filled in with information about the CU and
3037  TU lists in the section.
3038 
3039  Returns 1 if all went well, 0 otherwise. */
3040 
3041 static int
3042 read_index_from_section (struct objfile *objfile,
3043  const char *filename,
3044  int deprecated_ok,
3045  struct dwarf2_section_info *section,
3046  struct mapped_index *map,
3047  const gdb_byte **cu_list,
3048  offset_type *cu_list_elements,
3049  const gdb_byte **types_list,
3050  offset_type *types_list_elements)
3051 {
3052  const gdb_byte *addr;
3053  offset_type version;
3054  offset_type *metadata;
3055  int i;
3056 
3057  if (dwarf2_section_empty_p (section))
3058  return 0;
3059 
3060  /* Older elfutils strip versions could keep the section in the main
3061  executable while splitting it for the separate debug info file. */
3062  if ((get_section_flags (section) & SEC_HAS_CONTENTS) == 0)
3063  return 0;
3064 
3065  dwarf2_read_section (objfile, section);
3066 
3067  addr = section->buffer;
3068  /* Version check. */
3069  version = MAYBE_SWAP (*(offset_type *) addr);
3070  /* Versions earlier than 3 emitted every copy of a psymbol. This
3071  causes the index to behave very poorly for certain requests. Version 3
3072  contained incomplete addrmap. So, it seems better to just ignore such
3073  indices. */
3074  if (version < 4)
3075  {
3076  static int warning_printed = 0;
3077  if (!warning_printed)
3078  {
3079  warning (_("Skipping obsolete .gdb_index section in %s."),
3080  filename);
3081  warning_printed = 1;
3082  }
3083  return 0;
3084  }
3085  /* Index version 4 uses a different hash function than index version
3086  5 and later.
3087 
3088  Versions earlier than 6 did not emit psymbols for inlined
3089  functions. Using these files will cause GDB not to be able to
3090  set breakpoints on inlined functions by name, so we ignore these
3091  indices unless the user has done
3092  "set use-deprecated-index-sections on". */
3093  if (version < 6 && !deprecated_ok)
3094  {
3095  static int warning_printed = 0;
3096  if (!warning_printed)
3097  {
3098  warning (_("\
3099 Skipping deprecated .gdb_index section in %s.\n\
3100 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3101 to use the section anyway."),
3102  filename);
3103  warning_printed = 1;
3104  }
3105  return 0;
3106  }
3107  /* Version 7 indices generated by gold refer to the CU for a symbol instead
3108  of the TU (for symbols coming from TUs),
3109  http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3110  Plus gold-generated indices can have duplicate entries for global symbols,
3111  http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3112  These are just performance bugs, and we can't distinguish gdb-generated
3113  indices from gold-generated ones, so issue no warning here. */
3114 
3115  /* Indexes with higher version than the one supported by GDB may be no
3116  longer backward compatible. */
3117  if (version > 8)
3118  return 0;
3119 
3120  map->version = version;
3121  map->total_size = section->size;
3122 
3123  metadata = (offset_type *) (addr + sizeof (offset_type));
3124 
3125  i = 0;
3126  *cu_list = addr + MAYBE_SWAP (metadata[i]);
3127  *cu_list_elements = ((MAYBE_SWAP (metadata[i + 1]) - MAYBE_SWAP (metadata[i]))
3128  / 8);
3129  ++i;
3130 
3131  *types_list = addr + MAYBE_SWAP (metadata[i]);
3132  *types_list_elements = ((MAYBE_SWAP (metadata[i + 1])
3133  - MAYBE_SWAP (metadata[i]))
3134  / 8);
3135  ++i;
3136 
3137  map->address_table = addr + MAYBE_SWAP (metadata[i]);
3138  map->address_table_size = (MAYBE_SWAP (metadata[i + 1])
3139  - MAYBE_SWAP (metadata[i]));
3140  ++i;
3141 
3142  map->symbol_table = (offset_type *) (addr + MAYBE_SWAP (metadata[i]));
3143  map->symbol_table_slots = ((MAYBE_SWAP (metadata[i + 1])
3144  - MAYBE_SWAP (metadata[i]))
3145  / (2 * sizeof (offset_type)));
3146  ++i;
3147 
3148  map->constant_pool = (char *) (addr + MAYBE_SWAP (metadata[i]));
3149 
3150  return 1;
3151 }
3152 
3153 
3154 /* Read the index file. If everything went ok, initialize the "quick"
3155  elements of all the CUs and return 1. Otherwise, return 0. */
3156 
3157 static int
3158 dwarf2_read_index (struct objfile *objfile)
3159 {
3160  struct mapped_index local_map, *map;
3161  const gdb_byte *cu_list, *types_list, *dwz_list = NULL;
3162  offset_type cu_list_elements, types_list_elements, dwz_list_elements = 0;
3163  struct dwz_file *dwz;
3164 
3165  if (!read_index_from_section (objfile, objfile_name (objfile),
3166  use_deprecated_index_sections,
3167  &dwarf2_per_objfile->gdb_index, &local_map,
3168  &cu_list, &cu_list_elements,
3169  &types_list, &types_list_elements))
3170  return 0;
3171 
3172  /* Don't use the index if it's empty. */
3173  if (local_map.symbol_table_slots == 0)
3174  return 0;
3175 
3176  /* If there is a .dwz file, read it so we can get its CU list as
3177  well. */
3178  dwz = dwarf2_get_dwz_file ();
3179  if (dwz != NULL)
3180  {
3181  struct mapped_index dwz_map;
3182  const gdb_byte *dwz_types_ignore;
3183  offset_type dwz_types_elements_ignore;
3184 
3185  if (!read_index_from_section (objfile, bfd_get_filename (dwz->dwz_bfd),
3186  1,
3187  &dwz->gdb_index, &dwz_map,
3188  &dwz_list, &dwz_list_elements,
3189  &dwz_types_ignore,
3190  &dwz_types_elements_ignore))
3191  {
3192  warning (_("could not read '.gdb_index' section from %s; skipping"),
3193  bfd_get_filename (dwz->dwz_bfd));
3194  return 0;
3195  }
3196  }
3197 
3198  create_cus_from_index (objfile, cu_list, cu_list_elements, dwz_list,
3199  dwz_list_elements);
3200 
3201  if (types_list_elements)
3202  {
3203  struct dwarf2_section_info *section;
3204 
3205  /* We can only handle a single .debug_types when we have an
3206  index. */
3207  if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) != 1)
3208  return 0;
3209 
3211  dwarf2_per_objfile->types, 0);
3212 
3213  create_signatured_type_table_from_index (objfile, section, types_list,
3214  types_list_elements);
3215  }
3216 
3217  create_addrmap_from_index (objfile, &local_map);
3218 
3219  map = obstack_alloc (&objfile->objfile_obstack, sizeof (struct mapped_index));
3220  *map = local_map;
3221 
3222  dwarf2_per_objfile->index_table = map;
3223  dwarf2_per_objfile->using_index = 1;
3224  dwarf2_per_objfile->quick_file_names_table =
3225  create_quick_file_names_table (dwarf2_per_objfile->n_comp_units);
3226 
3227  return 1;
3228 }
3229 
3230 /* A helper for the "quick" functions which sets the global
3231  dwarf2_per_objfile according to OBJFILE. */
3232 
3233 static void
3234 dw2_setup (struct objfile *objfile)
3235 {
3236  dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
3237  gdb_assert (dwarf2_per_objfile);
3238 }
3239 
3240 /* die_reader_func for dw2_get_file_names. */
3241 
3242 static void
3244  const gdb_byte *info_ptr,
3245  struct die_info *comp_unit_die,
3246  int has_children,
3247  void *data)
3248 {
3249  struct dwarf2_cu *cu = reader->cu;
3250  struct dwarf2_per_cu_data *this_cu = cu->per_cu;
3251  struct objfile *objfile = dwarf2_per_objfile->objfile;
3252  struct dwarf2_per_cu_data *lh_cu;
3253  struct line_header *lh;
3254  struct attribute *attr;
3255  int i;
3256  const char *name, *comp_dir;
3257  void **slot;
3258  struct quick_file_names *qfn;
3259  unsigned int line_offset;
3260 
3261  gdb_assert (! this_cu->is_debug_types);
3262 
3263  /* Our callers never want to match partial units -- instead they
3264  will match the enclosing full CU. */
3265  if (comp_unit_die->tag == DW_TAG_partial_unit)
3266  {
3267  this_cu->v.quick->no_file_data = 1;
3268  return;
3269  }
3270 
3271  lh_cu = this_cu;
3272  lh = NULL;
3273  slot = NULL;
3274  line_offset = 0;
3275 
3276  attr = dwarf2_attr (comp_unit_die, DW_AT_stmt_list, cu);
3277  if (attr)
3278  {
3279  struct quick_file_names find_entry;
3280 
3281  line_offset = DW_UNSND (attr);
3282 
3283  /* We may have already read in this line header (TU line header sharing).
3284  If we have we're done. */
3285  find_entry.hash.dwo_unit = cu->dwo_unit;
3286  find_entry.hash.line_offset.sect_off = line_offset;
3287  slot = htab_find_slot (dwarf2_per_objfile->quick_file_names_table,
3288  &find_entry, INSERT);
3289  if (*slot != NULL)
3290  {
3291  lh_cu->v.quick->file_names = *slot;
3292  return;
3293  }
3294 
3295  lh = dwarf_decode_line_header (line_offset, cu);
3296  }
3297  if (lh == NULL)
3298  {
3299  lh_cu->v.quick->no_file_data = 1;
3300  return;
3301  }
3302 
3303  qfn = obstack_alloc (&objfile->objfile_obstack, sizeof (*qfn));
3304  qfn->hash.dwo_unit = cu->dwo_unit;
3305  qfn->hash.line_offset.sect_off = line_offset;
3306  gdb_assert (slot != NULL);
3307  *slot = qfn;
3308 
3309  find_file_and_directory (comp_unit_die, cu, &name, &comp_dir);
3310 
3311  qfn->num_file_names = lh->num_file_names;
3312  qfn->file_names = obstack_alloc (&objfile->objfile_obstack,
3313  lh->num_file_names * sizeof (char *));
3314  for (i = 0; i < lh->num_file_names; ++i)
3315  qfn->file_names[i] = file_full_name (i + 1, lh, comp_dir);
3316  qfn->real_names = NULL;
3317 
3318  free_line_header (lh);
3319 
3320  lh_cu->v.quick->file_names = qfn;
3321 }
3322 
3323 /* A helper for the "quick" functions which attempts to read the line
3324  table for THIS_CU. */
3325 
3326 static struct quick_file_names *
3328 {
3329  /* This should never be called for TUs. */
3330  gdb_assert (! this_cu->is_debug_types);
3331  /* Nor type unit groups. */
3332  gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu));
3333 
3334  if (this_cu->v.quick->file_names != NULL)
3335  return this_cu->v.quick->file_names;
3336  /* If we know there is no line data, no point in looking again. */
3337  if (this_cu->v.quick->no_file_data)
3338  return NULL;
3339 
3341 
3342  if (this_cu->v.quick->no_file_data)
3343  return NULL;
3344  return this_cu->v.quick->file_names;
3345 }
3346 
3347 /* A helper for the "quick" functions which computes and caches the
3348  real path for a given file name from the line table. */
3349 
3350 static const char *
3351 dw2_get_real_path (struct objfile *objfile,
3352  struct quick_file_names *qfn, int index)
3353 {
3354  if (qfn->real_names == NULL)
3355  qfn->real_names = OBSTACK_CALLOC (&objfile->objfile_obstack,
3356  qfn->num_file_names, const char *);
3357 
3358  if (qfn->real_names[index] == NULL)
3359  qfn->real_names[index] = gdb_realpath (qfn->file_names[index]);
3360 
3361  return qfn->real_names[index];
3362 }
3363 
3364 static struct symtab *
3365 dw2_find_last_source_symtab (struct objfile *objfile)
3366 {
3367  struct compunit_symtab *cust;
3368  int index;
3369 
3370  dw2_setup (objfile);
3371  index = dwarf2_per_objfile->n_comp_units - 1;
3372  cust = dw2_instantiate_symtab (dw2_get_cutu (index));
3373  if (cust == NULL)
3374  return NULL;
3375  return compunit_primary_filetab (cust);
3376 }
3377 
3378 /* Traversal function for dw2_forget_cached_source_info. */
3379 
3380 static int
3381 dw2_free_cached_file_names (void **slot, void *info)
3382 {
3383  struct quick_file_names *file_data = (struct quick_file_names *) *slot;
3384 
3385  if (file_data->real_names)
3386  {
3387  int i;
3388 
3389  for (i = 0; i < file_data->num_file_names; ++i)
3390  {
3391  xfree ((void*) file_data->real_names[i]);
3392  file_data->real_names[i] = NULL;
3393  }
3394  }
3395 
3396  return 1;
3397 }
3398 
3399 static void
3400 dw2_forget_cached_source_info (struct objfile *objfile)
3401 {
3402  dw2_setup (objfile);
3403 
3404  htab_traverse_noresize (dwarf2_per_objfile->quick_file_names_table,
3406 }
3407 
3408 /* Helper function for dw2_map_symtabs_matching_filename that expands
3409  the symtabs and calls the iterator. */
3410 
3411 static int
3412 dw2_map_expand_apply (struct objfile *objfile,
3413  struct dwarf2_per_cu_data *per_cu,
3414  const char *name, const char *real_path,
3415  int (*callback) (struct symtab *, void *),
3416  void *data)
3417 {
3418  struct compunit_symtab *last_made = objfile->compunit_symtabs;
3419 
3420  /* Don't visit already-expanded CUs. */
3421  if (per_cu->v.quick->compunit_symtab)
3422  return 0;
3423 
3424  /* This may expand more than one symtab, and we want to iterate over
3425  all of them. */
3426  dw2_instantiate_symtab (per_cu);
3427 
3428  return iterate_over_some_symtabs (name, real_path, callback, data,
3429  objfile->compunit_symtabs, last_made);
3430 }
3431 
3432 /* Implementation of the map_symtabs_matching_filename method. */
3433 
3434 static int
3435 dw2_map_symtabs_matching_filename (struct objfile *objfile, const char *name,
3436  const char *real_path,
3437  int (*callback) (struct symtab *, void *),
3438  void *data)
3439 {
3440  int i;
3441  const char *name_basename = lbasename (name);
3442 
3443  dw2_setup (objfile);
3444 
3445  /* The rule is CUs specify all the files, including those used by
3446  any TU, so there's no need to scan TUs here. */
3447 
3448  for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
3449  {
3450  int j;
3451  struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
3452  struct quick_file_names *file_data;
3453 
3454  /* We only need to look at symtabs not already expanded. */
3455  if (per_cu->v.quick->compunit_symtab)
3456  continue;
3457 
3458  file_data = dw2_get_file_names (per_cu);
3459  if (file_data == NULL)
3460  continue;
3461 
3462  for (j = 0; j < file_data->num_file_names; ++j)
3463  {
3464  const char *this_name = file_data->file_names[j];
3465  const char *this_real_name;
3466 
3467  if (compare_filenames_for_search (this_name, name))
3468  {
3469  if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3470  callback, data))
3471  return 1;
3472  continue;
3473  }
3474 
3475  /* Before we invoke realpath, which can get expensive when many
3476  files are involved, do a quick comparison of the basenames. */
3477  if (! basenames_may_differ
3478  && FILENAME_CMP (lbasename (this_name), name_basename) != 0)
3479  continue;
3480 
3481  this_real_name = dw2_get_real_path (objfile, file_data, j);
3482  if (compare_filenames_for_search (this_real_name, name))
3483  {
3484  if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3485  callback, data))
3486  return 1;
3487  continue;
3488  }
3489 
3490  if (real_path != NULL)
3491  {
3492  gdb_assert (IS_ABSOLUTE_PATH (real_path));
3493  gdb_assert (IS_ABSOLUTE_PATH (name));
3494  if (this_real_name != NULL
3495  && FILENAME_CMP (real_path, this_real_name) == 0)
3496  {
3497  if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3498  callback, data))
3499  return 1;
3500  continue;
3501  }
3502  }
3503  }
3504  }
3505 
3506  return 0;
3507 }
3508 
3509 /* Struct used to manage iterating over all CUs looking for a symbol. */
3510 
3512 {
3513  /* The internalized form of .gdb_index. */
3515  /* If non-zero, only look for symbols that match BLOCK_INDEX. */
3517  /* One of GLOBAL_BLOCK or STATIC_BLOCK.
3518  Unused if !WANT_SPECIFIC_BLOCK. */
3520  /* The kind of symbol we're looking for. */
3522  /* The list of CUs from the index entry of the symbol,
3523  or NULL if not found. */
3524  offset_type *vec;
3525  /* The next element in VEC to look at. */
3526  int next;
3527  /* The number of elements in VEC, or zero if there is no match. */
3528  int length;
3529  /* Have we seen a global version of the symbol?
3530  If so we can ignore all further global instances.
3531  This is to work around gold/15646, inefficient gold-generated
3532  indices. */
3534 };
3535 
3536 /* Initialize the index symtab iterator ITER.
3537  If WANT_SPECIFIC_BLOCK is non-zero, only look for symbols
3538  in block BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
3539 
3540 static void
3542  struct mapped_index *index,
3543  int want_specific_block,
3544  int block_index,
3545  domain_enum domain,
3546  const char *name)
3547 {
3548  iter->index = index;
3549  iter->want_specific_block = want_specific_block;
3550  iter->block_index = block_index;
3551  iter->domain = domain;
3552  iter->next = 0;
3553  iter->global_seen = 0;
3554 
3555  if (find_slot_in_mapped_hash (index, name, &iter->vec))
3556  iter->length = MAYBE_SWAP (*iter->vec);
3557  else
3558  {
3559  iter->vec = NULL;
3560  iter->length = 0;
3561  }
3562 }
3563 
3564 /* Return the next matching CU or NULL if there are no more. */
3565 
3566 static struct dwarf2_per_cu_data *
3568 {
3569  for ( ; iter->next < iter->length; ++iter->next)
3570  {
3571  offset_type cu_index_and_attrs =
3572  MAYBE_SWAP (iter->vec[iter->next + 1]);
3573  offset_type cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
3574  struct dwarf2_per_cu_data *per_cu;
3575  int want_static = iter->block_index != GLOBAL_BLOCK;
3576  /* This value is only valid for index versions >= 7. */
3577  int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
3578  gdb_index_symbol_kind symbol_kind =
3579  GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
3580  /* Only check the symbol attributes if they're present.
3581  Indices prior to version 7 don't record them,
3582  and indices >= 7 may elide them for certain symbols
3583  (gold does this). */
3584  int attrs_valid =
3585  (iter->index->version >= 7
3586  && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
3587 
3588  /* Don't crash on bad data. */
3589  if (cu_index >= (dwarf2_per_objfile->n_comp_units
3590  + dwarf2_per_objfile->n_type_units))
3591  {
3593  _(".gdb_index entry has bad CU index"
3594  " [in module %s]"),
3595  objfile_name (dwarf2_per_objfile->objfile));
3596  continue;
3597  }
3598 
3599  per_cu = dw2_get_cutu (cu_index);
3600 
3601  /* Skip if already read in. */
3602  if (per_cu->v.quick->compunit_symtab)
3603  continue;
3604 
3605  /* Check static vs global. */
3606  if (attrs_valid)
3607  {
3608  if (iter->want_specific_block
3609  && want_static != is_static)
3610  continue;
3611  /* Work around gold/15646. */
3612  if (!is_static && iter->global_seen)
3613  continue;
3614  if (!is_static)
3615  iter->global_seen = 1;
3616  }
3617 
3618  /* Only check the symbol's kind if it has one. */
3619  if (attrs_valid)
3620  {
3621  switch (iter->domain)
3622  {
3623  case VAR_DOMAIN:
3624  if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE
3625  && symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION
3626  /* Some types are also in VAR_DOMAIN. */
3627  && symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
3628  continue;
3629  break;
3630  case STRUCT_DOMAIN:
3631  if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
3632  continue;
3633  break;
3634  case LABEL_DOMAIN:
3635  if (symbol_kind != GDB_INDEX_SYMBOL_KIND_OTHER)
3636  continue;
3637  break;
3638  default:
3639  break;
3640  }
3641  }
3642 
3643  ++iter->next;
3644  return per_cu;
3645  }
3646 
3647  return NULL;
3648 }
3649 
3650 static struct compunit_symtab *
3651 dw2_lookup_symbol (struct objfile *objfile, int block_index,
3652  const char *name, domain_enum domain)
3653 {
3654  struct compunit_symtab *stab_best = NULL;
3655  struct mapped_index *index;
3656 
3657  dw2_setup (objfile);
3658 
3659  index = dwarf2_per_objfile->index_table;
3660 
3661  /* index is NULL if OBJF_READNOW. */
3662  if (index)
3663  {
3664  struct dw2_symtab_iterator iter;
3665  struct dwarf2_per_cu_data *per_cu;
3666 
3667  dw2_symtab_iter_init (&iter, index, 1, block_index, domain, name);
3668 
3669  while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
3670  {
3671  struct symbol *sym, *with_opaque = NULL;
3672  struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu);
3673  const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
3674  struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
3675 
3676  sym = block_find_symbol (block, name, domain,
3678  &with_opaque);
3679 
3680  /* Some caution must be observed with overloaded functions
3681  and methods, since the index will not contain any overload
3682  information (but NAME might contain it). */
3683 
3684  if (sym != NULL
3685  && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
3686  return stab;
3687  if (with_opaque != NULL
3688  && strcmp_iw (SYMBOL_SEARCH_NAME (with_opaque), name) == 0)
3689  stab_best = stab;
3690 
3691  /* Keep looking through other CUs. */
3692  }
3693  }
3694 
3695  return stab_best;
3696 }
3697 
3698 static void
3699 dw2_print_stats (struct objfile *objfile)
3700 {
3701  int i, total, count;
3702 
3703  dw2_setup (objfile);
3704  total = dwarf2_per_objfile->n_comp_units + dwarf2_per_objfile->n_type_units;
3705  count = 0;
3706  for (i = 0; i < total; ++i)
3707  {
3708  struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
3709 
3710  if (!per_cu->v.quick->compunit_symtab)
3711  ++count;
3712  }
3713  printf_filtered (_(" Number of read CUs: %d\n"), total - count);
3714  printf_filtered (_(" Number of unread CUs: %d\n"), count);
3715 }
3716 
3717 /* This dumps minimal information about the index.
3718  It is called via "mt print objfiles".
3719  One use is to verify .gdb_index has been loaded by the
3720  gdb.dwarf2/gdb-index.exp testcase. */
3721 
3722 static void
3723 dw2_dump (struct objfile *objfile)
3724 {
3725  dw2_setup (objfile);
3726  gdb_assert (dwarf2_per_objfile->using_index);
3727  printf_filtered (".gdb_index:");
3728  if (dwarf2_per_objfile->index_table != NULL)
3729  {
3730  printf_filtered (" version %d\n",
3731  dwarf2_per_objfile->index_table->version);
3732  }
3733  else
3734  printf_filtered (" faked for \"readnow\"\n");
3735  printf_filtered ("\n");
3736 }
3737 
3738 static void
3739 dw2_relocate (struct objfile *objfile,
3740  const struct section_offsets *new_offsets,
3741  const struct section_offsets *delta)
3742 {
3743  /* There's nothing to relocate here. */
3744 }
3745 
3746 static void
3747 dw2_expand_symtabs_for_function (struct objfile *objfile,
3748  const char *func_name)
3749 {
3750  struct mapped_index *index;
3751 
3752  dw2_setup (objfile);
3753 
3754  index = dwarf2_per_objfile->index_table;
3755 
3756  /* index is NULL if OBJF_READNOW. */
3757  if (index)
3758  {
3759  struct dw2_symtab_iterator iter;
3760  struct dwarf2_per_cu_data *per_cu;
3761 
3762  /* Note: It doesn't matter what we pass for block_index here. */
3763  dw2_symtab_iter_init (&iter, index, 0, GLOBAL_BLOCK, VAR_DOMAIN,
3764  func_name);
3765 
3766  while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
3767  dw2_instantiate_symtab (per_cu);
3768  }
3769 }
3770 
3771 static void
3772 dw2_expand_all_symtabs (struct objfile *objfile)
3773 {
3774  int i;
3775 
3776  dw2_setup (objfile);
3777 
3778  for (i = 0; i < (dwarf2_per_objfile->n_comp_units
3779  + dwarf2_per_objfile->n_type_units); ++i)
3780  {
3781  struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
3782 
3783  dw2_instantiate_symtab (per_cu);
3784  }
3785 }
3786 
3787 static void
3788 dw2_expand_symtabs_with_fullname (struct objfile *objfile,
3789  const char *fullname)
3790 {
3791  int i;
3792 
3793  dw2_setup (objfile);
3794 
3795  /* We don't need to consider type units here.
3796  This is only called for examining code, e.g. expand_line_sal.
3797  There can be an order of magnitude (or more) more type units
3798  than comp units, and we avoid them if we can. */
3799 
3800  for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
3801  {
3802  int j;
3803  struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
3804  struct quick_file_names *file_data;
3805 
3806  /* We only need to look at symtabs not already expanded. */
3807  if (per_cu->v.quick->compunit_symtab)
3808  continue;
3809 
3810  file_data = dw2_get_file_names (per_cu);
3811  if (file_data == NULL)
3812  continue;
3813 
3814  for (j = 0; j < file_data->num_file_names; ++j)
3815  {
3816  const char *this_fullname = file_data->file_names[j];
3817 
3818  if (filename_cmp (this_fullname, fullname) == 0)
3819  {
3820  dw2_instantiate_symtab (per_cu);
3821  break;
3822  }
3823  }
3824  }
3825 }
3826 
3827 static void
3828 dw2_map_matching_symbols (struct objfile *objfile,
3829  const char * name, domain_enum domain,
3830  int global,
3831  int (*callback) (struct block *,
3832  struct symbol *, void *),
3833  void *data, symbol_compare_ftype *match,
3834  symbol_compare_ftype *ordered_compare)
3835 {
3836  /* Currently unimplemented; used for Ada. The function can be called if the
3837  current language is Ada for a non-Ada objfile using GNU index. As Ada
3838  does not look for non-Ada symbols this function should just return. */
3839 }
3840 
3841 static void
3843  (struct objfile *objfile,
3844  expand_symtabs_file_matcher_ftype *file_matcher,
3845  expand_symtabs_symbol_matcher_ftype *symbol_matcher,
3846  expand_symtabs_exp_notify_ftype *expansion_notify,
3847  enum search_domain kind,
3848  void *data)
3849 {
3850  int i;
3851  offset_type iter;
3852  struct mapped_index *index;
3853 
3854  dw2_setup (objfile);
3855 
3856  /* index_table is NULL if OBJF_READNOW. */
3857  if (!dwarf2_per_objfile->index_table)
3858  return;
3859  index = dwarf2_per_objfile->index_table;
3860 
3861  if (file_matcher != NULL)
3862  {
3863  struct cleanup *cleanup;
3864  htab_t visited_found, visited_not_found;
3865 
3866  visited_found = htab_create_alloc (10,
3867  htab_hash_pointer, htab_eq_pointer,
3868  NULL, xcalloc, xfree);
3869  cleanup = make_cleanup_htab_delete (visited_found);
3870  visited_not_found = htab_create_alloc (10,
3871  htab_hash_pointer, htab_eq_pointer,
3872  NULL, xcalloc, xfree);
3873  make_cleanup_htab_delete (visited_not_found);
3874 
3875  /* The rule is CUs specify all the files, including those used by
3876  any TU, so there's no need to scan TUs here. */
3877 
3878  for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
3879  {
3880  int j;
3881  struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
3882  struct quick_file_names *file_data;
3883  void **slot;
3884 
3885  QUIT;
3886 
3887  per_cu->v.quick->mark = 0;
3888 
3889  /* We only need to look at symtabs not already expanded. */
3890  if (per_cu->v.quick->compunit_symtab)
3891  continue;
3892 
3893  file_data = dw2_get_file_names (per_cu);
3894  if (file_data == NULL)
3895  continue;
3896 
3897  if (htab_find (visited_not_found, file_data) != NULL)
3898  continue;
3899  else if (htab_find (visited_found, file_data) != NULL)
3900  {
3901  per_cu->v.quick->mark = 1;
3902  continue;
3903  }
3904 
3905  for (j = 0; j < file_data->num_file_names; ++j)
3906  {
3907  const char *this_real_name;
3908 
3909  if (file_matcher (file_data->file_names[j], data, 0))
3910  {
3911  per_cu->v.quick->mark = 1;
3912  break;
3913  }
3914 
3915  /* Before we invoke realpath, which can get expensive when many
3916  files are involved, do a quick comparison of the basenames. */
3918  && !file_matcher (lbasename (file_data->file_names[j]),
3919  data, 1))
3920  continue;
3921 
3922  this_real_name = dw2_get_real_path (objfile, file_data, j);
3923  if (file_matcher (this_real_name, data, 0))
3924  {
3925  per_cu->v.quick->mark = 1;
3926  break;
3927  }
3928  }
3929 
3930  slot = htab_find_slot (per_cu->v.quick->mark
3931  ? visited_found
3932  : visited_not_found,
3933  file_data, INSERT);
3934  *slot = file_data;
3935  }
3936 
3937  do_cleanups (cleanup);
3938  }
3939 
3940  for (iter = 0; iter < index->symbol_table_slots; ++iter)
3941  {
3942  offset_type idx = 2 * iter;
3943  const char *name;
3944  offset_type *vec, vec_len, vec_idx;
3945  int global_seen = 0;
3946 
3947  QUIT;
3948 
3949  if (index->symbol_table[idx] == 0 && index->symbol_table[idx + 1] == 0)
3950  continue;
3951 
3952  name = index->constant_pool + MAYBE_SWAP (index->symbol_table[idx]);
3953 
3954  if (! (*symbol_matcher) (name, data))
3955  continue;
3956 
3957  /* The name was matched, now expand corresponding CUs that were
3958  marked. */
3959  vec = (offset_type *) (index->constant_pool
3960  + MAYBE_SWAP (index->symbol_table[idx + 1]));
3961  vec_len = MAYBE_SWAP (vec[0]);
3962  for (vec_idx = 0; vec_idx < vec_len; ++vec_idx)
3963  {
3964  struct dwarf2_per_cu_data *per_cu;
3965  offset_type cu_index_and_attrs = MAYBE_SWAP (vec[vec_idx + 1]);
3966  /* This value is only valid for index versions >= 7. */
3967  int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
3968  gdb_index_symbol_kind symbol_kind =
3969  GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
3970  int cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
3971  /* Only check the symbol attributes if they're present.
3972  Indices prior to version 7 don't record them,
3973  and indices >= 7 may elide them for certain symbols
3974  (gold does this). */
3975  int attrs_valid =
3976  (index->version >= 7
3977  && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
3978 
3979  /* Work around gold/15646. */
3980  if (attrs_valid)
3981  {
3982  if (!is_static && global_seen)
3983  continue;
3984  if (!is_static)
3985  global_seen = 1;
3986  }
3987 
3988  /* Only check the symbol's kind if it has one. */
3989  if (attrs_valid)
3990  {
3991  switch (kind)
3992  {
3993  case VARIABLES_DOMAIN:
3994  if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE)
3995  continue;
3996  break;
3997  case FUNCTIONS_DOMAIN:
3998  if (symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION)
3999  continue;
4000  break;
4001  case TYPES_DOMAIN:
4002  if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
4003  continue;
4004  break;
4005  default:
4006  break;
4007  }
4008  }
4009 
4010  /* Don't crash on bad data. */
4011  if (cu_index >= (dwarf2_per_objfile->n_comp_units
4012  + dwarf2_per_objfile->n_type_units))
4013  {
4015  _(".gdb_index entry has bad CU index"
4016  " [in module %s]"), objfile_name (objfile));
4017  continue;
4018  }
4019 
4020  per_cu = dw2_get_cutu (cu_index);
4021  if (file_matcher == NULL || per_cu->v.quick->mark)
4022  {
4023  int symtab_was_null =
4024  (per_cu->v.quick->compunit_symtab == NULL);
4025 
4026  dw2_instantiate_symtab (per_cu);
4027 
4028  if (expansion_notify != NULL
4029  && symtab_was_null
4030  && per_cu->v.quick->compunit_symtab != NULL)
4031  {
4032  expansion_notify (per_cu->v.quick->compunit_symtab,
4033  data);
4034  }
4035  }
4036  }
4037  }
4038 }
4039 
4040 /* A helper for dw2_find_pc_sect_compunit_symtab which finds the most specific
4041  symtab. */
4042 
4043 static struct compunit_symtab *
4045  CORE_ADDR pc)
4046 {
4047  int i;
4048 
4049  if (COMPUNIT_BLOCKVECTOR (cust) != NULL
4051  return cust;
4052 
4053  if (cust->includes == NULL)
4054  return NULL;
4055 
4056  for (i = 0; cust->includes[i]; ++i)
4057  {
4058  struct compunit_symtab *s = cust->includes[i];
4059 
4061  if (s != NULL)
4062  return s;
4063  }
4064 
4065  return NULL;
4066 }
4067 
4068 static struct compunit_symtab *
4069 dw2_find_pc_sect_compunit_symtab (struct objfile *objfile,
4070  struct bound_minimal_symbol msymbol,
4071  CORE_ADDR pc,
4072  struct obj_section *section,
4073  int warn_if_readin)
4074 {
4075  struct dwarf2_per_cu_data *data;
4076  struct compunit_symtab *result;
4077 
4078  dw2_setup (objfile);
4079 
4080  if (!objfile->psymtabs_addrmap)
4081  return NULL;
4082 
4083  data = addrmap_find (objfile->psymtabs_addrmap, pc);
4084  if (!data)
4085  return NULL;
4086 
4087  if (warn_if_readin && data->v.quick->compunit_symtab)
4088  warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
4089  paddress (get_objfile_arch (objfile), pc));
4090 
4091  result
4093  pc);
4094  gdb_assert (result != NULL);
4095  return result;
4096 }
4097 
4098 static void
4099 dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun,
4100  void *data, int need_fullname)
4101 {
4102  int i;
4103  struct cleanup *cleanup;
4104  htab_t visited = htab_create_alloc (10, htab_hash_pointer, htab_eq_pointer,
4105  NULL, xcalloc, xfree);
4106 
4107  cleanup = make_cleanup_htab_delete (visited);
4108  dw2_setup (objfile);
4109 
4110  /* The rule is CUs specify all the files, including those used by
4111  any TU, so there's no need to scan TUs here.
4112  We can ignore file names coming from already-expanded CUs. */
4113 
4114  for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
4115  {
4116  struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
4117 
4118  if (per_cu->v.quick->compunit_symtab)
4119  {
4120  void **slot = htab_find_slot (visited, per_cu->v.quick->file_names,
4121  INSERT);
4122 
4123  *slot = per_cu->v.quick->file_names;
4124  }
4125  }
4126 
4127  for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
4128  {
4129  int j;
4130  struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
4131  struct quick_file_names *file_data;
4132  void **slot;
4133 
4134  /* We only need to look at symtabs not already expanded. */
4135  if (per_cu->v.quick->compunit_symtab)
4136  continue;
4137 
4138  file_data = dw2_get_file_names (per_cu);
4139  if (file_data == NULL)
4140  continue;
4141 
4142  slot = htab_find_slot (visited, file_data, INSERT);
4143  if (*slot)
4144  {
4145  /* Already visited. */
4146  continue;
4147  }
4148  *slot = file_data;
4149 
4150  for (j = 0; j < file_data->num_file_names; ++j)
4151  {
4152  const char *this_real_name;
4153 
4154  if (need_fullname)
4155  this_real_name = dw2_get_real_path (objfile, file_data, j);
4156  else
4157  this_real_name = NULL;
4158  (*fun) (file_data->file_names[j], this_real_name, data);
4159  }
4160  }
4161 
4162  do_cleanups (cleanup);
4163 }
4164 
4165 static int
4166 dw2_has_symbols (struct objfile *objfile)
4167 {
4168  return 1;
4169 }
4170 
4172 {
4179  dw2_dump,
4180  dw2_relocate,
4188 };
4189 
4190 /* Initialize for reading DWARF for this objfile. Return 0 if this
4191  file will use psymtabs, or 1 if using the GNU index. */
4192 
4193 int
4194 dwarf2_initialize_objfile (struct objfile *objfile)
4195 {
4196  /* If we're about to read full symbols, don't bother with the
4197  indices. In this case we also don't care if some other debug
4198  format is making psymtabs, because they are all about to be
4199  expanded anyway. */
4200  if ((objfile->flags & OBJF_READNOW))
4201  {
4202  int i;
4203 
4204  dwarf2_per_objfile->using_index = 1;
4205  create_all_comp_units (objfile);
4206  create_all_type_units (objfile);
4207  dwarf2_per_objfile->quick_file_names_table =
4208  create_quick_file_names_table (dwarf2_per_objfile->n_comp_units);
4209 
4210  for (i = 0; i < (dwarf2_per_objfile->n_comp_units
4211  + dwarf2_per_objfile->n_type_units); ++i)
4212  {
4213  struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
4214 
4215  per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
4216  struct dwarf2_per_cu_quick_data);
4217  }
4218 
4219  /* Return 1 so that gdb sees the "quick" functions. However,
4220  these functions will be no-ops because we will have expanded
4221  all symtabs. */
4222  return 1;
4223  }
4224 
4225  if (dwarf2_read_index (objfile))
4226  return 1;
4227 
4228  return 0;
4229 }
4230 
4231 
4232 
4233 /* Build a partial symbol table. */
4234 
4235 void
4236 dwarf2_build_psymtabs (struct objfile *objfile)
4237 {
4238 
4239  if (objfile->global_psymbols.size == 0 && objfile->static_psymbols.size == 0)
4240  {
4241  init_psymbol_list (objfile, 1024);
4242  }
4243 
4244  TRY
4245  {
4246  /* This isn't really ideal: all the data we allocate on the
4247  objfile's obstack is still uselessly kept around. However,
4248  freeing it seems unsafe. */
4249  struct cleanup *cleanups = make_cleanup_discard_psymtabs (objfile);
4250 
4251  dwarf2_build_psymtabs_hard (objfile);
4252  discard_cleanups (cleanups);
4253  }
4254  CATCH (except, RETURN_MASK_ERROR)
4255  {
4256  exception_print (gdb_stderr, except);
4257  }
4258  END_CATCH
4259 }
4260 
4261 /* Return the total length of the CU described by HEADER. */
4262 
4263 static unsigned int
4264 get_cu_length (const struct comp_unit_head *header)
4265 {
4266  return header->initial_length_size + header->length;
4267 }
4268 
4269 /* Return TRUE if OFFSET is within CU_HEADER. */
4270 
4271 static inline int
4272 offset_in_cu_p (const struct comp_unit_head *cu_header, sect_offset offset)
4273 {
4274  sect_offset bottom = { cu_header->offset.sect_off };
4275  sect_offset top = { cu_header->offset.sect_off + get_cu_length (cu_header) };
4276 
4277  return (offset.sect_off >= bottom.sect_off && offset.sect_off < top.sect_off);
4278 }
4279 
4280 /* Find the base address of the compilation unit for range lists and
4281  location lists. It will normally be specified by DW_AT_low_pc.
4282  In DWARF-3 draft 4, the base address could be overridden by
4283  DW_AT_entry_pc. It's been removed, but GCC still uses this for
4284  compilation units with discontinuous ranges. */
4285 
4286 static void
4288 {
4289  struct attribute *attr;
4290 
4291  cu->base_known = 0;
4292  cu->base_address = 0;
4293 
4294  attr = dwarf2_attr (die, DW_AT_entry_pc, cu);
4295  if (attr)
4296  {
4297  cu->base_address = attr_value_as_address (attr);
4298  cu->base_known = 1;
4299  }
4300  else
4301  {
4302  attr = dwarf2_attr (die, DW_AT_low_pc, cu);
4303  if (attr)
4304  {
4305  cu->base_address = attr_value_as_address (attr);
4306  cu->base_known = 1;
4307  }
4308  }
4309 }
4310 
4311 /* Read in the comp unit header information from the debug_info at info_ptr.
4312  NOTE: This leaves members offset, first_die_offset to be filled in
4313  by the caller. */
4314 
4315 static const gdb_byte *
4317  const gdb_byte *info_ptr, bfd *abfd)
4318 {
4319  int signed_addr;
4320  unsigned int bytes_read;
4321 
4322  cu_header->length = read_initial_length (abfd, info_ptr, &bytes_read);
4323  cu_header->initial_length_size = bytes_read;
4324  cu_header->offset_size = (bytes_read == 4) ? 4 : 8;
4325  info_ptr += bytes_read;
4326  cu_header->version = read_2_bytes (abfd, info_ptr);
4327  info_ptr += 2;
4328  cu_header->abbrev_offset.sect_off = read_offset (abfd, info_ptr, cu_header,
4329  &bytes_read);
4330  info_ptr += bytes_read;
4331  cu_header->addr_size = read_1_byte (abfd, info_ptr);
4332  info_ptr += 1;
4333  signed_addr = bfd_get_sign_extend_vma (abfd);
4334  if (signed_addr < 0)
4335  internal_error (__FILE__, __LINE__,
4336  _("read_comp_unit_head: dwarf from non elf file"));
4337  cu_header->signed_addr_p = signed_addr;
4338 
4339  return info_ptr;
4340 }
4341 
4342 /* Helper function that returns the proper abbrev section for
4343  THIS_CU. */
4344 
4345 static struct dwarf2_section_info *
4347 {
4348  struct dwarf2_section_info *abbrev;
4349 
4350  if (this_cu->is_dwz)
4351  abbrev = &dwarf2_get_dwz_file ()->abbrev;
4352  else
4353  abbrev = &dwarf2_per_objfile->abbrev;
4354 
4355  return abbrev;
4356 }
4357 
4358 /* Subroutine of read_and_check_comp_unit_head and
4359  read_and_check_type_unit_head to simplify them.
4360  Perform various error checking on the header. */
4361 
4362 static void
4364  struct dwarf2_section_info *section,
4365  struct dwarf2_section_info *abbrev_section)
4366 {
4367  bfd *abfd = get_section_bfd_owner (section);
4368  const char *filename = get_section_file_name (section);
4369 
4370  if (header->version != 2 && header->version != 3 && header->version != 4)
4371  error (_("Dwarf Error: wrong version in compilation unit header "
4372  "(is %d, should be 2, 3, or 4) [in module %s]"), header->version,
4373  filename);
4374 
4375  if (header->abbrev_offset.sect_off
4376  >= dwarf2_section_size (dwarf2_per_objfile->objfile, abbrev_section))
4377  error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
4378  "(offset 0x%lx + 6) [in module %s]"),
4379  (long) header->abbrev_offset.sect_off, (long) header->offset.sect_off,
4380  filename);
4381 
4382  /* Cast to unsigned long to use 64-bit arithmetic when possible to
4383  avoid potential 32-bit overflow. */
4384  if (((unsigned long) header->offset.sect_off + get_cu_length (header))
4385  > section->size)
4386  error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
4387  "(offset 0x%lx + 0) [in module %s]"),
4388  (long) header->length, (long) header->offset.sect_off,
4389  filename);
4390 }
4391 
4392 /* Read in a CU/TU header and perform some basic error checking.
4393  The contents of the header are stored in HEADER.
4394  The result is a pointer to the start of the first DIE. */
4395 
4396 static const gdb_byte *
4398  struct dwarf2_section_info *section,
4399  struct dwarf2_section_info *abbrev_section,
4400  const gdb_byte *info_ptr,
4401  int is_debug_types_section)
4402 {
4403  const gdb_byte *beg_of_comp_unit = info_ptr;
4404  bfd *abfd = get_section_bfd_owner (section);
4405 
4406  header->offset.sect_off = beg_of_comp_unit - section->buffer;
4407 
4408  info_ptr = read_comp_unit_head (header, info_ptr, abfd);
4409 
4410  /* If we're reading a type unit, skip over the signature and
4411  type_offset fields. */
4412  if (is_debug_types_section)
4413  info_ptr += 8 /*signature*/ + header->offset_size;
4414 
4415  header->first_die_offset.cu_off = info_ptr - beg_of_comp_unit;
4416 
4417  error_check_comp_unit_head (header, section, abbrev_section);
4418 
4419  return info_ptr;
4420 }
4421 
4422 /* Read in the types comp unit header information from .debug_types entry at
4423  types_ptr. The result is a pointer to one past the end of the header. */
4424 
4425 static const gdb_byte *
4427  struct dwarf2_section_info *section,
4428  struct dwarf2_section_info *abbrev_section,
4429  const gdb_byte *info_ptr,
4430  ULONGEST *signature,
4431  cu_offset *type_offset_in_tu)
4432 {
4433  const gdb_byte *beg_of_comp_unit = info_ptr;
4434  bfd *abfd = get_section_bfd_owner (section);
4435 
4436  header->offset.sect_off = beg_of_comp_unit - section->buffer;
4437 
4438  info_ptr = read_comp_unit_head (header, info_ptr, abfd);
4439 
4440  /* If we're reading a type unit, skip over the signature and
4441  type_offset fields. */
4442  if (signature != NULL)
4443  *signature = read_8_bytes (abfd, info_ptr);
4444  info_ptr += 8;
4445  if (type_offset_in_tu != NULL)
4446  type_offset_in_tu->cu_off = read_offset_1 (abfd, info_ptr,
4447  header->offset_size);
4448  info_ptr += header->offset_size;
4449 
4450  header->first_die_offset.cu_off = info_ptr - beg_of_comp_unit;
4451 
4452  error_check_comp_unit_head (header, section, abbrev_section);
4453 
4454  return info_ptr;
4455 }
4456 
4457 /* Fetch the abbreviation table offset from a comp or type unit header. */
4458 
4459 static sect_offset
4461  sect_offset offset)
4462 {
4463  bfd *abfd = get_section_bfd_owner (section);
4464  const gdb_byte *info_ptr;
4465  unsigned int length, initial_length_size, offset_size;
4466  sect_offset abbrev_offset;
4467 
4468  dwarf2_read_section (dwarf2_per_objfile->objfile, section);
4469  info_ptr = section->buffer + offset.sect_off;
4470  length = read_initial_length (abfd, info_ptr, &initial_length_size);
4471  offset_size = initial_length_size == 4 ? 4 : 8;
4472  info_ptr += initial_length_size + 2 /*version*/;
4473  abbrev_offset.sect_off = read_offset_1 (abfd, info_ptr, offset_size);
4474  return abbrev_offset;
4475 }
4476 
4477 /* Allocate a new partial symtab for file named NAME and mark this new
4478  partial symtab as being an include of PST. */
4479 
4480 static void
4481 dwarf2_create_include_psymtab (const char *name, struct partial_symtab *pst,
4482  struct objfile *objfile)
4483 {
4484  struct partial_symtab *subpst = allocate_psymtab (name, objfile);
4485 
4486  if (!IS_ABSOLUTE_PATH (subpst->filename))
4487  {
4488  /* It shares objfile->objfile_obstack. */
4489  subpst->dirname = pst->dirname;
4490  }
4491 
4492  subpst->textlow = 0;
4493  subpst->texthigh = 0;
4494 
4495  subpst->dependencies = (struct partial_symtab **)
4496  obstack_alloc (&objfile->objfile_obstack,
4497  sizeof (struct partial_symtab *));
4498  subpst->dependencies[0] = pst;
4499  subpst->number_of_dependencies = 1;
4500 
4501  subpst->globals_offset = 0;
4502  subpst->n_global_syms = 0;
4503  subpst->statics_offset = 0;
4504  subpst->n_static_syms = 0;
4505  subpst->compunit_symtab = NULL;
4506  subpst->read_symtab = pst->read_symtab;
4507  subpst->readin = 0;
4508 
4509  /* No private part is necessary for include psymtabs. This property
4510  can be used to differentiate between such include psymtabs and
4511  the regular ones. */
4512  subpst->read_symtab_private = NULL;
4513 }
4514 
4515 /* Read the Line Number Program data and extract the list of files
4516  included by the source file represented by PST. Build an include
4517  partial symtab for each of these included files. */
4518 
4519 static void
4521  struct die_info *die,
4522  struct partial_symtab *pst)
4523 {
4524  struct line_header *lh = NULL;
4525  struct attribute *attr;
4526 
4527  attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
4528  if (attr)
4529  lh = dwarf_decode_line_header (DW_UNSND (attr), cu);
4530  if (lh == NULL)
4531  return; /* No linetable, so no includes. */
4532 
4533  /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
4534  dwarf_decode_lines (lh, pst->dirname, cu, pst, pst->textlow, 1);
4535 
4536  free_line_header (lh);
4537 }
4538 
4539 static hashval_t
4540 hash_signatured_type (const void *item)
4541 {
4542  const struct signatured_type *sig_type = item;
4543 
4544  /* This drops the top 32 bits of the signature, but is ok for a hash. */
4545  return sig_type->signature;
4546 }
4547 
4548 static int
4549 eq_signatured_type (const void *item_lhs, const void *item_rhs)
4550 {
4551  const struct signatured_type *lhs = item_lhs;
4552  const struct signatured_type *rhs = item_rhs;
4553 
4554  return lhs->signature == rhs->signature;
4555 }
4556 
4557 /* Allocate a hash table for signatured types. */
4558 
4559 static htab_t
4560 allocate_signatured_type_table (struct objfile *objfile)
4561 {
4562  return htab_create_alloc_ex (41,
4565  NULL,
4566  &objfile->objfile_obstack,
4569 }
4570 
4571 /* A helper function to add a signatured type CU to a table. */
4572 
4573 static int
4574 add_signatured_type_cu_to_table (void **slot, void *datum)
4575 {
4576  struct signatured_type *sigt = *slot;
4577  struct signatured_type ***datap = datum;
4578 
4579  **datap = sigt;
4580  ++*datap;
4581 
4582  return 1;
4583 }
4584 
4585 /* Create the hash table of all entries in the .debug_types
4586  (or .debug_types.dwo) section(s).
4587  If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
4588  otherwise it is NULL.
4589 
4590  The result is a pointer to the hash table or NULL if there are no types.
4591 
4592  Note: This function processes DWO files only, not DWP files. */
4593 
4594 static htab_t
4596  VEC (dwarf2_section_info_def) *types)
4597 {
4598  struct objfile *objfile = dwarf2_per_objfile->objfile;
4599  htab_t types_htab = NULL;
4600  int ix;
4601  struct dwarf2_section_info *section;
4602  struct dwarf2_section_info *abbrev_section;
4603 
4604  if (VEC_empty (dwarf2_section_info_def, types))
4605  return NULL;
4606 
4607  abbrev_section = (dwo_file != NULL
4608  ? &dwo_file->sections.abbrev
4609  : &dwarf2_per_objfile->abbrev);
4610 
4611  if (dwarf_read_debug)
4612  fprintf_unfiltered (gdb_stdlog, "Reading .debug_types%s for %s:\n",
4613  dwo_file ? ".dwo" : "",
4614  get_section_file_name (abbrev_section));
4615 
4616  for (ix = 0;
4617  VEC_iterate (dwarf2_section_info_def, types, ix, section);
4618  ++ix)
4619  {
4620  bfd *abfd;
4621  const gdb_byte *info_ptr, *end_ptr;
4622 
4623  dwarf2_read_section (objfile, section);
4624  info_ptr = section->buffer;
4625 
4626  if (info_ptr == NULL)
4627  continue;
4628 
4629  /* We can't set abfd until now because the section may be empty or
4630  not present, in which case the bfd is unknown. */
4631  abfd = get_section_bfd_owner (section);
4632 
4633  /* We don't use init_cutu_and_read_dies_simple, or some such, here
4634  because we don't need to read any dies: the signature is in the
4635  header. */
4636 
4637  end_ptr = info_ptr + section->size;
4638  while (info_ptr < end_ptr)
4639  {
4641  cu_offset type_offset_in_tu;
4642  ULONGEST signature;
4643  struct signatured_type *sig_type;
4644  struct dwo_unit *dwo_tu;
4645  void **slot;
4646  const gdb_byte *ptr = info_ptr;
4647  struct comp_unit_head header;
4648  unsigned int length;
4649 
4650  offset.sect_off = ptr - section->buffer;
4651 
4652  /* We need to read the type's signature in order to build the hash
4653  table, but we don't need anything else just yet. */
4654 
4655  ptr = read_and_check_type_unit_head (&header, section,
4656  abbrev_section, ptr,
4657  &signature, &type_offset_in_tu);
4658 
4659  length = get_cu_length (&header);
4660 
4661  /* Skip dummy type units. */
4662  if (ptr >= info_ptr + length
4663  || peek_abbrev_code (abfd, ptr) == 0)
4664  {
4665  info_ptr += length;
4666  continue;
4667  }
4668 
4669  if (types_htab == NULL)
4670  {
4671  if (dwo_file)
4672  types_htab = allocate_dwo_unit_table (objfile);
4673  else
4674  types_htab = allocate_signatured_type_table (objfile);
4675  }
4676 
4677  if (dwo_file)
4678  {
4679  sig_type = NULL;
4680  dwo_tu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
4681  struct dwo_unit);
4682  dwo_tu->dwo_file = dwo_file;
4683  dwo_tu->signature = signature;
4684  dwo_tu->type_offset_in_tu = type_offset_in_tu;
4685  dwo_tu->section = section;
4686  dwo_tu->offset = offset;
4687  dwo_tu->length = length;
4688  }
4689  else
4690  {
4691  /* N.B.: type_offset is not usable if this type uses a DWO file.
4692  The real type_offset is in the DWO file. */
4693  dwo_tu = NULL;
4694  sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
4695  struct signatured_type);
4696  sig_type->signature = signature;
4697  sig_type->type_offset_in_tu = type_offset_in_tu;
4698  sig_type->per_cu.objfile = objfile;
4699  sig_type->per_cu.is_debug_types = 1;
4700  sig_type->per_cu.section = section;
4701  sig_type->per_cu.offset = offset;
4702  sig_type->per_cu.length = length;
4703  }
4704 
4705  slot = htab_find_slot (types_htab,
4706  dwo_file ? (void*) dwo_tu : (void *) sig_type,
4707  INSERT);
4708  gdb_assert (slot != NULL);
4709  if (*slot != NULL)
4710  {
4711  sect_offset dup_offset;
4712 
4713  if (dwo_file)
4714  {
4715  const struct dwo_unit *dup_tu = *slot;
4716 
4717  dup_offset = dup_tu->offset;
4718  }
4719  else
4720  {
4721  const struct signatured_type *dup_tu = *slot;
4722 
4723  dup_offset = dup_tu->per_cu.offset;
4724  }
4725 
4727  _("debug type entry at offset 0x%x is duplicate to"
4728  " the entry at offset 0x%x, signature %s"),
4729  offset.sect_off, dup_offset.sect_off,
4730  hex_string (signature));
4731  }
4732  *slot = dwo_file ? (void *) dwo_tu : (void *) sig_type;
4733 
4734  if (dwarf_read_debug > 1)
4735  fprintf_unfiltered (gdb_stdlog, " offset 0x%x, signature %s\n",
4736  offset.sect_off,
4737  hex_string (signature));
4738 
4739  info_ptr += length;
4740  }
4741  }
4742 
4743  return types_htab;
4744 }
4745 
4746 /* Create the hash table of all entries in the .debug_types section,
4747  and initialize all_type_units.
4748  The result is zero if there is an error (e.g. missing .debug_types section),
4749  otherwise non-zero. */
4750 
4751 static int
4752 create_all_type_units (struct objfile *objfile)
4753 {
4754  htab_t types_htab;
4755  struct signatured_type **iter;
4756 
4757  types_htab = create_debug_types_hash_table (NULL, dwarf2_per_objfile->types);
4758  if (types_htab == NULL)
4759  {
4760  dwarf2_per_objfile->signatured_types = NULL;
4761  return 0;
4762  }
4763 
4764  dwarf2_per_objfile->signatured_types = types_htab;
4765 
4766  dwarf2_per_objfile->n_type_units
4767  = dwarf2_per_objfile->n_allocated_type_units
4768  = htab_elements (types_htab);
4769  dwarf2_per_objfile->all_type_units
4770  = xmalloc (dwarf2_per_objfile->n_type_units
4771  * sizeof (struct signatured_type *));
4772  iter = &dwarf2_per_objfile->all_type_units[0];
4773  htab_traverse_noresize (types_htab, add_signatured_type_cu_to_table, &iter);
4774  gdb_assert (iter - &dwarf2_per_objfile->all_type_units[0]
4775  == dwarf2_per_objfile->n_type_units);
4776 
4777  return 1;
4778 }
4779 
4780 /* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
4781  If SLOT is non-NULL, it is the entry to use in the hash table.
4782  Otherwise we find one. */
4783 
4784 static struct signatured_type *
4785 add_type_unit (ULONGEST sig, void **slot)
4786 {
4787  struct objfile *objfile = dwarf2_per_objfile->objfile;
4788  int n_type_units = dwarf2_per_objfile->n_type_units;
4789  struct signatured_type *sig_type;
4790 
4791  gdb_assert (n_type_units <= dwarf2_per_objfile->n_allocated_type_units);
4792  ++n_type_units;
4793  if (n_type_units > dwarf2_per_objfile->n_allocated_type_units)
4794  {
4795  if (dwarf2_per_objfile->n_allocated_type_units == 0)
4796  dwarf2_per_objfile->n_allocated_type_units = 1;
4797  dwarf2_per_objfile->n_allocated_type_units *= 2;
4798  dwarf2_per_objfile->all_type_units
4799  = xrealloc (dwarf2_per_objfile->all_type_units,
4800  dwarf2_per_objfile->n_allocated_type_units
4801  * sizeof (struct signatured_type *));
4802  ++dwarf2_per_objfile->tu_stats.nr_all_type_units_reallocs;
4803  }
4804  dwarf2_per_objfile->n_type_units = n_type_units;
4805 
4806  sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
4807  struct signatured_type);
4808  dwarf2_per_objfile->all_type_units[n_type_units - 1] = sig_type;
4809  sig_type->signature = sig;
4810  sig_type->per_cu.is_debug_types = 1;
4811  if (dwarf2_per_objfile->using_index)
4812  {
4813  sig_type->per_cu.v.quick =
4814  OBSTACK_ZALLOC (&objfile->objfile_obstack,
4815  struct dwarf2_per_cu_quick_data);
4816  }
4817 
4818  if (slot == NULL)
4819  {
4820  slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
4821  sig_type, INSERT);
4822  }
4823  gdb_assert (*slot == NULL);
4824  *slot = sig_type;
4825  /* The rest of sig_type must be filled in by the caller. */
4826  return sig_type;
4827 }
4828 
4829 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
4830  Fill in SIG_ENTRY with DWO_ENTRY. */
4831 
4832 static void
4833 fill_in_sig_entry_from_dwo_entry (struct objfile *objfile,
4834  struct signatured_type *sig_entry,
4835  struct dwo_unit *dwo_entry)
4836 {
4837  /* Make sure we're not clobbering something we don't expect to. */
4838  gdb_assert (! sig_entry->per_cu.queued);
4839  gdb_assert (sig_entry->per_cu.cu == NULL);
4840  if (dwarf2_per_objfile->using_index)
4841  {
4842  gdb_assert (sig_entry->per_cu.v.quick != NULL);
4843  gdb_assert (sig_entry->per_cu.v.quick->compunit_symtab == NULL);
4844  }
4845  else
4846  gdb_assert (sig_entry->per_cu.v.psymtab == NULL);
4847  gdb_assert (sig_entry->signature == dwo_entry->signature);
4848  gdb_assert (sig_entry->type_offset_in_section.sect_off == 0);
4849  gdb_assert (sig_entry->type_unit_group == NULL);
4850  gdb_assert (sig_entry->dwo_unit == NULL);
4851 
4852  sig_entry->per_cu.section = dwo_entry->section;
4853  sig_entry->per_cu.offset = dwo_entry->offset;
4854  sig_entry->per_cu.length = dwo_entry->length;
4855  sig_entry->per_cu.reading_dwo_directly = 1;
4856  sig_entry->per_cu.objfile = objfile;
4857  sig_entry->type_offset_in_tu = dwo_entry->type_offset_in_tu;
4858  sig_entry->dwo_unit = dwo_entry;
4859 }
4860 
4861 /* Subroutine of lookup_signatured_type.
4862  If we haven't read the TU yet, create the signatured_type data structure
4863  for a TU to be read in directly from a DWO file, bypassing the stub.
4864  This is the "Stay in DWO Optimization": When there is no DWP file and we're
4865  using .gdb_index, then when reading a CU we want to stay in the DWO file
4866  containing that CU. Otherwise we could end up reading several other DWO
4867  files (due to comdat folding) to process the transitive closure of all the
4868  mentioned TUs, and that can be slow. The current DWO file will have every
4869  type signature that it needs.
4870  We only do this for .gdb_index because in the psymtab case we already have
4871  to read all the DWOs to build the type unit groups. */
4872 
4873 static struct signatured_type *
4875 {
4876  struct objfile *objfile = dwarf2_per_objfile->objfile;
4877  struct dwo_file *dwo_file;
4878  struct dwo_unit find_dwo_entry, *dwo_entry;
4879  struct signatured_type find_sig_entry, *sig_entry;
4880  void **slot;
4881 
4882  gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
4883 
4884  /* If TU skeletons have been removed then we may not have read in any
4885  TUs yet. */
4886  if (dwarf2_per_objfile->signatured_types == NULL)
4887  {
4888  dwarf2_per_objfile->signatured_types
4889  = allocate_signatured_type_table (objfile);
4890  }
4891 
4892  /* We only ever need to read in one copy of a signatured type.
4893  Use the global signatured_types array to do our own comdat-folding
4894  of types. If this is the first time we're reading this TU, and
4895  the TU has an entry in .gdb_index, replace the recorded data from
4896  .gdb_index with this TU. */
4897 
4898  find_sig_entry.signature = sig;
4899  slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
4900  &find_sig_entry, INSERT);
4901  sig_entry = *slot;
4902 
4903  /* We can get here with the TU already read, *or* in the process of being
4904  read. Don't reassign the global entry to point to this DWO if that's
4905  the case. Also note that if the TU is already being read, it may not
4906  have come from a DWO, the program may be a mix of Fission-compiled
4907  code and non-Fission-compiled code. */
4908 
4909  /* Have we already tried to read this TU?
4910  Note: sig_entry can be NULL if the skeleton TU was removed (thus it
4911  needn't exist in the global table yet). */
4912  if (sig_entry != NULL && sig_entry->per_cu.tu_read)
4913  return sig_entry;
4914 
4915  /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
4916  dwo_unit of the TU itself. */
4917  dwo_file = cu->dwo_unit->dwo_file;
4918 
4919  /* Ok, this is the first time we're reading this TU. */
4920  if (dwo_file->tus == NULL)
4921  return NULL;
4922  find_dwo_entry.signature = sig;
4923  dwo_entry = htab_find (dwo_file->tus, &find_dwo_entry);
4924  if (dwo_entry == NULL)
4925  return NULL;
4926 
4927  /* If the global table doesn't have an entry for this TU, add one. */
4928  if (sig_entry == NULL)
4929  sig_entry = add_type_unit (sig, slot);
4930 
4931  fill_in_sig_entry_from_dwo_entry (objfile, sig_entry, dwo_entry);
4932  sig_entry->per_cu.tu_read = 1;
4933  return sig_entry;
4934 }
4935 
4936 /* Subroutine of lookup_signatured_type.
4937  Look up the type for signature SIG, and if we can't find SIG in .gdb_index
4938  then try the DWP file. If the TU stub (skeleton) has been removed then
4939  it won't be in .gdb_index. */
4940 
4941 static struct signatured_type *
4943 {
4944  struct objfile *objfile = dwarf2_per_objfile->objfile;
4945  struct dwp_file *dwp_file = get_dwp_file ();
4946  struct dwo_unit *dwo_entry;
4947  struct signatured_type find_sig_entry, *sig_entry;
4948  void **slot;
4949 
4950  gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
4951  gdb_assert (dwp_file != NULL);
4952 
4953  /* If TU skeletons have been removed then we may not have read in any
4954  TUs yet. */
4955  if (dwarf2_per_objfile->signatured_types == NULL)
4956  {
4957  dwarf2_per_objfile->signatured_types
4958  = allocate_signatured_type_table (objfile);
4959  }
4960 
4961  find_sig_entry.signature = sig;
4962  slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
4963  &find_sig_entry, INSERT);
4964  sig_entry = *slot;
4965 
4966  /* Have we already tried to read this TU?
4967  Note: sig_entry can be NULL if the skeleton TU was removed (thus it
4968  needn't exist in the global table yet). */
4969  if (sig_entry != NULL)
4970  return sig_entry;
4971 
4972  if (dwp_file->tus == NULL)
4973  return NULL;
4974  dwo_entry = lookup_dwo_unit_in_dwp (dwp_file, NULL,
4975  sig, 1 /* is_debug_types */);
4976  if (dwo_entry == NULL)
4977  return NULL;
4978 
4979  sig_entry = add_type_unit (sig, slot);
4980  fill_in_sig_entry_from_dwo_entry (objfile, sig_entry, dwo_entry);
4981 
4982  return sig_entry;
4983 }
4984 
4985 /* Lookup a signature based type for DW_FORM_ref_sig8.
4986  Returns NULL if signature SIG is not present in the table.
4987  It is up to the caller to complain about this. */
4988 
4989 static struct signatured_type *
4991 {
4992  if (cu->dwo_unit
4993  && dwarf2_per_objfile->using_index)
4994  {
4995  /* We're in a DWO/DWP file, and we're using .gdb_index.
4996  These cases require special processing. */
4997  if (get_dwp_file () == NULL)
4998  return lookup_dwo_signatured_type (cu, sig);
4999  else
5000  return lookup_dwp_signatured_type (cu, sig);
5001  }
5002  else
5003  {
5004  struct signatured_type find_entry, *entry;
5005 
5006  if (dwarf2_per_objfile->signatured_types == NULL)
5007  return NULL;
5008  find_entry.signature = sig;
5009  entry = htab_find (dwarf2_per_objfile->signatured_types, &find_entry);
5010  return entry;
5011  }
5012 }
5013 
5014 /* Low level DIE reading support. */
5015 
5016 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
5017 
5018 static void
5020  struct dwarf2_cu *cu,
5021  struct dwarf2_section_info *section,
5022  struct dwo_file *dwo_file)
5023 {
5024  gdb_assert (section->readin && section->buffer != NULL);
5025  reader->abfd = get_section_bfd_owner (section);
5026  reader->cu = cu;
5027  reader->dwo_file = dwo_file;
5028  reader->die_section = section;
5029  reader->buffer = section->buffer;
5030  reader->buffer_end = section->buffer + section->size;
5031  reader->comp_dir = NULL;
5032 }
5033 
5034 /* Subroutine of init_cutu_and_read_dies to simplify it.
5035  Read in the rest of a CU/TU top level DIE from DWO_UNIT.
5036  There's just a lot of work to do, and init_cutu_and_read_dies is big enough
5037  already.
5038 
5039  STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
5040  from it to the DIE in the DWO. If NULL we are skipping the stub.
5041  STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
5042  from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
5043  attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
5044  STUB_COMP_DIR may be non-NULL.
5045  *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
5046  are filled in with the info of the DIE from the DWO file.
5047  ABBREV_TABLE_PROVIDED is non-zero if the caller of init_cutu_and_read_dies
5048  provided an abbrev table to use.
5049  The result is non-zero if a valid (non-dummy) DIE was found. */
5050 
5051 static int
5053  struct dwo_unit *dwo_unit,
5054  int abbrev_table_provided,
5055  struct die_info *stub_comp_unit_die,
5056  const char *stub_comp_dir,
5057  struct die_reader_specs *result_reader,
5058  const gdb_byte **result_info_ptr,
5059  struct die_info **result_comp_unit_die,
5060  int *result_has_children)
5061 {
5062  struct objfile *objfile = dwarf2_per_objfile->objfile;
5063  struct dwarf2_cu *cu = this_cu->cu;
5064  struct dwarf2_section_info *section;
5065  bfd *abfd;
5066  const gdb_byte *begin_info_ptr, *info_ptr;
5067  ULONGEST signature; /* Or dwo_id. */
5068  struct attribute *comp_dir, *stmt_list, *low_pc, *high_pc, *ranges;
5069  int i,num_extra_attrs;
5070  struct dwarf2_section_info *dwo_abbrev_section;
5071  struct attribute *attr;
5072  struct die_info *comp_unit_die;
5073 
5074  /* At most one of these may be provided. */
5075  gdb_assert ((stub_comp_unit_die != NULL) + (stub_comp_dir != NULL) <= 1);
5076 
5077  /* These attributes aren't processed until later:
5078  DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
5079  DW_AT_comp_dir is used now, to find the DWO file, but it is also
5080  referenced later. However, these attributes are found in the stub
5081  which we won't have later. In order to not impose this complication
5082  on the rest of the code, we read them here and copy them to the
5083  DWO CU/TU die. */
5084 
5085  stmt_list = NULL;
5086  low_pc = NULL;
5087  high_pc = NULL;
5088  ranges = NULL;
5089  comp_dir = NULL;
5090 
5091  if (stub_comp_unit_die != NULL)
5092  {
5093  /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
5094  DWO file. */
5095  if (! this_cu->is_debug_types)
5096  stmt_list = dwarf2_attr (stub_comp_unit_die, DW_AT_stmt_list, cu);
5097  low_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_low_pc, cu);
5098  high_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_high_pc, cu);
5099  ranges = dwarf2_attr (stub_comp_unit_die, DW_AT_ranges, cu);
5100  comp_dir = dwarf2_attr (stub_comp_unit_die, DW_AT_comp_dir, cu);
5101 
5102  /* There should be a DW_AT_addr_base attribute here (if needed).
5103  We need the value before we can process DW_FORM_GNU_addr_index. */
5104  cu->addr_base = 0;
5105  attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_addr_base, cu);
5106  if (attr)
5107  cu->addr_base = DW_UNSND (attr);
5108 
5109  /* There should be a DW_AT_ranges_base attribute here (if needed).
5110  We need the value before we can process DW_AT_ranges. */
5111  cu->ranges_base = 0;
5112  attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_ranges_base, cu);
5113  if (attr)
5114  cu->ranges_base = DW_UNSND (attr);
5115  }
5116  else if (stub_comp_dir != NULL)
5117  {
5118  /* Reconstruct the comp_dir attribute to simplify the code below. */
5119  comp_dir = (struct attribute *)
5120  obstack_alloc (&cu->comp_unit_obstack, sizeof (*comp_dir));
5121  comp_dir->name = DW_AT_comp_dir;
5122  comp_dir->form = DW_FORM_string;
5123  DW_STRING_IS_CANONICAL (comp_dir) = 0;
5124  DW_STRING (comp_dir) = stub_comp_dir;
5125  }
5126 
5127  /* Set up for reading the DWO CU/TU. */
5128  cu->dwo_unit = dwo_unit;
5129  section = dwo_unit->section;
5130  dwarf2_read_section (objfile, section);
5131  abfd = get_section_bfd_owner (section);
5132  begin_info_ptr = info_ptr = section->buffer + dwo_unit->offset.sect_off;
5133  dwo_abbrev_section = &dwo_unit->dwo_file->sections.abbrev;
5134  init_cu_die_reader (result_reader, cu, section, dwo_unit->dwo_file);
5135 
5136  if (this_cu->is_debug_types)
5137  {
5138  ULONGEST header_signature;
5139  cu_offset type_offset_in_tu;
5140  struct signatured_type *sig_type = (struct signatured_type *) this_cu;
5141 
5142  info_ptr = read_and_check_type_unit_head (&cu->header, section,
5143  dwo_abbrev_section,
5144  info_ptr,
5145  &header_signature,
5146  &type_offset_in_tu);
5147  /* This is not an assert because it can be caused by bad debug info. */
5148  if (sig_type->signature != header_signature)
5149  {
5150  error (_("Dwarf Error: signature mismatch %s vs %s while reading"
5151  " TU at offset 0x%x [in module %s]"),
5152  hex_string (sig_type->signature),
5153  hex_string (header_signature),
5154  dwo_unit->offset.sect_off,
5155  bfd_get_filename (abfd));
5156  }
5157  gdb_assert (dwo_unit->offset.sect_off == cu->header.offset.sect_off);
5158  /* For DWOs coming from DWP files, we don't know the CU length
5159  nor the type's offset in the TU until now. */
5160  dwo_unit->length = get_cu_length (&cu->header);
5162 
5163  /* Establish the type offset that can be used to lookup the type.
5164  For DWO files, we don't know it until now. */
5165  sig_type->type_offset_in_section.sect_off =
5166  dwo_unit->offset.sect_off + dwo_unit->type_offset_in_tu.cu_off;
5167  }
5168  else
5169  {
5170  info_ptr = read_and_check_comp_unit_head (&cu->header, section,
5171  dwo_abbrev_section,
5172  info_ptr, 0);
5173  gdb_assert (dwo_unit->offset.sect_off == cu->header.offset.sect_off);
5174  /* For DWOs coming from DWP files, we don't know the CU length
5175  until now. */
5176  dwo_unit->length = get_cu_length (&cu->header);
5177  }
5178 
5179  /* Replace the CU's original abbrev table with the DWO's.
5180  Reminder: We can't read the abbrev table until we've read the header. */
5181  if (abbrev_table_provided)
5182  {
5183  /* Don't free the provided abbrev table, the caller of
5184  init_cutu_and_read_dies owns it. */
5185  dwarf2_read_abbrevs (cu, dwo_abbrev_section);
5186  /* Ensure the DWO abbrev table gets freed. */
5188  }
5189  else
5190  {
5192  dwarf2_read_abbrevs (cu, dwo_abbrev_section);
5193  /* Leave any existing abbrev table cleanup as is. */
5194  }
5195 
5196  /* Read in the die, but leave space to copy over the attributes
5197  from the stub. This has the benefit of simplifying the rest of
5198  the code - all the work to maintain the illusion of a single
5199  DW_TAG_{compile,type}_unit DIE is done here. */
5200  num_extra_attrs = ((stmt_list != NULL)
5201  + (low_pc != NULL)
5202  + (high_pc != NULL)
5203  + (ranges != NULL)
5204  + (comp_dir != NULL));
5205  info_ptr = read_full_die_1 (result_reader, result_comp_unit_die, info_ptr,
5206  result_has_children, num_extra_attrs);
5207 
5208  /* Copy over the attributes from the stub to the DIE we just read in. */
5209  comp_unit_die = *result_comp_unit_die;
5210  i = comp_unit_die->num_attrs;
5211  if (stmt_list != NULL)
5212  comp_unit_die->attrs[i++] = *stmt_list;
5213  if (low_pc != NULL)
5214  comp_unit_die->attrs[i++] = *low_pc;
5215  if (high_pc != NULL)
5216  comp_unit_die->attrs[i++] = *high_pc;
5217  if (ranges != NULL)
5218  comp_unit_die->attrs[i++] = *ranges;
5219  if (comp_dir != NULL)
5220  comp_unit_die->attrs[i++] = *comp_dir;
5221  comp_unit_die->num_attrs += num_extra_attrs;
5222 
5223  if (dwarf_die_debug)
5224  {
5226  "Read die from %s@0x%x of %s:\n",
5227  get_section_name (section),
5228  (unsigned) (begin_info_ptr - section->buffer),
5229  bfd_get_filename (abfd));
5230  dump_die (comp_unit_die, dwarf_die_debug);
5231  }
5232 
5233  /* Save the comp_dir attribute. If there is no DWP file then we'll read
5234  TUs by skipping the stub and going directly to the entry in the DWO file.
5235  However, skipping the stub means we won't get DW_AT_comp_dir, so we have
5236  to get it via circuitous means. Blech. */
5237  if (comp_dir != NULL)
5238  result_reader->comp_dir = DW_STRING (comp_dir);
5239 
5240  /* Skip dummy compilation units. */
5241  if (info_ptr >= begin_info_ptr + dwo_unit->length
5242  || peek_abbrev_code (abfd, info_ptr) == 0)
5243  return 0;
5244 
5245  *result_info_ptr = info_ptr;
5246  return 1;
5247 }
5248 
5249 /* Subroutine of init_cutu_and_read_dies to simplify it.
5250  Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
5251  Returns NULL if the specified DWO unit cannot be found. */
5252 
5253 static struct dwo_unit *
5255  struct die_info *comp_unit_die)
5256 {
5257  struct dwarf2_cu *cu = this_cu->cu;
5258  struct attribute *attr;
5260  struct dwo_unit *dwo_unit;
5261  const char *comp_dir, *dwo_name;
5262 
5263  gdb_assert (cu != NULL);
5264 
5265  /* Yeah, we look dwo_name up again, but it simplifies the code. */
5266  attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
5267  gdb_assert (attr != NULL);
5268  dwo_name = DW_STRING (attr);
5269  comp_dir = NULL;
5270  attr = dwarf2_attr (comp_unit_die, DW_AT_comp_dir, cu);
5271  if (attr)
5272  comp_dir = DW_STRING (attr);
5273 
5274  if (this_cu->is_debug_types)
5275  {
5276  struct signatured_type *sig_type;
5277 
5278  /* Since this_cu is the first member of struct signatured_type,
5279  we can go from a pointer to one to a pointer to the other. */
5280  sig_type = (struct signatured_type *) this_cu;
5281  signature = sig_type->signature;
5282  dwo_unit = lookup_dwo_type_unit (sig_type, dwo_name, comp_dir);
5283  }
5284  else
5285  {
5286  struct attribute *attr;
5287 
5288  attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
5289  if (! attr)
5290  error (_("Dwarf Error: missing dwo_id for dwo_name %s"
5291  " [in module %s]"),
5292  dwo_name, objfile_name (this_cu->objfile));
5293  signature = DW_UNSND (attr);
5294  dwo_unit = lookup_dwo_comp_unit (this_cu, dwo_name, comp_dir,
5295  signature);
5296  }
5297 
5298  return dwo_unit;
5299 }
5300 
5301 /* Subroutine of init_cutu_and_read_dies to simplify it.
5302  See it for a description of the parameters.
5303  Read a TU directly from a DWO file, bypassing the stub.
5304 
5305  Note: This function could be a little bit simpler if we shared cleanups
5306  with our caller, init_cutu_and_read_dies. That's generally a fragile thing
5307  to do, so we keep this function self-contained. Or we could move this
5308  into our caller, but it's complex enough already. */
5309 
5310 static void
5312  int use_existing_cu, int keep,
5313  die_reader_func_ftype *die_reader_func,
5314  void *data)
5315 {
5316  struct dwarf2_cu *cu;
5317  struct signatured_type *sig_type;
5318  struct cleanup *cleanups, *free_cu_cleanup = NULL;
5319  struct die_reader_specs reader;
5320  const gdb_byte *info_ptr;
5321  struct die_info *comp_unit_die;
5322  int has_children;
5323 
5324  /* Verify we can do the following downcast, and that we have the
5325  data we need. */
5326  gdb_assert (this_cu->is_debug_types && this_cu->reading_dwo_directly);
5327  sig_type = (struct signatured_type *) this_cu;
5328  gdb_assert (sig_type->dwo_unit != NULL);
5329 
5330  cleanups = make_cleanup (null_cleanup, NULL);
5331 
5332  if (use_existing_cu && this_cu->cu != NULL)
5333  {
5334  gdb_assert (this_cu->cu->dwo_unit == sig_type->dwo_unit);
5335  cu = this_cu->cu;
5336  /* There's no need to do the rereading_dwo_cu handling that
5337  init_cutu_and_read_dies does since we don't read the stub. */
5338  }
5339  else
5340  {
5341  /* If !use_existing_cu, this_cu->cu must be NULL. */
5342  gdb_assert (this_cu->cu == NULL);
5343  cu = xmalloc (sizeof (*cu));
5344  init_one_comp_unit (cu, this_cu);
5345  /* If an error occurs while loading, release our storage. */
5346  free_cu_cleanup = make_cleanup (free_heap_comp_unit, cu);
5347  }
5348 
5349  /* A future optimization, if needed, would be to use an existing
5350  abbrev table. When reading DWOs with skeletonless TUs, all the TUs
5351  could share abbrev tables. */
5352 
5353  if (read_cutu_die_from_dwo (this_cu, sig_type->dwo_unit,
5354  0 /* abbrev_table_provided */,
5355  NULL /* stub_comp_unit_die */,
5356  sig_type->dwo_unit->dwo_file->comp_dir,
5357  &reader, &info_ptr,
5358  &comp_unit_die, &has_children) == 0)
5359  {
5360  /* Dummy die. */
5361  do_cleanups (cleanups);
5362  return;
5363  }
5364 
5365  /* All the "real" work is done here. */
5366  die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
5367 
5368  /* This duplicates the code in init_cutu_and_read_dies,
5369  but the alternative is making the latter more complex.
5370  This function is only for the special case of using DWO files directly:
5371  no point in overly complicating the general case just to handle this. */
5372  if (free_cu_cleanup != NULL)
5373  {
5374  if (keep)
5375  {
5376  /* We've successfully allocated this compilation unit. Let our
5377  caller clean it up when finished with it. */
5378  discard_cleanups (free_cu_cleanup);
5379 
5380  /* We can only discard free_cu_cleanup and all subsequent cleanups.
5381  So we have to manually free the abbrev table. */
5383 
5384  /* Link this CU into read_in_chain. */
5385  this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
5386  dwarf2_per_objfile->read_in_chain = this_cu;
5387  }
5388  else
5389  do_cleanups (free_cu_cleanup);
5390  }
5391 
5392  do_cleanups (cleanups);
5393 }
5394 
5395 /* Initialize a CU (or TU) and read its DIEs.
5396  If the CU defers to a DWO file, read the DWO file as well.
5397 
5398  ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
5399  Otherwise the table specified in the comp unit header is read in and used.
5400  This is an optimization for when we already have the abbrev table.
5401 
5402  If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
5403  Otherwise, a new CU is allocated with xmalloc.
5404 
5405  If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
5406  read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
5407 
5408  WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
5409  linker) then DIE_READER_FUNC will not get called. */
5410 
5411 static void
5413  struct abbrev_table *abbrev_table,
5414  int use_existing_cu, int keep,
5415  die_reader_func_ftype *die_reader_func,
5416  void *data)
5417 {
5418  struct objfile *objfile = dwarf2_per_objfile->objfile;
5419  struct dwarf2_section_info *section = this_cu->section;
5420  bfd *abfd = get_section_bfd_owner (section);
5421  struct dwarf2_cu *cu;
5422  const gdb_byte *begin_info_ptr, *info_ptr;
5423  struct die_reader_specs reader;
5424  struct die_info *comp_unit_die;
5425  int has_children;
5426  struct attribute *attr;
5427  struct cleanup *cleanups, *free_cu_cleanup = NULL;
5428  struct signatured_type *sig_type = NULL;
5429  struct dwarf2_section_info *abbrev_section;
5430  /* Non-zero if CU currently points to a DWO file and we need to
5431  reread it. When this happens we need to reread the skeleton die
5432  before we can reread the DWO file (this only applies to CUs, not TUs). */
5433  int rereading_dwo_cu = 0;
5434 
5435  if (dwarf_die_debug)
5436  fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset 0x%x\n",
5437  this_cu->is_debug_types ? "type" : "comp",
5438  this_cu->offset.sect_off);
5439 
5440  if (use_existing_cu)
5441  gdb_assert (keep);
5442 
5443  /* If we're reading a TU directly from a DWO file, including a virtual DWO
5444  file (instead of going through the stub), short-circuit all of this. */
5445  if (this_cu->reading_dwo_directly)
5446  {
5447  /* Narrow down the scope of possibilities to have to understand. */
5448  gdb_assert (this_cu->is_debug_types);
5449  gdb_assert (abbrev_table == NULL);
5450  init_tu_and_read_dwo_dies (this_cu, use_existing_cu, keep,
5451  die_reader_func, data);
5452  return;
5453  }
5454 
5455  cleanups = make_cleanup (null_cleanup, NULL);
5456 
5457  /* This is cheap if the section is already read in. */
5458  dwarf2_read_section (objfile, section);
5459 
5460  begin_info_ptr = info_ptr = section->buffer + this_cu->offset.sect_off;
5461 
5462  abbrev_section = get_abbrev_section_for_cu (this_cu);
5463 
5464  if (use_existing_cu && this_cu->cu != NULL)
5465  {
5466  cu = this_cu->cu;
5467  /* If this CU is from a DWO file we need to start over, we need to
5468  refetch the attributes from the skeleton CU.
5469  This could be optimized by retrieving those attributes from when we
5470  were here the first time: the previous comp_unit_die was stored in
5471  comp_unit_obstack. But there's no data yet that we need this
5472  optimization. */
5473  if (cu->dwo_unit != NULL)
5474  rereading_dwo_cu = 1;
5475  }
5476  else
5477  {
5478  /* If !use_existing_cu, this_cu->cu must be NULL. */
5479  gdb_assert (this_cu->cu == NULL);
5480  cu = xmalloc (sizeof (*cu));
5481  init_one_comp_unit (cu, this_cu);
5482  /* If an error occurs while loading, release our storage. */
5483  free_cu_cleanup = make_cleanup (free_heap_comp_unit, cu);
5484  }
5485 
5486  /* Get the header. */
5487  if (cu->header.first_die_offset.cu_off != 0 && ! rereading_dwo_cu)
5488  {
5489  /* We already have the header, there's no need to read it in again. */
5490  info_ptr += cu->header.first_die_offset.cu_off;
5491  }
5492  else
5493  {
5494  if (this_cu->is_debug_types)
5495  {
5496  ULONGEST signature;
5497  cu_offset type_offset_in_tu;
5498 
5499  info_ptr = read_and_check_type_unit_head (&cu->header, section,
5500  abbrev_section, info_ptr,
5501  &signature,
5502  &type_offset_in_tu);
5503 
5504  /* Since per_cu is the first member of struct signatured_type,
5505  we can go from a pointer to one to a pointer to the other. */
5506  sig_type = (struct signatured_type *) this_cu;
5507  gdb_assert (sig_type->signature == signature);
5509  == type_offset_in_tu.cu_off);
5510  gdb_assert (this_cu->offset.sect_off == cu->header.offset.sect_off);
5511 
5512  /* LENGTH has not been set yet for type units if we're
5513  using .gdb_index. */
5514  this_cu->length = get_cu_length (&cu->header);
5515 
5516  /* Establish the type offset that can be used to lookup the type. */
5517  sig_type->type_offset_in_section.sect_off =
5518  this_cu->offset.sect_off + sig_type->type_offset_in_tu.cu_off;
5519  }
5520  else
5521  {
5522  info_ptr = read_and_check_comp_unit_head (&cu->header, section,
5523  abbrev_section,
5524  info_ptr, 0);
5525 
5526  gdb_assert (this_cu->offset.sect_off == cu->header.offset.sect_off);
5527  gdb_assert (this_cu->length == get_cu_length (&cu->header));
5528  }
5529  }
5530 
5531  /* Skip dummy compilation units. */
5532  if (info_ptr >= begin_info_ptr + this_cu->length
5533  || peek_abbrev_code (abfd, info_ptr) == 0)
5534  {
5535  do_cleanups (cleanups);
5536  return;
5537  }
5538 
5539  /* If we don't have them yet, read the abbrevs for this compilation unit.
5540  And if we need to read them now, make sure they're freed when we're
5541  done. Note that it's important that if the CU had an abbrev table
5542  on entry we don't free it when we're done: Somewhere up the call stack
5543  it may be in use. */
5544  if (abbrev_table != NULL)
5545  {
5546  gdb_assert (cu->abbrev_table == NULL);
5548  == abbrev_table->offset.sect_off);
5549  cu->abbrev_table = abbrev_table;
5550  }
5551  else if (cu->abbrev_table == NULL)
5552  {
5553  dwarf2_read_abbrevs (cu, abbrev_section);
5555  }
5556  else if (rereading_dwo_cu)
5557  {
5559  dwarf2_read_abbrevs (cu, abbrev_section);
5560  }
5561 
5562  /* Read the top level CU/TU die. */
5563  init_cu_die_reader (&reader, cu, section, NULL);
5564  info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
5565 
5566  /* If we are in a DWO stub, process it and then read in the "real" CU/TU
5567  from the DWO file.
5568  Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
5569  DWO CU, that this test will fail (the attribute will not be present). */
5570  attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
5571  if (attr)
5572  {
5573  struct dwo_unit *dwo_unit;
5574  struct die_info *dwo_comp_unit_die;
5575 
5576  if (has_children)
5577  {
5579  _("compilation unit with DW_AT_GNU_dwo_name"
5580  " has children (offset 0x%x) [in module %s]"),
5581  this_cu->offset.sect_off, bfd_get_filename (abfd));
5582  }
5583  dwo_unit = lookup_dwo_unit (this_cu, comp_unit_die);
5584  if (dwo_unit != NULL)
5585  {
5586  if (read_cutu_die_from_dwo (this_cu, dwo_unit,
5587  abbrev_table != NULL,
5588  comp_unit_die, NULL,
5589  &reader, &info_ptr,
5590  &dwo_comp_unit_die, &has_children) == 0)
5591  {
5592  /* Dummy die. */
5593  do_cleanups (cleanups);
5594  return;
5595  }
5596  comp_unit_die = dwo_comp_unit_die;
5597  }
5598  else
5599  {
5600  /* Yikes, we couldn't find the rest of the DIE, we only have
5601  the stub. A complaint has already been logged. There's
5602  not much more we can do except pass on the stub DIE to
5603  die_reader_func. We don't want to throw an error on bad
5604  debug info. */
5605  }
5606  }
5607 
5608  /* All of the above is setup for this call. Yikes. */
5609  die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
5610 
5611  /* Done, clean up. */
5612  if (free_cu_cleanup != NULL)
5613  {
5614  if (keep)
5615  {
5616  /* We've successfully allocated this compilation unit. Let our
5617  caller clean it up when finished with it. */
5618  discard_cleanups (free_cu_cleanup);
5619 
5620  /* We can only discard free_cu_cleanup and all subsequent cleanups.
5621  So we have to manually free the abbrev table. */
5623 
5624  /* Link this CU into read_in_chain. */
5625  this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
5626  dwarf2_per_objfile->read_in_chain = this_cu;
5627  }
5628  else
5629  do_cleanups (free_cu_cleanup);
5630  }
5631 
5632  do_cleanups (cleanups);
5633 }
5634 
5635 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
5636  DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
5637  to have already done the lookup to find the DWO file).
5638 
5639  The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
5640  THIS_CU->is_debug_types, but nothing else.
5641 
5642  We fill in THIS_CU->length.
5643 
5644  WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
5645  linker) then DIE_READER_FUNC will not get called.
5646 
5647  THIS_CU->cu is always freed when done.
5648  This is done in order to not leave THIS_CU->cu in a state where we have
5649  to care whether it refers to the "main" CU or the DWO CU. */
5650 
5651 static void
5653  struct dwo_file *dwo_file,
5654  die_reader_func_ftype *die_reader_func,
5655  void *data)
5656 {
5657  struct objfile *objfile = dwarf2_per_objfile->objfile;
5658  struct dwarf2_section_info *section = this_cu->section;
5659  bfd *abfd = get_section_bfd_owner (section);
5660  struct dwarf2_section_info *abbrev_section;
5661  struct dwarf2_cu cu;
5662  const gdb_byte *begin_info_ptr, *info_ptr;
5663  struct die_reader_specs reader;
5664  struct cleanup *cleanups;
5665  struct die_info *comp_unit_die;
5666  int has_children;
5667 
5668  if (dwarf_die_debug)
5669  fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset 0x%x\n",
5670  this_cu->is_debug_types ? "type" : "comp",
5671  this_cu->offset.sect_off);
5672 
5673  gdb_assert (this_cu->cu == NULL);
5674 
5675  abbrev_section = (dwo_file != NULL
5676  ? &dwo_file->sections.abbrev
5677  : get_abbrev_section_for_cu (this_cu));
5678 
5679  /* This is cheap if the section is already read in. */
5680  dwarf2_read_section (objfile, section);
5681 
5682  init_one_comp_unit (&cu, this_cu);
5683 
5684  cleanups = make_cleanup (free_stack_comp_unit, &cu);
5685 
5686  begin_info_ptr = info_ptr = section->buffer + this_cu->offset.sect_off;
5687  info_ptr = read_and_check_comp_unit_head (&cu.header, section,
5688  abbrev_section, info_ptr,
5689  this_cu->is_debug_types);
5690 
5691  this_cu->length = get_cu_length (&cu.header);
5692 
5693  /* Skip dummy compilation units. */
5694  if (info_ptr >= begin_info_ptr + this_cu->length
5695  || peek_abbrev_code (abfd, info_ptr) == 0)
5696  {
5697  do_cleanups (cleanups);
5698  return;
5699  }
5700 
5701  dwarf2_read_abbrevs (&cu, abbrev_section);
5703 
5704  init_cu_die_reader (&reader, &cu, section, dwo_file);
5705  info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
5706 
5707  die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
5708 
5709  do_cleanups (cleanups);
5710 }
5711 
5712 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
5713  does not lookup the specified DWO file.
5714  This cannot be used to read DWO files.
5715 
5716  THIS_CU->cu is always freed when done.
5717  This is done in order to not leave THIS_CU->cu in a state where we have
5718  to care whether it refers to the "main" CU or the DWO CU.
5719  We can revisit this if the data shows there's a performance issue. */
5720 
5721 static void
5723  die_reader_func_ftype *die_reader_func,
5724  void *data)
5725 {
5726  init_cutu_and_read_dies_no_follow (this_cu, NULL, die_reader_func, data);
5727 }
5728 
5729 /* Type Unit Groups.
5730 
5731  Type Unit Groups are a way to collapse the set of all TUs (type units) into
5732  a more manageable set. The grouping is done by DW_AT_stmt_list entry
5733  so that all types coming from the same compilation (.o file) are grouped
5734  together. A future step could be to put the types in the same symtab as
5735  the CU the types ultimately came from. */
5736 
5737 static hashval_t
5738 hash_type_unit_group (const void *item)
5739 {
5740  const struct type_unit_group *tu_group = item;
5741 
5742  return hash_stmt_list_entry (&tu_group->hash);
5743 }
5744 
5745 static int
5746 eq_type_unit_group (const void *item_lhs, const void *item_rhs)
5747 {
5748  const struct type_unit_group *lhs = item_lhs;
5749  const struct type_unit_group *rhs = item_rhs;
5750 
5751  return eq_stmt_list_entry (&lhs->hash, &rhs->hash);
5752 }
5753 
5754 /* Allocate a hash table for type unit groups. */
5755 
5756 static htab_t
5758 {
5759  return htab_create_alloc_ex (3,
5762  NULL,
5763  &dwarf2_per_objfile->objfile->objfile_obstack,
5766 }
5767 
5768 /* Type units that don't have DW_AT_stmt_list are grouped into their own
5769  partial symtabs. We combine several TUs per psymtab to not let the size
5770  of any one psymtab grow too big. */
5771 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
5772 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
5773 
5774 /* Helper routine for get_type_unit_group.
5775  Create the type_unit_group object used to hold one or more TUs. */
5776 
5777 static struct type_unit_group *
5778 create_type_unit_group (struct dwarf2_cu *cu, sect_offset line_offset_struct)
5779 {
5780  struct objfile *objfile = dwarf2_per_objfile->objfile;
5781  struct dwarf2_per_cu_data *per_cu;
5782  struct type_unit_group *tu_group;
5783 
5784  tu_group = OBSTACK_ZALLOC (&objfile->objfile_obstack,
5785  struct type_unit_group);
5786  per_cu = &tu_group->per_cu;
5787  per_cu->objfile = objfile;
5788 
5789  if (dwarf2_per_objfile->using_index)
5790  {
5791  per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
5792  struct dwarf2_per_cu_quick_data);
5793  }
5794  else
5795  {
5796  unsigned int line_offset = line_offset_struct.sect_off;
5797  struct partial_symtab *pst;
5798  char *name;
5799 
5800  /* Give the symtab a useful name for debug purposes. */
5801  if ((line_offset & NO_STMT_LIST_TYPE_UNIT_PSYMTAB) != 0)
5802  name = xstrprintf ("<type_units_%d>",
5803  (line_offset & ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB));
5804  else
5805  name = xstrprintf ("<type_units_at_0x%x>", line_offset);
5806 
5807  pst = create_partial_symtab (per_cu, name);
5808  pst->anonymous = 1;
5809 
5810  xfree (name);
5811  }
5812 
5813  tu_group->hash.dwo_unit = cu->dwo_unit;
5814  tu_group->hash.line_offset = line_offset_struct;
5815 
5816  return tu_group;
5817 }
5818 
5819 /* Look up the type_unit_group for type unit CU, and create it if necessary.
5820  STMT_LIST is a DW_AT_stmt_list attribute. */
5821 
5822 static struct type_unit_group *
5823 get_type_unit_group (struct dwarf2_cu *cu, const struct attribute *stmt_list)
5824 {
5825  struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
5826  struct type_unit_group *tu_group;
5827  void **slot;
5828  unsigned int line_offset;
5829  struct type_unit_group type_unit_group_for_lookup;
5830 
5831  if (dwarf2_per_objfile->type_unit_groups == NULL)
5832  {
5833  dwarf2_per_objfile->type_unit_groups =
5835  }
5836 
5837  /* Do we need to create a new group, or can we use an existing one? */
5838 
5839  if (stmt_list)
5840  {
5841  line_offset = DW_UNSND (stmt_list);
5842  ++tu_stats->nr_symtab_sharers;
5843  }
5844  else
5845  {
5846  /* Ugh, no stmt_list. Rare, but we have to handle it.
5847  We can do various things here like create one group per TU or
5848  spread them over multiple groups to split up the expansion work.
5849  To avoid worst case scenarios (too many groups or too large groups)
5850  we, umm, group them in bunches. */
5851  line_offset = (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
5852  | (tu_stats->nr_stmt_less_type_units
5854  ++tu_stats->nr_stmt_less_type_units;
5855  }
5856 
5857  type_unit_group_for_lookup.hash.dwo_unit = cu->dwo_unit;
5858  type_unit_group_for_lookup.hash.line_offset.sect_off = line_offset;
5859  slot = htab_find_slot (dwarf2_per_objfile->type_unit_groups,
5860  &type_unit_group_for_lookup, INSERT);
5861  if (*slot != NULL)
5862  {
5863  tu_group = *slot;
5864  gdb_assert (tu_group != NULL);
5865  }
5866  else
5867  {
5868  sect_offset line_offset_struct;
5869 
5870  line_offset_struct.sect_off = line_offset;
5871  tu_group = create_type_unit_group (cu, line_offset_struct);
5872  *slot = tu_group;
5873  ++tu_stats->nr_symtabs;
5874  }
5875 
5876  return tu_group;
5877 }
5878 
5879 /* Partial symbol tables. */
5880 
5881 /* Create a psymtab named NAME and assign it to PER_CU.
5882 
5883  The caller must fill in the following details:
5884  dirname, textlow, texthigh. */
5885 
5886 static struct partial_symtab *
5887 create_partial_symtab (struct dwarf2_per_cu_data *per_cu, const char *name)
5888 {
5889  struct objfile *objfile = per_cu->objfile;
5890  struct partial_symtab *pst;
5891 
5892  pst = start_psymtab_common (objfile, name, 0,
5893  objfile->global_psymbols.next,
5894  objfile->static_psymbols.next);
5895 
5896  pst->psymtabs_addrmap_supported = 1;
5897 
5898  /* This is the glue that links PST into GDB's symbol API. */
5899  pst->read_symtab_private = per_cu;
5901  per_cu->v.psymtab = pst;
5902 
5903  return pst;
5904 }
5905 
5906 /* The DATA object passed to process_psymtab_comp_unit_reader has this
5907  type. */
5908 
5910 {
5911  /* True if we are reading a DW_TAG_partial_unit. */
5912 
5914 
5915  /* The "pretend" language that is used if the CU doesn't declare a
5916  language. */
5917 
5918  enum language pretend_language;
5919 };
5920 
5921 /* die_reader_func for process_psymtab_comp_unit. */
5922 
5923 static void
5925  const gdb_byte *info_ptr,
5926  struct die_info *comp_unit_die,
5927  int has_children,
5928  void *data)
5929 {
5930  struct dwarf2_cu *cu = reader->cu;
5931  struct objfile *objfile = cu->objfile;
5932  struct gdbarch *gdbarch = get_objfile_arch (objfile);
5933  struct dwarf2_per_cu_data *per_cu = cu->per_cu;
5934  struct attribute *attr;
5935  CORE_ADDR baseaddr;
5936  CORE_ADDR best_lowpc = 0, best_highpc = 0;
5937  struct partial_symtab *pst;
5938  int has_pc_info;
5939  const char *filename;
5940  struct process_psymtab_comp_unit_data *info = data;
5941 
5942  if (comp_unit_die->tag == DW_TAG_partial_unit && !info->want_partial_unit)
5943  return;
5944 
5945  gdb_assert (! per_cu->is_debug_types);
5946 
5947  prepare_one_comp_unit (cu, comp_unit_die, info->pretend_language);
5948 
5949  cu->list_in_scope = &file_symbols;
5950 
5951  /* Allocate a new partial symbol table structure. */
5952  attr = dwarf2_attr (comp_unit_die, DW_AT_name, cu);
5953  if (attr == NULL || !DW_STRING (attr))
5954  filename = "";
5955  else
5956  filename = DW_STRING (attr);
5957 
5958  pst = create_partial_symtab (per_cu, filename);
5959 
5960  /* This must be done before calling dwarf2_build_include_psymtabs. */
5961  attr = dwarf2_attr (comp_unit_die, DW_AT_comp_dir, cu);
5962  if (attr != NULL)
5963  pst->dirname = DW_STRING (attr);
5964 
5965  baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
5966 
5967  dwarf2_find_base_address (comp_unit_die, cu);
5968 
5969  /* Possibly set the default values of LOWPC and HIGHPC from
5970  `DW_AT_ranges'. */
5971  has_pc_info = dwarf2_get_pc_bounds (comp_unit_die, &best_lowpc,
5972  &best_highpc, cu, pst);
5973  if (has_pc_info == 1 && best_lowpc < best_highpc)
5974  /* Store the contiguous range if it is not empty; it can be empty for
5975  CUs with no code. */
5977  gdbarch_adjust_dwarf2_addr (gdbarch,
5978  best_lowpc + baseaddr),
5979  gdbarch_adjust_dwarf2_addr (gdbarch,
5980  best_highpc + baseaddr) - 1,
5981  pst);
5982 
5983  /* Check if comp unit has_children.
5984  If so, read the rest of the partial symbols from this comp unit.
5985  If not, there's no more debug_info for this comp unit. */
5986  if (has_children)
5987  {
5988  struct partial_die_info *first_die;
5990 
5991  lowpc = ((CORE_ADDR) -1);
5992  highpc = ((CORE_ADDR) 0);
5993 
5994  first_die = load_partial_dies (reader, info_ptr, 1);
5995 
5996  scan_partial_symbols (first_die, &lowpc, &highpc,
5997  ! has_pc_info, cu);
5998 
5999  /* If we didn't find a lowpc, set it to highpc to avoid
6000  complaints from `maint check'. */
6001  if (lowpc == ((CORE_ADDR) -1))
6002  lowpc = highpc;
6003 
6004  /* If the compilation unit didn't have an explicit address range,
6005  then use the information extracted from its child dies. */
6006  if (! has_pc_info)
6007  {
6008  best_lowpc = lowpc;
6009  best_highpc = highpc;
6010  }
6011  }
6012  pst->textlow = gdbarch_adjust_dwarf2_addr (gdbarch, best_lowpc + baseaddr);
6013  pst->texthigh = gdbarch_adjust_dwarf2_addr (gdbarch, best_highpc + baseaddr);
6014 
6015  pst->n_global_syms = objfile->global_psymbols.next -
6016  (objfile->global_psymbols.list + pst->globals_offset);
6017  pst->n_static_syms = objfile->static_psymbols.next -
6018  (objfile->static_psymbols.list + pst->statics_offset);
6019  sort_pst_symbols (objfile, pst);
6020 
6021  if (!VEC_empty (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs))
6022  {
6023  int i;
6024  int len = VEC_length (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
6025  struct dwarf2_per_cu_data *iter;
6026 
6027  /* Fill in 'dependencies' here; we fill in 'users' in a
6028  post-pass. */
6029  pst->number_of_dependencies = len;
6030  pst->dependencies = obstack_alloc (&objfile->objfile_obstack,
6031  len * sizeof (struct symtab *));
6032  for (i = 0;
6033  VEC_iterate (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
6034  i, iter);
6035  ++i)
6036  pst->dependencies[i] = iter->v.psymtab;
6037 
6038  VEC_free (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
6039  }
6040 
6041  /* Get the list of files included in the current compilation unit,
6042  and build a psymtab for each of them. */
6043  dwarf2_build_include_psymtabs (cu, comp_unit_die, pst);
6044 
6045  if (dwarf_read_debug)
6046  {
6047  struct gdbarch *gdbarch = get_objfile_arch (objfile);
6048 
6050  "Psymtab for %s unit @0x%x: %s - %s"
6051  ", %d global, %d static syms\n",
6052  per_cu->is_debug_types ? "type" : "comp",
6053  per_cu->offset.sect_off,
6054  paddress (gdbarch, pst->textlow),
6055  paddress (gdbarch, pst->texthigh),
6056  pst->n_global_syms, pst->n_static_syms);
6057  }
6058 }
6059 
6060 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
6061  Process compilation unit THIS_CU for a psymtab. */
6062 
6063 static void
6065  int want_partial_unit,
6066  enum language pretend_language)
6067 {
6068  struct process_psymtab_comp_unit_data info;
6069 
6070  /* If this compilation unit was already read in, free the
6071  cached copy in order to read it in again. This is
6072  necessary because we skipped some symbols when we first
6073  read in the compilation unit (see load_partial_dies).
6074  This problem could be avoided, but the benefit is unclear. */
6075  if (this_cu->cu != NULL)
6076  free_one_cached_comp_unit (this_cu);
6077 
6078  gdb_assert (! this_cu->is_debug_types);
6081  init_cutu_and_read_dies (this_cu, NULL, 0, 0,
6083  &info);
6084 
6085  /* Age out any secondary CUs. */
6087 }
6088 
6089 /* Reader function for build_type_psymtabs. */
6090 
6091 static void
6093  const gdb_byte *info_ptr,
6094  struct die_info *type_unit_die,
6095  int has_children,
6096  void *data)
6097 {
6098  struct objfile *objfile = dwarf2_per_objfile->objfile;
6099  struct dwarf2_cu *cu = reader->cu;
6100  struct dwarf2_per_cu_data *per_cu = cu->per_cu;
6101  struct signatured_type *sig_type;
6102  struct type_unit_group *tu_group;
6103  struct attribute *attr;
6104  struct partial_die_info *first_die;
6106  struct partial_symtab *pst;
6107 
6108  gdb_assert (data == NULL);
6109  gdb_assert (per_cu->is_debug_types);
6110  sig_type = (struct signatured_type *) per_cu;
6111 
6112  if (! has_children)
6113  return;
6114 
6115  attr = dwarf2_attr_no_follow (type_unit_die, DW_AT_stmt_list);
6116  tu_group = get_type_unit_group (cu, attr);
6117 
6118  VEC_safe_push (sig_type_ptr, tu_group->tus, sig_type);
6119 
6120  prepare_one_comp_unit (cu, type_unit_die, language_minimal);
6121  cu->list_in_scope = &file_symbols;
6122  pst = create_partial_symtab (per_cu, "");
6123  pst->anonymous = 1;
6124 
6125  first_die = load_partial_dies (reader, info_ptr, 1);
6126 
6127  lowpc = (CORE_ADDR) -1;
6128  highpc = (CORE_ADDR) 0;
6129  scan_partial_symbols (first_die, &lowpc, &highpc, 0, cu);
6130 
6131  pst->n_global_syms = objfile->global_psymbols.next -
6132  (objfile->global_psymbols.list + pst->globals_offset);
6133  pst->n_static_syms = objfile->static_psymbols.next -
6134  (objfile->static_psymbols.list + pst->statics_offset);
6135  sort_pst_symbols (objfile, pst);
6136 }
6137 
6138 /* Struct used to sort TUs by their abbreviation table offset. */
6139 
6141 {
6144 };
6145 
6146 /* Helper routine for build_type_psymtabs_1, passed to qsort. */
6147 
6148 static int
6149 sort_tu_by_abbrev_offset (const void *ap, const void *bp)
6150 {
6151  const struct tu_abbrev_offset * const *a = ap;
6152  const struct tu_abbrev_offset * const *b = bp;
6153  unsigned int aoff = (*a)->abbrev_offset.sect_off;
6154  unsigned int boff = (*b)->abbrev_offset.sect_off;
6155 
6156  return (aoff > boff) - (aoff < boff);
6157 }
6158 
6159 /* Efficiently read all the type units.
6160  This does the bulk of the work for build_type_psymtabs.
6161 
6162  The efficiency is because we sort TUs by the abbrev table they use and
6163  only read each abbrev table once. In one program there are 200K TUs
6164  sharing 8K abbrev tables.
6165 
6166  The main purpose of this function is to support building the
6167  dwarf2_per_objfile->type_unit_groups table.
6168  TUs typically share the DW_AT_stmt_list of the CU they came from, so we
6169  can collapse the search space by grouping them by stmt_list.
6170  The savings can be significant, in the same program from above the 200K TUs
6171  share 8K stmt_list tables.
6172 
6173  FUNC is expected to call get_type_unit_group, which will create the
6174  struct type_unit_group if necessary and add it to
6175  dwarf2_per_objfile->type_unit_groups. */
6176 
6177 static void
6179 {
6180  struct objfile *objfile = dwarf2_per_objfile->objfile;
6181  struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
6182  struct cleanup *cleanups;
6183  struct abbrev_table *abbrev_table;
6184  sect_offset abbrev_offset;
6185  struct tu_abbrev_offset *sorted_by_abbrev;
6186  struct type_unit_group **iter;
6187  int i;
6188 
6189  /* It's up to the caller to not call us multiple times. */
6190  gdb_assert (dwarf2_per_objfile->type_unit_groups == NULL);
6191 
6192  if (dwarf2_per_objfile->n_type_units == 0)
6193  return;
6194 
6195  /* TUs typically share abbrev tables, and there can be way more TUs than
6196  abbrev tables. Sort by abbrev table to reduce the number of times we
6197  read each abbrev table in.
6198  Alternatives are to punt or to maintain a cache of abbrev tables.
6199  This is simpler and efficient enough for now.
6200 
6201  Later we group TUs by their DW_AT_stmt_list value (as this defines the
6202  symtab to use). Typically TUs with the same abbrev offset have the same
6203  stmt_list value too so in practice this should work well.
6204 
6205  The basic algorithm here is:
6206 
6207  sort TUs by abbrev table
6208  for each TU with same abbrev table:
6209  read abbrev table if first user
6210  read TU top level DIE
6211  [IWBN if DWO skeletons had DW_AT_stmt_list]
6212  call FUNC */
6213 
6214  if (dwarf_read_debug)
6215  fprintf_unfiltered (gdb_stdlog, "Building type unit groups ...\n");
6216 
6217  /* Sort in a separate table to maintain the order of all_type_units
6218  for .gdb_index: TU indices directly index all_type_units. */
6219  sorted_by_abbrev = XNEWVEC (struct tu_abbrev_offset,
6220  dwarf2_per_objfile->n_type_units);
6221  for (i = 0; i < dwarf2_per_objfile->n_type_units; ++i)
6222  {
6223  struct signatured_type *sig_type = dwarf2_per_objfile->all_type_units[i];
6224 
6225  sorted_by_abbrev[i].sig_type = sig_type;
6226  sorted_by_abbrev[i].abbrev_offset =
6227  read_abbrev_offset (sig_type->per_cu.section,
6228  sig_type->per_cu.offset);
6229  }
6230  cleanups = make_cleanup (xfree, sorted_by_abbrev);
6231  qsort (sorted_by_abbrev, dwarf2_per_objfile->n_type_units,
6232  sizeof (struct tu_abbrev_offset), sort_tu_by_abbrev_offset);
6233 
6234  abbrev_offset.sect_off = ~(unsigned) 0;
6235  abbrev_table = NULL;
6236  make_cleanup (abbrev_table_free_cleanup, &abbrev_table);
6237 
6238  for (i = 0; i < dwarf2_per_objfile->n_type_units; ++i)
6239  {
6240  const struct tu_abbrev_offset *tu = &sorted_by_abbrev[i];
6241 
6242  /* Switch to the next abbrev table if necessary. */
6243  if (abbrev_table == NULL
6244  || tu->abbrev_offset.sect_off != abbrev_offset.sect_off)
6245  {
6246  if (abbrev_table != NULL)
6247  {
6248  abbrev_table_free (abbrev_table);
6249  /* Reset to NULL in case abbrev_table_read_table throws
6250  an error: abbrev_table_free_cleanup will get called. */
6251  abbrev_table = NULL;
6252  }
6253  abbrev_offset = tu->abbrev_offset;
6254  abbrev_table =
6255  abbrev_table_read_table (&dwarf2_per_objfile->abbrev,
6256  abbrev_offset);
6257  ++tu_stats->nr_uniq_abbrev_tables;
6258  }
6259 
6260  init_cutu_and_read_dies (&tu->sig_type->per_cu, abbrev_table, 0, 0,
6262  }
6263 
6264  do_cleanups (cleanups);
6265 }
6266 
6267 /* Print collected type unit statistics. */
6268 
6269 static void
6271 {
6272  struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
6273 
6274  fprintf_unfiltered (gdb_stdlog, "Type unit statistics:\n");
6275  fprintf_unfiltered (gdb_stdlog, " %d TUs\n",
6276  dwarf2_per_objfile->n_type_units);
6277  fprintf_unfiltered (gdb_stdlog, " %d uniq abbrev tables\n",
6278  tu_stats->nr_uniq_abbrev_tables);
6279  fprintf_unfiltered (gdb_stdlog, " %d symtabs from stmt_list entries\n",
6280  tu_stats->nr_symtabs);
6281  fprintf_unfiltered (gdb_stdlog, " %d symtab sharers\n",
6282  tu_stats->nr_symtab_sharers);
6283  fprintf_unfiltered (gdb_stdlog, " %d type units without a stmt_list\n",
6284  tu_stats->nr_stmt_less_type_units);
6285  fprintf_unfiltered (gdb_stdlog, " %d all_type_units reallocs\n",
6286  tu_stats->nr_all_type_units_reallocs);
6287 }
6288 
6289 /* Traversal function for build_type_psymtabs. */
6290 
6291 static int
6292 build_type_psymtab_dependencies (void **slot, void *info)
6293 {
6294  struct objfile *objfile = dwarf2_per_objfile->objfile;
6295  struct type_unit_group *tu_group = (struct type_unit_group *) *slot;
6296  struct dwarf2_per_cu_data *per_cu = &tu_group->per_cu;
6297  struct partial_symtab *pst = per_cu->v.psymtab;
6298  int len = VEC_length (sig_type_ptr, tu_group->tus);
6299  struct signatured_type *iter;
6300  int i;
6301 
6302  gdb_assert (len > 0);
6303  gdb_assert (IS_TYPE_UNIT_GROUP (per_cu));
6304 
6305  pst->number_of_dependencies = len;
6306  pst->dependencies = obstack_alloc (&objfile->objfile_obstack,
6307  len * sizeof (struct psymtab *));
6308  for (i = 0;
6309  VEC_iterate (sig_type_ptr, tu_group->tus, i, iter);
6310  ++i)
6311  {
6313  pst->dependencies[i] = iter->per_cu.v.psymtab;
6314  iter->type_unit_group = tu_group;
6315  }
6316 
6317  VEC_free (sig_type_ptr, tu_group->tus);
6318 
6319  return 1;
6320 }
6321 
6322 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
6323  Build partial symbol tables for the .debug_types comp-units. */
6324 
6325 static void
6326 build_type_psymtabs (struct objfile *objfile)
6327 {
6328  if (! create_all_type_units (objfile))
6329  return;
6330 
6332 }
6333 
6334 /* Traversal function for process_skeletonless_type_unit.
6335  Read a TU in a DWO file and build partial symbols for it. */
6336 
6337 static int
6338 process_skeletonless_type_unit (void **slot, void *info)
6339 {
6340  struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
6341  struct objfile *objfile = info;
6342  struct signatured_type find_entry, *entry;
6343 
6344  /* If this TU doesn't exist in the global table, add it and read it in. */
6345 
6346  if (dwarf2_per_objfile->signatured_types == NULL)
6347  {
6348  dwarf2_per_objfile->signatured_types
6349  = allocate_signatured_type_table (objfile);
6350  }
6351 
6352  find_entry.signature = dwo_unit->signature;
6353  slot = htab_find_slot (dwarf2_per_objfile->signatured_types, &find_entry,
6354  INSERT);
6355  /* If we've already seen this type there's nothing to do. What's happening
6356  is we're doing our own version of comdat-folding here. */
6357  if (*slot != NULL)
6358  return 1;
6359 
6360  /* This does the job that create_all_type_units would have done for
6361  this TU. */
6362  entry = add_type_unit (dwo_unit->signature, slot);
6363  fill_in_sig_entry_from_dwo_entry (objfile, entry, dwo_unit);
6364  *slot = entry;
6365 
6366  /* This does the job that build_type_psymtabs_1 would have done. */
6367  init_cutu_and_read_dies (&entry->per_cu, NULL, 0, 0,
6369 
6370  return 1;
6371 }
6372 
6373 /* Traversal function for process_skeletonless_type_units. */
6374 
6375 static int
6377 {
6378  struct dwo_file *dwo_file = (struct dwo_file *) *slot;
6379 
6380  if (dwo_file->tus != NULL)
6381  {
6382  htab_traverse_noresize (dwo_file->tus,
6384  }
6385 
6386  return 1;
6387 }
6388 
6389 /* Scan all TUs of DWO files, verifying we've processed them.
6390  This is needed in case a TU was emitted without its skeleton.
6391  Note: This can't be done until we know what all the DWO files are. */
6392 
6393 static void
6394 process_skeletonless_type_units (struct objfile *objfile)
6395 {
6396  /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
6397  if (get_dwp_file () == NULL
6398  && dwarf2_per_objfile->dwo_files != NULL)
6399  {
6400  htab_traverse_noresize (dwarf2_per_objfile->dwo_files,
6402  objfile);
6403  }
6404 }
6405 
6406 /* A cleanup function that clears objfile's psymtabs_addrmap field. */
6407 
6408 static void
6410 {
6411  struct objfile *objfile = o;
6412 
6413  objfile->psymtabs_addrmap = NULL;
6414 }
6415 
6416 /* Compute the 'user' field for each psymtab in OBJFILE. */
6417 
6418 static void
6419 set_partial_user (struct objfile *objfile)
6420 {
6421  int i;
6422 
6423  for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
6424  {
6425  struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
6426  struct partial_symtab *pst = per_cu->v.psymtab;
6427  int j;
6428 
6429  if (pst == NULL)
6430  continue;
6431 
6432  for (j = 0; j < pst->number_of_dependencies; ++j)
6433  {
6434  /* Set the 'user' field only if it is not already set. */
6435  if (pst->dependencies[j]->user == NULL)
6436  pst->dependencies[j]->user = pst;
6437  }
6438  }
6439 }
6440 
6441 /* Build the partial symbol table by doing a quick pass through the
6442  .debug_info and .debug_abbrev sections. */
6443 
6444 static void
6445 dwarf2_build_psymtabs_hard (struct objfile *objfile)
6446 {
6447  struct cleanup *back_to, *addrmap_cleanup;
6448  struct obstack temp_obstack;
6449  int i;
6450 
6451  if (dwarf_read_debug)
6452  {
6453  fprintf_unfiltered (gdb_stdlog, "Building psymtabs of objfile %s ...\n",
6454  objfile_name (objfile));
6455  }
6456 
6457  dwarf2_per_objfile->reading_partial_symbols = 1;
6458 
6459  dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
6460 
6461  /* Any cached compilation units will be linked by the per-objfile
6462  read_in_chain. Make sure to free them when we're done. */
6463  back_to = make_cleanup (free_cached_comp_units, NULL);
6464 
6465  build_type_psymtabs (objfile);
6466 
6467  create_all_comp_units (objfile);
6468 
6469  /* Create a temporary address map on a temporary obstack. We later
6470  copy this to the final obstack. */
6471  obstack_init (&temp_obstack);
6472  make_cleanup_obstack_free (&temp_obstack);
6473  objfile->psymtabs_addrmap = addrmap_create_mutable (&temp_obstack);
6474  addrmap_cleanup = make_cleanup (psymtabs_addrmap_cleanup, objfile);
6475 
6476  for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
6477  {
6478  struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
6479 
6481  }
6482 
6483  /* This has to wait until we read the CUs, we need the list of DWOs. */
6485 
6486  /* Now that all TUs have been processed we can fill in the dependencies. */
6487  if (dwarf2_per_objfile->type_unit_groups != NULL)
6488  {
6489  htab_traverse_noresize (dwarf2_per_objfile->type_unit_groups,
6491  }
6492 
6493  if (dwarf_read_debug)
6494  print_tu_stats ();
6495 
6496  set_partial_user (objfile);
6497 
6499  &objfile->objfile_obstack);
6500  discard_cleanups (addrmap_cleanup);
6501 
6502  do_cleanups (back_to);
6503 
6504  if (dwarf_read_debug)
6505  fprintf_unfiltered (gdb_stdlog, "Done building psymtabs of %s\n",
6506  objfile_name (objfile));
6507 }
6508 
6509 /* die_reader_func for load_partial_comp_unit. */
6510 
6511 static void
6513  const gdb_byte *info_ptr,
6514  struct die_info *comp_unit_die,
6515  int has_children,
6516  void *data)
6517 {
6518  struct dwarf2_cu *cu = reader->cu;
6519 
6520  prepare_one_comp_unit (cu, comp_unit_die, language_minimal);
6521 
6522  /* Check if comp unit has_children.
6523  If so, read the rest of the partial symbols from this comp unit.
6524  If not, there's no more debug_info for this comp unit. */
6525  if (has_children)
6526  load_partial_dies (reader, info_ptr, 0);
6527 }
6528 
6529 /* Load the partial DIEs for a secondary CU into memory.
6530  This is also used when rereading a primary CU with load_all_dies. */
6531 
6532 static void
6534 {
6535  init_cutu_and_read_dies (this_cu, NULL, 1, 1,
6537 }
6538 
6539 static void
6540 read_comp_units_from_section (struct objfile *objfile,
6541  struct dwarf2_section_info *section,
6542  unsigned int is_dwz,
6543  int *n_allocated,
6544  int *n_comp_units,
6545  struct dwarf2_per_cu_data ***all_comp_units)
6546 {
6547  const gdb_byte *info_ptr;
6548  bfd *abfd = get_section_bfd_owner (section);
6549 
6550  if (dwarf_read_debug)
6551  fprintf_unfiltered (gdb_stdlog, "Reading %s for %s\n",
6552  get_section_name (section),
6553  get_section_file_name (section));
6554 
6555  dwarf2_read_section (objfile, section);
6556 
6557  info_ptr = section->buffer;
6558 
6559  while (info_ptr < section->buffer + section->size)
6560  {
6561  unsigned int length, initial_length_size;
6562  struct dwarf2_per_cu_data *this_cu;
6564 
6565  offset.sect_off = info_ptr - section->buffer;
6566 
6567  /* Read just enough information to find out where the next
6568  compilation unit is. */
6569  length = read_initial_length (abfd, info_ptr, &initial_length_size);
6570 
6571  /* Save the compilation unit for later lookup. */
6572  this_cu = obstack_alloc (&objfile->objfile_obstack,
6573  sizeof (struct dwarf2_per_cu_data));
6574  memset (this_cu, 0, sizeof (*this_cu));
6575  this_cu->offset = offset;
6576  this_cu->length = length + initial_length_size;
6577  this_cu->is_dwz = is_dwz;
6578  this_cu->objfile = objfile;
6579  this_cu->section = section;
6580 
6581  if (*n_comp_units == *n_allocated)
6582  {
6583  *n_allocated *= 2;
6584  *all_comp_units = xrealloc (*all_comp_units,
6585  *n_allocated
6586  * sizeof (struct dwarf2_per_cu_data *));
6587  }
6588  (*all_comp_units)[*n_comp_units] = this_cu;
6589  ++*n_comp_units;
6590 
6591  info_ptr = info_ptr + this_cu->length;
6592  }
6593 }
6594 
6595 /* Create a list of all compilation units in OBJFILE.
6596  This is only done for -readnow and building partial symtabs. */
6597 
6598 static void
6599 create_all_comp_units (struct objfile *objfile)
6600 {
6601  int n_allocated;
6602  int n_comp_units;
6603  struct dwarf2_per_cu_data **all_comp_units;
6604  struct dwz_file *dwz;
6605 
6606  n_comp_units = 0;
6607  n_allocated = 10;
6608  all_comp_units = xmalloc (n_allocated
6609  * sizeof (struct dwarf2_per_cu_data *));
6610 
6611  read_comp_units_from_section (objfile, &dwarf2_per_objfile->info, 0,
6612  &n_allocated, &n_comp_units, &all_comp_units);
6613 
6614  dwz = dwarf2_get_dwz_file ();
6615  if (dwz != NULL)
6616  read_comp_units_from_section (objfile, &dwz->info, 1,
6617  &n_allocated, &n_comp_units,
6618  &all_comp_units);
6619 
6620  dwarf2_per_objfile->all_comp_units
6621  = obstack_alloc (&objfile->objfile_obstack,
6622  n_comp_units * sizeof (struct dwarf2_per_cu_data *));
6623  memcpy (dwarf2_per_objfile->all_comp_units, all_comp_units,
6624  n_comp_units * sizeof (struct dwarf2_per_cu_data *));
6625  xfree (all_comp_units);
6626  dwarf2_per_objfile->n_comp_units = n_comp_units;
6627 }
6628 
6629 /* Process all loaded DIEs for compilation unit CU, starting at
6630  FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
6631  unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
6632  DW_AT_ranges). See the comments of add_partial_subprogram on how
6633  SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
6634 
6635 static void
6637  CORE_ADDR *highpc, int set_addrmap,
6638  struct dwarf2_cu *cu)
6639 {
6640  struct partial_die_info *pdi;
6641 
6642  /* Now, march along the PDI's, descending into ones which have
6643  interesting children but skipping the children of the other ones,
6644  until we reach the end of the compilation unit. */
6645 
6646  pdi = first_die;
6647 
6648  while (pdi != NULL)
6649  {
6650  fixup_partial_die (pdi, cu);
6651 
6652  /* Anonymous namespaces or modules have no name but have interesting
6653  children, so we need to look at them. Ditto for anonymous
6654  enums. */
6655 
6656  if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
6657  || pdi->tag == DW_TAG_module || pdi->tag == DW_TAG_enumeration_type
6658  || pdi->tag == DW_TAG_imported_unit)
6659  {
6660  switch (pdi->tag)
6661  {
6662  case DW_TAG_subprogram:
6663  add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
6664  break;
6665  case DW_TAG_constant:
6666  case DW_TAG_variable:
6667  case DW_TAG_typedef:
6668  case DW_TAG_union_type:
6669  if (!pdi->is_declaration)
6670  {
6671  add_partial_symbol (pdi, cu);
6672  }
6673  break;
6674  case DW_TAG_class_type:
6675  case DW_TAG_interface_type:
6676  case DW_TAG_structure_type:
6677  if (!pdi->is_declaration)
6678  {
6679  add_partial_symbol (pdi, cu);
6680  }
6681  break;
6682  case DW_TAG_enumeration_type:
6683  if (!pdi->is_declaration)
6684  add_partial_enumeration (pdi, cu);
6685  break;
6686  case DW_TAG_base_type:
6687  case DW_TAG_subrange_type:
6688  /* File scope base type definitions are added to the partial
6689  symbol table. */
6690  add_partial_symbol (pdi, cu);
6691  break;
6692  case DW_TAG_namespace:
6693  add_partial_namespace (pdi, lowpc, highpc, set_addrmap, cu);
6694  break;
6695  case DW_TAG_module:
6696  add_partial_module (pdi, lowpc, highpc, set_addrmap, cu);
6697  break;
6698  case DW_TAG_imported_unit:
6699  {
6700  struct dwarf2_per_cu_data *per_cu;
6701 
6702  /* For now we don't handle imported units in type units. */
6703  if (cu->per_cu->is_debug_types)
6704  {
6705  error (_("Dwarf Error: DW_TAG_imported_unit is not"
6706  " supported in type units [in module %s]"),
6707  objfile_name (cu->objfile));
6708  }
6709 
6710  per_cu = dwarf2_find_containing_comp_unit (pdi->d.offset,
6711  pdi->is_dwz,
6712  cu->objfile);
6713 
6714  /* Go read the partial unit, if needed. */
6715  if (per_cu->v.psymtab == NULL)
6716  process_psymtab_comp_unit (per_cu, 1, cu->language);
6717 
6718  VEC_safe_push (dwarf2_per_cu_ptr,
6719  cu->per_cu->imported_symtabs, per_cu);
6720  }
6721  break;
6722  case DW_TAG_imported_declaration:
6723  add_partial_symbol (pdi, cu);
6724  break;
6725  default:
6726  break;
6727  }
6728  }
6729 
6730  /* If the die has a sibling, skip to the sibling. */
6731 
6732  pdi = pdi->die_sibling;
6733  }
6734 }
6735 
6736 /* Functions used to compute the fully scoped name of a partial DIE.
6737 
6738  Normally, this is simple. For C++, the parent DIE's fully scoped
6739  name is concatenated with "::" and the partial DIE's name. For
6740  Java, the same thing occurs except that "." is used instead of "::".
6741  Enumerators are an exception; they use the scope of their parent
6742  enumeration type, i.e. the name of the enumeration type is not
6743  prepended to the enumerator.
6744 
6745  There are two complexities. One is DW_AT_specification; in this
6746  case "parent" means the parent of the target of the specification,
6747  instead of the direct parent of the DIE. The other is compilers
6748  which do not emit DW_TAG_namespace; in this case we try to guess
6749  the fully qualified name of structure types from their members'
6750  linkage names. This must be done using the DIE's children rather
6751  than the children of any DW_AT_specification target. We only need
6752  to do this for structures at the top level, i.e. if the target of
6753  any DW_AT_specification (if any; otherwise the DIE itself) does not
6754  have a parent. */
6755 
6756 /* Compute the scope prefix associated with PDI's parent, in
6757  compilation unit CU. The result will be allocated on CU's
6758  comp_unit_obstack, or a copy of the already allocated PDI->NAME
6759  field. NULL is returned if no prefix is necessary. */
6760 static const char *
6762  struct dwarf2_cu *cu)
6763 {
6764  const char *grandparent_scope;
6765  struct partial_die_info *parent, *real_pdi;
6766 
6767  /* We need to look at our parent DIE; if we have a DW_AT_specification,
6768  then this means the parent of the specification DIE. */
6769 
6770  real_pdi = pdi;
6771  while (real_pdi->has_specification)
6772  real_pdi = find_partial_die (real_pdi->spec_offset,
6773  real_pdi->spec_is_dwz, cu);
6774 
6775  parent = real_pdi->die_parent;
6776  if (parent == NULL)
6777  return NULL;
6778 
6779  if (parent->scope_set)
6780  return parent->scope;
6781 
6782  fixup_partial_die (parent, cu);
6783 
6784  grandparent_scope = partial_die_parent_scope (parent, cu);
6785 
6786  /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
6787  DW_TAG_namespace DIEs with a name of "::" for the global namespace.
6788  Work around this problem here. */
6789  if (cu->language == language_cplus
6790  && parent->tag == DW_TAG_namespace
6791  && strcmp (parent->name, "::") == 0
6792  && grandparent_scope == NULL)
6793  {
6794  parent->scope = NULL;
6795  parent->scope_set = 1;
6796  return NULL;
6797  }
6798 
6799  if (pdi->tag == DW_TAG_enumerator)
6800  /* Enumerators should not get the name of the enumeration as a prefix. */
6801  parent->scope = grandparent_scope;
6802  else if (parent->tag == DW_TAG_namespace
6803  || parent->tag == DW_TAG_module
6804  || parent->tag == DW_TAG_structure_type
6805  || parent->tag == DW_TAG_class_type
6806  || parent->tag == DW_TAG_interface_type
6807  || parent->tag == DW_TAG_union_type
6808  || parent->tag == DW_TAG_enumeration_type)
6809  {
6810  if (grandparent_scope == NULL)
6811  parent->scope = parent->name;
6812  else
6813  parent->scope = typename_concat (&cu->comp_unit_obstack,
6814  grandparent_scope,
6815  parent->name, 0, cu);
6816  }
6817  else
6818  {
6819  /* FIXME drow/2004-04-01: What should we be doing with
6820  function-local names? For partial symbols, we should probably be
6821  ignoring them. */
6823  _("unhandled containing DIE tag %d for DIE at %d"),
6824  parent->tag, pdi->offset.sect_off);
6825  parent->scope = grandparent_scope;
6826  }
6827 
6828  parent->scope_set = 1;
6829  return parent->scope;
6830 }
6831 
6832 /* Return the fully scoped name associated with PDI, from compilation unit
6833  CU. The result will be allocated with malloc. */
6834 
6835 static char *
6837  struct dwarf2_cu *cu)
6838 {
6839  const char *parent_scope;
6840 
6841  /* If this is a template instantiation, we can not work out the
6842  template arguments from partial DIEs. So, unfortunately, we have
6843  to go through the full DIEs. At least any work we do building
6844  types here will be reused if full symbols are loaded later. */
6845  if (pdi->has_template_arguments)
6846  {
6847  fixup_partial_die (pdi, cu);
6848 
6849  if (pdi->name != NULL && strchr (pdi->name, '<') == NULL)
6850  {
6851  struct die_info *die;
6852  struct attribute attr;
6853  struct dwarf2_cu *ref_cu = cu;
6854 
6855  /* DW_FORM_ref_addr is using section offset. */
6856  attr.name = 0;
6857  attr.form = DW_FORM_ref_addr;
6858  attr.u.unsnd = pdi->offset.sect_off;
6859  die = follow_die_ref (NULL, &attr, &ref_cu);
6860 
6861  return xstrdup (dwarf2_full_name (NULL, die, ref_cu));
6862  }
6863  }
6864 
6865  parent_scope = partial_die_parent_scope (pdi, cu);
6866  if (parent_scope == NULL)
6867  return NULL;
6868  else
6869  return typename_concat (NULL, parent_scope, pdi->name, 0, cu);
6870 }
6871 
6872 static void
6874 {
6875  struct objfile *objfile = cu->objfile;
6876  struct gdbarch *gdbarch = get_objfile_arch (objfile);
6877  CORE_ADDR addr = 0;
6878  const char *actual_name = NULL;
6879  CORE_ADDR baseaddr;
6880  char *built_actual_name;
6881 
6882  baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6883 
6884  built_actual_name = partial_die_full_name (pdi, cu);
6885  if (built_actual_name != NULL)
6886  actual_name = built_actual_name;
6887 
6888  if (actual_name == NULL)
6889  actual_name = pdi->name;
6890 
6891  switch (pdi->tag)
6892  {
6893  case DW_TAG_subprogram:
6894  addr = gdbarch_adjust_dwarf2_addr (gdbarch, pdi->lowpc + baseaddr);
6895  if (pdi->is_external || cu->language == language_ada)
6896  {
6897  /* brobecker/2007-12-26: Normally, only "external" DIEs are part
6898  of the global scope. But in Ada, we want to be able to access
6899  nested procedures globally. So all Ada subprograms are stored
6900  in the global scope. */
6901  /* prim_record_minimal_symbol (actual_name, addr, mst_text,
6902  objfile); */
6903  add_psymbol_to_list (actual_name, strlen (actual_name),
6904  built_actual_name != NULL,
6906  &objfile->global_psymbols,
6907  0, addr, cu->language, objfile);
6908  }
6909  else
6910  {
6911  /* prim_record_minimal_symbol (actual_name, addr, mst_file_text,
6912  objfile); */
6913  add_psymbol_to_list (actual_name, strlen (actual_name),
6914  built_actual_name != NULL,
6916  &objfile->static_psymbols,
6917  0, addr, cu->language, objfile);
6918  }
6919  break;
6920  case DW_TAG_constant:
6921  {
6922  struct psymbol_allocation_list *list;
6923 
6924  if (pdi->is_external)
6925  list = &objfile->global_psymbols;
6926  else
6927  list = &objfile->static_psymbols;
6928  add_psymbol_to_list (actual_name, strlen (actual_name),
6929  built_actual_name != NULL, VAR_DOMAIN, LOC_STATIC,
6930  list, 0, 0, cu->language, objfile);
6931  }
6932  break;
6933  case DW_TAG_variable:
6934  if (pdi->d.locdesc)
6935  addr = decode_locdesc (pdi->d.locdesc, cu);
6936 
6937  if (pdi->d.locdesc
6938  && addr == 0
6939  && !dwarf2_per_objfile->has_section_at_zero)
6940  {
6941  /* A global or static variable may also have been stripped
6942  out by the linker if unused, in which case its address
6943  will be nullified; do not add such variables into partial
6944  symbol table then. */
6945  }
6946  else if (pdi->is_external)
6947  {
6948  /* Global Variable.
6949  Don't enter into the minimal symbol tables as there is
6950  a minimal symbol table entry from the ELF symbols already.
6951  Enter into partial symbol table if it has a location
6952  descriptor or a type.
6953  If the location descriptor is missing, new_symbol will create
6954  a LOC_UNRESOLVED symbol, the address of the variable will then
6955  be determined from the minimal symbol table whenever the variable
6956  is referenced.
6957  The address for the partial symbol table entry is not
6958  used by GDB, but it comes in handy for debugging partial symbol
6959  table building. */
6960 
6961  if (pdi->d.locdesc || pdi->has_type)
6962  add_psymbol_to_list (actual_name, strlen (actual_name),
6963  built_actual_name != NULL,
6965  &objfile->global_psymbols,
6966  0, addr + baseaddr,
6967  cu->language, objfile);
6968  }
6969  else
6970  {
6971  int has_loc = pdi->d.locdesc != NULL;
6972 
6973  /* Static Variable. Skip symbols whose value we cannot know (those
6974  without location descriptors or constant values). */
6975  if (!has_loc && !pdi->has_const_value)
6976  {
6977  xfree (built_actual_name);
6978  return;
6979  }
6980 
6981  /* prim_record_minimal_symbol (actual_name, addr + baseaddr,
6982  mst_file_data, objfile); */
6983  add_psymbol_to_list (actual_name, strlen (actual_name),
6984  built_actual_name != NULL,
6986  &objfile->static_psymbols,
6987  0,
6988  has_loc ? addr + baseaddr : (CORE_ADDR) 0,
6989  cu->language, objfile);
6990  }
6991  break;
6992  case DW_TAG_typedef:
6993  case DW_TAG_base_type:
6994  case DW_TAG_subrange_type:
6995  add_psymbol_to_list (actual_name, strlen (actual_name),
6996  built_actual_name != NULL,
6998  &objfile->static_psymbols,
6999  0, (CORE_ADDR) 0, cu->language, objfile);
7000  break;
7001  case DW_TAG_imported_declaration:
7002  case DW_TAG_namespace:
7003  add_psymbol_to_list (actual_name, strlen (actual_name),
7004  built_actual_name != NULL,
7006  &objfile->global_psymbols,
7007  0, (CORE_ADDR) 0, cu->language, objfile);
7008  break;
7009  case DW_TAG_module:
7010  add_psymbol_to_list (actual_name, strlen (actual_name),
7011  built_actual_name != NULL,
7013  &objfile->global_psymbols,
7014  0, (CORE_ADDR) 0, cu->language, objfile);
7015  break;
7016  case DW_TAG_class_type:
7017  case DW_TAG_interface_type:
7018  case DW_TAG_structure_type:
7019  case DW_TAG_union_type:
7020  case DW_TAG_enumeration_type:
7021  /* Skip external references. The DWARF standard says in the section
7022  about "Structure, Union, and Class Type Entries": "An incomplete
7023  structure, union or class type is represented by a structure,
7024  union or class entry that does not have a byte size attribute
7025  and that has a DW_AT_declaration attribute." */
7026  if (!pdi->has_byte_size && pdi->is_declaration)
7027  {
7028  xfree (built_actual_name);
7029  return;
7030  }
7031 
7032  /* NOTE: carlton/2003-10-07: See comment in new_symbol about
7033  static vs. global. */
7034  add_psymbol_to_list (actual_name, strlen (actual_name),
7035  built_actual_name != NULL,
7037  (cu->language == language_cplus
7038  || cu->language == language_java)
7039  ? &objfile->global_psymbols
7040  : &objfile->static_psymbols,
7041  0, (CORE_ADDR) 0, cu->language, objfile);
7042 
7043  break;
7044  case DW_TAG_enumerator:
7045  add_psymbol_to_list (actual_name, strlen (actual_name),
7046  built_actual_name != NULL,
7048  (cu->language == language_cplus
7049  || cu->language == language_java)
7050  ? &objfile->global_psymbols
7051  : &objfile->static_psymbols,
7052  0, (CORE_ADDR) 0, cu->language, objfile);
7053  break;
7054  default:
7055  break;
7056  }
7057 
7058  xfree (built_actual_name);
7059 }
7060 
7061 /* Read a partial die corresponding to a namespace; also, add a symbol
7062  corresponding to that namespace to the symbol table. NAMESPACE is
7063  the name of the enclosing namespace. */
7064 
7065 static void
7067  CORE_ADDR *lowpc, CORE_ADDR *highpc,
7068  int set_addrmap, struct dwarf2_cu *cu)
7069 {
7070  /* Add a symbol for the namespace. */
7071 
7072  add_partial_symbol (pdi, cu);
7073 
7074  /* Now scan partial symbols in that namespace. */
7075 
7076  if (pdi->has_children)
7077  scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
7078 }
7079 
7080 /* Read a partial die corresponding to a Fortran module. */
7081 
7082 static void
7084  CORE_ADDR *highpc, int set_addrmap, struct dwarf2_cu *cu)
7085 {
7086  /* Add a symbol for the namespace. */
7087 
7088  add_partial_symbol (pdi, cu);
7089 
7090  /* Now scan partial symbols in that module. */
7091 
7092  if (pdi->has_children)
7093  scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
7094 }
7095 
7096 /* Read a partial die corresponding to a subprogram and create a partial
7097  symbol for that subprogram. When the CU language allows it, this
7098  routine also defines a partial symbol for each nested subprogram
7099  that this subprogram contains. If SET_ADDRMAP is true, record the
7100  covered ranges in the addrmap. Set *LOWPC and *HIGHPC to the lowest
7101  and highest PC values found in PDI.
7102 
7103  PDI may also be a lexical block, in which case we simply search
7104  recursively for subprograms defined inside that lexical block.
7105  Again, this is only performed when the CU language allows this
7106  type of definitions. */
7107 
7108 static void
7110  CORE_ADDR *lowpc, CORE_ADDR *highpc,
7111  int set_addrmap, struct dwarf2_cu *cu)
7112 {
7113  if (pdi->tag == DW_TAG_subprogram)
7114  {
7115  if (pdi->has_pc_info)
7116  {
7117  if (pdi->lowpc < *lowpc)
7118  *lowpc = pdi->lowpc;
7119  if (pdi->highpc > *highpc)
7120  *highpc = pdi->highpc;
7121  if (set_addrmap)
7122  {
7123  struct objfile *objfile = cu->objfile;
7124  struct gdbarch *gdbarch = get_objfile_arch (objfile);
7125  CORE_ADDR baseaddr;
7126  CORE_ADDR highpc;
7127  CORE_ADDR lowpc;
7128 
7129  baseaddr = ANOFFSET (objfile->section_offsets,
7130  SECT_OFF_TEXT (objfile));
7131  lowpc = gdbarch_adjust_dwarf2_addr (gdbarch,
7132  pdi->lowpc + baseaddr);
7133  highpc = gdbarch_adjust_dwarf2_addr (gdbarch,
7134  pdi->highpc + baseaddr);
7135  addrmap_set_empty (objfile->psymtabs_addrmap, lowpc, highpc - 1,
7136  cu->per_cu->v.psymtab);
7137  }
7138  }
7139 
7140  if (pdi->has_pc_info || (!pdi->is_external && pdi->may_be_inlined))
7141  {
7142  if (!pdi->is_declaration)
7143  /* Ignore subprogram DIEs that do not have a name, they are
7144  illegal. Do not emit a complaint at this point, we will
7145  do so when we convert this psymtab into a symtab. */
7146  if (pdi->name)
7147  add_partial_symbol (pdi, cu);
7148  }
7149  }
7150 
7151  if (! pdi->has_children)
7152  return;
7153 
7154  if (cu->language == language_ada)
7155  {
7156  pdi = pdi->die_child;
7157  while (pdi != NULL)
7158  {
7159  fixup_partial_die (pdi, cu);
7160  if (pdi->tag == DW_TAG_subprogram
7161  || pdi->tag == DW_TAG_lexical_block)
7162  add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
7163  pdi = pdi->die_sibling;
7164  }
7165  }
7166 }
7167 
7168 /* Read a partial die corresponding to an enumeration type. */
7169 
7170 static void
7172  struct dwarf2_cu *cu)
7173 {
7174  struct partial_die_info *pdi;
7175 
7176  if (enum_pdi->name != NULL)
7177  add_partial_symbol (enum_pdi, cu);
7178 
7179  pdi = enum_pdi->die_child;
7180  while (pdi)
7181  {
7182  if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
7183  complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
7184  else
7185  add_partial_symbol (pdi, cu);
7186  pdi = pdi->die_sibling;
7187  }
7188 }
7189 
7190 /* Return the initial uleb128 in the die at INFO_PTR. */
7191 
7192 static unsigned int
7193 peek_abbrev_code (bfd *abfd, const gdb_byte *info_ptr)
7194 {
7195  unsigned int bytes_read;
7196 
7197  return read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
7198 }
7199 
7200 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
7201  Return the corresponding abbrev, or NULL if the number is zero (indicating
7202  an empty DIE). In either case *BYTES_READ will be set to the length of
7203  the initial number. */
7204 
7205 static struct abbrev_info *
7206 peek_die_abbrev (const gdb_byte *info_ptr, unsigned int *bytes_read,
7207  struct dwarf2_cu *cu)
7208 {
7209  bfd *abfd = cu->objfile->obfd;
7210  unsigned int abbrev_number;
7211  struct abbrev_info *abbrev;
7212 
7213  abbrev_number = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
7214 
7215  if (abbrev_number == 0)
7216  return NULL;
7217 
7218  abbrev = abbrev_table_lookup_abbrev (cu->abbrev_table, abbrev_number);
7219  if (!abbrev)
7220  {
7221  error (_("Dwarf Error: Could not find abbrev number %d in %s"
7222  " at offset 0x%x [in module %s]"),
7223  abbrev_number, cu->per_cu->is_debug_types ? "TU" : "CU",
7224  cu->header.offset.sect_off, bfd_get_filename (abfd));
7225  }
7226 
7227  return abbrev;
7228 }
7229 
7230 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
7231  Returns a pointer to the end of a series of DIEs, terminated by an empty
7232  DIE. Any children of the skipped DIEs will also be skipped. */
7233 
7234 static const gdb_byte *
7235 skip_children (const struct die_reader_specs *reader, const gdb_byte *info_ptr)
7236 {
7237  struct dwarf2_cu *cu = reader->cu;
7238  struct abbrev_info *abbrev;
7239  unsigned int bytes_read;
7240 
7241  while (1)
7242  {
7243  abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
7244  if (abbrev == NULL)
7245  return info_ptr + bytes_read;
7246  else
7247  info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
7248  }
7249 }
7250 
7251 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
7252  INFO_PTR should point just after the initial uleb128 of a DIE, and the
7253  abbrev corresponding to that skipped uleb128 should be passed in
7254  ABBREV. Returns a pointer to this DIE's sibling, skipping any
7255  children. */
7256 
7257 static const gdb_byte *
7258 skip_one_die (const struct die_reader_specs *reader, const gdb_byte *info_ptr,
7259  struct abbrev_info *abbrev)
7260 {
7261  unsigned int bytes_read;
7262  struct attribute attr;
7263  bfd *abfd = reader->abfd;
7264  struct dwarf2_cu *cu = reader->cu;
7265  const gdb_byte *buffer = reader->buffer;
7266  const gdb_byte *buffer_end = reader->buffer_end;
7267  const gdb_byte *start_info_ptr = info_ptr;
7268  unsigned int form, i;
7269 
7270  for (i = 0; i < abbrev->num_attrs; i++)
7271  {
7272  /* The only abbrev we care about is DW_AT_sibling. */
7273  if (abbrev->attrs[i].name == DW_AT_sibling)
7274  {
7275  read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
7276  if (attr.form == DW_FORM_ref_addr)
7278  _("ignoring absolute DW_AT_sibling"));
7279  else
7280  {
7281  unsigned int off = dwarf2_get_ref_die_offset (&attr).sect_off;
7282  const gdb_byte *sibling_ptr = buffer + off;
7283 
7284  if (sibling_ptr < info_ptr)
7286  _("DW_AT_sibling points backwards"));
7287  else if (sibling_ptr > reader->buffer_end)
7289  else
7290  return sibling_ptr;
7291  }
7292  }
7293 
7294  /* If it isn't DW_AT_sibling, skip this attribute. */
7295  form = abbrev->attrs[i].form;
7296  skip_attribute:
7297  switch (form)
7298  {
7299  case DW_FORM_ref_addr:
7300  /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
7301  and later it is offset sized. */
7302  if (cu->header.version == 2)
7303  info_ptr += cu->header.addr_size;
7304  else
7305  info_ptr += cu->header.offset_size;
7306  break;
7307  case DW_FORM_GNU_ref_alt:
7308  info_ptr += cu->header.offset_size;
7309  break;
7310  case DW_FORM_addr:
7311  info_ptr += cu->header.addr_size;
7312  break;
7313  case DW_FORM_data1:
7314  case DW_FORM_ref1:
7315  case DW_FORM_flag:
7316  info_ptr += 1;
7317  break;
7318  case DW_FORM_flag_present:
7319  break;
7320  case DW_FORM_data2:
7321  case DW_FORM_ref2:
7322  info_ptr += 2;
7323  break;
7324  case DW_FORM_data4:
7325  case DW_FORM_ref4:
7326  info_ptr += 4;
7327  break;
7328  case DW_FORM_data8:
7329  case DW_FORM_ref8:
7330  case DW_FORM_ref_sig8:
7331  info_ptr += 8;
7332  break;
7333  case DW_FORM_string:
7334  read_direct_string (abfd, info_ptr, &bytes_read);
7335  info_ptr += bytes_read;
7336  break;
7337  case DW_FORM_sec_offset:
7338  case DW_FORM_strp:
7339  case DW_FORM_GNU_strp_alt:
7340  info_ptr += cu->header.offset_size;
7341  break;
7342  case DW_FORM_exprloc:
7343  case DW_FORM_block:
7344  info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
7345  info_ptr += bytes_read;
7346  break;
7347  case DW_FORM_block1:
7348  info_ptr += 1 + read_1_byte (abfd, info_ptr);
7349  break;
7350  case DW_FORM_block2:
7351  info_ptr += 2 + read_2_bytes (abfd, info_ptr);
7352  break;
7353  case DW_FORM_block4:
7354  info_ptr += 4 + read_4_bytes (abfd, info_ptr);
7355  break;
7356  case DW_FORM_sdata:
7357  case DW_FORM_udata:
7358  case DW_FORM_ref_udata:
7359  case DW_FORM_GNU_addr_index:
7360  case DW_FORM_GNU_str_index:
7361  info_ptr = safe_skip_leb128 (info_ptr, buffer_end);
7362  break;
7363  case DW_FORM_indirect:
7364  form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
7365  info_ptr += bytes_read;
7366  /* We need to continue parsing from here, so just go back to
7367  the top. */
7368  goto skip_attribute;
7369 
7370  default:
7371  error (_("Dwarf Error: Cannot handle %s "
7372  "in DWARF reader [in module %s]"),
7373  dwarf_form_name (form),
7374  bfd_get_filename (abfd));
7375  }
7376  }
7377 
7378  if (abbrev->has_children)
7379  return skip_children (reader, info_ptr);
7380  else
7381  return info_ptr;
7382 }
7383 
7384 /* Locate ORIG_PDI's sibling.
7385  INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
7386 
7387 static const gdb_byte *
7388 locate_pdi_sibling (const struct die_reader_specs *reader,
7389  struct partial_die_info *orig_pdi,
7390  const gdb_byte *info_ptr)
7391 {
7392  /* Do we know the sibling already? */
7393 
7394  if (orig_pdi->sibling)
7395  return orig_pdi->sibling;
7396 
7397  /* Are there any children to deal with? */
7398 
7399  if (!orig_pdi->has_children)
7400  return info_ptr;
7401 
7402  /* Skip the children the long way. */
7403 
7404  return skip_children (reader, info_ptr);
7405 }
7406 
7407 /* Expand this partial symbol table into a full symbol table. SELF is
7408  not NULL. */
7409 
7410 static void
7412  struct objfile *objfile)
7413 {
7414  if (self->readin)
7415  {
7416  warning (_("bug: psymtab for %s is already read in."),
7417  self->filename);
7418  }
7419  else
7420  {
7421  if (info_verbose)
7422  {
7423  printf_filtered (_("Reading in symbols for %s..."),
7424  self->filename);
7426  }
7427 
7428  /* Restore our global data. */
7429  dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
7430 
7431  /* If this psymtab is constructed from a debug-only objfile, the
7432  has_section_at_zero flag will not necessarily be correct. We
7433  can get the correct value for this flag by looking at the data
7434  associated with the (presumably stripped) associated objfile. */
7435  if (objfile->separate_debug_objfile_backlink)
7436  {
7437  struct dwarf2_per_objfile *dpo_backlink
7438  = objfile_data (objfile->separate_debug_objfile_backlink,
7439  dwarf2_objfile_data_key);
7440 
7441  dwarf2_per_objfile->has_section_at_zero
7442  = dpo_backlink->has_section_at_zero;
7443  }
7444 
7445  dwarf2_per_objfile->reading_partial_symbols = 0;
7446 
7447  psymtab_to_symtab_1 (self);
7448 
7449  /* Finish up the debug error message. */
7450  if (info_verbose)
7451  printf_filtered (_("done.\n"));
7452  }
7453 
7455 }
7456 
7457 /* Reading in full CUs. */
7458 
7459 /* Add PER_CU to the queue. */
7460 
7461 static void
7463  enum language pretend_language)
7464 {
7465  struct dwarf2_queue_item *item;
7466 
7467  per_cu->queued = 1;
7468  item = xmalloc (sizeof (*item));
7469  item->per_cu = per_cu;
7471  item->next = NULL;
7472 
7473  if (dwarf2_queue == NULL)
7474  dwarf2_queue = item;
7475  else
7476  dwarf2_queue_tail->next = item;
7477 
7478  dwarf2_queue_tail = item;
7479 }
7480 
7481 /* If PER_CU is not yet queued, add it to the queue.
7482  If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
7483  dependency.
7484  The result is non-zero if PER_CU was queued, otherwise the result is zero
7485  meaning either PER_CU is already queued or it is already loaded.
7486 
7487  N.B. There is an invariant here that if a CU is queued then it is loaded.
7488  The caller is required to load PER_CU if we return non-zero. */
7489 
7490 static int
7491 maybe_queue_comp_unit (struct dwarf2_cu *dependent_cu,
7492  struct dwarf2_per_cu_data *per_cu,
7494 {
7495  /* We may arrive here during partial symbol reading, if we need full
7496  DIEs to process an unusual case (e.g. template arguments). Do
7497  not queue PER_CU, just tell our caller to load its DIEs. */
7498  if (dwarf2_per_objfile->reading_partial_symbols)
7499  {
7500  if (per_cu->cu == NULL || per_cu->cu->dies == NULL)
7501  return 1;
7502  return 0;
7503  }
7504 
7505  /* Mark the dependence relation so that we don't flush PER_CU
7506  too early. */
7507  if (dependent_cu != NULL)
7508  dwarf2_add_dependence (dependent_cu, per_cu);
7509 
7510  /* If it's already on the queue, we have nothing to do. */
7511  if (per_cu->queued)
7512  return 0;
7513 
7514  /* If the compilation unit is already loaded, just mark it as
7515  used. */
7516  if (per_cu->cu != NULL)
7517  {
7518  per_cu->cu->last_used = 0;
7519  return 0;
7520  }
7521 
7522  /* Add it to the queue. */
7523  queue_comp_unit (per_cu, pretend_language);
7524 
7525  return 1;
7526 }
7527 
7528 /* Process the queue. */
7529 
7530 static void
7532 {
7533  struct dwarf2_queue_item *item, *next_item;
7534 
7535  if (dwarf_read_debug)
7536  {
7538  "Expanding one or more symtabs of objfile %s ...\n",
7539  objfile_name (dwarf2_per_objfile->objfile));
7540  }
7541 
7542  /* The queue starts out with one item, but following a DIE reference
7543  may load a new CU, adding it to the end of the queue. */
7544  for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
7545  {
7546  if (dwarf2_per_objfile->using_index
7547  ? !item->per_cu->v.quick->compunit_symtab
7548  : (item->per_cu->v.psymtab && !item->per_cu->v.psymtab->readin))
7549  {
7550  struct dwarf2_per_cu_data *per_cu = item->per_cu;
7551  unsigned int debug_print_threshold;
7552  char buf[100];
7553 
7554  if (per_cu->is_debug_types)
7555  {
7556  struct signatured_type *sig_type =
7557  (struct signatured_type *) per_cu;
7558 
7559  sprintf (buf, "TU %s at offset 0x%x",
7560  hex_string (sig_type->signature),
7561  per_cu->offset.sect_off);
7562  /* There can be 100s of TUs.
7563  Only print them in verbose mode. */
7564  debug_print_threshold = 2;
7565  }
7566  else
7567  {
7568  sprintf (buf, "CU at offset 0x%x", per_cu->offset.sect_off);
7569  debug_print_threshold = 1;
7570  }
7571 
7572  if (dwarf_read_debug >= debug_print_threshold)
7573  fprintf_unfiltered (gdb_stdlog, "Expanding symtab of %s\n", buf);
7574 
7575  if (per_cu->is_debug_types)
7576  process_full_type_unit (per_cu, item->pretend_language);
7577  else
7578  process_full_comp_unit (per_cu, item->pretend_language);
7579 
7580  if (dwarf_read_debug >= debug_print_threshold)
7581  fprintf_unfiltered (gdb_stdlog, "Done expanding %s\n", buf);
7582  }
7583 
7584  item->per_cu->queued = 0;
7585  next_item = item->next;
7586  xfree (item);
7587  }
7588 
7589  dwarf2_queue_tail = NULL;
7590 
7591  if (dwarf_read_debug)
7592  {
7593  fprintf_unfiltered (gdb_stdlog, "Done expanding symtabs of %s.\n",
7594  objfile_name (dwarf2_per_objfile->objfile));
7595  }
7596 }
7597 
7598 /* Free all allocated queue entries. This function only releases anything if
7599  an error was thrown; if the queue was processed then it would have been
7600  freed as we went along. */
7601 
7602 static void
7604 {
7605  struct dwarf2_queue_item *item, *last;
7606 
7607  item = dwarf2_queue;
7608  while (item)
7609  {
7610  /* Anything still marked queued is likely to be in an
7611  inconsistent state, so discard it. */
7612  if (item->per_cu->queued)
7613  {
7614  if (item->per_cu->cu != NULL)
7616  item->per_cu->queued = 0;
7617  }
7618 
7619  last = item;
7620  item = item->next;
7621  xfree (last);
7622  }
7623 
7624  dwarf2_queue = dwarf2_queue_tail = NULL;
7625 }
7626 
7627 /* Read in full symbols for PST, and anything it depends on. */
7628 
7629 static void
7631 {
7632  struct dwarf2_per_cu_data *per_cu;
7633  int i;
7634 
7635  if (pst->readin)
7636  return;
7637 
7638  for (i = 0; i < pst->number_of_dependencies; i++)
7639  if (!pst->dependencies[i]->readin
7640  && pst->dependencies[i]->user == NULL)
7641  {
7642  /* Inform about additional files that need to be read in. */
7643  if (info_verbose)
7644  {
7645  /* FIXME: i18n: Need to make this a single string. */
7646  fputs_filtered (" ", gdb_stdout);
7647  wrap_here ("");
7648  fputs_filtered ("and ", gdb_stdout);
7649  wrap_here ("");
7650  printf_filtered ("%s...", pst->dependencies[i]->filename);
7651  wrap_here (""); /* Flush output. */
7653  }
7655  }
7656 
7657  per_cu = pst->read_symtab_private;
7658 
7659  if (per_cu == NULL)
7660  {
7661  /* It's an include file, no symbols to read for it.
7662  Everything is in the parent symtab. */
7663  pst->readin = 1;
7664  return;
7665  }
7666 
7667  dw2_do_instantiate_symtab (per_cu);
7668 }
7669 
7670 /* Trivial hash function for die_info: the hash value of a DIE
7671  is its offset in .debug_info for this objfile. */
7672 
7673 static hashval_t
7674 die_hash (const void *item)
7675 {
7676  const struct die_info *die = item;
7677 
7678  return die->offset.sect_off;
7679 }
7680 
7681 /* Trivial comparison function for die_info structures: two DIEs
7682  are equal if they have the same offset. */
7683 
7684 static int
7685 die_eq (const void *item_lhs, const void *item_rhs)
7686 {
7687  const struct die_info *die_lhs = item_lhs;
7688  const struct die_info *die_rhs = item_rhs;
7689 
7690  return die_lhs->offset.sect_off == die_rhs->offset.sect_off;
7691 }
7692 
7693 /* die_reader_func for load_full_comp_unit.
7694  This is identical to read_signatured_type_reader,
7695  but is kept separate for now. */
7696 
7697 static void
7699  const gdb_byte *info_ptr,
7700  struct die_info *comp_unit_die,
7701  int has_children,
7702  void *data)
7703 {
7704  struct dwarf2_cu *cu = reader->cu;
7705  enum language *language_ptr = data;
7706 
7707  gdb_assert (cu->die_hash == NULL);
7708  cu->die_hash =
7709  htab_create_alloc_ex (cu->header.length / 12,
7710  die_hash,
7711  die_eq,
7712  NULL,
7713  &cu->comp_unit_obstack,
7716 
7717  if (has_children)
7718  comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
7719  &info_ptr, comp_unit_die);
7720  cu->dies = comp_unit_die;
7721  /* comp_unit_die is not stored in die_hash, no need. */
7722 
7723  /* We try not to read any attributes in this function, because not
7724  all CUs needed for references have been loaded yet, and symbol
7725  table processing isn't initialized. But we have to set the CU language,
7726  or we won't be able to build types correctly.
7727  Similarly, if we do not read the producer, we can not apply
7728  producer-specific interpretation. */
7729  prepare_one_comp_unit (cu, cu->dies, *language_ptr);
7730 }
7731 
7732 /* Load the DIEs associated with PER_CU into memory. */
7733 
7734 static void
7736  enum language pretend_language)
7737 {
7738  gdb_assert (! this_cu->is_debug_types);
7739 
7740  init_cutu_and_read_dies (this_cu, NULL, 1, 1,
7741  load_full_comp_unit_reader, &pretend_language);
7742 }
7743 
7744 /* Add a DIE to the delayed physname list. */
7745 
7746 static void
7747 add_to_method_list (struct type *type, int fnfield_index, int index,
7748  const char *name, struct die_info *die,
7749  struct dwarf2_cu *cu)
7750 {
7751  struct delayed_method_info mi;
7752  mi.type = type;
7754  mi.index = index;
7755  mi.name = name;
7756  mi.die = die;
7757  VEC_safe_push (delayed_method_info, cu->method_list, &mi);
7758 }
7759 
7760 /* A cleanup for freeing the delayed method list. */
7761 
7762 static void
7764 {
7765  struct dwarf2_cu *cu = (struct dwarf2_cu *) ptr;
7766  if (cu->method_list != NULL)
7767  {
7768  VEC_free (delayed_method_info, cu->method_list);
7769  cu->method_list = NULL;
7770  }
7771 }
7772 
7773 /* Compute the physnames of any methods on the CU's method list.
7774 
7775  The computation of method physnames is delayed in order to avoid the
7776  (bad) condition that one of the method's formal parameters is of an as yet
7777  incomplete type. */
7778 
7779 static void
7781 {
7782  int i;
7783  struct delayed_method_info *mi;
7784  for (i = 0; VEC_iterate (delayed_method_info, cu->method_list, i, mi) ; ++i)
7785  {
7786  const char *physname;
7787  struct fn_fieldlist *fn_flp
7788  = &TYPE_FN_FIELDLIST (mi->type, mi->fnfield_index);
7789  physname = dwarf2_physname (mi->name, mi->die, cu);
7790  TYPE_FN_FIELD_PHYSNAME (fn_flp->fn_fields, mi->index)
7791  = physname ? physname : "";
7792  }
7793 }
7794 
7795 /* Go objects should be embedded in a DW_TAG_module DIE,
7796  and it's not clear if/how imported objects will appear.
7797  To keep Go support simple until that's worked out,
7798  go back through what we've read and create something usable.
7799  We could do this while processing each DIE, and feels kinda cleaner,
7800  but that way is more invasive.
7801  This is to, for example, allow the user to type "p var" or "b main"
7802  without having to specify the package name, and allow lookups
7803  of module.object to work in contexts that use the expression
7804  parser. */
7805 
7806 static void
7808 {
7809  char *package_name = NULL;
7810  struct pending *list;
7811  int i;
7812 
7813  for (list = global_symbols; list != NULL; list = list->next)
7814  {
7815  for (i = 0; i < list->nsyms; ++i)
7816  {
7817  struct symbol *sym = list->symbol[i];
7818 
7819  if (SYMBOL_LANGUAGE (sym) == language_go
7820  && SYMBOL_CLASS (sym) == LOC_BLOCK)
7821  {
7822  char *this_package_name = go_symbol_package_name (sym);
7823 
7824  if (this_package_name == NULL)
7825  continue;
7826  if (package_name == NULL)
7827  package_name = this_package_name;
7828  else
7829  {
7830  if (strcmp (package_name, this_package_name) != 0)
7832  _("Symtab %s has objects from two different Go packages: %s and %s"),
7833  (symbol_symtab (sym) != NULL
7835  (symbol_symtab (sym))
7836  : objfile_name (cu->objfile)),
7837  this_package_name, package_name);
7838  xfree (this_package_name);
7839  }
7840  }
7841  }
7842  }
7843 
7844  if (package_name != NULL)
7845  {
7846  struct objfile *objfile = cu->objfile;
7847  const char *saved_package_name
7848  = obstack_copy0 (&objfile->per_bfd->storage_obstack,
7849  package_name,
7850  strlen (package_name));
7851  struct type *type = init_type (TYPE_CODE_MODULE, 0, 0,
7852  saved_package_name, objfile);
7853  struct symbol *sym;
7854 
7855  TYPE_TAG_NAME (type) = TYPE_NAME (type);
7856 
7857  sym = allocate_symbol (objfile);
7859  SYMBOL_SET_NAMES (sym, saved_package_name,
7860  strlen (saved_package_name), 0, objfile);
7861  /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
7862  e.g., "main" finds the "main" module and not C's main(). */
7863  SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
7865  SYMBOL_TYPE (sym) = type;
7866 
7868 
7869  xfree (package_name);
7870  }
7871 }
7872 
7873 /* Return the symtab for PER_CU. This works properly regardless of
7874  whether we're using the index or psymtabs. */
7875 
7876 static struct compunit_symtab *
7878 {
7879  return (dwarf2_per_objfile->using_index
7880  ? per_cu->v.quick->compunit_symtab
7881  : per_cu->v.psymtab->compunit_symtab);
7882 }
7883 
7884 /* A helper function for computing the list of all symbol tables
7885  included by PER_CU. */
7886 
7887 static void
7889  htab_t all_children, htab_t all_type_symtabs,
7890  struct dwarf2_per_cu_data *per_cu,
7891  struct compunit_symtab *immediate_parent)
7892 {
7893  void **slot;
7894  int ix;
7895  struct compunit_symtab *cust;
7896  struct dwarf2_per_cu_data *iter;
7897 
7898  slot = htab_find_slot (all_children, per_cu, INSERT);
7899  if (*slot != NULL)
7900  {
7901  /* This inclusion and its children have been processed. */
7902  return;
7903  }
7904 
7905  *slot = per_cu;
7906  /* Only add a CU if it has a symbol table. */
7907  cust = get_compunit_symtab (per_cu);
7908  if (cust != NULL)
7909  {
7910  /* If this is a type unit only add its symbol table if we haven't
7911  seen it yet (type unit per_cu's can share symtabs). */
7912  if (per_cu->is_debug_types)
7913  {
7914  slot = htab_find_slot (all_type_symtabs, cust, INSERT);
7915  if (*slot == NULL)
7916  {
7917  *slot = cust;
7918  VEC_safe_push (compunit_symtab_ptr, *result, cust);
7919  if (cust->user == NULL)
7920  cust->user = immediate_parent;
7921  }
7922  }
7923  else
7924  {
7925  VEC_safe_push (compunit_symtab_ptr, *result, cust);
7926  if (cust->user == NULL)
7927  cust->user = immediate_parent;
7928  }
7929  }
7930 
7931  for (ix = 0;
7932  VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs, ix, iter);
7933  ++ix)
7934  {
7935  recursively_compute_inclusions (result, all_children,
7936  all_type_symtabs, iter, cust);
7937  }
7938 }
7939 
7940 /* Compute the compunit_symtab 'includes' fields for the compunit_symtab of
7941  PER_CU. */
7942 
7943 static void
7945 {
7946  gdb_assert (! per_cu->is_debug_types);
7947 
7948  if (!VEC_empty (dwarf2_per_cu_ptr, per_cu->imported_symtabs))
7949  {
7950  int ix, len;
7951  struct dwarf2_per_cu_data *per_cu_iter;
7952  struct compunit_symtab *compunit_symtab_iter;
7953  VEC (compunit_symtab_ptr) *result_symtabs = NULL;
7954  htab_t all_children, all_type_symtabs;
7955  struct compunit_symtab *cust = get_compunit_symtab (per_cu);
7956 
7957  /* If we don't have a symtab, we can just skip this case. */
7958  if (cust == NULL)
7959  return;
7960 
7961  all_children = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
7962  NULL, xcalloc, xfree);
7963  all_type_symtabs = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
7964  NULL, xcalloc, xfree);
7965 
7966  for (ix = 0;
7967  VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs,
7968  ix, per_cu_iter);
7969  ++ix)
7970  {
7971  recursively_compute_inclusions (&result_symtabs, all_children,
7972  all_type_symtabs, per_cu_iter,
7973  cust);
7974  }
7975 
7976  /* Now we have a transitive closure of all the included symtabs. */
7977  len = VEC_length (compunit_symtab_ptr, result_symtabs);
7978  cust->includes
7979  = obstack_alloc (&dwarf2_per_objfile->objfile->objfile_obstack,
7980  (len + 1) * sizeof (struct symtab *));
7981  for (ix = 0;
7982  VEC_iterate (compunit_symtab_ptr, result_symtabs, ix,
7983  compunit_symtab_iter);
7984  ++ix)
7985  cust->includes[ix] = compunit_symtab_iter;
7986  cust->includes[len] = NULL;
7987 
7988  VEC_free (compunit_symtab_ptr, result_symtabs);
7989  htab_delete (all_children);
7990  htab_delete (all_type_symtabs);
7991  }
7992 }
7993 
7994 /* Compute the 'includes' field for the symtabs of all the CUs we just
7995  read. */
7996 
7997 static void
7999 {
8000  int ix;
8001  struct dwarf2_per_cu_data *iter;
8002 
8003  for (ix = 0;
8004  VEC_iterate (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus,
8005  ix, iter);
8006  ++ix)
8007  {
8008  if (! iter->is_debug_types)
8010  }
8011 
8012  VEC_free (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus);
8013 }
8014 
8015 /* Generate full symbol information for PER_CU, whose DIEs have
8016  already been loaded into memory. */
8017 
8018 static void
8020  enum language pretend_language)
8021 {
8022  struct dwarf2_cu *cu = per_cu->cu;
8023  struct objfile *objfile = per_cu->objfile;
8024  struct gdbarch *gdbarch = get_objfile_arch (objfile);
8025  CORE_ADDR lowpc, highpc;
8026  struct compunit_symtab *cust;
8027  struct cleanup *back_to, *delayed_list_cleanup;
8028  CORE_ADDR baseaddr;
8029  struct block *static_block;
8030  CORE_ADDR addr;
8031 
8032  baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
8033 
8034  buildsym_init ();
8035  back_to = make_cleanup (really_free_pendings, NULL);
8036  delayed_list_cleanup = make_cleanup (free_delayed_list, cu);
8037 
8038  cu->list_in_scope = &file_symbols;
8039 
8040  cu->language = pretend_language;
8041  cu->language_defn = language_def (cu->language);
8042 
8043  /* Do line number decoding in read_file_scope () */
8044  process_die (cu->dies, cu);
8045 
8046  /* For now fudge the Go package. */
8047  if (cu->language == language_go)
8048  fixup_go_packaging (cu);
8049 
8050  /* Now that we have processed all the DIEs in the CU, all the types
8051  should be complete, and it should now be safe to compute all of the
8052  physnames. */
8054  do_cleanups (delayed_list_cleanup);
8055 
8056  /* Some compilers don't define a DW_AT_high_pc attribute for the
8057  compilation unit. If the DW_AT_high_pc is missing, synthesize
8058  it, by scanning the DIE's below the compilation unit. */
8059  get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
8060 
8061  addr = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
8062  static_block = end_symtab_get_static_block (addr, 0, 1);
8063 
8064  /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
8065  Also, DW_AT_ranges may record ranges not belonging to any child DIEs
8066  (such as virtual method tables). Record the ranges in STATIC_BLOCK's
8067  addrmap to help ensure it has an accurate map of pc values belonging to
8068  this comp unit. */
8069  dwarf2_record_block_ranges (cu->dies, static_block, baseaddr, cu);
8070 
8071  cust = end_symtab_from_static_block (static_block,
8072  SECT_OFF_TEXT (objfile), 0);
8073 
8074  if (cust != NULL)
8075  {
8076  int gcc_4_minor = producer_is_gcc_ge_4 (cu->producer);
8077 
8078  /* Set symtab language to language from DW_AT_language. If the
8079  compilation is from a C file generated by language preprocessors, do
8080  not set the language if it was already deduced by start_subfile. */
8081  if (!(cu->language == language_c
8082  && COMPUNIT_FILETABS (cust)->language != language_c))
8083  COMPUNIT_FILETABS (cust)->language = cu->language;
8084 
8085  /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
8086  produce DW_AT_location with location lists but it can be possibly
8087  invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
8088  there were bugs in prologue debug info, fixed later in GCC-4.5
8089  by "unwind info for epilogues" patch (which is not directly related).
8090 
8091  For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
8092  needed, it would be wrong due to missing DW_AT_producer there.
8093 
8094  Still one can confuse GDB by using non-standard GCC compilation
8095  options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
8096  */
8097  if (cu->has_loclist && gcc_4_minor >= 5)
8098  cust->locations_valid = 1;
8099 
8100  if (gcc_4_minor >= 5)
8101  cust->epilogue_unwind_valid = 1;
8102 
8103  cust->call_site_htab = cu->call_site_htab;
8104  }
8105 
8106  if (dwarf2_per_objfile->using_index)
8107  per_cu->v.quick->compunit_symtab = cust;
8108  else
8109  {
8110  struct partial_symtab *pst = per_cu->v.psymtab;
8111  pst->compunit_symtab = cust;
8112  pst->readin = 1;
8113  }
8114 
8115  /* Push it for inclusion processing later. */
8116  VEC_safe_push (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus, per_cu);
8117 
8118  do_cleanups (back_to);
8119 }
8120 
8121 /* Generate full symbol information for type unit PER_CU, whose DIEs have
8122  already been loaded into memory. */
8123 
8124 static void
8126  enum language pretend_language)
8127 {
8128  struct dwarf2_cu *cu = per_cu->cu;
8129  struct objfile *objfile = per_cu->objfile;
8130  struct compunit_symtab *cust;
8131  struct cleanup *back_to, *delayed_list_cleanup;
8132  struct signatured_type *sig_type;
8133 
8134  gdb_assert (per_cu->is_debug_types);
8135  sig_type = (struct signatured_type *) per_cu;
8136 
8137  buildsym_init ();
8138  back_to = make_cleanup (really_free_pendings, NULL);
8139  delayed_list_cleanup = make_cleanup (free_delayed_list, cu);
8140 
8141  cu->list_in_scope = &file_symbols;
8142 
8143  cu->language = pretend_language;
8144  cu->language_defn = language_def (cu->language);
8145 
8146  /* The symbol tables are set up in read_type_unit_scope. */
8147  process_die (cu->dies, cu);
8148 
8149  /* For now fudge the Go package. */
8150  if (cu->language == language_go)
8151  fixup_go_packaging (cu);
8152 
8153  /* Now that we have processed all the DIEs in the CU, all the types
8154  should be complete, and it should now be safe to compute all of the
8155  physnames. */
8157  do_cleanups (delayed_list_cleanup);
8158 
8159  /* TUs share symbol tables.
8160  If this is the first TU to use this symtab, complete the construction
8161  of it with end_expandable_symtab. Otherwise, complete the addition of
8162  this TU's symbols to the existing symtab. */
8163  if (sig_type->type_unit_group->compunit_symtab == NULL)
8164  {
8165  cust = end_expandable_symtab (0, SECT_OFF_TEXT (objfile));
8166  sig_type->type_unit_group->compunit_symtab = cust;
8167 
8168  if (cust != NULL)
8169  {
8170  /* Set symtab language to language from DW_AT_language. If the
8171  compilation is from a C file generated by language preprocessors,
8172  do not set the language if it was already deduced by
8173  start_subfile. */
8174  if (!(cu->language == language_c
8175  && COMPUNIT_FILETABS (cust)->language != language_c))
8176  COMPUNIT_FILETABS (cust)->language = cu->language;
8177  }
8178  }
8179  else
8180  {
8182  cust = sig_type->type_unit_group->compunit_symtab;
8183  }
8184 
8185  if (dwarf2_per_objfile->using_index)
8186  per_cu->v.quick->compunit_symtab = cust;
8187  else
8188  {
8189  struct partial_symtab *pst = per_cu->v.psymtab;
8190  pst->compunit_symtab = cust;
8191  pst->readin = 1;
8192  }
8193 
8194  do_cleanups (back_to);
8195 }
8196 
8197 /* Process an imported unit DIE. */
8198 
8199 static void
8201 {
8202  struct attribute *attr;
8203 
8204  /* For now we don't handle imported units in type units. */
8205  if (cu->per_cu->is_debug_types)
8206  {
8207  error (_("Dwarf Error: DW_TAG_imported_unit is not"
8208  " supported in type units [in module %s]"),
8209  objfile_name (cu->objfile));
8210  }
8211 
8212  attr = dwarf2_attr (die, DW_AT_import, cu);
8213  if (attr != NULL)
8214  {
8215  struct dwarf2_per_cu_data *per_cu;
8216  struct symtab *imported_symtab;
8218  int is_dwz;
8219 
8220  offset = dwarf2_get_ref_die_offset (attr);
8221  is_dwz = (attr->form == DW_FORM_GNU_ref_alt || cu->per_cu->is_dwz);
8222  per_cu = dwarf2_find_containing_comp_unit (offset, is_dwz, cu->objfile);
8223 
8224  /* If necessary, add it to the queue and load its DIEs. */
8225  if (maybe_queue_comp_unit (cu, per_cu, cu->language))
8226  load_full_comp_unit (per_cu, cu->language);
8227 
8228  VEC_safe_push (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
8229  per_cu);
8230  }
8231 }
8232 
8233 /* Reset the in_process bit of a die. */
8234 
8235 static void
8237 {
8238  struct die_info *die = arg;
8239 
8240  die->in_process = 0;
8241 }
8242 
8243 /* Process a die and its children. */
8244 
8245 static void
8246 process_die (struct die_info *die, struct dwarf2_cu *cu)
8247 {
8248  struct cleanup *in_process;
8249 
8250  /* We should only be processing those not already in process. */
8251  gdb_assert (!die->in_process);
8252 
8253  die->in_process = 1;
8254  in_process = make_cleanup (reset_die_in_process,die);
8255 
8256  switch (die->tag)
8257  {
8258  case DW_TAG_padding:
8259  break;
8260  case DW_TAG_compile_unit:
8261  case DW_TAG_partial_unit:
8262  read_file_scope (die, cu);
8263  break;
8264  case DW_TAG_type_unit:
8265  read_type_unit_scope (die, cu);
8266  break;
8267  case DW_TAG_subprogram:
8268  case DW_TAG_inlined_subroutine:
8269  read_func_scope (die, cu);
8270  break;
8271  case DW_TAG_lexical_block:
8272  case DW_TAG_try_block:
8273  case DW_TAG_catch_block:
8274  read_lexical_block_scope (die, cu);
8275  break;
8276  case DW_TAG_GNU_call_site:
8277  read_call_site_scope (die, cu);
8278  break;
8279  case DW_TAG_class_type:
8280  case DW_TAG_interface_type:
8281  case DW_TAG_structure_type:
8282  case DW_TAG_union_type:
8283  process_structure_scope (die, cu);
8284  break;
8285  case DW_TAG_enumeration_type:
8286  process_enumeration_scope (die, cu);
8287  break;
8288 
8289  /* These dies have a type, but processing them does not create
8290  a symbol or recurse to process the children. Therefore we can
8291  read them on-demand through read_type_die. */
8292  case DW_TAG_subroutine_type:
8293  case DW_TAG_set_type:
8294  case DW_TAG_array_type:
8295  case DW_TAG_pointer_type:
8296  case DW_TAG_ptr_to_member_type:
8297  case DW_TAG_reference_type:
8298  case DW_TAG_string_type:
8299  break;
8300 
8301  case DW_TAG_base_type:
8302  case DW_TAG_subrange_type:
8303  case DW_TAG_typedef:
8304  /* Add a typedef symbol for the type definition, if it has a
8305  DW_AT_name. */
8306  new_symbol (die, read_type_die (die, cu), cu);
8307  break;
8308  case DW_TAG_common_block:
8309  read_common_block (die, cu);
8310  break;
8311  case DW_TAG_common_inclusion:
8312  break;
8313  case DW_TAG_namespace:
8314  cu->processing_has_namespace_info = 1;
8315  read_namespace (die, cu);
8316  break;
8317  case DW_TAG_module:
8318  cu->processing_has_namespace_info = 1;
8319  read_module (die, cu);
8320  break;
8321  case DW_TAG_imported_declaration:
8322  cu->processing_has_namespace_info = 1;
8323  if (read_namespace_alias (die, cu))
8324  break;
8325  /* The declaration is not a global namespace alias: fall through. */
8326  case DW_TAG_imported_module:
8327  cu->processing_has_namespace_info = 1;
8328  if (die->child != NULL && (die->tag == DW_TAG_imported_declaration
8329  || cu->language != language_fortran))
8330  complaint (&symfile_complaints, _("Tag '%s' has unexpected children"),
8331  dwarf_tag_name (die->tag));
8332  read_import_statement (die, cu);
8333  break;
8334 
8335  case DW_TAG_imported_unit:
8336  process_imported_unit_die (die, cu);
8337  break;
8338 
8339  default:
8340  new_symbol (die, NULL, cu);
8341  break;
8342  }
8343 
8344  do_cleanups (in_process);
8345 }
8346 
8347 /* DWARF name computation. */
8348 
8349 /* A helper function for dwarf2_compute_name which determines whether DIE
8350  needs to have the name of the scope prepended to the name listed in the
8351  die. */
8352 
8353 static int
8354 die_needs_namespace (struct die_info *die, struct dwarf2_cu *cu)
8355 {
8356  struct attribute *attr;
8357 
8358  switch (die->tag)
8359  {
8360  case DW_TAG_namespace:
8361  case DW_TAG_typedef:
8362  case DW_TAG_class_type:
8363  case DW_TAG_interface_type:
8364  case DW_TAG_structure_type:
8365  case DW_TAG_union_type:
8366  case DW_TAG_enumeration_type:
8367  case DW_TAG_enumerator:
8368  case DW_TAG_subprogram:
8369  case DW_TAG_inlined_subroutine:
8370  case DW_TAG_member:
8371  case DW_TAG_imported_declaration:
8372  return 1;
8373 
8374  case DW_TAG_variable:
8375  case DW_TAG_constant:
8376  /* We only need to prefix "globally" visible variables. These include
8377  any variable marked with DW_AT_external or any variable that
8378  lives in a namespace. [Variables in anonymous namespaces
8379  require prefixing, but they are not DW_AT_external.] */
8380 
8381  if (dwarf2_attr (die, DW_AT_specification, cu))
8382  {
8383  struct dwarf2_cu *spec_cu = cu;
8384 
8385  return die_needs_namespace (die_specification (die, &spec_cu),
8386  spec_cu);
8387  }
8388 
8389  attr = dwarf2_attr (die, DW_AT_external, cu);
8390  if (attr == NULL && die->parent->tag != DW_TAG_namespace
8391  && die->parent->tag != DW_TAG_module)
8392  return 0;
8393  /* A variable in a lexical block of some kind does not need a
8394  namespace, even though in C++ such variables may be external
8395  and have a mangled name. */
8396  if (die->parent->tag == DW_TAG_lexical_block
8397  || die->parent->tag == DW_TAG_try_block
8398  || die->parent->tag == DW_TAG_catch_block
8399  || die->parent->tag == DW_TAG_subprogram)
8400  return 0;
8401  return 1;
8402 
8403  default:
8404  return 0;
8405  }
8406 }
8407 
8408 /* Retrieve the last character from a mem_file. */
8409 
8410 static void
8411 do_ui_file_peek_last (void *object, const char *buffer, long length)
8412 {
8413  char *last_char_p = (char *) object;
8414 
8415  if (length > 0)
8416  *last_char_p = buffer[length - 1];
8417 }
8418 
8419 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
8420  compute the physname for the object, which include a method's:
8421  - formal parameters (C++/Java),
8422  - receiver type (Go),
8423  - return type (Java).
8424 
8425  The term "physname" is a bit confusing.
8426  For C++, for example, it is the demangled name.
8427  For Go, for example, it's the mangled name.
8428 
8429  For Ada, return the DIE's linkage name rather than the fully qualified
8430  name. PHYSNAME is ignored..
8431 
8432  The result is allocated on the objfile_obstack and canonicalized. */
8433 
8434 static const char *
8435 dwarf2_compute_name (const char *name,
8436  struct die_info *die, struct dwarf2_cu *cu,
8437  int physname)
8438 {
8439  struct objfile *objfile = cu->objfile;
8440 
8441  if (name == NULL)
8442  name = dwarf2_name (die, cu);
8443 
8444  /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
8445  compute it by typename_concat inside GDB. */
8446  if (cu->language == language_ada
8447  || (cu->language == language_fortran && physname))
8448  {
8449  /* For Ada unit, we prefer the linkage name over the name, as
8450  the former contains the exported name, which the user expects
8451  to be able to reference. Ideally, we want the user to be able
8452  to reference this entity using either natural or linkage name,
8453  but we haven't started looking at this enhancement yet. */
8454  struct attribute *attr;
8455 
8456  attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
8457  if (attr == NULL)
8458  attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
8459  if (attr && DW_STRING (attr))
8460  return DW_STRING (attr);
8461  }
8462 
8463  /* These are the only languages we know how to qualify names in. */
8464  if (name != NULL
8465  && (cu->language == language_cplus || cu->language == language_java
8466  || cu->language == language_fortran))
8467  {
8468  if (die_needs_namespace (die, cu))
8469  {
8470  long length;
8471  const char *prefix;
8472  struct ui_file *buf;
8473  char *intermediate_name;
8474  const char *canonical_name = NULL;
8475 
8476  prefix = determine_prefix (die, cu);
8477  buf = mem_fileopen ();
8478  if (*prefix != '\0')
8479  {
8480  char *prefixed_name = typename_concat (NULL, prefix, name,
8481  physname, cu);
8482 
8483  fputs_unfiltered (prefixed_name, buf);
8484  xfree (prefixed_name);
8485  }
8486  else
8487  fputs_unfiltered (name, buf);
8488 
8489  /* Template parameters may be specified in the DIE's DW_AT_name, or
8490  as children with DW_TAG_template_type_param or
8491  DW_TAG_value_type_param. If the latter, add them to the name
8492  here. If the name already has template parameters, then
8493  skip this step; some versions of GCC emit both, and
8494  it is more efficient to use the pre-computed name.
8495 
8496  Something to keep in mind about this process: it is very
8497  unlikely, or in some cases downright impossible, to produce
8498  something that will match the mangled name of a function.
8499  If the definition of the function has the same debug info,
8500  we should be able to match up with it anyway. But fallbacks
8501  using the minimal symbol, for instance to find a method
8502  implemented in a stripped copy of libstdc++, will not work.
8503  If we do not have debug info for the definition, we will have to
8504  match them up some other way.
8505 
8506  When we do name matching there is a related problem with function
8507  templates; two instantiated function templates are allowed to
8508  differ only by their return types, which we do not add here. */
8509 
8510  if (cu->language == language_cplus && strchr (name, '<') == NULL)
8511  {
8512  struct attribute *attr;
8513  struct die_info *child;
8514  int first = 1;
8515 
8516  die->building_fullname = 1;
8517 
8518  for (child = die->child; child != NULL; child = child->sibling)
8519  {
8520  struct type *type;
8521  LONGEST value;
8522  const gdb_byte *bytes;
8523  struct dwarf2_locexpr_baton *baton;
8524  struct value *v;
8525 
8526  if (child->tag != DW_TAG_template_type_param
8527  && child->tag != DW_TAG_template_value_param)
8528  continue;
8529 
8530  if (first)
8531  {
8532  fputs_unfiltered ("<", buf);
8533  first = 0;
8534  }
8535  else
8536  fputs_unfiltered (", ", buf);
8537 
8538  attr = dwarf2_attr (child, DW_AT_type, cu);
8539  if (attr == NULL)
8540  {
8542  _("template parameter missing DW_AT_type"));
8543  fputs_unfiltered ("UNKNOWN_TYPE", buf);
8544  continue;
8545  }
8546  type = die_type (child, cu);
8547 
8548  if (child->tag == DW_TAG_template_type_param)
8549  {
8550  c_print_type (type, "", buf, -1, 0, &type_print_raw_options);
8551  continue;
8552  }
8553 
8554  attr = dwarf2_attr (child, DW_AT_const_value, cu);
8555  if (attr == NULL)
8556  {
8558  _("template parameter missing "
8559  "DW_AT_const_value"));
8560  fputs_unfiltered ("UNKNOWN_VALUE", buf);
8561  continue;
8562  }
8563 
8564  dwarf2_const_value_attr (attr, type, name,
8565  &cu->comp_unit_obstack, cu,
8566  &value, &bytes, &baton);
8567 
8568  if (TYPE_NOSIGN (type))
8569  /* GDB prints characters as NUMBER 'CHAR'. If that's
8570  changed, this can use value_print instead. */
8571  c_printchar (value, type, buf);
8572  else
8573  {
8574  struct value_print_options opts;
8575 
8576  if (baton != NULL)
8577  v = dwarf2_evaluate_loc_desc (type, NULL,
8578  baton->data,
8579  baton->size,
8580  baton->per_cu);
8581  else if (bytes != NULL)
8582  {
8583  v = allocate_value (type);
8584  memcpy (value_contents_writeable (v), bytes,
8585  TYPE_LENGTH (type));
8586  }
8587  else
8588  v = value_from_longest (type, value);
8589 
8590  /* Specify decimal so that we do not depend on
8591  the radix. */
8592  get_formatted_print_options (&opts, 'd');
8593  opts.raw = 1;
8594  value_print (v, buf, &opts);
8595  release_value (v);
8596  value_free (v);
8597  }
8598  }
8599 
8600  die->building_fullname = 0;
8601 
8602  if (!first)
8603  {
8604  /* Close the argument list, with a space if necessary
8605  (nested templates). */
8606  char last_char = '\0';
8607  ui_file_put (buf, do_ui_file_peek_last, &last_char);
8608  if (last_char == '>')
8609  fputs_unfiltered (" >", buf);
8610  else
8611  fputs_unfiltered (">", buf);
8612  }
8613  }
8614 
8615  /* For Java and C++ methods, append formal parameter type
8616  information, if PHYSNAME. */
8617 
8618  if (physname && die->tag == DW_TAG_subprogram
8619  && (cu->language == language_cplus
8620  || cu->language == language_java))
8621  {
8622  struct type *type = read_type_die (die, cu);
8623 
8624  c_type_print_args (type, buf, 1, cu->language,
8626 
8627  if (cu->language == language_java)
8628  {
8629  /* For java, we must append the return type to method
8630  names. */
8631  if (die->tag == DW_TAG_subprogram)
8632  java_print_type (TYPE_TARGET_TYPE (type), "", buf,
8633  0, 0, &type_print_raw_options);
8634  }
8635  else if (cu->language == language_cplus)
8636  {
8637  /* Assume that an artificial first parameter is
8638  "this", but do not crash if it is not. RealView
8639  marks unnamed (and thus unused) parameters as
8640  artificial; there is no way to differentiate
8641  the two cases. */
8642  if (TYPE_NFIELDS (type) > 0
8643  && TYPE_FIELD_ARTIFICIAL (type, 0)
8644  && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_PTR
8646  0))))
8647  fputs_unfiltered (" const", buf);
8648  }
8649  }
8650 
8651  intermediate_name = ui_file_xstrdup (buf, &length);
8652  ui_file_delete (buf);
8653 
8654  if (cu->language == language_cplus)
8655  canonical_name
8656  = dwarf2_canonicalize_name (intermediate_name, cu,
8657  &objfile->per_bfd->storage_obstack);
8658 
8659  /* If we only computed INTERMEDIATE_NAME, or if
8660  INTERMEDIATE_NAME is already canonical, then we need to
8661  copy it to the appropriate obstack. */
8662  if (canonical_name == NULL || canonical_name == intermediate_name)
8663  name = obstack_copy0 (&objfile->per_bfd->storage_obstack,
8664  intermediate_name,
8665  strlen (intermediate_name));
8666  else
8667  name = canonical_name;
8668 
8669  xfree (intermediate_name);
8670  }
8671  }
8672 
8673  return name;
8674 }
8675 
8676 /* Return the fully qualified name of DIE, based on its DW_AT_name.
8677  If scope qualifiers are appropriate they will be added. The result
8678  will be allocated on the storage_obstack, or NULL if the DIE does
8679  not have a name. NAME may either be from a previous call to
8680  dwarf2_name or NULL.
8681 
8682  The output string will be canonicalized (if C++/Java). */
8683 
8684 static const char *
8685 dwarf2_full_name (const char *name, struct die_info *die, struct dwarf2_cu *cu)
8686 {
8687  return dwarf2_compute_name (name, die, cu, 0);
8688 }
8689 
8690 /* Construct a physname for the given DIE in CU. NAME may either be
8691  from a previous call to dwarf2_name or NULL. The result will be
8692  allocated on the objfile_objstack or NULL if the DIE does not have a
8693  name.
8694 
8695  The output string will be canonicalized (if C++/Java). */
8696 
8697 static const char *
8698 dwarf2_physname (const char *name, struct die_info *die, struct dwarf2_cu *cu)
8699 {
8700  struct objfile *objfile = cu->objfile;
8701  struct attribute *attr;
8702  const char *retval, *mangled = NULL, *canon = NULL;
8703  struct cleanup *back_to;
8704  int need_copy = 1;
8705 
8706  /* In this case dwarf2_compute_name is just a shortcut not building anything
8707  on its own. */
8708  if (!die_needs_namespace (die, cu))
8709  return dwarf2_compute_name (name, die, cu, 1);
8710 
8711  back_to = make_cleanup (null_cleanup, NULL);
8712 
8713  attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
8714  if (!attr)
8715  attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
8716 
8717  /* DW_AT_linkage_name is missing in some cases - depend on what GDB
8718  has computed. */
8719  if (attr && DW_STRING (attr))
8720  {
8721  char *demangled;
8722 
8723  mangled = DW_STRING (attr);
8724 
8725  /* Use DMGL_RET_DROP for C++ template functions to suppress their return
8726  type. It is easier for GDB users to search for such functions as
8727  `name(params)' than `long name(params)'. In such case the minimal
8728  symbol names do not match the full symbol names but for template
8729  functions there is never a need to look up their definition from their
8730  declaration so the only disadvantage remains the minimal symbol
8731  variant `long name(params)' does not have the proper inferior type.
8732  */
8733 
8734  if (cu->language == language_go)
8735  {
8736  /* This is a lie, but we already lie to the caller new_symbol_full.
8737  new_symbol_full assumes we return the mangled name.
8738  This just undoes that lie until things are cleaned up. */
8739  demangled = NULL;
8740  }
8741  else
8742  {
8743  demangled = gdb_demangle (mangled,
8744  (DMGL_PARAMS | DMGL_ANSI
8745  | (cu->language == language_java
8746  ? DMGL_JAVA | DMGL_RET_POSTFIX
8747  : DMGL_RET_DROP)));
8748  }
8749  if (demangled)
8750  {
8751  make_cleanup (xfree, demangled);
8752  canon = demangled;
8753  }
8754  else
8755  {
8756  canon = mangled;
8757  need_copy = 0;
8758  }
8759  }
8760 
8761  if (canon == NULL || check_physname)
8762  {
8763  const char *physname = dwarf2_compute_name (name, die, cu, 1);
8764 
8765  if (canon != NULL && strcmp (physname, canon) != 0)
8766  {
8767  /* It may not mean a bug in GDB. The compiler could also
8768  compute DW_AT_linkage_name incorrectly. But in such case
8769  GDB would need to be bug-to-bug compatible. */
8770 
8772  _("Computed physname <%s> does not match demangled <%s> "
8773  "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
8774  physname, canon, mangled, die->offset.sect_off,
8775  objfile_name (objfile));
8776 
8777  /* Prefer DW_AT_linkage_name (in the CANON form) - when it
8778  is available here - over computed PHYSNAME. It is safer
8779  against both buggy GDB and buggy compilers. */
8780 
8781  retval = canon;
8782  }
8783  else
8784  {
8785  retval = physname;
8786  need_copy = 0;
8787  }
8788  }
8789  else
8790  retval = canon;
8791 
8792  if (need_copy)
8793  retval = obstack_copy0 (&objfile->per_bfd->storage_obstack,
8794  retval, strlen (retval));
8795 
8796  do_cleanups (back_to);
8797  return retval;
8798 }
8799 
8800 /* Inspect DIE in CU for a namespace alias. If one exists, record
8801  a new symbol for it.
8802 
8803  Returns 1 if a namespace alias was recorded, 0 otherwise. */
8804 
8805 static int
8806 read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu)
8807 {
8808  struct attribute *attr;
8809 
8810  /* If the die does not have a name, this is not a namespace
8811  alias. */
8812  attr = dwarf2_attr (die, DW_AT_name, cu);
8813  if (attr != NULL)
8814  {
8815  int num;
8816  struct die_info *d = die;
8817  struct dwarf2_cu *imported_cu = cu;
8818 
8819  /* If the compiler has nested DW_AT_imported_declaration DIEs,
8820  keep inspecting DIEs until we hit the underlying import. */
8821 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
8822  for (num = 0; num < MAX_NESTED_IMPORTED_DECLARATIONS; ++num)
8823  {
8824  attr = dwarf2_attr (d, DW_AT_import, cu);
8825  if (attr == NULL)
8826  break;
8827 
8828  d = follow_die_ref (d, attr, &imported_cu);
8829  if (d->tag != DW_TAG_imported_declaration)
8830  break;
8831  }
8832 
8833  if (num == MAX_NESTED_IMPORTED_DECLARATIONS)
8834  {
8836  _("DIE at 0x%x has too many recursively imported "
8837  "declarations"), d->offset.sect_off);
8838  return 0;
8839  }
8840 
8841  if (attr != NULL)
8842  {
8843  struct type *type;
8844  sect_offset offset = dwarf2_get_ref_die_offset (attr);
8845 
8846  type = get_die_type_at_offset (offset, cu->per_cu);
8847  if (type != NULL && TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
8848  {
8849  /* This declaration is a global namespace alias. Add
8850  a symbol for it whose type is the aliased namespace. */
8851  new_symbol (die, type, cu);
8852  return 1;
8853  }
8854  }
8855  }
8856 
8857  return 0;
8858 }
8859 
8860 /* Read the import statement specified by the given die and record it. */
8861 
8862 static void
8863 read_import_statement (struct die_info *die, struct dwarf2_cu *cu)
8864 {
8865  struct objfile *objfile = cu->objfile;
8866  struct attribute *import_attr;
8867  struct die_info *imported_die, *child_die;
8868  struct dwarf2_cu *imported_cu;
8869  const char *imported_name;
8870  const char *imported_name_prefix;
8871  const char *canonical_name;
8872  const char *import_alias;
8873  const char *imported_declaration = NULL;
8874  const char *import_prefix;
8875  VEC (const_char_ptr) *excludes = NULL;
8876  struct cleanup *cleanups;
8877 
8878  import_attr = dwarf2_attr (die, DW_AT_import, cu);
8879  if (import_attr == NULL)
8880  {
8881  complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
8882  dwarf_tag_name (die->tag));
8883  return;
8884  }
8885 
8886  imported_cu = cu;
8887  imported_die = follow_die_ref_or_sig (die, import_attr, &imported_cu);
8888  imported_name = dwarf2_name (imported_die, imported_cu);
8889  if (imported_name == NULL)
8890  {
8891  /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
8892 
8893  The import in the following code:
8894  namespace A
8895  {
8896  typedef int B;
8897  }
8898 
8899  int main ()
8900  {
8901  using A::B;
8902  B b;
8903  return b;
8904  }
8905 
8906  ...
8907  <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
8908  <52> DW_AT_decl_file : 1
8909  <53> DW_AT_decl_line : 6
8910  <54> DW_AT_import : <0x75>
8911  <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
8912  <59> DW_AT_name : B
8913  <5b> DW_AT_decl_file : 1
8914  <5c> DW_AT_decl_line : 2
8915  <5d> DW_AT_type : <0x6e>
8916  ...
8917  <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
8918  <76> DW_AT_byte_size : 4
8919  <77> DW_AT_encoding : 5 (signed)
8920 
8921  imports the wrong die ( 0x75 instead of 0x58 ).
8922  This case will be ignored until the gcc bug is fixed. */
8923  return;
8924  }
8925 
8926  /* Figure out the local name after import. */
8927  import_alias = dwarf2_name (die, cu);
8928 
8929  /* Figure out where the statement is being imported to. */
8930  import_prefix = determine_prefix (die, cu);
8931 
8932  /* Figure out what the scope of the imported die is and prepend it
8933  to the name of the imported die. */
8934  imported_name_prefix = determine_prefix (imported_die, imported_cu);
8935 
8936  if (imported_die->tag != DW_TAG_namespace
8937  && imported_die->tag != DW_TAG_module)
8938  {
8939  imported_declaration = imported_name;
8940  canonical_name = imported_name_prefix;
8941  }
8942  else if (strlen (imported_name_prefix) > 0)
8943  canonical_name = obconcat (&objfile->objfile_obstack,
8944  imported_name_prefix, "::", imported_name,
8945  (char *) NULL);
8946  else
8947  canonical_name = imported_name;
8948 
8949  cleanups = make_cleanup (VEC_cleanup (const_char_ptr), &excludes);
8950 
8951  if (die->tag == DW_TAG_imported_module && cu->language == language_fortran)
8952  for (child_die = die->child; child_die && child_die->tag;
8953  child_die = sibling_die (child_die))
8954  {
8955  /* DWARF-4: A Fortran use statement with a “rename list” may be
8956  represented by an imported module entry with an import attribute
8957  referring to the module and owned entries corresponding to those
8958  entities that are renamed as part of being imported. */
8959 
8960  if (child_die->tag != DW_TAG_imported_declaration)
8961  {
8963  _("child DW_TAG_imported_declaration expected "
8964  "- DIE at 0x%x [in module %s]"),
8965  child_die->offset.sect_off, objfile_name (objfile));
8966  continue;
8967  }
8968 
8969  import_attr = dwarf2_attr (child_die, DW_AT_import, cu);
8970  if (import_attr == NULL)
8971  {
8972  complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
8973  dwarf_tag_name (child_die->tag));
8974  continue;
8975  }
8976 
8977  imported_cu = cu;
8978  imported_die = follow_die_ref_or_sig (child_die, import_attr,
8979  &imported_cu);
8980  imported_name = dwarf2_name (imported_die, imported_cu);
8981  if (imported_name == NULL)
8982  {
8984  _("child DW_TAG_imported_declaration has unknown "
8985  "imported name - DIE at 0x%x [in module %s]"),
8986  child_die->offset.sect_off, objfile_name (objfile));
8987  continue;
8988  }
8989 
8990  VEC_safe_push (const_char_ptr, excludes, imported_name);
8991 
8992  process_die (child_die, cu);
8993  }
8994 
8995  cp_add_using_directive (import_prefix,
8996  canonical_name,
8997  import_alias,
8998  imported_declaration,
8999  excludes,
9000  0,
9001  &objfile->objfile_obstack);
9002 
9003  do_cleanups (cleanups);
9004 }
9005 
9006 /* Cleanup function for handle_DW_AT_stmt_list. */
9007 
9008 static void
9010 {
9011  struct dwarf2_cu *cu = arg;
9012 
9014  cu->line_header = NULL;
9015 }
9016 
9017 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
9018  directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
9019  this, it was first present in GCC release 4.3.0. */
9020 
9021 static int
9023 {
9024  if (!cu->checked_producer)
9025  check_producer (cu);
9026 
9027  return cu->producer_is_gcc_lt_4_3;
9028 }
9029 
9030 static void
9031 find_file_and_directory (struct die_info *die, struct dwarf2_cu *cu,
9032  const char **name, const char **comp_dir)
9033 {
9034  struct attribute *attr;
9035 
9036  *name = NULL;
9037  *comp_dir = NULL;
9038 
9039  /* Find the filename. Do not use dwarf2_name here, since the filename
9040  is not a source language identifier. */
9041  attr = dwarf2_attr (die, DW_AT_name, cu);
9042  if (attr)
9043  {
9044  *name = DW_STRING (attr);
9045  }
9046 
9047  attr = dwarf2_attr (die, DW_AT_comp_dir, cu);
9048  if (attr)
9049  *comp_dir = DW_STRING (attr);
9050  else if (producer_is_gcc_lt_4_3 (cu) && *name != NULL
9051  && IS_ABSOLUTE_PATH (*name))
9052  {
9053  char *d = ldirname (*name);
9054 
9055  *comp_dir = d;
9056  if (d != NULL)
9057  make_cleanup (xfree, d);
9058  }
9059  if (*comp_dir != NULL)
9060  {
9061  /* Irix 6.2 native cc prepends <machine>.: to the compilation
9062  directory, get rid of it. */
9063  char *cp = strchr (*comp_dir, ':');
9064 
9065  if (cp && cp != *comp_dir && cp[-1] == '.' && cp[1] == '/')
9066  *comp_dir = cp + 1;
9067  }
9068 
9069  if (*name == NULL)
9070  *name = "<unknown>";
9071 }
9072 
9073 /* Handle DW_AT_stmt_list for a compilation unit.
9074  DIE is the DW_TAG_compile_unit die for CU.
9075  COMP_DIR is the compilation directory. LOWPC is passed to
9076  dwarf_decode_lines. See dwarf_decode_lines comments about it. */
9077 
9078 static void
9079 handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
9080  const char *comp_dir, CORE_ADDR lowpc) /* ARI: editCase function */
9081 {
9082  struct objfile *objfile = dwarf2_per_objfile->objfile;
9083  struct attribute *attr;
9084  unsigned int line_offset;
9085  struct line_header line_header_local;
9086  hashval_t line_header_local_hash;
9087  unsigned u;
9088  void **slot;
9089  int decode_mapping;
9090 
9091  gdb_assert (! cu->per_cu->is_debug_types);
9092 
9093  attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
9094  if (attr == NULL)
9095  return;
9096 
9097  line_offset = DW_UNSND (attr);
9098 
9099  /* The line header hash table is only created if needed (it exists to
9100  prevent redundant reading of the line table for partial_units).
9101  If we're given a partial_unit, we'll need it. If we're given a
9102  compile_unit, then use the line header hash table if it's already
9103  created, but don't create one just yet. */
9104 
9105  if (dwarf2_per_objfile->line_header_hash == NULL
9106  && die->tag == DW_TAG_partial_unit)
9107  {
9108  dwarf2_per_objfile->line_header_hash
9109  = htab_create_alloc_ex (127, line_header_hash_voidp,
9112  &objfile->objfile_obstack,
9115  }
9116 
9117  line_header_local.offset.sect_off = line_offset;
9118  line_header_local.offset_in_dwz = cu->per_cu->is_dwz;
9119  line_header_local_hash = line_header_hash (&line_header_local);
9120  if (dwarf2_per_objfile->line_header_hash != NULL)
9121  {
9122  slot = htab_find_slot_with_hash (dwarf2_per_objfile->line_header_hash,
9123  &line_header_local,
9124  line_header_local_hash, NO_INSERT);
9125 
9126  /* For DW_TAG_compile_unit we need info like symtab::linetable which
9127  is not present in *SLOT (since if there is something in *SLOT then
9128  it will be for a partial_unit). */
9129  if (die->tag == DW_TAG_partial_unit && slot != NULL)
9130  {
9131  gdb_assert (*slot != NULL);
9132  cu->line_header = *slot;
9133  return;
9134  }
9135  }
9136 
9137  /* dwarf_decode_line_header does not yet provide sufficient information.
9138  We always have to call also dwarf_decode_lines for it. */
9139  cu->line_header = dwarf_decode_line_header (line_offset, cu);
9140  if (cu->line_header == NULL)
9141  return;
9142 
9143  if (dwarf2_per_objfile->line_header_hash == NULL)
9144  slot = NULL;
9145  else
9146  {
9147  slot = htab_find_slot_with_hash (dwarf2_per_objfile->line_header_hash,
9148  &line_header_local,
9149  line_header_local_hash, INSERT);
9150  gdb_assert (slot != NULL);
9151  }
9152  if (slot != NULL && *slot == NULL)
9153  {
9154  /* This newly decoded line number information unit will be owned
9155  by line_header_hash hash table. */
9156  *slot = cu->line_header;
9157  }
9158  else
9159  {
9160  /* We cannot free any current entry in (*slot) as that struct line_header
9161  may be already used by multiple CUs. Create only temporary decoded
9162  line_header for this CU - it may happen at most once for each line
9163  number information unit. And if we're not using line_header_hash
9164  then this is what we want as well. */
9165  gdb_assert (die->tag != DW_TAG_partial_unit);
9167  }
9168  decode_mapping = (die->tag != DW_TAG_partial_unit);
9169  dwarf_decode_lines (cu->line_header, comp_dir, cu, NULL, lowpc,
9170  decode_mapping);
9171 }
9172 
9173 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
9174 
9175 static void
9176 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
9177 {
9178  struct objfile *objfile = dwarf2_per_objfile->objfile;
9179  struct gdbarch *gdbarch = get_objfile_arch (objfile);
9180  struct cleanup *back_to = make_cleanup (null_cleanup, 0);
9181  CORE_ADDR lowpc = ((CORE_ADDR) -1);
9182  CORE_ADDR highpc = ((CORE_ADDR) 0);
9183  struct attribute *attr;
9184  const char *name = NULL;
9185  const char *comp_dir = NULL;
9186  struct die_info *child_die;
9187  bfd *abfd = objfile->obfd;
9188  CORE_ADDR baseaddr;
9189 
9190  baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
9191 
9192  get_scope_pc_bounds (die, &lowpc, &highpc, cu);
9193 
9194  /* If we didn't find a lowpc, set it to highpc to avoid complaints
9195  from finish_block. */
9196  if (lowpc == ((CORE_ADDR) -1))
9197  lowpc = highpc;
9198  lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
9199 
9200  find_file_and_directory (die, cu, &name, &comp_dir);
9201 
9202  prepare_one_comp_unit (cu, die, cu->language);
9203 
9204  /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
9205  standardised yet. As a workaround for the language detection we fall
9206  back to the DW_AT_producer string. */
9207  if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL") != NULL)
9208  cu->language = language_opencl;
9209 
9210  /* Similar hack for Go. */
9211  if (cu->producer && strstr (cu->producer, "GNU Go ") != NULL)
9212  set_cu_language (DW_LANG_Go, cu);
9213 
9214  dwarf2_start_symtab (cu, name, comp_dir, lowpc);
9215 
9216  /* Decode line number information if present. We do this before
9217  processing child DIEs, so that the line header table is available
9218  for DW_AT_decl_file. */
9219  handle_DW_AT_stmt_list (die, cu, comp_dir, lowpc);
9220 
9221  /* Process all dies in compilation unit. */
9222  if (die->child != NULL)
9223  {
9224  child_die = die->child;
9225  while (child_die && child_die->tag)
9226  {
9227  process_die (child_die, cu);
9228  child_die = sibling_die (child_die);
9229  }
9230  }
9231 
9232  /* Decode macro information, if present. Dwarf 2 macro information
9233  refers to information in the line number info statement program
9234  header, so we can only read it if we've read the header
9235  successfully. */
9236  attr = dwarf2_attr (die, DW_AT_GNU_macros, cu);
9237  if (attr && cu->line_header)
9238  {
9239  if (dwarf2_attr (die, DW_AT_macro_info, cu))
9241  _("CU refers to both DW_AT_GNU_macros and DW_AT_macro_info"));
9242 
9243  dwarf_decode_macros (cu, DW_UNSND (attr), 1);
9244  }
9245  else
9246  {
9247  attr = dwarf2_attr (die, DW_AT_macro_info, cu);
9248  if (attr && cu->line_header)
9249  {
9250  unsigned int macro_offset = DW_UNSND (attr);
9251 
9252  dwarf_decode_macros (cu, macro_offset, 0);
9253  }
9254  }
9255 
9256  do_cleanups (back_to);
9257 }
9258 
9259 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
9260  Create the set of symtabs used by this TU, or if this TU is sharing
9261  symtabs with another TU and the symtabs have already been created
9262  then restore those symtabs in the line header.
9263  We don't need the pc/line-number mapping for type units. */
9264 
9265 static void
9266 setup_type_unit_groups (struct die_info *die, struct dwarf2_cu *cu)
9267 {
9268  struct objfile *objfile = dwarf2_per_objfile->objfile;
9269  struct dwarf2_per_cu_data *per_cu = cu->per_cu;
9270  struct type_unit_group *tu_group;
9271  int first_time;
9272  struct line_header *lh;
9273  struct attribute *attr;
9274  unsigned int i, line_offset;
9275  struct signatured_type *sig_type;
9276 
9277  gdb_assert (per_cu->is_debug_types);
9278  sig_type = (struct signatured_type *) per_cu;
9279 
9280  attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
9281 
9282  /* If we're using .gdb_index (includes -readnow) then
9283  per_cu->type_unit_group may not have been set up yet. */
9284  if (sig_type->type_unit_group == NULL)
9285  sig_type->type_unit_group = get_type_unit_group (cu, attr);
9286  tu_group = sig_type->type_unit_group;
9287 
9288  /* If we've already processed this stmt_list there's no real need to
9289  do it again, we could fake it and just recreate the part we need
9290  (file name,index -> symtab mapping). If data shows this optimization
9291  is useful we can do it then. */
9292  first_time = tu_group->compunit_symtab == NULL;
9293 
9294  /* We have to handle the case of both a missing DW_AT_stmt_list or bad
9295  debug info. */
9296  lh = NULL;
9297  if (attr != NULL)
9298  {
9299  line_offset = DW_UNSND (attr);
9300  lh = dwarf_decode_line_header (line_offset, cu);
9301  }
9302  if (lh == NULL)
9303  {
9304  if (first_time)
9305  dwarf2_start_symtab (cu, "", NULL, 0);
9306  else
9307  {
9308  gdb_assert (tu_group->symtabs == NULL);
9309  restart_symtab (tu_group->compunit_symtab, "", 0);
9310  }
9311  return;
9312  }
9313 
9314  cu->line_header = lh;
9316 
9317  if (first_time)
9318  {
9319  struct compunit_symtab *cust = dwarf2_start_symtab (cu, "", NULL, 0);
9320 
9321  tu_group->num_symtabs = lh->num_file_names;
9322  tu_group->symtabs = XNEWVEC (struct symtab *, lh->num_file_names);
9323 
9324  for (i = 0; i < lh->num_file_names; ++i)
9325  {
9326  const char *dir = NULL;
9327  struct file_entry *fe = &lh->file_names[i];
9328 
9329  if (fe->dir_index && lh->include_dirs != NULL)
9330  dir = lh->include_dirs[fe->dir_index - 1];
9331  dwarf2_start_subfile (fe->name, dir);
9332 
9333  if (current_subfile->symtab == NULL)
9334  {
9335  /* NOTE: start_subfile will recognize when it's been passed
9336  a file it has already seen. So we can't assume there's a
9337  simple mapping from lh->file_names to subfiles, plus
9338  lh->file_names may contain dups. */
9341  }
9342 
9343  fe->symtab = current_subfile->symtab;
9344  tu_group->symtabs[i] = fe->symtab;
9345  }
9346  }
9347  else
9348  {
9349  restart_symtab (tu_group->compunit_symtab, "", 0);
9350 
9351  for (i = 0; i < lh->num_file_names; ++i)
9352  {
9353  struct file_entry *fe = &lh->file_names[i];
9354 
9355  fe->symtab = tu_group->symtabs[i];
9356  }
9357  }
9358 
9359  /* The main symtab is allocated last. Type units don't have DW_AT_name
9360  so they don't have a "real" (so to speak) symtab anyway.
9361  There is later code that will assign the main symtab to all symbols
9362  that don't have one. We need to handle the case of a symbol with a
9363  missing symtab (DW_AT_decl_file) anyway. */
9364 }
9365 
9366 /* Process DW_TAG_type_unit.
9367  For TUs we want to skip the first top level sibling if it's not the
9368  actual type being defined by this TU. In this case the first top
9369  level sibling is there to provide context only. */
9370 
9371 static void
9372 read_type_unit_scope (struct die_info *die, struct dwarf2_cu *cu)
9373 {
9374  struct die_info *child_die;
9375 
9377 
9378  /* Initialize (or reinitialize) the machinery for building symtabs.
9379  We do this before processing child DIEs, so that the line header table
9380  is available for DW_AT_decl_file. */
9381  setup_type_unit_groups (die, cu);
9382 
9383  if (die->child != NULL)
9384  {
9385  child_die = die->child;
9386  while (child_die && child_die->tag)
9387  {
9388  process_die (child_die, cu);
9389  child_die = sibling_die (child_die);
9390  }
9391  }
9392 }
9393 
9394 /* DWO/DWP files.
9395 
9396  http://gcc.gnu.org/wiki/DebugFission
9397  http://gcc.gnu.org/wiki/DebugFissionDWP
9398 
9399  To simplify handling of both DWO files ("object" files with the DWARF info)
9400  and DWP files (a file with the DWOs packaged up into one file), we treat
9401  DWP files as having a collection of virtual DWO files. */
9402 
9403 static hashval_t
9404 hash_dwo_file (const void *item)
9405 {
9406  const struct dwo_file *dwo_file = item;
9407  hashval_t hash;
9408 
9409  hash = htab_hash_string (dwo_file->dwo_name);
9410  if (dwo_file->comp_dir != NULL)
9411  hash += htab_hash_string (dwo_file->comp_dir);
9412  return hash;
9413 }
9414 
9415 static int
9416 eq_dwo_file (const void *item_lhs, const void *item_rhs)
9417 {
9418  const struct dwo_file *lhs = item_lhs;
9419  const struct dwo_file *rhs = item_rhs;
9420 
9421  if (strcmp (lhs->dwo_name, rhs->dwo_name) != 0)
9422  return 0;
9423  if (lhs->comp_dir == NULL || rhs->comp_dir == NULL)
9424  return lhs->comp_dir == rhs->comp_dir;
9425  return strcmp (lhs->comp_dir, rhs->comp_dir) == 0;
9426 }
9427 
9428 /* Allocate a hash table for DWO files. */
9429 
9430 static htab_t
9432 {
9433  struct objfile *objfile = dwarf2_per_objfile->objfile;
9434 
9435  return htab_create_alloc_ex (41,
9436  hash_dwo_file,
9437  eq_dwo_file,
9438  NULL,
9439  &objfile->objfile_obstack,
9442 }
9443 
9444 /* Lookup DWO file DWO_NAME. */
9445 
9446 static void **
9447 lookup_dwo_file_slot (const char *dwo_name, const char *comp_dir)
9448 {
9449  struct dwo_file find_entry;
9450  void **slot;
9451 
9452  if (dwarf2_per_objfile->dwo_files == NULL)
9453  dwarf2_per_objfile->dwo_files = allocate_dwo_file_hash_table ();
9454 
9455  memset (&find_entry, 0, sizeof (find_entry));
9456  find_entry.dwo_name = dwo_name;
9457  find_entry.comp_dir = comp_dir;
9458  slot = htab_find_slot (dwarf2_per_objfile->dwo_files, &find_entry, INSERT);
9459 
9460  return slot;
9461 }
9462 
9463 static hashval_t
9464 hash_dwo_unit (const void *item)
9465 {
9466  const struct dwo_unit *dwo_unit = item;
9467 
9468  /* This drops the top 32 bits of the id, but is ok for a hash. */
9469  return dwo_unit->signature;
9470 }
9471 
9472 static int
9473 eq_dwo_unit (const void *item_lhs, const void *item_rhs)
9474 {
9475  const struct dwo_unit *lhs = item_lhs;
9476  const struct dwo_unit *rhs = item_rhs;
9477 
9478  /* The signature is assumed to be unique within the DWO file.
9479  So while object file CU dwo_id's always have the value zero,
9480  that's OK, assuming each object file DWO file has only one CU,
9481  and that's the rule for now. */
9482  return lhs->signature == rhs->signature;
9483 }
9484 
9485 /* Allocate a hash table for DWO CUs,TUs.
9486  There is one of these tables for each of CUs,TUs for each DWO file. */
9487 
9488 static htab_t
9489 allocate_dwo_unit_table (struct objfile *objfile)
9490 {
9491  /* Start out with a pretty small number.
9492  Generally DWO files contain only one CU and maybe some TUs. */
9493  return htab_create_alloc_ex (3,
9494  hash_dwo_unit,
9495  eq_dwo_unit,
9496  NULL,
9497  &objfile->objfile_obstack,
9500 }
9501 
9502 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader. */
9503 
9505 {
9506  struct dwo_file *dwo_file;
9508 };
9509 
9510 /* die_reader_func for create_dwo_cu. */
9511 
9512 static void
9514  const gdb_byte *info_ptr,
9515  struct die_info *comp_unit_die,
9516  int has_children,
9517  void *datap)
9518 {
9519  struct dwarf2_cu *cu = reader->cu;
9520  struct objfile *objfile = dwarf2_per_objfile->objfile;
9521  sect_offset offset = cu->per_cu->offset;
9522  struct dwarf2_section_info *section = cu->per_cu->section;
9523  struct create_dwo_cu_data *data = datap;
9524  struct dwo_file *dwo_file = data->dwo_file;
9525  struct dwo_unit *dwo_unit = &data->dwo_unit;
9526  struct attribute *attr;
9527 
9528  attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
9529  if (attr == NULL)
9530  {
9532  _("Dwarf Error: debug entry at offset 0x%x is missing"
9533  " its dwo_id [in module %s]"),
9534  offset.sect_off, dwo_file->dwo_name);
9535  return;
9536  }
9537 
9538  dwo_unit->dwo_file = dwo_file;
9539  dwo_unit->signature = DW_UNSND (attr);
9540  dwo_unit->section = section;
9541  dwo_unit->offset = offset;
9542  dwo_unit->length = cu->per_cu->length;
9543 
9544  if (dwarf_read_debug)
9545  fprintf_unfiltered (gdb_stdlog, " offset 0x%x, dwo_id %s\n",
9546  offset.sect_off, hex_string (dwo_unit->signature));
9547 }
9548 
9549 /* Create the dwo_unit for the lone CU in DWO_FILE.
9550  Note: This function processes DWO files only, not DWP files. */
9551 
9552 static struct dwo_unit *
9553 create_dwo_cu (struct dwo_file *dwo_file)
9554 {
9555  struct objfile *objfile = dwarf2_per_objfile->objfile;
9556  struct dwarf2_section_info *section = &dwo_file->sections.info;
9557  bfd *abfd;
9558  htab_t cu_htab;
9559  const gdb_byte *info_ptr, *end_ptr;
9560  struct create_dwo_cu_data create_dwo_cu_data;
9561  struct dwo_unit *dwo_unit;
9562 
9563  dwarf2_read_section (objfile, section);
9564  info_ptr = section->buffer;
9565 
9566  if (info_ptr == NULL)
9567  return NULL;
9568 
9569  /* We can't set abfd until now because the section may be empty or
9570  not present, in which case section->asection will be NULL. */
9571  abfd = get_section_bfd_owner (section);
9572 
9573  if (dwarf_read_debug)
9574  {
9575  fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
9576  get_section_name (section),
9577  get_section_file_name (section));
9578  }
9579 
9580  create_dwo_cu_data.dwo_file = dwo_file;
9581  dwo_unit = NULL;
9582 
9583  end_ptr = info_ptr + section->size;
9584  while (info_ptr < end_ptr)
9585  {
9586  struct dwarf2_per_cu_data per_cu;
9587 
9588  memset (&create_dwo_cu_data.dwo_unit, 0,
9589  sizeof (create_dwo_cu_data.dwo_unit));
9590  memset (&per_cu, 0, sizeof (per_cu));
9591  per_cu.objfile = objfile;
9592  per_cu.is_debug_types = 0;
9593  per_cu.offset.sect_off = info_ptr - section->buffer;
9594  per_cu.section = section;
9595 
9596  init_cutu_and_read_dies_no_follow (&per_cu, dwo_file,
9598  &create_dwo_cu_data);
9599 
9600  if (create_dwo_cu_data.dwo_unit.dwo_file != NULL)
9601  {
9602  /* If we've already found one, complain. We only support one
9603  because having more than one requires hacking the dwo_name of
9604  each to match, which is highly unlikely to happen. */
9605  if (dwo_unit != NULL)
9606  {
9608  _("Multiple CUs in DWO file %s [in module %s]"),
9609  dwo_file->dwo_name, objfile_name (objfile));
9610  break;
9611  }
9612 
9613  dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
9614  *dwo_unit = create_dwo_cu_data.dwo_unit;
9615  }
9616 
9617  info_ptr += per_cu.length;
9618  }
9619 
9620  return dwo_unit;
9621 }
9622 
9623 /* DWP file .debug_{cu,tu}_index section format:
9624  [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
9625 
9626  DWP Version 1:
9627 
9628  Both index sections have the same format, and serve to map a 64-bit
9629  signature to a set of section numbers. Each section begins with a header,
9630  followed by a hash table of 64-bit signatures, a parallel table of 32-bit
9631  indexes, and a pool of 32-bit section numbers. The index sections will be
9632  aligned at 8-byte boundaries in the file.
9633 
9634  The index section header consists of:
9635 
9636  V, 32 bit version number
9637  -, 32 bits unused
9638  N, 32 bit number of compilation units or type units in the index
9639  M, 32 bit number of slots in the hash table
9640 
9641  Numbers are recorded using the byte order of the application binary.
9642 
9643  The hash table begins at offset 16 in the section, and consists of an array
9644  of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
9645  order of the application binary). Unused slots in the hash table are 0.
9646  (We rely on the extreme unlikeliness of a signature being exactly 0.)
9647 
9648  The parallel table begins immediately after the hash table
9649  (at offset 16 + 8 * M from the beginning of the section), and consists of an
9650  array of 32-bit indexes (using the byte order of the application binary),
9651  corresponding 1-1 with slots in the hash table. Each entry in the parallel
9652  table contains a 32-bit index into the pool of section numbers. For unused
9653  hash table slots, the corresponding entry in the parallel table will be 0.
9654 
9655  The pool of section numbers begins immediately following the hash table
9656  (at offset 16 + 12 * M from the beginning of the section). The pool of
9657  section numbers consists of an array of 32-bit words (using the byte order
9658  of the application binary). Each item in the array is indexed starting
9659  from 0. The hash table entry provides the index of the first section
9660  number in the set. Additional section numbers in the set follow, and the
9661  set is terminated by a 0 entry (section number 0 is not used in ELF).
9662 
9663  In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
9664  section must be the first entry in the set, and the .debug_abbrev.dwo must
9665  be the second entry. Other members of the set may follow in any order.
9666 
9667  ---
9668 
9669  DWP Version 2:
9670 
9671  DWP Version 2 combines all the .debug_info, etc. sections into one,
9672  and the entries in the index tables are now offsets into these sections.
9673  CU offsets begin at 0. TU offsets begin at the size of the .debug_info
9674  section.
9675 
9676  Index Section Contents:
9677  Header
9678  Hash Table of Signatures dwp_hash_table.hash_table
9679  Parallel Table of Indices dwp_hash_table.unit_table
9680  Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets}
9681  Table of Section Sizes dwp_hash_table.v2.sizes
9682 
9683  The index section header consists of:
9684 
9685  V, 32 bit version number
9686  L, 32 bit number of columns in the table of section offsets
9687  N, 32 bit number of compilation units or type units in the index
9688  M, 32 bit number of slots in the hash table
9689 
9690  Numbers are recorded using the byte order of the application binary.
9691 
9692  The hash table has the same format as version 1.
9693  The parallel table of indices has the same format as version 1,
9694  except that the entries are origin-1 indices into the table of sections
9695  offsets and the table of section sizes.
9696 
9697  The table of offsets begins immediately following the parallel table
9698  (at offset 16 + 12 * M from the beginning of the section). The table is
9699  a two-dimensional array of 32-bit words (using the byte order of the
9700  application binary), with L columns and N+1 rows, in row-major order.
9701  Each row in the array is indexed starting from 0. The first row provides
9702  a key to the remaining rows: each column in this row provides an identifier
9703  for a debug section, and the offsets in the same column of subsequent rows
9704  refer to that section. The section identifiers are:
9705 
9706  DW_SECT_INFO 1 .debug_info.dwo
9707  DW_SECT_TYPES 2 .debug_types.dwo
9708  DW_SECT_ABBREV 3 .debug_abbrev.dwo
9709  DW_SECT_LINE 4 .debug_line.dwo
9710  DW_SECT_LOC 5 .debug_loc.dwo
9711  DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
9712  DW_SECT_MACINFO 7 .debug_macinfo.dwo
9713  DW_SECT_MACRO 8 .debug_macro.dwo
9714 
9715  The offsets provided by the CU and TU index sections are the base offsets
9716  for the contributions made by each CU or TU to the corresponding section
9717  in the package file. Each CU and TU header contains an abbrev_offset
9718  field, used to find the abbreviations table for that CU or TU within the
9719  contribution to the .debug_abbrev.dwo section for that CU or TU, and should
9720  be interpreted as relative to the base offset given in the index section.
9721  Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
9722  should be interpreted as relative to the base offset for .debug_line.dwo,
9723  and offsets into other debug sections obtained from DWARF attributes should
9724  also be interpreted as relative to the corresponding base offset.
9725 
9726  The table of sizes begins immediately following the table of offsets.
9727  Like the table of offsets, it is a two-dimensional array of 32-bit words,
9728  with L columns and N rows, in row-major order. Each row in the array is
9729  indexed starting from 1 (row 0 is shared by the two tables).
9730 
9731  ---
9732 
9733  Hash table lookup is handled the same in version 1 and 2:
9734 
9735  We assume that N and M will not exceed 2^32 - 1.
9736  The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
9737 
9738  Given a 64-bit compilation unit signature or a type signature S, an entry
9739  in the hash table is located as follows:
9740 
9741  1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
9742  the low-order k bits all set to 1.
9743 
9744  2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
9745 
9746  3) If the hash table entry at index H matches the signature, use that
9747  entry. If the hash table entry at index H is unused (all zeroes),
9748  terminate the search: the signature is not present in the table.
9749 
9750  4) Let H = (H + H') modulo M. Repeat at Step 3.
9751 
9752  Because M > N and H' and M are relatively prime, the search is guaranteed
9753  to stop at an unused slot or find the match. */
9754 
9755 /* Create a hash table to map DWO IDs to their CU/TU entry in
9756  .debug_{info,types}.dwo in DWP_FILE.
9757  Returns NULL if there isn't one.
9758  Note: This function processes DWP files only, not DWO files. */
9759 
9760 static struct dwp_hash_table *
9761 create_dwp_hash_table (struct dwp_file *dwp_file, int is_debug_types)
9762 {
9763  struct objfile *objfile = dwarf2_per_objfile->objfile;
9764  bfd *dbfd = dwp_file->dbfd;
9765  const gdb_byte *index_ptr, *index_end;
9766  struct dwarf2_section_info *index;
9767  uint32_t version, nr_columns, nr_units, nr_slots;
9768  struct dwp_hash_table *htab;
9769 
9770  if (is_debug_types)
9771  index = &dwp_file->sections.tu_index;
9772  else
9773  index = &dwp_file->sections.cu_index;
9774 
9775  if (dwarf2_section_empty_p (index))
9776  return NULL;
9777  dwarf2_read_section (objfile, index);
9778 
9779  index_ptr = index->buffer;
9780  index_end = index_ptr + index->size;
9781 
9782  version = read_4_bytes (dbfd, index_ptr);
9783  index_ptr += 4;
9784  if (version == 2)
9785  nr_columns = read_4_bytes (dbfd, index_ptr);
9786  else
9787  nr_columns = 0;
9788  index_ptr += 4;
9789  nr_units = read_4_bytes (dbfd, index_ptr);
9790  index_ptr += 4;
9791  nr_slots = read_4_bytes (dbfd, index_ptr);
9792  index_ptr += 4;
9793 
9794  if (version != 1 && version != 2)
9795  {
9796  error (_("Dwarf Error: unsupported DWP file version (%s)"
9797  " [in module %s]"),
9798  pulongest (version), dwp_file->name);
9799  }
9800  if (nr_slots != (nr_slots & -nr_slots))
9801  {
9802  error (_("Dwarf Error: number of slots in DWP hash table (%s)"
9803  " is not power of 2 [in module %s]"),
9804  pulongest (nr_slots), dwp_file->name);
9805  }
9806 
9807  htab = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_hash_table);
9808  htab->version = version;
9809  htab->nr_columns = nr_columns;
9810  htab->nr_units = nr_units;
9811  htab->nr_slots = nr_slots;
9812  htab->hash_table = index_ptr;
9813  htab->unit_table = htab->hash_table + sizeof (uint64_t) * nr_slots;
9814 
9815  /* Exit early if the table is empty. */
9816  if (nr_slots == 0 || nr_units == 0
9817  || (version == 2 && nr_columns == 0))
9818  {
9819  /* All must be zero. */
9820  if (nr_slots != 0 || nr_units != 0
9821  || (version == 2 && nr_columns != 0))
9822  {
9824  _("Empty DWP but nr_slots,nr_units,nr_columns not"
9825  " all zero [in modules %s]"),
9826  dwp_file->name);
9827  }
9828  return htab;
9829  }
9830 
9831  if (version == 1)
9832  {
9833  htab->section_pool.v1.indices =
9834  htab->unit_table + sizeof (uint32_t) * nr_slots;
9835  /* It's harder to decide whether the section is too small in v1.
9836  V1 is deprecated anyway so we punt. */
9837  }
9838  else
9839  {
9840  const gdb_byte *ids_ptr = htab->unit_table + sizeof (uint32_t) * nr_slots;
9841  int *ids = htab->section_pool.v2.section_ids;
9842  /* Reverse map for error checking. */
9843  int ids_seen[DW_SECT_MAX + 1];
9844  int i;
9845 
9846  if (nr_columns < 2)
9847  {
9848  error (_("Dwarf Error: bad DWP hash table, too few columns"
9849  " in section table [in module %s]"),
9850  dwp_file->name);
9851  }
9852  if (nr_columns > MAX_NR_V2_DWO_SECTIONS)
9853  {
9854  error (_("Dwarf Error: bad DWP hash table, too many columns"
9855  " in section table [in module %s]"),
9856  dwp_file->name);
9857  }
9858  memset (ids, 255, (DW_SECT_MAX + 1) * sizeof (int32_t));
9859  memset (ids_seen, 255, (DW_SECT_MAX + 1) * sizeof (int32_t));
9860  for (i = 0; i < nr_columns; ++i)
9861  {
9862  int id = read_4_bytes (dbfd, ids_ptr + i * sizeof (uint32_t));
9863 
9864  if (id < DW_SECT_MIN || id > DW_SECT_MAX)
9865  {
9866  error (_("Dwarf Error: bad DWP hash table, bad section id %d"
9867  " in section table [in module %s]"),
9868  id, dwp_file->name);
9869  }
9870  if (ids_seen[id] != -1)
9871  {
9872  error (_("Dwarf Error: bad DWP hash table, duplicate section"
9873  " id %d in section table [in module %s]"),
9874  id, dwp_file->name);
9875  }
9876  ids_seen[id] = i;
9877  ids[i] = id;
9878  }
9879  /* Must have exactly one info or types section. */
9880  if (((ids_seen[DW_SECT_INFO] != -1)
9881  + (ids_seen[DW_SECT_TYPES] != -1))
9882  != 1)
9883  {
9884  error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
9885  " DWO info/types section [in module %s]"),
9886  dwp_file->name);
9887  }
9888  /* Must have an abbrev section. */
9889  if (ids_seen[DW_SECT_ABBREV] == -1)
9890  {
9891  error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
9892  " section [in module %s]"),
9893  dwp_file->name);
9894  }
9895  htab->section_pool.v2.offsets = ids_ptr + sizeof (uint32_t) * nr_columns;
9896  htab->section_pool.v2.sizes =
9897  htab->section_pool.v2.offsets + (sizeof (uint32_t)
9898  * nr_units * nr_columns);
9899  if ((htab->section_pool.v2.sizes + (sizeof (uint32_t)
9900  * nr_units * nr_columns))
9901  > index_end)
9902  {
9903  error (_("Dwarf Error: DWP index section is corrupt (too small)"
9904  " [in module %s]"),
9905  dwp_file->name);
9906  }
9907  }
9908 
9909  return htab;
9910 }
9911 
9912 /* Update SECTIONS with the data from SECTP.
9913 
9914  This function is like the other "locate" section routines that are
9915  passed to bfd_map_over_sections, but in this context the sections to
9916  read comes from the DWP V1 hash table, not the full ELF section table.
9917 
9918  The result is non-zero for success, or zero if an error was found. */
9919 
9920 static int
9922  struct virtual_v1_dwo_sections *sections)
9923 {
9924  const struct dwop_section_names *names = &dwop_section_names;
9925 
9926  if (section_is_p (sectp->name, &names->abbrev_dwo))
9927  {
9928  /* There can be only one. */
9929  if (sections->abbrev.s.asection != NULL)
9930  return 0;
9931  sections->abbrev.s.asection = sectp;
9932  sections->abbrev.size = bfd_get_section_size (sectp);
9933  }
9934  else if (section_is_p (sectp->name, &names->info_dwo)
9935  || section_is_p (sectp->name, &names->types_dwo))
9936  {
9937  /* There can be only one. */
9938  if (sections->info_or_types.s.asection != NULL)
9939  return 0;
9940  sections->info_or_types.s.asection = sectp;
9941  sections->info_or_types.size = bfd_get_section_size (sectp);
9942  }
9943  else if (section_is_p (sectp->name, &names->line_dwo))
9944  {
9945  /* There can be only one. */
9946  if (sections->line.s.asection != NULL)
9947  return 0;
9948  sections->line.s.asection = sectp;
9949  sections->line.size = bfd_get_section_size (sectp);
9950  }
9951  else if (section_is_p (sectp->name, &names->loc_dwo))
9952  {
9953  /* There can be only one. */
9954  if (sections->loc.s.asection != NULL)
9955  return 0;
9956  sections->loc.s.asection = sectp;
9957  sections->loc.size = bfd_get_section_size (sectp);
9958  }
9959  else if (section_is_p (sectp->name, &names->macinfo_dwo))
9960  {
9961  /* There can be only one. */
9962  if (sections->macinfo.s.asection != NULL)
9963  return 0;
9964  sections->macinfo.s.asection = sectp;
9965  sections->macinfo.size = bfd_get_section_size (sectp);
9966  }
9967  else if (section_is_p (sectp->name, &names->macro_dwo))
9968  {
9969  /* There can be only one. */
9970  if (sections->macro.s.asection != NULL)
9971  return 0;
9972  sections->macro.s.asection = sectp;
9973  sections->macro.size = bfd_get_section_size (sectp);
9974  }
9975  else if (section_is_p (sectp->name, &names->str_offsets_dwo))
9976  {
9977  /* There can be only one. */
9978  if (sections->str_offsets.s.asection != NULL)
9979  return 0;
9980  sections->str_offsets.s.asection = sectp;
9981  sections->str_offsets.size = bfd_get_section_size (sectp);
9982  }
9983  else
9984  {
9985  /* No other kind of section is valid. */
9986  return 0;
9987  }
9988 
9989  return 1;
9990 }
9991 
9992 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
9993  UNIT_INDEX is the index of the DWO unit in the DWP hash table.
9994  COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
9995  This is for DWP version 1 files. */
9996 
9997 static struct dwo_unit *
9999  uint32_t unit_index,
10000  const char *comp_dir,
10001  ULONGEST signature, int is_debug_types)
10002 {
10003  struct objfile *objfile = dwarf2_per_objfile->objfile;
10004  const struct dwp_hash_table *dwp_htab =
10005  is_debug_types ? dwp_file->tus : dwp_file->cus;
10006  bfd *dbfd = dwp_file->dbfd;
10007  const char *kind = is_debug_types ? "TU" : "CU";
10008  struct dwo_file *dwo_file;
10009  struct dwo_unit *dwo_unit;
10010  struct virtual_v1_dwo_sections sections;
10011  void **dwo_file_slot;
10012  char *virtual_dwo_name;
10013  struct dwarf2_section_info *cutu;
10014  struct cleanup *cleanups;
10015  int i;
10016 
10017  gdb_assert (dwp_file->version == 1);
10018 
10019  if (dwarf_read_debug)
10020  {
10021  fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V1 file: %s\n",
10022  kind,
10023  pulongest (unit_index), hex_string (signature),
10024  dwp_file->name);
10025  }
10026 
10027  /* Fetch the sections of this DWO unit.
10028  Put a limit on the number of sections we look for so that bad data
10029  doesn't cause us to loop forever. */
10030 
10031 #define MAX_NR_V1_DWO_SECTIONS \
10032  (1 /* .debug_info or .debug_types */ \
10033  + 1 /* .debug_abbrev */ \
10034  + 1 /* .debug_line */ \
10035  + 1 /* .debug_loc */ \
10036  + 1 /* .debug_str_offsets */ \
10037  + 1 /* .debug_macro or .debug_macinfo */ \
10038  + 1 /* trailing zero */)
10039 
10040  memset (&sections, 0, sizeof (sections));
10041  cleanups = make_cleanup (null_cleanup, 0);
10042 
10043  for (i = 0; i < MAX_NR_V1_DWO_SECTIONS; ++i)
10044  {
10045  asection *sectp;
10046  uint32_t section_nr =
10047  read_4_bytes (dbfd,
10048  dwp_htab->section_pool.v1.indices
10049  + (unit_index + i) * sizeof (uint32_t));
10050 
10051  if (section_nr == 0)
10052  break;
10053  if (section_nr >= dwp_file->num_sections)
10054  {
10055  error (_("Dwarf Error: bad DWP hash table, section number too large"
10056  " [in module %s]"),
10057  dwp_file->name);
10058  }
10059 
10060  sectp = dwp_file->elf_sections[section_nr];
10061  if (! locate_v1_virtual_dwo_sections (sectp, &sections))
10062  {
10063  error (_("Dwarf Error: bad DWP hash table, invalid section found"
10064  " [in module %s]"),
10065  dwp_file->name);
10066  }
10067  }
10068 
10069  if (i < 2
10070  || dwarf2_section_empty_p (&sections.info_or_types)
10071  || dwarf2_section_empty_p (&sections.abbrev))
10072  {
10073  error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
10074  " [in module %s]"),
10075  dwp_file->name);
10076  }
10077  if (i == MAX_NR_V1_DWO_SECTIONS)
10078  {
10079  error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
10080  " [in module %s]"),
10081  dwp_file->name);
10082  }
10083 
10084  /* It's easier for the rest of the code if we fake a struct dwo_file and
10085  have dwo_unit "live" in that. At least for now.
10086 
10087  The DWP file can be made up of a random collection of CUs and TUs.
10088  However, for each CU + set of TUs that came from the same original DWO
10089  file, we can combine them back into a virtual DWO file to save space
10090  (fewer struct dwo_file objects to allocate). Remember that for really
10091  large apps there can be on the order of 8K CUs and 200K TUs, or more. */
10092 
10093  virtual_dwo_name =
10094  xstrprintf ("virtual-dwo/%d-%d-%d-%d",
10095  get_section_id (&sections.abbrev),
10096  get_section_id (&sections.line),
10097  get_section_id (&sections.loc),
10098  get_section_id (&sections.str_offsets));
10099  make_cleanup (xfree, virtual_dwo_name);
10100  /* Can we use an existing virtual DWO file? */
10101  dwo_file_slot = lookup_dwo_file_slot (virtual_dwo_name, comp_dir);
10102  /* Create one if necessary. */
10103  if (*dwo_file_slot == NULL)
10104  {
10105  if (dwarf_read_debug)
10106  {
10107  fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
10108  virtual_dwo_name);
10109  }
10110  dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
10111  dwo_file->dwo_name = obstack_copy0 (&objfile->objfile_obstack,
10112  virtual_dwo_name,
10113  strlen (virtual_dwo_name));
10114  dwo_file->comp_dir = comp_dir;
10115  dwo_file->sections.abbrev = sections.abbrev;
10116  dwo_file->sections.line = sections.line;
10117  dwo_file->sections.loc = sections.loc;
10118  dwo_file->sections.macinfo = sections.macinfo;
10119  dwo_file->sections.macro = sections.macro;
10120  dwo_file->sections.str_offsets = sections.str_offsets;
10121  /* The "str" section is global to the entire DWP file. */
10122  dwo_file->sections.str = dwp_file->sections.str;
10123  /* The info or types section is assigned below to dwo_unit,
10124  there's no need to record it in dwo_file.
10125  Also, we can't simply record type sections in dwo_file because
10126  we record a pointer into the vector in dwo_unit. As we collect more
10127  types we'll grow the vector and eventually have to reallocate space
10128  for it, invalidating all copies of pointers into the previous
10129  contents. */
10130  *dwo_file_slot = dwo_file;
10131  }
10132  else
10133  {
10134  if (dwarf_read_debug)
10135  {
10136  fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
10137  virtual_dwo_name);
10138  }
10139  dwo_file = *dwo_file_slot;
10140  }
10141  do_cleanups (cleanups);
10142 
10143  dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
10144  dwo_unit->dwo_file = dwo_file;
10145  dwo_unit->signature = signature;
10146  dwo_unit->section = obstack_alloc (&objfile->objfile_obstack,
10147  sizeof (struct dwarf2_section_info));
10148  *dwo_unit->section = sections.info_or_types;
10149  /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
10150 
10151  return dwo_unit;
10152 }
10153 
10154 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
10155  Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
10156  piece within that section used by a TU/CU, return a virtual section
10157  of just that piece. */
10158 
10159 static struct dwarf2_section_info
10161  bfd_size_type offset, bfd_size_type size)
10162 {
10163  struct dwarf2_section_info result;
10164  asection *sectp;
10165 
10166  gdb_assert (section != NULL);
10167  gdb_assert (!section->is_virtual);
10168 
10169  memset (&result, 0, sizeof (result));
10170  result.s.containing_section = section;
10171  result.is_virtual = 1;
10172 
10173  if (size == 0)
10174  return result;
10175 
10176  sectp = get_section_bfd_section (section);
10177 
10178  /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
10179  bounds of the real section. This is a pretty-rare event, so just
10180  flag an error (easier) instead of a warning and trying to cope. */
10181  if (sectp == NULL
10182  || offset + size > bfd_get_section_size (sectp))
10183  {
10184  bfd *abfd = sectp->owner;
10185 
10186  error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
10187  " in section %s [in module %s]"),
10188  sectp ? bfd_section_name (abfd, sectp) : "<unknown>",
10189  objfile_name (dwarf2_per_objfile->objfile));
10190  }
10191 
10192  result.virtual_offset = offset;
10193  result.size = size;
10194  return result;
10195 }
10196 
10197 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
10198  UNIT_INDEX is the index of the DWO unit in the DWP hash table.
10199  COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
10200  This is for DWP version 2 files. */
10201 
10202 static struct dwo_unit *
10204  uint32_t unit_index,
10205  const char *comp_dir,
10206  ULONGEST signature, int is_debug_types)
10207 {
10208  struct objfile *objfile = dwarf2_per_objfile->objfile;
10209  const struct dwp_hash_table *dwp_htab =
10210  is_debug_types ? dwp_file->tus : dwp_file->cus;
10211  bfd *dbfd = dwp_file->dbfd;
10212  const char *kind = is_debug_types ? "TU" : "CU";
10213  struct dwo_file *dwo_file;
10214  struct dwo_unit *dwo_unit;
10215  struct virtual_v2_dwo_sections sections;
10216  void **dwo_file_slot;
10217  char *virtual_dwo_name;
10218  struct dwarf2_section_info *cutu;
10219  struct cleanup *cleanups;
10220  int i;
10221 
10222  gdb_assert (dwp_file->version == 2);
10223 
10224  if (dwarf_read_debug)
10225  {
10226  fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V2 file: %s\n",
10227  kind,
10228  pulongest (unit_index), hex_string (signature),
10229  dwp_file->name);
10230  }
10231 
10232  /* Fetch the section offsets of this DWO unit. */
10233 
10234  memset (&sections, 0, sizeof (sections));
10235  cleanups = make_cleanup (null_cleanup, 0);
10236 
10237  for (i = 0; i < dwp_htab->nr_columns; ++i)
10238  {
10239  uint32_t offset = read_4_bytes (dbfd,
10240  dwp_htab->section_pool.v2.offsets
10241  + (((unit_index - 1) * dwp_htab->nr_columns
10242  + i)
10243  * sizeof (uint32_t)));
10244  uint32_t size = read_4_bytes (dbfd,
10245  dwp_htab->section_pool.v2.sizes
10246  + (((unit_index - 1) * dwp_htab->nr_columns
10247  + i)
10248  * sizeof (uint32_t)));
10249 
10250  switch (dwp_htab->section_pool.v2.section_ids[i])
10251  {
10252  case DW_SECT_INFO:
10253  case DW_SECT_TYPES:
10254  sections.info_or_types_offset = offset;
10255  sections.info_or_types_size = size;
10256  break;
10257  case DW_SECT_ABBREV:
10258  sections.abbrev_offset = offset;
10259  sections.abbrev_size = size;
10260  break;
10261  case DW_SECT_LINE:
10262  sections.line_offset = offset;
10263  sections.line_size = size;
10264  break;
10265  case DW_SECT_LOC:
10266  sections.loc_offset = offset;
10267  sections.loc_size = size;
10268  break;
10269  case DW_SECT_STR_OFFSETS:
10270  sections.str_offsets_offset = offset;
10271  sections.str_offsets_size = size;
10272  break;
10273  case DW_SECT_MACINFO:
10274  sections.macinfo_offset = offset;
10275  sections.macinfo_size = size;
10276  break;
10277  case DW_SECT_MACRO:
10278  sections.macro_offset = offset;
10279  sections.macro_size = size;
10280  break;
10281  }
10282  }
10283 
10284  /* It's easier for the rest of the code if we fake a struct dwo_file and
10285  have dwo_unit "live" in that. At least for now.
10286 
10287  The DWP file can be made up of a random collection of CUs and TUs.
10288  However, for each CU + set of TUs that came from the same original DWO
10289  file, we can combine them back into a virtual DWO file to save space
10290  (fewer struct dwo_file objects to allocate). Remember that for really
10291  large apps there can be on the order of 8K CUs and 200K TUs, or more. */
10292 
10293  virtual_dwo_name =
10294  xstrprintf ("virtual-dwo/%ld-%ld-%ld-%ld",
10295  (long) (sections.abbrev_size ? sections.abbrev_offset : 0),
10296  (long) (sections.line_size ? sections.line_offset : 0),
10297  (long) (sections.loc_size ? sections.loc_offset : 0),
10298  (long) (sections.str_offsets_size
10299  ? sections.str_offsets_offset : 0));
10300  make_cleanup (xfree, virtual_dwo_name);
10301  /* Can we use an existing virtual DWO file? */
10302  dwo_file_slot = lookup_dwo_file_slot (virtual_dwo_name, comp_dir);
10303  /* Create one if necessary. */
10304  if (*dwo_file_slot == NULL)
10305  {
10306  if (dwarf_read_debug)
10307  {
10308  fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
10309  virtual_dwo_name);
10310  }
10311  dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
10312  dwo_file->dwo_name = obstack_copy0 (&objfile->objfile_obstack,
10313  virtual_dwo_name,
10314  strlen (virtual_dwo_name));
10315  dwo_file->comp_dir = comp_dir;
10316  dwo_file->sections.abbrev =
10318  sections.abbrev_offset, sections.abbrev_size);
10319  dwo_file->sections.line =
10320  create_dwp_v2_section (&dwp_file->sections.line,
10321  sections.line_offset, sections.line_size);
10322  dwo_file->sections.loc =
10323  create_dwp_v2_section (&dwp_file->sections.loc,
10324  sections.loc_offset, sections.loc_size);
10325  dwo_file->sections.macinfo =
10327  sections.macinfo_offset, sections.macinfo_size);
10328  dwo_file->sections.macro =
10329  create_dwp_v2_section (&dwp_file->sections.macro,
10330  sections.macro_offset, sections.macro_size);
10331  dwo_file->sections.str_offsets =
10333  sections.str_offsets_offset,
10334  sections.str_offsets_size);
10335  /* The "str" section is global to the entire DWP file. */
10336  dwo_file->sections.str = dwp_file->sections.str;
10337  /* The info or types section is assigned below to dwo_unit,
10338  there's no need to record it in dwo_file.
10339  Also, we can't simply record type sections in dwo_file because
10340  we record a pointer into the vector in dwo_unit. As we collect more
10341  types we'll grow the vector and eventually have to reallocate space
10342  for it, invalidating all copies of pointers into the previous
10343  contents. */
10344  *dwo_file_slot = dwo_file;
10345  }
10346  else
10347  {
10348  if (dwarf_read_debug)
10349  {
10350  fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
10351  virtual_dwo_name);
10352  }
10353  dwo_file = *dwo_file_slot;
10354  }
10355  do_cleanups (cleanups);
10356 
10357  dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
10358  dwo_unit->dwo_file = dwo_file;
10359  dwo_unit->signature = signature;
10360  dwo_unit->section = obstack_alloc (&objfile->objfile_obstack,
10361  sizeof (struct dwarf2_section_info));
10362  *dwo_unit->section = create_dwp_v2_section (is_debug_types
10363  ? &dwp_file->sections.types
10364  : &dwp_file->sections.info,
10365  sections.info_or_types_offset,
10366  sections.info_or_types_size);
10367  /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
10368 
10369  return dwo_unit;
10370 }
10371 
10372 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
10373  Returns NULL if the signature isn't found. */
10374 
10375 static struct dwo_unit *
10376 lookup_dwo_unit_in_dwp (struct dwp_file *dwp_file, const char *comp_dir,
10377  ULONGEST signature, int is_debug_types)
10378 {
10379  const struct dwp_hash_table *dwp_htab =
10380  is_debug_types ? dwp_file->tus : dwp_file->cus;
10381  bfd *dbfd = dwp_file->dbfd;
10382  uint32_t mask = dwp_htab->nr_slots - 1;
10383  uint32_t hash = signature & mask;
10384  uint32_t hash2 = ((signature >> 32) & mask) | 1;
10385  unsigned int i;
10386  void **slot;
10387  struct dwo_unit find_dwo_cu, *dwo_cu;
10388 
10389  memset (&find_dwo_cu, 0, sizeof (find_dwo_cu));
10390  find_dwo_cu.signature = signature;
10391  slot = htab_find_slot (is_debug_types
10392  ? dwp_file->loaded_tus
10393  : dwp_file->loaded_cus,
10394  &find_dwo_cu, INSERT);
10395 
10396  if (*slot != NULL)
10397  return *slot;
10398 
10399  /* Use a for loop so that we don't loop forever on bad debug info. */
10400  for (i = 0; i < dwp_htab->nr_slots; ++i)
10401  {
10402  ULONGEST signature_in_table;
10403 
10404  signature_in_table =
10405  read_8_bytes (dbfd, dwp_htab->hash_table + hash * sizeof (uint64_t));
10406  if (signature_in_table == signature)
10407  {
10408  uint32_t unit_index =
10409  read_4_bytes (dbfd,
10410  dwp_htab->unit_table + hash * sizeof (uint32_t));
10411 
10412  if (dwp_file->version == 1)
10413  {
10414  *slot = create_dwo_unit_in_dwp_v1 (dwp_file, unit_index,
10415  comp_dir, signature,
10416  is_debug_types);
10417  }
10418  else
10419  {
10420  *slot = create_dwo_unit_in_dwp_v2 (dwp_file, unit_index,
10421  comp_dir, signature,
10422  is_debug_types);
10423  }
10424  return *slot;
10425  }
10426  if (signature_in_table == 0)
10427  return NULL;
10428  hash = (hash + hash2) & mask;
10429  }
10430 
10431  error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
10432  " [in module %s]"),
10433  dwp_file->name);
10434 }
10435 
10436 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
10437  Open the file specified by FILE_NAME and hand it off to BFD for
10438  preliminary analysis. Return a newly initialized bfd *, which
10439  includes a canonicalized copy of FILE_NAME.
10440  If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
10441  SEARCH_CWD is true if the current directory is to be searched.
10442  It will be searched before debug-file-directory.
10443  If successful, the file is added to the bfd include table of the
10444  objfile's bfd (see gdb_bfd_record_inclusion).
10445  If unable to find/open the file, return NULL.
10446  NOTE: This function is derived from symfile_bfd_open. */
10447 
10448 static bfd *
10449 try_open_dwop_file (const char *file_name, int is_dwp, int search_cwd)
10450 {
10451  bfd *sym_bfd;
10452  int desc, flags;
10453  char *absolute_name;
10454  /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
10455  FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
10456  to debug_file_directory. */
10457  char *search_path;
10458  static const char dirname_separator_string[] = { DIRNAME_SEPARATOR, '\0' };
10459 
10460  if (search_cwd)
10461  {
10462  if (*debug_file_directory != '\0')
10463  search_path = concat (".", dirname_separator_string,
10464  debug_file_directory, NULL);
10465  else
10466  search_path = xstrdup (".");
10467  }
10468  else
10469  search_path = xstrdup (debug_file_directory);
10470 
10471  flags = OPF_RETURN_REALPATH;
10472  if (is_dwp)
10473  flags |= OPF_SEARCH_IN_PATH;
10474  desc = openp (search_path, flags, file_name,
10475  O_RDONLY | O_BINARY, &absolute_name);
10476  xfree (search_path);
10477  if (desc < 0)
10478  return NULL;
10479 
10480  sym_bfd = gdb_bfd_open (absolute_name, gnutarget, desc);
10481  xfree (absolute_name);
10482  if (sym_bfd == NULL)
10483  return NULL;
10484  bfd_set_cacheable (sym_bfd, 1);
10485 
10486  if (!bfd_check_format (sym_bfd, bfd_object))
10487  {
10488  gdb_bfd_unref (sym_bfd); /* This also closes desc. */
10489  return NULL;
10490  }
10491 
10492  /* Success. Record the bfd as having been included by the objfile's bfd.
10493  This is important because things like demangled_names_hash lives in the
10494  objfile's per_bfd space and may have references to things like symbol
10495  names that live in the DWO/DWP file's per_bfd space. PR 16426. */
10496  gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd, sym_bfd);
10497 
10498  return sym_bfd;
10499 }
10500 
10501 /* Try to open DWO file FILE_NAME.
10502  COMP_DIR is the DW_AT_comp_dir attribute.
10503  The result is the bfd handle of the file.
10504  If there is a problem finding or opening the file, return NULL.
10505  Upon success, the canonicalized path of the file is stored in the bfd,
10506  same as symfile_bfd_open. */
10507 
10508 static bfd *
10509 open_dwo_file (const char *file_name, const char *comp_dir)
10510 {
10511  bfd *abfd;
10512 
10513  if (IS_ABSOLUTE_PATH (file_name))
10514  return try_open_dwop_file (file_name, 0 /*is_dwp*/, 0 /*search_cwd*/);
10515 
10516  /* Before trying the search path, try DWO_NAME in COMP_DIR. */
10517 
10518  if (comp_dir != NULL)
10519  {
10520  char *path_to_try = concat (comp_dir, SLASH_STRING, file_name, NULL);
10521 
10522  /* NOTE: If comp_dir is a relative path, this will also try the
10523  search path, which seems useful. */
10524  abfd = try_open_dwop_file (path_to_try, 0 /*is_dwp*/, 1 /*search_cwd*/);
10525  xfree (path_to_try);
10526  if (abfd != NULL)
10527  return abfd;
10528  }
10529 
10530  /* That didn't work, try debug-file-directory, which, despite its name,
10531  is a list of paths. */
10532 
10533  if (*debug_file_directory == '\0')
10534  return NULL;
10535 
10536  return try_open_dwop_file (file_name, 0 /*is_dwp*/, 1 /*search_cwd*/);
10537 }
10538 
10539 /* This function is mapped across the sections and remembers the offset and
10540  size of each of the DWO debugging sections we are interested in. */
10541 
10542 static void
10543 dwarf2_locate_dwo_sections (bfd *abfd, asection *sectp, void *dwo_sections_ptr)
10544 {
10545  struct dwo_sections *dwo_sections = dwo_sections_ptr;
10546  const struct dwop_section_names *names = &dwop_section_names;
10547 
10548  if (section_is_p (sectp->name, &names->abbrev_dwo))
10549  {
10550  dwo_sections->abbrev.s.asection = sectp;
10551  dwo_sections->abbrev.size = bfd_get_section_size (sectp);
10552  }
10553  else if (section_is_p (sectp->name, &names->info_dwo))
10554  {
10555  dwo_sections->info.s.asection = sectp;
10556  dwo_sections->info.size = bfd_get_section_size (sectp);
10557  }
10558  else if (section_is_p (sectp->name, &names->line_dwo))
10559  {
10560  dwo_sections->line.s.asection = sectp;
10561  dwo_sections->line.size = bfd_get_section_size (sectp);
10562  }
10563  else if (section_is_p (sectp->name, &names->loc_dwo))
10564  {
10565  dwo_sections->loc.s.asection = sectp;
10566  dwo_sections->loc.size = bfd_get_section_size (sectp);
10567  }
10568  else if (section_is_p (sectp->name, &names->macinfo_dwo))
10569  {
10570  dwo_sections->macinfo.s.asection = sectp;
10571  dwo_sections->macinfo.size = bfd_get_section_size (sectp);
10572  }
10573  else if (section_is_p (sectp->name, &names->macro_dwo))
10574  {
10575  dwo_sections->macro.s.asection = sectp;
10576  dwo_sections->macro.size = bfd_get_section_size (sectp);
10577  }
10578  else if (section_is_p (sectp->name, &names->str_dwo))
10579  {
10580  dwo_sections->str.s.asection = sectp;
10581  dwo_sections->str.size = bfd_get_section_size (sectp);
10582  }
10583  else if (section_is_p (sectp->name, &names->str_offsets_dwo))
10584  {
10585  dwo_sections->str_offsets.s.asection = sectp;
10586  dwo_sections->str_offsets.size = bfd_get_section_size (sectp);
10587  }
10588  else if (section_is_p (sectp->name, &names->types_dwo))
10589  {
10590  struct dwarf2_section_info type_section;
10591 
10592  memset (&type_section, 0, sizeof (type_section));
10593  type_section.s.asection = sectp;
10594  type_section.size = bfd_get_section_size (sectp);
10595  VEC_safe_push (dwarf2_section_info_def, dwo_sections->types,
10596  &type_section);
10597  }
10598 }
10599 
10600 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
10601  by PER_CU. This is for the non-DWP case.
10602  The result is NULL if DWO_NAME can't be found. */
10603 
10604 static struct dwo_file *
10606  const char *dwo_name, const char *comp_dir)
10607 {
10608  struct objfile *objfile = dwarf2_per_objfile->objfile;
10609  struct dwo_file *dwo_file;
10610  bfd *dbfd;
10611  struct cleanup *cleanups;
10612 
10613  dbfd = open_dwo_file (dwo_name, comp_dir);
10614  if (dbfd == NULL)
10615  {
10616  if (dwarf_read_debug)
10617  fprintf_unfiltered (gdb_stdlog, "DWO file not found: %s\n", dwo_name);
10618  return NULL;
10619  }
10620  dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
10621  dwo_file->dwo_name = dwo_name;
10622  dwo_file->comp_dir = comp_dir;
10623  dwo_file->dbfd = dbfd;
10624 
10625  cleanups = make_cleanup (free_dwo_file_cleanup, dwo_file);
10626 
10627  bfd_map_over_sections (dbfd, dwarf2_locate_dwo_sections, &dwo_file->sections);
10628 
10629  dwo_file->cu = create_dwo_cu (dwo_file);
10630 
10631  dwo_file->tus = create_debug_types_hash_table (dwo_file,
10632  dwo_file->sections.types);
10633 
10634  discard_cleanups (cleanups);
10635 
10636  if (dwarf_read_debug)
10637  fprintf_unfiltered (gdb_stdlog, "DWO file found: %s\n", dwo_name);
10638 
10639  return dwo_file;
10640 }
10641 
10642 /* This function is mapped across the sections and remembers the offset and
10643  size of each of the DWP debugging sections common to version 1 and 2 that
10644  we are interested in. */
10645 
10646 static void
10647 dwarf2_locate_common_dwp_sections (bfd *abfd, asection *sectp,
10648  void *dwp_file_ptr)
10649 {
10650  struct dwp_file *dwp_file = dwp_file_ptr;
10651  const struct dwop_section_names *names = &dwop_section_names;
10652  unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
10653 
10654  /* Record the ELF section number for later lookup: this is what the
10655  .debug_cu_index,.debug_tu_index tables use in DWP V1. */
10656  gdb_assert (elf_section_nr < dwp_file->num_sections);
10657  dwp_file->elf_sections[elf_section_nr] = sectp;
10658 
10659  /* Look for specific sections that we need. */
10660  if (section_is_p (sectp->name, &names->str_dwo))
10661  {
10662  dwp_file->sections.str.s.asection = sectp;
10663  dwp_file->sections.str.size = bfd_get_section_size (sectp);
10664  }
10665  else if (section_is_p (sectp->name, &names->cu_index))
10666  {
10667  dwp_file->sections.cu_index.s.asection = sectp;
10668  dwp_file->sections.cu_index.size = bfd_get_section_size (sectp);
10669  }
10670  else if (section_is_p (sectp->name, &names->tu_index))
10671  {
10672  dwp_file->sections.tu_index.s.asection = sectp;
10673  dwp_file->sections.tu_index.size = bfd_get_section_size (sectp);
10674  }
10675 }
10676 
10677 /* This function is mapped across the sections and remembers the offset and
10678  size of each of the DWP version 2 debugging sections that we are interested
10679  in. This is split into a separate function because we don't know if we
10680  have version 1 or 2 until we parse the cu_index/tu_index sections. */
10681 
10682 static void
10683 dwarf2_locate_v2_dwp_sections (bfd *abfd, asection *sectp, void *dwp_file_ptr)
10684 {
10685  struct dwp_file *dwp_file = dwp_file_ptr;
10686  const struct dwop_section_names *names = &dwop_section_names;
10687  unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
10688 
10689  /* Record the ELF section number for later lookup: this is what the
10690  .debug_cu_index,.debug_tu_index tables use in DWP V1. */
10691  gdb_assert (elf_section_nr < dwp_file->num_sections);
10692  dwp_file->elf_sections[elf_section_nr] = sectp;
10693 
10694  /* Look for specific sections that we need. */
10695  if (section_is_p (sectp->name, &names->abbrev_dwo))
10696  {
10697  dwp_file->sections.abbrev.s.asection = sectp;
10698  dwp_file->sections.abbrev.size = bfd_get_section_size (sectp);
10699  }
10700  else if (section_is_p (sectp->name, &names->info_dwo))
10701  {
10702  dwp_file->sections.info.s.asection = sectp;
10703  dwp_file->sections.info.size = bfd_get_section_size (sectp);
10704  }
10705  else if (section_is_p (sectp->name, &names->line_dwo))
10706  {
10707  dwp_file->sections.line.s.asection = sectp;
10708  dwp_file->sections.line.size = bfd_get_section_size (sectp);
10709  }
10710  else if (section_is_p (sectp->name, &names->loc_dwo))
10711  {
10712  dwp_file->sections.loc.s.asection = sectp;
10713  dwp_file->sections.loc.size = bfd_get_section_size (sectp);
10714  }
10715  else if (section_is_p (sectp->name, &names->macinfo_dwo))
10716  {
10717  dwp_file->sections.macinfo.s.asection = sectp;
10718  dwp_file->sections.macinfo.size = bfd_get_section_size (sectp);
10719  }
10720  else if (section_is_p (sectp->name, &names->macro_dwo))
10721  {
10722  dwp_file->sections.macro.s.asection = sectp;
10723  dwp_file->sections.macro.size = bfd_get_section_size (sectp);
10724  }
10725  else if (section_is_p (sectp->name, &names->str_offsets_dwo))
10726  {
10727  dwp_file->sections.str_offsets.s.asection = sectp;
10728  dwp_file->sections.str_offsets.size = bfd_get_section_size (sectp);
10729  }
10730  else if (section_is_p (sectp->name, &names->types_dwo))
10731  {
10732  dwp_file->sections.types.s.asection = sectp;
10733  dwp_file->sections.types.size = bfd_get_section_size (sectp);
10734  }
10735 }
10736 
10737 /* Hash function for dwp_file loaded CUs/TUs. */
10738 
10739 static hashval_t
10740 hash_dwp_loaded_cutus (const void *item)
10741 {
10742  const struct dwo_unit *dwo_unit = item;
10743 
10744  /* This drops the top 32 bits of the signature, but is ok for a hash. */
10745  return dwo_unit->signature;
10746 }
10747 
10748 /* Equality function for dwp_file loaded CUs/TUs. */
10749 
10750 static int
10751 eq_dwp_loaded_cutus (const void *a, const void *b)
10752 {
10753  const struct dwo_unit *dua = a;
10754  const struct dwo_unit *dub = b;
10755 
10756  return dua->signature == dub->signature;
10757 }
10758 
10759 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
10760 
10761 static htab_t
10762 allocate_dwp_loaded_cutus_table (struct objfile *objfile)
10763 {
10764  return htab_create_alloc_ex (3,
10767  NULL,
10768  &objfile->objfile_obstack,
10771 }
10772 
10773 /* Try to open DWP file FILE_NAME.
10774  The result is the bfd handle of the file.
10775  If there is a problem finding or opening the file, return NULL.
10776  Upon success, the canonicalized path of the file is stored in the bfd,
10777  same as symfile_bfd_open. */
10778 
10779 static bfd *
10780 open_dwp_file (const char *file_name)
10781 {
10782  bfd *abfd;
10783 
10784  abfd = try_open_dwop_file (file_name, 1 /*is_dwp*/, 1 /*search_cwd*/);
10785  if (abfd != NULL)
10786  return abfd;
10787 
10788  /* Work around upstream bug 15652.
10789  http://sourceware.org/bugzilla/show_bug.cgi?id=15652
10790  [Whether that's a "bug" is debatable, but it is getting in our way.]
10791  We have no real idea where the dwp file is, because gdb's realpath-ing
10792  of the executable's path may have discarded the needed info.
10793  [IWBN if the dwp file name was recorded in the executable, akin to
10794  .gnu_debuglink, but that doesn't exist yet.]
10795  Strip the directory from FILE_NAME and search again. */
10796  if (*debug_file_directory != '\0')
10797  {
10798  /* Don't implicitly search the current directory here.
10799  If the user wants to search "." to handle this case,
10800  it must be added to debug-file-directory. */
10801  return try_open_dwop_file (lbasename (file_name), 1 /*is_dwp*/,
10802  0 /*search_cwd*/);
10803  }
10804 
10805  return NULL;
10806 }
10807 
10808 /* Initialize the use of the DWP file for the current objfile.
10809  By convention the name of the DWP file is ${objfile}.dwp.
10810  The result is NULL if it can't be found. */
10811 
10812 static struct dwp_file *
10814 {
10815  struct objfile *objfile = dwarf2_per_objfile->objfile;
10816  struct dwp_file *dwp_file;
10817  char *dwp_name;
10818  bfd *dbfd;
10819  struct cleanup *cleanups;
10820 
10821  /* Try to find first .dwp for the binary file before any symbolic links
10822  resolving. */
10823  dwp_name = xstrprintf ("%s.dwp", objfile->original_name);
10824  cleanups = make_cleanup (xfree, dwp_name);
10825 
10826  dbfd = open_dwp_file (dwp_name);
10827  if (dbfd == NULL
10828  && strcmp (objfile->original_name, objfile_name (objfile)) != 0)
10829  {
10830  /* Try to find .dwp for the binary file after gdb_realpath resolving. */
10831  dwp_name = xstrprintf ("%s.dwp", objfile_name (objfile));
10832  make_cleanup (xfree, dwp_name);
10833  dbfd = open_dwp_file (dwp_name);
10834  }
10835 
10836  if (dbfd == NULL)
10837  {
10838  if (dwarf_read_debug)
10839  fprintf_unfiltered (gdb_stdlog, "DWP file not found: %s\n", dwp_name);
10840  do_cleanups (cleanups);
10841  return NULL;
10842  }
10843  dwp_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_file);
10844  dwp_file->name = bfd_get_filename (dbfd);
10845  dwp_file->dbfd = dbfd;
10846  do_cleanups (cleanups);
10847 
10848  /* +1: section 0 is unused */
10849  dwp_file->num_sections = bfd_count_sections (dbfd) + 1;
10850  dwp_file->elf_sections =
10851  OBSTACK_CALLOC (&objfile->objfile_obstack,
10852  dwp_file->num_sections, asection *);
10853 
10854  bfd_map_over_sections (dbfd, dwarf2_locate_common_dwp_sections, dwp_file);
10855 
10856  dwp_file->cus = create_dwp_hash_table (dwp_file, 0);
10857 
10858  dwp_file->tus = create_dwp_hash_table (dwp_file, 1);
10859 
10860  /* The DWP file version is stored in the hash table. Oh well. */
10861  if (dwp_file->cus->version != dwp_file->tus->version)
10862  {
10863  /* Technically speaking, we should try to limp along, but this is
10864  pretty bizarre. We use pulongest here because that's the established
10865  portability solution (e.g, we cannot use %u for uint32_t). */
10866  error (_("Dwarf Error: DWP file CU version %s doesn't match"
10867  " TU version %s [in DWP file %s]"),
10868  pulongest (dwp_file->cus->version),
10869  pulongest (dwp_file->tus->version), dwp_name);
10870  }
10871  dwp_file->version = dwp_file->cus->version;
10872 
10873  if (dwp_file->version == 2)
10874  bfd_map_over_sections (dbfd, dwarf2_locate_v2_dwp_sections, dwp_file);
10875 
10876  dwp_file->loaded_cus = allocate_dwp_loaded_cutus_table (objfile);
10877  dwp_file->loaded_tus = allocate_dwp_loaded_cutus_table (objfile);
10878 
10879  if (dwarf_read_debug)
10880  {
10881  fprintf_unfiltered (gdb_stdlog, "DWP file found: %s\n", dwp_file->name);
10883  " %s CUs, %s TUs\n",
10884  pulongest (dwp_file->cus ? dwp_file->cus->nr_units : 0),
10885  pulongest (dwp_file->tus ? dwp_file->tus->nr_units : 0));
10886  }
10887 
10888  return dwp_file;
10889 }
10890 
10891 /* Wrapper around open_and_init_dwp_file, only open it once. */
10892 
10893 static struct dwp_file *
10895 {
10896  if (! dwarf2_per_objfile->dwp_checked)
10897  {
10898  dwarf2_per_objfile->dwp_file = open_and_init_dwp_file ();
10899  dwarf2_per_objfile->dwp_checked = 1;
10900  }
10901  return dwarf2_per_objfile->dwp_file;
10902 }
10903 
10904 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
10905  Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
10906  or in the DWP file for the objfile, referenced by THIS_UNIT.
10907  If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
10908  IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
10909 
10910  This is called, for example, when wanting to read a variable with a
10911  complex location. Therefore we don't want to do file i/o for every call.
10912  Therefore we don't want to look for a DWO file on every call.
10913  Therefore we first see if we've already seen SIGNATURE in a DWP file,
10914  then we check if we've already seen DWO_NAME, and only THEN do we check
10915  for a DWO file.
10916 
10917  The result is a pointer to the dwo_unit object or NULL if we didn't find it
10918  (dwo_id mismatch or couldn't find the DWO/DWP file). */
10919 
10920 static struct dwo_unit *
10922  const char *dwo_name, const char *comp_dir,
10923  ULONGEST signature, int is_debug_types)
10924 {
10925  struct objfile *objfile = dwarf2_per_objfile->objfile;
10926  const char *kind = is_debug_types ? "TU" : "CU";
10927  void **dwo_file_slot;
10928  struct dwo_file *dwo_file;
10929  struct dwp_file *dwp_file;
10930 
10931  /* First see if there's a DWP file.
10932  If we have a DWP file but didn't find the DWO inside it, don't
10933  look for the original DWO file. It makes gdb behave differently
10934  depending on whether one is debugging in the build tree. */
10935 
10936  dwp_file = get_dwp_file ();
10937  if (dwp_file != NULL)
10938  {
10939  const struct dwp_hash_table *dwp_htab =
10940  is_debug_types ? dwp_file->tus : dwp_file->cus;
10941 
10942  if (dwp_htab != NULL)
10943  {
10944  struct dwo_unit *dwo_cutu =
10945  lookup_dwo_unit_in_dwp (dwp_file, comp_dir,
10946  signature, is_debug_types);
10947 
10948  if (dwo_cutu != NULL)
10949  {
10950  if (dwarf_read_debug)
10951  {
10953  "Virtual DWO %s %s found: @%s\n",
10954  kind, hex_string (signature),
10955  host_address_to_string (dwo_cutu));
10956  }
10957  return dwo_cutu;
10958  }
10959  }
10960  }
10961  else
10962  {
10963  /* No DWP file, look for the DWO file. */
10964 
10965  dwo_file_slot = lookup_dwo_file_slot (dwo_name, comp_dir);
10966  if (*dwo_file_slot == NULL)
10967  {
10968  /* Read in the file and build a table of the CUs/TUs it contains. */
10969  *dwo_file_slot = open_and_init_dwo_file (this_unit, dwo_name, comp_dir);
10970  }
10971  /* NOTE: This will be NULL if unable to open the file. */
10972  dwo_file = *dwo_file_slot;
10973 
10974  if (dwo_file != NULL)
10975  {
10976  struct dwo_unit *dwo_cutu = NULL;
10977 
10978  if (is_debug_types && dwo_file->tus)
10979  {
10980  struct dwo_unit find_dwo_cutu;
10981 
10982  memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
10983  find_dwo_cutu.signature = signature;
10984  dwo_cutu = htab_find (dwo_file->tus, &find_dwo_cutu);
10985  }
10986  else if (!is_debug_types && dwo_file->cu)
10987  {
10988  if (signature == dwo_file->cu->signature)
10989  dwo_cutu = dwo_file->cu;
10990  }
10991 
10992  if (dwo_cutu != NULL)
10993  {
10994  if (dwarf_read_debug)
10995  {
10996  fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) found: @%s\n",
10997  kind, dwo_name, hex_string (signature),
10998  host_address_to_string (dwo_cutu));
10999  }
11000  return dwo_cutu;
11001  }
11002  }
11003  }
11004 
11005  /* We didn't find it. This could mean a dwo_id mismatch, or
11006  someone deleted the DWO/DWP file, or the search path isn't set up
11007  correctly to find the file. */
11008 
11009  if (dwarf_read_debug)
11010  {
11011  fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) not found\n",
11012  kind, dwo_name, hex_string (signature));
11013  }
11014 
11015  /* This is a warning and not a complaint because it can be caused by
11016  pilot error (e.g., user accidentally deleting the DWO). */
11017  {
11018  /* Print the name of the DWP file if we looked there, helps the user
11019  better diagnose the problem. */
11020  char *dwp_text = NULL;
11021  struct cleanup *cleanups;
11022 
11023  if (dwp_file != NULL)
11024  dwp_text = xstrprintf (" [in DWP file %s]", lbasename (dwp_file->name));
11025  cleanups = make_cleanup (xfree, dwp_text);
11026 
11027  warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset 0x%x"
11028  " [in module %s]"),
11029  kind, dwo_name, hex_string (signature),
11030  dwp_text != NULL ? dwp_text : "",
11031  this_unit->is_debug_types ? "TU" : "CU",
11032  this_unit->offset.sect_off, objfile_name (objfile));
11033 
11034  do_cleanups (cleanups);
11035  }
11036  return NULL;
11037 }
11038 
11039 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
11040  See lookup_dwo_cutu_unit for details. */
11041 
11042 static struct dwo_unit *
11044  const char *dwo_name, const char *comp_dir,
11046 {
11047  return lookup_dwo_cutu (this_cu, dwo_name, comp_dir, signature, 0);
11048 }
11049 
11050 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
11051  See lookup_dwo_cutu_unit for details. */
11052 
11053 static struct dwo_unit *
11055  const char *dwo_name, const char *comp_dir)
11056 {
11057  return lookup_dwo_cutu (&this_tu->per_cu, dwo_name, comp_dir, this_tu->signature, 1);
11058 }
11059 
11060 /* Traversal function for queue_and_load_all_dwo_tus. */
11061 
11062 static int
11063 queue_and_load_dwo_tu (void **slot, void *info)
11064 {
11065  struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
11066  struct dwarf2_per_cu_data *per_cu = (struct dwarf2_per_cu_data *) info;
11067  ULONGEST signature = dwo_unit->signature;
11068  struct signatured_type *sig_type =
11069  lookup_dwo_signatured_type (per_cu->cu, signature);
11070 
11071  if (sig_type != NULL)
11072  {
11073  struct dwarf2_per_cu_data *sig_cu = &sig_type->per_cu;
11074 
11075  /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
11076  a real dependency of PER_CU on SIG_TYPE. That is detected later
11077  while processing PER_CU. */
11078  if (maybe_queue_comp_unit (NULL, sig_cu, per_cu->cu->language))
11079  load_full_type_unit (sig_cu);
11080  VEC_safe_push (dwarf2_per_cu_ptr, per_cu->imported_symtabs, sig_cu);
11081  }
11082 
11083  return 1;
11084 }
11085 
11086 /* Queue all TUs contained in the DWO of PER_CU to be read in.
11087  The DWO may have the only definition of the type, though it may not be
11088  referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
11089  http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
11090 
11091 static void
11093 {
11094  struct dwo_unit *dwo_unit;
11095  struct dwo_file *dwo_file;
11096 
11097  gdb_assert (!per_cu->is_debug_types);
11098  gdb_assert (get_dwp_file () == NULL);
11099  gdb_assert (per_cu->cu != NULL);
11100 
11101  dwo_unit = per_cu->cu->dwo_unit;
11102  gdb_assert (dwo_unit != NULL);
11103 
11104  dwo_file = dwo_unit->dwo_file;
11105  if (dwo_file->tus != NULL)
11106  htab_traverse_noresize (dwo_file->tus, queue_and_load_dwo_tu, per_cu);
11107 }
11108 
11109 /* Free all resources associated with DWO_FILE.
11110  Close the DWO file and munmap the sections.
11111  All memory should be on the objfile obstack. */
11112 
11113 static void
11114 free_dwo_file (struct dwo_file *dwo_file, struct objfile *objfile)
11115 {
11116  int ix;
11117  struct dwarf2_section_info *section;
11118 
11119  /* Note: dbfd is NULL for virtual DWO files. */
11120  gdb_bfd_unref (dwo_file->dbfd);
11121 
11122  VEC_free (dwarf2_section_info_def, dwo_file->sections.types);
11123 }
11124 
11125 /* Wrapper for free_dwo_file for use in cleanups. */
11126 
11127 static void
11129 {
11130  struct dwo_file *dwo_file = (struct dwo_file *) arg;
11131  struct objfile *objfile = dwarf2_per_objfile->objfile;
11132 
11133  free_dwo_file (dwo_file, objfile);
11134 }
11135 
11136 /* Traversal function for free_dwo_files. */
11137 
11138 static int
11139 free_dwo_file_from_slot (void **slot, void *info)
11140 {
11141  struct dwo_file *dwo_file = (struct dwo_file *) *slot;
11142  struct objfile *objfile = (struct objfile *) info;
11143 
11144  free_dwo_file (dwo_file, objfile);
11145 
11146  return 1;
11147 }
11148 
11149 /* Free all resources associated with DWO_FILES. */
11150 
11151 static void
11152 free_dwo_files (htab_t dwo_files, struct objfile *objfile)
11153 {
11154  htab_traverse_noresize (dwo_files, free_dwo_file_from_slot, objfile);
11155 }
11156 
11157 /* Read in various DIEs. */
11158 
11159 /* qsort helper for inherit_abstract_dies. */
11160 
11161 static int
11162 unsigned_int_compar (const void *ap, const void *bp)
11163 {
11164  unsigned int a = *(unsigned int *) ap;
11165  unsigned int b = *(unsigned int *) bp;
11166 
11167  return (a > b) - (b > a);
11168 }
11169 
11170 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
11171  Inherit only the children of the DW_AT_abstract_origin DIE not being
11172  already referenced by DW_AT_abstract_origin from the children of the
11173  current DIE. */
11174 
11175 static void
11176 inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu)
11177 {
11178  struct die_info *child_die;
11179  unsigned die_children_count;
11180  /* CU offsets which were referenced by children of the current DIE. */
11181  sect_offset *offsets;
11182  sect_offset *offsets_end, *offsetp;
11183  /* Parent of DIE - referenced by DW_AT_abstract_origin. */
11184  struct die_info *origin_die;
11185  /* Iterator of the ORIGIN_DIE children. */
11186  struct die_info *origin_child_die;
11187  struct cleanup *cleanups;
11188  struct attribute *attr;
11189  struct dwarf2_cu *origin_cu;
11190  struct pending **origin_previous_list_in_scope;
11191 
11192  attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
11193  if (!attr)
11194  return;
11195 
11196  /* Note that following die references may follow to a die in a
11197  different cu. */
11198 
11199  origin_cu = cu;
11200  origin_die = follow_die_ref (die, attr, &origin_cu);
11201 
11202  /* We're inheriting ORIGIN's children into the scope we'd put DIE's
11203  symbols in. */
11204  origin_previous_list_in_scope = origin_cu->list_in_scope;
11205  origin_cu->list_in_scope = cu->list_in_scope;
11206 
11207  if (die->tag != origin_die->tag
11208  && !(die->tag == DW_TAG_inlined_subroutine
11209  && origin_die->tag == DW_TAG_subprogram))
11211  _("DIE 0x%x and its abstract origin 0x%x have different tags"),
11212  die->offset.sect_off, origin_die->offset.sect_off);
11213 
11214  child_die = die->child;
11215  die_children_count = 0;
11216  while (child_die && child_die->tag)
11217  {
11218  child_die = sibling_die (child_die);
11219  die_children_count++;
11220  }
11221  offsets = xmalloc (sizeof (*offsets) * die_children_count);
11222  cleanups = make_cleanup (xfree, offsets);
11223 
11224  offsets_end = offsets;
11225  for (child_die = die->child;
11226  child_die && child_die->tag;
11227  child_die = sibling_die (child_die))
11228  {
11229  struct die_info *child_origin_die;
11230  struct dwarf2_cu *child_origin_cu;
11231 
11232  /* We are trying to process concrete instance entries:
11233  DW_TAG_GNU_call_site DIEs indeed have a DW_AT_abstract_origin tag, but
11234  it's not relevant to our analysis here. i.e. detecting DIEs that are
11235  present in the abstract instance but not referenced in the concrete
11236  one. */
11237  if (child_die->tag == DW_TAG_GNU_call_site)
11238  continue;
11239 
11240  /* For each CHILD_DIE, find the corresponding child of
11241  ORIGIN_DIE. If there is more than one layer of
11242  DW_AT_abstract_origin, follow them all; there shouldn't be,
11243  but GCC versions at least through 4.4 generate this (GCC PR
11244  40573). */
11245  child_origin_die = child_die;
11246  child_origin_cu = cu;
11247  while (1)
11248  {
11249  attr = dwarf2_attr (child_origin_die, DW_AT_abstract_origin,
11250  child_origin_cu);
11251  if (attr == NULL)
11252  break;
11253  child_origin_die = follow_die_ref (child_origin_die, attr,
11254  &child_origin_cu);
11255  }
11256 
11257  /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
11258  counterpart may exist. */
11259  if (child_origin_die != child_die)
11260  {
11261  if (child_die->tag != child_origin_die->tag
11262  && !(child_die->tag == DW_TAG_inlined_subroutine
11263  && child_origin_die->tag == DW_TAG_subprogram))
11265  _("Child DIE 0x%x and its abstract origin 0x%x have "
11266  "different tags"), child_die->offset.sect_off,
11267  child_origin_die->offset.sect_off);
11268  if (child_origin_die->parent != origin_die)
11270  _("Child DIE 0x%x and its abstract origin 0x%x have "
11271  "different parents"), child_die->offset.sect_off,
11272  child_origin_die->offset.sect_off);
11273  else
11274  *offsets_end++ = child_origin_die->offset;
11275  }
11276  }
11277  qsort (offsets, offsets_end - offsets, sizeof (*offsets),
11279  for (offsetp = offsets + 1; offsetp < offsets_end; offsetp++)
11280  if (offsetp[-1].sect_off == offsetp->sect_off)
11282  _("Multiple children of DIE 0x%x refer "
11283  "to DIE 0x%x as their abstract origin"),
11284  die->offset.sect_off, offsetp->sect_off);
11285 
11286  offsetp = offsets;
11287  origin_child_die = origin_die->child;
11288  while (origin_child_die && origin_child_die->tag)
11289  {
11290  /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
11291  while (offsetp < offsets_end
11292  && offsetp->sect_off < origin_child_die->offset.sect_off)
11293  offsetp++;
11294  if (offsetp >= offsets_end
11295  || offsetp->sect_off > origin_child_die->offset.sect_off)
11296  {
11297  /* Found that ORIGIN_CHILD_DIE is really not referenced.
11298  Check whether we're already processing ORIGIN_CHILD_DIE.
11299  This can happen with mutually referenced abstract_origins.
11300  PR 16581. */
11301  if (!origin_child_die->in_process)
11302  process_die (origin_child_die, origin_cu);
11303  }
11304  origin_child_die = sibling_die (origin_child_die);
11305  }
11306  origin_cu->list_in_scope = origin_previous_list_in_scope;
11307 
11308  do_cleanups (cleanups);
11309 }
11310 
11311 static void
11312 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
11313 {
11314  struct objfile *objfile = cu->objfile;
11315  struct gdbarch *gdbarch = get_objfile_arch (objfile);
11316  struct context_stack *newobj;
11317  CORE_ADDR lowpc;
11318  CORE_ADDR highpc;
11319  struct die_info *child_die;
11320  struct attribute *attr, *call_line, *call_file;
11321  const char *name;
11322  CORE_ADDR baseaddr;
11323  struct block *block;
11324  int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
11325  VEC (symbolp) *template_args = NULL;
11326  struct template_symbol *templ_func = NULL;
11327 
11328  if (inlined_func)
11329  {
11330  /* If we do not have call site information, we can't show the
11331  caller of this inlined function. That's too confusing, so
11332  only use the scope for local variables. */
11333  call_line = dwarf2_attr (die, DW_AT_call_line, cu);
11334  call_file = dwarf2_attr (die, DW_AT_call_file, cu);
11335  if (call_line == NULL || call_file == NULL)
11336  {
11337  read_lexical_block_scope (die, cu);
11338  return;
11339  }
11340  }
11341 
11342  baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11343 
11344  name = dwarf2_name (die, cu);
11345 
11346  /* Ignore functions with missing or empty names. These are actually
11347  illegal according to the DWARF standard. */
11348  if (name == NULL)
11349  {
11351  _("missing name for subprogram DIE at %d"),
11352  die->offset.sect_off);
11353  return;
11354  }
11355 
11356  /* Ignore functions with missing or invalid low and high pc attributes. */
11357  if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
11358  {
11359  attr = dwarf2_attr (die, DW_AT_external, cu);
11360  if (!attr || !DW_UNSND (attr))
11362  _("cannot get low and high bounds "
11363  "for subprogram DIE at %d"),
11364  die->offset.sect_off);
11365  return;
11366  }
11367 
11368  lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
11369  highpc = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
11370 
11371  /* If we have any template arguments, then we must allocate a
11372  different sort of symbol. */
11373  for (child_die = die->child; child_die; child_die = sibling_die (child_die))
11374  {
11375  if (child_die->tag == DW_TAG_template_type_param
11376  || child_die->tag == DW_TAG_template_value_param)
11377  {
11378  templ_func = allocate_template_symbol (objfile);
11379  templ_func->base.is_cplus_template_function = 1;
11380  break;
11381  }
11382  }
11383 
11384  newobj = push_context (0, lowpc);
11385  newobj->name = new_symbol_full (die, read_type_die (die, cu), cu,
11386  (struct symbol *) templ_func);
11387 
11388  /* If there is a location expression for DW_AT_frame_base, record
11389  it. */
11390  attr = dwarf2_attr (die, DW_AT_frame_base, cu);
11391  if (attr)
11392  dwarf2_symbol_mark_computed (attr, newobj->name, cu, 1);
11393 
11395 
11396  if (die->child != NULL)
11397  {
11398  child_die = die->child;
11399  while (child_die && child_die->tag)
11400  {
11401  if (child_die->tag == DW_TAG_template_type_param
11402  || child_die->tag == DW_TAG_template_value_param)
11403  {
11404  struct symbol *arg = new_symbol (child_die, NULL, cu);
11405 
11406  if (arg != NULL)
11407  VEC_safe_push (symbolp, template_args, arg);
11408  }
11409  else
11410  process_die (child_die, cu);
11411  child_die = sibling_die (child_die);
11412  }
11413  }
11414 
11415  inherit_abstract_dies (die, cu);
11416 
11417  /* If we have a DW_AT_specification, we might need to import using
11418  directives from the context of the specification DIE. See the
11419  comment in determine_prefix. */
11420  if (cu->language == language_cplus
11421  && dwarf2_attr (die, DW_AT_specification, cu))
11422  {
11423  struct dwarf2_cu *spec_cu = cu;
11424  struct die_info *spec_die = die_specification (die, &spec_cu);
11425 
11426  while (spec_die)
11427  {
11428  child_die = spec_die->child;
11429  while (child_die && child_die->tag)
11430  {
11431  if (child_die->tag == DW_TAG_imported_module)
11432  process_die (child_die, spec_cu);
11433  child_die = sibling_die (child_die);
11434  }
11435 
11436  /* In some cases, GCC generates specification DIEs that
11437  themselves contain DW_AT_specification attributes. */
11438  spec_die = die_specification (spec_die, &spec_cu);
11439  }
11440  }
11441 
11442  newobj = pop_context ();
11443  /* Make a block for the local symbols within. */
11444  block = finish_block (newobj->name, &local_symbols, newobj->old_blocks,
11445  lowpc, highpc);
11446 
11447  /* For C++, set the block's scope. */
11448  if ((cu->language == language_cplus || cu->language == language_fortran)
11449  && cu->processing_has_namespace_info)
11450  block_set_scope (block, determine_prefix (die, cu),
11451  &objfile->objfile_obstack);
11452 
11453  /* If we have address ranges, record them. */
11454  dwarf2_record_block_ranges (die, block, baseaddr, cu);
11455 
11456  gdbarch_make_symbol_special (gdbarch, newobj->name, objfile);
11457 
11458  /* Attach template arguments to function. */
11459  if (! VEC_empty (symbolp, template_args))
11460  {
11461  gdb_assert (templ_func != NULL);
11462 
11463  templ_func->n_template_arguments = VEC_length (symbolp, template_args);
11464  templ_func->template_arguments
11465  = obstack_alloc (&objfile->objfile_obstack,
11466  (templ_func->n_template_arguments
11467  * sizeof (struct symbol *)));
11468  memcpy (templ_func->template_arguments,
11469  VEC_address (symbolp, template_args),
11470  (templ_func->n_template_arguments * sizeof (struct symbol *)));
11471  VEC_free (symbolp, template_args);
11472  }
11473 
11474  /* In C++, we can have functions nested inside functions (e.g., when
11475  a function declares a class that has methods). This means that
11476  when we finish processing a function scope, we may need to go
11477  back to building a containing block's symbol lists. */
11478  local_symbols = newobj->locals;
11480 
11481  /* If we've finished processing a top-level function, subsequent
11482  symbols go in the file symbol list. */
11483  if (outermost_context_p ())
11484  cu->list_in_scope = &file_symbols;
11485 }
11486 
11487 /* Process all the DIES contained within a lexical block scope. Start
11488  a new scope, process the dies, and then close the scope. */
11489 
11490 static void
11492 {
11493  struct objfile *objfile = cu->objfile;
11494  struct gdbarch *gdbarch = get_objfile_arch (objfile);
11495  struct context_stack *newobj;
11496  CORE_ADDR lowpc, highpc;
11497  struct die_info *child_die;
11498  CORE_ADDR baseaddr;
11499 
11500  baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11501 
11502  /* Ignore blocks with missing or invalid low and high pc attributes. */
11503  /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
11504  as multiple lexical blocks? Handling children in a sane way would
11505  be nasty. Might be easier to properly extend generic blocks to
11506  describe ranges. */
11507  if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
11508  return;
11509  lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
11510  highpc = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
11511 
11512  push_context (0, lowpc);
11513  if (die->child != NULL)
11514  {
11515  child_die = die->child;
11516  while (child_die && child_die->tag)
11517  {
11518  process_die (child_die, cu);
11519  child_die = sibling_die (child_die);
11520  }
11521  }
11522  inherit_abstract_dies (die, cu);
11523  newobj = pop_context ();
11524 
11525  if (local_symbols != NULL || using_directives != NULL)
11526  {
11527  struct block *block
11528  = finish_block (0, &local_symbols, newobj->old_blocks,
11529  newobj->start_addr, highpc);
11530 
11531  /* Note that recording ranges after traversing children, as we
11532  do here, means that recording a parent's ranges entails
11533  walking across all its children's ranges as they appear in
11534  the address map, which is quadratic behavior.
11535 
11536  It would be nicer to record the parent's ranges before
11537  traversing its children, simply overriding whatever you find
11538  there. But since we don't even decide whether to create a
11539  block until after we've traversed its children, that's hard
11540  to do. */
11541  dwarf2_record_block_ranges (die, block, baseaddr, cu);
11542  }
11543  local_symbols = newobj->locals;
11545 }
11546 
11547 /* Read in DW_TAG_GNU_call_site and insert it to CU->call_site_htab. */
11548 
11549 static void
11550 read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
11551 {
11552  struct objfile *objfile = cu->objfile;
11553  struct gdbarch *gdbarch = get_objfile_arch (objfile);
11554  CORE_ADDR pc, baseaddr;
11555  struct attribute *attr;
11556  struct call_site *call_site, call_site_local;
11557  void **slot;
11558  int nparams;
11559  struct die_info *child_die;
11560 
11561  baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11562 
11563  attr = dwarf2_attr (die, DW_AT_low_pc, cu);
11564  if (!attr)
11565  {
11567  _("missing DW_AT_low_pc for DW_TAG_GNU_call_site "
11568  "DIE 0x%x [in module %s]"),
11569  die->offset.sect_off, objfile_name (objfile));
11570  return;
11571  }
11572  pc = attr_value_as_address (attr) + baseaddr;
11573  pc = gdbarch_adjust_dwarf2_addr (gdbarch, pc);
11574 
11575  if (cu->call_site_htab == NULL)
11576  cu->call_site_htab = htab_create_alloc_ex (16, core_addr_hash, core_addr_eq,
11577  NULL, &objfile->objfile_obstack,
11578  hashtab_obstack_allocate, NULL);
11579  call_site_local.pc = pc;
11580  slot = htab_find_slot (cu->call_site_htab, &call_site_local, INSERT);
11581  if (*slot != NULL)
11582  {
11584  _("Duplicate PC %s for DW_TAG_GNU_call_site "
11585  "DIE 0x%x [in module %s]"),
11586  paddress (gdbarch, pc), die->offset.sect_off,
11587  objfile_name (objfile));
11588  return;
11589  }
11590 
11591  /* Count parameters at the caller. */
11592 
11593  nparams = 0;
11594  for (child_die = die->child; child_die && child_die->tag;
11595  child_die = sibling_die (child_die))
11596  {
11597  if (child_die->tag != DW_TAG_GNU_call_site_parameter)
11598  {
11600  _("Tag %d is not DW_TAG_GNU_call_site_parameter in "
11601  "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11602  child_die->tag, child_die->offset.sect_off,
11603  objfile_name (objfile));
11604  continue;
11605  }
11606 
11607  nparams++;
11608  }
11609 
11610  call_site = obstack_alloc (&objfile->objfile_obstack,
11611  (sizeof (*call_site)
11612  + (sizeof (*call_site->parameter)
11613  * (nparams - 1))));
11614  *slot = call_site;
11615  memset (call_site, 0, sizeof (*call_site) - sizeof (*call_site->parameter));
11616  call_site->pc = pc;
11617 
11618  if (dwarf2_flag_true_p (die, DW_AT_GNU_tail_call, cu))
11619  {
11620  struct die_info *func_die;
11621 
11622  /* Skip also over DW_TAG_inlined_subroutine. */
11623  for (func_die = die->parent;
11624  func_die && func_die->tag != DW_TAG_subprogram
11625  && func_die->tag != DW_TAG_subroutine_type;
11626  func_die = func_die->parent);
11627 
11628  /* DW_AT_GNU_all_call_sites is a superset
11629  of DW_AT_GNU_all_tail_call_sites. */
11630  if (func_die
11631  && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_call_sites, cu)
11632  && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_tail_call_sites, cu))
11633  {
11634  /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
11635  not complete. But keep CALL_SITE for look ups via call_site_htab,
11636  both the initial caller containing the real return address PC and
11637  the final callee containing the current PC of a chain of tail
11638  calls do not need to have the tail call list complete. But any
11639  function candidate for a virtual tail call frame searched via
11640  TYPE_TAIL_CALL_LIST must have the tail call list complete to be
11641  determined unambiguously. */
11642  }
11643  else
11644  {
11645  struct type *func_type = NULL;
11646 
11647  if (func_die)
11648  func_type = get_die_type (func_die, cu);
11649  if (func_type != NULL)
11650  {
11651  gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC);
11652 
11653  /* Enlist this call site to the function. */
11654  call_site->tail_call_next = TYPE_TAIL_CALL_LIST (func_type);
11655  TYPE_TAIL_CALL_LIST (func_type) = call_site;
11656  }
11657  else
11659  _("Cannot find function owning DW_TAG_GNU_call_site "
11660  "DIE 0x%x [in module %s]"),
11661  die->offset.sect_off, objfile_name (objfile));
11662  }
11663  }
11664 
11665  attr = dwarf2_attr (die, DW_AT_GNU_call_site_target, cu);
11666  if (attr == NULL)
11667  attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
11668  SET_FIELD_DWARF_BLOCK (call_site->target, NULL);
11669  if (!attr || (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0))
11670  /* Keep NULL DWARF_BLOCK. */;
11671  else if (attr_form_is_block (attr))
11672  {
11673  struct dwarf2_locexpr_baton *dlbaton;
11674 
11675  dlbaton = obstack_alloc (&objfile->objfile_obstack, sizeof (*dlbaton));
11676  dlbaton->data = DW_BLOCK (attr)->data;
11677  dlbaton->size = DW_BLOCK (attr)->size;
11678  dlbaton->per_cu = cu->per_cu;
11679 
11680  SET_FIELD_DWARF_BLOCK (call_site->target, dlbaton);
11681  }
11682  else if (attr_form_is_ref (attr))
11683  {
11684  struct dwarf2_cu *target_cu = cu;
11685  struct die_info *target_die;
11686 
11687  target_die = follow_die_ref (die, attr, &target_cu);
11688  gdb_assert (target_cu->objfile == objfile);
11689  if (die_is_declaration (target_die, target_cu))
11690  {
11691  const char *target_physname = NULL;
11692  struct attribute *target_attr;
11693 
11694  /* Prefer the mangled name; otherwise compute the demangled one. */
11695  target_attr = dwarf2_attr (target_die, DW_AT_linkage_name, target_cu);
11696  if (target_attr == NULL)
11697  target_attr = dwarf2_attr (target_die, DW_AT_MIPS_linkage_name,
11698  target_cu);
11699  if (target_attr != NULL && DW_STRING (target_attr) != NULL)
11700  target_physname = DW_STRING (target_attr);
11701  else
11702  target_physname = dwarf2_physname (NULL, target_die, target_cu);
11703  if (target_physname == NULL)
11705  _("DW_AT_GNU_call_site_target target DIE has invalid "
11706  "physname, for referencing DIE 0x%x [in module %s]"),
11707  die->offset.sect_off, objfile_name (objfile));
11708  else
11709  SET_FIELD_PHYSNAME (call_site->target, target_physname);
11710  }
11711  else
11712  {
11713  CORE_ADDR lowpc;
11714 
11715  /* DW_AT_entry_pc should be preferred. */
11716  if (!dwarf2_get_pc_bounds (target_die, &lowpc, NULL, target_cu, NULL))
11718  _("DW_AT_GNU_call_site_target target DIE has invalid "
11719  "low pc, for referencing DIE 0x%x [in module %s]"),
11720  die->offset.sect_off, objfile_name (objfile));
11721  else
11722  {
11723  lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
11724  SET_FIELD_PHYSADDR (call_site->target, lowpc);
11725  }
11726  }
11727  }
11728  else
11730  _("DW_TAG_GNU_call_site DW_AT_GNU_call_site_target is neither "
11731  "block nor reference, for DIE 0x%x [in module %s]"),
11732  die->offset.sect_off, objfile_name (objfile));
11733 
11734  call_site->per_cu = cu->per_cu;
11735 
11736  for (child_die = die->child;
11737  child_die && child_die->tag;
11738  child_die = sibling_die (child_die))
11739  {
11740  struct call_site_parameter *parameter;
11741  struct attribute *loc, *origin;
11742 
11743  if (child_die->tag != DW_TAG_GNU_call_site_parameter)
11744  {
11745  /* Already printed the complaint above. */
11746  continue;
11747  }
11748 
11749  gdb_assert (call_site->parameter_count < nparams);
11750  parameter = &call_site->parameter[call_site->parameter_count];
11751 
11752  /* DW_AT_location specifies the register number or DW_AT_abstract_origin
11753  specifies DW_TAG_formal_parameter. Value of the data assumed for the
11754  register is contained in DW_AT_GNU_call_site_value. */
11755 
11756  loc = dwarf2_attr (child_die, DW_AT_location, cu);
11757  origin = dwarf2_attr (child_die, DW_AT_abstract_origin, cu);
11758  if (loc == NULL && origin != NULL && attr_form_is_ref (origin))
11759  {
11761 
11763  offset = dwarf2_get_ref_die_offset (origin);
11764  if (!offset_in_cu_p (&cu->header, offset))
11765  {
11766  /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
11767  binding can be done only inside one CU. Such referenced DIE
11768  therefore cannot be even moved to DW_TAG_partial_unit. */
11770  _("DW_AT_abstract_origin offset is not in CU for "
11771  "DW_TAG_GNU_call_site child DIE 0x%x "
11772  "[in module %s]"),
11773  child_die->offset.sect_off, objfile_name (objfile));
11774  continue;
11775  }
11776  parameter->u.param_offset.cu_off = (offset.sect_off
11777  - cu->header.offset.sect_off);
11778  }
11779  else if (loc == NULL || origin != NULL || !attr_form_is_block (loc))
11780  {
11782  _("No DW_FORM_block* DW_AT_location for "
11783  "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11784  child_die->offset.sect_off, objfile_name (objfile));
11785  continue;
11786  }
11787  else
11788  {
11789  parameter->u.dwarf_reg = dwarf_block_to_dwarf_reg
11790  (DW_BLOCK (loc)->data, &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size]);
11791  if (parameter->u.dwarf_reg != -1)
11792  parameter->kind = CALL_SITE_PARAMETER_DWARF_REG;
11793  else if (dwarf_block_to_sp_offset (gdbarch, DW_BLOCK (loc)->data,
11794  &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size],
11795  &parameter->u.fb_offset))
11796  parameter->kind = CALL_SITE_PARAMETER_FB_OFFSET;
11797  else
11798  {
11800  _("Only single DW_OP_reg or DW_OP_fbreg is supported "
11801  "for DW_FORM_block* DW_AT_location is supported for "
11802  "DW_TAG_GNU_call_site child DIE 0x%x "
11803  "[in module %s]"),
11804  child_die->offset.sect_off, objfile_name (objfile));
11805  continue;
11806  }
11807  }
11808 
11809  attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_value, cu);
11810  if (!attr_form_is_block (attr))
11811  {
11813  _("No DW_FORM_block* DW_AT_GNU_call_site_value for "
11814  "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11815  child_die->offset.sect_off, objfile_name (objfile));
11816  continue;
11817  }
11818  parameter->value = DW_BLOCK (attr)->data;
11819  parameter->value_size = DW_BLOCK (attr)->size;
11820 
11821  /* Parameters are not pre-cleared by memset above. */
11822  parameter->data_value = NULL;
11823  parameter->data_value_size = 0;
11824  call_site->parameter_count++;
11825 
11826  attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_data_value, cu);
11827  if (attr)
11828  {
11829  if (!attr_form_is_block (attr))
11831  _("No DW_FORM_block* DW_AT_GNU_call_site_data_value for "
11832  "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11833  child_die->offset.sect_off, objfile_name (objfile));
11834  else
11835  {
11836  parameter->data_value = DW_BLOCK (attr)->data;
11837  parameter->data_value_size = DW_BLOCK (attr)->size;
11838  }
11839  }
11840  }
11841 }
11842 
11843 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
11844  Return 1 if the attributes are present and valid, otherwise, return 0.
11845  If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
11846 
11847 static int
11848 dwarf2_ranges_read (unsigned offset, CORE_ADDR *low_return,
11849  CORE_ADDR *high_return, struct dwarf2_cu *cu,
11850  struct partial_symtab *ranges_pst)
11851 {
11852  struct objfile *objfile = cu->objfile;
11853  struct gdbarch *gdbarch = get_objfile_arch (objfile);
11854  struct comp_unit_head *cu_header = &cu->header;
11855  bfd *obfd = objfile->obfd;
11856  unsigned int addr_size = cu_header->addr_size;
11857  CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
11858  /* Base address selection entry. */
11859  CORE_ADDR base;
11860  int found_base;
11861  unsigned int dummy;
11862  const gdb_byte *buffer;
11863  CORE_ADDR marker;
11864  int low_set;
11865  CORE_ADDR low = 0;
11866  CORE_ADDR high = 0;
11867  CORE_ADDR baseaddr;
11868 
11869  found_base = cu->base_known;
11870  base = cu->base_address;
11871 
11872  dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
11873  if (offset >= dwarf2_per_objfile->ranges.size)
11874  {
11876  _("Offset %d out of bounds for DW_AT_ranges attribute"),
11877  offset);
11878  return 0;
11879  }
11880  buffer = dwarf2_per_objfile->ranges.buffer + offset;
11881 
11882  /* Read in the largest possible address. */
11883  marker = read_address (obfd, buffer, cu, &dummy);
11884  if ((marker & mask) == mask)
11885  {
11886  /* If we found the largest possible address, then
11887  read the base address. */
11888  base = read_address (obfd, buffer + addr_size, cu, &dummy);
11889  buffer += 2 * addr_size;
11890  offset += 2 * addr_size;
11891  found_base = 1;
11892  }
11893 
11894  low_set = 0;
11895 
11896  baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11897 
11898  while (1)
11899  {
11900  CORE_ADDR range_beginning, range_end;
11901 
11902  range_beginning = read_address (obfd, buffer, cu, &dummy);
11903  buffer += addr_size;
11904  range_end = read_address (obfd, buffer, cu, &dummy);
11905  buffer += addr_size;
11906  offset += 2 * addr_size;
11907 
11908  /* An end of list marker is a pair of zero addresses. */
11909  if (range_beginning == 0 && range_end == 0)
11910  /* Found the end of list entry. */
11911  break;
11912 
11913  /* Each base address selection entry is a pair of 2 values.
11914  The first is the largest possible address, the second is
11915  the base address. Check for a base address here. */
11916  if ((range_beginning & mask) == mask)
11917  {
11918  /* If we found the largest possible address, then
11919  read the base address. */
11920  base = read_address (obfd, buffer + addr_size, cu, &dummy);
11921  found_base = 1;
11922  continue;
11923  }
11924 
11925  if (!found_base)
11926  {
11927  /* We have no valid base address for the ranges
11928  data. */
11930  _("Invalid .debug_ranges data (no base address)"));
11931  return 0;
11932  }
11933 
11934  if (range_beginning > range_end)
11935  {
11936  /* Inverted range entries are invalid. */
11938  _("Invalid .debug_ranges data (inverted range)"));
11939  return 0;
11940  }
11941 
11942  /* Empty range entries have no effect. */
11943  if (range_beginning == range_end)
11944  continue;
11945 
11946  range_beginning += base;
11947  range_end += base;
11948 
11949  /* A not-uncommon case of bad debug info.
11950  Don't pollute the addrmap with bad data. */
11951  if (range_beginning + baseaddr == 0
11952  && !dwarf2_per_objfile->has_section_at_zero)
11953  {
11955  _(".debug_ranges entry has start address of zero"
11956  " [in module %s]"), objfile_name (objfile));
11957  continue;
11958  }
11959 
11960  if (ranges_pst != NULL)
11961  {
11962  CORE_ADDR lowpc;
11963  CORE_ADDR highpc;
11964 
11965  lowpc = gdbarch_adjust_dwarf2_addr (gdbarch,
11966  range_beginning + baseaddr);
11967  highpc = gdbarch_adjust_dwarf2_addr (gdbarch,
11968  range_end + baseaddr);
11969  addrmap_set_empty (objfile->psymtabs_addrmap, lowpc, highpc - 1,
11970  ranges_pst);
11971  }
11972 
11973  /* FIXME: This is recording everything as a low-high
11974  segment of consecutive addresses. We should have a
11975  data structure for discontiguous block ranges
11976  instead. */
11977  if (! low_set)
11978  {
11979  low = range_beginning;
11980  high = range_end;
11981  low_set = 1;
11982  }
11983  else
11984  {
11985  if (range_beginning < low)
11986  low = range_beginning;
11987  if (range_end > high)
11988  high = range_end;
11989  }
11990  }
11991 
11992  if (! low_set)
11993  /* If the first entry is an end-of-list marker, the range
11994  describes an empty scope, i.e. no instructions. */
11995  return 0;
11996 
11997  if (low_return)
11998  *low_return = low;
11999  if (high_return)
12000  *high_return = high;
12001  return 1;
12002 }
12003 
12004 /* Get low and high pc attributes from a die. Return 1 if the attributes
12005  are present and valid, otherwise, return 0. Return -1 if the range is
12006  discontinuous, i.e. derived from DW_AT_ranges information. */
12007 
12008 static int
12010  CORE_ADDR *highpc, struct dwarf2_cu *cu,
12011  struct partial_symtab *pst)
12012 {
12013  struct attribute *attr;
12014  struct attribute *attr_high;
12015  CORE_ADDR low = 0;
12016  CORE_ADDR high = 0;
12017  int ret = 0;
12018 
12019  attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
12020  if (attr_high)
12021  {
12022  attr = dwarf2_attr (die, DW_AT_low_pc, cu);
12023  if (attr)
12024  {
12025  low = attr_value_as_address (attr);
12026  high = attr_value_as_address (attr_high);
12027  if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
12028  high += low;
12029  }
12030  else
12031  /* Found high w/o low attribute. */
12032  return 0;
12033 
12034  /* Found consecutive range of addresses. */
12035  ret = 1;
12036  }
12037  else
12038  {
12039  attr = dwarf2_attr (die, DW_AT_ranges, cu);
12040  if (attr != NULL)
12041  {
12042  /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
12043  We take advantage of the fact that DW_AT_ranges does not appear
12044  in DW_TAG_compile_unit of DWO files. */
12045  int need_ranges_base = die->tag != DW_TAG_compile_unit;
12046  unsigned int ranges_offset = (DW_UNSND (attr)
12047  + (need_ranges_base
12048  ? cu->ranges_base
12049  : 0));
12050 
12051  /* Value of the DW_AT_ranges attribute is the offset in the
12052  .debug_ranges section. */
12053  if (!dwarf2_ranges_read (ranges_offset, &low, &high, cu, pst))
12054  return 0;
12055  /* Found discontinuous range of addresses. */
12056  ret = -1;
12057  }
12058  }
12059 
12060  /* read_partial_die has also the strict LOW < HIGH requirement. */
12061  if (high <= low)
12062  return 0;
12063 
12064  /* When using the GNU linker, .gnu.linkonce. sections are used to
12065  eliminate duplicate copies of functions and vtables and such.
12066  The linker will arbitrarily choose one and discard the others.
12067  The AT_*_pc values for such functions refer to local labels in
12068  these sections. If the section from that file was discarded, the
12069  labels are not in the output, so the relocs get a value of 0.
12070  If this is a discarded function, mark the pc bounds as invalid,
12071  so that GDB will ignore it. */
12072  if (low == 0 && !dwarf2_per_objfile->has_section_at_zero)
12073  return 0;
12074 
12075  *lowpc = low;
12076  if (highpc)
12077  *highpc = high;
12078  return ret;
12079 }
12080 
12081 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
12082  its low and high PC addresses. Do nothing if these addresses could not
12083  be determined. Otherwise, set LOWPC to the low address if it is smaller,
12084  and HIGHPC to the high address if greater than HIGHPC. */
12085 
12086 static void
12088  CORE_ADDR *lowpc, CORE_ADDR *highpc,
12089  struct dwarf2_cu *cu)
12090 {
12091  CORE_ADDR low, high;
12092  struct die_info *child = die->child;
12093 
12094  if (dwarf2_get_pc_bounds (die, &low, &high, cu, NULL))
12095  {
12096  *lowpc = min (*lowpc, low);
12097  *highpc = max (*highpc, high);
12098  }
12099 
12100  /* If the language does not allow nested subprograms (either inside
12101  subprograms or lexical blocks), we're done. */
12102  if (cu->language != language_ada)
12103  return;
12104 
12105  /* Check all the children of the given DIE. If it contains nested
12106  subprograms, then check their pc bounds. Likewise, we need to
12107  check lexical blocks as well, as they may also contain subprogram
12108  definitions. */
12109  while (child && child->tag)
12110  {
12111  if (child->tag == DW_TAG_subprogram
12112  || child->tag == DW_TAG_lexical_block)
12113  dwarf2_get_subprogram_pc_bounds (child, lowpc, highpc, cu);
12114  child = sibling_die (child);
12115  }
12116 }
12117 
12118 /* Get the low and high pc's represented by the scope DIE, and store
12119  them in *LOWPC and *HIGHPC. If the correct values can't be
12120  determined, set *LOWPC to -1 and *HIGHPC to 0. */
12121 
12122 static void
12124  CORE_ADDR *lowpc, CORE_ADDR *highpc,
12125  struct dwarf2_cu *cu)
12126 {
12127  CORE_ADDR best_low = (CORE_ADDR) -1;
12128  CORE_ADDR best_high = (CORE_ADDR) 0;
12129  CORE_ADDR current_low, current_high;
12130 
12131  if (dwarf2_get_pc_bounds (die, &current_low, &current_high, cu, NULL))
12132  {
12133  best_low = current_low;
12134  best_high = current_high;
12135  }
12136  else
12137  {
12138  struct die_info *child = die->child;
12139 
12140  while (child && child->tag)
12141  {
12142  switch (child->tag) {
12143  case DW_TAG_subprogram:
12144  dwarf2_get_subprogram_pc_bounds (child, &best_low, &best_high, cu);
12145  break;
12146  case DW_TAG_namespace:
12147  case DW_TAG_module:
12148  /* FIXME: carlton/2004-01-16: Should we do this for
12149  DW_TAG_class_type/DW_TAG_structure_type, too? I think
12150  that current GCC's always emit the DIEs corresponding
12151  to definitions of methods of classes as children of a
12152  DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
12153  the DIEs giving the declarations, which could be
12154  anywhere). But I don't see any reason why the
12155  standards says that they have to be there. */
12156  get_scope_pc_bounds (child, &current_low, &current_high, cu);
12157 
12158  if (current_low != ((CORE_ADDR) -1))
12159  {
12160  best_low = min (best_low, current_low);
12161  best_high = max (best_high, current_high);
12162  }
12163  break;
12164  default:
12165  /* Ignore. */
12166  break;
12167  }
12168 
12169  child = sibling_die (child);
12170  }
12171  }
12172 
12173  *lowpc = best_low;
12174  *highpc = best_high;
12175 }
12176 
12177 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
12178  in DIE. */
12179 
12180 static void
12182  CORE_ADDR baseaddr, struct dwarf2_cu *cu)
12183 {
12184  struct objfile *objfile = cu->objfile;
12185  struct gdbarch *gdbarch = get_objfile_arch (objfile);
12186  struct attribute *attr;
12187  struct attribute *attr_high;
12188 
12189  attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
12190  if (attr_high)
12191  {
12192  attr = dwarf2_attr (die, DW_AT_low_pc, cu);
12193  if (attr)
12194  {
12195  CORE_ADDR low = attr_value_as_address (attr);
12196  CORE_ADDR high = attr_value_as_address (attr_high);
12197 
12198  if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
12199  high += low;
12200 
12201  low = gdbarch_adjust_dwarf2_addr (gdbarch, low + baseaddr);
12202  high = gdbarch_adjust_dwarf2_addr (gdbarch, high + baseaddr);
12203  record_block_range (block, low, high - 1);
12204  }
12205  }
12206 
12207  attr = dwarf2_attr (die, DW_AT_ranges, cu);
12208  if (attr)
12209  {
12210  bfd *obfd = objfile->obfd;
12211  /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
12212  We take advantage of the fact that DW_AT_ranges does not appear
12213  in DW_TAG_compile_unit of DWO files. */
12214  int need_ranges_base = die->tag != DW_TAG_compile_unit;
12215 
12216  /* The value of the DW_AT_ranges attribute is the offset of the
12217  address range list in the .debug_ranges section. */
12218  unsigned long offset = (DW_UNSND (attr)
12219  + (need_ranges_base ? cu->ranges_base : 0));
12220  const gdb_byte *buffer;
12221 
12222  /* For some target architectures, but not others, the
12223  read_address function sign-extends the addresses it returns.
12224  To recognize base address selection entries, we need a
12225  mask. */
12226  unsigned int addr_size = cu->header.addr_size;
12227  CORE_ADDR base_select_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
12228 
12229  /* The base address, to which the next pair is relative. Note
12230  that this 'base' is a DWARF concept: most entries in a range
12231  list are relative, to reduce the number of relocs against the
12232  debugging information. This is separate from this function's
12233  'baseaddr' argument, which GDB uses to relocate debugging
12234  information from a shared library based on the address at
12235  which the library was loaded. */
12236  CORE_ADDR base = cu->base_address;
12237  int base_known = cu->base_known;
12238 
12239  dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
12240  if (offset >= dwarf2_per_objfile->ranges.size)
12241  {
12243  _("Offset %lu out of bounds for DW_AT_ranges attribute"),
12244  offset);
12245  return;
12246  }
12247  buffer = dwarf2_per_objfile->ranges.buffer + offset;
12248 
12249  for (;;)
12250  {
12251  unsigned int bytes_read;
12252  CORE_ADDR start, end;
12253 
12254  start = read_address (obfd, buffer, cu, &bytes_read);
12255  buffer += bytes_read;
12256  end = read_address (obfd, buffer, cu, &bytes_read);
12257  buffer += bytes_read;
12258 
12259  /* Did we find the end of the range list? */
12260  if (start == 0 && end == 0)
12261  break;
12262 
12263  /* Did we find a base address selection entry? */
12264  else if ((start & base_select_mask) == base_select_mask)
12265  {
12266  base = end;
12267  base_known = 1;
12268  }
12269 
12270  /* We found an ordinary address range. */
12271  else
12272  {
12273  if (!base_known)
12274  {
12276  _("Invalid .debug_ranges data "
12277  "(no base address)"));
12278  return;
12279  }
12280 
12281  if (start > end)
12282  {
12283  /* Inverted range entries are invalid. */
12285  _("Invalid .debug_ranges data "
12286  "(inverted range)"));
12287  return;
12288  }
12289 
12290  /* Empty range entries have no effect. */
12291  if (start == end)
12292  continue;
12293 
12294  start += base + baseaddr;
12295  end += base + baseaddr;
12296 
12297  /* A not-uncommon case of bad debug info.
12298  Don't pollute the addrmap with bad data. */
12299  if (start == 0 && !dwarf2_per_objfile->has_section_at_zero)
12300  {
12302  _(".debug_ranges entry has start address of zero"
12303  " [in module %s]"), objfile_name (objfile));
12304  continue;
12305  }
12306 
12307  start = gdbarch_adjust_dwarf2_addr (gdbarch, start);
12308  end = gdbarch_adjust_dwarf2_addr (gdbarch, end);
12309  record_block_range (block, start, end - 1);
12310  }
12311  }
12312  }
12313 }
12314 
12315 /* Check whether the producer field indicates either of GCC < 4.6, or the
12316  Intel C/C++ compiler, and cache the result in CU. */
12317 
12318 static void
12320 {
12321  const char *cs;
12322  int major, minor;
12323 
12324  if (cu->producer == NULL)
12325  {
12326  /* For unknown compilers expect their behavior is DWARF version
12327  compliant.
12328 
12329  GCC started to support .debug_types sections by -gdwarf-4 since
12330  gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
12331  for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
12332  combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
12333  interpreted incorrectly by GDB now - GCC PR debug/48229. */
12334  }
12335  else if (producer_is_gcc (cu->producer, &major, &minor))
12336  {
12337  cu->producer_is_gxx_lt_4_6 = major < 4 || (major == 4 && minor < 6);
12338  cu->producer_is_gcc_lt_4_3 = major < 4 || (major == 4 && minor < 3);
12339  }
12340  else if (startswith (cu->producer, "Intel(R) C"))
12341  cu->producer_is_icc = 1;
12342  else
12343  {
12344  /* For other non-GCC compilers, expect their behavior is DWARF version
12345  compliant. */
12346  }
12347 
12348  cu->checked_producer = 1;
12349 }
12350 
12351 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
12352  to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
12353  during 4.6.0 experimental. */
12354 
12355 static int
12357 {
12358  if (!cu->checked_producer)
12359  check_producer (cu);
12360 
12361  return cu->producer_is_gxx_lt_4_6;
12362 }
12363 
12364 /* Return the default accessibility type if it is not overriden by
12365  DW_AT_accessibility. */
12366 
12367 static enum dwarf_access_attribute
12369 {
12370  if (cu->header.version < 3 || producer_is_gxx_lt_4_6 (cu))
12371  {
12372  /* The default DWARF 2 accessibility for members is public, the default
12373  accessibility for inheritance is private. */
12374 
12375  if (die->tag != DW_TAG_inheritance)
12376  return DW_ACCESS_public;
12377  else
12378  return DW_ACCESS_private;
12379  }
12380  else
12381  {
12382  /* DWARF 3+ defines the default accessibility a different way. The same
12383  rules apply now for DW_TAG_inheritance as for the members and it only
12384  depends on the container kind. */
12385 
12386  if (die->parent->tag == DW_TAG_class_type)
12387  return DW_ACCESS_private;
12388  else
12389  return DW_ACCESS_public;
12390  }
12391 }
12392 
12393 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
12394  offset. If the attribute was not found return 0, otherwise return
12395  1. If it was found but could not properly be handled, set *OFFSET
12396  to 0. */
12397 
12398 static int
12400  LONGEST *offset)
12401 {
12402  struct attribute *attr;
12403 
12404  attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
12405  if (attr != NULL)
12406  {
12407  *offset = 0;
12408 
12409  /* Note that we do not check for a section offset first here.
12410  This is because DW_AT_data_member_location is new in DWARF 4,
12411  so if we see it, we can assume that a constant form is really
12412  a constant and not a section offset. */
12413  if (attr_form_is_constant (attr))
12414  *offset = dwarf2_get_attr_constant_value (attr, 0);
12415  else if (attr_form_is_section_offset (attr))
12417  else if (attr_form_is_block (attr))
12418  *offset = decode_locdesc (DW_BLOCK (attr), cu);
12419  else
12421 
12422  return 1;
12423  }
12424 
12425  return 0;
12426 }
12427 
12428 /* Add an aggregate field to the field list. */
12429 
12430 static void
12431 dwarf2_add_field (struct field_info *fip, struct die_info *die,
12432  struct dwarf2_cu *cu)
12433 {
12434  struct objfile *objfile = cu->objfile;
12435  struct gdbarch *gdbarch = get_objfile_arch (objfile);
12436  struct nextfield *new_field;
12437  struct attribute *attr;
12438  struct field *fp;
12439  const char *fieldname = "";
12440 
12441  /* Allocate a new field list entry and link it in. */
12442  new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield));
12443  make_cleanup (xfree, new_field);
12444  memset (new_field, 0, sizeof (struct nextfield));
12445 
12446  if (die->tag == DW_TAG_inheritance)
12447  {
12448  new_field->next = fip->baseclasses;
12449  fip->baseclasses = new_field;
12450  }
12451  else
12452  {
12453  new_field->next = fip->fields;
12454  fip->fields = new_field;
12455  }
12456  fip->nfields++;
12457 
12458  attr = dwarf2_attr (die, DW_AT_accessibility, cu);
12459  if (attr)
12460  new_field->accessibility = DW_UNSND (attr);
12461  else
12462  new_field->accessibility = dwarf2_default_access_attribute (die, cu);
12463  if (new_field->accessibility != DW_ACCESS_public)
12464  fip->non_public_fields = 1;
12465 
12466  attr = dwarf2_attr (die, DW_AT_virtuality, cu);
12467  if (attr)
12468  new_field->virtuality = DW_UNSND (attr);
12469  else
12470  new_field->virtuality = DW_VIRTUALITY_none;
12471 
12472  fp = &new_field->field;
12473 
12474  if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
12475  {
12476  LONGEST offset;
12477 
12478  /* Data member other than a C++ static data member. */
12479 
12480  /* Get type of field. */
12481  fp->type = die_type (die, cu);
12482 
12483  SET_FIELD_BITPOS (*fp, 0);
12484 
12485  /* Get bit size of field (zero if none). */
12486  attr = dwarf2_attr (die, DW_AT_bit_size, cu);
12487  if (attr)
12488  {
12489  FIELD_BITSIZE (*fp) = DW_UNSND (attr);
12490  }
12491  else
12492  {
12493  FIELD_BITSIZE (*fp) = 0;
12494  }
12495 
12496  /* Get bit offset of field. */
12497  if (handle_data_member_location (die, cu, &offset))
12498  SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
12499  attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
12500  if (attr)
12501  {
12502  if (gdbarch_bits_big_endian (gdbarch))
12503  {
12504  /* For big endian bits, the DW_AT_bit_offset gives the
12505  additional bit offset from the MSB of the containing
12506  anonymous object to the MSB of the field. We don't
12507  have to do anything special since we don't need to
12508  know the size of the anonymous object. */
12509  SET_FIELD_BITPOS (*fp, FIELD_BITPOS (*fp) + DW_UNSND (attr));
12510  }
12511  else
12512  {
12513  /* For little endian bits, compute the bit offset to the
12514  MSB of the anonymous object, subtract off the number of
12515  bits from the MSB of the field to the MSB of the
12516  object, and then subtract off the number of bits of
12517  the field itself. The result is the bit offset of
12518  the LSB of the field. */
12519  int anonymous_size;
12520  int bit_offset = DW_UNSND (attr);
12521 
12522  attr = dwarf2_attr (die, DW_AT_byte_size, cu);
12523  if (attr)
12524  {
12525  /* The size of the anonymous object containing
12526  the bit field is explicit, so use the
12527  indicated size (in bytes). */
12528  anonymous_size = DW_UNSND (attr);
12529  }
12530  else
12531  {
12532  /* The size of the anonymous object containing
12533  the bit field must be inferred from the type
12534  attribute of the data member containing the
12535  bit field. */
12536  anonymous_size = TYPE_LENGTH (fp->type);
12537  }
12538  SET_FIELD_BITPOS (*fp,
12539  (FIELD_BITPOS (*fp)
12540  + anonymous_size * bits_per_byte
12541  - bit_offset - FIELD_BITSIZE (*fp)));
12542  }
12543  }
12544 
12545  /* Get name of field. */
12546  fieldname = dwarf2_name (die, cu);
12547  if (fieldname == NULL)
12548  fieldname = "";
12549 
12550  /* The name is already allocated along with this objfile, so we don't
12551  need to duplicate it for the type. */
12552  fp->name = fieldname;
12553 
12554  /* Change accessibility for artificial fields (e.g. virtual table
12555  pointer or virtual base class pointer) to private. */
12556  if (dwarf2_attr (die, DW_AT_artificial, cu))
12557  {
12558  FIELD_ARTIFICIAL (*fp) = 1;
12559  new_field->accessibility = DW_ACCESS_private;
12560  fip->non_public_fields = 1;
12561  }
12562  }
12563  else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
12564  {
12565  /* C++ static member. */
12566 
12567  /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
12568  is a declaration, but all versions of G++ as of this writing
12569  (so through at least 3.2.1) incorrectly generate
12570  DW_TAG_variable tags. */
12571 
12572  const char *physname;
12573 
12574  /* Get name of field. */
12575  fieldname = dwarf2_name (die, cu);
12576  if (fieldname == NULL)
12577  return;
12578 
12579  attr = dwarf2_attr (die, DW_AT_const_value, cu);
12580  if (attr
12581  /* Only create a symbol if this is an external value.
12582  new_symbol checks this and puts the value in the global symbol
12583  table, which we want. If it is not external, new_symbol
12584  will try to put the value in cu->list_in_scope which is wrong. */
12585  && dwarf2_flag_true_p (die, DW_AT_external, cu))
12586  {
12587  /* A static const member, not much different than an enum as far as
12588  we're concerned, except that we can support more types. */
12589  new_symbol (die, NULL, cu);
12590  }
12591 
12592  /* Get physical name. */
12593  physname = dwarf2_physname (fieldname, die, cu);
12594 
12595  /* The name is already allocated along with this objfile, so we don't
12596  need to duplicate it for the type. */
12597  SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
12598  FIELD_TYPE (*fp) = die_type (die, cu);
12599  FIELD_NAME (*fp) = fieldname;
12600  }
12601  else if (die->tag == DW_TAG_inheritance)
12602  {
12603  LONGEST offset;
12604 
12605  /* C++ base class field. */
12606  if (handle_data_member_location (die, cu, &offset))
12607  SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
12608  FIELD_BITSIZE (*fp) = 0;
12609  FIELD_TYPE (*fp) = die_type (die, cu);
12610  FIELD_NAME (*fp) = type_name_no_tag (fp->type);
12611  fip->nbaseclasses++;
12612  }
12613 }
12614 
12615 /* Add a typedef defined in the scope of the FIP's class. */
12616 
12617 static void
12618 dwarf2_add_typedef (struct field_info *fip, struct die_info *die,
12619  struct dwarf2_cu *cu)
12620 {
12621  struct objfile *objfile = cu->objfile;
12622  struct typedef_field_list *new_field;
12623  struct attribute *attr;
12624  struct typedef_field *fp;
12625  char *fieldname = "";
12626 
12627  /* Allocate a new field list entry and link it in. */
12628  new_field = xzalloc (sizeof (*new_field));
12629  make_cleanup (xfree, new_field);
12630 
12631  gdb_assert (die->tag == DW_TAG_typedef);
12632 
12633  fp = &new_field->field;
12634 
12635  /* Get name of field. */
12636  fp->name = dwarf2_name (die, cu);
12637  if (fp->name == NULL)
12638  return;
12639 
12640  fp->type = read_type_die (die, cu);
12641 
12642  new_field->next = fip->typedef_field_list;
12643  fip->typedef_field_list = new_field;
12644  fip->typedef_field_list_count++;
12645 }
12646 
12647 /* Create the vector of fields, and attach it to the type. */
12648 
12649 static void
12651  struct dwarf2_cu *cu)
12652 {
12653  int nfields = fip->nfields;
12654 
12655  /* Record the field count, allocate space for the array of fields,
12656  and create blank accessibility bitfields if necessary. */
12657  TYPE_NFIELDS (type) = nfields;
12658  TYPE_FIELDS (type) = (struct field *)
12659  TYPE_ALLOC (type, sizeof (struct field) * nfields);
12660  memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
12661 
12662  if (fip->non_public_fields && cu->language != language_ada)
12663  {
12665 
12666  TYPE_FIELD_PRIVATE_BITS (type) =
12667  (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
12668  B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
12669 
12670  TYPE_FIELD_PROTECTED_BITS (type) =
12671  (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
12672  B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
12673 
12674  TYPE_FIELD_IGNORE_BITS (type) =
12675  (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
12676  B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
12677  }
12678 
12679  /* If the type has baseclasses, allocate and clear a bit vector for
12680  TYPE_FIELD_VIRTUAL_BITS. */
12681  if (fip->nbaseclasses && cu->language != language_ada)
12682  {
12683  int num_bytes = B_BYTES (fip->nbaseclasses);
12684  unsigned char *pointer;
12685 
12687  pointer = TYPE_ALLOC (type, num_bytes);
12688  TYPE_FIELD_VIRTUAL_BITS (type) = pointer;
12690  TYPE_N_BASECLASSES (type) = fip->nbaseclasses;
12691  }
12692 
12693  /* Copy the saved-up fields into the field vector. Start from the head of
12694  the list, adding to the tail of the field array, so that they end up in
12695  the same order in the array in which they were added to the list. */
12696  while (nfields-- > 0)
12697  {
12698  struct nextfield *fieldp;
12699 
12700  if (fip->fields)
12701  {
12702  fieldp = fip->fields;
12703  fip->fields = fieldp->next;
12704  }
12705  else
12706  {
12707  fieldp = fip->baseclasses;
12708  fip->baseclasses = fieldp->next;
12709  }
12710 
12711  TYPE_FIELD (type, nfields) = fieldp->field;
12712  switch (fieldp->accessibility)
12713  {
12714  case DW_ACCESS_private:
12715  if (cu->language != language_ada)
12716  SET_TYPE_FIELD_PRIVATE (type, nfields);
12717  break;
12718 
12719  case DW_ACCESS_protected:
12720  if (cu->language != language_ada)
12721  SET_TYPE_FIELD_PROTECTED (type, nfields);
12722  break;
12723 
12724  case DW_ACCESS_public:
12725  break;
12726 
12727  default:
12728  /* Unknown accessibility. Complain and treat it as public. */
12729  {
12730  complaint (&symfile_complaints, _("unsupported accessibility %d"),
12731  fieldp->accessibility);
12732  }
12733  break;
12734  }
12735  if (nfields < fip->nbaseclasses)
12736  {
12737  switch (fieldp->virtuality)
12738  {
12739  case DW_VIRTUALITY_virtual:
12740  case DW_VIRTUALITY_pure_virtual:
12741  if (cu->language == language_ada)
12742  error (_("unexpected virtuality in component of Ada type"));
12743  SET_TYPE_FIELD_VIRTUAL (type, nfields);
12744  break;
12745  }
12746  }
12747  }
12748 }
12749 
12750 /* Return true if this member function is a constructor, false
12751  otherwise. */
12752 
12753 static int
12754 dwarf2_is_constructor (struct die_info *die, struct dwarf2_cu *cu)
12755 {
12756  const char *fieldname;
12757  const char *type_name;
12758  int len;
12759 
12760  if (die->parent == NULL)
12761  return 0;
12762 
12763  if (die->parent->tag != DW_TAG_structure_type
12764  && die->parent->tag != DW_TAG_union_type
12765  && die->parent->tag != DW_TAG_class_type)
12766  return 0;
12767 
12768  fieldname = dwarf2_name (die, cu);
12769  type_name = dwarf2_name (die->parent, cu);
12770  if (fieldname == NULL || type_name == NULL)
12771  return 0;
12772 
12773  len = strlen (fieldname);
12774  return (strncmp (fieldname, type_name, len) == 0
12775  && (type_name[len] == '\0' || type_name[len] == '<'));
12776 }
12777 
12778 /* Add a member function to the proper fieldlist. */
12779 
12780 static void
12781 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
12782  struct type *type, struct dwarf2_cu *cu)
12783 {
12784  struct objfile *objfile = cu->objfile;
12785  struct attribute *attr;
12786  struct fnfieldlist *flp;
12787  int i;
12788  struct fn_field *fnp;
12789  const char *fieldname;
12790  struct nextfnfield *new_fnfield;
12791  struct type *this_type;
12792  enum dwarf_access_attribute accessibility;
12793 
12794  if (cu->language == language_ada)
12795  error (_("unexpected member function in Ada type"));
12796 
12797  /* Get name of member function. */
12798  fieldname = dwarf2_name (die, cu);
12799  if (fieldname == NULL)
12800  return;
12801 
12802  /* Look up member function name in fieldlist. */
12803  for (i = 0; i < fip->nfnfields; i++)
12804  {
12805  if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
12806  break;
12807  }
12808 
12809  /* Create new list element if necessary. */
12810  if (i < fip->nfnfields)
12811  flp = &fip->fnfieldlists[i];
12812  else
12813  {
12814  if ((fip->nfnfields % DW_FIELD_ALLOC_CHUNK) == 0)
12815  {
12816  fip->fnfieldlists = (struct fnfieldlist *)
12817  xrealloc (fip->fnfieldlists,
12819  * sizeof (struct fnfieldlist));
12820  if (fip->nfnfields == 0)
12822  }
12823  flp = &fip->fnfieldlists[fip->nfnfields];
12824  flp->name = fieldname;
12825  flp->length = 0;
12826  flp->head = NULL;
12827  i = fip->nfnfields++;
12828  }
12829 
12830  /* Create a new member function field and chain it to the field list
12831  entry. */
12832  new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield));
12833  make_cleanup (xfree, new_fnfield);
12834  memset (new_fnfield, 0, sizeof (struct nextfnfield));
12835  new_fnfield->next = flp->head;
12836  flp->head = new_fnfield;
12837  flp->length++;
12838 
12839  /* Fill in the member function field info. */
12840  fnp = &new_fnfield->fnfield;
12841 
12842  /* Delay processing of the physname until later. */
12843  if (cu->language == language_cplus || cu->language == language_java)
12844  {
12845  add_to_method_list (type, i, flp->length - 1, fieldname,
12846  die, cu);
12847  }
12848  else
12849  {
12850  const char *physname = dwarf2_physname (fieldname, die, cu);
12851  fnp->physname = physname ? physname : "";
12852  }
12853 
12854  fnp->type = alloc_type (objfile);
12855  this_type = read_type_die (die, cu);
12856  if (this_type && TYPE_CODE (this_type) == TYPE_CODE_FUNC)
12857  {
12858  int nparams = TYPE_NFIELDS (this_type);
12859 
12860  /* TYPE is the domain of this method, and THIS_TYPE is the type
12861  of the method itself (TYPE_CODE_METHOD). */
12862  smash_to_method_type (fnp->type, type,
12863  TYPE_TARGET_TYPE (this_type),
12864  TYPE_FIELDS (this_type),
12865  TYPE_NFIELDS (this_type),
12866  TYPE_VARARGS (this_type));
12867 
12868  /* Handle static member functions.
12869  Dwarf2 has no clean way to discern C++ static and non-static
12870  member functions. G++ helps GDB by marking the first
12871  parameter for non-static member functions (which is the this
12872  pointer) as artificial. We obtain this information from
12873  read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
12874  if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (this_type, 0) == 0)
12875  fnp->voffset = VOFFSET_STATIC;
12876  }
12877  else
12878  complaint (&symfile_complaints, _("member function type missing for '%s'"),
12879  dwarf2_full_name (fieldname, die, cu));
12880 
12881  /* Get fcontext from DW_AT_containing_type if present. */
12882  if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
12883  fnp->fcontext = die_containing_type (die, cu);
12884 
12885  /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
12886  is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
12887 
12888  /* Get accessibility. */
12889  attr = dwarf2_attr (die, DW_AT_accessibility, cu);
12890  if (attr)
12891  accessibility = DW_UNSND (attr);
12892  else
12893  accessibility = dwarf2_default_access_attribute (die, cu);
12894  switch (accessibility)
12895  {
12896  case DW_ACCESS_private:
12897  fnp->is_private = 1;
12898  break;
12899  case DW_ACCESS_protected:
12900  fnp->is_protected = 1;
12901  break;
12902  }
12903 
12904  /* Check for artificial methods. */
12905  attr = dwarf2_attr (die, DW_AT_artificial, cu);
12906  if (attr && DW_UNSND (attr) != 0)
12907  fnp->is_artificial = 1;
12908 
12909  fnp->is_constructor = dwarf2_is_constructor (die, cu);
12910 
12911  /* Get index in virtual function table if it is a virtual member
12912  function. For older versions of GCC, this is an offset in the
12913  appropriate virtual table, as specified by DW_AT_containing_type.
12914  For everyone else, it is an expression to be evaluated relative
12915  to the object address. */
12916 
12917  attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
12918  if (attr)
12919  {
12920  if (attr_form_is_block (attr) && DW_BLOCK (attr)->size > 0)
12921  {
12922  if (DW_BLOCK (attr)->data[0] == DW_OP_constu)
12923  {
12924  /* Old-style GCC. */
12925  fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
12926  }
12927  else if (DW_BLOCK (attr)->data[0] == DW_OP_deref
12928  || (DW_BLOCK (attr)->size > 1
12929  && DW_BLOCK (attr)->data[0] == DW_OP_deref_size
12930  && DW_BLOCK (attr)->data[1] == cu->header.addr_size))
12931  {
12932  struct dwarf_block blk;
12933  int offset;
12934 
12935  offset = (DW_BLOCK (attr)->data[0] == DW_OP_deref
12936  ? 1 : 2);
12937  blk.size = DW_BLOCK (attr)->size - offset;
12938  blk.data = DW_BLOCK (attr)->data + offset;
12939  fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu);
12940  if ((fnp->voffset % cu->header.addr_size) != 0)
12942  else
12943  fnp->voffset /= cu->header.addr_size;
12944  fnp->voffset += 2;
12945  }
12946  else
12948 
12949  if (!fnp->fcontext)
12950  {
12951  /* If there is no `this' field and no DW_AT_containing_type,
12952  we cannot actually find a base class context for the
12953  vtable! */
12954  if (TYPE_NFIELDS (this_type) == 0
12955  || !TYPE_FIELD_ARTIFICIAL (this_type, 0))
12956  {
12958  _("cannot determine context for virtual member "
12959  "function \"%s\" (offset %d)"),
12960  fieldname, die->offset.sect_off);
12961  }
12962  else
12963  {
12964  fnp->fcontext
12965  = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type, 0));
12966  }
12967  }
12968  }
12969  else if (attr_form_is_section_offset (attr))
12970  {
12972  }
12973  else
12974  {
12975  dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
12976  fieldname);
12977  }
12978  }
12979  else
12980  {
12981  attr = dwarf2_attr (die, DW_AT_virtuality, cu);
12982  if (attr && DW_UNSND (attr))
12983  {
12984  /* GCC does this, as of 2008-08-25; PR debug/37237. */
12986  _("Member function \"%s\" (offset %d) is virtual "
12987  "but the vtable offset is not specified"),
12988  fieldname, die->offset.sect_off);
12990  TYPE_CPLUS_DYNAMIC (type) = 1;
12991  }
12992  }
12993 }
12994 
12995 /* Create the vector of member function fields, and attach it to the type. */
12996 
12997 static void
12999  struct dwarf2_cu *cu)
13000 {
13001  struct fnfieldlist *flp;
13002  int i;
13003 
13004  if (cu->language == language_ada)
13005  error (_("unexpected member functions in Ada type"));
13006 
13008  TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
13009  TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * fip->nfnfields);
13010 
13011  for (i = 0, flp = fip->fnfieldlists; i < fip->nfnfields; i++, flp++)
13012  {
13013  struct nextfnfield *nfp = flp->head;
13014  struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
13015  int k;
13016 
13017  TYPE_FN_FIELDLIST_NAME (type, i) = flp->name;
13018  TYPE_FN_FIELDLIST_LENGTH (type, i) = flp->length;
13019  fn_flp->fn_fields = (struct fn_field *)
13020  TYPE_ALLOC (type, sizeof (struct fn_field) * flp->length);
13021  for (k = flp->length; (k--, nfp); nfp = nfp->next)
13022  fn_flp->fn_fields[k] = nfp->fnfield;
13023  }
13024 
13025  TYPE_NFN_FIELDS (type) = fip->nfnfields;
13026 }
13027 
13028 /* Returns non-zero if NAME is the name of a vtable member in CU's
13029  language, zero otherwise. */
13030 static int
13031 is_vtable_name (const char *name, struct dwarf2_cu *cu)
13032 {
13033  static const char vptr[] = "_vptr";
13034  static const char vtable[] = "vtable";
13035 
13036  /* Look for the C++ and Java forms of the vtable. */
13037  if ((cu->language == language_java
13038  && startswith (name, vtable))
13039  || (startswith (name, vptr)
13040  && is_cplus_marker (name[sizeof (vptr) - 1])))
13041  return 1;
13042 
13043  return 0;
13044 }
13045 
13046 /* GCC outputs unnamed structures that are really pointers to member
13047  functions, with the ABI-specified layout. If TYPE describes
13048  such a structure, smash it into a member function type.
13049 
13050  GCC shouldn't do this; it should just output pointer to member DIEs.
13051  This is GCC PR debug/28767. */
13052 
13053 static void
13054 quirk_gcc_member_function_pointer (struct type *type, struct objfile *objfile)
13055 {
13056  struct type *pfn_type, *self_type, *new_type;
13057 
13058  /* Check for a structure with no name and two children. */
13059  if (TYPE_CODE (type) != TYPE_CODE_STRUCT || TYPE_NFIELDS (type) != 2)
13060  return;
13061 
13062  /* Check for __pfn and __delta members. */
13063  if (TYPE_FIELD_NAME (type, 0) == NULL
13064  || strcmp (TYPE_FIELD_NAME (type, 0), "__pfn") != 0
13065  || TYPE_FIELD_NAME (type, 1) == NULL
13066  || strcmp (TYPE_FIELD_NAME (type, 1), "__delta") != 0)
13067  return;
13068 
13069  /* Find the type of the method. */
13070  pfn_type = TYPE_FIELD_TYPE (type, 0);
13071  if (pfn_type == NULL
13072  || TYPE_CODE (pfn_type) != TYPE_CODE_PTR
13073  || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type)) != TYPE_CODE_FUNC)
13074  return;
13075 
13076  /* Look for the "this" argument. */
13077  pfn_type = TYPE_TARGET_TYPE (pfn_type);
13078  if (TYPE_NFIELDS (pfn_type) == 0
13079  /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
13080  || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type, 0)) != TYPE_CODE_PTR)
13081  return;
13082 
13083  self_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0));
13084  new_type = alloc_type (objfile);
13085  smash_to_method_type (new_type, self_type, TYPE_TARGET_TYPE (pfn_type),
13086  TYPE_FIELDS (pfn_type), TYPE_NFIELDS (pfn_type),
13087  TYPE_VARARGS (pfn_type));
13088  smash_to_methodptr_type (type, new_type);
13089 }
13090 
13091 /* Return non-zero if the CU's PRODUCER string matches the Intel C/C++ compiler
13092  (icc). */
13093 
13094 static int
13096 {
13097  if (!cu->checked_producer)
13098  check_producer (cu);
13099 
13100  return cu->producer_is_icc;
13101 }
13102 
13103 /* Called when we find the DIE that starts a structure or union scope
13104  (definition) to create a type for the structure or union. Fill in
13105  the type's name and general properties; the members will not be
13106  processed until process_structure_scope. A symbol table entry for
13107  the type will also not be done until process_structure_scope (assuming
13108  the type has a name).
13109 
13110  NOTE: we need to call these functions regardless of whether or not the
13111  DIE has a DW_AT_name attribute, since it might be an anonymous
13112  structure or union. This gets the type entered into our set of
13113  user defined types. */
13114 
13115 static struct type *
13116 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
13117 {
13118  struct objfile *objfile = cu->objfile;
13119  struct type *type;
13120  struct attribute *attr;
13121  const char *name;
13122 
13123  /* If the definition of this type lives in .debug_types, read that type.
13124  Don't follow DW_AT_specification though, that will take us back up
13125  the chain and we want to go down. */
13126  attr = dwarf2_attr_no_follow (die, DW_AT_signature);
13127  if (attr)
13128  {
13129  type = get_DW_AT_signature_type (die, attr, cu);
13130 
13131  /* The type's CU may not be the same as CU.
13132  Ensure TYPE is recorded with CU in die_type_hash. */
13133  return set_die_type (die, type, cu);
13134  }
13135 
13136  type = alloc_type (objfile);
13137  INIT_CPLUS_SPECIFIC (type);
13138 
13139  name = dwarf2_name (die, cu);
13140  if (name != NULL)
13141  {
13142  if (cu->language == language_cplus
13143  || cu->language == language_java)
13144  {
13145  const char *full_name = dwarf2_full_name (name, die, cu);
13146 
13147  /* dwarf2_full_name might have already finished building the DIE's
13148  type. If so, there is no need to continue. */
13149  if (get_die_type (die, cu) != NULL)
13150  return get_die_type (die, cu);
13151 
13152  TYPE_TAG_NAME (type) = full_name;
13153  if (die->tag == DW_TAG_structure_type
13154  || die->tag == DW_TAG_class_type)
13155  TYPE_NAME (type) = TYPE_TAG_NAME (type);
13156  }
13157  else
13158  {
13159  /* The name is already allocated along with this objfile, so
13160  we don't need to duplicate it for the type. */
13161  TYPE_TAG_NAME (type) = name;
13162  if (die->tag == DW_TAG_class_type)
13163  TYPE_NAME (type) = TYPE_TAG_NAME (type);
13164  }
13165  }
13166 
13167  if (die->tag == DW_TAG_structure_type)
13168  {
13169  TYPE_CODE (type) = TYPE_CODE_STRUCT;
13170  }
13171  else if (die->tag == DW_TAG_union_type)
13172  {
13173  TYPE_CODE (type) = TYPE_CODE_UNION;
13174  }
13175  else
13176  {
13177  TYPE_CODE (type) = TYPE_CODE_STRUCT;
13178  }
13179 
13180  if (cu->language == language_cplus && die->tag == DW_TAG_class_type)
13181  TYPE_DECLARED_CLASS (type) = 1;
13182 
13183  attr = dwarf2_attr (die, DW_AT_byte_size, cu);
13184  if (attr)
13185  {
13186  TYPE_LENGTH (type) = DW_UNSND (attr);
13187  }
13188  else
13189  {
13190  TYPE_LENGTH (type) = 0;
13191  }
13192 
13193  if (producer_is_icc (cu) && (TYPE_LENGTH (type) == 0))
13194  {
13195  /* ICC does not output the required DW_AT_declaration
13196  on incomplete types, but gives them a size of zero. */
13197  TYPE_STUB (type) = 1;
13198  }
13199  else
13200  TYPE_STUB_SUPPORTED (type) = 1;
13201 
13202  if (die_is_declaration (die, cu))
13203  TYPE_STUB (type) = 1;
13204  else if (attr == NULL && die->child == NULL
13205  && producer_is_realview (cu->producer))
13206  /* RealView does not output the required DW_AT_declaration
13207  on incomplete types. */
13208  TYPE_STUB (type) = 1;
13209 
13210  /* We need to add the type field to the die immediately so we don't
13211  infinitely recurse when dealing with pointers to the structure
13212  type within the structure itself. */
13213  set_die_type (die, type, cu);
13214 
13215  /* set_die_type should be already done. */
13216  set_descriptive_type (type, die, cu);
13217 
13218  return type;
13219 }
13220 
13221 /* Finish creating a structure or union type, including filling in
13222  its members and creating a symbol for it. */
13223 
13224 static void
13225 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
13226 {
13227  struct objfile *objfile = cu->objfile;
13228  struct die_info *child_die;
13229  struct type *type;
13230 
13231  type = get_die_type (die, cu);
13232  if (type == NULL)
13233  type = read_structure_type (die, cu);
13234 
13235  if (die->child != NULL && ! die_is_declaration (die, cu))
13236  {
13237  struct field_info fi;
13238  VEC (symbolp) *template_args = NULL;
13239  struct cleanup *back_to = make_cleanup (null_cleanup, 0);
13240 
13241  memset (&fi, 0, sizeof (struct field_info));
13242 
13243  child_die = die->child;
13244 
13245  while (child_die && child_die->tag)
13246  {
13247  if (child_die->tag == DW_TAG_member
13248  || child_die->tag == DW_TAG_variable)
13249  {
13250  /* NOTE: carlton/2002-11-05: A C++ static data member
13251  should be a DW_TAG_member that is a declaration, but
13252  all versions of G++ as of this writing (so through at
13253  least 3.2.1) incorrectly generate DW_TAG_variable
13254  tags for them instead. */
13255  dwarf2_add_field (&fi, child_die, cu);
13256  }
13257  else if (child_die->tag == DW_TAG_subprogram)
13258  {
13259  /* C++ member function. */
13260  dwarf2_add_member_fn (&fi, child_die, type, cu);
13261  }
13262  else if (child_die->tag == DW_TAG_inheritance)
13263  {
13264  /* C++ base class field. */
13265  dwarf2_add_field (&fi, child_die, cu);
13266  }
13267  else if (child_die->tag == DW_TAG_typedef)
13268  dwarf2_add_typedef (&fi, child_die, cu);
13269  else if (child_die->tag == DW_TAG_template_type_param
13270  || child_die->tag == DW_TAG_template_value_param)
13271  {
13272  struct symbol *arg = new_symbol (child_die, NULL, cu);
13273 
13274  if (arg != NULL)
13275  VEC_safe_push (symbolp, template_args, arg);
13276  }
13277 
13278  child_die = sibling_die (child_die);
13279  }
13280 
13281  /* Attach template arguments to type. */
13282  if (! VEC_empty (symbolp, template_args))
13283  {
13286  = VEC_length (symbolp, template_args);
13288  = obstack_alloc (&objfile->objfile_obstack,
13290  * sizeof (struct symbol *)));
13291  memcpy (TYPE_TEMPLATE_ARGUMENTS (type),
13292  VEC_address (symbolp, template_args),
13294  * sizeof (struct symbol *)));
13295  VEC_free (symbolp, template_args);
13296  }
13297 
13298  /* Attach fields and member functions to the type. */
13299  if (fi.nfields)
13300  dwarf2_attach_fields_to_type (&fi, type, cu);
13301  if (fi.nfnfields)
13302  {
13303  dwarf2_attach_fn_fields_to_type (&fi, type, cu);
13304 
13305  /* Get the type which refers to the base class (possibly this
13306  class itself) which contains the vtable pointer for the current
13307  class from the DW_AT_containing_type attribute. This use of
13308  DW_AT_containing_type is a GNU extension. */
13309 
13310  if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
13311  {
13312  struct type *t = die_containing_type (die, cu);
13313 
13314  set_type_vptr_basetype (type, t);
13315  if (type == t)
13316  {
13317  int i;
13318 
13319  /* Our own class provides vtbl ptr. */
13320  for (i = TYPE_NFIELDS (t) - 1;
13321  i >= TYPE_N_BASECLASSES (t);
13322  --i)
13323  {
13324  const char *fieldname = TYPE_FIELD_NAME (t, i);
13325 
13326  if (is_vtable_name (fieldname, cu))
13327  {
13328  set_type_vptr_fieldno (type, i);
13329  break;
13330  }
13331  }
13332 
13333  /* Complain if virtual function table field not found. */
13334  if (i < TYPE_N_BASECLASSES (t))
13336  _("virtual function table pointer "
13337  "not found when defining class '%s'"),
13338  TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) :
13339  "");
13340  }
13341  else
13342  {
13344  }
13345  }
13346  else if (cu->producer
13347  && startswith (cu->producer, "IBM(R) XL C/C++ Advanced Edition"))
13348  {
13349  /* The IBM XLC compiler does not provide direct indication
13350  of the containing type, but the vtable pointer is
13351  always named __vfp. */
13352 
13353  int i;
13354 
13355  for (i = TYPE_NFIELDS (type) - 1;
13356  i >= TYPE_N_BASECLASSES (type);
13357  --i)
13358  {
13359  if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
13360  {
13361  set_type_vptr_fieldno (type, i);
13362  set_type_vptr_basetype (type, type);
13363  break;
13364  }
13365  }
13366  }
13367  }
13368 
13369  /* Copy fi.typedef_field_list linked list elements content into the
13370  allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
13371  if (fi.typedef_field_list)
13372  {
13373  int i = fi.typedef_field_list_count;
13374 
13377  = TYPE_ALLOC (type, sizeof (TYPE_TYPEDEF_FIELD (type, 0)) * i);
13378  TYPE_TYPEDEF_FIELD_COUNT (type) = i;
13379 
13380  /* Reverse the list order to keep the debug info elements order. */
13381  while (--i >= 0)
13382  {
13383  struct typedef_field *dest, *src;
13384 
13385  dest = &TYPE_TYPEDEF_FIELD (type, i);
13386  src = &fi.typedef_field_list->field;
13388  *dest = *src;
13389  }
13390  }
13391 
13392  do_cleanups (back_to);
13393 
13394  if (HAVE_CPLUS_STRUCT (type))
13396  }
13397 
13398  quirk_gcc_member_function_pointer (type, objfile);
13399 
13400  /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
13401  snapshots) has been known to create a die giving a declaration
13402  for a class that has, as a child, a die giving a definition for a
13403  nested class. So we have to process our children even if the
13404  current die is a declaration. Normally, of course, a declaration
13405  won't have any children at all. */
13406 
13407  child_die = die->child;
13408 
13409  while (child_die != NULL && child_die->tag)
13410  {
13411  if (child_die->tag == DW_TAG_member
13412  || child_die->tag == DW_TAG_variable
13413  || child_die->tag == DW_TAG_inheritance
13414  || child_die->tag == DW_TAG_template_value_param
13415  || child_die->tag == DW_TAG_template_type_param)
13416  {
13417  /* Do nothing. */
13418  }
13419  else
13420  process_die (child_die, cu);
13421 
13422  child_die = sibling_die (child_die);
13423  }
13424 
13425  /* Do not consider external references. According to the DWARF standard,
13426  these DIEs are identified by the fact that they have no byte_size
13427  attribute, and a declaration attribute. */
13428  if (dwarf2_attr (die, DW_AT_byte_size, cu) != NULL
13429  || !die_is_declaration (die, cu))
13430  new_symbol (die, type, cu);
13431 }
13432 
13433 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
13434  update TYPE using some information only available in DIE's children. */
13435 
13436 static void
13438  struct type *type,
13439  struct dwarf2_cu *cu)
13440 {
13441  struct obstack obstack;
13442  struct die_info *child_die;
13443  int unsigned_enum = 1;
13444  int flag_enum = 1;
13445  ULONGEST mask = 0;
13446  struct cleanup *old_chain;
13447 
13448  obstack_init (&obstack);
13449  old_chain = make_cleanup_obstack_free (&obstack);
13450 
13451  for (child_die = die->child;
13452  child_die != NULL && child_die->tag;
13453  child_die = sibling_die (child_die))
13454  {
13455  struct attribute *attr;
13456  LONGEST value;
13457  const gdb_byte *bytes;
13458  struct dwarf2_locexpr_baton *baton;
13459  const char *name;
13460 
13461  if (child_die->tag != DW_TAG_enumerator)
13462  continue;
13463 
13464  attr = dwarf2_attr (child_die, DW_AT_const_value, cu);
13465  if (attr == NULL)
13466  continue;
13467 
13468  name = dwarf2_name (child_die, cu);
13469  if (name == NULL)
13470  name = "<anonymous enumerator>";
13471 
13472  dwarf2_const_value_attr (attr, type, name, &obstack, cu,
13473  &value, &bytes, &baton);
13474  if (value < 0)
13475  {
13476  unsigned_enum = 0;
13477  flag_enum = 0;
13478  }
13479  else if ((mask & value) != 0)
13480  flag_enum = 0;
13481  else
13482  mask |= value;
13483 
13484  /* If we already know that the enum type is neither unsigned, nor
13485  a flag type, no need to look at the rest of the enumerates. */
13486  if (!unsigned_enum && !flag_enum)
13487  break;
13488  }
13489 
13490  if (unsigned_enum)
13491  TYPE_UNSIGNED (type) = 1;
13492  if (flag_enum)
13493  TYPE_FLAG_ENUM (type) = 1;
13494 
13495  do_cleanups (old_chain);
13496 }
13497 
13498 /* Given a DW_AT_enumeration_type die, set its type. We do not
13499  complete the type's fields yet, or create any symbols. */
13500 
13501 static struct type *
13502 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
13503 {
13504  struct objfile *objfile = cu->objfile;
13505  struct type *type;
13506  struct attribute *attr;
13507  const char *name;
13508 
13509  /* If the definition of this type lives in .debug_types, read that type.
13510  Don't follow DW_AT_specification though, that will take us back up
13511  the chain and we want to go down. */
13512  attr = dwarf2_attr_no_follow (die, DW_AT_signature);
13513  if (attr)
13514  {
13515  type = get_DW_AT_signature_type (die, attr, cu);
13516 
13517  /* The type's CU may not be the same as CU.
13518  Ensure TYPE is recorded with CU in die_type_hash. */
13519  return set_die_type (die, type, cu);
13520  }
13521 
13522  type = alloc_type (objfile);
13523 
13524  TYPE_CODE (type) = TYPE_CODE_ENUM;
13525  name = dwarf2_full_name (NULL, die, cu);
13526  if (name != NULL)
13527  TYPE_TAG_NAME (type) = name;
13528 
13529  attr = dwarf2_attr (die, DW_AT_type, cu);
13530  if (attr != NULL)
13531  {
13532  struct type *underlying_type = die_type (die, cu);
13533 
13534  TYPE_TARGET_TYPE (type) = underlying_type;
13535  }
13536 
13537  attr = dwarf2_attr (die, DW_AT_byte_size, cu);
13538  if (attr)
13539  {
13540  TYPE_LENGTH (type) = DW_UNSND (attr);
13541  }
13542  else
13543  {
13544  TYPE_LENGTH (type) = 0;
13545  }
13546 
13547  /* The enumeration DIE can be incomplete. In Ada, any type can be
13548  declared as private in the package spec, and then defined only
13549  inside the package body. Such types are known as Taft Amendment
13550  Types. When another package uses such a type, an incomplete DIE
13551  may be generated by the compiler. */
13552  if (die_is_declaration (die, cu))
13553  TYPE_STUB (type) = 1;
13554 
13555  /* Finish the creation of this type by using the enum's children.
13556  We must call this even when the underlying type has been provided
13557  so that we can determine if we're looking at a "flag" enum. */
13558  update_enumeration_type_from_children (die, type, cu);
13559 
13560  /* If this type has an underlying type that is not a stub, then we
13561  may use its attributes. We always use the "unsigned" attribute
13562  in this situation, because ordinarily we guess whether the type
13563  is unsigned -- but the guess can be wrong and the underlying type
13564  can tell us the reality. However, we defer to a local size
13565  attribute if one exists, because this lets the compiler override
13566  the underlying type if needed. */
13567  if (TYPE_TARGET_TYPE (type) != NULL && !TYPE_STUB (TYPE_TARGET_TYPE (type)))
13568  {
13569  TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type));
13570  if (TYPE_LENGTH (type) == 0)
13571  TYPE_LENGTH (type) = TYPE_LENGTH (TYPE_TARGET_TYPE (type));
13572  }
13573 
13574  TYPE_DECLARED_CLASS (type) = dwarf2_flag_true_p (die, DW_AT_enum_class, cu);
13575 
13576  return set_die_type (die, type, cu);
13577 }
13578 
13579 /* Given a pointer to a die which begins an enumeration, process all
13580  the dies that define the members of the enumeration, and create the
13581  symbol for the enumeration type.
13582 
13583  NOTE: We reverse the order of the element list. */
13584 
13585 static void
13587 {
13588  struct type *this_type;
13589 
13590  this_type = get_die_type (die, cu);
13591  if (this_type == NULL)
13592  this_type = read_enumeration_type (die, cu);
13593 
13594  if (die->child != NULL)
13595  {
13596  struct die_info *child_die;
13597  struct symbol *sym;
13598  struct field *fields = NULL;
13599  int num_fields = 0;
13600  const char *name;
13601 
13602  child_die = die->child;
13603  while (child_die && child_die->tag)
13604  {
13605  if (child_die->tag != DW_TAG_enumerator)
13606  {
13607  process_die (child_die, cu);
13608  }
13609  else
13610  {
13611  name = dwarf2_name (child_die, cu);
13612  if (name)
13613  {
13614  sym = new_symbol (child_die, this_type, cu);
13615 
13616  if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
13617  {
13618  fields = (struct field *)
13619  xrealloc (fields,
13620  (num_fields + DW_FIELD_ALLOC_CHUNK)
13621  * sizeof (struct field));
13622  }
13623 
13624  FIELD_NAME (fields[num_fields]) = SYMBOL_LINKAGE_NAME (sym);
13625  FIELD_TYPE (fields[num_fields]) = NULL;
13626  SET_FIELD_ENUMVAL (fields[num_fields], SYMBOL_VALUE (sym));
13627  FIELD_BITSIZE (fields[num_fields]) = 0;
13628 
13629  num_fields++;
13630  }
13631  }
13632 
13633  child_die = sibling_die (child_die);
13634  }
13635 
13636  if (num_fields)
13637  {
13638  TYPE_NFIELDS (this_type) = num_fields;
13639  TYPE_FIELDS (this_type) = (struct field *)
13640  TYPE_ALLOC (this_type, sizeof (struct field) * num_fields);
13641  memcpy (TYPE_FIELDS (this_type), fields,
13642  sizeof (struct field) * num_fields);
13643  xfree (fields);
13644  }
13645  }
13646 
13647  /* If we are reading an enum from a .debug_types unit, and the enum
13648  is a declaration, and the enum is not the signatured type in the
13649  unit, then we do not want to add a symbol for it. Adding a
13650  symbol would in some cases obscure the true definition of the
13651  enum, giving users an incomplete type when the definition is
13652  actually available. Note that we do not want to do this for all
13653  enums which are just declarations, because C++0x allows forward
13654  enum declarations. */
13655  if (cu->per_cu->is_debug_types
13656  && die_is_declaration (die, cu))
13657  {
13658  struct signatured_type *sig_type;
13659 
13660  sig_type = (struct signatured_type *) cu->per_cu;
13661  gdb_assert (sig_type->type_offset_in_section.sect_off != 0);
13662  if (sig_type->type_offset_in_section.sect_off != die->offset.sect_off)
13663  return;
13664  }
13665 
13666  new_symbol (die, this_type, cu);
13667 }
13668 
13669 /* Extract all information from a DW_TAG_array_type DIE and put it in
13670  the DIE's type field. For now, this only handles one dimensional
13671  arrays. */
13672 
13673 static struct type *
13674 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
13675 {
13676  struct objfile *objfile = cu->objfile;
13677  struct die_info *child_die;
13678  struct type *type;
13679  struct type *element_type, *range_type, *index_type;
13680  struct type **range_types = NULL;
13681  struct attribute *attr;
13682  int ndim = 0;
13683  struct cleanup *back_to;
13684  const char *name;
13685  unsigned int bit_stride = 0;
13686 
13687  element_type = die_type (die, cu);
13688 
13689  /* The die_type call above may have already set the type for this DIE. */
13690  type = get_die_type (die, cu);
13691  if (type)
13692  return type;
13693 
13694  attr = dwarf2_attr (die, DW_AT_byte_stride, cu);
13695  if (attr != NULL)
13696  bit_stride = DW_UNSND (attr) * 8;
13697 
13698  attr = dwarf2_attr (die, DW_AT_bit_stride, cu);
13699  if (attr != NULL)
13700  bit_stride = DW_UNSND (attr);
13701 
13702  /* Irix 6.2 native cc creates array types without children for
13703  arrays with unspecified length. */
13704  if (die->child == NULL)
13705  {
13706  index_type = objfile_type (objfile)->builtin_int;
13707  range_type = create_static_range_type (NULL, index_type, 0, -1);
13708  type = create_array_type_with_stride (NULL, element_type, range_type,
13709  bit_stride);
13710  return set_die_type (die, type, cu);
13711  }
13712 
13713  back_to = make_cleanup (null_cleanup, NULL);
13714  child_die = die->child;
13715  while (child_die && child_die->tag)
13716  {
13717  if (child_die->tag == DW_TAG_subrange_type)
13718  {
13719  struct type *child_type = read_type_die (child_die, cu);
13720 
13721  if (child_type != NULL)
13722  {
13723  /* The range type was succesfully read. Save it for the
13724  array type creation. */
13725  if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0)
13726  {
13727  range_types = (struct type **)
13728  xrealloc (range_types, (ndim + DW_FIELD_ALLOC_CHUNK)
13729  * sizeof (struct type *));
13730  if (ndim == 0)
13731  make_cleanup (free_current_contents, &range_types);
13732  }
13733  range_types[ndim++] = child_type;
13734  }
13735  }
13736  child_die = sibling_die (child_die);
13737  }
13738 
13739  /* Dwarf2 dimensions are output from left to right, create the
13740  necessary array types in backwards order. */
13741 
13742  type = element_type;
13743 
13744  if (read_array_order (die, cu) == DW_ORD_col_major)
13745  {
13746  int i = 0;
13747 
13748  while (i < ndim)
13749  type = create_array_type_with_stride (NULL, type, range_types[i++],
13750  bit_stride);
13751  }
13752  else
13753  {
13754  while (ndim-- > 0)
13755  type = create_array_type_with_stride (NULL, type, range_types[ndim],
13756  bit_stride);
13757  }
13758 
13759  /* Understand Dwarf2 support for vector types (like they occur on
13760  the PowerPC w/ AltiVec). Gcc just adds another attribute to the
13761  array type. This is not part of the Dwarf2/3 standard yet, but a
13762  custom vendor extension. The main difference between a regular
13763  array and the vector variant is that vectors are passed by value
13764  to functions. */
13765  attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
13766  if (attr)
13767  make_vector_type (type);
13768 
13769  /* The DIE may have DW_AT_byte_size set. For example an OpenCL
13770  implementation may choose to implement triple vectors using this
13771  attribute. */
13772  attr = dwarf2_attr (die, DW_AT_byte_size, cu);
13773  if (attr)
13774  {
13775  if (DW_UNSND (attr) >= TYPE_LENGTH (type))
13776  TYPE_LENGTH (type) = DW_UNSND (attr);
13777  else
13779  _("DW_AT_byte_size for array type smaller "
13780  "than the total size of elements"));
13781  }
13782 
13783  name = dwarf2_name (die, cu);
13784  if (name)
13785  TYPE_NAME (type) = name;
13786 
13787  /* Install the type in the die. */
13788  set_die_type (die, type, cu);
13789 
13790  /* set_die_type should be already done. */
13791  set_descriptive_type (type, die, cu);
13792 
13793  do_cleanups (back_to);
13794 
13795  return type;
13796 }
13797 
13798 static enum dwarf_array_dim_ordering
13799 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
13800 {
13801  struct attribute *attr;
13802 
13803  attr = dwarf2_attr (die, DW_AT_ordering, cu);
13804 
13805  if (attr) return DW_SND (attr);
13806 
13807  /* GNU F77 is a special case, as at 08/2004 array type info is the
13808  opposite order to the dwarf2 specification, but data is still
13809  laid out as per normal fortran.
13810 
13811  FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
13812  version checking. */
13813 
13814  if (cu->language == language_fortran
13815  && cu->producer && strstr (cu->producer, "GNU F77"))
13816  {
13817  return DW_ORD_row_major;
13818  }
13819 
13820  switch (cu->language_defn->la_array_ordering)
13821  {
13822  case array_column_major:
13823  return DW_ORD_col_major;
13824  case array_row_major:
13825  default:
13826  return DW_ORD_row_major;
13827  };
13828 }
13829 
13830 /* Extract all information from a DW_TAG_set_type DIE and put it in
13831  the DIE's type field. */
13832 
13833 static struct type *
13834 read_set_type (struct die_info *die, struct dwarf2_cu *cu)
13835 {
13836  struct type *domain_type, *set_type;
13837  struct attribute *attr;
13838 
13839  domain_type = die_type (die, cu);
13840 
13841  /* The die_type call above may have already set the type for this DIE. */
13842  set_type = get_die_type (die, cu);
13843  if (set_type)
13844  return set_type;
13845 
13846  set_type = create_set_type (NULL, domain_type);
13847 
13848  attr = dwarf2_attr (die, DW_AT_byte_size, cu);
13849  if (attr)
13850  TYPE_LENGTH (set_type) = DW_UNSND (attr);
13851 
13852  return set_die_type (die, set_type, cu);
13853 }
13854 
13855 /* A helper for read_common_block that creates a locexpr baton.
13856  SYM is the symbol which we are marking as computed.
13857  COMMON_DIE is the DIE for the common block.
13858  COMMON_LOC is the location expression attribute for the common
13859  block itself.
13860  MEMBER_LOC is the location expression attribute for the particular
13861  member of the common block that we are processing.
13862  CU is the CU from which the above come. */
13863 
13864 static void
13866  struct die_info *common_die,
13867  struct attribute *common_loc,
13868  struct attribute *member_loc,
13869  struct dwarf2_cu *cu)
13870 {
13871  struct objfile *objfile = dwarf2_per_objfile->objfile;
13872  struct dwarf2_locexpr_baton *baton;
13873  gdb_byte *ptr;
13874  unsigned int cu_off;
13875  enum bfd_endian byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
13876  LONGEST offset = 0;
13877 
13878  gdb_assert (common_loc && member_loc);
13879  gdb_assert (attr_form_is_block (common_loc));
13880  gdb_assert (attr_form_is_block (member_loc)
13881  || attr_form_is_constant (member_loc));
13882 
13883  baton = obstack_alloc (&objfile->objfile_obstack,
13884  sizeof (struct dwarf2_locexpr_baton));
13885  baton->per_cu = cu->per_cu;
13886  gdb_assert (baton->per_cu);
13887 
13888  baton->size = 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
13889 
13890  if (attr_form_is_constant (member_loc))
13891  {
13892  offset = dwarf2_get_attr_constant_value (member_loc, 0);
13893  baton->size += 1 /* DW_OP_addr */ + cu->header.addr_size;
13894  }
13895  else
13896  baton->size += DW_BLOCK (member_loc)->size;
13897 
13898  ptr = obstack_alloc (&objfile->objfile_obstack, baton->size);
13899  baton->data = ptr;
13900 
13901  *ptr++ = DW_OP_call4;
13902  cu_off = common_die->offset.sect_off - cu->per_cu->offset.sect_off;
13903  store_unsigned_integer (ptr, 4, byte_order, cu_off);
13904  ptr += 4;
13905 
13906  if (attr_form_is_constant (member_loc))
13907  {
13908  *ptr++ = DW_OP_addr;
13909  store_unsigned_integer (ptr, cu->header.addr_size, byte_order, offset);
13910  ptr += cu->header.addr_size;
13911  }
13912  else
13913  {
13914  /* We have to copy the data here, because DW_OP_call4 will only
13915  use a DW_AT_location attribute. */
13916  memcpy (ptr, DW_BLOCK (member_loc)->data, DW_BLOCK (member_loc)->size);
13917  ptr += DW_BLOCK (member_loc)->size;
13918  }
13919 
13920  *ptr++ = DW_OP_plus;
13921  gdb_assert (ptr - baton->data == baton->size);
13922 
13923  SYMBOL_LOCATION_BATON (sym) = baton;
13925 }
13926 
13927 /* Create appropriate locally-scoped variables for all the
13928  DW_TAG_common_block entries. Also create a struct common_block
13929  listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
13930  is used to sepate the common blocks name namespace from regular
13931  variable names. */
13932 
13933 static void
13934 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
13935 {
13936  struct attribute *attr;
13937 
13938  attr = dwarf2_attr (die, DW_AT_location, cu);
13939  if (attr)
13940  {
13941  /* Support the .debug_loc offsets. */
13942  if (attr_form_is_block (attr))
13943  {
13944  /* Ok. */
13945  }
13946  else if (attr_form_is_section_offset (attr))
13947  {
13949  attr = NULL;
13950  }
13951  else
13952  {
13953  dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
13954  "common block member");
13955  attr = NULL;
13956  }
13957  }
13958 
13959  if (die->child != NULL)
13960  {
13961  struct objfile *objfile = cu->objfile;
13962  struct die_info *child_die;
13963  size_t n_entries = 0, size;
13964  struct common_block *common_block;
13965  struct symbol *sym;
13966 
13967  for (child_die = die->child;
13968  child_die && child_die->tag;
13969  child_die = sibling_die (child_die))
13970  ++n_entries;
13971 
13972  size = (sizeof (struct common_block)
13973  + (n_entries - 1) * sizeof (struct symbol *));
13974  common_block = obstack_alloc (&objfile->objfile_obstack, size);
13975  memset (common_block->contents, 0, n_entries * sizeof (struct symbol *));
13976  common_block->n_entries = 0;
13977 
13978  for (child_die = die->child;
13979  child_die && child_die->tag;
13980  child_die = sibling_die (child_die))
13981  {
13982  /* Create the symbol in the DW_TAG_common_block block in the current
13983  symbol scope. */
13984  sym = new_symbol (child_die, NULL, cu);
13985  if (sym != NULL)
13986  {
13987  struct attribute *member_loc;
13988 
13989  common_block->contents[common_block->n_entries++] = sym;
13990 
13991  member_loc = dwarf2_attr (child_die, DW_AT_data_member_location,
13992  cu);
13993  if (member_loc)
13994  {
13995  /* GDB has handled this for a long time, but it is
13996  not specified by DWARF. It seems to have been
13997  emitted by gfortran at least as recently as:
13998  http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
14000  _("Variable in common block has "
14001  "DW_AT_data_member_location "
14002  "- DIE at 0x%x [in module %s]"),
14003  child_die->offset.sect_off,
14004  objfile_name (cu->objfile));
14005 
14006  if (attr_form_is_section_offset (member_loc))
14008  else if (attr_form_is_constant (member_loc)
14009  || attr_form_is_block (member_loc))
14010  {
14011  if (attr)
14012  mark_common_block_symbol_computed (sym, die, attr,
14013  member_loc, cu);
14014  }
14015  else
14017  }
14018  }
14019  }
14020 
14021  sym = new_symbol (die, objfile_type (objfile)->builtin_void, cu);
14023  }
14024 }
14025 
14026 /* Create a type for a C++ namespace. */
14027 
14028 static struct type *
14029 read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
14030 {
14031  struct objfile *objfile = cu->objfile;
14032  const char *previous_prefix, *name;
14033  int is_anonymous;
14034  struct type *type;
14035 
14036  /* For extensions, reuse the type of the original namespace. */
14037  if (dwarf2_attr (die, DW_AT_extension, cu) != NULL)
14038  {
14039  struct die_info *ext_die;
14040  struct dwarf2_cu *ext_cu = cu;
14041 
14042  ext_die = dwarf2_extension (die, &ext_cu);
14043  type = read_type_die (ext_die, ext_cu);
14044 
14045  /* EXT_CU may not be the same as CU.
14046  Ensure TYPE is recorded with CU in die_type_hash. */
14047  return set_die_type (die, type, cu);
14048  }
14049 
14050  name = namespace_name (die, &is_anonymous, cu);
14051 
14052  /* Now build the name of the current namespace. */
14053 
14054  previous_prefix = determine_prefix (die, cu);
14055  if (previous_prefix[0] != '\0')
14056  name = typename_concat (&objfile->objfile_obstack,
14057  previous_prefix, name, 0, cu);
14058 
14059  /* Create the type. */
14060  type = init_type (TYPE_CODE_NAMESPACE, 0, 0, NULL,
14061  objfile);
14062  TYPE_NAME (type) = name;
14063  TYPE_TAG_NAME (type) = TYPE_NAME (type);
14064 
14065  return set_die_type (die, type, cu);
14066 }
14067 
14068 /* Read a C++ namespace. */
14069 
14070 static void
14071 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
14072 {
14073  struct objfile *objfile = cu->objfile;
14074  int is_anonymous;
14075 
14076  /* Add a symbol associated to this if we haven't seen the namespace
14077  before. Also, add a using directive if it's an anonymous
14078  namespace. */
14079 
14080  if (dwarf2_attr (die, DW_AT_extension, cu) == NULL)
14081  {
14082  struct type *type;
14083 
14084  type = read_type_die (die, cu);
14085  new_symbol (die, type, cu);
14086 
14087  namespace_name (die, &is_anonymous, cu);
14088  if (is_anonymous)
14089  {
14090  const char *previous_prefix = determine_prefix (die, cu);
14091 
14092  cp_add_using_directive (previous_prefix, TYPE_NAME (type), NULL,
14093  NULL, NULL, 0, &objfile->objfile_obstack);
14094  }
14095  }
14096 
14097  if (die->child != NULL)
14098  {
14099  struct die_info *child_die = die->child;
14100 
14101  while (child_die && child_die->tag)
14102  {
14103  process_die (child_die, cu);
14104  child_die = sibling_die (child_die);
14105  }
14106  }
14107 }
14108 
14109 /* Read a Fortran module as type. This DIE can be only a declaration used for
14110  imported module. Still we need that type as local Fortran "use ... only"
14111  declaration imports depend on the created type in determine_prefix. */
14112 
14113 static struct type *
14114 read_module_type (struct die_info *die, struct dwarf2_cu *cu)
14115 {
14116  struct objfile *objfile = cu->objfile;
14117  const char *module_name;
14118  struct type *type;
14119 
14120  module_name = dwarf2_name (die, cu);
14121  if (!module_name)
14123  _("DW_TAG_module has no name, offset 0x%x"),
14124  die->offset.sect_off);
14125  type = init_type (TYPE_CODE_MODULE, 0, 0, module_name, objfile);
14126 
14127  /* determine_prefix uses TYPE_TAG_NAME. */
14128  TYPE_TAG_NAME (type) = TYPE_NAME (type);
14129 
14130  return set_die_type (die, type, cu);
14131 }
14132 
14133 /* Read a Fortran module. */
14134 
14135 static void
14136 read_module (struct die_info *die, struct dwarf2_cu *cu)
14137 {
14138  struct die_info *child_die = die->child;
14139  struct type *type;
14140 
14141  type = read_type_die (die, cu);
14142  new_symbol (die, type, cu);
14143 
14144  while (child_die && child_die->tag)
14145  {
14146  process_die (child_die, cu);
14147  child_die = sibling_die (child_die);
14148  }
14149 }
14150 
14151 /* Return the name of the namespace represented by DIE. Set
14152  *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
14153  namespace. */
14154 
14155 static const char *
14156 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
14157 {
14158  struct die_info *current_die;
14159  const char *name = NULL;
14160 
14161  /* Loop through the extensions until we find a name. */
14162 
14163  for (current_die = die;
14164  current_die != NULL;
14165  current_die = dwarf2_extension (die, &cu))
14166  {
14167  /* We don't use dwarf2_name here so that we can detect the absence
14168  of a name -> anonymous namespace. */
14169  struct attribute *attr = dwarf2_attr (die, DW_AT_name, cu);
14170 
14171  if (attr != NULL)
14172  name = DW_STRING (attr);
14173  if (name != NULL)
14174  break;
14175  }
14176 
14177  /* Is it an anonymous namespace? */
14178 
14179  *is_anonymous = (name == NULL);
14180  if (*is_anonymous)
14182 
14183  return name;
14184 }
14185 
14186 /* Extract all information from a DW_TAG_pointer_type DIE and add to
14187  the user defined type vector. */
14188 
14189 static struct type *
14190 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
14191 {
14192  struct gdbarch *gdbarch = get_objfile_arch (cu->objfile);
14193  struct comp_unit_head *cu_header = &cu->header;
14194  struct type *type;
14195  struct attribute *attr_byte_size;
14196  struct attribute *attr_address_class;
14197  int byte_size, addr_class;
14198  struct type *target_type;
14199 
14200  target_type = die_type (die, cu);
14201 
14202  /* The die_type call above may have already set the type for this DIE. */
14203  type = get_die_type (die, cu);
14204  if (type)
14205  return type;
14206 
14207  type = lookup_pointer_type (target_type);
14208 
14209  attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
14210  if (attr_byte_size)
14211  byte_size = DW_UNSND (attr_byte_size);
14212  else
14213  byte_size = cu_header->addr_size;
14214 
14215  attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
14216  if (attr_address_class)
14217  addr_class = DW_UNSND (attr_address_class);
14218  else
14219  addr_class = DW_ADDR_none;
14220 
14221  /* If the pointer size or address class is different than the
14222  default, create a type variant marked as such and set the
14223  length accordingly. */
14224  if (TYPE_LENGTH (type) != byte_size || addr_class != DW_ADDR_none)
14225  {
14226  if (gdbarch_address_class_type_flags_p (gdbarch))
14227  {
14228  int type_flags;
14229 
14231  (gdbarch, byte_size, addr_class);
14233  == 0);
14234  type = make_type_with_address_space (type, type_flags);
14235  }
14236  else if (TYPE_LENGTH (type) != byte_size)
14237  {
14239  _("invalid pointer size %d"), byte_size);
14240  }
14241  else
14242  {
14243  /* Should we also complain about unhandled address classes? */
14244  }
14245  }
14246 
14247  TYPE_LENGTH (type) = byte_size;
14248  return set_die_type (die, type, cu);
14249 }
14250 
14251 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
14252  the user defined type vector. */
14253 
14254 static struct type *
14256 {
14257  struct type *type;
14258  struct type *to_type;
14259  struct type *domain;
14260 
14261  to_type = die_type (die, cu);
14262  domain = die_containing_type (die, cu);
14263 
14264  /* The calls above may have already set the type for this DIE. */
14265  type = get_die_type (die, cu);
14266  if (type)
14267  return type;
14268 
14269  if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_METHOD)
14270  type = lookup_methodptr_type (to_type);
14271  else if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_FUNC)
14272  {
14273  struct type *new_type = alloc_type (cu->objfile);
14274 
14275  smash_to_method_type (new_type, domain, TYPE_TARGET_TYPE (to_type),
14276  TYPE_FIELDS (to_type), TYPE_NFIELDS (to_type),
14277  TYPE_VARARGS (to_type));
14278  type = lookup_methodptr_type (new_type);
14279  }
14280  else
14281  type = lookup_memberptr_type (to_type, domain);
14282 
14283  return set_die_type (die, type, cu);
14284 }
14285 
14286 /* Extract all information from a DW_TAG_reference_type DIE and add to
14287  the user defined type vector. */
14288 
14289 static struct type *
14290 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu)
14291 {
14292  struct comp_unit_head *cu_header = &cu->header;
14293  struct type *type, *target_type;
14294  struct attribute *attr;
14295 
14296  target_type = die_type (die, cu);
14297 
14298  /* The die_type call above may have already set the type for this DIE. */
14299  type = get_die_type (die, cu);
14300  if (type)
14301  return type;
14302 
14303  type = lookup_reference_type (target_type);
14304  attr = dwarf2_attr (die, DW_AT_byte_size, cu);
14305  if (attr)
14306  {
14307  TYPE_LENGTH (type) = DW_UNSND (attr);
14308  }
14309  else
14310  {
14311  TYPE_LENGTH (type) = cu_header->addr_size;
14312  }
14313  return set_die_type (die, type, cu);
14314 }
14315 
14316 /* Add the given cv-qualifiers to the element type of the array. GCC
14317  outputs DWARF type qualifiers that apply to an array, not the
14318  element type. But GDB relies on the array element type to carry
14319  the cv-qualifiers. This mimics section 6.7.3 of the C99
14320  specification. */
14321 
14322 static struct type *
14323 add_array_cv_type (struct die_info *die, struct dwarf2_cu *cu,
14324  struct type *base_type, int cnst, int voltl)
14325 {
14326  struct type *el_type, *inner_array;
14327 
14328  base_type = copy_type (base_type);
14329  inner_array = base_type;
14330 
14331  while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
14332  {
14333  TYPE_TARGET_TYPE (inner_array) =
14334  copy_type (TYPE_TARGET_TYPE (inner_array));
14335  inner_array = TYPE_TARGET_TYPE (inner_array);
14336  }
14337 
14338  el_type = TYPE_TARGET_TYPE (inner_array);
14339  cnst |= TYPE_CONST (el_type);
14340  voltl |= TYPE_VOLATILE (el_type);
14341  TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, NULL);
14342 
14343  return set_die_type (die, base_type, cu);
14344 }
14345 
14346 static struct type *
14347 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
14348 {
14349  struct type *base_type, *cv_type;
14350 
14351  base_type = die_type (die, cu);
14352 
14353  /* The die_type call above may have already set the type for this DIE. */
14354  cv_type = get_die_type (die, cu);
14355  if (cv_type)
14356  return cv_type;
14357 
14358  /* In case the const qualifier is applied to an array type, the element type
14359  is so qualified, not the array type (section 6.7.3 of C99). */
14360  if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
14361  return add_array_cv_type (die, cu, base_type, 1, 0);
14362 
14363  cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
14364  return set_die_type (die, cv_type, cu);
14365 }
14366 
14367 static struct type *
14368 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
14369 {
14370  struct type *base_type, *cv_type;
14371 
14372  base_type = die_type (die, cu);
14373 
14374  /* The die_type call above may have already set the type for this DIE. */
14375  cv_type = get_die_type (die, cu);
14376  if (cv_type)
14377  return cv_type;
14378 
14379  /* In case the volatile qualifier is applied to an array type, the
14380  element type is so qualified, not the array type (section 6.7.3
14381  of C99). */
14382  if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
14383  return add_array_cv_type (die, cu, base_type, 0, 1);
14384 
14385  cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
14386  return set_die_type (die, cv_type, cu);
14387 }
14388 
14389 /* Handle DW_TAG_restrict_type. */
14390 
14391 static struct type *
14392 read_tag_restrict_type (struct die_info *die, struct dwarf2_cu *cu)
14393 {
14394  struct type *base_type, *cv_type;
14395 
14396  base_type = die_type (die, cu);
14397 
14398  /* The die_type call above may have already set the type for this DIE. */
14399  cv_type = get_die_type (die, cu);
14400  if (cv_type)
14401  return cv_type;
14402 
14403  cv_type = make_restrict_type (base_type);
14404  return set_die_type (die, cv_type, cu);
14405 }
14406 
14407 /* Handle DW_TAG_atomic_type. */
14408 
14409 static struct type *
14410 read_tag_atomic_type (struct die_info *die, struct dwarf2_cu *cu)
14411 {
14412  struct type *base_type, *cv_type;
14413 
14414  base_type = die_type (die, cu);
14415 
14416  /* The die_type call above may have already set the type for this DIE. */
14417  cv_type = get_die_type (die, cu);
14418  if (cv_type)
14419  return cv_type;
14420 
14421  cv_type = make_atomic_type (base_type);
14422  return set_die_type (die, cv_type, cu);
14423 }
14424 
14425 /* Extract all information from a DW_TAG_string_type DIE and add to
14426  the user defined type vector. It isn't really a user defined type,
14427  but it behaves like one, with other DIE's using an AT_user_def_type
14428  attribute to reference it. */
14429 
14430 static struct type *
14431 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
14432 {
14433  struct objfile *objfile = cu->objfile;
14434  struct gdbarch *gdbarch = get_objfile_arch (objfile);
14435  struct type *type, *range_type, *index_type, *char_type;
14436  struct attribute *attr;
14437  unsigned int length;
14438 
14439  attr = dwarf2_attr (die, DW_AT_string_length, cu);
14440  if (attr)
14441  {
14442  length = DW_UNSND (attr);
14443  }
14444  else
14445  {
14446  /* Check for the DW_AT_byte_size attribute. */
14447  attr = dwarf2_attr (die, DW_AT_byte_size, cu);
14448  if (attr)
14449  {
14450  length = DW_UNSND (attr);
14451  }
14452  else
14453  {
14454  length = 1;
14455  }
14456  }
14457 
14458  index_type = objfile_type (objfile)->builtin_int;
14459  range_type = create_static_range_type (NULL, index_type, 1, length);
14460  char_type = language_string_char_type (cu->language_defn, gdbarch);
14461  type = create_string_type (NULL, char_type, range_type);
14462 
14463  return set_die_type (die, type, cu);
14464 }
14465 
14466 /* Assuming that DIE corresponds to a function, returns nonzero
14467  if the function is prototyped. */
14468 
14469 static int
14470 prototyped_function_p (struct die_info *die, struct dwarf2_cu *cu)
14471 {
14472  struct attribute *attr;
14473 
14474  attr = dwarf2_attr (die, DW_AT_prototyped, cu);
14475  if (attr && (DW_UNSND (attr) != 0))
14476  return 1;
14477 
14478  /* The DWARF standard implies that the DW_AT_prototyped attribute
14479  is only meaninful for C, but the concept also extends to other
14480  languages that allow unprototyped functions (Eg: Objective C).
14481  For all other languages, assume that functions are always
14482  prototyped. */
14483  if (cu->language != language_c
14484  && cu->language != language_objc
14485  && cu->language != language_opencl)
14486  return 1;
14487 
14488  /* RealView does not emit DW_AT_prototyped. We can not distinguish
14489  prototyped and unprototyped functions; default to prototyped,
14490  since that is more common in modern code (and RealView warns
14491  about unprototyped functions). */
14492  if (producer_is_realview (cu->producer))
14493  return 1;
14494 
14495  return 0;
14496 }
14497 
14498 /* Handle DIES due to C code like:
14499 
14500  struct foo
14501  {
14502  int (*funcp)(int a, long l);
14503  int b;
14504  };
14505 
14506  ('funcp' generates a DW_TAG_subroutine_type DIE). */
14507 
14508 static struct type *
14509 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
14510 {
14511  struct objfile *objfile = cu->objfile;
14512  struct type *type; /* Type that this function returns. */
14513  struct type *ftype; /* Function that returns above type. */
14514  struct attribute *attr;
14515 
14516  type = die_type (die, cu);
14517 
14518  /* The die_type call above may have already set the type for this DIE. */
14519  ftype = get_die_type (die, cu);
14520  if (ftype)
14521  return ftype;
14522 
14523  ftype = lookup_function_type (type);
14524 
14525  if (prototyped_function_p (die, cu))
14526  TYPE_PROTOTYPED (ftype) = 1;
14527 
14528  /* Store the calling convention in the type if it's available in
14529  the subroutine die. Otherwise set the calling convention to
14530  the default value DW_CC_normal. */
14531  attr = dwarf2_attr (die, DW_AT_calling_convention, cu);
14532  if (attr)
14533  TYPE_CALLING_CONVENTION (ftype) = DW_UNSND (attr);
14534  else if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL"))
14535  TYPE_CALLING_CONVENTION (ftype) = DW_CC_GDB_IBM_OpenCL;
14536  else
14537  TYPE_CALLING_CONVENTION (ftype) = DW_CC_normal;
14538 
14539  /* Record whether the function returns normally to its caller or not
14540  if the DWARF producer set that information. */
14541  attr = dwarf2_attr (die, DW_AT_noreturn, cu);
14542  if (attr && (DW_UNSND (attr) != 0))
14543  TYPE_NO_RETURN (ftype) = 1;
14544 
14545  /* We need to add the subroutine type to the die immediately so
14546  we don't infinitely recurse when dealing with parameters
14547  declared as the same subroutine type. */
14548  set_die_type (die, ftype, cu);
14549 
14550  if (die->child != NULL)
14551  {
14552  struct type *void_type = objfile_type (objfile)->builtin_void;
14553  struct die_info *child_die;
14554  int nparams, iparams;
14555 
14556  /* Count the number of parameters.
14557  FIXME: GDB currently ignores vararg functions, but knows about
14558  vararg member functions. */
14559  nparams = 0;
14560  child_die = die->child;
14561  while (child_die && child_die->tag)
14562  {
14563  if (child_die->tag == DW_TAG_formal_parameter)
14564  nparams++;
14565  else if (child_die->tag == DW_TAG_unspecified_parameters)
14566  TYPE_VARARGS (ftype) = 1;
14567  child_die = sibling_die (child_die);
14568  }
14569 
14570  /* Allocate storage for parameters and fill them in. */
14571  TYPE_NFIELDS (ftype) = nparams;
14572  TYPE_FIELDS (ftype) = (struct field *)
14573  TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
14574 
14575  /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
14576  even if we error out during the parameters reading below. */
14577  for (iparams = 0; iparams < nparams; iparams++)
14578  TYPE_FIELD_TYPE (ftype, iparams) = void_type;
14579 
14580  iparams = 0;
14581  child_die = die->child;
14582  while (child_die && child_die->tag)
14583  {
14584  if (child_die->tag == DW_TAG_formal_parameter)
14585  {
14586  struct type *arg_type;
14587 
14588  /* DWARF version 2 has no clean way to discern C++
14589  static and non-static member functions. G++ helps
14590  GDB by marking the first parameter for non-static
14591  member functions (which is the this pointer) as
14592  artificial. We pass this information to
14593  dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
14594 
14595  DWARF version 3 added DW_AT_object_pointer, which GCC
14596  4.5 does not yet generate. */
14597  attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
14598  if (attr)
14599  TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
14600  else
14601  {
14602  TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
14603 
14604  /* GCC/43521: In java, the formal parameter
14605  "this" is sometimes not marked with DW_AT_artificial. */
14606  if (cu->language == language_java)
14607  {
14608  const char *name = dwarf2_name (child_die, cu);
14609 
14610  if (name && !strcmp (name, "this"))
14611  TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 1;
14612  }
14613  }
14614  arg_type = die_type (child_die, cu);
14615 
14616  /* RealView does not mark THIS as const, which the testsuite
14617  expects. GCC marks THIS as const in method definitions,
14618  but not in the class specifications (GCC PR 43053). */
14619  if (cu->language == language_cplus && !TYPE_CONST (arg_type)
14620  && TYPE_FIELD_ARTIFICIAL (ftype, iparams))
14621  {
14622  int is_this = 0;
14623  struct dwarf2_cu *arg_cu = cu;
14624  const char *name = dwarf2_name (child_die, cu);
14625 
14626  attr = dwarf2_attr (die, DW_AT_object_pointer, cu);
14627  if (attr)
14628  {
14629  /* If the compiler emits this, use it. */
14630  if (follow_die_ref (die, attr, &arg_cu) == child_die)
14631  is_this = 1;
14632  }
14633  else if (name && strcmp (name, "this") == 0)
14634  /* Function definitions will have the argument names. */
14635  is_this = 1;
14636  else if (name == NULL && iparams == 0)
14637  /* Declarations may not have the names, so like
14638  elsewhere in GDB, assume an artificial first
14639  argument is "this". */
14640  is_this = 1;
14641 
14642  if (is_this)
14643  arg_type = make_cv_type (1, TYPE_VOLATILE (arg_type),
14644  arg_type, 0);
14645  }
14646 
14647  TYPE_FIELD_TYPE (ftype, iparams) = arg_type;
14648  iparams++;
14649  }
14650  child_die = sibling_die (child_die);
14651  }
14652  }
14653 
14654  return ftype;
14655 }
14656 
14657 static struct type *
14658 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
14659 {
14660  struct objfile *objfile = cu->objfile;
14661  const char *name = NULL;
14662  struct type *this_type, *target_type;
14663 
14664  name = dwarf2_full_name (NULL, die, cu);
14665  this_type = init_type (TYPE_CODE_TYPEDEF, 0,
14666  TYPE_FLAG_TARGET_STUB, NULL, objfile);
14667  TYPE_NAME (this_type) = name;
14668  set_die_type (die, this_type, cu);
14669  target_type = die_type (die, cu);
14670  if (target_type != this_type)
14671  TYPE_TARGET_TYPE (this_type) = target_type;
14672  else
14673  {
14674  /* Self-referential typedefs are, it seems, not allowed by the DWARF
14675  spec and cause infinite loops in GDB. */
14677  _("Self-referential DW_TAG_typedef "
14678  "- DIE at 0x%x [in module %s]"),
14679  die->offset.sect_off, objfile_name (objfile));
14680  TYPE_TARGET_TYPE (this_type) = NULL;
14681  }
14682  return this_type;
14683 }
14684 
14685 /* Find a representation of a given base type and install
14686  it in the TYPE field of the die. */
14687 
14688 static struct type *
14689 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
14690 {
14691  struct objfile *objfile = cu->objfile;
14692  struct type *type;
14693  struct attribute *attr;
14694  int encoding = 0, size = 0;
14695  const char *name;
14696  enum type_code code = TYPE_CODE_INT;
14697  int type_flags = 0;
14698  struct type *target_type = NULL;
14699 
14700  attr = dwarf2_attr (die, DW_AT_encoding, cu);
14701  if (attr)
14702  {
14703  encoding = DW_UNSND (attr);
14704  }
14705  attr = dwarf2_attr (die, DW_AT_byte_size, cu);
14706  if (attr)
14707  {
14708  size = DW_UNSND (attr);
14709  }
14710  name = dwarf2_name (die, cu);
14711  if (!name)
14712  {
14714  _("DW_AT_name missing from DW_TAG_base_type"));
14715  }
14716 
14717  switch (encoding)
14718  {
14719  case DW_ATE_address:
14720  /* Turn DW_ATE_address into a void * pointer. */
14721  code = TYPE_CODE_PTR;
14722  type_flags |= TYPE_FLAG_UNSIGNED;
14723  target_type = init_type (TYPE_CODE_VOID, 1, 0, NULL, objfile);
14724  break;
14725  case DW_ATE_boolean:
14726  code = TYPE_CODE_BOOL;
14727  type_flags |= TYPE_FLAG_UNSIGNED;
14728  break;
14729  case DW_ATE_complex_float:
14730  code = TYPE_CODE_COMPLEX;
14731  target_type = init_type (TYPE_CODE_FLT, size / 2, 0, NULL, objfile);
14732  break;
14733  case DW_ATE_decimal_float:
14734  code = TYPE_CODE_DECFLOAT;
14735  break;
14736  case DW_ATE_float:
14737  code = TYPE_CODE_FLT;
14738  break;
14739  case DW_ATE_signed:
14740  break;
14741  case DW_ATE_unsigned:
14742  type_flags |= TYPE_FLAG_UNSIGNED;
14743  if (cu->language == language_fortran
14744  && name
14745  && startswith (name, "character("))
14746  code = TYPE_CODE_CHAR;
14747  break;
14748  case DW_ATE_signed_char:
14749  if (cu->language == language_ada || cu->language == language_m2
14750  || cu->language == language_pascal
14751  || cu->language == language_fortran)
14752  code = TYPE_CODE_CHAR;
14753  break;
14754  case DW_ATE_unsigned_char:
14755  if (cu->language == language_ada || cu->language == language_m2
14756  || cu->language == language_pascal
14757  || cu->language == language_fortran)
14758  code = TYPE_CODE_CHAR;
14759  type_flags |= TYPE_FLAG_UNSIGNED;
14760  break;
14761  case DW_ATE_UTF:
14762  /* We just treat this as an integer and then recognize the
14763  type by name elsewhere. */
14764  break;
14765 
14766  default:
14767  complaint (&symfile_complaints, _("unsupported DW_AT_encoding: '%s'"),
14768  dwarf_type_encoding_name (encoding));
14769  break;
14770  }
14771 
14772  type = init_type (code, size, type_flags, NULL, objfile);
14773  TYPE_NAME (type) = name;
14774  TYPE_TARGET_TYPE (type) = target_type;
14775 
14776  if (name && strcmp (name, "char") == 0)
14777  TYPE_NOSIGN (type) = 1;
14778 
14779  return set_die_type (die, type, cu);
14780 }
14781 
14782 /* Parse dwarf attribute if it's a block, reference or constant and put the
14783  resulting value of the attribute into struct bound_prop.
14784  Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
14785 
14786 static int
14787 attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die,
14788  struct dwarf2_cu *cu, struct dynamic_prop *prop)
14789 {
14790  struct dwarf2_property_baton *baton;
14791  struct obstack *obstack = &cu->objfile->objfile_obstack;
14792 
14793  if (attr == NULL || prop == NULL)
14794  return 0;
14795 
14796  if (attr_form_is_block (attr))
14797  {
14798  baton = obstack_alloc (obstack, sizeof (*baton));
14799  baton->referenced_type = NULL;
14800  baton->locexpr.per_cu = cu->per_cu;
14801  baton->locexpr.size = DW_BLOCK (attr)->size;
14802  baton->locexpr.data = DW_BLOCK (attr)->data;
14803  prop->data.baton = baton;
14804  prop->kind = PROP_LOCEXPR;
14805  gdb_assert (prop->data.baton != NULL);
14806  }
14807  else if (attr_form_is_ref (attr))
14808  {
14809  struct dwarf2_cu *target_cu = cu;
14810  struct die_info *target_die;
14811  struct attribute *target_attr;
14812 
14813  target_die = follow_die_ref (die, attr, &target_cu);
14814  target_attr = dwarf2_attr (target_die, DW_AT_location, target_cu);
14815  if (target_attr == NULL)
14816  target_attr = dwarf2_attr (target_die, DW_AT_data_member_location,
14817  target_cu);
14818  if (target_attr == NULL)
14819  return 0;
14820 
14821  switch (target_attr->name)
14822  {
14823  case DW_AT_location:
14824  if (attr_form_is_section_offset (target_attr))
14825  {
14826  baton = obstack_alloc (obstack, sizeof (*baton));
14827  baton->referenced_type = die_type (target_die, target_cu);
14828  fill_in_loclist_baton (cu, &baton->loclist, target_attr);
14829  prop->data.baton = baton;
14830  prop->kind = PROP_LOCLIST;
14831  gdb_assert (prop->data.baton != NULL);
14832  }
14833  else if (attr_form_is_block (target_attr))
14834  {
14835  baton = obstack_alloc (obstack, sizeof (*baton));
14836  baton->referenced_type = die_type (target_die, target_cu);
14837  baton->locexpr.per_cu = cu->per_cu;
14838  baton->locexpr.size = DW_BLOCK (target_attr)->size;
14839  baton->locexpr.data = DW_BLOCK (target_attr)->data;
14840  prop->data.baton = baton;
14841  prop->kind = PROP_LOCEXPR;
14842  gdb_assert (prop->data.baton != NULL);
14843  }
14844  else
14845  {
14846  dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
14847  "dynamic property");
14848  return 0;
14849  }
14850  break;
14851  case DW_AT_data_member_location:
14852  {
14853  LONGEST offset;
14854 
14855  if (!handle_data_member_location (target_die, target_cu,
14856  &offset))
14857  return 0;
14858 
14859  baton = obstack_alloc (obstack, sizeof (*baton));
14860  baton->referenced_type = read_type_die (target_die->parent,
14861  target_cu);
14862  baton->offset_info.offset = offset;
14863  baton->offset_info.type = die_type (target_die, target_cu);
14864  prop->data.baton = baton;
14865  prop->kind = PROP_ADDR_OFFSET;
14866  break;
14867  }
14868  }
14869  }
14870  else if (attr_form_is_constant (attr))
14871  {
14872  prop->data.const_val = dwarf2_get_attr_constant_value (attr, 0);
14873  prop->kind = PROP_CONST;
14874  }
14875  else
14876  {
14878  dwarf2_name (die, cu));
14879  return 0;
14880  }
14881 
14882  return 1;
14883 }
14884 
14885 /* Read the given DW_AT_subrange DIE. */
14886 
14887 static struct type *
14888 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
14889 {
14890  struct type *base_type, *orig_base_type;
14891  struct type *range_type;
14892  struct attribute *attr;
14893  struct dynamic_prop low, high;
14894  int low_default_is_valid;
14895  int high_bound_is_count = 0;
14896  const char *name;
14897  LONGEST negative_mask;
14898 
14899  orig_base_type = die_type (die, cu);
14900  /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
14901  whereas the real type might be. So, we use ORIG_BASE_TYPE when
14902  creating the range type, but we use the result of check_typedef
14903  when examining properties of the type. */
14904  base_type = check_typedef (orig_base_type);
14905 
14906  /* The die_type call above may have already set the type for this DIE. */
14907  range_type = get_die_type (die, cu);
14908  if (range_type)
14909  return range_type;
14910 
14911  low.kind = PROP_CONST;
14912  high.kind = PROP_CONST;
14913  high.data.const_val = 0;
14914 
14915  /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
14916  omitting DW_AT_lower_bound. */
14917  switch (cu->language)
14918  {
14919  case language_c:
14920  case language_cplus:
14921  low.data.const_val = 0;
14922  low_default_is_valid = 1;
14923  break;
14924  case language_fortran:
14925  low.data.const_val = 1;
14926  low_default_is_valid = 1;
14927  break;
14928  case language_d:
14929  case language_java:
14930  case language_objc:
14931  low.data.const_val = 0;
14932  low_default_is_valid = (cu->header.version >= 4);
14933  break;
14934  case language_ada:
14935  case language_m2:
14936  case language_pascal:
14937  low.data.const_val = 1;
14938  low_default_is_valid = (cu->header.version >= 4);
14939  break;
14940  default:
14941  low.data.const_val = 0;
14942  low_default_is_valid = 0;
14943  break;
14944  }
14945 
14946  attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
14947  if (attr)
14948  attr_to_dynamic_prop (attr, die, cu, &low);
14949  else if (!low_default_is_valid)
14950  complaint (&symfile_complaints, _("Missing DW_AT_lower_bound "
14951  "- DIE at 0x%x [in module %s]"),
14952  die->offset.sect_off, objfile_name (cu->objfile));
14953 
14954  attr = dwarf2_attr (die, DW_AT_upper_bound, cu);
14955  if (!attr_to_dynamic_prop (attr, die, cu, &high))
14956  {
14957  attr = dwarf2_attr (die, DW_AT_count, cu);
14958  if (attr_to_dynamic_prop (attr, die, cu, &high))
14959  {
14960  /* If bounds are constant do the final calculation here. */
14961  if (low.kind == PROP_CONST && high.kind == PROP_CONST)
14962  high.data.const_val = low.data.const_val + high.data.const_val - 1;
14963  else
14964  high_bound_is_count = 1;
14965  }
14966  }
14967 
14968  /* Dwarf-2 specifications explicitly allows to create subrange types
14969  without specifying a base type.
14970  In that case, the base type must be set to the type of
14971  the lower bound, upper bound or count, in that order, if any of these
14972  three attributes references an object that has a type.
14973  If no base type is found, the Dwarf-2 specifications say that
14974  a signed integer type of size equal to the size of an address should
14975  be used.
14976  For the following C code: `extern char gdb_int [];'
14977  GCC produces an empty range DIE.
14978  FIXME: muller/2010-05-28: Possible references to object for low bound,
14979  high bound or count are not yet handled by this code. */
14980  if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
14981  {
14982  struct objfile *objfile = cu->objfile;
14983  struct gdbarch *gdbarch = get_objfile_arch (objfile);
14984  int addr_size = gdbarch_addr_bit (gdbarch) /8;
14985  struct type *int_type = objfile_type (objfile)->builtin_int;
14986 
14987  /* Test "int", "long int", and "long long int" objfile types,
14988  and select the first one having a size above or equal to the
14989  architecture address size. */
14990  if (int_type && TYPE_LENGTH (int_type) >= addr_size)
14991  base_type = int_type;
14992  else
14993  {
14994  int_type = objfile_type (objfile)->builtin_long;
14995  if (int_type && TYPE_LENGTH (int_type) >= addr_size)
14996  base_type = int_type;
14997  else
14998  {
14999  int_type = objfile_type (objfile)->builtin_long_long;
15000  if (int_type && TYPE_LENGTH (int_type) >= addr_size)
15001  base_type = int_type;
15002  }
15003  }
15004  }
15005 
15006  /* Normally, the DWARF producers are expected to use a signed
15007  constant form (Eg. DW_FORM_sdata) to express negative bounds.
15008  But this is unfortunately not always the case, as witnessed
15009  with GCC, for instance, where the ambiguous DW_FORM_dataN form
15010  is used instead. To work around that ambiguity, we treat
15011  the bounds as signed, and thus sign-extend their values, when
15012  the base type is signed. */
15013  negative_mask =
15014  (LONGEST) -1 << (TYPE_LENGTH (base_type) * TARGET_CHAR_BIT - 1);
15015  if (low.kind == PROP_CONST
15016  && !TYPE_UNSIGNED (base_type) && (low.data.const_val & negative_mask))
15017  low.data.const_val |= negative_mask;
15018  if (high.kind == PROP_CONST
15019  && !TYPE_UNSIGNED (base_type) && (high.data.const_val & negative_mask))
15020  high.data.const_val |= negative_mask;
15021 
15022  range_type = create_range_type (NULL, orig_base_type, &low, &high);
15023 
15024  if (high_bound_is_count)
15025  TYPE_RANGE_DATA (range_type)->flag_upper_bound_is_count = 1;
15026 
15027  /* Ada expects an empty array on no boundary attributes. */
15028  if (attr == NULL && cu->language != language_ada)
15029  TYPE_HIGH_BOUND_KIND (range_type) = PROP_UNDEFINED;
15030 
15031  name = dwarf2_name (die, cu);
15032  if (name)
15033  TYPE_NAME (range_type) = name;
15034 
15035  attr = dwarf2_attr (die, DW_AT_byte_size, cu);
15036  if (attr)
15037  TYPE_LENGTH (range_type) = DW_UNSND (attr);
15038 
15039  set_die_type (die, range_type, cu);
15040 
15041  /* set_die_type should be already done. */
15042  set_descriptive_type (range_type, die, cu);
15043 
15044  return range_type;
15045 }
15046 
15047 static struct type *
15048 read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
15049 {
15050  struct type *type;
15051 
15052  /* For now, we only support the C meaning of an unspecified type: void. */
15053 
15054  type = init_type (TYPE_CODE_VOID, 0, 0, NULL, cu->objfile);
15055  TYPE_NAME (type) = dwarf2_name (die, cu);
15056 
15057  return set_die_type (die, type, cu);
15058 }
15059 
15060 /* Read a single die and all its descendents. Set the die's sibling
15061  field to NULL; set other fields in the die correctly, and set all
15062  of the descendents' fields correctly. Set *NEW_INFO_PTR to the
15063  location of the info_ptr after reading all of those dies. PARENT
15064  is the parent of the die in question. */
15065 
15066 static struct die_info *
15068  const gdb_byte *info_ptr,
15069  const gdb_byte **new_info_ptr,
15070  struct die_info *parent)
15071 {
15072  struct die_info *die;
15073  const gdb_byte *cur_ptr;
15074  int has_children;
15075 
15076  cur_ptr = read_full_die_1 (reader, &die, info_ptr, &has_children, 0);
15077  if (die == NULL)
15078  {
15079  *new_info_ptr = cur_ptr;
15080  return NULL;
15081  }
15082  store_in_ref_table (die, reader->cu);
15083 
15084  if (has_children)
15085  die->child = read_die_and_siblings_1 (reader, cur_ptr, new_info_ptr, die);
15086  else
15087  {
15088  die->child = NULL;
15089  *new_info_ptr = cur_ptr;
15090  }
15091 
15092  die->sibling = NULL;
15093  die->parent = parent;
15094  return die;
15095 }
15096 
15097 /* Read a die, all of its descendents, and all of its siblings; set
15098  all of the fields of all of the dies correctly. Arguments are as
15099  in read_die_and_children. */
15100 
15101 static struct die_info *
15103  const gdb_byte *info_ptr,
15104  const gdb_byte **new_info_ptr,
15105  struct die_info *parent)
15106 {
15107  struct die_info *first_die, *last_sibling;
15108  const gdb_byte *cur_ptr;
15109 
15110  cur_ptr = info_ptr;
15111  first_die = last_sibling = NULL;
15112 
15113  while (1)
15114  {
15115  struct die_info *die
15116  = read_die_and_children (reader, cur_ptr, &cur_ptr, parent);
15117 
15118  if (die == NULL)
15119  {
15120  *new_info_ptr = cur_ptr;
15121  return first_die;
15122  }
15123 
15124  if (!first_die)
15125  first_die = die;
15126  else
15127  last_sibling->sibling = die;
15128 
15129  last_sibling = die;
15130  }
15131 }
15132 
15133 /* Read a die, all of its descendents, and all of its siblings; set
15134  all of the fields of all of the dies correctly. Arguments are as
15135  in read_die_and_children.
15136  This the main entry point for reading a DIE and all its children. */
15137 
15138 static struct die_info *
15140  const gdb_byte *info_ptr,
15141  const gdb_byte **new_info_ptr,
15142  struct die_info *parent)
15143 {
15144  struct die_info *die = read_die_and_siblings_1 (reader, info_ptr,
15145  new_info_ptr, parent);
15146 
15147  if (dwarf_die_debug)
15148  {
15150  "Read die from %s@0x%x of %s:\n",
15151  get_section_name (reader->die_section),
15152  (unsigned) (info_ptr - reader->die_section->buffer),
15153  bfd_get_filename (reader->abfd));
15154  dump_die (die, dwarf_die_debug);
15155  }
15156 
15157  return die;
15158 }
15159 
15160 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
15161  attributes.
15162  The caller is responsible for filling in the extra attributes
15163  and updating (*DIEP)->num_attrs.
15164  Set DIEP to point to a newly allocated die with its information,
15165  except for its child, sibling, and parent fields.
15166  Set HAS_CHILDREN to tell whether the die has children or not. */
15167 
15168 static const gdb_byte *
15169 read_full_die_1 (const struct die_reader_specs *reader,
15170  struct die_info **diep, const gdb_byte *info_ptr,
15171  int *has_children, int num_extra_attrs)
15172 {
15173  unsigned int abbrev_number, bytes_read, i;
15175  struct abbrev_info *abbrev;
15176  struct die_info *die;
15177  struct dwarf2_cu *cu = reader->cu;
15178  bfd *abfd = reader->abfd;
15179 
15180  offset.sect_off = info_ptr - reader->buffer;
15181  abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
15182  info_ptr += bytes_read;
15183  if (!abbrev_number)
15184  {
15185  *diep = NULL;
15186  *has_children = 0;
15187  return info_ptr;
15188  }
15189 
15190  abbrev = abbrev_table_lookup_abbrev (cu->abbrev_table, abbrev_number);
15191  if (!abbrev)
15192  error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
15193  abbrev_number,
15194  bfd_get_filename (abfd));
15195 
15196  die = dwarf_alloc_die (cu, abbrev->num_attrs + num_extra_attrs);
15197  die->offset = offset;
15198  die->tag = abbrev->tag;
15199  die->abbrev = abbrev_number;
15200 
15201  /* Make the result usable.
15202  The caller needs to update num_attrs after adding the extra
15203  attributes. */
15204  die->num_attrs = abbrev->num_attrs;
15205 
15206  for (i = 0; i < abbrev->num_attrs; ++i)
15207  info_ptr = read_attribute (reader, &die->attrs[i], &abbrev->attrs[i],
15208  info_ptr);
15209 
15210  *diep = die;
15211  *has_children = abbrev->has_children;
15212  return info_ptr;
15213 }
15214 
15215 /* Read a die and all its attributes.
15216  Set DIEP to point to a newly allocated die with its information,
15217  except for its child, sibling, and parent fields.
15218  Set HAS_CHILDREN to tell whether the die has children or not. */
15219 
15220 static const gdb_byte *
15221 read_full_die (const struct die_reader_specs *reader,
15222  struct die_info **diep, const gdb_byte *info_ptr,
15223  int *has_children)
15224 {
15225  const gdb_byte *result;
15226 
15227  result = read_full_die_1 (reader, diep, info_ptr, has_children, 0);
15228 
15229  if (dwarf_die_debug)
15230  {
15232  "Read die from %s@0x%x of %s:\n",
15233  get_section_name (reader->die_section),
15234  (unsigned) (info_ptr - reader->die_section->buffer),
15235  bfd_get_filename (reader->abfd));
15236  dump_die (*diep, dwarf_die_debug);
15237  }
15238 
15239  return result;
15240 }
15241 
15242 /* Abbreviation tables.
15243 
15244  In DWARF version 2, the description of the debugging information is
15245  stored in a separate .debug_abbrev section. Before we read any
15246  dies from a section we read in all abbreviations and install them
15247  in a hash table. */
15248 
15249 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
15250 
15251 static struct abbrev_info *
15253 {
15254  struct abbrev_info *abbrev;
15255 
15256  abbrev = (struct abbrev_info *)
15257  obstack_alloc (&abbrev_table->abbrev_obstack, sizeof (struct abbrev_info));
15258  memset (abbrev, 0, sizeof (struct abbrev_info));
15259  return abbrev;
15260 }
15261 
15262 /* Add an abbreviation to the table. */
15263 
15264 static void
15266  unsigned int abbrev_number,
15267  struct abbrev_info *abbrev)
15268 {
15269  unsigned int hash_number;
15270 
15271  hash_number = abbrev_number % ABBREV_HASH_SIZE;
15272  abbrev->next = abbrev_table->abbrevs[hash_number];
15273  abbrev_table->abbrevs[hash_number] = abbrev;
15274 }
15275 
15276 /* Look up an abbrev in the table.
15277  Returns NULL if the abbrev is not found. */
15278 
15279 static struct abbrev_info *
15281  unsigned int abbrev_number)
15282 {
15283  unsigned int hash_number;
15284  struct abbrev_info *abbrev;
15285 
15286  hash_number = abbrev_number % ABBREV_HASH_SIZE;
15287  abbrev = abbrev_table->abbrevs[hash_number];
15288 
15289  while (abbrev)
15290  {
15291  if (abbrev->number == abbrev_number)
15292  return abbrev;
15293  abbrev = abbrev->next;
15294  }
15295  return NULL;
15296 }
15297 
15298 /* Read in an abbrev table. */
15299 
15300 static struct abbrev_table *
15302  sect_offset offset)
15303 {
15304  struct objfile *objfile = dwarf2_per_objfile->objfile;
15305  bfd *abfd = get_section_bfd_owner (section);
15306  struct abbrev_table *abbrev_table;
15307  const gdb_byte *abbrev_ptr;
15308  struct abbrev_info *cur_abbrev;
15309  unsigned int abbrev_number, bytes_read, abbrev_name;
15310  unsigned int abbrev_form;
15311  struct attr_abbrev *cur_attrs;
15312  unsigned int allocated_attrs;
15313 
15314  abbrev_table = XNEW (struct abbrev_table);
15315  abbrev_table->offset = offset;
15316  obstack_init (&abbrev_table->abbrev_obstack);
15317  abbrev_table->abbrevs = obstack_alloc (&abbrev_table->abbrev_obstack,
15319  * sizeof (struct abbrev_info *)));
15320  memset (abbrev_table->abbrevs, 0,
15321  ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
15322 
15323  dwarf2_read_section (objfile, section);
15324  abbrev_ptr = section->buffer + offset.sect_off;
15325  abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
15326  abbrev_ptr += bytes_read;
15327 
15328  allocated_attrs = ATTR_ALLOC_CHUNK;
15329  cur_attrs = xmalloc (allocated_attrs * sizeof (struct attr_abbrev));
15330 
15331  /* Loop until we reach an abbrev number of 0. */
15332  while (abbrev_number)
15333  {
15334  cur_abbrev = abbrev_table_alloc_abbrev (abbrev_table);
15335 
15336  /* read in abbrev header */
15337  cur_abbrev->number = abbrev_number;
15338  cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
15339  abbrev_ptr += bytes_read;
15340  cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
15341  abbrev_ptr += 1;
15342 
15343  /* now read in declarations */
15344  abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
15345  abbrev_ptr += bytes_read;
15346  abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
15347  abbrev_ptr += bytes_read;
15348  while (abbrev_name)
15349  {
15350  if (cur_abbrev->num_attrs == allocated_attrs)
15351  {
15352  allocated_attrs += ATTR_ALLOC_CHUNK;
15353  cur_attrs
15354  = xrealloc (cur_attrs, (allocated_attrs
15355  * sizeof (struct attr_abbrev)));
15356  }
15357 
15358  cur_attrs[cur_abbrev->num_attrs].name = abbrev_name;
15359  cur_attrs[cur_abbrev->num_attrs++].form = abbrev_form;
15360  abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
15361  abbrev_ptr += bytes_read;
15362  abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
15363  abbrev_ptr += bytes_read;
15364  }
15365 
15366  cur_abbrev->attrs = obstack_alloc (&abbrev_table->abbrev_obstack,
15367  (cur_abbrev->num_attrs
15368  * sizeof (struct attr_abbrev)));
15369  memcpy (cur_abbrev->attrs, cur_attrs,
15370  cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
15371 
15372  abbrev_table_add_abbrev (abbrev_table, abbrev_number, cur_abbrev);
15373 
15374  /* Get next abbreviation.
15375  Under Irix6 the abbreviations for a compilation unit are not
15376  always properly terminated with an abbrev number of 0.
15377  Exit loop if we encounter an abbreviation which we have
15378  already read (which means we are about to read the abbreviations
15379  for the next compile unit) or if the end of the abbreviation
15380  table is reached. */
15381  if ((unsigned int) (abbrev_ptr - section->buffer) >= section->size)
15382  break;
15383  abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
15384  abbrev_ptr += bytes_read;
15385  if (abbrev_table_lookup_abbrev (abbrev_table, abbrev_number) != NULL)
15386  break;
15387  }
15388 
15389  xfree (cur_attrs);
15390  return abbrev_table;
15391 }
15392 
15393 /* Free the resources held by ABBREV_TABLE. */
15394 
15395 static void
15397 {
15398  obstack_free (&abbrev_table->abbrev_obstack, NULL);
15399  xfree (abbrev_table);
15400 }
15401 
15402 /* Same as abbrev_table_free but as a cleanup.
15403  We pass in a pointer to the pointer to the table so that we can
15404  set the pointer to NULL when we're done. It also simplifies
15405  build_type_psymtabs_1. */
15406 
15407 static void
15408 abbrev_table_free_cleanup (void *table_ptr)
15409 {
15410  struct abbrev_table **abbrev_table_ptr = table_ptr;
15411 
15412  if (*abbrev_table_ptr != NULL)
15413  abbrev_table_free (*abbrev_table_ptr);
15414  *abbrev_table_ptr = NULL;
15415 }
15416 
15417 /* Read the abbrev table for CU from ABBREV_SECTION. */
15418 
15419 static void
15421  struct dwarf2_section_info *abbrev_section)
15422 {
15423  cu->abbrev_table =
15424  abbrev_table_read_table (abbrev_section, cu->header.abbrev_offset);
15425 }
15426 
15427 /* Release the memory used by the abbrev table for a compilation unit. */
15428 
15429 static void
15430 dwarf2_free_abbrev_table (void *ptr_to_cu)
15431 {
15432  struct dwarf2_cu *cu = ptr_to_cu;
15433 
15434  if (cu->abbrev_table != NULL)
15436  /* Set this to NULL so that we SEGV if we try to read it later,
15437  and also because free_comp_unit verifies this is NULL. */
15438  cu->abbrev_table = NULL;
15439 }
15440 
15441 /* Returns nonzero if TAG represents a type that we might generate a partial
15442  symbol for. */
15443 
15444 static int
15446 {
15447  switch (tag)
15448  {
15449 #if 0
15450  /* Some types that would be reasonable to generate partial symbols for,
15451  that we don't at present. */
15452  case DW_TAG_array_type:
15453  case DW_TAG_file_type:
15454  case DW_TAG_ptr_to_member_type:
15455  case DW_TAG_set_type:
15456  case DW_TAG_string_type:
15457  case DW_TAG_subroutine_type:
15458 #endif
15459  case DW_TAG_base_type:
15460  case DW_TAG_class_type:
15461  case DW_TAG_interface_type:
15462  case DW_TAG_enumeration_type:
15463  case DW_TAG_structure_type:
15464  case DW_TAG_subrange_type:
15465  case DW_TAG_typedef:
15466  case DW_TAG_union_type:
15467  return 1;
15468  default:
15469  return 0;
15470  }
15471 }
15472 
15473 /* Load all DIEs that are interesting for partial symbols into memory. */
15474 
15475 static struct partial_die_info *
15476 load_partial_dies (const struct die_reader_specs *reader,
15477  const gdb_byte *info_ptr, int building_psymtab)
15478 {
15479  struct dwarf2_cu *cu = reader->cu;
15480  struct objfile *objfile = cu->objfile;
15481  struct partial_die_info *part_die;
15482  struct partial_die_info *parent_die, *last_die, *first_die = NULL;
15483  struct abbrev_info *abbrev;
15484  unsigned int bytes_read;
15485  unsigned int load_all = 0;
15486  int nesting_level = 1;
15487 
15488  parent_die = NULL;
15489  last_die = NULL;
15490 
15491  gdb_assert (cu->per_cu != NULL);
15492  if (cu->per_cu->load_all_dies)
15493  load_all = 1;
15494 
15495  cu->partial_dies
15496  = htab_create_alloc_ex (cu->header.length / 12,
15499  NULL,
15500  &cu->comp_unit_obstack,
15503 
15504  part_die = obstack_alloc (&cu->comp_unit_obstack,
15505  sizeof (struct partial_die_info));
15506 
15507  while (1)
15508  {
15509  abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
15510 
15511  /* A NULL abbrev means the end of a series of children. */
15512  if (abbrev == NULL)
15513  {
15514  if (--nesting_level == 0)
15515  {
15516  /* PART_DIE was probably the last thing allocated on the
15517  comp_unit_obstack, so we could call obstack_free
15518  here. We don't do that because the waste is small,
15519  and will be cleaned up when we're done with this
15520  compilation unit. This way, we're also more robust
15521  against other users of the comp_unit_obstack. */
15522  return first_die;
15523  }
15524  info_ptr += bytes_read;
15525  last_die = parent_die;
15526  parent_die = parent_die->die_parent;
15527  continue;
15528  }
15529 
15530  /* Check for template arguments. We never save these; if
15531  they're seen, we just mark the parent, and go on our way. */
15532  if (parent_die != NULL
15533  && cu->language == language_cplus
15534  && (abbrev->tag == DW_TAG_template_type_param
15535  || abbrev->tag == DW_TAG_template_value_param))
15536  {
15537  parent_die->has_template_arguments = 1;
15538 
15539  if (!load_all)
15540  {
15541  /* We don't need a partial DIE for the template argument. */
15542  info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
15543  continue;
15544  }
15545  }
15546 
15547  /* We only recurse into c++ subprograms looking for template arguments.
15548  Skip their other children. */
15549  if (!load_all
15550  && cu->language == language_cplus
15551  && parent_die != NULL
15552  && parent_die->tag == DW_TAG_subprogram)
15553  {
15554  info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
15555  continue;
15556  }
15557 
15558  /* Check whether this DIE is interesting enough to save. Normally
15559  we would not be interested in members here, but there may be
15560  later variables referencing them via DW_AT_specification (for
15561  static members). */
15562  if (!load_all
15563  && !is_type_tag_for_partial (abbrev->tag)
15564  && abbrev->tag != DW_TAG_constant
15565  && abbrev->tag != DW_TAG_enumerator
15566  && abbrev->tag != DW_TAG_subprogram
15567  && abbrev->tag != DW_TAG_lexical_block
15568  && abbrev->tag != DW_TAG_variable
15569  && abbrev->tag != DW_TAG_namespace
15570  && abbrev->tag != DW_TAG_module
15571  && abbrev->tag != DW_TAG_member
15572  && abbrev->tag != DW_TAG_imported_unit
15573  && abbrev->tag != DW_TAG_imported_declaration)
15574  {
15575  /* Otherwise we skip to the next sibling, if any. */
15576  info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
15577  continue;
15578  }
15579 
15580  info_ptr = read_partial_die (reader, part_die, abbrev, bytes_read,
15581  info_ptr);
15582 
15583  /* This two-pass algorithm for processing partial symbols has a
15584  high cost in cache pressure. Thus, handle some simple cases
15585  here which cover the majority of C partial symbols. DIEs
15586  which neither have specification tags in them, nor could have
15587  specification tags elsewhere pointing at them, can simply be
15588  processed and discarded.
15589 
15590  This segment is also optional; scan_partial_symbols and
15591  add_partial_symbol will handle these DIEs if we chain
15592  them in normally. When compilers which do not emit large
15593  quantities of duplicate debug information are more common,
15594  this code can probably be removed. */
15595 
15596  /* Any complete simple types at the top level (pretty much all
15597  of them, for a language without namespaces), can be processed
15598  directly. */
15599  if (parent_die == NULL
15600  && part_die->has_specification == 0
15601  && part_die->is_declaration == 0
15602  && ((part_die->tag == DW_TAG_typedef && !part_die->has_children)
15603  || part_die->tag == DW_TAG_base_type
15604  || part_die->tag == DW_TAG_subrange_type))
15605  {
15606  if (building_psymtab && part_die->name != NULL)
15607  add_psymbol_to_list (part_die->name, strlen (part_die->name), 0,
15609  &objfile->static_psymbols,
15610  0, (CORE_ADDR) 0, cu->language, objfile);
15611  info_ptr = locate_pdi_sibling (reader, part_die, info_ptr);
15612  continue;
15613  }
15614 
15615  /* The exception for DW_TAG_typedef with has_children above is
15616  a workaround of GCC PR debug/47510. In the case of this complaint
15617  type_name_no_tag_or_error will error on such types later.
15618 
15619  GDB skipped children of DW_TAG_typedef by the shortcut above and then
15620  it could not find the child DIEs referenced later, this is checked
15621  above. In correct DWARF DW_TAG_typedef should have no children. */
15622 
15623  if (part_die->tag == DW_TAG_typedef && part_die->has_children)
15625  _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
15626  "- DIE at 0x%x [in module %s]"),
15627  part_die->offset.sect_off, objfile_name (objfile));
15628 
15629  /* If we're at the second level, and we're an enumerator, and
15630  our parent has no specification (meaning possibly lives in a
15631  namespace elsewhere), then we can add the partial symbol now
15632  instead of queueing it. */
15633  if (part_die->tag == DW_TAG_enumerator
15634  && parent_die != NULL
15635  && parent_die->die_parent == NULL
15636  && parent_die->tag == DW_TAG_enumeration_type
15637  && parent_die->has_specification == 0)
15638  {
15639  if (part_die->name == NULL)
15641  _("malformed enumerator DIE ignored"));
15642  else if (building_psymtab)
15643  add_psymbol_to_list (part_die->name, strlen (part_die->name), 0,
15645  (cu->language == language_cplus
15646  || cu->language == language_java)
15647  ? &objfile->global_psymbols
15648  : &objfile->static_psymbols,
15649  0, (CORE_ADDR) 0, cu->language, objfile);
15650 
15651  info_ptr = locate_pdi_sibling (reader, part_die, info_ptr);
15652  continue;
15653  }
15654 
15655  /* We'll save this DIE so link it in. */
15656  part_die->die_parent = parent_die;
15657  part_die->die_sibling = NULL;
15658  part_die->die_child = NULL;
15659 
15660  if (last_die && last_die == parent_die)
15661  last_die->die_child = part_die;
15662  else if (last_die)
15663  last_die->die_sibling = part_die;
15664 
15665  last_die = part_die;
15666 
15667  if (first_die == NULL)
15668  first_die = part_die;
15669 
15670  /* Maybe add the DIE to the hash table. Not all DIEs that we
15671  find interesting need to be in the hash table, because we
15672  also have the parent/sibling/child chains; only those that we
15673  might refer to by offset later during partial symbol reading.
15674 
15675  For now this means things that might have be the target of a
15676  DW_AT_specification, DW_AT_abstract_origin, or
15677  DW_AT_extension. DW_AT_extension will refer only to
15678  namespaces; DW_AT_abstract_origin refers to functions (and
15679  many things under the function DIE, but we do not recurse
15680  into function DIEs during partial symbol reading) and
15681  possibly variables as well; DW_AT_specification refers to
15682  declarations. Declarations ought to have the DW_AT_declaration
15683  flag. It happens that GCC forgets to put it in sometimes, but
15684  only for functions, not for types.
15685 
15686  Adding more things than necessary to the hash table is harmless
15687  except for the performance cost. Adding too few will result in
15688  wasted time in find_partial_die, when we reread the compilation
15689  unit with load_all_dies set. */
15690 
15691  if (load_all
15692  || abbrev->tag == DW_TAG_constant
15693  || abbrev->tag == DW_TAG_subprogram
15694  || abbrev->tag == DW_TAG_variable
15695  || abbrev->tag == DW_TAG_namespace
15696  || part_die->is_declaration)
15697  {
15698  void **slot;
15699 
15700  slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
15701  part_die->offset.sect_off, INSERT);
15702  *slot = part_die;
15703  }
15704 
15705  part_die = obstack_alloc (&cu->comp_unit_obstack,
15706  sizeof (struct partial_die_info));
15707 
15708  /* For some DIEs we want to follow their children (if any). For C
15709  we have no reason to follow the children of structures; for other
15710  languages we have to, so that we can get at method physnames
15711  to infer fully qualified class names, for DW_AT_specification,
15712  and for C++ template arguments. For C++, we also look one level
15713  inside functions to find template arguments (if the name of the
15714  function does not already contain the template arguments).
15715 
15716  For Ada, we need to scan the children of subprograms and lexical
15717  blocks as well because Ada allows the definition of nested
15718  entities that could be interesting for the debugger, such as
15719  nested subprograms for instance. */
15720  if (last_die->has_children
15721  && (load_all
15722  || last_die->tag == DW_TAG_namespace
15723  || last_die->tag == DW_TAG_module
15724  || last_die->tag == DW_TAG_enumeration_type
15725  || (cu->language == language_cplus
15726  && last_die->tag == DW_TAG_subprogram
15727  && (last_die->name == NULL
15728  || strchr (last_die->name, '<') == NULL))
15729  || (cu->language != language_c
15730  && (last_die->tag == DW_TAG_class_type
15731  || last_die->tag == DW_TAG_interface_type
15732  || last_die->tag == DW_TAG_structure_type
15733  || last_die->tag == DW_TAG_union_type))
15734  || (cu->language == language_ada
15735  && (last_die->tag == DW_TAG_subprogram
15736  || last_die->tag == DW_TAG_lexical_block))))
15737  {
15738  nesting_level++;
15739  parent_die = last_die;
15740  continue;
15741  }
15742 
15743  /* Otherwise we skip to the next sibling, if any. */
15744  info_ptr = locate_pdi_sibling (reader, last_die, info_ptr);
15745 
15746  /* Back to the top, do it again. */
15747  }
15748 }
15749 
15750 /* Read a minimal amount of information into the minimal die structure. */
15751 
15752 static const gdb_byte *
15753 read_partial_die (const struct die_reader_specs *reader,
15754  struct partial_die_info *part_die,
15755  struct abbrev_info *abbrev, unsigned int abbrev_len,
15756  const gdb_byte *info_ptr)
15757 {
15758  struct dwarf2_cu *cu = reader->cu;
15759  struct objfile *objfile = cu->objfile;
15760  const gdb_byte *buffer = reader->buffer;
15761  unsigned int i;
15762  struct attribute attr;
15763  int has_low_pc_attr = 0;
15764  int has_high_pc_attr = 0;
15765  int high_pc_relative = 0;
15766 
15767  memset (part_die, 0, sizeof (struct partial_die_info));
15768 
15769  part_die->offset.sect_off = info_ptr - buffer;
15770 
15771  info_ptr += abbrev_len;
15772 
15773  if (abbrev == NULL)
15774  return info_ptr;
15775 
15776  part_die->tag = abbrev->tag;
15777  part_die->has_children = abbrev->has_children;
15778 
15779  for (i = 0; i < abbrev->num_attrs; ++i)
15780  {
15781  info_ptr = read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
15782 
15783  /* Store the data if it is of an attribute we want to keep in a
15784  partial symbol table. */
15785  switch (attr.name)
15786  {
15787  case DW_AT_name:
15788  switch (part_die->tag)
15789  {
15790  case DW_TAG_compile_unit:
15791  case DW_TAG_partial_unit:
15792  case DW_TAG_type_unit:
15793  /* Compilation units have a DW_AT_name that is a filename, not
15794  a source language identifier. */
15795  case DW_TAG_enumeration_type:
15796  case DW_TAG_enumerator:
15797  /* These tags always have simple identifiers already; no need
15798  to canonicalize them. */
15799  part_die->name = DW_STRING (&attr);
15800  break;
15801  default:
15802  part_die->name
15803  = dwarf2_canonicalize_name (DW_STRING (&attr), cu,
15804  &objfile->per_bfd->storage_obstack);
15805  break;
15806  }
15807  break;
15808  case DW_AT_linkage_name:
15809  case DW_AT_MIPS_linkage_name:
15810  /* Note that both forms of linkage name might appear. We
15811  assume they will be the same, and we only store the last
15812  one we see. */
15813  if (cu->language == language_ada)
15814  part_die->name = DW_STRING (&attr);
15815  part_die->linkage_name = DW_STRING (&attr);
15816  break;
15817  case DW_AT_low_pc:
15818  has_low_pc_attr = 1;
15819  part_die->lowpc = attr_value_as_address (&attr);
15820  break;
15821  case DW_AT_high_pc:
15822  has_high_pc_attr = 1;
15823  part_die->highpc = attr_value_as_address (&attr);
15824  if (cu->header.version >= 4 && attr_form_is_constant (&attr))
15825  high_pc_relative = 1;
15826  break;
15827  case DW_AT_location:
15828  /* Support the .debug_loc offsets. */
15829  if (attr_form_is_block (&attr))
15830  {
15831  part_die->d.locdesc = DW_BLOCK (&attr);
15832  }
15833  else if (attr_form_is_section_offset (&attr))
15834  {
15836  }
15837  else
15838  {
15839  dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
15840  "partial symbol information");
15841  }
15842  break;
15843  case DW_AT_external:
15844  part_die->is_external = DW_UNSND (&attr);
15845  break;
15846  case DW_AT_declaration:
15847  part_die->is_declaration = DW_UNSND (&attr);
15848  break;
15849  case DW_AT_type:
15850  part_die->has_type = 1;
15851  break;
15852  case DW_AT_abstract_origin:
15853  case DW_AT_specification:
15854  case DW_AT_extension:
15855  part_die->has_specification = 1;
15856  part_die->spec_offset = dwarf2_get_ref_die_offset (&attr);
15857  part_die->spec_is_dwz = (attr.form == DW_FORM_GNU_ref_alt
15858  || cu->per_cu->is_dwz);
15859  break;
15860  case DW_AT_sibling:
15861  /* Ignore absolute siblings, they might point outside of
15862  the current compile unit. */
15863  if (attr.form == DW_FORM_ref_addr)
15865  _("ignoring absolute DW_AT_sibling"));
15866  else
15867  {
15868  unsigned int off = dwarf2_get_ref_die_offset (&attr).sect_off;
15869  const gdb_byte *sibling_ptr = buffer + off;
15870 
15871  if (sibling_ptr < info_ptr)
15873  _("DW_AT_sibling points backwards"));
15874  else if (sibling_ptr > reader->buffer_end)
15876  else
15877  part_die->sibling = sibling_ptr;
15878  }
15879  break;
15880  case DW_AT_byte_size:
15881  part_die->has_byte_size = 1;
15882  break;
15883  case DW_AT_const_value:
15884  part_die->has_const_value = 1;
15885  break;
15886  case DW_AT_calling_convention:
15887  /* DWARF doesn't provide a way to identify a program's source-level
15888  entry point. DW_AT_calling_convention attributes are only meant
15889  to describe functions' calling conventions.
15890 
15891  However, because it's a necessary piece of information in
15892  Fortran, and because DW_CC_program is the only piece of debugging
15893  information whose definition refers to a 'main program' at all,
15894  several compilers have begun marking Fortran main programs with
15895  DW_CC_program --- even when those functions use the standard
15896  calling conventions.
15897 
15898  So until DWARF specifies a way to provide this information and
15899  compilers pick up the new representation, we'll support this
15900  practice. */
15901  if (DW_UNSND (&attr) == DW_CC_program
15902  && cu->language == language_fortran)
15903  set_objfile_main_name (objfile, part_die->name, language_fortran);
15904  break;
15905  case DW_AT_inline:
15906  if (DW_UNSND (&attr) == DW_INL_inlined
15907  || DW_UNSND (&attr) == DW_INL_declared_inlined)
15908  part_die->may_be_inlined = 1;
15909  break;
15910 
15911  case DW_AT_import:
15912  if (part_die->tag == DW_TAG_imported_unit)
15913  {
15914  part_die->d.offset = dwarf2_get_ref_die_offset (&attr);
15915  part_die->is_dwz = (attr.form == DW_FORM_GNU_ref_alt
15916  || cu->per_cu->is_dwz);
15917  }
15918  break;
15919 
15920  default:
15921  break;
15922  }
15923  }
15924 
15925  if (high_pc_relative)
15926  part_die->highpc += part_die->lowpc;
15927 
15928  if (has_low_pc_attr && has_high_pc_attr)
15929  {
15930  /* When using the GNU linker, .gnu.linkonce. sections are used to
15931  eliminate duplicate copies of functions and vtables and such.
15932  The linker will arbitrarily choose one and discard the others.
15933  The AT_*_pc values for such functions refer to local labels in
15934  these sections. If the section from that file was discarded, the
15935  labels are not in the output, so the relocs get a value of 0.
15936  If this is a discarded function, mark the pc bounds as invalid,
15937  so that GDB will ignore it. */
15938  if (part_die->lowpc == 0 && !dwarf2_per_objfile->has_section_at_zero)
15939  {
15940  struct gdbarch *gdbarch = get_objfile_arch (objfile);
15941 
15943  _("DW_AT_low_pc %s is zero "
15944  "for DIE at 0x%x [in module %s]"),
15945  paddress (gdbarch, part_die->lowpc),
15946  part_die->offset.sect_off, objfile_name (objfile));
15947  }
15948  /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
15949  else if (part_die->lowpc >= part_die->highpc)
15950  {
15951  struct gdbarch *gdbarch = get_objfile_arch (objfile);
15952 
15954  _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
15955  "for DIE at 0x%x [in module %s]"),
15956  paddress (gdbarch, part_die->lowpc),
15957  paddress (gdbarch, part_die->highpc),
15958  part_die->offset.sect_off, objfile_name (objfile));
15959  }
15960  else
15961  part_die->has_pc_info = 1;
15962  }
15963 
15964  return info_ptr;
15965 }
15966 
15967 /* Find a cached partial DIE at OFFSET in CU. */
15968 
15969 static struct partial_die_info *
15971 {
15972  struct partial_die_info *lookup_die = NULL;
15973  struct partial_die_info part_die;
15974 
15975  part_die.offset = offset;
15976  lookup_die = htab_find_with_hash (cu->partial_dies, &part_die,
15977  offset.sect_off);
15978 
15979  return lookup_die;
15980 }
15981 
15982 /* Find a partial DIE at OFFSET, which may or may not be in CU,
15983  except in the case of .debug_types DIEs which do not reference
15984  outside their CU (they do however referencing other types via
15985  DW_FORM_ref_sig8). */
15986 
15987 static struct partial_die_info *
15988 find_partial_die (sect_offset offset, int offset_in_dwz, struct dwarf2_cu *cu)
15989 {
15990  struct objfile *objfile = cu->objfile;
15991  struct dwarf2_per_cu_data *per_cu = NULL;
15992  struct partial_die_info *pd = NULL;
15993 
15994  if (offset_in_dwz == cu->per_cu->is_dwz
15995  && offset_in_cu_p (&cu->header, offset))
15996  {
15997  pd = find_partial_die_in_comp_unit (offset, cu);
15998  if (pd != NULL)
15999  return pd;
16000  /* We missed recording what we needed.
16001  Load all dies and try again. */
16002  per_cu = cu->per_cu;
16003  }
16004  else
16005  {
16006  /* TUs don't reference other CUs/TUs (except via type signatures). */
16007  if (cu->per_cu->is_debug_types)
16008  {
16009  error (_("Dwarf Error: Type Unit at offset 0x%lx contains"
16010  " external reference to offset 0x%lx [in module %s].\n"),
16011  (long) cu->header.offset.sect_off, (long) offset.sect_off,
16012  bfd_get_filename (objfile->obfd));
16013  }
16014  per_cu = dwarf2_find_containing_comp_unit (offset, offset_in_dwz,
16015  objfile);
16016 
16017  if (per_cu->cu == NULL || per_cu->cu->partial_dies == NULL)
16018  load_partial_comp_unit (per_cu);
16019 
16020  per_cu->cu->last_used = 0;
16021  pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
16022  }
16023 
16024  /* If we didn't find it, and not all dies have been loaded,
16025  load them all and try again. */
16026 
16027  if (pd == NULL && per_cu->load_all_dies == 0)
16028  {
16029  per_cu->load_all_dies = 1;
16030 
16031  /* This is nasty. When we reread the DIEs, somewhere up the call chain
16032  THIS_CU->cu may already be in use. So we can't just free it and
16033  replace its DIEs with the ones we read in. Instead, we leave those
16034  DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
16035  and clobber THIS_CU->cu->partial_dies with the hash table for the new
16036  set. */
16037  load_partial_comp_unit (per_cu);
16038 
16039  pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
16040  }
16041 
16042  if (pd == NULL)
16043  internal_error (__FILE__, __LINE__,
16044  _("could not find partial DIE 0x%x "
16045  "in cache [from module %s]\n"),
16046  offset.sect_off, bfd_get_filename (objfile->obfd));
16047  return pd;
16048 }
16049 
16050 /* See if we can figure out if the class lives in a namespace. We do
16051  this by looking for a member function; its demangled name will
16052  contain namespace info, if there is any. */
16053 
16054 static void
16056  struct dwarf2_cu *cu)
16057 {
16058  /* NOTE: carlton/2003-10-07: Getting the info this way changes
16059  what template types look like, because the demangler
16060  frequently doesn't give the same name as the debug info. We
16061  could fix this by only using the demangled name to get the
16062  prefix (but see comment in read_structure_type). */
16063 
16064  struct partial_die_info *real_pdi;
16065  struct partial_die_info *child_pdi;
16066 
16067  /* If this DIE (this DIE's specification, if any) has a parent, then
16068  we should not do this. We'll prepend the parent's fully qualified
16069  name when we create the partial symbol. */
16070 
16071  real_pdi = struct_pdi;
16072  while (real_pdi->has_specification)
16073  real_pdi = find_partial_die (real_pdi->spec_offset,
16074  real_pdi->spec_is_dwz, cu);
16075 
16076  if (real_pdi->die_parent != NULL)
16077  return;
16078 
16079  for (child_pdi = struct_pdi->die_child;
16080  child_pdi != NULL;
16081  child_pdi = child_pdi->die_sibling)
16082  {
16083  if (child_pdi->tag == DW_TAG_subprogram
16084  && child_pdi->linkage_name != NULL)
16085  {
16086  char *actual_class_name
16088  child_pdi->linkage_name);
16089  if (actual_class_name != NULL)
16090  {
16091  struct_pdi->name
16092  = obstack_copy0 (&cu->objfile->per_bfd->storage_obstack,
16093  actual_class_name,
16094  strlen (actual_class_name));
16095  xfree (actual_class_name);
16096  }
16097  break;
16098  }
16099  }
16100 }
16101 
16102 /* Adjust PART_DIE before generating a symbol for it. This function
16103  may set the is_external flag or change the DIE's name. */
16104 
16105 static void
16107  struct dwarf2_cu *cu)
16108 {
16109  /* Once we've fixed up a die, there's no point in doing so again.
16110  This also avoids a memory leak if we were to call
16111  guess_partial_die_structure_name multiple times. */
16112  if (part_die->fixup_called)
16113  return;
16114 
16115  /* If we found a reference attribute and the DIE has no name, try
16116  to find a name in the referred to DIE. */
16117 
16118  if (part_die->name == NULL && part_die->has_specification)
16119  {
16120  struct partial_die_info *spec_die;
16121 
16122  spec_die = find_partial_die (part_die->spec_offset,
16123  part_die->spec_is_dwz, cu);
16124 
16125  fixup_partial_die (spec_die, cu);
16126 
16127  if (spec_die->name)
16128  {
16129  part_die->name = spec_die->name;
16130 
16131  /* Copy DW_AT_external attribute if it is set. */
16132  if (spec_die->is_external)
16133  part_die->is_external = spec_die->is_external;
16134  }
16135  }
16136 
16137  /* Set default names for some unnamed DIEs. */
16138 
16139  if (part_die->name == NULL && part_die->tag == DW_TAG_namespace)
16140  part_die->name = CP_ANONYMOUS_NAMESPACE_STR;
16141 
16142  /* If there is no parent die to provide a namespace, and there are
16143  children, see if we can determine the namespace from their linkage
16144  name. */
16145  if (cu->language == language_cplus
16146  && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
16147  && part_die->die_parent == NULL
16148  && part_die->has_children
16149  && (part_die->tag == DW_TAG_class_type
16150  || part_die->tag == DW_TAG_structure_type
16151  || part_die->tag == DW_TAG_union_type))
16152  guess_partial_die_structure_name (part_die, cu);
16153 
16154  /* GCC might emit a nameless struct or union that has a linkage
16155  name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
16156  if (part_die->name == NULL
16157  && (part_die->tag == DW_TAG_class_type
16158  || part_die->tag == DW_TAG_interface_type
16159  || part_die->tag == DW_TAG_structure_type
16160  || part_die->tag == DW_TAG_union_type)
16161  && part_die->linkage_name != NULL)
16162  {
16163  char *demangled;
16164 
16165  demangled = gdb_demangle (part_die->linkage_name, DMGL_TYPES);
16166  if (demangled)
16167  {
16168  const char *base;
16169 
16170  /* Strip any leading namespaces/classes, keep only the base name.
16171  DW_AT_name for named DIEs does not contain the prefixes. */
16172  base = strrchr (demangled, ':');
16173  if (base && base > demangled && base[-1] == ':')
16174  base++;
16175  else
16176  base = demangled;
16177 
16178  part_die->name
16179  = obstack_copy0 (&cu->objfile->per_bfd->storage_obstack,
16180  base, strlen (base));
16181  xfree (demangled);
16182  }
16183  }
16184 
16185  part_die->fixup_called = 1;
16186 }
16187 
16188 /* Read an attribute value described by an attribute form. */
16189 
16190 static const gdb_byte *
16192  struct attribute *attr, unsigned form,
16193  const gdb_byte *info_ptr)
16194 {
16195  struct dwarf2_cu *cu = reader->cu;
16196  struct objfile *objfile = cu->objfile;
16197  struct gdbarch *gdbarch = get_objfile_arch (objfile);
16198  bfd *abfd = reader->abfd;
16199  struct comp_unit_head *cu_header = &cu->header;
16200  unsigned int bytes_read;
16201  struct dwarf_block *blk;
16202 
16203  attr->form = form;
16204  switch (form)
16205  {
16206  case DW_FORM_ref_addr:
16207  if (cu->header.version == 2)
16208  DW_UNSND (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
16209  else
16210  DW_UNSND (attr) = read_offset (abfd, info_ptr,
16211  &cu->header, &bytes_read);
16212  info_ptr += bytes_read;
16213  break;
16214  case DW_FORM_GNU_ref_alt:
16215  DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
16216  info_ptr += bytes_read;
16217  break;
16218  case DW_FORM_addr:
16219  DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
16220  DW_ADDR (attr) = gdbarch_adjust_dwarf2_addr (gdbarch, DW_ADDR (attr));
16221  info_ptr += bytes_read;
16222  break;
16223  case DW_FORM_block2:
16224  blk = dwarf_alloc_block (cu);
16225  blk->size = read_2_bytes (abfd, info_ptr);
16226  info_ptr += 2;
16227  blk->data = read_n_bytes (abfd, info_ptr, blk->size);
16228  info_ptr += blk->size;
16229  DW_BLOCK (attr) = blk;
16230  break;
16231  case DW_FORM_block4:
16232  blk = dwarf_alloc_block (cu);
16233  blk->size = read_4_bytes (abfd, info_ptr);
16234  info_ptr += 4;
16235  blk->data = read_n_bytes (abfd, info_ptr, blk->size);
16236  info_ptr += blk->size;
16237  DW_BLOCK (attr) = blk;
16238  break;
16239  case DW_FORM_data2:
16240  DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
16241  info_ptr += 2;
16242  break;
16243  case DW_FORM_data4:
16244  DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
16245  info_ptr += 4;
16246  break;
16247  case DW_FORM_data8:
16248  DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
16249  info_ptr += 8;
16250  break;
16251  case DW_FORM_sec_offset:
16252  DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
16253  info_ptr += bytes_read;
16254  break;
16255  case DW_FORM_string:
16256  DW_STRING (attr) = read_direct_string (abfd, info_ptr, &bytes_read);
16257  DW_STRING_IS_CANONICAL (attr) = 0;
16258  info_ptr += bytes_read;
16259  break;
16260  case DW_FORM_strp:
16261  if (!cu->per_cu->is_dwz)
16262  {
16263  DW_STRING (attr) = read_indirect_string (abfd, info_ptr, cu_header,
16264  &bytes_read);
16265  DW_STRING_IS_CANONICAL (attr) = 0;
16266  info_ptr += bytes_read;
16267  break;
16268  }
16269  /* FALLTHROUGH */
16270  case DW_FORM_GNU_strp_alt:
16271  {
16272  struct dwz_file *dwz = dwarf2_get_dwz_file ();
16273  LONGEST str_offset = read_offset (abfd, info_ptr, cu_header,
16274  &bytes_read);
16275 
16276  DW_STRING (attr) = read_indirect_string_from_dwz (dwz, str_offset);
16277  DW_STRING_IS_CANONICAL (attr) = 0;
16278  info_ptr += bytes_read;
16279  }
16280  break;
16281  case DW_FORM_exprloc:
16282  case DW_FORM_block:
16283  blk = dwarf_alloc_block (cu);
16284  blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
16285  info_ptr += bytes_read;
16286  blk->data = read_n_bytes (abfd, info_ptr, blk->size);
16287  info_ptr += blk->size;
16288  DW_BLOCK (attr) = blk;
16289  break;
16290  case DW_FORM_block1:
16291  blk = dwarf_alloc_block (cu);
16292  blk->size = read_1_byte (abfd, info_ptr);
16293  info_ptr += 1;
16294  blk->data = read_n_bytes (abfd, info_ptr, blk->size);
16295  info_ptr += blk->size;
16296  DW_BLOCK (attr) = blk;
16297  break;
16298  case DW_FORM_data1:
16299  DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
16300  info_ptr += 1;
16301  break;
16302  case DW_FORM_flag:
16303  DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
16304  info_ptr += 1;
16305  break;
16306  case DW_FORM_flag_present:
16307  DW_UNSND (attr) = 1;
16308  break;
16309  case DW_FORM_sdata:
16310  DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
16311  info_ptr += bytes_read;
16312  break;
16313  case DW_FORM_udata:
16314  DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
16315  info_ptr += bytes_read;
16316  break;
16317  case DW_FORM_ref1:
16318  DW_UNSND (attr) = (cu->header.offset.sect_off
16319  + read_1_byte (abfd, info_ptr));
16320  info_ptr += 1;
16321  break;
16322  case DW_FORM_ref2:
16323  DW_UNSND (attr) = (cu->header.offset.sect_off
16324  + read_2_bytes (abfd, info_ptr));
16325  info_ptr += 2;
16326  break;
16327  case DW_FORM_ref4:
16328  DW_UNSND (attr) = (cu->header.offset.sect_off
16329  + read_4_bytes (abfd, info_ptr));
16330  info_ptr += 4;
16331  break;
16332  case DW_FORM_ref8:
16333  DW_UNSND (attr) = (cu->header.offset.sect_off
16334  + read_8_bytes (abfd, info_ptr));
16335  info_ptr += 8;
16336  break;
16337  case DW_FORM_ref_sig8:
16338  DW_SIGNATURE (attr) = read_8_bytes (abfd, info_ptr);
16339  info_ptr += 8;
16340  break;
16341  case DW_FORM_ref_udata:
16342  DW_UNSND (attr) = (cu->header.offset.sect_off
16343  + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
16344  info_ptr += bytes_read;
16345  break;
16346  case DW_FORM_indirect:
16347  form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
16348  info_ptr += bytes_read;
16349  info_ptr = read_attribute_value (reader, attr, form, info_ptr);
16350  break;
16351  case DW_FORM_GNU_addr_index:
16352  if (reader->dwo_file == NULL)
16353  {
16354  /* For now flag a hard error.
16355  Later we can turn this into a complaint. */
16356  error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
16357  dwarf_form_name (form),
16358  bfd_get_filename (abfd));
16359  }
16360  DW_ADDR (attr) = read_addr_index_from_leb128 (cu, info_ptr, &bytes_read);
16361  info_ptr += bytes_read;
16362  break;
16363  case DW_FORM_GNU_str_index:
16364  if (reader->dwo_file == NULL)
16365  {
16366  /* For now flag a hard error.
16367  Later we can turn this into a complaint if warranted. */
16368  error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
16369  dwarf_form_name (form),
16370  bfd_get_filename (abfd));
16371  }
16372  {
16373  ULONGEST str_index =
16374  read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
16375 
16376  DW_STRING (attr) = read_str_index (reader, str_index);
16377  DW_STRING_IS_CANONICAL (attr) = 0;
16378  info_ptr += bytes_read;
16379  }
16380  break;
16381  default:
16382  error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
16383  dwarf_form_name (form),
16384  bfd_get_filename (abfd));
16385  }
16386 
16387  /* Super hack. */
16388  if (cu->per_cu->is_dwz && attr_form_is_ref (attr))
16389  attr->form = DW_FORM_GNU_ref_alt;
16390 
16391  /* We have seen instances where the compiler tried to emit a byte
16392  size attribute of -1 which ended up being encoded as an unsigned
16393  0xffffffff. Although 0xffffffff is technically a valid size value,
16394  an object of this size seems pretty unlikely so we can relatively
16395  safely treat these cases as if the size attribute was invalid and
16396  treat them as zero by default. */
16397  if (attr->name == DW_AT_byte_size
16398  && form == DW_FORM_data4
16399  && DW_UNSND (attr) >= 0xffffffff)
16400  {
16401  complaint
16403  _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
16404  hex_string (DW_UNSND (attr)));
16405  DW_UNSND (attr) = 0;
16406  }
16407 
16408  return info_ptr;
16409 }
16410 
16411 /* Read an attribute described by an abbreviated attribute. */
16412 
16413 static const gdb_byte *
16414 read_attribute (const struct die_reader_specs *reader,
16415  struct attribute *attr, struct attr_abbrev *abbrev,
16416  const gdb_byte *info_ptr)
16417 {
16418  attr->name = abbrev->name;
16419  return read_attribute_value (reader, attr, abbrev->form, info_ptr);
16420 }
16421 
16422 /* Read dwarf information from a buffer. */
16423 
16424 static unsigned int
16425 read_1_byte (bfd *abfd, const gdb_byte *buf)
16426 {
16427  return bfd_get_8 (abfd, buf);
16428 }
16429 
16430 static int
16431 read_1_signed_byte (bfd *abfd, const gdb_byte *buf)
16432 {
16433  return bfd_get_signed_8 (abfd, buf);
16434 }
16435 
16436 static unsigned int
16437 read_2_bytes (bfd *abfd, const gdb_byte *buf)
16438 {
16439  return bfd_get_16 (abfd, buf);
16440 }
16441 
16442 static int
16443 read_2_signed_bytes (bfd *abfd, const gdb_byte *buf)
16444 {
16445  return bfd_get_signed_16 (abfd, buf);
16446 }
16447 
16448 static unsigned int
16449 read_4_bytes (bfd *abfd, const gdb_byte *buf)
16450 {
16451  return bfd_get_32 (abfd, buf);
16452 }
16453 
16454 static int
16455 read_4_signed_bytes (bfd *abfd, const gdb_byte *buf)
16456 {
16457  return bfd_get_signed_32 (abfd, buf);
16458 }
16459 
16460 static ULONGEST
16461 read_8_bytes (bfd *abfd, const gdb_byte *buf)
16462 {
16463  return bfd_get_64 (abfd, buf);
16464 }
16465 
16466 static CORE_ADDR
16467 read_address (bfd *abfd, const gdb_byte *buf, struct dwarf2_cu *cu,
16468  unsigned int *bytes_read)
16469 {
16470  struct comp_unit_head *cu_header = &cu->header;
16471  CORE_ADDR retval = 0;
16472 
16473  if (cu_header->signed_addr_p)
16474  {
16475  switch (cu_header->addr_size)
16476  {
16477  case 2:
16478  retval = bfd_get_signed_16 (abfd, buf);
16479  break;
16480  case 4:
16481  retval = bfd_get_signed_32 (abfd, buf);
16482  break;
16483  case 8:
16484  retval = bfd_get_signed_64 (abfd, buf);
16485  break;
16486  default:
16487  internal_error (__FILE__, __LINE__,
16488  _("read_address: bad switch, signed [in module %s]"),
16489  bfd_get_filename (abfd));
16490  }
16491  }
16492  else
16493  {
16494  switch (cu_header->addr_size)
16495  {
16496  case 2:
16497  retval = bfd_get_16 (abfd, buf);
16498  break;
16499  case 4:
16500  retval = bfd_get_32 (abfd, buf);
16501  break;
16502  case 8:
16503  retval = bfd_get_64 (abfd, buf);
16504  break;
16505  default:
16506  internal_error (__FILE__, __LINE__,
16507  _("read_address: bad switch, "
16508  "unsigned [in module %s]"),
16509  bfd_get_filename (abfd));
16510  }
16511  }
16512 
16513  *bytes_read = cu_header->addr_size;
16514  return retval;
16515 }
16516 
16517 /* Read the initial length from a section. The (draft) DWARF 3
16518  specification allows the initial length to take up either 4 bytes
16519  or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
16520  bytes describe the length and all offsets will be 8 bytes in length
16521  instead of 4.
16522 
16523  An older, non-standard 64-bit format is also handled by this
16524  function. The older format in question stores the initial length
16525  as an 8-byte quantity without an escape value. Lengths greater
16526  than 2^32 aren't very common which means that the initial 4 bytes
16527  is almost always zero. Since a length value of zero doesn't make
16528  sense for the 32-bit format, this initial zero can be considered to
16529  be an escape value which indicates the presence of the older 64-bit
16530  format. As written, the code can't detect (old format) lengths
16531  greater than 4GB. If it becomes necessary to handle lengths
16532  somewhat larger than 4GB, we could allow other small values (such
16533  as the non-sensical values of 1, 2, and 3) to also be used as
16534  escape values indicating the presence of the old format.
16535 
16536  The value returned via bytes_read should be used to increment the
16537  relevant pointer after calling read_initial_length().
16538 
16539  [ Note: read_initial_length() and read_offset() are based on the
16540  document entitled "DWARF Debugging Information Format", revision
16541  3, draft 8, dated November 19, 2001. This document was obtained
16542  from:
16543 
16544  http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
16545 
16546  This document is only a draft and is subject to change. (So beware.)
16547 
16548  Details regarding the older, non-standard 64-bit format were
16549  determined empirically by examining 64-bit ELF files produced by
16550  the SGI toolchain on an IRIX 6.5 machine.
16551 
16552  - Kevin, July 16, 2002
16553  ] */
16554 
16555 static LONGEST
16556 read_initial_length (bfd *abfd, const gdb_byte *buf, unsigned int *bytes_read)
16557 {
16558  LONGEST length = bfd_get_32 (abfd, buf);
16559 
16560  if (length == 0xffffffff)
16561  {
16562  length = bfd_get_64 (abfd, buf + 4);
16563  *bytes_read = 12;
16564  }
16565  else if (length == 0)
16566  {
16567  /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
16568  length = bfd_get_64 (abfd, buf);
16569  *bytes_read = 8;
16570  }
16571  else
16572  {
16573  *bytes_read = 4;
16574  }
16575 
16576  return length;
16577 }
16578 
16579 /* Cover function for read_initial_length.
16580  Returns the length of the object at BUF, and stores the size of the
16581  initial length in *BYTES_READ and stores the size that offsets will be in
16582  *OFFSET_SIZE.
16583  If the initial length size is not equivalent to that specified in
16584  CU_HEADER then issue a complaint.
16585  This is useful when reading non-comp-unit headers. */
16586 
16587 static LONGEST
16589  const struct comp_unit_head *cu_header,
16590  unsigned int *bytes_read,
16591  unsigned int *offset_size)
16592 {
16593  LONGEST length = read_initial_length (abfd, buf, bytes_read);
16594 
16595  gdb_assert (cu_header->initial_length_size == 4
16596  || cu_header->initial_length_size == 8
16597  || cu_header->initial_length_size == 12);
16598 
16599  if (cu_header->initial_length_size != *bytes_read)
16601  _("intermixed 32-bit and 64-bit DWARF sections"));
16602 
16603  *offset_size = (*bytes_read == 4) ? 4 : 8;
16604  return length;
16605 }
16606 
16607 /* Read an offset from the data stream. The size of the offset is
16608  given by cu_header->offset_size. */
16609 
16610 static LONGEST
16611 read_offset (bfd *abfd, const gdb_byte *buf,
16612  const struct comp_unit_head *cu_header,
16613  unsigned int *bytes_read)
16614 {
16615  LONGEST offset = read_offset_1 (abfd, buf, cu_header->offset_size);
16616 
16617  *bytes_read = cu_header->offset_size;
16618  return offset;
16619 }
16620 
16621 /* Read an offset from the data stream. */
16622 
16623 static LONGEST
16624 read_offset_1 (bfd *abfd, const gdb_byte *buf, unsigned int offset_size)
16625 {
16626  LONGEST retval = 0;
16627 
16628  switch (offset_size)
16629  {
16630  case 4:
16631  retval = bfd_get_32 (abfd, buf);
16632  break;
16633  case 8:
16634  retval = bfd_get_64 (abfd, buf);
16635  break;
16636  default:
16637  internal_error (__FILE__, __LINE__,
16638  _("read_offset_1: bad switch [in module %s]"),
16639  bfd_get_filename (abfd));
16640  }
16641 
16642  return retval;
16643 }
16644 
16645 static const gdb_byte *
16646 read_n_bytes (bfd *abfd, const gdb_byte *buf, unsigned int size)
16647 {
16648  /* If the size of a host char is 8 bits, we can return a pointer
16649  to the buffer, otherwise we have to copy the data to a buffer
16650  allocated on the temporary obstack. */
16651  gdb_assert (HOST_CHAR_BIT == 8);
16652  return buf;
16653 }
16654 
16655 static const char *
16656 read_direct_string (bfd *abfd, const gdb_byte *buf,
16657  unsigned int *bytes_read_ptr)
16658 {
16659  /* If the size of a host char is 8 bits, we can return a pointer
16660  to the string, otherwise we have to copy the string to a buffer
16661  allocated on the temporary obstack. */
16662  gdb_assert (HOST_CHAR_BIT == 8);
16663  if (*buf == '\0')
16664  {
16665  *bytes_read_ptr = 1;
16666  return NULL;
16667  }
16668  *bytes_read_ptr = strlen ((const char *) buf) + 1;
16669  return (const char *) buf;
16670 }
16671 
16672 static const char *
16674 {
16675  dwarf2_read_section (dwarf2_per_objfile->objfile, &dwarf2_per_objfile->str);
16676  if (dwarf2_per_objfile->str.buffer == NULL)
16677  error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
16678  bfd_get_filename (abfd));
16679  if (str_offset >= dwarf2_per_objfile->str.size)
16680  error (_("DW_FORM_strp pointing outside of "
16681  ".debug_str section [in module %s]"),
16682  bfd_get_filename (abfd));
16683  gdb_assert (HOST_CHAR_BIT == 8);
16684  if (dwarf2_per_objfile->str.buffer[str_offset] == '\0')
16685  return NULL;
16686  return (const char *) (dwarf2_per_objfile->str.buffer + str_offset);
16687 }
16688 
16689 /* Read a string at offset STR_OFFSET in the .debug_str section from
16690  the .dwz file DWZ. Throw an error if the offset is too large. If
16691  the string consists of a single NUL byte, return NULL; otherwise
16692  return a pointer to the string. */
16693 
16694 static const char *
16696 {
16697  dwarf2_read_section (dwarf2_per_objfile->objfile, &dwz->str);
16698 
16699  if (dwz->str.buffer == NULL)
16700  error (_("DW_FORM_GNU_strp_alt used without .debug_str "
16701  "section [in module %s]"),
16702  bfd_get_filename (dwz->dwz_bfd));
16703  if (str_offset >= dwz->str.size)
16704  error (_("DW_FORM_GNU_strp_alt pointing outside of "
16705  ".debug_str section [in module %s]"),
16706  bfd_get_filename (dwz->dwz_bfd));
16707  gdb_assert (HOST_CHAR_BIT == 8);
16708  if (dwz->str.buffer[str_offset] == '\0')
16709  return NULL;
16710  return (const char *) (dwz->str.buffer + str_offset);
16711 }
16712 
16713 static const char *
16714 read_indirect_string (bfd *abfd, const gdb_byte *buf,
16715  const struct comp_unit_head *cu_header,
16716  unsigned int *bytes_read_ptr)
16717 {
16718  LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
16719 
16720  return read_indirect_string_at_offset (abfd, str_offset);
16721 }
16722 
16723 static ULONGEST
16724 read_unsigned_leb128 (bfd *abfd, const gdb_byte *buf,
16725  unsigned int *bytes_read_ptr)
16726 {
16727  ULONGEST result;
16728  unsigned int num_read;
16729  int i, shift;
16730  unsigned char byte;
16731 
16732  result = 0;
16733  shift = 0;
16734  num_read = 0;
16735  i = 0;
16736  while (1)
16737  {
16738  byte = bfd_get_8 (abfd, buf);
16739  buf++;
16740  num_read++;
16741  result |= ((ULONGEST) (byte & 127) << shift);
16742  if ((byte & 128) == 0)
16743  {
16744  break;
16745  }
16746  shift += 7;
16747  }
16748  *bytes_read_ptr = num_read;
16749  return result;
16750 }
16751 
16752 static LONGEST
16753 read_signed_leb128 (bfd *abfd, const gdb_byte *buf,
16754  unsigned int *bytes_read_ptr)
16755 {
16756  LONGEST result;
16757  int i, shift, num_read;
16758  unsigned char byte;
16759 
16760  result = 0;
16761  shift = 0;
16762  num_read = 0;
16763  i = 0;
16764  while (1)
16765  {
16766  byte = bfd_get_8 (abfd, buf);
16767  buf++;
16768  num_read++;
16769  result |= ((LONGEST) (byte & 127) << shift);
16770  shift += 7;
16771  if ((byte & 128) == 0)
16772  {
16773  break;
16774  }
16775  }
16776  if ((shift < 8 * sizeof (result)) && (byte & 0x40))
16777  result |= -(((LONGEST) 1) << shift);
16778  *bytes_read_ptr = num_read;
16779  return result;
16780 }
16781 
16782 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
16783  ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
16784  ADDR_SIZE is the size of addresses from the CU header. */
16785 
16786 static CORE_ADDR
16787 read_addr_index_1 (unsigned int addr_index, ULONGEST addr_base, int addr_size)
16788 {
16789  struct objfile *objfile = dwarf2_per_objfile->objfile;
16790  bfd *abfd = objfile->obfd;
16791  const gdb_byte *info_ptr;
16792 
16793  dwarf2_read_section (objfile, &dwarf2_per_objfile->addr);
16794  if (dwarf2_per_objfile->addr.buffer == NULL)
16795  error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
16796  objfile_name (objfile));
16797  if (addr_base + addr_index * addr_size >= dwarf2_per_objfile->addr.size)
16798  error (_("DW_FORM_addr_index pointing outside of "
16799  ".debug_addr section [in module %s]"),
16800  objfile_name (objfile));
16801  info_ptr = (dwarf2_per_objfile->addr.buffer
16802  + addr_base + addr_index * addr_size);
16803  if (addr_size == 4)
16804  return bfd_get_32 (abfd, info_ptr);
16805  else
16806  return bfd_get_64 (abfd, info_ptr);
16807 }
16808 
16809 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
16810 
16811 static CORE_ADDR
16812 read_addr_index (struct dwarf2_cu *cu, unsigned int addr_index)
16813 {
16814  return read_addr_index_1 (addr_index, cu->addr_base, cu->header.addr_size);
16815 }
16816 
16817 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
16818 
16819 static CORE_ADDR
16820 read_addr_index_from_leb128 (struct dwarf2_cu *cu, const gdb_byte *info_ptr,
16821  unsigned int *bytes_read)
16822 {
16823  bfd *abfd = cu->objfile->obfd;
16824  unsigned int addr_index = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
16825 
16826  return read_addr_index (cu, addr_index);
16827 }
16828 
16829 /* Data structure to pass results from dwarf2_read_addr_index_reader
16830  back to dwarf2_read_addr_index. */
16831 
16833 {
16836 };
16837 
16838 /* die_reader_func for dwarf2_read_addr_index. */
16839 
16840 static void
16842  const gdb_byte *info_ptr,
16843  struct die_info *comp_unit_die,
16844  int has_children,
16845  void *data)
16846 {
16847  struct dwarf2_cu *cu = reader->cu;
16848  struct dwarf2_read_addr_index_data *aidata =
16849  (struct dwarf2_read_addr_index_data *) data;
16850 
16851  aidata->addr_base = cu->addr_base;
16852  aidata->addr_size = cu->header.addr_size;
16853 }
16854 
16855 /* Given an index in .debug_addr, fetch the value.
16856  NOTE: This can be called during dwarf expression evaluation,
16857  long after the debug information has been read, and thus per_cu->cu
16858  may no longer exist. */
16859 
16860 CORE_ADDR
16862  unsigned int addr_index)
16863 {
16864  struct objfile *objfile = per_cu->objfile;
16865  struct dwarf2_cu *cu = per_cu->cu;
16866  ULONGEST addr_base;
16867  int addr_size;
16868 
16869  /* This is intended to be called from outside this file. */
16870  dw2_setup (objfile);
16871 
16872  /* We need addr_base and addr_size.
16873  If we don't have PER_CU->cu, we have to get it.
16874  Nasty, but the alternative is storing the needed info in PER_CU,
16875  which at this point doesn't seem justified: it's not clear how frequently
16876  it would get used and it would increase the size of every PER_CU.
16877  Entry points like dwarf2_per_cu_addr_size do a similar thing
16878  so we're not in uncharted territory here.
16879  Alas we need to be a bit more complicated as addr_base is contained
16880  in the DIE.
16881 
16882  We don't need to read the entire CU(/TU).
16883  We just need the header and top level die.
16884 
16885  IWBN to use the aging mechanism to let us lazily later discard the CU.
16886  For now we skip this optimization. */
16887 
16888  if (cu != NULL)
16889  {
16890  addr_base = cu->addr_base;
16891  addr_size = cu->header.addr_size;
16892  }
16893  else
16894  {
16895  struct dwarf2_read_addr_index_data aidata;
16896 
16897  /* Note: We can't use init_cutu_and_read_dies_simple here,
16898  we need addr_base. */
16899  init_cutu_and_read_dies (per_cu, NULL, 0, 0,
16901  addr_base = aidata.addr_base;
16902  addr_size = aidata.addr_size;
16903  }
16904 
16905  return read_addr_index_1 (addr_index, addr_base, addr_size);
16906 }
16907 
16908 /* Given a DW_FORM_GNU_str_index, fetch the string.
16909  This is only used by the Fission support. */
16910 
16911 static const char *
16912 read_str_index (const struct die_reader_specs *reader, ULONGEST str_index)
16913 {
16914  struct objfile *objfile = dwarf2_per_objfile->objfile;
16915  const char *objf_name = objfile_name (objfile);
16916  bfd *abfd = objfile->obfd;
16917  struct dwarf2_cu *cu = reader->cu;
16918  struct dwarf2_section_info *str_section = &reader->dwo_file->sections.str;
16919  struct dwarf2_section_info *str_offsets_section =
16920  &reader->dwo_file->sections.str_offsets;
16921  const gdb_byte *info_ptr;
16922  ULONGEST str_offset;
16923  static const char form_name[] = "DW_FORM_GNU_str_index";
16924 
16925  dwarf2_read_section (objfile, str_section);
16926  dwarf2_read_section (objfile, str_offsets_section);
16927  if (str_section->buffer == NULL)
16928  error (_("%s used without .debug_str.dwo section"
16929  " in CU at offset 0x%lx [in module %s]"),
16930  form_name, (long) cu->header.offset.sect_off, objf_name);
16931  if (str_offsets_section->buffer == NULL)
16932  error (_("%s used without .debug_str_offsets.dwo section"
16933  " in CU at offset 0x%lx [in module %s]"),
16934  form_name, (long) cu->header.offset.sect_off, objf_name);
16935  if (str_index * cu->header.offset_size >= str_offsets_section->size)
16936  error (_("%s pointing outside of .debug_str_offsets.dwo"
16937  " section in CU at offset 0x%lx [in module %s]"),
16938  form_name, (long) cu->header.offset.sect_off, objf_name);
16939  info_ptr = (str_offsets_section->buffer
16940  + str_index * cu->header.offset_size);
16941  if (cu->header.offset_size == 4)
16942  str_offset = bfd_get_32 (abfd, info_ptr);
16943  else
16944  str_offset = bfd_get_64 (abfd, info_ptr);
16945  if (str_offset >= str_section->size)
16946  error (_("Offset from %s pointing outside of"
16947  " .debug_str.dwo section in CU at offset 0x%lx [in module %s]"),
16948  form_name, (long) cu->header.offset.sect_off, objf_name);
16949  return (const char *) (str_section->buffer + str_offset);
16950 }
16951 
16952 /* Return the length of an LEB128 number in BUF. */
16953 
16954 static int
16955 leb128_size (const gdb_byte *buf)
16956 {
16957  const gdb_byte *begin = buf;
16958  gdb_byte byte;
16959 
16960  while (1)
16961  {
16962  byte = *buf++;
16963  if ((byte & 128) == 0)
16964  return buf - begin;
16965  }
16966 }
16967 
16968 static void
16969 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
16970 {
16971  switch (lang)
16972  {
16973  case DW_LANG_C89:
16974  case DW_LANG_C99:
16975  case DW_LANG_C11:
16976  case DW_LANG_C:
16977  case DW_LANG_UPC:
16978  cu->language = language_c;
16979  break;
16980  case DW_LANG_C_plus_plus:
16981  case DW_LANG_C_plus_plus_11:
16982  case DW_LANG_C_plus_plus_14:
16983  cu->language = language_cplus;
16984  break;
16985  case DW_LANG_D:
16986  cu->language = language_d;
16987  break;
16988  case DW_LANG_Fortran77:
16989  case DW_LANG_Fortran90:
16990  case DW_LANG_Fortran95:
16991  case DW_LANG_Fortran03:
16992  case DW_LANG_Fortran08:
16993  cu->language = language_fortran;
16994  break;
16995  case DW_LANG_Go:
16996  cu->language = language_go;
16997  break;
16998  case DW_LANG_Mips_Assembler:
16999  cu->language = language_asm;
17000  break;
17001  case DW_LANG_Java:
17002  cu->language = language_java;
17003  break;
17004  case DW_LANG_Ada83:
17005  case DW_LANG_Ada95:
17006  cu->language = language_ada;
17007  break;
17008  case DW_LANG_Modula2:
17009  cu->language = language_m2;
17010  break;
17011  case DW_LANG_Pascal83:
17012  cu->language = language_pascal;
17013  break;
17014  case DW_LANG_ObjC:
17015  cu->language = language_objc;
17016  break;
17017  case DW_LANG_Cobol74:
17018  case DW_LANG_Cobol85:
17019  default:
17020  cu->language = language_minimal;
17021  break;
17022  }
17023  cu->language_defn = language_def (cu->language);
17024 }
17025 
17026 /* Return the named attribute or NULL if not there. */
17027 
17028 static struct attribute *
17029 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
17030 {
17031  for (;;)
17032  {
17033  unsigned int i;
17034  struct attribute *spec = NULL;
17035 
17036  for (i = 0; i < die->num_attrs; ++i)
17037  {
17038  if (die->attrs[i].name == name)
17039  return &die->attrs[i];
17040  if (die->attrs[i].name == DW_AT_specification
17041  || die->attrs[i].name == DW_AT_abstract_origin)
17042  spec = &die->attrs[i];
17043  }
17044 
17045  if (!spec)
17046  break;
17047 
17048  die = follow_die_ref (die, spec, &cu);
17049  }
17050 
17051  return NULL;
17052 }
17053 
17054 /* Return the named attribute or NULL if not there,
17055  but do not follow DW_AT_specification, etc.
17056  This is for use in contexts where we're reading .debug_types dies.
17057  Following DW_AT_specification, DW_AT_abstract_origin will take us
17058  back up the chain, and we want to go down. */
17059 
17060 static struct attribute *
17061 dwarf2_attr_no_follow (struct die_info *die, unsigned int name)
17062 {
17063  unsigned int i;
17064 
17065  for (i = 0; i < die->num_attrs; ++i)
17066  if (die->attrs[i].name == name)
17067  return &die->attrs[i];
17068 
17069  return NULL;
17070 }
17071 
17072 /* Return non-zero iff the attribute NAME is defined for the given DIE,
17073  and holds a non-zero value. This function should only be used for
17074  DW_FORM_flag or DW_FORM_flag_present attributes. */
17075 
17076 static int
17077 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
17078 {
17079  struct attribute *attr = dwarf2_attr (die, name, cu);
17080 
17081  return (attr && DW_UNSND (attr));
17082 }
17083 
17084 static int
17085 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
17086 {
17087  /* A DIE is a declaration if it has a DW_AT_declaration attribute
17088  which value is non-zero. However, we have to be careful with
17089  DIEs having a DW_AT_specification attribute, because dwarf2_attr()
17090  (via dwarf2_flag_true_p) follows this attribute. So we may
17091  end up accidently finding a declaration attribute that belongs
17092  to a different DIE referenced by the specification attribute,
17093  even though the given DIE does not have a declaration attribute. */
17094  return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
17095  && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
17096 }
17097 
17098 /* Return the die giving the specification for DIE, if there is
17099  one. *SPEC_CU is the CU containing DIE on input, and the CU
17100  containing the return value on output. If there is no
17101  specification, but there is an abstract origin, that is
17102  returned. */
17103 
17104 static struct die_info *
17105 die_specification (struct die_info *die, struct dwarf2_cu **spec_cu)
17106 {
17107  struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification,
17108  *spec_cu);
17109 
17110  if (spec_attr == NULL)
17111  spec_attr = dwarf2_attr (die, DW_AT_abstract_origin, *spec_cu);
17112 
17113  if (spec_attr == NULL)
17114  return NULL;
17115  else
17116  return follow_die_ref (die, spec_attr, spec_cu);
17117 }
17118 
17119 /* Free the line_header structure *LH, and any arrays and strings it
17120  refers to.
17121  NOTE: This is also used as a "cleanup" function. */
17122 
17123 static void
17125 {
17126  if (lh->standard_opcode_lengths)
17128 
17129  /* Remember that all the lh->file_names[i].name pointers are
17130  pointers into debug_line_buffer, and don't need to be freed. */
17131  if (lh->file_names)
17132  xfree (lh->file_names);
17133 
17134  /* Similarly for the include directory names. */
17135  if (lh->include_dirs)
17136  xfree (lh->include_dirs);
17137 
17138  xfree (lh);
17139 }
17140 
17141 /* Stub for free_line_header to match void * callback types. */
17142 
17143 static void
17145 {
17146  struct line_header *lh = arg;
17147 
17148  free_line_header (lh);
17149 }
17150 
17151 /* Add an entry to LH's include directory table. */
17152 
17153 static void
17154 add_include_dir (struct line_header *lh, const char *include_dir)
17155 {
17156  if (dwarf_line_debug >= 2)
17157  fprintf_unfiltered (gdb_stdlog, "Adding dir %u: %s\n",
17158  lh->num_include_dirs + 1, include_dir);
17159 
17160  /* Grow the array if necessary. */
17161  if (lh->include_dirs_size == 0)
17162  {
17163  lh->include_dirs_size = 1; /* for testing */
17165  * sizeof (*lh->include_dirs));
17166  }
17167  else if (lh->num_include_dirs >= lh->include_dirs_size)
17168  {
17169  lh->include_dirs_size *= 2;
17170  lh->include_dirs = xrealloc (lh->include_dirs,
17171  (lh->include_dirs_size
17172  * sizeof (*lh->include_dirs)));
17173  }
17174 
17175  lh->include_dirs[lh->num_include_dirs++] = include_dir;
17176 }
17177 
17178 /* Add an entry to LH's file name table. */
17179 
17180 static void
17182  const char *name,
17183  unsigned int dir_index,
17184  unsigned int mod_time,
17185  unsigned int length)
17186 {
17187  struct file_entry *fe;
17188 
17189  if (dwarf_line_debug >= 2)
17190  fprintf_unfiltered (gdb_stdlog, "Adding file %u: %s\n",
17191  lh->num_file_names + 1, name);
17192 
17193  /* Grow the array if necessary. */
17194  if (lh->file_names_size == 0)
17195  {
17196  lh->file_names_size = 1; /* for testing */
17198  * sizeof (*lh->file_names));
17199  }
17200  else if (lh->num_file_names >= lh->file_names_size)
17201  {
17202  lh->file_names_size *= 2;
17203  lh->file_names = xrealloc (lh->file_names,
17204  (lh->file_names_size
17205  * sizeof (*lh->file_names)));
17206  }
17207 
17208  fe = &lh->file_names[lh->num_file_names++];
17209  fe->name = name;
17210  fe->dir_index = dir_index;
17211  fe->mod_time = mod_time;
17212  fe->length = length;
17213  fe->included_p = 0;
17214  fe->symtab = NULL;
17215 }
17216 
17217 /* A convenience function to find the proper .debug_line section for a CU. */
17218 
17219 static struct dwarf2_section_info *
17221 {
17222  struct dwarf2_section_info *section;
17223 
17224  /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
17225  DWO file. */
17226  if (cu->dwo_unit && cu->per_cu->is_debug_types)
17227  section = &cu->dwo_unit->dwo_file->sections.line;
17228  else if (cu->per_cu->is_dwz)
17229  {
17230  struct dwz_file *dwz = dwarf2_get_dwz_file ();
17231 
17232  section = &dwz->line;
17233  }
17234  else
17235  section = &dwarf2_per_objfile->line;
17236 
17237  return section;
17238 }
17239 
17240 /* Read the statement program header starting at OFFSET in
17241  .debug_line, or .debug_line.dwo. Return a pointer
17242  to a struct line_header, allocated using xmalloc.
17243  Returns NULL if there is a problem reading the header, e.g., if it
17244  has a version we don't understand.
17245 
17246  NOTE: the strings in the include directory and file name tables of
17247  the returned object point into the dwarf line section buffer,
17248  and must not be freed. */
17249 
17250 static struct line_header *
17251 dwarf_decode_line_header (unsigned int offset, struct dwarf2_cu *cu)
17252 {
17253  struct cleanup *back_to;
17254  struct line_header *lh;
17255  const gdb_byte *line_ptr;
17256  unsigned int bytes_read, offset_size;
17257  int i;
17258  const char *cur_dir, *cur_file;
17259  struct dwarf2_section_info *section;
17260  bfd *abfd;
17261 
17262  section = get_debug_line_section (cu);
17263  dwarf2_read_section (dwarf2_per_objfile->objfile, section);
17264  if (section->buffer == NULL)
17265  {
17266  if (cu->dwo_unit && cu->per_cu->is_debug_types)
17267  complaint (&symfile_complaints, _("missing .debug_line.dwo section"));
17268  else
17269  complaint (&symfile_complaints, _("missing .debug_line section"));
17270  return 0;
17271  }
17272 
17273  /* We can't do this until we know the section is non-empty.
17274  Only then do we know we have such a section. */
17275  abfd = get_section_bfd_owner (section);
17276 
17277  /* Make sure that at least there's room for the total_length field.
17278  That could be 12 bytes long, but we're just going to fudge that. */
17279  if (offset + 4 >= section->size)
17280  {
17282  return 0;
17283  }
17284 
17285  lh = xmalloc (sizeof (*lh));
17286  memset (lh, 0, sizeof (*lh));
17288  (void *) lh);
17289 
17290  lh->offset.sect_off = offset;
17291  lh->offset_in_dwz = cu->per_cu->is_dwz;
17292 
17293  line_ptr = section->buffer + offset;
17294 
17295  /* Read in the header. */
17296  lh->total_length =
17297  read_checked_initial_length_and_offset (abfd, line_ptr, &cu->header,
17298  &bytes_read, &offset_size);
17299  line_ptr += bytes_read;
17300  if (line_ptr + lh->total_length > (section->buffer + section->size))
17301  {
17303  do_cleanups (back_to);
17304  return 0;
17305  }
17306  lh->statement_program_end = line_ptr + lh->total_length;
17307  lh->version = read_2_bytes (abfd, line_ptr);
17308  line_ptr += 2;
17309  if (lh->version > 4)
17310  {
17311  /* This is a version we don't understand. The format could have
17312  changed in ways we don't handle properly so just punt. */
17314  _("unsupported version in .debug_line section"));
17315  return NULL;
17316  }
17317  lh->header_length = read_offset_1 (abfd, line_ptr, offset_size);
17318  line_ptr += offset_size;
17319  lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
17320  line_ptr += 1;
17321  if (lh->version >= 4)
17322  {
17323  lh->maximum_ops_per_instruction = read_1_byte (abfd, line_ptr);
17324  line_ptr += 1;
17325  }
17326  else
17328 
17329  if (lh->maximum_ops_per_instruction == 0)
17330  {
17333  _("invalid maximum_ops_per_instruction "
17334  "in `.debug_line' section"));
17335  }
17336 
17337  lh->default_is_stmt = read_1_byte (abfd, line_ptr);
17338  line_ptr += 1;
17339  lh->line_base = read_1_signed_byte (abfd, line_ptr);
17340  line_ptr += 1;
17341  lh->line_range = read_1_byte (abfd, line_ptr);
17342  line_ptr += 1;
17343  lh->opcode_base = read_1_byte (abfd, line_ptr);
17344  line_ptr += 1;
17346  = xmalloc (lh->opcode_base * sizeof (lh->standard_opcode_lengths[0]));
17347 
17348  lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
17349  for (i = 1; i < lh->opcode_base; ++i)
17350  {
17351  lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
17352  line_ptr += 1;
17353  }
17354 
17355  /* Read directory table. */
17356  while ((cur_dir = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
17357  {
17358  line_ptr += bytes_read;
17359  add_include_dir (lh, cur_dir);
17360  }
17361  line_ptr += bytes_read;
17362 
17363  /* Read file name table. */
17364  while ((cur_file = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
17365  {
17366  unsigned int dir_index, mod_time, length;
17367 
17368  line_ptr += bytes_read;
17369  dir_index = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17370  line_ptr += bytes_read;
17371  mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17372  line_ptr += bytes_read;
17373  length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17374  line_ptr += bytes_read;
17375 
17376  add_file_name (lh, cur_file, dir_index, mod_time, length);
17377  }
17378  line_ptr += bytes_read;
17379  lh->statement_program_start = line_ptr;
17380 
17381  if (line_ptr > (section->buffer + section->size))
17383  _("line number info header doesn't "
17384  "fit in `.debug_line' section"));
17385 
17386  discard_cleanups (back_to);
17387  return lh;
17388 }
17389 
17390 /* Subroutine of dwarf_decode_lines to simplify it.
17391  Return the file name of the psymtab for included file FILE_INDEX
17392  in line header LH of PST.
17393  COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
17394  If space for the result is malloc'd, it will be freed by a cleanup.
17395  Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename.
17396 
17397  The function creates dangling cleanup registration. */
17398 
17399 static const char *
17400 psymtab_include_file_name (const struct line_header *lh, int file_index,
17401  const struct partial_symtab *pst,
17402  const char *comp_dir)
17403 {
17404  const struct file_entry fe = lh->file_names [file_index];
17405  const char *include_name = fe.name;
17406  const char *include_name_to_compare = include_name;
17407  const char *dir_name = NULL;
17408  const char *pst_filename;
17409  char *copied_name = NULL;
17410  int file_is_pst;
17411 
17412  if (fe.dir_index && lh->include_dirs != NULL)
17413  dir_name = lh->include_dirs[fe.dir_index - 1];
17414 
17415  if (!IS_ABSOLUTE_PATH (include_name)
17416  && (dir_name != NULL || comp_dir != NULL))
17417  {
17418  /* Avoid creating a duplicate psymtab for PST.
17419  We do this by comparing INCLUDE_NAME and PST_FILENAME.
17420  Before we do the comparison, however, we need to account
17421  for DIR_NAME and COMP_DIR.
17422  First prepend dir_name (if non-NULL). If we still don't
17423  have an absolute path prepend comp_dir (if non-NULL).
17424  However, the directory we record in the include-file's
17425  psymtab does not contain COMP_DIR (to match the
17426  corresponding symtab(s)).
17427 
17428  Example:
17429 
17430  bash$ cd /tmp
17431  bash$ gcc -g ./hello.c
17432  include_name = "hello.c"
17433  dir_name = "."
17434  DW_AT_comp_dir = comp_dir = "/tmp"
17435  DW_AT_name = "./hello.c"
17436 
17437  */
17438 
17439  if (dir_name != NULL)
17440  {
17441  char *tem = concat (dir_name, SLASH_STRING,
17442  include_name, (char *)NULL);
17443 
17444  make_cleanup (xfree, tem);
17445  include_name = tem;
17446  include_name_to_compare = include_name;
17447  }
17448  if (!IS_ABSOLUTE_PATH (include_name) && comp_dir != NULL)
17449  {
17450  char *tem = concat (comp_dir, SLASH_STRING,
17451  include_name, (char *)NULL);
17452 
17453  make_cleanup (xfree, tem);
17454  include_name_to_compare = tem;
17455  }
17456  }
17457 
17458  pst_filename = pst->filename;
17459  if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
17460  {
17461  copied_name = concat (pst->dirname, SLASH_STRING,
17462  pst_filename, (char *)NULL);
17463  pst_filename = copied_name;
17464  }
17465 
17466  file_is_pst = FILENAME_CMP (include_name_to_compare, pst_filename) == 0;
17467 
17468  if (copied_name != NULL)
17469  xfree (copied_name);
17470 
17471  if (file_is_pst)
17472  return NULL;
17473  return include_name;
17474 }
17475 
17476 /* State machine to track the state of the line number program. */
17477 
17478 typedef struct
17479 {
17480  /* These are part of the standard DWARF line number state machine. */
17481 
17482  unsigned char op_index;
17483  unsigned int file;
17484  unsigned int line;
17486  int is_stmt;
17487  unsigned int discriminator;
17488 
17489  /* Additional bits of state we need to track. */
17490 
17491  /* The last file that we called dwarf2_start_subfile for.
17492  This is only used for TLLs. */
17493  unsigned int last_file;
17494  /* The last file a line number was recorded for. */
17496 
17497  /* The function to call to record a line. */
17499 
17500  /* The last line number that was recorded, used to coalesce
17501  consecutive entries for the same line. This can happen, for
17502  example, when discriminators are present. PR 17276. */
17503  unsigned int last_line;
17506 
17507 /* There's a lot of static state to pass to dwarf_record_line.
17508  This keeps it all together. */
17509 
17510 typedef struct
17511 {
17512  /* The gdbarch. */
17513  struct gdbarch *gdbarch;
17514 
17515  /* The line number header. */
17517 
17518  /* Non-zero if we're recording lines.
17519  Otherwise we're building partial symtabs and are just interested in
17520  finding include files mentioned by the line number program. */
17523 
17524 /* Ignore this record_line request. */
17525 
17526 static void
17528 {
17529  return;
17530 }
17531 
17532 /* Return non-zero if we should add LINE to the line number table.
17533  LINE is the line to add, LAST_LINE is the last line that was added,
17534  LAST_SUBFILE is the subfile for LAST_LINE.
17535  LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
17536  had a non-zero discriminator.
17537 
17538  We have to be careful in the presence of discriminators.
17539  E.g., for this line:
17540 
17541  for (i = 0; i < 100000; i++);
17542 
17543  clang can emit four line number entries for that one line,
17544  each with a different discriminator.
17545  See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
17546 
17547  However, we want gdb to coalesce all four entries into one.
17548  Otherwise the user could stepi into the middle of the line and
17549  gdb would get confused about whether the pc really was in the
17550  middle of the line.
17551 
17552  Things are further complicated by the fact that two consecutive
17553  line number entries for the same line is a heuristic used by gcc
17554  to denote the end of the prologue. So we can't just discard duplicate
17555  entries, we have to be selective about it. The heuristic we use is
17556  that we only collapse consecutive entries for the same line if at least
17557  one of those entries has a non-zero discriminator. PR 17276.
17558 
17559  Note: Addresses in the line number state machine can never go backwards
17560  within one sequence, thus this coalescing is ok. */
17561 
17562 static int
17563 dwarf_record_line_p (unsigned int line, unsigned int last_line,
17564  int line_has_non_zero_discriminator,
17565  struct subfile *last_subfile)
17566 {
17567  if (current_subfile != last_subfile)
17568  return 1;
17569  if (line != last_line)
17570  return 1;
17571  /* Same line for the same file that we've seen already.
17572  As a last check, for pr 17276, only record the line if the line
17573  has never had a non-zero discriminator. */
17574  if (!line_has_non_zero_discriminator)
17575  return 1;
17576  return 0;
17577 }
17578 
17579 /* Use P_RECORD_LINE to record line number LINE beginning at address ADDRESS
17580  in the line table of subfile SUBFILE. */
17581 
17582 static void
17584  unsigned int line, CORE_ADDR address,
17585  record_line_ftype p_record_line)
17586 {
17587  CORE_ADDR addr = gdbarch_addr_bits_remove (gdbarch, address);
17588 
17589  if (dwarf_line_debug)
17590  {
17592  "Recording line %u, file %s, address %s\n",
17593  line, lbasename (subfile->name),
17594  paddress (gdbarch, address));
17595  }
17596 
17597  (*p_record_line) (subfile, line, addr);
17598 }
17599 
17600 /* Subroutine of dwarf_decode_lines_1 to simplify it.
17601  Mark the end of a set of line number records.
17602  The arguments are the same as for dwarf_record_line_1.
17603  If SUBFILE is NULL the request is ignored. */
17604 
17605 static void
17607  CORE_ADDR address, record_line_ftype p_record_line)
17608 {
17609  if (subfile == NULL)
17610  return;
17611 
17612  if (dwarf_line_debug)
17613  {
17615  "Finishing current line, file %s, address %s\n",
17616  lbasename (subfile->name),
17617  paddress (gdbarch, address));
17618  }
17619 
17620  dwarf_record_line_1 (gdbarch, subfile, 0, address, p_record_line);
17621 }
17622 
17623 /* Record the line in STATE.
17624  END_SEQUENCE is non-zero if we're processing the end of a sequence. */
17625 
17626 static void
17628  int end_sequence)
17629 {
17630  const struct line_header *lh = reader->line_header;
17631  unsigned int file, line, discriminator;
17632  int is_stmt;
17633 
17634  file = state->file;
17635  line = state->line;
17636  is_stmt = state->is_stmt;
17637  discriminator = state->discriminator;
17638 
17639  if (dwarf_line_debug)
17640  {
17642  "Processing actual line %u: file %u,"
17643  " address %s, is_stmt %u, discrim %u\n",
17644  line, file,
17645  paddress (reader->gdbarch, state->address),
17646  is_stmt, discriminator);
17647  }
17648 
17649  if (file == 0 || file - 1 >= lh->num_file_names)
17651  /* For now we ignore lines not starting on an instruction boundary.
17652  But not when processing end_sequence for compatibility with the
17653  previous version of the code. */
17654  else if (state->op_index == 0 || end_sequence)
17655  {
17656  lh->file_names[file - 1].included_p = 1;
17657  if (reader->record_lines_p && is_stmt)
17658  {
17659  if (state->last_subfile != current_subfile || end_sequence)
17660  {
17661  dwarf_finish_line (reader->gdbarch, state->last_subfile,
17662  state->address, state->record_line);
17663  }
17664 
17665  if (!end_sequence)
17666  {
17667  if (dwarf_record_line_p (line, state->last_line,
17669  state->last_subfile))
17670  {
17672  line, state->address,
17673  state->record_line);
17674  }
17675  state->last_subfile = current_subfile;
17676  state->last_line = line;
17677  }
17678  }
17679  }
17680 }
17681 
17682 /* Initialize STATE for the start of a line number program. */
17683 
17684 static void
17686  const lnp_reader_state *reader)
17687 {
17688  memset (state, 0, sizeof (*state));
17689 
17690  /* Just starting, there is no "last file". */
17691  state->last_file = 0;
17692  state->last_subfile = NULL;
17693 
17694  state->record_line = record_line;
17695 
17696  state->last_line = 0;
17698 
17699  /* Initialize these according to the DWARF spec. */
17700  state->op_index = 0;
17701  state->file = 1;
17702  state->line = 1;
17703  /* Call `gdbarch_adjust_dwarf2_line' on the initial 0 address as if there
17704  was a line entry for it so that the backend has a chance to adjust it
17705  and also record it in case it needs it. This is currently used by MIPS
17706  code, cf. `mips_adjust_dwarf2_line'. */
17707  state->address = gdbarch_adjust_dwarf2_line (reader->gdbarch, 0, 0);
17708  state->is_stmt = reader->line_header->default_is_stmt;
17709  state->discriminator = 0;
17710 }
17711 
17712 /* Check address and if invalid nop-out the rest of the lines in this
17713  sequence. */
17714 
17715 static void
17717  const gdb_byte *line_ptr,
17718  CORE_ADDR lowpc, CORE_ADDR address)
17719 {
17720  /* If address < lowpc then it's not a usable value, it's outside the
17721  pc range of the CU. However, we restrict the test to only address
17722  values of zero to preserve GDB's previous behaviour which is to
17723  handle the specific case of a function being GC'd by the linker. */
17724 
17725  if (address == 0 && address < lowpc)
17726  {
17727  /* This line table is for a function which has been
17728  GCd by the linker. Ignore it. PR gdb/12528 */
17729 
17730  struct objfile *objfile = cu->objfile;
17731  long line_offset = line_ptr - get_debug_line_section (cu)->buffer;
17732 
17734  _(".debug_line address at offset 0x%lx is 0 [in module %s]"),
17735  line_offset, objfile_name (objfile));
17736  state->record_line = noop_record_line;
17737  /* Note: sm.record_line is left as noop_record_line
17738  until we see DW_LNE_end_sequence. */
17739  }
17740 }
17741 
17742 /* Subroutine of dwarf_decode_lines to simplify it.
17743  Process the line number information in LH.
17744  If DECODE_FOR_PST_P is non-zero, all we do is process the line number
17745  program in order to set included_p for every referenced header. */
17746 
17747 static void
17749  const int decode_for_pst_p, CORE_ADDR lowpc)
17750 {
17751  const gdb_byte *line_ptr, *extended_end;
17752  const gdb_byte *line_end;
17753  unsigned int bytes_read, extended_len;
17754  unsigned char op_code, extended_op;
17755  CORE_ADDR baseaddr;
17756  struct objfile *objfile = cu->objfile;
17757  bfd *abfd = objfile->obfd;
17758  struct gdbarch *gdbarch = get_objfile_arch (objfile);
17759  /* Non-zero if we're recording line info (as opposed to building partial
17760  symtabs). */
17761  int record_lines_p = !decode_for_pst_p;
17762  /* A collection of things we need to pass to dwarf_record_line. */
17763  lnp_reader_state reader_state;
17764 
17765  baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
17766 
17767  line_ptr = lh->statement_program_start;
17768  line_end = lh->statement_program_end;
17769 
17770  reader_state.gdbarch = gdbarch;
17771  reader_state.line_header = lh;
17772  reader_state.record_lines_p = record_lines_p;
17773 
17774  /* Read the statement sequences until there's nothing left. */
17775  while (line_ptr < line_end)
17776  {
17777  /* The DWARF line number program state machine. */
17778  lnp_state_machine state_machine;
17779  int end_sequence = 0;
17780 
17781  /* Reset the state machine at the start of each sequence. */
17782  init_lnp_state_machine (&state_machine, &reader_state);
17783 
17784  if (record_lines_p && lh->num_file_names >= state_machine.file)
17785  {
17786  /* Start a subfile for the current file of the state machine. */
17787  /* lh->include_dirs and lh->file_names are 0-based, but the
17788  directory and file name numbers in the statement program
17789  are 1-based. */
17790  struct file_entry *fe = &lh->file_names[state_machine.file - 1];
17791  const char *dir = NULL;
17792 
17793  if (fe->dir_index && lh->include_dirs != NULL)
17794  dir = lh->include_dirs[fe->dir_index - 1];
17795 
17796  dwarf2_start_subfile (fe->name, dir);
17797  }
17798 
17799  /* Decode the table. */
17800  while (line_ptr < line_end && !end_sequence)
17801  {
17802  op_code = read_1_byte (abfd, line_ptr);
17803  line_ptr += 1;
17804 
17805  if (op_code >= lh->opcode_base)
17806  {
17807  /* Special opcode. */
17808  unsigned char adj_opcode;
17809  CORE_ADDR addr_adj;
17810  int line_delta;
17811 
17812  adj_opcode = op_code - lh->opcode_base;
17813  addr_adj = (((state_machine.op_index
17814  + (adj_opcode / lh->line_range))
17817  state_machine.address
17818  += gdbarch_adjust_dwarf2_line (gdbarch, addr_adj, 1);
17819  state_machine.op_index = ((state_machine.op_index
17820  + (adj_opcode / lh->line_range))
17822  line_delta = lh->line_base + (adj_opcode % lh->line_range);
17823  state_machine.line += line_delta;
17824  if (line_delta != 0)
17825  state_machine.line_has_non_zero_discriminator
17826  = state_machine.discriminator != 0;
17827 
17828  dwarf_record_line (&reader_state, &state_machine, 0);
17829  state_machine.discriminator = 0;
17830  }
17831  else switch (op_code)
17832  {
17833  case DW_LNS_extended_op:
17834  extended_len = read_unsigned_leb128 (abfd, line_ptr,
17835  &bytes_read);
17836  line_ptr += bytes_read;
17837  extended_end = line_ptr + extended_len;
17838  extended_op = read_1_byte (abfd, line_ptr);
17839  line_ptr += 1;
17840  switch (extended_op)
17841  {
17842  case DW_LNE_end_sequence:
17843  state_machine.record_line = record_line;
17844  end_sequence = 1;
17845  break;
17846  case DW_LNE_set_address:
17847  {
17848  CORE_ADDR address
17849  = read_address (abfd, line_ptr, cu, &bytes_read);
17850 
17851  line_ptr += bytes_read;
17852  check_line_address (cu, &state_machine, line_ptr,
17853  lowpc, address);
17854  state_machine.op_index = 0;
17855  address += baseaddr;
17856  state_machine.address
17857  = gdbarch_adjust_dwarf2_line (gdbarch, address, 0);
17858  }
17859  break;
17860  case DW_LNE_define_file:
17861  {
17862  const char *cur_file;
17863  unsigned int dir_index, mod_time, length;
17864 
17865  cur_file = read_direct_string (abfd, line_ptr,
17866  &bytes_read);
17867  line_ptr += bytes_read;
17868  dir_index =
17869  read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17870  line_ptr += bytes_read;
17871  mod_time =
17872  read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17873  line_ptr += bytes_read;
17874  length =
17875  read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17876  line_ptr += bytes_read;
17877  add_file_name (lh, cur_file, dir_index, mod_time, length);
17878  }
17879  break;
17880  case DW_LNE_set_discriminator:
17881  /* The discriminator is not interesting to the debugger;
17882  just ignore it. We still need to check its value though:
17883  if there are consecutive entries for the same
17884  (non-prologue) line we want to coalesce them.
17885  PR 17276. */
17886  state_machine.discriminator
17887  = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17888  state_machine.line_has_non_zero_discriminator
17889  |= state_machine.discriminator != 0;
17890  line_ptr += bytes_read;
17891  break;
17892  default:
17894  _("mangled .debug_line section"));
17895  return;
17896  }
17897  /* Make sure that we parsed the extended op correctly. If e.g.
17898  we expected a different address size than the producer used,
17899  we may have read the wrong number of bytes. */
17900  if (line_ptr != extended_end)
17901  {
17903  _("mangled .debug_line section"));
17904  return;
17905  }
17906  break;
17907  case DW_LNS_copy:
17908  dwarf_record_line (&reader_state, &state_machine, 0);
17909  state_machine.discriminator = 0;
17910  break;
17911  case DW_LNS_advance_pc:
17912  {
17913  CORE_ADDR adjust
17914  = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17915  CORE_ADDR addr_adj;
17916 
17917  addr_adj = (((state_machine.op_index + adjust)
17920  state_machine.address
17921  += gdbarch_adjust_dwarf2_line (gdbarch, addr_adj, 1);
17922  state_machine.op_index = ((state_machine.op_index + adjust)
17924  line_ptr += bytes_read;
17925  }
17926  break;
17927  case DW_LNS_advance_line:
17928  {
17929  int line_delta
17930  = read_signed_leb128 (abfd, line_ptr, &bytes_read);
17931 
17932  state_machine.line += line_delta;
17933  if (line_delta != 0)
17934  state_machine.line_has_non_zero_discriminator
17935  = state_machine.discriminator != 0;
17936  line_ptr += bytes_read;
17937  }
17938  break;
17939  case DW_LNS_set_file:
17940  {
17941  /* The arrays lh->include_dirs and lh->file_names are
17942  0-based, but the directory and file name numbers in
17943  the statement program are 1-based. */
17944  struct file_entry *fe;
17945  const char *dir = NULL;
17946 
17947  state_machine.file = read_unsigned_leb128 (abfd, line_ptr,
17948  &bytes_read);
17949  line_ptr += bytes_read;
17950  if (state_machine.file == 0
17951  || state_machine.file - 1 >= lh->num_file_names)
17953  else
17954  {
17955  fe = &lh->file_names[state_machine.file - 1];
17956  if (fe->dir_index && lh->include_dirs != NULL)
17957  dir = lh->include_dirs[fe->dir_index - 1];
17958  if (record_lines_p)
17959  {
17960  state_machine.last_subfile = current_subfile;
17961  state_machine.line_has_non_zero_discriminator
17962  = state_machine.discriminator != 0;
17963  dwarf2_start_subfile (fe->name, dir);
17964  }
17965  }
17966  }
17967  break;
17968  case DW_LNS_set_column:
17969  (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17970  line_ptr += bytes_read;
17971  break;
17972  case DW_LNS_negate_stmt:
17973  state_machine.is_stmt = (!state_machine.is_stmt);
17974  break;
17975  case DW_LNS_set_basic_block:
17976  break;
17977  /* Add to the address register of the state machine the
17978  address increment value corresponding to special opcode
17979  255. I.e., this value is scaled by the minimum
17980  instruction length since special opcode 255 would have
17981  scaled the increment. */
17982  case DW_LNS_const_add_pc:
17983  {
17984  CORE_ADDR adjust = (255 - lh->opcode_base) / lh->line_range;
17985  CORE_ADDR addr_adj;
17986 
17987  addr_adj = (((state_machine.op_index + adjust)
17990  state_machine.address
17991  += gdbarch_adjust_dwarf2_line (gdbarch, addr_adj, 1);
17992  state_machine.op_index = ((state_machine.op_index + adjust)
17994  }
17995  break;
17996  case DW_LNS_fixed_advance_pc:
17997  {
17998  CORE_ADDR addr_adj;
17999 
18000  addr_adj = read_2_bytes (abfd, line_ptr);
18001  state_machine.address
18002  += gdbarch_adjust_dwarf2_line (gdbarch, addr_adj, 1);
18003  state_machine.op_index = 0;
18004  line_ptr += 2;
18005  }
18006  break;
18007  default:
18008  {
18009  /* Unknown standard opcode, ignore it. */
18010  int i;
18011 
18012  for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
18013  {
18014  (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
18015  line_ptr += bytes_read;
18016  }
18017  }
18018  }
18019  }
18020 
18021  if (!end_sequence)
18023 
18024  /* We got a DW_LNE_end_sequence (or we ran off the end of the buffer,
18025  in which case we still finish recording the last line). */
18026  dwarf_record_line (&reader_state, &state_machine, 1);
18027  }
18028 }
18029 
18030 /* Decode the Line Number Program (LNP) for the given line_header
18031  structure and CU. The actual information extracted and the type
18032  of structures created from the LNP depends on the value of PST.
18033 
18034  1. If PST is NULL, then this procedure uses the data from the program
18035  to create all necessary symbol tables, and their linetables.
18036 
18037  2. If PST is not NULL, this procedure reads the program to determine
18038  the list of files included by the unit represented by PST, and
18039  builds all the associated partial symbol tables.
18040 
18041  COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
18042  It is used for relative paths in the line table.
18043  NOTE: When processing partial symtabs (pst != NULL),
18044  comp_dir == pst->dirname.
18045 
18046  NOTE: It is important that psymtabs have the same file name (via strcmp)
18047  as the corresponding symtab. Since COMP_DIR is not used in the name of the
18048  symtab we don't use it in the name of the psymtabs we create.
18049  E.g. expand_line_sal requires this when finding psymtabs to expand.
18050  A good testcase for this is mb-inline.exp.
18051 
18052  LOWPC is the lowest address in CU (or 0 if not known).
18053 
18054  Boolean DECODE_MAPPING specifies we need to fully decode .debug_line
18055  for its PC<->lines mapping information. Otherwise only the filename
18056  table is read in. */
18057 
18058 static void
18059 dwarf_decode_lines (struct line_header *lh, const char *comp_dir,
18060  struct dwarf2_cu *cu, struct partial_symtab *pst,
18061  CORE_ADDR lowpc, int decode_mapping)
18062 {
18063  struct objfile *objfile = cu->objfile;
18064  const int decode_for_pst_p = (pst != NULL);
18065 
18066  if (decode_mapping)
18067  dwarf_decode_lines_1 (lh, cu, decode_for_pst_p, lowpc);
18068 
18069  if (decode_for_pst_p)
18070  {
18071  int file_index;
18072 
18073  /* Now that we're done scanning the Line Header Program, we can
18074  create the psymtab of each included file. */
18075  for (file_index = 0; file_index < lh->num_file_names; file_index++)
18076  if (lh->file_names[file_index].included_p == 1)
18077  {
18078  const char *include_name =
18079  psymtab_include_file_name (lh, file_index, pst, comp_dir);
18080  if (include_name != NULL)
18081  dwarf2_create_include_psymtab (include_name, pst, objfile);
18082  }
18083  }
18084  else
18085  {
18086  /* Make sure a symtab is created for every file, even files
18087  which contain only variables (i.e. no code with associated
18088  line numbers). */
18089  struct compunit_symtab *cust = buildsym_compunit_symtab ();
18090  int i;
18091 
18092  for (i = 0; i < lh->num_file_names; i++)
18093  {
18094  const char *dir = NULL;
18095  struct file_entry *fe;
18096 
18097  fe = &lh->file_names[i];
18098  if (fe->dir_index && lh->include_dirs != NULL)
18099  dir = lh->include_dirs[fe->dir_index - 1];
18100  dwarf2_start_subfile (fe->name, dir);
18101 
18102  if (current_subfile->symtab == NULL)
18103  {
18106  }
18107  fe->symtab = current_subfile->symtab;
18108  }
18109  }
18110 }
18111 
18112 /* Start a subfile for DWARF. FILENAME is the name of the file and
18113  DIRNAME the name of the source directory which contains FILENAME
18114  or NULL if not known.
18115  This routine tries to keep line numbers from identical absolute and
18116  relative file names in a common subfile.
18117 
18118  Using the `list' example from the GDB testsuite, which resides in
18119  /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
18120  of /srcdir/list0.c yields the following debugging information for list0.c:
18121 
18122  DW_AT_name: /srcdir/list0.c
18123  DW_AT_comp_dir: /compdir
18124  files.files[0].name: list0.h
18125  files.files[0].dir: /srcdir
18126  files.files[1].name: list0.c
18127  files.files[1].dir: /srcdir
18128 
18129  The line number information for list0.c has to end up in a single
18130  subfile, so that `break /srcdir/list0.c:1' works as expected.
18131  start_subfile will ensure that this happens provided that we pass the
18132  concatenation of files.files[1].dir and files.files[1].name as the
18133  subfile's name. */
18134 
18135 static void
18136 dwarf2_start_subfile (const char *filename, const char *dirname)
18137 {
18138  char *copy = NULL;
18139 
18140  /* In order not to lose the line information directory,
18141  we concatenate it to the filename when it makes sense.
18142  Note that the Dwarf3 standard says (speaking of filenames in line
18143  information): ``The directory index is ignored for file names
18144  that represent full path names''. Thus ignoring dirname in the
18145  `else' branch below isn't an issue. */
18146 
18147  if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
18148  {
18149  copy = concat (dirname, SLASH_STRING, filename, (char *)NULL);
18150  filename = copy;
18151  }
18152 
18153  start_subfile (filename);
18154 
18155  if (copy != NULL)
18156  xfree (copy);
18157 }
18158 
18159 /* Start a symtab for DWARF.
18160  NAME, COMP_DIR, LOW_PC are passed to start_symtab. */
18161 
18162 static struct compunit_symtab *
18164  const char *name, const char *comp_dir, CORE_ADDR low_pc)
18165 {
18166  struct compunit_symtab *cust
18167  = start_symtab (cu->objfile, name, comp_dir, low_pc);
18168 
18169  record_debugformat ("DWARF 2");
18170  record_producer (cu->producer);
18171 
18172  /* We assume that we're processing GCC output. */
18174 
18175  cu->processing_has_namespace_info = 0;
18176 
18177  return cust;
18178 }
18179 
18180 static void
18181 var_decode_location (struct attribute *attr, struct symbol *sym,
18182  struct dwarf2_cu *cu)
18183 {
18184  struct objfile *objfile = cu->objfile;
18185  struct comp_unit_head *cu_header = &cu->header;
18186 
18187  /* NOTE drow/2003-01-30: There used to be a comment and some special
18188  code here to turn a symbol with DW_AT_external and a
18189  SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
18190  necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
18191  with some versions of binutils) where shared libraries could have
18192  relocations against symbols in their debug information - the
18193  minimal symbol would have the right address, but the debug info
18194  would not. It's no longer necessary, because we will explicitly
18195  apply relocations when we read in the debug information now. */
18196 
18197  /* A DW_AT_location attribute with no contents indicates that a
18198  variable has been optimized away. */
18199  if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
18200  {
18202  return;
18203  }
18204 
18205  /* Handle one degenerate form of location expression specially, to
18206  preserve GDB's previous behavior when section offsets are
18207  specified. If this is just a DW_OP_addr or DW_OP_GNU_addr_index
18208  then mark this symbol as LOC_STATIC. */
18209 
18210  if (attr_form_is_block (attr)
18211  && ((DW_BLOCK (attr)->data[0] == DW_OP_addr
18212  && DW_BLOCK (attr)->size == 1 + cu_header->addr_size)
18213  || (DW_BLOCK (attr)->data[0] == DW_OP_GNU_addr_index
18214  && (DW_BLOCK (attr)->size
18215  == 1 + leb128_size (&DW_BLOCK (attr)->data[1])))))
18216  {
18217  unsigned int dummy;
18218 
18219  if (DW_BLOCK (attr)->data[0] == DW_OP_addr)
18220  SYMBOL_VALUE_ADDRESS (sym) =
18221  read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
18222  else
18223  SYMBOL_VALUE_ADDRESS (sym) =
18224  read_addr_index_from_leb128 (cu, DW_BLOCK (attr)->data + 1, &dummy);
18226  fixup_symbol_section (sym, objfile);
18227  SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
18228  SYMBOL_SECTION (sym));
18229  return;
18230  }
18231 
18232  /* NOTE drow/2002-01-30: It might be worthwhile to have a static
18233  expression evaluator, and use LOC_COMPUTED only when necessary
18234  (i.e. when the value of a register or memory location is
18235  referenced, or a thread-local block, etc.). Then again, it might
18236  not be worthwhile. I'm assuming that it isn't unless performance
18237  or memory numbers show me otherwise. */
18238 
18239  dwarf2_symbol_mark_computed (attr, sym, cu, 0);
18240 
18241  if (SYMBOL_COMPUTED_OPS (sym)->location_has_loclist)
18242  cu->has_loclist = 1;
18243 }
18244 
18245 /* Given a pointer to a DWARF information entry, figure out if we need
18246  to make a symbol table entry for it, and if so, create a new entry
18247  and return a pointer to it.
18248  If TYPE is NULL, determine symbol type from the die, otherwise
18249  used the passed type.
18250  If SPACE is not NULL, use it to hold the new symbol. If it is
18251  NULL, allocate a new symbol on the objfile's obstack. */
18252 
18253 static struct symbol *
18254 new_symbol_full (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
18255  struct symbol *space)
18256 {
18257  struct objfile *objfile = cu->objfile;
18258  struct gdbarch *gdbarch = get_objfile_arch (objfile);
18259  struct symbol *sym = NULL;
18260  const char *name;
18261  struct attribute *attr = NULL;
18262  struct attribute *attr2 = NULL;
18263  CORE_ADDR baseaddr;
18264  struct pending **list_to_add = NULL;
18265 
18266  int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
18267 
18268  baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
18269 
18270  name = dwarf2_name (die, cu);
18271  if (name)
18272  {
18273  const char *linkagename;
18274  int suppress_add = 0;
18275 
18276  if (space)
18277  sym = space;
18278  else
18279  sym = allocate_symbol (objfile);
18280  OBJSTAT (objfile, n_syms++);
18281 
18282  /* Cache this symbol's name and the name's demangled form (if any). */
18283  SYMBOL_SET_LANGUAGE (sym, cu->language, &objfile->objfile_obstack);
18284  linkagename = dwarf2_physname (name, die, cu);
18285  SYMBOL_SET_NAMES (sym, linkagename, strlen (linkagename), 0, objfile);
18286 
18287  /* Fortran does not have mangling standard and the mangling does differ
18288  between gfortran, iFort etc. */
18289  if (cu->language == language_fortran
18290  && symbol_get_demangled_name (&(sym->ginfo)) == NULL)
18292  dwarf2_full_name (name, die, cu),
18293  NULL);
18294 
18295  /* Default assumptions.
18296  Use the passed type or decode it from the die. */
18297  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
18299  if (type != NULL)
18300  SYMBOL_TYPE (sym) = type;
18301  else
18302  SYMBOL_TYPE (sym) = die_type (die, cu);
18303  attr = dwarf2_attr (die,
18304  inlined_func ? DW_AT_call_line : DW_AT_decl_line,
18305  cu);
18306  if (attr)
18307  {
18308  SYMBOL_LINE (sym) = DW_UNSND (attr);
18309  }
18310 
18311  attr = dwarf2_attr (die,
18312  inlined_func ? DW_AT_call_file : DW_AT_decl_file,
18313  cu);
18314  if (attr)
18315  {
18316  int file_index = DW_UNSND (attr);
18317 
18318  if (cu->line_header == NULL
18319  || file_index > cu->line_header->num_file_names)
18321  _("file index out of range"));
18322  else if (file_index > 0)
18323  {
18324  struct file_entry *fe;
18325 
18326  fe = &cu->line_header->file_names[file_index - 1];
18327  symbol_set_symtab (sym, fe->symtab);
18328  }
18329  }
18330 
18331  switch (die->tag)
18332  {
18333  case DW_TAG_label:
18334  attr = dwarf2_attr (die, DW_AT_low_pc, cu);
18335  if (attr)
18336  {
18337  CORE_ADDR addr;
18338 
18339  addr = attr_value_as_address (attr);
18340  addr = gdbarch_adjust_dwarf2_addr (gdbarch, addr + baseaddr);
18341  SYMBOL_VALUE_ADDRESS (sym) = addr;
18342  }
18343  SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_core_addr;
18344  SYMBOL_DOMAIN (sym) = LABEL_DOMAIN;
18346  add_symbol_to_list (sym, cu->list_in_scope);
18347  break;
18348  case DW_TAG_subprogram:
18349  /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
18350  finish_block. */
18352  attr2 = dwarf2_attr (die, DW_AT_external, cu);
18353  if ((attr2 && (DW_UNSND (attr2) != 0))
18354  || cu->language == language_ada)
18355  {
18356  /* Subprograms marked external are stored as a global symbol.
18357  Ada subprograms, whether marked external or not, are always
18358  stored as a global symbol, because we want to be able to
18359  access them globally. For instance, we want to be able
18360  to break on a nested subprogram without having to
18361  specify the context. */
18362  list_to_add = &global_symbols;
18363  }
18364  else
18365  {
18366  list_to_add = cu->list_in_scope;
18367  }
18368  break;
18369  case DW_TAG_inlined_subroutine:
18370  /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
18371  finish_block. */
18373  SYMBOL_INLINED (sym) = 1;
18374  list_to_add = cu->list_in_scope;
18375  break;
18376  case DW_TAG_template_value_param:
18377  suppress_add = 1;
18378  /* Fall through. */
18379  case DW_TAG_constant:
18380  case DW_TAG_variable:
18381  case DW_TAG_member:
18382  /* Compilation with minimal debug info may result in
18383  variables with missing type entries. Change the
18384  misleading `void' type to something sensible. */
18385  if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
18386  SYMBOL_TYPE (sym)
18387  = objfile_type (objfile)->nodebug_data_symbol;
18388 
18389  attr = dwarf2_attr (die, DW_AT_const_value, cu);
18390  /* In the case of DW_TAG_member, we should only be called for
18391  static const members. */
18392  if (die->tag == DW_TAG_member)
18393  {
18394  /* dwarf2_add_field uses die_is_declaration,
18395  so we do the same. */
18396  gdb_assert (die_is_declaration (die, cu));
18397  gdb_assert (attr);
18398  }
18399  if (attr)
18400  {
18401  dwarf2_const_value (attr, sym, cu);
18402  attr2 = dwarf2_attr (die, DW_AT_external, cu);
18403  if (!suppress_add)
18404  {
18405  if (attr2 && (DW_UNSND (attr2) != 0))
18406  list_to_add = &global_symbols;
18407  else
18408  list_to_add = cu->list_in_scope;
18409  }
18410  break;
18411  }
18412  attr = dwarf2_attr (die, DW_AT_location, cu);
18413  if (attr)
18414  {
18415  var_decode_location (attr, sym, cu);
18416  attr2 = dwarf2_attr (die, DW_AT_external, cu);
18417 
18418  /* Fortran explicitly imports any global symbols to the local
18419  scope by DW_TAG_common_block. */
18420  if (cu->language == language_fortran && die->parent
18421  && die->parent->tag == DW_TAG_common_block)
18422  attr2 = NULL;
18423 
18424  if (SYMBOL_CLASS (sym) == LOC_STATIC
18425  && SYMBOL_VALUE_ADDRESS (sym) == 0
18426  && !dwarf2_per_objfile->has_section_at_zero)
18427  {
18428  /* When a static variable is eliminated by the linker,
18429  the corresponding debug information is not stripped
18430  out, but the variable address is set to null;
18431  do not add such variables into symbol table. */
18432  }
18433  else if (attr2 && (DW_UNSND (attr2) != 0))
18434  {
18435  /* Workaround gfortran PR debug/40040 - it uses
18436  DW_AT_location for variables in -fPIC libraries which may
18437  get overriden by other libraries/executable and get
18438  a different address. Resolve it by the minimal symbol
18439  which may come from inferior's executable using copy
18440  relocation. Make this workaround only for gfortran as for
18441  other compilers GDB cannot guess the minimal symbol
18442  Fortran mangling kind. */
18443  if (cu->language == language_fortran && die->parent
18444  && die->parent->tag == DW_TAG_module
18445  && cu->producer
18446  && startswith (cu->producer, "GNU Fortran "))
18448 
18449  /* A variable with DW_AT_external is never static,
18450  but it may be block-scoped. */
18451  list_to_add = (cu->list_in_scope == &file_symbols
18452  ? &global_symbols : cu->list_in_scope);
18453  }
18454  else
18455  list_to_add = cu->list_in_scope;
18456  }
18457  else
18458  {
18459  /* We do not know the address of this symbol.
18460  If it is an external symbol and we have type information
18461  for it, enter the symbol as a LOC_UNRESOLVED symbol.
18462  The address of the variable will then be determined from
18463  the minimal symbol table whenever the variable is
18464  referenced. */
18465  attr2 = dwarf2_attr (die, DW_AT_external, cu);
18466 
18467  /* Fortran explicitly imports any global symbols to the local
18468  scope by DW_TAG_common_block. */
18469  if (cu->language == language_fortran && die->parent
18470  && die->parent->tag == DW_TAG_common_block)
18471  {
18472  /* SYMBOL_CLASS doesn't matter here because
18473  read_common_block is going to reset it. */
18474  if (!suppress_add)
18475  list_to_add = cu->list_in_scope;
18476  }
18477  else if (attr2 && (DW_UNSND (attr2) != 0)
18478  && dwarf2_attr (die, DW_AT_type, cu) != NULL)
18479  {
18480  /* A variable with DW_AT_external is never static, but it
18481  may be block-scoped. */
18482  list_to_add = (cu->list_in_scope == &file_symbols
18483  ? &global_symbols : cu->list_in_scope);
18484 
18486  }
18487  else if (!die_is_declaration (die, cu))
18488  {
18489  /* Use the default LOC_OPTIMIZED_OUT class. */
18491  if (!suppress_add)
18492  list_to_add = cu->list_in_scope;
18493  }
18494  }
18495  break;
18496  case DW_TAG_formal_parameter:
18497  /* If we are inside a function, mark this as an argument. If
18498  not, we might be looking at an argument to an inlined function
18499  when we do not have enough information to show inlined frames;
18500  pretend it's a local variable in that case so that the user can
18501  still see it. */
18502  if (context_stack_depth > 0
18503  && context_stack[context_stack_depth - 1].name != NULL)
18504  SYMBOL_IS_ARGUMENT (sym) = 1;
18505  attr = dwarf2_attr (die, DW_AT_location, cu);
18506  if (attr)
18507  {
18508  var_decode_location (attr, sym, cu);
18509  }
18510  attr = dwarf2_attr (die, DW_AT_const_value, cu);
18511  if (attr)
18512  {
18513  dwarf2_const_value (attr, sym, cu);
18514  }
18515 
18516  list_to_add = cu->list_in_scope;
18517  break;
18518  case DW_TAG_unspecified_parameters:
18519  /* From varargs functions; gdb doesn't seem to have any
18520  interest in this information, so just ignore it for now.
18521  (FIXME?) */
18522  break;
18523  case DW_TAG_template_type_param:
18524  suppress_add = 1;
18525  /* Fall through. */
18526  case DW_TAG_class_type:
18527  case DW_TAG_interface_type:
18528  case DW_TAG_structure_type:
18529  case DW_TAG_union_type:
18530  case DW_TAG_set_type:
18531  case DW_TAG_enumeration_type:
18533  SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
18534 
18535  {
18536  /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
18537  really ever be static objects: otherwise, if you try
18538  to, say, break of a class's method and you're in a file
18539  which doesn't mention that class, it won't work unless
18540  the check for all static symbols in lookup_symbol_aux
18541  saves you. See the OtherFileClass tests in
18542  gdb.c++/namespace.exp. */
18543 
18544  if (!suppress_add)
18545  {
18546  list_to_add = (cu->list_in_scope == &file_symbols
18547  && (cu->language == language_cplus
18548  || cu->language == language_java)
18549  ? &global_symbols : cu->list_in_scope);
18550 
18551  /* The semantics of C++ state that "struct foo {
18552  ... }" also defines a typedef for "foo". A Java
18553  class declaration also defines a typedef for the
18554  class. */
18555  if (cu->language == language_cplus
18556  || cu->language == language_java
18557  || cu->language == language_ada)
18558  {
18559  /* The symbol's name is already allocated along
18560  with this objfile, so we don't need to
18561  duplicate it for the type. */
18562  if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
18563  TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
18564  }
18565  }
18566  }
18567  break;
18568  case DW_TAG_typedef:
18570  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
18571  list_to_add = cu->list_in_scope;
18572  break;
18573  case DW_TAG_base_type:
18574  case DW_TAG_subrange_type:
18576  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
18577  list_to_add = cu->list_in_scope;
18578  break;
18579  case DW_TAG_enumerator:
18580  attr = dwarf2_attr (die, DW_AT_const_value, cu);
18581  if (attr)
18582  {
18583  dwarf2_const_value (attr, sym, cu);
18584  }
18585  {
18586  /* NOTE: carlton/2003-11-10: See comment above in the
18587  DW_TAG_class_type, etc. block. */
18588 
18589  list_to_add = (cu->list_in_scope == &file_symbols
18590  && (cu->language == language_cplus
18591  || cu->language == language_java)
18592  ? &global_symbols : cu->list_in_scope);
18593  }
18594  break;
18595  case DW_TAG_imported_declaration:
18596  case DW_TAG_namespace:
18598  list_to_add = &global_symbols;
18599  break;
18600  case DW_TAG_module:
18602  SYMBOL_DOMAIN (sym) = MODULE_DOMAIN;
18603  list_to_add = &global_symbols;
18604  break;
18605  case DW_TAG_common_block:
18608  add_symbol_to_list (sym, cu->list_in_scope);
18609  break;
18610  default:
18611  /* Not a tag we recognize. Hopefully we aren't processing
18612  trash data, but since we must specifically ignore things
18613  we don't recognize, there is nothing else we should do at
18614  this point. */
18615  complaint (&symfile_complaints, _("unsupported tag: '%s'"),
18616  dwarf_tag_name (die->tag));
18617  break;
18618  }
18619 
18620  if (suppress_add)
18621  {
18622  sym->hash_next = objfile->template_symbols;
18623  objfile->template_symbols = sym;
18624  list_to_add = NULL;
18625  }
18626 
18627  if (list_to_add != NULL)
18628  add_symbol_to_list (sym, list_to_add);
18629 
18630  /* For the benefit of old versions of GCC, check for anonymous
18631  namespaces based on the demangled name. */
18632  if (!cu->processing_has_namespace_info
18633  && cu->language == language_cplus)
18634  cp_scan_for_anonymous_namespaces (sym, objfile);
18635  }
18636  return (sym);
18637 }
18638 
18639 /* A wrapper for new_symbol_full that always allocates a new symbol. */
18640 
18641 static struct symbol *
18642 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
18643 {
18644  return new_symbol_full (die, type, cu, NULL);
18645 }
18646 
18647 /* Given an attr with a DW_FORM_dataN value in host byte order,
18648  zero-extend it as appropriate for the symbol's type. The DWARF
18649  standard (v4) is not entirely clear about the meaning of using
18650  DW_FORM_dataN for a constant with a signed type, where the type is
18651  wider than the data. The conclusion of a discussion on the DWARF
18652  list was that this is unspecified. We choose to always zero-extend
18653  because that is the interpretation long in use by GCC. */
18654 
18655 static gdb_byte *
18656 dwarf2_const_value_data (const struct attribute *attr, struct obstack *obstack,
18657  struct dwarf2_cu *cu, LONGEST *value, int bits)
18658 {
18659  struct objfile *objfile = cu->objfile;
18660  enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ?
18661  BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
18662  LONGEST l = DW_UNSND (attr);
18663 
18664  if (bits < sizeof (*value) * 8)
18665  {
18666  l &= ((LONGEST) 1 << bits) - 1;
18667  *value = l;
18668  }
18669  else if (bits == sizeof (*value) * 8)
18670  *value = l;
18671  else
18672  {
18673  gdb_byte *bytes = obstack_alloc (obstack, bits / 8);
18674  store_unsigned_integer (bytes, bits / 8, byte_order, l);
18675  return bytes;
18676  }
18677 
18678  return NULL;
18679 }
18680 
18681 /* Read a constant value from an attribute. Either set *VALUE, or if
18682  the value does not fit in *VALUE, set *BYTES - either already
18683  allocated on the objfile obstack, or newly allocated on OBSTACK,
18684  or, set *BATON, if we translated the constant to a location
18685  expression. */
18686 
18687 static void
18688 dwarf2_const_value_attr (const struct attribute *attr, struct type *type,
18689  const char *name, struct obstack *obstack,
18690  struct dwarf2_cu *cu,
18691  LONGEST *value, const gdb_byte **bytes,
18692  struct dwarf2_locexpr_baton **baton)
18693 {
18694  struct objfile *objfile = cu->objfile;
18695  struct comp_unit_head *cu_header = &cu->header;
18696  struct dwarf_block *blk;
18697  enum bfd_endian byte_order = (bfd_big_endian (objfile->obfd) ?
18698  BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
18699 
18700  *value = 0;
18701  *bytes = NULL;
18702  *baton = NULL;
18703 
18704  switch (attr->form)
18705  {
18706  case DW_FORM_addr:
18707  case DW_FORM_GNU_addr_index:
18708  {
18709  gdb_byte *data;
18710 
18711  if (TYPE_LENGTH (type) != cu_header->addr_size)
18713  cu_header->addr_size,
18714  TYPE_LENGTH (type));
18715  /* Symbols of this form are reasonably rare, so we just
18716  piggyback on the existing location code rather than writing
18717  a new implementation of symbol_computed_ops. */
18718  *baton = obstack_alloc (obstack, sizeof (struct dwarf2_locexpr_baton));
18719  (*baton)->per_cu = cu->per_cu;
18720  gdb_assert ((*baton)->per_cu);
18721 
18722  (*baton)->size = 2 + cu_header->addr_size;
18723  data = obstack_alloc (obstack, (*baton)->size);
18724  (*baton)->data = data;
18725 
18726  data[0] = DW_OP_addr;
18727  store_unsigned_integer (&data[1], cu_header->addr_size,
18728  byte_order, DW_ADDR (attr));
18729  data[cu_header->addr_size + 1] = DW_OP_stack_value;
18730  }
18731  break;
18732  case DW_FORM_string:
18733  case DW_FORM_strp:
18734  case DW_FORM_GNU_str_index:
18735  case DW_FORM_GNU_strp_alt:
18736  /* DW_STRING is already allocated on the objfile obstack, point
18737  directly to it. */
18738  *bytes = (const gdb_byte *) DW_STRING (attr);
18739  break;
18740  case DW_FORM_block1:
18741  case DW_FORM_block2:
18742  case DW_FORM_block4:
18743  case DW_FORM_block:
18744  case DW_FORM_exprloc:
18745  blk = DW_BLOCK (attr);
18746  if (TYPE_LENGTH (type) != blk->size)
18748  TYPE_LENGTH (type));
18749  *bytes = blk->data;
18750  break;
18751 
18752  /* The DW_AT_const_value attributes are supposed to carry the
18753  symbol's value "represented as it would be on the target
18754  architecture." By the time we get here, it's already been
18755  converted to host endianness, so we just need to sign- or
18756  zero-extend it as appropriate. */
18757  case DW_FORM_data1:
18758  *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 8);
18759  break;
18760  case DW_FORM_data2:
18761  *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 16);
18762  break;
18763  case DW_FORM_data4:
18764  *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 32);
18765  break;
18766  case DW_FORM_data8:
18767  *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 64);
18768  break;
18769 
18770  case DW_FORM_sdata:
18771  *value = DW_SND (attr);
18772  break;
18773 
18774  case DW_FORM_udata:
18775  *value = DW_UNSND (attr);
18776  break;
18777 
18778  default:
18780  _("unsupported const value attribute form: '%s'"),
18781  dwarf_form_name (attr->form));
18782  *value = 0;
18783  break;
18784  }
18785 }
18786 
18787 
18788 /* Copy constant value from an attribute to a symbol. */
18789 
18790 static void
18791 dwarf2_const_value (const struct attribute *attr, struct symbol *sym,
18792  struct dwarf2_cu *cu)
18793 {
18794  struct objfile *objfile = cu->objfile;
18795  struct comp_unit_head *cu_header = &cu->header;
18796  LONGEST value;
18797  const gdb_byte *bytes;
18798  struct dwarf2_locexpr_baton *baton;
18799 
18800  dwarf2_const_value_attr (attr, SYMBOL_TYPE (sym),
18801  SYMBOL_PRINT_NAME (sym),
18802  &objfile->objfile_obstack, cu,
18803  &value, &bytes, &baton);
18804 
18805  if (baton != NULL)
18806  {
18807  SYMBOL_LOCATION_BATON (sym) = baton;
18809  }
18810  else if (bytes != NULL)
18811  {
18812  SYMBOL_VALUE_BYTES (sym) = bytes;
18814  }
18815  else
18816  {
18817  SYMBOL_VALUE (sym) = value;
18819  }
18820 }
18821 
18822 /* Return the type of the die in question using its DW_AT_type attribute. */
18823 
18824 static struct type *
18825 die_type (struct die_info *die, struct dwarf2_cu *cu)
18826 {
18827  struct attribute *type_attr;
18828 
18829  type_attr = dwarf2_attr (die, DW_AT_type, cu);
18830  if (!type_attr)
18831  {
18832  /* A missing DW_AT_type represents a void type. */
18833  return objfile_type (cu->objfile)->builtin_void;
18834  }
18835 
18836  return lookup_die_type (die, type_attr, cu);
18837 }
18838 
18839 /* True iff CU's producer generates GNAT Ada auxiliary information
18840  that allows to find parallel types through that information instead
18841  of having to do expensive parallel lookups by type name. */
18842 
18843 static int
18845 {
18846  /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
18847  of GNAT produces this auxiliary information, without any indication
18848  that it is produced. Part of enhancing the FSF version of GNAT
18849  to produce that information will be to put in place an indicator
18850  that we can use in order to determine whether the descriptive type
18851  info is available or not. One suggestion that has been made is
18852  to use a new attribute, attached to the CU die. For now, assume
18853  that the descriptive type info is not available. */
18854  return 0;
18855 }
18856 
18857 /* Return the auxiliary type of the die in question using its
18858  DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
18859  attribute is not present. */
18860 
18861 static struct type *
18862 die_descriptive_type (struct die_info *die, struct dwarf2_cu *cu)
18863 {
18864  struct attribute *type_attr;
18865 
18866  type_attr = dwarf2_attr (die, DW_AT_GNAT_descriptive_type, cu);
18867  if (!type_attr)
18868  return NULL;
18869 
18870  return lookup_die_type (die, type_attr, cu);
18871 }
18872 
18873 /* If DIE has a descriptive_type attribute, then set the TYPE's
18874  descriptive type accordingly. */
18875 
18876 static void
18877 set_descriptive_type (struct type *type, struct die_info *die,
18878  struct dwarf2_cu *cu)
18879 {
18880  struct type *descriptive_type = die_descriptive_type (die, cu);
18881 
18882  if (descriptive_type)
18883  {
18884  ALLOCATE_GNAT_AUX_TYPE (type);
18885  TYPE_DESCRIPTIVE_TYPE (type) = descriptive_type;
18886  }
18887 }
18888 
18889 /* Return the containing type of the die in question using its
18890  DW_AT_containing_type attribute. */
18891 
18892 static struct type *
18893 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
18894 {
18895  struct attribute *type_attr;
18896 
18897  type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
18898  if (!type_attr)
18899  error (_("Dwarf Error: Problem turning containing type into gdb type "
18900  "[in module %s]"), objfile_name (cu->objfile));
18901 
18902  return lookup_die_type (die, type_attr, cu);
18903 }
18904 
18905 /* Return an error marker type to use for the ill formed type in DIE/CU. */
18906 
18907 static struct type *
18908 build_error_marker_type (struct dwarf2_cu *cu, struct die_info *die)
18909 {
18910  struct objfile *objfile = dwarf2_per_objfile->objfile;
18911  char *message, *saved;
18912 
18913  message = xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
18914  objfile_name (objfile),
18915  cu->header.offset.sect_off,
18916  die->offset.sect_off);
18917  saved = obstack_copy0 (&objfile->objfile_obstack,
18918  message, strlen (message));
18919  xfree (message);
18920 
18921  return init_type (TYPE_CODE_ERROR, 0, 0, saved, objfile);
18922 }
18923 
18924 /* Look up the type of DIE in CU using its type attribute ATTR.
18925  ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
18926  DW_AT_containing_type.
18927  If there is no type substitute an error marker. */
18928 
18929 static struct type *
18930 lookup_die_type (struct die_info *die, const struct attribute *attr,
18931  struct dwarf2_cu *cu)
18932 {
18933  struct objfile *objfile = cu->objfile;
18934  struct type *this_type;
18935 
18936  gdb_assert (attr->name == DW_AT_type
18937  || attr->name == DW_AT_GNAT_descriptive_type
18938  || attr->name == DW_AT_containing_type);
18939 
18940  /* First see if we have it cached. */
18941 
18942  if (attr->form == DW_FORM_GNU_ref_alt)
18943  {
18944  struct dwarf2_per_cu_data *per_cu;
18945  sect_offset offset = dwarf2_get_ref_die_offset (attr);
18946 
18947  per_cu = dwarf2_find_containing_comp_unit (offset, 1, cu->objfile);
18948  this_type = get_die_type_at_offset (offset, per_cu);
18949  }
18950  else if (attr_form_is_ref (attr))
18951  {
18952  sect_offset offset = dwarf2_get_ref_die_offset (attr);
18953 
18954  this_type = get_die_type_at_offset (offset, cu->per_cu);
18955  }
18956  else if (attr->form == DW_FORM_ref_sig8)
18957  {
18958  ULONGEST signature = DW_SIGNATURE (attr);
18959 
18960  return get_signatured_type (die, signature, cu);
18961  }
18962  else
18963  {
18965  _("Dwarf Error: Bad type attribute %s in DIE"
18966  " at 0x%x [in module %s]"),
18967  dwarf_attr_name (attr->name), die->offset.sect_off,
18968  objfile_name (objfile));
18969  return build_error_marker_type (cu, die);
18970  }
18971 
18972  /* If not cached we need to read it in. */
18973 
18974  if (this_type == NULL)
18975  {
18976  struct die_info *type_die = NULL;
18977  struct dwarf2_cu *type_cu = cu;
18978 
18979  if (attr_form_is_ref (attr))
18980  type_die = follow_die_ref (die, attr, &type_cu);
18981  if (type_die == NULL)
18982  return build_error_marker_type (cu, die);
18983  /* If we find the type now, it's probably because the type came
18984  from an inter-CU reference and the type's CU got expanded before
18985  ours. */
18986  this_type = read_type_die (type_die, type_cu);
18987  }
18988 
18989  /* If we still don't have a type use an error marker. */
18990 
18991  if (this_type == NULL)
18992  return build_error_marker_type (cu, die);
18993 
18994  return this_type;
18995 }
18996 
18997 /* Return the type in DIE, CU.
18998  Returns NULL for invalid types.
18999 
19000  This first does a lookup in die_type_hash,
19001  and only reads the die in if necessary.
19002 
19003  NOTE: This can be called when reading in partial or full symbols. */
19004 
19005 static struct type *
19006 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
19007 {
19008  struct type *this_type;
19009 
19010  this_type = get_die_type (die, cu);
19011  if (this_type)
19012  return this_type;
19013 
19014  return read_type_die_1 (die, cu);
19015 }
19016 
19017 /* Read the type in DIE, CU.
19018  Returns NULL for invalid types. */
19019 
19020 static struct type *
19021 read_type_die_1 (struct die_info *die, struct dwarf2_cu *cu)
19022 {
19023  struct type *this_type = NULL;
19024 
19025  switch (die->tag)
19026  {
19027  case DW_TAG_class_type:
19028  case DW_TAG_interface_type:
19029  case DW_TAG_structure_type:
19030  case DW_TAG_union_type:
19031  this_type = read_structure_type (die, cu);
19032  break;
19033  case DW_TAG_enumeration_type:
19034  this_type = read_enumeration_type (die, cu);
19035  break;
19036  case DW_TAG_subprogram:
19037  case DW_TAG_subroutine_type:
19038  case DW_TAG_inlined_subroutine:
19039  this_type = read_subroutine_type (die, cu);
19040  break;
19041  case DW_TAG_array_type:
19042  this_type = read_array_type (die, cu);
19043  break;
19044  case DW_TAG_set_type:
19045  this_type = read_set_type (die, cu);
19046  break;
19047  case DW_TAG_pointer_type:
19048  this_type = read_tag_pointer_type (die, cu);
19049  break;
19050  case DW_TAG_ptr_to_member_type:
19051  this_type = read_tag_ptr_to_member_type (die, cu);
19052  break;
19053  case DW_TAG_reference_type:
19054  this_type = read_tag_reference_type (die, cu);
19055  break;
19056  case DW_TAG_const_type:
19057  this_type = read_tag_const_type (die, cu);
19058  break;
19059  case DW_TAG_volatile_type:
19060  this_type = read_tag_volatile_type (die, cu);
19061  break;
19062  case DW_TAG_restrict_type:
19063  this_type = read_tag_restrict_type (die, cu);
19064  break;
19065  case DW_TAG_string_type:
19066  this_type = read_tag_string_type (die, cu);
19067  break;
19068  case DW_TAG_typedef:
19069  this_type = read_typedef (die, cu);
19070  break;
19071  case DW_TAG_subrange_type:
19072  this_type = read_subrange_type (die, cu);
19073  break;
19074  case DW_TAG_base_type:
19075  this_type = read_base_type (die, cu);
19076  break;
19077  case DW_TAG_unspecified_type:
19078  this_type = read_unspecified_type (die, cu);
19079  break;
19080  case DW_TAG_namespace:
19081  this_type = read_namespace_type (die, cu);
19082  break;
19083  case DW_TAG_module:
19084  this_type = read_module_type (die, cu);
19085  break;
19086  case DW_TAG_atomic_type:
19087  this_type = read_tag_atomic_type (die, cu);
19088  break;
19089  default:
19091  _("unexpected tag in read_type_die: '%s'"),
19092  dwarf_tag_name (die->tag));
19093  break;
19094  }
19095 
19096  return this_type;
19097 }
19098 
19099 /* See if we can figure out if the class lives in a namespace. We do
19100  this by looking for a member function; its demangled name will
19101  contain namespace info, if there is any.
19102  Return the computed name or NULL.
19103  Space for the result is allocated on the objfile's obstack.
19104  This is the full-die version of guess_partial_die_structure_name.
19105  In this case we know DIE has no useful parent. */
19106 
19107 static char *
19109 {
19110  struct die_info *spec_die;
19111  struct dwarf2_cu *spec_cu;
19112  struct die_info *child;
19113 
19114  spec_cu = cu;
19115  spec_die = die_specification (die, &spec_cu);
19116  if (spec_die != NULL)
19117  {
19118  die = spec_die;
19119  cu = spec_cu;
19120  }
19121 
19122  for (child = die->child;
19123  child != NULL;
19124  child = child->sibling)
19125  {
19126  if (child->tag == DW_TAG_subprogram)
19127  {
19128  struct attribute *attr;
19129 
19130  attr = dwarf2_attr (child, DW_AT_linkage_name, cu);
19131  if (attr == NULL)
19132  attr = dwarf2_attr (child, DW_AT_MIPS_linkage_name, cu);
19133  if (attr != NULL)
19134  {
19135  char *actual_name
19137  DW_STRING (attr));
19138  char *name = NULL;
19139 
19140  if (actual_name != NULL)
19141  {
19142  const char *die_name = dwarf2_name (die, cu);
19143 
19144  if (die_name != NULL
19145  && strcmp (die_name, actual_name) != 0)
19146  {
19147  /* Strip off the class name from the full name.
19148  We want the prefix. */
19149  int die_name_len = strlen (die_name);
19150  int actual_name_len = strlen (actual_name);
19151 
19152  /* Test for '::' as a sanity check. */
19153  if (actual_name_len > die_name_len + 2
19154  && actual_name[actual_name_len
19155  - die_name_len - 1] == ':')
19156  name =
19157  obstack_copy0 (&cu->objfile->per_bfd->storage_obstack,
19158  actual_name,
19159  actual_name_len - die_name_len - 2);
19160  }
19161  }
19162  xfree (actual_name);
19163  return name;
19164  }
19165  }
19166  }
19167 
19168  return NULL;
19169 }
19170 
19171 /* GCC might emit a nameless typedef that has a linkage name. Determine the
19172  prefix part in such case. See
19173  http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19174 
19175 static char *
19176 anonymous_struct_prefix (struct die_info *die, struct dwarf2_cu *cu)
19177 {
19178  struct attribute *attr;
19179  char *base;
19180 
19181  if (die->tag != DW_TAG_class_type && die->tag != DW_TAG_interface_type
19182  && die->tag != DW_TAG_structure_type && die->tag != DW_TAG_union_type)
19183  return NULL;
19184 
19185  attr = dwarf2_attr (die, DW_AT_name, cu);
19186  if (attr != NULL && DW_STRING (attr) != NULL)
19187  return NULL;
19188 
19189  attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
19190  if (attr == NULL)
19191  attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
19192  if (attr == NULL || DW_STRING (attr) == NULL)
19193  return NULL;
19194 
19195  /* dwarf2_name had to be already called. */
19197 
19198  /* Strip the base name, keep any leading namespaces/classes. */
19199  base = strrchr (DW_STRING (attr), ':');
19200  if (base == NULL || base == DW_STRING (attr) || base[-1] != ':')
19201  return "";
19202 
19203  return obstack_copy0 (&cu->objfile->per_bfd->storage_obstack,
19204  DW_STRING (attr), &base[-1] - DW_STRING (attr));
19205 }
19206 
19207 /* Return the name of the namespace/class that DIE is defined within,
19208  or "" if we can't tell. The caller should not xfree the result.
19209 
19210  For example, if we're within the method foo() in the following
19211  code:
19212 
19213  namespace N {
19214  class C {
19215  void foo () {
19216  }
19217  };
19218  }
19219 
19220  then determine_prefix on foo's die will return "N::C". */
19221 
19222 static const char *
19223 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
19224 {
19225  struct die_info *parent, *spec_die;
19226  struct dwarf2_cu *spec_cu;
19227  struct type *parent_type;
19228  char *retval;
19229 
19230  if (cu->language != language_cplus && cu->language != language_java
19231  && cu->language != language_fortran)
19232  return "";
19233 
19234  retval = anonymous_struct_prefix (die, cu);
19235  if (retval)
19236  return retval;
19237 
19238  /* We have to be careful in the presence of DW_AT_specification.
19239  For example, with GCC 3.4, given the code
19240 
19241  namespace N {
19242  void foo() {
19243  // Definition of N::foo.
19244  }
19245  }
19246 
19247  then we'll have a tree of DIEs like this:
19248 
19249  1: DW_TAG_compile_unit
19250  2: DW_TAG_namespace // N
19251  3: DW_TAG_subprogram // declaration of N::foo
19252  4: DW_TAG_subprogram // definition of N::foo
19253  DW_AT_specification // refers to die #3
19254 
19255  Thus, when processing die #4, we have to pretend that we're in
19256  the context of its DW_AT_specification, namely the contex of die
19257  #3. */
19258  spec_cu = cu;
19259  spec_die = die_specification (die, &spec_cu);
19260  if (spec_die == NULL)
19261  parent = die->parent;
19262  else
19263  {
19264  parent = spec_die->parent;
19265  cu = spec_cu;
19266  }
19267 
19268  if (parent == NULL)
19269  return "";
19270  else if (parent->building_fullname)
19271  {
19272  const char *name;
19273  const char *parent_name;
19274 
19275  /* It has been seen on RealView 2.2 built binaries,
19276  DW_TAG_template_type_param types actually _defined_ as
19277  children of the parent class:
19278 
19279  enum E {};
19280  template class <class Enum> Class{};
19281  Class<enum E> class_e;
19282 
19283  1: DW_TAG_class_type (Class)
19284  2: DW_TAG_enumeration_type (E)
19285  3: DW_TAG_enumerator (enum1:0)
19286  3: DW_TAG_enumerator (enum2:1)
19287  ...
19288  2: DW_TAG_template_type_param
19289  DW_AT_type DW_FORM_ref_udata (E)
19290 
19291  Besides being broken debug info, it can put GDB into an
19292  infinite loop. Consider:
19293 
19294  When we're building the full name for Class<E>, we'll start
19295  at Class, and go look over its template type parameters,
19296  finding E. We'll then try to build the full name of E, and
19297  reach here. We're now trying to build the full name of E,
19298  and look over the parent DIE for containing scope. In the
19299  broken case, if we followed the parent DIE of E, we'd again
19300  find Class, and once again go look at its template type
19301  arguments, etc., etc. Simply don't consider such parent die
19302  as source-level parent of this die (it can't be, the language
19303  doesn't allow it), and break the loop here. */
19304  name = dwarf2_name (die, cu);
19305  parent_name = dwarf2_name (parent, cu);
19307  _("template param type '%s' defined within parent '%s'"),
19308  name ? name : "<unknown>",
19309  parent_name ? parent_name : "<unknown>");
19310  return "";
19311  }
19312  else
19313  switch (parent->tag)
19314  {
19315  case DW_TAG_namespace:
19316  parent_type = read_type_die (parent, cu);
19317  /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
19318  DW_TAG_namespace DIEs with a name of "::" for the global namespace.
19319  Work around this problem here. */
19320  if (cu->language == language_cplus
19321  && strcmp (TYPE_TAG_NAME (parent_type), "::") == 0)
19322  return "";
19323  /* We give a name to even anonymous namespaces. */
19324  return TYPE_TAG_NAME (parent_type);
19325  case DW_TAG_class_type:
19326  case DW_TAG_interface_type:
19327  case DW_TAG_structure_type:
19328  case DW_TAG_union_type:
19329  case DW_TAG_module:
19330  parent_type = read_type_die (parent, cu);
19331  if (TYPE_TAG_NAME (parent_type) != NULL)
19332  return TYPE_TAG_NAME (parent_type);
19333  else
19334  /* An anonymous structure is only allowed non-static data
19335  members; no typedefs, no member functions, et cetera.
19336  So it does not need a prefix. */
19337  return "";
19338  case DW_TAG_compile_unit:
19339  case DW_TAG_partial_unit:
19340  /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
19341  if (cu->language == language_cplus
19342  && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
19343  && die->child != NULL
19344  && (die->tag == DW_TAG_class_type
19345  || die->tag == DW_TAG_structure_type
19346  || die->tag == DW_TAG_union_type))
19347  {
19348  char *name = guess_full_die_structure_name (die, cu);
19349  if (name != NULL)
19350  return name;
19351  }
19352  return "";
19353  case DW_TAG_enumeration_type:
19354  parent_type = read_type_die (parent, cu);
19355  if (TYPE_DECLARED_CLASS (parent_type))
19356  {
19357  if (TYPE_TAG_NAME (parent_type) != NULL)
19358  return TYPE_TAG_NAME (parent_type);
19359  return "";
19360  }
19361  /* Fall through. */
19362  default:
19363  return determine_prefix (parent, cu);
19364  }
19365 }
19366 
19367 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
19368  with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
19369  simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
19370  an obconcat, otherwise allocate storage for the result. The CU argument is
19371  used to determine the language and hence, the appropriate separator. */
19372 
19373 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
19374 
19375 static char *
19376 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
19377  int physname, struct dwarf2_cu *cu)
19378 {
19379  const char *lead = "";
19380  const char *sep;
19381 
19382  if (suffix == NULL || suffix[0] == '\0'
19383  || prefix == NULL || prefix[0] == '\0')
19384  sep = "";
19385  else if (cu->language == language_java)
19386  sep = ".";
19387  else if (cu->language == language_fortran && physname)
19388  {
19389  /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
19390  DW_AT_MIPS_linkage_name is preferred and used instead. */
19391 
19392  lead = "__";
19393  sep = "_MOD_";
19394  }
19395  else
19396  sep = "::";
19397 
19398  if (prefix == NULL)
19399  prefix = "";
19400  if (suffix == NULL)
19401  suffix = "";
19402 
19403  if (obs == NULL)
19404  {
19405  char *retval
19406  = xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1);
19407 
19408  strcpy (retval, lead);
19409  strcat (retval, prefix);
19410  strcat (retval, sep);
19411  strcat (retval, suffix);
19412  return retval;
19413  }
19414  else
19415  {
19416  /* We have an obstack. */
19417  return obconcat (obs, lead, prefix, sep, suffix, (char *) NULL);
19418  }
19419 }
19420 
19421 /* Return sibling of die, NULL if no sibling. */
19422 
19423 static struct die_info *
19424 sibling_die (struct die_info *die)
19425 {
19426  return die->sibling;
19427 }
19428 
19429 /* Get name of a die, return NULL if not found. */
19430 
19431 static const char *
19432 dwarf2_canonicalize_name (const char *name, struct dwarf2_cu *cu,
19433  struct obstack *obstack)
19434 {
19435  if (name && cu->language == language_cplus)
19436  {
19437  char *canon_name = cp_canonicalize_string (name);
19438 
19439  if (canon_name != NULL)
19440  {
19441  if (strcmp (canon_name, name) != 0)
19442  name = obstack_copy0 (obstack, canon_name, strlen (canon_name));
19443  xfree (canon_name);
19444  }
19445  }
19446 
19447  return name;
19448 }
19449 
19450 /* Get name of a die, return NULL if not found.
19451  Anonymous namespaces are converted to their magic string. */
19452 
19453 static const char *
19454 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
19455 {
19456  struct attribute *attr;
19457 
19458  attr = dwarf2_attr (die, DW_AT_name, cu);
19459  if ((!attr || !DW_STRING (attr))
19460  && die->tag != DW_TAG_namespace
19461  && die->tag != DW_TAG_class_type
19462  && die->tag != DW_TAG_interface_type
19463  && die->tag != DW_TAG_structure_type
19464  && die->tag != DW_TAG_union_type)
19465  return NULL;
19466 
19467  switch (die->tag)
19468  {
19469  case DW_TAG_compile_unit:
19470  case DW_TAG_partial_unit:
19471  /* Compilation units have a DW_AT_name that is a filename, not
19472  a source language identifier. */
19473  case DW_TAG_enumeration_type:
19474  case DW_TAG_enumerator:
19475  /* These tags always have simple identifiers already; no need
19476  to canonicalize them. */
19477  return DW_STRING (attr);
19478 
19479  case DW_TAG_namespace:
19480  if (attr != NULL && DW_STRING (attr) != NULL)
19481  return DW_STRING (attr);
19483 
19484  case DW_TAG_subprogram:
19485  /* Java constructors will all be named "<init>", so return
19486  the class name when we see this special case. */
19487  if (cu->language == language_java
19488  && DW_STRING (attr) != NULL
19489  && strcmp (DW_STRING (attr), "<init>") == 0)
19490  {
19491  struct dwarf2_cu *spec_cu = cu;
19492  struct die_info *spec_die;
19493 
19494  /* GCJ will output '<init>' for Java constructor names.
19495  For this special case, return the name of the parent class. */
19496 
19497  /* GCJ may output subprogram DIEs with AT_specification set.
19498  If so, use the name of the specified DIE. */
19499  spec_die = die_specification (die, &spec_cu);
19500  if (spec_die != NULL)
19501  return dwarf2_name (spec_die, spec_cu);
19502 
19503  do
19504  {
19505  die = die->parent;
19506  if (die->tag == DW_TAG_class_type)
19507  return dwarf2_name (die, cu);
19508  }
19509  while (die->tag != DW_TAG_compile_unit
19510  && die->tag != DW_TAG_partial_unit);
19511  }
19512  break;
19513 
19514  case DW_TAG_class_type:
19515  case DW_TAG_interface_type:
19516  case DW_TAG_structure_type:
19517  case DW_TAG_union_type:
19518  /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
19519  structures or unions. These were of the form "._%d" in GCC 4.1,
19520  or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
19521  and GCC 4.4. We work around this problem by ignoring these. */
19522  if (attr && DW_STRING (attr)
19523  && (startswith (DW_STRING (attr), "._")
19524  || startswith (DW_STRING (attr), "<anonymous")))
19525  return NULL;
19526 
19527  /* GCC might emit a nameless typedef that has a linkage name. See
19528  http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19529  if (!attr || DW_STRING (attr) == NULL)
19530  {
19531  char *demangled = NULL;
19532 
19533  attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
19534  if (attr == NULL)
19535  attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
19536 
19537  if (attr == NULL || DW_STRING (attr) == NULL)
19538  return NULL;
19539 
19540  /* Avoid demangling DW_STRING (attr) the second time on a second
19541  call for the same DIE. */
19542  if (!DW_STRING_IS_CANONICAL (attr))
19543  demangled = gdb_demangle (DW_STRING (attr), DMGL_TYPES);
19544 
19545  if (demangled)
19546  {
19547  char *base;
19548 
19549  /* FIXME: we already did this for the partial symbol... */
19550  DW_STRING (attr)
19551  = obstack_copy0 (&cu->objfile->per_bfd->storage_obstack,
19552  demangled, strlen (demangled));
19553  DW_STRING_IS_CANONICAL (attr) = 1;
19554  xfree (demangled);
19555 
19556  /* Strip any leading namespaces/classes, keep only the base name.
19557  DW_AT_name for named DIEs does not contain the prefixes. */
19558  base = strrchr (DW_STRING (attr), ':');
19559  if (base && base > DW_STRING (attr) && base[-1] == ':')
19560  return &base[1];
19561  else
19562  return DW_STRING (attr);
19563  }
19564  }
19565  break;
19566 
19567  default:
19568  break;
19569  }
19570 
19571  if (!DW_STRING_IS_CANONICAL (attr))
19572  {
19573  DW_STRING (attr)
19574  = dwarf2_canonicalize_name (DW_STRING (attr), cu,
19576  DW_STRING_IS_CANONICAL (attr) = 1;
19577  }
19578  return DW_STRING (attr);
19579 }
19580 
19581 /* Return the die that this die in an extension of, or NULL if there
19582  is none. *EXT_CU is the CU containing DIE on input, and the CU
19583  containing the return value on output. */
19584 
19585 static struct die_info *
19586 dwarf2_extension (struct die_info *die, struct dwarf2_cu **ext_cu)
19587 {
19588  struct attribute *attr;
19589 
19590  attr = dwarf2_attr (die, DW_AT_extension, *ext_cu);
19591  if (attr == NULL)
19592  return NULL;
19593 
19594  return follow_die_ref (die, attr, ext_cu);
19595 }
19596 
19597 /* Convert a DIE tag into its string name. */
19598 
19599 static const char *
19600 dwarf_tag_name (unsigned tag)
19601 {
19602  const char *name = get_DW_TAG_name (tag);
19603 
19604  if (name == NULL)
19605  return "DW_TAG_<unknown>";
19606 
19607  return name;
19608 }
19609 
19610 /* Convert a DWARF attribute code into its string name. */
19611 
19612 static const char *
19613 dwarf_attr_name (unsigned attr)
19614 {
19615  const char *name;
19616 
19617 #ifdef MIPS /* collides with DW_AT_HP_block_index */
19618  if (attr == DW_AT_MIPS_fde)
19619  return "DW_AT_MIPS_fde";
19620 #else
19621  if (attr == DW_AT_HP_block_index)
19622  return "DW_AT_HP_block_index";
19623 #endif
19624 
19625  name = get_DW_AT_name (attr);
19626 
19627  if (name == NULL)
19628  return "DW_AT_<unknown>";
19629 
19630  return name;
19631 }
19632 
19633 /* Convert a DWARF value form code into its string name. */
19634 
19635 static const char *
19636 dwarf_form_name (unsigned form)
19637 {
19638  const char *name = get_DW_FORM_name (form);
19639 
19640  if (name == NULL)
19641  return "DW_FORM_<unknown>";
19642 
19643  return name;
19644 }
19645 
19646 static char *
19647 dwarf_bool_name (unsigned mybool)
19648 {
19649  if (mybool)
19650  return "TRUE";
19651  else
19652  return "FALSE";
19653 }
19654 
19655 /* Convert a DWARF type code into its string name. */
19656 
19657 static const char *
19659 {
19660  const char *name = get_DW_ATE_name (enc);
19661 
19662  if (name == NULL)
19663  return "DW_ATE_<unknown>";
19664 
19665  return name;
19666 }
19667 
19668 static void
19669 dump_die_shallow (struct ui_file *f, int indent, struct die_info *die)
19670 {
19671  unsigned int i;
19672 
19673  print_spaces (indent, f);
19674  fprintf_unfiltered (f, "Die: %s (abbrev %d, offset 0x%x)\n",
19675  dwarf_tag_name (die->tag), die->abbrev, die->offset.sect_off);
19676 
19677  if (die->parent != NULL)
19678  {
19679  print_spaces (indent, f);
19680  fprintf_unfiltered (f, " parent at offset: 0x%x\n",
19681  die->parent->offset.sect_off);
19682  }
19683 
19684  print_spaces (indent, f);
19685  fprintf_unfiltered (f, " has children: %s\n",
19686  dwarf_bool_name (die->child != NULL));
19687 
19688  print_spaces (indent, f);
19689  fprintf_unfiltered (f, " attributes:\n");
19690 
19691  for (i = 0; i < die->num_attrs; ++i)
19692  {
19693  print_spaces (indent, f);
19694  fprintf_unfiltered (f, " %s (%s) ",
19695  dwarf_attr_name (die->attrs[i].name),
19696  dwarf_form_name (die->attrs[i].form));
19697 
19698  switch (die->attrs[i].form)
19699  {
19700  case DW_FORM_addr:
19701  case DW_FORM_GNU_addr_index:
19702  fprintf_unfiltered (f, "address: ");
19703  fputs_filtered (hex_string (DW_ADDR (&die->attrs[i])), f);
19704  break;
19705  case DW_FORM_block2:
19706  case DW_FORM_block4:
19707  case DW_FORM_block:
19708  case DW_FORM_block1:
19709  fprintf_unfiltered (f, "block: size %s",
19710  pulongest (DW_BLOCK (&die->attrs[i])->size));
19711  break;
19712  case DW_FORM_exprloc:
19713  fprintf_unfiltered (f, "expression: size %s",
19714  pulongest (DW_BLOCK (&die->attrs[i])->size));
19715  break;
19716  case DW_FORM_ref_addr:
19717  fprintf_unfiltered (f, "ref address: ");
19718  fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
19719  break;
19720  case DW_FORM_GNU_ref_alt:
19721  fprintf_unfiltered (f, "alt ref address: ");
19722  fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
19723  break;
19724  case DW_FORM_ref1:
19725  case DW_FORM_ref2:
19726  case DW_FORM_ref4:
19727  case DW_FORM_ref8:
19728  case DW_FORM_ref_udata:
19729  fprintf_unfiltered (f, "constant ref: 0x%lx (adjusted)",
19730  (long) (DW_UNSND (&die->attrs[i])));
19731  break;
19732  case DW_FORM_data1:
19733  case DW_FORM_data2:
19734  case DW_FORM_data4:
19735  case DW_FORM_data8:
19736  case DW_FORM_udata:
19737  case DW_FORM_sdata:
19738  fprintf_unfiltered (f, "constant: %s",
19739  pulongest (DW_UNSND (&die->attrs[i])));
19740  break;
19741  case DW_FORM_sec_offset:
19742  fprintf_unfiltered (f, "section offset: %s",
19743  pulongest (DW_UNSND (&die->attrs[i])));
19744  break;
19745  case DW_FORM_ref_sig8:
19746  fprintf_unfiltered (f, "signature: %s",
19747  hex_string (DW_SIGNATURE (&die->attrs[i])));
19748  break;
19749  case DW_FORM_string:
19750  case DW_FORM_strp:
19751  case DW_FORM_GNU_str_index:
19752  case DW_FORM_GNU_strp_alt:
19753  fprintf_unfiltered (f, "string: \"%s\" (%s canonicalized)",
19754  DW_STRING (&die->attrs[i])
19755  ? DW_STRING (&die->attrs[i]) : "",
19756  DW_STRING_IS_CANONICAL (&die->attrs[i]) ? "is" : "not");
19757  break;
19758  case DW_FORM_flag:
19759  if (DW_UNSND (&die->attrs[i]))
19760  fprintf_unfiltered (f, "flag: TRUE");
19761  else
19762  fprintf_unfiltered (f, "flag: FALSE");
19763  break;
19764  case DW_FORM_flag_present:
19765  fprintf_unfiltered (f, "flag: TRUE");
19766  break;
19767  case DW_FORM_indirect:
19768  /* The reader will have reduced the indirect form to
19769  the "base form" so this form should not occur. */
19770  fprintf_unfiltered (f,
19771  "unexpected attribute form: DW_FORM_indirect");
19772  break;
19773  default:
19774  fprintf_unfiltered (f, "unsupported attribute form: %d.",
19775  die->attrs[i].form);
19776  break;
19777  }
19778  fprintf_unfiltered (f, "\n");
19779  }
19780 }
19781 
19782 static void
19784 {
19785  dump_die_shallow (gdb_stderr, 0, die);
19786 }
19787 
19788 static void
19789 dump_die_1 (struct ui_file *f, int level, int max_level, struct die_info *die)
19790 {
19791  int indent = level * 4;
19792 
19793  gdb_assert (die != NULL);
19794 
19795  if (level >= max_level)
19796  return;
19797 
19798  dump_die_shallow (f, indent, die);
19799 
19800  if (die->child != NULL)
19801  {
19802  print_spaces (indent, f);
19803  fprintf_unfiltered (f, " Children:");
19804  if (level + 1 < max_level)
19805  {
19806  fprintf_unfiltered (f, "\n");
19807  dump_die_1 (f, level + 1, max_level, die->child);
19808  }
19809  else
19810  {
19811  fprintf_unfiltered (f,
19812  " [not printed, max nesting level reached]\n");
19813  }
19814  }
19815 
19816  if (die->sibling != NULL && level > 0)
19817  {
19818  dump_die_1 (f, level, max_level, die->sibling);
19819  }
19820 }
19821 
19822 /* This is called from the pdie macro in gdbinit.in.
19823  It's not static so gcc will keep a copy callable from gdb. */
19824 
19825 void
19826 dump_die (struct die_info *die, int max_level)
19827 {
19828  dump_die_1 (gdb_stdlog, 0, max_level, die);
19829 }
19830 
19831 static void
19832 store_in_ref_table (struct die_info *die, struct dwarf2_cu *cu)
19833 {
19834  void **slot;
19835 
19836  slot = htab_find_slot_with_hash (cu->die_hash, die, die->offset.sect_off,
19837  INSERT);
19838 
19839  *slot = die;
19840 }
19841 
19842 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
19843  required kind. */
19844 
19845 static sect_offset
19847 {
19848  sect_offset retval = { DW_UNSND (attr) };
19849 
19850  if (attr_form_is_ref (attr))
19851  return retval;
19852 
19853  retval.sect_off = 0;
19855  _("unsupported die ref attribute form: '%s'"),
19856  dwarf_form_name (attr->form));
19857  return retval;
19858 }
19859 
19860 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
19861  * the value held by the attribute is not constant. */
19862 
19863 static LONGEST
19864 dwarf2_get_attr_constant_value (const struct attribute *attr, int default_value)
19865 {
19866  if (attr->form == DW_FORM_sdata)
19867  return DW_SND (attr);
19868  else if (attr->form == DW_FORM_udata
19869  || attr->form == DW_FORM_data1
19870  || attr->form == DW_FORM_data2
19871  || attr->form == DW_FORM_data4
19872  || attr->form == DW_FORM_data8)
19873  return DW_UNSND (attr);
19874  else
19875  {
19877  _("Attribute value is not a constant (%s)"),
19878  dwarf_form_name (attr->form));
19879  return default_value;
19880  }
19881 }
19882 
19883 /* Follow reference or signature attribute ATTR of SRC_DIE.
19884  On entry *REF_CU is the CU of SRC_DIE.
19885  On exit *REF_CU is the CU of the result. */
19886 
19887 static struct die_info *
19888 follow_die_ref_or_sig (struct die_info *src_die, const struct attribute *attr,
19889  struct dwarf2_cu **ref_cu)
19890 {
19891  struct die_info *die;
19892 
19893  if (attr_form_is_ref (attr))
19894  die = follow_die_ref (src_die, attr, ref_cu);
19895  else if (attr->form == DW_FORM_ref_sig8)
19896  die = follow_die_sig (src_die, attr, ref_cu);
19897  else
19898  {
19899  dump_die_for_error (src_die);
19900  error (_("Dwarf Error: Expected reference attribute [in module %s]"),
19901  objfile_name ((*ref_cu)->objfile));
19902  }
19903 
19904  return die;
19905 }
19906 
19907 /* Follow reference OFFSET.
19908  On entry *REF_CU is the CU of the source die referencing OFFSET.
19909  On exit *REF_CU is the CU of the result.
19910  Returns NULL if OFFSET is invalid. */
19911 
19912 static struct die_info *
19913 follow_die_offset (sect_offset offset, int offset_in_dwz,
19914  struct dwarf2_cu **ref_cu)
19915 {
19916  struct die_info temp_die;
19917  struct dwarf2_cu *target_cu, *cu = *ref_cu;
19918 
19919  gdb_assert (cu->per_cu != NULL);
19920 
19921  target_cu = cu;
19922 
19923  if (cu->per_cu->is_debug_types)
19924  {
19925  /* .debug_types CUs cannot reference anything outside their CU.
19926  If they need to, they have to reference a signatured type via
19927  DW_FORM_ref_sig8. */
19928  if (! offset_in_cu_p (&cu->header, offset))
19929  return NULL;
19930  }
19931  else if (offset_in_dwz != cu->per_cu->is_dwz
19932  || ! offset_in_cu_p (&cu->header, offset))
19933  {
19934  struct dwarf2_per_cu_data *per_cu;
19935 
19936  per_cu = dwarf2_find_containing_comp_unit (offset, offset_in_dwz,
19937  cu->objfile);
19938 
19939  /* If necessary, add it to the queue and load its DIEs. */
19940  if (maybe_queue_comp_unit (cu, per_cu, cu->language))
19941  load_full_comp_unit (per_cu, cu->language);
19942 
19943  target_cu = per_cu->cu;
19944  }
19945  else if (cu->dies == NULL)
19946  {
19947  /* We're loading full DIEs during partial symbol reading. */
19948  gdb_assert (dwarf2_per_objfile->reading_partial_symbols);
19950  }
19951 
19952  *ref_cu = target_cu;
19953  temp_die.offset = offset;
19954  return htab_find_with_hash (target_cu->die_hash, &temp_die, offset.sect_off);
19955 }
19956 
19957 /* Follow reference attribute ATTR of SRC_DIE.
19958  On entry *REF_CU is the CU of SRC_DIE.
19959  On exit *REF_CU is the CU of the result. */
19960 
19961 static struct die_info *
19962 follow_die_ref (struct die_info *src_die, const struct attribute *attr,
19963  struct dwarf2_cu **ref_cu)
19964 {
19965  sect_offset offset = dwarf2_get_ref_die_offset (attr);
19966  struct dwarf2_cu *cu = *ref_cu;
19967  struct die_info *die;
19968 
19969  die = follow_die_offset (offset,
19970  (attr->form == DW_FORM_GNU_ref_alt
19971  || cu->per_cu->is_dwz),
19972  ref_cu);
19973  if (!die)
19974  error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
19975  "at 0x%x [in module %s]"),
19976  offset.sect_off, src_die->offset.sect_off,
19977  objfile_name (cu->objfile));
19978 
19979  return die;
19980 }
19981 
19982 /* Return DWARF block referenced by DW_AT_location of DIE at OFFSET at PER_CU.
19983  Returned value is intended for DW_OP_call*. Returned
19984  dwarf2_locexpr_baton->data has lifetime of PER_CU->OBJFILE. */
19985 
19986 struct dwarf2_locexpr_baton
19988  struct dwarf2_per_cu_data *per_cu,
19989  CORE_ADDR (*get_frame_pc) (void *baton),
19990  void *baton)
19991 {
19992  struct dwarf2_cu *cu;
19993  struct die_info *die;
19994  struct attribute *attr;
19995  struct dwarf2_locexpr_baton retval;
19996 
19997  dw2_setup (per_cu->objfile);
19998 
19999  if (per_cu->cu == NULL)
20000  load_cu (per_cu);
20001  cu = per_cu->cu;
20002 
20003  die = follow_die_offset (offset, per_cu->is_dwz, &cu);
20004  if (!die)
20005  error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
20006  offset.sect_off, objfile_name (per_cu->objfile));
20007 
20008  attr = dwarf2_attr (die, DW_AT_location, cu);
20009  if (!attr)
20010  {
20011  /* DWARF: "If there is no such attribute, then there is no effect.".
20012  DATA is ignored if SIZE is 0. */
20013 
20014  retval.data = NULL;
20015  retval.size = 0;
20016  }
20017  else if (attr_form_is_section_offset (attr))
20018  {
20019  struct dwarf2_loclist_baton loclist_baton;
20020  CORE_ADDR pc = (*get_frame_pc) (baton);
20021  size_t size;
20022 
20023  fill_in_loclist_baton (cu, &loclist_baton, attr);
20024 
20025  retval.data = dwarf2_find_location_expression (&loclist_baton,
20026  &size, pc);
20027  retval.size = size;
20028  }
20029  else
20030  {
20031  if (!attr_form_is_block (attr))
20032  error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
20033  "is neither DW_FORM_block* nor DW_FORM_exprloc"),
20034  offset.sect_off, objfile_name (per_cu->objfile));
20035 
20036  retval.data = DW_BLOCK (attr)->data;
20037  retval.size = DW_BLOCK (attr)->size;
20038  }
20039  retval.per_cu = cu->per_cu;
20040 
20042 
20043  return retval;
20044 }
20045 
20046 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
20047  offset. */
20048 
20049 struct dwarf2_locexpr_baton
20051  struct dwarf2_per_cu_data *per_cu,
20052  CORE_ADDR (*get_frame_pc) (void *baton),
20053  void *baton)
20054 {
20055  sect_offset offset = { per_cu->offset.sect_off + offset_in_cu.cu_off };
20056 
20057  return dwarf2_fetch_die_loc_sect_off (offset, per_cu, get_frame_pc, baton);
20058 }
20059 
20060 /* Write a constant of a given type as target-ordered bytes into
20061  OBSTACK. */
20062 
20063 static const gdb_byte *
20064 write_constant_as_bytes (struct obstack *obstack,
20065  enum bfd_endian byte_order,
20066  struct type *type,
20067  ULONGEST value,
20068  LONGEST *len)
20069 {
20070  gdb_byte *result;
20071 
20072  *len = TYPE_LENGTH (type);
20073  result = obstack_alloc (obstack, *len);
20074  store_unsigned_integer (result, *len, byte_order, value);
20075 
20076  return result;
20077 }
20078 
20079 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
20080  pointer to the constant bytes and set LEN to the length of the
20081  data. If memory is needed, allocate it on OBSTACK. If the DIE
20082  does not have a DW_AT_const_value, return NULL. */
20083 
20084 const gdb_byte *
20086  struct dwarf2_per_cu_data *per_cu,
20087  struct obstack *obstack,
20088  LONGEST *len)
20089 {
20090  struct dwarf2_cu *cu;
20091  struct die_info *die;
20092  struct attribute *attr;
20093  const gdb_byte *result = NULL;
20094  struct type *type;
20095  LONGEST value;
20096  enum bfd_endian byte_order;
20097 
20098  dw2_setup (per_cu->objfile);
20099 
20100  if (per_cu->cu == NULL)
20101  load_cu (per_cu);
20102  cu = per_cu->cu;
20103 
20104  die = follow_die_offset (offset, per_cu->is_dwz, &cu);
20105  if (!die)
20106  error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
20107  offset.sect_off, objfile_name (per_cu->objfile));
20108 
20109 
20110  attr = dwarf2_attr (die, DW_AT_const_value, cu);
20111  if (attr == NULL)
20112  return NULL;
20113 
20114  byte_order = (bfd_big_endian (per_cu->objfile->obfd)
20115  ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
20116 
20117  switch (attr->form)
20118  {
20119  case DW_FORM_addr:
20120  case DW_FORM_GNU_addr_index:
20121  {
20122  gdb_byte *tem;
20123 
20124  *len = cu->header.addr_size;
20125  tem = obstack_alloc (obstack, *len);
20126  store_unsigned_integer (tem, *len, byte_order, DW_ADDR (attr));
20127  result = tem;
20128  }
20129  break;
20130  case DW_FORM_string:
20131  case DW_FORM_strp:
20132  case DW_FORM_GNU_str_index:
20133  case DW_FORM_GNU_strp_alt:
20134  /* DW_STRING is already allocated on the objfile obstack, point
20135  directly to it. */
20136  result = (const gdb_byte *) DW_STRING (attr);
20137  *len = strlen (DW_STRING (attr));
20138  break;
20139  case DW_FORM_block1:
20140  case DW_FORM_block2:
20141  case DW_FORM_block4:
20142  case DW_FORM_block:
20143  case DW_FORM_exprloc:
20144  result = DW_BLOCK (attr)->data;
20145  *len = DW_BLOCK (attr)->size;
20146  break;
20147 
20148  /* The DW_AT_const_value attributes are supposed to carry the
20149  symbol's value "represented as it would be on the target
20150  architecture." By the time we get here, it's already been
20151  converted to host endianness, so we just need to sign- or
20152  zero-extend it as appropriate. */
20153  case DW_FORM_data1:
20154  type = die_type (die, cu);
20155  result = dwarf2_const_value_data (attr, obstack, cu, &value, 8);
20156  if (result == NULL)
20157  result = write_constant_as_bytes (obstack, byte_order,
20158  type, value, len);
20159  break;
20160  case DW_FORM_data2:
20161  type = die_type (die, cu);
20162  result = dwarf2_const_value_data (attr, obstack, cu, &value, 16);
20163  if (result == NULL)
20164  result = write_constant_as_bytes (obstack, byte_order,
20165  type, value, len);
20166  break;
20167  case DW_FORM_data4:
20168  type = die_type (die, cu);
20169  result = dwarf2_const_value_data (attr, obstack, cu, &value, 32);
20170  if (result == NULL)
20171  result = write_constant_as_bytes (obstack, byte_order,
20172  type, value, len);
20173  break;
20174  case DW_FORM_data8:
20175  type = die_type (die, cu);
20176  result = dwarf2_const_value_data (attr, obstack, cu, &value, 64);
20177  if (result == NULL)
20178  result = write_constant_as_bytes (obstack, byte_order,
20179  type, value, len);
20180  break;
20181 
20182  case DW_FORM_sdata:
20183  type = die_type (die, cu);
20184  result = write_constant_as_bytes (obstack, byte_order,
20185  type, DW_SND (attr), len);
20186  break;
20187 
20188  case DW_FORM_udata:
20189  type = die_type (die, cu);
20190  result = write_constant_as_bytes (obstack, byte_order,
20191  type, DW_UNSND (attr), len);
20192  break;
20193 
20194  default:
20196  _("unsupported const value attribute form: '%s'"),
20197  dwarf_form_name (attr->form));
20198  break;
20199  }
20200 
20201  return result;
20202 }
20203 
20204 /* Return the type of the DIE at DIE_OFFSET in the CU named by
20205  PER_CU. */
20206 
20207 struct type *
20209  struct dwarf2_per_cu_data *per_cu)
20210 {
20211  sect_offset die_offset_sect;
20212 
20213  dw2_setup (per_cu->objfile);
20214 
20215  die_offset_sect.sect_off = per_cu->offset.sect_off + die_offset.cu_off;
20216  return get_die_type_at_offset (die_offset_sect, per_cu);
20217 }
20218 
20219 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
20220  On entry *REF_CU is the CU of SRC_DIE.
20221  On exit *REF_CU is the CU of the result.
20222  Returns NULL if the referenced DIE isn't found. */
20223 
20224 static struct die_info *
20225 follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type,
20226  struct dwarf2_cu **ref_cu)
20227 {
20228  struct objfile *objfile = (*ref_cu)->objfile;
20229  struct die_info temp_die;
20230  struct dwarf2_cu *sig_cu;
20231  struct die_info *die;
20232 
20233  /* While it might be nice to assert sig_type->type == NULL here,
20234  we can get here for DW_AT_imported_declaration where we need
20235  the DIE not the type. */
20236 
20237  /* If necessary, add it to the queue and load its DIEs. */
20238 
20239  if (maybe_queue_comp_unit (*ref_cu, &sig_type->per_cu, language_minimal))
20240  read_signatured_type (sig_type);
20241 
20242  sig_cu = sig_type->per_cu.cu;
20243  gdb_assert (sig_cu != NULL);
20244  gdb_assert (sig_type->type_offset_in_section.sect_off != 0);
20245  temp_die.offset = sig_type->type_offset_in_section;
20246  die = htab_find_with_hash (sig_cu->die_hash, &temp_die,
20247  temp_die.offset.sect_off);
20248  if (die)
20249  {
20250  /* For .gdb_index version 7 keep track of included TUs.
20251  http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
20252  if (dwarf2_per_objfile->index_table != NULL
20253  && dwarf2_per_objfile->index_table->version <= 7)
20254  {
20255  VEC_safe_push (dwarf2_per_cu_ptr,
20256  (*ref_cu)->per_cu->imported_symtabs,
20257  sig_cu->per_cu);
20258  }
20259 
20260  *ref_cu = sig_cu;
20261  return die;
20262  }
20263 
20264  return NULL;
20265 }
20266 
20267 /* Follow signatured type referenced by ATTR in SRC_DIE.
20268  On entry *REF_CU is the CU of SRC_DIE.
20269  On exit *REF_CU is the CU of the result.
20270  The result is the DIE of the type.
20271  If the referenced type cannot be found an error is thrown. */
20272 
20273 static struct die_info *
20274 follow_die_sig (struct die_info *src_die, const struct attribute *attr,
20275  struct dwarf2_cu **ref_cu)
20276 {
20277  ULONGEST signature = DW_SIGNATURE (attr);
20278  struct signatured_type *sig_type;
20279  struct die_info *die;
20280 
20281  gdb_assert (attr->form == DW_FORM_ref_sig8);
20282 
20283  sig_type = lookup_signatured_type (*ref_cu, signature);
20284  /* sig_type will be NULL if the signatured type is missing from
20285  the debug info. */
20286  if (sig_type == NULL)
20287  {
20288  error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
20289  " from DIE at 0x%x [in module %s]"),
20290  hex_string (signature), src_die->offset.sect_off,
20291  objfile_name ((*ref_cu)->objfile));
20292  }
20293 
20294  die = follow_die_sig_1 (src_die, sig_type, ref_cu);
20295  if (die == NULL)
20296  {
20297  dump_die_for_error (src_die);
20298  error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
20299  " from DIE at 0x%x [in module %s]"),
20300  hex_string (signature), src_die->offset.sect_off,
20301  objfile_name ((*ref_cu)->objfile));
20302  }
20303 
20304  return die;
20305 }
20306 
20307 /* Get the type specified by SIGNATURE referenced in DIE/CU,
20308  reading in and processing the type unit if necessary. */
20309 
20310 static struct type *
20311 get_signatured_type (struct die_info *die, ULONGEST signature,
20312  struct dwarf2_cu *cu)
20313 {
20314  struct signatured_type *sig_type;
20315  struct dwarf2_cu *type_cu;
20316  struct die_info *type_die;
20317  struct type *type;
20318 
20319  sig_type = lookup_signatured_type (cu, signature);
20320  /* sig_type will be NULL if the signatured type is missing from
20321  the debug info. */
20322  if (sig_type == NULL)
20323  {
20325  _("Dwarf Error: Cannot find signatured DIE %s referenced"
20326  " from DIE at 0x%x [in module %s]"),
20327  hex_string (signature), die->offset.sect_off,
20328  objfile_name (dwarf2_per_objfile->objfile));
20329  return build_error_marker_type (cu, die);
20330  }
20331 
20332  /* If we already know the type we're done. */
20333  if (sig_type->type != NULL)
20334  return sig_type->type;
20335 
20336  type_cu = cu;
20337  type_die = follow_die_sig_1 (die, sig_type, &type_cu);
20338  if (type_die != NULL)
20339  {
20340  /* N.B. We need to call get_die_type to ensure only one type for this DIE
20341  is created. This is important, for example, because for c++ classes
20342  we need TYPE_NAME set which is only done by new_symbol. Blech. */
20343  type = read_type_die (type_die, type_cu);
20344  if (type == NULL)
20345  {
20347  _("Dwarf Error: Cannot build signatured type %s"
20348  " referenced from DIE at 0x%x [in module %s]"),
20349  hex_string (signature), die->offset.sect_off,
20350  objfile_name (dwarf2_per_objfile->objfile));
20351  type = build_error_marker_type (cu, die);
20352  }
20353  }
20354  else
20355  {
20357  _("Dwarf Error: Problem reading signatured DIE %s referenced"
20358  " from DIE at 0x%x [in module %s]"),
20359  hex_string (signature), die->offset.sect_off,
20360  objfile_name (dwarf2_per_objfile->objfile));
20361  type = build_error_marker_type (cu, die);
20362  }
20363  sig_type->type = type;
20364 
20365  return type;
20366 }
20367 
20368 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
20369  reading in and processing the type unit if necessary. */
20370 
20371 static struct type *
20372 get_DW_AT_signature_type (struct die_info *die, const struct attribute *attr,
20373  struct dwarf2_cu *cu) /* ARI: editCase function */
20374 {
20375  /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
20376  if (attr_form_is_ref (attr))
20377  {
20378  struct dwarf2_cu *type_cu = cu;
20379  struct die_info *type_die = follow_die_ref (die, attr, &type_cu);
20380 
20381  return read_type_die (type_die, type_cu);
20382  }
20383  else if (attr->form == DW_FORM_ref_sig8)
20384  {
20385  return get_signatured_type (die, DW_SIGNATURE (attr), cu);
20386  }
20387  else
20388  {
20390  _("Dwarf Error: DW_AT_signature has bad form %s in DIE"
20391  " at 0x%x [in module %s]"),
20392  dwarf_form_name (attr->form), die->offset.sect_off,
20393  objfile_name (dwarf2_per_objfile->objfile));
20394  return build_error_marker_type (cu, die);
20395  }
20396 }
20397 
20398 /* Load the DIEs associated with type unit PER_CU into memory. */
20399 
20400 static void
20402 {
20403  struct signatured_type *sig_type;
20404 
20405  /* Caller is responsible for ensuring type_unit_groups don't get here. */
20406  gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu));
20407 
20408  /* We have the per_cu, but we need the signatured_type.
20409  Fortunately this is an easy translation. */
20410  gdb_assert (per_cu->is_debug_types);
20411  sig_type = (struct signatured_type *) per_cu;
20412 
20413  gdb_assert (per_cu->cu == NULL);
20414 
20415  read_signatured_type (sig_type);
20416 
20417  gdb_assert (per_cu->cu != NULL);
20418 }
20419 
20420 /* die_reader_func for read_signatured_type.
20421  This is identical to load_full_comp_unit_reader,
20422  but is kept separate for now. */
20423 
20424 static void
20426  const gdb_byte *info_ptr,
20427  struct die_info *comp_unit_die,
20428  int has_children,
20429  void *data)
20430 {
20431  struct dwarf2_cu *cu = reader->cu;
20432 
20433  gdb_assert (cu->die_hash == NULL);
20434  cu->die_hash =
20435  htab_create_alloc_ex (cu->header.length / 12,
20436  die_hash,
20437  die_eq,
20438  NULL,
20439  &cu->comp_unit_obstack,
20442 
20443  if (has_children)
20444  comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
20445  &info_ptr, comp_unit_die);
20446  cu->dies = comp_unit_die;
20447  /* comp_unit_die is not stored in die_hash, no need. */
20448 
20449  /* We try not to read any attributes in this function, because not
20450  all CUs needed for references have been loaded yet, and symbol
20451  table processing isn't initialized. But we have to set the CU language,
20452  or we won't be able to build types correctly.
20453  Similarly, if we do not read the producer, we can not apply
20454  producer-specific interpretation. */
20456 }
20457 
20458 /* Read in a signatured type and build its CU and DIEs.
20459  If the type is a stub for the real type in a DWO file,
20460  read in the real type from the DWO file as well. */
20461 
20462 static void
20464 {
20465  struct dwarf2_per_cu_data *per_cu = &sig_type->per_cu;
20466 
20467  gdb_assert (per_cu->is_debug_types);
20468  gdb_assert (per_cu->cu == NULL);
20469 
20470  init_cutu_and_read_dies (per_cu, NULL, 0, 1,
20472  sig_type->per_cu.tu_read = 1;
20473 }
20474 
20475 /* Decode simple location descriptions.
20476  Given a pointer to a dwarf block that defines a location, compute
20477  the location and return the value.
20478 
20479  NOTE drow/2003-11-18: This function is called in two situations
20480  now: for the address of static or global variables (partial symbols
20481  only) and for offsets into structures which are expected to be
20482  (more or less) constant. The partial symbol case should go away,
20483  and only the constant case should remain. That will let this
20484  function complain more accurately. A few special modes are allowed
20485  without complaint for global variables (for instance, global
20486  register values and thread-local values).
20487 
20488  A location description containing no operations indicates that the
20489  object is optimized out. The return value is 0 for that case.
20490  FIXME drow/2003-11-16: No callers check for this case any more; soon all
20491  callers will only want a very basic result and this can become a
20492  complaint.
20493 
20494  Note that stack[0] is unused except as a default error return. */
20495 
20496 static CORE_ADDR
20497 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
20498 {
20499  struct objfile *objfile = cu->objfile;
20500  size_t i;
20501  size_t size = blk->size;
20502  const gdb_byte *data = blk->data;
20503  CORE_ADDR stack[64];
20504  int stacki;
20505  unsigned int bytes_read, unsnd;
20506  gdb_byte op;
20507 
20508  i = 0;
20509  stacki = 0;
20510  stack[stacki] = 0;
20511  stack[++stacki] = 0;
20512 
20513  while (i < size)
20514  {
20515  op = data[i++];
20516  switch (op)
20517  {
20518  case DW_OP_lit0:
20519  case DW_OP_lit1:
20520  case DW_OP_lit2:
20521  case DW_OP_lit3:
20522  case DW_OP_lit4:
20523  case DW_OP_lit5:
20524  case DW_OP_lit6:
20525  case DW_OP_lit7:
20526  case DW_OP_lit8:
20527  case DW_OP_lit9:
20528  case DW_OP_lit10:
20529  case DW_OP_lit11:
20530  case DW_OP_lit12:
20531  case DW_OP_lit13:
20532  case DW_OP_lit14:
20533  case DW_OP_lit15:
20534  case DW_OP_lit16:
20535  case DW_OP_lit17:
20536  case DW_OP_lit18:
20537  case DW_OP_lit19:
20538  case DW_OP_lit20:
20539  case DW_OP_lit21:
20540  case DW_OP_lit22:
20541  case DW_OP_lit23:
20542  case DW_OP_lit24:
20543  case DW_OP_lit25:
20544  case DW_OP_lit26:
20545  case DW_OP_lit27:
20546  case DW_OP_lit28:
20547  case DW_OP_lit29:
20548  case DW_OP_lit30:
20549  case DW_OP_lit31:
20550  stack[++stacki] = op - DW_OP_lit0;
20551  break;
20552 
20553  case DW_OP_reg0:
20554  case DW_OP_reg1:
20555  case DW_OP_reg2:
20556  case DW_OP_reg3:
20557  case DW_OP_reg4:
20558  case DW_OP_reg5:
20559  case DW_OP_reg6:
20560  case DW_OP_reg7:
20561  case DW_OP_reg8:
20562  case DW_OP_reg9:
20563  case DW_OP_reg10:
20564  case DW_OP_reg11:
20565  case DW_OP_reg12:
20566  case DW_OP_reg13:
20567  case DW_OP_reg14:
20568  case DW_OP_reg15:
20569  case DW_OP_reg16:
20570  case DW_OP_reg17:
20571  case DW_OP_reg18:
20572  case DW_OP_reg19:
20573  case DW_OP_reg20:
20574  case DW_OP_reg21:
20575  case DW_OP_reg22:
20576  case DW_OP_reg23:
20577  case DW_OP_reg24:
20578  case DW_OP_reg25:
20579  case DW_OP_reg26:
20580  case DW_OP_reg27:
20581  case DW_OP_reg28:
20582  case DW_OP_reg29:
20583  case DW_OP_reg30:
20584  case DW_OP_reg31:
20585  stack[++stacki] = op - DW_OP_reg0;
20586  if (i < size)
20588  break;
20589 
20590  case DW_OP_regx:
20591  unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
20592  i += bytes_read;
20593  stack[++stacki] = unsnd;
20594  if (i < size)
20596  break;
20597 
20598  case DW_OP_addr:
20599  stack[++stacki] = read_address (objfile->obfd, &data[i],
20600  cu, &bytes_read);
20601  i += bytes_read;
20602  break;
20603 
20604  case DW_OP_const1u:
20605  stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
20606  i += 1;
20607  break;
20608 
20609  case DW_OP_const1s:
20610  stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
20611  i += 1;
20612  break;
20613 
20614  case DW_OP_const2u:
20615  stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
20616  i += 2;
20617  break;
20618 
20619  case DW_OP_const2s:
20620  stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
20621  i += 2;
20622  break;
20623 
20624  case DW_OP_const4u:
20625  stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
20626  i += 4;
20627  break;
20628 
20629  case DW_OP_const4s:
20630  stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
20631  i += 4;
20632  break;
20633 
20634  case DW_OP_const8u:
20635  stack[++stacki] = read_8_bytes (objfile->obfd, &data[i]);
20636  i += 8;
20637  break;
20638 
20639  case DW_OP_constu:
20640  stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
20641  &bytes_read);
20642  i += bytes_read;
20643  break;
20644 
20645  case DW_OP_consts:
20646  stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
20647  i += bytes_read;
20648  break;
20649 
20650  case DW_OP_dup:
20651  stack[stacki + 1] = stack[stacki];
20652  stacki++;
20653  break;
20654 
20655  case DW_OP_plus:
20656  stack[stacki - 1] += stack[stacki];
20657  stacki--;
20658  break;
20659 
20660  case DW_OP_plus_uconst:
20661  stack[stacki] += read_unsigned_leb128 (NULL, (data + i),
20662  &bytes_read);
20663  i += bytes_read;
20664  break;
20665 
20666  case DW_OP_minus:
20667  stack[stacki - 1] -= stack[stacki];
20668  stacki--;
20669  break;
20670 
20671  case DW_OP_deref:
20672  /* If we're not the last op, then we definitely can't encode
20673  this using GDB's address_class enum. This is valid for partial
20674  global symbols, although the variable's address will be bogus
20675  in the psymtab. */
20676  if (i < size)
20678  break;
20679 
20680  case DW_OP_GNU_push_tls_address:
20681  /* The top of the stack has the offset from the beginning
20682  of the thread control block at which the variable is located. */
20683  /* Nothing should follow this operator, so the top of stack would
20684  be returned. */
20685  /* This is valid for partial global symbols, but the variable's
20686  address will be bogus in the psymtab. Make it always at least
20687  non-zero to not look as a variable garbage collected by linker
20688  which have DW_OP_addr 0. */
20689  if (i < size)
20691  stack[stacki]++;
20692  break;
20693 
20694  case DW_OP_GNU_uninit:
20695  break;
20696 
20697  case DW_OP_GNU_addr_index:
20698  case DW_OP_GNU_const_index:
20699  stack[++stacki] = read_addr_index_from_leb128 (cu, &data[i],
20700  &bytes_read);
20701  i += bytes_read;
20702  break;
20703 
20704  default:
20705  {
20706  const char *name = get_DW_OP_name (op);
20707 
20708  if (name)
20709  complaint (&symfile_complaints, _("unsupported stack op: '%s'"),
20710  name);
20711  else
20712  complaint (&symfile_complaints, _("unsupported stack op: '%02x'"),
20713  op);
20714  }
20715 
20716  return (stack[stacki]);
20717  }
20718 
20719  /* Enforce maximum stack depth of SIZE-1 to avoid writing
20720  outside of the allocated space. Also enforce minimum>0. */
20721  if (stacki >= ARRAY_SIZE (stack) - 1)
20722  {
20724  _("location description stack overflow"));
20725  return 0;
20726  }
20727 
20728  if (stacki <= 0)
20729  {
20731  _("location description stack underflow"));
20732  return 0;
20733  }
20734  }
20735  return (stack[stacki]);
20736 }
20737 
20738 /* memory allocation interface */
20739 
20740 static struct dwarf_block *
20742 {
20743  struct dwarf_block *blk;
20744 
20745  blk = (struct dwarf_block *)
20746  obstack_alloc (&cu->comp_unit_obstack, sizeof (struct dwarf_block));
20747  return (blk);
20748 }
20749 
20750 static struct die_info *
20751 dwarf_alloc_die (struct dwarf2_cu *cu, int num_attrs)
20752 {
20753  struct die_info *die;
20754  size_t size = sizeof (struct die_info);
20755 
20756  if (num_attrs > 1)
20757  size += (num_attrs - 1) * sizeof (struct attribute);
20758 
20759  die = (struct die_info *) obstack_alloc (&cu->comp_unit_obstack, size);
20760  memset (die, 0, sizeof (struct die_info));
20761  return (die);
20762 }
20763 
20764 
20765 /* Macro support. */
20766 
20767 /* Return file name relative to the compilation directory of file number I in
20768  *LH's file name table. The result is allocated using xmalloc; the caller is
20769  responsible for freeing it. */
20770 
20771 static char *
20772 file_file_name (int file, struct line_header *lh)
20773 {
20774  /* Is the file number a valid index into the line header's file name
20775  table? Remember that file numbers start with one, not zero. */
20776  if (1 <= file && file <= lh->num_file_names)
20777  {
20778  struct file_entry *fe = &lh->file_names[file - 1];
20779 
20780  if (IS_ABSOLUTE_PATH (fe->name) || fe->dir_index == 0
20781  || lh->include_dirs == NULL)
20782  return xstrdup (fe->name);
20783  return concat (lh->include_dirs[fe->dir_index - 1], SLASH_STRING,
20784  fe->name, NULL);
20785  }
20786  else
20787  {
20788  /* The compiler produced a bogus file number. We can at least
20789  record the macro definitions made in the file, even if we
20790  won't be able to find the file by name. */
20791  char fake_name[80];
20792 
20793  xsnprintf (fake_name, sizeof (fake_name),
20794  "<bad macro file number %d>", file);
20795 
20797  _("bad file number in macro information (%d)"),
20798  file);
20799 
20800  return xstrdup (fake_name);
20801  }
20802 }
20803 
20804 /* Return the full name of file number I in *LH's file name table.
20805  Use COMP_DIR as the name of the current directory of the
20806  compilation. The result is allocated using xmalloc; the caller is
20807  responsible for freeing it. */
20808 static char *
20809 file_full_name (int file, struct line_header *lh, const char *comp_dir)
20810 {
20811  /* Is the file number a valid index into the line header's file name
20812  table? Remember that file numbers start with one, not zero. */
20813  if (1 <= file && file <= lh->num_file_names)
20814  {
20815  char *relative = file_file_name (file, lh);
20816 
20817  if (IS_ABSOLUTE_PATH (relative) || comp_dir == NULL)
20818  return relative;
20819  return reconcat (relative, comp_dir, SLASH_STRING, relative, NULL);
20820  }
20821  else
20822  return file_file_name (file, lh);
20823 }
20824 
20825 
20826 static struct macro_source_file *
20827 macro_start_file (int file, int line,
20828  struct macro_source_file *current_file,
20829  struct line_header *lh)
20830 {
20831  /* File name relative to the compilation directory of this source file. */
20832  char *file_name = file_file_name (file, lh);
20833 
20834  if (! current_file)
20835  {
20836  /* Note: We don't create a macro table for this compilation unit
20837  at all until we actually get a filename. */
20839 
20840  /* If we have no current file, then this must be the start_file
20841  directive for the compilation unit's main source file. */
20842  current_file = macro_set_main (macro_table, file_name);
20843  macro_define_special (macro_table);
20844  }
20845  else
20846  current_file = macro_include (current_file, line, file_name);
20847 
20848  xfree (file_name);
20849 
20850  return current_file;
20851 }
20852 
20853 
20854 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
20855  followed by a null byte. */
20856 static char *
20857 copy_string (const char *buf, int len)
20858 {
20859  char *s = xmalloc (len + 1);
20860 
20861  memcpy (s, buf, len);
20862  s[len] = '\0';
20863  return s;
20864 }
20865 
20866 
20867 static const char *
20868 consume_improper_spaces (const char *p, const char *body)
20869 {
20870  if (*p == ' ')
20871  {
20873  _("macro definition contains spaces "
20874  "in formal argument list:\n`%s'"),
20875  body);
20876 
20877  while (*p == ' ')
20878  p++;
20879  }
20880 
20881  return p;
20882 }
20883 
20884 
20885 static void
20887  const char *body)
20888 {
20889  const char *p;
20890 
20891  /* The body string takes one of two forms. For object-like macro
20892  definitions, it should be:
20893 
20894  <macro name> " " <definition>
20895 
20896  For function-like macro definitions, it should be:
20897 
20898  <macro name> "() " <definition>
20899  or
20900  <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
20901 
20902  Spaces may appear only where explicitly indicated, and in the
20903  <definition>.
20904 
20905  The Dwarf 2 spec says that an object-like macro's name is always
20906  followed by a space, but versions of GCC around March 2002 omit
20907  the space when the macro's definition is the empty string.
20908 
20909  The Dwarf 2 spec says that there should be no spaces between the
20910  formal arguments in a function-like macro's formal argument list,
20911  but versions of GCC around March 2002 include spaces after the
20912  commas. */
20913 
20914 
20915  /* Find the extent of the macro name. The macro name is terminated
20916  by either a space or null character (for an object-like macro) or
20917  an opening paren (for a function-like macro). */
20918  for (p = body; *p; p++)
20919  if (*p == ' ' || *p == '(')
20920  break;
20921 
20922  if (*p == ' ' || *p == '\0')
20923  {
20924  /* It's an object-like macro. */
20925  int name_len = p - body;
20926  char *name = copy_string (body, name_len);
20927  const char *replacement;
20928 
20929  if (*p == ' ')
20930  replacement = body + name_len + 1;
20931  else
20932  {
20934  replacement = body + name_len;
20935  }
20936 
20937  macro_define_object (file, line, name, replacement);
20938 
20939  xfree (name);
20940  }
20941  else if (*p == '(')
20942  {
20943  /* It's a function-like macro. */
20944  char *name = copy_string (body, p - body);
20945  int argc = 0;
20946  int argv_size = 1;
20947  char **argv = xmalloc (argv_size * sizeof (*argv));
20948 
20949  p++;
20950 
20951  p = consume_improper_spaces (p, body);
20952 
20953  /* Parse the formal argument list. */
20954  while (*p && *p != ')')
20955  {
20956  /* Find the extent of the current argument name. */
20957  const char *arg_start = p;
20958 
20959  while (*p && *p != ',' && *p != ')' && *p != ' ')
20960  p++;
20961 
20962  if (! *p || p == arg_start)
20964  else
20965  {
20966  /* Make sure argv has room for the new argument. */
20967  if (argc >= argv_size)
20968  {
20969  argv_size *= 2;
20970  argv = xrealloc (argv, argv_size * sizeof (*argv));
20971  }
20972 
20973  argv[argc++] = copy_string (arg_start, p - arg_start);
20974  }
20975 
20976  p = consume_improper_spaces (p, body);
20977 
20978  /* Consume the comma, if present. */
20979  if (*p == ',')
20980  {
20981  p++;
20982 
20983  p = consume_improper_spaces (p, body);
20984  }
20985  }
20986 
20987  if (*p == ')')
20988  {
20989  p++;
20990 
20991  if (*p == ' ')
20992  /* Perfectly formed definition, no complaints. */
20993  macro_define_function (file, line, name,
20994  argc, (const char **) argv,
20995  p + 1);
20996  else if (*p == '\0')
20997  {
20998  /* Complain, but do define it. */
21000  macro_define_function (file, line, name,
21001  argc, (const char **) argv,
21002  p);
21003  }
21004  else
21005  /* Just complain. */
21007  }
21008  else
21009  /* Just complain. */
21011 
21012  xfree (name);
21013  {
21014  int i;
21015 
21016  for (i = 0; i < argc; i++)
21017  xfree (argv[i]);
21018  }
21019  xfree (argv);
21020  }
21021  else
21023 }
21024 
21025 /* Skip some bytes from BYTES according to the form given in FORM.
21026  Returns the new pointer. */
21027 
21028 static const gdb_byte *
21029 skip_form_bytes (bfd *abfd, const gdb_byte *bytes, const gdb_byte *buffer_end,
21030  enum dwarf_form form,
21031  unsigned int offset_size,
21032  struct dwarf2_section_info *section)
21033 {
21034  unsigned int bytes_read;
21035 
21036  switch (form)
21037  {
21038  case DW_FORM_data1:
21039  case DW_FORM_flag:
21040  ++bytes;
21041  break;
21042 
21043  case DW_FORM_data2:
21044  bytes += 2;
21045  break;
21046 
21047  case DW_FORM_data4:
21048  bytes += 4;
21049  break;
21050 
21051  case DW_FORM_data8:
21052  bytes += 8;
21053  break;
21054 
21055  case DW_FORM_string:
21056  read_direct_string (abfd, bytes, &bytes_read);
21057  bytes += bytes_read;
21058  break;
21059 
21060  case DW_FORM_sec_offset:
21061  case DW_FORM_strp:
21062  case DW_FORM_GNU_strp_alt:
21063  bytes += offset_size;
21064  break;
21065 
21066  case DW_FORM_block:
21067  bytes += read_unsigned_leb128 (abfd, bytes, &bytes_read);
21068  bytes += bytes_read;
21069  break;
21070 
21071  case DW_FORM_block1:
21072  bytes += 1 + read_1_byte (abfd, bytes);
21073  break;
21074  case DW_FORM_block2:
21075  bytes += 2 + read_2_bytes (abfd, bytes);
21076  break;
21077  case DW_FORM_block4:
21078  bytes += 4 + read_4_bytes (abfd, bytes);
21079  break;
21080 
21081  case DW_FORM_sdata:
21082  case DW_FORM_udata:
21083  case DW_FORM_GNU_addr_index:
21084  case DW_FORM_GNU_str_index:
21085  bytes = gdb_skip_leb128 (bytes, buffer_end);
21086  if (bytes == NULL)
21087  {
21089  return NULL;
21090  }
21091  break;
21092 
21093  default:
21094  {
21095  complain:
21097  _("invalid form 0x%x in `%s'"),
21098  form, get_section_name (section));
21099  return NULL;
21100  }
21101  }
21102 
21103  return bytes;
21104 }
21105 
21106 /* A helper for dwarf_decode_macros that handles skipping an unknown
21107  opcode. Returns an updated pointer to the macro data buffer; or,
21108  on error, issues a complaint and returns NULL. */
21109 
21110 static const gdb_byte *
21111 skip_unknown_opcode (unsigned int opcode,
21112  const gdb_byte **opcode_definitions,
21113  const gdb_byte *mac_ptr, const gdb_byte *mac_end,
21114  bfd *abfd,
21115  unsigned int offset_size,
21116  struct dwarf2_section_info *section)
21117 {
21118  unsigned int bytes_read, i;
21119  unsigned long arg;
21120  const gdb_byte *defn;
21121 
21122  if (opcode_definitions[opcode] == NULL)
21123  {
21125  _("unrecognized DW_MACFINO opcode 0x%x"),
21126  opcode);
21127  return NULL;
21128  }
21129 
21130  defn = opcode_definitions[opcode];
21131  arg = read_unsigned_leb128 (abfd, defn, &bytes_read);
21132  defn += bytes_read;
21133 
21134  for (i = 0; i < arg; ++i)
21135  {
21136  mac_ptr = skip_form_bytes (abfd, mac_ptr, mac_end, defn[i], offset_size,
21137  section);
21138  if (mac_ptr == NULL)
21139  {
21140  /* skip_form_bytes already issued the complaint. */
21141  return NULL;
21142  }
21143  }
21144 
21145  return mac_ptr;
21146 }
21147 
21148 /* A helper function which parses the header of a macro section.
21149  If the macro section is the extended (for now called "GNU") type,
21150  then this updates *OFFSET_SIZE. Returns a pointer to just after
21151  the header, or issues a complaint and returns NULL on error. */
21152 
21153 static const gdb_byte *
21154 dwarf_parse_macro_header (const gdb_byte **opcode_definitions,
21155  bfd *abfd,
21156  const gdb_byte *mac_ptr,
21157  unsigned int *offset_size,
21158  int section_is_gnu)
21159 {
21160  memset (opcode_definitions, 0, 256 * sizeof (gdb_byte *));
21161 
21162  if (section_is_gnu)
21163  {
21164  unsigned int version, flags;
21165 
21166  version = read_2_bytes (abfd, mac_ptr);
21167  if (version != 4)
21168  {
21170  _("unrecognized version `%d' in .debug_macro section"),
21171  version);
21172  return NULL;
21173  }
21174  mac_ptr += 2;
21175 
21176  flags = read_1_byte (abfd, mac_ptr);
21177  ++mac_ptr;
21178  *offset_size = (flags & 1) ? 8 : 4;
21179 
21180  if ((flags & 2) != 0)
21181  /* We don't need the line table offset. */
21182  mac_ptr += *offset_size;
21183 
21184  /* Vendor opcode descriptions. */
21185  if ((flags & 4) != 0)
21186  {
21187  unsigned int i, count;
21188 
21189  count = read_1_byte (abfd, mac_ptr);
21190  ++mac_ptr;
21191  for (i = 0; i < count; ++i)
21192  {
21193  unsigned int opcode, bytes_read;
21194  unsigned long arg;
21195 
21196  opcode = read_1_byte (abfd, mac_ptr);
21197  ++mac_ptr;
21198  opcode_definitions[opcode] = mac_ptr;
21199  arg = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
21200  mac_ptr += bytes_read;
21201  mac_ptr += arg;
21202  }
21203  }
21204  }
21205 
21206  return mac_ptr;
21207 }
21208 
21209 /* A helper for dwarf_decode_macros that handles the GNU extensions,
21210  including DW_MACRO_GNU_transparent_include. */
21211 
21212 static void
21214  const gdb_byte *mac_ptr, const gdb_byte *mac_end,
21215  struct macro_source_file *current_file,
21216  struct line_header *lh,
21217  struct dwarf2_section_info *section,
21218  int section_is_gnu, int section_is_dwz,
21219  unsigned int offset_size,
21220  htab_t include_hash)
21221 {
21222  struct objfile *objfile = dwarf2_per_objfile->objfile;
21223  enum dwarf_macro_record_type macinfo_type;
21224  int at_commandline;
21225  const gdb_byte *opcode_definitions[256];
21226 
21227  mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
21228  &offset_size, section_is_gnu);
21229  if (mac_ptr == NULL)
21230  {
21231  /* We already issued a complaint. */
21232  return;
21233  }
21234 
21235  /* Determines if GDB is still before first DW_MACINFO_start_file. If true
21236  GDB is still reading the definitions from command line. First
21237  DW_MACINFO_start_file will need to be ignored as it was already executed
21238  to create CURRENT_FILE for the main source holding also the command line
21239  definitions. On first met DW_MACINFO_start_file this flag is reset to
21240  normally execute all the remaining DW_MACINFO_start_file macinfos. */
21241 
21242  at_commandline = 1;
21243 
21244  do
21245  {
21246  /* Do we at least have room for a macinfo type byte? */
21247  if (mac_ptr >= mac_end)
21248  {
21250  break;
21251  }
21252 
21253  macinfo_type = read_1_byte (abfd, mac_ptr);
21254  mac_ptr++;
21255 
21256  /* Note that we rely on the fact that the corresponding GNU and
21257  DWARF constants are the same. */
21258  switch (macinfo_type)
21259  {
21260  /* A zero macinfo type indicates the end of the macro
21261  information. */
21262  case 0:
21263  break;
21264 
21265  case DW_MACRO_GNU_define:
21266  case DW_MACRO_GNU_undef:
21267  case DW_MACRO_GNU_define_indirect:
21268  case DW_MACRO_GNU_undef_indirect:
21269  case DW_MACRO_GNU_define_indirect_alt:
21270  case DW_MACRO_GNU_undef_indirect_alt:
21271  {
21272  unsigned int bytes_read;
21273  int line;
21274  const char *body;
21275  int is_define;
21276 
21277  line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
21278  mac_ptr += bytes_read;
21279 
21280  if (macinfo_type == DW_MACRO_GNU_define
21281  || macinfo_type == DW_MACRO_GNU_undef)
21282  {
21283  body = read_direct_string (abfd, mac_ptr, &bytes_read);
21284  mac_ptr += bytes_read;
21285  }
21286  else
21287  {
21288  LONGEST str_offset;
21289 
21290  str_offset = read_offset_1 (abfd, mac_ptr, offset_size);
21291  mac_ptr += offset_size;
21292 
21293  if (macinfo_type == DW_MACRO_GNU_define_indirect_alt
21294  || macinfo_type == DW_MACRO_GNU_undef_indirect_alt
21295  || section_is_dwz)
21296  {
21297  struct dwz_file *dwz = dwarf2_get_dwz_file ();
21298 
21299  body = read_indirect_string_from_dwz (dwz, str_offset);
21300  }
21301  else
21302  body = read_indirect_string_at_offset (abfd, str_offset);
21303  }
21304 
21305  is_define = (macinfo_type == DW_MACRO_GNU_define
21306  || macinfo_type == DW_MACRO_GNU_define_indirect
21307  || macinfo_type == DW_MACRO_GNU_define_indirect_alt);
21308  if (! current_file)
21309  {
21310  /* DWARF violation as no main source is present. */
21312  _("debug info with no main source gives macro %s "
21313  "on line %d: %s"),
21314  is_define ? _("definition") : _("undefinition"),
21315  line, body);
21316  break;
21317  }
21318  if ((line == 0 && !at_commandline)
21319  || (line != 0 && at_commandline))
21321  _("debug info gives %s macro %s with %s line %d: %s"),
21322  at_commandline ? _("command-line") : _("in-file"),
21323  is_define ? _("definition") : _("undefinition"),
21324  line == 0 ? _("zero") : _("non-zero"), line, body);
21325 
21326  if (is_define)
21327  parse_macro_definition (current_file, line, body);
21328  else
21329  {
21330  gdb_assert (macinfo_type == DW_MACRO_GNU_undef
21331  || macinfo_type == DW_MACRO_GNU_undef_indirect
21332  || macinfo_type == DW_MACRO_GNU_undef_indirect_alt);
21333  macro_undef (current_file, line, body);
21334  }
21335  }
21336  break;
21337 
21338  case DW_MACRO_GNU_start_file:
21339  {
21340  unsigned int bytes_read;
21341  int line, file;
21342 
21343  line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
21344  mac_ptr += bytes_read;
21345  file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
21346  mac_ptr += bytes_read;
21347 
21348  if ((line == 0 && !at_commandline)
21349  || (line != 0 && at_commandline))
21351  _("debug info gives source %d included "
21352  "from %s at %s line %d"),
21353  file, at_commandline ? _("command-line") : _("file"),
21354  line == 0 ? _("zero") : _("non-zero"), line);
21355 
21356  if (at_commandline)
21357  {
21358  /* This DW_MACRO_GNU_start_file was executed in the
21359  pass one. */
21360  at_commandline = 0;
21361  }
21362  else
21363  current_file = macro_start_file (file, line, current_file, lh);
21364  }
21365  break;
21366 
21367  case DW_MACRO_GNU_end_file:
21368  if (! current_file)
21370  _("macro debug info has an unmatched "
21371  "`close_file' directive"));
21372  else
21373  {
21374  current_file = current_file->included_by;
21375  if (! current_file)
21376  {
21377  enum dwarf_macro_record_type next_type;
21378 
21379  /* GCC circa March 2002 doesn't produce the zero
21380  type byte marking the end of the compilation
21381  unit. Complain if it's not there, but exit no
21382  matter what. */
21383 
21384  /* Do we at least have room for a macinfo type byte? */
21385  if (mac_ptr >= mac_end)
21386  {
21388  return;
21389  }
21390 
21391  /* We don't increment mac_ptr here, so this is just
21392  a look-ahead. */
21393  next_type = read_1_byte (abfd, mac_ptr);
21394  if (next_type != 0)
21396  _("no terminating 0-type entry for "
21397  "macros in `.debug_macinfo' section"));
21398 
21399  return;
21400  }
21401  }
21402  break;
21403 
21404  case DW_MACRO_GNU_transparent_include:
21405  case DW_MACRO_GNU_transparent_include_alt:
21406  {
21407  LONGEST offset;
21408  void **slot;
21409  bfd *include_bfd = abfd;
21410  struct dwarf2_section_info *include_section = section;
21411  struct dwarf2_section_info alt_section;
21412  const gdb_byte *include_mac_end = mac_end;
21413  int is_dwz = section_is_dwz;
21414  const gdb_byte *new_mac_ptr;
21415 
21416  offset = read_offset_1 (abfd, mac_ptr, offset_size);
21417  mac_ptr += offset_size;
21418 
21419  if (macinfo_type == DW_MACRO_GNU_transparent_include_alt)
21420  {
21421  struct dwz_file *dwz = dwarf2_get_dwz_file ();
21422 
21423  dwarf2_read_section (objfile, &dwz->macro);
21424 
21425  include_section = &dwz->macro;
21426  include_bfd = get_section_bfd_owner (include_section);
21427  include_mac_end = dwz->macro.buffer + dwz->macro.size;
21428  is_dwz = 1;
21429  }
21430 
21431  new_mac_ptr = include_section->buffer + offset;
21432  slot = htab_find_slot (include_hash, new_mac_ptr, INSERT);
21433 
21434  if (*slot != NULL)
21435  {
21436  /* This has actually happened; see
21437  http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
21439  _("recursive DW_MACRO_GNU_transparent_include in "
21440  ".debug_macro section"));
21441  }
21442  else
21443  {
21444  *slot = (void *) new_mac_ptr;
21445 
21446  dwarf_decode_macro_bytes (include_bfd, new_mac_ptr,
21447  include_mac_end, current_file, lh,
21448  section, section_is_gnu, is_dwz,
21449  offset_size, include_hash);
21450 
21451  htab_remove_elt (include_hash, (void *) new_mac_ptr);
21452  }
21453  }
21454  break;
21455 
21456  case DW_MACINFO_vendor_ext:
21457  if (!section_is_gnu)
21458  {
21459  unsigned int bytes_read;
21460  int constant;
21461 
21462  constant = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
21463  mac_ptr += bytes_read;
21464  read_direct_string (abfd, mac_ptr, &bytes_read);
21465  mac_ptr += bytes_read;
21466 
21467  /* We don't recognize any vendor extensions. */
21468  break;
21469  }
21470  /* FALLTHROUGH */
21471 
21472  default:
21473  mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
21474  mac_ptr, mac_end, abfd, offset_size,
21475  section);
21476  if (mac_ptr == NULL)
21477  return;
21478  break;
21479  }
21480  } while (macinfo_type != 0);
21481 }
21482 
21483 static void
21484 dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset,
21485  int section_is_gnu)
21486 {
21487  struct objfile *objfile = dwarf2_per_objfile->objfile;
21488  struct line_header *lh = cu->line_header;
21489  bfd *abfd;
21490  const gdb_byte *mac_ptr, *mac_end;
21491  struct macro_source_file *current_file = 0;
21492  enum dwarf_macro_record_type macinfo_type;
21493  unsigned int offset_size = cu->header.offset_size;
21494  const gdb_byte *opcode_definitions[256];
21495  struct cleanup *cleanup;
21496  htab_t include_hash;
21497  void **slot;
21498  struct dwarf2_section_info *section;
21499  const char *section_name;
21500 
21501  if (cu->dwo_unit != NULL)
21502  {
21503  if (section_is_gnu)
21504  {
21505  section = &cu->dwo_unit->dwo_file->sections.macro;
21506  section_name = ".debug_macro.dwo";
21507  }
21508  else
21509  {
21510  section = &cu->dwo_unit->dwo_file->sections.macinfo;
21511  section_name = ".debug_macinfo.dwo";
21512  }
21513  }
21514  else
21515  {
21516  if (section_is_gnu)
21517  {
21518  section = &dwarf2_per_objfile->macro;
21519  section_name = ".debug_macro";
21520  }
21521  else
21522  {
21523  section = &dwarf2_per_objfile->macinfo;
21524  section_name = ".debug_macinfo";
21525  }
21526  }
21527 
21528  dwarf2_read_section (objfile, section);
21529  if (section->buffer == NULL)
21530  {
21531  complaint (&symfile_complaints, _("missing %s section"), section_name);
21532  return;
21533  }
21534  abfd = get_section_bfd_owner (section);
21535 
21536  /* First pass: Find the name of the base filename.
21537  This filename is needed in order to process all macros whose definition
21538  (or undefinition) comes from the command line. These macros are defined
21539  before the first DW_MACINFO_start_file entry, and yet still need to be
21540  associated to the base file.
21541 
21542  To determine the base file name, we scan the macro definitions until we
21543  reach the first DW_MACINFO_start_file entry. We then initialize
21544  CURRENT_FILE accordingly so that any macro definition found before the
21545  first DW_MACINFO_start_file can still be associated to the base file. */
21546 
21547  mac_ptr = section->buffer + offset;
21548  mac_end = section->buffer + section->size;
21549 
21550  mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
21551  &offset_size, section_is_gnu);
21552  if (mac_ptr == NULL)
21553  {
21554  /* We already issued a complaint. */
21555  return;
21556  }
21557 
21558  do
21559  {
21560  /* Do we at least have room for a macinfo type byte? */
21561  if (mac_ptr >= mac_end)
21562  {
21563  /* Complaint is printed during the second pass as GDB will probably
21564  stop the first pass earlier upon finding
21565  DW_MACINFO_start_file. */
21566  break;
21567  }
21568 
21569  macinfo_type = read_1_byte (abfd, mac_ptr);
21570  mac_ptr++;
21571 
21572  /* Note that we rely on the fact that the corresponding GNU and
21573  DWARF constants are the same. */
21574  switch (macinfo_type)
21575  {
21576  /* A zero macinfo type indicates the end of the macro
21577  information. */
21578  case 0:
21579  break;
21580 
21581  case DW_MACRO_GNU_define:
21582  case DW_MACRO_GNU_undef:
21583  /* Only skip the data by MAC_PTR. */
21584  {
21585  unsigned int bytes_read;
21586 
21587  read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
21588  mac_ptr += bytes_read;
21589  read_direct_string (abfd, mac_ptr, &bytes_read);
21590  mac_ptr += bytes_read;
21591  }
21592  break;
21593 
21594  case DW_MACRO_GNU_start_file:
21595  {
21596  unsigned int bytes_read;
21597  int line, file;
21598 
21599  line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
21600  mac_ptr += bytes_read;
21601  file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
21602  mac_ptr += bytes_read;
21603 
21604  current_file = macro_start_file (file, line, current_file, lh);
21605  }
21606  break;
21607 
21608  case DW_MACRO_GNU_end_file:
21609  /* No data to skip by MAC_PTR. */
21610  break;
21611 
21612  case DW_MACRO_GNU_define_indirect:
21613  case DW_MACRO_GNU_undef_indirect:
21614  case DW_MACRO_GNU_define_indirect_alt:
21615  case DW_MACRO_GNU_undef_indirect_alt:
21616  {
21617  unsigned int bytes_read;
21618 
21619  read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
21620  mac_ptr += bytes_read;
21621  mac_ptr += offset_size;
21622  }
21623  break;
21624 
21625  case DW_MACRO_GNU_transparent_include:
21626  case DW_MACRO_GNU_transparent_include_alt:
21627  /* Note that, according to the spec, a transparent include
21628  chain cannot call DW_MACRO_GNU_start_file. So, we can just
21629  skip this opcode. */
21630  mac_ptr += offset_size;
21631  break;
21632 
21633  case DW_MACINFO_vendor_ext:
21634  /* Only skip the data by MAC_PTR. */
21635  if (!section_is_gnu)
21636  {
21637  unsigned int bytes_read;
21638 
21639  read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
21640  mac_ptr += bytes_read;
21641  read_direct_string (abfd, mac_ptr, &bytes_read);
21642  mac_ptr += bytes_read;
21643  }
21644  /* FALLTHROUGH */
21645 
21646  default:
21647  mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
21648  mac_ptr, mac_end, abfd, offset_size,
21649  section);
21650  if (mac_ptr == NULL)
21651  return;
21652  break;
21653  }
21654  } while (macinfo_type != 0 && current_file == NULL);
21655 
21656  /* Second pass: Process all entries.
21657 
21658  Use the AT_COMMAND_LINE flag to determine whether we are still processing
21659  command-line macro definitions/undefinitions. This flag is unset when we
21660  reach the first DW_MACINFO_start_file entry. */
21661 
21662  include_hash = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
21663  NULL, xcalloc, xfree);
21664  cleanup = make_cleanup_htab_delete (include_hash);
21665  mac_ptr = section->buffer + offset;
21666  slot = htab_find_slot (include_hash, mac_ptr, INSERT);
21667  *slot = (void *) mac_ptr;
21668  dwarf_decode_macro_bytes (abfd, mac_ptr, mac_end,
21669  current_file, lh, section,
21670  section_is_gnu, 0, offset_size, include_hash);
21671  do_cleanups (cleanup);
21672 }
21673 
21674 /* Check if the attribute's form is a DW_FORM_block*
21675  if so return true else false. */
21676 
21677 static int
21678 attr_form_is_block (const struct attribute *attr)
21679 {
21680  return (attr == NULL ? 0 :
21681  attr->form == DW_FORM_block1
21682  || attr->form == DW_FORM_block2
21683  || attr->form == DW_FORM_block4
21684  || attr->form == DW_FORM_block
21685  || attr->form == DW_FORM_exprloc);
21686 }
21687 
21688 /* Return non-zero if ATTR's value is a section offset --- classes
21689  lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
21690  You may use DW_UNSND (attr) to retrieve such offsets.
21691 
21692  Section 7.5.4, "Attribute Encodings", explains that no attribute
21693  may have a value that belongs to more than one of these classes; it
21694  would be ambiguous if we did, because we use the same forms for all
21695  of them. */
21696 
21697 static int
21699 {
21700  return (attr->form == DW_FORM_data4
21701  || attr->form == DW_FORM_data8
21702  || attr->form == DW_FORM_sec_offset);
21703 }
21704 
21705 /* Return non-zero if ATTR's value falls in the 'constant' class, or
21706  zero otherwise. When this function returns true, you can apply
21707  dwarf2_get_attr_constant_value to it.
21708 
21709  However, note that for some attributes you must check
21710  attr_form_is_section_offset before using this test. DW_FORM_data4
21711  and DW_FORM_data8 are members of both the constant class, and of
21712  the classes that contain offsets into other debug sections
21713  (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
21714  that, if an attribute's can be either a constant or one of the
21715  section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
21716  taken as section offsets, not constants. */
21717 
21718 static int
21719 attr_form_is_constant (const struct attribute *attr)
21720 {
21721  switch (attr->form)
21722  {
21723  case DW_FORM_sdata:
21724  case DW_FORM_udata:
21725  case DW_FORM_data1:
21726  case DW_FORM_data2:
21727  case DW_FORM_data4:
21728  case DW_FORM_data8:
21729  return 1;
21730  default:
21731  return 0;
21732  }
21733 }
21734 
21735 
21736 /* DW_ADDR is always stored already as sect_offset; despite for the forms
21737  besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
21738 
21739 static int
21740 attr_form_is_ref (const struct attribute *attr)
21741 {
21742  switch (attr->form)
21743  {
21744  case DW_FORM_ref_addr:
21745  case DW_FORM_ref1:
21746  case DW_FORM_ref2:
21747  case DW_FORM_ref4:
21748  case DW_FORM_ref8:
21749  case DW_FORM_ref_udata:
21750  case DW_FORM_GNU_ref_alt:
21751  return 1;
21752  default:
21753  return 0;
21754  }
21755 }
21756 
21757 /* Return the .debug_loc section to use for CU.
21758  For DWO files use .debug_loc.dwo. */
21759 
21760 static struct dwarf2_section_info *
21762 {
21763  if (cu->dwo_unit)
21764  return &cu->dwo_unit->dwo_file->sections.loc;
21765  return &dwarf2_per_objfile->loc;
21766 }
21767 
21768 /* A helper function that fills in a dwarf2_loclist_baton. */
21769 
21770 static void
21772  struct dwarf2_loclist_baton *baton,
21773  const struct attribute *attr)
21774 {
21775  struct dwarf2_section_info *section = cu_debug_loc_section (cu);
21776 
21777  dwarf2_read_section (dwarf2_per_objfile->objfile, section);
21778 
21779  baton->per_cu = cu->per_cu;
21780  gdb_assert (baton->per_cu);
21781  /* We don't know how long the location list is, but make sure we
21782  don't run off the edge of the section. */
21783  baton->size = section->size - DW_UNSND (attr);
21784  baton->data = section->buffer + DW_UNSND (attr);
21785  baton->base_address = cu->base_address;
21786  baton->from_dwo = cu->dwo_unit != NULL;
21787 }
21788 
21789 static void
21790 dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym,
21791  struct dwarf2_cu *cu, int is_block)
21792 {
21793  struct objfile *objfile = dwarf2_per_objfile->objfile;
21794  struct dwarf2_section_info *section = cu_debug_loc_section (cu);
21795 
21796  if (attr_form_is_section_offset (attr)
21797  /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
21798  the section. If so, fall through to the complaint in the
21799  other branch. */
21800  && DW_UNSND (attr) < dwarf2_section_size (objfile, section))
21801  {
21802  struct dwarf2_loclist_baton *baton;
21803 
21804  baton = obstack_alloc (&objfile->objfile_obstack,
21805  sizeof (struct dwarf2_loclist_baton));
21806 
21807  fill_in_loclist_baton (cu, baton, attr);
21808 
21809  if (cu->base_known == 0)
21811  _("Location list used without "
21812  "specifying the CU base address."));
21813 
21814  SYMBOL_ACLASS_INDEX (sym) = (is_block
21815  ? dwarf2_loclist_block_index
21817  SYMBOL_LOCATION_BATON (sym) = baton;
21818  }
21819  else
21820  {
21821  struct dwarf2_locexpr_baton *baton;
21822 
21823  baton = obstack_alloc (&objfile->objfile_obstack,
21824  sizeof (struct dwarf2_locexpr_baton));
21825  baton->per_cu = cu->per_cu;
21826  gdb_assert (baton->per_cu);
21827 
21828  if (attr_form_is_block (attr))
21829  {
21830  /* Note that we're just copying the block's data pointer
21831  here, not the actual data. We're still pointing into the
21832  info_buffer for SYM's objfile; right now we never release
21833  that buffer, but when we do clean up properly this may
21834  need to change. */
21835  baton->size = DW_BLOCK (attr)->size;
21836  baton->data = DW_BLOCK (attr)->data;
21837  }
21838  else
21839  {
21840  dwarf2_invalid_attrib_class_complaint ("location description",
21841  SYMBOL_NATURAL_NAME (sym));
21842  baton->size = 0;
21843  }
21844 
21845  SYMBOL_ACLASS_INDEX (sym) = (is_block
21846  ? dwarf2_locexpr_block_index
21848  SYMBOL_LOCATION_BATON (sym) = baton;
21849  }
21850 }
21851 
21852 /* Return the OBJFILE associated with the compilation unit CU. If CU
21853  came from a separate debuginfo file, then the master objfile is
21854  returned. */
21855 
21856 struct objfile *
21858 {
21859  struct objfile *objfile = per_cu->objfile;
21860 
21861  /* Return the master objfile, so that we can report and look up the
21862  correct file containing this variable. */
21863  if (objfile->separate_debug_objfile_backlink)
21864  objfile = objfile->separate_debug_objfile_backlink;
21865 
21866  return objfile;
21867 }
21868 
21869 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
21870  (CU_HEADERP is unused in such case) or prepare a temporary copy at
21871  CU_HEADERP first. */
21872 
21873 static const struct comp_unit_head *
21875  struct dwarf2_per_cu_data *per_cu)
21876 {
21877  const gdb_byte *info_ptr;
21878 
21879  if (per_cu->cu)
21880  return &per_cu->cu->header;
21881 
21882  info_ptr = per_cu->section->buffer + per_cu->offset.sect_off;
21883 
21884  memset (cu_headerp, 0, sizeof (*cu_headerp));
21885  read_comp_unit_head (cu_headerp, info_ptr, per_cu->objfile->obfd);
21886 
21887  return cu_headerp;
21888 }
21889 
21890 /* Return the address size given in the compilation unit header for CU. */
21891 
21892 int
21894 {
21895  struct comp_unit_head cu_header_local;
21896  const struct comp_unit_head *cu_headerp;
21897 
21898  cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
21899 
21900  return cu_headerp->addr_size;
21901 }
21902 
21903 /* Return the offset size given in the compilation unit header for CU. */
21904 
21905 int
21907 {
21908  struct comp_unit_head cu_header_local;
21909  const struct comp_unit_head *cu_headerp;
21910 
21911  cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
21912 
21913  return cu_headerp->offset_size;
21914 }
21915 
21916 /* See its dwarf2loc.h declaration. */
21917 
21918 int
21920 {
21921  struct comp_unit_head cu_header_local;
21922  const struct comp_unit_head *cu_headerp;
21923 
21924  cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
21925 
21926  if (cu_headerp->version == 2)
21927  return cu_headerp->addr_size;
21928  else
21929  return cu_headerp->offset_size;
21930 }
21931 
21932 /* Return the text offset of the CU. The returned offset comes from
21933  this CU's objfile. If this objfile came from a separate debuginfo
21934  file, then the offset may be different from the corresponding
21935  offset in the parent objfile. */
21936 
21937 CORE_ADDR
21939 {
21940  struct objfile *objfile = per_cu->objfile;
21941 
21942  return ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
21943 }
21944 
21945 /* Locate the .debug_info compilation unit from CU's objfile which contains
21946  the DIE at OFFSET. Raises an error on failure. */
21947 
21948 static struct dwarf2_per_cu_data *
21950  unsigned int offset_in_dwz,
21951  struct objfile *objfile)
21952 {
21953  struct dwarf2_per_cu_data *this_cu;
21954  int low, high;
21955  const sect_offset *cu_off;
21956 
21957  low = 0;
21958  high = dwarf2_per_objfile->n_comp_units - 1;
21959  while (high > low)
21960  {
21961  struct dwarf2_per_cu_data *mid_cu;
21962  int mid = low + (high - low) / 2;
21963 
21964  mid_cu = dwarf2_per_objfile->all_comp_units[mid];
21965  cu_off = &mid_cu->offset;
21966  if (mid_cu->is_dwz > offset_in_dwz
21967  || (mid_cu->is_dwz == offset_in_dwz
21968  && cu_off->sect_off >= offset.sect_off))
21969  high = mid;
21970  else
21971  low = mid + 1;
21972  }
21973  gdb_assert (low == high);
21974  this_cu = dwarf2_per_objfile->all_comp_units[low];
21975  cu_off = &this_cu->offset;
21976  if (this_cu->is_dwz != offset_in_dwz || cu_off->sect_off > offset.sect_off)
21977  {
21978  if (low == 0 || this_cu->is_dwz != offset_in_dwz)
21979  error (_("Dwarf Error: could not find partial DIE containing "
21980  "offset 0x%lx [in module %s]"),
21981  (long) offset.sect_off, bfd_get_filename (objfile->obfd));
21982 
21983  gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->offset.sect_off
21984  <= offset.sect_off);
21985  return dwarf2_per_objfile->all_comp_units[low-1];
21986  }
21987  else
21988  {
21989  this_cu = dwarf2_per_objfile->all_comp_units[low];
21990  if (low == dwarf2_per_objfile->n_comp_units - 1
21991  && offset.sect_off >= this_cu->offset.sect_off + this_cu->length)
21992  error (_("invalid dwarf2 offset %u"), offset.sect_off);
21993  gdb_assert (offset.sect_off < this_cu->offset.sect_off + this_cu->length);
21994  return this_cu;
21995  }
21996 }
21997 
21998 /* Initialize dwarf2_cu CU, owned by PER_CU. */
21999 
22000 static void
22002 {
22003  memset (cu, 0, sizeof (*cu));
22004  per_cu->cu = cu;
22005  cu->per_cu = per_cu;
22006  cu->objfile = per_cu->objfile;
22007  obstack_init (&cu->comp_unit_obstack);
22008 }
22009 
22010 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
22011 
22012 static void
22013 prepare_one_comp_unit (struct dwarf2_cu *cu, struct die_info *comp_unit_die,
22014  enum language pretend_language)
22015 {
22016  struct attribute *attr;
22017 
22018  /* Set the language we're debugging. */
22019  attr = dwarf2_attr (comp_unit_die, DW_AT_language, cu);
22020  if (attr)
22021  set_cu_language (DW_UNSND (attr), cu);
22022  else
22023  {
22024  cu->language = pretend_language;
22025  cu->language_defn = language_def (cu->language);
22026  }
22027 
22028  attr = dwarf2_attr (comp_unit_die, DW_AT_producer, cu);
22029  if (attr)
22030  cu->producer = DW_STRING (attr);
22031 }
22032 
22033 /* Release one cached compilation unit, CU. We unlink it from the tree
22034  of compilation units, but we don't remove it from the read_in_chain;
22035  the caller is responsible for that.
22036  NOTE: DATA is a void * because this function is also used as a
22037  cleanup routine. */
22038 
22039 static void
22041 {
22042  struct dwarf2_cu *cu = data;
22043 
22044  gdb_assert (cu->per_cu != NULL);
22045  cu->per_cu->cu = NULL;
22046  cu->per_cu = NULL;
22047 
22048  obstack_free (&cu->comp_unit_obstack, NULL);
22049 
22050  xfree (cu);
22051 }
22052 
22053 /* This cleanup function is passed the address of a dwarf2_cu on the stack
22054  when we're finished with it. We can't free the pointer itself, but be
22055  sure to unlink it from the cache. Also release any associated storage. */
22056 
22057 static void
22059 {
22060  struct dwarf2_cu *cu = data;
22061 
22062  gdb_assert (cu->per_cu != NULL);
22063  cu->per_cu->cu = NULL;
22064  cu->per_cu = NULL;
22065 
22066  obstack_free (&cu->comp_unit_obstack, NULL);
22067  cu->partial_dies = NULL;
22068 }
22069 
22070 /* Free all cached compilation units. */
22071 
22072 static void
22074 {
22075  struct dwarf2_per_cu_data *per_cu, **last_chain;
22076 
22077  per_cu = dwarf2_per_objfile->read_in_chain;
22078  last_chain = &dwarf2_per_objfile->read_in_chain;
22079  while (per_cu != NULL)
22080  {
22081  struct dwarf2_per_cu_data *next_cu;
22082 
22083  next_cu = per_cu->cu->read_in_chain;
22084 
22085  free_heap_comp_unit (per_cu->cu);
22086  *last_chain = next_cu;
22087 
22088  per_cu = next_cu;
22089  }
22090 }
22091 
22092 /* Increase the age counter on each cached compilation unit, and free
22093  any that are too old. */
22094 
22095 static void
22097 {
22098  struct dwarf2_per_cu_data *per_cu, **last_chain;
22099 
22100  dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
22101  per_cu = dwarf2_per_objfile->read_in_chain;
22102  while (per_cu != NULL)
22103  {
22104  per_cu->cu->last_used ++;
22105  if (per_cu->cu->last_used <= dwarf_max_cache_age)
22106  dwarf2_mark (per_cu->cu);
22107  per_cu = per_cu->cu->read_in_chain;
22108  }
22109 
22110  per_cu = dwarf2_per_objfile->read_in_chain;
22111  last_chain = &dwarf2_per_objfile->read_in_chain;
22112  while (per_cu != NULL)
22113  {
22114  struct dwarf2_per_cu_data *next_cu;
22115 
22116  next_cu = per_cu->cu->read_in_chain;
22117 
22118  if (!per_cu->cu->mark)
22119  {
22120  free_heap_comp_unit (per_cu->cu);
22121  *last_chain = next_cu;
22122  }
22123  else
22124  last_chain = &per_cu->cu->read_in_chain;
22125 
22126  per_cu = next_cu;
22127  }
22128 }
22129 
22130 /* Remove a single compilation unit from the cache. */
22131 
22132 static void
22134 {
22135  struct dwarf2_per_cu_data *per_cu, **last_chain;
22136 
22137  per_cu = dwarf2_per_objfile->read_in_chain;
22138  last_chain = &dwarf2_per_objfile->read_in_chain;
22139  while (per_cu != NULL)
22140  {
22141  struct dwarf2_per_cu_data *next_cu;
22142 
22143  next_cu = per_cu->cu->read_in_chain;
22144 
22145  if (per_cu == target_per_cu)
22146  {
22147  free_heap_comp_unit (per_cu->cu);
22148  per_cu->cu = NULL;
22149  *last_chain = next_cu;
22150  break;
22151  }
22152  else
22153  last_chain = &per_cu->cu->read_in_chain;
22154 
22155  per_cu = next_cu;
22156  }
22157 }
22158 
22159 /* Release all extra memory associated with OBJFILE. */
22160 
22161 void
22162 dwarf2_free_objfile (struct objfile *objfile)
22163 {
22164  dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
22165 
22166  if (dwarf2_per_objfile == NULL)
22167  return;
22168 
22169  /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
22170  free_cached_comp_units (NULL);
22171 
22172  if (dwarf2_per_objfile->quick_file_names_table)
22173  htab_delete (dwarf2_per_objfile->quick_file_names_table);
22174 
22175  if (dwarf2_per_objfile->line_header_hash)
22176  htab_delete (dwarf2_per_objfile->line_header_hash);
22177 
22178  /* Everything else should be on the objfile obstack. */
22179 }
22180 
22181 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
22182  We store these in a hash table separate from the DIEs, and preserve them
22183  when the DIEs are flushed out of cache.
22184 
22185  The CU "per_cu" pointer is needed because offset alone is not enough to
22186  uniquely identify the type. A file may have multiple .debug_types sections,
22187  or the type may come from a DWO file. Furthermore, while it's more logical
22188  to use per_cu->section+offset, with Fission the section with the data is in
22189  the DWO file but we don't know that section at the point we need it.
22190  We have to use something in dwarf2_per_cu_data (or the pointer to it)
22191  because we can enter the lookup routine, get_die_type_at_offset, from
22192  outside this file, and thus won't necessarily have PER_CU->cu.
22193  Fortunately, PER_CU is stable for the life of the objfile. */
22194 
22196 {
22199  struct type *type;
22200 };
22201 
22202 /* Hash function for a dwarf2_per_cu_offset_and_type. */
22203 
22204 static hashval_t
22206 {
22207  const struct dwarf2_per_cu_offset_and_type *ofs = item;
22208 
22209  return (uintptr_t) ofs->per_cu + ofs->offset.sect_off;
22210 }
22211 
22212 /* Equality function for a dwarf2_per_cu_offset_and_type. */
22213 
22214 static int
22215 per_cu_offset_and_type_eq (const void *item_lhs, const void *item_rhs)
22216 {
22217  const struct dwarf2_per_cu_offset_and_type *ofs_lhs = item_lhs;
22218  const struct dwarf2_per_cu_offset_and_type *ofs_rhs = item_rhs;
22219 
22220  return (ofs_lhs->per_cu == ofs_rhs->per_cu
22221  && ofs_lhs->offset.sect_off == ofs_rhs->offset.sect_off);
22222 }
22223 
22224 /* Set the type associated with DIE to TYPE. Save it in CU's hash
22225  table if necessary. For convenience, return TYPE.
22226 
22227  The DIEs reading must have careful ordering to:
22228  * Not cause infite loops trying to read in DIEs as a prerequisite for
22229  reading current DIE.
22230  * Not trying to dereference contents of still incompletely read in types
22231  while reading in other DIEs.
22232  * Enable referencing still incompletely read in types just by a pointer to
22233  the type without accessing its fields.
22234 
22235  Therefore caller should follow these rules:
22236  * Try to fetch any prerequisite types we may need to build this DIE type
22237  before building the type and calling set_die_type.
22238  * After building type call set_die_type for current DIE as soon as
22239  possible before fetching more types to complete the current type.
22240  * Make the type as complete as possible before fetching more types. */
22241 
22242 static struct type *
22243 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
22244 {
22245  struct dwarf2_per_cu_offset_and_type **slot, ofs;
22246  struct objfile *objfile = cu->objfile;
22247  struct attribute *attr;
22248  struct dynamic_prop prop;
22249 
22250  /* For Ada types, make sure that the gnat-specific data is always
22251  initialized (if not already set). There are a few types where
22252  we should not be doing so, because the type-specific area is
22253  already used to hold some other piece of info (eg: TYPE_CODE_FLT
22254  where the type-specific area is used to store the floatformat).
22255  But this is not a problem, because the gnat-specific information
22256  is actually not needed for these types. */
22257  if (need_gnat_info (cu)
22258  && TYPE_CODE (type) != TYPE_CODE_FUNC
22259  && TYPE_CODE (type) != TYPE_CODE_FLT
22260  && TYPE_CODE (type) != TYPE_CODE_METHODPTR
22261  && TYPE_CODE (type) != TYPE_CODE_MEMBERPTR
22262  && TYPE_CODE (type) != TYPE_CODE_METHOD
22263  && !HAVE_GNAT_AUX_INFO (type))
22264  INIT_GNAT_SPECIFIC (type);
22265 
22266  /* Read DW_AT_data_location and set in type. */
22267  attr = dwarf2_attr (die, DW_AT_data_location, cu);
22268  if (attr_to_dynamic_prop (attr, die, cu, &prop))
22269  add_dyn_prop (DYN_PROP_DATA_LOCATION, prop, type, objfile);
22270 
22271  if (dwarf2_per_objfile->die_type_hash == NULL)
22272  {
22273  dwarf2_per_objfile->die_type_hash =
22274  htab_create_alloc_ex (127,
22277  NULL,
22278  &objfile->objfile_obstack,
22281  }
22282 
22283  ofs.per_cu = cu->per_cu;
22284  ofs.offset = die->offset;
22285  ofs.type = type;
22286  slot = (struct dwarf2_per_cu_offset_and_type **)
22287  htab_find_slot (dwarf2_per_objfile->die_type_hash, &ofs, INSERT);
22288  if (*slot)
22290  _("A problem internal to GDB: DIE 0x%x has type already set"),
22291  die->offset.sect_off);
22292  *slot = obstack_alloc (&objfile->objfile_obstack, sizeof (**slot));
22293  **slot = ofs;
22294  return type;
22295 }
22296 
22297 /* Look up the type for the die at OFFSET in PER_CU in die_type_hash,
22298  or return NULL if the die does not have a saved type. */
22299 
22300 static struct type *
22302  struct dwarf2_per_cu_data *per_cu)
22303 {
22304  struct dwarf2_per_cu_offset_and_type *slot, ofs;
22305 
22306  if (dwarf2_per_objfile->die_type_hash == NULL)
22307  return NULL;
22308 
22309  ofs.per_cu = per_cu;
22310  ofs.offset = offset;
22311  slot = htab_find (dwarf2_per_objfile->die_type_hash, &ofs);
22312  if (slot)
22313  return slot->type;
22314  else
22315  return NULL;
22316 }
22317 
22318 /* Look up the type for DIE in CU in die_type_hash,
22319  or return NULL if DIE does not have a saved type. */
22320 
22321 static struct type *
22322 get_die_type (struct die_info *die, struct dwarf2_cu *cu)
22323 {
22324  return get_die_type_at_offset (die->offset, cu->per_cu);
22325 }
22326 
22327 /* Add a dependence relationship from CU to REF_PER_CU. */
22328 
22329 static void
22331  struct dwarf2_per_cu_data *ref_per_cu)
22332 {
22333  void **slot;
22334 
22335  if (cu->dependencies == NULL)
22336  cu->dependencies
22337  = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
22338  NULL, &cu->comp_unit_obstack,
22341 
22342  slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
22343  if (*slot == NULL)
22344  *slot = ref_per_cu;
22345 }
22346 
22347 /* Subroutine of dwarf2_mark to pass to htab_traverse.
22348  Set the mark field in every compilation unit in the
22349  cache that we must keep because we are keeping CU. */
22350 
22351 static int
22352 dwarf2_mark_helper (void **slot, void *data)
22353 {
22354  struct dwarf2_per_cu_data *per_cu;
22355 
22356  per_cu = (struct dwarf2_per_cu_data *) *slot;
22357 
22358  /* cu->dependencies references may not yet have been ever read if QUIT aborts
22359  reading of the chain. As such dependencies remain valid it is not much
22360  useful to track and undo them during QUIT cleanups. */
22361  if (per_cu->cu == NULL)
22362  return 1;
22363 
22364  if (per_cu->cu->mark)
22365  return 1;
22366  per_cu->cu->mark = 1;
22367 
22368  if (per_cu->cu->dependencies != NULL)
22369  htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
22370 
22371  return 1;
22372 }
22373 
22374 /* Set the mark field in CU and in every other compilation unit in the
22375  cache that we must keep because we are keeping CU. */
22376 
22377 static void
22379 {
22380  if (cu->mark)
22381  return;
22382  cu->mark = 1;
22383  if (cu->dependencies != NULL)
22384  htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
22385 }
22386 
22387 static void
22389 {
22390  while (per_cu)
22391  {
22392  per_cu->cu->mark = 0;
22393  per_cu = per_cu->cu->read_in_chain;
22394  }
22395 }
22396 
22397 /* Trivial hash function for partial_die_info: the hash value of a DIE
22398  is its offset in .debug_info for this objfile. */
22399 
22400 static hashval_t
22401 partial_die_hash (const void *item)
22402 {
22403  const struct partial_die_info *part_die = item;
22404 
22405  return part_die->offset.sect_off;
22406 }
22407 
22408 /* Trivial comparison function for partial_die_info structures: two DIEs
22409  are equal if they have the same offset. */
22410 
22411 static int
22412 partial_die_eq (const void *item_lhs, const void *item_rhs)
22413 {
22414  const struct partial_die_info *part_die_lhs = item_lhs;
22415  const struct partial_die_info *part_die_rhs = item_rhs;
22416 
22417  return part_die_lhs->offset.sect_off == part_die_rhs->offset.sect_off;
22418 }
22419 
22422 
22423 static void
22424 set_dwarf_cmd (char *args, int from_tty)
22425 {
22426  help_list (set_dwarf_cmdlist, "maintenance set dwarf ", all_commands,
22427  gdb_stdout);
22428 }
22429 
22430 static void
22431 show_dwarf_cmd (char *args, int from_tty)
22432 {
22433  cmd_show_list (show_dwarf_cmdlist, from_tty, "");
22434 }
22435 
22436 /* Free data associated with OBJFILE, if necessary. */
22437 
22438 static void
22439 dwarf2_per_objfile_free (struct objfile *objfile, void *d)
22440 {
22441  struct dwarf2_per_objfile *data = d;
22442  int ix;
22443 
22444  /* Make sure we don't accidentally use dwarf2_per_objfile while
22445  cleaning up. */
22446  dwarf2_per_objfile = NULL;
22447 
22448  for (ix = 0; ix < data->n_comp_units; ++ix)
22449  VEC_free (dwarf2_per_cu_ptr, data->all_comp_units[ix]->imported_symtabs);
22450 
22451  for (ix = 0; ix < data->n_type_units; ++ix)
22452  VEC_free (dwarf2_per_cu_ptr,
22453  data->all_type_units[ix]->per_cu.imported_symtabs);
22454  xfree (data->all_type_units);
22455 
22456  VEC_free (dwarf2_section_info_def, data->types);
22457 
22458  if (data->dwo_files)
22459  free_dwo_files (data->dwo_files, objfile);
22460  if (data->dwp_file)
22461  gdb_bfd_unref (data->dwp_file->dbfd);
22462 
22463  if (data->dwz_file && data->dwz_file->dwz_bfd)
22464  gdb_bfd_unref (data->dwz_file->dwz_bfd);
22465 }
22466 
22467 
22468 /* The "save gdb-index" command. */
22469 
22470 /* The contents of the hash table we create when building the string
22471  table. */
22473 {
22474  offset_type offset;
22475  const char *str;
22476 };
22477 
22478 /* Hash function for a strtab_entry.
22479 
22480  Function is used only during write_hash_table so no index format backward
22481  compatibility is needed. */
22482 
22483 static hashval_t
22484 hash_strtab_entry (const void *e)
22485 {
22486  const struct strtab_entry *entry = e;
22487  return mapped_index_string_hash (INT_MAX, entry->str);
22488 }
22489 
22490 /* Equality function for a strtab_entry. */
22491 
22492 static int
22493 eq_strtab_entry (const void *a, const void *b)
22494 {
22495  const struct strtab_entry *ea = a;
22496  const struct strtab_entry *eb = b;
22497  return !strcmp (ea->str, eb->str);
22498 }
22499 
22500 /* Create a strtab_entry hash table. */
22501 
22502 static htab_t
22504 {
22505  return htab_create_alloc (100, hash_strtab_entry, eq_strtab_entry,
22506  xfree, xcalloc, xfree);
22507 }
22508 
22509 /* Add a string to the constant pool. Return the string's offset in
22510  host order. */
22511 
22512 static offset_type
22513 add_string (htab_t table, struct obstack *cpool, const char *str)
22514 {
22515  void **slot;
22516  struct strtab_entry entry;
22517  struct strtab_entry *result;
22518 
22519  entry.str = str;
22520  slot = htab_find_slot (table, &entry, INSERT);
22521  if (*slot)
22522  result = *slot;
22523  else
22524  {
22525  result = XNEW (struct strtab_entry);
22526  result->offset = obstack_object_size (cpool);
22527  result->str = str;
22528  obstack_grow_str0 (cpool, str);
22529  *slot = result;
22530  }
22531  return result->offset;
22532 }
22533 
22534 /* An entry in the symbol table. */
22536 {
22537  /* The name of the symbol. */
22538  const char *name;
22539  /* The offset of the name in the constant pool. */
22540  offset_type index_offset;
22541  /* A sorted vector of the indices of all the CUs that hold an object
22542  of this name. */
22543  VEC (offset_type) *cu_indices;
22544 };
22545 
22546 /* The symbol table. This is a power-of-2-sized hash table. */
22548 {
22549  offset_type n_elements;
22550  offset_type size;
22552 };
22553 
22554 /* Hash function for a symtab_index_entry. */
22555 
22556 static hashval_t
22557 hash_symtab_entry (const void *e)
22558 {
22559  const struct symtab_index_entry *entry = e;
22560  return iterative_hash (VEC_address (offset_type, entry->cu_indices),
22561  sizeof (offset_type) * VEC_length (offset_type,
22562  entry->cu_indices),
22563  0);
22564 }
22565 
22566 /* Equality function for a symtab_index_entry. */
22567 
22568 static int
22569 eq_symtab_entry (const void *a, const void *b)
22570 {
22571  const struct symtab_index_entry *ea = a;
22572  const struct symtab_index_entry *eb = b;
22573  int len = VEC_length (offset_type, ea->cu_indices);
22574  if (len != VEC_length (offset_type, eb->cu_indices))
22575  return 0;
22576  return !memcmp (VEC_address (offset_type, ea->cu_indices),
22577  VEC_address (offset_type, eb->cu_indices),
22578  sizeof (offset_type) * len);
22579 }
22580 
22581 /* Destroy a symtab_index_entry. */
22582 
22583 static void
22585 {
22586  struct symtab_index_entry *entry = p;
22587  VEC_free (offset_type, entry->cu_indices);
22588  xfree (entry);
22589 }
22590 
22591 /* Create a hash table holding symtab_index_entry objects. */
22592 
22593 static htab_t
22595 {
22596  return htab_create_alloc (100, hash_symtab_entry, eq_symtab_entry,
22598 }
22599 
22600 /* Create a new mapped symtab object. */
22601 
22602 static struct mapped_symtab *
22604 {
22605  struct mapped_symtab *symtab = XNEW (struct mapped_symtab);
22606  symtab->n_elements = 0;
22607  symtab->size = 1024;
22608  symtab->data = XCNEWVEC (struct symtab_index_entry *, symtab->size);
22609  return symtab;
22610 }
22611 
22612 /* Destroy a mapped_symtab. */
22613 
22614 static void
22616 {
22617  struct mapped_symtab *symtab = p;
22618  /* The contents of the array are freed when the other hash table is
22619  destroyed. */
22620  xfree (symtab->data);
22621  xfree (symtab);
22622 }
22623 
22624 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
22625  the slot.
22626 
22627  Function is used only during write_hash_table so no index format backward
22628  compatibility is needed. */
22629 
22630 static struct symtab_index_entry **
22631 find_slot (struct mapped_symtab *symtab, const char *name)
22632 {
22633  offset_type index, step, hash = mapped_index_string_hash (INT_MAX, name);
22634 
22635  index = hash & (symtab->size - 1);
22636  step = ((hash * 17) & (symtab->size - 1)) | 1;
22637 
22638  for (;;)
22639  {
22640  if (!symtab->data[index] || !strcmp (name, symtab->data[index]->name))
22641  return &symtab->data[index];
22642  index = (index + step) & (symtab->size - 1);
22643  }
22644 }
22645 
22646 /* Expand SYMTAB's hash table. */
22647 
22648 static void
22650 {
22651  offset_type old_size = symtab->size;
22652  offset_type i;
22653  struct symtab_index_entry **old_entries = symtab->data;
22654 
22655  symtab->size *= 2;
22656  symtab->data = XCNEWVEC (struct symtab_index_entry *, symtab->size);
22657 
22658  for (i = 0; i < old_size; ++i)
22659  {
22660  if (old_entries[i])
22661  {
22662  struct symtab_index_entry **slot = find_slot (symtab,
22663  old_entries[i]->name);
22664  *slot = old_entries[i];
22665  }
22666  }
22667 
22668  xfree (old_entries);
22669 }
22670 
22671 /* Add an entry to SYMTAB. NAME is the name of the symbol.
22672  CU_INDEX is the index of the CU in which the symbol appears.
22673  IS_STATIC is one if the symbol is static, otherwise zero (global). */
22674 
22675 static void
22676 add_index_entry (struct mapped_symtab *symtab, const char *name,
22677  int is_static, gdb_index_symbol_kind kind,
22678  offset_type cu_index)
22679 {
22680  struct symtab_index_entry **slot;
22681  offset_type cu_index_and_attrs;
22682 
22683  ++symtab->n_elements;
22684  if (4 * symtab->n_elements / 3 >= symtab->size)
22685  hash_expand (symtab);
22686 
22687  slot = find_slot (symtab, name);
22688  if (!*slot)
22689  {
22690  *slot = XNEW (struct symtab_index_entry);
22691  (*slot)->name = name;
22692  /* index_offset is set later. */
22693  (*slot)->cu_indices = NULL;
22694  }
22695 
22696  cu_index_and_attrs = 0;
22697  DW2_GDB_INDEX_CU_SET_VALUE (cu_index_and_attrs, cu_index);
22698  DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE (cu_index_and_attrs, is_static);
22699  DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE (cu_index_and_attrs, kind);
22700 
22701  /* We don't want to record an index value twice as we want to avoid the
22702  duplication.
22703  We process all global symbols and then all static symbols
22704  (which would allow us to avoid the duplication by only having to check
22705  the last entry pushed), but a symbol could have multiple kinds in one CU.
22706  To keep things simple we don't worry about the duplication here and
22707  sort and uniqufy the list after we've processed all symbols. */
22708  VEC_safe_push (offset_type, (*slot)->cu_indices, cu_index_and_attrs);
22709 }
22710 
22711 /* qsort helper routine for uniquify_cu_indices. */
22712 
22713 static int
22714 offset_type_compare (const void *ap, const void *bp)
22715 {
22716  offset_type a = *(offset_type *) ap;
22717  offset_type b = *(offset_type *) bp;
22718 
22719  return (a > b) - (b > a);
22720 }
22721 
22722 /* Sort and remove duplicates of all symbols' cu_indices lists. */
22723 
22724 static void
22726 {
22727  int i;
22728 
22729  for (i = 0; i < symtab->size; ++i)
22730  {
22731  struct symtab_index_entry *entry = symtab->data[i];
22732 
22733  if (entry
22734  && entry->cu_indices != NULL)
22735  {
22736  unsigned int next_to_insert, next_to_check;
22737  offset_type last_value;
22738 
22739  qsort (VEC_address (offset_type, entry->cu_indices),
22740  VEC_length (offset_type, entry->cu_indices),
22741  sizeof (offset_type), offset_type_compare);
22742 
22743  last_value = VEC_index (offset_type, entry->cu_indices, 0);
22744  next_to_insert = 1;
22745  for (next_to_check = 1;
22746  next_to_check < VEC_length (offset_type, entry->cu_indices);
22747  ++next_to_check)
22748  {
22749  if (VEC_index (offset_type, entry->cu_indices, next_to_check)
22750  != last_value)
22751  {
22752  last_value = VEC_index (offset_type, entry->cu_indices,
22753  next_to_check);
22754  VEC_replace (offset_type, entry->cu_indices, next_to_insert,
22755  last_value);
22756  ++next_to_insert;
22757  }
22758  }
22759  VEC_truncate (offset_type, entry->cu_indices, next_to_insert);
22760  }
22761  }
22762 }
22763 
22764 /* Add a vector of indices to the constant pool. */
22765 
22766 static offset_type
22767 add_indices_to_cpool (htab_t symbol_hash_table, struct obstack *cpool,
22768  struct symtab_index_entry *entry)
22769 {
22770  void **slot;
22771 
22772  slot = htab_find_slot (symbol_hash_table, entry, INSERT);
22773  if (!*slot)
22774  {
22775  offset_type len = VEC_length (offset_type, entry->cu_indices);
22776  offset_type val = MAYBE_SWAP (len);
22777  offset_type iter;
22778  int i;
22779 
22780  *slot = entry;
22781  entry->index_offset = obstack_object_size (cpool);
22782 
22783  obstack_grow (cpool, &val, sizeof (val));
22784  for (i = 0;
22785  VEC_iterate (offset_type, entry->cu_indices, i, iter);
22786  ++i)
22787  {
22788  val = MAYBE_SWAP (iter);
22789  obstack_grow (cpool, &val, sizeof (val));
22790  }
22791  }
22792  else
22793  {
22794  struct symtab_index_entry *old_entry = *slot;
22795  entry->index_offset = old_entry->index_offset;
22796  entry = old_entry;
22797  }
22798  return entry->index_offset;
22799 }
22800 
22801 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
22802  constant pool entries going into the obstack CPOOL. */
22803 
22804 static void
22806  struct obstack *output, struct obstack *cpool)
22807 {
22808  offset_type i;
22809  htab_t symbol_hash_table;
22810  htab_t str_table;
22811 
22812  symbol_hash_table = create_symbol_hash_table ();
22813  str_table = create_strtab ();
22814 
22815  /* We add all the index vectors to the constant pool first, to
22816  ensure alignment is ok. */
22817  for (i = 0; i < symtab->size; ++i)
22818  {
22819  if (symtab->data[i])
22820  add_indices_to_cpool (symbol_hash_table, cpool, symtab->data[i]);
22821  }
22822 
22823  /* Now write out the hash table. */
22824  for (i = 0; i < symtab->size; ++i)
22825  {
22826  offset_type str_off, vec_off;
22827 
22828  if (symtab->data[i])
22829  {
22830  str_off = add_string (str_table, cpool, symtab->data[i]->name);
22831  vec_off = symtab->data[i]->index_offset;
22832  }
22833  else
22834  {
22835  /* While 0 is a valid constant pool index, it is not valid
22836  to have 0 for both offsets. */
22837  str_off = 0;
22838  vec_off = 0;
22839  }
22840 
22841  str_off = MAYBE_SWAP (str_off);
22842  vec_off = MAYBE_SWAP (vec_off);
22843 
22844  obstack_grow (output, &str_off, sizeof (str_off));
22845  obstack_grow (output, &vec_off, sizeof (vec_off));
22846  }
22847 
22848  htab_delete (str_table);
22849  htab_delete (symbol_hash_table);
22850 }
22851 
22852 /* Struct to map psymtab to CU index in the index file. */
22854 {
22856  unsigned int cu_index;
22857 };
22858 
22859 static hashval_t
22860 hash_psymtab_cu_index (const void *item)
22861 {
22862  const struct psymtab_cu_index_map *map = item;
22863 
22864  return htab_hash_pointer (map->psymtab);
22865 }
22866 
22867 static int
22868 eq_psymtab_cu_index (const void *item_lhs, const void *item_rhs)
22869 {
22870  const struct psymtab_cu_index_map *lhs = item_lhs;
22871  const struct psymtab_cu_index_map *rhs = item_rhs;
22872 
22873  return lhs->psymtab == rhs->psymtab;
22874 }
22875 
22876 /* Helper struct for building the address table. */
22878 {
22879  struct objfile *objfile;
22880  struct obstack *addr_obstack;
22882 
22883  /* Non-zero if the previous_* fields are valid.
22884  We can't write an entry until we see the next entry (since it is only then
22885  that we know the end of the entry). */
22887  /* Index of the CU in the table of all CUs in the index file. */
22888  unsigned int previous_cu_index;
22889  /* Start address of the CU. */
22891 };
22892 
22893 /* Write an address entry to OBSTACK. */
22894 
22895 static void
22896 add_address_entry (struct objfile *objfile, struct obstack *obstack,
22897  CORE_ADDR start, CORE_ADDR end, unsigned int cu_index)
22898 {
22899  offset_type cu_index_to_write;
22900  gdb_byte addr[8];
22901  CORE_ADDR baseaddr;
22902 
22903  baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
22904 
22905  store_unsigned_integer (addr, 8, BFD_ENDIAN_LITTLE, start - baseaddr);
22906  obstack_grow (obstack, addr, 8);
22907  store_unsigned_integer (addr, 8, BFD_ENDIAN_LITTLE, end - baseaddr);
22908  obstack_grow (obstack, addr, 8);
22909  cu_index_to_write = MAYBE_SWAP (cu_index);
22910  obstack_grow (obstack, &cu_index_to_write, sizeof (offset_type));
22911 }
22912 
22913 /* Worker function for traversing an addrmap to build the address table. */
22914 
22915 static int
22916 add_address_entry_worker (void *datap, CORE_ADDR start_addr, void *obj)
22917 {
22918  struct addrmap_index_data *data = datap;
22919  struct partial_symtab *pst = obj;
22920 
22921  if (data->previous_valid)
22922  add_address_entry (data->objfile, data->addr_obstack,
22923  data->previous_cu_start, start_addr,
22924  data->previous_cu_index);
22925 
22926  data->previous_cu_start = start_addr;
22927  if (pst != NULL)
22928  {
22929  struct psymtab_cu_index_map find_map, *map;
22930  find_map.psymtab = pst;
22931  map = htab_find (data->cu_index_htab, &find_map);
22932  gdb_assert (map != NULL);
22933  data->previous_cu_index = map->cu_index;
22934  data->previous_valid = 1;
22935  }
22936  else
22937  data->previous_valid = 0;
22938 
22939  return 0;
22940 }
22941 
22942 /* Write OBJFILE's address map to OBSTACK.
22943  CU_INDEX_HTAB is used to map addrmap entries to their CU indices
22944  in the index file. */
22945 
22946 static void
22947 write_address_map (struct objfile *objfile, struct obstack *obstack,
22948  htab_t cu_index_htab)
22949 {
22950  struct addrmap_index_data addrmap_index_data;
22951 
22952  /* When writing the address table, we have to cope with the fact that
22953  the addrmap iterator only provides the start of a region; we have to
22954  wait until the next invocation to get the start of the next region. */
22955 
22956  addrmap_index_data.objfile = objfile;
22957  addrmap_index_data.addr_obstack = obstack;
22958  addrmap_index_data.cu_index_htab = cu_index_htab;
22959  addrmap_index_data.previous_valid = 0;
22960 
22962  &addrmap_index_data);
22963 
22964  /* It's highly unlikely the last entry (end address = 0xff...ff)
22965  is valid, but we should still handle it.
22966  The end address is recorded as the start of the next region, but that
22967  doesn't work here. To cope we pass 0xff...ff, this is a rare situation
22968  anyway. */
22969  if (addrmap_index_data.previous_valid)
22970  add_address_entry (objfile, obstack,
22971  addrmap_index_data.previous_cu_start, (CORE_ADDR) -1,
22972  addrmap_index_data.previous_cu_index);
22973 }
22974 
22975 /* Return the symbol kind of PSYM. */
22976 
22977 static gdb_index_symbol_kind
22979 {
22980  domain_enum domain = PSYMBOL_DOMAIN (psym);
22981  enum address_class aclass = PSYMBOL_CLASS (psym);
22982 
22983  switch (domain)
22984  {
22985  case VAR_DOMAIN:
22986  switch (aclass)
22987  {
22988  case LOC_BLOCK:
22989  return GDB_INDEX_SYMBOL_KIND_FUNCTION;
22990  case LOC_TYPEDEF:
22991  return GDB_INDEX_SYMBOL_KIND_TYPE;
22992  case LOC_COMPUTED:
22993  case LOC_CONST_BYTES:
22994  case LOC_OPTIMIZED_OUT:
22995  case LOC_STATIC:
22996  return GDB_INDEX_SYMBOL_KIND_VARIABLE;
22997  case LOC_CONST:
22998  /* Note: It's currently impossible to recognize psyms as enum values
22999  short of reading the type info. For now punt. */
23000  return GDB_INDEX_SYMBOL_KIND_VARIABLE;
23001  default:
23002  /* There are other LOC_FOO values that one might want to classify
23003  as variables, but dwarf2read.c doesn't currently use them. */
23004  return GDB_INDEX_SYMBOL_KIND_OTHER;
23005  }
23006  case STRUCT_DOMAIN:
23007  return GDB_INDEX_SYMBOL_KIND_TYPE;
23008  default:
23009  return GDB_INDEX_SYMBOL_KIND_OTHER;
23010  }
23011 }
23012 
23013 /* Add a list of partial symbols to SYMTAB. */
23014 
23015 static void
23017  htab_t psyms_seen,
23018  struct partial_symbol **psymp,
23019  int count,
23020  offset_type cu_index,
23021  int is_static)
23022 {
23023  for (; count-- > 0; ++psymp)
23024  {
23025  struct partial_symbol *psym = *psymp;
23026  void **slot;
23027 
23028  if (SYMBOL_LANGUAGE (psym) == language_ada)
23029  error (_("Ada is not currently supported by the index"));
23030 
23031  /* Only add a given psymbol once. */
23032  slot = htab_find_slot (psyms_seen, psym, INSERT);
23033  if (!*slot)
23034  {
23035  gdb_index_symbol_kind kind = symbol_kind (psym);
23036 
23037  *slot = psym;
23038  add_index_entry (symtab, SYMBOL_SEARCH_NAME (psym),
23039  is_static, kind, cu_index);
23040  }
23041  }
23042 }
23043 
23044 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
23045  exception if there is an error. */
23046 
23047 static void
23048 write_obstack (FILE *file, struct obstack *obstack)
23049 {
23050  if (fwrite (obstack_base (obstack), 1, obstack_object_size (obstack),
23051  file)
23052  != obstack_object_size (obstack))
23053  error (_("couldn't data write to file"));
23054 }
23055 
23056 /* Unlink a file if the argument is not NULL. */
23057 
23058 static void
23059 unlink_if_set (void *p)
23060 {
23061  char **filename = p;
23062  if (*filename)
23063  unlink (*filename);
23064 }
23065 
23066 /* A helper struct used when iterating over debug_types. */
23068 {
23069  struct objfile *objfile;
23071  struct obstack *types_list;
23072  htab_t psyms_seen;
23074 };
23075 
23076 /* A helper function that writes a single signatured_type to an
23077  obstack. */
23078 
23079 static int
23080 write_one_signatured_type (void **slot, void *d)
23081 {
23082  struct signatured_type_index_data *info = d;
23083  struct signatured_type *entry = (struct signatured_type *) *slot;
23084  struct partial_symtab *psymtab = entry->per_cu.v.psymtab;
23085  gdb_byte val[8];
23086 
23087  write_psymbols (info->symtab,
23088  info->psyms_seen,
23090  + psymtab->globals_offset,
23091  psymtab->n_global_syms, info->cu_index,
23092  0);
23093  write_psymbols (info->symtab,
23094  info->psyms_seen,
23096  + psymtab->statics_offset,
23097  psymtab->n_static_syms, info->cu_index,
23098  1);
23099 
23100  store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE,
23101  entry->per_cu.offset.sect_off);
23102  obstack_grow (info->types_list, val, 8);
23103  store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE,
23104  entry->type_offset_in_tu.cu_off);
23105  obstack_grow (info->types_list, val, 8);
23106  store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, entry->signature);
23107  obstack_grow (info->types_list, val, 8);
23108 
23109  ++info->cu_index;
23110 
23111  return 1;
23112 }
23113 
23114 /* Recurse into all "included" dependencies and write their symbols as
23115  if they appeared in this psymtab. */
23116 
23117 static void
23118 recursively_write_psymbols (struct objfile *objfile,
23119  struct partial_symtab *psymtab,
23120  struct mapped_symtab *symtab,
23121  htab_t psyms_seen,
23122  offset_type cu_index)
23123 {
23124  int i;
23125 
23126  for (i = 0; i < psymtab->number_of_dependencies; ++i)
23127  if (psymtab->dependencies[i]->user != NULL)
23128  recursively_write_psymbols (objfile, psymtab->dependencies[i],
23129  symtab, psyms_seen, cu_index);
23130 
23131  write_psymbols (symtab,
23132  psyms_seen,
23133  objfile->global_psymbols.list + psymtab->globals_offset,
23134  psymtab->n_global_syms, cu_index,
23135  0);
23136  write_psymbols (symtab,
23137  psyms_seen,
23138  objfile->static_psymbols.list + psymtab->statics_offset,
23139  psymtab->n_static_syms, cu_index,
23140  1);
23141 }
23142 
23143 /* Create an index file for OBJFILE in the directory DIR. */
23144 
23145 static void
23146 write_psymtabs_to_index (struct objfile *objfile, const char *dir)
23147 {
23148  struct cleanup *cleanup;
23149  char *filename, *cleanup_filename;
23150  struct obstack contents, addr_obstack, constant_pool, symtab_obstack;
23151  struct obstack cu_list, types_cu_list;
23152  int i;
23153  FILE *out_file;
23154  struct mapped_symtab *symtab;
23155  offset_type val, size_of_contents, total_len;
23156  struct stat st;
23157  htab_t psyms_seen;
23158  htab_t cu_index_htab;
23160 
23161  if (dwarf2_per_objfile->using_index)
23162  error (_("Cannot use an index to create the index"));
23163 
23164  if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) > 1)
23165  error (_("Cannot make an index when the file has multiple .debug_types sections"));
23166 
23167  if (!objfile->psymtabs || !objfile->psymtabs_addrmap)
23168  return;
23169 
23170  if (stat (objfile_name (objfile), &st) < 0)
23171  perror_with_name (objfile_name (objfile));
23172 
23173  filename = concat (dir, SLASH_STRING, lbasename (objfile_name (objfile)),
23174  INDEX_SUFFIX, (char *) NULL);
23175  cleanup = make_cleanup (xfree, filename);
23176 
23177  out_file = gdb_fopen_cloexec (filename, "wb");
23178  if (!out_file)
23179  error (_("Can't open `%s' for writing"), filename);
23180 
23181  cleanup_filename = filename;
23182  make_cleanup (unlink_if_set, &cleanup_filename);
23183 
23184  symtab = create_mapped_symtab ();
23186 
23187  obstack_init (&addr_obstack);
23188  make_cleanup_obstack_free (&addr_obstack);
23189 
23190  obstack_init (&cu_list);
23191  make_cleanup_obstack_free (&cu_list);
23192 
23193  obstack_init (&types_cu_list);
23194  make_cleanup_obstack_free (&types_cu_list);
23195 
23196  psyms_seen = htab_create_alloc (100, htab_hash_pointer, htab_eq_pointer,
23197  NULL, xcalloc, xfree);
23198  make_cleanup_htab_delete (psyms_seen);
23199 
23200  /* While we're scanning CU's create a table that maps a psymtab pointer
23201  (which is what addrmap records) to its index (which is what is recorded
23202  in the index file). This will later be needed to write the address
23203  table. */
23204  cu_index_htab = htab_create_alloc (100,
23207  NULL, xcalloc, xfree);
23208  make_cleanup_htab_delete (cu_index_htab);
23209  psymtab_cu_index_map = (struct psymtab_cu_index_map *)
23210  xmalloc (sizeof (struct psymtab_cu_index_map)
23211  * dwarf2_per_objfile->n_comp_units);
23212  make_cleanup (xfree, psymtab_cu_index_map);
23213 
23214  /* The CU list is already sorted, so we don't need to do additional
23215  work here. Also, the debug_types entries do not appear in
23216  all_comp_units, but only in their own hash table. */
23217  for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
23218  {
23219  struct dwarf2_per_cu_data *per_cu
23220  = dwarf2_per_objfile->all_comp_units[i];
23221  struct partial_symtab *psymtab = per_cu->v.psymtab;
23222  gdb_byte val[8];
23223  struct psymtab_cu_index_map *map;
23224  void **slot;
23225 
23226  /* CU of a shared file from 'dwz -m' may be unused by this main file.
23227  It may be referenced from a local scope but in such case it does not
23228  need to be present in .gdb_index. */
23229  if (psymtab == NULL)
23230  continue;
23231 
23232  if (psymtab->user == NULL)
23233  recursively_write_psymbols (objfile, psymtab, symtab, psyms_seen, i);
23234 
23235  map = &psymtab_cu_index_map[i];
23236  map->psymtab = psymtab;
23237  map->cu_index = i;
23238  slot = htab_find_slot (cu_index_htab, map, INSERT);
23239  gdb_assert (slot != NULL);
23240  gdb_assert (*slot == NULL);
23241  *slot = map;
23242 
23243  store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE,
23244  per_cu->offset.sect_off);
23245  obstack_grow (&cu_list, val, 8);
23246  store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, per_cu->length);
23247  obstack_grow (&cu_list, val, 8);
23248  }
23249 
23250  /* Dump the address map. */
23251  write_address_map (objfile, &addr_obstack, cu_index_htab);
23252 
23253  /* Write out the .debug_type entries, if any. */
23254  if (dwarf2_per_objfile->signatured_types)
23255  {
23256  struct signatured_type_index_data sig_data;
23257 
23258  sig_data.objfile = objfile;
23259  sig_data.symtab = symtab;
23260  sig_data.types_list = &types_cu_list;
23261  sig_data.psyms_seen = psyms_seen;
23262  sig_data.cu_index = dwarf2_per_objfile->n_comp_units;
23263  htab_traverse_noresize (dwarf2_per_objfile->signatured_types,
23264  write_one_signatured_type, &sig_data);
23265  }
23266 
23267  /* Now that we've processed all symbols we can shrink their cu_indices
23268  lists. */
23269  uniquify_cu_indices (symtab);
23270 
23271  obstack_init (&constant_pool);
23272  make_cleanup_obstack_free (&constant_pool);
23273  obstack_init (&symtab_obstack);
23274  make_cleanup_obstack_free (&symtab_obstack);
23275  write_hash_table (symtab, &symtab_obstack, &constant_pool);
23276 
23277  obstack_init (&contents);
23278  make_cleanup_obstack_free (&contents);
23279  size_of_contents = 6 * sizeof (offset_type);
23280  total_len = size_of_contents;
23281 
23282  /* The version number. */
23283  val = MAYBE_SWAP (8);
23284  obstack_grow (&contents, &val, sizeof (val));
23285 
23286  /* The offset of the CU list from the start of the file. */
23287  val = MAYBE_SWAP (total_len);
23288  obstack_grow (&contents, &val, sizeof (val));
23289  total_len += obstack_object_size (&cu_list);
23290 
23291  /* The offset of the types CU list from the start of the file. */
23292  val = MAYBE_SWAP (total_len);
23293  obstack_grow (&contents, &val, sizeof (val));
23294  total_len += obstack_object_size (&types_cu_list);
23295 
23296  /* The offset of the address table from the start of the file. */
23297  val = MAYBE_SWAP (total_len);
23298  obstack_grow (&contents, &val, sizeof (val));
23299  total_len += obstack_object_size (&addr_obstack);
23300 
23301  /* The offset of the symbol table from the start of the file. */
23302  val = MAYBE_SWAP (total_len);
23303  obstack_grow (&contents, &val, sizeof (val));
23304  total_len += obstack_object_size (&symtab_obstack);
23305 
23306  /* The offset of the constant pool from the start of the file. */
23307  val = MAYBE_SWAP (total_len);
23308  obstack_grow (&contents, &val, sizeof (val));
23309  total_len += obstack_object_size (&constant_pool);
23310 
23311  gdb_assert (obstack_object_size (&contents) == size_of_contents);
23312 
23313  write_obstack (out_file, &contents);
23314  write_obstack (out_file, &cu_list);
23315  write_obstack (out_file, &types_cu_list);
23316  write_obstack (out_file, &addr_obstack);
23317  write_obstack (out_file, &symtab_obstack);
23318  write_obstack (out_file, &constant_pool);
23319 
23320  fclose (out_file);
23321 
23322  /* We want to keep the file, so we set cleanup_filename to NULL
23323  here. See unlink_if_set. */
23324  cleanup_filename = NULL;
23325 
23326  do_cleanups (cleanup);
23327 }
23328 
23329 /* Implementation of the `save gdb-index' command.
23330 
23331  Note that the file format used by this command is documented in the
23332  GDB manual. Any changes here must be documented there. */
23333 
23334 static void
23335 save_gdb_index_command (char *arg, int from_tty)
23336 {
23337  struct objfile *objfile;
23338 
23339  if (!arg || !*arg)
23340  error (_("usage: save gdb-index DIRECTORY"));
23341 
23342  ALL_OBJFILES (objfile)
23343  {
23344  struct stat st;
23345 
23346  /* If the objfile does not correspond to an actual file, skip it. */
23347  if (stat (objfile_name (objfile), &st) < 0)
23348  continue;
23349 
23350  dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
23351  if (dwarf2_per_objfile)
23352  {
23353 
23354  TRY
23355  {
23356  write_psymtabs_to_index (objfile, arg);
23357  }
23358  CATCH (except, RETURN_MASK_ERROR)
23359  {
23360  exception_fprintf (gdb_stderr, except,
23361  _("Error while writing index for `%s': "),
23362  objfile_name (objfile));
23363  }
23364  END_CATCH
23365  }
23366  }
23367 }
23368 
23369 
23370 
23372 
23373 static void
23374 show_dwarf_always_disassemble (struct ui_file *file, int from_tty,
23375  struct cmd_list_element *c, const char *value)
23376 {
23377  fprintf_filtered (file,
23378  _("Whether to always disassemble "
23379  "DWARF expressions is %s.\n"),
23380  value);
23381 }
23382 
23383 static void
23384 show_check_physname (struct ui_file *file, int from_tty,
23385  struct cmd_list_element *c, const char *value)
23386 {
23387  fprintf_filtered (file,
23388  _("Whether to check \"physname\" is %s.\n"),
23389  value);
23390 }
23391 
23392 void _initialize_dwarf2_read (void);
23393 
23394 void
23396 {
23397  struct cmd_list_element *c;
23398 
23399  dwarf2_objfile_data_key
23400  = register_objfile_data_with_cleanup (NULL, dwarf2_per_objfile_free);
23401 
23403 Set DWARF specific variables.\n\
23404 Configure DWARF variables such as the cache size"),
23405  &set_dwarf_cmdlist, "maintenance set dwarf ",
23406  0/*allow-unknown*/, &maintenance_set_cmdlist);
23407 
23409 Show DWARF specific variables\n\
23410 Show DWARF variables such as the cache size"),
23411  &show_dwarf_cmdlist, "maintenance show dwarf ",
23412  0/*allow-unknown*/, &maintenance_show_cmdlist);
23413 
23414  add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
23415  &dwarf_max_cache_age, _("\
23416 Set the upper bound on the age of cached DWARF compilation units."), _("\
23417 Show the upper bound on the age of cached DWARF compilation units."), _("\
23418 A higher limit means that cached compilation units will be stored\n\
23419 in memory longer, and more total memory will be used. Zero disables\n\
23420 caching, which can slow down startup."),
23421  NULL,
23423  &set_dwarf_cmdlist,
23424  &show_dwarf_cmdlist);
23425 
23426  add_setshow_boolean_cmd ("always-disassemble", class_obscure,
23427  &dwarf_always_disassemble, _("\
23428 Set whether `info address' always disassembles DWARF expressions."), _("\
23429 Show whether `info address' always disassembles DWARF expressions."), _("\
23430 When enabled, DWARF expressions are always printed in an assembly-like\n\
23431 syntax. When disabled, expressions will be printed in a more\n\
23432 conversational style, when possible."),
23433  NULL,
23435  &set_dwarf_cmdlist,
23436  &show_dwarf_cmdlist);
23437 
23438  add_setshow_zuinteger_cmd ("dwarf-read", no_class, &dwarf_read_debug, _("\
23439 Set debugging of the DWARF reader."), _("\
23440 Show debugging of the DWARF reader."), _("\
23441 When enabled (non-zero), debugging messages are printed during DWARF\n\
23442 reading and symtab expansion. A value of 1 (one) provides basic\n\
23443 information. A value greater than 1 provides more verbose information."),
23444  NULL,
23445  NULL,
23447 
23448  add_setshow_zuinteger_cmd ("dwarf-die", no_class, &dwarf_die_debug, _("\
23449 Set debugging of the DWARF DIE reader."), _("\
23450 Show debugging of the DWARF DIE reader."), _("\
23451 When enabled (non-zero), DIEs are dumped after they are read in.\n\
23452 The value is the maximum depth to print."),
23453  NULL,
23454  NULL,
23456 
23457  add_setshow_zuinteger_cmd ("dwarf-line", no_class, &dwarf_line_debug, _("\
23458 Set debugging of the dwarf line reader."), _("\
23459 Show debugging of the dwarf line reader."), _("\
23460 When enabled (non-zero), line number entries are dumped as they are read in.\n\
23461 A value of 1 (one) provides basic information.\n\
23462 A value greater than 1 provides more verbose information."),
23463  NULL,
23464  NULL,
23466 
23467  add_setshow_boolean_cmd ("check-physname", no_class, &check_physname, _("\
23468 Set cross-checking of \"physname\" code against demangler."), _("\
23469 Show cross-checking of \"physname\" code against demangler."), _("\
23470 When enabled, GDB's internal \"physname\" code is checked against\n\
23471 the demangler."),
23472  NULL, show_check_physname,
23474 
23475  add_setshow_boolean_cmd ("use-deprecated-index-sections",
23476  no_class, &use_deprecated_index_sections, _("\
23477 Set whether to use deprecated gdb_index sections."), _("\
23478 Show whether to use deprecated gdb_index sections."), _("\
23479 When enabled, deprecated .gdb_index sections are used anyway.\n\
23480 Normally they are ignored either because of a missing feature or\n\
23481 performance issue.\n\
23482 Warning: This option must be enabled before gdb reads the file."),
23483  NULL,
23484  NULL,
23485  &setlist, &showlist);
23486 
23487  c = add_cmd ("gdb-index", class_files, save_gdb_index_command,
23488  _("\
23489 Save a gdb-index file.\n\
23490 Usage: save gdb-index DIRECTORY"),
23491  &save_cmdlist);
23492  set_cmd_completer (c, filename_completer);
23493 
23494  dwarf2_locexpr_index = register_symbol_computed_impl (LOC_COMPUTED,
23496  dwarf2_loclist_index = register_symbol_computed_impl (LOC_COMPUTED,
23498 
23499  dwarf2_locexpr_block_index = register_symbol_block_impl (LOC_BLOCK,
23501  dwarf2_loclist_block_index = register_symbol_block_impl (LOC_BLOCK,
23503 }
static struct dwp_file * get_dwp_file(void)
Definition: dwarf2read.c:10894
struct dwarf2_section_info abbrev
Definition: dwarf2read.c:982
bfd_size_type line_offset
Definition: dwarf2read.c:893
const char * filename
Definition: psympriv.h:91
static void free_cached_comp_units(void *)
Definition: dwarf2read.c:22073
void macro_define_function(struct macro_source_file *source, int line, const char *name, int argc, const char **argv, const char *replacement)
Definition: macrotab.c:800
bfd_size_type macinfo_offset
Definition: dwarf2read.c:899
static void unlink_if_set(void *p)
Definition: dwarf2read.c:23059
#define TYPE_HIGH_BOUND_KIND(range_type)
Definition: gdbtypes.h:1254
struct psymbol_allocation_list static_psymbols
Definition: objfiles.h:339
void set_type_vptr_basetype(struct type *type, struct type *basetype)
Definition: gdbtypes.c:1715
int n_template_arguments
Definition: symtab.h:849
static void save_gdb_index_command(char *arg, int from_tty)
Definition: dwarf2read.c:23335
static struct die_info * follow_die_offset(sect_offset offset, int offset_in_dwz, struct dwarf2_cu **ref_cu)
Definition: dwarf2read.c:19913
unsigned int queued
Definition: dwarf2read.c:575
static struct dwarf2_section_info * get_debug_line_section(struct dwarf2_cu *cu)
Definition: dwarf2read.c:17220
struct dwarf2_per_cu_data * dwarf2_per_cu_ptr
Definition: dwarf2read.c:202
size_t data_value_size
Definition: gdbtypes.h:1150
struct partial_die_info * die_sibling
Definition: dwarf2read.c:1167
#define DW_BLOCK(attr)
Definition: dwarf2read.c:1272
bfd_byte * symfile_relocate_debug_section(struct objfile *objfile, asection *sectp, bfd_byte *buf)
Definition: symfile.c:3774
__extension__ enum dwarf_form form
Definition: dwarf2read.c:1184
const char * name
Definition: dwarf2read.c:1130
static void free_delayed_list(void *ptr)
Definition: dwarf2read.c:7763
static struct type * read_set_type(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:13834
static struct dwarf_block * dwarf_alloc_block(struct dwarf2_cu *)
Definition: dwarf2read.c:20741
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
unsigned typedef_field_list_count
Definition: dwarf2read.c:1359
static struct die_info * follow_die_sig(struct die_info *, const struct attribute *, struct dwarf2_cu **)
Definition: dwarf2read.c:20274
uint32_t nr_units
Definition: dwarf2read.c:919
static struct dwo_unit * create_dwo_unit_in_dwp_v1(struct dwp_file *dwp_file, uint32_t unit_index, const char *comp_dir, ULONGEST signature, int is_debug_types)
Definition: dwarf2read.c:9998
struct cmd_list_element * add_prefix_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **prefixlist, const char *prefixname, int allow_unknown, struct cmd_list_element **list)
Definition: cli-decode.c:338
void cp_add_using_directive(const char *dest, const char *src, const char *alias, const char *declaration, VEC(const_char_ptr)*excludes, int copy_names, struct obstack *obstack)
Definition: cp-namespace.c:121
const char * symtab_to_filename_for_display(struct symtab *symtab)
Definition: source.c:1171
struct dwarf2_per_cu_data * per_cu
Definition: gdbtypes.h:1181
type_code
Definition: gdbtypes.h:85
static struct dwarf2_queue_item * dwarf2_queue_tail
Definition: dwarf2read.c:1372
unsigned char from_dwo
Definition: dwarf2loc.h:197
#define TYPE_RANGE_DATA(thistype)
Definition: gdbtypes.h:1245
static unsigned int get_cu_length(const struct comp_unit_head *header)
Definition: dwarf2read.c:4264
struct type * referenced_type
Definition: dwarf2loc.h:226
static struct die_info * read_die_and_siblings_1(const struct die_reader_specs *, const gdb_byte *, const gdb_byte **, struct die_info *)
Definition: dwarf2read.c:15102
static void free_line_header(struct line_header *lh)
Definition: dwarf2read.c:17124
struct dwarf_block * locdesc
Definition: dwarf2read.c:1145
char * gdb_realpath(const char *filename)
Definition: utils.c:2840
static int producer_is_gcc_lt_4_3(struct dwarf2_cu *cu)
Definition: dwarf2read.c:9022
bfd_size_type info_or_types_offset
Definition: dwarf2read.c:910
static void dw2_map_matching_symbols(struct objfile *objfile, const char *name, domain_enum domain, int global, int(*callback)(struct block *, struct symbol *, void *), void *data, symbol_compare_ftype *match, symbol_compare_ftype *ordered_compare)
Definition: dwarf2read.c:3828
#define B_TYPE
Definition: gdbtypes.h:78
static struct die_info * sibling_die(struct die_info *)
Definition: dwarf2read.c:19424
static void psymtab_to_symtab_1(struct partial_symtab *)
Definition: dwarf2read.c:7630
static void process_psymtab_comp_unit(struct dwarf2_per_cu_data *this_cu, int want_partial_unit, enum language pretend_language)
Definition: dwarf2read.c:6064
static void fixup_go_packaging(struct dwarf2_cu *cu)
Definition: dwarf2read.c:7807
int dwarf2_has_info(struct objfile *objfile, const struct dwarf2_debug_sections *names)
Definition: dwarf2read.c:2032
static void process_structure_scope(struct die_info *, struct dwarf2_cu *)
Definition: dwarf2read.c:13225
static void show_dwarf_always_disassemble(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: dwarf2read.c:23374
#define OBSTACK_CALLOC(OBSTACK, NUMBER, TYPE)
Definition: gdb_obstack.h:30
#define DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE(cu_index, value)
Definition: dwarf2read.c:155
static void scan_partial_symbols(struct partial_die_info *, CORE_ADDR *, CORE_ADDR *, int, struct dwarf2_cu *)
Definition: dwarf2read.c:6636
struct field field
Definition: dwarf2read.c:1305
const gdb_byte * buffer
Definition: dwarf2read.c:132
static CORE_ADDR read_addr_index_from_leb128(struct dwarf2_cu *, const gdb_byte *, unsigned int *)
Definition: dwarf2read.c:16820
const struct dwp_hash_table * tus
Definition: dwarf2read.c:965
struct dwarf2_per_cu_data * per_cu
Definition: dwarf2loc.h:193
__extension__ enum dwarf_tag tag
Definition: dwarf2read.c:1235
struct using_direct * using_directives
Definition: buildsym.h:134
static void delete_file_name_entry(void *e)
Definition: dwarf2read.c:2620
int dwarf_always_disassemble
Definition: dwarf2read.c:23371
unsigned int header_length
Definition: dwarf2read.c:1055
#define SECT_OFF_TEXT(objfile)
Definition: objfiles.h:683
bfd * obfd
Definition: objfiles.h:313
struct type * copy_type(const struct type *type)
Definition: gdbtypes.c:4507
union dynamic_prop_data data
Definition: gdbtypes.h:434
struct attr_abbrev * attrs
Definition: dwarf2read.c:1177
static struct type * read_unspecified_type(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:15048
static void dw2_map_symbol_filenames(struct objfile *objfile, symbol_filename_ftype *fun, void *data, int need_fullname)
Definition: dwarf2read.c:4099
static struct type * read_subroutine_type(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:14509
struct template_symbol * allocate_template_symbol(struct objfile *objfile)
Definition: symtab.c:6218
struct type * create_static_range_type(struct type *result_type, struct type *index_type, LONGEST low_bound, LONGEST high_bound)
Definition: gdbtypes.c:867
#define MAYBE_SWAP(V)
Definition: dwarf2read.c:1990
unsigned char readin
Definition: psympriv.h:173
#define VEC_replace(T, V, I, O)
Definition: vec.h:302
htab_t die_hash
Definition: dwarf2read.c:486
struct dwarf2_section_info str
Definition: dwarf2read.c:758
static struct symtab * dw2_find_last_source_symtab(struct objfile *objfile)
Definition: dwarf2read.c:3365
int block_find_non_opaque_type_preferred(struct symbol *sym, void *data)
Definition: block.c:857
int base_known
Definition: dwarf2read.c:440
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2217
hashval_t core_addr_hash(const void *ap)
Definition: utils.c:2783
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:260
struct partial_die_info * die_parent
Definition: dwarf2read.c:1167
static bfd_size_type dwarf2_section_size(struct objfile *objfile, struct dwarf2_section_info *info)
Definition: dwarf2read.c:2350
static int dw2_map_expand_apply(struct objfile *objfile, struct dwarf2_per_cu_data *per_cu, const char *name, const char *real_path, int(*callback)(struct symtab *, void *), void *data)
Definition: dwarf2read.c:3412
static struct die_info * follow_die_sig_1(struct die_info *src_die, struct signatured_type *sig_type, struct dwarf2_cu **ref_cu)
Definition: dwarf2read.c:20225
#define ABBREV_HASH_SIZE
Definition: dwarf2read.c:1188
struct dwarf2_section_names macro_dwo
Definition: dwarf2read.c:355
static const char * psymtab_include_file_name(const struct line_header *lh, int file_index, const struct partial_symtab *pst, const char *comp_dir)
Definition: dwarf2read.c:17400
void value_print(struct value *val, struct ui_file *stream, const struct value_print_options *options)
Definition: valprint.c:870
void add_setshow_zinteger_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:719
unsigned int has_children
Definition: dwarf2read.c:1098
void add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:763
domain_enum domain
Definition: dwarf2read.c:3521
void symbol_set_symtab(struct symbol *symbol, struct symtab *symtab)
Definition: symtab.c:6259
int dwarf2_per_cu_ref_addr_size(struct dwarf2_per_cu_data *per_cu)
Definition: dwarf2read.c:21919
struct obstack storage_obstack
Definition: objfiles.h:177
struct dwarf2_section_names types
Definition: symfile.h:618
#define TYPE_FIELD_PRIVATE_BITS(thistype)
Definition: gdbtypes.h:1380
static int leb128_size(const gdb_byte *buf)
Definition: dwarf2read.c:16955
unsigned int has_specification
Definition: dwarf2read.c:1102
struct dwarf2_section_names str_offsets_dwo
Definition: dwarf2read.c:357
static struct type * set_die_type(struct die_info *, struct type *, struct dwarf2_cu *)
Definition: dwarf2read.c:22243
static void free_line_header_voidp(void *arg)
Definition: dwarf2read.c:17144
static void create_all_comp_units(struct objfile *)
Definition: dwarf2read.c:6599
struct type * builtin_void
Definition: gdbtypes.h:1570
bfd_vma CORE_ADDR
Definition: common-types.h:41
struct dwarf2_section_info ranges
Definition: dwarf2read.c:226
void record_block_range(struct block *block, CORE_ADDR start, CORE_ADDR end_inclusive)
Definition: buildsym.c:564
struct fn_field * fn_fields
Definition: gdbtypes.h:831
int nr_stmt_less_type_units
Definition: dwarf2read.c:210
static void reset_die_in_process(void *arg)
Definition: dwarf2read.c:8236
#define TYPE_FIELD_NAME(thistype, n)
Definition: gdbtypes.h:1369
#define TYPE_N_BASECLASSES(thistype)
Definition: gdbtypes.h:1327
static const char * dwarf2_name(struct die_info *die, struct dwarf2_cu *)
Definition: dwarf2read.c:19454
static void init_cutu_and_read_dies_no_follow(struct dwarf2_per_cu_data *this_cu, struct dwo_file *dwo_file, die_reader_func_ftype *die_reader_func, void *data)
Definition: dwarf2read.c:5652
static struct type * read_enumeration_type(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:13502
void fputs_unfiltered(const char *buf, struct ui_file *file)
Definition: ui-file.c:252
static struct type * get_signatured_type(struct die_info *, ULONGEST, struct dwarf2_cu *)
Definition: dwarf2read.c:20311
struct dwarf2_section_info macro
Definition: dwarf2read.c:876
int producer_is_gcc_ge_4(const char *producer)
Definition: utils.c:3147
sect_offset offset
Definition: dwarf2read.c:1048
static struct dwz_file * dwarf2_get_dwz_file(void)
Definition: dwarf2read.c:2445
static const struct comp_unit_head * per_cu_header_read_in(struct comp_unit_head *cu_headerp, struct dwarf2_per_cu_data *per_cu)
Definition: dwarf2read.c:21874
unsigned is_cplus_template_function
Definition: symtab.h:752
CORE_ADDR dwarf2_read_addr_index(struct dwarf2_per_cu_data *per_cu, unsigned int addr_index)
Definition: dwarf2read.c:16861
static LONGEST read_offset_1(bfd *, const gdb_byte *, unsigned int)
Definition: dwarf2read.c:16624
struct dwarf2_section_info * containing_section
Definition: dwarf2read.c:129
bfd * dbfd
Definition: dwarf2read.c:956
struct dwarf2_section_names macinfo
Definition: symfile.h:614
void xfree(void *)
Definition: common-utils.c:97
struct objfile * separate_debug_objfile_backlink
Definition: objfiles.h:401
struct dwarf2_section_info macro
Definition: dwarf2read.c:986
#define HAVE_GNAT_AUX_INFO(type)
Definition: gdbtypes.h:1216
CORE_ADDR base_address
Definition: dwarf2loc.h:183
static const struct dwarf2_debug_sections dwarf2_elf_names
Definition: dwarf2read.c:328
int strcmp_iw(const char *string1, const char *string2)
Definition: utils.c:2511
static CORE_ADDR read_addr_index(struct dwarf2_cu *cu, unsigned int addr_index)
Definition: dwarf2read.c:16812
#define TYPE_NFN_FIELDS(thistype)
Definition: gdbtypes.h:1307
struct dwarf2_section_info eh_frame
Definition: dwarf2read.c:229
static void compute_delayed_physnames(struct dwarf2_cu *cu)
Definition: dwarf2read.c:7780
void dummy_obstack_deallocate(void *object, void *data)
Definition: utils.c:2997
CORE_ADDR base_address
Definition: dwarf2read.c:437
static struct partial_die_info * find_partial_die_in_comp_unit(sect_offset offset, struct dwarf2_cu *cu)
Definition: dwarf2read.c:15970
static int dwarf2_is_constructor(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:12754
static enum dwarf_access_attribute dwarf2_default_access_attribute(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:12368
struct dwarf2_section_names tu_index
Definition: dwarf2read.c:360
struct dwo_unit * cu
Definition: dwarf2read.c:833
const gdb_byte * statement_program_start
Definition: dwarf2read.c:1084
void add_symbol_to_list(struct symbol *symbol, struct pending **listhead)
Definition: buildsym.c:216
static const gdb_byte * skip_form_bytes(bfd *abfd, const gdb_byte *bytes, const gdb_byte *buffer_end, enum dwarf_form form, unsigned int offset_size, struct dwarf2_section_info *section)
Definition: dwarf2read.c:21029
struct nextfnfield * head
Definition: dwarf2read.c:1318
struct symbol * hash_next
Definition: symtab.h:782
EXTERN unsigned char processing_gcc_compilation
Definition: buildsym.h:78
static int section_is_p(const char *section_name, const struct dwarf2_section_names *names)
Definition: dwarf2read.c:2142
bfd_size_type abbrev_size
Definition: dwarf2read.c:891
#define INT_MAX
Definition: defs.h:509
static const gdb_byte * read_attribute_value(const struct die_reader_specs *reader, struct attribute *attr, unsigned form, const gdb_byte *info_ptr)
Definition: dwarf2read.c:16191
cu_offset first_die_offset
Definition: dwarf2read.c:401
__extension__ enum dwarf_attribute name
Definition: dwarf2read.c:1183
void warning(const char *fmt,...)
Definition: errors.c:26
const gdb_byte * data
Definition: dwarf2loc.h:186
struct dwarf2_section_info str_offsets
Definition: dwarf2read.c:863
static void read_common_block(struct die_info *, struct dwarf2_cu *)
Definition: dwarf2read.c:13934
static void create_dwo_cu_reader(const struct die_reader_specs *reader, const gdb_byte *info_ptr, struct die_info *comp_unit_die, int has_children, void *datap)
Definition: dwarf2read.c:9513
struct psymbol_allocation_list global_psymbols
Definition: objfiles.h:338
static hashval_t hash_file_name_entry(const void *e)
Definition: dwarf2read.c:2599
static void dwarf2_build_psymtabs_hard(struct objfile *)
Definition: dwarf2read.c:6445
struct type ** const(pascal_builtin_types[])
unsigned int is_private
Definition: gdbtypes.h:867
static int attr_form_is_constant(const struct attribute *)
Definition: dwarf2read.c:21719
void set_type_vptr_fieldno(struct type *type, int fieldno)
Definition: gdbtypes.c:1689
#define TYPE_NAME(thistype)
Definition: gdbtypes.h:1227
static struct cmd_list_element * set_dwarf_cmdlist
Definition: dwarf2read.c:22420
struct dwarf2_locexpr_baton dwarf2_fetch_die_loc_cu_off(cu_offset offset_in_cu, struct dwarf2_per_cu_data *per_cu, CORE_ADDR(*get_frame_pc)(void *baton), void *baton)
Definition: dwarf2read.c:20050
ULONGEST signature
Definition: dwarf2read.c:775
#define TYPE_FIELD_ARTIFICIAL(thistype, n)
Definition: gdbtypes.h:1376
struct macro_source_file * included_by
Definition: macrotab.h:136
int nr_uniq_abbrev_tables
Definition: dwarf2read.c:207
void gdbarch_make_symbol_special(struct gdbarch *gdbarch, struct symbol *sym, struct objfile *objfile)
Definition: gdbarch.c:3183
static void guess_partial_die_structure_name(struct partial_die_info *struct_pdi, struct dwarf2_cu *cu)
Definition: dwarf2read.c:16055
const gdb_byte * hash_table
Definition: dwarf2read.c:920
static void dump_die_shallow(struct ui_file *, int indent, struct die_info *)
Definition: dwarf2read.c:19669
static unsigned int peek_abbrev_code(bfd *, const gdb_byte *)
Definition: dwarf2read.c:7193
#define INIT_CPLUS_SPECIFIC(type)
Definition: gdbtypes.h:1195
int nr_symtab_sharers
Definition: dwarf2read.c:209
struct line_header * line_header
Definition: dwarf2read.c:17516
record_line_ftype * record_line
Definition: dwarf2read.c:17498
char * ui_file_xstrdup(struct ui_file *file, long *length)
Definition: ui-file.c:345
#define TYPE_VOLATILE(t)
Definition: gdbtypes.h:350
static int eq_type_unit_group(const void *item_lhs, const void *item_rhs)
Definition: dwarf2read.c:5746
struct dwarf2_section_names gdb_index
Definition: symfile.h:622
unsigned int discriminator
Definition: dwarf2read.c:17487
#define TYPE_FN_FIELDLIST(thistype, n)
Definition: gdbtypes.h:1410
static hashval_t hash_symtab_entry(const void *e)
Definition: dwarf2read.c:22557
struct dwarf2_section_info abbrev
Definition: dwarf2read.c:753
struct dwarf2_section_info macinfo
Definition: dwarf2read.c:756
unsigned int epilogue_unwind_valid
Definition: symtab.h:1067
offset_type symbol_table_slots
Definition: dwarf2read.c:196
unsigned int tu_read
Definition: dwarf2read.c:605
void ui_file_delete(struct ui_file *file)
Definition: ui-file.c:76
unsigned int last_line
Definition: dwarf2read.c:17503
static struct quick_file_names * dw2_get_file_names(struct dwarf2_per_cu_data *this_cu)
Definition: dwarf2read.c:3327
static struct die_info * follow_die_ref(struct die_info *, const struct attribute *, struct dwarf2_cu **)
Definition: dwarf2read.c:19962
static int read_1_signed_byte(bfd *, const gdb_byte *)
Definition: dwarf2read.c:16431
void( record_line_ftype)(struct subfile *subfile, int line, CORE_ADDR pc)
Definition: buildsym.h:177
void ui_file_put(struct ui_file *file, ui_file_put_method_ftype *write, void *dest)
Definition: ui-file.c:210
const struct dwarf2_per_cu_data * per_cu
Definition: dwarf2read.c:22197
static void prepare_one_comp_unit(struct dwarf2_cu *cu, struct die_info *comp_unit_die, enum language pretend_language)
Definition: dwarf2read.c:22013
static void add_index_entry(struct mapped_symtab *symtab, const char *name, int is_static, gdb_index_symbol_kind kind, offset_type cu_index)
Definition: dwarf2read.c:22676
struct type * language_string_char_type(const struct language_defn *la, struct gdbarch *gdbarch)
Definition: language.c:956
#define FIELD_ARTIFICIAL(thisfld)
Definition: gdbtypes.h:1364
void get_formatted_print_options(struct value_print_options *opts, char format)
Definition: valprint.c:146
enum domain_enum_tag domain_enum
int gdbarch_address_class_type_flags_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3268
#define TYPE_FIELD_VIRTUAL_BITS(thistype)
Definition: gdbtypes.h:1386
int compare_filenames_for_search(const char *filename, const char *search_name)
Definition: symtab.c:313
#define ALLOCATE_GNAT_AUX_TYPE(type)
Definition: gdbtypes.h:1213
struct ui_file * gdb_stdout
Definition: main.c:71
static struct type * read_tag_ptr_to_member_type(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:14255
static void set_partial_user(struct objfile *objfile)
Definition: dwarf2read.c:6419
static void write_psymtabs_to_index(struct objfile *objfile, const char *dir)
Definition: dwarf2read.c:23146
union dwarf2_section_info::@58 s
#define PSYMBOL_DOMAIN(psymbol)
Definition: psympriv.h:56
const struct type_print_options type_print_raw_options
Definition: typeprint.c:48
static int eq_stmt_list_entry(const struct stmt_list_hash *lhs, const struct stmt_list_hash *rhs)
Definition: dwarf2read.c:2584
const struct objfile_type * objfile_type(struct objfile *objfile)
Definition: gdbtypes.c:4909
struct dwarf2_per_cu_data * read_in_chain
Definition: dwarf2read.c:476
static void abbrev_table_free(struct abbrev_table *)
Definition: dwarf2read.c:15396
char * ldirname(const char *filename)
Definition: utils.c:3006
static htab_t create_debug_types_hash_table(struct dwo_file *dwo_file, VEC(dwarf2_section_info_def)*types)
Definition: dwarf2read.c:4595
cu_offset param_offset
Definition: gdbtypes.h:1131
static char * file_full_name(int file, struct line_header *lh, const char *comp_dir)
Definition: dwarf2read.c:20809
struct dwarf2_section_names abbrev_dwo
Definition: dwarf2read.c:350
static void write_psymbols(struct mapped_symtab *symtab, htab_t psyms_seen, struct partial_symbol **psymp, int count, offset_type cu_index, int is_static)
Definition: dwarf2read.c:23016
#define SYMBOL_CLASS(symbol)
Definition: symtab.h:793
int dwarf2_per_cu_offset_size(struct dwarf2_per_cu_data *per_cu)
Definition: dwarf2read.c:21906
struct dwarf2_per_cu_data per_cu
Definition: dwarf2read.c:662
void( expand_symtabs_exp_notify_ftype)(struct compunit_symtab *symtab, void *data)
Definition: symfile.h:146
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
static int locate_v1_virtual_dwo_sections(asection *sectp, struct virtual_v1_dwo_sections *sections)
Definition: dwarf2read.c:9921
static void build_type_psymtabs(struct objfile *objfile)
Definition: dwarf2read.c:6326
static int eq_symtab_entry(const void *a, const void *b)
Definition: dwarf2read.c:22569
static void load_full_comp_unit_reader(const struct die_reader_specs *reader, const gdb_byte *info_ptr, struct die_info *comp_unit_die, int has_children, void *data)
Definition: dwarf2read.c:7698
const struct language_defn * language_def(enum language lang)
Definition: language.c:471
void print_spaces(int n, struct ui_file *file)
Definition: utils.c:1098
struct objfile * dwarf2_per_cu_objfile(struct dwarf2_per_cu_data *per_cu)
Definition: dwarf2read.c:21857
int info_verbose
Definition: top.c:1699
EXTERN struct pending * file_symbols
Definition: buildsym.h:109
static void setup_type_unit_groups(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:9266
#define TYPE_FIELD_PROTECTED_BITS(thistype)
Definition: gdbtypes.h:1382
static void build_type_psymtabs_reader(const struct die_reader_specs *reader, const gdb_byte *info_ptr, struct die_info *type_unit_die, int has_children, void *data)
Definition: dwarf2read.c:6092
static unsigned int read_4_bytes(bfd *, const gdb_byte *)
Definition: dwarf2read.c:16449
void smash_to_method_type(struct type *type, struct type *self_type, struct type *to_type, struct field *args, int nargs, int varargs)
Definition: gdbtypes.c:1342
const char * str
Definition: dwarf2read.c:22475
bfd_size_type line_size
Definition: dwarf2read.c:894
int virtuality
Definition: dwarf2read.c:1304
unsigned int line
Definition: dwarf2read.c:17484
unsigned char addr_size
Definition: dwarf2read.c:385
static unsigned int dwarf_line_debug
Definition: dwarf2read.c:88
struct dwarf2_locexpr_baton dwarf2_fetch_die_loc_sect_off(sect_offset offset, struct dwarf2_per_cu_data *per_cu, CORE_ADDR(*get_frame_pc)(void *baton), void *baton)
Definition: dwarf2read.c:19987
struct symbol ** template_arguments
Definition: symtab.h:853
void value_free(struct value *val)
Definition: value.c:1518
static const gdb_byte * read_full_die_1(const struct die_reader_specs *, struct die_info **, const gdb_byte *, int *, int)
Definition: dwarf2read.c:15169
static void update_enumeration_type_from_children(struct die_info *die, struct type *type, struct dwarf2_cu *cu)
Definition: dwarf2read.c:13437
static struct type * read_module_type(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:14114
struct dwarf2_queue_item * next
Definition: dwarf2read.c:1368
unsigned int is_dwz
Definition: dwarf2read.c:589
accessibility
Definition: c-varobj.c:686
static bfd * open_dwp_file(const char *file_name)
Definition: dwarf2read.c:10780
struct dwarf2_section_names line_dwo
Definition: dwarf2read.c:352
struct dwp_sections sections
Definition: dwarf2read.c:959
char * name
Definition: buildsym.h:63
#define DIRNAME_SEPARATOR
Definition: host-defs.h:54
struct symbol * symbol[PENDINGSIZE]
Definition: buildsym.h:102
void augment_type_symtab(void)
Definition: buildsym.c:1574
static void queue_comp_unit(struct dwarf2_per_cu_data *per_cu, enum language pretend_language)
Definition: dwarf2read.c:7462
unsigned int voffset
Definition: gdbtypes.h:893
static void set_cu_language(unsigned int, struct dwarf2_cu *)
Definition: dwarf2read.c:16969
void set_objfile_main_name(struct objfile *objfile, const char *name, enum language lang)
Definition: objfiles.c:192
static hashval_t die_hash(const void *item)
Definition: dwarf2read.c:7674
static void dwarf2_read_section(struct objfile *objfile, struct dwarf2_section_info *info)
Definition: dwarf2read.c:2267
static char * dwarf_bool_name(unsigned int)
Definition: dwarf2read.c:19647
static void dw2_setup(struct objfile *objfile)
Definition: dwarf2read.c:3234
#define SYMBOL_VALUE_COMMON_BLOCK(symbol)
Definition: symtab.h:184
int addrmap_foreach(struct addrmap *map, addrmap_foreach_fn fn, void *data)
Definition: addrmap.c:82
static void dw2_symtab_iter_init(struct dw2_symtab_iterator *iter, struct mapped_index *index, int want_specific_block, int block_index, domain_enum domain, const char *name)
Definition: dwarf2read.c:3541
static struct type * read_tag_const_type(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:14347
static void load_full_type_unit(struct dwarf2_per_cu_data *per_cu)
Definition: dwarf2read.c:20401
#define TYPE_NO_RETURN(thistype)
Definition: gdbtypes.h:1324
static int dwarf2_mark_helper(void **slot, void *data)
Definition: dwarf2read.c:22352
#define DW_SND(attr)
Definition: dwarf2read.c:1273
unsigned char num_attrs
Definition: dwarf2read.c:1238
#define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE
Definition: dwarf2read.c:5772
enum language la_language
Definition: language.h:152
static char * partial_die_full_name(struct partial_die_info *pdi, struct dwarf2_cu *cu)
Definition: dwarf2read.c:6836
static void dwarf2_free_abbrev_table(void *)
Definition: dwarf2read.c:15430
static void dw2_expand_symtabs_matching(struct objfile *objfile, expand_symtabs_file_matcher_ftype *file_matcher, expand_symtabs_symbol_matcher_ftype *symbol_matcher, expand_symtabs_exp_notify_ftype *expansion_notify, enum search_domain kind, void *data)
Definition: dwarf2read.c:3843
struct dwarf2_section_info str
Definition: dwarf2read.c:984
int gdbarch_address_class_type_flags(struct gdbarch *gdbarch, int byte_size, int dwarf2_addr_class)
Definition: gdbarch.c:3275
static struct attribute * dwarf2_attr(struct die_info *, unsigned int, struct dwarf2_cu *)
Definition: dwarf2read.c:17029
void dwarf2_build_psymtabs(struct objfile *objfile)
Definition: dwarf2read.c:4236
#define SET_FIELD_PHYSADDR(thisfld, addr)
Definition: gdbtypes.h:1358
struct partial_symtab * psymtab
Definition: dwarf2read.c:22855
#define IS_TYPE_UNIT_GROUP(per_cu)
Definition: dwarf2read.c:718
static int sort_tu_by_abbrev_offset(const void *ap, const void *bp)
Definition: dwarf2read.c:6149
struct objfile * objfile
Definition: dwarf2read.c:619
struct type * nodebug_data_symbol
Definition: gdbtypes.h:1597
static int dwarf2_loclist_index
Definition: dwarf2read.c:101
#define VEC_safe_push(T, V, O)
Definition: vec.h:260
#define BLOCKVECTOR_BLOCK(blocklist, n)
Definition: block.h:136
const gdb_byte * sibling
Definition: dwarf2read.c:1158
union partial_die_info::@63 d
static offset_type add_indices_to_cpool(htab_t symbol_hash_table, struct obstack *cpool, struct symtab_index_entry *entry)
Definition: dwarf2read.c:22767
static void read_file_scope(struct die_info *, struct dwarf2_cu *)
Definition: dwarf2read.c:9176
struct type * init_type(enum type_code code, int length, int flags, const char *name, struct objfile *objfile)
Definition: gdbtypes.c:2616
#define DW_ADDR(attr)
Definition: dwarf2read.c:1274
FILE * gdb_fopen_cloexec(const char *filename, const char *opentype)
Definition: filestuff.c:304
#define VEC(T)
Definition: vec.h:398
static void check_producer(struct dwarf2_cu *cu)
Definition: dwarf2read.c:12319
static htab_t create_quick_file_names_table(unsigned int nr_initial_entries)
Definition: dwarf2read.c:2639
enum dwarf_tag tag
Definition: dwarf2read.c:1174
unsigned int sect_off
Definition: gdbtypes.h:70
static void psymtabs_addrmap_cleanup(void *o)
Definition: dwarf2read.c:6409
static void uniquify_cu_indices(struct mapped_symtab *symtab)
Definition: dwarf2read.c:22725
static const gdb_byte * gdb_skip_leb128(const gdb_byte *buf, const gdb_byte *buf_end)
Definition: dwarf2expr.h:325
static hashval_t hash_type_unit_group(const void *item)
Definition: dwarf2read.c:5738
search_domain
Definition: symtab.h:473
const char * producer
Definition: dwarf2read.c:446
unsigned char line_range
Definition: dwarf2read.c:1060
#define _(String)
Definition: gdb_locale.h:40
struct type * builtin_core_addr
Definition: gdbtypes.h:1587
static struct type * read_tag_restrict_type(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:14392
struct dwarf2_section_info info
Definition: dwarf2read.c:761
static CORE_ADDR read_addr_index_1(unsigned int addr_index, ULONGEST addr_base, int addr_size)
Definition: dwarf2read.c:16787
bfd_size_type virtual_offset
Definition: dwarf2read.c:137
struct dwarf2_section_info abbrev
Definition: dwarf2read.c:872
static struct die_info * follow_die_ref_or_sig(struct die_info *, const struct attribute *, struct dwarf2_cu **)
Definition: dwarf2read.c:19888
static int producer_is_icc(struct dwarf2_cu *cu)
Definition: dwarf2read.c:13095
static int dwarf2_locexpr_block_index
Definition: dwarf2read.c:102
#define TYPE_FIELD_IGNORE_BITS(thistype)
Definition: gdbtypes.h:1384
unsigned int length
Definition: dwarf2read.c:1035
struct type * builtin_long_long
Definition: gdbtypes.h:1575
sect_offset offset
Definition: dwarf2read.c:1196
struct die_info * parent
Definition: dwarf2read.c:1259
const gdb_byte * address_table
Definition: dwarf2read.c:187
EXTERN int context_stack_depth
Definition: buildsym.h:162
void java_print_type(struct type *, const char *, struct ui_file *, int, int, const struct type_print_options *)
Definition: jv-typeprint.c:335
static int dw2_free_cached_file_names(void **slot, void *info)
Definition: dwarf2read.c:3381
static int read_cutu_die_from_dwo(struct dwarf2_per_cu_data *this_cu, struct dwo_unit *dwo_unit, int abbrev_table_provided, struct die_info *stub_comp_unit_die, const char *stub_comp_dir, struct die_reader_specs *result_reader, const gdb_byte **result_info_ptr, struct die_info **result_comp_unit_die, int *result_has_children)
Definition: dwarf2read.c:5052
const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs
Definition: dwarf2loc.c:387
#define SET_FIELD_BITPOS(thisfld, bitpos)
Definition: gdbtypes.h:1349
struct bfd * gdb_bfd_open(const char *name, const char *target, int fd)
Definition: gdb_bfd.c:320
struct signatured_type * sig_type
Definition: dwarf2read.c:6142
struct objfile * objfile
Definition: dwarf2read.c:23069
dwarf2_section_enum
Definition: symfile.h:632
static gdb_byte * dwarf2_const_value_data(const struct attribute *attr, struct obstack *obstack, struct dwarf2_cu *cu, LONGEST *value, int bits)
Definition: dwarf2read.c:18656
#define outermost_context_p()
Definition: buildsym.h:169
struct dwarf2_section_info line
Definition: dwarf2read.c:859
struct type * builtin_long
Definition: gdbtypes.h:1574
#define TYPE_FIELD(thistype, n)
Definition: gdbtypes.h:1367
char * original_name
Definition: objfiles.h:275
static void dwarf2_read_abbrevs(struct dwarf2_cu *, struct dwarf2_section_info *)
Definition: dwarf2read.c:15420
static int die_is_declaration(struct die_info *, struct dwarf2_cu *cu)
Definition: dwarf2read.c:17085
static struct dwarf2_per_cu_data * dw2_get_cu(int index)
Definition: dwarf2read.c:2756
#define bits(obj, st, fn)
char * go_symbol_package_name(const struct symbol *sym)
Definition: go-lang.c:392
static void dwarf2_section_buffer_overflow_complaint(struct dwarf2_section_info *section)
Definition: dwarf2read.c:1915
struct dwarf2_section_info macro
Definition: dwarf2read.c:862
#define OPF_SEARCH_IN_PATH
Definition: defs.h:318
struct dwarf2_section_info line
Definition: dwarf2read.c:873
uint32_t version
Definition: dwarf2read.c:918
static struct dwo_unit * lookup_dwo_unit(struct dwarf2_per_cu_data *this_cu, struct die_info *comp_unit_die)
Definition: dwarf2read.c:5254
const struct symbol_computed_ops dwarf2_locexpr_funcs
Definition: dwarf2loc.c:4268
static bfd * try_open_dwop_file(const char *file_name, int is_dwp, int search_cwd)
Definition: dwarf2read.c:10449
struct symbol * symbolp
Definition: dwarf2read.c:76
static int add_address_entry_worker(void *datap, CORE_ADDR start_addr, void *obj)
Definition: dwarf2read.c:22916
unsigned int abbrev
Definition: dwarf2read.c:1248
bfd_size_type macro_offset
Definition: dwarf2read.c:902
const gdb_byte * dwarf2_find_location_expression(struct dwarf2_loclist_baton *baton, size_t *locexpr_length, CORE_ADDR pc)
Definition: dwarf2loc.c:205
static struct compunit_symtab * get_compunit_symtab(struct dwarf2_per_cu_data *per_cu)
Definition: dwarf2read.c:7877
#define TYPE_PROTOTYPED(t)
Definition: gdbtypes.h:267
int producer_is_realview(const char *producer)
Definition: symtab.c:6052
static void read_type_unit_scope(struct die_info *, struct dwarf2_cu *)
Definition: dwarf2read.c:9372
static char * anonymous_struct_prefix(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:19176
struct objfile * objfile
Definition: dwarf2read.c:431
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1368
#define END_CATCH
static struct dwarf2_per_objfile * dwarf2_per_objfile
Definition: dwarf2read.c:321
const char ** include_dirs
Definition: dwarf2read.c:1074
sect_offset offset
Definition: dwarf2read.c:1092
static struct pending * common_block
Definition: stabsread.c:4318
int non_public_fields
Definition: dwarf2read.c:1342
int register_symbol_computed_impl(enum address_class aclass, const struct symbol_computed_ops *ops)
Definition: symtab.c:6105
int register_symbol_block_impl(enum address_class aclass, const struct symbol_block_ops *ops)
Definition: symtab.c:6131
static int dw2_map_symtabs_matching_filename(struct objfile *objfile, const char *name, const char *real_path, int(*callback)(struct symtab *, void *), void *data)
Definition: dwarf2read.c:3435
dwp_v2_section_ids
Definition: dwarf2read.c:792
unsigned offset_in_dwz
Definition: dwarf2read.c:1051
bfd * dbfd
Definition: dwarf2read.c:821
struct objfile_per_bfd_storage * per_bfd
Definition: objfiles.h:318
struct type * fcontext
Definition: gdbtypes.h:861
struct value * allocate_value(struct type *type)
Definition: value.c:962
struct dwarf2_section_info * section
Definition: dwarf2read.c:778
htab_t loaded_cus
Definition: dwarf2read.c:968
struct partial_symtab * psymtab
Definition: dwarf2read.c:627
char * debug_file_directory
Definition: symfile.c:1434
enum language pretend_language
Definition: dwarf2read.c:1367
struct symbol * template_symbols
Definition: objfiles.h:414
struct cmd_list_element * maintenance_set_cmdlist
Definition: maint.c:646
static void process_enumeration_scope(struct die_info *, struct dwarf2_cu *)
Definition: dwarf2read.c:13586
static void show_check_physname(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: dwarf2read.c:23384
static void mark_common_block_symbol_computed(struct symbol *sym, struct die_info *common_die, struct attribute *common_loc, struct attribute *member_loc, struct dwarf2_cu *cu)
Definition: dwarf2read.c:13865
size_t n_entries
Definition: f-lang.h:58
Definition: dwarf2read.c:22535
#define INDEX_SUFFIX
Definition: dwarf2read.c:2024
static int bits_per_byte
Definition: dwarf2read.c:1298
struct macro_table * get_macro_table(void)
Definition: buildsym.c:982
unsigned int num_file_names
Definition: dwarf2read.c:2534
static const gdb_byte * read_and_check_comp_unit_head(struct comp_unit_head *header, struct dwarf2_section_info *section, struct dwarf2_section_info *abbrev_section, const gdb_byte *info_ptr, int is_debug_types_section)
Definition: dwarf2read.c:4397
struct dwarf2_section_names abbrev
Definition: symfile.h:611
void store_unsigned_integer(gdb_byte *, int, enum bfd_endian, ULONGEST)
Definition: findvar.c:212
struct compunit_symtab * buildsym_compunit_symtab(void)
Definition: buildsym.c:972
void restart_symtab(struct compunit_symtab *cust, const char *name, CORE_ADDR start_addr)
Definition: buildsym.c:1072
void printf_filtered(const char *format,...)
Definition: utils.c:2388
static void dwarf2_locate_common_dwp_sections(bfd *abfd, asection *sectp, void *dwp_file_ptr)
Definition: dwarf2read.c:10647
void gdb_bfd_record_inclusion(bfd *includer, bfd *includee)
Definition: gdb_bfd.c:777
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
int n_static_syms
Definition: psympriv.h:167
struct die_info * dies
Definition: dwarf2read.c:489
static gdb_index_symbol_kind symbol_kind(struct partial_symbol *psym)
Definition: dwarf2read.c:22978
static struct type * new_type(char *)
Definition: mdebugread.c:4864
void c_type_print_args(struct type *type, struct ui_file *stream, int linkage_name, enum language language, const struct type_print_options *flags)
Definition: c-typeprint.c:470
uint32_t offset_type
Definition: dwarf2read.c:150
static struct type * die_type(struct die_info *, struct dwarf2_cu *)
Definition: dwarf2read.c:18825
static void dwarf2_read_addr_index_reader(const struct die_reader_specs *reader, const gdb_byte *info_ptr, struct die_info *comp_unit_die, int has_children, void *data)
Definition: dwarf2read.c:16841
static struct type * read_tag_reference_type(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:14290
struct block * end_symtab_get_static_block(CORE_ADDR end_addr, int expandable, int required)
Definition: buildsym.c:1209
void macro_define_object(struct macro_source_file *source, int line, const char *name, const char *replacement)
Definition: macrotab.c:781
static void dwarf2_const_value_length_mismatch_complaint(const char *arg1, int arg2, int arg3)
Definition: dwarf2read.c:1906
unsigned int cu_index
Definition: dwarf2read.c:22856
EXTERN struct subfile * current_subfile
Definition: buildsym.h:73
static void create_addrmap_from_index(struct objfile *objfile, struct mapped_index *index)
Definition: dwarf2read.c:2883
static struct line_header * dwarf_decode_line_header(unsigned int offset, struct dwarf2_cu *cu)
Definition: dwarf2read.c:17251
ULONGEST signature
Definition: dwarf2read.c:665
static void dwarf2_record_block_ranges(struct die_info *, struct block *, CORE_ADDR, struct dwarf2_cu *)
Definition: dwarf2read.c:12181
struct obstack objfile_obstack
Definition: objfiles.h:328
int globals_offset
Definition: psympriv.h:155
struct stmt_list_hash hash
Definition: dwarf2read.c:2531
mach_port_t kern_return_t mach_port_t msgports mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition: gnu-nat.c:1885
#define TYPE_N_TEMPLATE_ARGUMENTS(thistype)
Definition: gdbtypes.h:1415
struct die_info * child
Definition: dwarf2read.c:1257
void null_cleanup(void *arg)
Definition: cleanups.c:295
struct dwarf2_section_info * section
Definition: dwarf2read.c:610
__extension__ enum dwarf_form form
Definition: dwarf2read.c:1212
const char * name
Definition: dwarf2read.c:1032
#define TRY
unsigned int num_file_names
Definition: dwarf2read.c:1079
struct type * create_string_type(struct type *result_type, struct type *string_char_type, struct type *range_type)
Definition: gdbtypes.c:1152
static void dw2_expand_symtabs_with_fullname(struct objfile *objfile, const char *fullname)
Definition: dwarf2read.c:3788
static struct type_unit_group * create_type_unit_group(struct dwarf2_cu *cu, sect_offset line_offset_struct)
Definition: dwarf2read.c:5778
struct fnfieldlist * fnfieldlists
Definition: dwarf2read.c:1351
#define TYPE_VPTR_FIELDNO(thistype)
Definition: gdbtypes.h:1304
static int is_vtable_name(const char *name, struct dwarf2_cu *cu)
Definition: dwarf2read.c:13031
static void dwarf2_locate_v2_dwp_sections(bfd *abfd, asection *sectp, void *dwp_file_ptr)
Definition: dwarf2read.c:10683
static void add_partial_module(struct partial_die_info *pdi, CORE_ADDR *lowpc, CORE_ADDR *highpc, int set_addrmap, struct dwarf2_cu *cu)
Definition: dwarf2read.c:7083
CORE_ADDR addr
Definition: dwarf2read.c:1225
struct value * dwarf2_evaluate_loc_desc(struct type *type, struct frame_info *frame, const gdb_byte *data, size_t size, struct dwarf2_per_cu_data *per_cu)
Definition: dwarf2loc.c:2391
static void set_type(type_object *obj, struct type *type)
Definition: py-type.c:1122
struct dwp_hash_table::@60::@61 v1
struct typedef_field_list * next
Definition: dwarf2read.c:1324
struct dwarf2_section_info line
Definition: dwarf2read.c:754
struct cmd_list_element * setlist
Definition: cli-cmds.c:135
static LONGEST read_signed_leb128(bfd *, const gdb_byte *, unsigned int *)
Definition: dwarf2read.c:16753
int is_cplus_marker(int c)
Definition: demangle.c:154
static void dwarf2_locate_dwo_sections(bfd *abfd, asection *sectp, void *dwo_sections_ptr)
Definition: dwarf2read.c:10543
static void fixup_partial_die(struct partial_die_info *, struct dwarf2_cu *)
Definition: dwarf2read.c:16106
const gdb_byte * safe_skip_leb128(const gdb_byte *buf, const gdb_byte *buf_end)
Definition: dwarf2expr.c:395
struct compunit_symtab ** includes
Definition: symtab.h:1085
struct obstack comp_unit_obstack
Definition: dwarf2read.c:470
#define TYPE_TYPEDEF_FIELD_ARRAY(thistype)
Definition: gdbtypes.h:1444
const char ** file_names
Definition: dwarf2read.c:2538
char * gdb_demangle(const char *name, int options)
Definition: cp-support.c:1529
#define ALL_OBJFILES(obj)
Definition: objfiles.h:579
static struct mapped_symtab * create_mapped_symtab(void)
Definition: dwarf2read.c:22603
static void age_cached_comp_units(void)
Definition: dwarf2read.c:22096
EXTERN struct using_direct * using_directives
Definition: buildsym.h:121
struct signatured_type * sig_type_ptr
Definition: dwarf2read.c:693
static int read_2_signed_bytes(bfd *abfd, const gdb_byte *buf)
Definition: dwarf2read.c:16443
static struct type * get_die_type_at_offset(sect_offset, struct dwarf2_per_cu_data *)
Definition: dwarf2read.c:22301
static void check_line_address(struct dwarf2_cu *cu, lnp_state_machine *state, const gdb_byte *line_ptr, CORE_ADDR lowpc, CORE_ADDR address)
Definition: dwarf2read.c:17716
#define TYPE_FN_FIELD_PHYSNAME(thisfn, n)
Definition: gdbtypes.h:1423
static const char * dwarf_tag_name(unsigned int)
Definition: dwarf2read.c:19600
struct dwarf2_section_info addr
Definition: dwarf2read.c:227
struct dwarf2_section_info gdb_index
Definition: dwarf2read.c:987
static struct dwarf2_per_cu_data * dw2_symtab_iter_next(struct dw2_symtab_iterator *iter)
Definition: dwarf2read.c:3567
static struct signatured_type * lookup_signatured_type(struct dwarf2_cu *cu, ULONGEST sig)
Definition: dwarf2read.c:4990
#define VEC_iterate(T, V, I, P)
Definition: vec.h:165
#define PSYMBOL_CLASS(psymbol)
Definition: psympriv.h:57
static void delete_symtab_entry(void *p)
Definition: dwarf2read.c:22584
#define SLASH_STRING
Definition: host-defs.h:58
static void hash_expand(struct mapped_symtab *symtab)
Definition: dwarf2read.c:22649
uint32_t nr_slots
Definition: dwarf2read.c:919
const gdb_byte * buffer
Definition: dwarf2read.c:1014
struct partial_die_info * die_child
Definition: dwarf2read.c:1167
enum array_ordering la_array_ordering
Definition: language.h:162
static struct type_unit_group * get_type_unit_group(struct dwarf2_cu *cu, const struct attribute *stmt_list)
Definition: dwarf2read.c:5823
static const gdb_byte * skip_one_die(const struct die_reader_specs *reader, const gdb_byte *info_ptr, struct abbrev_info *abbrev)
Definition: dwarf2read.c:7258
#define SYMBOL_ACLASS_INDEX(symbol)
Definition: symtab.h:792
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2217
static void get_scope_pc_bounds(struct die_info *, CORE_ADDR *, CORE_ADDR *, struct dwarf2_cu *)
Definition: dwarf2read.c:12123
static struct type * read_structure_type(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:13116
int included_p
Definition: dwarf2read.c:1037
bfd_size_type info_or_types_size
Definition: dwarf2read.c:911
#define SYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:182
struct symbol * contents[1]
Definition: f-lang.h:62
int build_id_verify(bfd *abfd, size_t check_len, const bfd_byte *check)
Definition: build-id.c:48
static int write_one_signatured_type(void **slot, void *d)
Definition: dwarf2read.c:23080
static struct compunit_symtab * dwarf2_start_symtab(struct dwarf2_cu *, const char *, const char *, CORE_ADDR)
Definition: dwarf2read.c:18163
int nsyms
Definition: buildsym.h:101
static const struct objfile_data * dwarf2_objfile_data_key
Definition: dwarf2read.c:96
static void add_partial_enumeration(struct partial_die_info *enum_pdi, struct dwarf2_cu *cu)
Definition: dwarf2read.c:7171
#define CATCH(EXCEPTION, MASK)
bfd_size_type loc_offset
Definition: dwarf2read.c:896
unsigned int total_length
Definition: dwarf2read.c:1053
int dwarf2_initialize_objfile(struct objfile *objfile)
Definition: dwarf2read.c:4194
static void free_dwo_file_cleanup(void *)
Definition: dwarf2read.c:11128
static int eq_psymtab_cu_index(const void *item_lhs, const void *item_rhs)
Definition: dwarf2read.c:22868
static const char * consume_improper_spaces(const char *p, const char *body)
Definition: dwarf2read.c:20868
struct dwarf2_section_info abbrev
Definition: dwarf2read.c:857
static void read_import_statement(struct die_info *die, struct dwarf2_cu *)
Definition: dwarf2read.c:8863
const gdb_byte * buffer_end
Definition: dwarf2read.c:1017
struct type * create_set_type(struct type *result_type, struct type *domain_type)
Definition: gdbtypes.c:1176
struct abbrev_table * abbrev_table
Definition: dwarf2read.c:462
void block_set_scope(struct block *block, const char *scope, struct obstack *obstack)
Definition: block.c:312
struct type * create_range_type(struct type *result_type, struct type *index_type, const struct dynamic_prop *low_bound, const struct dynamic_prop *high_bound)
Definition: gdbtypes.c:825
static const struct dwop_section_names dwop_section_names
static void dwarf2_macro_malformed_definition_complaint(const char *arg1)
Definition: dwarf2read.c:1925
static int dwarf2_flag_true_p(struct die_info *die, unsigned name, struct dwarf2_cu *cu)
Definition: dwarf2read.c:17077
static const char * dwarf_attr_name(unsigned int)
Definition: dwarf2read.c:19613
struct type * make_restrict_type(struct type *type)
Definition: gdbtypes.c:696
static hashval_t hash_dwp_loaded_cutus(const void *item)
Definition: dwarf2read.c:10740
static int first_time
Definition: monitor.c:106
void dwarf2_free_objfile(struct objfile *objfile)
Definition: dwarf2read.c:22162
int section_ids[MAX_NR_V2_DWO_SECTIONS]
Definition: dwarf2read.c:938
htab_t partial_dies
Definition: dwarf2read.c:466
struct dwarf2_section_info frame
Definition: dwarf2read.c:228
struct type * lookup_memberptr_type(struct type *type, struct type *domain)
Definition: gdbtypes.c:780
static void dw2_expand_all_symtabs(struct objfile *objfile)
Definition: dwarf2read.c:3772
char * gnutarget
Definition: corefile.c:437
struct dwarf2_section_info loc
Definition: dwarf2read.c:222
void gdb_bfd_unref(struct bfd *abfd)
Definition: gdb_bfd.c:475
static void dwarf_decode_lines(struct line_header *, const char *, struct dwarf2_cu *, struct partial_symtab *, CORE_ADDR, int decode_mapping)
Definition: dwarf2read.c:18059
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:2992
#define SYMBOL_DOMAIN(symbol)
Definition: symtab.h:790
int core_addr_eq(const void *ap, const void *bp)
Definition: utils.c:2793
EXTERN struct pending * global_symbols
Definition: buildsym.h:113
static struct abbrev_info * abbrev_table_alloc_abbrev(struct abbrev_table *abbrev_table)
Definition: dwarf2read.c:15252
struct pending * next
Definition: buildsym.h:100
struct pending_block * old_blocks
Definition: buildsym.h:138
static hashval_t hash_signatured_type(const void *item)
Definition: dwarf2read.c:4540
const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs
Definition: dwarf2loc.c:407
static void write_address_map(struct objfile *objfile, struct obstack *obstack, htab_t cu_index_htab)
Definition: dwarf2read.c:22947
char * cp_remove_params(const char *demangled_name)
Definition: cp-support.c:880
struct dwarf2_section_info info_or_types
Definition: dwarf2read.c:880
static void read_module(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:14136
static htab_t create_strtab(void)
Definition: dwarf2read.c:22503
struct compunit_symtab * end_symtab_from_static_block(struct block *static_block, int section, int expandable)
Definition: buildsym.c:1481
__extension__ enum dwarf_attribute name
Definition: dwarf2read.c:1211
const char * linkage_name
Definition: dwarf2read.c:1133
static void dwarf2_release_queue(void *dummy)
Definition: dwarf2read.c:7603
unsigned int load_all_dies
Definition: dwarf2read.c:581
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
static void process_full_comp_unit(struct dwarf2_per_cu_data *, enum language)
Definition: dwarf2read.c:8019
int openp(const char *, int, const char *, int, char **)
Definition: source.c:739
const char * const_char_ptr
Definition: gdb_vecs.h:26
#define SYMBOL_SET_LANGUAGE(symbol, language, obstack)
Definition: symtab.h:196
void * xzalloc(size_t size)
Definition: common-utils.c:91
struct partial_symbol ** next
Definition: symfile.h:64
const char * comp_dir
Definition: dwarf2read.c:817
struct dwarf2_section_names cu_index
Definition: dwarf2read.c:359
Definition: dwarf2read.c:1030
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition: cli-decode.c:159
static struct partial_die_info * find_partial_die(sect_offset, int, struct dwarf2_cu *)
Definition: dwarf2read.c:15988
static void set_dwarf_cmd(char *args, int from_tty)
Definition: dwarf2read.c:22424
unsigned int number
Definition: dwarf2read.c:1173
int nr_all_type_units_reallocs
Definition: dwarf2read.c:211
static void dwarf2_debug_line_missing_file_complaint(void)
Definition: dwarf2read.c:1885
static void dwarf2_get_subprogram_pc_bounds(struct die_info *die, CORE_ADDR *lowpc, CORE_ADDR *highpc, struct dwarf2_cu *cu)
Definition: dwarf2read.c:12087
const char * symbol_get_demangled_name(const struct general_symbol_info *gsymbol)
Definition: symtab.c:612
struct nextfnfield * next
Definition: dwarf2read.c:1310
static void dw2_relocate(struct objfile *objfile, const struct section_offsets *new_offsets, const struct section_offsets *delta)
Definition: dwarf2read.c:3739
#define DW_FIELD_ALLOC_CHUNK
Definition: dwarf2read.c:1292
static struct type * read_base_type(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:14689
static void dwarf2_find_base_address(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:4287
static hashval_t hash_dwo_unit(const void *item)
Definition: dwarf2read.c:9464
asection * asection
Definition: dwarf2read.c:126
void init_psymbol_list(struct objfile *, int)
Definition: psymtab.c:1737
struct dwarf2_per_cu_data * per_cu
Definition: dwarf2read.c:1366
static int get_section_id(const struct dwarf2_section_info *section)
Definition: dwarf2read.c:2117
static struct die_info * die_specification(struct die_info *die, struct dwarf2_cu **)
Definition: dwarf2read.c:17105
static void write_obstack(FILE *file, struct obstack *obstack)
Definition: dwarf2read.c:23048
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
static struct abbrev_info * peek_die_abbrev(const gdb_byte *info_ptr, unsigned int *bytes_read, struct dwarf2_cu *cu)
Definition: dwarf2read.c:7206
static hashval_t partial_die_hash(const void *item)
Definition: dwarf2read.c:22401
struct symtab * compunit_primary_filetab(const struct compunit_symtab *cust)
Definition: symtab.c:287
struct partial_symtab * start_psymtab_common(struct objfile *, const char *, CORE_ADDR, struct partial_symbol **, struct partial_symbol **)
Definition: psymtab.c:1516
static int dwarf_max_cache_age
Definition: dwarf2read.c:1379
#define MAX_NESTED_IMPORTED_DECLARATIONS
#define ATTR_ALLOC_CHUNK
Definition: dwarf2read.c:1287
static int die_needs_namespace(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:8354
char * obconcat(struct obstack *obstackp,...)
Definition: gdb_obstack.c:29
struct cmd_list_element * showlist
Definition: cli-cmds.c:143
void exception_print(struct ui_file *file, struct gdb_exception e)
Definition: exceptions.c:109
static struct type * get_DW_AT_signature_type(struct die_info *, const struct attribute *, struct dwarf2_cu *)
Definition: dwarf2read.c:20372
static const char * dwarf2_full_name(const char *name, struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:8685
int line_has_non_zero_discriminator
Definition: dwarf2read.c:17504
static int handle_data_member_location(struct die_info *die, struct dwarf2_cu *cu, LONGEST *offset)
Definition: dwarf2read.c:12399
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:2145
static struct dwarf2_section_info create_dwp_v2_section(struct dwarf2_section_info *section, bfd_size_type offset, bfd_size_type size)
Definition: dwarf2read.c:10160
static struct macro_source_file * macro_start_file(int file, int line, struct macro_source_file *current_file, struct line_header *lh)
Definition: dwarf2read.c:20827
static struct dwo_unit * create_dwo_unit_in_dwp_v2(struct dwp_file *dwp_file, uint32_t unit_index, const char *comp_dir, ULONGEST signature, int is_debug_types)
Definition: dwarf2read.c:10203
CORE_ADDR pc
Definition: gdbtypes.h:1163
const char * name
Definition: gdbtypes.h:904
static void read_signatured_type_reader(const struct die_reader_specs *reader, const gdb_byte *info_ptr, struct die_info *comp_unit_die, int has_children, void *data)
Definition: dwarf2read.c:20425
struct dwarf2_section_info loc
Definition: dwarf2read.c:755
static void dwarf_decode_lines_1(struct line_header *lh, struct dwarf2_cu *cu, const int decode_for_pst_p, CORE_ADDR lowpc)
Definition: dwarf2read.c:17748
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:56
static struct type * read_type_die_1(struct die_info *, struct dwarf2_cu *)
Definition: dwarf2read.c:19021
struct cleanup * make_cleanup_discard_psymtabs(struct objfile *)
Definition: psymtab.c:1876
unsigned int has_pc_info
Definition: dwarf2read.c:1103
#define ALLOCATE_CPLUS_STRUCT_TYPE(type)
Definition: gdbtypes.h:1200
#define DW2_GDB_INDEX_CU_SET_VALUE(cu_index, value)
Definition: dwarf2read.c:170
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:192
void free_current_contents(void *ptr)
Definition: utils.c:476
int version
Definition: dwarf2read.c:953
static void queue_and_load_all_dwo_tus(struct dwarf2_per_cu_data *)
Definition: dwarf2read.c:11092
void dwarf2_get_section_info(struct objfile *objfile, enum dwarf2_section_enum sect, asection **sectp, const gdb_byte **bufp, bfd_size_type *sizep)
Definition: dwarf2read.c:2362
static void read_func_scope(struct die_info *, struct dwarf2_cu *)
Definition: dwarf2read.c:11312
struct abbrev_info ** abbrevs
Definition: dwarf2read.c:1205
#define SYMBOL_COMPUTED_OPS(symbol)
Definition: symtab.h:801
sect_offset offset
Definition: dwarf2read.c:397
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
#define VEC_length(T, V)
Definition: vec.h:124
unsigned int has_byte_size
Definition: dwarf2read.c:1111
static const gdb_byte * skip_children(const struct die_reader_specs *reader, const gdb_byte *info_ptr)
Definition: dwarf2read.c:7235
void complaint(struct complaints **complaints, const char *fmt,...)
Definition: complaints.c:251
struct dwarf2_section_info types
Definition: dwarf2read.c:864
int( expand_symtabs_symbol_matcher_ftype)(const char *name, void *data)
Definition: symfile.h:139
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
bfd_size_type abbrev_offset
Definition: dwarf2read.c:890
struct dwarf2_per_cu_data * per_cu
Definition: dwarf2loc.h:176
offset_type size
Definition: dwarf2read.c:22550
static ULONGEST read_8_bytes(bfd *, const gdb_byte *)
Definition: dwarf2read.c:16461
const struct language_defn * language_defn
Definition: dwarf2read.c:444
static void dwarf2_read_symtab(struct partial_symtab *, struct objfile *)
Definition: dwarf2read.c:7411
static hashval_t line_header_hash_voidp(const void *item)
Definition: dwarf2read.c:1952
#define ANOFFSET(secoff, whichone)
Definition: symtab.h:910
htab_t call_site_htab
Definition: symtab.h:1070
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:368
static void dump_die_for_error(struct die_info *)
Definition: dwarf2read.c:19783
struct dwarf2_section_info macro
Definition: dwarf2read.c:757
static const char * get_section_name(const struct dwarf2_section_info *)
Definition: dwarf2read.c:2095
static int queue_and_load_dwo_tu(void **slot, void *info)
Definition: dwarf2read.c:11063
unsigned int previous_cu_index
Definition: dwarf2read.c:22888
EXTERN struct pending * local_symbols
Definition: buildsym.h:117
struct addrmap * addrmap_create_mutable(struct obstack *obstack)
Definition: addrmap.c:568
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
static int dwarf2_section_empty_p(const struct dwarf2_section_info *section)
Definition: dwarf2read.c:2253
const char version[]
Definition: version.c:2
#define B_BYTES(x)
Definition: gdbtypes.h:79
unsigned int locations_valid
Definition: symtab.h:1063
struct dwarf2_section_info info
Definition: dwarf2read.c:983
static struct compunit_symtab * dw2_lookup_symbol(struct objfile *objfile, int block_index, const char *name, domain_enum domain)
Definition: dwarf2read.c:3651
Definition: gdbtypes.h:749
static struct symtab_index_entry ** find_slot(struct mapped_symtab *symtab, const char *name)
Definition: dwarf2read.c:22631
struct compunit_symtab * end_expandable_symtab(CORE_ADDR end_addr, int section)
Definition: buildsym.c:1540
static struct type * get_die_type(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:22322
static int build_type_psymtab_dependencies(void **slot, void *info)
Definition: dwarf2read.c:6292
static int producer_is_gxx_lt_4_6(struct dwarf2_cu *cu)
Definition: dwarf2read.c:12356
void( die_reader_func_ftype)(const struct die_reader_specs *reader, const gdb_byte *info_ptr, struct die_info *comp_unit_die, int has_children, void *data)
Definition: dwarf2read.c:1024
static int process_dwo_file_for_skeletonless_type_units(void **slot, void *info)
Definition: dwarf2read.c:6376
unsigned char signed_addr_p
Definition: dwarf2read.c:386
struct type * type
Definition: gdbtypes.h:553
#define VEC_index(T, V, I)
Definition: vec.h:151
static struct signatured_type * lookup_dwo_signatured_type(struct dwarf2_cu *cu, ULONGEST sig)
Definition: dwarf2read.c:4874
int statics_offset
Definition: psympriv.h:166
struct dwarf2_section_names line
Definition: symfile.h:612
struct macro_source_file * macro_include(struct macro_source_file *source, int line, const char *included)
Definition: macrotab.c:449
#define TYPE_CPLUS_DYNAMIC(thistype)
Definition: gdbtypes.h:1332
#define SET_TYPE_FIELD_PRIVATE(thistype, n)
Definition: gdbtypes.h:1388
static void dwarf2_complex_location_expr_complaint(void)
Definition: dwarf2read.c:1900
static void dump_die_1(struct ui_file *, int level, int max_level, struct die_info *)
Definition: dwarf2read.c:19789
static void build_type_psymtabs_1(void)
Definition: dwarf2read.c:6178
const gdb_byte * indices
Definition: dwarf2read.c:925
static asection * get_section_bfd_section(const struct dwarf2_section_info *section)
Definition: dwarf2read.c:2082
static LONGEST read_checked_initial_length_and_offset(bfd *, const gdb_byte *, const struct comp_unit_head *, unsigned int *, unsigned int *)
Definition: dwarf2read.c:16588
static void dw2_do_instantiate_symtab(struct dwarf2_per_cu_data *per_cu)
Definition: dwarf2read.c:2666
struct context_stack * pop_context(void)
Definition: buildsym.c:1653
#define NO_STMT_LIST_TYPE_UNIT_PSYMTAB
Definition: dwarf2read.c:5771
gdb_byte * value_contents_writeable(struct value *value)
Definition: value.c:1338
union dwp_hash_table::@60 section_pool
struct type * alloc_type(struct objfile *objfile)
Definition: gdbtypes.c:165
struct dwarf2_locexpr_baton locexpr
Definition: dwarf2loc.h:230
#define CP_ANONYMOUS_NAMESPACE_STR
Definition: cp-support.h:42
address_class
Definition: symtab.h:493
static int line_header_eq_voidp(const void *item_lhs, const void *item_rhs)
Definition: dwarf2read.c:1962
static const char * type
Definition: language.c:103
struct dwarf2_section_info line
Definition: dwarf2read.c:221
struct die_info * die
Definition: dwarf2read.c:421
unsigned int has_type
Definition: dwarf2read.c:1101
#define gdb_assert(expr)
Definition: gdb_assert.h:33
static unsigned int read_2_bytes(bfd *, const gdb_byte *)
Definition: dwarf2read.c:16437
static int dwarf2_locexpr_index
Definition: dwarf2read.c:100
static int attr_form_is_block(const struct attribute *)
Definition: dwarf2read.c:21678
const char * name
Definition: dwarf2read.c:1316
struct value * value_from_longest(struct type *type, LONGEST num)
Definition: value.c:3464
#define SYMBOL_LINE(symbol)
Definition: symtab.h:800
unsigned dummy
Definition: go32-nat.c:1071
static struct signatured_type * lookup_dwp_signatured_type(struct dwarf2_cu *cu, ULONGEST sig)
Definition: dwarf2read.c:4942
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:241
struct dwarf2_per_cu_quick_data * quick
Definition: dwarf2read.c:630
CORE_ADDR gdbarch_adjust_dwarf2_addr(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: gdbarch.c:3200
void exception_fprintf(struct ui_file *file, struct gdb_exception e, const char *prefix,...)
Definition: exceptions.c:119
CORE_ADDR lowpc
Definition: dwarf2read.c:1151
#define min(a, b)
Definition: defs.h:106
struct compunit_symtab * compunit_symtabs
Definition: objfiles.h:291
static const char * read_indirect_string(bfd *, const gdb_byte *, const struct comp_unit_head *, unsigned int *)
Definition: dwarf2read.c:16714
struct type * type
Definition: gdbtypes.h:908
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:75
static void noop_record_line(struct subfile *subfile, int line, CORE_ADDR pc)
Definition: dwarf2read.c:17527
static void dwarf_decode_macros(struct dwarf2_cu *, unsigned int, int)
Definition: dwarf2read.c:21484
void dump_die(struct die_info *, int max_level)
Definition: dwarf2read.c:19826
void add_dyn_prop(enum dynamic_prop_node_kind prop_kind, struct dynamic_prop prop, struct type *type, struct objfile *objfile)
Definition: gdbtypes.c:2171
static htab_t allocate_dwo_unit_table(struct objfile *objfile)
Definition: dwarf2read.c:9489
#define B_CLRALL(a, x)
Definition: gdbtypes.h:80
int iterate_over_some_symtabs(const char *name, const char *real_path, int(*callback)(struct symtab *symtab, void *data), void *data, struct compunit_symtab *first, struct compunit_symtab *after_last)
Definition: symtab.c:361
#define SET_FIELD_ENUMVAL(thisfld, enumval)
Definition: gdbtypes.h:1352
static int maybe_queue_comp_unit(struct dwarf2_cu *dependent_cu, struct dwarf2_per_cu_data *per_cu, enum language pretend_language)
Definition: dwarf2read.c:7491
struct dwarf2_section_names info_dwo
Definition: dwarf2read.c:351
struct dwarf2_section_names info
Definition: symfile.h:610
ULONGEST unsnd
Definition: dwarf2read.c:1223
unsigned int dir_index
Definition: dwarf2read.c:1033
static const char * dwarf2_physname(const char *name, struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:8698
CORE_ADDR textlow
Definition: psympriv.h:105
int gdbarch_addr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1707
static struct symbol * new_symbol(struct die_info *, struct type *, struct dwarf2_cu *)
Definition: dwarf2read.c:18642
void macro_define_special(struct macro_table *table)
Definition: macrotab.c:791
unsigned char building_fullname
Definition: dwarf2read.c:1242
static struct dwo_unit * lookup_dwo_type_unit(struct signatured_type *, const char *, const char *)
Definition: dwarf2read.c:11054
static void error_check_comp_unit_head(struct comp_unit_head *header, struct dwarf2_section_info *section, struct dwarf2_section_info *abbrev_section)
Definition: dwarf2read.c:4363
static int need_gnat_info(struct dwarf2_cu *)
Definition: dwarf2read.c:18844
static void dwarf_decode_macro_bytes(bfd *abfd, const gdb_byte *mac_ptr, const gdb_byte *mac_end, struct macro_source_file *current_file, struct line_header *lh, struct dwarf2_section_info *section, int section_is_gnu, int section_is_dwz, unsigned int offset_size, htab_t include_hash)
Definition: dwarf2read.c:21213
static void handle_DW_AT_stmt_list(struct die_info *die, struct dwarf2_cu *cu, const char *comp_dir, CORE_ADDR lowpc)
Definition: dwarf2read.c:9079
bfd * dwz_bfd
Definition: dwarf2read.c:990
static int find_slot_in_mapped_hash(struct mapped_index *index, const char *name, offset_type **vec_out)
Definition: dwarf2read.c:2967
struct dwarf2_section_names frame
Definition: symfile.h:620
struct dwarf2_section_names loc
Definition: symfile.h:613
static void init_cutu_and_read_dies_simple(struct dwarf2_per_cu_data *this_cu, die_reader_func_ftype *die_reader_func, void *data)
Definition: dwarf2read.c:5722
static int attr_form_is_section_offset(const struct attribute *)
Definition: dwarf2read.c:21698
char * xstrprintf(const char *format,...)
Definition: common-utils.c:107
static const gdb_byte * write_constant_as_bytes(struct obstack *obstack, enum bfd_endian byte_order, struct type *type, ULONGEST value, LONGEST *len)
Definition: dwarf2read.c:20064
struct nextfield * fields
Definition: dwarf2read.c:1333
void wrap_here(char *indent)
Definition: utils.c:1930
struct dwarf2_section_info str_offsets
Definition: dwarf2read.c:877
struct symtab_index_entry ** data
Definition: dwarf2read.c:22551
static struct type * die_descriptive_type(struct die_info *, struct dwarf2_cu *)
Definition: dwarf2read.c:18862
static unsigned int dwarf_die_debug
Definition: dwarf2read.c:85
static void dwarf2_mark(struct dwarf2_cu *)
Definition: dwarf2read.c:22378
int number_of_dependencies
Definition: psympriv.h:148
static struct partial_die_info * load_partial_dies(const struct die_reader_specs *, const gdb_byte *, int)
Definition: dwarf2read.c:15476
struct cmd_list_element * setdebuglist
Definition: cli-cmds.c:173
#define TYPE_FIELDS(thistype)
Definition: gdbtypes.h:1242
unsigned char minimum_instruction_length
Definition: dwarf2read.c:1056
static struct type * die_containing_type(struct die_info *, struct dwarf2_cu *)
Definition: dwarf2read.c:18893
static int dwarf_record_line_p(unsigned int line, unsigned int last_line, int line_has_non_zero_discriminator, struct subfile *last_subfile)
Definition: dwarf2read.c:17563
char * cp_canonicalize_string(const char *string)
Definition: cp-support.c:587
void addrmap_set_empty(struct addrmap *map, CORE_ADDR start, CORE_ADDR end_inclusive, void *obj)
Definition: addrmap.c:50
Definition: symtab.h:925
static const gdb_byte * read_n_bytes(bfd *, const gdb_byte *, unsigned int)
Definition: dwarf2read.c:16646
static struct type * lookup_die_type(struct die_info *, const struct attribute *, struct dwarf2_cu *)
Definition: dwarf2read.c:18930
static int offset_type_compare(const void *ap, const void *bp)
Definition: dwarf2read.c:22714
unsigned int has_const_value
Definition: dwarf2read.c:1114
static void free_stack_comp_unit(void *)
Definition: dwarf2read.c:22058
bfd_size_type str_offsets_size
Definition: dwarf2read.c:906
struct dwarf2_per_cu_data per_cu
Definition: dwarf2read.c:719
static void add_partial_symbol(struct partial_die_info *, struct dwarf2_cu *)
Definition: dwarf2read.c:6873
unsigned char psymtabs_addrmap_supported
Definition: psympriv.h:179
static char encoding[]
Definition: remote-mips.c:2988
const char * objfile_name(const struct objfile *objfile)
Definition: objfiles.c:1499
#define FIELD_BITSIZE(thisfld)
Definition: gdbtypes.h:1365
asection ** elf_sections
Definition: dwarf2read.c:974
struct dwarf2_section_names macro
Definition: symfile.h:615
static void init_lnp_state_machine(lnp_state_machine *state, const lnp_reader_state *reader)
Definition: dwarf2read.c:17685
int basenames_may_differ
Definition: symtab.c:220
void * xmalloc(YYSIZE_T)
struct compunit_symtab * start_symtab(struct objfile *objfile, const char *name, const char *comp_dir, CORE_ADDR start_addr)
Definition: buildsym.c:1036
#define TYPE_TAIL_CALL_LIST(thistype)
Definition: gdbtypes.h:1325
LONGEST const_val
Definition: gdbtypes.h:419
offset_type offset
Definition: dwarf2read.c:22474
static CORE_ADDR decode_locdesc(struct dwarf_block *, struct dwarf2_cu *)
Definition: dwarf2read.c:20497
struct ui_file * gdb_stdlog
Definition: main.c:73
const char * normal
Definition: symfile.h:598
static void add_address_entry(struct objfile *objfile, struct obstack *obstack, CORE_ADDR start, CORE_ADDR end, unsigned int cu_index)
Definition: dwarf2read.c:22896
static const char * namespace_name(struct die_info *die, int *is_anonymous, struct dwarf2_cu *)
Definition: dwarf2read.c:14156
struct ui_file * mem_fileopen(void)
Definition: ui-file.c:427
void symbol_set_demangled_name(struct general_symbol_info *gsymbol, const char *name, struct obstack *obstack)
Definition: symtab.c:588
static int use_deprecated_index_sections
Definition: dwarf2read.c:94
htab_t loaded_tus
Definition: dwarf2read.c:969
static void dwarf2_const_value(const struct attribute *, struct symbol *, struct dwarf2_cu *)
Definition: dwarf2read.c:18791
static void process_die(struct die_info *, struct dwarf2_cu *)
Definition: dwarf2read.c:8246
struct dwarf_block * blk
Definition: dwarf2read.c:1222
struct partial_symtab * user
Definition: psympriv.h:135
unsigned int reading_dwo_directly
Definition: dwarf2read.c:595
char * language_class_name_from_physname(const struct language_defn *lang, const char *physname)
Definition: language.c:639
LONGEST snd
Definition: dwarf2read.c:1224
void * read_symtab_private
Definition: psympriv.h:204
union attribute::@64 u
struct dwarf2_section_info str
Definition: dwarf2read.c:225
bfd_size_type str_offsets_offset
Definition: dwarf2read.c:905
DEF_VEC_O(dwarf2_section_info_def)
unsigned int length
Definition: dwarf2read.c:782
void cmd_show_list(struct cmd_list_element *list, int from_tty, const char *prefix)
Definition: cli-setshow.c:672
static const char * read_str_index(const struct die_reader_specs *reader, ULONGEST str_index)
Definition: dwarf2read.c:16912
struct symtab * symtab
Definition: dwarf2read.c:1039
static void find_file_and_directory(struct die_info *die, struct dwarf2_cu *cu, const char **name, const char **comp_dir)
Definition: dwarf2read.c:9031
static struct bfd * get_section_bfd_owner(const struct dwarf2_section_info *section)
Definition: dwarf2read.c:2068
ULONGEST signature
Definition: dwarf2read.c:1226
struct dwarf2_section_names macinfo_dwo
Definition: dwarf2read.c:354
unsigned int mod_time
Definition: dwarf2read.c:1034
unsigned int is_external
Definition: dwarf2read.c:1099
#define TYPE_UNSIGNED(t)
Definition: gdbtypes.h:233
static htab_t allocate_signatured_type_table(struct objfile *objfile)
Definition: dwarf2read.c:4560
static void load_partial_comp_unit(struct dwarf2_per_cu_data *this_cu)
Definition: dwarf2read.c:6533
#define SYMBOL_VALUE(symbol)
Definition: symtab.h:181
static void free_dwo_file(struct dwo_file *dwo_file, struct objfile *objfile)
Definition: dwarf2read.c:11114
unsigned int no_file_data
Definition: dwarf2read.c:2565
static struct dwarf2_queue_item * dwarf2_queue
Definition: dwarf2read.c:1372
struct partial_symtab * allocate_psymtab(const char *, struct objfile *) ATTRIBUTE_NONNULL(1)
Definition: psymtab.c:1774
#define TYPE_STUB_SUPPORTED(t)
Definition: gdbtypes.h:306
Definition: block.h:60
static int attr_form_is_ref(const struct attribute *)
Definition: dwarf2read.c:21740
static void dwarf2_add_member_fn(struct field_info *, struct die_info *, struct type *, struct dwarf2_cu *)
Definition: dwarf2read.c:12781
#define VEC_empty(T, V)
Definition: vec.h:132
void add_psymbol_to_list(const char *, int, int, domain_enum, enum address_class, struct psymbol_allocation_list *, long, CORE_ADDR, enum language, struct objfile *)
Definition: value.c:172
static const char * dwarf2_canonicalize_name(const char *, struct dwarf2_cu *, struct obstack *)
Definition: dwarf2read.c:19432
static void dwarf2_const_value_attr(const struct attribute *attr, struct type *type, const char *name, struct obstack *obstack, struct dwarf2_cu *cu, LONGEST *value, const gdb_byte **bytes, struct dwarf2_locexpr_baton **baton)
Definition: dwarf2read.c:18688
struct type * builtin_int
Definition: gdbtypes.h:1573
unsigned long hash(const void *addr, int length)
Definition: bcache.c:98
struct dwarf2_section_names loc_dwo
Definition: dwarf2read.c:353
sect_offset spec_offset
Definition: dwarf2read.c:1163
static void read_lexical_block_scope(struct die_info *, struct dwarf2_cu *)
Definition: dwarf2read.c:11491
static struct type * add_array_cv_type(struct die_info *die, struct dwarf2_cu *cu, struct type *base_type, int cnst, int voltl)
Definition: dwarf2read.c:14323
static void dwarf_record_line_1(struct gdbarch *gdbarch, struct subfile *subfile, unsigned int line, CORE_ADDR address, record_line_ftype p_record_line)
Definition: dwarf2read.c:17583
static void abbrev_table_add_abbrev(struct abbrev_table *abbrev_table, unsigned int abbrev_number, struct abbrev_info *abbrev)
Definition: dwarf2read.c:15265
static void dw2_get_file_names_reader(const struct die_reader_specs *reader, const gdb_byte *info_ptr, struct die_info *comp_unit_die, int has_children, void *data)
Definition: dwarf2read.c:3243
static struct type * read_tag_atomic_type(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:14410
static const char * read_direct_string(bfd *, const gdb_byte *, unsigned int *)
Definition: dwarf2read.c:16656
unsigned int scope_set
Definition: dwarf2read.c:1108
static void recursively_write_psymbols(struct objfile *objfile, struct partial_symtab *psymtab, struct mapped_symtab *symtab, htab_t psyms_seen, offset_type cu_index)
Definition: dwarf2read.c:23118
int blockvector_contains_pc(const struct blockvector *bv, CORE_ADDR pc)
Definition: block.c:214
struct dwo_unit dwo_unit
Definition: dwarf2read.c:9507
struct dwarf2_offset_baton offset_info
Definition: dwarf2loc.h:236
static struct dwarf2_per_cu_data * dwarf2_find_containing_comp_unit(sect_offset offset, unsigned int offset_in_dwz, struct objfile *objfile)
Definition: dwarf2read.c:21949
cu_offset type_offset_in_tu
Definition: dwarf2read.c:670
static ULONGEST read_unsigned_leb128(bfd *, const gdb_byte *, unsigned int *)
Definition: dwarf2read.c:16724
void * hashtab_obstack_allocate(void *data, size_t size, size_t count)
Definition: utils.c:2982
unsigned int file
Definition: dwarf2read.c:17483
struct type * create_array_type_with_stride(struct type *result_type, struct type *element_type, struct type *range_type, unsigned int bit_stride)
Definition: gdbtypes.c:1061
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:51
static bfd * open_dwo_file(const char *file_name, const char *comp_dir)
Definition: dwarf2read.c:10509
#define TYPE_TEMPLATE_ARGUMENTS(thistype)
Definition: gdbtypes.h:1417
struct dwarf2_section_names eh_frame
Definition: symfile.h:621
offset_type address_table_size
Definition: dwarf2read.c:190
int n_global_syms
Definition: psympriv.h:156
unsigned int offset_size
Definition: dwarf2read.c:390
struct type * type
Definition: dwarf2read.c:409
int dwarf_block_to_dwarf_reg(const gdb_byte *buf, const gdb_byte *buf_end)
Definition: dwarf2expr.c:464
#define VEC_truncate(T, V, I)
Definition: vec.h:278
static int eq_signatured_type(const void *item_lhs, const void *item_rhs)
Definition: dwarf2read.c:4549
static void read_comp_units_from_section(struct objfile *objfile, struct dwarf2_section_info *section, unsigned int is_dwz, int *n_allocated, int *n_comp_units, struct dwarf2_per_cu_data ***all_comp_units)
Definition: dwarf2read.c:6540
struct dwarf2_section_info tu_index
Definition: dwarf2read.c:847
#define OBJF_READNOW
Definition: objfiles.h:436
static void init_cu_die_reader(struct die_reader_specs *reader, struct dwarf2_cu *cu, struct dwarf2_section_info *section, struct dwo_file *dwo_file)
Definition: dwarf2read.c:5019
#define gdb_static_assert(expr)
Definition: gdb_assert.h:25
#define COMPUNIT_BLOCKVECTOR(cust)
Definition: symtab.h:1099
static void dwarf2_statement_list_fits_in_line_number_section_complaint(void)
Definition: dwarf2read.c:1878
struct symbol * fixup_symbol_section(struct symbol *sym, struct objfile *objfile)
Definition: symtab.c:1809
struct dwarf2_section_info macinfo
Definition: dwarf2read.c:875
static const char * dwarf_form_name(unsigned int)
Definition: dwarf2read.c:19636
static struct dwo_unit * lookup_dwo_cutu(struct dwarf2_per_cu_data *this_unit, const char *dwo_name, const char *comp_dir, ULONGEST signature, int is_debug_types)
Definition: dwarf2read.c:10921
static const gdb_byte * read_and_check_type_unit_head(struct comp_unit_head *header, struct dwarf2_section_info *section, struct dwarf2_section_info *abbrev_section, const gdb_byte *info_ptr, ULONGEST *signature, cu_offset *type_offset_in_tu)
Definition: dwarf2read.c:4426
bfd_size_type loc_size
Definition: dwarf2read.c:897
const char const char int
Definition: command.h:229
bfd_byte gdb_byte
Definition: common-types.h:38
void cp_scan_for_anonymous_namespaces(const struct symbol *const symbol, struct objfile *const objfile)
Definition: cp-namespace.c:51
struct comp_unit_head header
Definition: dwarf2read.c:434
unsigned int may_be_inlined
Definition: dwarf2read.c:1104
static int dwarf2_loclist_block_index
Definition: dwarf2read.c:103
void smash_to_methodptr_type(struct type *type, struct type *to_type)
Definition: gdbtypes.c:1325
void sort_pst_symbols(struct objfile *, struct partial_symtab *)
Definition: psymtab.c:1501
static const char * get_section_file_name(const struct dwarf2_section_info *)
Definition: dwarf2read.c:2106
int( symbol_compare_ftype)(const char *string1, const char *string2)
Definition: symfile.h:41
#define SYMBOL_SET_NAMES(symbol, linkage_name, len, copy_name, objfile)
Definition: symtab.h:212
struct dwarf2_section_info info
Definition: dwarf2read.c:219
struct dwarf2_cu * cu
Definition: dwarf2read.c:1004
struct dwarf2_section_names addr
Definition: symfile.h:619
struct dwarf2_loclist_baton loclist
Definition: dwarf2loc.h:233
struct nextfield * next
Definition: dwarf2read.c:1302
unsigned int is_constructor
Definition: gdbtypes.h:884
static const gdb_byte * read_attribute(const struct die_reader_specs *, struct attribute *, struct attr_abbrev *, const gdb_byte *)
Definition: dwarf2read.c:16414
static int read_4_signed_bytes(bfd *abfd, const gdb_byte *buf)
Definition: dwarf2read.c:16455
void help_list(struct cmd_list_element *list, const char *cmdtype, enum command_class theclass, struct ui_file *stream)
Definition: cli-decode.c:1023
static LONGEST read_offset(bfd *, const gdb_byte *, const struct comp_unit_head *, unsigned int *)
Definition: dwarf2read.c:16611
static char * file_file_name(int file, struct line_header *lh)
Definition: dwarf2read.c:20772
struct type * make_cv_type(int cnst, int voltl, struct type *type, struct type **typeptr)
Definition: gdbtypes.c:651
#define SET_TYPE_FIELD_VIRTUAL(thistype, n)
Definition: gdbtypes.h:1394
#define O_BINARY
Definition: defs.h:100
__extension__ enum call_site_parameter_kind kind
Definition: gdbtypes.h:1136
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:213
static CORE_ADDR read_address(bfd *, const gdb_byte *ptr, struct dwarf2_cu *, unsigned int *)
Definition: dwarf2read.c:16467
struct dwo_file * dwo_file
Definition: dwarf2read.c:9506
#define TYPE_VARARGS(t)
Definition: gdbtypes.h:282
struct symbol * block_find_symbol(const struct block *block, const char *name, const domain_enum domain, block_symbol_matcher_ftype *matcher, void *data)
Definition: block.c:823
static int per_cu_offset_and_type_eq(const void *item_lhs, const void *item_rhs)
Definition: dwarf2read.c:22215
static void do_ui_file_peek_last(void *object, const char *buffer, long length)
Definition: dwarf2read.c:8411
static int add_signatured_type_cu_to_table(void **slot, void *datum)
Definition: dwarf2read.c:4574
static void dw2_forget_cached_source_info(struct objfile *objfile)
Definition: dwarf2read.c:3400
off_t total_size
Definition: dwarf2read.c:184
const struct language_defn * current_language
Definition: language.c:85
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1229
#define DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE(cu_index, value)
Definition: dwarf2read.c:162
const char * physname
Definition: gdbtypes.h:848
void void void void void void void void void perror_with_name(const char *string) ATTRIBUTE_NORETURN
Definition: utils.c:979
struct dwarf2_section_info macinfo
Definition: dwarf2read.c:223
__extension__ enum dwarf_tag tag
Definition: dwarf2read.c:1095
struct pending * locals
Definition: buildsym.h:130
struct symbol * allocate_symbol(struct objfile *objfile)
Definition: symtab.c:6204
#define max(a, b)
Definition: defs.h:109
static struct type * read_tag_pointer_type(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:14190
struct attribute attrs[1]
Definition: dwarf2read.c:1264
static const char * read_indirect_string_at_offset(bfd *abfd, LONGEST str_offset)
Definition: dwarf2read.c:16673
static void abbrev_table_free_cleanup(void *)
Definition: dwarf2read.c:15408
static struct compunit_symtab * dw2_find_pc_sect_compunit_symtab(struct objfile *objfile, struct bound_minimal_symbol msymbol, CORE_ADDR pc, struct obj_section *section, int warn_if_readin)
Definition: dwarf2read.c:4069
static const gdb_byte * read_full_die(const struct die_reader_specs *, struct die_info **, const gdb_byte *, int *)
Definition: dwarf2read.c:15221
static void dw2_expand_symtabs_for_function(struct objfile *objfile, const char *func_name)
Definition: dwarf2read.c:3747
#define SEEK_SET
Definition: defs.h:87
struct mapped_index * index
Definition: dwarf2read.c:3514
const gdb_byte * statement_program_end
Definition: dwarf2read.c:1084
static void cleanup_mapped_symtab(void *p)
Definition: dwarf2read.c:22615
static int eq_dwp_loaded_cutus(const void *a, const void *b)
Definition: dwarf2read.c:10751
struct dwarf2_section_info info
Definition: dwarf2read.c:858
struct mapped_symtab * symtab
Definition: dwarf2read.c:23070
static struct type * read_typedef(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:14658
int last_used
Definition: dwarf2read.c:482
static htab_t allocate_type_unit_groups_table(void)
Definition: dwarf2read.c:5757
static struct symbol * new_symbol_full(struct die_info *, struct type *, struct dwarf2_cu *, struct symbol *)
Definition: dwarf2read.c:18254
int( expand_symtabs_file_matcher_ftype)(const char *filename, void *data, int basenames)
Definition: symfile.h:133
struct dwarf2_section_names ranges
Definition: symfile.h:617
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
static struct compunit_symtab * dw2_instantiate_symtab(struct dwarf2_per_cu_data *per_cu)
Definition: dwarf2read.c:2710
const char * dirname
Definition: psympriv.h:99
static const char * dw2_get_real_path(struct objfile *objfile, struct quick_file_names *qfn, int index)
Definition: dwarf2read.c:3351
uint32_t nr_columns
Definition: dwarf2read.c:918
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
static htab_t create_symbol_hash_table(void)
Definition: dwarf2read.c:22594
sect_offset offset
Definition: dwarf2read.c:1251
enum language language
Definition: dwarf2read.c:443
const char * constant_pool
Definition: dwarf2read.c:199
union dwarf2_per_cu_data::@59 v
static void read_call_site_scope(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:11550
const gdb_byte * value
Definition: gdbtypes.h:1143
unsigned int cu_off
Definition: gdbtypes.h:62
static sect_offset dwarf2_get_ref_die_offset(const struct attribute *)
Definition: dwarf2read.c:19846
struct partial_symtab ** dependencies
Definition: psympriv.h:146
static void dwarf2_attach_fn_fields_to_type(struct field_info *, struct type *, struct dwarf2_cu *)
Definition: dwarf2read.c:12998
struct ui_file * gdb_stderr
Definition: main.c:72
const offset_type * symbol_table
Definition: dwarf2read.c:193
struct dwarf2_section_info gdb_index
Definition: dwarf2read.c:230
int dwarf2_per_cu_addr_size(struct dwarf2_per_cu_data *per_cu)
Definition: dwarf2read.c:21893
struct dwarf2_per_cu_data * per_cu
Definition: dwarf2read.c:479
struct dwo_file * dwo_file
Definition: dwarf2read.c:770
void record_debugformat(const char *format)
Definition: buildsym.c:1671
static struct type * read_type_die(struct die_info *, struct dwarf2_cu *)
Definition: dwarf2read.c:19006
#define TYPE_CALLING_CONVENTION(thistype)
Definition: gdbtypes.h:1323
struct complaints * symfile_complaints
Definition: complaints.c:105
static struct type * read_tag_volatile_type(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:14368
static int dwarf2_get_pc_bounds(struct die_info *, CORE_ADDR *, CORE_ADDR *, struct dwarf2_cu *, struct partial_symtab *)
Definition: dwarf2read.c:12009
const gdb_byte * data_value
Definition: gdbtypes.h:1149
static void process_queue(void)
Definition: dwarf2read.c:7531
void( make_cleanup_ftype)(void *)
Definition: cleanups.h:30
#define DW_SIGNATURE(attr)
Definition: dwarf2read.c:1275
void c_print_type(struct type *, const char *, struct ui_file *, int, int, const struct type_print_options *)
Definition: c-typeprint.c:80
static int dwarf2_ranges_read(unsigned, CORE_ADDR *, CORE_ADDR *, struct dwarf2_cu *, struct partial_symtab *)
Definition: dwarf2read.c:11848
const char * name
Definition: gdbtypes.h:559
const gdb_byte * dwarf2_fetch_constant_bytes(sect_offset offset, struct dwarf2_per_cu_data *per_cu, struct obstack *obstack, LONGEST *len)
Definition: dwarf2read.c:20085
struct call_site_parameter parameter[1]
Definition: gdbtypes.h:1185
const gdb_byte * offsets
Definition: dwarf2read.c:939
static void compute_compunit_symtab_includes(struct dwarf2_per_cu_data *per_cu)
Definition: dwarf2read.c:7944
static void dwarf_record_line(lnp_reader_state *reader, lnp_state_machine *state, int end_sequence)
Definition: dwarf2read.c:17627
bfd_size_type size
Definition: dwarf2read.c:134
struct dwo_sections sections
Definition: dwarf2read.c:826
static CORE_ADDR attr_value_as_address(struct attribute *attr)
Definition: dwarf2read.c:1997
void really_free_pendings(void *dummy)
Definition: buildsym.c:279
static char * guess_full_die_structure_name(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:19108
#define OBJSTAT(objfile, expr)
Definition: objfiles.h:160
static sect_offset read_abbrev_offset(struct dwarf2_section_info *, sect_offset)
Definition: dwarf2read.c:4460
static struct type * read_subrange_type(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:14888
static void dwarf_finish_line(struct gdbarch *gdbarch, struct subfile *subfile, CORE_ADDR address, record_line_ftype p_record_line)
Definition: dwarf2read.c:17606
static void dwarf2_debug_line_missing_end_sequence_complaint(void)
Definition: dwarf2read.c:1892
void _initialize_dwarf2_read(void)
Definition: dwarf2read.c:23395
static unsigned int read_1_byte(bfd *, const gdb_byte *)
Definition: dwarf2read.c:16425
const struct quick_symbol_functions dwarf2_gdb_index_functions
Definition: dwarf2read.c:4171
CORE_ADDR highpc
Definition: dwarf2read.c:1152
static void process_psymtab_comp_unit_reader(const struct die_reader_specs *reader, const gdb_byte *info_ptr, struct die_info *comp_unit_die, int has_children, void *data)
Definition: dwarf2read.c:5924
static void store_in_ref_table(struct die_info *, struct dwarf2_cu *)
Definition: dwarf2read.c:19832
int offset
Definition: agent.c:65
#define HAVE_CPLUS_STRUCT(type)
Definition: gdbtypes.h:1202
struct dwarf2_section_info macro
Definition: dwarf2read.c:224
static void free_dwo_files(htab_t dwo_files, struct objfile *objfile)
Definition: dwarf2read.c:11152
int accessibility
Definition: dwarf2read.c:1303
cu_offset type_offset_in_tu
Definition: dwarf2read.c:785
static void dwarf2_create_include_psymtab(const char *name, struct partial_symtab *pst, struct objfile *objfile)
Definition: dwarf2read.c:4481
int code
Definition: ser-unix.c:684
#define INIT_GNAT_SPECIFIC(type)
Definition: gdbtypes.h:1210
#define MAX_NR_V1_DWO_SECTIONS
struct symtab * allocate_symtab(struct compunit_symtab *cust, const char *filename)
Definition: symfile.c:2898
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1241
unsigned int is_debug_types
Definition: dwarf2read.c:586
static void process_full_type_unit(struct dwarf2_per_cu_data *, enum language)
Definition: dwarf2read.c:8125
#define OPF_RETURN_REALPATH
Definition: defs.h:319
struct general_symbol_info ginfo
Definition: symtab.h:708
record_line_ftype record_line
Definition: buffer.h:23
struct die_info * sibling
Definition: dwarf2read.c:1258
CORE_ADDR start_addr
Definition: buildsym.h:146
#define VEC_free(T, V)
Definition: vec.h:180
static void add_file_name(struct line_header *lh, const char *name, unsigned int dir_index, unsigned int mod_time, unsigned int length)
Definition: dwarf2read.c:17181
struct type * make_type_with_address_space(struct type *type, int space_flag)
Definition: gdbtypes.c:627
#define qsort
Definition: ada-exp.c:2747
static void locate_dwz_sections(bfd *abfd, asection *sectp, void *arg)
Definition: dwarf2read.c:2402
static void free_heap_comp_unit(void *)
Definition: dwarf2read.c:22040
static int eq_file_name_entry(const void *a, const void *b)
Definition: dwarf2read.c:2609
static char * typename_concat(struct obstack *obs, const char *prefix, const char *suffix, int physname, struct dwarf2_cu *cu)
Definition: dwarf2read.c:19376
unsigned char opcode_base
Definition: dwarf2read.c:1061
struct dwarf2_section_info loc
Definition: dwarf2read.c:860
Definition: dwarf2read.c:22472
#define SYMBOL_LANGUAGE(symbol)
Definition: symtab.h:187
static void parse_macro_definition(struct macro_source_file *file, int line, const char *body)
Definition: dwarf2read.c:20886
static int eq_dwo_file(const void *item_lhs, const void *item_rhs)
Definition: dwarf2read.c:9416
struct addrmap * addrmap_create_fixed(struct addrmap *original, struct obstack *obstack)
Definition: addrmap.c:66
static void dwarf2_locate_sections(bfd *, asection *, void *)
Definition: dwarf2read.c:2159
bfd_size_type macinfo_size
Definition: dwarf2read.c:900
CORE_ADDR gdbarch_adjust_dwarf2_line(struct gdbarch *gdbarch, CORE_ADDR addr, int rel)
Definition: gdbarch.c:3217
static const char * read_indirect_string_from_dwz(struct dwz_file *, LONGEST)
Definition: dwarf2read.c:16695
#define COMPUNIT_FILETABS(cust)
Definition: symtab.h:1095
int line
Definition: symtab.h:1570
unsigned short has_children
Definition: dwarf2read.c:1175
static void ** lookup_dwo_file_slot(const char *dwo_name, const char *comp_dir)
Definition: dwarf2read.c:9447
struct dwo_unit * dwo_unit
Definition: dwarf2read.c:690
static void dwarf2_per_objfile_free(struct objfile *objfile, void *d)
Definition: dwarf2read.c:22439
#define VEC_address(T, V)
Definition: vec.h:369
unsigned parameter_count
Definition: gdbtypes.h:1176
static struct type * read_namespace_type(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:14029
static void var_decode_location(struct attribute *attr, struct symbol *sym, struct dwarf2_cu *cu)
Definition: dwarf2read.c:18181
static int attr_to_dynamic_prop(const struct attribute *attr, struct die_info *die, struct dwarf2_cu *cu, struct dynamic_prop *prop)
Definition: dwarf2read.c:14787
static hashval_t hash_dwo_file(const void *item)
Definition: dwarf2read.c:9404
unsigned int last_file
Definition: dwarf2read.c:17493
void start_subfile(const char *name)
Definition: buildsym.c:656
struct pending ** list_in_scope
Definition: dwarf2read.c:457
#define SET_TYPE_FIELD_PROTECTED(thistype, n)
Definition: gdbtypes.h:1390
#define DW_STRING_IS_CANONICAL(attr)
Definition: dwarf2read.c:1270
struct cleanup * make_cleanup_htab_delete(htab_t htab)
Definition: utils.c:343
const gdb_byte * unit_table
Definition: dwarf2read.c:920
struct dwarf2_section_names types_dwo
Definition: dwarf2read.c:358
DEF_VEC_I(offset_type)
static int partial_die_eq(const void *item_lhs, const void *item_rhs)
Definition: dwarf2read.c:22412
static struct dwp_file * open_and_init_dwp_file(void)
Definition: dwarf2read.c:10813
static void dwarf2_build_include_psymtabs(struct dwarf2_cu *cu, struct die_info *die, struct partial_symtab *pst)
Definition: dwarf2read.c:4520
static unsigned int dwarf_read_debug
Definition: dwarf2read.c:82
#define TYPE_TAG_NAME(type)
Definition: gdbtypes.h:1228
static struct die_info * dwarf_alloc_die(struct dwarf2_cu *, int)
Definition: dwarf2read.c:20751
static void init_cutu_and_read_dies(struct dwarf2_per_cu_data *this_cu, struct abbrev_table *abbrev_table, int use_existing_cu, int keep, die_reader_func_ftype *die_reader_func, void *data)
Definition: dwarf2read.c:5412
#define TYPE_STUB(t)
Definition: gdbtypes.h:245
struct cmd_list_element * save_cmdlist
static void fill_in_loclist_baton(struct dwarf2_cu *cu, struct dwarf2_loclist_baton *baton, const struct attribute *attr)
Definition: dwarf2read.c:21771
struct symbol base
Definition: symtab.h:846
#define TYPE_TYPEDEF_FIELD(thistype, n)
Definition: gdbtypes.h:1446
struct compunit_symtab * compunit_symtab
Definition: dwarf2read.c:2557
static int unsigned_int_compar(const void *ap, const void *bp)
Definition: dwarf2read.c:11162
static struct signatured_type * add_type_unit(ULONGEST sig, void **slot)
Definition: dwarf2read.c:4785
static hashval_t hash_psymtab_cu_index(const void *item)
Definition: dwarf2read.c:22860
struct dwarf2_section_info str
Definition: dwarf2read.c:845
struct dwarf2_section_info macinfo
Definition: dwarf2read.c:861
struct partial_symbol ** list
Definition: symfile.h:59
sect_offset line_offset
Definition: dwarf2read.c:705
static htab_t allocate_dwp_loaded_cutus_table(struct objfile *objfile)
Definition: dwarf2read.c:10762
#define TYPE_FLAG_ENUM(t)
Definition: gdbtypes.h:340
offset_type * vec
Definition: dwarf2read.c:3524
const char ** real_names
Definition: dwarf2read.c:2542
enum dynamic_prop_kind kind
Definition: gdbtypes.h:431
int producer_is_gcc(const char *producer, int *major, int *minor)
Definition: utils.c:3165
struct type_unit_group * type_unit_group
Definition: dwarf2read.c:681
struct objfile * objfile
Definition: dwarf2read.c:22879
#define SYMBOL_NATURAL_NAME(symbol)
Definition: symtab.h:231
static void create_cus_from_index_list(struct objfile *objfile, const gdb_byte *cu_list, offset_type n_elements, struct dwarf2_section_info *section, int is_dwz, int base_offset)
Definition: dwarf2read.c:2767
#define FIELD_NAME(thisfld)
Definition: gdbtypes.h:1340
void(* read_symtab)(struct partial_symtab *, struct objfile *)
Definition: psympriv.h:197
struct dwarf2_section_names str_dwo
Definition: dwarf2read.c:356
static int die_eq(const void *item_lhs, const void *item_rhs)
Definition: dwarf2read.c:7685
static struct dwarf2_section_info * cu_debug_loc_section(struct dwarf2_cu *cu)
Definition: dwarf2read.c:21761
struct symbol * name
Definition: buildsym.h:142
offset_type index_offset
Definition: dwarf2read.c:22540
static int eq_strtab_entry(const void *a, const void *b)
Definition: dwarf2read.c:22493
int gdbarch_bits_big_endian(struct gdbarch *gdbarch)
Definition: gdbarch.c:1456
#define SET_FIELD_DWARF_BLOCK(thisfld, addr)
Definition: gdbtypes.h:1361
static struct dwarf2_section_info * get_abbrev_section_for_cu(struct dwarf2_per_cu_data *this_cu)
Definition: dwarf2read.c:4346
static const gdb_byte * read_partial_die(const struct die_reader_specs *, struct partial_die_info *, struct abbrev_info *, unsigned int, const gdb_byte *)
Definition: dwarf2read.c:15753
unsigned long long ULONGEST
Definition: common-types.h:53
unsigned char * standard_opcode_lengths
Definition: dwarf2read.c:1067
struct dwarf2_section_info loc
Definition: dwarf2read.c:874
htab_t dependencies
Definition: dwarf2read.c:494
size_t size
Definition: dwarf2read.c:1280
unsigned int num_sections
Definition: dwarf2read.c:973
#define TYPE_TYPEDEF_FIELD_COUNT(thistype)
Definition: gdbtypes.h:1452
static void load_partial_comp_unit_reader(const struct die_reader_specs *reader, const gdb_byte *info_ptr, struct die_info *comp_unit_die, int has_children, void *data)
Definition: dwarf2read.c:6512
unsigned int length
Definition: dwarf2read.c:383
struct cleanup * increment_reading_symtab(void)
Definition: symfile.c:211
unsigned char anonymous
Definition: psympriv.h:183
struct addrmap * psymtabs_addrmap
Definition: objfiles.h:304
unsigned int has_template_arguments
Definition: dwarf2read.c:1117
#define SYMBOL_SEARCH_NAME(symbol)
Definition: symtab.h:269
language
Definition: defs.h:167
void release_value(struct value *val)
Definition: value.c:1603
unsigned char maximum_ops_per_instruction
Definition: dwarf2read.c:1057
struct dwarf2_section_info cu_index
Definition: dwarf2read.c:846
void buildsym_init(void)
Definition: buildsym.c:1741
static void dwarf2_clear_marks(struct dwarf2_per_cu_data *)
Definition: dwarf2read.c:22388
static void print_tu_stats(void)
Definition: dwarf2read.c:6270
static void fill_in_sig_entry_from_dwo_entry(struct objfile *objfile, struct signatured_type *sig_entry, struct dwo_unit *dwo_entry)
Definition: dwarf2read.c:4833
static struct compunit_symtab * recursively_find_pc_sect_compunit_symtab(struct compunit_symtab *cust, CORE_ADDR pc)
Definition: dwarf2read.c:4044
static void recursively_compute_inclusions(VEC(compunit_symtab_ptr)**result, htab_t all_children, htab_t all_type_symtabs, struct dwarf2_per_cu_data *per_cu, struct compunit_symtab *immediate_parent)
Definition: dwarf2read.c:7888
static void write_hash_table(struct mapped_symtab *symtab, struct obstack *output, struct obstack *cpool)
Definition: dwarf2read.c:22805
const gdb_byte * data
Definition: dwarf2loc.h:168
#define VEC_cleanup(T)
Definition: vec.h:187
static const char * partial_die_parent_scope(struct partial_die_info *pdi, struct dwarf2_cu *cu)
Definition: dwarf2read.c:6761
static void dwarf2_symbol_mark_computed(const struct attribute *attr, struct symbol *sym, struct dwarf2_cu *cu, int is_block)
Definition: dwarf2read.c:21790
static void set_descriptive_type(struct type *, struct die_info *, struct dwarf2_cu *)
Definition: dwarf2read.c:18877
static const gdb_byte * read_comp_unit_head(struct comp_unit_head *cu_header, const gdb_byte *info_ptr, bfd *abfd)
Definition: dwarf2read.c:4316
static const gdb_byte * skip_unknown_opcode(unsigned int opcode, const gdb_byte **opcode_definitions, const gdb_byte *mac_ptr, const gdb_byte *mac_end, bfd *abfd, unsigned int offset_size, struct dwarf2_section_info *section)
Definition: dwarf2read.c:21111
static void free_cu_line_header(void *arg)
Definition: dwarf2read.c:9009
#define obstack_grow_str0(OBSTACK, STRING)
Definition: gdb_obstack.h:48
struct macro_source_file * macro_set_main(struct macro_table *t, const char *filename)
Definition: macrotab.c:418
#define TYPE_NOSIGN(t)
Definition: gdbtypes.h:239
static void add_partial_subprogram(struct partial_die_info *pdi, CORE_ADDR *lowpc, CORE_ADDR *highpc, int need_pc, struct dwarf2_cu *cu)
Definition: dwarf2read.c:7109
unsigned int spec_is_dwz
Definition: dwarf2read.c:1126
#define SYMBOL_INLINED(symbol)
Definition: symtab.h:796
void c_printchar(int c, struct type *type, struct ui_file *stream)
Definition: c-lang.c:156
static struct type * build_error_marker_type(struct dwarf2_cu *cu, struct die_info *die)
Definition: dwarf2read.c:18908
static struct attribute * dwarf2_attr_no_follow(struct die_info *, unsigned int)
Definition: dwarf2read.c:17061
static void dwarf2_add_typedef(struct field_info *fip, struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:12618
#define TYPE_ALLOC(t, size)
Definition: gdbtypes.h:1631
static void dwarf2_attach_fields_to_type(struct field_info *, struct type *, struct dwarf2_cu *)
Definition: dwarf2read.c:12650
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:799
static void add_include_dir(struct line_header *lh, const char *include_dir)
Definition: dwarf2read.c:17154
static struct dwarf2_section_info * get_containing_section(const struct dwarf2_section_info *section)
Definition: dwarf2read.c:2059
struct call_site * tail_call_next
Definition: gdbtypes.h:1167
Definition: symtab.h:703
static enum dwarf_array_dim_ordering read_array_order(struct die_info *, struct dwarf2_cu *)
Definition: dwarf2read.c:13799
struct type * lookup_reference_type(struct type *type)
Definition: gdbtypes.c:441
static int free_dwo_file_from_slot(void **slot, void *info)
Definition: dwarf2read.c:11139
static int offset_in_cu_p(const struct comp_unit_head *cu_header, sect_offset offset)
Definition: dwarf2read.c:4272
struct cmd_list_element * showdebuglist
Definition: cli-cmds.c:175
static const char * determine_prefix(struct die_info *die, struct dwarf2_cu *)
Definition: dwarf2read.c:19223
#define TYPE_CPLUS_REALLY_JAVA(thistype)
Definition: gdbtypes.h:1333
bfd_size_type macro_size
Definition: dwarf2read.c:903
static struct cmd_list_element * show_dwarf_cmdlist
Definition: dwarf2read.c:22421
static int eq_dwo_unit(const void *item_lhs, const void *item_rhs)
Definition: dwarf2read.c:9473
struct type * dwarf2_get_die_type(cu_offset die_offset, struct dwarf2_per_cu_data *per_cu)
Definition: dwarf2read.c:20208
static struct die_info * dwarf2_extension(struct die_info *die, struct dwarf2_cu **)
Definition: dwarf2read.c:19586
unsigned int is_dwz
Definition: dwarf2read.c:1123
struct typedef_field field
Definition: dwarf2read.c:1323
static int check_physname
Definition: dwarf2read.c:91
struct context_stack * push_context(int desc, CORE_ADDR valu)
Definition: buildsym.c:1623
static int dwarf2_read_index(struct objfile *objfile)
Definition: dwarf2read.c:3158
unsigned short flags
Definition: objfiles.h:282
htab_t tus
Definition: dwarf2read.c:837
const gdb_byte * gdb_bfd_map_section(asection *sectp, bfd_size_type *size)
Definition: gdb_bfd.c:547
#define VOFFSET_STATIC
Definition: gdbtypes.h:895
#define TYPE_FN_FIELDLISTS(thistype)
Definition: gdbtypes.h:1409
static void dwarf2_add_field(struct field_info *, struct die_info *, struct dwarf2_cu *)
Definition: dwarf2read.c:12431
struct type * lookup_methodptr_type(struct type *to_type)
Definition: gdbtypes.c:792
void * addrmap_find(struct addrmap *map, CORE_ADDR addr)
Definition: addrmap.c:59
bfd * build_id_to_debug_bfd(size_t build_id_len, const bfd_byte *build_id)
Definition: build-id.c:71
unsigned int file_names_size
Definition: dwarf2read.c:1079
struct quick_file_names * file_names
Definition: dwarf2read.c:2553
#define TYPE_FN_FIELDLIST_NAME(thistype, n)
Definition: gdbtypes.h:1412
#define OBSTACK_ZALLOC(OBSTACK, TYPE)
Definition: gdb_obstack.h:27
CORE_ADDR dwarf2_per_cu_text_offset(struct dwarf2_per_cu_data *per_cu)
Definition: dwarf2read.c:21938
const char * scope
Definition: dwarf2read.c:1138
struct fn_field fnfield
Definition: dwarf2read.c:1311
const char * type_name_no_tag(const struct type *type)
Definition: gdbtypes.c:1361
struct abbrev_info * next
Definition: dwarf2read.c:1178
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
#define MAX_SEP_LEN
Definition: dwarf2read.c:19373
#define MAX_NR_V2_DWO_SECTIONS
Definition: dwarf2read.c:931
struct typedef_field_list * typedef_field_list
Definition: dwarf2read.c:1358
struct type * make_atomic_type(struct type *type)
Definition: gdbtypes.c:720
struct subfile * last_subfile
Definition: dwarf2read.c:17495
#define DW_UNSND(attr)
Definition: dwarf2read.c:1271
const char * str
Definition: dwarf2read.c:1221
#define SYMBOL_SECTION(symbol)
Definition: symtab.h:188
static void dwarf2_add_dependence(struct dwarf2_cu *, struct dwarf2_per_cu_data *)
Definition: dwarf2read.c:22330
static void show_dwarf_cmd(char *args, int from_tty)
Definition: dwarf2read.c:22431
#define HOST_CHAR_BIT
Definition: host-defs.h:40
unsigned int is_artificial
Definition: gdbtypes.h:875
unsigned int num_include_dirs
Definition: dwarf2read.c:1073
#define TYPE_ZALLOC(t, size)
Definition: gdbtypes.h:1636
static struct partial_symtab * create_partial_symtab(struct dwarf2_per_cu_data *per_cu, const char *name)
Definition: dwarf2read.c:5887
void * arg
Definition: cleanups.c:43
struct dwarf2_section_info * die_section
Definition: dwarf2read.c:1011
static void show_dwarf_max_cache_age(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: dwarf2read.c:1381
static LONGEST dwarf2_get_attr_constant_value(const struct attribute *, int)
Definition: dwarf2read.c:19864
struct compunit_symtab * compunit_symtab
Definition: psympriv.h:192
const char * name
Definition: dwarf2read.c:418
static void load_cu(struct dwarf2_per_cu_data *per_cu)
Definition: dwarf2read.c:2651
struct nextfield * baseclasses
Definition: dwarf2read.c:1333
struct dwo_file * dwo_file
Definition: dwarf2read.c:1007
DEF_VEC_P(symbolp)
struct nextfnfield * fnfields
Definition: dwarf2read.c:1346
#define TYPE_FN_FIELDLIST_LENGTH(thistype, n)
Definition: gdbtypes.h:1413
static int is_type_tag_for_partial(int tag)
Definition: dwarf2read.c:15445
struct section_offsets * section_offsets
Definition: objfiles.h:362
#define FIELD_BITPOS(thisfld)
Definition: gdbtypes.h:1343
static struct dwo_file * open_and_init_dwo_file(struct dwarf2_per_cu_data *per_cu, const char *dwo_name, const char *comp_dir)
Definition: dwarf2read.c:10605
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:192
#define SYMBOL_VALUE_BYTES(symbol)
Definition: symtab.h:183
struct type * type
Definition: gdbtypes.h:856
struct line_header * line_header
Definition: dwarf2read.c:497
const struct dwp_hash_table * cus
Definition: dwarf2read.c:962
unsigned char in_process
Definition: dwarf2read.c:1245
const struct symbol_computed_ops dwarf2_loclist_funcs
Definition: dwarf2loc.c:4474
#define DW_STRING(attr)
Definition: dwarf2read.c:1269
static void dw2_dump(struct objfile *objfile)
Definition: dwarf2read.c:3723
static struct dwo_unit * create_dwo_cu(struct dwo_file *dwo_file)
Definition: dwarf2read.c:9553
#define QUIT
Definition: defs.h:160
const char * compressed
Definition: symfile.h:599
static void free_one_cached_comp_unit(struct dwarf2_per_cu_data *)
Definition: dwarf2read.c:22133
static void add_to_method_list(struct type *type, int fnfield_index, int index, const char *name, struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:7747
static struct dwo_unit * lookup_dwo_comp_unit(struct dwarf2_per_cu_data *, const char *, const char *, ULONGEST)
Definition: dwarf2read.c:11043
static hashval_t hash_stmt_list_entry(const struct stmt_list_hash *stmt_list_hash)
Definition: dwarf2read.c:2571
struct cleanup * make_cleanup_obstack_free(struct obstack *obstack)
Definition: utils.c:225
sect_offset type_offset_in_section
Definition: dwarf2read.c:677
struct file_entry * file_names
Definition: dwarf2read.c:1080
static void dwarf2_start_subfile(const char *, const char *)
Definition: dwarf2read.c:18136
offset_type n_elements
Definition: dwarf2read.c:22549
struct type * type
Definition: dwarf2read.c:686
unsigned char default_is_stmt
Definition: dwarf2read.c:1058
struct gdbarch * gdbarch
Definition: dwarf2read.c:17513
static struct die_info * read_die_and_siblings(const struct die_reader_specs *, const gdb_byte *info_ptr, const gdb_byte **new_info_ptr, struct die_info *parent)
Definition: dwarf2read.c:15139
static void init_tu_and_read_dwo_dies(struct dwarf2_per_cu_data *this_cu, int use_existing_cu, int keep, die_reader_func_ftype *die_reader_func, void *data)
Definition: dwarf2read.c:5311
struct compunit_symtab * user
Definition: symtab.h:1091
unsigned int initial_length_size
Definition: dwarf2read.c:393
#define TYPE_DECLARED_CLASS(t)
Definition: gdbtypes.h:334
sect_offset offset
Definition: dwarf2read.c:570
static void dwarf2_invalid_attrib_class_complaint(const char *arg1, const char *arg2)
Definition: dwarf2read.c:1934
#define TYPE_DESCRIPTIVE_TYPE(thistype)
Definition: gdbtypes.h:1322
static int process_skeletonless_type_unit(void **slot, void *info)
Definition: dwarf2read.c:6338
unsigned int is_protected
Definition: gdbtypes.h:868
#define TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL
Definition: gdbtypes.h:401
struct type * type
Definition: dwarf2loc.h:214
static const char * dwarf2_compute_name(const char *name, struct die_info *die, struct dwarf2_cu *cu, int physname)
Definition: dwarf2read.c:8435
static int get_section_flags(const struct dwarf2_section_info *section)
Definition: dwarf2read.c:2130
PTR xcalloc(size_t number, size_t size)
Definition: common-utils.c:71
unsigned int fixup_called
Definition: dwarf2read.c:1120
struct symtab * symbol_symtab(const struct symbol *symbol)
Definition: symtab.c:6250
struct dwarf2_section_info str_offsets
Definition: dwarf2read.c:759
const char * name
Definition: dwarf2read.c:950
void record_producer(const char *producer)
Definition: buildsym.c:1677
struct obstack * addr_obstack
Definition: dwarf2read.c:22880
struct cmd_list_element * maintenance_show_cmdlist
Definition: maint.c:647
#define TYPE_CONST(t)
Definition: gdbtypes.h:345
struct call_site_target target
Definition: gdbtypes.h:1172
static void load_full_comp_unit(struct dwarf2_per_cu_data *, enum language)
Definition: dwarf2read.c:7735
static void inherit_abstract_dies(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:11176
int nr_symtabs
Definition: dwarf2read.c:208
static int dw2_has_symbols(struct objfile *objfile)
Definition: dwarf2read.c:4166
struct obstack abbrev_obstack
Definition: dwarf2read.c:1199
static hashval_t hash_strtab_entry(const void *e)
Definition: dwarf2read.c:22484
sect_offset abbrev_offset
Definition: dwarf2read.c:387
const char * dwo_name
Definition: dwarf2read.c:814
struct dwo_unit * dwo_unit
Definition: dwarf2read.c:702
static int read_index_from_section(struct objfile *objfile, const char *filename, int deprecated_ok, struct dwarf2_section_info *section, struct mapped_index *map, const gdb_byte **cu_list, offset_type *cu_list_elements, const gdb_byte **types_list, offset_type *types_list_elements)
Definition: dwarf2read.c:3042
static struct abbrev_table * abbrev_table_read_table(struct dwarf2_section_info *, sect_offset)
Definition: dwarf2read.c:15301
case_sensitivity
Definition: language.h:88
static char * copy_string(const char *buf, int len)
Definition: dwarf2read.c:20857
struct dwarf2_section_names str
Definition: symfile.h:616
static struct dwp_hash_table * create_dwp_hash_table(struct dwp_file *dwp_file, int is_debug_types)
Definition: dwarf2read.c:9761
static struct dwarf2_per_cu_data * dw2_get_cutu(int index)
Definition: dwarf2read.c:2739
int dwarf_block_to_sp_offset(struct gdbarch *gdbarch, const gdb_byte *buf, const gdb_byte *buf_end, CORE_ADDR *sp_offset_return)
Definition: dwarf2expr.c:593
static struct type * read_array_type(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:13674
static void quirk_gcc_member_function_pointer(struct type *type, struct objfile *objfile)
Definition: dwarf2read.c:13054
struct dwarf2_section_info line
Definition: dwarf2read.c:985
void make_vector_type(struct type *array_type)
Definition: gdbtypes.c:1206
unsigned char op_index
Definition: dwarf2read.c:17482
void error(const char *fmt,...)
Definition: errors.c:38
struct dwarf2_cu * cu
Definition: dwarf2read.c:614
static int prototyped_function_p(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:14470
size_t size
Definition: go32-nat.c:242
static hashval_t line_header_hash(const struct line_header *ofs)
Definition: dwarf2read.c:1944
static LONGEST read_initial_length(bfd *, const gdb_byte *, unsigned int *)
Definition: dwarf2read.c:16556
void macro_undef(struct macro_source_file *source, int line, const char *name)
Definition: macrotab.c:828
int nbaseclasses
Definition: dwarf2read.c:1339
static int read_namespace_alias(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:8806
static hashval_t per_cu_offset_and_type_hash(const void *item)
Definition: dwarf2read.c:22205
static void dw2_print_stats(struct objfile *objfile)
Definition: dwarf2read.c:3699
static struct dwo_unit * lookup_dwo_unit_in_dwp(struct dwp_file *dwp_file, const char *comp_dir, ULONGEST signature, int is_debug_types)
Definition: dwarf2read.c:10376
unsigned short num_attrs
Definition: dwarf2read.c:1176
CORE_ADDR previous_cu_start
Definition: dwarf2read.c:22890
static const gdb_byte * locate_pdi_sibling(const struct die_reader_specs *reader, struct partial_die_info *orig_pdi, const gdb_byte *info_ptr)
Definition: dwarf2read.c:7388
union call_site_parameter_u u
Definition: gdbtypes.h:1138
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:368
sect_offset offset
Definition: dwarf2read.c:781
struct dwarf2_section_info abbrev
Definition: dwarf2read.c:220
unsigned int is_declaration
Definition: dwarf2read.c:1100
void( symbol_filename_ftype)(const char *filename, const char *fullname, void *data)
Definition: symfile.h:127
sect_offset abbrev_offset
Definition: dwarf2read.c:6143
const char * comp_dir
Definition: dwarf2read.c:1020
CORE_ADDR texthigh
Definition: psympriv.h:106
unsigned short version
Definition: dwarf2read.c:1054
const gdb_byte * data
Definition: dwarf2read.c:1283
static struct die_info * read_die_and_children(const struct die_reader_specs *reader, const gdb_byte *info_ptr, const gdb_byte **new_info_ptr, struct die_info *parent)
Definition: dwarf2read.c:15067
static void process_skeletonless_type_units(struct objfile *objfile)
Definition: dwarf2read.c:6394
long long LONGEST
Definition: common-types.h:52
struct obstack * types_list
Definition: dwarf2read.c:23071
static void read_namespace(struct die_info *die, struct dwarf2_cu *)
Definition: dwarf2read.c:14071
static struct type * read_tag_string_type(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:14431
static const gdb_byte * dwarf_parse_macro_header(const gdb_byte **opcode_definitions, bfd *abfd, const gdb_byte *mac_ptr, unsigned int *offset_size, int section_is_gnu)
Definition: dwarf2read.c:21154
static void init_one_comp_unit(struct dwarf2_cu *cu, struct dwarf2_per_cu_data *per_cu)
Definition: dwarf2read.c:22001
static const char * dwarf_type_encoding_name(unsigned int)
Definition: dwarf2read.c:19658
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:541
#define FIELD_TYPE(thisfld)
Definition: gdbtypes.h:1339
const char * name
Definition: dwarf2read.c:22538
static void create_cus_from_index(struct objfile *objfile, const gdb_byte *cu_list, offset_type cu_list_elements, const gdb_byte *dwz_list, offset_type dwz_elements)
Definition: dwarf2read.c:2802
#define SYMBOL_LOCATION_BATON(symbol)
Definition: symtab.h:804
static int create_all_type_units(struct objfile *)
Definition: dwarf2read.c:4752
struct type * lookup_function_type(struct type *type)
Definition: gdbtypes.c:482
static htab_t allocate_dwo_file_hash_table(void)
Definition: dwarf2read.c:9431
#define SYMBOL_IS_ARGUMENT(symbol)
Definition: symtab.h:795
struct partial_symtab * psymtabs
Definition: objfiles.h:297
static hashval_t mapped_index_string_hash(int index_version, const void *p)
Definition: dwarf2read.c:2946
static void read_signatured_type(struct signatured_type *)
Definition: dwarf2read.c:20463
static void process_imported_unit_die(struct die_info *die, struct dwarf2_cu *cu)
Definition: dwarf2read.c:8200
static void create_signatured_type_table_from_index(struct objfile *objfile, struct dwarf2_section_info *section, const gdb_byte *bytes, offset_type elements)
Definition: dwarf2read.c:2828
#define SET_FIELD_PHYSNAME(thisfld, name)
Definition: gdbtypes.h:1355
struct block * finish_block(struct symbol *symbol, struct pending **listhead, struct pending_block *old_blocks, CORE_ADDR start, CORE_ADDR end)
Definition: buildsym.c:515
static struct abbrev_info * abbrev_table_lookup_abbrev(const struct abbrev_table *, unsigned int)
Definition: dwarf2read.c:15280
struct dwp_hash_table::@60::@62 v2
unsigned int include_dirs_size
Definition: dwarf2read.c:1073
const gdb_byte * sizes
Definition: dwarf2read.c:940
struct symtab * symtab
Definition: buildsym.h:70
static offset_type add_string(htab_t table, struct obstack *cpool, const char *str)
Definition: dwarf2read.c:22513
static void process_cu_includes(void)
Definition: dwarf2read.c:7998
const ULONGEST const LONGEST len
Definition: target.h:309
static void add_partial_namespace(struct partial_die_info *pdi, CORE_ADDR *lowpc, CORE_ADDR *highpc, int set_addrmap, struct dwarf2_cu *cu)
Definition: dwarf2read.c:7066
unsigned int length
Definition: dwarf2read.c:571