[AArch64] Fix off by one error in instruction relaxation mask.
[deliverable/binutils-gdb.git] / gdb / dwarf2read.c
1 /* DWARF 2 debugging format support for GDB.
2
3 Copyright (C) 1994-2014 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 "exceptions.h"
59 #include <sys/stat.h>
60 #include "completer.h"
61 #include "vec.h"
62 #include "c-lang.h"
63 #include "go-lang.h"
64 #include "valprint.h"
65 #include "gdbcore.h" /* for gnutarget */
66 #include "gdb/gdb-index.h"
67 #include <ctype.h>
68 #include "gdb_bfd.h"
69 #include "f-lang.h"
70 #include "source.h"
71 #include "filestuff.h"
72 #include "build-id.h"
73
74 #include <fcntl.h>
75 #include <string.h>
76 #include "gdb_assert.h"
77 #include <sys/types.h>
78
79 typedef struct symbol *symbolp;
80 DEF_VEC_P (symbolp);
81
82 /* When == 1, print basic high level tracing messages.
83 When > 1, be more verbose.
84 This is in contrast to the low level DIE reading of dwarf2_die_debug. */
85 static unsigned int dwarf2_read_debug = 0;
86
87 /* When non-zero, dump DIEs after they are read in. */
88 static unsigned int dwarf2_die_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. */
94 static int use_deprecated_index_sections = 0;
95
96 static const struct objfile_data *dwarf2_objfile_data_key;
97
98 /* The "aclass" indices for various kinds of computed DWARF symbols. */
99
100 static int dwarf2_locexpr_index;
101 static int dwarf2_loclist_index;
102 static int dwarf2_locexpr_block_index;
103 static int dwarf2_loclist_block_index;
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
121 struct dwarf2_section_info
122 {
123 union
124 {
125 /* If this is a real section, the bfd section. */
126 asection *asection;
127 /* If this is a virtual section, pointer to the containing ("real")
128 section. */
129 struct dwarf2_section_info *containing_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. */
142 char is_virtual;
143 };
144
145 typedef struct dwarf2_section_info dwarf2_section_info_def;
146 DEF_VEC_O (dwarf2_section_info_def);
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. */
178 struct mapped_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. */
187 const gdb_byte *address_table;
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
202 typedef struct dwarf2_per_cu_data *dwarf2_per_cu_ptr;
203 DEF_VEC_P (dwarf2_per_cu_ptr);
204
205 /* Collection of data recorded per objfile.
206 This hangs off of dwarf2_objfile_data_key. */
207
208 struct dwarf2_per_objfile
209 {
210 struct dwarf2_section_info info;
211 struct dwarf2_section_info abbrev;
212 struct dwarf2_section_info line;
213 struct dwarf2_section_info loc;
214 struct dwarf2_section_info macinfo;
215 struct dwarf2_section_info macro;
216 struct dwarf2_section_info str;
217 struct dwarf2_section_info ranges;
218 struct dwarf2_section_info addr;
219 struct dwarf2_section_info frame;
220 struct dwarf2_section_info eh_frame;
221 struct dwarf2_section_info gdb_index;
222
223 VEC (dwarf2_section_info_def) *types;
224
225 /* Back link. */
226 struct objfile *objfile;
227
228 /* Table of all the compilation units. This is used to locate
229 the target compilation unit of a particular reference. */
230 struct dwarf2_per_cu_data **all_comp_units;
231
232 /* The number of compilation units in ALL_COMP_UNITS. */
233 int n_comp_units;
234
235 /* The number of .debug_types-related CUs. */
236 int n_type_units;
237
238 /* The .debug_types-related CUs (TUs).
239 This is stored in malloc space because we may realloc it. */
240 struct signatured_type **all_type_units;
241
242 /* The number of entries in all_type_unit_groups. */
243 int n_type_unit_groups;
244
245 /* Table of type unit groups.
246 This exists to make it easy to iterate over all CUs and TU groups. */
247 struct type_unit_group **all_type_unit_groups;
248
249 /* Table of struct type_unit_group objects.
250 The hash key is the DW_AT_stmt_list value. */
251 htab_t type_unit_groups;
252
253 /* A table mapping .debug_types signatures to its signatured_type entry.
254 This is NULL if the .debug_types section hasn't been read in yet. */
255 htab_t signatured_types;
256
257 /* Type unit statistics, to see how well the scaling improvements
258 are doing. */
259 struct tu_stats
260 {
261 int nr_uniq_abbrev_tables;
262 int nr_symtabs;
263 int nr_symtab_sharers;
264 int nr_stmt_less_type_units;
265 } 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
318 static struct dwarf2_per_objfile *dwarf2_per_objfile;
319
320 /* Default names of the debugging sections. */
321
322 /* Note that if the debugging section has been compressed, it might
323 have a name like .zdebug_info. */
324
325 static const struct dwarf2_debug_sections dwarf2_elf_names =
326 {
327 { ".debug_info", ".zdebug_info" },
328 { ".debug_abbrev", ".zdebug_abbrev" },
329 { ".debug_line", ".zdebug_line" },
330 { ".debug_loc", ".zdebug_loc" },
331 { ".debug_macinfo", ".zdebug_macinfo" },
332 { ".debug_macro", ".zdebug_macro" },
333 { ".debug_str", ".zdebug_str" },
334 { ".debug_ranges", ".zdebug_ranges" },
335 { ".debug_types", ".zdebug_types" },
336 { ".debug_addr", ".zdebug_addr" },
337 { ".debug_frame", ".zdebug_frame" },
338 { ".eh_frame", NULL },
339 { ".gdb_index", ".zgdb_index" },
340 23
341 };
342
343 /* List of DWO/DWP sections. */
344
345 static const struct dwop_section_names
346 {
347 struct dwarf2_section_names abbrev_dwo;
348 struct dwarf2_section_names info_dwo;
349 struct dwarf2_section_names line_dwo;
350 struct dwarf2_section_names loc_dwo;
351 struct dwarf2_section_names macinfo_dwo;
352 struct dwarf2_section_names macro_dwo;
353 struct dwarf2_section_names str_dwo;
354 struct dwarf2_section_names str_offsets_dwo;
355 struct dwarf2_section_names types_dwo;
356 struct dwarf2_section_names cu_index;
357 struct dwarf2_section_names tu_index;
358 }
359 dwop_section_names =
360 {
361 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
362 { ".debug_info.dwo", ".zdebug_info.dwo" },
363 { ".debug_line.dwo", ".zdebug_line.dwo" },
364 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
365 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
366 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
367 { ".debug_str.dwo", ".zdebug_str.dwo" },
368 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
369 { ".debug_types.dwo", ".zdebug_types.dwo" },
370 { ".debug_cu_index", ".zdebug_cu_index" },
371 { ".debug_tu_index", ".zdebug_tu_index" },
372 };
373
374 /* local data types */
375
376 /* The data in a compilation unit header, after target2host
377 translation, looks like this. */
378 struct comp_unit_head
379 {
380 unsigned int length;
381 short version;
382 unsigned char addr_size;
383 unsigned char signed_addr_p;
384 sect_offset abbrev_offset;
385
386 /* Size of file offsets; either 4 or 8. */
387 unsigned int offset_size;
388
389 /* Size of the length field; either 4 or 12. */
390 unsigned int initial_length_size;
391
392 /* Offset to the first byte of this compilation unit header in the
393 .debug_info section, for resolving relative reference dies. */
394 sect_offset offset;
395
396 /* Offset to first die in this cu from the start of the cu.
397 This will be the first byte following the compilation unit header. */
398 cu_offset first_die_offset;
399 };
400
401 /* Type used for delaying computation of method physnames.
402 See comments for compute_delayed_physnames. */
403 struct delayed_method_info
404 {
405 /* The type to which the method is attached, i.e., its parent class. */
406 struct type *type;
407
408 /* The index of the method in the type's function fieldlists. */
409 int fnfield_index;
410
411 /* The index of the method in the fieldlist. */
412 int index;
413
414 /* The name of the DIE. */
415 const char *name;
416
417 /* The DIE associated with this method. */
418 struct die_info *die;
419 };
420
421 typedef struct delayed_method_info delayed_method_info;
422 DEF_VEC_O (delayed_method_info);
423
424 /* Internal state when decoding a particular compilation unit. */
425 struct dwarf2_cu
426 {
427 /* The objfile containing this compilation unit. */
428 struct objfile *objfile;
429
430 /* The header of the compilation unit. */
431 struct comp_unit_head header;
432
433 /* Base address of this compilation unit. */
434 CORE_ADDR base_address;
435
436 /* Non-zero if base_address has been set. */
437 int base_known;
438
439 /* The language we are debugging. */
440 enum language language;
441 const struct language_defn *language_defn;
442
443 const char *producer;
444
445 /* The generic symbol table building routines have separate lists for
446 file scope symbols and all all other scopes (local scopes). So
447 we need to select the right one to pass to add_symbol_to_list().
448 We do it by keeping a pointer to the correct list in list_in_scope.
449
450 FIXME: The original dwarf code just treated the file scope as the
451 first local scope, and all other local scopes as nested local
452 scopes, and worked fine. Check to see if we really need to
453 distinguish these in buildsym.c. */
454 struct pending **list_in_scope;
455
456 /* The abbrev table for this CU.
457 Normally this points to the abbrev table in the objfile.
458 But if DWO_UNIT is non-NULL this is the abbrev table in the DWO file. */
459 struct abbrev_table *abbrev_table;
460
461 /* Hash table holding all the loaded partial DIEs
462 with partial_die->offset.SECT_OFF as hash. */
463 htab_t partial_dies;
464
465 /* Storage for things with the same lifetime as this read-in compilation
466 unit, including partial DIEs. */
467 struct obstack comp_unit_obstack;
468
469 /* When multiple dwarf2_cu structures are living in memory, this field
470 chains them all together, so that they can be released efficiently.
471 We will probably also want a generation counter so that most-recently-used
472 compilation units are cached... */
473 struct dwarf2_per_cu_data *read_in_chain;
474
475 /* Backlink to our per_cu entry. */
476 struct dwarf2_per_cu_data *per_cu;
477
478 /* How many compilation units ago was this CU last referenced? */
479 int last_used;
480
481 /* A hash table of DIE cu_offset for following references with
482 die_info->offset.sect_off as hash. */
483 htab_t die_hash;
484
485 /* Full DIEs if read in. */
486 struct die_info *dies;
487
488 /* A set of pointers to dwarf2_per_cu_data objects for compilation
489 units referenced by this one. Only set during full symbol processing;
490 partial symbol tables do not have dependencies. */
491 htab_t dependencies;
492
493 /* Header data from the line table, during full symbol processing. */
494 struct line_header *line_header;
495
496 /* A list of methods which need to have physnames computed
497 after all type information has been read. */
498 VEC (delayed_method_info) *method_list;
499
500 /* To be copied to symtab->call_site_htab. */
501 htab_t call_site_htab;
502
503 /* Non-NULL if this CU came from a DWO file.
504 There is an invariant here that is important to remember:
505 Except for attributes copied from the top level DIE in the "main"
506 (or "stub") file in preparation for reading the DWO file
507 (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
508 Either there isn't a DWO file (in which case this is NULL and the point
509 is moot), or there is and either we're not going to read it (in which
510 case this is NULL) or there is and we are reading it (in which case this
511 is non-NULL). */
512 struct dwo_unit *dwo_unit;
513
514 /* The DW_AT_addr_base attribute if present, zero otherwise
515 (zero is a valid value though).
516 Note this value comes from the Fission stub CU/TU's DIE. */
517 ULONGEST addr_base;
518
519 /* The DW_AT_ranges_base attribute if present, zero otherwise
520 (zero is a valid value though).
521 Note this value comes from the Fission stub CU/TU's DIE.
522 Also note that the value is zero in the non-DWO case so this value can
523 be used without needing to know whether DWO files are in use or not.
524 N.B. This does not apply to DW_AT_ranges appearing in
525 DW_TAG_compile_unit dies. This is a bit of a wart, consider if ever
526 DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
527 DW_AT_ranges_base *would* have to be applied, and we'd have to care
528 whether the DW_AT_ranges attribute came from the skeleton or DWO. */
529 ULONGEST ranges_base;
530
531 /* Mark used when releasing cached dies. */
532 unsigned int mark : 1;
533
534 /* This CU references .debug_loc. See the symtab->locations_valid field.
535 This test is imperfect as there may exist optimized debug code not using
536 any location list and still facing inlining issues if handled as
537 unoptimized code. For a future better test see GCC PR other/32998. */
538 unsigned int has_loclist : 1;
539
540 /* These cache the results for producer_is_* fields. CHECKED_PRODUCER is set
541 if all the producer_is_* fields are valid. This information is cached
542 because profiling CU expansion showed excessive time spent in
543 producer_is_gxx_lt_4_6. */
544 unsigned int checked_producer : 1;
545 unsigned int producer_is_gxx_lt_4_6 : 1;
546 unsigned int producer_is_gcc_lt_4_3 : 1;
547 unsigned int producer_is_icc : 1;
548
549 /* When set, the file that we're processing is known to have
550 debugging info for C++ namespaces. GCC 3.3.x did not produce
551 this information, but later versions do. */
552
553 unsigned int processing_has_namespace_info : 1;
554 };
555
556 /* Persistent data held for a compilation unit, even when not
557 processing it. We put a pointer to this structure in the
558 read_symtab_private field of the psymtab. */
559
560 struct dwarf2_per_cu_data
561 {
562 /* The start offset and length of this compilation unit.
563 NOTE: Unlike comp_unit_head.length, this length includes
564 initial_length_size.
565 If the DIE refers to a DWO file, this is always of the original die,
566 not the DWO file. */
567 sect_offset offset;
568 unsigned int length;
569
570 /* Flag indicating this compilation unit will be read in before
571 any of the current compilation units are processed. */
572 unsigned int queued : 1;
573
574 /* This flag will be set when reading partial DIEs if we need to load
575 absolutely all DIEs for this compilation unit, instead of just the ones
576 we think are interesting. It gets set if we look for a DIE in the
577 hash table and don't find it. */
578 unsigned int load_all_dies : 1;
579
580 /* Non-zero if this CU is from .debug_types.
581 Struct dwarf2_per_cu_data is contained in struct signatured_type iff
582 this is non-zero. */
583 unsigned int is_debug_types : 1;
584
585 /* Non-zero if this CU is from the .dwz file. */
586 unsigned int is_dwz : 1;
587
588 /* Non-zero if reading a TU directly from a DWO file, bypassing the stub.
589 This flag is only valid if is_debug_types is true.
590 We can't read a CU directly from a DWO file: There are required
591 attributes in the stub. */
592 unsigned int reading_dwo_directly : 1;
593
594 /* Non-zero if the TU has been read.
595 This is used to assist the "Stay in DWO Optimization" for Fission:
596 When reading a DWO, it's faster to read TUs from the DWO instead of
597 fetching them from random other DWOs (due to comdat folding).
598 If the TU has already been read, the optimization is unnecessary
599 (and unwise - we don't want to change where gdb thinks the TU lives
600 "midflight").
601 This flag is only valid if is_debug_types is true. */
602 unsigned int tu_read : 1;
603
604 /* The section this CU/TU lives in.
605 If the DIE refers to a DWO file, this is always the original die,
606 not the DWO file. */
607 struct dwarf2_section_info *section;
608
609 /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
610 of the CU cache it gets reset to NULL again. */
611 struct dwarf2_cu *cu;
612
613 /* The corresponding objfile.
614 Normally we can get the objfile from dwarf2_per_objfile.
615 However we can enter this file with just a "per_cu" handle. */
616 struct objfile *objfile;
617
618 /* When using partial symbol tables, the 'psymtab' field is active.
619 Otherwise the 'quick' field is active. */
620 union
621 {
622 /* The partial symbol table associated with this compilation unit,
623 or NULL for unread partial units. */
624 struct partial_symtab *psymtab;
625
626 /* Data needed by the "quick" functions. */
627 struct dwarf2_per_cu_quick_data *quick;
628 } v;
629
630 /* The CUs we import using DW_TAG_imported_unit. This is filled in
631 while reading psymtabs, used to compute the psymtab dependencies,
632 and then cleared. Then it is filled in again while reading full
633 symbols, and only deleted when the objfile is destroyed.
634
635 This is also used to work around a difference between the way gold
636 generates .gdb_index version <=7 and the way gdb does. Arguably this
637 is a gold bug. For symbols coming from TUs, gold records in the index
638 the CU that includes the TU instead of the TU itself. This breaks
639 dw2_lookup_symbol: It assumes that if the index says symbol X lives
640 in CU/TU Y, then one need only expand Y and a subsequent lookup in Y
641 will find X. Alas TUs live in their own symtab, so after expanding CU Y
642 we need to look in TU Z to find X. Fortunately, this is akin to
643 DW_TAG_imported_unit, so we just use the same mechanism: For
644 .gdb_index version <=7 this also records the TUs that the CU referred
645 to. Concurrently with this change gdb was modified to emit version 8
646 indices so we only pay a price for gold generated indices.
647 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
648 VEC (dwarf2_per_cu_ptr) *imported_symtabs;
649 };
650
651 /* Entry in the signatured_types hash table. */
652
653 struct signatured_type
654 {
655 /* The "per_cu" object of this type.
656 This struct is used iff per_cu.is_debug_types.
657 N.B.: This is the first member so that it's easy to convert pointers
658 between them. */
659 struct dwarf2_per_cu_data per_cu;
660
661 /* The type's signature. */
662 ULONGEST signature;
663
664 /* Offset in the TU of the type's DIE, as read from the TU header.
665 If this TU is a DWO stub and the definition lives in a DWO file
666 (specified by DW_AT_GNU_dwo_name), this value is unusable. */
667 cu_offset type_offset_in_tu;
668
669 /* Offset in the section of the type's DIE.
670 If the definition lives in a DWO file, this is the offset in the
671 .debug_types.dwo section.
672 The value is zero until the actual value is known.
673 Zero is otherwise not a valid section offset. */
674 sect_offset type_offset_in_section;
675
676 /* Type units are grouped by their DW_AT_stmt_list entry so that they
677 can share them. This points to the containing symtab. */
678 struct type_unit_group *type_unit_group;
679
680 /* The type.
681 The first time we encounter this type we fully read it in and install it
682 in the symbol tables. Subsequent times we only need the type. */
683 struct type *type;
684
685 /* Containing DWO unit.
686 This field is valid iff per_cu.reading_dwo_directly. */
687 struct dwo_unit *dwo_unit;
688 };
689
690 typedef struct signatured_type *sig_type_ptr;
691 DEF_VEC_P (sig_type_ptr);
692
693 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
694 This includes type_unit_group and quick_file_names. */
695
696 struct stmt_list_hash
697 {
698 /* The DWO unit this table is from or NULL if there is none. */
699 struct dwo_unit *dwo_unit;
700
701 /* Offset in .debug_line or .debug_line.dwo. */
702 sect_offset line_offset;
703 };
704
705 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
706 an object of this type. */
707
708 struct type_unit_group
709 {
710 /* dwarf2read.c's main "handle" on a TU symtab.
711 To simplify things we create an artificial CU that "includes" all the
712 type units using this stmt_list so that the rest of the code still has
713 a "per_cu" handle on the symtab.
714 This PER_CU is recognized by having no section. */
715 #define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->section == NULL)
716 struct dwarf2_per_cu_data per_cu;
717
718 /* The TUs that share this DW_AT_stmt_list entry.
719 This is added to while parsing type units to build partial symtabs,
720 and is deleted afterwards and not used again. */
721 VEC (sig_type_ptr) *tus;
722
723 /* The primary symtab.
724 Type units in a group needn't all be defined in the same source file,
725 so we create an essentially anonymous symtab as the primary symtab. */
726 struct symtab *primary_symtab;
727
728 /* The data used to construct the hash key. */
729 struct stmt_list_hash hash;
730
731 /* The number of symtabs from the line header.
732 The value here must match line_header.num_file_names. */
733 unsigned int num_symtabs;
734
735 /* The symbol tables for this TU (obtained from the files listed in
736 DW_AT_stmt_list).
737 WARNING: The order of entries here must match the order of entries
738 in the line header. After the first TU using this type_unit_group, the
739 line header for the subsequent TUs is recreated from this. This is done
740 because we need to use the same symtabs for each TU using the same
741 DW_AT_stmt_list value. Also note that symtabs may be repeated here,
742 there's no guarantee the line header doesn't have duplicate entries. */
743 struct symtab **symtabs;
744 };
745
746 /* These sections are what may appear in a (real or virtual) DWO file. */
747
748 struct dwo_sections
749 {
750 struct dwarf2_section_info abbrev;
751 struct dwarf2_section_info line;
752 struct dwarf2_section_info loc;
753 struct dwarf2_section_info macinfo;
754 struct dwarf2_section_info macro;
755 struct dwarf2_section_info str;
756 struct dwarf2_section_info str_offsets;
757 /* In the case of a virtual DWO file, these two are unused. */
758 struct dwarf2_section_info info;
759 VEC (dwarf2_section_info_def) *types;
760 };
761
762 /* CUs/TUs in DWP/DWO files. */
763
764 struct dwo_unit
765 {
766 /* Backlink to the containing struct dwo_file. */
767 struct dwo_file *dwo_file;
768
769 /* The "id" that distinguishes this CU/TU.
770 .debug_info calls this "dwo_id", .debug_types calls this "signature".
771 Since signatures came first, we stick with it for consistency. */
772 ULONGEST signature;
773
774 /* The section this CU/TU lives in, in the DWO file. */
775 struct dwarf2_section_info *section;
776
777 /* Same as dwarf2_per_cu_data:{offset,length} but in the DWO section. */
778 sect_offset offset;
779 unsigned int length;
780
781 /* For types, offset in the type's DIE of the type defined by this TU. */
782 cu_offset type_offset_in_tu;
783 };
784
785 /* include/dwarf2.h defines the DWP section codes.
786 It defines a max value but it doesn't define a min value, which we
787 use for error checking, so provide one. */
788
789 enum dwp_v2_section_ids
790 {
791 DW_SECT_MIN = 1
792 };
793
794 /* Data for one DWO file.
795
796 This includes virtual DWO files (a virtual DWO file is a DWO file as it
797 appears in a DWP file). DWP files don't really have DWO files per se -
798 comdat folding of types "loses" the DWO file they came from, and from
799 a high level view DWP files appear to contain a mass of random types.
800 However, to maintain consistency with the non-DWP case we pretend DWP
801 files contain virtual DWO files, and we assign each TU with one virtual
802 DWO file (generally based on the line and abbrev section offsets -
803 a heuristic that seems to work in practice). */
804
805 struct dwo_file
806 {
807 /* The DW_AT_GNU_dwo_name attribute.
808 For virtual DWO files the name is constructed from the section offsets
809 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
810 from related CU+TUs. */
811 const char *dwo_name;
812
813 /* The DW_AT_comp_dir attribute. */
814 const char *comp_dir;
815
816 /* The bfd, when the file is open. Otherwise this is NULL.
817 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
818 bfd *dbfd;
819
820 /* The sections that make up this DWO file.
821 Remember that for virtual DWO files in DWP V2, these are virtual
822 sections (for lack of a better name). */
823 struct dwo_sections sections;
824
825 /* The CU in the file.
826 We only support one because having more than one requires hacking the
827 dwo_name of each to match, which is highly unlikely to happen.
828 Doing this means all TUs can share comp_dir: We also assume that
829 DW_AT_comp_dir across all TUs in a DWO file will be identical. */
830 struct dwo_unit *cu;
831
832 /* Table of TUs in the file.
833 Each element is a struct dwo_unit. */
834 htab_t tus;
835 };
836
837 /* These sections are what may appear in a DWP file. */
838
839 struct dwp_sections
840 {
841 /* These are used by both DWP version 1 and 2. */
842 struct dwarf2_section_info str;
843 struct dwarf2_section_info cu_index;
844 struct dwarf2_section_info tu_index;
845
846 /* These are only used by DWP version 2 files.
847 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
848 sections are referenced by section number, and are not recorded here.
849 In DWP version 2 there is at most one copy of all these sections, each
850 section being (effectively) comprised of the concatenation of all of the
851 individual sections that exist in the version 1 format.
852 To keep the code simple we treat each of these concatenated pieces as a
853 section itself (a virtual section?). */
854 struct dwarf2_section_info abbrev;
855 struct dwarf2_section_info info;
856 struct dwarf2_section_info line;
857 struct dwarf2_section_info loc;
858 struct dwarf2_section_info macinfo;
859 struct dwarf2_section_info macro;
860 struct dwarf2_section_info str_offsets;
861 struct dwarf2_section_info types;
862 };
863
864 /* These sections are what may appear in a virtual DWO file in DWP version 1.
865 A virtual DWO file is a DWO file as it appears in a DWP file. */
866
867 struct virtual_v1_dwo_sections
868 {
869 struct dwarf2_section_info abbrev;
870 struct dwarf2_section_info line;
871 struct dwarf2_section_info loc;
872 struct dwarf2_section_info macinfo;
873 struct dwarf2_section_info macro;
874 struct dwarf2_section_info str_offsets;
875 /* Each DWP hash table entry records one CU or one TU.
876 That is recorded here, and copied to dwo_unit.section. */
877 struct dwarf2_section_info info_or_types;
878 };
879
880 /* Similar to virtual_v1_dwo_sections, but for DWP version 2.
881 In version 2, the sections of the DWO files are concatenated together
882 and stored in one section of that name. Thus each ELF section contains
883 several "virtual" sections. */
884
885 struct virtual_v2_dwo_sections
886 {
887 bfd_size_type abbrev_offset;
888 bfd_size_type abbrev_size;
889
890 bfd_size_type line_offset;
891 bfd_size_type line_size;
892
893 bfd_size_type loc_offset;
894 bfd_size_type loc_size;
895
896 bfd_size_type macinfo_offset;
897 bfd_size_type macinfo_size;
898
899 bfd_size_type macro_offset;
900 bfd_size_type macro_size;
901
902 bfd_size_type str_offsets_offset;
903 bfd_size_type str_offsets_size;
904
905 /* Each DWP hash table entry records one CU or one TU.
906 That is recorded here, and copied to dwo_unit.section. */
907 bfd_size_type info_or_types_offset;
908 bfd_size_type info_or_types_size;
909 };
910
911 /* Contents of DWP hash tables. */
912
913 struct dwp_hash_table
914 {
915 uint32_t version, nr_columns;
916 uint32_t nr_units, nr_slots;
917 const gdb_byte *hash_table, *unit_table;
918 union
919 {
920 struct
921 {
922 const gdb_byte *indices;
923 } v1;
924 struct
925 {
926 /* This is indexed by column number and gives the id of the section
927 in that column. */
928 #define MAX_NR_V2_DWO_SECTIONS \
929 (1 /* .debug_info or .debug_types */ \
930 + 1 /* .debug_abbrev */ \
931 + 1 /* .debug_line */ \
932 + 1 /* .debug_loc */ \
933 + 1 /* .debug_str_offsets */ \
934 + 1 /* .debug_macro or .debug_macinfo */)
935 int section_ids[MAX_NR_V2_DWO_SECTIONS];
936 const gdb_byte *offsets;
937 const gdb_byte *sizes;
938 } v2;
939 } section_pool;
940 };
941
942 /* Data for one DWP file. */
943
944 struct dwp_file
945 {
946 /* Name of the file. */
947 const char *name;
948
949 /* File format version. */
950 int version;
951
952 /* The bfd. */
953 bfd *dbfd;
954
955 /* Section info for this file. */
956 struct dwp_sections sections;
957
958 /* Table of CUs in the file. */
959 const struct dwp_hash_table *cus;
960
961 /* Table of TUs in the file. */
962 const struct dwp_hash_table *tus;
963
964 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
965 htab_t loaded_cus;
966 htab_t loaded_tus;
967
968 /* Table to map ELF section numbers to their sections.
969 This is only needed for the DWP V1 file format. */
970 unsigned int num_sections;
971 asection **elf_sections;
972 };
973
974 /* This represents a '.dwz' file. */
975
976 struct dwz_file
977 {
978 /* A dwz file can only contain a few sections. */
979 struct dwarf2_section_info abbrev;
980 struct dwarf2_section_info info;
981 struct dwarf2_section_info str;
982 struct dwarf2_section_info line;
983 struct dwarf2_section_info macro;
984 struct dwarf2_section_info gdb_index;
985
986 /* The dwz's BFD. */
987 bfd *dwz_bfd;
988 };
989
990 /* Struct used to pass misc. parameters to read_die_and_children, et
991 al. which are used for both .debug_info and .debug_types dies.
992 All parameters here are unchanging for the life of the call. This
993 struct exists to abstract away the constant parameters of die reading. */
994
995 struct die_reader_specs
996 {
997 /* The bfd of die_section. */
998 bfd* abfd;
999
1000 /* The CU of the DIE we are parsing. */
1001 struct dwarf2_cu *cu;
1002
1003 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
1004 struct dwo_file *dwo_file;
1005
1006 /* The section the die comes from.
1007 This is either .debug_info or .debug_types, or the .dwo variants. */
1008 struct dwarf2_section_info *die_section;
1009
1010 /* die_section->buffer. */
1011 const gdb_byte *buffer;
1012
1013 /* The end of the buffer. */
1014 const gdb_byte *buffer_end;
1015
1016 /* The value of the DW_AT_comp_dir attribute. */
1017 const char *comp_dir;
1018 };
1019
1020 /* Type of function passed to init_cutu_and_read_dies, et.al. */
1021 typedef void (die_reader_func_ftype) (const struct die_reader_specs *reader,
1022 const gdb_byte *info_ptr,
1023 struct die_info *comp_unit_die,
1024 int has_children,
1025 void *data);
1026
1027 /* The line number information for a compilation unit (found in the
1028 .debug_line section) begins with a "statement program header",
1029 which contains the following information. */
1030 struct line_header
1031 {
1032 unsigned int total_length;
1033 unsigned short version;
1034 unsigned int header_length;
1035 unsigned char minimum_instruction_length;
1036 unsigned char maximum_ops_per_instruction;
1037 unsigned char default_is_stmt;
1038 int line_base;
1039 unsigned char line_range;
1040 unsigned char opcode_base;
1041
1042 /* standard_opcode_lengths[i] is the number of operands for the
1043 standard opcode whose value is i. This means that
1044 standard_opcode_lengths[0] is unused, and the last meaningful
1045 element is standard_opcode_lengths[opcode_base - 1]. */
1046 unsigned char *standard_opcode_lengths;
1047
1048 /* The include_directories table. NOTE! These strings are not
1049 allocated with xmalloc; instead, they are pointers into
1050 debug_line_buffer. If you try to free them, `free' will get
1051 indigestion. */
1052 unsigned int num_include_dirs, include_dirs_size;
1053 const char **include_dirs;
1054
1055 /* The file_names table. NOTE! These strings are not allocated
1056 with xmalloc; instead, they are pointers into debug_line_buffer.
1057 Don't try to free them directly. */
1058 unsigned int num_file_names, file_names_size;
1059 struct file_entry
1060 {
1061 const char *name;
1062 unsigned int dir_index;
1063 unsigned int mod_time;
1064 unsigned int length;
1065 int included_p; /* Non-zero if referenced by the Line Number Program. */
1066 struct symtab *symtab; /* The associated symbol table, if any. */
1067 } *file_names;
1068
1069 /* The start and end of the statement program following this
1070 header. These point into dwarf2_per_objfile->line_buffer. */
1071 const gdb_byte *statement_program_start, *statement_program_end;
1072 };
1073
1074 /* When we construct a partial symbol table entry we only
1075 need this much information. */
1076 struct partial_die_info
1077 {
1078 /* Offset of this DIE. */
1079 sect_offset offset;
1080
1081 /* DWARF-2 tag for this DIE. */
1082 ENUM_BITFIELD(dwarf_tag) tag : 16;
1083
1084 /* Assorted flags describing the data found in this DIE. */
1085 unsigned int has_children : 1;
1086 unsigned int is_external : 1;
1087 unsigned int is_declaration : 1;
1088 unsigned int has_type : 1;
1089 unsigned int has_specification : 1;
1090 unsigned int has_pc_info : 1;
1091 unsigned int may_be_inlined : 1;
1092
1093 /* Flag set if the SCOPE field of this structure has been
1094 computed. */
1095 unsigned int scope_set : 1;
1096
1097 /* Flag set if the DIE has a byte_size attribute. */
1098 unsigned int has_byte_size : 1;
1099
1100 /* Flag set if any of the DIE's children are template arguments. */
1101 unsigned int has_template_arguments : 1;
1102
1103 /* Flag set if fixup_partial_die has been called on this die. */
1104 unsigned int fixup_called : 1;
1105
1106 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1107 unsigned int is_dwz : 1;
1108
1109 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1110 unsigned int spec_is_dwz : 1;
1111
1112 /* The name of this DIE. Normally the value of DW_AT_name, but
1113 sometimes a default name for unnamed DIEs. */
1114 const char *name;
1115
1116 /* The linkage name, if present. */
1117 const char *linkage_name;
1118
1119 /* The scope to prepend to our children. This is generally
1120 allocated on the comp_unit_obstack, so will disappear
1121 when this compilation unit leaves the cache. */
1122 const char *scope;
1123
1124 /* Some data associated with the partial DIE. The tag determines
1125 which field is live. */
1126 union
1127 {
1128 /* The location description associated with this DIE, if any. */
1129 struct dwarf_block *locdesc;
1130 /* The offset of an import, for DW_TAG_imported_unit. */
1131 sect_offset offset;
1132 } d;
1133
1134 /* If HAS_PC_INFO, the PC range associated with this DIE. */
1135 CORE_ADDR lowpc;
1136 CORE_ADDR highpc;
1137
1138 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1139 DW_AT_sibling, if any. */
1140 /* NOTE: This member isn't strictly necessary, read_partial_die could
1141 return DW_AT_sibling values to its caller load_partial_dies. */
1142 const gdb_byte *sibling;
1143
1144 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1145 DW_AT_specification (or DW_AT_abstract_origin or
1146 DW_AT_extension). */
1147 sect_offset spec_offset;
1148
1149 /* Pointers to this DIE's parent, first child, and next sibling,
1150 if any. */
1151 struct partial_die_info *die_parent, *die_child, *die_sibling;
1152 };
1153
1154 /* This data structure holds the information of an abbrev. */
1155 struct abbrev_info
1156 {
1157 unsigned int number; /* number identifying abbrev */
1158 enum dwarf_tag tag; /* dwarf tag */
1159 unsigned short has_children; /* boolean */
1160 unsigned short num_attrs; /* number of attributes */
1161 struct attr_abbrev *attrs; /* an array of attribute descriptions */
1162 struct abbrev_info *next; /* next in chain */
1163 };
1164
1165 struct attr_abbrev
1166 {
1167 ENUM_BITFIELD(dwarf_attribute) name : 16;
1168 ENUM_BITFIELD(dwarf_form) form : 16;
1169 };
1170
1171 /* Size of abbrev_table.abbrev_hash_table. */
1172 #define ABBREV_HASH_SIZE 121
1173
1174 /* Top level data structure to contain an abbreviation table. */
1175
1176 struct abbrev_table
1177 {
1178 /* Where the abbrev table came from.
1179 This is used as a sanity check when the table is used. */
1180 sect_offset offset;
1181
1182 /* Storage for the abbrev table. */
1183 struct obstack abbrev_obstack;
1184
1185 /* Hash table of abbrevs.
1186 This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1187 It could be statically allocated, but the previous code didn't so we
1188 don't either. */
1189 struct abbrev_info **abbrevs;
1190 };
1191
1192 /* Attributes have a name and a value. */
1193 struct attribute
1194 {
1195 ENUM_BITFIELD(dwarf_attribute) name : 16;
1196 ENUM_BITFIELD(dwarf_form) form : 15;
1197
1198 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
1199 field should be in u.str (existing only for DW_STRING) but it is kept
1200 here for better struct attribute alignment. */
1201 unsigned int string_is_canonical : 1;
1202
1203 union
1204 {
1205 const char *str;
1206 struct dwarf_block *blk;
1207 ULONGEST unsnd;
1208 LONGEST snd;
1209 CORE_ADDR addr;
1210 ULONGEST signature;
1211 }
1212 u;
1213 };
1214
1215 /* This data structure holds a complete die structure. */
1216 struct die_info
1217 {
1218 /* DWARF-2 tag for this DIE. */
1219 ENUM_BITFIELD(dwarf_tag) tag : 16;
1220
1221 /* Number of attributes */
1222 unsigned char num_attrs;
1223
1224 /* True if we're presently building the full type name for the
1225 type derived from this DIE. */
1226 unsigned char building_fullname : 1;
1227
1228 /* True if this die is in process. PR 16581. */
1229 unsigned char in_process : 1;
1230
1231 /* Abbrev number */
1232 unsigned int abbrev;
1233
1234 /* Offset in .debug_info or .debug_types section. */
1235 sect_offset offset;
1236
1237 /* The dies in a compilation unit form an n-ary tree. PARENT
1238 points to this die's parent; CHILD points to the first child of
1239 this node; and all the children of a given node are chained
1240 together via their SIBLING fields. */
1241 struct die_info *child; /* Its first child, if any. */
1242 struct die_info *sibling; /* Its next sibling, if any. */
1243 struct die_info *parent; /* Its parent, if any. */
1244
1245 /* An array of attributes, with NUM_ATTRS elements. There may be
1246 zero, but it's not common and zero-sized arrays are not
1247 sufficiently portable C. */
1248 struct attribute attrs[1];
1249 };
1250
1251 /* Get at parts of an attribute structure. */
1252
1253 #define DW_STRING(attr) ((attr)->u.str)
1254 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1255 #define DW_UNSND(attr) ((attr)->u.unsnd)
1256 #define DW_BLOCK(attr) ((attr)->u.blk)
1257 #define DW_SND(attr) ((attr)->u.snd)
1258 #define DW_ADDR(attr) ((attr)->u.addr)
1259 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1260
1261 /* Blocks are a bunch of untyped bytes. */
1262 struct dwarf_block
1263 {
1264 size_t size;
1265
1266 /* Valid only if SIZE is not zero. */
1267 const gdb_byte *data;
1268 };
1269
1270 #ifndef ATTR_ALLOC_CHUNK
1271 #define ATTR_ALLOC_CHUNK 4
1272 #endif
1273
1274 /* Allocate fields for structs, unions and enums in this size. */
1275 #ifndef DW_FIELD_ALLOC_CHUNK
1276 #define DW_FIELD_ALLOC_CHUNK 4
1277 #endif
1278
1279 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1280 but this would require a corresponding change in unpack_field_as_long
1281 and friends. */
1282 static int bits_per_byte = 8;
1283
1284 /* The routines that read and process dies for a C struct or C++ class
1285 pass lists of data member fields and lists of member function fields
1286 in an instance of a field_info structure, as defined below. */
1287 struct field_info
1288 {
1289 /* List of data member and baseclasses fields. */
1290 struct nextfield
1291 {
1292 struct nextfield *next;
1293 int accessibility;
1294 int virtuality;
1295 struct field field;
1296 }
1297 *fields, *baseclasses;
1298
1299 /* Number of fields (including baseclasses). */
1300 int nfields;
1301
1302 /* Number of baseclasses. */
1303 int nbaseclasses;
1304
1305 /* Set if the accesibility of one of the fields is not public. */
1306 int non_public_fields;
1307
1308 /* Member function fields array, entries are allocated in the order they
1309 are encountered in the object file. */
1310 struct nextfnfield
1311 {
1312 struct nextfnfield *next;
1313 struct fn_field fnfield;
1314 }
1315 *fnfields;
1316
1317 /* Member function fieldlist array, contains name of possibly overloaded
1318 member function, number of overloaded member functions and a pointer
1319 to the head of the member function field chain. */
1320 struct fnfieldlist
1321 {
1322 const char *name;
1323 int length;
1324 struct nextfnfield *head;
1325 }
1326 *fnfieldlists;
1327
1328 /* Number of entries in the fnfieldlists array. */
1329 int nfnfields;
1330
1331 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1332 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1333 struct typedef_field_list
1334 {
1335 struct typedef_field field;
1336 struct typedef_field_list *next;
1337 }
1338 *typedef_field_list;
1339 unsigned typedef_field_list_count;
1340 };
1341
1342 /* One item on the queue of compilation units to read in full symbols
1343 for. */
1344 struct dwarf2_queue_item
1345 {
1346 struct dwarf2_per_cu_data *per_cu;
1347 enum language pretend_language;
1348 struct dwarf2_queue_item *next;
1349 };
1350
1351 /* The current queue. */
1352 static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail;
1353
1354 /* Loaded secondary compilation units are kept in memory until they
1355 have not been referenced for the processing of this many
1356 compilation units. Set this to zero to disable caching. Cache
1357 sizes of up to at least twenty will improve startup time for
1358 typical inter-CU-reference binaries, at an obvious memory cost. */
1359 static int dwarf2_max_cache_age = 5;
1360 static void
1361 show_dwarf2_max_cache_age (struct ui_file *file, int from_tty,
1362 struct cmd_list_element *c, const char *value)
1363 {
1364 fprintf_filtered (file, _("The upper bound on the age of cached "
1365 "dwarf2 compilation units is %s.\n"),
1366 value);
1367 }
1368 \f
1369 /* local function prototypes */
1370
1371 static const char *get_section_name (const struct dwarf2_section_info *);
1372
1373 static const char *get_section_file_name (const struct dwarf2_section_info *);
1374
1375 static void dwarf2_locate_sections (bfd *, asection *, void *);
1376
1377 static void dwarf2_find_base_address (struct die_info *die,
1378 struct dwarf2_cu *cu);
1379
1380 static struct partial_symtab *create_partial_symtab
1381 (struct dwarf2_per_cu_data *per_cu, const char *name);
1382
1383 static void dwarf2_build_psymtabs_hard (struct objfile *);
1384
1385 static void scan_partial_symbols (struct partial_die_info *,
1386 CORE_ADDR *, CORE_ADDR *,
1387 int, struct dwarf2_cu *);
1388
1389 static void add_partial_symbol (struct partial_die_info *,
1390 struct dwarf2_cu *);
1391
1392 static void add_partial_namespace (struct partial_die_info *pdi,
1393 CORE_ADDR *lowpc, CORE_ADDR *highpc,
1394 int need_pc, struct dwarf2_cu *cu);
1395
1396 static void add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
1397 CORE_ADDR *highpc, int need_pc,
1398 struct dwarf2_cu *cu);
1399
1400 static void add_partial_enumeration (struct partial_die_info *enum_pdi,
1401 struct dwarf2_cu *cu);
1402
1403 static void add_partial_subprogram (struct partial_die_info *pdi,
1404 CORE_ADDR *lowpc, CORE_ADDR *highpc,
1405 int need_pc, struct dwarf2_cu *cu);
1406
1407 static void dwarf2_read_symtab (struct partial_symtab *,
1408 struct objfile *);
1409
1410 static void psymtab_to_symtab_1 (struct partial_symtab *);
1411
1412 static struct abbrev_info *abbrev_table_lookup_abbrev
1413 (const struct abbrev_table *, unsigned int);
1414
1415 static struct abbrev_table *abbrev_table_read_table
1416 (struct dwarf2_section_info *, sect_offset);
1417
1418 static void abbrev_table_free (struct abbrev_table *);
1419
1420 static void abbrev_table_free_cleanup (void *);
1421
1422 static void dwarf2_read_abbrevs (struct dwarf2_cu *,
1423 struct dwarf2_section_info *);
1424
1425 static void dwarf2_free_abbrev_table (void *);
1426
1427 static unsigned int peek_abbrev_code (bfd *, const gdb_byte *);
1428
1429 static struct partial_die_info *load_partial_dies
1430 (const struct die_reader_specs *, const gdb_byte *, int);
1431
1432 static const gdb_byte *read_partial_die (const struct die_reader_specs *,
1433 struct partial_die_info *,
1434 struct abbrev_info *,
1435 unsigned int,
1436 const gdb_byte *);
1437
1438 static struct partial_die_info *find_partial_die (sect_offset, int,
1439 struct dwarf2_cu *);
1440
1441 static void fixup_partial_die (struct partial_die_info *,
1442 struct dwarf2_cu *);
1443
1444 static const gdb_byte *read_attribute (const struct die_reader_specs *,
1445 struct attribute *, struct attr_abbrev *,
1446 const gdb_byte *);
1447
1448 static unsigned int read_1_byte (bfd *, const gdb_byte *);
1449
1450 static int read_1_signed_byte (bfd *, const gdb_byte *);
1451
1452 static unsigned int read_2_bytes (bfd *, const gdb_byte *);
1453
1454 static unsigned int read_4_bytes (bfd *, const gdb_byte *);
1455
1456 static ULONGEST read_8_bytes (bfd *, const gdb_byte *);
1457
1458 static CORE_ADDR read_address (bfd *, const gdb_byte *ptr, struct dwarf2_cu *,
1459 unsigned int *);
1460
1461 static LONGEST read_initial_length (bfd *, const gdb_byte *, unsigned int *);
1462
1463 static LONGEST read_checked_initial_length_and_offset
1464 (bfd *, const gdb_byte *, const struct comp_unit_head *,
1465 unsigned int *, unsigned int *);
1466
1467 static LONGEST read_offset (bfd *, const gdb_byte *,
1468 const struct comp_unit_head *,
1469 unsigned int *);
1470
1471 static LONGEST read_offset_1 (bfd *, const gdb_byte *, unsigned int);
1472
1473 static sect_offset read_abbrev_offset (struct dwarf2_section_info *,
1474 sect_offset);
1475
1476 static const gdb_byte *read_n_bytes (bfd *, const gdb_byte *, unsigned int);
1477
1478 static const char *read_direct_string (bfd *, const gdb_byte *, unsigned int *);
1479
1480 static const char *read_indirect_string (bfd *, const gdb_byte *,
1481 const struct comp_unit_head *,
1482 unsigned int *);
1483
1484 static const char *read_indirect_string_from_dwz (struct dwz_file *, LONGEST);
1485
1486 static ULONGEST read_unsigned_leb128 (bfd *, const gdb_byte *, unsigned int *);
1487
1488 static LONGEST read_signed_leb128 (bfd *, const gdb_byte *, unsigned int *);
1489
1490 static CORE_ADDR read_addr_index_from_leb128 (struct dwarf2_cu *,
1491 const gdb_byte *,
1492 unsigned int *);
1493
1494 static const char *read_str_index (const struct die_reader_specs *reader,
1495 ULONGEST str_index);
1496
1497 static void set_cu_language (unsigned int, struct dwarf2_cu *);
1498
1499 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
1500 struct dwarf2_cu *);
1501
1502 static struct attribute *dwarf2_attr_no_follow (struct die_info *,
1503 unsigned int);
1504
1505 static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
1506 struct dwarf2_cu *cu);
1507
1508 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
1509
1510 static struct die_info *die_specification (struct die_info *die,
1511 struct dwarf2_cu **);
1512
1513 static void free_line_header (struct line_header *lh);
1514
1515 static struct line_header *dwarf_decode_line_header (unsigned int offset,
1516 struct dwarf2_cu *cu);
1517
1518 static void dwarf_decode_lines (struct line_header *, const char *,
1519 struct dwarf2_cu *, struct partial_symtab *,
1520 int);
1521
1522 static void dwarf2_start_subfile (const char *, const char *, const char *);
1523
1524 static void dwarf2_start_symtab (struct dwarf2_cu *,
1525 const char *, const char *, CORE_ADDR);
1526
1527 static struct symbol *new_symbol (struct die_info *, struct type *,
1528 struct dwarf2_cu *);
1529
1530 static struct symbol *new_symbol_full (struct die_info *, struct type *,
1531 struct dwarf2_cu *, struct symbol *);
1532
1533 static void dwarf2_const_value (const struct attribute *, struct symbol *,
1534 struct dwarf2_cu *);
1535
1536 static void dwarf2_const_value_attr (const struct attribute *attr,
1537 struct type *type,
1538 const char *name,
1539 struct obstack *obstack,
1540 struct dwarf2_cu *cu, LONGEST *value,
1541 const gdb_byte **bytes,
1542 struct dwarf2_locexpr_baton **baton);
1543
1544 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
1545
1546 static int need_gnat_info (struct dwarf2_cu *);
1547
1548 static struct type *die_descriptive_type (struct die_info *,
1549 struct dwarf2_cu *);
1550
1551 static void set_descriptive_type (struct type *, struct die_info *,
1552 struct dwarf2_cu *);
1553
1554 static struct type *die_containing_type (struct die_info *,
1555 struct dwarf2_cu *);
1556
1557 static struct type *lookup_die_type (struct die_info *, const struct attribute *,
1558 struct dwarf2_cu *);
1559
1560 static struct type *read_type_die (struct die_info *, struct dwarf2_cu *);
1561
1562 static struct type *read_type_die_1 (struct die_info *, struct dwarf2_cu *);
1563
1564 static const char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
1565
1566 static char *typename_concat (struct obstack *obs, const char *prefix,
1567 const char *suffix, int physname,
1568 struct dwarf2_cu *cu);
1569
1570 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
1571
1572 static void read_type_unit_scope (struct die_info *, struct dwarf2_cu *);
1573
1574 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
1575
1576 static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
1577
1578 static void read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu);
1579
1580 static int dwarf2_ranges_read (unsigned, CORE_ADDR *, CORE_ADDR *,
1581 struct dwarf2_cu *, struct partial_symtab *);
1582
1583 static int dwarf2_get_pc_bounds (struct die_info *,
1584 CORE_ADDR *, CORE_ADDR *, struct dwarf2_cu *,
1585 struct partial_symtab *);
1586
1587 static void get_scope_pc_bounds (struct die_info *,
1588 CORE_ADDR *, CORE_ADDR *,
1589 struct dwarf2_cu *);
1590
1591 static void dwarf2_record_block_ranges (struct die_info *, struct block *,
1592 CORE_ADDR, struct dwarf2_cu *);
1593
1594 static void dwarf2_add_field (struct field_info *, struct die_info *,
1595 struct dwarf2_cu *);
1596
1597 static void dwarf2_attach_fields_to_type (struct field_info *,
1598 struct type *, struct dwarf2_cu *);
1599
1600 static void dwarf2_add_member_fn (struct field_info *,
1601 struct die_info *, struct type *,
1602 struct dwarf2_cu *);
1603
1604 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
1605 struct type *,
1606 struct dwarf2_cu *);
1607
1608 static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
1609
1610 static void read_common_block (struct die_info *, struct dwarf2_cu *);
1611
1612 static void read_namespace (struct die_info *die, struct dwarf2_cu *);
1613
1614 static void read_module (struct die_info *die, struct dwarf2_cu *cu);
1615
1616 static void read_import_statement (struct die_info *die, struct dwarf2_cu *);
1617
1618 static int read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu);
1619
1620 static struct type *read_module_type (struct die_info *die,
1621 struct dwarf2_cu *cu);
1622
1623 static const char *namespace_name (struct die_info *die,
1624 int *is_anonymous, struct dwarf2_cu *);
1625
1626 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
1627
1628 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
1629
1630 static enum dwarf_array_dim_ordering read_array_order (struct die_info *,
1631 struct dwarf2_cu *);
1632
1633 static struct die_info *read_die_and_siblings_1
1634 (const struct die_reader_specs *, const gdb_byte *, const gdb_byte **,
1635 struct die_info *);
1636
1637 static struct die_info *read_die_and_siblings (const struct die_reader_specs *,
1638 const gdb_byte *info_ptr,
1639 const gdb_byte **new_info_ptr,
1640 struct die_info *parent);
1641
1642 static const gdb_byte *read_full_die_1 (const struct die_reader_specs *,
1643 struct die_info **, const gdb_byte *,
1644 int *, int);
1645
1646 static const gdb_byte *read_full_die (const struct die_reader_specs *,
1647 struct die_info **, const gdb_byte *,
1648 int *);
1649
1650 static void process_die (struct die_info *, struct dwarf2_cu *);
1651
1652 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu *,
1653 struct obstack *);
1654
1655 static const char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
1656
1657 static const char *dwarf2_full_name (const char *name,
1658 struct die_info *die,
1659 struct dwarf2_cu *cu);
1660
1661 static const char *dwarf2_physname (const char *name, struct die_info *die,
1662 struct dwarf2_cu *cu);
1663
1664 static struct die_info *dwarf2_extension (struct die_info *die,
1665 struct dwarf2_cu **);
1666
1667 static const char *dwarf_tag_name (unsigned int);
1668
1669 static const char *dwarf_attr_name (unsigned int);
1670
1671 static const char *dwarf_form_name (unsigned int);
1672
1673 static char *dwarf_bool_name (unsigned int);
1674
1675 static const char *dwarf_type_encoding_name (unsigned int);
1676
1677 static struct die_info *sibling_die (struct die_info *);
1678
1679 static void dump_die_shallow (struct ui_file *, int indent, struct die_info *);
1680
1681 static void dump_die_for_error (struct die_info *);
1682
1683 static void dump_die_1 (struct ui_file *, int level, int max_level,
1684 struct die_info *);
1685
1686 /*static*/ void dump_die (struct die_info *, int max_level);
1687
1688 static void store_in_ref_table (struct die_info *,
1689 struct dwarf2_cu *);
1690
1691 static sect_offset dwarf2_get_ref_die_offset (const struct attribute *);
1692
1693 static LONGEST dwarf2_get_attr_constant_value (const struct attribute *, int);
1694
1695 static struct die_info *follow_die_ref_or_sig (struct die_info *,
1696 const struct attribute *,
1697 struct dwarf2_cu **);
1698
1699 static struct die_info *follow_die_ref (struct die_info *,
1700 const struct attribute *,
1701 struct dwarf2_cu **);
1702
1703 static struct die_info *follow_die_sig (struct die_info *,
1704 const struct attribute *,
1705 struct dwarf2_cu **);
1706
1707 static struct type *get_signatured_type (struct die_info *, ULONGEST,
1708 struct dwarf2_cu *);
1709
1710 static struct type *get_DW_AT_signature_type (struct die_info *,
1711 const struct attribute *,
1712 struct dwarf2_cu *);
1713
1714 static void load_full_type_unit (struct dwarf2_per_cu_data *per_cu);
1715
1716 static void read_signatured_type (struct signatured_type *);
1717
1718 static struct type_unit_group *get_type_unit_group
1719 (struct dwarf2_cu *, const struct attribute *);
1720
1721 static void build_type_unit_groups (die_reader_func_ftype *, void *);
1722
1723 /* memory allocation interface */
1724
1725 static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
1726
1727 static struct die_info *dwarf_alloc_die (struct dwarf2_cu *, int);
1728
1729 static void dwarf_decode_macros (struct dwarf2_cu *, unsigned int,
1730 const char *, int);
1731
1732 static int attr_form_is_block (const struct attribute *);
1733
1734 static int attr_form_is_section_offset (const struct attribute *);
1735
1736 static int attr_form_is_constant (const struct attribute *);
1737
1738 static int attr_form_is_ref (const struct attribute *);
1739
1740 static void fill_in_loclist_baton (struct dwarf2_cu *cu,
1741 struct dwarf2_loclist_baton *baton,
1742 const struct attribute *attr);
1743
1744 static void dwarf2_symbol_mark_computed (const struct attribute *attr,
1745 struct symbol *sym,
1746 struct dwarf2_cu *cu,
1747 int is_block);
1748
1749 static const gdb_byte *skip_one_die (const struct die_reader_specs *reader,
1750 const gdb_byte *info_ptr,
1751 struct abbrev_info *abbrev);
1752
1753 static void free_stack_comp_unit (void *);
1754
1755 static hashval_t partial_die_hash (const void *item);
1756
1757 static int partial_die_eq (const void *item_lhs, const void *item_rhs);
1758
1759 static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit
1760 (sect_offset offset, unsigned int offset_in_dwz, struct objfile *objfile);
1761
1762 static void init_one_comp_unit (struct dwarf2_cu *cu,
1763 struct dwarf2_per_cu_data *per_cu);
1764
1765 static void prepare_one_comp_unit (struct dwarf2_cu *cu,
1766 struct die_info *comp_unit_die,
1767 enum language pretend_language);
1768
1769 static void free_heap_comp_unit (void *);
1770
1771 static void free_cached_comp_units (void *);
1772
1773 static void age_cached_comp_units (void);
1774
1775 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data *);
1776
1777 static struct type *set_die_type (struct die_info *, struct type *,
1778 struct dwarf2_cu *);
1779
1780 static void create_all_comp_units (struct objfile *);
1781
1782 static int create_all_type_units (struct objfile *);
1783
1784 static void load_full_comp_unit (struct dwarf2_per_cu_data *,
1785 enum language);
1786
1787 static void process_full_comp_unit (struct dwarf2_per_cu_data *,
1788 enum language);
1789
1790 static void process_full_type_unit (struct dwarf2_per_cu_data *,
1791 enum language);
1792
1793 static void dwarf2_add_dependence (struct dwarf2_cu *,
1794 struct dwarf2_per_cu_data *);
1795
1796 static void dwarf2_mark (struct dwarf2_cu *);
1797
1798 static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
1799
1800 static struct type *get_die_type_at_offset (sect_offset,
1801 struct dwarf2_per_cu_data *);
1802
1803 static struct type *get_die_type (struct die_info *die, struct dwarf2_cu *cu);
1804
1805 static void dwarf2_release_queue (void *dummy);
1806
1807 static void queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
1808 enum language pretend_language);
1809
1810 static void process_queue (void);
1811
1812 static void find_file_and_directory (struct die_info *die,
1813 struct dwarf2_cu *cu,
1814 const char **name, const char **comp_dir);
1815
1816 static char *file_full_name (int file, struct line_header *lh,
1817 const char *comp_dir);
1818
1819 static const gdb_byte *read_and_check_comp_unit_head
1820 (struct comp_unit_head *header,
1821 struct dwarf2_section_info *section,
1822 struct dwarf2_section_info *abbrev_section, const gdb_byte *info_ptr,
1823 int is_debug_types_section);
1824
1825 static void init_cutu_and_read_dies
1826 (struct dwarf2_per_cu_data *this_cu, struct abbrev_table *abbrev_table,
1827 int use_existing_cu, int keep,
1828 die_reader_func_ftype *die_reader_func, void *data);
1829
1830 static void init_cutu_and_read_dies_simple
1831 (struct dwarf2_per_cu_data *this_cu,
1832 die_reader_func_ftype *die_reader_func, void *data);
1833
1834 static htab_t allocate_signatured_type_table (struct objfile *objfile);
1835
1836 static htab_t allocate_dwo_unit_table (struct objfile *objfile);
1837
1838 static struct dwo_unit *lookup_dwo_unit_in_dwp
1839 (struct dwp_file *dwp_file, const char *comp_dir,
1840 ULONGEST signature, int is_debug_types);
1841
1842 static struct dwp_file *get_dwp_file (void);
1843
1844 static struct dwo_unit *lookup_dwo_comp_unit
1845 (struct dwarf2_per_cu_data *, const char *, const char *, ULONGEST);
1846
1847 static struct dwo_unit *lookup_dwo_type_unit
1848 (struct signatured_type *, const char *, const char *);
1849
1850 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *);
1851
1852 static void free_dwo_file_cleanup (void *);
1853
1854 static void process_cu_includes (void);
1855
1856 static void check_producer (struct dwarf2_cu *cu);
1857 \f
1858 /* Various complaints about symbol reading that don't abort the process. */
1859
1860 static void
1861 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
1862 {
1863 complaint (&symfile_complaints,
1864 _("statement list doesn't fit in .debug_line section"));
1865 }
1866
1867 static void
1868 dwarf2_debug_line_missing_file_complaint (void)
1869 {
1870 complaint (&symfile_complaints,
1871 _(".debug_line section has line data without a file"));
1872 }
1873
1874 static void
1875 dwarf2_debug_line_missing_end_sequence_complaint (void)
1876 {
1877 complaint (&symfile_complaints,
1878 _(".debug_line section has line "
1879 "program sequence without an end"));
1880 }
1881
1882 static void
1883 dwarf2_complex_location_expr_complaint (void)
1884 {
1885 complaint (&symfile_complaints, _("location expression too complex"));
1886 }
1887
1888 static void
1889 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
1890 int arg3)
1891 {
1892 complaint (&symfile_complaints,
1893 _("const value length mismatch for '%s', got %d, expected %d"),
1894 arg1, arg2, arg3);
1895 }
1896
1897 static void
1898 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info *section)
1899 {
1900 complaint (&symfile_complaints,
1901 _("debug info runs off end of %s section"
1902 " [in module %s]"),
1903 get_section_name (section),
1904 get_section_file_name (section));
1905 }
1906
1907 static void
1908 dwarf2_macro_malformed_definition_complaint (const char *arg1)
1909 {
1910 complaint (&symfile_complaints,
1911 _("macro debug info contains a "
1912 "malformed macro definition:\n`%s'"),
1913 arg1);
1914 }
1915
1916 static void
1917 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
1918 {
1919 complaint (&symfile_complaints,
1920 _("invalid attribute class or form for '%s' in '%s'"),
1921 arg1, arg2);
1922 }
1923 \f
1924 #if WORDS_BIGENDIAN
1925
1926 /* Convert VALUE between big- and little-endian. */
1927 static offset_type
1928 byte_swap (offset_type value)
1929 {
1930 offset_type result;
1931
1932 result = (value & 0xff) << 24;
1933 result |= (value & 0xff00) << 8;
1934 result |= (value & 0xff0000) >> 8;
1935 result |= (value & 0xff000000) >> 24;
1936 return result;
1937 }
1938
1939 #define MAYBE_SWAP(V) byte_swap (V)
1940
1941 #else
1942 #define MAYBE_SWAP(V) (V)
1943 #endif /* WORDS_BIGENDIAN */
1944
1945 /* Read the given attribute value as an address, taking the attribute's
1946 form into account. */
1947
1948 static CORE_ADDR
1949 attr_value_as_address (struct attribute *attr)
1950 {
1951 CORE_ADDR addr;
1952
1953 if (attr->form != DW_FORM_addr && attr->form != DW_FORM_GNU_addr_index)
1954 {
1955 /* Aside from a few clearly defined exceptions, attributes that
1956 contain an address must always be in DW_FORM_addr form.
1957 Unfortunately, some compilers happen to be violating this
1958 requirement by encoding addresses using other forms, such
1959 as DW_FORM_data4 for example. For those broken compilers,
1960 we try to do our best, without any guarantee of success,
1961 to interpret the address correctly. It would also be nice
1962 to generate a complaint, but that would require us to maintain
1963 a list of legitimate cases where a non-address form is allowed,
1964 as well as update callers to pass in at least the CU's DWARF
1965 version. This is more overhead than what we're willing to
1966 expand for a pretty rare case. */
1967 addr = DW_UNSND (attr);
1968 }
1969 else
1970 addr = DW_ADDR (attr);
1971
1972 return addr;
1973 }
1974
1975 /* The suffix for an index file. */
1976 #define INDEX_SUFFIX ".gdb-index"
1977
1978 /* Try to locate the sections we need for DWARF 2 debugging
1979 information and return true if we have enough to do something.
1980 NAMES points to the dwarf2 section names, or is NULL if the standard
1981 ELF names are used. */
1982
1983 int
1984 dwarf2_has_info (struct objfile *objfile,
1985 const struct dwarf2_debug_sections *names)
1986 {
1987 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
1988 if (!dwarf2_per_objfile)
1989 {
1990 /* Initialize per-objfile state. */
1991 struct dwarf2_per_objfile *data
1992 = obstack_alloc (&objfile->objfile_obstack, sizeof (*data));
1993
1994 memset (data, 0, sizeof (*data));
1995 set_objfile_data (objfile, dwarf2_objfile_data_key, data);
1996 dwarf2_per_objfile = data;
1997
1998 bfd_map_over_sections (objfile->obfd, dwarf2_locate_sections,
1999 (void *) names);
2000 dwarf2_per_objfile->objfile = objfile;
2001 }
2002 return (!dwarf2_per_objfile->info.is_virtual
2003 && dwarf2_per_objfile->info.s.asection != NULL
2004 && !dwarf2_per_objfile->abbrev.is_virtual
2005 && dwarf2_per_objfile->abbrev.s.asection != NULL);
2006 }
2007
2008 /* Return the containing section of virtual section SECTION. */
2009
2010 static struct dwarf2_section_info *
2011 get_containing_section (const struct dwarf2_section_info *section)
2012 {
2013 gdb_assert (section->is_virtual);
2014 return section->s.containing_section;
2015 }
2016
2017 /* Return the bfd owner of SECTION. */
2018
2019 static struct bfd *
2020 get_section_bfd_owner (const struct dwarf2_section_info *section)
2021 {
2022 if (section->is_virtual)
2023 {
2024 section = get_containing_section (section);
2025 gdb_assert (!section->is_virtual);
2026 }
2027 return section->s.asection->owner;
2028 }
2029
2030 /* Return the bfd section of SECTION.
2031 Returns NULL if the section is not present. */
2032
2033 static asection *
2034 get_section_bfd_section (const struct dwarf2_section_info *section)
2035 {
2036 if (section->is_virtual)
2037 {
2038 section = get_containing_section (section);
2039 gdb_assert (!section->is_virtual);
2040 }
2041 return section->s.asection;
2042 }
2043
2044 /* Return the name of SECTION. */
2045
2046 static const char *
2047 get_section_name (const struct dwarf2_section_info *section)
2048 {
2049 asection *sectp = get_section_bfd_section (section);
2050
2051 gdb_assert (sectp != NULL);
2052 return bfd_section_name (get_section_bfd_owner (section), sectp);
2053 }
2054
2055 /* Return the name of the file SECTION is in. */
2056
2057 static const char *
2058 get_section_file_name (const struct dwarf2_section_info *section)
2059 {
2060 bfd *abfd = get_section_bfd_owner (section);
2061
2062 return bfd_get_filename (abfd);
2063 }
2064
2065 /* Return the id of SECTION.
2066 Returns 0 if SECTION doesn't exist. */
2067
2068 static int
2069 get_section_id (const struct dwarf2_section_info *section)
2070 {
2071 asection *sectp = get_section_bfd_section (section);
2072
2073 if (sectp == NULL)
2074 return 0;
2075 return sectp->id;
2076 }
2077
2078 /* Return the flags of SECTION.
2079 SECTION (or containing section if this is a virtual section) must exist. */
2080
2081 static int
2082 get_section_flags (const struct dwarf2_section_info *section)
2083 {
2084 asection *sectp = get_section_bfd_section (section);
2085
2086 gdb_assert (sectp != NULL);
2087 return bfd_get_section_flags (sectp->owner, sectp);
2088 }
2089
2090 /* When loading sections, we look either for uncompressed section or for
2091 compressed section names. */
2092
2093 static int
2094 section_is_p (const char *section_name,
2095 const struct dwarf2_section_names *names)
2096 {
2097 if (names->normal != NULL
2098 && strcmp (section_name, names->normal) == 0)
2099 return 1;
2100 if (names->compressed != NULL
2101 && strcmp (section_name, names->compressed) == 0)
2102 return 1;
2103 return 0;
2104 }
2105
2106 /* This function is mapped across the sections and remembers the
2107 offset and size of each of the debugging sections we are interested
2108 in. */
2109
2110 static void
2111 dwarf2_locate_sections (bfd *abfd, asection *sectp, void *vnames)
2112 {
2113 const struct dwarf2_debug_sections *names;
2114 flagword aflag = bfd_get_section_flags (abfd, sectp);
2115
2116 if (vnames == NULL)
2117 names = &dwarf2_elf_names;
2118 else
2119 names = (const struct dwarf2_debug_sections *) vnames;
2120
2121 if ((aflag & SEC_HAS_CONTENTS) == 0)
2122 {
2123 }
2124 else if (section_is_p (sectp->name, &names->info))
2125 {
2126 dwarf2_per_objfile->info.s.asection = sectp;
2127 dwarf2_per_objfile->info.size = bfd_get_section_size (sectp);
2128 }
2129 else if (section_is_p (sectp->name, &names->abbrev))
2130 {
2131 dwarf2_per_objfile->abbrev.s.asection = sectp;
2132 dwarf2_per_objfile->abbrev.size = bfd_get_section_size (sectp);
2133 }
2134 else if (section_is_p (sectp->name, &names->line))
2135 {
2136 dwarf2_per_objfile->line.s.asection = sectp;
2137 dwarf2_per_objfile->line.size = bfd_get_section_size (sectp);
2138 }
2139 else if (section_is_p (sectp->name, &names->loc))
2140 {
2141 dwarf2_per_objfile->loc.s.asection = sectp;
2142 dwarf2_per_objfile->loc.size = bfd_get_section_size (sectp);
2143 }
2144 else if (section_is_p (sectp->name, &names->macinfo))
2145 {
2146 dwarf2_per_objfile->macinfo.s.asection = sectp;
2147 dwarf2_per_objfile->macinfo.size = bfd_get_section_size (sectp);
2148 }
2149 else if (section_is_p (sectp->name, &names->macro))
2150 {
2151 dwarf2_per_objfile->macro.s.asection = sectp;
2152 dwarf2_per_objfile->macro.size = bfd_get_section_size (sectp);
2153 }
2154 else if (section_is_p (sectp->name, &names->str))
2155 {
2156 dwarf2_per_objfile->str.s.asection = sectp;
2157 dwarf2_per_objfile->str.size = bfd_get_section_size (sectp);
2158 }
2159 else if (section_is_p (sectp->name, &names->addr))
2160 {
2161 dwarf2_per_objfile->addr.s.asection = sectp;
2162 dwarf2_per_objfile->addr.size = bfd_get_section_size (sectp);
2163 }
2164 else if (section_is_p (sectp->name, &names->frame))
2165 {
2166 dwarf2_per_objfile->frame.s.asection = sectp;
2167 dwarf2_per_objfile->frame.size = bfd_get_section_size (sectp);
2168 }
2169 else if (section_is_p (sectp->name, &names->eh_frame))
2170 {
2171 dwarf2_per_objfile->eh_frame.s.asection = sectp;
2172 dwarf2_per_objfile->eh_frame.size = bfd_get_section_size (sectp);
2173 }
2174 else if (section_is_p (sectp->name, &names->ranges))
2175 {
2176 dwarf2_per_objfile->ranges.s.asection = sectp;
2177 dwarf2_per_objfile->ranges.size = bfd_get_section_size (sectp);
2178 }
2179 else if (section_is_p (sectp->name, &names->types))
2180 {
2181 struct dwarf2_section_info type_section;
2182
2183 memset (&type_section, 0, sizeof (type_section));
2184 type_section.s.asection = sectp;
2185 type_section.size = bfd_get_section_size (sectp);
2186
2187 VEC_safe_push (dwarf2_section_info_def, dwarf2_per_objfile->types,
2188 &type_section);
2189 }
2190 else if (section_is_p (sectp->name, &names->gdb_index))
2191 {
2192 dwarf2_per_objfile->gdb_index.s.asection = sectp;
2193 dwarf2_per_objfile->gdb_index.size = bfd_get_section_size (sectp);
2194 }
2195
2196 if ((bfd_get_section_flags (abfd, sectp) & SEC_LOAD)
2197 && bfd_section_vma (abfd, sectp) == 0)
2198 dwarf2_per_objfile->has_section_at_zero = 1;
2199 }
2200
2201 /* A helper function that decides whether a section is empty,
2202 or not present. */
2203
2204 static int
2205 dwarf2_section_empty_p (const struct dwarf2_section_info *section)
2206 {
2207 if (section->is_virtual)
2208 return section->size == 0;
2209 return section->s.asection == NULL || section->size == 0;
2210 }
2211
2212 /* Read the contents of the section INFO.
2213 OBJFILE is the main object file, but not necessarily the file where
2214 the section comes from. E.g., for DWO files the bfd of INFO is the bfd
2215 of the DWO file.
2216 If the section is compressed, uncompress it before returning. */
2217
2218 static void
2219 dwarf2_read_section (struct objfile *objfile, struct dwarf2_section_info *info)
2220 {
2221 asection *sectp;
2222 bfd *abfd;
2223 gdb_byte *buf, *retbuf;
2224
2225 if (info->readin)
2226 return;
2227 info->buffer = NULL;
2228 info->readin = 1;
2229
2230 if (dwarf2_section_empty_p (info))
2231 return;
2232
2233 sectp = get_section_bfd_section (info);
2234
2235 /* If this is a virtual section we need to read in the real one first. */
2236 if (info->is_virtual)
2237 {
2238 struct dwarf2_section_info *containing_section =
2239 get_containing_section (info);
2240
2241 gdb_assert (sectp != NULL);
2242 if ((sectp->flags & SEC_RELOC) != 0)
2243 {
2244 error (_("Dwarf Error: DWP format V2 with relocations is not"
2245 " supported in section %s [in module %s]"),
2246 get_section_name (info), get_section_file_name (info));
2247 }
2248 dwarf2_read_section (objfile, containing_section);
2249 /* Other code should have already caught virtual sections that don't
2250 fit. */
2251 gdb_assert (info->virtual_offset + info->size
2252 <= containing_section->size);
2253 /* If the real section is empty or there was a problem reading the
2254 section we shouldn't get here. */
2255 gdb_assert (containing_section->buffer != NULL);
2256 info->buffer = containing_section->buffer + info->virtual_offset;
2257 return;
2258 }
2259
2260 /* If the section has relocations, we must read it ourselves.
2261 Otherwise we attach it to the BFD. */
2262 if ((sectp->flags & SEC_RELOC) == 0)
2263 {
2264 info->buffer = gdb_bfd_map_section (sectp, &info->size);
2265 return;
2266 }
2267
2268 buf = obstack_alloc (&objfile->objfile_obstack, info->size);
2269 info->buffer = buf;
2270
2271 /* When debugging .o files, we may need to apply relocations; see
2272 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2273 We never compress sections in .o files, so we only need to
2274 try this when the section is not compressed. */
2275 retbuf = symfile_relocate_debug_section (objfile, sectp, buf);
2276 if (retbuf != NULL)
2277 {
2278 info->buffer = retbuf;
2279 return;
2280 }
2281
2282 abfd = get_section_bfd_owner (info);
2283 gdb_assert (abfd != NULL);
2284
2285 if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
2286 || bfd_bread (buf, info->size, abfd) != info->size)
2287 {
2288 error (_("Dwarf Error: Can't read DWARF data"
2289 " in section %s [in module %s]"),
2290 bfd_section_name (abfd, sectp), bfd_get_filename (abfd));
2291 }
2292 }
2293
2294 /* A helper function that returns the size of a section in a safe way.
2295 If you are positive that the section has been read before using the
2296 size, then it is safe to refer to the dwarf2_section_info object's
2297 "size" field directly. In other cases, you must call this
2298 function, because for compressed sections the size field is not set
2299 correctly until the section has been read. */
2300
2301 static bfd_size_type
2302 dwarf2_section_size (struct objfile *objfile,
2303 struct dwarf2_section_info *info)
2304 {
2305 if (!info->readin)
2306 dwarf2_read_section (objfile, info);
2307 return info->size;
2308 }
2309
2310 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2311 SECTION_NAME. */
2312
2313 void
2314 dwarf2_get_section_info (struct objfile *objfile,
2315 enum dwarf2_section_enum sect,
2316 asection **sectp, const gdb_byte **bufp,
2317 bfd_size_type *sizep)
2318 {
2319 struct dwarf2_per_objfile *data
2320 = objfile_data (objfile, dwarf2_objfile_data_key);
2321 struct dwarf2_section_info *info;
2322
2323 /* We may see an objfile without any DWARF, in which case we just
2324 return nothing. */
2325 if (data == NULL)
2326 {
2327 *sectp = NULL;
2328 *bufp = NULL;
2329 *sizep = 0;
2330 return;
2331 }
2332 switch (sect)
2333 {
2334 case DWARF2_DEBUG_FRAME:
2335 info = &data->frame;
2336 break;
2337 case DWARF2_EH_FRAME:
2338 info = &data->eh_frame;
2339 break;
2340 default:
2341 gdb_assert_not_reached ("unexpected section");
2342 }
2343
2344 dwarf2_read_section (objfile, info);
2345
2346 *sectp = get_section_bfd_section (info);
2347 *bufp = info->buffer;
2348 *sizep = info->size;
2349 }
2350
2351 /* A helper function to find the sections for a .dwz file. */
2352
2353 static void
2354 locate_dwz_sections (bfd *abfd, asection *sectp, void *arg)
2355 {
2356 struct dwz_file *dwz_file = arg;
2357
2358 /* Note that we only support the standard ELF names, because .dwz
2359 is ELF-only (at the time of writing). */
2360 if (section_is_p (sectp->name, &dwarf2_elf_names.abbrev))
2361 {
2362 dwz_file->abbrev.s.asection = sectp;
2363 dwz_file->abbrev.size = bfd_get_section_size (sectp);
2364 }
2365 else if (section_is_p (sectp->name, &dwarf2_elf_names.info))
2366 {
2367 dwz_file->info.s.asection = sectp;
2368 dwz_file->info.size = bfd_get_section_size (sectp);
2369 }
2370 else if (section_is_p (sectp->name, &dwarf2_elf_names.str))
2371 {
2372 dwz_file->str.s.asection = sectp;
2373 dwz_file->str.size = bfd_get_section_size (sectp);
2374 }
2375 else if (section_is_p (sectp->name, &dwarf2_elf_names.line))
2376 {
2377 dwz_file->line.s.asection = sectp;
2378 dwz_file->line.size = bfd_get_section_size (sectp);
2379 }
2380 else if (section_is_p (sectp->name, &dwarf2_elf_names.macro))
2381 {
2382 dwz_file->macro.s.asection = sectp;
2383 dwz_file->macro.size = bfd_get_section_size (sectp);
2384 }
2385 else if (section_is_p (sectp->name, &dwarf2_elf_names.gdb_index))
2386 {
2387 dwz_file->gdb_index.s.asection = sectp;
2388 dwz_file->gdb_index.size = bfd_get_section_size (sectp);
2389 }
2390 }
2391
2392 /* Open the separate '.dwz' debug file, if needed. Return NULL if
2393 there is no .gnu_debugaltlink section in the file. Error if there
2394 is such a section but the file cannot be found. */
2395
2396 static struct dwz_file *
2397 dwarf2_get_dwz_file (void)
2398 {
2399 bfd *dwz_bfd;
2400 char *data;
2401 struct cleanup *cleanup;
2402 const char *filename;
2403 struct dwz_file *result;
2404 bfd_size_type buildid_len_arg;
2405 size_t buildid_len;
2406 bfd_byte *buildid;
2407
2408 if (dwarf2_per_objfile->dwz_file != NULL)
2409 return dwarf2_per_objfile->dwz_file;
2410
2411 bfd_set_error (bfd_error_no_error);
2412 data = bfd_get_alt_debug_link_info (dwarf2_per_objfile->objfile->obfd,
2413 &buildid_len_arg, &buildid);
2414 if (data == NULL)
2415 {
2416 if (bfd_get_error () == bfd_error_no_error)
2417 return NULL;
2418 error (_("could not read '.gnu_debugaltlink' section: %s"),
2419 bfd_errmsg (bfd_get_error ()));
2420 }
2421 cleanup = make_cleanup (xfree, data);
2422 make_cleanup (xfree, buildid);
2423
2424 buildid_len = (size_t) buildid_len_arg;
2425
2426 filename = (const char *) data;
2427 if (!IS_ABSOLUTE_PATH (filename))
2428 {
2429 char *abs = gdb_realpath (objfile_name (dwarf2_per_objfile->objfile));
2430 char *rel;
2431
2432 make_cleanup (xfree, abs);
2433 abs = ldirname (abs);
2434 make_cleanup (xfree, abs);
2435
2436 rel = concat (abs, SLASH_STRING, filename, (char *) NULL);
2437 make_cleanup (xfree, rel);
2438 filename = rel;
2439 }
2440
2441 /* First try the file name given in the section. If that doesn't
2442 work, try to use the build-id instead. */
2443 dwz_bfd = gdb_bfd_open (filename, gnutarget, -1);
2444 if (dwz_bfd != NULL)
2445 {
2446 if (!build_id_verify (dwz_bfd, buildid_len, buildid))
2447 {
2448 gdb_bfd_unref (dwz_bfd);
2449 dwz_bfd = NULL;
2450 }
2451 }
2452
2453 if (dwz_bfd == NULL)
2454 dwz_bfd = build_id_to_debug_bfd (buildid_len, buildid);
2455
2456 if (dwz_bfd == NULL)
2457 error (_("could not find '.gnu_debugaltlink' file for %s"),
2458 objfile_name (dwarf2_per_objfile->objfile));
2459
2460 result = OBSTACK_ZALLOC (&dwarf2_per_objfile->objfile->objfile_obstack,
2461 struct dwz_file);
2462 result->dwz_bfd = dwz_bfd;
2463
2464 bfd_map_over_sections (dwz_bfd, locate_dwz_sections, result);
2465
2466 do_cleanups (cleanup);
2467
2468 gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd, dwz_bfd);
2469 dwarf2_per_objfile->dwz_file = result;
2470 return result;
2471 }
2472 \f
2473 /* DWARF quick_symbols_functions support. */
2474
2475 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2476 unique line tables, so we maintain a separate table of all .debug_line
2477 derived entries to support the sharing.
2478 All the quick functions need is the list of file names. We discard the
2479 line_header when we're done and don't need to record it here. */
2480 struct quick_file_names
2481 {
2482 /* The data used to construct the hash key. */
2483 struct stmt_list_hash hash;
2484
2485 /* The number of entries in file_names, real_names. */
2486 unsigned int num_file_names;
2487
2488 /* The file names from the line table, after being run through
2489 file_full_name. */
2490 const char **file_names;
2491
2492 /* The file names from the line table after being run through
2493 gdb_realpath. These are computed lazily. */
2494 const char **real_names;
2495 };
2496
2497 /* When using the index (and thus not using psymtabs), each CU has an
2498 object of this type. This is used to hold information needed by
2499 the various "quick" methods. */
2500 struct dwarf2_per_cu_quick_data
2501 {
2502 /* The file table. This can be NULL if there was no file table
2503 or it's currently not read in.
2504 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2505 struct quick_file_names *file_names;
2506
2507 /* The corresponding symbol table. This is NULL if symbols for this
2508 CU have not yet been read. */
2509 struct symtab *symtab;
2510
2511 /* A temporary mark bit used when iterating over all CUs in
2512 expand_symtabs_matching. */
2513 unsigned int mark : 1;
2514
2515 /* True if we've tried to read the file table and found there isn't one.
2516 There will be no point in trying to read it again next time. */
2517 unsigned int no_file_data : 1;
2518 };
2519
2520 /* Utility hash function for a stmt_list_hash. */
2521
2522 static hashval_t
2523 hash_stmt_list_entry (const struct stmt_list_hash *stmt_list_hash)
2524 {
2525 hashval_t v = 0;
2526
2527 if (stmt_list_hash->dwo_unit != NULL)
2528 v += (uintptr_t) stmt_list_hash->dwo_unit->dwo_file;
2529 v += stmt_list_hash->line_offset.sect_off;
2530 return v;
2531 }
2532
2533 /* Utility equality function for a stmt_list_hash. */
2534
2535 static int
2536 eq_stmt_list_entry (const struct stmt_list_hash *lhs,
2537 const struct stmt_list_hash *rhs)
2538 {
2539 if ((lhs->dwo_unit != NULL) != (rhs->dwo_unit != NULL))
2540 return 0;
2541 if (lhs->dwo_unit != NULL
2542 && lhs->dwo_unit->dwo_file != rhs->dwo_unit->dwo_file)
2543 return 0;
2544
2545 return lhs->line_offset.sect_off == rhs->line_offset.sect_off;
2546 }
2547
2548 /* Hash function for a quick_file_names. */
2549
2550 static hashval_t
2551 hash_file_name_entry (const void *e)
2552 {
2553 const struct quick_file_names *file_data = e;
2554
2555 return hash_stmt_list_entry (&file_data->hash);
2556 }
2557
2558 /* Equality function for a quick_file_names. */
2559
2560 static int
2561 eq_file_name_entry (const void *a, const void *b)
2562 {
2563 const struct quick_file_names *ea = a;
2564 const struct quick_file_names *eb = b;
2565
2566 return eq_stmt_list_entry (&ea->hash, &eb->hash);
2567 }
2568
2569 /* Delete function for a quick_file_names. */
2570
2571 static void
2572 delete_file_name_entry (void *e)
2573 {
2574 struct quick_file_names *file_data = e;
2575 int i;
2576
2577 for (i = 0; i < file_data->num_file_names; ++i)
2578 {
2579 xfree ((void*) file_data->file_names[i]);
2580 if (file_data->real_names)
2581 xfree ((void*) file_data->real_names[i]);
2582 }
2583
2584 /* The space for the struct itself lives on objfile_obstack,
2585 so we don't free it here. */
2586 }
2587
2588 /* Create a quick_file_names hash table. */
2589
2590 static htab_t
2591 create_quick_file_names_table (unsigned int nr_initial_entries)
2592 {
2593 return htab_create_alloc (nr_initial_entries,
2594 hash_file_name_entry, eq_file_name_entry,
2595 delete_file_name_entry, xcalloc, xfree);
2596 }
2597
2598 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
2599 have to be created afterwards. You should call age_cached_comp_units after
2600 processing PER_CU->CU. dw2_setup must have been already called. */
2601
2602 static void
2603 load_cu (struct dwarf2_per_cu_data *per_cu)
2604 {
2605 if (per_cu->is_debug_types)
2606 load_full_type_unit (per_cu);
2607 else
2608 load_full_comp_unit (per_cu, language_minimal);
2609
2610 gdb_assert (per_cu->cu != NULL);
2611
2612 dwarf2_find_base_address (per_cu->cu->dies, per_cu->cu);
2613 }
2614
2615 /* Read in the symbols for PER_CU. */
2616
2617 static void
2618 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data *per_cu)
2619 {
2620 struct cleanup *back_to;
2621
2622 /* Skip type_unit_groups, reading the type units they contain
2623 is handled elsewhere. */
2624 if (IS_TYPE_UNIT_GROUP (per_cu))
2625 return;
2626
2627 back_to = make_cleanup (dwarf2_release_queue, NULL);
2628
2629 if (dwarf2_per_objfile->using_index
2630 ? per_cu->v.quick->symtab == NULL
2631 : (per_cu->v.psymtab == NULL || !per_cu->v.psymtab->readin))
2632 {
2633 queue_comp_unit (per_cu, language_minimal);
2634 load_cu (per_cu);
2635
2636 /* If we just loaded a CU from a DWO, and we're working with an index
2637 that may badly handle TUs, load all the TUs in that DWO as well.
2638 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2639 if (!per_cu->is_debug_types
2640 && per_cu->cu->dwo_unit != NULL
2641 && dwarf2_per_objfile->index_table != NULL
2642 && dwarf2_per_objfile->index_table->version <= 7
2643 /* DWP files aren't supported yet. */
2644 && get_dwp_file () == NULL)
2645 queue_and_load_all_dwo_tus (per_cu);
2646 }
2647
2648 process_queue ();
2649
2650 /* Age the cache, releasing compilation units that have not
2651 been used recently. */
2652 age_cached_comp_units ();
2653
2654 do_cleanups (back_to);
2655 }
2656
2657 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2658 the objfile from which this CU came. Returns the resulting symbol
2659 table. */
2660
2661 static struct symtab *
2662 dw2_instantiate_symtab (struct dwarf2_per_cu_data *per_cu)
2663 {
2664 gdb_assert (dwarf2_per_objfile->using_index);
2665 if (!per_cu->v.quick->symtab)
2666 {
2667 struct cleanup *back_to = make_cleanup (free_cached_comp_units, NULL);
2668 increment_reading_symtab ();
2669 dw2_do_instantiate_symtab (per_cu);
2670 process_cu_includes ();
2671 do_cleanups (back_to);
2672 }
2673 return per_cu->v.quick->symtab;
2674 }
2675
2676 /* Return the CU given its index.
2677
2678 This is intended for loops like:
2679
2680 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2681 + dwarf2_per_objfile->n_type_units); ++i)
2682 {
2683 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
2684
2685 ...;
2686 }
2687 */
2688
2689 static struct dwarf2_per_cu_data *
2690 dw2_get_cu (int index)
2691 {
2692 if (index >= dwarf2_per_objfile->n_comp_units)
2693 {
2694 index -= dwarf2_per_objfile->n_comp_units;
2695 gdb_assert (index < dwarf2_per_objfile->n_type_units);
2696 return &dwarf2_per_objfile->all_type_units[index]->per_cu;
2697 }
2698
2699 return dwarf2_per_objfile->all_comp_units[index];
2700 }
2701
2702 /* Return the primary CU given its index.
2703 The difference between this function and dw2_get_cu is in the handling
2704 of type units (TUs). Here we return the type_unit_group object.
2705
2706 This is intended for loops like:
2707
2708 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2709 + dwarf2_per_objfile->n_type_unit_groups); ++i)
2710 {
2711 struct dwarf2_per_cu_data *per_cu = dw2_get_primary_cu (i);
2712
2713 ...;
2714 }
2715 */
2716
2717 static struct dwarf2_per_cu_data *
2718 dw2_get_primary_cu (int index)
2719 {
2720 if (index >= dwarf2_per_objfile->n_comp_units)
2721 {
2722 index -= dwarf2_per_objfile->n_comp_units;
2723 gdb_assert (index < dwarf2_per_objfile->n_type_unit_groups);
2724 return &dwarf2_per_objfile->all_type_unit_groups[index]->per_cu;
2725 }
2726
2727 return dwarf2_per_objfile->all_comp_units[index];
2728 }
2729
2730 /* A helper for create_cus_from_index that handles a given list of
2731 CUs. */
2732
2733 static void
2734 create_cus_from_index_list (struct objfile *objfile,
2735 const gdb_byte *cu_list, offset_type n_elements,
2736 struct dwarf2_section_info *section,
2737 int is_dwz,
2738 int base_offset)
2739 {
2740 offset_type i;
2741
2742 for (i = 0; i < n_elements; i += 2)
2743 {
2744 struct dwarf2_per_cu_data *the_cu;
2745 ULONGEST offset, length;
2746
2747 gdb_static_assert (sizeof (ULONGEST) >= 8);
2748 offset = extract_unsigned_integer (cu_list, 8, BFD_ENDIAN_LITTLE);
2749 length = extract_unsigned_integer (cu_list + 8, 8, BFD_ENDIAN_LITTLE);
2750 cu_list += 2 * 8;
2751
2752 the_cu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2753 struct dwarf2_per_cu_data);
2754 the_cu->offset.sect_off = offset;
2755 the_cu->length = length;
2756 the_cu->objfile = objfile;
2757 the_cu->section = section;
2758 the_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2759 struct dwarf2_per_cu_quick_data);
2760 the_cu->is_dwz = is_dwz;
2761 dwarf2_per_objfile->all_comp_units[base_offset + i / 2] = the_cu;
2762 }
2763 }
2764
2765 /* Read the CU list from the mapped index, and use it to create all
2766 the CU objects for this objfile. */
2767
2768 static void
2769 create_cus_from_index (struct objfile *objfile,
2770 const gdb_byte *cu_list, offset_type cu_list_elements,
2771 const gdb_byte *dwz_list, offset_type dwz_elements)
2772 {
2773 struct dwz_file *dwz;
2774
2775 dwarf2_per_objfile->n_comp_units = (cu_list_elements + dwz_elements) / 2;
2776 dwarf2_per_objfile->all_comp_units
2777 = obstack_alloc (&objfile->objfile_obstack,
2778 dwarf2_per_objfile->n_comp_units
2779 * sizeof (struct dwarf2_per_cu_data *));
2780
2781 create_cus_from_index_list (objfile, cu_list, cu_list_elements,
2782 &dwarf2_per_objfile->info, 0, 0);
2783
2784 if (dwz_elements == 0)
2785 return;
2786
2787 dwz = dwarf2_get_dwz_file ();
2788 create_cus_from_index_list (objfile, dwz_list, dwz_elements, &dwz->info, 1,
2789 cu_list_elements / 2);
2790 }
2791
2792 /* Create the signatured type hash table from the index. */
2793
2794 static void
2795 create_signatured_type_table_from_index (struct objfile *objfile,
2796 struct dwarf2_section_info *section,
2797 const gdb_byte *bytes,
2798 offset_type elements)
2799 {
2800 offset_type i;
2801 htab_t sig_types_hash;
2802
2803 dwarf2_per_objfile->n_type_units = elements / 3;
2804 dwarf2_per_objfile->all_type_units
2805 = xmalloc (dwarf2_per_objfile->n_type_units
2806 * sizeof (struct signatured_type *));
2807
2808 sig_types_hash = allocate_signatured_type_table (objfile);
2809
2810 for (i = 0; i < elements; i += 3)
2811 {
2812 struct signatured_type *sig_type;
2813 ULONGEST offset, type_offset_in_tu, signature;
2814 void **slot;
2815
2816 gdb_static_assert (sizeof (ULONGEST) >= 8);
2817 offset = extract_unsigned_integer (bytes, 8, BFD_ENDIAN_LITTLE);
2818 type_offset_in_tu = extract_unsigned_integer (bytes + 8, 8,
2819 BFD_ENDIAN_LITTLE);
2820 signature = extract_unsigned_integer (bytes + 16, 8, BFD_ENDIAN_LITTLE);
2821 bytes += 3 * 8;
2822
2823 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2824 struct signatured_type);
2825 sig_type->signature = signature;
2826 sig_type->type_offset_in_tu.cu_off = type_offset_in_tu;
2827 sig_type->per_cu.is_debug_types = 1;
2828 sig_type->per_cu.section = section;
2829 sig_type->per_cu.offset.sect_off = offset;
2830 sig_type->per_cu.objfile = objfile;
2831 sig_type->per_cu.v.quick
2832 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2833 struct dwarf2_per_cu_quick_data);
2834
2835 slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
2836 *slot = sig_type;
2837
2838 dwarf2_per_objfile->all_type_units[i / 3] = sig_type;
2839 }
2840
2841 dwarf2_per_objfile->signatured_types = sig_types_hash;
2842 }
2843
2844 /* Read the address map data from the mapped index, and use it to
2845 populate the objfile's psymtabs_addrmap. */
2846
2847 static void
2848 create_addrmap_from_index (struct objfile *objfile, struct mapped_index *index)
2849 {
2850 const gdb_byte *iter, *end;
2851 struct obstack temp_obstack;
2852 struct addrmap *mutable_map;
2853 struct cleanup *cleanup;
2854 CORE_ADDR baseaddr;
2855
2856 obstack_init (&temp_obstack);
2857 cleanup = make_cleanup_obstack_free (&temp_obstack);
2858 mutable_map = addrmap_create_mutable (&temp_obstack);
2859
2860 iter = index->address_table;
2861 end = iter + index->address_table_size;
2862
2863 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2864
2865 while (iter < end)
2866 {
2867 ULONGEST hi, lo, cu_index;
2868 lo = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
2869 iter += 8;
2870 hi = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
2871 iter += 8;
2872 cu_index = extract_unsigned_integer (iter, 4, BFD_ENDIAN_LITTLE);
2873 iter += 4;
2874
2875 if (lo > hi)
2876 {
2877 complaint (&symfile_complaints,
2878 _(".gdb_index address table has invalid range (%s - %s)"),
2879 hex_string (lo), hex_string (hi));
2880 continue;
2881 }
2882
2883 if (cu_index >= dwarf2_per_objfile->n_comp_units)
2884 {
2885 complaint (&symfile_complaints,
2886 _(".gdb_index address table has invalid CU number %u"),
2887 (unsigned) cu_index);
2888 continue;
2889 }
2890
2891 addrmap_set_empty (mutable_map, lo + baseaddr, hi + baseaddr - 1,
2892 dw2_get_cu (cu_index));
2893 }
2894
2895 objfile->psymtabs_addrmap = addrmap_create_fixed (mutable_map,
2896 &objfile->objfile_obstack);
2897 do_cleanups (cleanup);
2898 }
2899
2900 /* The hash function for strings in the mapped index. This is the same as
2901 SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
2902 implementation. This is necessary because the hash function is tied to the
2903 format of the mapped index file. The hash values do not have to match with
2904 SYMBOL_HASH_NEXT.
2905
2906 Use INT_MAX for INDEX_VERSION if you generate the current index format. */
2907
2908 static hashval_t
2909 mapped_index_string_hash (int index_version, const void *p)
2910 {
2911 const unsigned char *str = (const unsigned char *) p;
2912 hashval_t r = 0;
2913 unsigned char c;
2914
2915 while ((c = *str++) != 0)
2916 {
2917 if (index_version >= 5)
2918 c = tolower (c);
2919 r = r * 67 + c - 113;
2920 }
2921
2922 return r;
2923 }
2924
2925 /* Find a slot in the mapped index INDEX for the object named NAME.
2926 If NAME is found, set *VEC_OUT to point to the CU vector in the
2927 constant pool and return 1. If NAME cannot be found, return 0. */
2928
2929 static int
2930 find_slot_in_mapped_hash (struct mapped_index *index, const char *name,
2931 offset_type **vec_out)
2932 {
2933 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
2934 offset_type hash;
2935 offset_type slot, step;
2936 int (*cmp) (const char *, const char *);
2937
2938 if (current_language->la_language == language_cplus
2939 || current_language->la_language == language_java
2940 || current_language->la_language == language_fortran)
2941 {
2942 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2943 not contain any. */
2944 const char *paren = strchr (name, '(');
2945
2946 if (paren)
2947 {
2948 char *dup;
2949
2950 dup = xmalloc (paren - name + 1);
2951 memcpy (dup, name, paren - name);
2952 dup[paren - name] = 0;
2953
2954 make_cleanup (xfree, dup);
2955 name = dup;
2956 }
2957 }
2958
2959 /* Index version 4 did not support case insensitive searches. But the
2960 indices for case insensitive languages are built in lowercase, therefore
2961 simulate our NAME being searched is also lowercased. */
2962 hash = mapped_index_string_hash ((index->version == 4
2963 && case_sensitivity == case_sensitive_off
2964 ? 5 : index->version),
2965 name);
2966
2967 slot = hash & (index->symbol_table_slots - 1);
2968 step = ((hash * 17) & (index->symbol_table_slots - 1)) | 1;
2969 cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
2970
2971 for (;;)
2972 {
2973 /* Convert a slot number to an offset into the table. */
2974 offset_type i = 2 * slot;
2975 const char *str;
2976 if (index->symbol_table[i] == 0 && index->symbol_table[i + 1] == 0)
2977 {
2978 do_cleanups (back_to);
2979 return 0;
2980 }
2981
2982 str = index->constant_pool + MAYBE_SWAP (index->symbol_table[i]);
2983 if (!cmp (name, str))
2984 {
2985 *vec_out = (offset_type *) (index->constant_pool
2986 + MAYBE_SWAP (index->symbol_table[i + 1]));
2987 do_cleanups (back_to);
2988 return 1;
2989 }
2990
2991 slot = (slot + step) & (index->symbol_table_slots - 1);
2992 }
2993 }
2994
2995 /* A helper function that reads the .gdb_index from SECTION and fills
2996 in MAP. FILENAME is the name of the file containing the section;
2997 it is used for error reporting. DEPRECATED_OK is nonzero if it is
2998 ok to use deprecated sections.
2999
3000 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
3001 out parameters that are filled in with information about the CU and
3002 TU lists in the section.
3003
3004 Returns 1 if all went well, 0 otherwise. */
3005
3006 static int
3007 read_index_from_section (struct objfile *objfile,
3008 const char *filename,
3009 int deprecated_ok,
3010 struct dwarf2_section_info *section,
3011 struct mapped_index *map,
3012 const gdb_byte **cu_list,
3013 offset_type *cu_list_elements,
3014 const gdb_byte **types_list,
3015 offset_type *types_list_elements)
3016 {
3017 const gdb_byte *addr;
3018 offset_type version;
3019 offset_type *metadata;
3020 int i;
3021
3022 if (dwarf2_section_empty_p (section))
3023 return 0;
3024
3025 /* Older elfutils strip versions could keep the section in the main
3026 executable while splitting it for the separate debug info file. */
3027 if ((get_section_flags (section) & SEC_HAS_CONTENTS) == 0)
3028 return 0;
3029
3030 dwarf2_read_section (objfile, section);
3031
3032 addr = section->buffer;
3033 /* Version check. */
3034 version = MAYBE_SWAP (*(offset_type *) addr);
3035 /* Versions earlier than 3 emitted every copy of a psymbol. This
3036 causes the index to behave very poorly for certain requests. Version 3
3037 contained incomplete addrmap. So, it seems better to just ignore such
3038 indices. */
3039 if (version < 4)
3040 {
3041 static int warning_printed = 0;
3042 if (!warning_printed)
3043 {
3044 warning (_("Skipping obsolete .gdb_index section in %s."),
3045 filename);
3046 warning_printed = 1;
3047 }
3048 return 0;
3049 }
3050 /* Index version 4 uses a different hash function than index version
3051 5 and later.
3052
3053 Versions earlier than 6 did not emit psymbols for inlined
3054 functions. Using these files will cause GDB not to be able to
3055 set breakpoints on inlined functions by name, so we ignore these
3056 indices unless the user has done
3057 "set use-deprecated-index-sections on". */
3058 if (version < 6 && !deprecated_ok)
3059 {
3060 static int warning_printed = 0;
3061 if (!warning_printed)
3062 {
3063 warning (_("\
3064 Skipping deprecated .gdb_index section in %s.\n\
3065 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3066 to use the section anyway."),
3067 filename);
3068 warning_printed = 1;
3069 }
3070 return 0;
3071 }
3072 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3073 of the TU (for symbols coming from TUs),
3074 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3075 Plus gold-generated indices can have duplicate entries for global symbols,
3076 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3077 These are just performance bugs, and we can't distinguish gdb-generated
3078 indices from gold-generated ones, so issue no warning here. */
3079
3080 /* Indexes with higher version than the one supported by GDB may be no
3081 longer backward compatible. */
3082 if (version > 8)
3083 return 0;
3084
3085 map->version = version;
3086 map->total_size = section->size;
3087
3088 metadata = (offset_type *) (addr + sizeof (offset_type));
3089
3090 i = 0;
3091 *cu_list = addr + MAYBE_SWAP (metadata[i]);
3092 *cu_list_elements = ((MAYBE_SWAP (metadata[i + 1]) - MAYBE_SWAP (metadata[i]))
3093 / 8);
3094 ++i;
3095
3096 *types_list = addr + MAYBE_SWAP (metadata[i]);
3097 *types_list_elements = ((MAYBE_SWAP (metadata[i + 1])
3098 - MAYBE_SWAP (metadata[i]))
3099 / 8);
3100 ++i;
3101
3102 map->address_table = addr + MAYBE_SWAP (metadata[i]);
3103 map->address_table_size = (MAYBE_SWAP (metadata[i + 1])
3104 - MAYBE_SWAP (metadata[i]));
3105 ++i;
3106
3107 map->symbol_table = (offset_type *) (addr + MAYBE_SWAP (metadata[i]));
3108 map->symbol_table_slots = ((MAYBE_SWAP (metadata[i + 1])
3109 - MAYBE_SWAP (metadata[i]))
3110 / (2 * sizeof (offset_type)));
3111 ++i;
3112
3113 map->constant_pool = (char *) (addr + MAYBE_SWAP (metadata[i]));
3114
3115 return 1;
3116 }
3117
3118
3119 /* Read the index file. If everything went ok, initialize the "quick"
3120 elements of all the CUs and return 1. Otherwise, return 0. */
3121
3122 static int
3123 dwarf2_read_index (struct objfile *objfile)
3124 {
3125 struct mapped_index local_map, *map;
3126 const gdb_byte *cu_list, *types_list, *dwz_list = NULL;
3127 offset_type cu_list_elements, types_list_elements, dwz_list_elements = 0;
3128 struct dwz_file *dwz;
3129
3130 if (!read_index_from_section (objfile, objfile_name (objfile),
3131 use_deprecated_index_sections,
3132 &dwarf2_per_objfile->gdb_index, &local_map,
3133 &cu_list, &cu_list_elements,
3134 &types_list, &types_list_elements))
3135 return 0;
3136
3137 /* Don't use the index if it's empty. */
3138 if (local_map.symbol_table_slots == 0)
3139 return 0;
3140
3141 /* If there is a .dwz file, read it so we can get its CU list as
3142 well. */
3143 dwz = dwarf2_get_dwz_file ();
3144 if (dwz != NULL)
3145 {
3146 struct mapped_index dwz_map;
3147 const gdb_byte *dwz_types_ignore;
3148 offset_type dwz_types_elements_ignore;
3149
3150 if (!read_index_from_section (objfile, bfd_get_filename (dwz->dwz_bfd),
3151 1,
3152 &dwz->gdb_index, &dwz_map,
3153 &dwz_list, &dwz_list_elements,
3154 &dwz_types_ignore,
3155 &dwz_types_elements_ignore))
3156 {
3157 warning (_("could not read '.gdb_index' section from %s; skipping"),
3158 bfd_get_filename (dwz->dwz_bfd));
3159 return 0;
3160 }
3161 }
3162
3163 create_cus_from_index (objfile, cu_list, cu_list_elements, dwz_list,
3164 dwz_list_elements);
3165
3166 if (types_list_elements)
3167 {
3168 struct dwarf2_section_info *section;
3169
3170 /* We can only handle a single .debug_types when we have an
3171 index. */
3172 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) != 1)
3173 return 0;
3174
3175 section = VEC_index (dwarf2_section_info_def,
3176 dwarf2_per_objfile->types, 0);
3177
3178 create_signatured_type_table_from_index (objfile, section, types_list,
3179 types_list_elements);
3180 }
3181
3182 create_addrmap_from_index (objfile, &local_map);
3183
3184 map = obstack_alloc (&objfile->objfile_obstack, sizeof (struct mapped_index));
3185 *map = local_map;
3186
3187 dwarf2_per_objfile->index_table = map;
3188 dwarf2_per_objfile->using_index = 1;
3189 dwarf2_per_objfile->quick_file_names_table =
3190 create_quick_file_names_table (dwarf2_per_objfile->n_comp_units);
3191
3192 return 1;
3193 }
3194
3195 /* A helper for the "quick" functions which sets the global
3196 dwarf2_per_objfile according to OBJFILE. */
3197
3198 static void
3199 dw2_setup (struct objfile *objfile)
3200 {
3201 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
3202 gdb_assert (dwarf2_per_objfile);
3203 }
3204
3205 /* die_reader_func for dw2_get_file_names. */
3206
3207 static void
3208 dw2_get_file_names_reader (const struct die_reader_specs *reader,
3209 const gdb_byte *info_ptr,
3210 struct die_info *comp_unit_die,
3211 int has_children,
3212 void *data)
3213 {
3214 struct dwarf2_cu *cu = reader->cu;
3215 struct dwarf2_per_cu_data *this_cu = cu->per_cu;
3216 struct objfile *objfile = dwarf2_per_objfile->objfile;
3217 struct dwarf2_per_cu_data *lh_cu;
3218 struct line_header *lh;
3219 struct attribute *attr;
3220 int i;
3221 const char *name, *comp_dir;
3222 void **slot;
3223 struct quick_file_names *qfn;
3224 unsigned int line_offset;
3225
3226 gdb_assert (! this_cu->is_debug_types);
3227
3228 /* Our callers never want to match partial units -- instead they
3229 will match the enclosing full CU. */
3230 if (comp_unit_die->tag == DW_TAG_partial_unit)
3231 {
3232 this_cu->v.quick->no_file_data = 1;
3233 return;
3234 }
3235
3236 lh_cu = this_cu;
3237 lh = NULL;
3238 slot = NULL;
3239 line_offset = 0;
3240
3241 attr = dwarf2_attr (comp_unit_die, DW_AT_stmt_list, cu);
3242 if (attr)
3243 {
3244 struct quick_file_names find_entry;
3245
3246 line_offset = DW_UNSND (attr);
3247
3248 /* We may have already read in this line header (TU line header sharing).
3249 If we have we're done. */
3250 find_entry.hash.dwo_unit = cu->dwo_unit;
3251 find_entry.hash.line_offset.sect_off = line_offset;
3252 slot = htab_find_slot (dwarf2_per_objfile->quick_file_names_table,
3253 &find_entry, INSERT);
3254 if (*slot != NULL)
3255 {
3256 lh_cu->v.quick->file_names = *slot;
3257 return;
3258 }
3259
3260 lh = dwarf_decode_line_header (line_offset, cu);
3261 }
3262 if (lh == NULL)
3263 {
3264 lh_cu->v.quick->no_file_data = 1;
3265 return;
3266 }
3267
3268 qfn = obstack_alloc (&objfile->objfile_obstack, sizeof (*qfn));
3269 qfn->hash.dwo_unit = cu->dwo_unit;
3270 qfn->hash.line_offset.sect_off = line_offset;
3271 gdb_assert (slot != NULL);
3272 *slot = qfn;
3273
3274 find_file_and_directory (comp_unit_die, cu, &name, &comp_dir);
3275
3276 qfn->num_file_names = lh->num_file_names;
3277 qfn->file_names = obstack_alloc (&objfile->objfile_obstack,
3278 lh->num_file_names * sizeof (char *));
3279 for (i = 0; i < lh->num_file_names; ++i)
3280 qfn->file_names[i] = file_full_name (i + 1, lh, comp_dir);
3281 qfn->real_names = NULL;
3282
3283 free_line_header (lh);
3284
3285 lh_cu->v.quick->file_names = qfn;
3286 }
3287
3288 /* A helper for the "quick" functions which attempts to read the line
3289 table for THIS_CU. */
3290
3291 static struct quick_file_names *
3292 dw2_get_file_names (struct dwarf2_per_cu_data *this_cu)
3293 {
3294 /* This should never be called for TUs. */
3295 gdb_assert (! this_cu->is_debug_types);
3296 /* Nor type unit groups. */
3297 gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu));
3298
3299 if (this_cu->v.quick->file_names != NULL)
3300 return this_cu->v.quick->file_names;
3301 /* If we know there is no line data, no point in looking again. */
3302 if (this_cu->v.quick->no_file_data)
3303 return NULL;
3304
3305 init_cutu_and_read_dies_simple (this_cu, dw2_get_file_names_reader, NULL);
3306
3307 if (this_cu->v.quick->no_file_data)
3308 return NULL;
3309 return this_cu->v.quick->file_names;
3310 }
3311
3312 /* A helper for the "quick" functions which computes and caches the
3313 real path for a given file name from the line table. */
3314
3315 static const char *
3316 dw2_get_real_path (struct objfile *objfile,
3317 struct quick_file_names *qfn, int index)
3318 {
3319 if (qfn->real_names == NULL)
3320 qfn->real_names = OBSTACK_CALLOC (&objfile->objfile_obstack,
3321 qfn->num_file_names, char *);
3322
3323 if (qfn->real_names[index] == NULL)
3324 qfn->real_names[index] = gdb_realpath (qfn->file_names[index]);
3325
3326 return qfn->real_names[index];
3327 }
3328
3329 static struct symtab *
3330 dw2_find_last_source_symtab (struct objfile *objfile)
3331 {
3332 int index;
3333
3334 dw2_setup (objfile);
3335 index = dwarf2_per_objfile->n_comp_units - 1;
3336 return dw2_instantiate_symtab (dw2_get_cu (index));
3337 }
3338
3339 /* Traversal function for dw2_forget_cached_source_info. */
3340
3341 static int
3342 dw2_free_cached_file_names (void **slot, void *info)
3343 {
3344 struct quick_file_names *file_data = (struct quick_file_names *) *slot;
3345
3346 if (file_data->real_names)
3347 {
3348 int i;
3349
3350 for (i = 0; i < file_data->num_file_names; ++i)
3351 {
3352 xfree ((void*) file_data->real_names[i]);
3353 file_data->real_names[i] = NULL;
3354 }
3355 }
3356
3357 return 1;
3358 }
3359
3360 static void
3361 dw2_forget_cached_source_info (struct objfile *objfile)
3362 {
3363 dw2_setup (objfile);
3364
3365 htab_traverse_noresize (dwarf2_per_objfile->quick_file_names_table,
3366 dw2_free_cached_file_names, NULL);
3367 }
3368
3369 /* Helper function for dw2_map_symtabs_matching_filename that expands
3370 the symtabs and calls the iterator. */
3371
3372 static int
3373 dw2_map_expand_apply (struct objfile *objfile,
3374 struct dwarf2_per_cu_data *per_cu,
3375 const char *name, const char *real_path,
3376 int (*callback) (struct symtab *, void *),
3377 void *data)
3378 {
3379 struct symtab *last_made = objfile->symtabs;
3380
3381 /* Don't visit already-expanded CUs. */
3382 if (per_cu->v.quick->symtab)
3383 return 0;
3384
3385 /* This may expand more than one symtab, and we want to iterate over
3386 all of them. */
3387 dw2_instantiate_symtab (per_cu);
3388
3389 return iterate_over_some_symtabs (name, real_path, callback, data,
3390 objfile->symtabs, last_made);
3391 }
3392
3393 /* Implementation of the map_symtabs_matching_filename method. */
3394
3395 static int
3396 dw2_map_symtabs_matching_filename (struct objfile *objfile, const char *name,
3397 const char *real_path,
3398 int (*callback) (struct symtab *, void *),
3399 void *data)
3400 {
3401 int i;
3402 const char *name_basename = lbasename (name);
3403
3404 dw2_setup (objfile);
3405
3406 /* The rule is CUs specify all the files, including those used by
3407 any TU, so there's no need to scan TUs here. */
3408
3409 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
3410 {
3411 int j;
3412 struct dwarf2_per_cu_data *per_cu = dw2_get_primary_cu (i);
3413 struct quick_file_names *file_data;
3414
3415 /* We only need to look at symtabs not already expanded. */
3416 if (per_cu->v.quick->symtab)
3417 continue;
3418
3419 file_data = dw2_get_file_names (per_cu);
3420 if (file_data == NULL)
3421 continue;
3422
3423 for (j = 0; j < file_data->num_file_names; ++j)
3424 {
3425 const char *this_name = file_data->file_names[j];
3426 const char *this_real_name;
3427
3428 if (compare_filenames_for_search (this_name, name))
3429 {
3430 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3431 callback, data))
3432 return 1;
3433 continue;
3434 }
3435
3436 /* Before we invoke realpath, which can get expensive when many
3437 files are involved, do a quick comparison of the basenames. */
3438 if (! basenames_may_differ
3439 && FILENAME_CMP (lbasename (this_name), name_basename) != 0)
3440 continue;
3441
3442 this_real_name = dw2_get_real_path (objfile, file_data, j);
3443 if (compare_filenames_for_search (this_real_name, name))
3444 {
3445 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3446 callback, data))
3447 return 1;
3448 continue;
3449 }
3450
3451 if (real_path != NULL)
3452 {
3453 gdb_assert (IS_ABSOLUTE_PATH (real_path));
3454 gdb_assert (IS_ABSOLUTE_PATH (name));
3455 if (this_real_name != NULL
3456 && FILENAME_CMP (real_path, this_real_name) == 0)
3457 {
3458 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3459 callback, data))
3460 return 1;
3461 continue;
3462 }
3463 }
3464 }
3465 }
3466
3467 return 0;
3468 }
3469
3470 /* Struct used to manage iterating over all CUs looking for a symbol. */
3471
3472 struct dw2_symtab_iterator
3473 {
3474 /* The internalized form of .gdb_index. */
3475 struct mapped_index *index;
3476 /* If non-zero, only look for symbols that match BLOCK_INDEX. */
3477 int want_specific_block;
3478 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
3479 Unused if !WANT_SPECIFIC_BLOCK. */
3480 int block_index;
3481 /* The kind of symbol we're looking for. */
3482 domain_enum domain;
3483 /* The list of CUs from the index entry of the symbol,
3484 or NULL if not found. */
3485 offset_type *vec;
3486 /* The next element in VEC to look at. */
3487 int next;
3488 /* The number of elements in VEC, or zero if there is no match. */
3489 int length;
3490 /* Have we seen a global version of the symbol?
3491 If so we can ignore all further global instances.
3492 This is to work around gold/15646, inefficient gold-generated
3493 indices. */
3494 int global_seen;
3495 };
3496
3497 /* Initialize the index symtab iterator ITER.
3498 If WANT_SPECIFIC_BLOCK is non-zero, only look for symbols
3499 in block BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
3500
3501 static void
3502 dw2_symtab_iter_init (struct dw2_symtab_iterator *iter,
3503 struct mapped_index *index,
3504 int want_specific_block,
3505 int block_index,
3506 domain_enum domain,
3507 const char *name)
3508 {
3509 iter->index = index;
3510 iter->want_specific_block = want_specific_block;
3511 iter->block_index = block_index;
3512 iter->domain = domain;
3513 iter->next = 0;
3514 iter->global_seen = 0;
3515
3516 if (find_slot_in_mapped_hash (index, name, &iter->vec))
3517 iter->length = MAYBE_SWAP (*iter->vec);
3518 else
3519 {
3520 iter->vec = NULL;
3521 iter->length = 0;
3522 }
3523 }
3524
3525 /* Return the next matching CU or NULL if there are no more. */
3526
3527 static struct dwarf2_per_cu_data *
3528 dw2_symtab_iter_next (struct dw2_symtab_iterator *iter)
3529 {
3530 for ( ; iter->next < iter->length; ++iter->next)
3531 {
3532 offset_type cu_index_and_attrs =
3533 MAYBE_SWAP (iter->vec[iter->next + 1]);
3534 offset_type cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
3535 struct dwarf2_per_cu_data *per_cu;
3536 int want_static = iter->block_index != GLOBAL_BLOCK;
3537 /* This value is only valid for index versions >= 7. */
3538 int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
3539 gdb_index_symbol_kind symbol_kind =
3540 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
3541 /* Only check the symbol attributes if they're present.
3542 Indices prior to version 7 don't record them,
3543 and indices >= 7 may elide them for certain symbols
3544 (gold does this). */
3545 int attrs_valid =
3546 (iter->index->version >= 7
3547 && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
3548
3549 /* Don't crash on bad data. */
3550 if (cu_index >= (dwarf2_per_objfile->n_comp_units
3551 + dwarf2_per_objfile->n_type_units))
3552 {
3553 complaint (&symfile_complaints,
3554 _(".gdb_index entry has bad CU index"
3555 " [in module %s]"),
3556 objfile_name (dwarf2_per_objfile->objfile));
3557 continue;
3558 }
3559
3560 per_cu = dw2_get_cu (cu_index);
3561
3562 /* Skip if already read in. */
3563 if (per_cu->v.quick->symtab)
3564 continue;
3565
3566 /* Check static vs global. */
3567 if (attrs_valid)
3568 {
3569 if (iter->want_specific_block
3570 && want_static != is_static)
3571 continue;
3572 /* Work around gold/15646. */
3573 if (!is_static && iter->global_seen)
3574 continue;
3575 if (!is_static)
3576 iter->global_seen = 1;
3577 }
3578
3579 /* Only check the symbol's kind if it has one. */
3580 if (attrs_valid)
3581 {
3582 switch (iter->domain)
3583 {
3584 case VAR_DOMAIN:
3585 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE
3586 && symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION
3587 /* Some types are also in VAR_DOMAIN. */
3588 && symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
3589 continue;
3590 break;
3591 case STRUCT_DOMAIN:
3592 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
3593 continue;
3594 break;
3595 case LABEL_DOMAIN:
3596 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_OTHER)
3597 continue;
3598 break;
3599 default:
3600 break;
3601 }
3602 }
3603
3604 ++iter->next;
3605 return per_cu;
3606 }
3607
3608 return NULL;
3609 }
3610
3611 static struct symtab *
3612 dw2_lookup_symbol (struct objfile *objfile, int block_index,
3613 const char *name, domain_enum domain)
3614 {
3615 struct symtab *stab_best = NULL;
3616 struct mapped_index *index;
3617
3618 dw2_setup (objfile);
3619
3620 index = dwarf2_per_objfile->index_table;
3621
3622 /* index is NULL if OBJF_READNOW. */
3623 if (index)
3624 {
3625 struct dw2_symtab_iterator iter;
3626 struct dwarf2_per_cu_data *per_cu;
3627
3628 dw2_symtab_iter_init (&iter, index, 1, block_index, domain, name);
3629
3630 while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
3631 {
3632 struct symbol *sym = NULL;
3633 struct symtab *stab = dw2_instantiate_symtab (per_cu);
3634
3635 /* Some caution must be observed with overloaded functions
3636 and methods, since the index will not contain any overload
3637 information (but NAME might contain it). */
3638 if (stab->primary)
3639 {
3640 struct blockvector *bv = BLOCKVECTOR (stab);
3641 struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
3642
3643 sym = lookup_block_symbol (block, name, domain);
3644 }
3645
3646 if (sym && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
3647 {
3648 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
3649 return stab;
3650
3651 stab_best = stab;
3652 }
3653
3654 /* Keep looking through other CUs. */
3655 }
3656 }
3657
3658 return stab_best;
3659 }
3660
3661 static void
3662 dw2_print_stats (struct objfile *objfile)
3663 {
3664 int i, total, count;
3665
3666 dw2_setup (objfile);
3667 total = dwarf2_per_objfile->n_comp_units + dwarf2_per_objfile->n_type_units;
3668 count = 0;
3669 for (i = 0; i < total; ++i)
3670 {
3671 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
3672
3673 if (!per_cu->v.quick->symtab)
3674 ++count;
3675 }
3676 printf_filtered (_(" Number of read CUs: %d\n"), total - count);
3677 printf_filtered (_(" Number of unread CUs: %d\n"), count);
3678 }
3679
3680 /* This dumps minimal information about the index.
3681 It is called via "mt print objfiles".
3682 One use is to verify .gdb_index has been loaded by the
3683 gdb.dwarf2/gdb-index.exp testcase. */
3684
3685 static void
3686 dw2_dump (struct objfile *objfile)
3687 {
3688 dw2_setup (objfile);
3689 gdb_assert (dwarf2_per_objfile->using_index);
3690 printf_filtered (".gdb_index:");
3691 if (dwarf2_per_objfile->index_table != NULL)
3692 {
3693 printf_filtered (" version %d\n",
3694 dwarf2_per_objfile->index_table->version);
3695 }
3696 else
3697 printf_filtered (" faked for \"readnow\"\n");
3698 printf_filtered ("\n");
3699 }
3700
3701 static void
3702 dw2_relocate (struct objfile *objfile,
3703 const struct section_offsets *new_offsets,
3704 const struct section_offsets *delta)
3705 {
3706 /* There's nothing to relocate here. */
3707 }
3708
3709 static void
3710 dw2_expand_symtabs_for_function (struct objfile *objfile,
3711 const char *func_name)
3712 {
3713 struct mapped_index *index;
3714
3715 dw2_setup (objfile);
3716
3717 index = dwarf2_per_objfile->index_table;
3718
3719 /* index is NULL if OBJF_READNOW. */
3720 if (index)
3721 {
3722 struct dw2_symtab_iterator iter;
3723 struct dwarf2_per_cu_data *per_cu;
3724
3725 /* Note: It doesn't matter what we pass for block_index here. */
3726 dw2_symtab_iter_init (&iter, index, 0, GLOBAL_BLOCK, VAR_DOMAIN,
3727 func_name);
3728
3729 while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
3730 dw2_instantiate_symtab (per_cu);
3731 }
3732 }
3733
3734 static void
3735 dw2_expand_all_symtabs (struct objfile *objfile)
3736 {
3737 int i;
3738
3739 dw2_setup (objfile);
3740
3741 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
3742 + dwarf2_per_objfile->n_type_units); ++i)
3743 {
3744 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
3745
3746 dw2_instantiate_symtab (per_cu);
3747 }
3748 }
3749
3750 static void
3751 dw2_expand_symtabs_with_fullname (struct objfile *objfile,
3752 const char *fullname)
3753 {
3754 int i;
3755
3756 dw2_setup (objfile);
3757
3758 /* We don't need to consider type units here.
3759 This is only called for examining code, e.g. expand_line_sal.
3760 There can be an order of magnitude (or more) more type units
3761 than comp units, and we avoid them if we can. */
3762
3763 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
3764 {
3765 int j;
3766 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
3767 struct quick_file_names *file_data;
3768
3769 /* We only need to look at symtabs not already expanded. */
3770 if (per_cu->v.quick->symtab)
3771 continue;
3772
3773 file_data = dw2_get_file_names (per_cu);
3774 if (file_data == NULL)
3775 continue;
3776
3777 for (j = 0; j < file_data->num_file_names; ++j)
3778 {
3779 const char *this_fullname = file_data->file_names[j];
3780
3781 if (filename_cmp (this_fullname, fullname) == 0)
3782 {
3783 dw2_instantiate_symtab (per_cu);
3784 break;
3785 }
3786 }
3787 }
3788 }
3789
3790 static void
3791 dw2_map_matching_symbols (struct objfile *objfile,
3792 const char * name, domain_enum namespace,
3793 int global,
3794 int (*callback) (struct block *,
3795 struct symbol *, void *),
3796 void *data, symbol_compare_ftype *match,
3797 symbol_compare_ftype *ordered_compare)
3798 {
3799 /* Currently unimplemented; used for Ada. The function can be called if the
3800 current language is Ada for a non-Ada objfile using GNU index. As Ada
3801 does not look for non-Ada symbols this function should just return. */
3802 }
3803
3804 static void
3805 dw2_expand_symtabs_matching
3806 (struct objfile *objfile,
3807 expand_symtabs_file_matcher_ftype *file_matcher,
3808 expand_symtabs_symbol_matcher_ftype *symbol_matcher,
3809 enum search_domain kind,
3810 void *data)
3811 {
3812 int i;
3813 offset_type iter;
3814 struct mapped_index *index;
3815
3816 dw2_setup (objfile);
3817
3818 /* index_table is NULL if OBJF_READNOW. */
3819 if (!dwarf2_per_objfile->index_table)
3820 return;
3821 index = dwarf2_per_objfile->index_table;
3822
3823 if (file_matcher != NULL)
3824 {
3825 struct cleanup *cleanup;
3826 htab_t visited_found, visited_not_found;
3827
3828 visited_found = htab_create_alloc (10,
3829 htab_hash_pointer, htab_eq_pointer,
3830 NULL, xcalloc, xfree);
3831 cleanup = make_cleanup_htab_delete (visited_found);
3832 visited_not_found = htab_create_alloc (10,
3833 htab_hash_pointer, htab_eq_pointer,
3834 NULL, xcalloc, xfree);
3835 make_cleanup_htab_delete (visited_not_found);
3836
3837 /* The rule is CUs specify all the files, including those used by
3838 any TU, so there's no need to scan TUs here. */
3839
3840 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
3841 {
3842 int j;
3843 struct dwarf2_per_cu_data *per_cu = dw2_get_primary_cu (i);
3844 struct quick_file_names *file_data;
3845 void **slot;
3846
3847 per_cu->v.quick->mark = 0;
3848
3849 /* We only need to look at symtabs not already expanded. */
3850 if (per_cu->v.quick->symtab)
3851 continue;
3852
3853 file_data = dw2_get_file_names (per_cu);
3854 if (file_data == NULL)
3855 continue;
3856
3857 if (htab_find (visited_not_found, file_data) != NULL)
3858 continue;
3859 else if (htab_find (visited_found, file_data) != NULL)
3860 {
3861 per_cu->v.quick->mark = 1;
3862 continue;
3863 }
3864
3865 for (j = 0; j < file_data->num_file_names; ++j)
3866 {
3867 const char *this_real_name;
3868
3869 if (file_matcher (file_data->file_names[j], data, 0))
3870 {
3871 per_cu->v.quick->mark = 1;
3872 break;
3873 }
3874
3875 /* Before we invoke realpath, which can get expensive when many
3876 files are involved, do a quick comparison of the basenames. */
3877 if (!basenames_may_differ
3878 && !file_matcher (lbasename (file_data->file_names[j]),
3879 data, 1))
3880 continue;
3881
3882 this_real_name = dw2_get_real_path (objfile, file_data, j);
3883 if (file_matcher (this_real_name, data, 0))
3884 {
3885 per_cu->v.quick->mark = 1;
3886 break;
3887 }
3888 }
3889
3890 slot = htab_find_slot (per_cu->v.quick->mark
3891 ? visited_found
3892 : visited_not_found,
3893 file_data, INSERT);
3894 *slot = file_data;
3895 }
3896
3897 do_cleanups (cleanup);
3898 }
3899
3900 for (iter = 0; iter < index->symbol_table_slots; ++iter)
3901 {
3902 offset_type idx = 2 * iter;
3903 const char *name;
3904 offset_type *vec, vec_len, vec_idx;
3905 int global_seen = 0;
3906
3907 if (index->symbol_table[idx] == 0 && index->symbol_table[idx + 1] == 0)
3908 continue;
3909
3910 name = index->constant_pool + MAYBE_SWAP (index->symbol_table[idx]);
3911
3912 if (! (*symbol_matcher) (name, data))
3913 continue;
3914
3915 /* The name was matched, now expand corresponding CUs that were
3916 marked. */
3917 vec = (offset_type *) (index->constant_pool
3918 + MAYBE_SWAP (index->symbol_table[idx + 1]));
3919 vec_len = MAYBE_SWAP (vec[0]);
3920 for (vec_idx = 0; vec_idx < vec_len; ++vec_idx)
3921 {
3922 struct dwarf2_per_cu_data *per_cu;
3923 offset_type cu_index_and_attrs = MAYBE_SWAP (vec[vec_idx + 1]);
3924 /* This value is only valid for index versions >= 7. */
3925 int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
3926 gdb_index_symbol_kind symbol_kind =
3927 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
3928 int cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
3929 /* Only check the symbol attributes if they're present.
3930 Indices prior to version 7 don't record them,
3931 and indices >= 7 may elide them for certain symbols
3932 (gold does this). */
3933 int attrs_valid =
3934 (index->version >= 7
3935 && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
3936
3937 /* Work around gold/15646. */
3938 if (attrs_valid)
3939 {
3940 if (!is_static && global_seen)
3941 continue;
3942 if (!is_static)
3943 global_seen = 1;
3944 }
3945
3946 /* Only check the symbol's kind if it has one. */
3947 if (attrs_valid)
3948 {
3949 switch (kind)
3950 {
3951 case VARIABLES_DOMAIN:
3952 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE)
3953 continue;
3954 break;
3955 case FUNCTIONS_DOMAIN:
3956 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION)
3957 continue;
3958 break;
3959 case TYPES_DOMAIN:
3960 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
3961 continue;
3962 break;
3963 default:
3964 break;
3965 }
3966 }
3967
3968 /* Don't crash on bad data. */
3969 if (cu_index >= (dwarf2_per_objfile->n_comp_units
3970 + dwarf2_per_objfile->n_type_units))
3971 {
3972 complaint (&symfile_complaints,
3973 _(".gdb_index entry has bad CU index"
3974 " [in module %s]"), objfile_name (objfile));
3975 continue;
3976 }
3977
3978 per_cu = dw2_get_cu (cu_index);
3979 if (file_matcher == NULL || per_cu->v.quick->mark)
3980 dw2_instantiate_symtab (per_cu);
3981 }
3982 }
3983 }
3984
3985 /* A helper for dw2_find_pc_sect_symtab which finds the most specific
3986 symtab. */
3987
3988 static struct symtab *
3989 recursively_find_pc_sect_symtab (struct symtab *symtab, CORE_ADDR pc)
3990 {
3991 int i;
3992
3993 if (BLOCKVECTOR (symtab) != NULL
3994 && blockvector_contains_pc (BLOCKVECTOR (symtab), pc))
3995 return symtab;
3996
3997 if (symtab->includes == NULL)
3998 return NULL;
3999
4000 for (i = 0; symtab->includes[i]; ++i)
4001 {
4002 struct symtab *s = symtab->includes[i];
4003
4004 s = recursively_find_pc_sect_symtab (s, pc);
4005 if (s != NULL)
4006 return s;
4007 }
4008
4009 return NULL;
4010 }
4011
4012 static struct symtab *
4013 dw2_find_pc_sect_symtab (struct objfile *objfile,
4014 struct bound_minimal_symbol msymbol,
4015 CORE_ADDR pc,
4016 struct obj_section *section,
4017 int warn_if_readin)
4018 {
4019 struct dwarf2_per_cu_data *data;
4020 struct symtab *result;
4021
4022 dw2_setup (objfile);
4023
4024 if (!objfile->psymtabs_addrmap)
4025 return NULL;
4026
4027 data = addrmap_find (objfile->psymtabs_addrmap, pc);
4028 if (!data)
4029 return NULL;
4030
4031 if (warn_if_readin && data->v.quick->symtab)
4032 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
4033 paddress (get_objfile_arch (objfile), pc));
4034
4035 result = recursively_find_pc_sect_symtab (dw2_instantiate_symtab (data), pc);
4036 gdb_assert (result != NULL);
4037 return result;
4038 }
4039
4040 static void
4041 dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun,
4042 void *data, int need_fullname)
4043 {
4044 int i;
4045 struct cleanup *cleanup;
4046 htab_t visited = htab_create_alloc (10, htab_hash_pointer, htab_eq_pointer,
4047 NULL, xcalloc, xfree);
4048
4049 cleanup = make_cleanup_htab_delete (visited);
4050 dw2_setup (objfile);
4051
4052 /* The rule is CUs specify all the files, including those used by
4053 any TU, so there's no need to scan TUs here.
4054 We can ignore file names coming from already-expanded CUs. */
4055
4056 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
4057 {
4058 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
4059
4060 if (per_cu->v.quick->symtab)
4061 {
4062 void **slot = htab_find_slot (visited, per_cu->v.quick->file_names,
4063 INSERT);
4064
4065 *slot = per_cu->v.quick->file_names;
4066 }
4067 }
4068
4069 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
4070 {
4071 int j;
4072 struct dwarf2_per_cu_data *per_cu = dw2_get_primary_cu (i);
4073 struct quick_file_names *file_data;
4074 void **slot;
4075
4076 /* We only need to look at symtabs not already expanded. */
4077 if (per_cu->v.quick->symtab)
4078 continue;
4079
4080 file_data = dw2_get_file_names (per_cu);
4081 if (file_data == NULL)
4082 continue;
4083
4084 slot = htab_find_slot (visited, file_data, INSERT);
4085 if (*slot)
4086 {
4087 /* Already visited. */
4088 continue;
4089 }
4090 *slot = file_data;
4091
4092 for (j = 0; j < file_data->num_file_names; ++j)
4093 {
4094 const char *this_real_name;
4095
4096 if (need_fullname)
4097 this_real_name = dw2_get_real_path (objfile, file_data, j);
4098 else
4099 this_real_name = NULL;
4100 (*fun) (file_data->file_names[j], this_real_name, data);
4101 }
4102 }
4103
4104 do_cleanups (cleanup);
4105 }
4106
4107 static int
4108 dw2_has_symbols (struct objfile *objfile)
4109 {
4110 return 1;
4111 }
4112
4113 const struct quick_symbol_functions dwarf2_gdb_index_functions =
4114 {
4115 dw2_has_symbols,
4116 dw2_find_last_source_symtab,
4117 dw2_forget_cached_source_info,
4118 dw2_map_symtabs_matching_filename,
4119 dw2_lookup_symbol,
4120 dw2_print_stats,
4121 dw2_dump,
4122 dw2_relocate,
4123 dw2_expand_symtabs_for_function,
4124 dw2_expand_all_symtabs,
4125 dw2_expand_symtabs_with_fullname,
4126 dw2_map_matching_symbols,
4127 dw2_expand_symtabs_matching,
4128 dw2_find_pc_sect_symtab,
4129 dw2_map_symbol_filenames
4130 };
4131
4132 /* Initialize for reading DWARF for this objfile. Return 0 if this
4133 file will use psymtabs, or 1 if using the GNU index. */
4134
4135 int
4136 dwarf2_initialize_objfile (struct objfile *objfile)
4137 {
4138 /* If we're about to read full symbols, don't bother with the
4139 indices. In this case we also don't care if some other debug
4140 format is making psymtabs, because they are all about to be
4141 expanded anyway. */
4142 if ((objfile->flags & OBJF_READNOW))
4143 {
4144 int i;
4145
4146 dwarf2_per_objfile->using_index = 1;
4147 create_all_comp_units (objfile);
4148 create_all_type_units (objfile);
4149 dwarf2_per_objfile->quick_file_names_table =
4150 create_quick_file_names_table (dwarf2_per_objfile->n_comp_units);
4151
4152 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
4153 + dwarf2_per_objfile->n_type_units); ++i)
4154 {
4155 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
4156
4157 per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
4158 struct dwarf2_per_cu_quick_data);
4159 }
4160
4161 /* Return 1 so that gdb sees the "quick" functions. However,
4162 these functions will be no-ops because we will have expanded
4163 all symtabs. */
4164 return 1;
4165 }
4166
4167 if (dwarf2_read_index (objfile))
4168 return 1;
4169
4170 return 0;
4171 }
4172
4173 \f
4174
4175 /* Build a partial symbol table. */
4176
4177 void
4178 dwarf2_build_psymtabs (struct objfile *objfile)
4179 {
4180 volatile struct gdb_exception except;
4181
4182 if (objfile->global_psymbols.size == 0 && objfile->static_psymbols.size == 0)
4183 {
4184 init_psymbol_list (objfile, 1024);
4185 }
4186
4187 TRY_CATCH (except, RETURN_MASK_ERROR)
4188 {
4189 /* This isn't really ideal: all the data we allocate on the
4190 objfile's obstack is still uselessly kept around. However,
4191 freeing it seems unsafe. */
4192 struct cleanup *cleanups = make_cleanup_discard_psymtabs (objfile);
4193
4194 dwarf2_build_psymtabs_hard (objfile);
4195 discard_cleanups (cleanups);
4196 }
4197 if (except.reason < 0)
4198 exception_print (gdb_stderr, except);
4199 }
4200
4201 /* Return the total length of the CU described by HEADER. */
4202
4203 static unsigned int
4204 get_cu_length (const struct comp_unit_head *header)
4205 {
4206 return header->initial_length_size + header->length;
4207 }
4208
4209 /* Return TRUE if OFFSET is within CU_HEADER. */
4210
4211 static inline int
4212 offset_in_cu_p (const struct comp_unit_head *cu_header, sect_offset offset)
4213 {
4214 sect_offset bottom = { cu_header->offset.sect_off };
4215 sect_offset top = { cu_header->offset.sect_off + get_cu_length (cu_header) };
4216
4217 return (offset.sect_off >= bottom.sect_off && offset.sect_off < top.sect_off);
4218 }
4219
4220 /* Find the base address of the compilation unit for range lists and
4221 location lists. It will normally be specified by DW_AT_low_pc.
4222 In DWARF-3 draft 4, the base address could be overridden by
4223 DW_AT_entry_pc. It's been removed, but GCC still uses this for
4224 compilation units with discontinuous ranges. */
4225
4226 static void
4227 dwarf2_find_base_address (struct die_info *die, struct dwarf2_cu *cu)
4228 {
4229 struct attribute *attr;
4230
4231 cu->base_known = 0;
4232 cu->base_address = 0;
4233
4234 attr = dwarf2_attr (die, DW_AT_entry_pc, cu);
4235 if (attr)
4236 {
4237 cu->base_address = attr_value_as_address (attr);
4238 cu->base_known = 1;
4239 }
4240 else
4241 {
4242 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
4243 if (attr)
4244 {
4245 cu->base_address = attr_value_as_address (attr);
4246 cu->base_known = 1;
4247 }
4248 }
4249 }
4250
4251 /* Read in the comp unit header information from the debug_info at info_ptr.
4252 NOTE: This leaves members offset, first_die_offset to be filled in
4253 by the caller. */
4254
4255 static const gdb_byte *
4256 read_comp_unit_head (struct comp_unit_head *cu_header,
4257 const gdb_byte *info_ptr, bfd *abfd)
4258 {
4259 int signed_addr;
4260 unsigned int bytes_read;
4261
4262 cu_header->length = read_initial_length (abfd, info_ptr, &bytes_read);
4263 cu_header->initial_length_size = bytes_read;
4264 cu_header->offset_size = (bytes_read == 4) ? 4 : 8;
4265 info_ptr += bytes_read;
4266 cu_header->version = read_2_bytes (abfd, info_ptr);
4267 info_ptr += 2;
4268 cu_header->abbrev_offset.sect_off = read_offset (abfd, info_ptr, cu_header,
4269 &bytes_read);
4270 info_ptr += bytes_read;
4271 cu_header->addr_size = read_1_byte (abfd, info_ptr);
4272 info_ptr += 1;
4273 signed_addr = bfd_get_sign_extend_vma (abfd);
4274 if (signed_addr < 0)
4275 internal_error (__FILE__, __LINE__,
4276 _("read_comp_unit_head: dwarf from non elf file"));
4277 cu_header->signed_addr_p = signed_addr;
4278
4279 return info_ptr;
4280 }
4281
4282 /* Helper function that returns the proper abbrev section for
4283 THIS_CU. */
4284
4285 static struct dwarf2_section_info *
4286 get_abbrev_section_for_cu (struct dwarf2_per_cu_data *this_cu)
4287 {
4288 struct dwarf2_section_info *abbrev;
4289
4290 if (this_cu->is_dwz)
4291 abbrev = &dwarf2_get_dwz_file ()->abbrev;
4292 else
4293 abbrev = &dwarf2_per_objfile->abbrev;
4294
4295 return abbrev;
4296 }
4297
4298 /* Subroutine of read_and_check_comp_unit_head and
4299 read_and_check_type_unit_head to simplify them.
4300 Perform various error checking on the header. */
4301
4302 static void
4303 error_check_comp_unit_head (struct comp_unit_head *header,
4304 struct dwarf2_section_info *section,
4305 struct dwarf2_section_info *abbrev_section)
4306 {
4307 bfd *abfd = get_section_bfd_owner (section);
4308 const char *filename = get_section_file_name (section);
4309
4310 if (header->version != 2 && header->version != 3 && header->version != 4)
4311 error (_("Dwarf Error: wrong version in compilation unit header "
4312 "(is %d, should be 2, 3, or 4) [in module %s]"), header->version,
4313 filename);
4314
4315 if (header->abbrev_offset.sect_off
4316 >= dwarf2_section_size (dwarf2_per_objfile->objfile, abbrev_section))
4317 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
4318 "(offset 0x%lx + 6) [in module %s]"),
4319 (long) header->abbrev_offset.sect_off, (long) header->offset.sect_off,
4320 filename);
4321
4322 /* Cast to unsigned long to use 64-bit arithmetic when possible to
4323 avoid potential 32-bit overflow. */
4324 if (((unsigned long) header->offset.sect_off + get_cu_length (header))
4325 > section->size)
4326 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
4327 "(offset 0x%lx + 0) [in module %s]"),
4328 (long) header->length, (long) header->offset.sect_off,
4329 filename);
4330 }
4331
4332 /* Read in a CU/TU header and perform some basic error checking.
4333 The contents of the header are stored in HEADER.
4334 The result is a pointer to the start of the first DIE. */
4335
4336 static const gdb_byte *
4337 read_and_check_comp_unit_head (struct comp_unit_head *header,
4338 struct dwarf2_section_info *section,
4339 struct dwarf2_section_info *abbrev_section,
4340 const gdb_byte *info_ptr,
4341 int is_debug_types_section)
4342 {
4343 const gdb_byte *beg_of_comp_unit = info_ptr;
4344 bfd *abfd = get_section_bfd_owner (section);
4345
4346 header->offset.sect_off = beg_of_comp_unit - section->buffer;
4347
4348 info_ptr = read_comp_unit_head (header, info_ptr, abfd);
4349
4350 /* If we're reading a type unit, skip over the signature and
4351 type_offset fields. */
4352 if (is_debug_types_section)
4353 info_ptr += 8 /*signature*/ + header->offset_size;
4354
4355 header->first_die_offset.cu_off = info_ptr - beg_of_comp_unit;
4356
4357 error_check_comp_unit_head (header, section, abbrev_section);
4358
4359 return info_ptr;
4360 }
4361
4362 /* Read in the types comp unit header information from .debug_types entry at
4363 types_ptr. The result is a pointer to one past the end of the header. */
4364
4365 static const gdb_byte *
4366 read_and_check_type_unit_head (struct comp_unit_head *header,
4367 struct dwarf2_section_info *section,
4368 struct dwarf2_section_info *abbrev_section,
4369 const gdb_byte *info_ptr,
4370 ULONGEST *signature,
4371 cu_offset *type_offset_in_tu)
4372 {
4373 const gdb_byte *beg_of_comp_unit = info_ptr;
4374 bfd *abfd = get_section_bfd_owner (section);
4375
4376 header->offset.sect_off = beg_of_comp_unit - section->buffer;
4377
4378 info_ptr = read_comp_unit_head (header, info_ptr, abfd);
4379
4380 /* If we're reading a type unit, skip over the signature and
4381 type_offset fields. */
4382 if (signature != NULL)
4383 *signature = read_8_bytes (abfd, info_ptr);
4384 info_ptr += 8;
4385 if (type_offset_in_tu != NULL)
4386 type_offset_in_tu->cu_off = read_offset_1 (abfd, info_ptr,
4387 header->offset_size);
4388 info_ptr += header->offset_size;
4389
4390 header->first_die_offset.cu_off = info_ptr - beg_of_comp_unit;
4391
4392 error_check_comp_unit_head (header, section, abbrev_section);
4393
4394 return info_ptr;
4395 }
4396
4397 /* Fetch the abbreviation table offset from a comp or type unit header. */
4398
4399 static sect_offset
4400 read_abbrev_offset (struct dwarf2_section_info *section,
4401 sect_offset offset)
4402 {
4403 bfd *abfd = get_section_bfd_owner (section);
4404 const gdb_byte *info_ptr;
4405 unsigned int length, initial_length_size, offset_size;
4406 sect_offset abbrev_offset;
4407
4408 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
4409 info_ptr = section->buffer + offset.sect_off;
4410 length = read_initial_length (abfd, info_ptr, &initial_length_size);
4411 offset_size = initial_length_size == 4 ? 4 : 8;
4412 info_ptr += initial_length_size + 2 /*version*/;
4413 abbrev_offset.sect_off = read_offset_1 (abfd, info_ptr, offset_size);
4414 return abbrev_offset;
4415 }
4416
4417 /* Allocate a new partial symtab for file named NAME and mark this new
4418 partial symtab as being an include of PST. */
4419
4420 static void
4421 dwarf2_create_include_psymtab (const char *name, struct partial_symtab *pst,
4422 struct objfile *objfile)
4423 {
4424 struct partial_symtab *subpst = allocate_psymtab (name, objfile);
4425
4426 if (!IS_ABSOLUTE_PATH (subpst->filename))
4427 {
4428 /* It shares objfile->objfile_obstack. */
4429 subpst->dirname = pst->dirname;
4430 }
4431
4432 subpst->section_offsets = pst->section_offsets;
4433 subpst->textlow = 0;
4434 subpst->texthigh = 0;
4435
4436 subpst->dependencies = (struct partial_symtab **)
4437 obstack_alloc (&objfile->objfile_obstack,
4438 sizeof (struct partial_symtab *));
4439 subpst->dependencies[0] = pst;
4440 subpst->number_of_dependencies = 1;
4441
4442 subpst->globals_offset = 0;
4443 subpst->n_global_syms = 0;
4444 subpst->statics_offset = 0;
4445 subpst->n_static_syms = 0;
4446 subpst->symtab = NULL;
4447 subpst->read_symtab = pst->read_symtab;
4448 subpst->readin = 0;
4449
4450 /* No private part is necessary for include psymtabs. This property
4451 can be used to differentiate between such include psymtabs and
4452 the regular ones. */
4453 subpst->read_symtab_private = NULL;
4454 }
4455
4456 /* Read the Line Number Program data and extract the list of files
4457 included by the source file represented by PST. Build an include
4458 partial symtab for each of these included files. */
4459
4460 static void
4461 dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
4462 struct die_info *die,
4463 struct partial_symtab *pst)
4464 {
4465 struct line_header *lh = NULL;
4466 struct attribute *attr;
4467
4468 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
4469 if (attr)
4470 lh = dwarf_decode_line_header (DW_UNSND (attr), cu);
4471 if (lh == NULL)
4472 return; /* No linetable, so no includes. */
4473
4474 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
4475 dwarf_decode_lines (lh, pst->dirname, cu, pst, 1);
4476
4477 free_line_header (lh);
4478 }
4479
4480 static hashval_t
4481 hash_signatured_type (const void *item)
4482 {
4483 const struct signatured_type *sig_type = item;
4484
4485 /* This drops the top 32 bits of the signature, but is ok for a hash. */
4486 return sig_type->signature;
4487 }
4488
4489 static int
4490 eq_signatured_type (const void *item_lhs, const void *item_rhs)
4491 {
4492 const struct signatured_type *lhs = item_lhs;
4493 const struct signatured_type *rhs = item_rhs;
4494
4495 return lhs->signature == rhs->signature;
4496 }
4497
4498 /* Allocate a hash table for signatured types. */
4499
4500 static htab_t
4501 allocate_signatured_type_table (struct objfile *objfile)
4502 {
4503 return htab_create_alloc_ex (41,
4504 hash_signatured_type,
4505 eq_signatured_type,
4506 NULL,
4507 &objfile->objfile_obstack,
4508 hashtab_obstack_allocate,
4509 dummy_obstack_deallocate);
4510 }
4511
4512 /* A helper function to add a signatured type CU to a table. */
4513
4514 static int
4515 add_signatured_type_cu_to_table (void **slot, void *datum)
4516 {
4517 struct signatured_type *sigt = *slot;
4518 struct signatured_type ***datap = datum;
4519
4520 **datap = sigt;
4521 ++*datap;
4522
4523 return 1;
4524 }
4525
4526 /* Create the hash table of all entries in the .debug_types
4527 (or .debug_types.dwo) section(s).
4528 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
4529 otherwise it is NULL.
4530
4531 The result is a pointer to the hash table or NULL if there are no types.
4532
4533 Note: This function processes DWO files only, not DWP files. */
4534
4535 static htab_t
4536 create_debug_types_hash_table (struct dwo_file *dwo_file,
4537 VEC (dwarf2_section_info_def) *types)
4538 {
4539 struct objfile *objfile = dwarf2_per_objfile->objfile;
4540 htab_t types_htab = NULL;
4541 int ix;
4542 struct dwarf2_section_info *section;
4543 struct dwarf2_section_info *abbrev_section;
4544
4545 if (VEC_empty (dwarf2_section_info_def, types))
4546 return NULL;
4547
4548 abbrev_section = (dwo_file != NULL
4549 ? &dwo_file->sections.abbrev
4550 : &dwarf2_per_objfile->abbrev);
4551
4552 if (dwarf2_read_debug)
4553 fprintf_unfiltered (gdb_stdlog, "Reading .debug_types%s for %s:\n",
4554 dwo_file ? ".dwo" : "",
4555 get_section_file_name (abbrev_section));
4556
4557 for (ix = 0;
4558 VEC_iterate (dwarf2_section_info_def, types, ix, section);
4559 ++ix)
4560 {
4561 bfd *abfd;
4562 const gdb_byte *info_ptr, *end_ptr;
4563
4564 dwarf2_read_section (objfile, section);
4565 info_ptr = section->buffer;
4566
4567 if (info_ptr == NULL)
4568 continue;
4569
4570 /* We can't set abfd until now because the section may be empty or
4571 not present, in which case the bfd is unknown. */
4572 abfd = get_section_bfd_owner (section);
4573
4574 /* We don't use init_cutu_and_read_dies_simple, or some such, here
4575 because we don't need to read any dies: the signature is in the
4576 header. */
4577
4578 end_ptr = info_ptr + section->size;
4579 while (info_ptr < end_ptr)
4580 {
4581 sect_offset offset;
4582 cu_offset type_offset_in_tu;
4583 ULONGEST signature;
4584 struct signatured_type *sig_type;
4585 struct dwo_unit *dwo_tu;
4586 void **slot;
4587 const gdb_byte *ptr = info_ptr;
4588 struct comp_unit_head header;
4589 unsigned int length;
4590
4591 offset.sect_off = ptr - section->buffer;
4592
4593 /* We need to read the type's signature in order to build the hash
4594 table, but we don't need anything else just yet. */
4595
4596 ptr = read_and_check_type_unit_head (&header, section,
4597 abbrev_section, ptr,
4598 &signature, &type_offset_in_tu);
4599
4600 length = get_cu_length (&header);
4601
4602 /* Skip dummy type units. */
4603 if (ptr >= info_ptr + length
4604 || peek_abbrev_code (abfd, ptr) == 0)
4605 {
4606 info_ptr += length;
4607 continue;
4608 }
4609
4610 if (types_htab == NULL)
4611 {
4612 if (dwo_file)
4613 types_htab = allocate_dwo_unit_table (objfile);
4614 else
4615 types_htab = allocate_signatured_type_table (objfile);
4616 }
4617
4618 if (dwo_file)
4619 {
4620 sig_type = NULL;
4621 dwo_tu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
4622 struct dwo_unit);
4623 dwo_tu->dwo_file = dwo_file;
4624 dwo_tu->signature = signature;
4625 dwo_tu->type_offset_in_tu = type_offset_in_tu;
4626 dwo_tu->section = section;
4627 dwo_tu->offset = offset;
4628 dwo_tu->length = length;
4629 }
4630 else
4631 {
4632 /* N.B.: type_offset is not usable if this type uses a DWO file.
4633 The real type_offset is in the DWO file. */
4634 dwo_tu = NULL;
4635 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
4636 struct signatured_type);
4637 sig_type->signature = signature;
4638 sig_type->type_offset_in_tu = type_offset_in_tu;
4639 sig_type->per_cu.objfile = objfile;
4640 sig_type->per_cu.is_debug_types = 1;
4641 sig_type->per_cu.section = section;
4642 sig_type->per_cu.offset = offset;
4643 sig_type->per_cu.length = length;
4644 }
4645
4646 slot = htab_find_slot (types_htab,
4647 dwo_file ? (void*) dwo_tu : (void *) sig_type,
4648 INSERT);
4649 gdb_assert (slot != NULL);
4650 if (*slot != NULL)
4651 {
4652 sect_offset dup_offset;
4653
4654 if (dwo_file)
4655 {
4656 const struct dwo_unit *dup_tu = *slot;
4657
4658 dup_offset = dup_tu->offset;
4659 }
4660 else
4661 {
4662 const struct signatured_type *dup_tu = *slot;
4663
4664 dup_offset = dup_tu->per_cu.offset;
4665 }
4666
4667 complaint (&symfile_complaints,
4668 _("debug type entry at offset 0x%x is duplicate to"
4669 " the entry at offset 0x%x, signature %s"),
4670 offset.sect_off, dup_offset.sect_off,
4671 hex_string (signature));
4672 }
4673 *slot = dwo_file ? (void *) dwo_tu : (void *) sig_type;
4674
4675 if (dwarf2_read_debug > 1)
4676 fprintf_unfiltered (gdb_stdlog, " offset 0x%x, signature %s\n",
4677 offset.sect_off,
4678 hex_string (signature));
4679
4680 info_ptr += length;
4681 }
4682 }
4683
4684 return types_htab;
4685 }
4686
4687 /* Create the hash table of all entries in the .debug_types section,
4688 and initialize all_type_units.
4689 The result is zero if there is an error (e.g. missing .debug_types section),
4690 otherwise non-zero. */
4691
4692 static int
4693 create_all_type_units (struct objfile *objfile)
4694 {
4695 htab_t types_htab;
4696 struct signatured_type **iter;
4697
4698 types_htab = create_debug_types_hash_table (NULL, dwarf2_per_objfile->types);
4699 if (types_htab == NULL)
4700 {
4701 dwarf2_per_objfile->signatured_types = NULL;
4702 return 0;
4703 }
4704
4705 dwarf2_per_objfile->signatured_types = types_htab;
4706
4707 dwarf2_per_objfile->n_type_units = htab_elements (types_htab);
4708 dwarf2_per_objfile->all_type_units
4709 = xmalloc (dwarf2_per_objfile->n_type_units
4710 * sizeof (struct signatured_type *));
4711 iter = &dwarf2_per_objfile->all_type_units[0];
4712 htab_traverse_noresize (types_htab, add_signatured_type_cu_to_table, &iter);
4713 gdb_assert (iter - &dwarf2_per_objfile->all_type_units[0]
4714 == dwarf2_per_objfile->n_type_units);
4715
4716 return 1;
4717 }
4718
4719 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
4720 Fill in SIG_ENTRY with DWO_ENTRY. */
4721
4722 static void
4723 fill_in_sig_entry_from_dwo_entry (struct objfile *objfile,
4724 struct signatured_type *sig_entry,
4725 struct dwo_unit *dwo_entry)
4726 {
4727 /* Make sure we're not clobbering something we don't expect to. */
4728 gdb_assert (! sig_entry->per_cu.queued);
4729 gdb_assert (sig_entry->per_cu.cu == NULL);
4730 gdb_assert (sig_entry->per_cu.v.quick != NULL);
4731 gdb_assert (sig_entry->per_cu.v.quick->symtab == NULL);
4732 gdb_assert (sig_entry->signature == dwo_entry->signature);
4733 gdb_assert (sig_entry->type_offset_in_section.sect_off == 0);
4734 gdb_assert (sig_entry->type_unit_group == NULL);
4735 gdb_assert (sig_entry->dwo_unit == NULL);
4736
4737 sig_entry->per_cu.section = dwo_entry->section;
4738 sig_entry->per_cu.offset = dwo_entry->offset;
4739 sig_entry->per_cu.length = dwo_entry->length;
4740 sig_entry->per_cu.reading_dwo_directly = 1;
4741 sig_entry->per_cu.objfile = objfile;
4742 sig_entry->type_offset_in_tu = dwo_entry->type_offset_in_tu;
4743 sig_entry->dwo_unit = dwo_entry;
4744 }
4745
4746 /* Subroutine of lookup_signatured_type.
4747 If we haven't read the TU yet, create the signatured_type data structure
4748 for a TU to be read in directly from a DWO file, bypassing the stub.
4749 This is the "Stay in DWO Optimization": When there is no DWP file and we're
4750 using .gdb_index, then when reading a CU we want to stay in the DWO file
4751 containing that CU. Otherwise we could end up reading several other DWO
4752 files (due to comdat folding) to process the transitive closure of all the
4753 mentioned TUs, and that can be slow. The current DWO file will have every
4754 type signature that it needs.
4755 We only do this for .gdb_index because in the psymtab case we already have
4756 to read all the DWOs to build the type unit groups. */
4757
4758 static struct signatured_type *
4759 lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
4760 {
4761 struct objfile *objfile = dwarf2_per_objfile->objfile;
4762 struct dwo_file *dwo_file;
4763 struct dwo_unit find_dwo_entry, *dwo_entry;
4764 struct signatured_type find_sig_entry, *sig_entry;
4765
4766 gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
4767
4768 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
4769 dwo_unit of the TU itself. */
4770 dwo_file = cu->dwo_unit->dwo_file;
4771
4772 /* We only ever need to read in one copy of a signatured type.
4773 Just use the global signatured_types array. If this is the first time
4774 we're reading this type, replace the recorded data from .gdb_index with
4775 this TU. */
4776
4777 if (dwarf2_per_objfile->signatured_types == NULL)
4778 return NULL;
4779 find_sig_entry.signature = sig;
4780 sig_entry = htab_find (dwarf2_per_objfile->signatured_types, &find_sig_entry);
4781 if (sig_entry == NULL)
4782 return NULL;
4783
4784 /* We can get here with the TU already read, *or* in the process of being
4785 read. Don't reassign it if that's the case. Also note that if the TU is
4786 already being read, it may not have come from a DWO, the program may be
4787 a mix of Fission-compiled code and non-Fission-compiled code. */
4788 /* Have we already tried to read this TU? */
4789 if (sig_entry->per_cu.tu_read)
4790 return sig_entry;
4791
4792 /* Ok, this is the first time we're reading this TU. */
4793 if (dwo_file->tus == NULL)
4794 return NULL;
4795 find_dwo_entry.signature = sig;
4796 dwo_entry = htab_find (dwo_file->tus, &find_dwo_entry);
4797 if (dwo_entry == NULL)
4798 return NULL;
4799
4800 fill_in_sig_entry_from_dwo_entry (objfile, sig_entry, dwo_entry);
4801 sig_entry->per_cu.tu_read = 1;
4802 return sig_entry;
4803 }
4804
4805 /* Subroutine of lookup_dwp_signatured_type.
4806 Add an entry for signature SIG to dwarf2_per_objfile->signatured_types. */
4807
4808 static struct signatured_type *
4809 add_type_unit (ULONGEST sig)
4810 {
4811 struct objfile *objfile = dwarf2_per_objfile->objfile;
4812 int n_type_units = dwarf2_per_objfile->n_type_units;
4813 struct signatured_type *sig_type;
4814 void **slot;
4815
4816 ++n_type_units;
4817 dwarf2_per_objfile->all_type_units =
4818 xrealloc (dwarf2_per_objfile->all_type_units,
4819 n_type_units * sizeof (struct signatured_type *));
4820 dwarf2_per_objfile->n_type_units = n_type_units;
4821 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
4822 struct signatured_type);
4823 dwarf2_per_objfile->all_type_units[n_type_units - 1] = sig_type;
4824 sig_type->signature = sig;
4825 sig_type->per_cu.is_debug_types = 1;
4826 sig_type->per_cu.v.quick =
4827 OBSTACK_ZALLOC (&objfile->objfile_obstack,
4828 struct dwarf2_per_cu_quick_data);
4829 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
4830 sig_type, INSERT);
4831 gdb_assert (*slot == NULL);
4832 *slot = sig_type;
4833 /* The rest of sig_type must be filled in by the caller. */
4834 return sig_type;
4835 }
4836
4837 /* Subroutine of lookup_signatured_type.
4838 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
4839 then try the DWP file.
4840 Normally this "can't happen", but if there's a bug in signature
4841 generation and/or the DWP file is built incorrectly, it can happen.
4842 Using the type directly from the DWP file means we don't have the stub
4843 which has some useful attributes (e.g., DW_AT_comp_dir), but they're
4844 not critical. [Eventually the stub may go away for type units anyway.] */
4845
4846 static struct signatured_type *
4847 lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
4848 {
4849 struct objfile *objfile = dwarf2_per_objfile->objfile;
4850 struct dwp_file *dwp_file = get_dwp_file ();
4851 struct dwo_unit *dwo_entry;
4852 struct signatured_type find_sig_entry, *sig_entry;
4853
4854 gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
4855 gdb_assert (dwp_file != NULL);
4856
4857 if (dwarf2_per_objfile->signatured_types != NULL)
4858 {
4859 find_sig_entry.signature = sig;
4860 sig_entry = htab_find (dwarf2_per_objfile->signatured_types,
4861 &find_sig_entry);
4862 if (sig_entry != NULL)
4863 return sig_entry;
4864 }
4865
4866 /* This is the "shouldn't happen" case.
4867 Try the DWP file and hope for the best. */
4868 if (dwp_file->tus == NULL)
4869 return NULL;
4870 dwo_entry = lookup_dwo_unit_in_dwp (dwp_file, NULL,
4871 sig, 1 /* is_debug_types */);
4872 if (dwo_entry == NULL)
4873 return NULL;
4874
4875 sig_entry = add_type_unit (sig);
4876 fill_in_sig_entry_from_dwo_entry (objfile, sig_entry, dwo_entry);
4877
4878 /* The caller will signal a complaint if we return NULL.
4879 Here we don't return NULL but we still want to complain. */
4880 complaint (&symfile_complaints,
4881 _("Bad type signature %s referenced by %s at 0x%x,"
4882 " coping by using copy in DWP [in module %s]"),
4883 hex_string (sig),
4884 cu->per_cu->is_debug_types ? "TU" : "CU",
4885 cu->per_cu->offset.sect_off,
4886 objfile_name (objfile));
4887
4888 return sig_entry;
4889 }
4890
4891 /* Lookup a signature based type for DW_FORM_ref_sig8.
4892 Returns NULL if signature SIG is not present in the table.
4893 It is up to the caller to complain about this. */
4894
4895 static struct signatured_type *
4896 lookup_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
4897 {
4898 if (cu->dwo_unit
4899 && dwarf2_per_objfile->using_index)
4900 {
4901 /* We're in a DWO/DWP file, and we're using .gdb_index.
4902 These cases require special processing. */
4903 if (get_dwp_file () == NULL)
4904 return lookup_dwo_signatured_type (cu, sig);
4905 else
4906 return lookup_dwp_signatured_type (cu, sig);
4907 }
4908 else
4909 {
4910 struct signatured_type find_entry, *entry;
4911
4912 if (dwarf2_per_objfile->signatured_types == NULL)
4913 return NULL;
4914 find_entry.signature = sig;
4915 entry = htab_find (dwarf2_per_objfile->signatured_types, &find_entry);
4916 return entry;
4917 }
4918 }
4919 \f
4920 /* Low level DIE reading support. */
4921
4922 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
4923
4924 static void
4925 init_cu_die_reader (struct die_reader_specs *reader,
4926 struct dwarf2_cu *cu,
4927 struct dwarf2_section_info *section,
4928 struct dwo_file *dwo_file)
4929 {
4930 gdb_assert (section->readin && section->buffer != NULL);
4931 reader->abfd = get_section_bfd_owner (section);
4932 reader->cu = cu;
4933 reader->dwo_file = dwo_file;
4934 reader->die_section = section;
4935 reader->buffer = section->buffer;
4936 reader->buffer_end = section->buffer + section->size;
4937 reader->comp_dir = NULL;
4938 }
4939
4940 /* Subroutine of init_cutu_and_read_dies to simplify it.
4941 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
4942 There's just a lot of work to do, and init_cutu_and_read_dies is big enough
4943 already.
4944
4945 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
4946 from it to the DIE in the DWO. If NULL we are skipping the stub.
4947 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
4948 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
4949 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
4950 STUB_COMP_DIR may be non-NULL.
4951 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
4952 are filled in with the info of the DIE from the DWO file.
4953 ABBREV_TABLE_PROVIDED is non-zero if the caller of init_cutu_and_read_dies
4954 provided an abbrev table to use.
4955 The result is non-zero if a valid (non-dummy) DIE was found. */
4956
4957 static int
4958 read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu,
4959 struct dwo_unit *dwo_unit,
4960 int abbrev_table_provided,
4961 struct die_info *stub_comp_unit_die,
4962 const char *stub_comp_dir,
4963 struct die_reader_specs *result_reader,
4964 const gdb_byte **result_info_ptr,
4965 struct die_info **result_comp_unit_die,
4966 int *result_has_children)
4967 {
4968 struct objfile *objfile = dwarf2_per_objfile->objfile;
4969 struct dwarf2_cu *cu = this_cu->cu;
4970 struct dwarf2_section_info *section;
4971 bfd *abfd;
4972 const gdb_byte *begin_info_ptr, *info_ptr;
4973 ULONGEST signature; /* Or dwo_id. */
4974 struct attribute *comp_dir, *stmt_list, *low_pc, *high_pc, *ranges;
4975 int i,num_extra_attrs;
4976 struct dwarf2_section_info *dwo_abbrev_section;
4977 struct attribute *attr;
4978 struct die_info *comp_unit_die;
4979
4980 /* At most one of these may be provided. */
4981 gdb_assert ((stub_comp_unit_die != NULL) + (stub_comp_dir != NULL) <= 1);
4982
4983 /* These attributes aren't processed until later:
4984 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
4985 DW_AT_comp_dir is used now, to find the DWO file, but it is also
4986 referenced later. However, these attributes are found in the stub
4987 which we won't have later. In order to not impose this complication
4988 on the rest of the code, we read them here and copy them to the
4989 DWO CU/TU die. */
4990
4991 stmt_list = NULL;
4992 low_pc = NULL;
4993 high_pc = NULL;
4994 ranges = NULL;
4995 comp_dir = NULL;
4996
4997 if (stub_comp_unit_die != NULL)
4998 {
4999 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
5000 DWO file. */
5001 if (! this_cu->is_debug_types)
5002 stmt_list = dwarf2_attr (stub_comp_unit_die, DW_AT_stmt_list, cu);
5003 low_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_low_pc, cu);
5004 high_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_high_pc, cu);
5005 ranges = dwarf2_attr (stub_comp_unit_die, DW_AT_ranges, cu);
5006 comp_dir = dwarf2_attr (stub_comp_unit_die, DW_AT_comp_dir, cu);
5007
5008 /* There should be a DW_AT_addr_base attribute here (if needed).
5009 We need the value before we can process DW_FORM_GNU_addr_index. */
5010 cu->addr_base = 0;
5011 attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_addr_base, cu);
5012 if (attr)
5013 cu->addr_base = DW_UNSND (attr);
5014
5015 /* There should be a DW_AT_ranges_base attribute here (if needed).
5016 We need the value before we can process DW_AT_ranges. */
5017 cu->ranges_base = 0;
5018 attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_ranges_base, cu);
5019 if (attr)
5020 cu->ranges_base = DW_UNSND (attr);
5021 }
5022 else if (stub_comp_dir != NULL)
5023 {
5024 /* Reconstruct the comp_dir attribute to simplify the code below. */
5025 comp_dir = (struct attribute *)
5026 obstack_alloc (&cu->comp_unit_obstack, sizeof (*comp_dir));
5027 comp_dir->name = DW_AT_comp_dir;
5028 comp_dir->form = DW_FORM_string;
5029 DW_STRING_IS_CANONICAL (comp_dir) = 0;
5030 DW_STRING (comp_dir) = stub_comp_dir;
5031 }
5032
5033 /* Set up for reading the DWO CU/TU. */
5034 cu->dwo_unit = dwo_unit;
5035 section = dwo_unit->section;
5036 dwarf2_read_section (objfile, section);
5037 abfd = get_section_bfd_owner (section);
5038 begin_info_ptr = info_ptr = section->buffer + dwo_unit->offset.sect_off;
5039 dwo_abbrev_section = &dwo_unit->dwo_file->sections.abbrev;
5040 init_cu_die_reader (result_reader, cu, section, dwo_unit->dwo_file);
5041
5042 if (this_cu->is_debug_types)
5043 {
5044 ULONGEST header_signature;
5045 cu_offset type_offset_in_tu;
5046 struct signatured_type *sig_type = (struct signatured_type *) this_cu;
5047
5048 info_ptr = read_and_check_type_unit_head (&cu->header, section,
5049 dwo_abbrev_section,
5050 info_ptr,
5051 &header_signature,
5052 &type_offset_in_tu);
5053 /* This is not an assert because it can be caused by bad debug info. */
5054 if (sig_type->signature != header_signature)
5055 {
5056 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
5057 " TU at offset 0x%x [in module %s]"),
5058 hex_string (sig_type->signature),
5059 hex_string (header_signature),
5060 dwo_unit->offset.sect_off,
5061 bfd_get_filename (abfd));
5062 }
5063 gdb_assert (dwo_unit->offset.sect_off == cu->header.offset.sect_off);
5064 /* For DWOs coming from DWP files, we don't know the CU length
5065 nor the type's offset in the TU until now. */
5066 dwo_unit->length = get_cu_length (&cu->header);
5067 dwo_unit->type_offset_in_tu = type_offset_in_tu;
5068
5069 /* Establish the type offset that can be used to lookup the type.
5070 For DWO files, we don't know it until now. */
5071 sig_type->type_offset_in_section.sect_off =
5072 dwo_unit->offset.sect_off + dwo_unit->type_offset_in_tu.cu_off;
5073 }
5074 else
5075 {
5076 info_ptr = read_and_check_comp_unit_head (&cu->header, section,
5077 dwo_abbrev_section,
5078 info_ptr, 0);
5079 gdb_assert (dwo_unit->offset.sect_off == cu->header.offset.sect_off);
5080 /* For DWOs coming from DWP files, we don't know the CU length
5081 until now. */
5082 dwo_unit->length = get_cu_length (&cu->header);
5083 }
5084
5085 /* Replace the CU's original abbrev table with the DWO's.
5086 Reminder: We can't read the abbrev table until we've read the header. */
5087 if (abbrev_table_provided)
5088 {
5089 /* Don't free the provided abbrev table, the caller of
5090 init_cutu_and_read_dies owns it. */
5091 dwarf2_read_abbrevs (cu, dwo_abbrev_section);
5092 /* Ensure the DWO abbrev table gets freed. */
5093 make_cleanup (dwarf2_free_abbrev_table, cu);
5094 }
5095 else
5096 {
5097 dwarf2_free_abbrev_table (cu);
5098 dwarf2_read_abbrevs (cu, dwo_abbrev_section);
5099 /* Leave any existing abbrev table cleanup as is. */
5100 }
5101
5102 /* Read in the die, but leave space to copy over the attributes
5103 from the stub. This has the benefit of simplifying the rest of
5104 the code - all the work to maintain the illusion of a single
5105 DW_TAG_{compile,type}_unit DIE is done here. */
5106 num_extra_attrs = ((stmt_list != NULL)
5107 + (low_pc != NULL)
5108 + (high_pc != NULL)
5109 + (ranges != NULL)
5110 + (comp_dir != NULL));
5111 info_ptr = read_full_die_1 (result_reader, result_comp_unit_die, info_ptr,
5112 result_has_children, num_extra_attrs);
5113
5114 /* Copy over the attributes from the stub to the DIE we just read in. */
5115 comp_unit_die = *result_comp_unit_die;
5116 i = comp_unit_die->num_attrs;
5117 if (stmt_list != NULL)
5118 comp_unit_die->attrs[i++] = *stmt_list;
5119 if (low_pc != NULL)
5120 comp_unit_die->attrs[i++] = *low_pc;
5121 if (high_pc != NULL)
5122 comp_unit_die->attrs[i++] = *high_pc;
5123 if (ranges != NULL)
5124 comp_unit_die->attrs[i++] = *ranges;
5125 if (comp_dir != NULL)
5126 comp_unit_die->attrs[i++] = *comp_dir;
5127 comp_unit_die->num_attrs += num_extra_attrs;
5128
5129 if (dwarf2_die_debug)
5130 {
5131 fprintf_unfiltered (gdb_stdlog,
5132 "Read die from %s@0x%x of %s:\n",
5133 get_section_name (section),
5134 (unsigned) (begin_info_ptr - section->buffer),
5135 bfd_get_filename (abfd));
5136 dump_die (comp_unit_die, dwarf2_die_debug);
5137 }
5138
5139 /* Save the comp_dir attribute. If there is no DWP file then we'll read
5140 TUs by skipping the stub and going directly to the entry in the DWO file.
5141 However, skipping the stub means we won't get DW_AT_comp_dir, so we have
5142 to get it via circuitous means. Blech. */
5143 if (comp_dir != NULL)
5144 result_reader->comp_dir = DW_STRING (comp_dir);
5145
5146 /* Skip dummy compilation units. */
5147 if (info_ptr >= begin_info_ptr + dwo_unit->length
5148 || peek_abbrev_code (abfd, info_ptr) == 0)
5149 return 0;
5150
5151 *result_info_ptr = info_ptr;
5152 return 1;
5153 }
5154
5155 /* Subroutine of init_cutu_and_read_dies to simplify it.
5156 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
5157 Returns NULL if the specified DWO unit cannot be found. */
5158
5159 static struct dwo_unit *
5160 lookup_dwo_unit (struct dwarf2_per_cu_data *this_cu,
5161 struct die_info *comp_unit_die)
5162 {
5163 struct dwarf2_cu *cu = this_cu->cu;
5164 struct attribute *attr;
5165 ULONGEST signature;
5166 struct dwo_unit *dwo_unit;
5167 const char *comp_dir, *dwo_name;
5168
5169 gdb_assert (cu != NULL);
5170
5171 /* Yeah, we look dwo_name up again, but it simplifies the code. */
5172 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
5173 gdb_assert (attr != NULL);
5174 dwo_name = DW_STRING (attr);
5175 comp_dir = NULL;
5176 attr = dwarf2_attr (comp_unit_die, DW_AT_comp_dir, cu);
5177 if (attr)
5178 comp_dir = DW_STRING (attr);
5179
5180 if (this_cu->is_debug_types)
5181 {
5182 struct signatured_type *sig_type;
5183
5184 /* Since this_cu is the first member of struct signatured_type,
5185 we can go from a pointer to one to a pointer to the other. */
5186 sig_type = (struct signatured_type *) this_cu;
5187 signature = sig_type->signature;
5188 dwo_unit = lookup_dwo_type_unit (sig_type, dwo_name, comp_dir);
5189 }
5190 else
5191 {
5192 struct attribute *attr;
5193
5194 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
5195 if (! attr)
5196 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
5197 " [in module %s]"),
5198 dwo_name, objfile_name (this_cu->objfile));
5199 signature = DW_UNSND (attr);
5200 dwo_unit = lookup_dwo_comp_unit (this_cu, dwo_name, comp_dir,
5201 signature);
5202 }
5203
5204 return dwo_unit;
5205 }
5206
5207 /* Subroutine of init_cutu_and_read_dies to simplify it.
5208 Read a TU directly from a DWO file, bypassing the stub. */
5209
5210 static void
5211 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data *this_cu, int keep,
5212 die_reader_func_ftype *die_reader_func,
5213 void *data)
5214 {
5215 struct dwarf2_cu *cu;
5216 struct signatured_type *sig_type;
5217 struct cleanup *cleanups, *free_cu_cleanup;
5218 struct die_reader_specs reader;
5219 const gdb_byte *info_ptr;
5220 struct die_info *comp_unit_die;
5221 int has_children;
5222
5223 /* Verify we can do the following downcast, and that we have the
5224 data we need. */
5225 gdb_assert (this_cu->is_debug_types && this_cu->reading_dwo_directly);
5226 sig_type = (struct signatured_type *) this_cu;
5227 gdb_assert (sig_type->dwo_unit != NULL);
5228
5229 cleanups = make_cleanup (null_cleanup, NULL);
5230
5231 gdb_assert (this_cu->cu == NULL);
5232 cu = xmalloc (sizeof (*cu));
5233 init_one_comp_unit (cu, this_cu);
5234 /* If an error occurs while loading, release our storage. */
5235 free_cu_cleanup = make_cleanup (free_heap_comp_unit, cu);
5236
5237 if (read_cutu_die_from_dwo (this_cu, sig_type->dwo_unit,
5238 0 /* abbrev_table_provided */,
5239 NULL /* stub_comp_unit_die */,
5240 sig_type->dwo_unit->dwo_file->comp_dir,
5241 &reader, &info_ptr,
5242 &comp_unit_die, &has_children) == 0)
5243 {
5244 /* Dummy die. */
5245 do_cleanups (cleanups);
5246 return;
5247 }
5248
5249 /* All the "real" work is done here. */
5250 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
5251
5252 /* This duplicates some code in init_cutu_and_read_dies,
5253 but the alternative is making the latter more complex.
5254 This function is only for the special case of using DWO files directly:
5255 no point in overly complicating the general case just to handle this. */
5256 if (keep)
5257 {
5258 /* We've successfully allocated this compilation unit. Let our
5259 caller clean it up when finished with it. */
5260 discard_cleanups (free_cu_cleanup);
5261
5262 /* We can only discard free_cu_cleanup and all subsequent cleanups.
5263 So we have to manually free the abbrev table. */
5264 dwarf2_free_abbrev_table (cu);
5265
5266 /* Link this CU into read_in_chain. */
5267 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
5268 dwarf2_per_objfile->read_in_chain = this_cu;
5269 }
5270 else
5271 do_cleanups (free_cu_cleanup);
5272
5273 do_cleanups (cleanups);
5274 }
5275
5276 /* Initialize a CU (or TU) and read its DIEs.
5277 If the CU defers to a DWO file, read the DWO file as well.
5278
5279 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
5280 Otherwise the table specified in the comp unit header is read in and used.
5281 This is an optimization for when we already have the abbrev table.
5282
5283 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
5284 Otherwise, a new CU is allocated with xmalloc.
5285
5286 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
5287 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
5288
5289 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
5290 linker) then DIE_READER_FUNC will not get called. */
5291
5292 static void
5293 init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu,
5294 struct abbrev_table *abbrev_table,
5295 int use_existing_cu, int keep,
5296 die_reader_func_ftype *die_reader_func,
5297 void *data)
5298 {
5299 struct objfile *objfile = dwarf2_per_objfile->objfile;
5300 struct dwarf2_section_info *section = this_cu->section;
5301 bfd *abfd = get_section_bfd_owner (section);
5302 struct dwarf2_cu *cu;
5303 const gdb_byte *begin_info_ptr, *info_ptr;
5304 struct die_reader_specs reader;
5305 struct die_info *comp_unit_die;
5306 int has_children;
5307 struct attribute *attr;
5308 struct cleanup *cleanups, *free_cu_cleanup = NULL;
5309 struct signatured_type *sig_type = NULL;
5310 struct dwarf2_section_info *abbrev_section;
5311 /* Non-zero if CU currently points to a DWO file and we need to
5312 reread it. When this happens we need to reread the skeleton die
5313 before we can reread the DWO file (this only applies to CUs, not TUs). */
5314 int rereading_dwo_cu = 0;
5315
5316 if (dwarf2_die_debug)
5317 fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset 0x%x\n",
5318 this_cu->is_debug_types ? "type" : "comp",
5319 this_cu->offset.sect_off);
5320
5321 if (use_existing_cu)
5322 gdb_assert (keep);
5323
5324 /* If we're reading a TU directly from a DWO file, including a virtual DWO
5325 file (instead of going through the stub), short-circuit all of this. */
5326 if (this_cu->reading_dwo_directly)
5327 {
5328 /* Narrow down the scope of possibilities to have to understand. */
5329 gdb_assert (this_cu->is_debug_types);
5330 gdb_assert (abbrev_table == NULL);
5331 gdb_assert (!use_existing_cu);
5332 init_tu_and_read_dwo_dies (this_cu, keep, die_reader_func, data);
5333 return;
5334 }
5335
5336 cleanups = make_cleanup (null_cleanup, NULL);
5337
5338 /* This is cheap if the section is already read in. */
5339 dwarf2_read_section (objfile, section);
5340
5341 begin_info_ptr = info_ptr = section->buffer + this_cu->offset.sect_off;
5342
5343 abbrev_section = get_abbrev_section_for_cu (this_cu);
5344
5345 if (use_existing_cu && this_cu->cu != NULL)
5346 {
5347 cu = this_cu->cu;
5348
5349 /* If this CU is from a DWO file we need to start over, we need to
5350 refetch the attributes from the skeleton CU.
5351 This could be optimized by retrieving those attributes from when we
5352 were here the first time: the previous comp_unit_die was stored in
5353 comp_unit_obstack. But there's no data yet that we need this
5354 optimization. */
5355 if (cu->dwo_unit != NULL)
5356 rereading_dwo_cu = 1;
5357 }
5358 else
5359 {
5360 /* If !use_existing_cu, this_cu->cu must be NULL. */
5361 gdb_assert (this_cu->cu == NULL);
5362
5363 cu = xmalloc (sizeof (*cu));
5364 init_one_comp_unit (cu, this_cu);
5365
5366 /* If an error occurs while loading, release our storage. */
5367 free_cu_cleanup = make_cleanup (free_heap_comp_unit, cu);
5368 }
5369
5370 /* Get the header. */
5371 if (cu->header.first_die_offset.cu_off != 0 && ! rereading_dwo_cu)
5372 {
5373 /* We already have the header, there's no need to read it in again. */
5374 info_ptr += cu->header.first_die_offset.cu_off;
5375 }
5376 else
5377 {
5378 if (this_cu->is_debug_types)
5379 {
5380 ULONGEST signature;
5381 cu_offset type_offset_in_tu;
5382
5383 info_ptr = read_and_check_type_unit_head (&cu->header, section,
5384 abbrev_section, info_ptr,
5385 &signature,
5386 &type_offset_in_tu);
5387
5388 /* Since per_cu is the first member of struct signatured_type,
5389 we can go from a pointer to one to a pointer to the other. */
5390 sig_type = (struct signatured_type *) this_cu;
5391 gdb_assert (sig_type->signature == signature);
5392 gdb_assert (sig_type->type_offset_in_tu.cu_off
5393 == type_offset_in_tu.cu_off);
5394 gdb_assert (this_cu->offset.sect_off == cu->header.offset.sect_off);
5395
5396 /* LENGTH has not been set yet for type units if we're
5397 using .gdb_index. */
5398 this_cu->length = get_cu_length (&cu->header);
5399
5400 /* Establish the type offset that can be used to lookup the type. */
5401 sig_type->type_offset_in_section.sect_off =
5402 this_cu->offset.sect_off + sig_type->type_offset_in_tu.cu_off;
5403 }
5404 else
5405 {
5406 info_ptr = read_and_check_comp_unit_head (&cu->header, section,
5407 abbrev_section,
5408 info_ptr, 0);
5409
5410 gdb_assert (this_cu->offset.sect_off == cu->header.offset.sect_off);
5411 gdb_assert (this_cu->length == get_cu_length (&cu->header));
5412 }
5413 }
5414
5415 /* Skip dummy compilation units. */
5416 if (info_ptr >= begin_info_ptr + this_cu->length
5417 || peek_abbrev_code (abfd, info_ptr) == 0)
5418 {
5419 do_cleanups (cleanups);
5420 return;
5421 }
5422
5423 /* If we don't have them yet, read the abbrevs for this compilation unit.
5424 And if we need to read them now, make sure they're freed when we're
5425 done. Note that it's important that if the CU had an abbrev table
5426 on entry we don't free it when we're done: Somewhere up the call stack
5427 it may be in use. */
5428 if (abbrev_table != NULL)
5429 {
5430 gdb_assert (cu->abbrev_table == NULL);
5431 gdb_assert (cu->header.abbrev_offset.sect_off
5432 == abbrev_table->offset.sect_off);
5433 cu->abbrev_table = abbrev_table;
5434 }
5435 else if (cu->abbrev_table == NULL)
5436 {
5437 dwarf2_read_abbrevs (cu, abbrev_section);
5438 make_cleanup (dwarf2_free_abbrev_table, cu);
5439 }
5440 else if (rereading_dwo_cu)
5441 {
5442 dwarf2_free_abbrev_table (cu);
5443 dwarf2_read_abbrevs (cu, abbrev_section);
5444 }
5445
5446 /* Read the top level CU/TU die. */
5447 init_cu_die_reader (&reader, cu, section, NULL);
5448 info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
5449
5450 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
5451 from the DWO file.
5452 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
5453 DWO CU, that this test will fail (the attribute will not be present). */
5454 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
5455 if (attr)
5456 {
5457 struct dwo_unit *dwo_unit;
5458 struct die_info *dwo_comp_unit_die;
5459
5460 if (has_children)
5461 {
5462 complaint (&symfile_complaints,
5463 _("compilation unit with DW_AT_GNU_dwo_name"
5464 " has children (offset 0x%x) [in module %s]"),
5465 this_cu->offset.sect_off, bfd_get_filename (abfd));
5466 }
5467 dwo_unit = lookup_dwo_unit (this_cu, comp_unit_die);
5468 if (dwo_unit != NULL)
5469 {
5470 if (read_cutu_die_from_dwo (this_cu, dwo_unit,
5471 abbrev_table != NULL,
5472 comp_unit_die, NULL,
5473 &reader, &info_ptr,
5474 &dwo_comp_unit_die, &has_children) == 0)
5475 {
5476 /* Dummy die. */
5477 do_cleanups (cleanups);
5478 return;
5479 }
5480 comp_unit_die = dwo_comp_unit_die;
5481 }
5482 else
5483 {
5484 /* Yikes, we couldn't find the rest of the DIE, we only have
5485 the stub. A complaint has already been logged. There's
5486 not much more we can do except pass on the stub DIE to
5487 die_reader_func. We don't want to throw an error on bad
5488 debug info. */
5489 }
5490 }
5491
5492 /* All of the above is setup for this call. Yikes. */
5493 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
5494
5495 /* Done, clean up. */
5496 if (free_cu_cleanup != NULL)
5497 {
5498 if (keep)
5499 {
5500 /* We've successfully allocated this compilation unit. Let our
5501 caller clean it up when finished with it. */
5502 discard_cleanups (free_cu_cleanup);
5503
5504 /* We can only discard free_cu_cleanup and all subsequent cleanups.
5505 So we have to manually free the abbrev table. */
5506 dwarf2_free_abbrev_table (cu);
5507
5508 /* Link this CU into read_in_chain. */
5509 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
5510 dwarf2_per_objfile->read_in_chain = this_cu;
5511 }
5512 else
5513 do_cleanups (free_cu_cleanup);
5514 }
5515
5516 do_cleanups (cleanups);
5517 }
5518
5519 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
5520 DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
5521 to have already done the lookup to find the DWO file).
5522
5523 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
5524 THIS_CU->is_debug_types, but nothing else.
5525
5526 We fill in THIS_CU->length.
5527
5528 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
5529 linker) then DIE_READER_FUNC will not get called.
5530
5531 THIS_CU->cu is always freed when done.
5532 This is done in order to not leave THIS_CU->cu in a state where we have
5533 to care whether it refers to the "main" CU or the DWO CU. */
5534
5535 static void
5536 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data *this_cu,
5537 struct dwo_file *dwo_file,
5538 die_reader_func_ftype *die_reader_func,
5539 void *data)
5540 {
5541 struct objfile *objfile = dwarf2_per_objfile->objfile;
5542 struct dwarf2_section_info *section = this_cu->section;
5543 bfd *abfd = get_section_bfd_owner (section);
5544 struct dwarf2_section_info *abbrev_section;
5545 struct dwarf2_cu cu;
5546 const gdb_byte *begin_info_ptr, *info_ptr;
5547 struct die_reader_specs reader;
5548 struct cleanup *cleanups;
5549 struct die_info *comp_unit_die;
5550 int has_children;
5551
5552 if (dwarf2_die_debug)
5553 fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset 0x%x\n",
5554 this_cu->is_debug_types ? "type" : "comp",
5555 this_cu->offset.sect_off);
5556
5557 gdb_assert (this_cu->cu == NULL);
5558
5559 abbrev_section = (dwo_file != NULL
5560 ? &dwo_file->sections.abbrev
5561 : get_abbrev_section_for_cu (this_cu));
5562
5563 /* This is cheap if the section is already read in. */
5564 dwarf2_read_section (objfile, section);
5565
5566 init_one_comp_unit (&cu, this_cu);
5567
5568 cleanups = make_cleanup (free_stack_comp_unit, &cu);
5569
5570 begin_info_ptr = info_ptr = section->buffer + this_cu->offset.sect_off;
5571 info_ptr = read_and_check_comp_unit_head (&cu.header, section,
5572 abbrev_section, info_ptr,
5573 this_cu->is_debug_types);
5574
5575 this_cu->length = get_cu_length (&cu.header);
5576
5577 /* Skip dummy compilation units. */
5578 if (info_ptr >= begin_info_ptr + this_cu->length
5579 || peek_abbrev_code (abfd, info_ptr) == 0)
5580 {
5581 do_cleanups (cleanups);
5582 return;
5583 }
5584
5585 dwarf2_read_abbrevs (&cu, abbrev_section);
5586 make_cleanup (dwarf2_free_abbrev_table, &cu);
5587
5588 init_cu_die_reader (&reader, &cu, section, dwo_file);
5589 info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
5590
5591 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
5592
5593 do_cleanups (cleanups);
5594 }
5595
5596 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
5597 does not lookup the specified DWO file.
5598 This cannot be used to read DWO files.
5599
5600 THIS_CU->cu is always freed when done.
5601 This is done in order to not leave THIS_CU->cu in a state where we have
5602 to care whether it refers to the "main" CU or the DWO CU.
5603 We can revisit this if the data shows there's a performance issue. */
5604
5605 static void
5606 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data *this_cu,
5607 die_reader_func_ftype *die_reader_func,
5608 void *data)
5609 {
5610 init_cutu_and_read_dies_no_follow (this_cu, NULL, die_reader_func, data);
5611 }
5612 \f
5613 /* Type Unit Groups.
5614
5615 Type Unit Groups are a way to collapse the set of all TUs (type units) into
5616 a more manageable set. The grouping is done by DW_AT_stmt_list entry
5617 so that all types coming from the same compilation (.o file) are grouped
5618 together. A future step could be to put the types in the same symtab as
5619 the CU the types ultimately came from. */
5620
5621 static hashval_t
5622 hash_type_unit_group (const void *item)
5623 {
5624 const struct type_unit_group *tu_group = item;
5625
5626 return hash_stmt_list_entry (&tu_group->hash);
5627 }
5628
5629 static int
5630 eq_type_unit_group (const void *item_lhs, const void *item_rhs)
5631 {
5632 const struct type_unit_group *lhs = item_lhs;
5633 const struct type_unit_group *rhs = item_rhs;
5634
5635 return eq_stmt_list_entry (&lhs->hash, &rhs->hash);
5636 }
5637
5638 /* Allocate a hash table for type unit groups. */
5639
5640 static htab_t
5641 allocate_type_unit_groups_table (void)
5642 {
5643 return htab_create_alloc_ex (3,
5644 hash_type_unit_group,
5645 eq_type_unit_group,
5646 NULL,
5647 &dwarf2_per_objfile->objfile->objfile_obstack,
5648 hashtab_obstack_allocate,
5649 dummy_obstack_deallocate);
5650 }
5651
5652 /* Type units that don't have DW_AT_stmt_list are grouped into their own
5653 partial symtabs. We combine several TUs per psymtab to not let the size
5654 of any one psymtab grow too big. */
5655 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
5656 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
5657
5658 /* Helper routine for get_type_unit_group.
5659 Create the type_unit_group object used to hold one or more TUs. */
5660
5661 static struct type_unit_group *
5662 create_type_unit_group (struct dwarf2_cu *cu, sect_offset line_offset_struct)
5663 {
5664 struct objfile *objfile = dwarf2_per_objfile->objfile;
5665 struct dwarf2_per_cu_data *per_cu;
5666 struct type_unit_group *tu_group;
5667
5668 tu_group = OBSTACK_ZALLOC (&objfile->objfile_obstack,
5669 struct type_unit_group);
5670 per_cu = &tu_group->per_cu;
5671 per_cu->objfile = objfile;
5672
5673 if (dwarf2_per_objfile->using_index)
5674 {
5675 per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
5676 struct dwarf2_per_cu_quick_data);
5677 }
5678 else
5679 {
5680 unsigned int line_offset = line_offset_struct.sect_off;
5681 struct partial_symtab *pst;
5682 char *name;
5683
5684 /* Give the symtab a useful name for debug purposes. */
5685 if ((line_offset & NO_STMT_LIST_TYPE_UNIT_PSYMTAB) != 0)
5686 name = xstrprintf ("<type_units_%d>",
5687 (line_offset & ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB));
5688 else
5689 name = xstrprintf ("<type_units_at_0x%x>", line_offset);
5690
5691 pst = create_partial_symtab (per_cu, name);
5692 pst->anonymous = 1;
5693
5694 xfree (name);
5695 }
5696
5697 tu_group->hash.dwo_unit = cu->dwo_unit;
5698 tu_group->hash.line_offset = line_offset_struct;
5699
5700 return tu_group;
5701 }
5702
5703 /* Look up the type_unit_group for type unit CU, and create it if necessary.
5704 STMT_LIST is a DW_AT_stmt_list attribute. */
5705
5706 static struct type_unit_group *
5707 get_type_unit_group (struct dwarf2_cu *cu, const struct attribute *stmt_list)
5708 {
5709 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
5710 struct type_unit_group *tu_group;
5711 void **slot;
5712 unsigned int line_offset;
5713 struct type_unit_group type_unit_group_for_lookup;
5714
5715 if (dwarf2_per_objfile->type_unit_groups == NULL)
5716 {
5717 dwarf2_per_objfile->type_unit_groups =
5718 allocate_type_unit_groups_table ();
5719 }
5720
5721 /* Do we need to create a new group, or can we use an existing one? */
5722
5723 if (stmt_list)
5724 {
5725 line_offset = DW_UNSND (stmt_list);
5726 ++tu_stats->nr_symtab_sharers;
5727 }
5728 else
5729 {
5730 /* Ugh, no stmt_list. Rare, but we have to handle it.
5731 We can do various things here like create one group per TU or
5732 spread them over multiple groups to split up the expansion work.
5733 To avoid worst case scenarios (too many groups or too large groups)
5734 we, umm, group them in bunches. */
5735 line_offset = (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
5736 | (tu_stats->nr_stmt_less_type_units
5737 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE));
5738 ++tu_stats->nr_stmt_less_type_units;
5739 }
5740
5741 type_unit_group_for_lookup.hash.dwo_unit = cu->dwo_unit;
5742 type_unit_group_for_lookup.hash.line_offset.sect_off = line_offset;
5743 slot = htab_find_slot (dwarf2_per_objfile->type_unit_groups,
5744 &type_unit_group_for_lookup, INSERT);
5745 if (*slot != NULL)
5746 {
5747 tu_group = *slot;
5748 gdb_assert (tu_group != NULL);
5749 }
5750 else
5751 {
5752 sect_offset line_offset_struct;
5753
5754 line_offset_struct.sect_off = line_offset;
5755 tu_group = create_type_unit_group (cu, line_offset_struct);
5756 *slot = tu_group;
5757 ++tu_stats->nr_symtabs;
5758 }
5759
5760 return tu_group;
5761 }
5762
5763 /* Struct used to sort TUs by their abbreviation table offset. */
5764
5765 struct tu_abbrev_offset
5766 {
5767 struct signatured_type *sig_type;
5768 sect_offset abbrev_offset;
5769 };
5770
5771 /* Helper routine for build_type_unit_groups, passed to qsort. */
5772
5773 static int
5774 sort_tu_by_abbrev_offset (const void *ap, const void *bp)
5775 {
5776 const struct tu_abbrev_offset * const *a = ap;
5777 const struct tu_abbrev_offset * const *b = bp;
5778 unsigned int aoff = (*a)->abbrev_offset.sect_off;
5779 unsigned int boff = (*b)->abbrev_offset.sect_off;
5780
5781 return (aoff > boff) - (aoff < boff);
5782 }
5783
5784 /* A helper function to add a type_unit_group to a table. */
5785
5786 static int
5787 add_type_unit_group_to_table (void **slot, void *datum)
5788 {
5789 struct type_unit_group *tu_group = *slot;
5790 struct type_unit_group ***datap = datum;
5791
5792 **datap = tu_group;
5793 ++*datap;
5794
5795 return 1;
5796 }
5797
5798 /* Efficiently read all the type units, calling init_cutu_and_read_dies on
5799 each one passing FUNC,DATA.
5800
5801 The efficiency is because we sort TUs by the abbrev table they use and
5802 only read each abbrev table once. In one program there are 200K TUs
5803 sharing 8K abbrev tables.
5804
5805 The main purpose of this function is to support building the
5806 dwarf2_per_objfile->type_unit_groups table.
5807 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
5808 can collapse the search space by grouping them by stmt_list.
5809 The savings can be significant, in the same program from above the 200K TUs
5810 share 8K stmt_list tables.
5811
5812 FUNC is expected to call get_type_unit_group, which will create the
5813 struct type_unit_group if necessary and add it to
5814 dwarf2_per_objfile->type_unit_groups. */
5815
5816 static void
5817 build_type_unit_groups (die_reader_func_ftype *func, void *data)
5818 {
5819 struct objfile *objfile = dwarf2_per_objfile->objfile;
5820 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
5821 struct cleanup *cleanups;
5822 struct abbrev_table *abbrev_table;
5823 sect_offset abbrev_offset;
5824 struct tu_abbrev_offset *sorted_by_abbrev;
5825 struct type_unit_group **iter;
5826 int i;
5827
5828 /* It's up to the caller to not call us multiple times. */
5829 gdb_assert (dwarf2_per_objfile->type_unit_groups == NULL);
5830
5831 if (dwarf2_per_objfile->n_type_units == 0)
5832 return;
5833
5834 /* TUs typically share abbrev tables, and there can be way more TUs than
5835 abbrev tables. Sort by abbrev table to reduce the number of times we
5836 read each abbrev table in.
5837 Alternatives are to punt or to maintain a cache of abbrev tables.
5838 This is simpler and efficient enough for now.
5839
5840 Later we group TUs by their DW_AT_stmt_list value (as this defines the
5841 symtab to use). Typically TUs with the same abbrev offset have the same
5842 stmt_list value too so in practice this should work well.
5843
5844 The basic algorithm here is:
5845
5846 sort TUs by abbrev table
5847 for each TU with same abbrev table:
5848 read abbrev table if first user
5849 read TU top level DIE
5850 [IWBN if DWO skeletons had DW_AT_stmt_list]
5851 call FUNC */
5852
5853 if (dwarf2_read_debug)
5854 fprintf_unfiltered (gdb_stdlog, "Building type unit groups ...\n");
5855
5856 /* Sort in a separate table to maintain the order of all_type_units
5857 for .gdb_index: TU indices directly index all_type_units. */
5858 sorted_by_abbrev = XNEWVEC (struct tu_abbrev_offset,
5859 dwarf2_per_objfile->n_type_units);
5860 for (i = 0; i < dwarf2_per_objfile->n_type_units; ++i)
5861 {
5862 struct signatured_type *sig_type = dwarf2_per_objfile->all_type_units[i];
5863
5864 sorted_by_abbrev[i].sig_type = sig_type;
5865 sorted_by_abbrev[i].abbrev_offset =
5866 read_abbrev_offset (sig_type->per_cu.section,
5867 sig_type->per_cu.offset);
5868 }
5869 cleanups = make_cleanup (xfree, sorted_by_abbrev);
5870 qsort (sorted_by_abbrev, dwarf2_per_objfile->n_type_units,
5871 sizeof (struct tu_abbrev_offset), sort_tu_by_abbrev_offset);
5872
5873 /* Note: In the .gdb_index case, get_type_unit_group may have already been
5874 called any number of times, so we don't reset tu_stats here. */
5875
5876 abbrev_offset.sect_off = ~(unsigned) 0;
5877 abbrev_table = NULL;
5878 make_cleanup (abbrev_table_free_cleanup, &abbrev_table);
5879
5880 for (i = 0; i < dwarf2_per_objfile->n_type_units; ++i)
5881 {
5882 const struct tu_abbrev_offset *tu = &sorted_by_abbrev[i];
5883
5884 /* Switch to the next abbrev table if necessary. */
5885 if (abbrev_table == NULL
5886 || tu->abbrev_offset.sect_off != abbrev_offset.sect_off)
5887 {
5888 if (abbrev_table != NULL)
5889 {
5890 abbrev_table_free (abbrev_table);
5891 /* Reset to NULL in case abbrev_table_read_table throws
5892 an error: abbrev_table_free_cleanup will get called. */
5893 abbrev_table = NULL;
5894 }
5895 abbrev_offset = tu->abbrev_offset;
5896 abbrev_table =
5897 abbrev_table_read_table (&dwarf2_per_objfile->abbrev,
5898 abbrev_offset);
5899 ++tu_stats->nr_uniq_abbrev_tables;
5900 }
5901
5902 init_cutu_and_read_dies (&tu->sig_type->per_cu, abbrev_table, 0, 0,
5903 func, data);
5904 }
5905
5906 /* type_unit_groups can be NULL if there is an error in the debug info.
5907 Just create an empty table so the rest of gdb doesn't have to watch
5908 for this error case. */
5909 if (dwarf2_per_objfile->type_unit_groups == NULL)
5910 {
5911 dwarf2_per_objfile->type_unit_groups =
5912 allocate_type_unit_groups_table ();
5913 dwarf2_per_objfile->n_type_unit_groups = 0;
5914 }
5915
5916 /* Create a vector of pointers to primary type units to make it easy to
5917 iterate over them and CUs. See dw2_get_primary_cu. */
5918 dwarf2_per_objfile->n_type_unit_groups =
5919 htab_elements (dwarf2_per_objfile->type_unit_groups);
5920 dwarf2_per_objfile->all_type_unit_groups =
5921 obstack_alloc (&objfile->objfile_obstack,
5922 dwarf2_per_objfile->n_type_unit_groups
5923 * sizeof (struct type_unit_group *));
5924 iter = &dwarf2_per_objfile->all_type_unit_groups[0];
5925 htab_traverse_noresize (dwarf2_per_objfile->type_unit_groups,
5926 add_type_unit_group_to_table, &iter);
5927 gdb_assert (iter - &dwarf2_per_objfile->all_type_unit_groups[0]
5928 == dwarf2_per_objfile->n_type_unit_groups);
5929
5930 do_cleanups (cleanups);
5931
5932 if (dwarf2_read_debug)
5933 {
5934 fprintf_unfiltered (gdb_stdlog, "Done building type unit groups:\n");
5935 fprintf_unfiltered (gdb_stdlog, " %d TUs\n",
5936 dwarf2_per_objfile->n_type_units);
5937 fprintf_unfiltered (gdb_stdlog, " %d uniq abbrev tables\n",
5938 tu_stats->nr_uniq_abbrev_tables);
5939 fprintf_unfiltered (gdb_stdlog, " %d symtabs from stmt_list entries\n",
5940 tu_stats->nr_symtabs);
5941 fprintf_unfiltered (gdb_stdlog, " %d symtab sharers\n",
5942 tu_stats->nr_symtab_sharers);
5943 fprintf_unfiltered (gdb_stdlog, " %d type units without a stmt_list\n",
5944 tu_stats->nr_stmt_less_type_units);
5945 }
5946 }
5947 \f
5948 /* Partial symbol tables. */
5949
5950 /* Create a psymtab named NAME and assign it to PER_CU.
5951
5952 The caller must fill in the following details:
5953 dirname, textlow, texthigh. */
5954
5955 static struct partial_symtab *
5956 create_partial_symtab (struct dwarf2_per_cu_data *per_cu, const char *name)
5957 {
5958 struct objfile *objfile = per_cu->objfile;
5959 struct partial_symtab *pst;
5960
5961 pst = start_psymtab_common (objfile, objfile->section_offsets,
5962 name, 0,
5963 objfile->global_psymbols.next,
5964 objfile->static_psymbols.next);
5965
5966 pst->psymtabs_addrmap_supported = 1;
5967
5968 /* This is the glue that links PST into GDB's symbol API. */
5969 pst->read_symtab_private = per_cu;
5970 pst->read_symtab = dwarf2_read_symtab;
5971 per_cu->v.psymtab = pst;
5972
5973 return pst;
5974 }
5975
5976 /* The DATA object passed to process_psymtab_comp_unit_reader has this
5977 type. */
5978
5979 struct process_psymtab_comp_unit_data
5980 {
5981 /* True if we are reading a DW_TAG_partial_unit. */
5982
5983 int want_partial_unit;
5984
5985 /* The "pretend" language that is used if the CU doesn't declare a
5986 language. */
5987
5988 enum language pretend_language;
5989 };
5990
5991 /* die_reader_func for process_psymtab_comp_unit. */
5992
5993 static void
5994 process_psymtab_comp_unit_reader (const struct die_reader_specs *reader,
5995 const gdb_byte *info_ptr,
5996 struct die_info *comp_unit_die,
5997 int has_children,
5998 void *data)
5999 {
6000 struct dwarf2_cu *cu = reader->cu;
6001 struct objfile *objfile = cu->objfile;
6002 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
6003 struct attribute *attr;
6004 CORE_ADDR baseaddr;
6005 CORE_ADDR best_lowpc = 0, best_highpc = 0;
6006 struct partial_symtab *pst;
6007 int has_pc_info;
6008 const char *filename;
6009 struct process_psymtab_comp_unit_data *info = data;
6010
6011 if (comp_unit_die->tag == DW_TAG_partial_unit && !info->want_partial_unit)
6012 return;
6013
6014 gdb_assert (! per_cu->is_debug_types);
6015
6016 prepare_one_comp_unit (cu, comp_unit_die, info->pretend_language);
6017
6018 cu->list_in_scope = &file_symbols;
6019
6020 /* Allocate a new partial symbol table structure. */
6021 attr = dwarf2_attr (comp_unit_die, DW_AT_name, cu);
6022 if (attr == NULL || !DW_STRING (attr))
6023 filename = "";
6024 else
6025 filename = DW_STRING (attr);
6026
6027 pst = create_partial_symtab (per_cu, filename);
6028
6029 /* This must be done before calling dwarf2_build_include_psymtabs. */
6030 attr = dwarf2_attr (comp_unit_die, DW_AT_comp_dir, cu);
6031 if (attr != NULL)
6032 pst->dirname = DW_STRING (attr);
6033
6034 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6035
6036 dwarf2_find_base_address (comp_unit_die, cu);
6037
6038 /* Possibly set the default values of LOWPC and HIGHPC from
6039 `DW_AT_ranges'. */
6040 has_pc_info = dwarf2_get_pc_bounds (comp_unit_die, &best_lowpc,
6041 &best_highpc, cu, pst);
6042 if (has_pc_info == 1 && best_lowpc < best_highpc)
6043 /* Store the contiguous range if it is not empty; it can be empty for
6044 CUs with no code. */
6045 addrmap_set_empty (objfile->psymtabs_addrmap,
6046 best_lowpc + baseaddr,
6047 best_highpc + baseaddr - 1, pst);
6048
6049 /* Check if comp unit has_children.
6050 If so, read the rest of the partial symbols from this comp unit.
6051 If not, there's no more debug_info for this comp unit. */
6052 if (has_children)
6053 {
6054 struct partial_die_info *first_die;
6055 CORE_ADDR lowpc, highpc;
6056
6057 lowpc = ((CORE_ADDR) -1);
6058 highpc = ((CORE_ADDR) 0);
6059
6060 first_die = load_partial_dies (reader, info_ptr, 1);
6061
6062 scan_partial_symbols (first_die, &lowpc, &highpc,
6063 ! has_pc_info, cu);
6064
6065 /* If we didn't find a lowpc, set it to highpc to avoid
6066 complaints from `maint check'. */
6067 if (lowpc == ((CORE_ADDR) -1))
6068 lowpc = highpc;
6069
6070 /* If the compilation unit didn't have an explicit address range,
6071 then use the information extracted from its child dies. */
6072 if (! has_pc_info)
6073 {
6074 best_lowpc = lowpc;
6075 best_highpc = highpc;
6076 }
6077 }
6078 pst->textlow = best_lowpc + baseaddr;
6079 pst->texthigh = best_highpc + baseaddr;
6080
6081 pst->n_global_syms = objfile->global_psymbols.next -
6082 (objfile->global_psymbols.list + pst->globals_offset);
6083 pst->n_static_syms = objfile->static_psymbols.next -
6084 (objfile->static_psymbols.list + pst->statics_offset);
6085 sort_pst_symbols (objfile, pst);
6086
6087 if (!VEC_empty (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs))
6088 {
6089 int i;
6090 int len = VEC_length (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
6091 struct dwarf2_per_cu_data *iter;
6092
6093 /* Fill in 'dependencies' here; we fill in 'users' in a
6094 post-pass. */
6095 pst->number_of_dependencies = len;
6096 pst->dependencies = obstack_alloc (&objfile->objfile_obstack,
6097 len * sizeof (struct symtab *));
6098 for (i = 0;
6099 VEC_iterate (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
6100 i, iter);
6101 ++i)
6102 pst->dependencies[i] = iter->v.psymtab;
6103
6104 VEC_free (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
6105 }
6106
6107 /* Get the list of files included in the current compilation unit,
6108 and build a psymtab for each of them. */
6109 dwarf2_build_include_psymtabs (cu, comp_unit_die, pst);
6110
6111 if (dwarf2_read_debug)
6112 {
6113 struct gdbarch *gdbarch = get_objfile_arch (objfile);
6114
6115 fprintf_unfiltered (gdb_stdlog,
6116 "Psymtab for %s unit @0x%x: %s - %s"
6117 ", %d global, %d static syms\n",
6118 per_cu->is_debug_types ? "type" : "comp",
6119 per_cu->offset.sect_off,
6120 paddress (gdbarch, pst->textlow),
6121 paddress (gdbarch, pst->texthigh),
6122 pst->n_global_syms, pst->n_static_syms);
6123 }
6124 }
6125
6126 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
6127 Process compilation unit THIS_CU for a psymtab. */
6128
6129 static void
6130 process_psymtab_comp_unit (struct dwarf2_per_cu_data *this_cu,
6131 int want_partial_unit,
6132 enum language pretend_language)
6133 {
6134 struct process_psymtab_comp_unit_data info;
6135
6136 /* If this compilation unit was already read in, free the
6137 cached copy in order to read it in again. This is
6138 necessary because we skipped some symbols when we first
6139 read in the compilation unit (see load_partial_dies).
6140 This problem could be avoided, but the benefit is unclear. */
6141 if (this_cu->cu != NULL)
6142 free_one_cached_comp_unit (this_cu);
6143
6144 gdb_assert (! this_cu->is_debug_types);
6145 info.want_partial_unit = want_partial_unit;
6146 info.pretend_language = pretend_language;
6147 init_cutu_and_read_dies (this_cu, NULL, 0, 0,
6148 process_psymtab_comp_unit_reader,
6149 &info);
6150
6151 /* Age out any secondary CUs. */
6152 age_cached_comp_units ();
6153 }
6154
6155 /* Reader function for build_type_psymtabs. */
6156
6157 static void
6158 build_type_psymtabs_reader (const struct die_reader_specs *reader,
6159 const gdb_byte *info_ptr,
6160 struct die_info *type_unit_die,
6161 int has_children,
6162 void *data)
6163 {
6164 struct objfile *objfile = dwarf2_per_objfile->objfile;
6165 struct dwarf2_cu *cu = reader->cu;
6166 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
6167 struct signatured_type *sig_type;
6168 struct type_unit_group *tu_group;
6169 struct attribute *attr;
6170 struct partial_die_info *first_die;
6171 CORE_ADDR lowpc, highpc;
6172 struct partial_symtab *pst;
6173
6174 gdb_assert (data == NULL);
6175 gdb_assert (per_cu->is_debug_types);
6176 sig_type = (struct signatured_type *) per_cu;
6177
6178 if (! has_children)
6179 return;
6180
6181 attr = dwarf2_attr_no_follow (type_unit_die, DW_AT_stmt_list);
6182 tu_group = get_type_unit_group (cu, attr);
6183
6184 VEC_safe_push (sig_type_ptr, tu_group->tus, sig_type);
6185
6186 prepare_one_comp_unit (cu, type_unit_die, language_minimal);
6187 cu->list_in_scope = &file_symbols;
6188 pst = create_partial_symtab (per_cu, "");
6189 pst->anonymous = 1;
6190
6191 first_die = load_partial_dies (reader, info_ptr, 1);
6192
6193 lowpc = (CORE_ADDR) -1;
6194 highpc = (CORE_ADDR) 0;
6195 scan_partial_symbols (first_die, &lowpc, &highpc, 0, cu);
6196
6197 pst->n_global_syms = objfile->global_psymbols.next -
6198 (objfile->global_psymbols.list + pst->globals_offset);
6199 pst->n_static_syms = objfile->static_psymbols.next -
6200 (objfile->static_psymbols.list + pst->statics_offset);
6201 sort_pst_symbols (objfile, pst);
6202 }
6203
6204 /* Traversal function for build_type_psymtabs. */
6205
6206 static int
6207 build_type_psymtab_dependencies (void **slot, void *info)
6208 {
6209 struct objfile *objfile = dwarf2_per_objfile->objfile;
6210 struct type_unit_group *tu_group = (struct type_unit_group *) *slot;
6211 struct dwarf2_per_cu_data *per_cu = &tu_group->per_cu;
6212 struct partial_symtab *pst = per_cu->v.psymtab;
6213 int len = VEC_length (sig_type_ptr, tu_group->tus);
6214 struct signatured_type *iter;
6215 int i;
6216
6217 gdb_assert (len > 0);
6218 gdb_assert (IS_TYPE_UNIT_GROUP (per_cu));
6219
6220 pst->number_of_dependencies = len;
6221 pst->dependencies = obstack_alloc (&objfile->objfile_obstack,
6222 len * sizeof (struct psymtab *));
6223 for (i = 0;
6224 VEC_iterate (sig_type_ptr, tu_group->tus, i, iter);
6225 ++i)
6226 {
6227 gdb_assert (iter->per_cu.is_debug_types);
6228 pst->dependencies[i] = iter->per_cu.v.psymtab;
6229 iter->type_unit_group = tu_group;
6230 }
6231
6232 VEC_free (sig_type_ptr, tu_group->tus);
6233
6234 return 1;
6235 }
6236
6237 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
6238 Build partial symbol tables for the .debug_types comp-units. */
6239
6240 static void
6241 build_type_psymtabs (struct objfile *objfile)
6242 {
6243 if (! create_all_type_units (objfile))
6244 return;
6245
6246 build_type_unit_groups (build_type_psymtabs_reader, NULL);
6247
6248 /* Now that all TUs have been processed we can fill in the dependencies. */
6249 htab_traverse_noresize (dwarf2_per_objfile->type_unit_groups,
6250 build_type_psymtab_dependencies, NULL);
6251 }
6252
6253 /* A cleanup function that clears objfile's psymtabs_addrmap field. */
6254
6255 static void
6256 psymtabs_addrmap_cleanup (void *o)
6257 {
6258 struct objfile *objfile = o;
6259
6260 objfile->psymtabs_addrmap = NULL;
6261 }
6262
6263 /* Compute the 'user' field for each psymtab in OBJFILE. */
6264
6265 static void
6266 set_partial_user (struct objfile *objfile)
6267 {
6268 int i;
6269
6270 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
6271 {
6272 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
6273 struct partial_symtab *pst = per_cu->v.psymtab;
6274 int j;
6275
6276 if (pst == NULL)
6277 continue;
6278
6279 for (j = 0; j < pst->number_of_dependencies; ++j)
6280 {
6281 /* Set the 'user' field only if it is not already set. */
6282 if (pst->dependencies[j]->user == NULL)
6283 pst->dependencies[j]->user = pst;
6284 }
6285 }
6286 }
6287
6288 /* Build the partial symbol table by doing a quick pass through the
6289 .debug_info and .debug_abbrev sections. */
6290
6291 static void
6292 dwarf2_build_psymtabs_hard (struct objfile *objfile)
6293 {
6294 struct cleanup *back_to, *addrmap_cleanup;
6295 struct obstack temp_obstack;
6296 int i;
6297
6298 if (dwarf2_read_debug)
6299 {
6300 fprintf_unfiltered (gdb_stdlog, "Building psymtabs of objfile %s ...\n",
6301 objfile_name (objfile));
6302 }
6303
6304 dwarf2_per_objfile->reading_partial_symbols = 1;
6305
6306 dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
6307
6308 /* Any cached compilation units will be linked by the per-objfile
6309 read_in_chain. Make sure to free them when we're done. */
6310 back_to = make_cleanup (free_cached_comp_units, NULL);
6311
6312 build_type_psymtabs (objfile);
6313
6314 create_all_comp_units (objfile);
6315
6316 /* Create a temporary address map on a temporary obstack. We later
6317 copy this to the final obstack. */
6318 obstack_init (&temp_obstack);
6319 make_cleanup_obstack_free (&temp_obstack);
6320 objfile->psymtabs_addrmap = addrmap_create_mutable (&temp_obstack);
6321 addrmap_cleanup = make_cleanup (psymtabs_addrmap_cleanup, objfile);
6322
6323 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
6324 {
6325 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
6326
6327 process_psymtab_comp_unit (per_cu, 0, language_minimal);
6328 }
6329
6330 set_partial_user (objfile);
6331
6332 objfile->psymtabs_addrmap = addrmap_create_fixed (objfile->psymtabs_addrmap,
6333 &objfile->objfile_obstack);
6334 discard_cleanups (addrmap_cleanup);
6335
6336 do_cleanups (back_to);
6337
6338 if (dwarf2_read_debug)
6339 fprintf_unfiltered (gdb_stdlog, "Done building psymtabs of %s\n",
6340 objfile_name (objfile));
6341 }
6342
6343 /* die_reader_func for load_partial_comp_unit. */
6344
6345 static void
6346 load_partial_comp_unit_reader (const struct die_reader_specs *reader,
6347 const gdb_byte *info_ptr,
6348 struct die_info *comp_unit_die,
6349 int has_children,
6350 void *data)
6351 {
6352 struct dwarf2_cu *cu = reader->cu;
6353
6354 prepare_one_comp_unit (cu, comp_unit_die, language_minimal);
6355
6356 /* Check if comp unit has_children.
6357 If so, read the rest of the partial symbols from this comp unit.
6358 If not, there's no more debug_info for this comp unit. */
6359 if (has_children)
6360 load_partial_dies (reader, info_ptr, 0);
6361 }
6362
6363 /* Load the partial DIEs for a secondary CU into memory.
6364 This is also used when rereading a primary CU with load_all_dies. */
6365
6366 static void
6367 load_partial_comp_unit (struct dwarf2_per_cu_data *this_cu)
6368 {
6369 init_cutu_and_read_dies (this_cu, NULL, 1, 1,
6370 load_partial_comp_unit_reader, NULL);
6371 }
6372
6373 static void
6374 read_comp_units_from_section (struct objfile *objfile,
6375 struct dwarf2_section_info *section,
6376 unsigned int is_dwz,
6377 int *n_allocated,
6378 int *n_comp_units,
6379 struct dwarf2_per_cu_data ***all_comp_units)
6380 {
6381 const gdb_byte *info_ptr;
6382 bfd *abfd = get_section_bfd_owner (section);
6383
6384 if (dwarf2_read_debug)
6385 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s\n",
6386 get_section_name (section),
6387 get_section_file_name (section));
6388
6389 dwarf2_read_section (objfile, section);
6390
6391 info_ptr = section->buffer;
6392
6393 while (info_ptr < section->buffer + section->size)
6394 {
6395 unsigned int length, initial_length_size;
6396 struct dwarf2_per_cu_data *this_cu;
6397 sect_offset offset;
6398
6399 offset.sect_off = info_ptr - section->buffer;
6400
6401 /* Read just enough information to find out where the next
6402 compilation unit is. */
6403 length = read_initial_length (abfd, info_ptr, &initial_length_size);
6404
6405 /* Save the compilation unit for later lookup. */
6406 this_cu = obstack_alloc (&objfile->objfile_obstack,
6407 sizeof (struct dwarf2_per_cu_data));
6408 memset (this_cu, 0, sizeof (*this_cu));
6409 this_cu->offset = offset;
6410 this_cu->length = length + initial_length_size;
6411 this_cu->is_dwz = is_dwz;
6412 this_cu->objfile = objfile;
6413 this_cu->section = section;
6414
6415 if (*n_comp_units == *n_allocated)
6416 {
6417 *n_allocated *= 2;
6418 *all_comp_units = xrealloc (*all_comp_units,
6419 *n_allocated
6420 * sizeof (struct dwarf2_per_cu_data *));
6421 }
6422 (*all_comp_units)[*n_comp_units] = this_cu;
6423 ++*n_comp_units;
6424
6425 info_ptr = info_ptr + this_cu->length;
6426 }
6427 }
6428
6429 /* Create a list of all compilation units in OBJFILE.
6430 This is only done for -readnow and building partial symtabs. */
6431
6432 static void
6433 create_all_comp_units (struct objfile *objfile)
6434 {
6435 int n_allocated;
6436 int n_comp_units;
6437 struct dwarf2_per_cu_data **all_comp_units;
6438 struct dwz_file *dwz;
6439
6440 n_comp_units = 0;
6441 n_allocated = 10;
6442 all_comp_units = xmalloc (n_allocated
6443 * sizeof (struct dwarf2_per_cu_data *));
6444
6445 read_comp_units_from_section (objfile, &dwarf2_per_objfile->info, 0,
6446 &n_allocated, &n_comp_units, &all_comp_units);
6447
6448 dwz = dwarf2_get_dwz_file ();
6449 if (dwz != NULL)
6450 read_comp_units_from_section (objfile, &dwz->info, 1,
6451 &n_allocated, &n_comp_units,
6452 &all_comp_units);
6453
6454 dwarf2_per_objfile->all_comp_units
6455 = obstack_alloc (&objfile->objfile_obstack,
6456 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
6457 memcpy (dwarf2_per_objfile->all_comp_units, all_comp_units,
6458 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
6459 xfree (all_comp_units);
6460 dwarf2_per_objfile->n_comp_units = n_comp_units;
6461 }
6462
6463 /* Process all loaded DIEs for compilation unit CU, starting at
6464 FIRST_DIE. The caller should pass NEED_PC == 1 if the compilation
6465 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
6466 DW_AT_ranges). If NEED_PC is set, then this function will set
6467 *LOWPC and *HIGHPC to the lowest and highest PC values found in CU
6468 and record the covered ranges in the addrmap. */
6469
6470 static void
6471 scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
6472 CORE_ADDR *highpc, int need_pc, struct dwarf2_cu *cu)
6473 {
6474 struct partial_die_info *pdi;
6475
6476 /* Now, march along the PDI's, descending into ones which have
6477 interesting children but skipping the children of the other ones,
6478 until we reach the end of the compilation unit. */
6479
6480 pdi = first_die;
6481
6482 while (pdi != NULL)
6483 {
6484 fixup_partial_die (pdi, cu);
6485
6486 /* Anonymous namespaces or modules have no name but have interesting
6487 children, so we need to look at them. Ditto for anonymous
6488 enums. */
6489
6490 if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
6491 || pdi->tag == DW_TAG_module || pdi->tag == DW_TAG_enumeration_type
6492 || pdi->tag == DW_TAG_imported_unit)
6493 {
6494 switch (pdi->tag)
6495 {
6496 case DW_TAG_subprogram:
6497 add_partial_subprogram (pdi, lowpc, highpc, need_pc, cu);
6498 break;
6499 case DW_TAG_constant:
6500 case DW_TAG_variable:
6501 case DW_TAG_typedef:
6502 case DW_TAG_union_type:
6503 if (!pdi->is_declaration)
6504 {
6505 add_partial_symbol (pdi, cu);
6506 }
6507 break;
6508 case DW_TAG_class_type:
6509 case DW_TAG_interface_type:
6510 case DW_TAG_structure_type:
6511 if (!pdi->is_declaration)
6512 {
6513 add_partial_symbol (pdi, cu);
6514 }
6515 break;
6516 case DW_TAG_enumeration_type:
6517 if (!pdi->is_declaration)
6518 add_partial_enumeration (pdi, cu);
6519 break;
6520 case DW_TAG_base_type:
6521 case DW_TAG_subrange_type:
6522 /* File scope base type definitions are added to the partial
6523 symbol table. */
6524 add_partial_symbol (pdi, cu);
6525 break;
6526 case DW_TAG_namespace:
6527 add_partial_namespace (pdi, lowpc, highpc, need_pc, cu);
6528 break;
6529 case DW_TAG_module:
6530 add_partial_module (pdi, lowpc, highpc, need_pc, cu);
6531 break;
6532 case DW_TAG_imported_unit:
6533 {
6534 struct dwarf2_per_cu_data *per_cu;
6535
6536 /* For now we don't handle imported units in type units. */
6537 if (cu->per_cu->is_debug_types)
6538 {
6539 error (_("Dwarf Error: DW_TAG_imported_unit is not"
6540 " supported in type units [in module %s]"),
6541 objfile_name (cu->objfile));
6542 }
6543
6544 per_cu = dwarf2_find_containing_comp_unit (pdi->d.offset,
6545 pdi->is_dwz,
6546 cu->objfile);
6547
6548 /* Go read the partial unit, if needed. */
6549 if (per_cu->v.psymtab == NULL)
6550 process_psymtab_comp_unit (per_cu, 1, cu->language);
6551
6552 VEC_safe_push (dwarf2_per_cu_ptr,
6553 cu->per_cu->imported_symtabs, per_cu);
6554 }
6555 break;
6556 case DW_TAG_imported_declaration:
6557 add_partial_symbol (pdi, cu);
6558 break;
6559 default:
6560 break;
6561 }
6562 }
6563
6564 /* If the die has a sibling, skip to the sibling. */
6565
6566 pdi = pdi->die_sibling;
6567 }
6568 }
6569
6570 /* Functions used to compute the fully scoped name of a partial DIE.
6571
6572 Normally, this is simple. For C++, the parent DIE's fully scoped
6573 name is concatenated with "::" and the partial DIE's name. For
6574 Java, the same thing occurs except that "." is used instead of "::".
6575 Enumerators are an exception; they use the scope of their parent
6576 enumeration type, i.e. the name of the enumeration type is not
6577 prepended to the enumerator.
6578
6579 There are two complexities. One is DW_AT_specification; in this
6580 case "parent" means the parent of the target of the specification,
6581 instead of the direct parent of the DIE. The other is compilers
6582 which do not emit DW_TAG_namespace; in this case we try to guess
6583 the fully qualified name of structure types from their members'
6584 linkage names. This must be done using the DIE's children rather
6585 than the children of any DW_AT_specification target. We only need
6586 to do this for structures at the top level, i.e. if the target of
6587 any DW_AT_specification (if any; otherwise the DIE itself) does not
6588 have a parent. */
6589
6590 /* Compute the scope prefix associated with PDI's parent, in
6591 compilation unit CU. The result will be allocated on CU's
6592 comp_unit_obstack, or a copy of the already allocated PDI->NAME
6593 field. NULL is returned if no prefix is necessary. */
6594 static const char *
6595 partial_die_parent_scope (struct partial_die_info *pdi,
6596 struct dwarf2_cu *cu)
6597 {
6598 const char *grandparent_scope;
6599 struct partial_die_info *parent, *real_pdi;
6600
6601 /* We need to look at our parent DIE; if we have a DW_AT_specification,
6602 then this means the parent of the specification DIE. */
6603
6604 real_pdi = pdi;
6605 while (real_pdi->has_specification)
6606 real_pdi = find_partial_die (real_pdi->spec_offset,
6607 real_pdi->spec_is_dwz, cu);
6608
6609 parent = real_pdi->die_parent;
6610 if (parent == NULL)
6611 return NULL;
6612
6613 if (parent->scope_set)
6614 return parent->scope;
6615
6616 fixup_partial_die (parent, cu);
6617
6618 grandparent_scope = partial_die_parent_scope (parent, cu);
6619
6620 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
6621 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
6622 Work around this problem here. */
6623 if (cu->language == language_cplus
6624 && parent->tag == DW_TAG_namespace
6625 && strcmp (parent->name, "::") == 0
6626 && grandparent_scope == NULL)
6627 {
6628 parent->scope = NULL;
6629 parent->scope_set = 1;
6630 return NULL;
6631 }
6632
6633 if (pdi->tag == DW_TAG_enumerator)
6634 /* Enumerators should not get the name of the enumeration as a prefix. */
6635 parent->scope = grandparent_scope;
6636 else if (parent->tag == DW_TAG_namespace
6637 || parent->tag == DW_TAG_module
6638 || parent->tag == DW_TAG_structure_type
6639 || parent->tag == DW_TAG_class_type
6640 || parent->tag == DW_TAG_interface_type
6641 || parent->tag == DW_TAG_union_type
6642 || parent->tag == DW_TAG_enumeration_type)
6643 {
6644 if (grandparent_scope == NULL)
6645 parent->scope = parent->name;
6646 else
6647 parent->scope = typename_concat (&cu->comp_unit_obstack,
6648 grandparent_scope,
6649 parent->name, 0, cu);
6650 }
6651 else
6652 {
6653 /* FIXME drow/2004-04-01: What should we be doing with
6654 function-local names? For partial symbols, we should probably be
6655 ignoring them. */
6656 complaint (&symfile_complaints,
6657 _("unhandled containing DIE tag %d for DIE at %d"),
6658 parent->tag, pdi->offset.sect_off);
6659 parent->scope = grandparent_scope;
6660 }
6661
6662 parent->scope_set = 1;
6663 return parent->scope;
6664 }
6665
6666 /* Return the fully scoped name associated with PDI, from compilation unit
6667 CU. The result will be allocated with malloc. */
6668
6669 static char *
6670 partial_die_full_name (struct partial_die_info *pdi,
6671 struct dwarf2_cu *cu)
6672 {
6673 const char *parent_scope;
6674
6675 /* If this is a template instantiation, we can not work out the
6676 template arguments from partial DIEs. So, unfortunately, we have
6677 to go through the full DIEs. At least any work we do building
6678 types here will be reused if full symbols are loaded later. */
6679 if (pdi->has_template_arguments)
6680 {
6681 fixup_partial_die (pdi, cu);
6682
6683 if (pdi->name != NULL && strchr (pdi->name, '<') == NULL)
6684 {
6685 struct die_info *die;
6686 struct attribute attr;
6687 struct dwarf2_cu *ref_cu = cu;
6688
6689 /* DW_FORM_ref_addr is using section offset. */
6690 attr.name = 0;
6691 attr.form = DW_FORM_ref_addr;
6692 attr.u.unsnd = pdi->offset.sect_off;
6693 die = follow_die_ref (NULL, &attr, &ref_cu);
6694
6695 return xstrdup (dwarf2_full_name (NULL, die, ref_cu));
6696 }
6697 }
6698
6699 parent_scope = partial_die_parent_scope (pdi, cu);
6700 if (parent_scope == NULL)
6701 return NULL;
6702 else
6703 return typename_concat (NULL, parent_scope, pdi->name, 0, cu);
6704 }
6705
6706 static void
6707 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
6708 {
6709 struct objfile *objfile = cu->objfile;
6710 CORE_ADDR addr = 0;
6711 const char *actual_name = NULL;
6712 CORE_ADDR baseaddr;
6713 char *built_actual_name;
6714
6715 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6716
6717 built_actual_name = partial_die_full_name (pdi, cu);
6718 if (built_actual_name != NULL)
6719 actual_name = built_actual_name;
6720
6721 if (actual_name == NULL)
6722 actual_name = pdi->name;
6723
6724 switch (pdi->tag)
6725 {
6726 case DW_TAG_subprogram:
6727 if (pdi->is_external || cu->language == language_ada)
6728 {
6729 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
6730 of the global scope. But in Ada, we want to be able to access
6731 nested procedures globally. So all Ada subprograms are stored
6732 in the global scope. */
6733 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
6734 mst_text, objfile); */
6735 add_psymbol_to_list (actual_name, strlen (actual_name),
6736 built_actual_name != NULL,
6737 VAR_DOMAIN, LOC_BLOCK,
6738 &objfile->global_psymbols,
6739 0, pdi->lowpc + baseaddr,
6740 cu->language, objfile);
6741 }
6742 else
6743 {
6744 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
6745 mst_file_text, objfile); */
6746 add_psymbol_to_list (actual_name, strlen (actual_name),
6747 built_actual_name != NULL,
6748 VAR_DOMAIN, LOC_BLOCK,
6749 &objfile->static_psymbols,
6750 0, pdi->lowpc + baseaddr,
6751 cu->language, objfile);
6752 }
6753 break;
6754 case DW_TAG_constant:
6755 {
6756 struct psymbol_allocation_list *list;
6757
6758 if (pdi->is_external)
6759 list = &objfile->global_psymbols;
6760 else
6761 list = &objfile->static_psymbols;
6762 add_psymbol_to_list (actual_name, strlen (actual_name),
6763 built_actual_name != NULL, VAR_DOMAIN, LOC_STATIC,
6764 list, 0, 0, cu->language, objfile);
6765 }
6766 break;
6767 case DW_TAG_variable:
6768 if (pdi->d.locdesc)
6769 addr = decode_locdesc (pdi->d.locdesc, cu);
6770
6771 if (pdi->d.locdesc
6772 && addr == 0
6773 && !dwarf2_per_objfile->has_section_at_zero)
6774 {
6775 /* A global or static variable may also have been stripped
6776 out by the linker if unused, in which case its address
6777 will be nullified; do not add such variables into partial
6778 symbol table then. */
6779 }
6780 else if (pdi->is_external)
6781 {
6782 /* Global Variable.
6783 Don't enter into the minimal symbol tables as there is
6784 a minimal symbol table entry from the ELF symbols already.
6785 Enter into partial symbol table if it has a location
6786 descriptor or a type.
6787 If the location descriptor is missing, new_symbol will create
6788 a LOC_UNRESOLVED symbol, the address of the variable will then
6789 be determined from the minimal symbol table whenever the variable
6790 is referenced.
6791 The address for the partial symbol table entry is not
6792 used by GDB, but it comes in handy for debugging partial symbol
6793 table building. */
6794
6795 if (pdi->d.locdesc || pdi->has_type)
6796 add_psymbol_to_list (actual_name, strlen (actual_name),
6797 built_actual_name != NULL,
6798 VAR_DOMAIN, LOC_STATIC,
6799 &objfile->global_psymbols,
6800 0, addr + baseaddr,
6801 cu->language, objfile);
6802 }
6803 else
6804 {
6805 /* Static Variable. Skip symbols without location descriptors. */
6806 if (pdi->d.locdesc == NULL)
6807 {
6808 xfree (built_actual_name);
6809 return;
6810 }
6811 /* prim_record_minimal_symbol (actual_name, addr + baseaddr,
6812 mst_file_data, objfile); */
6813 add_psymbol_to_list (actual_name, strlen (actual_name),
6814 built_actual_name != NULL,
6815 VAR_DOMAIN, LOC_STATIC,
6816 &objfile->static_psymbols,
6817 0, addr + baseaddr,
6818 cu->language, objfile);
6819 }
6820 break;
6821 case DW_TAG_typedef:
6822 case DW_TAG_base_type:
6823 case DW_TAG_subrange_type:
6824 add_psymbol_to_list (actual_name, strlen (actual_name),
6825 built_actual_name != NULL,
6826 VAR_DOMAIN, LOC_TYPEDEF,
6827 &objfile->static_psymbols,
6828 0, (CORE_ADDR) 0, cu->language, objfile);
6829 break;
6830 case DW_TAG_imported_declaration:
6831 case DW_TAG_namespace:
6832 add_psymbol_to_list (actual_name, strlen (actual_name),
6833 built_actual_name != NULL,
6834 VAR_DOMAIN, LOC_TYPEDEF,
6835 &objfile->global_psymbols,
6836 0, (CORE_ADDR) 0, cu->language, objfile);
6837 break;
6838 case DW_TAG_module:
6839 add_psymbol_to_list (actual_name, strlen (actual_name),
6840 built_actual_name != NULL,
6841 MODULE_DOMAIN, LOC_TYPEDEF,
6842 &objfile->global_psymbols,
6843 0, (CORE_ADDR) 0, cu->language, objfile);
6844 break;
6845 case DW_TAG_class_type:
6846 case DW_TAG_interface_type:
6847 case DW_TAG_structure_type:
6848 case DW_TAG_union_type:
6849 case DW_TAG_enumeration_type:
6850 /* Skip external references. The DWARF standard says in the section
6851 about "Structure, Union, and Class Type Entries": "An incomplete
6852 structure, union or class type is represented by a structure,
6853 union or class entry that does not have a byte size attribute
6854 and that has a DW_AT_declaration attribute." */
6855 if (!pdi->has_byte_size && pdi->is_declaration)
6856 {
6857 xfree (built_actual_name);
6858 return;
6859 }
6860
6861 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
6862 static vs. global. */
6863 add_psymbol_to_list (actual_name, strlen (actual_name),
6864 built_actual_name != NULL,
6865 STRUCT_DOMAIN, LOC_TYPEDEF,
6866 (cu->language == language_cplus
6867 || cu->language == language_java)
6868 ? &objfile->global_psymbols
6869 : &objfile->static_psymbols,
6870 0, (CORE_ADDR) 0, cu->language, objfile);
6871
6872 break;
6873 case DW_TAG_enumerator:
6874 add_psymbol_to_list (actual_name, strlen (actual_name),
6875 built_actual_name != NULL,
6876 VAR_DOMAIN, LOC_CONST,
6877 (cu->language == language_cplus
6878 || cu->language == language_java)
6879 ? &objfile->global_psymbols
6880 : &objfile->static_psymbols,
6881 0, (CORE_ADDR) 0, cu->language, objfile);
6882 break;
6883 default:
6884 break;
6885 }
6886
6887 xfree (built_actual_name);
6888 }
6889
6890 /* Read a partial die corresponding to a namespace; also, add a symbol
6891 corresponding to that namespace to the symbol table. NAMESPACE is
6892 the name of the enclosing namespace. */
6893
6894 static void
6895 add_partial_namespace (struct partial_die_info *pdi,
6896 CORE_ADDR *lowpc, CORE_ADDR *highpc,
6897 int need_pc, struct dwarf2_cu *cu)
6898 {
6899 /* Add a symbol for the namespace. */
6900
6901 add_partial_symbol (pdi, cu);
6902
6903 /* Now scan partial symbols in that namespace. */
6904
6905 if (pdi->has_children)
6906 scan_partial_symbols (pdi->die_child, lowpc, highpc, need_pc, cu);
6907 }
6908
6909 /* Read a partial die corresponding to a Fortran module. */
6910
6911 static void
6912 add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
6913 CORE_ADDR *highpc, int need_pc, struct dwarf2_cu *cu)
6914 {
6915 /* Add a symbol for the namespace. */
6916
6917 add_partial_symbol (pdi, cu);
6918
6919 /* Now scan partial symbols in that module. */
6920
6921 if (pdi->has_children)
6922 scan_partial_symbols (pdi->die_child, lowpc, highpc, need_pc, cu);
6923 }
6924
6925 /* Read a partial die corresponding to a subprogram and create a partial
6926 symbol for that subprogram. When the CU language allows it, this
6927 routine also defines a partial symbol for each nested subprogram
6928 that this subprogram contains.
6929
6930 DIE my also be a lexical block, in which case we simply search
6931 recursively for suprograms defined inside that lexical block.
6932 Again, this is only performed when the CU language allows this
6933 type of definitions. */
6934
6935 static void
6936 add_partial_subprogram (struct partial_die_info *pdi,
6937 CORE_ADDR *lowpc, CORE_ADDR *highpc,
6938 int need_pc, struct dwarf2_cu *cu)
6939 {
6940 if (pdi->tag == DW_TAG_subprogram)
6941 {
6942 if (pdi->has_pc_info)
6943 {
6944 if (pdi->lowpc < *lowpc)
6945 *lowpc = pdi->lowpc;
6946 if (pdi->highpc > *highpc)
6947 *highpc = pdi->highpc;
6948 if (need_pc)
6949 {
6950 CORE_ADDR baseaddr;
6951 struct objfile *objfile = cu->objfile;
6952
6953 baseaddr = ANOFFSET (objfile->section_offsets,
6954 SECT_OFF_TEXT (objfile));
6955 addrmap_set_empty (objfile->psymtabs_addrmap,
6956 pdi->lowpc + baseaddr,
6957 pdi->highpc - 1 + baseaddr,
6958 cu->per_cu->v.psymtab);
6959 }
6960 }
6961
6962 if (pdi->has_pc_info || (!pdi->is_external && pdi->may_be_inlined))
6963 {
6964 if (!pdi->is_declaration)
6965 /* Ignore subprogram DIEs that do not have a name, they are
6966 illegal. Do not emit a complaint at this point, we will
6967 do so when we convert this psymtab into a symtab. */
6968 if (pdi->name)
6969 add_partial_symbol (pdi, cu);
6970 }
6971 }
6972
6973 if (! pdi->has_children)
6974 return;
6975
6976 if (cu->language == language_ada)
6977 {
6978 pdi = pdi->die_child;
6979 while (pdi != NULL)
6980 {
6981 fixup_partial_die (pdi, cu);
6982 if (pdi->tag == DW_TAG_subprogram
6983 || pdi->tag == DW_TAG_lexical_block)
6984 add_partial_subprogram (pdi, lowpc, highpc, need_pc, cu);
6985 pdi = pdi->die_sibling;
6986 }
6987 }
6988 }
6989
6990 /* Read a partial die corresponding to an enumeration type. */
6991
6992 static void
6993 add_partial_enumeration (struct partial_die_info *enum_pdi,
6994 struct dwarf2_cu *cu)
6995 {
6996 struct partial_die_info *pdi;
6997
6998 if (enum_pdi->name != NULL)
6999 add_partial_symbol (enum_pdi, cu);
7000
7001 pdi = enum_pdi->die_child;
7002 while (pdi)
7003 {
7004 if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
7005 complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
7006 else
7007 add_partial_symbol (pdi, cu);
7008 pdi = pdi->die_sibling;
7009 }
7010 }
7011
7012 /* Return the initial uleb128 in the die at INFO_PTR. */
7013
7014 static unsigned int
7015 peek_abbrev_code (bfd *abfd, const gdb_byte *info_ptr)
7016 {
7017 unsigned int bytes_read;
7018
7019 return read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
7020 }
7021
7022 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
7023 Return the corresponding abbrev, or NULL if the number is zero (indicating
7024 an empty DIE). In either case *BYTES_READ will be set to the length of
7025 the initial number. */
7026
7027 static struct abbrev_info *
7028 peek_die_abbrev (const gdb_byte *info_ptr, unsigned int *bytes_read,
7029 struct dwarf2_cu *cu)
7030 {
7031 bfd *abfd = cu->objfile->obfd;
7032 unsigned int abbrev_number;
7033 struct abbrev_info *abbrev;
7034
7035 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
7036
7037 if (abbrev_number == 0)
7038 return NULL;
7039
7040 abbrev = abbrev_table_lookup_abbrev (cu->abbrev_table, abbrev_number);
7041 if (!abbrev)
7042 {
7043 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"),
7044 abbrev_number, bfd_get_filename (abfd));
7045 }
7046
7047 return abbrev;
7048 }
7049
7050 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
7051 Returns a pointer to the end of a series of DIEs, terminated by an empty
7052 DIE. Any children of the skipped DIEs will also be skipped. */
7053
7054 static const gdb_byte *
7055 skip_children (const struct die_reader_specs *reader, const gdb_byte *info_ptr)
7056 {
7057 struct dwarf2_cu *cu = reader->cu;
7058 struct abbrev_info *abbrev;
7059 unsigned int bytes_read;
7060
7061 while (1)
7062 {
7063 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
7064 if (abbrev == NULL)
7065 return info_ptr + bytes_read;
7066 else
7067 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
7068 }
7069 }
7070
7071 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
7072 INFO_PTR should point just after the initial uleb128 of a DIE, and the
7073 abbrev corresponding to that skipped uleb128 should be passed in
7074 ABBREV. Returns a pointer to this DIE's sibling, skipping any
7075 children. */
7076
7077 static const gdb_byte *
7078 skip_one_die (const struct die_reader_specs *reader, const gdb_byte *info_ptr,
7079 struct abbrev_info *abbrev)
7080 {
7081 unsigned int bytes_read;
7082 struct attribute attr;
7083 bfd *abfd = reader->abfd;
7084 struct dwarf2_cu *cu = reader->cu;
7085 const gdb_byte *buffer = reader->buffer;
7086 const gdb_byte *buffer_end = reader->buffer_end;
7087 const gdb_byte *start_info_ptr = info_ptr;
7088 unsigned int form, i;
7089
7090 for (i = 0; i < abbrev->num_attrs; i++)
7091 {
7092 /* The only abbrev we care about is DW_AT_sibling. */
7093 if (abbrev->attrs[i].name == DW_AT_sibling)
7094 {
7095 read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
7096 if (attr.form == DW_FORM_ref_addr)
7097 complaint (&symfile_complaints,
7098 _("ignoring absolute DW_AT_sibling"));
7099 else
7100 {
7101 unsigned int off = dwarf2_get_ref_die_offset (&attr).sect_off;
7102 const gdb_byte *sibling_ptr = buffer + off;
7103
7104 if (sibling_ptr < info_ptr)
7105 complaint (&symfile_complaints,
7106 _("DW_AT_sibling points backwards"));
7107 else
7108 return sibling_ptr;
7109 }
7110 }
7111
7112 /* If it isn't DW_AT_sibling, skip this attribute. */
7113 form = abbrev->attrs[i].form;
7114 skip_attribute:
7115 switch (form)
7116 {
7117 case DW_FORM_ref_addr:
7118 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
7119 and later it is offset sized. */
7120 if (cu->header.version == 2)
7121 info_ptr += cu->header.addr_size;
7122 else
7123 info_ptr += cu->header.offset_size;
7124 break;
7125 case DW_FORM_GNU_ref_alt:
7126 info_ptr += cu->header.offset_size;
7127 break;
7128 case DW_FORM_addr:
7129 info_ptr += cu->header.addr_size;
7130 break;
7131 case DW_FORM_data1:
7132 case DW_FORM_ref1:
7133 case DW_FORM_flag:
7134 info_ptr += 1;
7135 break;
7136 case DW_FORM_flag_present:
7137 break;
7138 case DW_FORM_data2:
7139 case DW_FORM_ref2:
7140 info_ptr += 2;
7141 break;
7142 case DW_FORM_data4:
7143 case DW_FORM_ref4:
7144 info_ptr += 4;
7145 break;
7146 case DW_FORM_data8:
7147 case DW_FORM_ref8:
7148 case DW_FORM_ref_sig8:
7149 info_ptr += 8;
7150 break;
7151 case DW_FORM_string:
7152 read_direct_string (abfd, info_ptr, &bytes_read);
7153 info_ptr += bytes_read;
7154 break;
7155 case DW_FORM_sec_offset:
7156 case DW_FORM_strp:
7157 case DW_FORM_GNU_strp_alt:
7158 info_ptr += cu->header.offset_size;
7159 break;
7160 case DW_FORM_exprloc:
7161 case DW_FORM_block:
7162 info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
7163 info_ptr += bytes_read;
7164 break;
7165 case DW_FORM_block1:
7166 info_ptr += 1 + read_1_byte (abfd, info_ptr);
7167 break;
7168 case DW_FORM_block2:
7169 info_ptr += 2 + read_2_bytes (abfd, info_ptr);
7170 break;
7171 case DW_FORM_block4:
7172 info_ptr += 4 + read_4_bytes (abfd, info_ptr);
7173 break;
7174 case DW_FORM_sdata:
7175 case DW_FORM_udata:
7176 case DW_FORM_ref_udata:
7177 case DW_FORM_GNU_addr_index:
7178 case DW_FORM_GNU_str_index:
7179 info_ptr = safe_skip_leb128 (info_ptr, buffer_end);
7180 break;
7181 case DW_FORM_indirect:
7182 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
7183 info_ptr += bytes_read;
7184 /* We need to continue parsing from here, so just go back to
7185 the top. */
7186 goto skip_attribute;
7187
7188 default:
7189 error (_("Dwarf Error: Cannot handle %s "
7190 "in DWARF reader [in module %s]"),
7191 dwarf_form_name (form),
7192 bfd_get_filename (abfd));
7193 }
7194 }
7195
7196 if (abbrev->has_children)
7197 return skip_children (reader, info_ptr);
7198 else
7199 return info_ptr;
7200 }
7201
7202 /* Locate ORIG_PDI's sibling.
7203 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
7204
7205 static const gdb_byte *
7206 locate_pdi_sibling (const struct die_reader_specs *reader,
7207 struct partial_die_info *orig_pdi,
7208 const gdb_byte *info_ptr)
7209 {
7210 /* Do we know the sibling already? */
7211
7212 if (orig_pdi->sibling)
7213 return orig_pdi->sibling;
7214
7215 /* Are there any children to deal with? */
7216
7217 if (!orig_pdi->has_children)
7218 return info_ptr;
7219
7220 /* Skip the children the long way. */
7221
7222 return skip_children (reader, info_ptr);
7223 }
7224
7225 /* Expand this partial symbol table into a full symbol table. SELF is
7226 not NULL. */
7227
7228 static void
7229 dwarf2_read_symtab (struct partial_symtab *self,
7230 struct objfile *objfile)
7231 {
7232 if (self->readin)
7233 {
7234 warning (_("bug: psymtab for %s is already read in."),
7235 self->filename);
7236 }
7237 else
7238 {
7239 if (info_verbose)
7240 {
7241 printf_filtered (_("Reading in symbols for %s..."),
7242 self->filename);
7243 gdb_flush (gdb_stdout);
7244 }
7245
7246 /* Restore our global data. */
7247 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
7248
7249 /* If this psymtab is constructed from a debug-only objfile, the
7250 has_section_at_zero flag will not necessarily be correct. We
7251 can get the correct value for this flag by looking at the data
7252 associated with the (presumably stripped) associated objfile. */
7253 if (objfile->separate_debug_objfile_backlink)
7254 {
7255 struct dwarf2_per_objfile *dpo_backlink
7256 = objfile_data (objfile->separate_debug_objfile_backlink,
7257 dwarf2_objfile_data_key);
7258
7259 dwarf2_per_objfile->has_section_at_zero
7260 = dpo_backlink->has_section_at_zero;
7261 }
7262
7263 dwarf2_per_objfile->reading_partial_symbols = 0;
7264
7265 psymtab_to_symtab_1 (self);
7266
7267 /* Finish up the debug error message. */
7268 if (info_verbose)
7269 printf_filtered (_("done.\n"));
7270 }
7271
7272 process_cu_includes ();
7273 }
7274 \f
7275 /* Reading in full CUs. */
7276
7277 /* Add PER_CU to the queue. */
7278
7279 static void
7280 queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
7281 enum language pretend_language)
7282 {
7283 struct dwarf2_queue_item *item;
7284
7285 per_cu->queued = 1;
7286 item = xmalloc (sizeof (*item));
7287 item->per_cu = per_cu;
7288 item->pretend_language = pretend_language;
7289 item->next = NULL;
7290
7291 if (dwarf2_queue == NULL)
7292 dwarf2_queue = item;
7293 else
7294 dwarf2_queue_tail->next = item;
7295
7296 dwarf2_queue_tail = item;
7297 }
7298
7299 /* If PER_CU is not yet queued, add it to the queue.
7300 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
7301 dependency.
7302 The result is non-zero if PER_CU was queued, otherwise the result is zero
7303 meaning either PER_CU is already queued or it is already loaded.
7304
7305 N.B. There is an invariant here that if a CU is queued then it is loaded.
7306 The caller is required to load PER_CU if we return non-zero. */
7307
7308 static int
7309 maybe_queue_comp_unit (struct dwarf2_cu *dependent_cu,
7310 struct dwarf2_per_cu_data *per_cu,
7311 enum language pretend_language)
7312 {
7313 /* We may arrive here during partial symbol reading, if we need full
7314 DIEs to process an unusual case (e.g. template arguments). Do
7315 not queue PER_CU, just tell our caller to load its DIEs. */
7316 if (dwarf2_per_objfile->reading_partial_symbols)
7317 {
7318 if (per_cu->cu == NULL || per_cu->cu->dies == NULL)
7319 return 1;
7320 return 0;
7321 }
7322
7323 /* Mark the dependence relation so that we don't flush PER_CU
7324 too early. */
7325 if (dependent_cu != NULL)
7326 dwarf2_add_dependence (dependent_cu, per_cu);
7327
7328 /* If it's already on the queue, we have nothing to do. */
7329 if (per_cu->queued)
7330 return 0;
7331
7332 /* If the compilation unit is already loaded, just mark it as
7333 used. */
7334 if (per_cu->cu != NULL)
7335 {
7336 per_cu->cu->last_used = 0;
7337 return 0;
7338 }
7339
7340 /* Add it to the queue. */
7341 queue_comp_unit (per_cu, pretend_language);
7342
7343 return 1;
7344 }
7345
7346 /* Process the queue. */
7347
7348 static void
7349 process_queue (void)
7350 {
7351 struct dwarf2_queue_item *item, *next_item;
7352
7353 if (dwarf2_read_debug)
7354 {
7355 fprintf_unfiltered (gdb_stdlog,
7356 "Expanding one or more symtabs of objfile %s ...\n",
7357 objfile_name (dwarf2_per_objfile->objfile));
7358 }
7359
7360 /* The queue starts out with one item, but following a DIE reference
7361 may load a new CU, adding it to the end of the queue. */
7362 for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
7363 {
7364 if (dwarf2_per_objfile->using_index
7365 ? !item->per_cu->v.quick->symtab
7366 : (item->per_cu->v.psymtab && !item->per_cu->v.psymtab->readin))
7367 {
7368 struct dwarf2_per_cu_data *per_cu = item->per_cu;
7369 unsigned int debug_print_threshold;
7370 char buf[100];
7371
7372 if (per_cu->is_debug_types)
7373 {
7374 struct signatured_type *sig_type =
7375 (struct signatured_type *) per_cu;
7376
7377 sprintf (buf, "TU %s at offset 0x%x",
7378 hex_string (sig_type->signature),
7379 per_cu->offset.sect_off);
7380 /* There can be 100s of TUs.
7381 Only print them in verbose mode. */
7382 debug_print_threshold = 2;
7383 }
7384 else
7385 {
7386 sprintf (buf, "CU at offset 0x%x", per_cu->offset.sect_off);
7387 debug_print_threshold = 1;
7388 }
7389
7390 if (dwarf2_read_debug >= debug_print_threshold)
7391 fprintf_unfiltered (gdb_stdlog, "Expanding symtab of %s\n", buf);
7392
7393 if (per_cu->is_debug_types)
7394 process_full_type_unit (per_cu, item->pretend_language);
7395 else
7396 process_full_comp_unit (per_cu, item->pretend_language);
7397
7398 if (dwarf2_read_debug >= debug_print_threshold)
7399 fprintf_unfiltered (gdb_stdlog, "Done expanding %s\n", buf);
7400 }
7401
7402 item->per_cu->queued = 0;
7403 next_item = item->next;
7404 xfree (item);
7405 }
7406
7407 dwarf2_queue_tail = NULL;
7408
7409 if (dwarf2_read_debug)
7410 {
7411 fprintf_unfiltered (gdb_stdlog, "Done expanding symtabs of %s.\n",
7412 objfile_name (dwarf2_per_objfile->objfile));
7413 }
7414 }
7415
7416 /* Free all allocated queue entries. This function only releases anything if
7417 an error was thrown; if the queue was processed then it would have been
7418 freed as we went along. */
7419
7420 static void
7421 dwarf2_release_queue (void *dummy)
7422 {
7423 struct dwarf2_queue_item *item, *last;
7424
7425 item = dwarf2_queue;
7426 while (item)
7427 {
7428 /* Anything still marked queued is likely to be in an
7429 inconsistent state, so discard it. */
7430 if (item->per_cu->queued)
7431 {
7432 if (item->per_cu->cu != NULL)
7433 free_one_cached_comp_unit (item->per_cu);
7434 item->per_cu->queued = 0;
7435 }
7436
7437 last = item;
7438 item = item->next;
7439 xfree (last);
7440 }
7441
7442 dwarf2_queue = dwarf2_queue_tail = NULL;
7443 }
7444
7445 /* Read in full symbols for PST, and anything it depends on. */
7446
7447 static void
7448 psymtab_to_symtab_1 (struct partial_symtab *pst)
7449 {
7450 struct dwarf2_per_cu_data *per_cu;
7451 int i;
7452
7453 if (pst->readin)
7454 return;
7455
7456 for (i = 0; i < pst->number_of_dependencies; i++)
7457 if (!pst->dependencies[i]->readin
7458 && pst->dependencies[i]->user == NULL)
7459 {
7460 /* Inform about additional files that need to be read in. */
7461 if (info_verbose)
7462 {
7463 /* FIXME: i18n: Need to make this a single string. */
7464 fputs_filtered (" ", gdb_stdout);
7465 wrap_here ("");
7466 fputs_filtered ("and ", gdb_stdout);
7467 wrap_here ("");
7468 printf_filtered ("%s...", pst->dependencies[i]->filename);
7469 wrap_here (""); /* Flush output. */
7470 gdb_flush (gdb_stdout);
7471 }
7472 psymtab_to_symtab_1 (pst->dependencies[i]);
7473 }
7474
7475 per_cu = pst->read_symtab_private;
7476
7477 if (per_cu == NULL)
7478 {
7479 /* It's an include file, no symbols to read for it.
7480 Everything is in the parent symtab. */
7481 pst->readin = 1;
7482 return;
7483 }
7484
7485 dw2_do_instantiate_symtab (per_cu);
7486 }
7487
7488 /* Trivial hash function for die_info: the hash value of a DIE
7489 is its offset in .debug_info for this objfile. */
7490
7491 static hashval_t
7492 die_hash (const void *item)
7493 {
7494 const struct die_info *die = item;
7495
7496 return die->offset.sect_off;
7497 }
7498
7499 /* Trivial comparison function for die_info structures: two DIEs
7500 are equal if they have the same offset. */
7501
7502 static int
7503 die_eq (const void *item_lhs, const void *item_rhs)
7504 {
7505 const struct die_info *die_lhs = item_lhs;
7506 const struct die_info *die_rhs = item_rhs;
7507
7508 return die_lhs->offset.sect_off == die_rhs->offset.sect_off;
7509 }
7510
7511 /* die_reader_func for load_full_comp_unit.
7512 This is identical to read_signatured_type_reader,
7513 but is kept separate for now. */
7514
7515 static void
7516 load_full_comp_unit_reader (const struct die_reader_specs *reader,
7517 const gdb_byte *info_ptr,
7518 struct die_info *comp_unit_die,
7519 int has_children,
7520 void *data)
7521 {
7522 struct dwarf2_cu *cu = reader->cu;
7523 enum language *language_ptr = data;
7524
7525 gdb_assert (cu->die_hash == NULL);
7526 cu->die_hash =
7527 htab_create_alloc_ex (cu->header.length / 12,
7528 die_hash,
7529 die_eq,
7530 NULL,
7531 &cu->comp_unit_obstack,
7532 hashtab_obstack_allocate,
7533 dummy_obstack_deallocate);
7534
7535 if (has_children)
7536 comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
7537 &info_ptr, comp_unit_die);
7538 cu->dies = comp_unit_die;
7539 /* comp_unit_die is not stored in die_hash, no need. */
7540
7541 /* We try not to read any attributes in this function, because not
7542 all CUs needed for references have been loaded yet, and symbol
7543 table processing isn't initialized. But we have to set the CU language,
7544 or we won't be able to build types correctly.
7545 Similarly, if we do not read the producer, we can not apply
7546 producer-specific interpretation. */
7547 prepare_one_comp_unit (cu, cu->dies, *language_ptr);
7548 }
7549
7550 /* Load the DIEs associated with PER_CU into memory. */
7551
7552 static void
7553 load_full_comp_unit (struct dwarf2_per_cu_data *this_cu,
7554 enum language pretend_language)
7555 {
7556 gdb_assert (! this_cu->is_debug_types);
7557
7558 init_cutu_and_read_dies (this_cu, NULL, 1, 1,
7559 load_full_comp_unit_reader, &pretend_language);
7560 }
7561
7562 /* Add a DIE to the delayed physname list. */
7563
7564 static void
7565 add_to_method_list (struct type *type, int fnfield_index, int index,
7566 const char *name, struct die_info *die,
7567 struct dwarf2_cu *cu)
7568 {
7569 struct delayed_method_info mi;
7570 mi.type = type;
7571 mi.fnfield_index = fnfield_index;
7572 mi.index = index;
7573 mi.name = name;
7574 mi.die = die;
7575 VEC_safe_push (delayed_method_info, cu->method_list, &mi);
7576 }
7577
7578 /* A cleanup for freeing the delayed method list. */
7579
7580 static void
7581 free_delayed_list (void *ptr)
7582 {
7583 struct dwarf2_cu *cu = (struct dwarf2_cu *) ptr;
7584 if (cu->method_list != NULL)
7585 {
7586 VEC_free (delayed_method_info, cu->method_list);
7587 cu->method_list = NULL;
7588 }
7589 }
7590
7591 /* Compute the physnames of any methods on the CU's method list.
7592
7593 The computation of method physnames is delayed in order to avoid the
7594 (bad) condition that one of the method's formal parameters is of an as yet
7595 incomplete type. */
7596
7597 static void
7598 compute_delayed_physnames (struct dwarf2_cu *cu)
7599 {
7600 int i;
7601 struct delayed_method_info *mi;
7602 for (i = 0; VEC_iterate (delayed_method_info, cu->method_list, i, mi) ; ++i)
7603 {
7604 const char *physname;
7605 struct fn_fieldlist *fn_flp
7606 = &TYPE_FN_FIELDLIST (mi->type, mi->fnfield_index);
7607 physname = dwarf2_physname (mi->name, mi->die, cu);
7608 fn_flp->fn_fields[mi->index].physname = physname ? physname : "";
7609 }
7610 }
7611
7612 /* Go objects should be embedded in a DW_TAG_module DIE,
7613 and it's not clear if/how imported objects will appear.
7614 To keep Go support simple until that's worked out,
7615 go back through what we've read and create something usable.
7616 We could do this while processing each DIE, and feels kinda cleaner,
7617 but that way is more invasive.
7618 This is to, for example, allow the user to type "p var" or "b main"
7619 without having to specify the package name, and allow lookups
7620 of module.object to work in contexts that use the expression
7621 parser. */
7622
7623 static void
7624 fixup_go_packaging (struct dwarf2_cu *cu)
7625 {
7626 char *package_name = NULL;
7627 struct pending *list;
7628 int i;
7629
7630 for (list = global_symbols; list != NULL; list = list->next)
7631 {
7632 for (i = 0; i < list->nsyms; ++i)
7633 {
7634 struct symbol *sym = list->symbol[i];
7635
7636 if (SYMBOL_LANGUAGE (sym) == language_go
7637 && SYMBOL_CLASS (sym) == LOC_BLOCK)
7638 {
7639 char *this_package_name = go_symbol_package_name (sym);
7640
7641 if (this_package_name == NULL)
7642 continue;
7643 if (package_name == NULL)
7644 package_name = this_package_name;
7645 else
7646 {
7647 if (strcmp (package_name, this_package_name) != 0)
7648 complaint (&symfile_complaints,
7649 _("Symtab %s has objects from two different Go packages: %s and %s"),
7650 (SYMBOL_SYMTAB (sym)
7651 ? symtab_to_filename_for_display (SYMBOL_SYMTAB (sym))
7652 : objfile_name (cu->objfile)),
7653 this_package_name, package_name);
7654 xfree (this_package_name);
7655 }
7656 }
7657 }
7658 }
7659
7660 if (package_name != NULL)
7661 {
7662 struct objfile *objfile = cu->objfile;
7663 const char *saved_package_name = obstack_copy0 (&objfile->objfile_obstack,
7664 package_name,
7665 strlen (package_name));
7666 struct type *type = init_type (TYPE_CODE_MODULE, 0, 0,
7667 saved_package_name, objfile);
7668 struct symbol *sym;
7669
7670 TYPE_TAG_NAME (type) = TYPE_NAME (type);
7671
7672 sym = allocate_symbol (objfile);
7673 SYMBOL_SET_LANGUAGE (sym, language_go, &objfile->objfile_obstack);
7674 SYMBOL_SET_NAMES (sym, saved_package_name,
7675 strlen (saved_package_name), 0, objfile);
7676 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
7677 e.g., "main" finds the "main" module and not C's main(). */
7678 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
7679 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
7680 SYMBOL_TYPE (sym) = type;
7681
7682 add_symbol_to_list (sym, &global_symbols);
7683
7684 xfree (package_name);
7685 }
7686 }
7687
7688 /* Return the symtab for PER_CU. This works properly regardless of
7689 whether we're using the index or psymtabs. */
7690
7691 static struct symtab *
7692 get_symtab (struct dwarf2_per_cu_data *per_cu)
7693 {
7694 return (dwarf2_per_objfile->using_index
7695 ? per_cu->v.quick->symtab
7696 : per_cu->v.psymtab->symtab);
7697 }
7698
7699 /* A helper function for computing the list of all symbol tables
7700 included by PER_CU. */
7701
7702 static void
7703 recursively_compute_inclusions (VEC (symtab_ptr) **result,
7704 htab_t all_children, htab_t all_type_symtabs,
7705 struct dwarf2_per_cu_data *per_cu,
7706 struct symtab *immediate_parent)
7707 {
7708 void **slot;
7709 int ix;
7710 struct symtab *symtab;
7711 struct dwarf2_per_cu_data *iter;
7712
7713 slot = htab_find_slot (all_children, per_cu, INSERT);
7714 if (*slot != NULL)
7715 {
7716 /* This inclusion and its children have been processed. */
7717 return;
7718 }
7719
7720 *slot = per_cu;
7721 /* Only add a CU if it has a symbol table. */
7722 symtab = get_symtab (per_cu);
7723 if (symtab != NULL)
7724 {
7725 /* If this is a type unit only add its symbol table if we haven't
7726 seen it yet (type unit per_cu's can share symtabs). */
7727 if (per_cu->is_debug_types)
7728 {
7729 slot = htab_find_slot (all_type_symtabs, symtab, INSERT);
7730 if (*slot == NULL)
7731 {
7732 *slot = symtab;
7733 VEC_safe_push (symtab_ptr, *result, symtab);
7734 if (symtab->user == NULL)
7735 symtab->user = immediate_parent;
7736 }
7737 }
7738 else
7739 {
7740 VEC_safe_push (symtab_ptr, *result, symtab);
7741 if (symtab->user == NULL)
7742 symtab->user = immediate_parent;
7743 }
7744 }
7745
7746 for (ix = 0;
7747 VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs, ix, iter);
7748 ++ix)
7749 {
7750 recursively_compute_inclusions (result, all_children,
7751 all_type_symtabs, iter, symtab);
7752 }
7753 }
7754
7755 /* Compute the symtab 'includes' fields for the symtab related to
7756 PER_CU. */
7757
7758 static void
7759 compute_symtab_includes (struct dwarf2_per_cu_data *per_cu)
7760 {
7761 gdb_assert (! per_cu->is_debug_types);
7762
7763 if (!VEC_empty (dwarf2_per_cu_ptr, per_cu->imported_symtabs))
7764 {
7765 int ix, len;
7766 struct dwarf2_per_cu_data *per_cu_iter;
7767 struct symtab *symtab_iter;
7768 VEC (symtab_ptr) *result_symtabs = NULL;
7769 htab_t all_children, all_type_symtabs;
7770 struct symtab *symtab = get_symtab (per_cu);
7771
7772 /* If we don't have a symtab, we can just skip this case. */
7773 if (symtab == NULL)
7774 return;
7775
7776 all_children = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
7777 NULL, xcalloc, xfree);
7778 all_type_symtabs = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
7779 NULL, xcalloc, xfree);
7780
7781 for (ix = 0;
7782 VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs,
7783 ix, per_cu_iter);
7784 ++ix)
7785 {
7786 recursively_compute_inclusions (&result_symtabs, all_children,
7787 all_type_symtabs, per_cu_iter,
7788 symtab);
7789 }
7790
7791 /* Now we have a transitive closure of all the included symtabs. */
7792 len = VEC_length (symtab_ptr, result_symtabs);
7793 symtab->includes
7794 = obstack_alloc (&dwarf2_per_objfile->objfile->objfile_obstack,
7795 (len + 1) * sizeof (struct symtab *));
7796 for (ix = 0;
7797 VEC_iterate (symtab_ptr, result_symtabs, ix, symtab_iter);
7798 ++ix)
7799 symtab->includes[ix] = symtab_iter;
7800 symtab->includes[len] = NULL;
7801
7802 VEC_free (symtab_ptr, result_symtabs);
7803 htab_delete (all_children);
7804 htab_delete (all_type_symtabs);
7805 }
7806 }
7807
7808 /* Compute the 'includes' field for the symtabs of all the CUs we just
7809 read. */
7810
7811 static void
7812 process_cu_includes (void)
7813 {
7814 int ix;
7815 struct dwarf2_per_cu_data *iter;
7816
7817 for (ix = 0;
7818 VEC_iterate (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus,
7819 ix, iter);
7820 ++ix)
7821 {
7822 if (! iter->is_debug_types)
7823 compute_symtab_includes (iter);
7824 }
7825
7826 VEC_free (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus);
7827 }
7828
7829 /* Generate full symbol information for PER_CU, whose DIEs have
7830 already been loaded into memory. */
7831
7832 static void
7833 process_full_comp_unit (struct dwarf2_per_cu_data *per_cu,
7834 enum language pretend_language)
7835 {
7836 struct dwarf2_cu *cu = per_cu->cu;
7837 struct objfile *objfile = per_cu->objfile;
7838 CORE_ADDR lowpc, highpc;
7839 struct symtab *symtab;
7840 struct cleanup *back_to, *delayed_list_cleanup;
7841 CORE_ADDR baseaddr;
7842 struct block *static_block;
7843
7844 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
7845
7846 buildsym_init ();
7847 back_to = make_cleanup (really_free_pendings, NULL);
7848 delayed_list_cleanup = make_cleanup (free_delayed_list, cu);
7849
7850 cu->list_in_scope = &file_symbols;
7851
7852 cu->language = pretend_language;
7853 cu->language_defn = language_def (cu->language);
7854
7855 /* Do line number decoding in read_file_scope () */
7856 process_die (cu->dies, cu);
7857
7858 /* For now fudge the Go package. */
7859 if (cu->language == language_go)
7860 fixup_go_packaging (cu);
7861
7862 /* Now that we have processed all the DIEs in the CU, all the types
7863 should be complete, and it should now be safe to compute all of the
7864 physnames. */
7865 compute_delayed_physnames (cu);
7866 do_cleanups (delayed_list_cleanup);
7867
7868 /* Some compilers don't define a DW_AT_high_pc attribute for the
7869 compilation unit. If the DW_AT_high_pc is missing, synthesize
7870 it, by scanning the DIE's below the compilation unit. */
7871 get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
7872
7873 static_block
7874 = end_symtab_get_static_block (highpc + baseaddr, objfile, 0, 1);
7875
7876 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
7877 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
7878 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
7879 addrmap to help ensure it has an accurate map of pc values belonging to
7880 this comp unit. */
7881 dwarf2_record_block_ranges (cu->dies, static_block, baseaddr, cu);
7882
7883 symtab = end_symtab_from_static_block (static_block, objfile,
7884 SECT_OFF_TEXT (objfile), 0);
7885
7886 if (symtab != NULL)
7887 {
7888 int gcc_4_minor = producer_is_gcc_ge_4 (cu->producer);
7889
7890 /* Set symtab language to language from DW_AT_language. If the
7891 compilation is from a C file generated by language preprocessors, do
7892 not set the language if it was already deduced by start_subfile. */
7893 if (!(cu->language == language_c && symtab->language != language_c))
7894 symtab->language = cu->language;
7895
7896 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
7897 produce DW_AT_location with location lists but it can be possibly
7898 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
7899 there were bugs in prologue debug info, fixed later in GCC-4.5
7900 by "unwind info for epilogues" patch (which is not directly related).
7901
7902 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
7903 needed, it would be wrong due to missing DW_AT_producer there.
7904
7905 Still one can confuse GDB by using non-standard GCC compilation
7906 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
7907 */
7908 if (cu->has_loclist && gcc_4_minor >= 5)
7909 symtab->locations_valid = 1;
7910
7911 if (gcc_4_minor >= 5)
7912 symtab->epilogue_unwind_valid = 1;
7913
7914 symtab->call_site_htab = cu->call_site_htab;
7915 }
7916
7917 if (dwarf2_per_objfile->using_index)
7918 per_cu->v.quick->symtab = symtab;
7919 else
7920 {
7921 struct partial_symtab *pst = per_cu->v.psymtab;
7922 pst->symtab = symtab;
7923 pst->readin = 1;
7924 }
7925
7926 /* Push it for inclusion processing later. */
7927 VEC_safe_push (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus, per_cu);
7928
7929 do_cleanups (back_to);
7930 }
7931
7932 /* Generate full symbol information for type unit PER_CU, whose DIEs have
7933 already been loaded into memory. */
7934
7935 static void
7936 process_full_type_unit (struct dwarf2_per_cu_data *per_cu,
7937 enum language pretend_language)
7938 {
7939 struct dwarf2_cu *cu = per_cu->cu;
7940 struct objfile *objfile = per_cu->objfile;
7941 struct symtab *symtab;
7942 struct cleanup *back_to, *delayed_list_cleanup;
7943 struct signatured_type *sig_type;
7944
7945 gdb_assert (per_cu->is_debug_types);
7946 sig_type = (struct signatured_type *) per_cu;
7947
7948 buildsym_init ();
7949 back_to = make_cleanup (really_free_pendings, NULL);
7950 delayed_list_cleanup = make_cleanup (free_delayed_list, cu);
7951
7952 cu->list_in_scope = &file_symbols;
7953
7954 cu->language = pretend_language;
7955 cu->language_defn = language_def (cu->language);
7956
7957 /* The symbol tables are set up in read_type_unit_scope. */
7958 process_die (cu->dies, cu);
7959
7960 /* For now fudge the Go package. */
7961 if (cu->language == language_go)
7962 fixup_go_packaging (cu);
7963
7964 /* Now that we have processed all the DIEs in the CU, all the types
7965 should be complete, and it should now be safe to compute all of the
7966 physnames. */
7967 compute_delayed_physnames (cu);
7968 do_cleanups (delayed_list_cleanup);
7969
7970 /* TUs share symbol tables.
7971 If this is the first TU to use this symtab, complete the construction
7972 of it with end_expandable_symtab. Otherwise, complete the addition of
7973 this TU's symbols to the existing symtab. */
7974 if (sig_type->type_unit_group->primary_symtab == NULL)
7975 {
7976 symtab = end_expandable_symtab (0, objfile, SECT_OFF_TEXT (objfile));
7977 sig_type->type_unit_group->primary_symtab = symtab;
7978
7979 if (symtab != NULL)
7980 {
7981 /* Set symtab language to language from DW_AT_language. If the
7982 compilation is from a C file generated by language preprocessors,
7983 do not set the language if it was already deduced by
7984 start_subfile. */
7985 if (!(cu->language == language_c && symtab->language != language_c))
7986 symtab->language = cu->language;
7987 }
7988 }
7989 else
7990 {
7991 augment_type_symtab (objfile,
7992 sig_type->type_unit_group->primary_symtab);
7993 symtab = sig_type->type_unit_group->primary_symtab;
7994 }
7995
7996 if (dwarf2_per_objfile->using_index)
7997 per_cu->v.quick->symtab = symtab;
7998 else
7999 {
8000 struct partial_symtab *pst = per_cu->v.psymtab;
8001 pst->symtab = symtab;
8002 pst->readin = 1;
8003 }
8004
8005 do_cleanups (back_to);
8006 }
8007
8008 /* Process an imported unit DIE. */
8009
8010 static void
8011 process_imported_unit_die (struct die_info *die, struct dwarf2_cu *cu)
8012 {
8013 struct attribute *attr;
8014
8015 /* For now we don't handle imported units in type units. */
8016 if (cu->per_cu->is_debug_types)
8017 {
8018 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8019 " supported in type units [in module %s]"),
8020 objfile_name (cu->objfile));
8021 }
8022
8023 attr = dwarf2_attr (die, DW_AT_import, cu);
8024 if (attr != NULL)
8025 {
8026 struct dwarf2_per_cu_data *per_cu;
8027 struct symtab *imported_symtab;
8028 sect_offset offset;
8029 int is_dwz;
8030
8031 offset = dwarf2_get_ref_die_offset (attr);
8032 is_dwz = (attr->form == DW_FORM_GNU_ref_alt || cu->per_cu->is_dwz);
8033 per_cu = dwarf2_find_containing_comp_unit (offset, is_dwz, cu->objfile);
8034
8035 /* If necessary, add it to the queue and load its DIEs. */
8036 if (maybe_queue_comp_unit (cu, per_cu, cu->language))
8037 load_full_comp_unit (per_cu, cu->language);
8038
8039 VEC_safe_push (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
8040 per_cu);
8041 }
8042 }
8043
8044 /* Reset the in_process bit of a die. */
8045
8046 static void
8047 reset_die_in_process (void *arg)
8048 {
8049 struct die_info *die = arg;
8050
8051 die->in_process = 0;
8052 }
8053
8054 /* Process a die and its children. */
8055
8056 static void
8057 process_die (struct die_info *die, struct dwarf2_cu *cu)
8058 {
8059 struct cleanup *in_process;
8060
8061 /* We should only be processing those not already in process. */
8062 gdb_assert (!die->in_process);
8063
8064 die->in_process = 1;
8065 in_process = make_cleanup (reset_die_in_process,die);
8066
8067 switch (die->tag)
8068 {
8069 case DW_TAG_padding:
8070 break;
8071 case DW_TAG_compile_unit:
8072 case DW_TAG_partial_unit:
8073 read_file_scope (die, cu);
8074 break;
8075 case DW_TAG_type_unit:
8076 read_type_unit_scope (die, cu);
8077 break;
8078 case DW_TAG_subprogram:
8079 case DW_TAG_inlined_subroutine:
8080 read_func_scope (die, cu);
8081 break;
8082 case DW_TAG_lexical_block:
8083 case DW_TAG_try_block:
8084 case DW_TAG_catch_block:
8085 read_lexical_block_scope (die, cu);
8086 break;
8087 case DW_TAG_GNU_call_site:
8088 read_call_site_scope (die, cu);
8089 break;
8090 case DW_TAG_class_type:
8091 case DW_TAG_interface_type:
8092 case DW_TAG_structure_type:
8093 case DW_TAG_union_type:
8094 process_structure_scope (die, cu);
8095 break;
8096 case DW_TAG_enumeration_type:
8097 process_enumeration_scope (die, cu);
8098 break;
8099
8100 /* These dies have a type, but processing them does not create
8101 a symbol or recurse to process the children. Therefore we can
8102 read them on-demand through read_type_die. */
8103 case DW_TAG_subroutine_type:
8104 case DW_TAG_set_type:
8105 case DW_TAG_array_type:
8106 case DW_TAG_pointer_type:
8107 case DW_TAG_ptr_to_member_type:
8108 case DW_TAG_reference_type:
8109 case DW_TAG_string_type:
8110 break;
8111
8112 case DW_TAG_base_type:
8113 case DW_TAG_subrange_type:
8114 case DW_TAG_typedef:
8115 /* Add a typedef symbol for the type definition, if it has a
8116 DW_AT_name. */
8117 new_symbol (die, read_type_die (die, cu), cu);
8118 break;
8119 case DW_TAG_common_block:
8120 read_common_block (die, cu);
8121 break;
8122 case DW_TAG_common_inclusion:
8123 break;
8124 case DW_TAG_namespace:
8125 cu->processing_has_namespace_info = 1;
8126 read_namespace (die, cu);
8127 break;
8128 case DW_TAG_module:
8129 cu->processing_has_namespace_info = 1;
8130 read_module (die, cu);
8131 break;
8132 case DW_TAG_imported_declaration:
8133 cu->processing_has_namespace_info = 1;
8134 if (read_namespace_alias (die, cu))
8135 break;
8136 /* The declaration is not a global namespace alias: fall through. */
8137 case DW_TAG_imported_module:
8138 cu->processing_has_namespace_info = 1;
8139 if (die->child != NULL && (die->tag == DW_TAG_imported_declaration
8140 || cu->language != language_fortran))
8141 complaint (&symfile_complaints, _("Tag '%s' has unexpected children"),
8142 dwarf_tag_name (die->tag));
8143 read_import_statement (die, cu);
8144 break;
8145
8146 case DW_TAG_imported_unit:
8147 process_imported_unit_die (die, cu);
8148 break;
8149
8150 default:
8151 new_symbol (die, NULL, cu);
8152 break;
8153 }
8154
8155 do_cleanups (in_process);
8156 }
8157 \f
8158 /* DWARF name computation. */
8159
8160 /* A helper function for dwarf2_compute_name which determines whether DIE
8161 needs to have the name of the scope prepended to the name listed in the
8162 die. */
8163
8164 static int
8165 die_needs_namespace (struct die_info *die, struct dwarf2_cu *cu)
8166 {
8167 struct attribute *attr;
8168
8169 switch (die->tag)
8170 {
8171 case DW_TAG_namespace:
8172 case DW_TAG_typedef:
8173 case DW_TAG_class_type:
8174 case DW_TAG_interface_type:
8175 case DW_TAG_structure_type:
8176 case DW_TAG_union_type:
8177 case DW_TAG_enumeration_type:
8178 case DW_TAG_enumerator:
8179 case DW_TAG_subprogram:
8180 case DW_TAG_member:
8181 case DW_TAG_imported_declaration:
8182 return 1;
8183
8184 case DW_TAG_variable:
8185 case DW_TAG_constant:
8186 /* We only need to prefix "globally" visible variables. These include
8187 any variable marked with DW_AT_external or any variable that
8188 lives in a namespace. [Variables in anonymous namespaces
8189 require prefixing, but they are not DW_AT_external.] */
8190
8191 if (dwarf2_attr (die, DW_AT_specification, cu))
8192 {
8193 struct dwarf2_cu *spec_cu = cu;
8194
8195 return die_needs_namespace (die_specification (die, &spec_cu),
8196 spec_cu);
8197 }
8198
8199 attr = dwarf2_attr (die, DW_AT_external, cu);
8200 if (attr == NULL && die->parent->tag != DW_TAG_namespace
8201 && die->parent->tag != DW_TAG_module)
8202 return 0;
8203 /* A variable in a lexical block of some kind does not need a
8204 namespace, even though in C++ such variables may be external
8205 and have a mangled name. */
8206 if (die->parent->tag == DW_TAG_lexical_block
8207 || die->parent->tag == DW_TAG_try_block
8208 || die->parent->tag == DW_TAG_catch_block
8209 || die->parent->tag == DW_TAG_subprogram)
8210 return 0;
8211 return 1;
8212
8213 default:
8214 return 0;
8215 }
8216 }
8217
8218 /* Retrieve the last character from a mem_file. */
8219
8220 static void
8221 do_ui_file_peek_last (void *object, const char *buffer, long length)
8222 {
8223 char *last_char_p = (char *) object;
8224
8225 if (length > 0)
8226 *last_char_p = buffer[length - 1];
8227 }
8228
8229 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
8230 compute the physname for the object, which include a method's:
8231 - formal parameters (C++/Java),
8232 - receiver type (Go),
8233 - return type (Java).
8234
8235 The term "physname" is a bit confusing.
8236 For C++, for example, it is the demangled name.
8237 For Go, for example, it's the mangled name.
8238
8239 For Ada, return the DIE's linkage name rather than the fully qualified
8240 name. PHYSNAME is ignored..
8241
8242 The result is allocated on the objfile_obstack and canonicalized. */
8243
8244 static const char *
8245 dwarf2_compute_name (const char *name,
8246 struct die_info *die, struct dwarf2_cu *cu,
8247 int physname)
8248 {
8249 struct objfile *objfile = cu->objfile;
8250
8251 if (name == NULL)
8252 name = dwarf2_name (die, cu);
8253
8254 /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
8255 compute it by typename_concat inside GDB. */
8256 if (cu->language == language_ada
8257 || (cu->language == language_fortran && physname))
8258 {
8259 /* For Ada unit, we prefer the linkage name over the name, as
8260 the former contains the exported name, which the user expects
8261 to be able to reference. Ideally, we want the user to be able
8262 to reference this entity using either natural or linkage name,
8263 but we haven't started looking at this enhancement yet. */
8264 struct attribute *attr;
8265
8266 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
8267 if (attr == NULL)
8268 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
8269 if (attr && DW_STRING (attr))
8270 return DW_STRING (attr);
8271 }
8272
8273 /* These are the only languages we know how to qualify names in. */
8274 if (name != NULL
8275 && (cu->language == language_cplus || cu->language == language_java
8276 || cu->language == language_fortran))
8277 {
8278 if (die_needs_namespace (die, cu))
8279 {
8280 long length;
8281 const char *prefix;
8282 struct ui_file *buf;
8283
8284 prefix = determine_prefix (die, cu);
8285 buf = mem_fileopen ();
8286 if (*prefix != '\0')
8287 {
8288 char *prefixed_name = typename_concat (NULL, prefix, name,
8289 physname, cu);
8290
8291 fputs_unfiltered (prefixed_name, buf);
8292 xfree (prefixed_name);
8293 }
8294 else
8295 fputs_unfiltered (name, buf);
8296
8297 /* Template parameters may be specified in the DIE's DW_AT_name, or
8298 as children with DW_TAG_template_type_param or
8299 DW_TAG_value_type_param. If the latter, add them to the name
8300 here. If the name already has template parameters, then
8301 skip this step; some versions of GCC emit both, and
8302 it is more efficient to use the pre-computed name.
8303
8304 Something to keep in mind about this process: it is very
8305 unlikely, or in some cases downright impossible, to produce
8306 something that will match the mangled name of a function.
8307 If the definition of the function has the same debug info,
8308 we should be able to match up with it anyway. But fallbacks
8309 using the minimal symbol, for instance to find a method
8310 implemented in a stripped copy of libstdc++, will not work.
8311 If we do not have debug info for the definition, we will have to
8312 match them up some other way.
8313
8314 When we do name matching there is a related problem with function
8315 templates; two instantiated function templates are allowed to
8316 differ only by their return types, which we do not add here. */
8317
8318 if (cu->language == language_cplus && strchr (name, '<') == NULL)
8319 {
8320 struct attribute *attr;
8321 struct die_info *child;
8322 int first = 1;
8323
8324 die->building_fullname = 1;
8325
8326 for (child = die->child; child != NULL; child = child->sibling)
8327 {
8328 struct type *type;
8329 LONGEST value;
8330 const gdb_byte *bytes;
8331 struct dwarf2_locexpr_baton *baton;
8332 struct value *v;
8333
8334 if (child->tag != DW_TAG_template_type_param
8335 && child->tag != DW_TAG_template_value_param)
8336 continue;
8337
8338 if (first)
8339 {
8340 fputs_unfiltered ("<", buf);
8341 first = 0;
8342 }
8343 else
8344 fputs_unfiltered (", ", buf);
8345
8346 attr = dwarf2_attr (child, DW_AT_type, cu);
8347 if (attr == NULL)
8348 {
8349 complaint (&symfile_complaints,
8350 _("template parameter missing DW_AT_type"));
8351 fputs_unfiltered ("UNKNOWN_TYPE", buf);
8352 continue;
8353 }
8354 type = die_type (child, cu);
8355
8356 if (child->tag == DW_TAG_template_type_param)
8357 {
8358 c_print_type (type, "", buf, -1, 0, &type_print_raw_options);
8359 continue;
8360 }
8361
8362 attr = dwarf2_attr (child, DW_AT_const_value, cu);
8363 if (attr == NULL)
8364 {
8365 complaint (&symfile_complaints,
8366 _("template parameter missing "
8367 "DW_AT_const_value"));
8368 fputs_unfiltered ("UNKNOWN_VALUE", buf);
8369 continue;
8370 }
8371
8372 dwarf2_const_value_attr (attr, type, name,
8373 &cu->comp_unit_obstack, cu,
8374 &value, &bytes, &baton);
8375
8376 if (TYPE_NOSIGN (type))
8377 /* GDB prints characters as NUMBER 'CHAR'. If that's
8378 changed, this can use value_print instead. */
8379 c_printchar (value, type, buf);
8380 else
8381 {
8382 struct value_print_options opts;
8383
8384 if (baton != NULL)
8385 v = dwarf2_evaluate_loc_desc (type, NULL,
8386 baton->data,
8387 baton->size,
8388 baton->per_cu);
8389 else if (bytes != NULL)
8390 {
8391 v = allocate_value (type);
8392 memcpy (value_contents_writeable (v), bytes,
8393 TYPE_LENGTH (type));
8394 }
8395 else
8396 v = value_from_longest (type, value);
8397
8398 /* Specify decimal so that we do not depend on
8399 the radix. */
8400 get_formatted_print_options (&opts, 'd');
8401 opts.raw = 1;
8402 value_print (v, buf, &opts);
8403 release_value (v);
8404 value_free (v);
8405 }
8406 }
8407
8408 die->building_fullname = 0;
8409
8410 if (!first)
8411 {
8412 /* Close the argument list, with a space if necessary
8413 (nested templates). */
8414 char last_char = '\0';
8415 ui_file_put (buf, do_ui_file_peek_last, &last_char);
8416 if (last_char == '>')
8417 fputs_unfiltered (" >", buf);
8418 else
8419 fputs_unfiltered (">", buf);
8420 }
8421 }
8422
8423 /* For Java and C++ methods, append formal parameter type
8424 information, if PHYSNAME. */
8425
8426 if (physname && die->tag == DW_TAG_subprogram
8427 && (cu->language == language_cplus
8428 || cu->language == language_java))
8429 {
8430 struct type *type = read_type_die (die, cu);
8431
8432 c_type_print_args (type, buf, 1, cu->language,
8433 &type_print_raw_options);
8434
8435 if (cu->language == language_java)
8436 {
8437 /* For java, we must append the return type to method
8438 names. */
8439 if (die->tag == DW_TAG_subprogram)
8440 java_print_type (TYPE_TARGET_TYPE (type), "", buf,
8441 0, 0, &type_print_raw_options);
8442 }
8443 else if (cu->language == language_cplus)
8444 {
8445 /* Assume that an artificial first parameter is
8446 "this", but do not crash if it is not. RealView
8447 marks unnamed (and thus unused) parameters as
8448 artificial; there is no way to differentiate
8449 the two cases. */
8450 if (TYPE_NFIELDS (type) > 0
8451 && TYPE_FIELD_ARTIFICIAL (type, 0)
8452 && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_PTR
8453 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type,
8454 0))))
8455 fputs_unfiltered (" const", buf);
8456 }
8457 }
8458
8459 name = ui_file_obsavestring (buf, &objfile->objfile_obstack,
8460 &length);
8461 ui_file_delete (buf);
8462
8463 if (cu->language == language_cplus)
8464 {
8465 const char *cname
8466 = dwarf2_canonicalize_name (name, cu,
8467 &objfile->objfile_obstack);
8468
8469 if (cname != NULL)
8470 name = cname;
8471 }
8472 }
8473 }
8474
8475 return name;
8476 }
8477
8478 /* Return the fully qualified name of DIE, based on its DW_AT_name.
8479 If scope qualifiers are appropriate they will be added. The result
8480 will be allocated on the objfile_obstack, or NULL if the DIE does
8481 not have a name. NAME may either be from a previous call to
8482 dwarf2_name or NULL.
8483
8484 The output string will be canonicalized (if C++/Java). */
8485
8486 static const char *
8487 dwarf2_full_name (const char *name, struct die_info *die, struct dwarf2_cu *cu)
8488 {
8489 return dwarf2_compute_name (name, die, cu, 0);
8490 }
8491
8492 /* Construct a physname for the given DIE in CU. NAME may either be
8493 from a previous call to dwarf2_name or NULL. The result will be
8494 allocated on the objfile_objstack or NULL if the DIE does not have a
8495 name.
8496
8497 The output string will be canonicalized (if C++/Java). */
8498
8499 static const char *
8500 dwarf2_physname (const char *name, struct die_info *die, struct dwarf2_cu *cu)
8501 {
8502 struct objfile *objfile = cu->objfile;
8503 struct attribute *attr;
8504 const char *retval, *mangled = NULL, *canon = NULL;
8505 struct cleanup *back_to;
8506 int need_copy = 1;
8507
8508 /* In this case dwarf2_compute_name is just a shortcut not building anything
8509 on its own. */
8510 if (!die_needs_namespace (die, cu))
8511 return dwarf2_compute_name (name, die, cu, 1);
8512
8513 back_to = make_cleanup (null_cleanup, NULL);
8514
8515 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
8516 if (!attr)
8517 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
8518
8519 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
8520 has computed. */
8521 if (attr && DW_STRING (attr))
8522 {
8523 char *demangled;
8524
8525 mangled = DW_STRING (attr);
8526
8527 /* Use DMGL_RET_DROP for C++ template functions to suppress their return
8528 type. It is easier for GDB users to search for such functions as
8529 `name(params)' than `long name(params)'. In such case the minimal
8530 symbol names do not match the full symbol names but for template
8531 functions there is never a need to look up their definition from their
8532 declaration so the only disadvantage remains the minimal symbol
8533 variant `long name(params)' does not have the proper inferior type.
8534 */
8535
8536 if (cu->language == language_go)
8537 {
8538 /* This is a lie, but we already lie to the caller new_symbol_full.
8539 new_symbol_full assumes we return the mangled name.
8540 This just undoes that lie until things are cleaned up. */
8541 demangled = NULL;
8542 }
8543 else
8544 {
8545 demangled = gdb_demangle (mangled,
8546 (DMGL_PARAMS | DMGL_ANSI
8547 | (cu->language == language_java
8548 ? DMGL_JAVA | DMGL_RET_POSTFIX
8549 : DMGL_RET_DROP)));
8550 }
8551 if (demangled)
8552 {
8553 make_cleanup (xfree, demangled);
8554 canon = demangled;
8555 }
8556 else
8557 {
8558 canon = mangled;
8559 need_copy = 0;
8560 }
8561 }
8562
8563 if (canon == NULL || check_physname)
8564 {
8565 const char *physname = dwarf2_compute_name (name, die, cu, 1);
8566
8567 if (canon != NULL && strcmp (physname, canon) != 0)
8568 {
8569 /* It may not mean a bug in GDB. The compiler could also
8570 compute DW_AT_linkage_name incorrectly. But in such case
8571 GDB would need to be bug-to-bug compatible. */
8572
8573 complaint (&symfile_complaints,
8574 _("Computed physname <%s> does not match demangled <%s> "
8575 "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
8576 physname, canon, mangled, die->offset.sect_off,
8577 objfile_name (objfile));
8578
8579 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
8580 is available here - over computed PHYSNAME. It is safer
8581 against both buggy GDB and buggy compilers. */
8582
8583 retval = canon;
8584 }
8585 else
8586 {
8587 retval = physname;
8588 need_copy = 0;
8589 }
8590 }
8591 else
8592 retval = canon;
8593
8594 if (need_copy)
8595 retval = obstack_copy0 (&objfile->objfile_obstack, retval, strlen (retval));
8596
8597 do_cleanups (back_to);
8598 return retval;
8599 }
8600
8601 /* Inspect DIE in CU for a namespace alias. If one exists, record
8602 a new symbol for it.
8603
8604 Returns 1 if a namespace alias was recorded, 0 otherwise. */
8605
8606 static int
8607 read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu)
8608 {
8609 struct attribute *attr;
8610
8611 /* If the die does not have a name, this is not a namespace
8612 alias. */
8613 attr = dwarf2_attr (die, DW_AT_name, cu);
8614 if (attr != NULL)
8615 {
8616 int num;
8617 struct die_info *d = die;
8618 struct dwarf2_cu *imported_cu = cu;
8619
8620 /* If the compiler has nested DW_AT_imported_declaration DIEs,
8621 keep inspecting DIEs until we hit the underlying import. */
8622 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
8623 for (num = 0; num < MAX_NESTED_IMPORTED_DECLARATIONS; ++num)
8624 {
8625 attr = dwarf2_attr (d, DW_AT_import, cu);
8626 if (attr == NULL)
8627 break;
8628
8629 d = follow_die_ref (d, attr, &imported_cu);
8630 if (d->tag != DW_TAG_imported_declaration)
8631 break;
8632 }
8633
8634 if (num == MAX_NESTED_IMPORTED_DECLARATIONS)
8635 {
8636 complaint (&symfile_complaints,
8637 _("DIE at 0x%x has too many recursively imported "
8638 "declarations"), d->offset.sect_off);
8639 return 0;
8640 }
8641
8642 if (attr != NULL)
8643 {
8644 struct type *type;
8645 sect_offset offset = dwarf2_get_ref_die_offset (attr);
8646
8647 type = get_die_type_at_offset (offset, cu->per_cu);
8648 if (type != NULL && TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
8649 {
8650 /* This declaration is a global namespace alias. Add
8651 a symbol for it whose type is the aliased namespace. */
8652 new_symbol (die, type, cu);
8653 return 1;
8654 }
8655 }
8656 }
8657
8658 return 0;
8659 }
8660
8661 /* Read the import statement specified by the given die and record it. */
8662
8663 static void
8664 read_import_statement (struct die_info *die, struct dwarf2_cu *cu)
8665 {
8666 struct objfile *objfile = cu->objfile;
8667 struct attribute *import_attr;
8668 struct die_info *imported_die, *child_die;
8669 struct dwarf2_cu *imported_cu;
8670 const char *imported_name;
8671 const char *imported_name_prefix;
8672 const char *canonical_name;
8673 const char *import_alias;
8674 const char *imported_declaration = NULL;
8675 const char *import_prefix;
8676 VEC (const_char_ptr) *excludes = NULL;
8677 struct cleanup *cleanups;
8678
8679 import_attr = dwarf2_attr (die, DW_AT_import, cu);
8680 if (import_attr == NULL)
8681 {
8682 complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
8683 dwarf_tag_name (die->tag));
8684 return;
8685 }
8686
8687 imported_cu = cu;
8688 imported_die = follow_die_ref_or_sig (die, import_attr, &imported_cu);
8689 imported_name = dwarf2_name (imported_die, imported_cu);
8690 if (imported_name == NULL)
8691 {
8692 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
8693
8694 The import in the following code:
8695 namespace A
8696 {
8697 typedef int B;
8698 }
8699
8700 int main ()
8701 {
8702 using A::B;
8703 B b;
8704 return b;
8705 }
8706
8707 ...
8708 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
8709 <52> DW_AT_decl_file : 1
8710 <53> DW_AT_decl_line : 6
8711 <54> DW_AT_import : <0x75>
8712 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
8713 <59> DW_AT_name : B
8714 <5b> DW_AT_decl_file : 1
8715 <5c> DW_AT_decl_line : 2
8716 <5d> DW_AT_type : <0x6e>
8717 ...
8718 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
8719 <76> DW_AT_byte_size : 4
8720 <77> DW_AT_encoding : 5 (signed)
8721
8722 imports the wrong die ( 0x75 instead of 0x58 ).
8723 This case will be ignored until the gcc bug is fixed. */
8724 return;
8725 }
8726
8727 /* Figure out the local name after import. */
8728 import_alias = dwarf2_name (die, cu);
8729
8730 /* Figure out where the statement is being imported to. */
8731 import_prefix = determine_prefix (die, cu);
8732
8733 /* Figure out what the scope of the imported die is and prepend it
8734 to the name of the imported die. */
8735 imported_name_prefix = determine_prefix (imported_die, imported_cu);
8736
8737 if (imported_die->tag != DW_TAG_namespace
8738 && imported_die->tag != DW_TAG_module)
8739 {
8740 imported_declaration = imported_name;
8741 canonical_name = imported_name_prefix;
8742 }
8743 else if (strlen (imported_name_prefix) > 0)
8744 canonical_name = obconcat (&objfile->objfile_obstack,
8745 imported_name_prefix, "::", imported_name,
8746 (char *) NULL);
8747 else
8748 canonical_name = imported_name;
8749
8750 cleanups = make_cleanup (VEC_cleanup (const_char_ptr), &excludes);
8751
8752 if (die->tag == DW_TAG_imported_module && cu->language == language_fortran)
8753 for (child_die = die->child; child_die && child_die->tag;
8754 child_die = sibling_die (child_die))
8755 {
8756 /* DWARF-4: A Fortran use statement with a “rename list” may be
8757 represented by an imported module entry with an import attribute
8758 referring to the module and owned entries corresponding to those
8759 entities that are renamed as part of being imported. */
8760
8761 if (child_die->tag != DW_TAG_imported_declaration)
8762 {
8763 complaint (&symfile_complaints,
8764 _("child DW_TAG_imported_declaration expected "
8765 "- DIE at 0x%x [in module %s]"),
8766 child_die->offset.sect_off, objfile_name (objfile));
8767 continue;
8768 }
8769
8770 import_attr = dwarf2_attr (child_die, DW_AT_import, cu);
8771 if (import_attr == NULL)
8772 {
8773 complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
8774 dwarf_tag_name (child_die->tag));
8775 continue;
8776 }
8777
8778 imported_cu = cu;
8779 imported_die = follow_die_ref_or_sig (child_die, import_attr,
8780 &imported_cu);
8781 imported_name = dwarf2_name (imported_die, imported_cu);
8782 if (imported_name == NULL)
8783 {
8784 complaint (&symfile_complaints,
8785 _("child DW_TAG_imported_declaration has unknown "
8786 "imported name - DIE at 0x%x [in module %s]"),
8787 child_die->offset.sect_off, objfile_name (objfile));
8788 continue;
8789 }
8790
8791 VEC_safe_push (const_char_ptr, excludes, imported_name);
8792
8793 process_die (child_die, cu);
8794 }
8795
8796 cp_add_using_directive (import_prefix,
8797 canonical_name,
8798 import_alias,
8799 imported_declaration,
8800 excludes,
8801 0,
8802 &objfile->objfile_obstack);
8803
8804 do_cleanups (cleanups);
8805 }
8806
8807 /* Cleanup function for handle_DW_AT_stmt_list. */
8808
8809 static void
8810 free_cu_line_header (void *arg)
8811 {
8812 struct dwarf2_cu *cu = arg;
8813
8814 free_line_header (cu->line_header);
8815 cu->line_header = NULL;
8816 }
8817
8818 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
8819 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
8820 this, it was first present in GCC release 4.3.0. */
8821
8822 static int
8823 producer_is_gcc_lt_4_3 (struct dwarf2_cu *cu)
8824 {
8825 if (!cu->checked_producer)
8826 check_producer (cu);
8827
8828 return cu->producer_is_gcc_lt_4_3;
8829 }
8830
8831 static void
8832 find_file_and_directory (struct die_info *die, struct dwarf2_cu *cu,
8833 const char **name, const char **comp_dir)
8834 {
8835 struct attribute *attr;
8836
8837 *name = NULL;
8838 *comp_dir = NULL;
8839
8840 /* Find the filename. Do not use dwarf2_name here, since the filename
8841 is not a source language identifier. */
8842 attr = dwarf2_attr (die, DW_AT_name, cu);
8843 if (attr)
8844 {
8845 *name = DW_STRING (attr);
8846 }
8847
8848 attr = dwarf2_attr (die, DW_AT_comp_dir, cu);
8849 if (attr)
8850 *comp_dir = DW_STRING (attr);
8851 else if (producer_is_gcc_lt_4_3 (cu) && *name != NULL
8852 && IS_ABSOLUTE_PATH (*name))
8853 {
8854 char *d = ldirname (*name);
8855
8856 *comp_dir = d;
8857 if (d != NULL)
8858 make_cleanup (xfree, d);
8859 }
8860 if (*comp_dir != NULL)
8861 {
8862 /* Irix 6.2 native cc prepends <machine>.: to the compilation
8863 directory, get rid of it. */
8864 char *cp = strchr (*comp_dir, ':');
8865
8866 if (cp && cp != *comp_dir && cp[-1] == '.' && cp[1] == '/')
8867 *comp_dir = cp + 1;
8868 }
8869
8870 if (*name == NULL)
8871 *name = "<unknown>";
8872 }
8873
8874 /* Handle DW_AT_stmt_list for a compilation unit.
8875 DIE is the DW_TAG_compile_unit die for CU.
8876 COMP_DIR is the compilation directory.
8877 WANT_LINE_INFO is non-zero if the pc/line-number mapping is needed. */
8878
8879 static void
8880 handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
8881 const char *comp_dir) /* ARI: editCase function */
8882 {
8883 struct attribute *attr;
8884
8885 gdb_assert (! cu->per_cu->is_debug_types);
8886
8887 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
8888 if (attr)
8889 {
8890 unsigned int line_offset = DW_UNSND (attr);
8891 struct line_header *line_header
8892 = dwarf_decode_line_header (line_offset, cu);
8893
8894 if (line_header)
8895 {
8896 cu->line_header = line_header;
8897 make_cleanup (free_cu_line_header, cu);
8898 dwarf_decode_lines (line_header, comp_dir, cu, NULL, 1);
8899 }
8900 }
8901 }
8902
8903 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
8904
8905 static void
8906 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
8907 {
8908 struct objfile *objfile = dwarf2_per_objfile->objfile;
8909 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
8910 CORE_ADDR lowpc = ((CORE_ADDR) -1);
8911 CORE_ADDR highpc = ((CORE_ADDR) 0);
8912 struct attribute *attr;
8913 const char *name = NULL;
8914 const char *comp_dir = NULL;
8915 struct die_info *child_die;
8916 bfd *abfd = objfile->obfd;
8917 CORE_ADDR baseaddr;
8918
8919 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
8920
8921 get_scope_pc_bounds (die, &lowpc, &highpc, cu);
8922
8923 /* If we didn't find a lowpc, set it to highpc to avoid complaints
8924 from finish_block. */
8925 if (lowpc == ((CORE_ADDR) -1))
8926 lowpc = highpc;
8927 lowpc += baseaddr;
8928 highpc += baseaddr;
8929
8930 find_file_and_directory (die, cu, &name, &comp_dir);
8931
8932 prepare_one_comp_unit (cu, die, cu->language);
8933
8934 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
8935 standardised yet. As a workaround for the language detection we fall
8936 back to the DW_AT_producer string. */
8937 if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL") != NULL)
8938 cu->language = language_opencl;
8939
8940 /* Similar hack for Go. */
8941 if (cu->producer && strstr (cu->producer, "GNU Go ") != NULL)
8942 set_cu_language (DW_LANG_Go, cu);
8943
8944 dwarf2_start_symtab (cu, name, comp_dir, lowpc);
8945
8946 /* Decode line number information if present. We do this before
8947 processing child DIEs, so that the line header table is available
8948 for DW_AT_decl_file. */
8949 handle_DW_AT_stmt_list (die, cu, comp_dir);
8950
8951 /* Process all dies in compilation unit. */
8952 if (die->child != NULL)
8953 {
8954 child_die = die->child;
8955 while (child_die && child_die->tag)
8956 {
8957 process_die (child_die, cu);
8958 child_die = sibling_die (child_die);
8959 }
8960 }
8961
8962 /* Decode macro information, if present. Dwarf 2 macro information
8963 refers to information in the line number info statement program
8964 header, so we can only read it if we've read the header
8965 successfully. */
8966 attr = dwarf2_attr (die, DW_AT_GNU_macros, cu);
8967 if (attr && cu->line_header)
8968 {
8969 if (dwarf2_attr (die, DW_AT_macro_info, cu))
8970 complaint (&symfile_complaints,
8971 _("CU refers to both DW_AT_GNU_macros and DW_AT_macro_info"));
8972
8973 dwarf_decode_macros (cu, DW_UNSND (attr), comp_dir, 1);
8974 }
8975 else
8976 {
8977 attr = dwarf2_attr (die, DW_AT_macro_info, cu);
8978 if (attr && cu->line_header)
8979 {
8980 unsigned int macro_offset = DW_UNSND (attr);
8981
8982 dwarf_decode_macros (cu, macro_offset, comp_dir, 0);
8983 }
8984 }
8985
8986 do_cleanups (back_to);
8987 }
8988
8989 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
8990 Create the set of symtabs used by this TU, or if this TU is sharing
8991 symtabs with another TU and the symtabs have already been created
8992 then restore those symtabs in the line header.
8993 We don't need the pc/line-number mapping for type units. */
8994
8995 static void
8996 setup_type_unit_groups (struct die_info *die, struct dwarf2_cu *cu)
8997 {
8998 struct objfile *objfile = dwarf2_per_objfile->objfile;
8999 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
9000 struct type_unit_group *tu_group;
9001 int first_time;
9002 struct line_header *lh;
9003 struct attribute *attr;
9004 unsigned int i, line_offset;
9005 struct signatured_type *sig_type;
9006
9007 gdb_assert (per_cu->is_debug_types);
9008 sig_type = (struct signatured_type *) per_cu;
9009
9010 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
9011
9012 /* If we're using .gdb_index (includes -readnow) then
9013 per_cu->type_unit_group may not have been set up yet. */
9014 if (sig_type->type_unit_group == NULL)
9015 sig_type->type_unit_group = get_type_unit_group (cu, attr);
9016 tu_group = sig_type->type_unit_group;
9017
9018 /* If we've already processed this stmt_list there's no real need to
9019 do it again, we could fake it and just recreate the part we need
9020 (file name,index -> symtab mapping). If data shows this optimization
9021 is useful we can do it then. */
9022 first_time = tu_group->primary_symtab == NULL;
9023
9024 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
9025 debug info. */
9026 lh = NULL;
9027 if (attr != NULL)
9028 {
9029 line_offset = DW_UNSND (attr);
9030 lh = dwarf_decode_line_header (line_offset, cu);
9031 }
9032 if (lh == NULL)
9033 {
9034 if (first_time)
9035 dwarf2_start_symtab (cu, "", NULL, 0);
9036 else
9037 {
9038 gdb_assert (tu_group->symtabs == NULL);
9039 restart_symtab (0);
9040 }
9041 /* Note: The primary symtab will get allocated at the end. */
9042 return;
9043 }
9044
9045 cu->line_header = lh;
9046 make_cleanup (free_cu_line_header, cu);
9047
9048 if (first_time)
9049 {
9050 dwarf2_start_symtab (cu, "", NULL, 0);
9051
9052 tu_group->num_symtabs = lh->num_file_names;
9053 tu_group->symtabs = XNEWVEC (struct symtab *, lh->num_file_names);
9054
9055 for (i = 0; i < lh->num_file_names; ++i)
9056 {
9057 const char *dir = NULL;
9058 struct file_entry *fe = &lh->file_names[i];
9059
9060 if (fe->dir_index)
9061 dir = lh->include_dirs[fe->dir_index - 1];
9062 dwarf2_start_subfile (fe->name, dir, NULL);
9063
9064 /* Note: We don't have to watch for the main subfile here, type units
9065 don't have DW_AT_name. */
9066
9067 if (current_subfile->symtab == NULL)
9068 {
9069 /* NOTE: start_subfile will recognize when it's been passed
9070 a file it has already seen. So we can't assume there's a
9071 simple mapping from lh->file_names to subfiles,
9072 lh->file_names may contain dups. */
9073 current_subfile->symtab = allocate_symtab (current_subfile->name,
9074 objfile);
9075 }
9076
9077 fe->symtab = current_subfile->symtab;
9078 tu_group->symtabs[i] = fe->symtab;
9079 }
9080 }
9081 else
9082 {
9083 restart_symtab (0);
9084
9085 for (i = 0; i < lh->num_file_names; ++i)
9086 {
9087 struct file_entry *fe = &lh->file_names[i];
9088
9089 fe->symtab = tu_group->symtabs[i];
9090 }
9091 }
9092
9093 /* The main symtab is allocated last. Type units don't have DW_AT_name
9094 so they don't have a "real" (so to speak) symtab anyway.
9095 There is later code that will assign the main symtab to all symbols
9096 that don't have one. We need to handle the case of a symbol with a
9097 missing symtab (DW_AT_decl_file) anyway. */
9098 }
9099
9100 /* Process DW_TAG_type_unit.
9101 For TUs we want to skip the first top level sibling if it's not the
9102 actual type being defined by this TU. In this case the first top
9103 level sibling is there to provide context only. */
9104
9105 static void
9106 read_type_unit_scope (struct die_info *die, struct dwarf2_cu *cu)
9107 {
9108 struct die_info *child_die;
9109
9110 prepare_one_comp_unit (cu, die, language_minimal);
9111
9112 /* Initialize (or reinitialize) the machinery for building symtabs.
9113 We do this before processing child DIEs, so that the line header table
9114 is available for DW_AT_decl_file. */
9115 setup_type_unit_groups (die, cu);
9116
9117 if (die->child != NULL)
9118 {
9119 child_die = die->child;
9120 while (child_die && child_die->tag)
9121 {
9122 process_die (child_die, cu);
9123 child_die = sibling_die (child_die);
9124 }
9125 }
9126 }
9127 \f
9128 /* DWO/DWP files.
9129
9130 http://gcc.gnu.org/wiki/DebugFission
9131 http://gcc.gnu.org/wiki/DebugFissionDWP
9132
9133 To simplify handling of both DWO files ("object" files with the DWARF info)
9134 and DWP files (a file with the DWOs packaged up into one file), we treat
9135 DWP files as having a collection of virtual DWO files. */
9136
9137 static hashval_t
9138 hash_dwo_file (const void *item)
9139 {
9140 const struct dwo_file *dwo_file = item;
9141 hashval_t hash;
9142
9143 hash = htab_hash_string (dwo_file->dwo_name);
9144 if (dwo_file->comp_dir != NULL)
9145 hash += htab_hash_string (dwo_file->comp_dir);
9146 return hash;
9147 }
9148
9149 static int
9150 eq_dwo_file (const void *item_lhs, const void *item_rhs)
9151 {
9152 const struct dwo_file *lhs = item_lhs;
9153 const struct dwo_file *rhs = item_rhs;
9154
9155 if (strcmp (lhs->dwo_name, rhs->dwo_name) != 0)
9156 return 0;
9157 if (lhs->comp_dir == NULL || rhs->comp_dir == NULL)
9158 return lhs->comp_dir == rhs->comp_dir;
9159 return strcmp (lhs->comp_dir, rhs->comp_dir) == 0;
9160 }
9161
9162 /* Allocate a hash table for DWO files. */
9163
9164 static htab_t
9165 allocate_dwo_file_hash_table (void)
9166 {
9167 struct objfile *objfile = dwarf2_per_objfile->objfile;
9168
9169 return htab_create_alloc_ex (41,
9170 hash_dwo_file,
9171 eq_dwo_file,
9172 NULL,
9173 &objfile->objfile_obstack,
9174 hashtab_obstack_allocate,
9175 dummy_obstack_deallocate);
9176 }
9177
9178 /* Lookup DWO file DWO_NAME. */
9179
9180 static void **
9181 lookup_dwo_file_slot (const char *dwo_name, const char *comp_dir)
9182 {
9183 struct dwo_file find_entry;
9184 void **slot;
9185
9186 if (dwarf2_per_objfile->dwo_files == NULL)
9187 dwarf2_per_objfile->dwo_files = allocate_dwo_file_hash_table ();
9188
9189 memset (&find_entry, 0, sizeof (find_entry));
9190 find_entry.dwo_name = dwo_name;
9191 find_entry.comp_dir = comp_dir;
9192 slot = htab_find_slot (dwarf2_per_objfile->dwo_files, &find_entry, INSERT);
9193
9194 return slot;
9195 }
9196
9197 static hashval_t
9198 hash_dwo_unit (const void *item)
9199 {
9200 const struct dwo_unit *dwo_unit = item;
9201
9202 /* This drops the top 32 bits of the id, but is ok for a hash. */
9203 return dwo_unit->signature;
9204 }
9205
9206 static int
9207 eq_dwo_unit (const void *item_lhs, const void *item_rhs)
9208 {
9209 const struct dwo_unit *lhs = item_lhs;
9210 const struct dwo_unit *rhs = item_rhs;
9211
9212 /* The signature is assumed to be unique within the DWO file.
9213 So while object file CU dwo_id's always have the value zero,
9214 that's OK, assuming each object file DWO file has only one CU,
9215 and that's the rule for now. */
9216 return lhs->signature == rhs->signature;
9217 }
9218
9219 /* Allocate a hash table for DWO CUs,TUs.
9220 There is one of these tables for each of CUs,TUs for each DWO file. */
9221
9222 static htab_t
9223 allocate_dwo_unit_table (struct objfile *objfile)
9224 {
9225 /* Start out with a pretty small number.
9226 Generally DWO files contain only one CU and maybe some TUs. */
9227 return htab_create_alloc_ex (3,
9228 hash_dwo_unit,
9229 eq_dwo_unit,
9230 NULL,
9231 &objfile->objfile_obstack,
9232 hashtab_obstack_allocate,
9233 dummy_obstack_deallocate);
9234 }
9235
9236 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader. */
9237
9238 struct create_dwo_cu_data
9239 {
9240 struct dwo_file *dwo_file;
9241 struct dwo_unit dwo_unit;
9242 };
9243
9244 /* die_reader_func for create_dwo_cu. */
9245
9246 static void
9247 create_dwo_cu_reader (const struct die_reader_specs *reader,
9248 const gdb_byte *info_ptr,
9249 struct die_info *comp_unit_die,
9250 int has_children,
9251 void *datap)
9252 {
9253 struct dwarf2_cu *cu = reader->cu;
9254 struct objfile *objfile = dwarf2_per_objfile->objfile;
9255 sect_offset offset = cu->per_cu->offset;
9256 struct dwarf2_section_info *section = cu->per_cu->section;
9257 struct create_dwo_cu_data *data = datap;
9258 struct dwo_file *dwo_file = data->dwo_file;
9259 struct dwo_unit *dwo_unit = &data->dwo_unit;
9260 struct attribute *attr;
9261
9262 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
9263 if (attr == NULL)
9264 {
9265 complaint (&symfile_complaints,
9266 _("Dwarf Error: debug entry at offset 0x%x is missing"
9267 " its dwo_id [in module %s]"),
9268 offset.sect_off, dwo_file->dwo_name);
9269 return;
9270 }
9271
9272 dwo_unit->dwo_file = dwo_file;
9273 dwo_unit->signature = DW_UNSND (attr);
9274 dwo_unit->section = section;
9275 dwo_unit->offset = offset;
9276 dwo_unit->length = cu->per_cu->length;
9277
9278 if (dwarf2_read_debug)
9279 fprintf_unfiltered (gdb_stdlog, " offset 0x%x, dwo_id %s\n",
9280 offset.sect_off, hex_string (dwo_unit->signature));
9281 }
9282
9283 /* Create the dwo_unit for the lone CU in DWO_FILE.
9284 Note: This function processes DWO files only, not DWP files. */
9285
9286 static struct dwo_unit *
9287 create_dwo_cu (struct dwo_file *dwo_file)
9288 {
9289 struct objfile *objfile = dwarf2_per_objfile->objfile;
9290 struct dwarf2_section_info *section = &dwo_file->sections.info;
9291 bfd *abfd;
9292 htab_t cu_htab;
9293 const gdb_byte *info_ptr, *end_ptr;
9294 struct create_dwo_cu_data create_dwo_cu_data;
9295 struct dwo_unit *dwo_unit;
9296
9297 dwarf2_read_section (objfile, section);
9298 info_ptr = section->buffer;
9299
9300 if (info_ptr == NULL)
9301 return NULL;
9302
9303 /* We can't set abfd until now because the section may be empty or
9304 not present, in which case section->asection will be NULL. */
9305 abfd = get_section_bfd_owner (section);
9306
9307 if (dwarf2_read_debug)
9308 {
9309 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
9310 get_section_name (section),
9311 get_section_file_name (section));
9312 }
9313
9314 create_dwo_cu_data.dwo_file = dwo_file;
9315 dwo_unit = NULL;
9316
9317 end_ptr = info_ptr + section->size;
9318 while (info_ptr < end_ptr)
9319 {
9320 struct dwarf2_per_cu_data per_cu;
9321
9322 memset (&create_dwo_cu_data.dwo_unit, 0,
9323 sizeof (create_dwo_cu_data.dwo_unit));
9324 memset (&per_cu, 0, sizeof (per_cu));
9325 per_cu.objfile = objfile;
9326 per_cu.is_debug_types = 0;
9327 per_cu.offset.sect_off = info_ptr - section->buffer;
9328 per_cu.section = section;
9329
9330 init_cutu_and_read_dies_no_follow (&per_cu, dwo_file,
9331 create_dwo_cu_reader,
9332 &create_dwo_cu_data);
9333
9334 if (create_dwo_cu_data.dwo_unit.dwo_file != NULL)
9335 {
9336 /* If we've already found one, complain. We only support one
9337 because having more than one requires hacking the dwo_name of
9338 each to match, which is highly unlikely to happen. */
9339 if (dwo_unit != NULL)
9340 {
9341 complaint (&symfile_complaints,
9342 _("Multiple CUs in DWO file %s [in module %s]"),
9343 dwo_file->dwo_name, objfile_name (objfile));
9344 break;
9345 }
9346
9347 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
9348 *dwo_unit = create_dwo_cu_data.dwo_unit;
9349 }
9350
9351 info_ptr += per_cu.length;
9352 }
9353
9354 return dwo_unit;
9355 }
9356
9357 /* DWP file .debug_{cu,tu}_index section format:
9358 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
9359
9360 DWP Version 1:
9361
9362 Both index sections have the same format, and serve to map a 64-bit
9363 signature to a set of section numbers. Each section begins with a header,
9364 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
9365 indexes, and a pool of 32-bit section numbers. The index sections will be
9366 aligned at 8-byte boundaries in the file.
9367
9368 The index section header consists of:
9369
9370 V, 32 bit version number
9371 -, 32 bits unused
9372 N, 32 bit number of compilation units or type units in the index
9373 M, 32 bit number of slots in the hash table
9374
9375 Numbers are recorded using the byte order of the application binary.
9376
9377 The hash table begins at offset 16 in the section, and consists of an array
9378 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
9379 order of the application binary). Unused slots in the hash table are 0.
9380 (We rely on the extreme unlikeliness of a signature being exactly 0.)
9381
9382 The parallel table begins immediately after the hash table
9383 (at offset 16 + 8 * M from the beginning of the section), and consists of an
9384 array of 32-bit indexes (using the byte order of the application binary),
9385 corresponding 1-1 with slots in the hash table. Each entry in the parallel
9386 table contains a 32-bit index into the pool of section numbers. For unused
9387 hash table slots, the corresponding entry in the parallel table will be 0.
9388
9389 The pool of section numbers begins immediately following the hash table
9390 (at offset 16 + 12 * M from the beginning of the section). The pool of
9391 section numbers consists of an array of 32-bit words (using the byte order
9392 of the application binary). Each item in the array is indexed starting
9393 from 0. The hash table entry provides the index of the first section
9394 number in the set. Additional section numbers in the set follow, and the
9395 set is terminated by a 0 entry (section number 0 is not used in ELF).
9396
9397 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
9398 section must be the first entry in the set, and the .debug_abbrev.dwo must
9399 be the second entry. Other members of the set may follow in any order.
9400
9401 ---
9402
9403 DWP Version 2:
9404
9405 DWP Version 2 combines all the .debug_info, etc. sections into one,
9406 and the entries in the index tables are now offsets into these sections.
9407 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
9408 section.
9409
9410 Index Section Contents:
9411 Header
9412 Hash Table of Signatures dwp_hash_table.hash_table
9413 Parallel Table of Indices dwp_hash_table.unit_table
9414 Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets}
9415 Table of Section Sizes dwp_hash_table.v2.sizes
9416
9417 The index section header consists of:
9418
9419 V, 32 bit version number
9420 L, 32 bit number of columns in the table of section offsets
9421 N, 32 bit number of compilation units or type units in the index
9422 M, 32 bit number of slots in the hash table
9423
9424 Numbers are recorded using the byte order of the application binary.
9425
9426 The hash table has the same format as version 1.
9427 The parallel table of indices has the same format as version 1,
9428 except that the entries are origin-1 indices into the table of sections
9429 offsets and the table of section sizes.
9430
9431 The table of offsets begins immediately following the parallel table
9432 (at offset 16 + 12 * M from the beginning of the section). The table is
9433 a two-dimensional array of 32-bit words (using the byte order of the
9434 application binary), with L columns and N+1 rows, in row-major order.
9435 Each row in the array is indexed starting from 0. The first row provides
9436 a key to the remaining rows: each column in this row provides an identifier
9437 for a debug section, and the offsets in the same column of subsequent rows
9438 refer to that section. The section identifiers are:
9439
9440 DW_SECT_INFO 1 .debug_info.dwo
9441 DW_SECT_TYPES 2 .debug_types.dwo
9442 DW_SECT_ABBREV 3 .debug_abbrev.dwo
9443 DW_SECT_LINE 4 .debug_line.dwo
9444 DW_SECT_LOC 5 .debug_loc.dwo
9445 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
9446 DW_SECT_MACINFO 7 .debug_macinfo.dwo
9447 DW_SECT_MACRO 8 .debug_macro.dwo
9448
9449 The offsets provided by the CU and TU index sections are the base offsets
9450 for the contributions made by each CU or TU to the corresponding section
9451 in the package file. Each CU and TU header contains an abbrev_offset
9452 field, used to find the abbreviations table for that CU or TU within the
9453 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
9454 be interpreted as relative to the base offset given in the index section.
9455 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
9456 should be interpreted as relative to the base offset for .debug_line.dwo,
9457 and offsets into other debug sections obtained from DWARF attributes should
9458 also be interpreted as relative to the corresponding base offset.
9459
9460 The table of sizes begins immediately following the table of offsets.
9461 Like the table of offsets, it is a two-dimensional array of 32-bit words,
9462 with L columns and N rows, in row-major order. Each row in the array is
9463 indexed starting from 1 (row 0 is shared by the two tables).
9464
9465 ---
9466
9467 Hash table lookup is handled the same in version 1 and 2:
9468
9469 We assume that N and M will not exceed 2^32 - 1.
9470 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
9471
9472 Given a 64-bit compilation unit signature or a type signature S, an entry
9473 in the hash table is located as follows:
9474
9475 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
9476 the low-order k bits all set to 1.
9477
9478 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
9479
9480 3) If the hash table entry at index H matches the signature, use that
9481 entry. If the hash table entry at index H is unused (all zeroes),
9482 terminate the search: the signature is not present in the table.
9483
9484 4) Let H = (H + H') modulo M. Repeat at Step 3.
9485
9486 Because M > N and H' and M are relatively prime, the search is guaranteed
9487 to stop at an unused slot or find the match. */
9488
9489 /* Create a hash table to map DWO IDs to their CU/TU entry in
9490 .debug_{info,types}.dwo in DWP_FILE.
9491 Returns NULL if there isn't one.
9492 Note: This function processes DWP files only, not DWO files. */
9493
9494 static struct dwp_hash_table *
9495 create_dwp_hash_table (struct dwp_file *dwp_file, int is_debug_types)
9496 {
9497 struct objfile *objfile = dwarf2_per_objfile->objfile;
9498 bfd *dbfd = dwp_file->dbfd;
9499 const gdb_byte *index_ptr, *index_end;
9500 struct dwarf2_section_info *index;
9501 uint32_t version, nr_columns, nr_units, nr_slots;
9502 struct dwp_hash_table *htab;
9503
9504 if (is_debug_types)
9505 index = &dwp_file->sections.tu_index;
9506 else
9507 index = &dwp_file->sections.cu_index;
9508
9509 if (dwarf2_section_empty_p (index))
9510 return NULL;
9511 dwarf2_read_section (objfile, index);
9512
9513 index_ptr = index->buffer;
9514 index_end = index_ptr + index->size;
9515
9516 version = read_4_bytes (dbfd, index_ptr);
9517 index_ptr += 4;
9518 if (version == 2)
9519 nr_columns = read_4_bytes (dbfd, index_ptr);
9520 else
9521 nr_columns = 0;
9522 index_ptr += 4;
9523 nr_units = read_4_bytes (dbfd, index_ptr);
9524 index_ptr += 4;
9525 nr_slots = read_4_bytes (dbfd, index_ptr);
9526 index_ptr += 4;
9527
9528 if (version != 1 && version != 2)
9529 {
9530 error (_("Dwarf Error: unsupported DWP file version (%s)"
9531 " [in module %s]"),
9532 pulongest (version), dwp_file->name);
9533 }
9534 if (nr_slots != (nr_slots & -nr_slots))
9535 {
9536 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
9537 " is not power of 2 [in module %s]"),
9538 pulongest (nr_slots), dwp_file->name);
9539 }
9540
9541 htab = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_hash_table);
9542 htab->version = version;
9543 htab->nr_columns = nr_columns;
9544 htab->nr_units = nr_units;
9545 htab->nr_slots = nr_slots;
9546 htab->hash_table = index_ptr;
9547 htab->unit_table = htab->hash_table + sizeof (uint64_t) * nr_slots;
9548
9549 /* Exit early if the table is empty. */
9550 if (nr_slots == 0 || nr_units == 0
9551 || (version == 2 && nr_columns == 0))
9552 {
9553 /* All must be zero. */
9554 if (nr_slots != 0 || nr_units != 0
9555 || (version == 2 && nr_columns != 0))
9556 {
9557 complaint (&symfile_complaints,
9558 _("Empty DWP but nr_slots,nr_units,nr_columns not"
9559 " all zero [in modules %s]"),
9560 dwp_file->name);
9561 }
9562 return htab;
9563 }
9564
9565 if (version == 1)
9566 {
9567 htab->section_pool.v1.indices =
9568 htab->unit_table + sizeof (uint32_t) * nr_slots;
9569 /* It's harder to decide whether the section is too small in v1.
9570 V1 is deprecated anyway so we punt. */
9571 }
9572 else
9573 {
9574 const gdb_byte *ids_ptr = htab->unit_table + sizeof (uint32_t) * nr_slots;
9575 int *ids = htab->section_pool.v2.section_ids;
9576 /* Reverse map for error checking. */
9577 int ids_seen[DW_SECT_MAX + 1];
9578 int i;
9579
9580 if (nr_columns < 2)
9581 {
9582 error (_("Dwarf Error: bad DWP hash table, too few columns"
9583 " in section table [in module %s]"),
9584 dwp_file->name);
9585 }
9586 if (nr_columns > MAX_NR_V2_DWO_SECTIONS)
9587 {
9588 error (_("Dwarf Error: bad DWP hash table, too many columns"
9589 " in section table [in module %s]"),
9590 dwp_file->name);
9591 }
9592 memset (ids, 255, (DW_SECT_MAX + 1) * sizeof (int32_t));
9593 memset (ids_seen, 255, (DW_SECT_MAX + 1) * sizeof (int32_t));
9594 for (i = 0; i < nr_columns; ++i)
9595 {
9596 int id = read_4_bytes (dbfd, ids_ptr + i * sizeof (uint32_t));
9597
9598 if (id < DW_SECT_MIN || id > DW_SECT_MAX)
9599 {
9600 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
9601 " in section table [in module %s]"),
9602 id, dwp_file->name);
9603 }
9604 if (ids_seen[id] != -1)
9605 {
9606 error (_("Dwarf Error: bad DWP hash table, duplicate section"
9607 " id %d in section table [in module %s]"),
9608 id, dwp_file->name);
9609 }
9610 ids_seen[id] = i;
9611 ids[i] = id;
9612 }
9613 /* Must have exactly one info or types section. */
9614 if (((ids_seen[DW_SECT_INFO] != -1)
9615 + (ids_seen[DW_SECT_TYPES] != -1))
9616 != 1)
9617 {
9618 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
9619 " DWO info/types section [in module %s]"),
9620 dwp_file->name);
9621 }
9622 /* Must have an abbrev section. */
9623 if (ids_seen[DW_SECT_ABBREV] == -1)
9624 {
9625 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
9626 " section [in module %s]"),
9627 dwp_file->name);
9628 }
9629 htab->section_pool.v2.offsets = ids_ptr + sizeof (uint32_t) * nr_columns;
9630 htab->section_pool.v2.sizes =
9631 htab->section_pool.v2.offsets + (sizeof (uint32_t)
9632 * nr_units * nr_columns);
9633 if ((htab->section_pool.v2.sizes + (sizeof (uint32_t)
9634 * nr_units * nr_columns))
9635 > index_end)
9636 {
9637 error (_("Dwarf Error: DWP index section is corrupt (too small)"
9638 " [in module %s]"),
9639 dwp_file->name);
9640 }
9641 }
9642
9643 return htab;
9644 }
9645
9646 /* Update SECTIONS with the data from SECTP.
9647
9648 This function is like the other "locate" section routines that are
9649 passed to bfd_map_over_sections, but in this context the sections to
9650 read comes from the DWP V1 hash table, not the full ELF section table.
9651
9652 The result is non-zero for success, or zero if an error was found. */
9653
9654 static int
9655 locate_v1_virtual_dwo_sections (asection *sectp,
9656 struct virtual_v1_dwo_sections *sections)
9657 {
9658 const struct dwop_section_names *names = &dwop_section_names;
9659
9660 if (section_is_p (sectp->name, &names->abbrev_dwo))
9661 {
9662 /* There can be only one. */
9663 if (sections->abbrev.s.asection != NULL)
9664 return 0;
9665 sections->abbrev.s.asection = sectp;
9666 sections->abbrev.size = bfd_get_section_size (sectp);
9667 }
9668 else if (section_is_p (sectp->name, &names->info_dwo)
9669 || section_is_p (sectp->name, &names->types_dwo))
9670 {
9671 /* There can be only one. */
9672 if (sections->info_or_types.s.asection != NULL)
9673 return 0;
9674 sections->info_or_types.s.asection = sectp;
9675 sections->info_or_types.size = bfd_get_section_size (sectp);
9676 }
9677 else if (section_is_p (sectp->name, &names->line_dwo))
9678 {
9679 /* There can be only one. */
9680 if (sections->line.s.asection != NULL)
9681 return 0;
9682 sections->line.s.asection = sectp;
9683 sections->line.size = bfd_get_section_size (sectp);
9684 }
9685 else if (section_is_p (sectp->name, &names->loc_dwo))
9686 {
9687 /* There can be only one. */
9688 if (sections->loc.s.asection != NULL)
9689 return 0;
9690 sections->loc.s.asection = sectp;
9691 sections->loc.size = bfd_get_section_size (sectp);
9692 }
9693 else if (section_is_p (sectp->name, &names->macinfo_dwo))
9694 {
9695 /* There can be only one. */
9696 if (sections->macinfo.s.asection != NULL)
9697 return 0;
9698 sections->macinfo.s.asection = sectp;
9699 sections->macinfo.size = bfd_get_section_size (sectp);
9700 }
9701 else if (section_is_p (sectp->name, &names->macro_dwo))
9702 {
9703 /* There can be only one. */
9704 if (sections->macro.s.asection != NULL)
9705 return 0;
9706 sections->macro.s.asection = sectp;
9707 sections->macro.size = bfd_get_section_size (sectp);
9708 }
9709 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
9710 {
9711 /* There can be only one. */
9712 if (sections->str_offsets.s.asection != NULL)
9713 return 0;
9714 sections->str_offsets.s.asection = sectp;
9715 sections->str_offsets.size = bfd_get_section_size (sectp);
9716 }
9717 else
9718 {
9719 /* No other kind of section is valid. */
9720 return 0;
9721 }
9722
9723 return 1;
9724 }
9725
9726 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
9727 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
9728 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
9729 This is for DWP version 1 files. */
9730
9731 static struct dwo_unit *
9732 create_dwo_unit_in_dwp_v1 (struct dwp_file *dwp_file,
9733 uint32_t unit_index,
9734 const char *comp_dir,
9735 ULONGEST signature, int is_debug_types)
9736 {
9737 struct objfile *objfile = dwarf2_per_objfile->objfile;
9738 const struct dwp_hash_table *dwp_htab =
9739 is_debug_types ? dwp_file->tus : dwp_file->cus;
9740 bfd *dbfd = dwp_file->dbfd;
9741 const char *kind = is_debug_types ? "TU" : "CU";
9742 struct dwo_file *dwo_file;
9743 struct dwo_unit *dwo_unit;
9744 struct virtual_v1_dwo_sections sections;
9745 void **dwo_file_slot;
9746 char *virtual_dwo_name;
9747 struct dwarf2_section_info *cutu;
9748 struct cleanup *cleanups;
9749 int i;
9750
9751 gdb_assert (dwp_file->version == 1);
9752
9753 if (dwarf2_read_debug)
9754 {
9755 fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V1 file: %s\n",
9756 kind,
9757 pulongest (unit_index), hex_string (signature),
9758 dwp_file->name);
9759 }
9760
9761 /* Fetch the sections of this DWO unit.
9762 Put a limit on the number of sections we look for so that bad data
9763 doesn't cause us to loop forever. */
9764
9765 #define MAX_NR_V1_DWO_SECTIONS \
9766 (1 /* .debug_info or .debug_types */ \
9767 + 1 /* .debug_abbrev */ \
9768 + 1 /* .debug_line */ \
9769 + 1 /* .debug_loc */ \
9770 + 1 /* .debug_str_offsets */ \
9771 + 1 /* .debug_macro or .debug_macinfo */ \
9772 + 1 /* trailing zero */)
9773
9774 memset (&sections, 0, sizeof (sections));
9775 cleanups = make_cleanup (null_cleanup, 0);
9776
9777 for (i = 0; i < MAX_NR_V1_DWO_SECTIONS; ++i)
9778 {
9779 asection *sectp;
9780 uint32_t section_nr =
9781 read_4_bytes (dbfd,
9782 dwp_htab->section_pool.v1.indices
9783 + (unit_index + i) * sizeof (uint32_t));
9784
9785 if (section_nr == 0)
9786 break;
9787 if (section_nr >= dwp_file->num_sections)
9788 {
9789 error (_("Dwarf Error: bad DWP hash table, section number too large"
9790 " [in module %s]"),
9791 dwp_file->name);
9792 }
9793
9794 sectp = dwp_file->elf_sections[section_nr];
9795 if (! locate_v1_virtual_dwo_sections (sectp, &sections))
9796 {
9797 error (_("Dwarf Error: bad DWP hash table, invalid section found"
9798 " [in module %s]"),
9799 dwp_file->name);
9800 }
9801 }
9802
9803 if (i < 2
9804 || dwarf2_section_empty_p (&sections.info_or_types)
9805 || dwarf2_section_empty_p (&sections.abbrev))
9806 {
9807 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
9808 " [in module %s]"),
9809 dwp_file->name);
9810 }
9811 if (i == MAX_NR_V1_DWO_SECTIONS)
9812 {
9813 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
9814 " [in module %s]"),
9815 dwp_file->name);
9816 }
9817
9818 /* It's easier for the rest of the code if we fake a struct dwo_file and
9819 have dwo_unit "live" in that. At least for now.
9820
9821 The DWP file can be made up of a random collection of CUs and TUs.
9822 However, for each CU + set of TUs that came from the same original DWO
9823 file, we can combine them back into a virtual DWO file to save space
9824 (fewer struct dwo_file objects to allocate). Remember that for really
9825 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
9826
9827 virtual_dwo_name =
9828 xstrprintf ("virtual-dwo/%d-%d-%d-%d",
9829 get_section_id (&sections.abbrev),
9830 get_section_id (&sections.line),
9831 get_section_id (&sections.loc),
9832 get_section_id (&sections.str_offsets));
9833 make_cleanup (xfree, virtual_dwo_name);
9834 /* Can we use an existing virtual DWO file? */
9835 dwo_file_slot = lookup_dwo_file_slot (virtual_dwo_name, comp_dir);
9836 /* Create one if necessary. */
9837 if (*dwo_file_slot == NULL)
9838 {
9839 if (dwarf2_read_debug)
9840 {
9841 fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
9842 virtual_dwo_name);
9843 }
9844 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
9845 dwo_file->dwo_name = obstack_copy0 (&objfile->objfile_obstack,
9846 virtual_dwo_name,
9847 strlen (virtual_dwo_name));
9848 dwo_file->comp_dir = comp_dir;
9849 dwo_file->sections.abbrev = sections.abbrev;
9850 dwo_file->sections.line = sections.line;
9851 dwo_file->sections.loc = sections.loc;
9852 dwo_file->sections.macinfo = sections.macinfo;
9853 dwo_file->sections.macro = sections.macro;
9854 dwo_file->sections.str_offsets = sections.str_offsets;
9855 /* The "str" section is global to the entire DWP file. */
9856 dwo_file->sections.str = dwp_file->sections.str;
9857 /* The info or types section is assigned below to dwo_unit,
9858 there's no need to record it in dwo_file.
9859 Also, we can't simply record type sections in dwo_file because
9860 we record a pointer into the vector in dwo_unit. As we collect more
9861 types we'll grow the vector and eventually have to reallocate space
9862 for it, invalidating all copies of pointers into the previous
9863 contents. */
9864 *dwo_file_slot = dwo_file;
9865 }
9866 else
9867 {
9868 if (dwarf2_read_debug)
9869 {
9870 fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
9871 virtual_dwo_name);
9872 }
9873 dwo_file = *dwo_file_slot;
9874 }
9875 do_cleanups (cleanups);
9876
9877 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
9878 dwo_unit->dwo_file = dwo_file;
9879 dwo_unit->signature = signature;
9880 dwo_unit->section = obstack_alloc (&objfile->objfile_obstack,
9881 sizeof (struct dwarf2_section_info));
9882 *dwo_unit->section = sections.info_or_types;
9883 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
9884
9885 return dwo_unit;
9886 }
9887
9888 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
9889 Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
9890 piece within that section used by a TU/CU, return a virtual section
9891 of just that piece. */
9892
9893 static struct dwarf2_section_info
9894 create_dwp_v2_section (struct dwarf2_section_info *section,
9895 bfd_size_type offset, bfd_size_type size)
9896 {
9897 struct dwarf2_section_info result;
9898 asection *sectp;
9899
9900 gdb_assert (section != NULL);
9901 gdb_assert (!section->is_virtual);
9902
9903 memset (&result, 0, sizeof (result));
9904 result.s.containing_section = section;
9905 result.is_virtual = 1;
9906
9907 if (size == 0)
9908 return result;
9909
9910 sectp = get_section_bfd_section (section);
9911
9912 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
9913 bounds of the real section. This is a pretty-rare event, so just
9914 flag an error (easier) instead of a warning and trying to cope. */
9915 if (sectp == NULL
9916 || offset + size > bfd_get_section_size (sectp))
9917 {
9918 bfd *abfd = sectp->owner;
9919
9920 error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
9921 " in section %s [in module %s]"),
9922 sectp ? bfd_section_name (abfd, sectp) : "<unknown>",
9923 objfile_name (dwarf2_per_objfile->objfile));
9924 }
9925
9926 result.virtual_offset = offset;
9927 result.size = size;
9928 return result;
9929 }
9930
9931 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
9932 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
9933 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
9934 This is for DWP version 2 files. */
9935
9936 static struct dwo_unit *
9937 create_dwo_unit_in_dwp_v2 (struct dwp_file *dwp_file,
9938 uint32_t unit_index,
9939 const char *comp_dir,
9940 ULONGEST signature, int is_debug_types)
9941 {
9942 struct objfile *objfile = dwarf2_per_objfile->objfile;
9943 const struct dwp_hash_table *dwp_htab =
9944 is_debug_types ? dwp_file->tus : dwp_file->cus;
9945 bfd *dbfd = dwp_file->dbfd;
9946 const char *kind = is_debug_types ? "TU" : "CU";
9947 struct dwo_file *dwo_file;
9948 struct dwo_unit *dwo_unit;
9949 struct virtual_v2_dwo_sections sections;
9950 void **dwo_file_slot;
9951 char *virtual_dwo_name;
9952 struct dwarf2_section_info *cutu;
9953 struct cleanup *cleanups;
9954 int i;
9955
9956 gdb_assert (dwp_file->version == 2);
9957
9958 if (dwarf2_read_debug)
9959 {
9960 fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V2 file: %s\n",
9961 kind,
9962 pulongest (unit_index), hex_string (signature),
9963 dwp_file->name);
9964 }
9965
9966 /* Fetch the section offsets of this DWO unit. */
9967
9968 memset (&sections, 0, sizeof (sections));
9969 cleanups = make_cleanup (null_cleanup, 0);
9970
9971 for (i = 0; i < dwp_htab->nr_columns; ++i)
9972 {
9973 uint32_t offset = read_4_bytes (dbfd,
9974 dwp_htab->section_pool.v2.offsets
9975 + (((unit_index - 1) * dwp_htab->nr_columns
9976 + i)
9977 * sizeof (uint32_t)));
9978 uint32_t size = read_4_bytes (dbfd,
9979 dwp_htab->section_pool.v2.sizes
9980 + (((unit_index - 1) * dwp_htab->nr_columns
9981 + i)
9982 * sizeof (uint32_t)));
9983
9984 switch (dwp_htab->section_pool.v2.section_ids[i])
9985 {
9986 case DW_SECT_INFO:
9987 case DW_SECT_TYPES:
9988 sections.info_or_types_offset = offset;
9989 sections.info_or_types_size = size;
9990 break;
9991 case DW_SECT_ABBREV:
9992 sections.abbrev_offset = offset;
9993 sections.abbrev_size = size;
9994 break;
9995 case DW_SECT_LINE:
9996 sections.line_offset = offset;
9997 sections.line_size = size;
9998 break;
9999 case DW_SECT_LOC:
10000 sections.loc_offset = offset;
10001 sections.loc_size = size;
10002 break;
10003 case DW_SECT_STR_OFFSETS:
10004 sections.str_offsets_offset = offset;
10005 sections.str_offsets_size = size;
10006 break;
10007 case DW_SECT_MACINFO:
10008 sections.macinfo_offset = offset;
10009 sections.macinfo_size = size;
10010 break;
10011 case DW_SECT_MACRO:
10012 sections.macro_offset = offset;
10013 sections.macro_size = size;
10014 break;
10015 }
10016 }
10017
10018 /* It's easier for the rest of the code if we fake a struct dwo_file and
10019 have dwo_unit "live" in that. At least for now.
10020
10021 The DWP file can be made up of a random collection of CUs and TUs.
10022 However, for each CU + set of TUs that came from the same original DWO
10023 file, we can combine them back into a virtual DWO file to save space
10024 (fewer struct dwo_file objects to allocate). Remember that for really
10025 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
10026
10027 virtual_dwo_name =
10028 xstrprintf ("virtual-dwo/%ld-%ld-%ld-%ld",
10029 (long) (sections.abbrev_size ? sections.abbrev_offset : 0),
10030 (long) (sections.line_size ? sections.line_offset : 0),
10031 (long) (sections.loc_size ? sections.loc_offset : 0),
10032 (long) (sections.str_offsets_size
10033 ? sections.str_offsets_offset : 0));
10034 make_cleanup (xfree, virtual_dwo_name);
10035 /* Can we use an existing virtual DWO file? */
10036 dwo_file_slot = lookup_dwo_file_slot (virtual_dwo_name, comp_dir);
10037 /* Create one if necessary. */
10038 if (*dwo_file_slot == NULL)
10039 {
10040 if (dwarf2_read_debug)
10041 {
10042 fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
10043 virtual_dwo_name);
10044 }
10045 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
10046 dwo_file->dwo_name = obstack_copy0 (&objfile->objfile_obstack,
10047 virtual_dwo_name,
10048 strlen (virtual_dwo_name));
10049 dwo_file->comp_dir = comp_dir;
10050 dwo_file->sections.abbrev =
10051 create_dwp_v2_section (&dwp_file->sections.abbrev,
10052 sections.abbrev_offset, sections.abbrev_size);
10053 dwo_file->sections.line =
10054 create_dwp_v2_section (&dwp_file->sections.line,
10055 sections.line_offset, sections.line_size);
10056 dwo_file->sections.loc =
10057 create_dwp_v2_section (&dwp_file->sections.loc,
10058 sections.loc_offset, sections.loc_size);
10059 dwo_file->sections.macinfo =
10060 create_dwp_v2_section (&dwp_file->sections.macinfo,
10061 sections.macinfo_offset, sections.macinfo_size);
10062 dwo_file->sections.macro =
10063 create_dwp_v2_section (&dwp_file->sections.macro,
10064 sections.macro_offset, sections.macro_size);
10065 dwo_file->sections.str_offsets =
10066 create_dwp_v2_section (&dwp_file->sections.str_offsets,
10067 sections.str_offsets_offset,
10068 sections.str_offsets_size);
10069 /* The "str" section is global to the entire DWP file. */
10070 dwo_file->sections.str = dwp_file->sections.str;
10071 /* The info or types section is assigned below to dwo_unit,
10072 there's no need to record it in dwo_file.
10073 Also, we can't simply record type sections in dwo_file because
10074 we record a pointer into the vector in dwo_unit. As we collect more
10075 types we'll grow the vector and eventually have to reallocate space
10076 for it, invalidating all copies of pointers into the previous
10077 contents. */
10078 *dwo_file_slot = dwo_file;
10079 }
10080 else
10081 {
10082 if (dwarf2_read_debug)
10083 {
10084 fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
10085 virtual_dwo_name);
10086 }
10087 dwo_file = *dwo_file_slot;
10088 }
10089 do_cleanups (cleanups);
10090
10091 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
10092 dwo_unit->dwo_file = dwo_file;
10093 dwo_unit->signature = signature;
10094 dwo_unit->section = obstack_alloc (&objfile->objfile_obstack,
10095 sizeof (struct dwarf2_section_info));
10096 *dwo_unit->section = create_dwp_v2_section (is_debug_types
10097 ? &dwp_file->sections.types
10098 : &dwp_file->sections.info,
10099 sections.info_or_types_offset,
10100 sections.info_or_types_size);
10101 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
10102
10103 return dwo_unit;
10104 }
10105
10106 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
10107 Returns NULL if the signature isn't found. */
10108
10109 static struct dwo_unit *
10110 lookup_dwo_unit_in_dwp (struct dwp_file *dwp_file, const char *comp_dir,
10111 ULONGEST signature, int is_debug_types)
10112 {
10113 const struct dwp_hash_table *dwp_htab =
10114 is_debug_types ? dwp_file->tus : dwp_file->cus;
10115 bfd *dbfd = dwp_file->dbfd;
10116 uint32_t mask = dwp_htab->nr_slots - 1;
10117 uint32_t hash = signature & mask;
10118 uint32_t hash2 = ((signature >> 32) & mask) | 1;
10119 unsigned int i;
10120 void **slot;
10121 struct dwo_unit find_dwo_cu, *dwo_cu;
10122
10123 memset (&find_dwo_cu, 0, sizeof (find_dwo_cu));
10124 find_dwo_cu.signature = signature;
10125 slot = htab_find_slot (is_debug_types
10126 ? dwp_file->loaded_tus
10127 : dwp_file->loaded_cus,
10128 &find_dwo_cu, INSERT);
10129
10130 if (*slot != NULL)
10131 return *slot;
10132
10133 /* Use a for loop so that we don't loop forever on bad debug info. */
10134 for (i = 0; i < dwp_htab->nr_slots; ++i)
10135 {
10136 ULONGEST signature_in_table;
10137
10138 signature_in_table =
10139 read_8_bytes (dbfd, dwp_htab->hash_table + hash * sizeof (uint64_t));
10140 if (signature_in_table == signature)
10141 {
10142 uint32_t unit_index =
10143 read_4_bytes (dbfd,
10144 dwp_htab->unit_table + hash * sizeof (uint32_t));
10145
10146 if (dwp_file->version == 1)
10147 {
10148 *slot = create_dwo_unit_in_dwp_v1 (dwp_file, unit_index,
10149 comp_dir, signature,
10150 is_debug_types);
10151 }
10152 else
10153 {
10154 *slot = create_dwo_unit_in_dwp_v2 (dwp_file, unit_index,
10155 comp_dir, signature,
10156 is_debug_types);
10157 }
10158 return *slot;
10159 }
10160 if (signature_in_table == 0)
10161 return NULL;
10162 hash = (hash + hash2) & mask;
10163 }
10164
10165 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
10166 " [in module %s]"),
10167 dwp_file->name);
10168 }
10169
10170 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
10171 Open the file specified by FILE_NAME and hand it off to BFD for
10172 preliminary analysis. Return a newly initialized bfd *, which
10173 includes a canonicalized copy of FILE_NAME.
10174 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
10175 SEARCH_CWD is true if the current directory is to be searched.
10176 It will be searched before debug-file-directory.
10177 If successful, the file is added to the bfd include table of the
10178 objfile's bfd (see gdb_bfd_record_inclusion).
10179 If unable to find/open the file, return NULL.
10180 NOTE: This function is derived from symfile_bfd_open. */
10181
10182 static bfd *
10183 try_open_dwop_file (const char *file_name, int is_dwp, int search_cwd)
10184 {
10185 bfd *sym_bfd;
10186 int desc, flags;
10187 char *absolute_name;
10188 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
10189 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
10190 to debug_file_directory. */
10191 char *search_path;
10192 static const char dirname_separator_string[] = { DIRNAME_SEPARATOR, '\0' };
10193
10194 if (search_cwd)
10195 {
10196 if (*debug_file_directory != '\0')
10197 search_path = concat (".", dirname_separator_string,
10198 debug_file_directory, NULL);
10199 else
10200 search_path = xstrdup (".");
10201 }
10202 else
10203 search_path = xstrdup (debug_file_directory);
10204
10205 flags = OPF_RETURN_REALPATH;
10206 if (is_dwp)
10207 flags |= OPF_SEARCH_IN_PATH;
10208 desc = openp (search_path, flags, file_name,
10209 O_RDONLY | O_BINARY, &absolute_name);
10210 xfree (search_path);
10211 if (desc < 0)
10212 return NULL;
10213
10214 sym_bfd = gdb_bfd_open (absolute_name, gnutarget, desc);
10215 xfree (absolute_name);
10216 if (sym_bfd == NULL)
10217 return NULL;
10218 bfd_set_cacheable (sym_bfd, 1);
10219
10220 if (!bfd_check_format (sym_bfd, bfd_object))
10221 {
10222 gdb_bfd_unref (sym_bfd); /* This also closes desc. */
10223 return NULL;
10224 }
10225
10226 /* Success. Record the bfd as having been included by the objfile's bfd.
10227 This is important because things like demangled_names_hash lives in the
10228 objfile's per_bfd space and may have references to things like symbol
10229 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
10230 gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd, sym_bfd);
10231
10232 return sym_bfd;
10233 }
10234
10235 /* Try to open DWO file FILE_NAME.
10236 COMP_DIR is the DW_AT_comp_dir attribute.
10237 The result is the bfd handle of the file.
10238 If there is a problem finding or opening the file, return NULL.
10239 Upon success, the canonicalized path of the file is stored in the bfd,
10240 same as symfile_bfd_open. */
10241
10242 static bfd *
10243 open_dwo_file (const char *file_name, const char *comp_dir)
10244 {
10245 bfd *abfd;
10246
10247 if (IS_ABSOLUTE_PATH (file_name))
10248 return try_open_dwop_file (file_name, 0 /*is_dwp*/, 0 /*search_cwd*/);
10249
10250 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
10251
10252 if (comp_dir != NULL)
10253 {
10254 char *path_to_try = concat (comp_dir, SLASH_STRING, file_name, NULL);
10255
10256 /* NOTE: If comp_dir is a relative path, this will also try the
10257 search path, which seems useful. */
10258 abfd = try_open_dwop_file (path_to_try, 0 /*is_dwp*/, 1 /*search_cwd*/);
10259 xfree (path_to_try);
10260 if (abfd != NULL)
10261 return abfd;
10262 }
10263
10264 /* That didn't work, try debug-file-directory, which, despite its name,
10265 is a list of paths. */
10266
10267 if (*debug_file_directory == '\0')
10268 return NULL;
10269
10270 return try_open_dwop_file (file_name, 0 /*is_dwp*/, 1 /*search_cwd*/);
10271 }
10272
10273 /* This function is mapped across the sections and remembers the offset and
10274 size of each of the DWO debugging sections we are interested in. */
10275
10276 static void
10277 dwarf2_locate_dwo_sections (bfd *abfd, asection *sectp, void *dwo_sections_ptr)
10278 {
10279 struct dwo_sections *dwo_sections = dwo_sections_ptr;
10280 const struct dwop_section_names *names = &dwop_section_names;
10281
10282 if (section_is_p (sectp->name, &names->abbrev_dwo))
10283 {
10284 dwo_sections->abbrev.s.asection = sectp;
10285 dwo_sections->abbrev.size = bfd_get_section_size (sectp);
10286 }
10287 else if (section_is_p (sectp->name, &names->info_dwo))
10288 {
10289 dwo_sections->info.s.asection = sectp;
10290 dwo_sections->info.size = bfd_get_section_size (sectp);
10291 }
10292 else if (section_is_p (sectp->name, &names->line_dwo))
10293 {
10294 dwo_sections->line.s.asection = sectp;
10295 dwo_sections->line.size = bfd_get_section_size (sectp);
10296 }
10297 else if (section_is_p (sectp->name, &names->loc_dwo))
10298 {
10299 dwo_sections->loc.s.asection = sectp;
10300 dwo_sections->loc.size = bfd_get_section_size (sectp);
10301 }
10302 else if (section_is_p (sectp->name, &names->macinfo_dwo))
10303 {
10304 dwo_sections->macinfo.s.asection = sectp;
10305 dwo_sections->macinfo.size = bfd_get_section_size (sectp);
10306 }
10307 else if (section_is_p (sectp->name, &names->macro_dwo))
10308 {
10309 dwo_sections->macro.s.asection = sectp;
10310 dwo_sections->macro.size = bfd_get_section_size (sectp);
10311 }
10312 else if (section_is_p (sectp->name, &names->str_dwo))
10313 {
10314 dwo_sections->str.s.asection = sectp;
10315 dwo_sections->str.size = bfd_get_section_size (sectp);
10316 }
10317 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
10318 {
10319 dwo_sections->str_offsets.s.asection = sectp;
10320 dwo_sections->str_offsets.size = bfd_get_section_size (sectp);
10321 }
10322 else if (section_is_p (sectp->name, &names->types_dwo))
10323 {
10324 struct dwarf2_section_info type_section;
10325
10326 memset (&type_section, 0, sizeof (type_section));
10327 type_section.s.asection = sectp;
10328 type_section.size = bfd_get_section_size (sectp);
10329 VEC_safe_push (dwarf2_section_info_def, dwo_sections->types,
10330 &type_section);
10331 }
10332 }
10333
10334 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
10335 by PER_CU. This is for the non-DWP case.
10336 The result is NULL if DWO_NAME can't be found. */
10337
10338 static struct dwo_file *
10339 open_and_init_dwo_file (struct dwarf2_per_cu_data *per_cu,
10340 const char *dwo_name, const char *comp_dir)
10341 {
10342 struct objfile *objfile = dwarf2_per_objfile->objfile;
10343 struct dwo_file *dwo_file;
10344 bfd *dbfd;
10345 struct cleanup *cleanups;
10346
10347 dbfd = open_dwo_file (dwo_name, comp_dir);
10348 if (dbfd == NULL)
10349 {
10350 if (dwarf2_read_debug)
10351 fprintf_unfiltered (gdb_stdlog, "DWO file not found: %s\n", dwo_name);
10352 return NULL;
10353 }
10354 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
10355 dwo_file->dwo_name = dwo_name;
10356 dwo_file->comp_dir = comp_dir;
10357 dwo_file->dbfd = dbfd;
10358
10359 cleanups = make_cleanup (free_dwo_file_cleanup, dwo_file);
10360
10361 bfd_map_over_sections (dbfd, dwarf2_locate_dwo_sections, &dwo_file->sections);
10362
10363 dwo_file->cu = create_dwo_cu (dwo_file);
10364
10365 dwo_file->tus = create_debug_types_hash_table (dwo_file,
10366 dwo_file->sections.types);
10367
10368 discard_cleanups (cleanups);
10369
10370 if (dwarf2_read_debug)
10371 fprintf_unfiltered (gdb_stdlog, "DWO file found: %s\n", dwo_name);
10372
10373 return dwo_file;
10374 }
10375
10376 /* This function is mapped across the sections and remembers the offset and
10377 size of each of the DWP debugging sections common to version 1 and 2 that
10378 we are interested in. */
10379
10380 static void
10381 dwarf2_locate_common_dwp_sections (bfd *abfd, asection *sectp,
10382 void *dwp_file_ptr)
10383 {
10384 struct dwp_file *dwp_file = dwp_file_ptr;
10385 const struct dwop_section_names *names = &dwop_section_names;
10386 unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
10387
10388 /* Record the ELF section number for later lookup: this is what the
10389 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
10390 gdb_assert (elf_section_nr < dwp_file->num_sections);
10391 dwp_file->elf_sections[elf_section_nr] = sectp;
10392
10393 /* Look for specific sections that we need. */
10394 if (section_is_p (sectp->name, &names->str_dwo))
10395 {
10396 dwp_file->sections.str.s.asection = sectp;
10397 dwp_file->sections.str.size = bfd_get_section_size (sectp);
10398 }
10399 else if (section_is_p (sectp->name, &names->cu_index))
10400 {
10401 dwp_file->sections.cu_index.s.asection = sectp;
10402 dwp_file->sections.cu_index.size = bfd_get_section_size (sectp);
10403 }
10404 else if (section_is_p (sectp->name, &names->tu_index))
10405 {
10406 dwp_file->sections.tu_index.s.asection = sectp;
10407 dwp_file->sections.tu_index.size = bfd_get_section_size (sectp);
10408 }
10409 }
10410
10411 /* This function is mapped across the sections and remembers the offset and
10412 size of each of the DWP version 2 debugging sections that we are interested
10413 in. This is split into a separate function because we don't know if we
10414 have version 1 or 2 until we parse the cu_index/tu_index sections. */
10415
10416 static void
10417 dwarf2_locate_v2_dwp_sections (bfd *abfd, asection *sectp, void *dwp_file_ptr)
10418 {
10419 struct dwp_file *dwp_file = dwp_file_ptr;
10420 const struct dwop_section_names *names = &dwop_section_names;
10421 unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
10422
10423 /* Record the ELF section number for later lookup: this is what the
10424 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
10425 gdb_assert (elf_section_nr < dwp_file->num_sections);
10426 dwp_file->elf_sections[elf_section_nr] = sectp;
10427
10428 /* Look for specific sections that we need. */
10429 if (section_is_p (sectp->name, &names->abbrev_dwo))
10430 {
10431 dwp_file->sections.abbrev.s.asection = sectp;
10432 dwp_file->sections.abbrev.size = bfd_get_section_size (sectp);
10433 }
10434 else if (section_is_p (sectp->name, &names->info_dwo))
10435 {
10436 dwp_file->sections.info.s.asection = sectp;
10437 dwp_file->sections.info.size = bfd_get_section_size (sectp);
10438 }
10439 else if (section_is_p (sectp->name, &names->line_dwo))
10440 {
10441 dwp_file->sections.line.s.asection = sectp;
10442 dwp_file->sections.line.size = bfd_get_section_size (sectp);
10443 }
10444 else if (section_is_p (sectp->name, &names->loc_dwo))
10445 {
10446 dwp_file->sections.loc.s.asection = sectp;
10447 dwp_file->sections.loc.size = bfd_get_section_size (sectp);
10448 }
10449 else if (section_is_p (sectp->name, &names->macinfo_dwo))
10450 {
10451 dwp_file->sections.macinfo.s.asection = sectp;
10452 dwp_file->sections.macinfo.size = bfd_get_section_size (sectp);
10453 }
10454 else if (section_is_p (sectp->name, &names->macro_dwo))
10455 {
10456 dwp_file->sections.macro.s.asection = sectp;
10457 dwp_file->sections.macro.size = bfd_get_section_size (sectp);
10458 }
10459 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
10460 {
10461 dwp_file->sections.str_offsets.s.asection = sectp;
10462 dwp_file->sections.str_offsets.size = bfd_get_section_size (sectp);
10463 }
10464 else if (section_is_p (sectp->name, &names->types_dwo))
10465 {
10466 dwp_file->sections.types.s.asection = sectp;
10467 dwp_file->sections.types.size = bfd_get_section_size (sectp);
10468 }
10469 }
10470
10471 /* Hash function for dwp_file loaded CUs/TUs. */
10472
10473 static hashval_t
10474 hash_dwp_loaded_cutus (const void *item)
10475 {
10476 const struct dwo_unit *dwo_unit = item;
10477
10478 /* This drops the top 32 bits of the signature, but is ok for a hash. */
10479 return dwo_unit->signature;
10480 }
10481
10482 /* Equality function for dwp_file loaded CUs/TUs. */
10483
10484 static int
10485 eq_dwp_loaded_cutus (const void *a, const void *b)
10486 {
10487 const struct dwo_unit *dua = a;
10488 const struct dwo_unit *dub = b;
10489
10490 return dua->signature == dub->signature;
10491 }
10492
10493 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
10494
10495 static htab_t
10496 allocate_dwp_loaded_cutus_table (struct objfile *objfile)
10497 {
10498 return htab_create_alloc_ex (3,
10499 hash_dwp_loaded_cutus,
10500 eq_dwp_loaded_cutus,
10501 NULL,
10502 &objfile->objfile_obstack,
10503 hashtab_obstack_allocate,
10504 dummy_obstack_deallocate);
10505 }
10506
10507 /* Try to open DWP file FILE_NAME.
10508 The result is the bfd handle of the file.
10509 If there is a problem finding or opening the file, return NULL.
10510 Upon success, the canonicalized path of the file is stored in the bfd,
10511 same as symfile_bfd_open. */
10512
10513 static bfd *
10514 open_dwp_file (const char *file_name)
10515 {
10516 bfd *abfd;
10517
10518 abfd = try_open_dwop_file (file_name, 1 /*is_dwp*/, 1 /*search_cwd*/);
10519 if (abfd != NULL)
10520 return abfd;
10521
10522 /* Work around upstream bug 15652.
10523 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
10524 [Whether that's a "bug" is debatable, but it is getting in our way.]
10525 We have no real idea where the dwp file is, because gdb's realpath-ing
10526 of the executable's path may have discarded the needed info.
10527 [IWBN if the dwp file name was recorded in the executable, akin to
10528 .gnu_debuglink, but that doesn't exist yet.]
10529 Strip the directory from FILE_NAME and search again. */
10530 if (*debug_file_directory != '\0')
10531 {
10532 /* Don't implicitly search the current directory here.
10533 If the user wants to search "." to handle this case,
10534 it must be added to debug-file-directory. */
10535 return try_open_dwop_file (lbasename (file_name), 1 /*is_dwp*/,
10536 0 /*search_cwd*/);
10537 }
10538
10539 return NULL;
10540 }
10541
10542 /* Initialize the use of the DWP file for the current objfile.
10543 By convention the name of the DWP file is ${objfile}.dwp.
10544 The result is NULL if it can't be found. */
10545
10546 static struct dwp_file *
10547 open_and_init_dwp_file (void)
10548 {
10549 struct objfile *objfile = dwarf2_per_objfile->objfile;
10550 struct dwp_file *dwp_file;
10551 char *dwp_name;
10552 bfd *dbfd;
10553 struct cleanup *cleanups;
10554
10555 /* Try to find first .dwp for the binary file before any symbolic links
10556 resolving. */
10557 dwp_name = xstrprintf ("%s.dwp", objfile->original_name);
10558 cleanups = make_cleanup (xfree, dwp_name);
10559
10560 dbfd = open_dwp_file (dwp_name);
10561 if (dbfd == NULL
10562 && strcmp (objfile->original_name, objfile_name (objfile)) != 0)
10563 {
10564 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
10565 dwp_name = xstrprintf ("%s.dwp", objfile_name (objfile));
10566 make_cleanup (xfree, dwp_name);
10567 dbfd = open_dwp_file (dwp_name);
10568 }
10569
10570 if (dbfd == NULL)
10571 {
10572 if (dwarf2_read_debug)
10573 fprintf_unfiltered (gdb_stdlog, "DWP file not found: %s\n", dwp_name);
10574 do_cleanups (cleanups);
10575 return NULL;
10576 }
10577 dwp_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_file);
10578 dwp_file->name = bfd_get_filename (dbfd);
10579 dwp_file->dbfd = dbfd;
10580 do_cleanups (cleanups);
10581
10582 /* +1: section 0 is unused */
10583 dwp_file->num_sections = bfd_count_sections (dbfd) + 1;
10584 dwp_file->elf_sections =
10585 OBSTACK_CALLOC (&objfile->objfile_obstack,
10586 dwp_file->num_sections, asection *);
10587
10588 bfd_map_over_sections (dbfd, dwarf2_locate_common_dwp_sections, dwp_file);
10589
10590 dwp_file->cus = create_dwp_hash_table (dwp_file, 0);
10591
10592 dwp_file->tus = create_dwp_hash_table (dwp_file, 1);
10593
10594 /* The DWP file version is stored in the hash table. Oh well. */
10595 if (dwp_file->cus->version != dwp_file->tus->version)
10596 {
10597 /* Technically speaking, we should try to limp along, but this is
10598 pretty bizarre. We use pulongest here because that's the established
10599 portability solution (e.g, we cannot use %u for uint32_t). */
10600 error (_("Dwarf Error: DWP file CU version %s doesn't match"
10601 " TU version %s [in DWP file %s]"),
10602 pulongest (dwp_file->cus->version),
10603 pulongest (dwp_file->tus->version), dwp_name);
10604 }
10605 dwp_file->version = dwp_file->cus->version;
10606
10607 if (dwp_file->version == 2)
10608 bfd_map_over_sections (dbfd, dwarf2_locate_v2_dwp_sections, dwp_file);
10609
10610 dwp_file->loaded_cus = allocate_dwp_loaded_cutus_table (objfile);
10611 dwp_file->loaded_tus = allocate_dwp_loaded_cutus_table (objfile);
10612
10613 if (dwarf2_read_debug)
10614 {
10615 fprintf_unfiltered (gdb_stdlog, "DWP file found: %s\n", dwp_file->name);
10616 fprintf_unfiltered (gdb_stdlog,
10617 " %s CUs, %s TUs\n",
10618 pulongest (dwp_file->cus ? dwp_file->cus->nr_units : 0),
10619 pulongest (dwp_file->tus ? dwp_file->tus->nr_units : 0));
10620 }
10621
10622 return dwp_file;
10623 }
10624
10625 /* Wrapper around open_and_init_dwp_file, only open it once. */
10626
10627 static struct dwp_file *
10628 get_dwp_file (void)
10629 {
10630 if (! dwarf2_per_objfile->dwp_checked)
10631 {
10632 dwarf2_per_objfile->dwp_file = open_and_init_dwp_file ();
10633 dwarf2_per_objfile->dwp_checked = 1;
10634 }
10635 return dwarf2_per_objfile->dwp_file;
10636 }
10637
10638 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
10639 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
10640 or in the DWP file for the objfile, referenced by THIS_UNIT.
10641 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
10642 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
10643
10644 This is called, for example, when wanting to read a variable with a
10645 complex location. Therefore we don't want to do file i/o for every call.
10646 Therefore we don't want to look for a DWO file on every call.
10647 Therefore we first see if we've already seen SIGNATURE in a DWP file,
10648 then we check if we've already seen DWO_NAME, and only THEN do we check
10649 for a DWO file.
10650
10651 The result is a pointer to the dwo_unit object or NULL if we didn't find it
10652 (dwo_id mismatch or couldn't find the DWO/DWP file). */
10653
10654 static struct dwo_unit *
10655 lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit,
10656 const char *dwo_name, const char *comp_dir,
10657 ULONGEST signature, int is_debug_types)
10658 {
10659 struct objfile *objfile = dwarf2_per_objfile->objfile;
10660 const char *kind = is_debug_types ? "TU" : "CU";
10661 void **dwo_file_slot;
10662 struct dwo_file *dwo_file;
10663 struct dwp_file *dwp_file;
10664
10665 /* First see if there's a DWP file.
10666 If we have a DWP file but didn't find the DWO inside it, don't
10667 look for the original DWO file. It makes gdb behave differently
10668 depending on whether one is debugging in the build tree. */
10669
10670 dwp_file = get_dwp_file ();
10671 if (dwp_file != NULL)
10672 {
10673 const struct dwp_hash_table *dwp_htab =
10674 is_debug_types ? dwp_file->tus : dwp_file->cus;
10675
10676 if (dwp_htab != NULL)
10677 {
10678 struct dwo_unit *dwo_cutu =
10679 lookup_dwo_unit_in_dwp (dwp_file, comp_dir,
10680 signature, is_debug_types);
10681
10682 if (dwo_cutu != NULL)
10683 {
10684 if (dwarf2_read_debug)
10685 {
10686 fprintf_unfiltered (gdb_stdlog,
10687 "Virtual DWO %s %s found: @%s\n",
10688 kind, hex_string (signature),
10689 host_address_to_string (dwo_cutu));
10690 }
10691 return dwo_cutu;
10692 }
10693 }
10694 }
10695 else
10696 {
10697 /* No DWP file, look for the DWO file. */
10698
10699 dwo_file_slot = lookup_dwo_file_slot (dwo_name, comp_dir);
10700 if (*dwo_file_slot == NULL)
10701 {
10702 /* Read in the file and build a table of the CUs/TUs it contains. */
10703 *dwo_file_slot = open_and_init_dwo_file (this_unit, dwo_name, comp_dir);
10704 }
10705 /* NOTE: This will be NULL if unable to open the file. */
10706 dwo_file = *dwo_file_slot;
10707
10708 if (dwo_file != NULL)
10709 {
10710 struct dwo_unit *dwo_cutu = NULL;
10711
10712 if (is_debug_types && dwo_file->tus)
10713 {
10714 struct dwo_unit find_dwo_cutu;
10715
10716 memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
10717 find_dwo_cutu.signature = signature;
10718 dwo_cutu = htab_find (dwo_file->tus, &find_dwo_cutu);
10719 }
10720 else if (!is_debug_types && dwo_file->cu)
10721 {
10722 if (signature == dwo_file->cu->signature)
10723 dwo_cutu = dwo_file->cu;
10724 }
10725
10726 if (dwo_cutu != NULL)
10727 {
10728 if (dwarf2_read_debug)
10729 {
10730 fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) found: @%s\n",
10731 kind, dwo_name, hex_string (signature),
10732 host_address_to_string (dwo_cutu));
10733 }
10734 return dwo_cutu;
10735 }
10736 }
10737 }
10738
10739 /* We didn't find it. This could mean a dwo_id mismatch, or
10740 someone deleted the DWO/DWP file, or the search path isn't set up
10741 correctly to find the file. */
10742
10743 if (dwarf2_read_debug)
10744 {
10745 fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) not found\n",
10746 kind, dwo_name, hex_string (signature));
10747 }
10748
10749 /* This is a warning and not a complaint because it can be caused by
10750 pilot error (e.g., user accidentally deleting the DWO). */
10751 {
10752 /* Print the name of the DWP file if we looked there, helps the user
10753 better diagnose the problem. */
10754 char *dwp_text = NULL;
10755 struct cleanup *cleanups;
10756
10757 if (dwp_file != NULL)
10758 dwp_text = xstrprintf (" [in DWP file %s]", lbasename (dwp_file->name));
10759 cleanups = make_cleanup (xfree, dwp_text);
10760
10761 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset 0x%x"
10762 " [in module %s]"),
10763 kind, dwo_name, hex_string (signature),
10764 dwp_text != NULL ? dwp_text : "",
10765 this_unit->is_debug_types ? "TU" : "CU",
10766 this_unit->offset.sect_off, objfile_name (objfile));
10767
10768 do_cleanups (cleanups);
10769 }
10770 return NULL;
10771 }
10772
10773 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
10774 See lookup_dwo_cutu_unit for details. */
10775
10776 static struct dwo_unit *
10777 lookup_dwo_comp_unit (struct dwarf2_per_cu_data *this_cu,
10778 const char *dwo_name, const char *comp_dir,
10779 ULONGEST signature)
10780 {
10781 return lookup_dwo_cutu (this_cu, dwo_name, comp_dir, signature, 0);
10782 }
10783
10784 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
10785 See lookup_dwo_cutu_unit for details. */
10786
10787 static struct dwo_unit *
10788 lookup_dwo_type_unit (struct signatured_type *this_tu,
10789 const char *dwo_name, const char *comp_dir)
10790 {
10791 return lookup_dwo_cutu (&this_tu->per_cu, dwo_name, comp_dir, this_tu->signature, 1);
10792 }
10793
10794 /* Traversal function for queue_and_load_all_dwo_tus. */
10795
10796 static int
10797 queue_and_load_dwo_tu (void **slot, void *info)
10798 {
10799 struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
10800 struct dwarf2_per_cu_data *per_cu = (struct dwarf2_per_cu_data *) info;
10801 ULONGEST signature = dwo_unit->signature;
10802 struct signatured_type *sig_type =
10803 lookup_dwo_signatured_type (per_cu->cu, signature);
10804
10805 if (sig_type != NULL)
10806 {
10807 struct dwarf2_per_cu_data *sig_cu = &sig_type->per_cu;
10808
10809 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
10810 a real dependency of PER_CU on SIG_TYPE. That is detected later
10811 while processing PER_CU. */
10812 if (maybe_queue_comp_unit (NULL, sig_cu, per_cu->cu->language))
10813 load_full_type_unit (sig_cu);
10814 VEC_safe_push (dwarf2_per_cu_ptr, per_cu->imported_symtabs, sig_cu);
10815 }
10816
10817 return 1;
10818 }
10819
10820 /* Queue all TUs contained in the DWO of PER_CU to be read in.
10821 The DWO may have the only definition of the type, though it may not be
10822 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
10823 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
10824
10825 static void
10826 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *per_cu)
10827 {
10828 struct dwo_unit *dwo_unit;
10829 struct dwo_file *dwo_file;
10830
10831 gdb_assert (!per_cu->is_debug_types);
10832 gdb_assert (get_dwp_file () == NULL);
10833 gdb_assert (per_cu->cu != NULL);
10834
10835 dwo_unit = per_cu->cu->dwo_unit;
10836 gdb_assert (dwo_unit != NULL);
10837
10838 dwo_file = dwo_unit->dwo_file;
10839 if (dwo_file->tus != NULL)
10840 htab_traverse_noresize (dwo_file->tus, queue_and_load_dwo_tu, per_cu);
10841 }
10842
10843 /* Free all resources associated with DWO_FILE.
10844 Close the DWO file and munmap the sections.
10845 All memory should be on the objfile obstack. */
10846
10847 static void
10848 free_dwo_file (struct dwo_file *dwo_file, struct objfile *objfile)
10849 {
10850 int ix;
10851 struct dwarf2_section_info *section;
10852
10853 /* Note: dbfd is NULL for virtual DWO files. */
10854 gdb_bfd_unref (dwo_file->dbfd);
10855
10856 VEC_free (dwarf2_section_info_def, dwo_file->sections.types);
10857 }
10858
10859 /* Wrapper for free_dwo_file for use in cleanups. */
10860
10861 static void
10862 free_dwo_file_cleanup (void *arg)
10863 {
10864 struct dwo_file *dwo_file = (struct dwo_file *) arg;
10865 struct objfile *objfile = dwarf2_per_objfile->objfile;
10866
10867 free_dwo_file (dwo_file, objfile);
10868 }
10869
10870 /* Traversal function for free_dwo_files. */
10871
10872 static int
10873 free_dwo_file_from_slot (void **slot, void *info)
10874 {
10875 struct dwo_file *dwo_file = (struct dwo_file *) *slot;
10876 struct objfile *objfile = (struct objfile *) info;
10877
10878 free_dwo_file (dwo_file, objfile);
10879
10880 return 1;
10881 }
10882
10883 /* Free all resources associated with DWO_FILES. */
10884
10885 static void
10886 free_dwo_files (htab_t dwo_files, struct objfile *objfile)
10887 {
10888 htab_traverse_noresize (dwo_files, free_dwo_file_from_slot, objfile);
10889 }
10890 \f
10891 /* Read in various DIEs. */
10892
10893 /* qsort helper for inherit_abstract_dies. */
10894
10895 static int
10896 unsigned_int_compar (const void *ap, const void *bp)
10897 {
10898 unsigned int a = *(unsigned int *) ap;
10899 unsigned int b = *(unsigned int *) bp;
10900
10901 return (a > b) - (b > a);
10902 }
10903
10904 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
10905 Inherit only the children of the DW_AT_abstract_origin DIE not being
10906 already referenced by DW_AT_abstract_origin from the children of the
10907 current DIE. */
10908
10909 static void
10910 inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu)
10911 {
10912 struct die_info *child_die;
10913 unsigned die_children_count;
10914 /* CU offsets which were referenced by children of the current DIE. */
10915 sect_offset *offsets;
10916 sect_offset *offsets_end, *offsetp;
10917 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
10918 struct die_info *origin_die;
10919 /* Iterator of the ORIGIN_DIE children. */
10920 struct die_info *origin_child_die;
10921 struct cleanup *cleanups;
10922 struct attribute *attr;
10923 struct dwarf2_cu *origin_cu;
10924 struct pending **origin_previous_list_in_scope;
10925
10926 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
10927 if (!attr)
10928 return;
10929
10930 /* Note that following die references may follow to a die in a
10931 different cu. */
10932
10933 origin_cu = cu;
10934 origin_die = follow_die_ref (die, attr, &origin_cu);
10935
10936 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
10937 symbols in. */
10938 origin_previous_list_in_scope = origin_cu->list_in_scope;
10939 origin_cu->list_in_scope = cu->list_in_scope;
10940
10941 if (die->tag != origin_die->tag
10942 && !(die->tag == DW_TAG_inlined_subroutine
10943 && origin_die->tag == DW_TAG_subprogram))
10944 complaint (&symfile_complaints,
10945 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
10946 die->offset.sect_off, origin_die->offset.sect_off);
10947
10948 child_die = die->child;
10949 die_children_count = 0;
10950 while (child_die && child_die->tag)
10951 {
10952 child_die = sibling_die (child_die);
10953 die_children_count++;
10954 }
10955 offsets = xmalloc (sizeof (*offsets) * die_children_count);
10956 cleanups = make_cleanup (xfree, offsets);
10957
10958 offsets_end = offsets;
10959 child_die = die->child;
10960 while (child_die && child_die->tag)
10961 {
10962 /* For each CHILD_DIE, find the corresponding child of
10963 ORIGIN_DIE. If there is more than one layer of
10964 DW_AT_abstract_origin, follow them all; there shouldn't be,
10965 but GCC versions at least through 4.4 generate this (GCC PR
10966 40573). */
10967 struct die_info *child_origin_die = child_die;
10968 struct dwarf2_cu *child_origin_cu = cu;
10969
10970 while (1)
10971 {
10972 attr = dwarf2_attr (child_origin_die, DW_AT_abstract_origin,
10973 child_origin_cu);
10974 if (attr == NULL)
10975 break;
10976 child_origin_die = follow_die_ref (child_origin_die, attr,
10977 &child_origin_cu);
10978 }
10979
10980 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
10981 counterpart may exist. */
10982 if (child_origin_die != child_die)
10983 {
10984 if (child_die->tag != child_origin_die->tag
10985 && !(child_die->tag == DW_TAG_inlined_subroutine
10986 && child_origin_die->tag == DW_TAG_subprogram))
10987 complaint (&symfile_complaints,
10988 _("Child DIE 0x%x and its abstract origin 0x%x have "
10989 "different tags"), child_die->offset.sect_off,
10990 child_origin_die->offset.sect_off);
10991 if (child_origin_die->parent != origin_die)
10992 complaint (&symfile_complaints,
10993 _("Child DIE 0x%x and its abstract origin 0x%x have "
10994 "different parents"), child_die->offset.sect_off,
10995 child_origin_die->offset.sect_off);
10996 else
10997 *offsets_end++ = child_origin_die->offset;
10998 }
10999 child_die = sibling_die (child_die);
11000 }
11001 qsort (offsets, offsets_end - offsets, sizeof (*offsets),
11002 unsigned_int_compar);
11003 for (offsetp = offsets + 1; offsetp < offsets_end; offsetp++)
11004 if (offsetp[-1].sect_off == offsetp->sect_off)
11005 complaint (&symfile_complaints,
11006 _("Multiple children of DIE 0x%x refer "
11007 "to DIE 0x%x as their abstract origin"),
11008 die->offset.sect_off, offsetp->sect_off);
11009
11010 offsetp = offsets;
11011 origin_child_die = origin_die->child;
11012 while (origin_child_die && origin_child_die->tag)
11013 {
11014 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
11015 while (offsetp < offsets_end
11016 && offsetp->sect_off < origin_child_die->offset.sect_off)
11017 offsetp++;
11018 if (offsetp >= offsets_end
11019 || offsetp->sect_off > origin_child_die->offset.sect_off)
11020 {
11021 /* Found that ORIGIN_CHILD_DIE is really not referenced.
11022 Check whether we're already processing ORIGIN_CHILD_DIE.
11023 This can happen with mutually referenced abstract_origins.
11024 PR 16581. */
11025 if (!origin_child_die->in_process)
11026 process_die (origin_child_die, origin_cu);
11027 }
11028 origin_child_die = sibling_die (origin_child_die);
11029 }
11030 origin_cu->list_in_scope = origin_previous_list_in_scope;
11031
11032 do_cleanups (cleanups);
11033 }
11034
11035 static void
11036 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
11037 {
11038 struct objfile *objfile = cu->objfile;
11039 struct context_stack *new;
11040 CORE_ADDR lowpc;
11041 CORE_ADDR highpc;
11042 struct die_info *child_die;
11043 struct attribute *attr, *call_line, *call_file;
11044 const char *name;
11045 CORE_ADDR baseaddr;
11046 struct block *block;
11047 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
11048 VEC (symbolp) *template_args = NULL;
11049 struct template_symbol *templ_func = NULL;
11050
11051 if (inlined_func)
11052 {
11053 /* If we do not have call site information, we can't show the
11054 caller of this inlined function. That's too confusing, so
11055 only use the scope for local variables. */
11056 call_line = dwarf2_attr (die, DW_AT_call_line, cu);
11057 call_file = dwarf2_attr (die, DW_AT_call_file, cu);
11058 if (call_line == NULL || call_file == NULL)
11059 {
11060 read_lexical_block_scope (die, cu);
11061 return;
11062 }
11063 }
11064
11065 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11066
11067 name = dwarf2_name (die, cu);
11068
11069 /* Ignore functions with missing or empty names. These are actually
11070 illegal according to the DWARF standard. */
11071 if (name == NULL)
11072 {
11073 complaint (&symfile_complaints,
11074 _("missing name for subprogram DIE at %d"),
11075 die->offset.sect_off);
11076 return;
11077 }
11078
11079 /* Ignore functions with missing or invalid low and high pc attributes. */
11080 if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
11081 {
11082 attr = dwarf2_attr (die, DW_AT_external, cu);
11083 if (!attr || !DW_UNSND (attr))
11084 complaint (&symfile_complaints,
11085 _("cannot get low and high bounds "
11086 "for subprogram DIE at %d"),
11087 die->offset.sect_off);
11088 return;
11089 }
11090
11091 lowpc += baseaddr;
11092 highpc += baseaddr;
11093
11094 /* If we have any template arguments, then we must allocate a
11095 different sort of symbol. */
11096 for (child_die = die->child; child_die; child_die = sibling_die (child_die))
11097 {
11098 if (child_die->tag == DW_TAG_template_type_param
11099 || child_die->tag == DW_TAG_template_value_param)
11100 {
11101 templ_func = allocate_template_symbol (objfile);
11102 templ_func->base.is_cplus_template_function = 1;
11103 break;
11104 }
11105 }
11106
11107 new = push_context (0, lowpc);
11108 new->name = new_symbol_full (die, read_type_die (die, cu), cu,
11109 (struct symbol *) templ_func);
11110
11111 /* If there is a location expression for DW_AT_frame_base, record
11112 it. */
11113 attr = dwarf2_attr (die, DW_AT_frame_base, cu);
11114 if (attr)
11115 dwarf2_symbol_mark_computed (attr, new->name, cu, 1);
11116
11117 cu->list_in_scope = &local_symbols;
11118
11119 if (die->child != NULL)
11120 {
11121 child_die = die->child;
11122 while (child_die && child_die->tag)
11123 {
11124 if (child_die->tag == DW_TAG_template_type_param
11125 || child_die->tag == DW_TAG_template_value_param)
11126 {
11127 struct symbol *arg = new_symbol (child_die, NULL, cu);
11128
11129 if (arg != NULL)
11130 VEC_safe_push (symbolp, template_args, arg);
11131 }
11132 else
11133 process_die (child_die, cu);
11134 child_die = sibling_die (child_die);
11135 }
11136 }
11137
11138 inherit_abstract_dies (die, cu);
11139
11140 /* If we have a DW_AT_specification, we might need to import using
11141 directives from the context of the specification DIE. See the
11142 comment in determine_prefix. */
11143 if (cu->language == language_cplus
11144 && dwarf2_attr (die, DW_AT_specification, cu))
11145 {
11146 struct dwarf2_cu *spec_cu = cu;
11147 struct die_info *spec_die = die_specification (die, &spec_cu);
11148
11149 while (spec_die)
11150 {
11151 child_die = spec_die->child;
11152 while (child_die && child_die->tag)
11153 {
11154 if (child_die->tag == DW_TAG_imported_module)
11155 process_die (child_die, spec_cu);
11156 child_die = sibling_die (child_die);
11157 }
11158
11159 /* In some cases, GCC generates specification DIEs that
11160 themselves contain DW_AT_specification attributes. */
11161 spec_die = die_specification (spec_die, &spec_cu);
11162 }
11163 }
11164
11165 new = pop_context ();
11166 /* Make a block for the local symbols within. */
11167 block = finish_block (new->name, &local_symbols, new->old_blocks,
11168 lowpc, highpc, objfile);
11169
11170 /* For C++, set the block's scope. */
11171 if ((cu->language == language_cplus || cu->language == language_fortran)
11172 && cu->processing_has_namespace_info)
11173 block_set_scope (block, determine_prefix (die, cu),
11174 &objfile->objfile_obstack);
11175
11176 /* If we have address ranges, record them. */
11177 dwarf2_record_block_ranges (die, block, baseaddr, cu);
11178
11179 /* Attach template arguments to function. */
11180 if (! VEC_empty (symbolp, template_args))
11181 {
11182 gdb_assert (templ_func != NULL);
11183
11184 templ_func->n_template_arguments = VEC_length (symbolp, template_args);
11185 templ_func->template_arguments
11186 = obstack_alloc (&objfile->objfile_obstack,
11187 (templ_func->n_template_arguments
11188 * sizeof (struct symbol *)));
11189 memcpy (templ_func->template_arguments,
11190 VEC_address (symbolp, template_args),
11191 (templ_func->n_template_arguments * sizeof (struct symbol *)));
11192 VEC_free (symbolp, template_args);
11193 }
11194
11195 /* In C++, we can have functions nested inside functions (e.g., when
11196 a function declares a class that has methods). This means that
11197 when we finish processing a function scope, we may need to go
11198 back to building a containing block's symbol lists. */
11199 local_symbols = new->locals;
11200 using_directives = new->using_directives;
11201
11202 /* If we've finished processing a top-level function, subsequent
11203 symbols go in the file symbol list. */
11204 if (outermost_context_p ())
11205 cu->list_in_scope = &file_symbols;
11206 }
11207
11208 /* Process all the DIES contained within a lexical block scope. Start
11209 a new scope, process the dies, and then close the scope. */
11210
11211 static void
11212 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
11213 {
11214 struct objfile *objfile = cu->objfile;
11215 struct context_stack *new;
11216 CORE_ADDR lowpc, highpc;
11217 struct die_info *child_die;
11218 CORE_ADDR baseaddr;
11219
11220 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11221
11222 /* Ignore blocks with missing or invalid low and high pc attributes. */
11223 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
11224 as multiple lexical blocks? Handling children in a sane way would
11225 be nasty. Might be easier to properly extend generic blocks to
11226 describe ranges. */
11227 if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
11228 return;
11229 lowpc += baseaddr;
11230 highpc += baseaddr;
11231
11232 push_context (0, lowpc);
11233 if (die->child != NULL)
11234 {
11235 child_die = die->child;
11236 while (child_die && child_die->tag)
11237 {
11238 process_die (child_die, cu);
11239 child_die = sibling_die (child_die);
11240 }
11241 }
11242 new = pop_context ();
11243
11244 if (local_symbols != NULL || using_directives != NULL)
11245 {
11246 struct block *block
11247 = finish_block (0, &local_symbols, new->old_blocks, new->start_addr,
11248 highpc, objfile);
11249
11250 /* Note that recording ranges after traversing children, as we
11251 do here, means that recording a parent's ranges entails
11252 walking across all its children's ranges as they appear in
11253 the address map, which is quadratic behavior.
11254
11255 It would be nicer to record the parent's ranges before
11256 traversing its children, simply overriding whatever you find
11257 there. But since we don't even decide whether to create a
11258 block until after we've traversed its children, that's hard
11259 to do. */
11260 dwarf2_record_block_ranges (die, block, baseaddr, cu);
11261 }
11262 local_symbols = new->locals;
11263 using_directives = new->using_directives;
11264 }
11265
11266 /* Read in DW_TAG_GNU_call_site and insert it to CU->call_site_htab. */
11267
11268 static void
11269 read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
11270 {
11271 struct objfile *objfile = cu->objfile;
11272 struct gdbarch *gdbarch = get_objfile_arch (objfile);
11273 CORE_ADDR pc, baseaddr;
11274 struct attribute *attr;
11275 struct call_site *call_site, call_site_local;
11276 void **slot;
11277 int nparams;
11278 struct die_info *child_die;
11279
11280 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11281
11282 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
11283 if (!attr)
11284 {
11285 complaint (&symfile_complaints,
11286 _("missing DW_AT_low_pc for DW_TAG_GNU_call_site "
11287 "DIE 0x%x [in module %s]"),
11288 die->offset.sect_off, objfile_name (objfile));
11289 return;
11290 }
11291 pc = attr_value_as_address (attr) + baseaddr;
11292
11293 if (cu->call_site_htab == NULL)
11294 cu->call_site_htab = htab_create_alloc_ex (16, core_addr_hash, core_addr_eq,
11295 NULL, &objfile->objfile_obstack,
11296 hashtab_obstack_allocate, NULL);
11297 call_site_local.pc = pc;
11298 slot = htab_find_slot (cu->call_site_htab, &call_site_local, INSERT);
11299 if (*slot != NULL)
11300 {
11301 complaint (&symfile_complaints,
11302 _("Duplicate PC %s for DW_TAG_GNU_call_site "
11303 "DIE 0x%x [in module %s]"),
11304 paddress (gdbarch, pc), die->offset.sect_off,
11305 objfile_name (objfile));
11306 return;
11307 }
11308
11309 /* Count parameters at the caller. */
11310
11311 nparams = 0;
11312 for (child_die = die->child; child_die && child_die->tag;
11313 child_die = sibling_die (child_die))
11314 {
11315 if (child_die->tag != DW_TAG_GNU_call_site_parameter)
11316 {
11317 complaint (&symfile_complaints,
11318 _("Tag %d is not DW_TAG_GNU_call_site_parameter in "
11319 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11320 child_die->tag, child_die->offset.sect_off,
11321 objfile_name (objfile));
11322 continue;
11323 }
11324
11325 nparams++;
11326 }
11327
11328 call_site = obstack_alloc (&objfile->objfile_obstack,
11329 (sizeof (*call_site)
11330 + (sizeof (*call_site->parameter)
11331 * (nparams - 1))));
11332 *slot = call_site;
11333 memset (call_site, 0, sizeof (*call_site) - sizeof (*call_site->parameter));
11334 call_site->pc = pc;
11335
11336 if (dwarf2_flag_true_p (die, DW_AT_GNU_tail_call, cu))
11337 {
11338 struct die_info *func_die;
11339
11340 /* Skip also over DW_TAG_inlined_subroutine. */
11341 for (func_die = die->parent;
11342 func_die && func_die->tag != DW_TAG_subprogram
11343 && func_die->tag != DW_TAG_subroutine_type;
11344 func_die = func_die->parent);
11345
11346 /* DW_AT_GNU_all_call_sites is a superset
11347 of DW_AT_GNU_all_tail_call_sites. */
11348 if (func_die
11349 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_call_sites, cu)
11350 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_tail_call_sites, cu))
11351 {
11352 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
11353 not complete. But keep CALL_SITE for look ups via call_site_htab,
11354 both the initial caller containing the real return address PC and
11355 the final callee containing the current PC of a chain of tail
11356 calls do not need to have the tail call list complete. But any
11357 function candidate for a virtual tail call frame searched via
11358 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
11359 determined unambiguously. */
11360 }
11361 else
11362 {
11363 struct type *func_type = NULL;
11364
11365 if (func_die)
11366 func_type = get_die_type (func_die, cu);
11367 if (func_type != NULL)
11368 {
11369 gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC);
11370
11371 /* Enlist this call site to the function. */
11372 call_site->tail_call_next = TYPE_TAIL_CALL_LIST (func_type);
11373 TYPE_TAIL_CALL_LIST (func_type) = call_site;
11374 }
11375 else
11376 complaint (&symfile_complaints,
11377 _("Cannot find function owning DW_TAG_GNU_call_site "
11378 "DIE 0x%x [in module %s]"),
11379 die->offset.sect_off, objfile_name (objfile));
11380 }
11381 }
11382
11383 attr = dwarf2_attr (die, DW_AT_GNU_call_site_target, cu);
11384 if (attr == NULL)
11385 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
11386 SET_FIELD_DWARF_BLOCK (call_site->target, NULL);
11387 if (!attr || (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0))
11388 /* Keep NULL DWARF_BLOCK. */;
11389 else if (attr_form_is_block (attr))
11390 {
11391 struct dwarf2_locexpr_baton *dlbaton;
11392
11393 dlbaton = obstack_alloc (&objfile->objfile_obstack, sizeof (*dlbaton));
11394 dlbaton->data = DW_BLOCK (attr)->data;
11395 dlbaton->size = DW_BLOCK (attr)->size;
11396 dlbaton->per_cu = cu->per_cu;
11397
11398 SET_FIELD_DWARF_BLOCK (call_site->target, dlbaton);
11399 }
11400 else if (attr_form_is_ref (attr))
11401 {
11402 struct dwarf2_cu *target_cu = cu;
11403 struct die_info *target_die;
11404
11405 target_die = follow_die_ref (die, attr, &target_cu);
11406 gdb_assert (target_cu->objfile == objfile);
11407 if (die_is_declaration (target_die, target_cu))
11408 {
11409 const char *target_physname = NULL;
11410 struct attribute *target_attr;
11411
11412 /* Prefer the mangled name; otherwise compute the demangled one. */
11413 target_attr = dwarf2_attr (target_die, DW_AT_linkage_name, target_cu);
11414 if (target_attr == NULL)
11415 target_attr = dwarf2_attr (target_die, DW_AT_MIPS_linkage_name,
11416 target_cu);
11417 if (target_attr != NULL && DW_STRING (target_attr) != NULL)
11418 target_physname = DW_STRING (target_attr);
11419 else
11420 target_physname = dwarf2_physname (NULL, target_die, target_cu);
11421 if (target_physname == NULL)
11422 complaint (&symfile_complaints,
11423 _("DW_AT_GNU_call_site_target target DIE has invalid "
11424 "physname, for referencing DIE 0x%x [in module %s]"),
11425 die->offset.sect_off, objfile_name (objfile));
11426 else
11427 SET_FIELD_PHYSNAME (call_site->target, target_physname);
11428 }
11429 else
11430 {
11431 CORE_ADDR lowpc;
11432
11433 /* DW_AT_entry_pc should be preferred. */
11434 if (!dwarf2_get_pc_bounds (target_die, &lowpc, NULL, target_cu, NULL))
11435 complaint (&symfile_complaints,
11436 _("DW_AT_GNU_call_site_target target DIE has invalid "
11437 "low pc, for referencing DIE 0x%x [in module %s]"),
11438 die->offset.sect_off, objfile_name (objfile));
11439 else
11440 SET_FIELD_PHYSADDR (call_site->target, lowpc + baseaddr);
11441 }
11442 }
11443 else
11444 complaint (&symfile_complaints,
11445 _("DW_TAG_GNU_call_site DW_AT_GNU_call_site_target is neither "
11446 "block nor reference, for DIE 0x%x [in module %s]"),
11447 die->offset.sect_off, objfile_name (objfile));
11448
11449 call_site->per_cu = cu->per_cu;
11450
11451 for (child_die = die->child;
11452 child_die && child_die->tag;
11453 child_die = sibling_die (child_die))
11454 {
11455 struct call_site_parameter *parameter;
11456 struct attribute *loc, *origin;
11457
11458 if (child_die->tag != DW_TAG_GNU_call_site_parameter)
11459 {
11460 /* Already printed the complaint above. */
11461 continue;
11462 }
11463
11464 gdb_assert (call_site->parameter_count < nparams);
11465 parameter = &call_site->parameter[call_site->parameter_count];
11466
11467 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
11468 specifies DW_TAG_formal_parameter. Value of the data assumed for the
11469 register is contained in DW_AT_GNU_call_site_value. */
11470
11471 loc = dwarf2_attr (child_die, DW_AT_location, cu);
11472 origin = dwarf2_attr (child_die, DW_AT_abstract_origin, cu);
11473 if (loc == NULL && origin != NULL && attr_form_is_ref (origin))
11474 {
11475 sect_offset offset;
11476
11477 parameter->kind = CALL_SITE_PARAMETER_PARAM_OFFSET;
11478 offset = dwarf2_get_ref_die_offset (origin);
11479 if (!offset_in_cu_p (&cu->header, offset))
11480 {
11481 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
11482 binding can be done only inside one CU. Such referenced DIE
11483 therefore cannot be even moved to DW_TAG_partial_unit. */
11484 complaint (&symfile_complaints,
11485 _("DW_AT_abstract_origin offset is not in CU for "
11486 "DW_TAG_GNU_call_site child DIE 0x%x "
11487 "[in module %s]"),
11488 child_die->offset.sect_off, objfile_name (objfile));
11489 continue;
11490 }
11491 parameter->u.param_offset.cu_off = (offset.sect_off
11492 - cu->header.offset.sect_off);
11493 }
11494 else if (loc == NULL || origin != NULL || !attr_form_is_block (loc))
11495 {
11496 complaint (&symfile_complaints,
11497 _("No DW_FORM_block* DW_AT_location for "
11498 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11499 child_die->offset.sect_off, objfile_name (objfile));
11500 continue;
11501 }
11502 else
11503 {
11504 parameter->u.dwarf_reg = dwarf_block_to_dwarf_reg
11505 (DW_BLOCK (loc)->data, &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size]);
11506 if (parameter->u.dwarf_reg != -1)
11507 parameter->kind = CALL_SITE_PARAMETER_DWARF_REG;
11508 else if (dwarf_block_to_sp_offset (gdbarch, DW_BLOCK (loc)->data,
11509 &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size],
11510 &parameter->u.fb_offset))
11511 parameter->kind = CALL_SITE_PARAMETER_FB_OFFSET;
11512 else
11513 {
11514 complaint (&symfile_complaints,
11515 _("Only single DW_OP_reg or DW_OP_fbreg is supported "
11516 "for DW_FORM_block* DW_AT_location is supported for "
11517 "DW_TAG_GNU_call_site child DIE 0x%x "
11518 "[in module %s]"),
11519 child_die->offset.sect_off, objfile_name (objfile));
11520 continue;
11521 }
11522 }
11523
11524 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_value, cu);
11525 if (!attr_form_is_block (attr))
11526 {
11527 complaint (&symfile_complaints,
11528 _("No DW_FORM_block* DW_AT_GNU_call_site_value for "
11529 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11530 child_die->offset.sect_off, objfile_name (objfile));
11531 continue;
11532 }
11533 parameter->value = DW_BLOCK (attr)->data;
11534 parameter->value_size = DW_BLOCK (attr)->size;
11535
11536 /* Parameters are not pre-cleared by memset above. */
11537 parameter->data_value = NULL;
11538 parameter->data_value_size = 0;
11539 call_site->parameter_count++;
11540
11541 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_data_value, cu);
11542 if (attr)
11543 {
11544 if (!attr_form_is_block (attr))
11545 complaint (&symfile_complaints,
11546 _("No DW_FORM_block* DW_AT_GNU_call_site_data_value for "
11547 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11548 child_die->offset.sect_off, objfile_name (objfile));
11549 else
11550 {
11551 parameter->data_value = DW_BLOCK (attr)->data;
11552 parameter->data_value_size = DW_BLOCK (attr)->size;
11553 }
11554 }
11555 }
11556 }
11557
11558 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
11559 Return 1 if the attributes are present and valid, otherwise, return 0.
11560 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
11561
11562 static int
11563 dwarf2_ranges_read (unsigned offset, CORE_ADDR *low_return,
11564 CORE_ADDR *high_return, struct dwarf2_cu *cu,
11565 struct partial_symtab *ranges_pst)
11566 {
11567 struct objfile *objfile = cu->objfile;
11568 struct comp_unit_head *cu_header = &cu->header;
11569 bfd *obfd = objfile->obfd;
11570 unsigned int addr_size = cu_header->addr_size;
11571 CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
11572 /* Base address selection entry. */
11573 CORE_ADDR base;
11574 int found_base;
11575 unsigned int dummy;
11576 const gdb_byte *buffer;
11577 CORE_ADDR marker;
11578 int low_set;
11579 CORE_ADDR low = 0;
11580 CORE_ADDR high = 0;
11581 CORE_ADDR baseaddr;
11582
11583 found_base = cu->base_known;
11584 base = cu->base_address;
11585
11586 dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
11587 if (offset >= dwarf2_per_objfile->ranges.size)
11588 {
11589 complaint (&symfile_complaints,
11590 _("Offset %d out of bounds for DW_AT_ranges attribute"),
11591 offset);
11592 return 0;
11593 }
11594 buffer = dwarf2_per_objfile->ranges.buffer + offset;
11595
11596 /* Read in the largest possible address. */
11597 marker = read_address (obfd, buffer, cu, &dummy);
11598 if ((marker & mask) == mask)
11599 {
11600 /* If we found the largest possible address, then
11601 read the base address. */
11602 base = read_address (obfd, buffer + addr_size, cu, &dummy);
11603 buffer += 2 * addr_size;
11604 offset += 2 * addr_size;
11605 found_base = 1;
11606 }
11607
11608 low_set = 0;
11609
11610 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11611
11612 while (1)
11613 {
11614 CORE_ADDR range_beginning, range_end;
11615
11616 range_beginning = read_address (obfd, buffer, cu, &dummy);
11617 buffer += addr_size;
11618 range_end = read_address (obfd, buffer, cu, &dummy);
11619 buffer += addr_size;
11620 offset += 2 * addr_size;
11621
11622 /* An end of list marker is a pair of zero addresses. */
11623 if (range_beginning == 0 && range_end == 0)
11624 /* Found the end of list entry. */
11625 break;
11626
11627 /* Each base address selection entry is a pair of 2 values.
11628 The first is the largest possible address, the second is
11629 the base address. Check for a base address here. */
11630 if ((range_beginning & mask) == mask)
11631 {
11632 /* If we found the largest possible address, then
11633 read the base address. */
11634 base = read_address (obfd, buffer + addr_size, cu, &dummy);
11635 found_base = 1;
11636 continue;
11637 }
11638
11639 if (!found_base)
11640 {
11641 /* We have no valid base address for the ranges
11642 data. */
11643 complaint (&symfile_complaints,
11644 _("Invalid .debug_ranges data (no base address)"));
11645 return 0;
11646 }
11647
11648 if (range_beginning > range_end)
11649 {
11650 /* Inverted range entries are invalid. */
11651 complaint (&symfile_complaints,
11652 _("Invalid .debug_ranges data (inverted range)"));
11653 return 0;
11654 }
11655
11656 /* Empty range entries have no effect. */
11657 if (range_beginning == range_end)
11658 continue;
11659
11660 range_beginning += base;
11661 range_end += base;
11662
11663 /* A not-uncommon case of bad debug info.
11664 Don't pollute the addrmap with bad data. */
11665 if (range_beginning + baseaddr == 0
11666 && !dwarf2_per_objfile->has_section_at_zero)
11667 {
11668 complaint (&symfile_complaints,
11669 _(".debug_ranges entry has start address of zero"
11670 " [in module %s]"), objfile_name (objfile));
11671 continue;
11672 }
11673
11674 if (ranges_pst != NULL)
11675 addrmap_set_empty (objfile->psymtabs_addrmap,
11676 range_beginning + baseaddr,
11677 range_end - 1 + baseaddr,
11678 ranges_pst);
11679
11680 /* FIXME: This is recording everything as a low-high
11681 segment of consecutive addresses. We should have a
11682 data structure for discontiguous block ranges
11683 instead. */
11684 if (! low_set)
11685 {
11686 low = range_beginning;
11687 high = range_end;
11688 low_set = 1;
11689 }
11690 else
11691 {
11692 if (range_beginning < low)
11693 low = range_beginning;
11694 if (range_end > high)
11695 high = range_end;
11696 }
11697 }
11698
11699 if (! low_set)
11700 /* If the first entry is an end-of-list marker, the range
11701 describes an empty scope, i.e. no instructions. */
11702 return 0;
11703
11704 if (low_return)
11705 *low_return = low;
11706 if (high_return)
11707 *high_return = high;
11708 return 1;
11709 }
11710
11711 /* Get low and high pc attributes from a die. Return 1 if the attributes
11712 are present and valid, otherwise, return 0. Return -1 if the range is
11713 discontinuous, i.e. derived from DW_AT_ranges information. */
11714
11715 static int
11716 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
11717 CORE_ADDR *highpc, struct dwarf2_cu *cu,
11718 struct partial_symtab *pst)
11719 {
11720 struct attribute *attr;
11721 struct attribute *attr_high;
11722 CORE_ADDR low = 0;
11723 CORE_ADDR high = 0;
11724 int ret = 0;
11725
11726 attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
11727 if (attr_high)
11728 {
11729 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
11730 if (attr)
11731 {
11732 low = attr_value_as_address (attr);
11733 high = attr_value_as_address (attr_high);
11734 if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
11735 high += low;
11736 }
11737 else
11738 /* Found high w/o low attribute. */
11739 return 0;
11740
11741 /* Found consecutive range of addresses. */
11742 ret = 1;
11743 }
11744 else
11745 {
11746 attr = dwarf2_attr (die, DW_AT_ranges, cu);
11747 if (attr != NULL)
11748 {
11749 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
11750 We take advantage of the fact that DW_AT_ranges does not appear
11751 in DW_TAG_compile_unit of DWO files. */
11752 int need_ranges_base = die->tag != DW_TAG_compile_unit;
11753 unsigned int ranges_offset = (DW_UNSND (attr)
11754 + (need_ranges_base
11755 ? cu->ranges_base
11756 : 0));
11757
11758 /* Value of the DW_AT_ranges attribute is the offset in the
11759 .debug_ranges section. */
11760 if (!dwarf2_ranges_read (ranges_offset, &low, &high, cu, pst))
11761 return 0;
11762 /* Found discontinuous range of addresses. */
11763 ret = -1;
11764 }
11765 }
11766
11767 /* read_partial_die has also the strict LOW < HIGH requirement. */
11768 if (high <= low)
11769 return 0;
11770
11771 /* When using the GNU linker, .gnu.linkonce. sections are used to
11772 eliminate duplicate copies of functions and vtables and such.
11773 The linker will arbitrarily choose one and discard the others.
11774 The AT_*_pc values for such functions refer to local labels in
11775 these sections. If the section from that file was discarded, the
11776 labels are not in the output, so the relocs get a value of 0.
11777 If this is a discarded function, mark the pc bounds as invalid,
11778 so that GDB will ignore it. */
11779 if (low == 0 && !dwarf2_per_objfile->has_section_at_zero)
11780 return 0;
11781
11782 *lowpc = low;
11783 if (highpc)
11784 *highpc = high;
11785 return ret;
11786 }
11787
11788 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
11789 its low and high PC addresses. Do nothing if these addresses could not
11790 be determined. Otherwise, set LOWPC to the low address if it is smaller,
11791 and HIGHPC to the high address if greater than HIGHPC. */
11792
11793 static void
11794 dwarf2_get_subprogram_pc_bounds (struct die_info *die,
11795 CORE_ADDR *lowpc, CORE_ADDR *highpc,
11796 struct dwarf2_cu *cu)
11797 {
11798 CORE_ADDR low, high;
11799 struct die_info *child = die->child;
11800
11801 if (dwarf2_get_pc_bounds (die, &low, &high, cu, NULL))
11802 {
11803 *lowpc = min (*lowpc, low);
11804 *highpc = max (*highpc, high);
11805 }
11806
11807 /* If the language does not allow nested subprograms (either inside
11808 subprograms or lexical blocks), we're done. */
11809 if (cu->language != language_ada)
11810 return;
11811
11812 /* Check all the children of the given DIE. If it contains nested
11813 subprograms, then check their pc bounds. Likewise, we need to
11814 check lexical blocks as well, as they may also contain subprogram
11815 definitions. */
11816 while (child && child->tag)
11817 {
11818 if (child->tag == DW_TAG_subprogram
11819 || child->tag == DW_TAG_lexical_block)
11820 dwarf2_get_subprogram_pc_bounds (child, lowpc, highpc, cu);
11821 child = sibling_die (child);
11822 }
11823 }
11824
11825 /* Get the low and high pc's represented by the scope DIE, and store
11826 them in *LOWPC and *HIGHPC. If the correct values can't be
11827 determined, set *LOWPC to -1 and *HIGHPC to 0. */
11828
11829 static void
11830 get_scope_pc_bounds (struct die_info *die,
11831 CORE_ADDR *lowpc, CORE_ADDR *highpc,
11832 struct dwarf2_cu *cu)
11833 {
11834 CORE_ADDR best_low = (CORE_ADDR) -1;
11835 CORE_ADDR best_high = (CORE_ADDR) 0;
11836 CORE_ADDR current_low, current_high;
11837
11838 if (dwarf2_get_pc_bounds (die, &current_low, &current_high, cu, NULL))
11839 {
11840 best_low = current_low;
11841 best_high = current_high;
11842 }
11843 else
11844 {
11845 struct die_info *child = die->child;
11846
11847 while (child && child->tag)
11848 {
11849 switch (child->tag) {
11850 case DW_TAG_subprogram:
11851 dwarf2_get_subprogram_pc_bounds (child, &best_low, &best_high, cu);
11852 break;
11853 case DW_TAG_namespace:
11854 case DW_TAG_module:
11855 /* FIXME: carlton/2004-01-16: Should we do this for
11856 DW_TAG_class_type/DW_TAG_structure_type, too? I think
11857 that current GCC's always emit the DIEs corresponding
11858 to definitions of methods of classes as children of a
11859 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
11860 the DIEs giving the declarations, which could be
11861 anywhere). But I don't see any reason why the
11862 standards says that they have to be there. */
11863 get_scope_pc_bounds (child, &current_low, &current_high, cu);
11864
11865 if (current_low != ((CORE_ADDR) -1))
11866 {
11867 best_low = min (best_low, current_low);
11868 best_high = max (best_high, current_high);
11869 }
11870 break;
11871 default:
11872 /* Ignore. */
11873 break;
11874 }
11875
11876 child = sibling_die (child);
11877 }
11878 }
11879
11880 *lowpc = best_low;
11881 *highpc = best_high;
11882 }
11883
11884 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
11885 in DIE. */
11886
11887 static void
11888 dwarf2_record_block_ranges (struct die_info *die, struct block *block,
11889 CORE_ADDR baseaddr, struct dwarf2_cu *cu)
11890 {
11891 struct objfile *objfile = cu->objfile;
11892 struct attribute *attr;
11893 struct attribute *attr_high;
11894
11895 attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
11896 if (attr_high)
11897 {
11898 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
11899 if (attr)
11900 {
11901 CORE_ADDR low = attr_value_as_address (attr);
11902 CORE_ADDR high = attr_value_as_address (attr_high);
11903
11904 if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
11905 high += low;
11906
11907 record_block_range (block, baseaddr + low, baseaddr + high - 1);
11908 }
11909 }
11910
11911 attr = dwarf2_attr (die, DW_AT_ranges, cu);
11912 if (attr)
11913 {
11914 bfd *obfd = objfile->obfd;
11915 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
11916 We take advantage of the fact that DW_AT_ranges does not appear
11917 in DW_TAG_compile_unit of DWO files. */
11918 int need_ranges_base = die->tag != DW_TAG_compile_unit;
11919
11920 /* The value of the DW_AT_ranges attribute is the offset of the
11921 address range list in the .debug_ranges section. */
11922 unsigned long offset = (DW_UNSND (attr)
11923 + (need_ranges_base ? cu->ranges_base : 0));
11924 const gdb_byte *buffer;
11925
11926 /* For some target architectures, but not others, the
11927 read_address function sign-extends the addresses it returns.
11928 To recognize base address selection entries, we need a
11929 mask. */
11930 unsigned int addr_size = cu->header.addr_size;
11931 CORE_ADDR base_select_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
11932
11933 /* The base address, to which the next pair is relative. Note
11934 that this 'base' is a DWARF concept: most entries in a range
11935 list are relative, to reduce the number of relocs against the
11936 debugging information. This is separate from this function's
11937 'baseaddr' argument, which GDB uses to relocate debugging
11938 information from a shared library based on the address at
11939 which the library was loaded. */
11940 CORE_ADDR base = cu->base_address;
11941 int base_known = cu->base_known;
11942
11943 dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
11944 if (offset >= dwarf2_per_objfile->ranges.size)
11945 {
11946 complaint (&symfile_complaints,
11947 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
11948 offset);
11949 return;
11950 }
11951 buffer = dwarf2_per_objfile->ranges.buffer + offset;
11952
11953 for (;;)
11954 {
11955 unsigned int bytes_read;
11956 CORE_ADDR start, end;
11957
11958 start = read_address (obfd, buffer, cu, &bytes_read);
11959 buffer += bytes_read;
11960 end = read_address (obfd, buffer, cu, &bytes_read);
11961 buffer += bytes_read;
11962
11963 /* Did we find the end of the range list? */
11964 if (start == 0 && end == 0)
11965 break;
11966
11967 /* Did we find a base address selection entry? */
11968 else if ((start & base_select_mask) == base_select_mask)
11969 {
11970 base = end;
11971 base_known = 1;
11972 }
11973
11974 /* We found an ordinary address range. */
11975 else
11976 {
11977 if (!base_known)
11978 {
11979 complaint (&symfile_complaints,
11980 _("Invalid .debug_ranges data "
11981 "(no base address)"));
11982 return;
11983 }
11984
11985 if (start > end)
11986 {
11987 /* Inverted range entries are invalid. */
11988 complaint (&symfile_complaints,
11989 _("Invalid .debug_ranges data "
11990 "(inverted range)"));
11991 return;
11992 }
11993
11994 /* Empty range entries have no effect. */
11995 if (start == end)
11996 continue;
11997
11998 start += base + baseaddr;
11999 end += base + baseaddr;
12000
12001 /* A not-uncommon case of bad debug info.
12002 Don't pollute the addrmap with bad data. */
12003 if (start == 0 && !dwarf2_per_objfile->has_section_at_zero)
12004 {
12005 complaint (&symfile_complaints,
12006 _(".debug_ranges entry has start address of zero"
12007 " [in module %s]"), objfile_name (objfile));
12008 continue;
12009 }
12010
12011 record_block_range (block, start, end - 1);
12012 }
12013 }
12014 }
12015 }
12016
12017 /* Check whether the producer field indicates either of GCC < 4.6, or the
12018 Intel C/C++ compiler, and cache the result in CU. */
12019
12020 static void
12021 check_producer (struct dwarf2_cu *cu)
12022 {
12023 const char *cs;
12024 int major, minor, release;
12025
12026 if (cu->producer == NULL)
12027 {
12028 /* For unknown compilers expect their behavior is DWARF version
12029 compliant.
12030
12031 GCC started to support .debug_types sections by -gdwarf-4 since
12032 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
12033 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
12034 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
12035 interpreted incorrectly by GDB now - GCC PR debug/48229. */
12036 }
12037 else if (strncmp (cu->producer, "GNU ", strlen ("GNU ")) == 0)
12038 {
12039 /* Skip any identifier after "GNU " - such as "C++" or "Java". */
12040
12041 cs = &cu->producer[strlen ("GNU ")];
12042 while (*cs && !isdigit (*cs))
12043 cs++;
12044 if (sscanf (cs, "%d.%d.%d", &major, &minor, &release) != 3)
12045 {
12046 /* Not recognized as GCC. */
12047 }
12048 else
12049 {
12050 cu->producer_is_gxx_lt_4_6 = major < 4 || (major == 4 && minor < 6);
12051 cu->producer_is_gcc_lt_4_3 = major < 4 || (major == 4 && minor < 3);
12052 }
12053 }
12054 else if (strncmp (cu->producer, "Intel(R) C", strlen ("Intel(R) C")) == 0)
12055 cu->producer_is_icc = 1;
12056 else
12057 {
12058 /* For other non-GCC compilers, expect their behavior is DWARF version
12059 compliant. */
12060 }
12061
12062 cu->checked_producer = 1;
12063 }
12064
12065 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
12066 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
12067 during 4.6.0 experimental. */
12068
12069 static int
12070 producer_is_gxx_lt_4_6 (struct dwarf2_cu *cu)
12071 {
12072 if (!cu->checked_producer)
12073 check_producer (cu);
12074
12075 return cu->producer_is_gxx_lt_4_6;
12076 }
12077
12078 /* Return the default accessibility type if it is not overriden by
12079 DW_AT_accessibility. */
12080
12081 static enum dwarf_access_attribute
12082 dwarf2_default_access_attribute (struct die_info *die, struct dwarf2_cu *cu)
12083 {
12084 if (cu->header.version < 3 || producer_is_gxx_lt_4_6 (cu))
12085 {
12086 /* The default DWARF 2 accessibility for members is public, the default
12087 accessibility for inheritance is private. */
12088
12089 if (die->tag != DW_TAG_inheritance)
12090 return DW_ACCESS_public;
12091 else
12092 return DW_ACCESS_private;
12093 }
12094 else
12095 {
12096 /* DWARF 3+ defines the default accessibility a different way. The same
12097 rules apply now for DW_TAG_inheritance as for the members and it only
12098 depends on the container kind. */
12099
12100 if (die->parent->tag == DW_TAG_class_type)
12101 return DW_ACCESS_private;
12102 else
12103 return DW_ACCESS_public;
12104 }
12105 }
12106
12107 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
12108 offset. If the attribute was not found return 0, otherwise return
12109 1. If it was found but could not properly be handled, set *OFFSET
12110 to 0. */
12111
12112 static int
12113 handle_data_member_location (struct die_info *die, struct dwarf2_cu *cu,
12114 LONGEST *offset)
12115 {
12116 struct attribute *attr;
12117
12118 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
12119 if (attr != NULL)
12120 {
12121 *offset = 0;
12122
12123 /* Note that we do not check for a section offset first here.
12124 This is because DW_AT_data_member_location is new in DWARF 4,
12125 so if we see it, we can assume that a constant form is really
12126 a constant and not a section offset. */
12127 if (attr_form_is_constant (attr))
12128 *offset = dwarf2_get_attr_constant_value (attr, 0);
12129 else if (attr_form_is_section_offset (attr))
12130 dwarf2_complex_location_expr_complaint ();
12131 else if (attr_form_is_block (attr))
12132 *offset = decode_locdesc (DW_BLOCK (attr), cu);
12133 else
12134 dwarf2_complex_location_expr_complaint ();
12135
12136 return 1;
12137 }
12138
12139 return 0;
12140 }
12141
12142 /* Add an aggregate field to the field list. */
12143
12144 static void
12145 dwarf2_add_field (struct field_info *fip, struct die_info *die,
12146 struct dwarf2_cu *cu)
12147 {
12148 struct objfile *objfile = cu->objfile;
12149 struct gdbarch *gdbarch = get_objfile_arch (objfile);
12150 struct nextfield *new_field;
12151 struct attribute *attr;
12152 struct field *fp;
12153 const char *fieldname = "";
12154
12155 /* Allocate a new field list entry and link it in. */
12156 new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield));
12157 make_cleanup (xfree, new_field);
12158 memset (new_field, 0, sizeof (struct nextfield));
12159
12160 if (die->tag == DW_TAG_inheritance)
12161 {
12162 new_field->next = fip->baseclasses;
12163 fip->baseclasses = new_field;
12164 }
12165 else
12166 {
12167 new_field->next = fip->fields;
12168 fip->fields = new_field;
12169 }
12170 fip->nfields++;
12171
12172 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
12173 if (attr)
12174 new_field->accessibility = DW_UNSND (attr);
12175 else
12176 new_field->accessibility = dwarf2_default_access_attribute (die, cu);
12177 if (new_field->accessibility != DW_ACCESS_public)
12178 fip->non_public_fields = 1;
12179
12180 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
12181 if (attr)
12182 new_field->virtuality = DW_UNSND (attr);
12183 else
12184 new_field->virtuality = DW_VIRTUALITY_none;
12185
12186 fp = &new_field->field;
12187
12188 if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
12189 {
12190 LONGEST offset;
12191
12192 /* Data member other than a C++ static data member. */
12193
12194 /* Get type of field. */
12195 fp->type = die_type (die, cu);
12196
12197 SET_FIELD_BITPOS (*fp, 0);
12198
12199 /* Get bit size of field (zero if none). */
12200 attr = dwarf2_attr (die, DW_AT_bit_size, cu);
12201 if (attr)
12202 {
12203 FIELD_BITSIZE (*fp) = DW_UNSND (attr);
12204 }
12205 else
12206 {
12207 FIELD_BITSIZE (*fp) = 0;
12208 }
12209
12210 /* Get bit offset of field. */
12211 if (handle_data_member_location (die, cu, &offset))
12212 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
12213 attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
12214 if (attr)
12215 {
12216 if (gdbarch_bits_big_endian (gdbarch))
12217 {
12218 /* For big endian bits, the DW_AT_bit_offset gives the
12219 additional bit offset from the MSB of the containing
12220 anonymous object to the MSB of the field. We don't
12221 have to do anything special since we don't need to
12222 know the size of the anonymous object. */
12223 SET_FIELD_BITPOS (*fp, FIELD_BITPOS (*fp) + DW_UNSND (attr));
12224 }
12225 else
12226 {
12227 /* For little endian bits, compute the bit offset to the
12228 MSB of the anonymous object, subtract off the number of
12229 bits from the MSB of the field to the MSB of the
12230 object, and then subtract off the number of bits of
12231 the field itself. The result is the bit offset of
12232 the LSB of the field. */
12233 int anonymous_size;
12234 int bit_offset = DW_UNSND (attr);
12235
12236 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
12237 if (attr)
12238 {
12239 /* The size of the anonymous object containing
12240 the bit field is explicit, so use the
12241 indicated size (in bytes). */
12242 anonymous_size = DW_UNSND (attr);
12243 }
12244 else
12245 {
12246 /* The size of the anonymous object containing
12247 the bit field must be inferred from the type
12248 attribute of the data member containing the
12249 bit field. */
12250 anonymous_size = TYPE_LENGTH (fp->type);
12251 }
12252 SET_FIELD_BITPOS (*fp,
12253 (FIELD_BITPOS (*fp)
12254 + anonymous_size * bits_per_byte
12255 - bit_offset - FIELD_BITSIZE (*fp)));
12256 }
12257 }
12258
12259 /* Get name of field. */
12260 fieldname = dwarf2_name (die, cu);
12261 if (fieldname == NULL)
12262 fieldname = "";
12263
12264 /* The name is already allocated along with this objfile, so we don't
12265 need to duplicate it for the type. */
12266 fp->name = fieldname;
12267
12268 /* Change accessibility for artificial fields (e.g. virtual table
12269 pointer or virtual base class pointer) to private. */
12270 if (dwarf2_attr (die, DW_AT_artificial, cu))
12271 {
12272 FIELD_ARTIFICIAL (*fp) = 1;
12273 new_field->accessibility = DW_ACCESS_private;
12274 fip->non_public_fields = 1;
12275 }
12276 }
12277 else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
12278 {
12279 /* C++ static member. */
12280
12281 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
12282 is a declaration, but all versions of G++ as of this writing
12283 (so through at least 3.2.1) incorrectly generate
12284 DW_TAG_variable tags. */
12285
12286 const char *physname;
12287
12288 /* Get name of field. */
12289 fieldname = dwarf2_name (die, cu);
12290 if (fieldname == NULL)
12291 return;
12292
12293 attr = dwarf2_attr (die, DW_AT_const_value, cu);
12294 if (attr
12295 /* Only create a symbol if this is an external value.
12296 new_symbol checks this and puts the value in the global symbol
12297 table, which we want. If it is not external, new_symbol
12298 will try to put the value in cu->list_in_scope which is wrong. */
12299 && dwarf2_flag_true_p (die, DW_AT_external, cu))
12300 {
12301 /* A static const member, not much different than an enum as far as
12302 we're concerned, except that we can support more types. */
12303 new_symbol (die, NULL, cu);
12304 }
12305
12306 /* Get physical name. */
12307 physname = dwarf2_physname (fieldname, die, cu);
12308
12309 /* The name is already allocated along with this objfile, so we don't
12310 need to duplicate it for the type. */
12311 SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
12312 FIELD_TYPE (*fp) = die_type (die, cu);
12313 FIELD_NAME (*fp) = fieldname;
12314 }
12315 else if (die->tag == DW_TAG_inheritance)
12316 {
12317 LONGEST offset;
12318
12319 /* C++ base class field. */
12320 if (handle_data_member_location (die, cu, &offset))
12321 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
12322 FIELD_BITSIZE (*fp) = 0;
12323 FIELD_TYPE (*fp) = die_type (die, cu);
12324 FIELD_NAME (*fp) = type_name_no_tag (fp->type);
12325 fip->nbaseclasses++;
12326 }
12327 }
12328
12329 /* Add a typedef defined in the scope of the FIP's class. */
12330
12331 static void
12332 dwarf2_add_typedef (struct field_info *fip, struct die_info *die,
12333 struct dwarf2_cu *cu)
12334 {
12335 struct objfile *objfile = cu->objfile;
12336 struct typedef_field_list *new_field;
12337 struct attribute *attr;
12338 struct typedef_field *fp;
12339 char *fieldname = "";
12340
12341 /* Allocate a new field list entry and link it in. */
12342 new_field = xzalloc (sizeof (*new_field));
12343 make_cleanup (xfree, new_field);
12344
12345 gdb_assert (die->tag == DW_TAG_typedef);
12346
12347 fp = &new_field->field;
12348
12349 /* Get name of field. */
12350 fp->name = dwarf2_name (die, cu);
12351 if (fp->name == NULL)
12352 return;
12353
12354 fp->type = read_type_die (die, cu);
12355
12356 new_field->next = fip->typedef_field_list;
12357 fip->typedef_field_list = new_field;
12358 fip->typedef_field_list_count++;
12359 }
12360
12361 /* Create the vector of fields, and attach it to the type. */
12362
12363 static void
12364 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
12365 struct dwarf2_cu *cu)
12366 {
12367 int nfields = fip->nfields;
12368
12369 /* Record the field count, allocate space for the array of fields,
12370 and create blank accessibility bitfields if necessary. */
12371 TYPE_NFIELDS (type) = nfields;
12372 TYPE_FIELDS (type) = (struct field *)
12373 TYPE_ALLOC (type, sizeof (struct field) * nfields);
12374 memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
12375
12376 if (fip->non_public_fields && cu->language != language_ada)
12377 {
12378 ALLOCATE_CPLUS_STRUCT_TYPE (type);
12379
12380 TYPE_FIELD_PRIVATE_BITS (type) =
12381 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
12382 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
12383
12384 TYPE_FIELD_PROTECTED_BITS (type) =
12385 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
12386 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
12387
12388 TYPE_FIELD_IGNORE_BITS (type) =
12389 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
12390 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
12391 }
12392
12393 /* If the type has baseclasses, allocate and clear a bit vector for
12394 TYPE_FIELD_VIRTUAL_BITS. */
12395 if (fip->nbaseclasses && cu->language != language_ada)
12396 {
12397 int num_bytes = B_BYTES (fip->nbaseclasses);
12398 unsigned char *pointer;
12399
12400 ALLOCATE_CPLUS_STRUCT_TYPE (type);
12401 pointer = TYPE_ALLOC (type, num_bytes);
12402 TYPE_FIELD_VIRTUAL_BITS (type) = pointer;
12403 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->nbaseclasses);
12404 TYPE_N_BASECLASSES (type) = fip->nbaseclasses;
12405 }
12406
12407 /* Copy the saved-up fields into the field vector. Start from the head of
12408 the list, adding to the tail of the field array, so that they end up in
12409 the same order in the array in which they were added to the list. */
12410 while (nfields-- > 0)
12411 {
12412 struct nextfield *fieldp;
12413
12414 if (fip->fields)
12415 {
12416 fieldp = fip->fields;
12417 fip->fields = fieldp->next;
12418 }
12419 else
12420 {
12421 fieldp = fip->baseclasses;
12422 fip->baseclasses = fieldp->next;
12423 }
12424
12425 TYPE_FIELD (type, nfields) = fieldp->field;
12426 switch (fieldp->accessibility)
12427 {
12428 case DW_ACCESS_private:
12429 if (cu->language != language_ada)
12430 SET_TYPE_FIELD_PRIVATE (type, nfields);
12431 break;
12432
12433 case DW_ACCESS_protected:
12434 if (cu->language != language_ada)
12435 SET_TYPE_FIELD_PROTECTED (type, nfields);
12436 break;
12437
12438 case DW_ACCESS_public:
12439 break;
12440
12441 default:
12442 /* Unknown accessibility. Complain and treat it as public. */
12443 {
12444 complaint (&symfile_complaints, _("unsupported accessibility %d"),
12445 fieldp->accessibility);
12446 }
12447 break;
12448 }
12449 if (nfields < fip->nbaseclasses)
12450 {
12451 switch (fieldp->virtuality)
12452 {
12453 case DW_VIRTUALITY_virtual:
12454 case DW_VIRTUALITY_pure_virtual:
12455 if (cu->language == language_ada)
12456 error (_("unexpected virtuality in component of Ada type"));
12457 SET_TYPE_FIELD_VIRTUAL (type, nfields);
12458 break;
12459 }
12460 }
12461 }
12462 }
12463
12464 /* Return true if this member function is a constructor, false
12465 otherwise. */
12466
12467 static int
12468 dwarf2_is_constructor (struct die_info *die, struct dwarf2_cu *cu)
12469 {
12470 const char *fieldname;
12471 const char *typename;
12472 int len;
12473
12474 if (die->parent == NULL)
12475 return 0;
12476
12477 if (die->parent->tag != DW_TAG_structure_type
12478 && die->parent->tag != DW_TAG_union_type
12479 && die->parent->tag != DW_TAG_class_type)
12480 return 0;
12481
12482 fieldname = dwarf2_name (die, cu);
12483 typename = dwarf2_name (die->parent, cu);
12484 if (fieldname == NULL || typename == NULL)
12485 return 0;
12486
12487 len = strlen (fieldname);
12488 return (strncmp (fieldname, typename, len) == 0
12489 && (typename[len] == '\0' || typename[len] == '<'));
12490 }
12491
12492 /* Add a member function to the proper fieldlist. */
12493
12494 static void
12495 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
12496 struct type *type, struct dwarf2_cu *cu)
12497 {
12498 struct objfile *objfile = cu->objfile;
12499 struct attribute *attr;
12500 struct fnfieldlist *flp;
12501 int i;
12502 struct fn_field *fnp;
12503 const char *fieldname;
12504 struct nextfnfield *new_fnfield;
12505 struct type *this_type;
12506 enum dwarf_access_attribute accessibility;
12507
12508 if (cu->language == language_ada)
12509 error (_("unexpected member function in Ada type"));
12510
12511 /* Get name of member function. */
12512 fieldname = dwarf2_name (die, cu);
12513 if (fieldname == NULL)
12514 return;
12515
12516 /* Look up member function name in fieldlist. */
12517 for (i = 0; i < fip->nfnfields; i++)
12518 {
12519 if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
12520 break;
12521 }
12522
12523 /* Create new list element if necessary. */
12524 if (i < fip->nfnfields)
12525 flp = &fip->fnfieldlists[i];
12526 else
12527 {
12528 if ((fip->nfnfields % DW_FIELD_ALLOC_CHUNK) == 0)
12529 {
12530 fip->fnfieldlists = (struct fnfieldlist *)
12531 xrealloc (fip->fnfieldlists,
12532 (fip->nfnfields + DW_FIELD_ALLOC_CHUNK)
12533 * sizeof (struct fnfieldlist));
12534 if (fip->nfnfields == 0)
12535 make_cleanup (free_current_contents, &fip->fnfieldlists);
12536 }
12537 flp = &fip->fnfieldlists[fip->nfnfields];
12538 flp->name = fieldname;
12539 flp->length = 0;
12540 flp->head = NULL;
12541 i = fip->nfnfields++;
12542 }
12543
12544 /* Create a new member function field and chain it to the field list
12545 entry. */
12546 new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield));
12547 make_cleanup (xfree, new_fnfield);
12548 memset (new_fnfield, 0, sizeof (struct nextfnfield));
12549 new_fnfield->next = flp->head;
12550 flp->head = new_fnfield;
12551 flp->length++;
12552
12553 /* Fill in the member function field info. */
12554 fnp = &new_fnfield->fnfield;
12555
12556 /* Delay processing of the physname until later. */
12557 if (cu->language == language_cplus || cu->language == language_java)
12558 {
12559 add_to_method_list (type, i, flp->length - 1, fieldname,
12560 die, cu);
12561 }
12562 else
12563 {
12564 const char *physname = dwarf2_physname (fieldname, die, cu);
12565 fnp->physname = physname ? physname : "";
12566 }
12567
12568 fnp->type = alloc_type (objfile);
12569 this_type = read_type_die (die, cu);
12570 if (this_type && TYPE_CODE (this_type) == TYPE_CODE_FUNC)
12571 {
12572 int nparams = TYPE_NFIELDS (this_type);
12573
12574 /* TYPE is the domain of this method, and THIS_TYPE is the type
12575 of the method itself (TYPE_CODE_METHOD). */
12576 smash_to_method_type (fnp->type, type,
12577 TYPE_TARGET_TYPE (this_type),
12578 TYPE_FIELDS (this_type),
12579 TYPE_NFIELDS (this_type),
12580 TYPE_VARARGS (this_type));
12581
12582 /* Handle static member functions.
12583 Dwarf2 has no clean way to discern C++ static and non-static
12584 member functions. G++ helps GDB by marking the first
12585 parameter for non-static member functions (which is the this
12586 pointer) as artificial. We obtain this information from
12587 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
12588 if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (this_type, 0) == 0)
12589 fnp->voffset = VOFFSET_STATIC;
12590 }
12591 else
12592 complaint (&symfile_complaints, _("member function type missing for '%s'"),
12593 dwarf2_full_name (fieldname, die, cu));
12594
12595 /* Get fcontext from DW_AT_containing_type if present. */
12596 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
12597 fnp->fcontext = die_containing_type (die, cu);
12598
12599 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
12600 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
12601
12602 /* Get accessibility. */
12603 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
12604 if (attr)
12605 accessibility = DW_UNSND (attr);
12606 else
12607 accessibility = dwarf2_default_access_attribute (die, cu);
12608 switch (accessibility)
12609 {
12610 case DW_ACCESS_private:
12611 fnp->is_private = 1;
12612 break;
12613 case DW_ACCESS_protected:
12614 fnp->is_protected = 1;
12615 break;
12616 }
12617
12618 /* Check for artificial methods. */
12619 attr = dwarf2_attr (die, DW_AT_artificial, cu);
12620 if (attr && DW_UNSND (attr) != 0)
12621 fnp->is_artificial = 1;
12622
12623 fnp->is_constructor = dwarf2_is_constructor (die, cu);
12624
12625 /* Get index in virtual function table if it is a virtual member
12626 function. For older versions of GCC, this is an offset in the
12627 appropriate virtual table, as specified by DW_AT_containing_type.
12628 For everyone else, it is an expression to be evaluated relative
12629 to the object address. */
12630
12631 attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
12632 if (attr)
12633 {
12634 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size > 0)
12635 {
12636 if (DW_BLOCK (attr)->data[0] == DW_OP_constu)
12637 {
12638 /* Old-style GCC. */
12639 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
12640 }
12641 else if (DW_BLOCK (attr)->data[0] == DW_OP_deref
12642 || (DW_BLOCK (attr)->size > 1
12643 && DW_BLOCK (attr)->data[0] == DW_OP_deref_size
12644 && DW_BLOCK (attr)->data[1] == cu->header.addr_size))
12645 {
12646 struct dwarf_block blk;
12647 int offset;
12648
12649 offset = (DW_BLOCK (attr)->data[0] == DW_OP_deref
12650 ? 1 : 2);
12651 blk.size = DW_BLOCK (attr)->size - offset;
12652 blk.data = DW_BLOCK (attr)->data + offset;
12653 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu);
12654 if ((fnp->voffset % cu->header.addr_size) != 0)
12655 dwarf2_complex_location_expr_complaint ();
12656 else
12657 fnp->voffset /= cu->header.addr_size;
12658 fnp->voffset += 2;
12659 }
12660 else
12661 dwarf2_complex_location_expr_complaint ();
12662
12663 if (!fnp->fcontext)
12664 fnp->fcontext = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type, 0));
12665 }
12666 else if (attr_form_is_section_offset (attr))
12667 {
12668 dwarf2_complex_location_expr_complaint ();
12669 }
12670 else
12671 {
12672 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
12673 fieldname);
12674 }
12675 }
12676 else
12677 {
12678 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
12679 if (attr && DW_UNSND (attr))
12680 {
12681 /* GCC does this, as of 2008-08-25; PR debug/37237. */
12682 complaint (&symfile_complaints,
12683 _("Member function \"%s\" (offset %d) is virtual "
12684 "but the vtable offset is not specified"),
12685 fieldname, die->offset.sect_off);
12686 ALLOCATE_CPLUS_STRUCT_TYPE (type);
12687 TYPE_CPLUS_DYNAMIC (type) = 1;
12688 }
12689 }
12690 }
12691
12692 /* Create the vector of member function fields, and attach it to the type. */
12693
12694 static void
12695 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
12696 struct dwarf2_cu *cu)
12697 {
12698 struct fnfieldlist *flp;
12699 int i;
12700
12701 if (cu->language == language_ada)
12702 error (_("unexpected member functions in Ada type"));
12703
12704 ALLOCATE_CPLUS_STRUCT_TYPE (type);
12705 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
12706 TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * fip->nfnfields);
12707
12708 for (i = 0, flp = fip->fnfieldlists; i < fip->nfnfields; i++, flp++)
12709 {
12710 struct nextfnfield *nfp = flp->head;
12711 struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
12712 int k;
12713
12714 TYPE_FN_FIELDLIST_NAME (type, i) = flp->name;
12715 TYPE_FN_FIELDLIST_LENGTH (type, i) = flp->length;
12716 fn_flp->fn_fields = (struct fn_field *)
12717 TYPE_ALLOC (type, sizeof (struct fn_field) * flp->length);
12718 for (k = flp->length; (k--, nfp); nfp = nfp->next)
12719 fn_flp->fn_fields[k] = nfp->fnfield;
12720 }
12721
12722 TYPE_NFN_FIELDS (type) = fip->nfnfields;
12723 }
12724
12725 /* Returns non-zero if NAME is the name of a vtable member in CU's
12726 language, zero otherwise. */
12727 static int
12728 is_vtable_name (const char *name, struct dwarf2_cu *cu)
12729 {
12730 static const char vptr[] = "_vptr";
12731 static const char vtable[] = "vtable";
12732
12733 /* Look for the C++ and Java forms of the vtable. */
12734 if ((cu->language == language_java
12735 && strncmp (name, vtable, sizeof (vtable) - 1) == 0)
12736 || (strncmp (name, vptr, sizeof (vptr) - 1) == 0
12737 && is_cplus_marker (name[sizeof (vptr) - 1])))
12738 return 1;
12739
12740 return 0;
12741 }
12742
12743 /* GCC outputs unnamed structures that are really pointers to member
12744 functions, with the ABI-specified layout. If TYPE describes
12745 such a structure, smash it into a member function type.
12746
12747 GCC shouldn't do this; it should just output pointer to member DIEs.
12748 This is GCC PR debug/28767. */
12749
12750 static void
12751 quirk_gcc_member_function_pointer (struct type *type, struct objfile *objfile)
12752 {
12753 struct type *pfn_type, *domain_type, *new_type;
12754
12755 /* Check for a structure with no name and two children. */
12756 if (TYPE_CODE (type) != TYPE_CODE_STRUCT || TYPE_NFIELDS (type) != 2)
12757 return;
12758
12759 /* Check for __pfn and __delta members. */
12760 if (TYPE_FIELD_NAME (type, 0) == NULL
12761 || strcmp (TYPE_FIELD_NAME (type, 0), "__pfn") != 0
12762 || TYPE_FIELD_NAME (type, 1) == NULL
12763 || strcmp (TYPE_FIELD_NAME (type, 1), "__delta") != 0)
12764 return;
12765
12766 /* Find the type of the method. */
12767 pfn_type = TYPE_FIELD_TYPE (type, 0);
12768 if (pfn_type == NULL
12769 || TYPE_CODE (pfn_type) != TYPE_CODE_PTR
12770 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type)) != TYPE_CODE_FUNC)
12771 return;
12772
12773 /* Look for the "this" argument. */
12774 pfn_type = TYPE_TARGET_TYPE (pfn_type);
12775 if (TYPE_NFIELDS (pfn_type) == 0
12776 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
12777 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type, 0)) != TYPE_CODE_PTR)
12778 return;
12779
12780 domain_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0));
12781 new_type = alloc_type (objfile);
12782 smash_to_method_type (new_type, domain_type, TYPE_TARGET_TYPE (pfn_type),
12783 TYPE_FIELDS (pfn_type), TYPE_NFIELDS (pfn_type),
12784 TYPE_VARARGS (pfn_type));
12785 smash_to_methodptr_type (type, new_type);
12786 }
12787
12788 /* Return non-zero if the CU's PRODUCER string matches the Intel C/C++ compiler
12789 (icc). */
12790
12791 static int
12792 producer_is_icc (struct dwarf2_cu *cu)
12793 {
12794 if (!cu->checked_producer)
12795 check_producer (cu);
12796
12797 return cu->producer_is_icc;
12798 }
12799
12800 /* Called when we find the DIE that starts a structure or union scope
12801 (definition) to create a type for the structure or union. Fill in
12802 the type's name and general properties; the members will not be
12803 processed until process_structure_scope.
12804
12805 NOTE: we need to call these functions regardless of whether or not the
12806 DIE has a DW_AT_name attribute, since it might be an anonymous
12807 structure or union. This gets the type entered into our set of
12808 user defined types.
12809
12810 However, if the structure is incomplete (an opaque struct/union)
12811 then suppress creating a symbol table entry for it since gdb only
12812 wants to find the one with the complete definition. Note that if
12813 it is complete, we just call new_symbol, which does it's own
12814 checking about whether the struct/union is anonymous or not (and
12815 suppresses creating a symbol table entry itself). */
12816
12817 static struct type *
12818 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
12819 {
12820 struct objfile *objfile = cu->objfile;
12821 struct type *type;
12822 struct attribute *attr;
12823 const char *name;
12824
12825 /* If the definition of this type lives in .debug_types, read that type.
12826 Don't follow DW_AT_specification though, that will take us back up
12827 the chain and we want to go down. */
12828 attr = dwarf2_attr_no_follow (die, DW_AT_signature);
12829 if (attr)
12830 {
12831 type = get_DW_AT_signature_type (die, attr, cu);
12832
12833 /* The type's CU may not be the same as CU.
12834 Ensure TYPE is recorded with CU in die_type_hash. */
12835 return set_die_type (die, type, cu);
12836 }
12837
12838 type = alloc_type (objfile);
12839 INIT_CPLUS_SPECIFIC (type);
12840
12841 name = dwarf2_name (die, cu);
12842 if (name != NULL)
12843 {
12844 if (cu->language == language_cplus
12845 || cu->language == language_java)
12846 {
12847 const char *full_name = dwarf2_full_name (name, die, cu);
12848
12849 /* dwarf2_full_name might have already finished building the DIE's
12850 type. If so, there is no need to continue. */
12851 if (get_die_type (die, cu) != NULL)
12852 return get_die_type (die, cu);
12853
12854 TYPE_TAG_NAME (type) = full_name;
12855 if (die->tag == DW_TAG_structure_type
12856 || die->tag == DW_TAG_class_type)
12857 TYPE_NAME (type) = TYPE_TAG_NAME (type);
12858 }
12859 else
12860 {
12861 /* The name is already allocated along with this objfile, so
12862 we don't need to duplicate it for the type. */
12863 TYPE_TAG_NAME (type) = name;
12864 if (die->tag == DW_TAG_class_type)
12865 TYPE_NAME (type) = TYPE_TAG_NAME (type);
12866 }
12867 }
12868
12869 if (die->tag == DW_TAG_structure_type)
12870 {
12871 TYPE_CODE (type) = TYPE_CODE_STRUCT;
12872 }
12873 else if (die->tag == DW_TAG_union_type)
12874 {
12875 TYPE_CODE (type) = TYPE_CODE_UNION;
12876 }
12877 else
12878 {
12879 TYPE_CODE (type) = TYPE_CODE_CLASS;
12880 }
12881
12882 if (cu->language == language_cplus && die->tag == DW_TAG_class_type)
12883 TYPE_DECLARED_CLASS (type) = 1;
12884
12885 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
12886 if (attr)
12887 {
12888 TYPE_LENGTH (type) = DW_UNSND (attr);
12889 }
12890 else
12891 {
12892 TYPE_LENGTH (type) = 0;
12893 }
12894
12895 if (producer_is_icc (cu))
12896 {
12897 /* ICC does not output the required DW_AT_declaration
12898 on incomplete types, but gives them a size of zero. */
12899 }
12900 else
12901 TYPE_STUB_SUPPORTED (type) = 1;
12902
12903 if (die_is_declaration (die, cu))
12904 TYPE_STUB (type) = 1;
12905 else if (attr == NULL && die->child == NULL
12906 && producer_is_realview (cu->producer))
12907 /* RealView does not output the required DW_AT_declaration
12908 on incomplete types. */
12909 TYPE_STUB (type) = 1;
12910
12911 /* We need to add the type field to the die immediately so we don't
12912 infinitely recurse when dealing with pointers to the structure
12913 type within the structure itself. */
12914 set_die_type (die, type, cu);
12915
12916 /* set_die_type should be already done. */
12917 set_descriptive_type (type, die, cu);
12918
12919 return type;
12920 }
12921
12922 /* Finish creating a structure or union type, including filling in
12923 its members and creating a symbol for it. */
12924
12925 static void
12926 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
12927 {
12928 struct objfile *objfile = cu->objfile;
12929 struct die_info *child_die = die->child;
12930 struct type *type;
12931
12932 type = get_die_type (die, cu);
12933 if (type == NULL)
12934 type = read_structure_type (die, cu);
12935
12936 if (die->child != NULL && ! die_is_declaration (die, cu))
12937 {
12938 struct field_info fi;
12939 struct die_info *child_die;
12940 VEC (symbolp) *template_args = NULL;
12941 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
12942
12943 memset (&fi, 0, sizeof (struct field_info));
12944
12945 child_die = die->child;
12946
12947 while (child_die && child_die->tag)
12948 {
12949 if (child_die->tag == DW_TAG_member
12950 || child_die->tag == DW_TAG_variable)
12951 {
12952 /* NOTE: carlton/2002-11-05: A C++ static data member
12953 should be a DW_TAG_member that is a declaration, but
12954 all versions of G++ as of this writing (so through at
12955 least 3.2.1) incorrectly generate DW_TAG_variable
12956 tags for them instead. */
12957 dwarf2_add_field (&fi, child_die, cu);
12958 }
12959 else if (child_die->tag == DW_TAG_subprogram)
12960 {
12961 /* C++ member function. */
12962 dwarf2_add_member_fn (&fi, child_die, type, cu);
12963 }
12964 else if (child_die->tag == DW_TAG_inheritance)
12965 {
12966 /* C++ base class field. */
12967 dwarf2_add_field (&fi, child_die, cu);
12968 }
12969 else if (child_die->tag == DW_TAG_typedef)
12970 dwarf2_add_typedef (&fi, child_die, cu);
12971 else if (child_die->tag == DW_TAG_template_type_param
12972 || child_die->tag == DW_TAG_template_value_param)
12973 {
12974 struct symbol *arg = new_symbol (child_die, NULL, cu);
12975
12976 if (arg != NULL)
12977 VEC_safe_push (symbolp, template_args, arg);
12978 }
12979
12980 child_die = sibling_die (child_die);
12981 }
12982
12983 /* Attach template arguments to type. */
12984 if (! VEC_empty (symbolp, template_args))
12985 {
12986 ALLOCATE_CPLUS_STRUCT_TYPE (type);
12987 TYPE_N_TEMPLATE_ARGUMENTS (type)
12988 = VEC_length (symbolp, template_args);
12989 TYPE_TEMPLATE_ARGUMENTS (type)
12990 = obstack_alloc (&objfile->objfile_obstack,
12991 (TYPE_N_TEMPLATE_ARGUMENTS (type)
12992 * sizeof (struct symbol *)));
12993 memcpy (TYPE_TEMPLATE_ARGUMENTS (type),
12994 VEC_address (symbolp, template_args),
12995 (TYPE_N_TEMPLATE_ARGUMENTS (type)
12996 * sizeof (struct symbol *)));
12997 VEC_free (symbolp, template_args);
12998 }
12999
13000 /* Attach fields and member functions to the type. */
13001 if (fi.nfields)
13002 dwarf2_attach_fields_to_type (&fi, type, cu);
13003 if (fi.nfnfields)
13004 {
13005 dwarf2_attach_fn_fields_to_type (&fi, type, cu);
13006
13007 /* Get the type which refers to the base class (possibly this
13008 class itself) which contains the vtable pointer for the current
13009 class from the DW_AT_containing_type attribute. This use of
13010 DW_AT_containing_type is a GNU extension. */
13011
13012 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
13013 {
13014 struct type *t = die_containing_type (die, cu);
13015
13016 TYPE_VPTR_BASETYPE (type) = t;
13017 if (type == t)
13018 {
13019 int i;
13020
13021 /* Our own class provides vtbl ptr. */
13022 for (i = TYPE_NFIELDS (t) - 1;
13023 i >= TYPE_N_BASECLASSES (t);
13024 --i)
13025 {
13026 const char *fieldname = TYPE_FIELD_NAME (t, i);
13027
13028 if (is_vtable_name (fieldname, cu))
13029 {
13030 TYPE_VPTR_FIELDNO (type) = i;
13031 break;
13032 }
13033 }
13034
13035 /* Complain if virtual function table field not found. */
13036 if (i < TYPE_N_BASECLASSES (t))
13037 complaint (&symfile_complaints,
13038 _("virtual function table pointer "
13039 "not found when defining class '%s'"),
13040 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) :
13041 "");
13042 }
13043 else
13044 {
13045 TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
13046 }
13047 }
13048 else if (cu->producer
13049 && strncmp (cu->producer,
13050 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
13051 {
13052 /* The IBM XLC compiler does not provide direct indication
13053 of the containing type, but the vtable pointer is
13054 always named __vfp. */
13055
13056 int i;
13057
13058 for (i = TYPE_NFIELDS (type) - 1;
13059 i >= TYPE_N_BASECLASSES (type);
13060 --i)
13061 {
13062 if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
13063 {
13064 TYPE_VPTR_FIELDNO (type) = i;
13065 TYPE_VPTR_BASETYPE (type) = type;
13066 break;
13067 }
13068 }
13069 }
13070 }
13071
13072 /* Copy fi.typedef_field_list linked list elements content into the
13073 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
13074 if (fi.typedef_field_list)
13075 {
13076 int i = fi.typedef_field_list_count;
13077
13078 ALLOCATE_CPLUS_STRUCT_TYPE (type);
13079 TYPE_TYPEDEF_FIELD_ARRAY (type)
13080 = TYPE_ALLOC (type, sizeof (TYPE_TYPEDEF_FIELD (type, 0)) * i);
13081 TYPE_TYPEDEF_FIELD_COUNT (type) = i;
13082
13083 /* Reverse the list order to keep the debug info elements order. */
13084 while (--i >= 0)
13085 {
13086 struct typedef_field *dest, *src;
13087
13088 dest = &TYPE_TYPEDEF_FIELD (type, i);
13089 src = &fi.typedef_field_list->field;
13090 fi.typedef_field_list = fi.typedef_field_list->next;
13091 *dest = *src;
13092 }
13093 }
13094
13095 do_cleanups (back_to);
13096
13097 if (HAVE_CPLUS_STRUCT (type))
13098 TYPE_CPLUS_REALLY_JAVA (type) = cu->language == language_java;
13099 }
13100
13101 quirk_gcc_member_function_pointer (type, objfile);
13102
13103 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
13104 snapshots) has been known to create a die giving a declaration
13105 for a class that has, as a child, a die giving a definition for a
13106 nested class. So we have to process our children even if the
13107 current die is a declaration. Normally, of course, a declaration
13108 won't have any children at all. */
13109
13110 while (child_die != NULL && child_die->tag)
13111 {
13112 if (child_die->tag == DW_TAG_member
13113 || child_die->tag == DW_TAG_variable
13114 || child_die->tag == DW_TAG_inheritance
13115 || child_die->tag == DW_TAG_template_value_param
13116 || child_die->tag == DW_TAG_template_type_param)
13117 {
13118 /* Do nothing. */
13119 }
13120 else
13121 process_die (child_die, cu);
13122
13123 child_die = sibling_die (child_die);
13124 }
13125
13126 /* Do not consider external references. According to the DWARF standard,
13127 these DIEs are identified by the fact that they have no byte_size
13128 attribute, and a declaration attribute. */
13129 if (dwarf2_attr (die, DW_AT_byte_size, cu) != NULL
13130 || !die_is_declaration (die, cu))
13131 new_symbol (die, type, cu);
13132 }
13133
13134 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
13135 update TYPE using some information only available in DIE's children. */
13136
13137 static void
13138 update_enumeration_type_from_children (struct die_info *die,
13139 struct type *type,
13140 struct dwarf2_cu *cu)
13141 {
13142 struct obstack obstack;
13143 struct die_info *child_die = die->child;
13144 int unsigned_enum = 1;
13145 int flag_enum = 1;
13146 ULONGEST mask = 0;
13147 struct cleanup *old_chain;
13148
13149 obstack_init (&obstack);
13150 old_chain = make_cleanup_obstack_free (&obstack);
13151
13152 while (child_die != NULL && child_die->tag)
13153 {
13154 struct attribute *attr;
13155 LONGEST value;
13156 const gdb_byte *bytes;
13157 struct dwarf2_locexpr_baton *baton;
13158 const char *name;
13159 if (child_die->tag != DW_TAG_enumerator)
13160 continue;
13161
13162 attr = dwarf2_attr (child_die, DW_AT_const_value, cu);
13163 if (attr == NULL)
13164 continue;
13165
13166 name = dwarf2_name (child_die, cu);
13167 if (name == NULL)
13168 name = "<anonymous enumerator>";
13169
13170 dwarf2_const_value_attr (attr, type, name, &obstack, cu,
13171 &value, &bytes, &baton);
13172 if (value < 0)
13173 {
13174 unsigned_enum = 0;
13175 flag_enum = 0;
13176 }
13177 else if ((mask & value) != 0)
13178 flag_enum = 0;
13179 else
13180 mask |= value;
13181
13182 /* If we already know that the enum type is neither unsigned, nor
13183 a flag type, no need to look at the rest of the enumerates. */
13184 if (!unsigned_enum && !flag_enum)
13185 break;
13186 child_die = sibling_die (child_die);
13187 }
13188
13189 if (unsigned_enum)
13190 TYPE_UNSIGNED (type) = 1;
13191 if (flag_enum)
13192 TYPE_FLAG_ENUM (type) = 1;
13193
13194 do_cleanups (old_chain);
13195 }
13196
13197 /* Given a DW_AT_enumeration_type die, set its type. We do not
13198 complete the type's fields yet, or create any symbols. */
13199
13200 static struct type *
13201 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
13202 {
13203 struct objfile *objfile = cu->objfile;
13204 struct type *type;
13205 struct attribute *attr;
13206 const char *name;
13207
13208 /* If the definition of this type lives in .debug_types, read that type.
13209 Don't follow DW_AT_specification though, that will take us back up
13210 the chain and we want to go down. */
13211 attr = dwarf2_attr_no_follow (die, DW_AT_signature);
13212 if (attr)
13213 {
13214 type = get_DW_AT_signature_type (die, attr, cu);
13215
13216 /* The type's CU may not be the same as CU.
13217 Ensure TYPE is recorded with CU in die_type_hash. */
13218 return set_die_type (die, type, cu);
13219 }
13220
13221 type = alloc_type (objfile);
13222
13223 TYPE_CODE (type) = TYPE_CODE_ENUM;
13224 name = dwarf2_full_name (NULL, die, cu);
13225 if (name != NULL)
13226 TYPE_TAG_NAME (type) = name;
13227
13228 attr = dwarf2_attr (die, DW_AT_type, cu);
13229 if (attr != NULL)
13230 {
13231 struct type *underlying_type = die_type (die, cu);
13232
13233 TYPE_TARGET_TYPE (type) = underlying_type;
13234 }
13235
13236 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
13237 if (attr)
13238 {
13239 TYPE_LENGTH (type) = DW_UNSND (attr);
13240 }
13241 else
13242 {
13243 TYPE_LENGTH (type) = 0;
13244 }
13245
13246 /* The enumeration DIE can be incomplete. In Ada, any type can be
13247 declared as private in the package spec, and then defined only
13248 inside the package body. Such types are known as Taft Amendment
13249 Types. When another package uses such a type, an incomplete DIE
13250 may be generated by the compiler. */
13251 if (die_is_declaration (die, cu))
13252 TYPE_STUB (type) = 1;
13253
13254 /* Finish the creation of this type by using the enum's children.
13255 We must call this even when the underlying type has been provided
13256 so that we can determine if we're looking at a "flag" enum. */
13257 update_enumeration_type_from_children (die, type, cu);
13258
13259 /* If this type has an underlying type that is not a stub, then we
13260 may use its attributes. We always use the "unsigned" attribute
13261 in this situation, because ordinarily we guess whether the type
13262 is unsigned -- but the guess can be wrong and the underlying type
13263 can tell us the reality. However, we defer to a local size
13264 attribute if one exists, because this lets the compiler override
13265 the underlying type if needed. */
13266 if (TYPE_TARGET_TYPE (type) != NULL && !TYPE_STUB (TYPE_TARGET_TYPE (type)))
13267 {
13268 TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type));
13269 if (TYPE_LENGTH (type) == 0)
13270 TYPE_LENGTH (type) = TYPE_LENGTH (TYPE_TARGET_TYPE (type));
13271 }
13272
13273 TYPE_DECLARED_CLASS (type) = dwarf2_flag_true_p (die, DW_AT_enum_class, cu);
13274
13275 return set_die_type (die, type, cu);
13276 }
13277
13278 /* Given a pointer to a die which begins an enumeration, process all
13279 the dies that define the members of the enumeration, and create the
13280 symbol for the enumeration type.
13281
13282 NOTE: We reverse the order of the element list. */
13283
13284 static void
13285 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
13286 {
13287 struct type *this_type;
13288
13289 this_type = get_die_type (die, cu);
13290 if (this_type == NULL)
13291 this_type = read_enumeration_type (die, cu);
13292
13293 if (die->child != NULL)
13294 {
13295 struct die_info *child_die;
13296 struct symbol *sym;
13297 struct field *fields = NULL;
13298 int num_fields = 0;
13299 const char *name;
13300
13301 child_die = die->child;
13302 while (child_die && child_die->tag)
13303 {
13304 if (child_die->tag != DW_TAG_enumerator)
13305 {
13306 process_die (child_die, cu);
13307 }
13308 else
13309 {
13310 name = dwarf2_name (child_die, cu);
13311 if (name)
13312 {
13313 sym = new_symbol (child_die, this_type, cu);
13314
13315 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
13316 {
13317 fields = (struct field *)
13318 xrealloc (fields,
13319 (num_fields + DW_FIELD_ALLOC_CHUNK)
13320 * sizeof (struct field));
13321 }
13322
13323 FIELD_NAME (fields[num_fields]) = SYMBOL_LINKAGE_NAME (sym);
13324 FIELD_TYPE (fields[num_fields]) = NULL;
13325 SET_FIELD_ENUMVAL (fields[num_fields], SYMBOL_VALUE (sym));
13326 FIELD_BITSIZE (fields[num_fields]) = 0;
13327
13328 num_fields++;
13329 }
13330 }
13331
13332 child_die = sibling_die (child_die);
13333 }
13334
13335 if (num_fields)
13336 {
13337 TYPE_NFIELDS (this_type) = num_fields;
13338 TYPE_FIELDS (this_type) = (struct field *)
13339 TYPE_ALLOC (this_type, sizeof (struct field) * num_fields);
13340 memcpy (TYPE_FIELDS (this_type), fields,
13341 sizeof (struct field) * num_fields);
13342 xfree (fields);
13343 }
13344 }
13345
13346 /* If we are reading an enum from a .debug_types unit, and the enum
13347 is a declaration, and the enum is not the signatured type in the
13348 unit, then we do not want to add a symbol for it. Adding a
13349 symbol would in some cases obscure the true definition of the
13350 enum, giving users an incomplete type when the definition is
13351 actually available. Note that we do not want to do this for all
13352 enums which are just declarations, because C++0x allows forward
13353 enum declarations. */
13354 if (cu->per_cu->is_debug_types
13355 && die_is_declaration (die, cu))
13356 {
13357 struct signatured_type *sig_type;
13358
13359 sig_type = (struct signatured_type *) cu->per_cu;
13360 gdb_assert (sig_type->type_offset_in_section.sect_off != 0);
13361 if (sig_type->type_offset_in_section.sect_off != die->offset.sect_off)
13362 return;
13363 }
13364
13365 new_symbol (die, this_type, cu);
13366 }
13367
13368 /* Extract all information from a DW_TAG_array_type DIE and put it in
13369 the DIE's type field. For now, this only handles one dimensional
13370 arrays. */
13371
13372 static struct type *
13373 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
13374 {
13375 struct objfile *objfile = cu->objfile;
13376 struct die_info *child_die;
13377 struct type *type;
13378 struct type *element_type, *range_type, *index_type;
13379 struct type **range_types = NULL;
13380 struct attribute *attr;
13381 int ndim = 0;
13382 struct cleanup *back_to;
13383 const char *name;
13384 unsigned int bit_stride = 0;
13385
13386 element_type = die_type (die, cu);
13387
13388 /* The die_type call above may have already set the type for this DIE. */
13389 type = get_die_type (die, cu);
13390 if (type)
13391 return type;
13392
13393 attr = dwarf2_attr (die, DW_AT_byte_stride, cu);
13394 if (attr != NULL)
13395 bit_stride = DW_UNSND (attr) * 8;
13396
13397 attr = dwarf2_attr (die, DW_AT_bit_stride, cu);
13398 if (attr != NULL)
13399 bit_stride = DW_UNSND (attr);
13400
13401 /* Irix 6.2 native cc creates array types without children for
13402 arrays with unspecified length. */
13403 if (die->child == NULL)
13404 {
13405 index_type = objfile_type (objfile)->builtin_int;
13406 range_type = create_static_range_type (NULL, index_type, 0, -1);
13407 type = create_array_type_with_stride (NULL, element_type, range_type,
13408 bit_stride);
13409 return set_die_type (die, type, cu);
13410 }
13411
13412 back_to = make_cleanup (null_cleanup, NULL);
13413 child_die = die->child;
13414 while (child_die && child_die->tag)
13415 {
13416 if (child_die->tag == DW_TAG_subrange_type)
13417 {
13418 struct type *child_type = read_type_die (child_die, cu);
13419
13420 if (child_type != NULL)
13421 {
13422 /* The range type was succesfully read. Save it for the
13423 array type creation. */
13424 if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0)
13425 {
13426 range_types = (struct type **)
13427 xrealloc (range_types, (ndim + DW_FIELD_ALLOC_CHUNK)
13428 * sizeof (struct type *));
13429 if (ndim == 0)
13430 make_cleanup (free_current_contents, &range_types);
13431 }
13432 range_types[ndim++] = child_type;
13433 }
13434 }
13435 child_die = sibling_die (child_die);
13436 }
13437
13438 /* Dwarf2 dimensions are output from left to right, create the
13439 necessary array types in backwards order. */
13440
13441 type = element_type;
13442
13443 if (read_array_order (die, cu) == DW_ORD_col_major)
13444 {
13445 int i = 0;
13446
13447 while (i < ndim)
13448 type = create_array_type_with_stride (NULL, type, range_types[i++],
13449 bit_stride);
13450 }
13451 else
13452 {
13453 while (ndim-- > 0)
13454 type = create_array_type_with_stride (NULL, type, range_types[ndim],
13455 bit_stride);
13456 }
13457
13458 /* Understand Dwarf2 support for vector types (like they occur on
13459 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
13460 array type. This is not part of the Dwarf2/3 standard yet, but a
13461 custom vendor extension. The main difference between a regular
13462 array and the vector variant is that vectors are passed by value
13463 to functions. */
13464 attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
13465 if (attr)
13466 make_vector_type (type);
13467
13468 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
13469 implementation may choose to implement triple vectors using this
13470 attribute. */
13471 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
13472 if (attr)
13473 {
13474 if (DW_UNSND (attr) >= TYPE_LENGTH (type))
13475 TYPE_LENGTH (type) = DW_UNSND (attr);
13476 else
13477 complaint (&symfile_complaints,
13478 _("DW_AT_byte_size for array type smaller "
13479 "than the total size of elements"));
13480 }
13481
13482 name = dwarf2_name (die, cu);
13483 if (name)
13484 TYPE_NAME (type) = name;
13485
13486 /* Install the type in the die. */
13487 set_die_type (die, type, cu);
13488
13489 /* set_die_type should be already done. */
13490 set_descriptive_type (type, die, cu);
13491
13492 do_cleanups (back_to);
13493
13494 return type;
13495 }
13496
13497 static enum dwarf_array_dim_ordering
13498 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
13499 {
13500 struct attribute *attr;
13501
13502 attr = dwarf2_attr (die, DW_AT_ordering, cu);
13503
13504 if (attr) return DW_SND (attr);
13505
13506 /* GNU F77 is a special case, as at 08/2004 array type info is the
13507 opposite order to the dwarf2 specification, but data is still
13508 laid out as per normal fortran.
13509
13510 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
13511 version checking. */
13512
13513 if (cu->language == language_fortran
13514 && cu->producer && strstr (cu->producer, "GNU F77"))
13515 {
13516 return DW_ORD_row_major;
13517 }
13518
13519 switch (cu->language_defn->la_array_ordering)
13520 {
13521 case array_column_major:
13522 return DW_ORD_col_major;
13523 case array_row_major:
13524 default:
13525 return DW_ORD_row_major;
13526 };
13527 }
13528
13529 /* Extract all information from a DW_TAG_set_type DIE and put it in
13530 the DIE's type field. */
13531
13532 static struct type *
13533 read_set_type (struct die_info *die, struct dwarf2_cu *cu)
13534 {
13535 struct type *domain_type, *set_type;
13536 struct attribute *attr;
13537
13538 domain_type = die_type (die, cu);
13539
13540 /* The die_type call above may have already set the type for this DIE. */
13541 set_type = get_die_type (die, cu);
13542 if (set_type)
13543 return set_type;
13544
13545 set_type = create_set_type (NULL, domain_type);
13546
13547 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
13548 if (attr)
13549 TYPE_LENGTH (set_type) = DW_UNSND (attr);
13550
13551 return set_die_type (die, set_type, cu);
13552 }
13553
13554 /* A helper for read_common_block that creates a locexpr baton.
13555 SYM is the symbol which we are marking as computed.
13556 COMMON_DIE is the DIE for the common block.
13557 COMMON_LOC is the location expression attribute for the common
13558 block itself.
13559 MEMBER_LOC is the location expression attribute for the particular
13560 member of the common block that we are processing.
13561 CU is the CU from which the above come. */
13562
13563 static void
13564 mark_common_block_symbol_computed (struct symbol *sym,
13565 struct die_info *common_die,
13566 struct attribute *common_loc,
13567 struct attribute *member_loc,
13568 struct dwarf2_cu *cu)
13569 {
13570 struct objfile *objfile = dwarf2_per_objfile->objfile;
13571 struct dwarf2_locexpr_baton *baton;
13572 gdb_byte *ptr;
13573 unsigned int cu_off;
13574 enum bfd_endian byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
13575 LONGEST offset = 0;
13576
13577 gdb_assert (common_loc && member_loc);
13578 gdb_assert (attr_form_is_block (common_loc));
13579 gdb_assert (attr_form_is_block (member_loc)
13580 || attr_form_is_constant (member_loc));
13581
13582 baton = obstack_alloc (&objfile->objfile_obstack,
13583 sizeof (struct dwarf2_locexpr_baton));
13584 baton->per_cu = cu->per_cu;
13585 gdb_assert (baton->per_cu);
13586
13587 baton->size = 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
13588
13589 if (attr_form_is_constant (member_loc))
13590 {
13591 offset = dwarf2_get_attr_constant_value (member_loc, 0);
13592 baton->size += 1 /* DW_OP_addr */ + cu->header.addr_size;
13593 }
13594 else
13595 baton->size += DW_BLOCK (member_loc)->size;
13596
13597 ptr = obstack_alloc (&objfile->objfile_obstack, baton->size);
13598 baton->data = ptr;
13599
13600 *ptr++ = DW_OP_call4;
13601 cu_off = common_die->offset.sect_off - cu->per_cu->offset.sect_off;
13602 store_unsigned_integer (ptr, 4, byte_order, cu_off);
13603 ptr += 4;
13604
13605 if (attr_form_is_constant (member_loc))
13606 {
13607 *ptr++ = DW_OP_addr;
13608 store_unsigned_integer (ptr, cu->header.addr_size, byte_order, offset);
13609 ptr += cu->header.addr_size;
13610 }
13611 else
13612 {
13613 /* We have to copy the data here, because DW_OP_call4 will only
13614 use a DW_AT_location attribute. */
13615 memcpy (ptr, DW_BLOCK (member_loc)->data, DW_BLOCK (member_loc)->size);
13616 ptr += DW_BLOCK (member_loc)->size;
13617 }
13618
13619 *ptr++ = DW_OP_plus;
13620 gdb_assert (ptr - baton->data == baton->size);
13621
13622 SYMBOL_LOCATION_BATON (sym) = baton;
13623 SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
13624 }
13625
13626 /* Create appropriate locally-scoped variables for all the
13627 DW_TAG_common_block entries. Also create a struct common_block
13628 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
13629 is used to sepate the common blocks name namespace from regular
13630 variable names. */
13631
13632 static void
13633 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
13634 {
13635 struct attribute *attr;
13636
13637 attr = dwarf2_attr (die, DW_AT_location, cu);
13638 if (attr)
13639 {
13640 /* Support the .debug_loc offsets. */
13641 if (attr_form_is_block (attr))
13642 {
13643 /* Ok. */
13644 }
13645 else if (attr_form_is_section_offset (attr))
13646 {
13647 dwarf2_complex_location_expr_complaint ();
13648 attr = NULL;
13649 }
13650 else
13651 {
13652 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
13653 "common block member");
13654 attr = NULL;
13655 }
13656 }
13657
13658 if (die->child != NULL)
13659 {
13660 struct objfile *objfile = cu->objfile;
13661 struct die_info *child_die;
13662 size_t n_entries = 0, size;
13663 struct common_block *common_block;
13664 struct symbol *sym;
13665
13666 for (child_die = die->child;
13667 child_die && child_die->tag;
13668 child_die = sibling_die (child_die))
13669 ++n_entries;
13670
13671 size = (sizeof (struct common_block)
13672 + (n_entries - 1) * sizeof (struct symbol *));
13673 common_block = obstack_alloc (&objfile->objfile_obstack, size);
13674 memset (common_block->contents, 0, n_entries * sizeof (struct symbol *));
13675 common_block->n_entries = 0;
13676
13677 for (child_die = die->child;
13678 child_die && child_die->tag;
13679 child_die = sibling_die (child_die))
13680 {
13681 /* Create the symbol in the DW_TAG_common_block block in the current
13682 symbol scope. */
13683 sym = new_symbol (child_die, NULL, cu);
13684 if (sym != NULL)
13685 {
13686 struct attribute *member_loc;
13687
13688 common_block->contents[common_block->n_entries++] = sym;
13689
13690 member_loc = dwarf2_attr (child_die, DW_AT_data_member_location,
13691 cu);
13692 if (member_loc)
13693 {
13694 /* GDB has handled this for a long time, but it is
13695 not specified by DWARF. It seems to have been
13696 emitted by gfortran at least as recently as:
13697 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
13698 complaint (&symfile_complaints,
13699 _("Variable in common block has "
13700 "DW_AT_data_member_location "
13701 "- DIE at 0x%x [in module %s]"),
13702 child_die->offset.sect_off,
13703 objfile_name (cu->objfile));
13704
13705 if (attr_form_is_section_offset (member_loc))
13706 dwarf2_complex_location_expr_complaint ();
13707 else if (attr_form_is_constant (member_loc)
13708 || attr_form_is_block (member_loc))
13709 {
13710 if (attr)
13711 mark_common_block_symbol_computed (sym, die, attr,
13712 member_loc, cu);
13713 }
13714 else
13715 dwarf2_complex_location_expr_complaint ();
13716 }
13717 }
13718 }
13719
13720 sym = new_symbol (die, objfile_type (objfile)->builtin_void, cu);
13721 SYMBOL_VALUE_COMMON_BLOCK (sym) = common_block;
13722 }
13723 }
13724
13725 /* Create a type for a C++ namespace. */
13726
13727 static struct type *
13728 read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
13729 {
13730 struct objfile *objfile = cu->objfile;
13731 const char *previous_prefix, *name;
13732 int is_anonymous;
13733 struct type *type;
13734
13735 /* For extensions, reuse the type of the original namespace. */
13736 if (dwarf2_attr (die, DW_AT_extension, cu) != NULL)
13737 {
13738 struct die_info *ext_die;
13739 struct dwarf2_cu *ext_cu = cu;
13740
13741 ext_die = dwarf2_extension (die, &ext_cu);
13742 type = read_type_die (ext_die, ext_cu);
13743
13744 /* EXT_CU may not be the same as CU.
13745 Ensure TYPE is recorded with CU in die_type_hash. */
13746 return set_die_type (die, type, cu);
13747 }
13748
13749 name = namespace_name (die, &is_anonymous, cu);
13750
13751 /* Now build the name of the current namespace. */
13752
13753 previous_prefix = determine_prefix (die, cu);
13754 if (previous_prefix[0] != '\0')
13755 name = typename_concat (&objfile->objfile_obstack,
13756 previous_prefix, name, 0, cu);
13757
13758 /* Create the type. */
13759 type = init_type (TYPE_CODE_NAMESPACE, 0, 0, NULL,
13760 objfile);
13761 TYPE_NAME (type) = name;
13762 TYPE_TAG_NAME (type) = TYPE_NAME (type);
13763
13764 return set_die_type (die, type, cu);
13765 }
13766
13767 /* Read a C++ namespace. */
13768
13769 static void
13770 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
13771 {
13772 struct objfile *objfile = cu->objfile;
13773 int is_anonymous;
13774
13775 /* Add a symbol associated to this if we haven't seen the namespace
13776 before. Also, add a using directive if it's an anonymous
13777 namespace. */
13778
13779 if (dwarf2_attr (die, DW_AT_extension, cu) == NULL)
13780 {
13781 struct type *type;
13782
13783 type = read_type_die (die, cu);
13784 new_symbol (die, type, cu);
13785
13786 namespace_name (die, &is_anonymous, cu);
13787 if (is_anonymous)
13788 {
13789 const char *previous_prefix = determine_prefix (die, cu);
13790
13791 cp_add_using_directive (previous_prefix, TYPE_NAME (type), NULL,
13792 NULL, NULL, 0, &objfile->objfile_obstack);
13793 }
13794 }
13795
13796 if (die->child != NULL)
13797 {
13798 struct die_info *child_die = die->child;
13799
13800 while (child_die && child_die->tag)
13801 {
13802 process_die (child_die, cu);
13803 child_die = sibling_die (child_die);
13804 }
13805 }
13806 }
13807
13808 /* Read a Fortran module as type. This DIE can be only a declaration used for
13809 imported module. Still we need that type as local Fortran "use ... only"
13810 declaration imports depend on the created type in determine_prefix. */
13811
13812 static struct type *
13813 read_module_type (struct die_info *die, struct dwarf2_cu *cu)
13814 {
13815 struct objfile *objfile = cu->objfile;
13816 const char *module_name;
13817 struct type *type;
13818
13819 module_name = dwarf2_name (die, cu);
13820 if (!module_name)
13821 complaint (&symfile_complaints,
13822 _("DW_TAG_module has no name, offset 0x%x"),
13823 die->offset.sect_off);
13824 type = init_type (TYPE_CODE_MODULE, 0, 0, module_name, objfile);
13825
13826 /* determine_prefix uses TYPE_TAG_NAME. */
13827 TYPE_TAG_NAME (type) = TYPE_NAME (type);
13828
13829 return set_die_type (die, type, cu);
13830 }
13831
13832 /* Read a Fortran module. */
13833
13834 static void
13835 read_module (struct die_info *die, struct dwarf2_cu *cu)
13836 {
13837 struct die_info *child_die = die->child;
13838 struct type *type;
13839
13840 type = read_type_die (die, cu);
13841 new_symbol (die, type, cu);
13842
13843 while (child_die && child_die->tag)
13844 {
13845 process_die (child_die, cu);
13846 child_die = sibling_die (child_die);
13847 }
13848 }
13849
13850 /* Return the name of the namespace represented by DIE. Set
13851 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
13852 namespace. */
13853
13854 static const char *
13855 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
13856 {
13857 struct die_info *current_die;
13858 const char *name = NULL;
13859
13860 /* Loop through the extensions until we find a name. */
13861
13862 for (current_die = die;
13863 current_die != NULL;
13864 current_die = dwarf2_extension (die, &cu))
13865 {
13866 name = dwarf2_name (current_die, cu);
13867 if (name != NULL)
13868 break;
13869 }
13870
13871 /* Is it an anonymous namespace? */
13872
13873 *is_anonymous = (name == NULL);
13874 if (*is_anonymous)
13875 name = CP_ANONYMOUS_NAMESPACE_STR;
13876
13877 return name;
13878 }
13879
13880 /* Extract all information from a DW_TAG_pointer_type DIE and add to
13881 the user defined type vector. */
13882
13883 static struct type *
13884 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
13885 {
13886 struct gdbarch *gdbarch = get_objfile_arch (cu->objfile);
13887 struct comp_unit_head *cu_header = &cu->header;
13888 struct type *type;
13889 struct attribute *attr_byte_size;
13890 struct attribute *attr_address_class;
13891 int byte_size, addr_class;
13892 struct type *target_type;
13893
13894 target_type = die_type (die, cu);
13895
13896 /* The die_type call above may have already set the type for this DIE. */
13897 type = get_die_type (die, cu);
13898 if (type)
13899 return type;
13900
13901 type = lookup_pointer_type (target_type);
13902
13903 attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
13904 if (attr_byte_size)
13905 byte_size = DW_UNSND (attr_byte_size);
13906 else
13907 byte_size = cu_header->addr_size;
13908
13909 attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
13910 if (attr_address_class)
13911 addr_class = DW_UNSND (attr_address_class);
13912 else
13913 addr_class = DW_ADDR_none;
13914
13915 /* If the pointer size or address class is different than the
13916 default, create a type variant marked as such and set the
13917 length accordingly. */
13918 if (TYPE_LENGTH (type) != byte_size || addr_class != DW_ADDR_none)
13919 {
13920 if (gdbarch_address_class_type_flags_p (gdbarch))
13921 {
13922 int type_flags;
13923
13924 type_flags = gdbarch_address_class_type_flags
13925 (gdbarch, byte_size, addr_class);
13926 gdb_assert ((type_flags & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
13927 == 0);
13928 type = make_type_with_address_space (type, type_flags);
13929 }
13930 else if (TYPE_LENGTH (type) != byte_size)
13931 {
13932 complaint (&symfile_complaints,
13933 _("invalid pointer size %d"), byte_size);
13934 }
13935 else
13936 {
13937 /* Should we also complain about unhandled address classes? */
13938 }
13939 }
13940
13941 TYPE_LENGTH (type) = byte_size;
13942 return set_die_type (die, type, cu);
13943 }
13944
13945 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
13946 the user defined type vector. */
13947
13948 static struct type *
13949 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
13950 {
13951 struct type *type;
13952 struct type *to_type;
13953 struct type *domain;
13954
13955 to_type = die_type (die, cu);
13956 domain = die_containing_type (die, cu);
13957
13958 /* The calls above may have already set the type for this DIE. */
13959 type = get_die_type (die, cu);
13960 if (type)
13961 return type;
13962
13963 if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_METHOD)
13964 type = lookup_methodptr_type (to_type);
13965 else if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_FUNC)
13966 {
13967 struct type *new_type = alloc_type (cu->objfile);
13968
13969 smash_to_method_type (new_type, domain, TYPE_TARGET_TYPE (to_type),
13970 TYPE_FIELDS (to_type), TYPE_NFIELDS (to_type),
13971 TYPE_VARARGS (to_type));
13972 type = lookup_methodptr_type (new_type);
13973 }
13974 else
13975 type = lookup_memberptr_type (to_type, domain);
13976
13977 return set_die_type (die, type, cu);
13978 }
13979
13980 /* Extract all information from a DW_TAG_reference_type DIE and add to
13981 the user defined type vector. */
13982
13983 static struct type *
13984 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu)
13985 {
13986 struct comp_unit_head *cu_header = &cu->header;
13987 struct type *type, *target_type;
13988 struct attribute *attr;
13989
13990 target_type = die_type (die, cu);
13991
13992 /* The die_type call above may have already set the type for this DIE. */
13993 type = get_die_type (die, cu);
13994 if (type)
13995 return type;
13996
13997 type = lookup_reference_type (target_type);
13998 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
13999 if (attr)
14000 {
14001 TYPE_LENGTH (type) = DW_UNSND (attr);
14002 }
14003 else
14004 {
14005 TYPE_LENGTH (type) = cu_header->addr_size;
14006 }
14007 return set_die_type (die, type, cu);
14008 }
14009
14010 static struct type *
14011 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
14012 {
14013 struct type *base_type, *cv_type;
14014
14015 base_type = die_type (die, cu);
14016
14017 /* The die_type call above may have already set the type for this DIE. */
14018 cv_type = get_die_type (die, cu);
14019 if (cv_type)
14020 return cv_type;
14021
14022 /* In case the const qualifier is applied to an array type, the element type
14023 is so qualified, not the array type (section 6.7.3 of C99). */
14024 if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
14025 {
14026 struct type *el_type, *inner_array;
14027
14028 base_type = copy_type (base_type);
14029 inner_array = base_type;
14030
14031 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
14032 {
14033 TYPE_TARGET_TYPE (inner_array) =
14034 copy_type (TYPE_TARGET_TYPE (inner_array));
14035 inner_array = TYPE_TARGET_TYPE (inner_array);
14036 }
14037
14038 el_type = TYPE_TARGET_TYPE (inner_array);
14039 TYPE_TARGET_TYPE (inner_array) =
14040 make_cv_type (1, TYPE_VOLATILE (el_type), el_type, NULL);
14041
14042 return set_die_type (die, base_type, cu);
14043 }
14044
14045 cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
14046 return set_die_type (die, cv_type, cu);
14047 }
14048
14049 static struct type *
14050 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
14051 {
14052 struct type *base_type, *cv_type;
14053
14054 base_type = die_type (die, cu);
14055
14056 /* The die_type call above may have already set the type for this DIE. */
14057 cv_type = get_die_type (die, cu);
14058 if (cv_type)
14059 return cv_type;
14060
14061 cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
14062 return set_die_type (die, cv_type, cu);
14063 }
14064
14065 /* Handle DW_TAG_restrict_type. */
14066
14067 static struct type *
14068 read_tag_restrict_type (struct die_info *die, struct dwarf2_cu *cu)
14069 {
14070 struct type *base_type, *cv_type;
14071
14072 base_type = die_type (die, cu);
14073
14074 /* The die_type call above may have already set the type for this DIE. */
14075 cv_type = get_die_type (die, cu);
14076 if (cv_type)
14077 return cv_type;
14078
14079 cv_type = make_restrict_type (base_type);
14080 return set_die_type (die, cv_type, cu);
14081 }
14082
14083 /* Extract all information from a DW_TAG_string_type DIE and add to
14084 the user defined type vector. It isn't really a user defined type,
14085 but it behaves like one, with other DIE's using an AT_user_def_type
14086 attribute to reference it. */
14087
14088 static struct type *
14089 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
14090 {
14091 struct objfile *objfile = cu->objfile;
14092 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14093 struct type *type, *range_type, *index_type, *char_type;
14094 struct attribute *attr;
14095 unsigned int length;
14096
14097 attr = dwarf2_attr (die, DW_AT_string_length, cu);
14098 if (attr)
14099 {
14100 length = DW_UNSND (attr);
14101 }
14102 else
14103 {
14104 /* Check for the DW_AT_byte_size attribute. */
14105 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
14106 if (attr)
14107 {
14108 length = DW_UNSND (attr);
14109 }
14110 else
14111 {
14112 length = 1;
14113 }
14114 }
14115
14116 index_type = objfile_type (objfile)->builtin_int;
14117 range_type = create_static_range_type (NULL, index_type, 1, length);
14118 char_type = language_string_char_type (cu->language_defn, gdbarch);
14119 type = create_string_type (NULL, char_type, range_type);
14120
14121 return set_die_type (die, type, cu);
14122 }
14123
14124 /* Assuming that DIE corresponds to a function, returns nonzero
14125 if the function is prototyped. */
14126
14127 static int
14128 prototyped_function_p (struct die_info *die, struct dwarf2_cu *cu)
14129 {
14130 struct attribute *attr;
14131
14132 attr = dwarf2_attr (die, DW_AT_prototyped, cu);
14133 if (attr && (DW_UNSND (attr) != 0))
14134 return 1;
14135
14136 /* The DWARF standard implies that the DW_AT_prototyped attribute
14137 is only meaninful for C, but the concept also extends to other
14138 languages that allow unprototyped functions (Eg: Objective C).
14139 For all other languages, assume that functions are always
14140 prototyped. */
14141 if (cu->language != language_c
14142 && cu->language != language_objc
14143 && cu->language != language_opencl)
14144 return 1;
14145
14146 /* RealView does not emit DW_AT_prototyped. We can not distinguish
14147 prototyped and unprototyped functions; default to prototyped,
14148 since that is more common in modern code (and RealView warns
14149 about unprototyped functions). */
14150 if (producer_is_realview (cu->producer))
14151 return 1;
14152
14153 return 0;
14154 }
14155
14156 /* Handle DIES due to C code like:
14157
14158 struct foo
14159 {
14160 int (*funcp)(int a, long l);
14161 int b;
14162 };
14163
14164 ('funcp' generates a DW_TAG_subroutine_type DIE). */
14165
14166 static struct type *
14167 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
14168 {
14169 struct objfile *objfile = cu->objfile;
14170 struct type *type; /* Type that this function returns. */
14171 struct type *ftype; /* Function that returns above type. */
14172 struct attribute *attr;
14173
14174 type = die_type (die, cu);
14175
14176 /* The die_type call above may have already set the type for this DIE. */
14177 ftype = get_die_type (die, cu);
14178 if (ftype)
14179 return ftype;
14180
14181 ftype = lookup_function_type (type);
14182
14183 if (prototyped_function_p (die, cu))
14184 TYPE_PROTOTYPED (ftype) = 1;
14185
14186 /* Store the calling convention in the type if it's available in
14187 the subroutine die. Otherwise set the calling convention to
14188 the default value DW_CC_normal. */
14189 attr = dwarf2_attr (die, DW_AT_calling_convention, cu);
14190 if (attr)
14191 TYPE_CALLING_CONVENTION (ftype) = DW_UNSND (attr);
14192 else if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL"))
14193 TYPE_CALLING_CONVENTION (ftype) = DW_CC_GDB_IBM_OpenCL;
14194 else
14195 TYPE_CALLING_CONVENTION (ftype) = DW_CC_normal;
14196
14197 /* We need to add the subroutine type to the die immediately so
14198 we don't infinitely recurse when dealing with parameters
14199 declared as the same subroutine type. */
14200 set_die_type (die, ftype, cu);
14201
14202 if (die->child != NULL)
14203 {
14204 struct type *void_type = objfile_type (objfile)->builtin_void;
14205 struct die_info *child_die;
14206 int nparams, iparams;
14207
14208 /* Count the number of parameters.
14209 FIXME: GDB currently ignores vararg functions, but knows about
14210 vararg member functions. */
14211 nparams = 0;
14212 child_die = die->child;
14213 while (child_die && child_die->tag)
14214 {
14215 if (child_die->tag == DW_TAG_formal_parameter)
14216 nparams++;
14217 else if (child_die->tag == DW_TAG_unspecified_parameters)
14218 TYPE_VARARGS (ftype) = 1;
14219 child_die = sibling_die (child_die);
14220 }
14221
14222 /* Allocate storage for parameters and fill them in. */
14223 TYPE_NFIELDS (ftype) = nparams;
14224 TYPE_FIELDS (ftype) = (struct field *)
14225 TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
14226
14227 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
14228 even if we error out during the parameters reading below. */
14229 for (iparams = 0; iparams < nparams; iparams++)
14230 TYPE_FIELD_TYPE (ftype, iparams) = void_type;
14231
14232 iparams = 0;
14233 child_die = die->child;
14234 while (child_die && child_die->tag)
14235 {
14236 if (child_die->tag == DW_TAG_formal_parameter)
14237 {
14238 struct type *arg_type;
14239
14240 /* DWARF version 2 has no clean way to discern C++
14241 static and non-static member functions. G++ helps
14242 GDB by marking the first parameter for non-static
14243 member functions (which is the this pointer) as
14244 artificial. We pass this information to
14245 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
14246
14247 DWARF version 3 added DW_AT_object_pointer, which GCC
14248 4.5 does not yet generate. */
14249 attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
14250 if (attr)
14251 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
14252 else
14253 {
14254 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
14255
14256 /* GCC/43521: In java, the formal parameter
14257 "this" is sometimes not marked with DW_AT_artificial. */
14258 if (cu->language == language_java)
14259 {
14260 const char *name = dwarf2_name (child_die, cu);
14261
14262 if (name && !strcmp (name, "this"))
14263 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 1;
14264 }
14265 }
14266 arg_type = die_type (child_die, cu);
14267
14268 /* RealView does not mark THIS as const, which the testsuite
14269 expects. GCC marks THIS as const in method definitions,
14270 but not in the class specifications (GCC PR 43053). */
14271 if (cu->language == language_cplus && !TYPE_CONST (arg_type)
14272 && TYPE_FIELD_ARTIFICIAL (ftype, iparams))
14273 {
14274 int is_this = 0;
14275 struct dwarf2_cu *arg_cu = cu;
14276 const char *name = dwarf2_name (child_die, cu);
14277
14278 attr = dwarf2_attr (die, DW_AT_object_pointer, cu);
14279 if (attr)
14280 {
14281 /* If the compiler emits this, use it. */
14282 if (follow_die_ref (die, attr, &arg_cu) == child_die)
14283 is_this = 1;
14284 }
14285 else if (name && strcmp (name, "this") == 0)
14286 /* Function definitions will have the argument names. */
14287 is_this = 1;
14288 else if (name == NULL && iparams == 0)
14289 /* Declarations may not have the names, so like
14290 elsewhere in GDB, assume an artificial first
14291 argument is "this". */
14292 is_this = 1;
14293
14294 if (is_this)
14295 arg_type = make_cv_type (1, TYPE_VOLATILE (arg_type),
14296 arg_type, 0);
14297 }
14298
14299 TYPE_FIELD_TYPE (ftype, iparams) = arg_type;
14300 iparams++;
14301 }
14302 child_die = sibling_die (child_die);
14303 }
14304 }
14305
14306 return ftype;
14307 }
14308
14309 static struct type *
14310 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
14311 {
14312 struct objfile *objfile = cu->objfile;
14313 const char *name = NULL;
14314 struct type *this_type, *target_type;
14315
14316 name = dwarf2_full_name (NULL, die, cu);
14317 this_type = init_type (TYPE_CODE_TYPEDEF, 0,
14318 TYPE_FLAG_TARGET_STUB, NULL, objfile);
14319 TYPE_NAME (this_type) = name;
14320 set_die_type (die, this_type, cu);
14321 target_type = die_type (die, cu);
14322 if (target_type != this_type)
14323 TYPE_TARGET_TYPE (this_type) = target_type;
14324 else
14325 {
14326 /* Self-referential typedefs are, it seems, not allowed by the DWARF
14327 spec and cause infinite loops in GDB. */
14328 complaint (&symfile_complaints,
14329 _("Self-referential DW_TAG_typedef "
14330 "- DIE at 0x%x [in module %s]"),
14331 die->offset.sect_off, objfile_name (objfile));
14332 TYPE_TARGET_TYPE (this_type) = NULL;
14333 }
14334 return this_type;
14335 }
14336
14337 /* Find a representation of a given base type and install
14338 it in the TYPE field of the die. */
14339
14340 static struct type *
14341 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
14342 {
14343 struct objfile *objfile = cu->objfile;
14344 struct type *type;
14345 struct attribute *attr;
14346 int encoding = 0, size = 0;
14347 const char *name;
14348 enum type_code code = TYPE_CODE_INT;
14349 int type_flags = 0;
14350 struct type *target_type = NULL;
14351
14352 attr = dwarf2_attr (die, DW_AT_encoding, cu);
14353 if (attr)
14354 {
14355 encoding = DW_UNSND (attr);
14356 }
14357 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
14358 if (attr)
14359 {
14360 size = DW_UNSND (attr);
14361 }
14362 name = dwarf2_name (die, cu);
14363 if (!name)
14364 {
14365 complaint (&symfile_complaints,
14366 _("DW_AT_name missing from DW_TAG_base_type"));
14367 }
14368
14369 switch (encoding)
14370 {
14371 case DW_ATE_address:
14372 /* Turn DW_ATE_address into a void * pointer. */
14373 code = TYPE_CODE_PTR;
14374 type_flags |= TYPE_FLAG_UNSIGNED;
14375 target_type = init_type (TYPE_CODE_VOID, 1, 0, NULL, objfile);
14376 break;
14377 case DW_ATE_boolean:
14378 code = TYPE_CODE_BOOL;
14379 type_flags |= TYPE_FLAG_UNSIGNED;
14380 break;
14381 case DW_ATE_complex_float:
14382 code = TYPE_CODE_COMPLEX;
14383 target_type = init_type (TYPE_CODE_FLT, size / 2, 0, NULL, objfile);
14384 break;
14385 case DW_ATE_decimal_float:
14386 code = TYPE_CODE_DECFLOAT;
14387 break;
14388 case DW_ATE_float:
14389 code = TYPE_CODE_FLT;
14390 break;
14391 case DW_ATE_signed:
14392 break;
14393 case DW_ATE_unsigned:
14394 type_flags |= TYPE_FLAG_UNSIGNED;
14395 if (cu->language == language_fortran
14396 && name
14397 && strncmp (name, "character(", sizeof ("character(") - 1) == 0)
14398 code = TYPE_CODE_CHAR;
14399 break;
14400 case DW_ATE_signed_char:
14401 if (cu->language == language_ada || cu->language == language_m2
14402 || cu->language == language_pascal
14403 || cu->language == language_fortran)
14404 code = TYPE_CODE_CHAR;
14405 break;
14406 case DW_ATE_unsigned_char:
14407 if (cu->language == language_ada || cu->language == language_m2
14408 || cu->language == language_pascal
14409 || cu->language == language_fortran)
14410 code = TYPE_CODE_CHAR;
14411 type_flags |= TYPE_FLAG_UNSIGNED;
14412 break;
14413 case DW_ATE_UTF:
14414 /* We just treat this as an integer and then recognize the
14415 type by name elsewhere. */
14416 break;
14417
14418 default:
14419 complaint (&symfile_complaints, _("unsupported DW_AT_encoding: '%s'"),
14420 dwarf_type_encoding_name (encoding));
14421 break;
14422 }
14423
14424 type = init_type (code, size, type_flags, NULL, objfile);
14425 TYPE_NAME (type) = name;
14426 TYPE_TARGET_TYPE (type) = target_type;
14427
14428 if (name && strcmp (name, "char") == 0)
14429 TYPE_NOSIGN (type) = 1;
14430
14431 return set_die_type (die, type, cu);
14432 }
14433
14434 /* Parse dwarf attribute if it's a block, reference or constant and put the
14435 resulting value of the attribute into struct bound_prop.
14436 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
14437
14438 static int
14439 attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die,
14440 struct dwarf2_cu *cu, struct dynamic_prop *prop)
14441 {
14442 struct dwarf2_property_baton *baton;
14443 struct obstack *obstack = &cu->objfile->objfile_obstack;
14444
14445 if (attr == NULL || prop == NULL)
14446 return 0;
14447
14448 if (attr_form_is_block (attr))
14449 {
14450 baton = obstack_alloc (obstack, sizeof (*baton));
14451 baton->referenced_type = NULL;
14452 baton->locexpr.per_cu = cu->per_cu;
14453 baton->locexpr.size = DW_BLOCK (attr)->size;
14454 baton->locexpr.data = DW_BLOCK (attr)->data;
14455 prop->data.baton = baton;
14456 prop->kind = PROP_LOCEXPR;
14457 gdb_assert (prop->data.baton != NULL);
14458 }
14459 else if (attr_form_is_ref (attr))
14460 {
14461 struct dwarf2_cu *target_cu = cu;
14462 struct die_info *target_die;
14463 struct attribute *target_attr;
14464
14465 target_die = follow_die_ref (die, attr, &target_cu);
14466 target_attr = dwarf2_attr (target_die, DW_AT_location, target_cu);
14467 if (target_attr == NULL)
14468 return 0;
14469
14470 if (attr_form_is_section_offset (target_attr))
14471 {
14472 baton = obstack_alloc (obstack, sizeof (*baton));
14473 baton->referenced_type = die_type (target_die, target_cu);
14474 fill_in_loclist_baton (cu, &baton->loclist, target_attr);
14475 prop->data.baton = baton;
14476 prop->kind = PROP_LOCLIST;
14477 gdb_assert (prop->data.baton != NULL);
14478 }
14479 else if (attr_form_is_block (target_attr))
14480 {
14481 baton = obstack_alloc (obstack, sizeof (*baton));
14482 baton->referenced_type = die_type (target_die, target_cu);
14483 baton->locexpr.per_cu = cu->per_cu;
14484 baton->locexpr.size = DW_BLOCK (target_attr)->size;
14485 baton->locexpr.data = DW_BLOCK (target_attr)->data;
14486 prop->data.baton = baton;
14487 prop->kind = PROP_LOCEXPR;
14488 gdb_assert (prop->data.baton != NULL);
14489 }
14490 else
14491 {
14492 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
14493 "dynamic property");
14494 return 0;
14495 }
14496 }
14497 else if (attr_form_is_constant (attr))
14498 {
14499 prop->data.const_val = dwarf2_get_attr_constant_value (attr, 0);
14500 prop->kind = PROP_CONST;
14501 }
14502 else
14503 {
14504 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr->form),
14505 dwarf2_name (die, cu));
14506 return 0;
14507 }
14508
14509 return 1;
14510 }
14511
14512 /* Read the given DW_AT_subrange DIE. */
14513
14514 static struct type *
14515 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
14516 {
14517 struct type *base_type, *orig_base_type;
14518 struct type *range_type;
14519 struct attribute *attr;
14520 struct dynamic_prop low, high;
14521 int low_default_is_valid;
14522 int high_bound_is_count = 0;
14523 const char *name;
14524 LONGEST negative_mask;
14525
14526 orig_base_type = die_type (die, cu);
14527 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
14528 whereas the real type might be. So, we use ORIG_BASE_TYPE when
14529 creating the range type, but we use the result of check_typedef
14530 when examining properties of the type. */
14531 base_type = check_typedef (orig_base_type);
14532
14533 /* The die_type call above may have already set the type for this DIE. */
14534 range_type = get_die_type (die, cu);
14535 if (range_type)
14536 return range_type;
14537
14538 low.kind = PROP_CONST;
14539 high.kind = PROP_CONST;
14540 high.data.const_val = 0;
14541
14542 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
14543 omitting DW_AT_lower_bound. */
14544 switch (cu->language)
14545 {
14546 case language_c:
14547 case language_cplus:
14548 low.data.const_val = 0;
14549 low_default_is_valid = 1;
14550 break;
14551 case language_fortran:
14552 low.data.const_val = 1;
14553 low_default_is_valid = 1;
14554 break;
14555 case language_d:
14556 case language_java:
14557 case language_objc:
14558 low.data.const_val = 0;
14559 low_default_is_valid = (cu->header.version >= 4);
14560 break;
14561 case language_ada:
14562 case language_m2:
14563 case language_pascal:
14564 low.data.const_val = 1;
14565 low_default_is_valid = (cu->header.version >= 4);
14566 break;
14567 default:
14568 low.data.const_val = 0;
14569 low_default_is_valid = 0;
14570 break;
14571 }
14572
14573 /* FIXME: For variable sized arrays either of these could be
14574 a variable rather than a constant value. We'll allow it,
14575 but we don't know how to handle it. */
14576 attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
14577 if (attr)
14578 low.data.const_val
14579 = dwarf2_get_attr_constant_value (attr, low.data.const_val);
14580 else if (!low_default_is_valid)
14581 complaint (&symfile_complaints, _("Missing DW_AT_lower_bound "
14582 "- DIE at 0x%x [in module %s]"),
14583 die->offset.sect_off, objfile_name (cu->objfile));
14584
14585 attr = dwarf2_attr (die, DW_AT_upper_bound, cu);
14586 if (!attr_to_dynamic_prop (attr, die, cu, &high))
14587 {
14588 attr = dwarf2_attr (die, DW_AT_count, cu);
14589 if (attr_to_dynamic_prop (attr, die, cu, &high))
14590 {
14591 /* If bounds are constant do the final calculation here. */
14592 if (low.kind == PROP_CONST && high.kind == PROP_CONST)
14593 high.data.const_val = low.data.const_val + high.data.const_val - 1;
14594 else
14595 high_bound_is_count = 1;
14596 }
14597 }
14598
14599 /* Dwarf-2 specifications explicitly allows to create subrange types
14600 without specifying a base type.
14601 In that case, the base type must be set to the type of
14602 the lower bound, upper bound or count, in that order, if any of these
14603 three attributes references an object that has a type.
14604 If no base type is found, the Dwarf-2 specifications say that
14605 a signed integer type of size equal to the size of an address should
14606 be used.
14607 For the following C code: `extern char gdb_int [];'
14608 GCC produces an empty range DIE.
14609 FIXME: muller/2010-05-28: Possible references to object for low bound,
14610 high bound or count are not yet handled by this code. */
14611 if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
14612 {
14613 struct objfile *objfile = cu->objfile;
14614 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14615 int addr_size = gdbarch_addr_bit (gdbarch) /8;
14616 struct type *int_type = objfile_type (objfile)->builtin_int;
14617
14618 /* Test "int", "long int", and "long long int" objfile types,
14619 and select the first one having a size above or equal to the
14620 architecture address size. */
14621 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
14622 base_type = int_type;
14623 else
14624 {
14625 int_type = objfile_type (objfile)->builtin_long;
14626 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
14627 base_type = int_type;
14628 else
14629 {
14630 int_type = objfile_type (objfile)->builtin_long_long;
14631 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
14632 base_type = int_type;
14633 }
14634 }
14635 }
14636
14637 /* Normally, the DWARF producers are expected to use a signed
14638 constant form (Eg. DW_FORM_sdata) to express negative bounds.
14639 But this is unfortunately not always the case, as witnessed
14640 with GCC, for instance, where the ambiguous DW_FORM_dataN form
14641 is used instead. To work around that ambiguity, we treat
14642 the bounds as signed, and thus sign-extend their values, when
14643 the base type is signed. */
14644 negative_mask =
14645 (LONGEST) -1 << (TYPE_LENGTH (base_type) * TARGET_CHAR_BIT - 1);
14646 if (low.kind == PROP_CONST
14647 && !TYPE_UNSIGNED (base_type) && (low.data.const_val & negative_mask))
14648 low.data.const_val |= negative_mask;
14649 if (high.kind == PROP_CONST
14650 && !TYPE_UNSIGNED (base_type) && (high.data.const_val & negative_mask))
14651 high.data.const_val |= negative_mask;
14652
14653 range_type = create_range_type (NULL, orig_base_type, &low, &high);
14654
14655 if (high_bound_is_count)
14656 TYPE_RANGE_DATA (range_type)->flag_upper_bound_is_count = 1;
14657
14658 /* Ada expects an empty array on no boundary attributes. */
14659 if (attr == NULL && cu->language != language_ada)
14660 TYPE_HIGH_BOUND_KIND (range_type) = PROP_UNDEFINED;
14661
14662 name = dwarf2_name (die, cu);
14663 if (name)
14664 TYPE_NAME (range_type) = name;
14665
14666 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
14667 if (attr)
14668 TYPE_LENGTH (range_type) = DW_UNSND (attr);
14669
14670 set_die_type (die, range_type, cu);
14671
14672 /* set_die_type should be already done. */
14673 set_descriptive_type (range_type, die, cu);
14674
14675 return range_type;
14676 }
14677
14678 static struct type *
14679 read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
14680 {
14681 struct type *type;
14682
14683 /* For now, we only support the C meaning of an unspecified type: void. */
14684
14685 type = init_type (TYPE_CODE_VOID, 0, 0, NULL, cu->objfile);
14686 TYPE_NAME (type) = dwarf2_name (die, cu);
14687
14688 return set_die_type (die, type, cu);
14689 }
14690
14691 /* Read a single die and all its descendents. Set the die's sibling
14692 field to NULL; set other fields in the die correctly, and set all
14693 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
14694 location of the info_ptr after reading all of those dies. PARENT
14695 is the parent of the die in question. */
14696
14697 static struct die_info *
14698 read_die_and_children (const struct die_reader_specs *reader,
14699 const gdb_byte *info_ptr,
14700 const gdb_byte **new_info_ptr,
14701 struct die_info *parent)
14702 {
14703 struct die_info *die;
14704 const gdb_byte *cur_ptr;
14705 int has_children;
14706
14707 cur_ptr = read_full_die_1 (reader, &die, info_ptr, &has_children, 0);
14708 if (die == NULL)
14709 {
14710 *new_info_ptr = cur_ptr;
14711 return NULL;
14712 }
14713 store_in_ref_table (die, reader->cu);
14714
14715 if (has_children)
14716 die->child = read_die_and_siblings_1 (reader, cur_ptr, new_info_ptr, die);
14717 else
14718 {
14719 die->child = NULL;
14720 *new_info_ptr = cur_ptr;
14721 }
14722
14723 die->sibling = NULL;
14724 die->parent = parent;
14725 return die;
14726 }
14727
14728 /* Read a die, all of its descendents, and all of its siblings; set
14729 all of the fields of all of the dies correctly. Arguments are as
14730 in read_die_and_children. */
14731
14732 static struct die_info *
14733 read_die_and_siblings_1 (const struct die_reader_specs *reader,
14734 const gdb_byte *info_ptr,
14735 const gdb_byte **new_info_ptr,
14736 struct die_info *parent)
14737 {
14738 struct die_info *first_die, *last_sibling;
14739 const gdb_byte *cur_ptr;
14740
14741 cur_ptr = info_ptr;
14742 first_die = last_sibling = NULL;
14743
14744 while (1)
14745 {
14746 struct die_info *die
14747 = read_die_and_children (reader, cur_ptr, &cur_ptr, parent);
14748
14749 if (die == NULL)
14750 {
14751 *new_info_ptr = cur_ptr;
14752 return first_die;
14753 }
14754
14755 if (!first_die)
14756 first_die = die;
14757 else
14758 last_sibling->sibling = die;
14759
14760 last_sibling = die;
14761 }
14762 }
14763
14764 /* Read a die, all of its descendents, and all of its siblings; set
14765 all of the fields of all of the dies correctly. Arguments are as
14766 in read_die_and_children.
14767 This the main entry point for reading a DIE and all its children. */
14768
14769 static struct die_info *
14770 read_die_and_siblings (const struct die_reader_specs *reader,
14771 const gdb_byte *info_ptr,
14772 const gdb_byte **new_info_ptr,
14773 struct die_info *parent)
14774 {
14775 struct die_info *die = read_die_and_siblings_1 (reader, info_ptr,
14776 new_info_ptr, parent);
14777
14778 if (dwarf2_die_debug)
14779 {
14780 fprintf_unfiltered (gdb_stdlog,
14781 "Read die from %s@0x%x of %s:\n",
14782 get_section_name (reader->die_section),
14783 (unsigned) (info_ptr - reader->die_section->buffer),
14784 bfd_get_filename (reader->abfd));
14785 dump_die (die, dwarf2_die_debug);
14786 }
14787
14788 return die;
14789 }
14790
14791 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
14792 attributes.
14793 The caller is responsible for filling in the extra attributes
14794 and updating (*DIEP)->num_attrs.
14795 Set DIEP to point to a newly allocated die with its information,
14796 except for its child, sibling, and parent fields.
14797 Set HAS_CHILDREN to tell whether the die has children or not. */
14798
14799 static const gdb_byte *
14800 read_full_die_1 (const struct die_reader_specs *reader,
14801 struct die_info **diep, const gdb_byte *info_ptr,
14802 int *has_children, int num_extra_attrs)
14803 {
14804 unsigned int abbrev_number, bytes_read, i;
14805 sect_offset offset;
14806 struct abbrev_info *abbrev;
14807 struct die_info *die;
14808 struct dwarf2_cu *cu = reader->cu;
14809 bfd *abfd = reader->abfd;
14810
14811 offset.sect_off = info_ptr - reader->buffer;
14812 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
14813 info_ptr += bytes_read;
14814 if (!abbrev_number)
14815 {
14816 *diep = NULL;
14817 *has_children = 0;
14818 return info_ptr;
14819 }
14820
14821 abbrev = abbrev_table_lookup_abbrev (cu->abbrev_table, abbrev_number);
14822 if (!abbrev)
14823 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
14824 abbrev_number,
14825 bfd_get_filename (abfd));
14826
14827 die = dwarf_alloc_die (cu, abbrev->num_attrs + num_extra_attrs);
14828 die->offset = offset;
14829 die->tag = abbrev->tag;
14830 die->abbrev = abbrev_number;
14831
14832 /* Make the result usable.
14833 The caller needs to update num_attrs after adding the extra
14834 attributes. */
14835 die->num_attrs = abbrev->num_attrs;
14836
14837 for (i = 0; i < abbrev->num_attrs; ++i)
14838 info_ptr = read_attribute (reader, &die->attrs[i], &abbrev->attrs[i],
14839 info_ptr);
14840
14841 *diep = die;
14842 *has_children = abbrev->has_children;
14843 return info_ptr;
14844 }
14845
14846 /* Read a die and all its attributes.
14847 Set DIEP to point to a newly allocated die with its information,
14848 except for its child, sibling, and parent fields.
14849 Set HAS_CHILDREN to tell whether the die has children or not. */
14850
14851 static const gdb_byte *
14852 read_full_die (const struct die_reader_specs *reader,
14853 struct die_info **diep, const gdb_byte *info_ptr,
14854 int *has_children)
14855 {
14856 const gdb_byte *result;
14857
14858 result = read_full_die_1 (reader, diep, info_ptr, has_children, 0);
14859
14860 if (dwarf2_die_debug)
14861 {
14862 fprintf_unfiltered (gdb_stdlog,
14863 "Read die from %s@0x%x of %s:\n",
14864 get_section_name (reader->die_section),
14865 (unsigned) (info_ptr - reader->die_section->buffer),
14866 bfd_get_filename (reader->abfd));
14867 dump_die (*diep, dwarf2_die_debug);
14868 }
14869
14870 return result;
14871 }
14872 \f
14873 /* Abbreviation tables.
14874
14875 In DWARF version 2, the description of the debugging information is
14876 stored in a separate .debug_abbrev section. Before we read any
14877 dies from a section we read in all abbreviations and install them
14878 in a hash table. */
14879
14880 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
14881
14882 static struct abbrev_info *
14883 abbrev_table_alloc_abbrev (struct abbrev_table *abbrev_table)
14884 {
14885 struct abbrev_info *abbrev;
14886
14887 abbrev = (struct abbrev_info *)
14888 obstack_alloc (&abbrev_table->abbrev_obstack, sizeof (struct abbrev_info));
14889 memset (abbrev, 0, sizeof (struct abbrev_info));
14890 return abbrev;
14891 }
14892
14893 /* Add an abbreviation to the table. */
14894
14895 static void
14896 abbrev_table_add_abbrev (struct abbrev_table *abbrev_table,
14897 unsigned int abbrev_number,
14898 struct abbrev_info *abbrev)
14899 {
14900 unsigned int hash_number;
14901
14902 hash_number = abbrev_number % ABBREV_HASH_SIZE;
14903 abbrev->next = abbrev_table->abbrevs[hash_number];
14904 abbrev_table->abbrevs[hash_number] = abbrev;
14905 }
14906
14907 /* Look up an abbrev in the table.
14908 Returns NULL if the abbrev is not found. */
14909
14910 static struct abbrev_info *
14911 abbrev_table_lookup_abbrev (const struct abbrev_table *abbrev_table,
14912 unsigned int abbrev_number)
14913 {
14914 unsigned int hash_number;
14915 struct abbrev_info *abbrev;
14916
14917 hash_number = abbrev_number % ABBREV_HASH_SIZE;
14918 abbrev = abbrev_table->abbrevs[hash_number];
14919
14920 while (abbrev)
14921 {
14922 if (abbrev->number == abbrev_number)
14923 return abbrev;
14924 abbrev = abbrev->next;
14925 }
14926 return NULL;
14927 }
14928
14929 /* Read in an abbrev table. */
14930
14931 static struct abbrev_table *
14932 abbrev_table_read_table (struct dwarf2_section_info *section,
14933 sect_offset offset)
14934 {
14935 struct objfile *objfile = dwarf2_per_objfile->objfile;
14936 bfd *abfd = get_section_bfd_owner (section);
14937 struct abbrev_table *abbrev_table;
14938 const gdb_byte *abbrev_ptr;
14939 struct abbrev_info *cur_abbrev;
14940 unsigned int abbrev_number, bytes_read, abbrev_name;
14941 unsigned int abbrev_form;
14942 struct attr_abbrev *cur_attrs;
14943 unsigned int allocated_attrs;
14944
14945 abbrev_table = XNEW (struct abbrev_table);
14946 abbrev_table->offset = offset;
14947 obstack_init (&abbrev_table->abbrev_obstack);
14948 abbrev_table->abbrevs = obstack_alloc (&abbrev_table->abbrev_obstack,
14949 (ABBREV_HASH_SIZE
14950 * sizeof (struct abbrev_info *)));
14951 memset (abbrev_table->abbrevs, 0,
14952 ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
14953
14954 dwarf2_read_section (objfile, section);
14955 abbrev_ptr = section->buffer + offset.sect_off;
14956 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
14957 abbrev_ptr += bytes_read;
14958
14959 allocated_attrs = ATTR_ALLOC_CHUNK;
14960 cur_attrs = xmalloc (allocated_attrs * sizeof (struct attr_abbrev));
14961
14962 /* Loop until we reach an abbrev number of 0. */
14963 while (abbrev_number)
14964 {
14965 cur_abbrev = abbrev_table_alloc_abbrev (abbrev_table);
14966
14967 /* read in abbrev header */
14968 cur_abbrev->number = abbrev_number;
14969 cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
14970 abbrev_ptr += bytes_read;
14971 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
14972 abbrev_ptr += 1;
14973
14974 /* now read in declarations */
14975 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
14976 abbrev_ptr += bytes_read;
14977 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
14978 abbrev_ptr += bytes_read;
14979 while (abbrev_name)
14980 {
14981 if (cur_abbrev->num_attrs == allocated_attrs)
14982 {
14983 allocated_attrs += ATTR_ALLOC_CHUNK;
14984 cur_attrs
14985 = xrealloc (cur_attrs, (allocated_attrs
14986 * sizeof (struct attr_abbrev)));
14987 }
14988
14989 cur_attrs[cur_abbrev->num_attrs].name = abbrev_name;
14990 cur_attrs[cur_abbrev->num_attrs++].form = abbrev_form;
14991 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
14992 abbrev_ptr += bytes_read;
14993 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
14994 abbrev_ptr += bytes_read;
14995 }
14996
14997 cur_abbrev->attrs = obstack_alloc (&abbrev_table->abbrev_obstack,
14998 (cur_abbrev->num_attrs
14999 * sizeof (struct attr_abbrev)));
15000 memcpy (cur_abbrev->attrs, cur_attrs,
15001 cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
15002
15003 abbrev_table_add_abbrev (abbrev_table, abbrev_number, cur_abbrev);
15004
15005 /* Get next abbreviation.
15006 Under Irix6 the abbreviations for a compilation unit are not
15007 always properly terminated with an abbrev number of 0.
15008 Exit loop if we encounter an abbreviation which we have
15009 already read (which means we are about to read the abbreviations
15010 for the next compile unit) or if the end of the abbreviation
15011 table is reached. */
15012 if ((unsigned int) (abbrev_ptr - section->buffer) >= section->size)
15013 break;
15014 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
15015 abbrev_ptr += bytes_read;
15016 if (abbrev_table_lookup_abbrev (abbrev_table, abbrev_number) != NULL)
15017 break;
15018 }
15019
15020 xfree (cur_attrs);
15021 return abbrev_table;
15022 }
15023
15024 /* Free the resources held by ABBREV_TABLE. */
15025
15026 static void
15027 abbrev_table_free (struct abbrev_table *abbrev_table)
15028 {
15029 obstack_free (&abbrev_table->abbrev_obstack, NULL);
15030 xfree (abbrev_table);
15031 }
15032
15033 /* Same as abbrev_table_free but as a cleanup.
15034 We pass in a pointer to the pointer to the table so that we can
15035 set the pointer to NULL when we're done. It also simplifies
15036 build_type_unit_groups. */
15037
15038 static void
15039 abbrev_table_free_cleanup (void *table_ptr)
15040 {
15041 struct abbrev_table **abbrev_table_ptr = table_ptr;
15042
15043 if (*abbrev_table_ptr != NULL)
15044 abbrev_table_free (*abbrev_table_ptr);
15045 *abbrev_table_ptr = NULL;
15046 }
15047
15048 /* Read the abbrev table for CU from ABBREV_SECTION. */
15049
15050 static void
15051 dwarf2_read_abbrevs (struct dwarf2_cu *cu,
15052 struct dwarf2_section_info *abbrev_section)
15053 {
15054 cu->abbrev_table =
15055 abbrev_table_read_table (abbrev_section, cu->header.abbrev_offset);
15056 }
15057
15058 /* Release the memory used by the abbrev table for a compilation unit. */
15059
15060 static void
15061 dwarf2_free_abbrev_table (void *ptr_to_cu)
15062 {
15063 struct dwarf2_cu *cu = ptr_to_cu;
15064
15065 if (cu->abbrev_table != NULL)
15066 abbrev_table_free (cu->abbrev_table);
15067 /* Set this to NULL so that we SEGV if we try to read it later,
15068 and also because free_comp_unit verifies this is NULL. */
15069 cu->abbrev_table = NULL;
15070 }
15071 \f
15072 /* Returns nonzero if TAG represents a type that we might generate a partial
15073 symbol for. */
15074
15075 static int
15076 is_type_tag_for_partial (int tag)
15077 {
15078 switch (tag)
15079 {
15080 #if 0
15081 /* Some types that would be reasonable to generate partial symbols for,
15082 that we don't at present. */
15083 case DW_TAG_array_type:
15084 case DW_TAG_file_type:
15085 case DW_TAG_ptr_to_member_type:
15086 case DW_TAG_set_type:
15087 case DW_TAG_string_type:
15088 case DW_TAG_subroutine_type:
15089 #endif
15090 case DW_TAG_base_type:
15091 case DW_TAG_class_type:
15092 case DW_TAG_interface_type:
15093 case DW_TAG_enumeration_type:
15094 case DW_TAG_structure_type:
15095 case DW_TAG_subrange_type:
15096 case DW_TAG_typedef:
15097 case DW_TAG_union_type:
15098 return 1;
15099 default:
15100 return 0;
15101 }
15102 }
15103
15104 /* Load all DIEs that are interesting for partial symbols into memory. */
15105
15106 static struct partial_die_info *
15107 load_partial_dies (const struct die_reader_specs *reader,
15108 const gdb_byte *info_ptr, int building_psymtab)
15109 {
15110 struct dwarf2_cu *cu = reader->cu;
15111 struct objfile *objfile = cu->objfile;
15112 struct partial_die_info *part_die;
15113 struct partial_die_info *parent_die, *last_die, *first_die = NULL;
15114 struct abbrev_info *abbrev;
15115 unsigned int bytes_read;
15116 unsigned int load_all = 0;
15117 int nesting_level = 1;
15118
15119 parent_die = NULL;
15120 last_die = NULL;
15121
15122 gdb_assert (cu->per_cu != NULL);
15123 if (cu->per_cu->load_all_dies)
15124 load_all = 1;
15125
15126 cu->partial_dies
15127 = htab_create_alloc_ex (cu->header.length / 12,
15128 partial_die_hash,
15129 partial_die_eq,
15130 NULL,
15131 &cu->comp_unit_obstack,
15132 hashtab_obstack_allocate,
15133 dummy_obstack_deallocate);
15134
15135 part_die = obstack_alloc (&cu->comp_unit_obstack,
15136 sizeof (struct partial_die_info));
15137
15138 while (1)
15139 {
15140 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
15141
15142 /* A NULL abbrev means the end of a series of children. */
15143 if (abbrev == NULL)
15144 {
15145 if (--nesting_level == 0)
15146 {
15147 /* PART_DIE was probably the last thing allocated on the
15148 comp_unit_obstack, so we could call obstack_free
15149 here. We don't do that because the waste is small,
15150 and will be cleaned up when we're done with this
15151 compilation unit. This way, we're also more robust
15152 against other users of the comp_unit_obstack. */
15153 return first_die;
15154 }
15155 info_ptr += bytes_read;
15156 last_die = parent_die;
15157 parent_die = parent_die->die_parent;
15158 continue;
15159 }
15160
15161 /* Check for template arguments. We never save these; if
15162 they're seen, we just mark the parent, and go on our way. */
15163 if (parent_die != NULL
15164 && cu->language == language_cplus
15165 && (abbrev->tag == DW_TAG_template_type_param
15166 || abbrev->tag == DW_TAG_template_value_param))
15167 {
15168 parent_die->has_template_arguments = 1;
15169
15170 if (!load_all)
15171 {
15172 /* We don't need a partial DIE for the template argument. */
15173 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
15174 continue;
15175 }
15176 }
15177
15178 /* We only recurse into c++ subprograms looking for template arguments.
15179 Skip their other children. */
15180 if (!load_all
15181 && cu->language == language_cplus
15182 && parent_die != NULL
15183 && parent_die->tag == DW_TAG_subprogram)
15184 {
15185 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
15186 continue;
15187 }
15188
15189 /* Check whether this DIE is interesting enough to save. Normally
15190 we would not be interested in members here, but there may be
15191 later variables referencing them via DW_AT_specification (for
15192 static members). */
15193 if (!load_all
15194 && !is_type_tag_for_partial (abbrev->tag)
15195 && abbrev->tag != DW_TAG_constant
15196 && abbrev->tag != DW_TAG_enumerator
15197 && abbrev->tag != DW_TAG_subprogram
15198 && abbrev->tag != DW_TAG_lexical_block
15199 && abbrev->tag != DW_TAG_variable
15200 && abbrev->tag != DW_TAG_namespace
15201 && abbrev->tag != DW_TAG_module
15202 && abbrev->tag != DW_TAG_member
15203 && abbrev->tag != DW_TAG_imported_unit
15204 && abbrev->tag != DW_TAG_imported_declaration)
15205 {
15206 /* Otherwise we skip to the next sibling, if any. */
15207 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
15208 continue;
15209 }
15210
15211 info_ptr = read_partial_die (reader, part_die, abbrev, bytes_read,
15212 info_ptr);
15213
15214 /* This two-pass algorithm for processing partial symbols has a
15215 high cost in cache pressure. Thus, handle some simple cases
15216 here which cover the majority of C partial symbols. DIEs
15217 which neither have specification tags in them, nor could have
15218 specification tags elsewhere pointing at them, can simply be
15219 processed and discarded.
15220
15221 This segment is also optional; scan_partial_symbols and
15222 add_partial_symbol will handle these DIEs if we chain
15223 them in normally. When compilers which do not emit large
15224 quantities of duplicate debug information are more common,
15225 this code can probably be removed. */
15226
15227 /* Any complete simple types at the top level (pretty much all
15228 of them, for a language without namespaces), can be processed
15229 directly. */
15230 if (parent_die == NULL
15231 && part_die->has_specification == 0
15232 && part_die->is_declaration == 0
15233 && ((part_die->tag == DW_TAG_typedef && !part_die->has_children)
15234 || part_die->tag == DW_TAG_base_type
15235 || part_die->tag == DW_TAG_subrange_type))
15236 {
15237 if (building_psymtab && part_die->name != NULL)
15238 add_psymbol_to_list (part_die->name, strlen (part_die->name), 0,
15239 VAR_DOMAIN, LOC_TYPEDEF,
15240 &objfile->static_psymbols,
15241 0, (CORE_ADDR) 0, cu->language, objfile);
15242 info_ptr = locate_pdi_sibling (reader, part_die, info_ptr);
15243 continue;
15244 }
15245
15246 /* The exception for DW_TAG_typedef with has_children above is
15247 a workaround of GCC PR debug/47510. In the case of this complaint
15248 type_name_no_tag_or_error will error on such types later.
15249
15250 GDB skipped children of DW_TAG_typedef by the shortcut above and then
15251 it could not find the child DIEs referenced later, this is checked
15252 above. In correct DWARF DW_TAG_typedef should have no children. */
15253
15254 if (part_die->tag == DW_TAG_typedef && part_die->has_children)
15255 complaint (&symfile_complaints,
15256 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
15257 "- DIE at 0x%x [in module %s]"),
15258 part_die->offset.sect_off, objfile_name (objfile));
15259
15260 /* If we're at the second level, and we're an enumerator, and
15261 our parent has no specification (meaning possibly lives in a
15262 namespace elsewhere), then we can add the partial symbol now
15263 instead of queueing it. */
15264 if (part_die->tag == DW_TAG_enumerator
15265 && parent_die != NULL
15266 && parent_die->die_parent == NULL
15267 && parent_die->tag == DW_TAG_enumeration_type
15268 && parent_die->has_specification == 0)
15269 {
15270 if (part_die->name == NULL)
15271 complaint (&symfile_complaints,
15272 _("malformed enumerator DIE ignored"));
15273 else if (building_psymtab)
15274 add_psymbol_to_list (part_die->name, strlen (part_die->name), 0,
15275 VAR_DOMAIN, LOC_CONST,
15276 (cu->language == language_cplus
15277 || cu->language == language_java)
15278 ? &objfile->global_psymbols
15279 : &objfile->static_psymbols,
15280 0, (CORE_ADDR) 0, cu->language, objfile);
15281
15282 info_ptr = locate_pdi_sibling (reader, part_die, info_ptr);
15283 continue;
15284 }
15285
15286 /* We'll save this DIE so link it in. */
15287 part_die->die_parent = parent_die;
15288 part_die->die_sibling = NULL;
15289 part_die->die_child = NULL;
15290
15291 if (last_die && last_die == parent_die)
15292 last_die->die_child = part_die;
15293 else if (last_die)
15294 last_die->die_sibling = part_die;
15295
15296 last_die = part_die;
15297
15298 if (first_die == NULL)
15299 first_die = part_die;
15300
15301 /* Maybe add the DIE to the hash table. Not all DIEs that we
15302 find interesting need to be in the hash table, because we
15303 also have the parent/sibling/child chains; only those that we
15304 might refer to by offset later during partial symbol reading.
15305
15306 For now this means things that might have be the target of a
15307 DW_AT_specification, DW_AT_abstract_origin, or
15308 DW_AT_extension. DW_AT_extension will refer only to
15309 namespaces; DW_AT_abstract_origin refers to functions (and
15310 many things under the function DIE, but we do not recurse
15311 into function DIEs during partial symbol reading) and
15312 possibly variables as well; DW_AT_specification refers to
15313 declarations. Declarations ought to have the DW_AT_declaration
15314 flag. It happens that GCC forgets to put it in sometimes, but
15315 only for functions, not for types.
15316
15317 Adding more things than necessary to the hash table is harmless
15318 except for the performance cost. Adding too few will result in
15319 wasted time in find_partial_die, when we reread the compilation
15320 unit with load_all_dies set. */
15321
15322 if (load_all
15323 || abbrev->tag == DW_TAG_constant
15324 || abbrev->tag == DW_TAG_subprogram
15325 || abbrev->tag == DW_TAG_variable
15326 || abbrev->tag == DW_TAG_namespace
15327 || part_die->is_declaration)
15328 {
15329 void **slot;
15330
15331 slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
15332 part_die->offset.sect_off, INSERT);
15333 *slot = part_die;
15334 }
15335
15336 part_die = obstack_alloc (&cu->comp_unit_obstack,
15337 sizeof (struct partial_die_info));
15338
15339 /* For some DIEs we want to follow their children (if any). For C
15340 we have no reason to follow the children of structures; for other
15341 languages we have to, so that we can get at method physnames
15342 to infer fully qualified class names, for DW_AT_specification,
15343 and for C++ template arguments. For C++, we also look one level
15344 inside functions to find template arguments (if the name of the
15345 function does not already contain the template arguments).
15346
15347 For Ada, we need to scan the children of subprograms and lexical
15348 blocks as well because Ada allows the definition of nested
15349 entities that could be interesting for the debugger, such as
15350 nested subprograms for instance. */
15351 if (last_die->has_children
15352 && (load_all
15353 || last_die->tag == DW_TAG_namespace
15354 || last_die->tag == DW_TAG_module
15355 || last_die->tag == DW_TAG_enumeration_type
15356 || (cu->language == language_cplus
15357 && last_die->tag == DW_TAG_subprogram
15358 && (last_die->name == NULL
15359 || strchr (last_die->name, '<') == NULL))
15360 || (cu->language != language_c
15361 && (last_die->tag == DW_TAG_class_type
15362 || last_die->tag == DW_TAG_interface_type
15363 || last_die->tag == DW_TAG_structure_type
15364 || last_die->tag == DW_TAG_union_type))
15365 || (cu->language == language_ada
15366 && (last_die->tag == DW_TAG_subprogram
15367 || last_die->tag == DW_TAG_lexical_block))))
15368 {
15369 nesting_level++;
15370 parent_die = last_die;
15371 continue;
15372 }
15373
15374 /* Otherwise we skip to the next sibling, if any. */
15375 info_ptr = locate_pdi_sibling (reader, last_die, info_ptr);
15376
15377 /* Back to the top, do it again. */
15378 }
15379 }
15380
15381 /* Read a minimal amount of information into the minimal die structure. */
15382
15383 static const gdb_byte *
15384 read_partial_die (const struct die_reader_specs *reader,
15385 struct partial_die_info *part_die,
15386 struct abbrev_info *abbrev, unsigned int abbrev_len,
15387 const gdb_byte *info_ptr)
15388 {
15389 struct dwarf2_cu *cu = reader->cu;
15390 struct objfile *objfile = cu->objfile;
15391 const gdb_byte *buffer = reader->buffer;
15392 unsigned int i;
15393 struct attribute attr;
15394 int has_low_pc_attr = 0;
15395 int has_high_pc_attr = 0;
15396 int high_pc_relative = 0;
15397
15398 memset (part_die, 0, sizeof (struct partial_die_info));
15399
15400 part_die->offset.sect_off = info_ptr - buffer;
15401
15402 info_ptr += abbrev_len;
15403
15404 if (abbrev == NULL)
15405 return info_ptr;
15406
15407 part_die->tag = abbrev->tag;
15408 part_die->has_children = abbrev->has_children;
15409
15410 for (i = 0; i < abbrev->num_attrs; ++i)
15411 {
15412 info_ptr = read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
15413
15414 /* Store the data if it is of an attribute we want to keep in a
15415 partial symbol table. */
15416 switch (attr.name)
15417 {
15418 case DW_AT_name:
15419 switch (part_die->tag)
15420 {
15421 case DW_TAG_compile_unit:
15422 case DW_TAG_partial_unit:
15423 case DW_TAG_type_unit:
15424 /* Compilation units have a DW_AT_name that is a filename, not
15425 a source language identifier. */
15426 case DW_TAG_enumeration_type:
15427 case DW_TAG_enumerator:
15428 /* These tags always have simple identifiers already; no need
15429 to canonicalize them. */
15430 part_die->name = DW_STRING (&attr);
15431 break;
15432 default:
15433 part_die->name
15434 = dwarf2_canonicalize_name (DW_STRING (&attr), cu,
15435 &objfile->objfile_obstack);
15436 break;
15437 }
15438 break;
15439 case DW_AT_linkage_name:
15440 case DW_AT_MIPS_linkage_name:
15441 /* Note that both forms of linkage name might appear. We
15442 assume they will be the same, and we only store the last
15443 one we see. */
15444 if (cu->language == language_ada)
15445 part_die->name = DW_STRING (&attr);
15446 part_die->linkage_name = DW_STRING (&attr);
15447 break;
15448 case DW_AT_low_pc:
15449 has_low_pc_attr = 1;
15450 part_die->lowpc = attr_value_as_address (&attr);
15451 break;
15452 case DW_AT_high_pc:
15453 has_high_pc_attr = 1;
15454 part_die->highpc = attr_value_as_address (&attr);
15455 if (cu->header.version >= 4 && attr_form_is_constant (&attr))
15456 high_pc_relative = 1;
15457 break;
15458 case DW_AT_location:
15459 /* Support the .debug_loc offsets. */
15460 if (attr_form_is_block (&attr))
15461 {
15462 part_die->d.locdesc = DW_BLOCK (&attr);
15463 }
15464 else if (attr_form_is_section_offset (&attr))
15465 {
15466 dwarf2_complex_location_expr_complaint ();
15467 }
15468 else
15469 {
15470 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
15471 "partial symbol information");
15472 }
15473 break;
15474 case DW_AT_external:
15475 part_die->is_external = DW_UNSND (&attr);
15476 break;
15477 case DW_AT_declaration:
15478 part_die->is_declaration = DW_UNSND (&attr);
15479 break;
15480 case DW_AT_type:
15481 part_die->has_type = 1;
15482 break;
15483 case DW_AT_abstract_origin:
15484 case DW_AT_specification:
15485 case DW_AT_extension:
15486 part_die->has_specification = 1;
15487 part_die->spec_offset = dwarf2_get_ref_die_offset (&attr);
15488 part_die->spec_is_dwz = (attr.form == DW_FORM_GNU_ref_alt
15489 || cu->per_cu->is_dwz);
15490 break;
15491 case DW_AT_sibling:
15492 /* Ignore absolute siblings, they might point outside of
15493 the current compile unit. */
15494 if (attr.form == DW_FORM_ref_addr)
15495 complaint (&symfile_complaints,
15496 _("ignoring absolute DW_AT_sibling"));
15497 else
15498 {
15499 unsigned int off = dwarf2_get_ref_die_offset (&attr).sect_off;
15500 const gdb_byte *sibling_ptr = buffer + off;
15501
15502 if (sibling_ptr < info_ptr)
15503 complaint (&symfile_complaints,
15504 _("DW_AT_sibling points backwards"));
15505 else
15506 part_die->sibling = sibling_ptr;
15507 }
15508 break;
15509 case DW_AT_byte_size:
15510 part_die->has_byte_size = 1;
15511 break;
15512 case DW_AT_calling_convention:
15513 /* DWARF doesn't provide a way to identify a program's source-level
15514 entry point. DW_AT_calling_convention attributes are only meant
15515 to describe functions' calling conventions.
15516
15517 However, because it's a necessary piece of information in
15518 Fortran, and because DW_CC_program is the only piece of debugging
15519 information whose definition refers to a 'main program' at all,
15520 several compilers have begun marking Fortran main programs with
15521 DW_CC_program --- even when those functions use the standard
15522 calling conventions.
15523
15524 So until DWARF specifies a way to provide this information and
15525 compilers pick up the new representation, we'll support this
15526 practice. */
15527 if (DW_UNSND (&attr) == DW_CC_program
15528 && cu->language == language_fortran)
15529 set_objfile_main_name (objfile, part_die->name, language_fortran);
15530 break;
15531 case DW_AT_inline:
15532 if (DW_UNSND (&attr) == DW_INL_inlined
15533 || DW_UNSND (&attr) == DW_INL_declared_inlined)
15534 part_die->may_be_inlined = 1;
15535 break;
15536
15537 case DW_AT_import:
15538 if (part_die->tag == DW_TAG_imported_unit)
15539 {
15540 part_die->d.offset = dwarf2_get_ref_die_offset (&attr);
15541 part_die->is_dwz = (attr.form == DW_FORM_GNU_ref_alt
15542 || cu->per_cu->is_dwz);
15543 }
15544 break;
15545
15546 default:
15547 break;
15548 }
15549 }
15550
15551 if (high_pc_relative)
15552 part_die->highpc += part_die->lowpc;
15553
15554 if (has_low_pc_attr && has_high_pc_attr)
15555 {
15556 /* When using the GNU linker, .gnu.linkonce. sections are used to
15557 eliminate duplicate copies of functions and vtables and such.
15558 The linker will arbitrarily choose one and discard the others.
15559 The AT_*_pc values for such functions refer to local labels in
15560 these sections. If the section from that file was discarded, the
15561 labels are not in the output, so the relocs get a value of 0.
15562 If this is a discarded function, mark the pc bounds as invalid,
15563 so that GDB will ignore it. */
15564 if (part_die->lowpc == 0 && !dwarf2_per_objfile->has_section_at_zero)
15565 {
15566 struct gdbarch *gdbarch = get_objfile_arch (objfile);
15567
15568 complaint (&symfile_complaints,
15569 _("DW_AT_low_pc %s is zero "
15570 "for DIE at 0x%x [in module %s]"),
15571 paddress (gdbarch, part_die->lowpc),
15572 part_die->offset.sect_off, objfile_name (objfile));
15573 }
15574 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
15575 else if (part_die->lowpc >= part_die->highpc)
15576 {
15577 struct gdbarch *gdbarch = get_objfile_arch (objfile);
15578
15579 complaint (&symfile_complaints,
15580 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
15581 "for DIE at 0x%x [in module %s]"),
15582 paddress (gdbarch, part_die->lowpc),
15583 paddress (gdbarch, part_die->highpc),
15584 part_die->offset.sect_off, objfile_name (objfile));
15585 }
15586 else
15587 part_die->has_pc_info = 1;
15588 }
15589
15590 return info_ptr;
15591 }
15592
15593 /* Find a cached partial DIE at OFFSET in CU. */
15594
15595 static struct partial_die_info *
15596 find_partial_die_in_comp_unit (sect_offset offset, struct dwarf2_cu *cu)
15597 {
15598 struct partial_die_info *lookup_die = NULL;
15599 struct partial_die_info part_die;
15600
15601 part_die.offset = offset;
15602 lookup_die = htab_find_with_hash (cu->partial_dies, &part_die,
15603 offset.sect_off);
15604
15605 return lookup_die;
15606 }
15607
15608 /* Find a partial DIE at OFFSET, which may or may not be in CU,
15609 except in the case of .debug_types DIEs which do not reference
15610 outside their CU (they do however referencing other types via
15611 DW_FORM_ref_sig8). */
15612
15613 static struct partial_die_info *
15614 find_partial_die (sect_offset offset, int offset_in_dwz, struct dwarf2_cu *cu)
15615 {
15616 struct objfile *objfile = cu->objfile;
15617 struct dwarf2_per_cu_data *per_cu = NULL;
15618 struct partial_die_info *pd = NULL;
15619
15620 if (offset_in_dwz == cu->per_cu->is_dwz
15621 && offset_in_cu_p (&cu->header, offset))
15622 {
15623 pd = find_partial_die_in_comp_unit (offset, cu);
15624 if (pd != NULL)
15625 return pd;
15626 /* We missed recording what we needed.
15627 Load all dies and try again. */
15628 per_cu = cu->per_cu;
15629 }
15630 else
15631 {
15632 /* TUs don't reference other CUs/TUs (except via type signatures). */
15633 if (cu->per_cu->is_debug_types)
15634 {
15635 error (_("Dwarf Error: Type Unit at offset 0x%lx contains"
15636 " external reference to offset 0x%lx [in module %s].\n"),
15637 (long) cu->header.offset.sect_off, (long) offset.sect_off,
15638 bfd_get_filename (objfile->obfd));
15639 }
15640 per_cu = dwarf2_find_containing_comp_unit (offset, offset_in_dwz,
15641 objfile);
15642
15643 if (per_cu->cu == NULL || per_cu->cu->partial_dies == NULL)
15644 load_partial_comp_unit (per_cu);
15645
15646 per_cu->cu->last_used = 0;
15647 pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
15648 }
15649
15650 /* If we didn't find it, and not all dies have been loaded,
15651 load them all and try again. */
15652
15653 if (pd == NULL && per_cu->load_all_dies == 0)
15654 {
15655 per_cu->load_all_dies = 1;
15656
15657 /* This is nasty. When we reread the DIEs, somewhere up the call chain
15658 THIS_CU->cu may already be in use. So we can't just free it and
15659 replace its DIEs with the ones we read in. Instead, we leave those
15660 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
15661 and clobber THIS_CU->cu->partial_dies with the hash table for the new
15662 set. */
15663 load_partial_comp_unit (per_cu);
15664
15665 pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
15666 }
15667
15668 if (pd == NULL)
15669 internal_error (__FILE__, __LINE__,
15670 _("could not find partial DIE 0x%x "
15671 "in cache [from module %s]\n"),
15672 offset.sect_off, bfd_get_filename (objfile->obfd));
15673 return pd;
15674 }
15675
15676 /* See if we can figure out if the class lives in a namespace. We do
15677 this by looking for a member function; its demangled name will
15678 contain namespace info, if there is any. */
15679
15680 static void
15681 guess_partial_die_structure_name (struct partial_die_info *struct_pdi,
15682 struct dwarf2_cu *cu)
15683 {
15684 /* NOTE: carlton/2003-10-07: Getting the info this way changes
15685 what template types look like, because the demangler
15686 frequently doesn't give the same name as the debug info. We
15687 could fix this by only using the demangled name to get the
15688 prefix (but see comment in read_structure_type). */
15689
15690 struct partial_die_info *real_pdi;
15691 struct partial_die_info *child_pdi;
15692
15693 /* If this DIE (this DIE's specification, if any) has a parent, then
15694 we should not do this. We'll prepend the parent's fully qualified
15695 name when we create the partial symbol. */
15696
15697 real_pdi = struct_pdi;
15698 while (real_pdi->has_specification)
15699 real_pdi = find_partial_die (real_pdi->spec_offset,
15700 real_pdi->spec_is_dwz, cu);
15701
15702 if (real_pdi->die_parent != NULL)
15703 return;
15704
15705 for (child_pdi = struct_pdi->die_child;
15706 child_pdi != NULL;
15707 child_pdi = child_pdi->die_sibling)
15708 {
15709 if (child_pdi->tag == DW_TAG_subprogram
15710 && child_pdi->linkage_name != NULL)
15711 {
15712 char *actual_class_name
15713 = language_class_name_from_physname (cu->language_defn,
15714 child_pdi->linkage_name);
15715 if (actual_class_name != NULL)
15716 {
15717 struct_pdi->name
15718 = obstack_copy0 (&cu->objfile->objfile_obstack,
15719 actual_class_name,
15720 strlen (actual_class_name));
15721 xfree (actual_class_name);
15722 }
15723 break;
15724 }
15725 }
15726 }
15727
15728 /* Adjust PART_DIE before generating a symbol for it. This function
15729 may set the is_external flag or change the DIE's name. */
15730
15731 static void
15732 fixup_partial_die (struct partial_die_info *part_die,
15733 struct dwarf2_cu *cu)
15734 {
15735 /* Once we've fixed up a die, there's no point in doing so again.
15736 This also avoids a memory leak if we were to call
15737 guess_partial_die_structure_name multiple times. */
15738 if (part_die->fixup_called)
15739 return;
15740
15741 /* If we found a reference attribute and the DIE has no name, try
15742 to find a name in the referred to DIE. */
15743
15744 if (part_die->name == NULL && part_die->has_specification)
15745 {
15746 struct partial_die_info *spec_die;
15747
15748 spec_die = find_partial_die (part_die->spec_offset,
15749 part_die->spec_is_dwz, cu);
15750
15751 fixup_partial_die (spec_die, cu);
15752
15753 if (spec_die->name)
15754 {
15755 part_die->name = spec_die->name;
15756
15757 /* Copy DW_AT_external attribute if it is set. */
15758 if (spec_die->is_external)
15759 part_die->is_external = spec_die->is_external;
15760 }
15761 }
15762
15763 /* Set default names for some unnamed DIEs. */
15764
15765 if (part_die->name == NULL && part_die->tag == DW_TAG_namespace)
15766 part_die->name = CP_ANONYMOUS_NAMESPACE_STR;
15767
15768 /* If there is no parent die to provide a namespace, and there are
15769 children, see if we can determine the namespace from their linkage
15770 name. */
15771 if (cu->language == language_cplus
15772 && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
15773 && part_die->die_parent == NULL
15774 && part_die->has_children
15775 && (part_die->tag == DW_TAG_class_type
15776 || part_die->tag == DW_TAG_structure_type
15777 || part_die->tag == DW_TAG_union_type))
15778 guess_partial_die_structure_name (part_die, cu);
15779
15780 /* GCC might emit a nameless struct or union that has a linkage
15781 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
15782 if (part_die->name == NULL
15783 && (part_die->tag == DW_TAG_class_type
15784 || part_die->tag == DW_TAG_interface_type
15785 || part_die->tag == DW_TAG_structure_type
15786 || part_die->tag == DW_TAG_union_type)
15787 && part_die->linkage_name != NULL)
15788 {
15789 char *demangled;
15790
15791 demangled = gdb_demangle (part_die->linkage_name, DMGL_TYPES);
15792 if (demangled)
15793 {
15794 const char *base;
15795
15796 /* Strip any leading namespaces/classes, keep only the base name.
15797 DW_AT_name for named DIEs does not contain the prefixes. */
15798 base = strrchr (demangled, ':');
15799 if (base && base > demangled && base[-1] == ':')
15800 base++;
15801 else
15802 base = demangled;
15803
15804 part_die->name = obstack_copy0 (&cu->objfile->objfile_obstack,
15805 base, strlen (base));
15806 xfree (demangled);
15807 }
15808 }
15809
15810 part_die->fixup_called = 1;
15811 }
15812
15813 /* Read an attribute value described by an attribute form. */
15814
15815 static const gdb_byte *
15816 read_attribute_value (const struct die_reader_specs *reader,
15817 struct attribute *attr, unsigned form,
15818 const gdb_byte *info_ptr)
15819 {
15820 struct dwarf2_cu *cu = reader->cu;
15821 bfd *abfd = reader->abfd;
15822 struct comp_unit_head *cu_header = &cu->header;
15823 unsigned int bytes_read;
15824 struct dwarf_block *blk;
15825
15826 attr->form = form;
15827 switch (form)
15828 {
15829 case DW_FORM_ref_addr:
15830 if (cu->header.version == 2)
15831 DW_UNSND (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
15832 else
15833 DW_UNSND (attr) = read_offset (abfd, info_ptr,
15834 &cu->header, &bytes_read);
15835 info_ptr += bytes_read;
15836 break;
15837 case DW_FORM_GNU_ref_alt:
15838 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
15839 info_ptr += bytes_read;
15840 break;
15841 case DW_FORM_addr:
15842 DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
15843 info_ptr += bytes_read;
15844 break;
15845 case DW_FORM_block2:
15846 blk = dwarf_alloc_block (cu);
15847 blk->size = read_2_bytes (abfd, info_ptr);
15848 info_ptr += 2;
15849 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
15850 info_ptr += blk->size;
15851 DW_BLOCK (attr) = blk;
15852 break;
15853 case DW_FORM_block4:
15854 blk = dwarf_alloc_block (cu);
15855 blk->size = read_4_bytes (abfd, info_ptr);
15856 info_ptr += 4;
15857 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
15858 info_ptr += blk->size;
15859 DW_BLOCK (attr) = blk;
15860 break;
15861 case DW_FORM_data2:
15862 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
15863 info_ptr += 2;
15864 break;
15865 case DW_FORM_data4:
15866 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
15867 info_ptr += 4;
15868 break;
15869 case DW_FORM_data8:
15870 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
15871 info_ptr += 8;
15872 break;
15873 case DW_FORM_sec_offset:
15874 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
15875 info_ptr += bytes_read;
15876 break;
15877 case DW_FORM_string:
15878 DW_STRING (attr) = read_direct_string (abfd, info_ptr, &bytes_read);
15879 DW_STRING_IS_CANONICAL (attr) = 0;
15880 info_ptr += bytes_read;
15881 break;
15882 case DW_FORM_strp:
15883 if (!cu->per_cu->is_dwz)
15884 {
15885 DW_STRING (attr) = read_indirect_string (abfd, info_ptr, cu_header,
15886 &bytes_read);
15887 DW_STRING_IS_CANONICAL (attr) = 0;
15888 info_ptr += bytes_read;
15889 break;
15890 }
15891 /* FALLTHROUGH */
15892 case DW_FORM_GNU_strp_alt:
15893 {
15894 struct dwz_file *dwz = dwarf2_get_dwz_file ();
15895 LONGEST str_offset = read_offset (abfd, info_ptr, cu_header,
15896 &bytes_read);
15897
15898 DW_STRING (attr) = read_indirect_string_from_dwz (dwz, str_offset);
15899 DW_STRING_IS_CANONICAL (attr) = 0;
15900 info_ptr += bytes_read;
15901 }
15902 break;
15903 case DW_FORM_exprloc:
15904 case DW_FORM_block:
15905 blk = dwarf_alloc_block (cu);
15906 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
15907 info_ptr += bytes_read;
15908 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
15909 info_ptr += blk->size;
15910 DW_BLOCK (attr) = blk;
15911 break;
15912 case DW_FORM_block1:
15913 blk = dwarf_alloc_block (cu);
15914 blk->size = read_1_byte (abfd, info_ptr);
15915 info_ptr += 1;
15916 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
15917 info_ptr += blk->size;
15918 DW_BLOCK (attr) = blk;
15919 break;
15920 case DW_FORM_data1:
15921 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
15922 info_ptr += 1;
15923 break;
15924 case DW_FORM_flag:
15925 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
15926 info_ptr += 1;
15927 break;
15928 case DW_FORM_flag_present:
15929 DW_UNSND (attr) = 1;
15930 break;
15931 case DW_FORM_sdata:
15932 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
15933 info_ptr += bytes_read;
15934 break;
15935 case DW_FORM_udata:
15936 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
15937 info_ptr += bytes_read;
15938 break;
15939 case DW_FORM_ref1:
15940 DW_UNSND (attr) = (cu->header.offset.sect_off
15941 + read_1_byte (abfd, info_ptr));
15942 info_ptr += 1;
15943 break;
15944 case DW_FORM_ref2:
15945 DW_UNSND (attr) = (cu->header.offset.sect_off
15946 + read_2_bytes (abfd, info_ptr));
15947 info_ptr += 2;
15948 break;
15949 case DW_FORM_ref4:
15950 DW_UNSND (attr) = (cu->header.offset.sect_off
15951 + read_4_bytes (abfd, info_ptr));
15952 info_ptr += 4;
15953 break;
15954 case DW_FORM_ref8:
15955 DW_UNSND (attr) = (cu->header.offset.sect_off
15956 + read_8_bytes (abfd, info_ptr));
15957 info_ptr += 8;
15958 break;
15959 case DW_FORM_ref_sig8:
15960 DW_SIGNATURE (attr) = read_8_bytes (abfd, info_ptr);
15961 info_ptr += 8;
15962 break;
15963 case DW_FORM_ref_udata:
15964 DW_UNSND (attr) = (cu->header.offset.sect_off
15965 + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
15966 info_ptr += bytes_read;
15967 break;
15968 case DW_FORM_indirect:
15969 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
15970 info_ptr += bytes_read;
15971 info_ptr = read_attribute_value (reader, attr, form, info_ptr);
15972 break;
15973 case DW_FORM_GNU_addr_index:
15974 if (reader->dwo_file == NULL)
15975 {
15976 /* For now flag a hard error.
15977 Later we can turn this into a complaint. */
15978 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
15979 dwarf_form_name (form),
15980 bfd_get_filename (abfd));
15981 }
15982 DW_ADDR (attr) = read_addr_index_from_leb128 (cu, info_ptr, &bytes_read);
15983 info_ptr += bytes_read;
15984 break;
15985 case DW_FORM_GNU_str_index:
15986 if (reader->dwo_file == NULL)
15987 {
15988 /* For now flag a hard error.
15989 Later we can turn this into a complaint if warranted. */
15990 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
15991 dwarf_form_name (form),
15992 bfd_get_filename (abfd));
15993 }
15994 {
15995 ULONGEST str_index =
15996 read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
15997
15998 DW_STRING (attr) = read_str_index (reader, str_index);
15999 DW_STRING_IS_CANONICAL (attr) = 0;
16000 info_ptr += bytes_read;
16001 }
16002 break;
16003 default:
16004 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
16005 dwarf_form_name (form),
16006 bfd_get_filename (abfd));
16007 }
16008
16009 /* Super hack. */
16010 if (cu->per_cu->is_dwz && attr_form_is_ref (attr))
16011 attr->form = DW_FORM_GNU_ref_alt;
16012
16013 /* We have seen instances where the compiler tried to emit a byte
16014 size attribute of -1 which ended up being encoded as an unsigned
16015 0xffffffff. Although 0xffffffff is technically a valid size value,
16016 an object of this size seems pretty unlikely so we can relatively
16017 safely treat these cases as if the size attribute was invalid and
16018 treat them as zero by default. */
16019 if (attr->name == DW_AT_byte_size
16020 && form == DW_FORM_data4
16021 && DW_UNSND (attr) >= 0xffffffff)
16022 {
16023 complaint
16024 (&symfile_complaints,
16025 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
16026 hex_string (DW_UNSND (attr)));
16027 DW_UNSND (attr) = 0;
16028 }
16029
16030 return info_ptr;
16031 }
16032
16033 /* Read an attribute described by an abbreviated attribute. */
16034
16035 static const gdb_byte *
16036 read_attribute (const struct die_reader_specs *reader,
16037 struct attribute *attr, struct attr_abbrev *abbrev,
16038 const gdb_byte *info_ptr)
16039 {
16040 attr->name = abbrev->name;
16041 return read_attribute_value (reader, attr, abbrev->form, info_ptr);
16042 }
16043
16044 /* Read dwarf information from a buffer. */
16045
16046 static unsigned int
16047 read_1_byte (bfd *abfd, const gdb_byte *buf)
16048 {
16049 return bfd_get_8 (abfd, buf);
16050 }
16051
16052 static int
16053 read_1_signed_byte (bfd *abfd, const gdb_byte *buf)
16054 {
16055 return bfd_get_signed_8 (abfd, buf);
16056 }
16057
16058 static unsigned int
16059 read_2_bytes (bfd *abfd, const gdb_byte *buf)
16060 {
16061 return bfd_get_16 (abfd, buf);
16062 }
16063
16064 static int
16065 read_2_signed_bytes (bfd *abfd, const gdb_byte *buf)
16066 {
16067 return bfd_get_signed_16 (abfd, buf);
16068 }
16069
16070 static unsigned int
16071 read_4_bytes (bfd *abfd, const gdb_byte *buf)
16072 {
16073 return bfd_get_32 (abfd, buf);
16074 }
16075
16076 static int
16077 read_4_signed_bytes (bfd *abfd, const gdb_byte *buf)
16078 {
16079 return bfd_get_signed_32 (abfd, buf);
16080 }
16081
16082 static ULONGEST
16083 read_8_bytes (bfd *abfd, const gdb_byte *buf)
16084 {
16085 return bfd_get_64 (abfd, buf);
16086 }
16087
16088 static CORE_ADDR
16089 read_address (bfd *abfd, const gdb_byte *buf, struct dwarf2_cu *cu,
16090 unsigned int *bytes_read)
16091 {
16092 struct comp_unit_head *cu_header = &cu->header;
16093 CORE_ADDR retval = 0;
16094
16095 if (cu_header->signed_addr_p)
16096 {
16097 switch (cu_header->addr_size)
16098 {
16099 case 2:
16100 retval = bfd_get_signed_16 (abfd, buf);
16101 break;
16102 case 4:
16103 retval = bfd_get_signed_32 (abfd, buf);
16104 break;
16105 case 8:
16106 retval = bfd_get_signed_64 (abfd, buf);
16107 break;
16108 default:
16109 internal_error (__FILE__, __LINE__,
16110 _("read_address: bad switch, signed [in module %s]"),
16111 bfd_get_filename (abfd));
16112 }
16113 }
16114 else
16115 {
16116 switch (cu_header->addr_size)
16117 {
16118 case 2:
16119 retval = bfd_get_16 (abfd, buf);
16120 break;
16121 case 4:
16122 retval = bfd_get_32 (abfd, buf);
16123 break;
16124 case 8:
16125 retval = bfd_get_64 (abfd, buf);
16126 break;
16127 default:
16128 internal_error (__FILE__, __LINE__,
16129 _("read_address: bad switch, "
16130 "unsigned [in module %s]"),
16131 bfd_get_filename (abfd));
16132 }
16133 }
16134
16135 *bytes_read = cu_header->addr_size;
16136 return retval;
16137 }
16138
16139 /* Read the initial length from a section. The (draft) DWARF 3
16140 specification allows the initial length to take up either 4 bytes
16141 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
16142 bytes describe the length and all offsets will be 8 bytes in length
16143 instead of 4.
16144
16145 An older, non-standard 64-bit format is also handled by this
16146 function. The older format in question stores the initial length
16147 as an 8-byte quantity without an escape value. Lengths greater
16148 than 2^32 aren't very common which means that the initial 4 bytes
16149 is almost always zero. Since a length value of zero doesn't make
16150 sense for the 32-bit format, this initial zero can be considered to
16151 be an escape value which indicates the presence of the older 64-bit
16152 format. As written, the code can't detect (old format) lengths
16153 greater than 4GB. If it becomes necessary to handle lengths
16154 somewhat larger than 4GB, we could allow other small values (such
16155 as the non-sensical values of 1, 2, and 3) to also be used as
16156 escape values indicating the presence of the old format.
16157
16158 The value returned via bytes_read should be used to increment the
16159 relevant pointer after calling read_initial_length().
16160
16161 [ Note: read_initial_length() and read_offset() are based on the
16162 document entitled "DWARF Debugging Information Format", revision
16163 3, draft 8, dated November 19, 2001. This document was obtained
16164 from:
16165
16166 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
16167
16168 This document is only a draft and is subject to change. (So beware.)
16169
16170 Details regarding the older, non-standard 64-bit format were
16171 determined empirically by examining 64-bit ELF files produced by
16172 the SGI toolchain on an IRIX 6.5 machine.
16173
16174 - Kevin, July 16, 2002
16175 ] */
16176
16177 static LONGEST
16178 read_initial_length (bfd *abfd, const gdb_byte *buf, unsigned int *bytes_read)
16179 {
16180 LONGEST length = bfd_get_32 (abfd, buf);
16181
16182 if (length == 0xffffffff)
16183 {
16184 length = bfd_get_64 (abfd, buf + 4);
16185 *bytes_read = 12;
16186 }
16187 else if (length == 0)
16188 {
16189 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
16190 length = bfd_get_64 (abfd, buf);
16191 *bytes_read = 8;
16192 }
16193 else
16194 {
16195 *bytes_read = 4;
16196 }
16197
16198 return length;
16199 }
16200
16201 /* Cover function for read_initial_length.
16202 Returns the length of the object at BUF, and stores the size of the
16203 initial length in *BYTES_READ and stores the size that offsets will be in
16204 *OFFSET_SIZE.
16205 If the initial length size is not equivalent to that specified in
16206 CU_HEADER then issue a complaint.
16207 This is useful when reading non-comp-unit headers. */
16208
16209 static LONGEST
16210 read_checked_initial_length_and_offset (bfd *abfd, const gdb_byte *buf,
16211 const struct comp_unit_head *cu_header,
16212 unsigned int *bytes_read,
16213 unsigned int *offset_size)
16214 {
16215 LONGEST length = read_initial_length (abfd, buf, bytes_read);
16216
16217 gdb_assert (cu_header->initial_length_size == 4
16218 || cu_header->initial_length_size == 8
16219 || cu_header->initial_length_size == 12);
16220
16221 if (cu_header->initial_length_size != *bytes_read)
16222 complaint (&symfile_complaints,
16223 _("intermixed 32-bit and 64-bit DWARF sections"));
16224
16225 *offset_size = (*bytes_read == 4) ? 4 : 8;
16226 return length;
16227 }
16228
16229 /* Read an offset from the data stream. The size of the offset is
16230 given by cu_header->offset_size. */
16231
16232 static LONGEST
16233 read_offset (bfd *abfd, const gdb_byte *buf,
16234 const struct comp_unit_head *cu_header,
16235 unsigned int *bytes_read)
16236 {
16237 LONGEST offset = read_offset_1 (abfd, buf, cu_header->offset_size);
16238
16239 *bytes_read = cu_header->offset_size;
16240 return offset;
16241 }
16242
16243 /* Read an offset from the data stream. */
16244
16245 static LONGEST
16246 read_offset_1 (bfd *abfd, const gdb_byte *buf, unsigned int offset_size)
16247 {
16248 LONGEST retval = 0;
16249
16250 switch (offset_size)
16251 {
16252 case 4:
16253 retval = bfd_get_32 (abfd, buf);
16254 break;
16255 case 8:
16256 retval = bfd_get_64 (abfd, buf);
16257 break;
16258 default:
16259 internal_error (__FILE__, __LINE__,
16260 _("read_offset_1: bad switch [in module %s]"),
16261 bfd_get_filename (abfd));
16262 }
16263
16264 return retval;
16265 }
16266
16267 static const gdb_byte *
16268 read_n_bytes (bfd *abfd, const gdb_byte *buf, unsigned int size)
16269 {
16270 /* If the size of a host char is 8 bits, we can return a pointer
16271 to the buffer, otherwise we have to copy the data to a buffer
16272 allocated on the temporary obstack. */
16273 gdb_assert (HOST_CHAR_BIT == 8);
16274 return buf;
16275 }
16276
16277 static const char *
16278 read_direct_string (bfd *abfd, const gdb_byte *buf,
16279 unsigned int *bytes_read_ptr)
16280 {
16281 /* If the size of a host char is 8 bits, we can return a pointer
16282 to the string, otherwise we have to copy the string to a buffer
16283 allocated on the temporary obstack. */
16284 gdb_assert (HOST_CHAR_BIT == 8);
16285 if (*buf == '\0')
16286 {
16287 *bytes_read_ptr = 1;
16288 return NULL;
16289 }
16290 *bytes_read_ptr = strlen ((const char *) buf) + 1;
16291 return (const char *) buf;
16292 }
16293
16294 static const char *
16295 read_indirect_string_at_offset (bfd *abfd, LONGEST str_offset)
16296 {
16297 dwarf2_read_section (dwarf2_per_objfile->objfile, &dwarf2_per_objfile->str);
16298 if (dwarf2_per_objfile->str.buffer == NULL)
16299 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
16300 bfd_get_filename (abfd));
16301 if (str_offset >= dwarf2_per_objfile->str.size)
16302 error (_("DW_FORM_strp pointing outside of "
16303 ".debug_str section [in module %s]"),
16304 bfd_get_filename (abfd));
16305 gdb_assert (HOST_CHAR_BIT == 8);
16306 if (dwarf2_per_objfile->str.buffer[str_offset] == '\0')
16307 return NULL;
16308 return (const char *) (dwarf2_per_objfile->str.buffer + str_offset);
16309 }
16310
16311 /* Read a string at offset STR_OFFSET in the .debug_str section from
16312 the .dwz file DWZ. Throw an error if the offset is too large. If
16313 the string consists of a single NUL byte, return NULL; otherwise
16314 return a pointer to the string. */
16315
16316 static const char *
16317 read_indirect_string_from_dwz (struct dwz_file *dwz, LONGEST str_offset)
16318 {
16319 dwarf2_read_section (dwarf2_per_objfile->objfile, &dwz->str);
16320
16321 if (dwz->str.buffer == NULL)
16322 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
16323 "section [in module %s]"),
16324 bfd_get_filename (dwz->dwz_bfd));
16325 if (str_offset >= dwz->str.size)
16326 error (_("DW_FORM_GNU_strp_alt pointing outside of "
16327 ".debug_str section [in module %s]"),
16328 bfd_get_filename (dwz->dwz_bfd));
16329 gdb_assert (HOST_CHAR_BIT == 8);
16330 if (dwz->str.buffer[str_offset] == '\0')
16331 return NULL;
16332 return (const char *) (dwz->str.buffer + str_offset);
16333 }
16334
16335 static const char *
16336 read_indirect_string (bfd *abfd, const gdb_byte *buf,
16337 const struct comp_unit_head *cu_header,
16338 unsigned int *bytes_read_ptr)
16339 {
16340 LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
16341
16342 return read_indirect_string_at_offset (abfd, str_offset);
16343 }
16344
16345 static ULONGEST
16346 read_unsigned_leb128 (bfd *abfd, const gdb_byte *buf,
16347 unsigned int *bytes_read_ptr)
16348 {
16349 ULONGEST result;
16350 unsigned int num_read;
16351 int i, shift;
16352 unsigned char byte;
16353
16354 result = 0;
16355 shift = 0;
16356 num_read = 0;
16357 i = 0;
16358 while (1)
16359 {
16360 byte = bfd_get_8 (abfd, buf);
16361 buf++;
16362 num_read++;
16363 result |= ((ULONGEST) (byte & 127) << shift);
16364 if ((byte & 128) == 0)
16365 {
16366 break;
16367 }
16368 shift += 7;
16369 }
16370 *bytes_read_ptr = num_read;
16371 return result;
16372 }
16373
16374 static LONGEST
16375 read_signed_leb128 (bfd *abfd, const gdb_byte *buf,
16376 unsigned int *bytes_read_ptr)
16377 {
16378 LONGEST result;
16379 int i, shift, num_read;
16380 unsigned char byte;
16381
16382 result = 0;
16383 shift = 0;
16384 num_read = 0;
16385 i = 0;
16386 while (1)
16387 {
16388 byte = bfd_get_8 (abfd, buf);
16389 buf++;
16390 num_read++;
16391 result |= ((LONGEST) (byte & 127) << shift);
16392 shift += 7;
16393 if ((byte & 128) == 0)
16394 {
16395 break;
16396 }
16397 }
16398 if ((shift < 8 * sizeof (result)) && (byte & 0x40))
16399 result |= -(((LONGEST) 1) << shift);
16400 *bytes_read_ptr = num_read;
16401 return result;
16402 }
16403
16404 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
16405 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
16406 ADDR_SIZE is the size of addresses from the CU header. */
16407
16408 static CORE_ADDR
16409 read_addr_index_1 (unsigned int addr_index, ULONGEST addr_base, int addr_size)
16410 {
16411 struct objfile *objfile = dwarf2_per_objfile->objfile;
16412 bfd *abfd = objfile->obfd;
16413 const gdb_byte *info_ptr;
16414
16415 dwarf2_read_section (objfile, &dwarf2_per_objfile->addr);
16416 if (dwarf2_per_objfile->addr.buffer == NULL)
16417 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
16418 objfile_name (objfile));
16419 if (addr_base + addr_index * addr_size >= dwarf2_per_objfile->addr.size)
16420 error (_("DW_FORM_addr_index pointing outside of "
16421 ".debug_addr section [in module %s]"),
16422 objfile_name (objfile));
16423 info_ptr = (dwarf2_per_objfile->addr.buffer
16424 + addr_base + addr_index * addr_size);
16425 if (addr_size == 4)
16426 return bfd_get_32 (abfd, info_ptr);
16427 else
16428 return bfd_get_64 (abfd, info_ptr);
16429 }
16430
16431 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
16432
16433 static CORE_ADDR
16434 read_addr_index (struct dwarf2_cu *cu, unsigned int addr_index)
16435 {
16436 return read_addr_index_1 (addr_index, cu->addr_base, cu->header.addr_size);
16437 }
16438
16439 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
16440
16441 static CORE_ADDR
16442 read_addr_index_from_leb128 (struct dwarf2_cu *cu, const gdb_byte *info_ptr,
16443 unsigned int *bytes_read)
16444 {
16445 bfd *abfd = cu->objfile->obfd;
16446 unsigned int addr_index = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
16447
16448 return read_addr_index (cu, addr_index);
16449 }
16450
16451 /* Data structure to pass results from dwarf2_read_addr_index_reader
16452 back to dwarf2_read_addr_index. */
16453
16454 struct dwarf2_read_addr_index_data
16455 {
16456 ULONGEST addr_base;
16457 int addr_size;
16458 };
16459
16460 /* die_reader_func for dwarf2_read_addr_index. */
16461
16462 static void
16463 dwarf2_read_addr_index_reader (const struct die_reader_specs *reader,
16464 const gdb_byte *info_ptr,
16465 struct die_info *comp_unit_die,
16466 int has_children,
16467 void *data)
16468 {
16469 struct dwarf2_cu *cu = reader->cu;
16470 struct dwarf2_read_addr_index_data *aidata =
16471 (struct dwarf2_read_addr_index_data *) data;
16472
16473 aidata->addr_base = cu->addr_base;
16474 aidata->addr_size = cu->header.addr_size;
16475 }
16476
16477 /* Given an index in .debug_addr, fetch the value.
16478 NOTE: This can be called during dwarf expression evaluation,
16479 long after the debug information has been read, and thus per_cu->cu
16480 may no longer exist. */
16481
16482 CORE_ADDR
16483 dwarf2_read_addr_index (struct dwarf2_per_cu_data *per_cu,
16484 unsigned int addr_index)
16485 {
16486 struct objfile *objfile = per_cu->objfile;
16487 struct dwarf2_cu *cu = per_cu->cu;
16488 ULONGEST addr_base;
16489 int addr_size;
16490
16491 /* This is intended to be called from outside this file. */
16492 dw2_setup (objfile);
16493
16494 /* We need addr_base and addr_size.
16495 If we don't have PER_CU->cu, we have to get it.
16496 Nasty, but the alternative is storing the needed info in PER_CU,
16497 which at this point doesn't seem justified: it's not clear how frequently
16498 it would get used and it would increase the size of every PER_CU.
16499 Entry points like dwarf2_per_cu_addr_size do a similar thing
16500 so we're not in uncharted territory here.
16501 Alas we need to be a bit more complicated as addr_base is contained
16502 in the DIE.
16503
16504 We don't need to read the entire CU(/TU).
16505 We just need the header and top level die.
16506
16507 IWBN to use the aging mechanism to let us lazily later discard the CU.
16508 For now we skip this optimization. */
16509
16510 if (cu != NULL)
16511 {
16512 addr_base = cu->addr_base;
16513 addr_size = cu->header.addr_size;
16514 }
16515 else
16516 {
16517 struct dwarf2_read_addr_index_data aidata;
16518
16519 /* Note: We can't use init_cutu_and_read_dies_simple here,
16520 we need addr_base. */
16521 init_cutu_and_read_dies (per_cu, NULL, 0, 0,
16522 dwarf2_read_addr_index_reader, &aidata);
16523 addr_base = aidata.addr_base;
16524 addr_size = aidata.addr_size;
16525 }
16526
16527 return read_addr_index_1 (addr_index, addr_base, addr_size);
16528 }
16529
16530 /* Given a DW_FORM_GNU_str_index, fetch the string.
16531 This is only used by the Fission support. */
16532
16533 static const char *
16534 read_str_index (const struct die_reader_specs *reader, ULONGEST str_index)
16535 {
16536 struct objfile *objfile = dwarf2_per_objfile->objfile;
16537 const char *objf_name = objfile_name (objfile);
16538 bfd *abfd = objfile->obfd;
16539 struct dwarf2_cu *cu = reader->cu;
16540 struct dwarf2_section_info *str_section = &reader->dwo_file->sections.str;
16541 struct dwarf2_section_info *str_offsets_section =
16542 &reader->dwo_file->sections.str_offsets;
16543 const gdb_byte *info_ptr;
16544 ULONGEST str_offset;
16545 static const char form_name[] = "DW_FORM_GNU_str_index";
16546
16547 dwarf2_read_section (objfile, str_section);
16548 dwarf2_read_section (objfile, str_offsets_section);
16549 if (str_section->buffer == NULL)
16550 error (_("%s used without .debug_str.dwo section"
16551 " in CU at offset 0x%lx [in module %s]"),
16552 form_name, (long) cu->header.offset.sect_off, objf_name);
16553 if (str_offsets_section->buffer == NULL)
16554 error (_("%s used without .debug_str_offsets.dwo section"
16555 " in CU at offset 0x%lx [in module %s]"),
16556 form_name, (long) cu->header.offset.sect_off, objf_name);
16557 if (str_index * cu->header.offset_size >= str_offsets_section->size)
16558 error (_("%s pointing outside of .debug_str_offsets.dwo"
16559 " section in CU at offset 0x%lx [in module %s]"),
16560 form_name, (long) cu->header.offset.sect_off, objf_name);
16561 info_ptr = (str_offsets_section->buffer
16562 + str_index * cu->header.offset_size);
16563 if (cu->header.offset_size == 4)
16564 str_offset = bfd_get_32 (abfd, info_ptr);
16565 else
16566 str_offset = bfd_get_64 (abfd, info_ptr);
16567 if (str_offset >= str_section->size)
16568 error (_("Offset from %s pointing outside of"
16569 " .debug_str.dwo section in CU at offset 0x%lx [in module %s]"),
16570 form_name, (long) cu->header.offset.sect_off, objf_name);
16571 return (const char *) (str_section->buffer + str_offset);
16572 }
16573
16574 /* Return the length of an LEB128 number in BUF. */
16575
16576 static int
16577 leb128_size (const gdb_byte *buf)
16578 {
16579 const gdb_byte *begin = buf;
16580 gdb_byte byte;
16581
16582 while (1)
16583 {
16584 byte = *buf++;
16585 if ((byte & 128) == 0)
16586 return buf - begin;
16587 }
16588 }
16589
16590 static void
16591 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
16592 {
16593 switch (lang)
16594 {
16595 case DW_LANG_C89:
16596 case DW_LANG_C99:
16597 case DW_LANG_C:
16598 case DW_LANG_UPC:
16599 cu->language = language_c;
16600 break;
16601 case DW_LANG_C_plus_plus:
16602 cu->language = language_cplus;
16603 break;
16604 case DW_LANG_D:
16605 cu->language = language_d;
16606 break;
16607 case DW_LANG_Fortran77:
16608 case DW_LANG_Fortran90:
16609 case DW_LANG_Fortran95:
16610 cu->language = language_fortran;
16611 break;
16612 case DW_LANG_Go:
16613 cu->language = language_go;
16614 break;
16615 case DW_LANG_Mips_Assembler:
16616 cu->language = language_asm;
16617 break;
16618 case DW_LANG_Java:
16619 cu->language = language_java;
16620 break;
16621 case DW_LANG_Ada83:
16622 case DW_LANG_Ada95:
16623 cu->language = language_ada;
16624 break;
16625 case DW_LANG_Modula2:
16626 cu->language = language_m2;
16627 break;
16628 case DW_LANG_Pascal83:
16629 cu->language = language_pascal;
16630 break;
16631 case DW_LANG_ObjC:
16632 cu->language = language_objc;
16633 break;
16634 case DW_LANG_Cobol74:
16635 case DW_LANG_Cobol85:
16636 default:
16637 cu->language = language_minimal;
16638 break;
16639 }
16640 cu->language_defn = language_def (cu->language);
16641 }
16642
16643 /* Return the named attribute or NULL if not there. */
16644
16645 static struct attribute *
16646 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
16647 {
16648 for (;;)
16649 {
16650 unsigned int i;
16651 struct attribute *spec = NULL;
16652
16653 for (i = 0; i < die->num_attrs; ++i)
16654 {
16655 if (die->attrs[i].name == name)
16656 return &die->attrs[i];
16657 if (die->attrs[i].name == DW_AT_specification
16658 || die->attrs[i].name == DW_AT_abstract_origin)
16659 spec = &die->attrs[i];
16660 }
16661
16662 if (!spec)
16663 break;
16664
16665 die = follow_die_ref (die, spec, &cu);
16666 }
16667
16668 return NULL;
16669 }
16670
16671 /* Return the named attribute or NULL if not there,
16672 but do not follow DW_AT_specification, etc.
16673 This is for use in contexts where we're reading .debug_types dies.
16674 Following DW_AT_specification, DW_AT_abstract_origin will take us
16675 back up the chain, and we want to go down. */
16676
16677 static struct attribute *
16678 dwarf2_attr_no_follow (struct die_info *die, unsigned int name)
16679 {
16680 unsigned int i;
16681
16682 for (i = 0; i < die->num_attrs; ++i)
16683 if (die->attrs[i].name == name)
16684 return &die->attrs[i];
16685
16686 return NULL;
16687 }
16688
16689 /* Return non-zero iff the attribute NAME is defined for the given DIE,
16690 and holds a non-zero value. This function should only be used for
16691 DW_FORM_flag or DW_FORM_flag_present attributes. */
16692
16693 static int
16694 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
16695 {
16696 struct attribute *attr = dwarf2_attr (die, name, cu);
16697
16698 return (attr && DW_UNSND (attr));
16699 }
16700
16701 static int
16702 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
16703 {
16704 /* A DIE is a declaration if it has a DW_AT_declaration attribute
16705 which value is non-zero. However, we have to be careful with
16706 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
16707 (via dwarf2_flag_true_p) follows this attribute. So we may
16708 end up accidently finding a declaration attribute that belongs
16709 to a different DIE referenced by the specification attribute,
16710 even though the given DIE does not have a declaration attribute. */
16711 return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
16712 && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
16713 }
16714
16715 /* Return the die giving the specification for DIE, if there is
16716 one. *SPEC_CU is the CU containing DIE on input, and the CU
16717 containing the return value on output. If there is no
16718 specification, but there is an abstract origin, that is
16719 returned. */
16720
16721 static struct die_info *
16722 die_specification (struct die_info *die, struct dwarf2_cu **spec_cu)
16723 {
16724 struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification,
16725 *spec_cu);
16726
16727 if (spec_attr == NULL)
16728 spec_attr = dwarf2_attr (die, DW_AT_abstract_origin, *spec_cu);
16729
16730 if (spec_attr == NULL)
16731 return NULL;
16732 else
16733 return follow_die_ref (die, spec_attr, spec_cu);
16734 }
16735
16736 /* Free the line_header structure *LH, and any arrays and strings it
16737 refers to.
16738 NOTE: This is also used as a "cleanup" function. */
16739
16740 static void
16741 free_line_header (struct line_header *lh)
16742 {
16743 if (lh->standard_opcode_lengths)
16744 xfree (lh->standard_opcode_lengths);
16745
16746 /* Remember that all the lh->file_names[i].name pointers are
16747 pointers into debug_line_buffer, and don't need to be freed. */
16748 if (lh->file_names)
16749 xfree (lh->file_names);
16750
16751 /* Similarly for the include directory names. */
16752 if (lh->include_dirs)
16753 xfree (lh->include_dirs);
16754
16755 xfree (lh);
16756 }
16757
16758 /* Add an entry to LH's include directory table. */
16759
16760 static void
16761 add_include_dir (struct line_header *lh, const char *include_dir)
16762 {
16763 /* Grow the array if necessary. */
16764 if (lh->include_dirs_size == 0)
16765 {
16766 lh->include_dirs_size = 1; /* for testing */
16767 lh->include_dirs = xmalloc (lh->include_dirs_size
16768 * sizeof (*lh->include_dirs));
16769 }
16770 else if (lh->num_include_dirs >= lh->include_dirs_size)
16771 {
16772 lh->include_dirs_size *= 2;
16773 lh->include_dirs = xrealloc (lh->include_dirs,
16774 (lh->include_dirs_size
16775 * sizeof (*lh->include_dirs)));
16776 }
16777
16778 lh->include_dirs[lh->num_include_dirs++] = include_dir;
16779 }
16780
16781 /* Add an entry to LH's file name table. */
16782
16783 static void
16784 add_file_name (struct line_header *lh,
16785 const char *name,
16786 unsigned int dir_index,
16787 unsigned int mod_time,
16788 unsigned int length)
16789 {
16790 struct file_entry *fe;
16791
16792 /* Grow the array if necessary. */
16793 if (lh->file_names_size == 0)
16794 {
16795 lh->file_names_size = 1; /* for testing */
16796 lh->file_names = xmalloc (lh->file_names_size
16797 * sizeof (*lh->file_names));
16798 }
16799 else if (lh->num_file_names >= lh->file_names_size)
16800 {
16801 lh->file_names_size *= 2;
16802 lh->file_names = xrealloc (lh->file_names,
16803 (lh->file_names_size
16804 * sizeof (*lh->file_names)));
16805 }
16806
16807 fe = &lh->file_names[lh->num_file_names++];
16808 fe->name = name;
16809 fe->dir_index = dir_index;
16810 fe->mod_time = mod_time;
16811 fe->length = length;
16812 fe->included_p = 0;
16813 fe->symtab = NULL;
16814 }
16815
16816 /* A convenience function to find the proper .debug_line section for a
16817 CU. */
16818
16819 static struct dwarf2_section_info *
16820 get_debug_line_section (struct dwarf2_cu *cu)
16821 {
16822 struct dwarf2_section_info *section;
16823
16824 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
16825 DWO file. */
16826 if (cu->dwo_unit && cu->per_cu->is_debug_types)
16827 section = &cu->dwo_unit->dwo_file->sections.line;
16828 else if (cu->per_cu->is_dwz)
16829 {
16830 struct dwz_file *dwz = dwarf2_get_dwz_file ();
16831
16832 section = &dwz->line;
16833 }
16834 else
16835 section = &dwarf2_per_objfile->line;
16836
16837 return section;
16838 }
16839
16840 /* Read the statement program header starting at OFFSET in
16841 .debug_line, or .debug_line.dwo. Return a pointer
16842 to a struct line_header, allocated using xmalloc.
16843
16844 NOTE: the strings in the include directory and file name tables of
16845 the returned object point into the dwarf line section buffer,
16846 and must not be freed. */
16847
16848 static struct line_header *
16849 dwarf_decode_line_header (unsigned int offset, struct dwarf2_cu *cu)
16850 {
16851 struct cleanup *back_to;
16852 struct line_header *lh;
16853 const gdb_byte *line_ptr;
16854 unsigned int bytes_read, offset_size;
16855 int i;
16856 const char *cur_dir, *cur_file;
16857 struct dwarf2_section_info *section;
16858 bfd *abfd;
16859
16860 section = get_debug_line_section (cu);
16861 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
16862 if (section->buffer == NULL)
16863 {
16864 if (cu->dwo_unit && cu->per_cu->is_debug_types)
16865 complaint (&symfile_complaints, _("missing .debug_line.dwo section"));
16866 else
16867 complaint (&symfile_complaints, _("missing .debug_line section"));
16868 return 0;
16869 }
16870
16871 /* We can't do this until we know the section is non-empty.
16872 Only then do we know we have such a section. */
16873 abfd = get_section_bfd_owner (section);
16874
16875 /* Make sure that at least there's room for the total_length field.
16876 That could be 12 bytes long, but we're just going to fudge that. */
16877 if (offset + 4 >= section->size)
16878 {
16879 dwarf2_statement_list_fits_in_line_number_section_complaint ();
16880 return 0;
16881 }
16882
16883 lh = xmalloc (sizeof (*lh));
16884 memset (lh, 0, sizeof (*lh));
16885 back_to = make_cleanup ((make_cleanup_ftype *) free_line_header,
16886 (void *) lh);
16887
16888 line_ptr = section->buffer + offset;
16889
16890 /* Read in the header. */
16891 lh->total_length =
16892 read_checked_initial_length_and_offset (abfd, line_ptr, &cu->header,
16893 &bytes_read, &offset_size);
16894 line_ptr += bytes_read;
16895 if (line_ptr + lh->total_length > (section->buffer + section->size))
16896 {
16897 dwarf2_statement_list_fits_in_line_number_section_complaint ();
16898 do_cleanups (back_to);
16899 return 0;
16900 }
16901 lh->statement_program_end = line_ptr + lh->total_length;
16902 lh->version = read_2_bytes (abfd, line_ptr);
16903 line_ptr += 2;
16904 lh->header_length = read_offset_1 (abfd, line_ptr, offset_size);
16905 line_ptr += offset_size;
16906 lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
16907 line_ptr += 1;
16908 if (lh->version >= 4)
16909 {
16910 lh->maximum_ops_per_instruction = read_1_byte (abfd, line_ptr);
16911 line_ptr += 1;
16912 }
16913 else
16914 lh->maximum_ops_per_instruction = 1;
16915
16916 if (lh->maximum_ops_per_instruction == 0)
16917 {
16918 lh->maximum_ops_per_instruction = 1;
16919 complaint (&symfile_complaints,
16920 _("invalid maximum_ops_per_instruction "
16921 "in `.debug_line' section"));
16922 }
16923
16924 lh->default_is_stmt = read_1_byte (abfd, line_ptr);
16925 line_ptr += 1;
16926 lh->line_base = read_1_signed_byte (abfd, line_ptr);
16927 line_ptr += 1;
16928 lh->line_range = read_1_byte (abfd, line_ptr);
16929 line_ptr += 1;
16930 lh->opcode_base = read_1_byte (abfd, line_ptr);
16931 line_ptr += 1;
16932 lh->standard_opcode_lengths
16933 = xmalloc (lh->opcode_base * sizeof (lh->standard_opcode_lengths[0]));
16934
16935 lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
16936 for (i = 1; i < lh->opcode_base; ++i)
16937 {
16938 lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
16939 line_ptr += 1;
16940 }
16941
16942 /* Read directory table. */
16943 while ((cur_dir = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
16944 {
16945 line_ptr += bytes_read;
16946 add_include_dir (lh, cur_dir);
16947 }
16948 line_ptr += bytes_read;
16949
16950 /* Read file name table. */
16951 while ((cur_file = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
16952 {
16953 unsigned int dir_index, mod_time, length;
16954
16955 line_ptr += bytes_read;
16956 dir_index = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
16957 line_ptr += bytes_read;
16958 mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
16959 line_ptr += bytes_read;
16960 length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
16961 line_ptr += bytes_read;
16962
16963 add_file_name (lh, cur_file, dir_index, mod_time, length);
16964 }
16965 line_ptr += bytes_read;
16966 lh->statement_program_start = line_ptr;
16967
16968 if (line_ptr > (section->buffer + section->size))
16969 complaint (&symfile_complaints,
16970 _("line number info header doesn't "
16971 "fit in `.debug_line' section"));
16972
16973 discard_cleanups (back_to);
16974 return lh;
16975 }
16976
16977 /* Subroutine of dwarf_decode_lines to simplify it.
16978 Return the file name of the psymtab for included file FILE_INDEX
16979 in line header LH of PST.
16980 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
16981 If space for the result is malloc'd, it will be freed by a cleanup.
16982 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename.
16983
16984 The function creates dangling cleanup registration. */
16985
16986 static const char *
16987 psymtab_include_file_name (const struct line_header *lh, int file_index,
16988 const struct partial_symtab *pst,
16989 const char *comp_dir)
16990 {
16991 const struct file_entry fe = lh->file_names [file_index];
16992 const char *include_name = fe.name;
16993 const char *include_name_to_compare = include_name;
16994 const char *dir_name = NULL;
16995 const char *pst_filename;
16996 char *copied_name = NULL;
16997 int file_is_pst;
16998
16999 if (fe.dir_index)
17000 dir_name = lh->include_dirs[fe.dir_index - 1];
17001
17002 if (!IS_ABSOLUTE_PATH (include_name)
17003 && (dir_name != NULL || comp_dir != NULL))
17004 {
17005 /* Avoid creating a duplicate psymtab for PST.
17006 We do this by comparing INCLUDE_NAME and PST_FILENAME.
17007 Before we do the comparison, however, we need to account
17008 for DIR_NAME and COMP_DIR.
17009 First prepend dir_name (if non-NULL). If we still don't
17010 have an absolute path prepend comp_dir (if non-NULL).
17011 However, the directory we record in the include-file's
17012 psymtab does not contain COMP_DIR (to match the
17013 corresponding symtab(s)).
17014
17015 Example:
17016
17017 bash$ cd /tmp
17018 bash$ gcc -g ./hello.c
17019 include_name = "hello.c"
17020 dir_name = "."
17021 DW_AT_comp_dir = comp_dir = "/tmp"
17022 DW_AT_name = "./hello.c" */
17023
17024 if (dir_name != NULL)
17025 {
17026 char *tem = concat (dir_name, SLASH_STRING,
17027 include_name, (char *)NULL);
17028
17029 make_cleanup (xfree, tem);
17030 include_name = tem;
17031 include_name_to_compare = include_name;
17032 }
17033 if (!IS_ABSOLUTE_PATH (include_name) && comp_dir != NULL)
17034 {
17035 char *tem = concat (comp_dir, SLASH_STRING,
17036 include_name, (char *)NULL);
17037
17038 make_cleanup (xfree, tem);
17039 include_name_to_compare = tem;
17040 }
17041 }
17042
17043 pst_filename = pst->filename;
17044 if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
17045 {
17046 copied_name = concat (pst->dirname, SLASH_STRING,
17047 pst_filename, (char *)NULL);
17048 pst_filename = copied_name;
17049 }
17050
17051 file_is_pst = FILENAME_CMP (include_name_to_compare, pst_filename) == 0;
17052
17053 if (copied_name != NULL)
17054 xfree (copied_name);
17055
17056 if (file_is_pst)
17057 return NULL;
17058 return include_name;
17059 }
17060
17061 /* Ignore this record_line request. */
17062
17063 static void
17064 noop_record_line (struct subfile *subfile, int line, CORE_ADDR pc)
17065 {
17066 return;
17067 }
17068
17069 /* Subroutine of dwarf_decode_lines to simplify it.
17070 Process the line number information in LH. */
17071
17072 static void
17073 dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir,
17074 struct dwarf2_cu *cu, struct partial_symtab *pst)
17075 {
17076 const gdb_byte *line_ptr, *extended_end;
17077 const gdb_byte *line_end;
17078 unsigned int bytes_read, extended_len;
17079 unsigned char op_code, extended_op, adj_opcode;
17080 CORE_ADDR baseaddr;
17081 struct objfile *objfile = cu->objfile;
17082 bfd *abfd = objfile->obfd;
17083 struct gdbarch *gdbarch = get_objfile_arch (objfile);
17084 const int decode_for_pst_p = (pst != NULL);
17085 struct subfile *last_subfile = NULL;
17086 void (*p_record_line) (struct subfile *subfile, int line, CORE_ADDR pc)
17087 = record_line;
17088
17089 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
17090
17091 line_ptr = lh->statement_program_start;
17092 line_end = lh->statement_program_end;
17093
17094 /* Read the statement sequences until there's nothing left. */
17095 while (line_ptr < line_end)
17096 {
17097 /* state machine registers */
17098 CORE_ADDR address = 0;
17099 unsigned int file = 1;
17100 unsigned int line = 1;
17101 unsigned int column = 0;
17102 int is_stmt = lh->default_is_stmt;
17103 int basic_block = 0;
17104 int end_sequence = 0;
17105 CORE_ADDR addr;
17106 unsigned char op_index = 0;
17107
17108 if (!decode_for_pst_p && lh->num_file_names >= file)
17109 {
17110 /* Start a subfile for the current file of the state machine. */
17111 /* lh->include_dirs and lh->file_names are 0-based, but the
17112 directory and file name numbers in the statement program
17113 are 1-based. */
17114 struct file_entry *fe = &lh->file_names[file - 1];
17115 const char *dir = NULL;
17116
17117 if (fe->dir_index)
17118 dir = lh->include_dirs[fe->dir_index - 1];
17119
17120 dwarf2_start_subfile (fe->name, dir, comp_dir);
17121 }
17122
17123 /* Decode the table. */
17124 while (!end_sequence)
17125 {
17126 op_code = read_1_byte (abfd, line_ptr);
17127 line_ptr += 1;
17128 if (line_ptr > line_end)
17129 {
17130 dwarf2_debug_line_missing_end_sequence_complaint ();
17131 break;
17132 }
17133
17134 if (op_code >= lh->opcode_base)
17135 {
17136 /* Special operand. */
17137 adj_opcode = op_code - lh->opcode_base;
17138 address += (((op_index + (adj_opcode / lh->line_range))
17139 / lh->maximum_ops_per_instruction)
17140 * lh->minimum_instruction_length);
17141 op_index = ((op_index + (adj_opcode / lh->line_range))
17142 % lh->maximum_ops_per_instruction);
17143 line += lh->line_base + (adj_opcode % lh->line_range);
17144 if (lh->num_file_names < file || file == 0)
17145 dwarf2_debug_line_missing_file_complaint ();
17146 /* For now we ignore lines not starting on an
17147 instruction boundary. */
17148 else if (op_index == 0)
17149 {
17150 lh->file_names[file - 1].included_p = 1;
17151 if (!decode_for_pst_p && is_stmt)
17152 {
17153 if (last_subfile != current_subfile)
17154 {
17155 addr = gdbarch_addr_bits_remove (gdbarch, address);
17156 if (last_subfile)
17157 (*p_record_line) (last_subfile, 0, addr);
17158 last_subfile = current_subfile;
17159 }
17160 /* Append row to matrix using current values. */
17161 addr = gdbarch_addr_bits_remove (gdbarch, address);
17162 (*p_record_line) (current_subfile, line, addr);
17163 }
17164 }
17165 basic_block = 0;
17166 }
17167 else switch (op_code)
17168 {
17169 case DW_LNS_extended_op:
17170 extended_len = read_unsigned_leb128 (abfd, line_ptr,
17171 &bytes_read);
17172 line_ptr += bytes_read;
17173 extended_end = line_ptr + extended_len;
17174 extended_op = read_1_byte (abfd, line_ptr);
17175 line_ptr += 1;
17176 switch (extended_op)
17177 {
17178 case DW_LNE_end_sequence:
17179 p_record_line = record_line;
17180 end_sequence = 1;
17181 break;
17182 case DW_LNE_set_address:
17183 address = read_address (abfd, line_ptr, cu, &bytes_read);
17184
17185 if (address == 0 && !dwarf2_per_objfile->has_section_at_zero)
17186 {
17187 /* This line table is for a function which has been
17188 GCd by the linker. Ignore it. PR gdb/12528 */
17189
17190 long line_offset
17191 = line_ptr - get_debug_line_section (cu)->buffer;
17192
17193 complaint (&symfile_complaints,
17194 _(".debug_line address at offset 0x%lx is 0 "
17195 "[in module %s]"),
17196 line_offset, objfile_name (objfile));
17197 p_record_line = noop_record_line;
17198 }
17199
17200 op_index = 0;
17201 line_ptr += bytes_read;
17202 address += baseaddr;
17203 break;
17204 case DW_LNE_define_file:
17205 {
17206 const char *cur_file;
17207 unsigned int dir_index, mod_time, length;
17208
17209 cur_file = read_direct_string (abfd, line_ptr,
17210 &bytes_read);
17211 line_ptr += bytes_read;
17212 dir_index =
17213 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17214 line_ptr += bytes_read;
17215 mod_time =
17216 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17217 line_ptr += bytes_read;
17218 length =
17219 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17220 line_ptr += bytes_read;
17221 add_file_name (lh, cur_file, dir_index, mod_time, length);
17222 }
17223 break;
17224 case DW_LNE_set_discriminator:
17225 /* The discriminator is not interesting to the debugger;
17226 just ignore it. */
17227 line_ptr = extended_end;
17228 break;
17229 default:
17230 complaint (&symfile_complaints,
17231 _("mangled .debug_line section"));
17232 return;
17233 }
17234 /* Make sure that we parsed the extended op correctly. If e.g.
17235 we expected a different address size than the producer used,
17236 we may have read the wrong number of bytes. */
17237 if (line_ptr != extended_end)
17238 {
17239 complaint (&symfile_complaints,
17240 _("mangled .debug_line section"));
17241 return;
17242 }
17243 break;
17244 case DW_LNS_copy:
17245 if (lh->num_file_names < file || file == 0)
17246 dwarf2_debug_line_missing_file_complaint ();
17247 else
17248 {
17249 lh->file_names[file - 1].included_p = 1;
17250 if (!decode_for_pst_p && is_stmt)
17251 {
17252 if (last_subfile != current_subfile)
17253 {
17254 addr = gdbarch_addr_bits_remove (gdbarch, address);
17255 if (last_subfile)
17256 (*p_record_line) (last_subfile, 0, addr);
17257 last_subfile = current_subfile;
17258 }
17259 addr = gdbarch_addr_bits_remove (gdbarch, address);
17260 (*p_record_line) (current_subfile, line, addr);
17261 }
17262 }
17263 basic_block = 0;
17264 break;
17265 case DW_LNS_advance_pc:
17266 {
17267 CORE_ADDR adjust
17268 = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17269
17270 address += (((op_index + adjust)
17271 / lh->maximum_ops_per_instruction)
17272 * lh->minimum_instruction_length);
17273 op_index = ((op_index + adjust)
17274 % lh->maximum_ops_per_instruction);
17275 line_ptr += bytes_read;
17276 }
17277 break;
17278 case DW_LNS_advance_line:
17279 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
17280 line_ptr += bytes_read;
17281 break;
17282 case DW_LNS_set_file:
17283 {
17284 /* The arrays lh->include_dirs and lh->file_names are
17285 0-based, but the directory and file name numbers in
17286 the statement program are 1-based. */
17287 struct file_entry *fe;
17288 const char *dir = NULL;
17289
17290 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17291 line_ptr += bytes_read;
17292 if (lh->num_file_names < file || file == 0)
17293 dwarf2_debug_line_missing_file_complaint ();
17294 else
17295 {
17296 fe = &lh->file_names[file - 1];
17297 if (fe->dir_index)
17298 dir = lh->include_dirs[fe->dir_index - 1];
17299 if (!decode_for_pst_p)
17300 {
17301 last_subfile = current_subfile;
17302 dwarf2_start_subfile (fe->name, dir, comp_dir);
17303 }
17304 }
17305 }
17306 break;
17307 case DW_LNS_set_column:
17308 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17309 line_ptr += bytes_read;
17310 break;
17311 case DW_LNS_negate_stmt:
17312 is_stmt = (!is_stmt);
17313 break;
17314 case DW_LNS_set_basic_block:
17315 basic_block = 1;
17316 break;
17317 /* Add to the address register of the state machine the
17318 address increment value corresponding to special opcode
17319 255. I.e., this value is scaled by the minimum
17320 instruction length since special opcode 255 would have
17321 scaled the increment. */
17322 case DW_LNS_const_add_pc:
17323 {
17324 CORE_ADDR adjust = (255 - lh->opcode_base) / lh->line_range;
17325
17326 address += (((op_index + adjust)
17327 / lh->maximum_ops_per_instruction)
17328 * lh->minimum_instruction_length);
17329 op_index = ((op_index + adjust)
17330 % lh->maximum_ops_per_instruction);
17331 }
17332 break;
17333 case DW_LNS_fixed_advance_pc:
17334 address += read_2_bytes (abfd, line_ptr);
17335 op_index = 0;
17336 line_ptr += 2;
17337 break;
17338 default:
17339 {
17340 /* Unknown standard opcode, ignore it. */
17341 int i;
17342
17343 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
17344 {
17345 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17346 line_ptr += bytes_read;
17347 }
17348 }
17349 }
17350 }
17351 if (lh->num_file_names < file || file == 0)
17352 dwarf2_debug_line_missing_file_complaint ();
17353 else
17354 {
17355 lh->file_names[file - 1].included_p = 1;
17356 if (!decode_for_pst_p)
17357 {
17358 addr = gdbarch_addr_bits_remove (gdbarch, address);
17359 (*p_record_line) (current_subfile, 0, addr);
17360 }
17361 }
17362 }
17363 }
17364
17365 /* Decode the Line Number Program (LNP) for the given line_header
17366 structure and CU. The actual information extracted and the type
17367 of structures created from the LNP depends on the value of PST.
17368
17369 1. If PST is NULL, then this procedure uses the data from the program
17370 to create all necessary symbol tables, and their linetables.
17371
17372 2. If PST is not NULL, this procedure reads the program to determine
17373 the list of files included by the unit represented by PST, and
17374 builds all the associated partial symbol tables.
17375
17376 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
17377 It is used for relative paths in the line table.
17378 NOTE: When processing partial symtabs (pst != NULL),
17379 comp_dir == pst->dirname.
17380
17381 NOTE: It is important that psymtabs have the same file name (via strcmp)
17382 as the corresponding symtab. Since COMP_DIR is not used in the name of the
17383 symtab we don't use it in the name of the psymtabs we create.
17384 E.g. expand_line_sal requires this when finding psymtabs to expand.
17385 A good testcase for this is mb-inline.exp. */
17386
17387 static void
17388 dwarf_decode_lines (struct line_header *lh, const char *comp_dir,
17389 struct dwarf2_cu *cu, struct partial_symtab *pst,
17390 int want_line_info)
17391 {
17392 struct objfile *objfile = cu->objfile;
17393 const int decode_for_pst_p = (pst != NULL);
17394 struct subfile *first_subfile = current_subfile;
17395
17396 if (want_line_info)
17397 dwarf_decode_lines_1 (lh, comp_dir, cu, pst);
17398
17399 if (decode_for_pst_p)
17400 {
17401 int file_index;
17402
17403 /* Now that we're done scanning the Line Header Program, we can
17404 create the psymtab of each included file. */
17405 for (file_index = 0; file_index < lh->num_file_names; file_index++)
17406 if (lh->file_names[file_index].included_p == 1)
17407 {
17408 const char *include_name =
17409 psymtab_include_file_name (lh, file_index, pst, comp_dir);
17410 if (include_name != NULL)
17411 dwarf2_create_include_psymtab (include_name, pst, objfile);
17412 }
17413 }
17414 else
17415 {
17416 /* Make sure a symtab is created for every file, even files
17417 which contain only variables (i.e. no code with associated
17418 line numbers). */
17419 int i;
17420
17421 for (i = 0; i < lh->num_file_names; i++)
17422 {
17423 const char *dir = NULL;
17424 struct file_entry *fe;
17425
17426 fe = &lh->file_names[i];
17427 if (fe->dir_index)
17428 dir = lh->include_dirs[fe->dir_index - 1];
17429 dwarf2_start_subfile (fe->name, dir, comp_dir);
17430
17431 /* Skip the main file; we don't need it, and it must be
17432 allocated last, so that it will show up before the
17433 non-primary symtabs in the objfile's symtab list. */
17434 if (current_subfile == first_subfile)
17435 continue;
17436
17437 if (current_subfile->symtab == NULL)
17438 current_subfile->symtab = allocate_symtab (current_subfile->name,
17439 objfile);
17440 fe->symtab = current_subfile->symtab;
17441 }
17442 }
17443 }
17444
17445 /* Start a subfile for DWARF. FILENAME is the name of the file and
17446 DIRNAME the name of the source directory which contains FILENAME
17447 or NULL if not known. COMP_DIR is the compilation directory for the
17448 linetable's compilation unit or NULL if not known.
17449 This routine tries to keep line numbers from identical absolute and
17450 relative file names in a common subfile.
17451
17452 Using the `list' example from the GDB testsuite, which resides in
17453 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
17454 of /srcdir/list0.c yields the following debugging information for list0.c:
17455
17456 DW_AT_name: /srcdir/list0.c
17457 DW_AT_comp_dir: /compdir
17458 files.files[0].name: list0.h
17459 files.files[0].dir: /srcdir
17460 files.files[1].name: list0.c
17461 files.files[1].dir: /srcdir
17462
17463 The line number information for list0.c has to end up in a single
17464 subfile, so that `break /srcdir/list0.c:1' works as expected.
17465 start_subfile will ensure that this happens provided that we pass the
17466 concatenation of files.files[1].dir and files.files[1].name as the
17467 subfile's name. */
17468
17469 static void
17470 dwarf2_start_subfile (const char *filename, const char *dirname,
17471 const char *comp_dir)
17472 {
17473 char *copy = NULL;
17474
17475 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
17476 `start_symtab' will always pass the contents of DW_AT_comp_dir as
17477 second argument to start_subfile. To be consistent, we do the
17478 same here. In order not to lose the line information directory,
17479 we concatenate it to the filename when it makes sense.
17480 Note that the Dwarf3 standard says (speaking of filenames in line
17481 information): ``The directory index is ignored for file names
17482 that represent full path names''. Thus ignoring dirname in the
17483 `else' branch below isn't an issue. */
17484
17485 if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
17486 {
17487 copy = concat (dirname, SLASH_STRING, filename, (char *)NULL);
17488 filename = copy;
17489 }
17490
17491 start_subfile (filename, comp_dir);
17492
17493 if (copy != NULL)
17494 xfree (copy);
17495 }
17496
17497 /* Start a symtab for DWARF.
17498 NAME, COMP_DIR, LOW_PC are passed to start_symtab. */
17499
17500 static void
17501 dwarf2_start_symtab (struct dwarf2_cu *cu,
17502 const char *name, const char *comp_dir, CORE_ADDR low_pc)
17503 {
17504 start_symtab (name, comp_dir, low_pc);
17505 record_debugformat ("DWARF 2");
17506 record_producer (cu->producer);
17507
17508 /* We assume that we're processing GCC output. */
17509 processing_gcc_compilation = 2;
17510
17511 cu->processing_has_namespace_info = 0;
17512 }
17513
17514 static void
17515 var_decode_location (struct attribute *attr, struct symbol *sym,
17516 struct dwarf2_cu *cu)
17517 {
17518 struct objfile *objfile = cu->objfile;
17519 struct comp_unit_head *cu_header = &cu->header;
17520
17521 /* NOTE drow/2003-01-30: There used to be a comment and some special
17522 code here to turn a symbol with DW_AT_external and a
17523 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
17524 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
17525 with some versions of binutils) where shared libraries could have
17526 relocations against symbols in their debug information - the
17527 minimal symbol would have the right address, but the debug info
17528 would not. It's no longer necessary, because we will explicitly
17529 apply relocations when we read in the debug information now. */
17530
17531 /* A DW_AT_location attribute with no contents indicates that a
17532 variable has been optimized away. */
17533 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
17534 {
17535 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
17536 return;
17537 }
17538
17539 /* Handle one degenerate form of location expression specially, to
17540 preserve GDB's previous behavior when section offsets are
17541 specified. If this is just a DW_OP_addr or DW_OP_GNU_addr_index
17542 then mark this symbol as LOC_STATIC. */
17543
17544 if (attr_form_is_block (attr)
17545 && ((DW_BLOCK (attr)->data[0] == DW_OP_addr
17546 && DW_BLOCK (attr)->size == 1 + cu_header->addr_size)
17547 || (DW_BLOCK (attr)->data[0] == DW_OP_GNU_addr_index
17548 && (DW_BLOCK (attr)->size
17549 == 1 + leb128_size (&DW_BLOCK (attr)->data[1])))))
17550 {
17551 unsigned int dummy;
17552
17553 if (DW_BLOCK (attr)->data[0] == DW_OP_addr)
17554 SYMBOL_VALUE_ADDRESS (sym) =
17555 read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
17556 else
17557 SYMBOL_VALUE_ADDRESS (sym) =
17558 read_addr_index_from_leb128 (cu, DW_BLOCK (attr)->data + 1, &dummy);
17559 SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
17560 fixup_symbol_section (sym, objfile);
17561 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
17562 SYMBOL_SECTION (sym));
17563 return;
17564 }
17565
17566 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
17567 expression evaluator, and use LOC_COMPUTED only when necessary
17568 (i.e. when the value of a register or memory location is
17569 referenced, or a thread-local block, etc.). Then again, it might
17570 not be worthwhile. I'm assuming that it isn't unless performance
17571 or memory numbers show me otherwise. */
17572
17573 dwarf2_symbol_mark_computed (attr, sym, cu, 0);
17574
17575 if (SYMBOL_COMPUTED_OPS (sym)->location_has_loclist)
17576 cu->has_loclist = 1;
17577 }
17578
17579 /* Given a pointer to a DWARF information entry, figure out if we need
17580 to make a symbol table entry for it, and if so, create a new entry
17581 and return a pointer to it.
17582 If TYPE is NULL, determine symbol type from the die, otherwise
17583 used the passed type.
17584 If SPACE is not NULL, use it to hold the new symbol. If it is
17585 NULL, allocate a new symbol on the objfile's obstack. */
17586
17587 static struct symbol *
17588 new_symbol_full (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
17589 struct symbol *space)
17590 {
17591 struct objfile *objfile = cu->objfile;
17592 struct symbol *sym = NULL;
17593 const char *name;
17594 struct attribute *attr = NULL;
17595 struct attribute *attr2 = NULL;
17596 CORE_ADDR baseaddr;
17597 struct pending **list_to_add = NULL;
17598
17599 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
17600
17601 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
17602
17603 name = dwarf2_name (die, cu);
17604 if (name)
17605 {
17606 const char *linkagename;
17607 int suppress_add = 0;
17608
17609 if (space)
17610 sym = space;
17611 else
17612 sym = allocate_symbol (objfile);
17613 OBJSTAT (objfile, n_syms++);
17614
17615 /* Cache this symbol's name and the name's demangled form (if any). */
17616 SYMBOL_SET_LANGUAGE (sym, cu->language, &objfile->objfile_obstack);
17617 linkagename = dwarf2_physname (name, die, cu);
17618 SYMBOL_SET_NAMES (sym, linkagename, strlen (linkagename), 0, objfile);
17619
17620 /* Fortran does not have mangling standard and the mangling does differ
17621 between gfortran, iFort etc. */
17622 if (cu->language == language_fortran
17623 && symbol_get_demangled_name (&(sym->ginfo)) == NULL)
17624 symbol_set_demangled_name (&(sym->ginfo),
17625 dwarf2_full_name (name, die, cu),
17626 NULL);
17627
17628 /* Default assumptions.
17629 Use the passed type or decode it from the die. */
17630 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
17631 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
17632 if (type != NULL)
17633 SYMBOL_TYPE (sym) = type;
17634 else
17635 SYMBOL_TYPE (sym) = die_type (die, cu);
17636 attr = dwarf2_attr (die,
17637 inlined_func ? DW_AT_call_line : DW_AT_decl_line,
17638 cu);
17639 if (attr)
17640 {
17641 SYMBOL_LINE (sym) = DW_UNSND (attr);
17642 }
17643
17644 attr = dwarf2_attr (die,
17645 inlined_func ? DW_AT_call_file : DW_AT_decl_file,
17646 cu);
17647 if (attr)
17648 {
17649 int file_index = DW_UNSND (attr);
17650
17651 if (cu->line_header == NULL
17652 || file_index > cu->line_header->num_file_names)
17653 complaint (&symfile_complaints,
17654 _("file index out of range"));
17655 else if (file_index > 0)
17656 {
17657 struct file_entry *fe;
17658
17659 fe = &cu->line_header->file_names[file_index - 1];
17660 SYMBOL_SYMTAB (sym) = fe->symtab;
17661 }
17662 }
17663
17664 switch (die->tag)
17665 {
17666 case DW_TAG_label:
17667 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
17668 if (attr)
17669 SYMBOL_VALUE_ADDRESS (sym)
17670 = attr_value_as_address (attr) + baseaddr;
17671 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_core_addr;
17672 SYMBOL_DOMAIN (sym) = LABEL_DOMAIN;
17673 SYMBOL_ACLASS_INDEX (sym) = LOC_LABEL;
17674 add_symbol_to_list (sym, cu->list_in_scope);
17675 break;
17676 case DW_TAG_subprogram:
17677 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
17678 finish_block. */
17679 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
17680 attr2 = dwarf2_attr (die, DW_AT_external, cu);
17681 if ((attr2 && (DW_UNSND (attr2) != 0))
17682 || cu->language == language_ada)
17683 {
17684 /* Subprograms marked external are stored as a global symbol.
17685 Ada subprograms, whether marked external or not, are always
17686 stored as a global symbol, because we want to be able to
17687 access them globally. For instance, we want to be able
17688 to break on a nested subprogram without having to
17689 specify the context. */
17690 list_to_add = &global_symbols;
17691 }
17692 else
17693 {
17694 list_to_add = cu->list_in_scope;
17695 }
17696 break;
17697 case DW_TAG_inlined_subroutine:
17698 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
17699 finish_block. */
17700 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
17701 SYMBOL_INLINED (sym) = 1;
17702 list_to_add = cu->list_in_scope;
17703 break;
17704 case DW_TAG_template_value_param:
17705 suppress_add = 1;
17706 /* Fall through. */
17707 case DW_TAG_constant:
17708 case DW_TAG_variable:
17709 case DW_TAG_member:
17710 /* Compilation with minimal debug info may result in
17711 variables with missing type entries. Change the
17712 misleading `void' type to something sensible. */
17713 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
17714 SYMBOL_TYPE (sym)
17715 = objfile_type (objfile)->nodebug_data_symbol;
17716
17717 attr = dwarf2_attr (die, DW_AT_const_value, cu);
17718 /* In the case of DW_TAG_member, we should only be called for
17719 static const members. */
17720 if (die->tag == DW_TAG_member)
17721 {
17722 /* dwarf2_add_field uses die_is_declaration,
17723 so we do the same. */
17724 gdb_assert (die_is_declaration (die, cu));
17725 gdb_assert (attr);
17726 }
17727 if (attr)
17728 {
17729 dwarf2_const_value (attr, sym, cu);
17730 attr2 = dwarf2_attr (die, DW_AT_external, cu);
17731 if (!suppress_add)
17732 {
17733 if (attr2 && (DW_UNSND (attr2) != 0))
17734 list_to_add = &global_symbols;
17735 else
17736 list_to_add = cu->list_in_scope;
17737 }
17738 break;
17739 }
17740 attr = dwarf2_attr (die, DW_AT_location, cu);
17741 if (attr)
17742 {
17743 var_decode_location (attr, sym, cu);
17744 attr2 = dwarf2_attr (die, DW_AT_external, cu);
17745
17746 /* Fortran explicitly imports any global symbols to the local
17747 scope by DW_TAG_common_block. */
17748 if (cu->language == language_fortran && die->parent
17749 && die->parent->tag == DW_TAG_common_block)
17750 attr2 = NULL;
17751
17752 if (SYMBOL_CLASS (sym) == LOC_STATIC
17753 && SYMBOL_VALUE_ADDRESS (sym) == 0
17754 && !dwarf2_per_objfile->has_section_at_zero)
17755 {
17756 /* When a static variable is eliminated by the linker,
17757 the corresponding debug information is not stripped
17758 out, but the variable address is set to null;
17759 do not add such variables into symbol table. */
17760 }
17761 else if (attr2 && (DW_UNSND (attr2) != 0))
17762 {
17763 /* Workaround gfortran PR debug/40040 - it uses
17764 DW_AT_location for variables in -fPIC libraries which may
17765 get overriden by other libraries/executable and get
17766 a different address. Resolve it by the minimal symbol
17767 which may come from inferior's executable using copy
17768 relocation. Make this workaround only for gfortran as for
17769 other compilers GDB cannot guess the minimal symbol
17770 Fortran mangling kind. */
17771 if (cu->language == language_fortran && die->parent
17772 && die->parent->tag == DW_TAG_module
17773 && cu->producer
17774 && strncmp (cu->producer, "GNU Fortran ", 12) == 0)
17775 SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
17776
17777 /* A variable with DW_AT_external is never static,
17778 but it may be block-scoped. */
17779 list_to_add = (cu->list_in_scope == &file_symbols
17780 ? &global_symbols : cu->list_in_scope);
17781 }
17782 else
17783 list_to_add = cu->list_in_scope;
17784 }
17785 else
17786 {
17787 /* We do not know the address of this symbol.
17788 If it is an external symbol and we have type information
17789 for it, enter the symbol as a LOC_UNRESOLVED symbol.
17790 The address of the variable will then be determined from
17791 the minimal symbol table whenever the variable is
17792 referenced. */
17793 attr2 = dwarf2_attr (die, DW_AT_external, cu);
17794
17795 /* Fortran explicitly imports any global symbols to the local
17796 scope by DW_TAG_common_block. */
17797 if (cu->language == language_fortran && die->parent
17798 && die->parent->tag == DW_TAG_common_block)
17799 {
17800 /* SYMBOL_CLASS doesn't matter here because
17801 read_common_block is going to reset it. */
17802 if (!suppress_add)
17803 list_to_add = cu->list_in_scope;
17804 }
17805 else if (attr2 && (DW_UNSND (attr2) != 0)
17806 && dwarf2_attr (die, DW_AT_type, cu) != NULL)
17807 {
17808 /* A variable with DW_AT_external is never static, but it
17809 may be block-scoped. */
17810 list_to_add = (cu->list_in_scope == &file_symbols
17811 ? &global_symbols : cu->list_in_scope);
17812
17813 SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
17814 }
17815 else if (!die_is_declaration (die, cu))
17816 {
17817 /* Use the default LOC_OPTIMIZED_OUT class. */
17818 gdb_assert (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT);
17819 if (!suppress_add)
17820 list_to_add = cu->list_in_scope;
17821 }
17822 }
17823 break;
17824 case DW_TAG_formal_parameter:
17825 /* If we are inside a function, mark this as an argument. If
17826 not, we might be looking at an argument to an inlined function
17827 when we do not have enough information to show inlined frames;
17828 pretend it's a local variable in that case so that the user can
17829 still see it. */
17830 if (context_stack_depth > 0
17831 && context_stack[context_stack_depth - 1].name != NULL)
17832 SYMBOL_IS_ARGUMENT (sym) = 1;
17833 attr = dwarf2_attr (die, DW_AT_location, cu);
17834 if (attr)
17835 {
17836 var_decode_location (attr, sym, cu);
17837 }
17838 attr = dwarf2_attr (die, DW_AT_const_value, cu);
17839 if (attr)
17840 {
17841 dwarf2_const_value (attr, sym, cu);
17842 }
17843
17844 list_to_add = cu->list_in_scope;
17845 break;
17846 case DW_TAG_unspecified_parameters:
17847 /* From varargs functions; gdb doesn't seem to have any
17848 interest in this information, so just ignore it for now.
17849 (FIXME?) */
17850 break;
17851 case DW_TAG_template_type_param:
17852 suppress_add = 1;
17853 /* Fall through. */
17854 case DW_TAG_class_type:
17855 case DW_TAG_interface_type:
17856 case DW_TAG_structure_type:
17857 case DW_TAG_union_type:
17858 case DW_TAG_set_type:
17859 case DW_TAG_enumeration_type:
17860 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
17861 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
17862
17863 {
17864 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
17865 really ever be static objects: otherwise, if you try
17866 to, say, break of a class's method and you're in a file
17867 which doesn't mention that class, it won't work unless
17868 the check for all static symbols in lookup_symbol_aux
17869 saves you. See the OtherFileClass tests in
17870 gdb.c++/namespace.exp. */
17871
17872 if (!suppress_add)
17873 {
17874 list_to_add = (cu->list_in_scope == &file_symbols
17875 && (cu->language == language_cplus
17876 || cu->language == language_java)
17877 ? &global_symbols : cu->list_in_scope);
17878
17879 /* The semantics of C++ state that "struct foo {
17880 ... }" also defines a typedef for "foo". A Java
17881 class declaration also defines a typedef for the
17882 class. */
17883 if (cu->language == language_cplus
17884 || cu->language == language_java
17885 || cu->language == language_ada)
17886 {
17887 /* The symbol's name is already allocated along
17888 with this objfile, so we don't need to
17889 duplicate it for the type. */
17890 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
17891 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
17892 }
17893 }
17894 }
17895 break;
17896 case DW_TAG_typedef:
17897 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
17898 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
17899 list_to_add = cu->list_in_scope;
17900 break;
17901 case DW_TAG_base_type:
17902 case DW_TAG_subrange_type:
17903 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
17904 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
17905 list_to_add = cu->list_in_scope;
17906 break;
17907 case DW_TAG_enumerator:
17908 attr = dwarf2_attr (die, DW_AT_const_value, cu);
17909 if (attr)
17910 {
17911 dwarf2_const_value (attr, sym, cu);
17912 }
17913 {
17914 /* NOTE: carlton/2003-11-10: See comment above in the
17915 DW_TAG_class_type, etc. block. */
17916
17917 list_to_add = (cu->list_in_scope == &file_symbols
17918 && (cu->language == language_cplus
17919 || cu->language == language_java)
17920 ? &global_symbols : cu->list_in_scope);
17921 }
17922 break;
17923 case DW_TAG_imported_declaration:
17924 case DW_TAG_namespace:
17925 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
17926 list_to_add = &global_symbols;
17927 break;
17928 case DW_TAG_module:
17929 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
17930 SYMBOL_DOMAIN (sym) = MODULE_DOMAIN;
17931 list_to_add = &global_symbols;
17932 break;
17933 case DW_TAG_common_block:
17934 SYMBOL_ACLASS_INDEX (sym) = LOC_COMMON_BLOCK;
17935 SYMBOL_DOMAIN (sym) = COMMON_BLOCK_DOMAIN;
17936 add_symbol_to_list (sym, cu->list_in_scope);
17937 break;
17938 default:
17939 /* Not a tag we recognize. Hopefully we aren't processing
17940 trash data, but since we must specifically ignore things
17941 we don't recognize, there is nothing else we should do at
17942 this point. */
17943 complaint (&symfile_complaints, _("unsupported tag: '%s'"),
17944 dwarf_tag_name (die->tag));
17945 break;
17946 }
17947
17948 if (suppress_add)
17949 {
17950 sym->hash_next = objfile->template_symbols;
17951 objfile->template_symbols = sym;
17952 list_to_add = NULL;
17953 }
17954
17955 if (list_to_add != NULL)
17956 add_symbol_to_list (sym, list_to_add);
17957
17958 /* For the benefit of old versions of GCC, check for anonymous
17959 namespaces based on the demangled name. */
17960 if (!cu->processing_has_namespace_info
17961 && cu->language == language_cplus)
17962 cp_scan_for_anonymous_namespaces (sym, objfile);
17963 }
17964 return (sym);
17965 }
17966
17967 /* A wrapper for new_symbol_full that always allocates a new symbol. */
17968
17969 static struct symbol *
17970 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
17971 {
17972 return new_symbol_full (die, type, cu, NULL);
17973 }
17974
17975 /* Given an attr with a DW_FORM_dataN value in host byte order,
17976 zero-extend it as appropriate for the symbol's type. The DWARF
17977 standard (v4) is not entirely clear about the meaning of using
17978 DW_FORM_dataN for a constant with a signed type, where the type is
17979 wider than the data. The conclusion of a discussion on the DWARF
17980 list was that this is unspecified. We choose to always zero-extend
17981 because that is the interpretation long in use by GCC. */
17982
17983 static gdb_byte *
17984 dwarf2_const_value_data (const struct attribute *attr, struct obstack *obstack,
17985 struct dwarf2_cu *cu, LONGEST *value, int bits)
17986 {
17987 struct objfile *objfile = cu->objfile;
17988 enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ?
17989 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
17990 LONGEST l = DW_UNSND (attr);
17991
17992 if (bits < sizeof (*value) * 8)
17993 {
17994 l &= ((LONGEST) 1 << bits) - 1;
17995 *value = l;
17996 }
17997 else if (bits == sizeof (*value) * 8)
17998 *value = l;
17999 else
18000 {
18001 gdb_byte *bytes = obstack_alloc (obstack, bits / 8);
18002 store_unsigned_integer (bytes, bits / 8, byte_order, l);
18003 return bytes;
18004 }
18005
18006 return NULL;
18007 }
18008
18009 /* Read a constant value from an attribute. Either set *VALUE, or if
18010 the value does not fit in *VALUE, set *BYTES - either already
18011 allocated on the objfile obstack, or newly allocated on OBSTACK,
18012 or, set *BATON, if we translated the constant to a location
18013 expression. */
18014
18015 static void
18016 dwarf2_const_value_attr (const struct attribute *attr, struct type *type,
18017 const char *name, struct obstack *obstack,
18018 struct dwarf2_cu *cu,
18019 LONGEST *value, const gdb_byte **bytes,
18020 struct dwarf2_locexpr_baton **baton)
18021 {
18022 struct objfile *objfile = cu->objfile;
18023 struct comp_unit_head *cu_header = &cu->header;
18024 struct dwarf_block *blk;
18025 enum bfd_endian byte_order = (bfd_big_endian (objfile->obfd) ?
18026 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
18027
18028 *value = 0;
18029 *bytes = NULL;
18030 *baton = NULL;
18031
18032 switch (attr->form)
18033 {
18034 case DW_FORM_addr:
18035 case DW_FORM_GNU_addr_index:
18036 {
18037 gdb_byte *data;
18038
18039 if (TYPE_LENGTH (type) != cu_header->addr_size)
18040 dwarf2_const_value_length_mismatch_complaint (name,
18041 cu_header->addr_size,
18042 TYPE_LENGTH (type));
18043 /* Symbols of this form are reasonably rare, so we just
18044 piggyback on the existing location code rather than writing
18045 a new implementation of symbol_computed_ops. */
18046 *baton = obstack_alloc (obstack, sizeof (struct dwarf2_locexpr_baton));
18047 (*baton)->per_cu = cu->per_cu;
18048 gdb_assert ((*baton)->per_cu);
18049
18050 (*baton)->size = 2 + cu_header->addr_size;
18051 data = obstack_alloc (obstack, (*baton)->size);
18052 (*baton)->data = data;
18053
18054 data[0] = DW_OP_addr;
18055 store_unsigned_integer (&data[1], cu_header->addr_size,
18056 byte_order, DW_ADDR (attr));
18057 data[cu_header->addr_size + 1] = DW_OP_stack_value;
18058 }
18059 break;
18060 case DW_FORM_string:
18061 case DW_FORM_strp:
18062 case DW_FORM_GNU_str_index:
18063 case DW_FORM_GNU_strp_alt:
18064 /* DW_STRING is already allocated on the objfile obstack, point
18065 directly to it. */
18066 *bytes = (const gdb_byte *) DW_STRING (attr);
18067 break;
18068 case DW_FORM_block1:
18069 case DW_FORM_block2:
18070 case DW_FORM_block4:
18071 case DW_FORM_block:
18072 case DW_FORM_exprloc:
18073 blk = DW_BLOCK (attr);
18074 if (TYPE_LENGTH (type) != blk->size)
18075 dwarf2_const_value_length_mismatch_complaint (name, blk->size,
18076 TYPE_LENGTH (type));
18077 *bytes = blk->data;
18078 break;
18079
18080 /* The DW_AT_const_value attributes are supposed to carry the
18081 symbol's value "represented as it would be on the target
18082 architecture." By the time we get here, it's already been
18083 converted to host endianness, so we just need to sign- or
18084 zero-extend it as appropriate. */
18085 case DW_FORM_data1:
18086 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 8);
18087 break;
18088 case DW_FORM_data2:
18089 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 16);
18090 break;
18091 case DW_FORM_data4:
18092 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 32);
18093 break;
18094 case DW_FORM_data8:
18095 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 64);
18096 break;
18097
18098 case DW_FORM_sdata:
18099 *value = DW_SND (attr);
18100 break;
18101
18102 case DW_FORM_udata:
18103 *value = DW_UNSND (attr);
18104 break;
18105
18106 default:
18107 complaint (&symfile_complaints,
18108 _("unsupported const value attribute form: '%s'"),
18109 dwarf_form_name (attr->form));
18110 *value = 0;
18111 break;
18112 }
18113 }
18114
18115
18116 /* Copy constant value from an attribute to a symbol. */
18117
18118 static void
18119 dwarf2_const_value (const struct attribute *attr, struct symbol *sym,
18120 struct dwarf2_cu *cu)
18121 {
18122 struct objfile *objfile = cu->objfile;
18123 struct comp_unit_head *cu_header = &cu->header;
18124 LONGEST value;
18125 const gdb_byte *bytes;
18126 struct dwarf2_locexpr_baton *baton;
18127
18128 dwarf2_const_value_attr (attr, SYMBOL_TYPE (sym),
18129 SYMBOL_PRINT_NAME (sym),
18130 &objfile->objfile_obstack, cu,
18131 &value, &bytes, &baton);
18132
18133 if (baton != NULL)
18134 {
18135 SYMBOL_LOCATION_BATON (sym) = baton;
18136 SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
18137 }
18138 else if (bytes != NULL)
18139 {
18140 SYMBOL_VALUE_BYTES (sym) = bytes;
18141 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST_BYTES;
18142 }
18143 else
18144 {
18145 SYMBOL_VALUE (sym) = value;
18146 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
18147 }
18148 }
18149
18150 /* Return the type of the die in question using its DW_AT_type attribute. */
18151
18152 static struct type *
18153 die_type (struct die_info *die, struct dwarf2_cu *cu)
18154 {
18155 struct attribute *type_attr;
18156
18157 type_attr = dwarf2_attr (die, DW_AT_type, cu);
18158 if (!type_attr)
18159 {
18160 /* A missing DW_AT_type represents a void type. */
18161 return objfile_type (cu->objfile)->builtin_void;
18162 }
18163
18164 return lookup_die_type (die, type_attr, cu);
18165 }
18166
18167 /* True iff CU's producer generates GNAT Ada auxiliary information
18168 that allows to find parallel types through that information instead
18169 of having to do expensive parallel lookups by type name. */
18170
18171 static int
18172 need_gnat_info (struct dwarf2_cu *cu)
18173 {
18174 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
18175 of GNAT produces this auxiliary information, without any indication
18176 that it is produced. Part of enhancing the FSF version of GNAT
18177 to produce that information will be to put in place an indicator
18178 that we can use in order to determine whether the descriptive type
18179 info is available or not. One suggestion that has been made is
18180 to use a new attribute, attached to the CU die. For now, assume
18181 that the descriptive type info is not available. */
18182 return 0;
18183 }
18184
18185 /* Return the auxiliary type of the die in question using its
18186 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
18187 attribute is not present. */
18188
18189 static struct type *
18190 die_descriptive_type (struct die_info *die, struct dwarf2_cu *cu)
18191 {
18192 struct attribute *type_attr;
18193
18194 type_attr = dwarf2_attr (die, DW_AT_GNAT_descriptive_type, cu);
18195 if (!type_attr)
18196 return NULL;
18197
18198 return lookup_die_type (die, type_attr, cu);
18199 }
18200
18201 /* If DIE has a descriptive_type attribute, then set the TYPE's
18202 descriptive type accordingly. */
18203
18204 static void
18205 set_descriptive_type (struct type *type, struct die_info *die,
18206 struct dwarf2_cu *cu)
18207 {
18208 struct type *descriptive_type = die_descriptive_type (die, cu);
18209
18210 if (descriptive_type)
18211 {
18212 ALLOCATE_GNAT_AUX_TYPE (type);
18213 TYPE_DESCRIPTIVE_TYPE (type) = descriptive_type;
18214 }
18215 }
18216
18217 /* Return the containing type of the die in question using its
18218 DW_AT_containing_type attribute. */
18219
18220 static struct type *
18221 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
18222 {
18223 struct attribute *type_attr;
18224
18225 type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
18226 if (!type_attr)
18227 error (_("Dwarf Error: Problem turning containing type into gdb type "
18228 "[in module %s]"), objfile_name (cu->objfile));
18229
18230 return lookup_die_type (die, type_attr, cu);
18231 }
18232
18233 /* Return an error marker type to use for the ill formed type in DIE/CU. */
18234
18235 static struct type *
18236 build_error_marker_type (struct dwarf2_cu *cu, struct die_info *die)
18237 {
18238 struct objfile *objfile = dwarf2_per_objfile->objfile;
18239 char *message, *saved;
18240
18241 message = xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
18242 objfile_name (objfile),
18243 cu->header.offset.sect_off,
18244 die->offset.sect_off);
18245 saved = obstack_copy0 (&objfile->objfile_obstack,
18246 message, strlen (message));
18247 xfree (message);
18248
18249 return init_type (TYPE_CODE_ERROR, 0, 0, saved, objfile);
18250 }
18251
18252 /* Look up the type of DIE in CU using its type attribute ATTR.
18253 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
18254 DW_AT_containing_type.
18255 If there is no type substitute an error marker. */
18256
18257 static struct type *
18258 lookup_die_type (struct die_info *die, const struct attribute *attr,
18259 struct dwarf2_cu *cu)
18260 {
18261 struct objfile *objfile = cu->objfile;
18262 struct type *this_type;
18263
18264 gdb_assert (attr->name == DW_AT_type
18265 || attr->name == DW_AT_GNAT_descriptive_type
18266 || attr->name == DW_AT_containing_type);
18267
18268 /* First see if we have it cached. */
18269
18270 if (attr->form == DW_FORM_GNU_ref_alt)
18271 {
18272 struct dwarf2_per_cu_data *per_cu;
18273 sect_offset offset = dwarf2_get_ref_die_offset (attr);
18274
18275 per_cu = dwarf2_find_containing_comp_unit (offset, 1, cu->objfile);
18276 this_type = get_die_type_at_offset (offset, per_cu);
18277 }
18278 else if (attr_form_is_ref (attr))
18279 {
18280 sect_offset offset = dwarf2_get_ref_die_offset (attr);
18281
18282 this_type = get_die_type_at_offset (offset, cu->per_cu);
18283 }
18284 else if (attr->form == DW_FORM_ref_sig8)
18285 {
18286 ULONGEST signature = DW_SIGNATURE (attr);
18287
18288 return get_signatured_type (die, signature, cu);
18289 }
18290 else
18291 {
18292 complaint (&symfile_complaints,
18293 _("Dwarf Error: Bad type attribute %s in DIE"
18294 " at 0x%x [in module %s]"),
18295 dwarf_attr_name (attr->name), die->offset.sect_off,
18296 objfile_name (objfile));
18297 return build_error_marker_type (cu, die);
18298 }
18299
18300 /* If not cached we need to read it in. */
18301
18302 if (this_type == NULL)
18303 {
18304 struct die_info *type_die = NULL;
18305 struct dwarf2_cu *type_cu = cu;
18306
18307 if (attr_form_is_ref (attr))
18308 type_die = follow_die_ref (die, attr, &type_cu);
18309 if (type_die == NULL)
18310 return build_error_marker_type (cu, die);
18311 /* If we find the type now, it's probably because the type came
18312 from an inter-CU reference and the type's CU got expanded before
18313 ours. */
18314 this_type = read_type_die (type_die, type_cu);
18315 }
18316
18317 /* If we still don't have a type use an error marker. */
18318
18319 if (this_type == NULL)
18320 return build_error_marker_type (cu, die);
18321
18322 return this_type;
18323 }
18324
18325 /* Return the type in DIE, CU.
18326 Returns NULL for invalid types.
18327
18328 This first does a lookup in die_type_hash,
18329 and only reads the die in if necessary.
18330
18331 NOTE: This can be called when reading in partial or full symbols. */
18332
18333 static struct type *
18334 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
18335 {
18336 struct type *this_type;
18337
18338 this_type = get_die_type (die, cu);
18339 if (this_type)
18340 return this_type;
18341
18342 return read_type_die_1 (die, cu);
18343 }
18344
18345 /* Read the type in DIE, CU.
18346 Returns NULL for invalid types. */
18347
18348 static struct type *
18349 read_type_die_1 (struct die_info *die, struct dwarf2_cu *cu)
18350 {
18351 struct type *this_type = NULL;
18352
18353 switch (die->tag)
18354 {
18355 case DW_TAG_class_type:
18356 case DW_TAG_interface_type:
18357 case DW_TAG_structure_type:
18358 case DW_TAG_union_type:
18359 this_type = read_structure_type (die, cu);
18360 break;
18361 case DW_TAG_enumeration_type:
18362 this_type = read_enumeration_type (die, cu);
18363 break;
18364 case DW_TAG_subprogram:
18365 case DW_TAG_subroutine_type:
18366 case DW_TAG_inlined_subroutine:
18367 this_type = read_subroutine_type (die, cu);
18368 break;
18369 case DW_TAG_array_type:
18370 this_type = read_array_type (die, cu);
18371 break;
18372 case DW_TAG_set_type:
18373 this_type = read_set_type (die, cu);
18374 break;
18375 case DW_TAG_pointer_type:
18376 this_type = read_tag_pointer_type (die, cu);
18377 break;
18378 case DW_TAG_ptr_to_member_type:
18379 this_type = read_tag_ptr_to_member_type (die, cu);
18380 break;
18381 case DW_TAG_reference_type:
18382 this_type = read_tag_reference_type (die, cu);
18383 break;
18384 case DW_TAG_const_type:
18385 this_type = read_tag_const_type (die, cu);
18386 break;
18387 case DW_TAG_volatile_type:
18388 this_type = read_tag_volatile_type (die, cu);
18389 break;
18390 case DW_TAG_restrict_type:
18391 this_type = read_tag_restrict_type (die, cu);
18392 break;
18393 case DW_TAG_string_type:
18394 this_type = read_tag_string_type (die, cu);
18395 break;
18396 case DW_TAG_typedef:
18397 this_type = read_typedef (die, cu);
18398 break;
18399 case DW_TAG_subrange_type:
18400 this_type = read_subrange_type (die, cu);
18401 break;
18402 case DW_TAG_base_type:
18403 this_type = read_base_type (die, cu);
18404 break;
18405 case DW_TAG_unspecified_type:
18406 this_type = read_unspecified_type (die, cu);
18407 break;
18408 case DW_TAG_namespace:
18409 this_type = read_namespace_type (die, cu);
18410 break;
18411 case DW_TAG_module:
18412 this_type = read_module_type (die, cu);
18413 break;
18414 default:
18415 complaint (&symfile_complaints,
18416 _("unexpected tag in read_type_die: '%s'"),
18417 dwarf_tag_name (die->tag));
18418 break;
18419 }
18420
18421 return this_type;
18422 }
18423
18424 /* See if we can figure out if the class lives in a namespace. We do
18425 this by looking for a member function; its demangled name will
18426 contain namespace info, if there is any.
18427 Return the computed name or NULL.
18428 Space for the result is allocated on the objfile's obstack.
18429 This is the full-die version of guess_partial_die_structure_name.
18430 In this case we know DIE has no useful parent. */
18431
18432 static char *
18433 guess_full_die_structure_name (struct die_info *die, struct dwarf2_cu *cu)
18434 {
18435 struct die_info *spec_die;
18436 struct dwarf2_cu *spec_cu;
18437 struct die_info *child;
18438
18439 spec_cu = cu;
18440 spec_die = die_specification (die, &spec_cu);
18441 if (spec_die != NULL)
18442 {
18443 die = spec_die;
18444 cu = spec_cu;
18445 }
18446
18447 for (child = die->child;
18448 child != NULL;
18449 child = child->sibling)
18450 {
18451 if (child->tag == DW_TAG_subprogram)
18452 {
18453 struct attribute *attr;
18454
18455 attr = dwarf2_attr (child, DW_AT_linkage_name, cu);
18456 if (attr == NULL)
18457 attr = dwarf2_attr (child, DW_AT_MIPS_linkage_name, cu);
18458 if (attr != NULL)
18459 {
18460 char *actual_name
18461 = language_class_name_from_physname (cu->language_defn,
18462 DW_STRING (attr));
18463 char *name = NULL;
18464
18465 if (actual_name != NULL)
18466 {
18467 const char *die_name = dwarf2_name (die, cu);
18468
18469 if (die_name != NULL
18470 && strcmp (die_name, actual_name) != 0)
18471 {
18472 /* Strip off the class name from the full name.
18473 We want the prefix. */
18474 int die_name_len = strlen (die_name);
18475 int actual_name_len = strlen (actual_name);
18476
18477 /* Test for '::' as a sanity check. */
18478 if (actual_name_len > die_name_len + 2
18479 && actual_name[actual_name_len
18480 - die_name_len - 1] == ':')
18481 name =
18482 obstack_copy0 (&cu->objfile->objfile_obstack,
18483 actual_name,
18484 actual_name_len - die_name_len - 2);
18485 }
18486 }
18487 xfree (actual_name);
18488 return name;
18489 }
18490 }
18491 }
18492
18493 return NULL;
18494 }
18495
18496 /* GCC might emit a nameless typedef that has a linkage name. Determine the
18497 prefix part in such case. See
18498 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
18499
18500 static char *
18501 anonymous_struct_prefix (struct die_info *die, struct dwarf2_cu *cu)
18502 {
18503 struct attribute *attr;
18504 char *base;
18505
18506 if (die->tag != DW_TAG_class_type && die->tag != DW_TAG_interface_type
18507 && die->tag != DW_TAG_structure_type && die->tag != DW_TAG_union_type)
18508 return NULL;
18509
18510 attr = dwarf2_attr (die, DW_AT_name, cu);
18511 if (attr != NULL && DW_STRING (attr) != NULL)
18512 return NULL;
18513
18514 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
18515 if (attr == NULL)
18516 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
18517 if (attr == NULL || DW_STRING (attr) == NULL)
18518 return NULL;
18519
18520 /* dwarf2_name had to be already called. */
18521 gdb_assert (DW_STRING_IS_CANONICAL (attr));
18522
18523 /* Strip the base name, keep any leading namespaces/classes. */
18524 base = strrchr (DW_STRING (attr), ':');
18525 if (base == NULL || base == DW_STRING (attr) || base[-1] != ':')
18526 return "";
18527
18528 return obstack_copy0 (&cu->objfile->objfile_obstack,
18529 DW_STRING (attr), &base[-1] - DW_STRING (attr));
18530 }
18531
18532 /* Return the name of the namespace/class that DIE is defined within,
18533 or "" if we can't tell. The caller should not xfree the result.
18534
18535 For example, if we're within the method foo() in the following
18536 code:
18537
18538 namespace N {
18539 class C {
18540 void foo () {
18541 }
18542 };
18543 }
18544
18545 then determine_prefix on foo's die will return "N::C". */
18546
18547 static const char *
18548 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
18549 {
18550 struct die_info *parent, *spec_die;
18551 struct dwarf2_cu *spec_cu;
18552 struct type *parent_type;
18553 char *retval;
18554
18555 if (cu->language != language_cplus && cu->language != language_java
18556 && cu->language != language_fortran)
18557 return "";
18558
18559 retval = anonymous_struct_prefix (die, cu);
18560 if (retval)
18561 return retval;
18562
18563 /* We have to be careful in the presence of DW_AT_specification.
18564 For example, with GCC 3.4, given the code
18565
18566 namespace N {
18567 void foo() {
18568 // Definition of N::foo.
18569 }
18570 }
18571
18572 then we'll have a tree of DIEs like this:
18573
18574 1: DW_TAG_compile_unit
18575 2: DW_TAG_namespace // N
18576 3: DW_TAG_subprogram // declaration of N::foo
18577 4: DW_TAG_subprogram // definition of N::foo
18578 DW_AT_specification // refers to die #3
18579
18580 Thus, when processing die #4, we have to pretend that we're in
18581 the context of its DW_AT_specification, namely the contex of die
18582 #3. */
18583 spec_cu = cu;
18584 spec_die = die_specification (die, &spec_cu);
18585 if (spec_die == NULL)
18586 parent = die->parent;
18587 else
18588 {
18589 parent = spec_die->parent;
18590 cu = spec_cu;
18591 }
18592
18593 if (parent == NULL)
18594 return "";
18595 else if (parent->building_fullname)
18596 {
18597 const char *name;
18598 const char *parent_name;
18599
18600 /* It has been seen on RealView 2.2 built binaries,
18601 DW_TAG_template_type_param types actually _defined_ as
18602 children of the parent class:
18603
18604 enum E {};
18605 template class <class Enum> Class{};
18606 Class<enum E> class_e;
18607
18608 1: DW_TAG_class_type (Class)
18609 2: DW_TAG_enumeration_type (E)
18610 3: DW_TAG_enumerator (enum1:0)
18611 3: DW_TAG_enumerator (enum2:1)
18612 ...
18613 2: DW_TAG_template_type_param
18614 DW_AT_type DW_FORM_ref_udata (E)
18615
18616 Besides being broken debug info, it can put GDB into an
18617 infinite loop. Consider:
18618
18619 When we're building the full name for Class<E>, we'll start
18620 at Class, and go look over its template type parameters,
18621 finding E. We'll then try to build the full name of E, and
18622 reach here. We're now trying to build the full name of E,
18623 and look over the parent DIE for containing scope. In the
18624 broken case, if we followed the parent DIE of E, we'd again
18625 find Class, and once again go look at its template type
18626 arguments, etc., etc. Simply don't consider such parent die
18627 as source-level parent of this die (it can't be, the language
18628 doesn't allow it), and break the loop here. */
18629 name = dwarf2_name (die, cu);
18630 parent_name = dwarf2_name (parent, cu);
18631 complaint (&symfile_complaints,
18632 _("template param type '%s' defined within parent '%s'"),
18633 name ? name : "<unknown>",
18634 parent_name ? parent_name : "<unknown>");
18635 return "";
18636 }
18637 else
18638 switch (parent->tag)
18639 {
18640 case DW_TAG_namespace:
18641 parent_type = read_type_die (parent, cu);
18642 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
18643 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
18644 Work around this problem here. */
18645 if (cu->language == language_cplus
18646 && strcmp (TYPE_TAG_NAME (parent_type), "::") == 0)
18647 return "";
18648 /* We give a name to even anonymous namespaces. */
18649 return TYPE_TAG_NAME (parent_type);
18650 case DW_TAG_class_type:
18651 case DW_TAG_interface_type:
18652 case DW_TAG_structure_type:
18653 case DW_TAG_union_type:
18654 case DW_TAG_module:
18655 parent_type = read_type_die (parent, cu);
18656 if (TYPE_TAG_NAME (parent_type) != NULL)
18657 return TYPE_TAG_NAME (parent_type);
18658 else
18659 /* An anonymous structure is only allowed non-static data
18660 members; no typedefs, no member functions, et cetera.
18661 So it does not need a prefix. */
18662 return "";
18663 case DW_TAG_compile_unit:
18664 case DW_TAG_partial_unit:
18665 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
18666 if (cu->language == language_cplus
18667 && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
18668 && die->child != NULL
18669 && (die->tag == DW_TAG_class_type
18670 || die->tag == DW_TAG_structure_type
18671 || die->tag == DW_TAG_union_type))
18672 {
18673 char *name = guess_full_die_structure_name (die, cu);
18674 if (name != NULL)
18675 return name;
18676 }
18677 return "";
18678 case DW_TAG_enumeration_type:
18679 parent_type = read_type_die (parent, cu);
18680 if (TYPE_DECLARED_CLASS (parent_type))
18681 {
18682 if (TYPE_TAG_NAME (parent_type) != NULL)
18683 return TYPE_TAG_NAME (parent_type);
18684 return "";
18685 }
18686 /* Fall through. */
18687 default:
18688 return determine_prefix (parent, cu);
18689 }
18690 }
18691
18692 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
18693 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
18694 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
18695 an obconcat, otherwise allocate storage for the result. The CU argument is
18696 used to determine the language and hence, the appropriate separator. */
18697
18698 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
18699
18700 static char *
18701 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
18702 int physname, struct dwarf2_cu *cu)
18703 {
18704 const char *lead = "";
18705 const char *sep;
18706
18707 if (suffix == NULL || suffix[0] == '\0'
18708 || prefix == NULL || prefix[0] == '\0')
18709 sep = "";
18710 else if (cu->language == language_java)
18711 sep = ".";
18712 else if (cu->language == language_fortran && physname)
18713 {
18714 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
18715 DW_AT_MIPS_linkage_name is preferred and used instead. */
18716
18717 lead = "__";
18718 sep = "_MOD_";
18719 }
18720 else
18721 sep = "::";
18722
18723 if (prefix == NULL)
18724 prefix = "";
18725 if (suffix == NULL)
18726 suffix = "";
18727
18728 if (obs == NULL)
18729 {
18730 char *retval
18731 = xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1);
18732
18733 strcpy (retval, lead);
18734 strcat (retval, prefix);
18735 strcat (retval, sep);
18736 strcat (retval, suffix);
18737 return retval;
18738 }
18739 else
18740 {
18741 /* We have an obstack. */
18742 return obconcat (obs, lead, prefix, sep, suffix, (char *) NULL);
18743 }
18744 }
18745
18746 /* Return sibling of die, NULL if no sibling. */
18747
18748 static struct die_info *
18749 sibling_die (struct die_info *die)
18750 {
18751 return die->sibling;
18752 }
18753
18754 /* Get name of a die, return NULL if not found. */
18755
18756 static const char *
18757 dwarf2_canonicalize_name (const char *name, struct dwarf2_cu *cu,
18758 struct obstack *obstack)
18759 {
18760 if (name && cu->language == language_cplus)
18761 {
18762 char *canon_name = cp_canonicalize_string (name);
18763
18764 if (canon_name != NULL)
18765 {
18766 if (strcmp (canon_name, name) != 0)
18767 name = obstack_copy0 (obstack, canon_name, strlen (canon_name));
18768 xfree (canon_name);
18769 }
18770 }
18771
18772 return name;
18773 }
18774
18775 /* Get name of a die, return NULL if not found. */
18776
18777 static const char *
18778 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
18779 {
18780 struct attribute *attr;
18781
18782 attr = dwarf2_attr (die, DW_AT_name, cu);
18783 if ((!attr || !DW_STRING (attr))
18784 && die->tag != DW_TAG_class_type
18785 && die->tag != DW_TAG_interface_type
18786 && die->tag != DW_TAG_structure_type
18787 && die->tag != DW_TAG_union_type)
18788 return NULL;
18789
18790 switch (die->tag)
18791 {
18792 case DW_TAG_compile_unit:
18793 case DW_TAG_partial_unit:
18794 /* Compilation units have a DW_AT_name that is a filename, not
18795 a source language identifier. */
18796 case DW_TAG_enumeration_type:
18797 case DW_TAG_enumerator:
18798 /* These tags always have simple identifiers already; no need
18799 to canonicalize them. */
18800 return DW_STRING (attr);
18801
18802 case DW_TAG_subprogram:
18803 /* Java constructors will all be named "<init>", so return
18804 the class name when we see this special case. */
18805 if (cu->language == language_java
18806 && DW_STRING (attr) != NULL
18807 && strcmp (DW_STRING (attr), "<init>") == 0)
18808 {
18809 struct dwarf2_cu *spec_cu = cu;
18810 struct die_info *spec_die;
18811
18812 /* GCJ will output '<init>' for Java constructor names.
18813 For this special case, return the name of the parent class. */
18814
18815 /* GCJ may output suprogram DIEs with AT_specification set.
18816 If so, use the name of the specified DIE. */
18817 spec_die = die_specification (die, &spec_cu);
18818 if (spec_die != NULL)
18819 return dwarf2_name (spec_die, spec_cu);
18820
18821 do
18822 {
18823 die = die->parent;
18824 if (die->tag == DW_TAG_class_type)
18825 return dwarf2_name (die, cu);
18826 }
18827 while (die->tag != DW_TAG_compile_unit
18828 && die->tag != DW_TAG_partial_unit);
18829 }
18830 break;
18831
18832 case DW_TAG_class_type:
18833 case DW_TAG_interface_type:
18834 case DW_TAG_structure_type:
18835 case DW_TAG_union_type:
18836 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
18837 structures or unions. These were of the form "._%d" in GCC 4.1,
18838 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
18839 and GCC 4.4. We work around this problem by ignoring these. */
18840 if (attr && DW_STRING (attr)
18841 && (strncmp (DW_STRING (attr), "._", 2) == 0
18842 || strncmp (DW_STRING (attr), "<anonymous", 10) == 0))
18843 return NULL;
18844
18845 /* GCC might emit a nameless typedef that has a linkage name. See
18846 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
18847 if (!attr || DW_STRING (attr) == NULL)
18848 {
18849 char *demangled = NULL;
18850
18851 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
18852 if (attr == NULL)
18853 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
18854
18855 if (attr == NULL || DW_STRING (attr) == NULL)
18856 return NULL;
18857
18858 /* Avoid demangling DW_STRING (attr) the second time on a second
18859 call for the same DIE. */
18860 if (!DW_STRING_IS_CANONICAL (attr))
18861 demangled = gdb_demangle (DW_STRING (attr), DMGL_TYPES);
18862
18863 if (demangled)
18864 {
18865 char *base;
18866
18867 /* FIXME: we already did this for the partial symbol... */
18868 DW_STRING (attr) = obstack_copy0 (&cu->objfile->objfile_obstack,
18869 demangled, strlen (demangled));
18870 DW_STRING_IS_CANONICAL (attr) = 1;
18871 xfree (demangled);
18872
18873 /* Strip any leading namespaces/classes, keep only the base name.
18874 DW_AT_name for named DIEs does not contain the prefixes. */
18875 base = strrchr (DW_STRING (attr), ':');
18876 if (base && base > DW_STRING (attr) && base[-1] == ':')
18877 return &base[1];
18878 else
18879 return DW_STRING (attr);
18880 }
18881 }
18882 break;
18883
18884 default:
18885 break;
18886 }
18887
18888 if (!DW_STRING_IS_CANONICAL (attr))
18889 {
18890 DW_STRING (attr)
18891 = dwarf2_canonicalize_name (DW_STRING (attr), cu,
18892 &cu->objfile->objfile_obstack);
18893 DW_STRING_IS_CANONICAL (attr) = 1;
18894 }
18895 return DW_STRING (attr);
18896 }
18897
18898 /* Return the die that this die in an extension of, or NULL if there
18899 is none. *EXT_CU is the CU containing DIE on input, and the CU
18900 containing the return value on output. */
18901
18902 static struct die_info *
18903 dwarf2_extension (struct die_info *die, struct dwarf2_cu **ext_cu)
18904 {
18905 struct attribute *attr;
18906
18907 attr = dwarf2_attr (die, DW_AT_extension, *ext_cu);
18908 if (attr == NULL)
18909 return NULL;
18910
18911 return follow_die_ref (die, attr, ext_cu);
18912 }
18913
18914 /* Convert a DIE tag into its string name. */
18915
18916 static const char *
18917 dwarf_tag_name (unsigned tag)
18918 {
18919 const char *name = get_DW_TAG_name (tag);
18920
18921 if (name == NULL)
18922 return "DW_TAG_<unknown>";
18923
18924 return name;
18925 }
18926
18927 /* Convert a DWARF attribute code into its string name. */
18928
18929 static const char *
18930 dwarf_attr_name (unsigned attr)
18931 {
18932 const char *name;
18933
18934 #ifdef MIPS /* collides with DW_AT_HP_block_index */
18935 if (attr == DW_AT_MIPS_fde)
18936 return "DW_AT_MIPS_fde";
18937 #else
18938 if (attr == DW_AT_HP_block_index)
18939 return "DW_AT_HP_block_index";
18940 #endif
18941
18942 name = get_DW_AT_name (attr);
18943
18944 if (name == NULL)
18945 return "DW_AT_<unknown>";
18946
18947 return name;
18948 }
18949
18950 /* Convert a DWARF value form code into its string name. */
18951
18952 static const char *
18953 dwarf_form_name (unsigned form)
18954 {
18955 const char *name = get_DW_FORM_name (form);
18956
18957 if (name == NULL)
18958 return "DW_FORM_<unknown>";
18959
18960 return name;
18961 }
18962
18963 static char *
18964 dwarf_bool_name (unsigned mybool)
18965 {
18966 if (mybool)
18967 return "TRUE";
18968 else
18969 return "FALSE";
18970 }
18971
18972 /* Convert a DWARF type code into its string name. */
18973
18974 static const char *
18975 dwarf_type_encoding_name (unsigned enc)
18976 {
18977 const char *name = get_DW_ATE_name (enc);
18978
18979 if (name == NULL)
18980 return "DW_ATE_<unknown>";
18981
18982 return name;
18983 }
18984
18985 static void
18986 dump_die_shallow (struct ui_file *f, int indent, struct die_info *die)
18987 {
18988 unsigned int i;
18989
18990 print_spaces (indent, f);
18991 fprintf_unfiltered (f, "Die: %s (abbrev %d, offset 0x%x)\n",
18992 dwarf_tag_name (die->tag), die->abbrev, die->offset.sect_off);
18993
18994 if (die->parent != NULL)
18995 {
18996 print_spaces (indent, f);
18997 fprintf_unfiltered (f, " parent at offset: 0x%x\n",
18998 die->parent->offset.sect_off);
18999 }
19000
19001 print_spaces (indent, f);
19002 fprintf_unfiltered (f, " has children: %s\n",
19003 dwarf_bool_name (die->child != NULL));
19004
19005 print_spaces (indent, f);
19006 fprintf_unfiltered (f, " attributes:\n");
19007
19008 for (i = 0; i < die->num_attrs; ++i)
19009 {
19010 print_spaces (indent, f);
19011 fprintf_unfiltered (f, " %s (%s) ",
19012 dwarf_attr_name (die->attrs[i].name),
19013 dwarf_form_name (die->attrs[i].form));
19014
19015 switch (die->attrs[i].form)
19016 {
19017 case DW_FORM_addr:
19018 case DW_FORM_GNU_addr_index:
19019 fprintf_unfiltered (f, "address: ");
19020 fputs_filtered (hex_string (DW_ADDR (&die->attrs[i])), f);
19021 break;
19022 case DW_FORM_block2:
19023 case DW_FORM_block4:
19024 case DW_FORM_block:
19025 case DW_FORM_block1:
19026 fprintf_unfiltered (f, "block: size %s",
19027 pulongest (DW_BLOCK (&die->attrs[i])->size));
19028 break;
19029 case DW_FORM_exprloc:
19030 fprintf_unfiltered (f, "expression: size %s",
19031 pulongest (DW_BLOCK (&die->attrs[i])->size));
19032 break;
19033 case DW_FORM_ref_addr:
19034 fprintf_unfiltered (f, "ref address: ");
19035 fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
19036 break;
19037 case DW_FORM_GNU_ref_alt:
19038 fprintf_unfiltered (f, "alt ref address: ");
19039 fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
19040 break;
19041 case DW_FORM_ref1:
19042 case DW_FORM_ref2:
19043 case DW_FORM_ref4:
19044 case DW_FORM_ref8:
19045 case DW_FORM_ref_udata:
19046 fprintf_unfiltered (f, "constant ref: 0x%lx (adjusted)",
19047 (long) (DW_UNSND (&die->attrs[i])));
19048 break;
19049 case DW_FORM_data1:
19050 case DW_FORM_data2:
19051 case DW_FORM_data4:
19052 case DW_FORM_data8:
19053 case DW_FORM_udata:
19054 case DW_FORM_sdata:
19055 fprintf_unfiltered (f, "constant: %s",
19056 pulongest (DW_UNSND (&die->attrs[i])));
19057 break;
19058 case DW_FORM_sec_offset:
19059 fprintf_unfiltered (f, "section offset: %s",
19060 pulongest (DW_UNSND (&die->attrs[i])));
19061 break;
19062 case DW_FORM_ref_sig8:
19063 fprintf_unfiltered (f, "signature: %s",
19064 hex_string (DW_SIGNATURE (&die->attrs[i])));
19065 break;
19066 case DW_FORM_string:
19067 case DW_FORM_strp:
19068 case DW_FORM_GNU_str_index:
19069 case DW_FORM_GNU_strp_alt:
19070 fprintf_unfiltered (f, "string: \"%s\" (%s canonicalized)",
19071 DW_STRING (&die->attrs[i])
19072 ? DW_STRING (&die->attrs[i]) : "",
19073 DW_STRING_IS_CANONICAL (&die->attrs[i]) ? "is" : "not");
19074 break;
19075 case DW_FORM_flag:
19076 if (DW_UNSND (&die->attrs[i]))
19077 fprintf_unfiltered (f, "flag: TRUE");
19078 else
19079 fprintf_unfiltered (f, "flag: FALSE");
19080 break;
19081 case DW_FORM_flag_present:
19082 fprintf_unfiltered (f, "flag: TRUE");
19083 break;
19084 case DW_FORM_indirect:
19085 /* The reader will have reduced the indirect form to
19086 the "base form" so this form should not occur. */
19087 fprintf_unfiltered (f,
19088 "unexpected attribute form: DW_FORM_indirect");
19089 break;
19090 default:
19091 fprintf_unfiltered (f, "unsupported attribute form: %d.",
19092 die->attrs[i].form);
19093 break;
19094 }
19095 fprintf_unfiltered (f, "\n");
19096 }
19097 }
19098
19099 static void
19100 dump_die_for_error (struct die_info *die)
19101 {
19102 dump_die_shallow (gdb_stderr, 0, die);
19103 }
19104
19105 static void
19106 dump_die_1 (struct ui_file *f, int level, int max_level, struct die_info *die)
19107 {
19108 int indent = level * 4;
19109
19110 gdb_assert (die != NULL);
19111
19112 if (level >= max_level)
19113 return;
19114
19115 dump_die_shallow (f, indent, die);
19116
19117 if (die->child != NULL)
19118 {
19119 print_spaces (indent, f);
19120 fprintf_unfiltered (f, " Children:");
19121 if (level + 1 < max_level)
19122 {
19123 fprintf_unfiltered (f, "\n");
19124 dump_die_1 (f, level + 1, max_level, die->child);
19125 }
19126 else
19127 {
19128 fprintf_unfiltered (f,
19129 " [not printed, max nesting level reached]\n");
19130 }
19131 }
19132
19133 if (die->sibling != NULL && level > 0)
19134 {
19135 dump_die_1 (f, level, max_level, die->sibling);
19136 }
19137 }
19138
19139 /* This is called from the pdie macro in gdbinit.in.
19140 It's not static so gcc will keep a copy callable from gdb. */
19141
19142 void
19143 dump_die (struct die_info *die, int max_level)
19144 {
19145 dump_die_1 (gdb_stdlog, 0, max_level, die);
19146 }
19147
19148 static void
19149 store_in_ref_table (struct die_info *die, struct dwarf2_cu *cu)
19150 {
19151 void **slot;
19152
19153 slot = htab_find_slot_with_hash (cu->die_hash, die, die->offset.sect_off,
19154 INSERT);
19155
19156 *slot = die;
19157 }
19158
19159 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
19160 required kind. */
19161
19162 static sect_offset
19163 dwarf2_get_ref_die_offset (const struct attribute *attr)
19164 {
19165 sect_offset retval = { DW_UNSND (attr) };
19166
19167 if (attr_form_is_ref (attr))
19168 return retval;
19169
19170 retval.sect_off = 0;
19171 complaint (&symfile_complaints,
19172 _("unsupported die ref attribute form: '%s'"),
19173 dwarf_form_name (attr->form));
19174 return retval;
19175 }
19176
19177 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
19178 * the value held by the attribute is not constant. */
19179
19180 static LONGEST
19181 dwarf2_get_attr_constant_value (const struct attribute *attr, int default_value)
19182 {
19183 if (attr->form == DW_FORM_sdata)
19184 return DW_SND (attr);
19185 else if (attr->form == DW_FORM_udata
19186 || attr->form == DW_FORM_data1
19187 || attr->form == DW_FORM_data2
19188 || attr->form == DW_FORM_data4
19189 || attr->form == DW_FORM_data8)
19190 return DW_UNSND (attr);
19191 else
19192 {
19193 complaint (&symfile_complaints,
19194 _("Attribute value is not a constant (%s)"),
19195 dwarf_form_name (attr->form));
19196 return default_value;
19197 }
19198 }
19199
19200 /* Follow reference or signature attribute ATTR of SRC_DIE.
19201 On entry *REF_CU is the CU of SRC_DIE.
19202 On exit *REF_CU is the CU of the result. */
19203
19204 static struct die_info *
19205 follow_die_ref_or_sig (struct die_info *src_die, const struct attribute *attr,
19206 struct dwarf2_cu **ref_cu)
19207 {
19208 struct die_info *die;
19209
19210 if (attr_form_is_ref (attr))
19211 die = follow_die_ref (src_die, attr, ref_cu);
19212 else if (attr->form == DW_FORM_ref_sig8)
19213 die = follow_die_sig (src_die, attr, ref_cu);
19214 else
19215 {
19216 dump_die_for_error (src_die);
19217 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
19218 objfile_name ((*ref_cu)->objfile));
19219 }
19220
19221 return die;
19222 }
19223
19224 /* Follow reference OFFSET.
19225 On entry *REF_CU is the CU of the source die referencing OFFSET.
19226 On exit *REF_CU is the CU of the result.
19227 Returns NULL if OFFSET is invalid. */
19228
19229 static struct die_info *
19230 follow_die_offset (sect_offset offset, int offset_in_dwz,
19231 struct dwarf2_cu **ref_cu)
19232 {
19233 struct die_info temp_die;
19234 struct dwarf2_cu *target_cu, *cu = *ref_cu;
19235
19236 gdb_assert (cu->per_cu != NULL);
19237
19238 target_cu = cu;
19239
19240 if (cu->per_cu->is_debug_types)
19241 {
19242 /* .debug_types CUs cannot reference anything outside their CU.
19243 If they need to, they have to reference a signatured type via
19244 DW_FORM_ref_sig8. */
19245 if (! offset_in_cu_p (&cu->header, offset))
19246 return NULL;
19247 }
19248 else if (offset_in_dwz != cu->per_cu->is_dwz
19249 || ! offset_in_cu_p (&cu->header, offset))
19250 {
19251 struct dwarf2_per_cu_data *per_cu;
19252
19253 per_cu = dwarf2_find_containing_comp_unit (offset, offset_in_dwz,
19254 cu->objfile);
19255
19256 /* If necessary, add it to the queue and load its DIEs. */
19257 if (maybe_queue_comp_unit (cu, per_cu, cu->language))
19258 load_full_comp_unit (per_cu, cu->language);
19259
19260 target_cu = per_cu->cu;
19261 }
19262 else if (cu->dies == NULL)
19263 {
19264 /* We're loading full DIEs during partial symbol reading. */
19265 gdb_assert (dwarf2_per_objfile->reading_partial_symbols);
19266 load_full_comp_unit (cu->per_cu, language_minimal);
19267 }
19268
19269 *ref_cu = target_cu;
19270 temp_die.offset = offset;
19271 return htab_find_with_hash (target_cu->die_hash, &temp_die, offset.sect_off);
19272 }
19273
19274 /* Follow reference attribute ATTR of SRC_DIE.
19275 On entry *REF_CU is the CU of SRC_DIE.
19276 On exit *REF_CU is the CU of the result. */
19277
19278 static struct die_info *
19279 follow_die_ref (struct die_info *src_die, const struct attribute *attr,
19280 struct dwarf2_cu **ref_cu)
19281 {
19282 sect_offset offset = dwarf2_get_ref_die_offset (attr);
19283 struct dwarf2_cu *cu = *ref_cu;
19284 struct die_info *die;
19285
19286 die = follow_die_offset (offset,
19287 (attr->form == DW_FORM_GNU_ref_alt
19288 || cu->per_cu->is_dwz),
19289 ref_cu);
19290 if (!die)
19291 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
19292 "at 0x%x [in module %s]"),
19293 offset.sect_off, src_die->offset.sect_off,
19294 objfile_name (cu->objfile));
19295
19296 return die;
19297 }
19298
19299 /* Return DWARF block referenced by DW_AT_location of DIE at OFFSET at PER_CU.
19300 Returned value is intended for DW_OP_call*. Returned
19301 dwarf2_locexpr_baton->data has lifetime of PER_CU->OBJFILE. */
19302
19303 struct dwarf2_locexpr_baton
19304 dwarf2_fetch_die_loc_sect_off (sect_offset offset,
19305 struct dwarf2_per_cu_data *per_cu,
19306 CORE_ADDR (*get_frame_pc) (void *baton),
19307 void *baton)
19308 {
19309 struct dwarf2_cu *cu;
19310 struct die_info *die;
19311 struct attribute *attr;
19312 struct dwarf2_locexpr_baton retval;
19313
19314 dw2_setup (per_cu->objfile);
19315
19316 if (per_cu->cu == NULL)
19317 load_cu (per_cu);
19318 cu = per_cu->cu;
19319
19320 die = follow_die_offset (offset, per_cu->is_dwz, &cu);
19321 if (!die)
19322 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
19323 offset.sect_off, objfile_name (per_cu->objfile));
19324
19325 attr = dwarf2_attr (die, DW_AT_location, cu);
19326 if (!attr)
19327 {
19328 /* DWARF: "If there is no such attribute, then there is no effect.".
19329 DATA is ignored if SIZE is 0. */
19330
19331 retval.data = NULL;
19332 retval.size = 0;
19333 }
19334 else if (attr_form_is_section_offset (attr))
19335 {
19336 struct dwarf2_loclist_baton loclist_baton;
19337 CORE_ADDR pc = (*get_frame_pc) (baton);
19338 size_t size;
19339
19340 fill_in_loclist_baton (cu, &loclist_baton, attr);
19341
19342 retval.data = dwarf2_find_location_expression (&loclist_baton,
19343 &size, pc);
19344 retval.size = size;
19345 }
19346 else
19347 {
19348 if (!attr_form_is_block (attr))
19349 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
19350 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
19351 offset.sect_off, objfile_name (per_cu->objfile));
19352
19353 retval.data = DW_BLOCK (attr)->data;
19354 retval.size = DW_BLOCK (attr)->size;
19355 }
19356 retval.per_cu = cu->per_cu;
19357
19358 age_cached_comp_units ();
19359
19360 return retval;
19361 }
19362
19363 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
19364 offset. */
19365
19366 struct dwarf2_locexpr_baton
19367 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu,
19368 struct dwarf2_per_cu_data *per_cu,
19369 CORE_ADDR (*get_frame_pc) (void *baton),
19370 void *baton)
19371 {
19372 sect_offset offset = { per_cu->offset.sect_off + offset_in_cu.cu_off };
19373
19374 return dwarf2_fetch_die_loc_sect_off (offset, per_cu, get_frame_pc, baton);
19375 }
19376
19377 /* Write a constant of a given type as target-ordered bytes into
19378 OBSTACK. */
19379
19380 static const gdb_byte *
19381 write_constant_as_bytes (struct obstack *obstack,
19382 enum bfd_endian byte_order,
19383 struct type *type,
19384 ULONGEST value,
19385 LONGEST *len)
19386 {
19387 gdb_byte *result;
19388
19389 *len = TYPE_LENGTH (type);
19390 result = obstack_alloc (obstack, *len);
19391 store_unsigned_integer (result, *len, byte_order, value);
19392
19393 return result;
19394 }
19395
19396 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
19397 pointer to the constant bytes and set LEN to the length of the
19398 data. If memory is needed, allocate it on OBSTACK. If the DIE
19399 does not have a DW_AT_const_value, return NULL. */
19400
19401 const gdb_byte *
19402 dwarf2_fetch_constant_bytes (sect_offset offset,
19403 struct dwarf2_per_cu_data *per_cu,
19404 struct obstack *obstack,
19405 LONGEST *len)
19406 {
19407 struct dwarf2_cu *cu;
19408 struct die_info *die;
19409 struct attribute *attr;
19410 const gdb_byte *result = NULL;
19411 struct type *type;
19412 LONGEST value;
19413 enum bfd_endian byte_order;
19414
19415 dw2_setup (per_cu->objfile);
19416
19417 if (per_cu->cu == NULL)
19418 load_cu (per_cu);
19419 cu = per_cu->cu;
19420
19421 die = follow_die_offset (offset, per_cu->is_dwz, &cu);
19422 if (!die)
19423 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
19424 offset.sect_off, objfile_name (per_cu->objfile));
19425
19426
19427 attr = dwarf2_attr (die, DW_AT_const_value, cu);
19428 if (attr == NULL)
19429 return NULL;
19430
19431 byte_order = (bfd_big_endian (per_cu->objfile->obfd)
19432 ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
19433
19434 switch (attr->form)
19435 {
19436 case DW_FORM_addr:
19437 case DW_FORM_GNU_addr_index:
19438 {
19439 gdb_byte *tem;
19440
19441 *len = cu->header.addr_size;
19442 tem = obstack_alloc (obstack, *len);
19443 store_unsigned_integer (tem, *len, byte_order, DW_ADDR (attr));
19444 result = tem;
19445 }
19446 break;
19447 case DW_FORM_string:
19448 case DW_FORM_strp:
19449 case DW_FORM_GNU_str_index:
19450 case DW_FORM_GNU_strp_alt:
19451 /* DW_STRING is already allocated on the objfile obstack, point
19452 directly to it. */
19453 result = (const gdb_byte *) DW_STRING (attr);
19454 *len = strlen (DW_STRING (attr));
19455 break;
19456 case DW_FORM_block1:
19457 case DW_FORM_block2:
19458 case DW_FORM_block4:
19459 case DW_FORM_block:
19460 case DW_FORM_exprloc:
19461 result = DW_BLOCK (attr)->data;
19462 *len = DW_BLOCK (attr)->size;
19463 break;
19464
19465 /* The DW_AT_const_value attributes are supposed to carry the
19466 symbol's value "represented as it would be on the target
19467 architecture." By the time we get here, it's already been
19468 converted to host endianness, so we just need to sign- or
19469 zero-extend it as appropriate. */
19470 case DW_FORM_data1:
19471 type = die_type (die, cu);
19472 result = dwarf2_const_value_data (attr, obstack, cu, &value, 8);
19473 if (result == NULL)
19474 result = write_constant_as_bytes (obstack, byte_order,
19475 type, value, len);
19476 break;
19477 case DW_FORM_data2:
19478 type = die_type (die, cu);
19479 result = dwarf2_const_value_data (attr, obstack, cu, &value, 16);
19480 if (result == NULL)
19481 result = write_constant_as_bytes (obstack, byte_order,
19482 type, value, len);
19483 break;
19484 case DW_FORM_data4:
19485 type = die_type (die, cu);
19486 result = dwarf2_const_value_data (attr, obstack, cu, &value, 32);
19487 if (result == NULL)
19488 result = write_constant_as_bytes (obstack, byte_order,
19489 type, value, len);
19490 break;
19491 case DW_FORM_data8:
19492 type = die_type (die, cu);
19493 result = dwarf2_const_value_data (attr, obstack, cu, &value, 64);
19494 if (result == NULL)
19495 result = write_constant_as_bytes (obstack, byte_order,
19496 type, value, len);
19497 break;
19498
19499 case DW_FORM_sdata:
19500 type = die_type (die, cu);
19501 result = write_constant_as_bytes (obstack, byte_order,
19502 type, DW_SND (attr), len);
19503 break;
19504
19505 case DW_FORM_udata:
19506 type = die_type (die, cu);
19507 result = write_constant_as_bytes (obstack, byte_order,
19508 type, DW_UNSND (attr), len);
19509 break;
19510
19511 default:
19512 complaint (&symfile_complaints,
19513 _("unsupported const value attribute form: '%s'"),
19514 dwarf_form_name (attr->form));
19515 break;
19516 }
19517
19518 return result;
19519 }
19520
19521 /* Return the type of the DIE at DIE_OFFSET in the CU named by
19522 PER_CU. */
19523
19524 struct type *
19525 dwarf2_get_die_type (cu_offset die_offset,
19526 struct dwarf2_per_cu_data *per_cu)
19527 {
19528 sect_offset die_offset_sect;
19529
19530 dw2_setup (per_cu->objfile);
19531
19532 die_offset_sect.sect_off = per_cu->offset.sect_off + die_offset.cu_off;
19533 return get_die_type_at_offset (die_offset_sect, per_cu);
19534 }
19535
19536 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
19537 On entry *REF_CU is the CU of SRC_DIE.
19538 On exit *REF_CU is the CU of the result.
19539 Returns NULL if the referenced DIE isn't found. */
19540
19541 static struct die_info *
19542 follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type,
19543 struct dwarf2_cu **ref_cu)
19544 {
19545 struct objfile *objfile = (*ref_cu)->objfile;
19546 struct die_info temp_die;
19547 struct dwarf2_cu *sig_cu;
19548 struct die_info *die;
19549
19550 /* While it might be nice to assert sig_type->type == NULL here,
19551 we can get here for DW_AT_imported_declaration where we need
19552 the DIE not the type. */
19553
19554 /* If necessary, add it to the queue and load its DIEs. */
19555
19556 if (maybe_queue_comp_unit (*ref_cu, &sig_type->per_cu, language_minimal))
19557 read_signatured_type (sig_type);
19558
19559 sig_cu = sig_type->per_cu.cu;
19560 gdb_assert (sig_cu != NULL);
19561 gdb_assert (sig_type->type_offset_in_section.sect_off != 0);
19562 temp_die.offset = sig_type->type_offset_in_section;
19563 die = htab_find_with_hash (sig_cu->die_hash, &temp_die,
19564 temp_die.offset.sect_off);
19565 if (die)
19566 {
19567 /* For .gdb_index version 7 keep track of included TUs.
19568 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
19569 if (dwarf2_per_objfile->index_table != NULL
19570 && dwarf2_per_objfile->index_table->version <= 7)
19571 {
19572 VEC_safe_push (dwarf2_per_cu_ptr,
19573 (*ref_cu)->per_cu->imported_symtabs,
19574 sig_cu->per_cu);
19575 }
19576
19577 *ref_cu = sig_cu;
19578 return die;
19579 }
19580
19581 return NULL;
19582 }
19583
19584 /* Follow signatured type referenced by ATTR in SRC_DIE.
19585 On entry *REF_CU is the CU of SRC_DIE.
19586 On exit *REF_CU is the CU of the result.
19587 The result is the DIE of the type.
19588 If the referenced type cannot be found an error is thrown. */
19589
19590 static struct die_info *
19591 follow_die_sig (struct die_info *src_die, const struct attribute *attr,
19592 struct dwarf2_cu **ref_cu)
19593 {
19594 ULONGEST signature = DW_SIGNATURE (attr);
19595 struct signatured_type *sig_type;
19596 struct die_info *die;
19597
19598 gdb_assert (attr->form == DW_FORM_ref_sig8);
19599
19600 sig_type = lookup_signatured_type (*ref_cu, signature);
19601 /* sig_type will be NULL if the signatured type is missing from
19602 the debug info. */
19603 if (sig_type == NULL)
19604 {
19605 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
19606 " from DIE at 0x%x [in module %s]"),
19607 hex_string (signature), src_die->offset.sect_off,
19608 objfile_name ((*ref_cu)->objfile));
19609 }
19610
19611 die = follow_die_sig_1 (src_die, sig_type, ref_cu);
19612 if (die == NULL)
19613 {
19614 dump_die_for_error (src_die);
19615 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
19616 " from DIE at 0x%x [in module %s]"),
19617 hex_string (signature), src_die->offset.sect_off,
19618 objfile_name ((*ref_cu)->objfile));
19619 }
19620
19621 return die;
19622 }
19623
19624 /* Get the type specified by SIGNATURE referenced in DIE/CU,
19625 reading in and processing the type unit if necessary. */
19626
19627 static struct type *
19628 get_signatured_type (struct die_info *die, ULONGEST signature,
19629 struct dwarf2_cu *cu)
19630 {
19631 struct signatured_type *sig_type;
19632 struct dwarf2_cu *type_cu;
19633 struct die_info *type_die;
19634 struct type *type;
19635
19636 sig_type = lookup_signatured_type (cu, signature);
19637 /* sig_type will be NULL if the signatured type is missing from
19638 the debug info. */
19639 if (sig_type == NULL)
19640 {
19641 complaint (&symfile_complaints,
19642 _("Dwarf Error: Cannot find signatured DIE %s referenced"
19643 " from DIE at 0x%x [in module %s]"),
19644 hex_string (signature), die->offset.sect_off,
19645 objfile_name (dwarf2_per_objfile->objfile));
19646 return build_error_marker_type (cu, die);
19647 }
19648
19649 /* If we already know the type we're done. */
19650 if (sig_type->type != NULL)
19651 return sig_type->type;
19652
19653 type_cu = cu;
19654 type_die = follow_die_sig_1 (die, sig_type, &type_cu);
19655 if (type_die != NULL)
19656 {
19657 /* N.B. We need to call get_die_type to ensure only one type for this DIE
19658 is created. This is important, for example, because for c++ classes
19659 we need TYPE_NAME set which is only done by new_symbol. Blech. */
19660 type = read_type_die (type_die, type_cu);
19661 if (type == NULL)
19662 {
19663 complaint (&symfile_complaints,
19664 _("Dwarf Error: Cannot build signatured type %s"
19665 " referenced from DIE at 0x%x [in module %s]"),
19666 hex_string (signature), die->offset.sect_off,
19667 objfile_name (dwarf2_per_objfile->objfile));
19668 type = build_error_marker_type (cu, die);
19669 }
19670 }
19671 else
19672 {
19673 complaint (&symfile_complaints,
19674 _("Dwarf Error: Problem reading signatured DIE %s referenced"
19675 " from DIE at 0x%x [in module %s]"),
19676 hex_string (signature), die->offset.sect_off,
19677 objfile_name (dwarf2_per_objfile->objfile));
19678 type = build_error_marker_type (cu, die);
19679 }
19680 sig_type->type = type;
19681
19682 return type;
19683 }
19684
19685 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
19686 reading in and processing the type unit if necessary. */
19687
19688 static struct type *
19689 get_DW_AT_signature_type (struct die_info *die, const struct attribute *attr,
19690 struct dwarf2_cu *cu) /* ARI: editCase function */
19691 {
19692 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
19693 if (attr_form_is_ref (attr))
19694 {
19695 struct dwarf2_cu *type_cu = cu;
19696 struct die_info *type_die = follow_die_ref (die, attr, &type_cu);
19697
19698 return read_type_die (type_die, type_cu);
19699 }
19700 else if (attr->form == DW_FORM_ref_sig8)
19701 {
19702 return get_signatured_type (die, DW_SIGNATURE (attr), cu);
19703 }
19704 else
19705 {
19706 complaint (&symfile_complaints,
19707 _("Dwarf Error: DW_AT_signature has bad form %s in DIE"
19708 " at 0x%x [in module %s]"),
19709 dwarf_form_name (attr->form), die->offset.sect_off,
19710 objfile_name (dwarf2_per_objfile->objfile));
19711 return build_error_marker_type (cu, die);
19712 }
19713 }
19714
19715 /* Load the DIEs associated with type unit PER_CU into memory. */
19716
19717 static void
19718 load_full_type_unit (struct dwarf2_per_cu_data *per_cu)
19719 {
19720 struct signatured_type *sig_type;
19721
19722 /* Caller is responsible for ensuring type_unit_groups don't get here. */
19723 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu));
19724
19725 /* We have the per_cu, but we need the signatured_type.
19726 Fortunately this is an easy translation. */
19727 gdb_assert (per_cu->is_debug_types);
19728 sig_type = (struct signatured_type *) per_cu;
19729
19730 gdb_assert (per_cu->cu == NULL);
19731
19732 read_signatured_type (sig_type);
19733
19734 gdb_assert (per_cu->cu != NULL);
19735 }
19736
19737 /* die_reader_func for read_signatured_type.
19738 This is identical to load_full_comp_unit_reader,
19739 but is kept separate for now. */
19740
19741 static void
19742 read_signatured_type_reader (const struct die_reader_specs *reader,
19743 const gdb_byte *info_ptr,
19744 struct die_info *comp_unit_die,
19745 int has_children,
19746 void *data)
19747 {
19748 struct dwarf2_cu *cu = reader->cu;
19749
19750 gdb_assert (cu->die_hash == NULL);
19751 cu->die_hash =
19752 htab_create_alloc_ex (cu->header.length / 12,
19753 die_hash,
19754 die_eq,
19755 NULL,
19756 &cu->comp_unit_obstack,
19757 hashtab_obstack_allocate,
19758 dummy_obstack_deallocate);
19759
19760 if (has_children)
19761 comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
19762 &info_ptr, comp_unit_die);
19763 cu->dies = comp_unit_die;
19764 /* comp_unit_die is not stored in die_hash, no need. */
19765
19766 /* We try not to read any attributes in this function, because not
19767 all CUs needed for references have been loaded yet, and symbol
19768 table processing isn't initialized. But we have to set the CU language,
19769 or we won't be able to build types correctly.
19770 Similarly, if we do not read the producer, we can not apply
19771 producer-specific interpretation. */
19772 prepare_one_comp_unit (cu, cu->dies, language_minimal);
19773 }
19774
19775 /* Read in a signatured type and build its CU and DIEs.
19776 If the type is a stub for the real type in a DWO file,
19777 read in the real type from the DWO file as well. */
19778
19779 static void
19780 read_signatured_type (struct signatured_type *sig_type)
19781 {
19782 struct dwarf2_per_cu_data *per_cu = &sig_type->per_cu;
19783
19784 gdb_assert (per_cu->is_debug_types);
19785 gdb_assert (per_cu->cu == NULL);
19786
19787 init_cutu_and_read_dies (per_cu, NULL, 0, 1,
19788 read_signatured_type_reader, NULL);
19789 sig_type->per_cu.tu_read = 1;
19790 }
19791
19792 /* Decode simple location descriptions.
19793 Given a pointer to a dwarf block that defines a location, compute
19794 the location and return the value.
19795
19796 NOTE drow/2003-11-18: This function is called in two situations
19797 now: for the address of static or global variables (partial symbols
19798 only) and for offsets into structures which are expected to be
19799 (more or less) constant. The partial symbol case should go away,
19800 and only the constant case should remain. That will let this
19801 function complain more accurately. A few special modes are allowed
19802 without complaint for global variables (for instance, global
19803 register values and thread-local values).
19804
19805 A location description containing no operations indicates that the
19806 object is optimized out. The return value is 0 for that case.
19807 FIXME drow/2003-11-16: No callers check for this case any more; soon all
19808 callers will only want a very basic result and this can become a
19809 complaint.
19810
19811 Note that stack[0] is unused except as a default error return. */
19812
19813 static CORE_ADDR
19814 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
19815 {
19816 struct objfile *objfile = cu->objfile;
19817 size_t i;
19818 size_t size = blk->size;
19819 const gdb_byte *data = blk->data;
19820 CORE_ADDR stack[64];
19821 int stacki;
19822 unsigned int bytes_read, unsnd;
19823 gdb_byte op;
19824
19825 i = 0;
19826 stacki = 0;
19827 stack[stacki] = 0;
19828 stack[++stacki] = 0;
19829
19830 while (i < size)
19831 {
19832 op = data[i++];
19833 switch (op)
19834 {
19835 case DW_OP_lit0:
19836 case DW_OP_lit1:
19837 case DW_OP_lit2:
19838 case DW_OP_lit3:
19839 case DW_OP_lit4:
19840 case DW_OP_lit5:
19841 case DW_OP_lit6:
19842 case DW_OP_lit7:
19843 case DW_OP_lit8:
19844 case DW_OP_lit9:
19845 case DW_OP_lit10:
19846 case DW_OP_lit11:
19847 case DW_OP_lit12:
19848 case DW_OP_lit13:
19849 case DW_OP_lit14:
19850 case DW_OP_lit15:
19851 case DW_OP_lit16:
19852 case DW_OP_lit17:
19853 case DW_OP_lit18:
19854 case DW_OP_lit19:
19855 case DW_OP_lit20:
19856 case DW_OP_lit21:
19857 case DW_OP_lit22:
19858 case DW_OP_lit23:
19859 case DW_OP_lit24:
19860 case DW_OP_lit25:
19861 case DW_OP_lit26:
19862 case DW_OP_lit27:
19863 case DW_OP_lit28:
19864 case DW_OP_lit29:
19865 case DW_OP_lit30:
19866 case DW_OP_lit31:
19867 stack[++stacki] = op - DW_OP_lit0;
19868 break;
19869
19870 case DW_OP_reg0:
19871 case DW_OP_reg1:
19872 case DW_OP_reg2:
19873 case DW_OP_reg3:
19874 case DW_OP_reg4:
19875 case DW_OP_reg5:
19876 case DW_OP_reg6:
19877 case DW_OP_reg7:
19878 case DW_OP_reg8:
19879 case DW_OP_reg9:
19880 case DW_OP_reg10:
19881 case DW_OP_reg11:
19882 case DW_OP_reg12:
19883 case DW_OP_reg13:
19884 case DW_OP_reg14:
19885 case DW_OP_reg15:
19886 case DW_OP_reg16:
19887 case DW_OP_reg17:
19888 case DW_OP_reg18:
19889 case DW_OP_reg19:
19890 case DW_OP_reg20:
19891 case DW_OP_reg21:
19892 case DW_OP_reg22:
19893 case DW_OP_reg23:
19894 case DW_OP_reg24:
19895 case DW_OP_reg25:
19896 case DW_OP_reg26:
19897 case DW_OP_reg27:
19898 case DW_OP_reg28:
19899 case DW_OP_reg29:
19900 case DW_OP_reg30:
19901 case DW_OP_reg31:
19902 stack[++stacki] = op - DW_OP_reg0;
19903 if (i < size)
19904 dwarf2_complex_location_expr_complaint ();
19905 break;
19906
19907 case DW_OP_regx:
19908 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
19909 i += bytes_read;
19910 stack[++stacki] = unsnd;
19911 if (i < size)
19912 dwarf2_complex_location_expr_complaint ();
19913 break;
19914
19915 case DW_OP_addr:
19916 stack[++stacki] = read_address (objfile->obfd, &data[i],
19917 cu, &bytes_read);
19918 i += bytes_read;
19919 break;
19920
19921 case DW_OP_const1u:
19922 stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
19923 i += 1;
19924 break;
19925
19926 case DW_OP_const1s:
19927 stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
19928 i += 1;
19929 break;
19930
19931 case DW_OP_const2u:
19932 stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
19933 i += 2;
19934 break;
19935
19936 case DW_OP_const2s:
19937 stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
19938 i += 2;
19939 break;
19940
19941 case DW_OP_const4u:
19942 stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
19943 i += 4;
19944 break;
19945
19946 case DW_OP_const4s:
19947 stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
19948 i += 4;
19949 break;
19950
19951 case DW_OP_const8u:
19952 stack[++stacki] = read_8_bytes (objfile->obfd, &data[i]);
19953 i += 8;
19954 break;
19955
19956 case DW_OP_constu:
19957 stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
19958 &bytes_read);
19959 i += bytes_read;
19960 break;
19961
19962 case DW_OP_consts:
19963 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
19964 i += bytes_read;
19965 break;
19966
19967 case DW_OP_dup:
19968 stack[stacki + 1] = stack[stacki];
19969 stacki++;
19970 break;
19971
19972 case DW_OP_plus:
19973 stack[stacki - 1] += stack[stacki];
19974 stacki--;
19975 break;
19976
19977 case DW_OP_plus_uconst:
19978 stack[stacki] += read_unsigned_leb128 (NULL, (data + i),
19979 &bytes_read);
19980 i += bytes_read;
19981 break;
19982
19983 case DW_OP_minus:
19984 stack[stacki - 1] -= stack[stacki];
19985 stacki--;
19986 break;
19987
19988 case DW_OP_deref:
19989 /* If we're not the last op, then we definitely can't encode
19990 this using GDB's address_class enum. This is valid for partial
19991 global symbols, although the variable's address will be bogus
19992 in the psymtab. */
19993 if (i < size)
19994 dwarf2_complex_location_expr_complaint ();
19995 break;
19996
19997 case DW_OP_GNU_push_tls_address:
19998 /* The top of the stack has the offset from the beginning
19999 of the thread control block at which the variable is located. */
20000 /* Nothing should follow this operator, so the top of stack would
20001 be returned. */
20002 /* This is valid for partial global symbols, but the variable's
20003 address will be bogus in the psymtab. Make it always at least
20004 non-zero to not look as a variable garbage collected by linker
20005 which have DW_OP_addr 0. */
20006 if (i < size)
20007 dwarf2_complex_location_expr_complaint ();
20008 stack[stacki]++;
20009 break;
20010
20011 case DW_OP_GNU_uninit:
20012 break;
20013
20014 case DW_OP_GNU_addr_index:
20015 case DW_OP_GNU_const_index:
20016 stack[++stacki] = read_addr_index_from_leb128 (cu, &data[i],
20017 &bytes_read);
20018 i += bytes_read;
20019 break;
20020
20021 default:
20022 {
20023 const char *name = get_DW_OP_name (op);
20024
20025 if (name)
20026 complaint (&symfile_complaints, _("unsupported stack op: '%s'"),
20027 name);
20028 else
20029 complaint (&symfile_complaints, _("unsupported stack op: '%02x'"),
20030 op);
20031 }
20032
20033 return (stack[stacki]);
20034 }
20035
20036 /* Enforce maximum stack depth of SIZE-1 to avoid writing
20037 outside of the allocated space. Also enforce minimum>0. */
20038 if (stacki >= ARRAY_SIZE (stack) - 1)
20039 {
20040 complaint (&symfile_complaints,
20041 _("location description stack overflow"));
20042 return 0;
20043 }
20044
20045 if (stacki <= 0)
20046 {
20047 complaint (&symfile_complaints,
20048 _("location description stack underflow"));
20049 return 0;
20050 }
20051 }
20052 return (stack[stacki]);
20053 }
20054
20055 /* memory allocation interface */
20056
20057 static struct dwarf_block *
20058 dwarf_alloc_block (struct dwarf2_cu *cu)
20059 {
20060 struct dwarf_block *blk;
20061
20062 blk = (struct dwarf_block *)
20063 obstack_alloc (&cu->comp_unit_obstack, sizeof (struct dwarf_block));
20064 return (blk);
20065 }
20066
20067 static struct die_info *
20068 dwarf_alloc_die (struct dwarf2_cu *cu, int num_attrs)
20069 {
20070 struct die_info *die;
20071 size_t size = sizeof (struct die_info);
20072
20073 if (num_attrs > 1)
20074 size += (num_attrs - 1) * sizeof (struct attribute);
20075
20076 die = (struct die_info *) obstack_alloc (&cu->comp_unit_obstack, size);
20077 memset (die, 0, sizeof (struct die_info));
20078 return (die);
20079 }
20080
20081 \f
20082 /* Macro support. */
20083
20084 /* Return file name relative to the compilation directory of file number I in
20085 *LH's file name table. The result is allocated using xmalloc; the caller is
20086 responsible for freeing it. */
20087
20088 static char *
20089 file_file_name (int file, struct line_header *lh)
20090 {
20091 /* Is the file number a valid index into the line header's file name
20092 table? Remember that file numbers start with one, not zero. */
20093 if (1 <= file && file <= lh->num_file_names)
20094 {
20095 struct file_entry *fe = &lh->file_names[file - 1];
20096
20097 if (IS_ABSOLUTE_PATH (fe->name) || fe->dir_index == 0)
20098 return xstrdup (fe->name);
20099 return concat (lh->include_dirs[fe->dir_index - 1], SLASH_STRING,
20100 fe->name, NULL);
20101 }
20102 else
20103 {
20104 /* The compiler produced a bogus file number. We can at least
20105 record the macro definitions made in the file, even if we
20106 won't be able to find the file by name. */
20107 char fake_name[80];
20108
20109 xsnprintf (fake_name, sizeof (fake_name),
20110 "<bad macro file number %d>", file);
20111
20112 complaint (&symfile_complaints,
20113 _("bad file number in macro information (%d)"),
20114 file);
20115
20116 return xstrdup (fake_name);
20117 }
20118 }
20119
20120 /* Return the full name of file number I in *LH's file name table.
20121 Use COMP_DIR as the name of the current directory of the
20122 compilation. The result is allocated using xmalloc; the caller is
20123 responsible for freeing it. */
20124 static char *
20125 file_full_name (int file, struct line_header *lh, const char *comp_dir)
20126 {
20127 /* Is the file number a valid index into the line header's file name
20128 table? Remember that file numbers start with one, not zero. */
20129 if (1 <= file && file <= lh->num_file_names)
20130 {
20131 char *relative = file_file_name (file, lh);
20132
20133 if (IS_ABSOLUTE_PATH (relative) || comp_dir == NULL)
20134 return relative;
20135 return reconcat (relative, comp_dir, SLASH_STRING, relative, NULL);
20136 }
20137 else
20138 return file_file_name (file, lh);
20139 }
20140
20141
20142 static struct macro_source_file *
20143 macro_start_file (int file, int line,
20144 struct macro_source_file *current_file,
20145 const char *comp_dir,
20146 struct line_header *lh, struct objfile *objfile)
20147 {
20148 /* File name relative to the compilation directory of this source file. */
20149 char *file_name = file_file_name (file, lh);
20150
20151 if (! current_file)
20152 {
20153 /* Note: We don't create a macro table for this compilation unit
20154 at all until we actually get a filename. */
20155 struct macro_table *macro_table = get_macro_table (objfile, comp_dir);
20156
20157 /* If we have no current file, then this must be the start_file
20158 directive for the compilation unit's main source file. */
20159 current_file = macro_set_main (macro_table, file_name);
20160 macro_define_special (macro_table);
20161 }
20162 else
20163 current_file = macro_include (current_file, line, file_name);
20164
20165 xfree (file_name);
20166
20167 return current_file;
20168 }
20169
20170
20171 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
20172 followed by a null byte. */
20173 static char *
20174 copy_string (const char *buf, int len)
20175 {
20176 char *s = xmalloc (len + 1);
20177
20178 memcpy (s, buf, len);
20179 s[len] = '\0';
20180 return s;
20181 }
20182
20183
20184 static const char *
20185 consume_improper_spaces (const char *p, const char *body)
20186 {
20187 if (*p == ' ')
20188 {
20189 complaint (&symfile_complaints,
20190 _("macro definition contains spaces "
20191 "in formal argument list:\n`%s'"),
20192 body);
20193
20194 while (*p == ' ')
20195 p++;
20196 }
20197
20198 return p;
20199 }
20200
20201
20202 static void
20203 parse_macro_definition (struct macro_source_file *file, int line,
20204 const char *body)
20205 {
20206 const char *p;
20207
20208 /* The body string takes one of two forms. For object-like macro
20209 definitions, it should be:
20210
20211 <macro name> " " <definition>
20212
20213 For function-like macro definitions, it should be:
20214
20215 <macro name> "() " <definition>
20216 or
20217 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
20218
20219 Spaces may appear only where explicitly indicated, and in the
20220 <definition>.
20221
20222 The Dwarf 2 spec says that an object-like macro's name is always
20223 followed by a space, but versions of GCC around March 2002 omit
20224 the space when the macro's definition is the empty string.
20225
20226 The Dwarf 2 spec says that there should be no spaces between the
20227 formal arguments in a function-like macro's formal argument list,
20228 but versions of GCC around March 2002 include spaces after the
20229 commas. */
20230
20231
20232 /* Find the extent of the macro name. The macro name is terminated
20233 by either a space or null character (for an object-like macro) or
20234 an opening paren (for a function-like macro). */
20235 for (p = body; *p; p++)
20236 if (*p == ' ' || *p == '(')
20237 break;
20238
20239 if (*p == ' ' || *p == '\0')
20240 {
20241 /* It's an object-like macro. */
20242 int name_len = p - body;
20243 char *name = copy_string (body, name_len);
20244 const char *replacement;
20245
20246 if (*p == ' ')
20247 replacement = body + name_len + 1;
20248 else
20249 {
20250 dwarf2_macro_malformed_definition_complaint (body);
20251 replacement = body + name_len;
20252 }
20253
20254 macro_define_object (file, line, name, replacement);
20255
20256 xfree (name);
20257 }
20258 else if (*p == '(')
20259 {
20260 /* It's a function-like macro. */
20261 char *name = copy_string (body, p - body);
20262 int argc = 0;
20263 int argv_size = 1;
20264 char **argv = xmalloc (argv_size * sizeof (*argv));
20265
20266 p++;
20267
20268 p = consume_improper_spaces (p, body);
20269
20270 /* Parse the formal argument list. */
20271 while (*p && *p != ')')
20272 {
20273 /* Find the extent of the current argument name. */
20274 const char *arg_start = p;
20275
20276 while (*p && *p != ',' && *p != ')' && *p != ' ')
20277 p++;
20278
20279 if (! *p || p == arg_start)
20280 dwarf2_macro_malformed_definition_complaint (body);
20281 else
20282 {
20283 /* Make sure argv has room for the new argument. */
20284 if (argc >= argv_size)
20285 {
20286 argv_size *= 2;
20287 argv = xrealloc (argv, argv_size * sizeof (*argv));
20288 }
20289
20290 argv[argc++] = copy_string (arg_start, p - arg_start);
20291 }
20292
20293 p = consume_improper_spaces (p, body);
20294
20295 /* Consume the comma, if present. */
20296 if (*p == ',')
20297 {
20298 p++;
20299
20300 p = consume_improper_spaces (p, body);
20301 }
20302 }
20303
20304 if (*p == ')')
20305 {
20306 p++;
20307
20308 if (*p == ' ')
20309 /* Perfectly formed definition, no complaints. */
20310 macro_define_function (file, line, name,
20311 argc, (const char **) argv,
20312 p + 1);
20313 else if (*p == '\0')
20314 {
20315 /* Complain, but do define it. */
20316 dwarf2_macro_malformed_definition_complaint (body);
20317 macro_define_function (file, line, name,
20318 argc, (const char **) argv,
20319 p);
20320 }
20321 else
20322 /* Just complain. */
20323 dwarf2_macro_malformed_definition_complaint (body);
20324 }
20325 else
20326 /* Just complain. */
20327 dwarf2_macro_malformed_definition_complaint (body);
20328
20329 xfree (name);
20330 {
20331 int i;
20332
20333 for (i = 0; i < argc; i++)
20334 xfree (argv[i]);
20335 }
20336 xfree (argv);
20337 }
20338 else
20339 dwarf2_macro_malformed_definition_complaint (body);
20340 }
20341
20342 /* Skip some bytes from BYTES according to the form given in FORM.
20343 Returns the new pointer. */
20344
20345 static const gdb_byte *
20346 skip_form_bytes (bfd *abfd, const gdb_byte *bytes, const gdb_byte *buffer_end,
20347 enum dwarf_form form,
20348 unsigned int offset_size,
20349 struct dwarf2_section_info *section)
20350 {
20351 unsigned int bytes_read;
20352
20353 switch (form)
20354 {
20355 case DW_FORM_data1:
20356 case DW_FORM_flag:
20357 ++bytes;
20358 break;
20359
20360 case DW_FORM_data2:
20361 bytes += 2;
20362 break;
20363
20364 case DW_FORM_data4:
20365 bytes += 4;
20366 break;
20367
20368 case DW_FORM_data8:
20369 bytes += 8;
20370 break;
20371
20372 case DW_FORM_string:
20373 read_direct_string (abfd, bytes, &bytes_read);
20374 bytes += bytes_read;
20375 break;
20376
20377 case DW_FORM_sec_offset:
20378 case DW_FORM_strp:
20379 case DW_FORM_GNU_strp_alt:
20380 bytes += offset_size;
20381 break;
20382
20383 case DW_FORM_block:
20384 bytes += read_unsigned_leb128 (abfd, bytes, &bytes_read);
20385 bytes += bytes_read;
20386 break;
20387
20388 case DW_FORM_block1:
20389 bytes += 1 + read_1_byte (abfd, bytes);
20390 break;
20391 case DW_FORM_block2:
20392 bytes += 2 + read_2_bytes (abfd, bytes);
20393 break;
20394 case DW_FORM_block4:
20395 bytes += 4 + read_4_bytes (abfd, bytes);
20396 break;
20397
20398 case DW_FORM_sdata:
20399 case DW_FORM_udata:
20400 case DW_FORM_GNU_addr_index:
20401 case DW_FORM_GNU_str_index:
20402 bytes = gdb_skip_leb128 (bytes, buffer_end);
20403 if (bytes == NULL)
20404 {
20405 dwarf2_section_buffer_overflow_complaint (section);
20406 return NULL;
20407 }
20408 break;
20409
20410 default:
20411 {
20412 complain:
20413 complaint (&symfile_complaints,
20414 _("invalid form 0x%x in `%s'"),
20415 form, get_section_name (section));
20416 return NULL;
20417 }
20418 }
20419
20420 return bytes;
20421 }
20422
20423 /* A helper for dwarf_decode_macros that handles skipping an unknown
20424 opcode. Returns an updated pointer to the macro data buffer; or,
20425 on error, issues a complaint and returns NULL. */
20426
20427 static const gdb_byte *
20428 skip_unknown_opcode (unsigned int opcode,
20429 const gdb_byte **opcode_definitions,
20430 const gdb_byte *mac_ptr, const gdb_byte *mac_end,
20431 bfd *abfd,
20432 unsigned int offset_size,
20433 struct dwarf2_section_info *section)
20434 {
20435 unsigned int bytes_read, i;
20436 unsigned long arg;
20437 const gdb_byte *defn;
20438
20439 if (opcode_definitions[opcode] == NULL)
20440 {
20441 complaint (&symfile_complaints,
20442 _("unrecognized DW_MACFINO opcode 0x%x"),
20443 opcode);
20444 return NULL;
20445 }
20446
20447 defn = opcode_definitions[opcode];
20448 arg = read_unsigned_leb128 (abfd, defn, &bytes_read);
20449 defn += bytes_read;
20450
20451 for (i = 0; i < arg; ++i)
20452 {
20453 mac_ptr = skip_form_bytes (abfd, mac_ptr, mac_end, defn[i], offset_size,
20454 section);
20455 if (mac_ptr == NULL)
20456 {
20457 /* skip_form_bytes already issued the complaint. */
20458 return NULL;
20459 }
20460 }
20461
20462 return mac_ptr;
20463 }
20464
20465 /* A helper function which parses the header of a macro section.
20466 If the macro section is the extended (for now called "GNU") type,
20467 then this updates *OFFSET_SIZE. Returns a pointer to just after
20468 the header, or issues a complaint and returns NULL on error. */
20469
20470 static const gdb_byte *
20471 dwarf_parse_macro_header (const gdb_byte **opcode_definitions,
20472 bfd *abfd,
20473 const gdb_byte *mac_ptr,
20474 unsigned int *offset_size,
20475 int section_is_gnu)
20476 {
20477 memset (opcode_definitions, 0, 256 * sizeof (gdb_byte *));
20478
20479 if (section_is_gnu)
20480 {
20481 unsigned int version, flags;
20482
20483 version = read_2_bytes (abfd, mac_ptr);
20484 if (version != 4)
20485 {
20486 complaint (&symfile_complaints,
20487 _("unrecognized version `%d' in .debug_macro section"),
20488 version);
20489 return NULL;
20490 }
20491 mac_ptr += 2;
20492
20493 flags = read_1_byte (abfd, mac_ptr);
20494 ++mac_ptr;
20495 *offset_size = (flags & 1) ? 8 : 4;
20496
20497 if ((flags & 2) != 0)
20498 /* We don't need the line table offset. */
20499 mac_ptr += *offset_size;
20500
20501 /* Vendor opcode descriptions. */
20502 if ((flags & 4) != 0)
20503 {
20504 unsigned int i, count;
20505
20506 count = read_1_byte (abfd, mac_ptr);
20507 ++mac_ptr;
20508 for (i = 0; i < count; ++i)
20509 {
20510 unsigned int opcode, bytes_read;
20511 unsigned long arg;
20512
20513 opcode = read_1_byte (abfd, mac_ptr);
20514 ++mac_ptr;
20515 opcode_definitions[opcode] = mac_ptr;
20516 arg = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20517 mac_ptr += bytes_read;
20518 mac_ptr += arg;
20519 }
20520 }
20521 }
20522
20523 return mac_ptr;
20524 }
20525
20526 /* A helper for dwarf_decode_macros that handles the GNU extensions,
20527 including DW_MACRO_GNU_transparent_include. */
20528
20529 static void
20530 dwarf_decode_macro_bytes (bfd *abfd,
20531 const gdb_byte *mac_ptr, const gdb_byte *mac_end,
20532 struct macro_source_file *current_file,
20533 struct line_header *lh, const char *comp_dir,
20534 struct dwarf2_section_info *section,
20535 int section_is_gnu, int section_is_dwz,
20536 unsigned int offset_size,
20537 struct objfile *objfile,
20538 htab_t include_hash)
20539 {
20540 enum dwarf_macro_record_type macinfo_type;
20541 int at_commandline;
20542 const gdb_byte *opcode_definitions[256];
20543
20544 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
20545 &offset_size, section_is_gnu);
20546 if (mac_ptr == NULL)
20547 {
20548 /* We already issued a complaint. */
20549 return;
20550 }
20551
20552 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
20553 GDB is still reading the definitions from command line. First
20554 DW_MACINFO_start_file will need to be ignored as it was already executed
20555 to create CURRENT_FILE for the main source holding also the command line
20556 definitions. On first met DW_MACINFO_start_file this flag is reset to
20557 normally execute all the remaining DW_MACINFO_start_file macinfos. */
20558
20559 at_commandline = 1;
20560
20561 do
20562 {
20563 /* Do we at least have room for a macinfo type byte? */
20564 if (mac_ptr >= mac_end)
20565 {
20566 dwarf2_section_buffer_overflow_complaint (section);
20567 break;
20568 }
20569
20570 macinfo_type = read_1_byte (abfd, mac_ptr);
20571 mac_ptr++;
20572
20573 /* Note that we rely on the fact that the corresponding GNU and
20574 DWARF constants are the same. */
20575 switch (macinfo_type)
20576 {
20577 /* A zero macinfo type indicates the end of the macro
20578 information. */
20579 case 0:
20580 break;
20581
20582 case DW_MACRO_GNU_define:
20583 case DW_MACRO_GNU_undef:
20584 case DW_MACRO_GNU_define_indirect:
20585 case DW_MACRO_GNU_undef_indirect:
20586 case DW_MACRO_GNU_define_indirect_alt:
20587 case DW_MACRO_GNU_undef_indirect_alt:
20588 {
20589 unsigned int bytes_read;
20590 int line;
20591 const char *body;
20592 int is_define;
20593
20594 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20595 mac_ptr += bytes_read;
20596
20597 if (macinfo_type == DW_MACRO_GNU_define
20598 || macinfo_type == DW_MACRO_GNU_undef)
20599 {
20600 body = read_direct_string (abfd, mac_ptr, &bytes_read);
20601 mac_ptr += bytes_read;
20602 }
20603 else
20604 {
20605 LONGEST str_offset;
20606
20607 str_offset = read_offset_1 (abfd, mac_ptr, offset_size);
20608 mac_ptr += offset_size;
20609
20610 if (macinfo_type == DW_MACRO_GNU_define_indirect_alt
20611 || macinfo_type == DW_MACRO_GNU_undef_indirect_alt
20612 || section_is_dwz)
20613 {
20614 struct dwz_file *dwz = dwarf2_get_dwz_file ();
20615
20616 body = read_indirect_string_from_dwz (dwz, str_offset);
20617 }
20618 else
20619 body = read_indirect_string_at_offset (abfd, str_offset);
20620 }
20621
20622 is_define = (macinfo_type == DW_MACRO_GNU_define
20623 || macinfo_type == DW_MACRO_GNU_define_indirect
20624 || macinfo_type == DW_MACRO_GNU_define_indirect_alt);
20625 if (! current_file)
20626 {
20627 /* DWARF violation as no main source is present. */
20628 complaint (&symfile_complaints,
20629 _("debug info with no main source gives macro %s "
20630 "on line %d: %s"),
20631 is_define ? _("definition") : _("undefinition"),
20632 line, body);
20633 break;
20634 }
20635 if ((line == 0 && !at_commandline)
20636 || (line != 0 && at_commandline))
20637 complaint (&symfile_complaints,
20638 _("debug info gives %s macro %s with %s line %d: %s"),
20639 at_commandline ? _("command-line") : _("in-file"),
20640 is_define ? _("definition") : _("undefinition"),
20641 line == 0 ? _("zero") : _("non-zero"), line, body);
20642
20643 if (is_define)
20644 parse_macro_definition (current_file, line, body);
20645 else
20646 {
20647 gdb_assert (macinfo_type == DW_MACRO_GNU_undef
20648 || macinfo_type == DW_MACRO_GNU_undef_indirect
20649 || macinfo_type == DW_MACRO_GNU_undef_indirect_alt);
20650 macro_undef (current_file, line, body);
20651 }
20652 }
20653 break;
20654
20655 case DW_MACRO_GNU_start_file:
20656 {
20657 unsigned int bytes_read;
20658 int line, file;
20659
20660 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20661 mac_ptr += bytes_read;
20662 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20663 mac_ptr += bytes_read;
20664
20665 if ((line == 0 && !at_commandline)
20666 || (line != 0 && at_commandline))
20667 complaint (&symfile_complaints,
20668 _("debug info gives source %d included "
20669 "from %s at %s line %d"),
20670 file, at_commandline ? _("command-line") : _("file"),
20671 line == 0 ? _("zero") : _("non-zero"), line);
20672
20673 if (at_commandline)
20674 {
20675 /* This DW_MACRO_GNU_start_file was executed in the
20676 pass one. */
20677 at_commandline = 0;
20678 }
20679 else
20680 current_file = macro_start_file (file, line,
20681 current_file, comp_dir,
20682 lh, objfile);
20683 }
20684 break;
20685
20686 case DW_MACRO_GNU_end_file:
20687 if (! current_file)
20688 complaint (&symfile_complaints,
20689 _("macro debug info has an unmatched "
20690 "`close_file' directive"));
20691 else
20692 {
20693 current_file = current_file->included_by;
20694 if (! current_file)
20695 {
20696 enum dwarf_macro_record_type next_type;
20697
20698 /* GCC circa March 2002 doesn't produce the zero
20699 type byte marking the end of the compilation
20700 unit. Complain if it's not there, but exit no
20701 matter what. */
20702
20703 /* Do we at least have room for a macinfo type byte? */
20704 if (mac_ptr >= mac_end)
20705 {
20706 dwarf2_section_buffer_overflow_complaint (section);
20707 return;
20708 }
20709
20710 /* We don't increment mac_ptr here, so this is just
20711 a look-ahead. */
20712 next_type = read_1_byte (abfd, mac_ptr);
20713 if (next_type != 0)
20714 complaint (&symfile_complaints,
20715 _("no terminating 0-type entry for "
20716 "macros in `.debug_macinfo' section"));
20717
20718 return;
20719 }
20720 }
20721 break;
20722
20723 case DW_MACRO_GNU_transparent_include:
20724 case DW_MACRO_GNU_transparent_include_alt:
20725 {
20726 LONGEST offset;
20727 void **slot;
20728 bfd *include_bfd = abfd;
20729 struct dwarf2_section_info *include_section = section;
20730 struct dwarf2_section_info alt_section;
20731 const gdb_byte *include_mac_end = mac_end;
20732 int is_dwz = section_is_dwz;
20733 const gdb_byte *new_mac_ptr;
20734
20735 offset = read_offset_1 (abfd, mac_ptr, offset_size);
20736 mac_ptr += offset_size;
20737
20738 if (macinfo_type == DW_MACRO_GNU_transparent_include_alt)
20739 {
20740 struct dwz_file *dwz = dwarf2_get_dwz_file ();
20741
20742 dwarf2_read_section (dwarf2_per_objfile->objfile,
20743 &dwz->macro);
20744
20745 include_section = &dwz->macro;
20746 include_bfd = get_section_bfd_owner (include_section);
20747 include_mac_end = dwz->macro.buffer + dwz->macro.size;
20748 is_dwz = 1;
20749 }
20750
20751 new_mac_ptr = include_section->buffer + offset;
20752 slot = htab_find_slot (include_hash, new_mac_ptr, INSERT);
20753
20754 if (*slot != NULL)
20755 {
20756 /* This has actually happened; see
20757 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
20758 complaint (&symfile_complaints,
20759 _("recursive DW_MACRO_GNU_transparent_include in "
20760 ".debug_macro section"));
20761 }
20762 else
20763 {
20764 *slot = (void *) new_mac_ptr;
20765
20766 dwarf_decode_macro_bytes (include_bfd, new_mac_ptr,
20767 include_mac_end, current_file,
20768 lh, comp_dir,
20769 section, section_is_gnu, is_dwz,
20770 offset_size, objfile, include_hash);
20771
20772 htab_remove_elt (include_hash, (void *) new_mac_ptr);
20773 }
20774 }
20775 break;
20776
20777 case DW_MACINFO_vendor_ext:
20778 if (!section_is_gnu)
20779 {
20780 unsigned int bytes_read;
20781 int constant;
20782
20783 constant = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20784 mac_ptr += bytes_read;
20785 read_direct_string (abfd, mac_ptr, &bytes_read);
20786 mac_ptr += bytes_read;
20787
20788 /* We don't recognize any vendor extensions. */
20789 break;
20790 }
20791 /* FALLTHROUGH */
20792
20793 default:
20794 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
20795 mac_ptr, mac_end, abfd, offset_size,
20796 section);
20797 if (mac_ptr == NULL)
20798 return;
20799 break;
20800 }
20801 } while (macinfo_type != 0);
20802 }
20803
20804 static void
20805 dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset,
20806 const char *comp_dir, int section_is_gnu)
20807 {
20808 struct objfile *objfile = dwarf2_per_objfile->objfile;
20809 struct line_header *lh = cu->line_header;
20810 bfd *abfd;
20811 const gdb_byte *mac_ptr, *mac_end;
20812 struct macro_source_file *current_file = 0;
20813 enum dwarf_macro_record_type macinfo_type;
20814 unsigned int offset_size = cu->header.offset_size;
20815 const gdb_byte *opcode_definitions[256];
20816 struct cleanup *cleanup;
20817 htab_t include_hash;
20818 void **slot;
20819 struct dwarf2_section_info *section;
20820 const char *section_name;
20821
20822 if (cu->dwo_unit != NULL)
20823 {
20824 if (section_is_gnu)
20825 {
20826 section = &cu->dwo_unit->dwo_file->sections.macro;
20827 section_name = ".debug_macro.dwo";
20828 }
20829 else
20830 {
20831 section = &cu->dwo_unit->dwo_file->sections.macinfo;
20832 section_name = ".debug_macinfo.dwo";
20833 }
20834 }
20835 else
20836 {
20837 if (section_is_gnu)
20838 {
20839 section = &dwarf2_per_objfile->macro;
20840 section_name = ".debug_macro";
20841 }
20842 else
20843 {
20844 section = &dwarf2_per_objfile->macinfo;
20845 section_name = ".debug_macinfo";
20846 }
20847 }
20848
20849 dwarf2_read_section (objfile, section);
20850 if (section->buffer == NULL)
20851 {
20852 complaint (&symfile_complaints, _("missing %s section"), section_name);
20853 return;
20854 }
20855 abfd = get_section_bfd_owner (section);
20856
20857 /* First pass: Find the name of the base filename.
20858 This filename is needed in order to process all macros whose definition
20859 (or undefinition) comes from the command line. These macros are defined
20860 before the first DW_MACINFO_start_file entry, and yet still need to be
20861 associated to the base file.
20862
20863 To determine the base file name, we scan the macro definitions until we
20864 reach the first DW_MACINFO_start_file entry. We then initialize
20865 CURRENT_FILE accordingly so that any macro definition found before the
20866 first DW_MACINFO_start_file can still be associated to the base file. */
20867
20868 mac_ptr = section->buffer + offset;
20869 mac_end = section->buffer + section->size;
20870
20871 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
20872 &offset_size, section_is_gnu);
20873 if (mac_ptr == NULL)
20874 {
20875 /* We already issued a complaint. */
20876 return;
20877 }
20878
20879 do
20880 {
20881 /* Do we at least have room for a macinfo type byte? */
20882 if (mac_ptr >= mac_end)
20883 {
20884 /* Complaint is printed during the second pass as GDB will probably
20885 stop the first pass earlier upon finding
20886 DW_MACINFO_start_file. */
20887 break;
20888 }
20889
20890 macinfo_type = read_1_byte (abfd, mac_ptr);
20891 mac_ptr++;
20892
20893 /* Note that we rely on the fact that the corresponding GNU and
20894 DWARF constants are the same. */
20895 switch (macinfo_type)
20896 {
20897 /* A zero macinfo type indicates the end of the macro
20898 information. */
20899 case 0:
20900 break;
20901
20902 case DW_MACRO_GNU_define:
20903 case DW_MACRO_GNU_undef:
20904 /* Only skip the data by MAC_PTR. */
20905 {
20906 unsigned int bytes_read;
20907
20908 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20909 mac_ptr += bytes_read;
20910 read_direct_string (abfd, mac_ptr, &bytes_read);
20911 mac_ptr += bytes_read;
20912 }
20913 break;
20914
20915 case DW_MACRO_GNU_start_file:
20916 {
20917 unsigned int bytes_read;
20918 int line, file;
20919
20920 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20921 mac_ptr += bytes_read;
20922 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20923 mac_ptr += bytes_read;
20924
20925 current_file = macro_start_file (file, line, current_file,
20926 comp_dir, lh, objfile);
20927 }
20928 break;
20929
20930 case DW_MACRO_GNU_end_file:
20931 /* No data to skip by MAC_PTR. */
20932 break;
20933
20934 case DW_MACRO_GNU_define_indirect:
20935 case DW_MACRO_GNU_undef_indirect:
20936 case DW_MACRO_GNU_define_indirect_alt:
20937 case DW_MACRO_GNU_undef_indirect_alt:
20938 {
20939 unsigned int bytes_read;
20940
20941 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20942 mac_ptr += bytes_read;
20943 mac_ptr += offset_size;
20944 }
20945 break;
20946
20947 case DW_MACRO_GNU_transparent_include:
20948 case DW_MACRO_GNU_transparent_include_alt:
20949 /* Note that, according to the spec, a transparent include
20950 chain cannot call DW_MACRO_GNU_start_file. So, we can just
20951 skip this opcode. */
20952 mac_ptr += offset_size;
20953 break;
20954
20955 case DW_MACINFO_vendor_ext:
20956 /* Only skip the data by MAC_PTR. */
20957 if (!section_is_gnu)
20958 {
20959 unsigned int bytes_read;
20960
20961 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20962 mac_ptr += bytes_read;
20963 read_direct_string (abfd, mac_ptr, &bytes_read);
20964 mac_ptr += bytes_read;
20965 }
20966 /* FALLTHROUGH */
20967
20968 default:
20969 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
20970 mac_ptr, mac_end, abfd, offset_size,
20971 section);
20972 if (mac_ptr == NULL)
20973 return;
20974 break;
20975 }
20976 } while (macinfo_type != 0 && current_file == NULL);
20977
20978 /* Second pass: Process all entries.
20979
20980 Use the AT_COMMAND_LINE flag to determine whether we are still processing
20981 command-line macro definitions/undefinitions. This flag is unset when we
20982 reach the first DW_MACINFO_start_file entry. */
20983
20984 include_hash = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
20985 NULL, xcalloc, xfree);
20986 cleanup = make_cleanup_htab_delete (include_hash);
20987 mac_ptr = section->buffer + offset;
20988 slot = htab_find_slot (include_hash, mac_ptr, INSERT);
20989 *slot = (void *) mac_ptr;
20990 dwarf_decode_macro_bytes (abfd, mac_ptr, mac_end,
20991 current_file, lh, comp_dir, section,
20992 section_is_gnu, 0,
20993 offset_size, objfile, include_hash);
20994 do_cleanups (cleanup);
20995 }
20996
20997 /* Check if the attribute's form is a DW_FORM_block*
20998 if so return true else false. */
20999
21000 static int
21001 attr_form_is_block (const struct attribute *attr)
21002 {
21003 return (attr == NULL ? 0 :
21004 attr->form == DW_FORM_block1
21005 || attr->form == DW_FORM_block2
21006 || attr->form == DW_FORM_block4
21007 || attr->form == DW_FORM_block
21008 || attr->form == DW_FORM_exprloc);
21009 }
21010
21011 /* Return non-zero if ATTR's value is a section offset --- classes
21012 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
21013 You may use DW_UNSND (attr) to retrieve such offsets.
21014
21015 Section 7.5.4, "Attribute Encodings", explains that no attribute
21016 may have a value that belongs to more than one of these classes; it
21017 would be ambiguous if we did, because we use the same forms for all
21018 of them. */
21019
21020 static int
21021 attr_form_is_section_offset (const struct attribute *attr)
21022 {
21023 return (attr->form == DW_FORM_data4
21024 || attr->form == DW_FORM_data8
21025 || attr->form == DW_FORM_sec_offset);
21026 }
21027
21028 /* Return non-zero if ATTR's value falls in the 'constant' class, or
21029 zero otherwise. When this function returns true, you can apply
21030 dwarf2_get_attr_constant_value to it.
21031
21032 However, note that for some attributes you must check
21033 attr_form_is_section_offset before using this test. DW_FORM_data4
21034 and DW_FORM_data8 are members of both the constant class, and of
21035 the classes that contain offsets into other debug sections
21036 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
21037 that, if an attribute's can be either a constant or one of the
21038 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
21039 taken as section offsets, not constants. */
21040
21041 static int
21042 attr_form_is_constant (const struct attribute *attr)
21043 {
21044 switch (attr->form)
21045 {
21046 case DW_FORM_sdata:
21047 case DW_FORM_udata:
21048 case DW_FORM_data1:
21049 case DW_FORM_data2:
21050 case DW_FORM_data4:
21051 case DW_FORM_data8:
21052 return 1;
21053 default:
21054 return 0;
21055 }
21056 }
21057
21058
21059 /* DW_ADDR is always stored already as sect_offset; despite for the forms
21060 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
21061
21062 static int
21063 attr_form_is_ref (const struct attribute *attr)
21064 {
21065 switch (attr->form)
21066 {
21067 case DW_FORM_ref_addr:
21068 case DW_FORM_ref1:
21069 case DW_FORM_ref2:
21070 case DW_FORM_ref4:
21071 case DW_FORM_ref8:
21072 case DW_FORM_ref_udata:
21073 case DW_FORM_GNU_ref_alt:
21074 return 1;
21075 default:
21076 return 0;
21077 }
21078 }
21079
21080 /* Return the .debug_loc section to use for CU.
21081 For DWO files use .debug_loc.dwo. */
21082
21083 static struct dwarf2_section_info *
21084 cu_debug_loc_section (struct dwarf2_cu *cu)
21085 {
21086 if (cu->dwo_unit)
21087 return &cu->dwo_unit->dwo_file->sections.loc;
21088 return &dwarf2_per_objfile->loc;
21089 }
21090
21091 /* A helper function that fills in a dwarf2_loclist_baton. */
21092
21093 static void
21094 fill_in_loclist_baton (struct dwarf2_cu *cu,
21095 struct dwarf2_loclist_baton *baton,
21096 const struct attribute *attr)
21097 {
21098 struct dwarf2_section_info *section = cu_debug_loc_section (cu);
21099
21100 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
21101
21102 baton->per_cu = cu->per_cu;
21103 gdb_assert (baton->per_cu);
21104 /* We don't know how long the location list is, but make sure we
21105 don't run off the edge of the section. */
21106 baton->size = section->size - DW_UNSND (attr);
21107 baton->data = section->buffer + DW_UNSND (attr);
21108 baton->base_address = cu->base_address;
21109 baton->from_dwo = cu->dwo_unit != NULL;
21110 }
21111
21112 static void
21113 dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym,
21114 struct dwarf2_cu *cu, int is_block)
21115 {
21116 struct objfile *objfile = dwarf2_per_objfile->objfile;
21117 struct dwarf2_section_info *section = cu_debug_loc_section (cu);
21118
21119 if (attr_form_is_section_offset (attr)
21120 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
21121 the section. If so, fall through to the complaint in the
21122 other branch. */
21123 && DW_UNSND (attr) < dwarf2_section_size (objfile, section))
21124 {
21125 struct dwarf2_loclist_baton *baton;
21126
21127 baton = obstack_alloc (&objfile->objfile_obstack,
21128 sizeof (struct dwarf2_loclist_baton));
21129
21130 fill_in_loclist_baton (cu, baton, attr);
21131
21132 if (cu->base_known == 0)
21133 complaint (&symfile_complaints,
21134 _("Location list used without "
21135 "specifying the CU base address."));
21136
21137 SYMBOL_ACLASS_INDEX (sym) = (is_block
21138 ? dwarf2_loclist_block_index
21139 : dwarf2_loclist_index);
21140 SYMBOL_LOCATION_BATON (sym) = baton;
21141 }
21142 else
21143 {
21144 struct dwarf2_locexpr_baton *baton;
21145
21146 baton = obstack_alloc (&objfile->objfile_obstack,
21147 sizeof (struct dwarf2_locexpr_baton));
21148 baton->per_cu = cu->per_cu;
21149 gdb_assert (baton->per_cu);
21150
21151 if (attr_form_is_block (attr))
21152 {
21153 /* Note that we're just copying the block's data pointer
21154 here, not the actual data. We're still pointing into the
21155 info_buffer for SYM's objfile; right now we never release
21156 that buffer, but when we do clean up properly this may
21157 need to change. */
21158 baton->size = DW_BLOCK (attr)->size;
21159 baton->data = DW_BLOCK (attr)->data;
21160 }
21161 else
21162 {
21163 dwarf2_invalid_attrib_class_complaint ("location description",
21164 SYMBOL_NATURAL_NAME (sym));
21165 baton->size = 0;
21166 }
21167
21168 SYMBOL_ACLASS_INDEX (sym) = (is_block
21169 ? dwarf2_locexpr_block_index
21170 : dwarf2_locexpr_index);
21171 SYMBOL_LOCATION_BATON (sym) = baton;
21172 }
21173 }
21174
21175 /* Return the OBJFILE associated with the compilation unit CU. If CU
21176 came from a separate debuginfo file, then the master objfile is
21177 returned. */
21178
21179 struct objfile *
21180 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data *per_cu)
21181 {
21182 struct objfile *objfile = per_cu->objfile;
21183
21184 /* Return the master objfile, so that we can report and look up the
21185 correct file containing this variable. */
21186 if (objfile->separate_debug_objfile_backlink)
21187 objfile = objfile->separate_debug_objfile_backlink;
21188
21189 return objfile;
21190 }
21191
21192 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
21193 (CU_HEADERP is unused in such case) or prepare a temporary copy at
21194 CU_HEADERP first. */
21195
21196 static const struct comp_unit_head *
21197 per_cu_header_read_in (struct comp_unit_head *cu_headerp,
21198 struct dwarf2_per_cu_data *per_cu)
21199 {
21200 const gdb_byte *info_ptr;
21201
21202 if (per_cu->cu)
21203 return &per_cu->cu->header;
21204
21205 info_ptr = per_cu->section->buffer + per_cu->offset.sect_off;
21206
21207 memset (cu_headerp, 0, sizeof (*cu_headerp));
21208 read_comp_unit_head (cu_headerp, info_ptr, per_cu->objfile->obfd);
21209
21210 return cu_headerp;
21211 }
21212
21213 /* Return the address size given in the compilation unit header for CU. */
21214
21215 int
21216 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data *per_cu)
21217 {
21218 struct comp_unit_head cu_header_local;
21219 const struct comp_unit_head *cu_headerp;
21220
21221 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
21222
21223 return cu_headerp->addr_size;
21224 }
21225
21226 /* Return the offset size given in the compilation unit header for CU. */
21227
21228 int
21229 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data *per_cu)
21230 {
21231 struct comp_unit_head cu_header_local;
21232 const struct comp_unit_head *cu_headerp;
21233
21234 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
21235
21236 return cu_headerp->offset_size;
21237 }
21238
21239 /* See its dwarf2loc.h declaration. */
21240
21241 int
21242 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data *per_cu)
21243 {
21244 struct comp_unit_head cu_header_local;
21245 const struct comp_unit_head *cu_headerp;
21246
21247 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
21248
21249 if (cu_headerp->version == 2)
21250 return cu_headerp->addr_size;
21251 else
21252 return cu_headerp->offset_size;
21253 }
21254
21255 /* Return the text offset of the CU. The returned offset comes from
21256 this CU's objfile. If this objfile came from a separate debuginfo
21257 file, then the offset may be different from the corresponding
21258 offset in the parent objfile. */
21259
21260 CORE_ADDR
21261 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data *per_cu)
21262 {
21263 struct objfile *objfile = per_cu->objfile;
21264
21265 return ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
21266 }
21267
21268 /* Locate the .debug_info compilation unit from CU's objfile which contains
21269 the DIE at OFFSET. Raises an error on failure. */
21270
21271 static struct dwarf2_per_cu_data *
21272 dwarf2_find_containing_comp_unit (sect_offset offset,
21273 unsigned int offset_in_dwz,
21274 struct objfile *objfile)
21275 {
21276 struct dwarf2_per_cu_data *this_cu;
21277 int low, high;
21278 const sect_offset *cu_off;
21279
21280 low = 0;
21281 high = dwarf2_per_objfile->n_comp_units - 1;
21282 while (high > low)
21283 {
21284 struct dwarf2_per_cu_data *mid_cu;
21285 int mid = low + (high - low) / 2;
21286
21287 mid_cu = dwarf2_per_objfile->all_comp_units[mid];
21288 cu_off = &mid_cu->offset;
21289 if (mid_cu->is_dwz > offset_in_dwz
21290 || (mid_cu->is_dwz == offset_in_dwz
21291 && cu_off->sect_off >= offset.sect_off))
21292 high = mid;
21293 else
21294 low = mid + 1;
21295 }
21296 gdb_assert (low == high);
21297 this_cu = dwarf2_per_objfile->all_comp_units[low];
21298 cu_off = &this_cu->offset;
21299 if (this_cu->is_dwz != offset_in_dwz || cu_off->sect_off > offset.sect_off)
21300 {
21301 if (low == 0 || this_cu->is_dwz != offset_in_dwz)
21302 error (_("Dwarf Error: could not find partial DIE containing "
21303 "offset 0x%lx [in module %s]"),
21304 (long) offset.sect_off, bfd_get_filename (objfile->obfd));
21305
21306 gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->offset.sect_off
21307 <= offset.sect_off);
21308 return dwarf2_per_objfile->all_comp_units[low-1];
21309 }
21310 else
21311 {
21312 this_cu = dwarf2_per_objfile->all_comp_units[low];
21313 if (low == dwarf2_per_objfile->n_comp_units - 1
21314 && offset.sect_off >= this_cu->offset.sect_off + this_cu->length)
21315 error (_("invalid dwarf2 offset %u"), offset.sect_off);
21316 gdb_assert (offset.sect_off < this_cu->offset.sect_off + this_cu->length);
21317 return this_cu;
21318 }
21319 }
21320
21321 /* Initialize dwarf2_cu CU, owned by PER_CU. */
21322
21323 static void
21324 init_one_comp_unit (struct dwarf2_cu *cu, struct dwarf2_per_cu_data *per_cu)
21325 {
21326 memset (cu, 0, sizeof (*cu));
21327 per_cu->cu = cu;
21328 cu->per_cu = per_cu;
21329 cu->objfile = per_cu->objfile;
21330 obstack_init (&cu->comp_unit_obstack);
21331 }
21332
21333 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
21334
21335 static void
21336 prepare_one_comp_unit (struct dwarf2_cu *cu, struct die_info *comp_unit_die,
21337 enum language pretend_language)
21338 {
21339 struct attribute *attr;
21340
21341 /* Set the language we're debugging. */
21342 attr = dwarf2_attr (comp_unit_die, DW_AT_language, cu);
21343 if (attr)
21344 set_cu_language (DW_UNSND (attr), cu);
21345 else
21346 {
21347 cu->language = pretend_language;
21348 cu->language_defn = language_def (cu->language);
21349 }
21350
21351 attr = dwarf2_attr (comp_unit_die, DW_AT_producer, cu);
21352 if (attr)
21353 cu->producer = DW_STRING (attr);
21354 }
21355
21356 /* Release one cached compilation unit, CU. We unlink it from the tree
21357 of compilation units, but we don't remove it from the read_in_chain;
21358 the caller is responsible for that.
21359 NOTE: DATA is a void * because this function is also used as a
21360 cleanup routine. */
21361
21362 static void
21363 free_heap_comp_unit (void *data)
21364 {
21365 struct dwarf2_cu *cu = data;
21366
21367 gdb_assert (cu->per_cu != NULL);
21368 cu->per_cu->cu = NULL;
21369 cu->per_cu = NULL;
21370
21371 obstack_free (&cu->comp_unit_obstack, NULL);
21372
21373 xfree (cu);
21374 }
21375
21376 /* This cleanup function is passed the address of a dwarf2_cu on the stack
21377 when we're finished with it. We can't free the pointer itself, but be
21378 sure to unlink it from the cache. Also release any associated storage. */
21379
21380 static void
21381 free_stack_comp_unit (void *data)
21382 {
21383 struct dwarf2_cu *cu = data;
21384
21385 gdb_assert (cu->per_cu != NULL);
21386 cu->per_cu->cu = NULL;
21387 cu->per_cu = NULL;
21388
21389 obstack_free (&cu->comp_unit_obstack, NULL);
21390 cu->partial_dies = NULL;
21391 }
21392
21393 /* Free all cached compilation units. */
21394
21395 static void
21396 free_cached_comp_units (void *data)
21397 {
21398 struct dwarf2_per_cu_data *per_cu, **last_chain;
21399
21400 per_cu = dwarf2_per_objfile->read_in_chain;
21401 last_chain = &dwarf2_per_objfile->read_in_chain;
21402 while (per_cu != NULL)
21403 {
21404 struct dwarf2_per_cu_data *next_cu;
21405
21406 next_cu = per_cu->cu->read_in_chain;
21407
21408 free_heap_comp_unit (per_cu->cu);
21409 *last_chain = next_cu;
21410
21411 per_cu = next_cu;
21412 }
21413 }
21414
21415 /* Increase the age counter on each cached compilation unit, and free
21416 any that are too old. */
21417
21418 static void
21419 age_cached_comp_units (void)
21420 {
21421 struct dwarf2_per_cu_data *per_cu, **last_chain;
21422
21423 dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
21424 per_cu = dwarf2_per_objfile->read_in_chain;
21425 while (per_cu != NULL)
21426 {
21427 per_cu->cu->last_used ++;
21428 if (per_cu->cu->last_used <= dwarf2_max_cache_age)
21429 dwarf2_mark (per_cu->cu);
21430 per_cu = per_cu->cu->read_in_chain;
21431 }
21432
21433 per_cu = dwarf2_per_objfile->read_in_chain;
21434 last_chain = &dwarf2_per_objfile->read_in_chain;
21435 while (per_cu != NULL)
21436 {
21437 struct dwarf2_per_cu_data *next_cu;
21438
21439 next_cu = per_cu->cu->read_in_chain;
21440
21441 if (!per_cu->cu->mark)
21442 {
21443 free_heap_comp_unit (per_cu->cu);
21444 *last_chain = next_cu;
21445 }
21446 else
21447 last_chain = &per_cu->cu->read_in_chain;
21448
21449 per_cu = next_cu;
21450 }
21451 }
21452
21453 /* Remove a single compilation unit from the cache. */
21454
21455 static void
21456 free_one_cached_comp_unit (struct dwarf2_per_cu_data *target_per_cu)
21457 {
21458 struct dwarf2_per_cu_data *per_cu, **last_chain;
21459
21460 per_cu = dwarf2_per_objfile->read_in_chain;
21461 last_chain = &dwarf2_per_objfile->read_in_chain;
21462 while (per_cu != NULL)
21463 {
21464 struct dwarf2_per_cu_data *next_cu;
21465
21466 next_cu = per_cu->cu->read_in_chain;
21467
21468 if (per_cu == target_per_cu)
21469 {
21470 free_heap_comp_unit (per_cu->cu);
21471 per_cu->cu = NULL;
21472 *last_chain = next_cu;
21473 break;
21474 }
21475 else
21476 last_chain = &per_cu->cu->read_in_chain;
21477
21478 per_cu = next_cu;
21479 }
21480 }
21481
21482 /* Release all extra memory associated with OBJFILE. */
21483
21484 void
21485 dwarf2_free_objfile (struct objfile *objfile)
21486 {
21487 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
21488
21489 if (dwarf2_per_objfile == NULL)
21490 return;
21491
21492 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
21493 free_cached_comp_units (NULL);
21494
21495 if (dwarf2_per_objfile->quick_file_names_table)
21496 htab_delete (dwarf2_per_objfile->quick_file_names_table);
21497
21498 /* Everything else should be on the objfile obstack. */
21499 }
21500
21501 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
21502 We store these in a hash table separate from the DIEs, and preserve them
21503 when the DIEs are flushed out of cache.
21504
21505 The CU "per_cu" pointer is needed because offset alone is not enough to
21506 uniquely identify the type. A file may have multiple .debug_types sections,
21507 or the type may come from a DWO file. Furthermore, while it's more logical
21508 to use per_cu->section+offset, with Fission the section with the data is in
21509 the DWO file but we don't know that section at the point we need it.
21510 We have to use something in dwarf2_per_cu_data (or the pointer to it)
21511 because we can enter the lookup routine, get_die_type_at_offset, from
21512 outside this file, and thus won't necessarily have PER_CU->cu.
21513 Fortunately, PER_CU is stable for the life of the objfile. */
21514
21515 struct dwarf2_per_cu_offset_and_type
21516 {
21517 const struct dwarf2_per_cu_data *per_cu;
21518 sect_offset offset;
21519 struct type *type;
21520 };
21521
21522 /* Hash function for a dwarf2_per_cu_offset_and_type. */
21523
21524 static hashval_t
21525 per_cu_offset_and_type_hash (const void *item)
21526 {
21527 const struct dwarf2_per_cu_offset_and_type *ofs = item;
21528
21529 return (uintptr_t) ofs->per_cu + ofs->offset.sect_off;
21530 }
21531
21532 /* Equality function for a dwarf2_per_cu_offset_and_type. */
21533
21534 static int
21535 per_cu_offset_and_type_eq (const void *item_lhs, const void *item_rhs)
21536 {
21537 const struct dwarf2_per_cu_offset_and_type *ofs_lhs = item_lhs;
21538 const struct dwarf2_per_cu_offset_and_type *ofs_rhs = item_rhs;
21539
21540 return (ofs_lhs->per_cu == ofs_rhs->per_cu
21541 && ofs_lhs->offset.sect_off == ofs_rhs->offset.sect_off);
21542 }
21543
21544 /* Set the type associated with DIE to TYPE. Save it in CU's hash
21545 table if necessary. For convenience, return TYPE.
21546
21547 The DIEs reading must have careful ordering to:
21548 * Not cause infite loops trying to read in DIEs as a prerequisite for
21549 reading current DIE.
21550 * Not trying to dereference contents of still incompletely read in types
21551 while reading in other DIEs.
21552 * Enable referencing still incompletely read in types just by a pointer to
21553 the type without accessing its fields.
21554
21555 Therefore caller should follow these rules:
21556 * Try to fetch any prerequisite types we may need to build this DIE type
21557 before building the type and calling set_die_type.
21558 * After building type call set_die_type for current DIE as soon as
21559 possible before fetching more types to complete the current type.
21560 * Make the type as complete as possible before fetching more types. */
21561
21562 static struct type *
21563 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
21564 {
21565 struct dwarf2_per_cu_offset_and_type **slot, ofs;
21566 struct objfile *objfile = cu->objfile;
21567
21568 /* For Ada types, make sure that the gnat-specific data is always
21569 initialized (if not already set). There are a few types where
21570 we should not be doing so, because the type-specific area is
21571 already used to hold some other piece of info (eg: TYPE_CODE_FLT
21572 where the type-specific area is used to store the floatformat).
21573 But this is not a problem, because the gnat-specific information
21574 is actually not needed for these types. */
21575 if (need_gnat_info (cu)
21576 && TYPE_CODE (type) != TYPE_CODE_FUNC
21577 && TYPE_CODE (type) != TYPE_CODE_FLT
21578 && !HAVE_GNAT_AUX_INFO (type))
21579 INIT_GNAT_SPECIFIC (type);
21580
21581 if (dwarf2_per_objfile->die_type_hash == NULL)
21582 {
21583 dwarf2_per_objfile->die_type_hash =
21584 htab_create_alloc_ex (127,
21585 per_cu_offset_and_type_hash,
21586 per_cu_offset_and_type_eq,
21587 NULL,
21588 &objfile->objfile_obstack,
21589 hashtab_obstack_allocate,
21590 dummy_obstack_deallocate);
21591 }
21592
21593 ofs.per_cu = cu->per_cu;
21594 ofs.offset = die->offset;
21595 ofs.type = type;
21596 slot = (struct dwarf2_per_cu_offset_and_type **)
21597 htab_find_slot (dwarf2_per_objfile->die_type_hash, &ofs, INSERT);
21598 if (*slot)
21599 complaint (&symfile_complaints,
21600 _("A problem internal to GDB: DIE 0x%x has type already set"),
21601 die->offset.sect_off);
21602 *slot = obstack_alloc (&objfile->objfile_obstack, sizeof (**slot));
21603 **slot = ofs;
21604 return type;
21605 }
21606
21607 /* Look up the type for the die at OFFSET in PER_CU in die_type_hash,
21608 or return NULL if the die does not have a saved type. */
21609
21610 static struct type *
21611 get_die_type_at_offset (sect_offset offset,
21612 struct dwarf2_per_cu_data *per_cu)
21613 {
21614 struct dwarf2_per_cu_offset_and_type *slot, ofs;
21615
21616 if (dwarf2_per_objfile->die_type_hash == NULL)
21617 return NULL;
21618
21619 ofs.per_cu = per_cu;
21620 ofs.offset = offset;
21621 slot = htab_find (dwarf2_per_objfile->die_type_hash, &ofs);
21622 if (slot)
21623 return slot->type;
21624 else
21625 return NULL;
21626 }
21627
21628 /* Look up the type for DIE in CU in die_type_hash,
21629 or return NULL if DIE does not have a saved type. */
21630
21631 static struct type *
21632 get_die_type (struct die_info *die, struct dwarf2_cu *cu)
21633 {
21634 return get_die_type_at_offset (die->offset, cu->per_cu);
21635 }
21636
21637 /* Add a dependence relationship from CU to REF_PER_CU. */
21638
21639 static void
21640 dwarf2_add_dependence (struct dwarf2_cu *cu,
21641 struct dwarf2_per_cu_data *ref_per_cu)
21642 {
21643 void **slot;
21644
21645 if (cu->dependencies == NULL)
21646 cu->dependencies
21647 = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
21648 NULL, &cu->comp_unit_obstack,
21649 hashtab_obstack_allocate,
21650 dummy_obstack_deallocate);
21651
21652 slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
21653 if (*slot == NULL)
21654 *slot = ref_per_cu;
21655 }
21656
21657 /* Subroutine of dwarf2_mark to pass to htab_traverse.
21658 Set the mark field in every compilation unit in the
21659 cache that we must keep because we are keeping CU. */
21660
21661 static int
21662 dwarf2_mark_helper (void **slot, void *data)
21663 {
21664 struct dwarf2_per_cu_data *per_cu;
21665
21666 per_cu = (struct dwarf2_per_cu_data *) *slot;
21667
21668 /* cu->dependencies references may not yet have been ever read if QUIT aborts
21669 reading of the chain. As such dependencies remain valid it is not much
21670 useful to track and undo them during QUIT cleanups. */
21671 if (per_cu->cu == NULL)
21672 return 1;
21673
21674 if (per_cu->cu->mark)
21675 return 1;
21676 per_cu->cu->mark = 1;
21677
21678 if (per_cu->cu->dependencies != NULL)
21679 htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
21680
21681 return 1;
21682 }
21683
21684 /* Set the mark field in CU and in every other compilation unit in the
21685 cache that we must keep because we are keeping CU. */
21686
21687 static void
21688 dwarf2_mark (struct dwarf2_cu *cu)
21689 {
21690 if (cu->mark)
21691 return;
21692 cu->mark = 1;
21693 if (cu->dependencies != NULL)
21694 htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
21695 }
21696
21697 static void
21698 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
21699 {
21700 while (per_cu)
21701 {
21702 per_cu->cu->mark = 0;
21703 per_cu = per_cu->cu->read_in_chain;
21704 }
21705 }
21706
21707 /* Trivial hash function for partial_die_info: the hash value of a DIE
21708 is its offset in .debug_info for this objfile. */
21709
21710 static hashval_t
21711 partial_die_hash (const void *item)
21712 {
21713 const struct partial_die_info *part_die = item;
21714
21715 return part_die->offset.sect_off;
21716 }
21717
21718 /* Trivial comparison function for partial_die_info structures: two DIEs
21719 are equal if they have the same offset. */
21720
21721 static int
21722 partial_die_eq (const void *item_lhs, const void *item_rhs)
21723 {
21724 const struct partial_die_info *part_die_lhs = item_lhs;
21725 const struct partial_die_info *part_die_rhs = item_rhs;
21726
21727 return part_die_lhs->offset.sect_off == part_die_rhs->offset.sect_off;
21728 }
21729
21730 static struct cmd_list_element *set_dwarf2_cmdlist;
21731 static struct cmd_list_element *show_dwarf2_cmdlist;
21732
21733 static void
21734 set_dwarf2_cmd (char *args, int from_tty)
21735 {
21736 help_list (set_dwarf2_cmdlist, "maintenance set dwarf2 ", -1, gdb_stdout);
21737 }
21738
21739 static void
21740 show_dwarf2_cmd (char *args, int from_tty)
21741 {
21742 cmd_show_list (show_dwarf2_cmdlist, from_tty, "");
21743 }
21744
21745 /* Free data associated with OBJFILE, if necessary. */
21746
21747 static void
21748 dwarf2_per_objfile_free (struct objfile *objfile, void *d)
21749 {
21750 struct dwarf2_per_objfile *data = d;
21751 int ix;
21752
21753 /* Make sure we don't accidentally use dwarf2_per_objfile while
21754 cleaning up. */
21755 dwarf2_per_objfile = NULL;
21756
21757 for (ix = 0; ix < data->n_comp_units; ++ix)
21758 VEC_free (dwarf2_per_cu_ptr, data->all_comp_units[ix]->imported_symtabs);
21759
21760 for (ix = 0; ix < data->n_type_units; ++ix)
21761 VEC_free (dwarf2_per_cu_ptr,
21762 data->all_type_units[ix]->per_cu.imported_symtabs);
21763 xfree (data->all_type_units);
21764
21765 VEC_free (dwarf2_section_info_def, data->types);
21766
21767 if (data->dwo_files)
21768 free_dwo_files (data->dwo_files, objfile);
21769 if (data->dwp_file)
21770 gdb_bfd_unref (data->dwp_file->dbfd);
21771
21772 if (data->dwz_file && data->dwz_file->dwz_bfd)
21773 gdb_bfd_unref (data->dwz_file->dwz_bfd);
21774 }
21775
21776 \f
21777 /* The "save gdb-index" command. */
21778
21779 /* The contents of the hash table we create when building the string
21780 table. */
21781 struct strtab_entry
21782 {
21783 offset_type offset;
21784 const char *str;
21785 };
21786
21787 /* Hash function for a strtab_entry.
21788
21789 Function is used only during write_hash_table so no index format backward
21790 compatibility is needed. */
21791
21792 static hashval_t
21793 hash_strtab_entry (const void *e)
21794 {
21795 const struct strtab_entry *entry = e;
21796 return mapped_index_string_hash (INT_MAX, entry->str);
21797 }
21798
21799 /* Equality function for a strtab_entry. */
21800
21801 static int
21802 eq_strtab_entry (const void *a, const void *b)
21803 {
21804 const struct strtab_entry *ea = a;
21805 const struct strtab_entry *eb = b;
21806 return !strcmp (ea->str, eb->str);
21807 }
21808
21809 /* Create a strtab_entry hash table. */
21810
21811 static htab_t
21812 create_strtab (void)
21813 {
21814 return htab_create_alloc (100, hash_strtab_entry, eq_strtab_entry,
21815 xfree, xcalloc, xfree);
21816 }
21817
21818 /* Add a string to the constant pool. Return the string's offset in
21819 host order. */
21820
21821 static offset_type
21822 add_string (htab_t table, struct obstack *cpool, const char *str)
21823 {
21824 void **slot;
21825 struct strtab_entry entry;
21826 struct strtab_entry *result;
21827
21828 entry.str = str;
21829 slot = htab_find_slot (table, &entry, INSERT);
21830 if (*slot)
21831 result = *slot;
21832 else
21833 {
21834 result = XNEW (struct strtab_entry);
21835 result->offset = obstack_object_size (cpool);
21836 result->str = str;
21837 obstack_grow_str0 (cpool, str);
21838 *slot = result;
21839 }
21840 return result->offset;
21841 }
21842
21843 /* An entry in the symbol table. */
21844 struct symtab_index_entry
21845 {
21846 /* The name of the symbol. */
21847 const char *name;
21848 /* The offset of the name in the constant pool. */
21849 offset_type index_offset;
21850 /* A sorted vector of the indices of all the CUs that hold an object
21851 of this name. */
21852 VEC (offset_type) *cu_indices;
21853 };
21854
21855 /* The symbol table. This is a power-of-2-sized hash table. */
21856 struct mapped_symtab
21857 {
21858 offset_type n_elements;
21859 offset_type size;
21860 struct symtab_index_entry **data;
21861 };
21862
21863 /* Hash function for a symtab_index_entry. */
21864
21865 static hashval_t
21866 hash_symtab_entry (const void *e)
21867 {
21868 const struct symtab_index_entry *entry = e;
21869 return iterative_hash (VEC_address (offset_type, entry->cu_indices),
21870 sizeof (offset_type) * VEC_length (offset_type,
21871 entry->cu_indices),
21872 0);
21873 }
21874
21875 /* Equality function for a symtab_index_entry. */
21876
21877 static int
21878 eq_symtab_entry (const void *a, const void *b)
21879 {
21880 const struct symtab_index_entry *ea = a;
21881 const struct symtab_index_entry *eb = b;
21882 int len = VEC_length (offset_type, ea->cu_indices);
21883 if (len != VEC_length (offset_type, eb->cu_indices))
21884 return 0;
21885 return !memcmp (VEC_address (offset_type, ea->cu_indices),
21886 VEC_address (offset_type, eb->cu_indices),
21887 sizeof (offset_type) * len);
21888 }
21889
21890 /* Destroy a symtab_index_entry. */
21891
21892 static void
21893 delete_symtab_entry (void *p)
21894 {
21895 struct symtab_index_entry *entry = p;
21896 VEC_free (offset_type, entry->cu_indices);
21897 xfree (entry);
21898 }
21899
21900 /* Create a hash table holding symtab_index_entry objects. */
21901
21902 static htab_t
21903 create_symbol_hash_table (void)
21904 {
21905 return htab_create_alloc (100, hash_symtab_entry, eq_symtab_entry,
21906 delete_symtab_entry, xcalloc, xfree);
21907 }
21908
21909 /* Create a new mapped symtab object. */
21910
21911 static struct mapped_symtab *
21912 create_mapped_symtab (void)
21913 {
21914 struct mapped_symtab *symtab = XNEW (struct mapped_symtab);
21915 symtab->n_elements = 0;
21916 symtab->size = 1024;
21917 symtab->data = XCNEWVEC (struct symtab_index_entry *, symtab->size);
21918 return symtab;
21919 }
21920
21921 /* Destroy a mapped_symtab. */
21922
21923 static void
21924 cleanup_mapped_symtab (void *p)
21925 {
21926 struct mapped_symtab *symtab = p;
21927 /* The contents of the array are freed when the other hash table is
21928 destroyed. */
21929 xfree (symtab->data);
21930 xfree (symtab);
21931 }
21932
21933 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
21934 the slot.
21935
21936 Function is used only during write_hash_table so no index format backward
21937 compatibility is needed. */
21938
21939 static struct symtab_index_entry **
21940 find_slot (struct mapped_symtab *symtab, const char *name)
21941 {
21942 offset_type index, step, hash = mapped_index_string_hash (INT_MAX, name);
21943
21944 index = hash & (symtab->size - 1);
21945 step = ((hash * 17) & (symtab->size - 1)) | 1;
21946
21947 for (;;)
21948 {
21949 if (!symtab->data[index] || !strcmp (name, symtab->data[index]->name))
21950 return &symtab->data[index];
21951 index = (index + step) & (symtab->size - 1);
21952 }
21953 }
21954
21955 /* Expand SYMTAB's hash table. */
21956
21957 static void
21958 hash_expand (struct mapped_symtab *symtab)
21959 {
21960 offset_type old_size = symtab->size;
21961 offset_type i;
21962 struct symtab_index_entry **old_entries = symtab->data;
21963
21964 symtab->size *= 2;
21965 symtab->data = XCNEWVEC (struct symtab_index_entry *, symtab->size);
21966
21967 for (i = 0; i < old_size; ++i)
21968 {
21969 if (old_entries[i])
21970 {
21971 struct symtab_index_entry **slot = find_slot (symtab,
21972 old_entries[i]->name);
21973 *slot = old_entries[i];
21974 }
21975 }
21976
21977 xfree (old_entries);
21978 }
21979
21980 /* Add an entry to SYMTAB. NAME is the name of the symbol.
21981 CU_INDEX is the index of the CU in which the symbol appears.
21982 IS_STATIC is one if the symbol is static, otherwise zero (global). */
21983
21984 static void
21985 add_index_entry (struct mapped_symtab *symtab, const char *name,
21986 int is_static, gdb_index_symbol_kind kind,
21987 offset_type cu_index)
21988 {
21989 struct symtab_index_entry **slot;
21990 offset_type cu_index_and_attrs;
21991
21992 ++symtab->n_elements;
21993 if (4 * symtab->n_elements / 3 >= symtab->size)
21994 hash_expand (symtab);
21995
21996 slot = find_slot (symtab, name);
21997 if (!*slot)
21998 {
21999 *slot = XNEW (struct symtab_index_entry);
22000 (*slot)->name = name;
22001 /* index_offset is set later. */
22002 (*slot)->cu_indices = NULL;
22003 }
22004
22005 cu_index_and_attrs = 0;
22006 DW2_GDB_INDEX_CU_SET_VALUE (cu_index_and_attrs, cu_index);
22007 DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE (cu_index_and_attrs, is_static);
22008 DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE (cu_index_and_attrs, kind);
22009
22010 /* We don't want to record an index value twice as we want to avoid the
22011 duplication.
22012 We process all global symbols and then all static symbols
22013 (which would allow us to avoid the duplication by only having to check
22014 the last entry pushed), but a symbol could have multiple kinds in one CU.
22015 To keep things simple we don't worry about the duplication here and
22016 sort and uniqufy the list after we've processed all symbols. */
22017 VEC_safe_push (offset_type, (*slot)->cu_indices, cu_index_and_attrs);
22018 }
22019
22020 /* qsort helper routine for uniquify_cu_indices. */
22021
22022 static int
22023 offset_type_compare (const void *ap, const void *bp)
22024 {
22025 offset_type a = *(offset_type *) ap;
22026 offset_type b = *(offset_type *) bp;
22027
22028 return (a > b) - (b > a);
22029 }
22030
22031 /* Sort and remove duplicates of all symbols' cu_indices lists. */
22032
22033 static void
22034 uniquify_cu_indices (struct mapped_symtab *symtab)
22035 {
22036 int i;
22037
22038 for (i = 0; i < symtab->size; ++i)
22039 {
22040 struct symtab_index_entry *entry = symtab->data[i];
22041
22042 if (entry
22043 && entry->cu_indices != NULL)
22044 {
22045 unsigned int next_to_insert, next_to_check;
22046 offset_type last_value;
22047
22048 qsort (VEC_address (offset_type, entry->cu_indices),
22049 VEC_length (offset_type, entry->cu_indices),
22050 sizeof (offset_type), offset_type_compare);
22051
22052 last_value = VEC_index (offset_type, entry->cu_indices, 0);
22053 next_to_insert = 1;
22054 for (next_to_check = 1;
22055 next_to_check < VEC_length (offset_type, entry->cu_indices);
22056 ++next_to_check)
22057 {
22058 if (VEC_index (offset_type, entry->cu_indices, next_to_check)
22059 != last_value)
22060 {
22061 last_value = VEC_index (offset_type, entry->cu_indices,
22062 next_to_check);
22063 VEC_replace (offset_type, entry->cu_indices, next_to_insert,
22064 last_value);
22065 ++next_to_insert;
22066 }
22067 }
22068 VEC_truncate (offset_type, entry->cu_indices, next_to_insert);
22069 }
22070 }
22071 }
22072
22073 /* Add a vector of indices to the constant pool. */
22074
22075 static offset_type
22076 add_indices_to_cpool (htab_t symbol_hash_table, struct obstack *cpool,
22077 struct symtab_index_entry *entry)
22078 {
22079 void **slot;
22080
22081 slot = htab_find_slot (symbol_hash_table, entry, INSERT);
22082 if (!*slot)
22083 {
22084 offset_type len = VEC_length (offset_type, entry->cu_indices);
22085 offset_type val = MAYBE_SWAP (len);
22086 offset_type iter;
22087 int i;
22088
22089 *slot = entry;
22090 entry->index_offset = obstack_object_size (cpool);
22091
22092 obstack_grow (cpool, &val, sizeof (val));
22093 for (i = 0;
22094 VEC_iterate (offset_type, entry->cu_indices, i, iter);
22095 ++i)
22096 {
22097 val = MAYBE_SWAP (iter);
22098 obstack_grow (cpool, &val, sizeof (val));
22099 }
22100 }
22101 else
22102 {
22103 struct symtab_index_entry *old_entry = *slot;
22104 entry->index_offset = old_entry->index_offset;
22105 entry = old_entry;
22106 }
22107 return entry->index_offset;
22108 }
22109
22110 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
22111 constant pool entries going into the obstack CPOOL. */
22112
22113 static void
22114 write_hash_table (struct mapped_symtab *symtab,
22115 struct obstack *output, struct obstack *cpool)
22116 {
22117 offset_type i;
22118 htab_t symbol_hash_table;
22119 htab_t str_table;
22120
22121 symbol_hash_table = create_symbol_hash_table ();
22122 str_table = create_strtab ();
22123
22124 /* We add all the index vectors to the constant pool first, to
22125 ensure alignment is ok. */
22126 for (i = 0; i < symtab->size; ++i)
22127 {
22128 if (symtab->data[i])
22129 add_indices_to_cpool (symbol_hash_table, cpool, symtab->data[i]);
22130 }
22131
22132 /* Now write out the hash table. */
22133 for (i = 0; i < symtab->size; ++i)
22134 {
22135 offset_type str_off, vec_off;
22136
22137 if (symtab->data[i])
22138 {
22139 str_off = add_string (str_table, cpool, symtab->data[i]->name);
22140 vec_off = symtab->data[i]->index_offset;
22141 }
22142 else
22143 {
22144 /* While 0 is a valid constant pool index, it is not valid
22145 to have 0 for both offsets. */
22146 str_off = 0;
22147 vec_off = 0;
22148 }
22149
22150 str_off = MAYBE_SWAP (str_off);
22151 vec_off = MAYBE_SWAP (vec_off);
22152
22153 obstack_grow (output, &str_off, sizeof (str_off));
22154 obstack_grow (output, &vec_off, sizeof (vec_off));
22155 }
22156
22157 htab_delete (str_table);
22158 htab_delete (symbol_hash_table);
22159 }
22160
22161 /* Struct to map psymtab to CU index in the index file. */
22162 struct psymtab_cu_index_map
22163 {
22164 struct partial_symtab *psymtab;
22165 unsigned int cu_index;
22166 };
22167
22168 static hashval_t
22169 hash_psymtab_cu_index (const void *item)
22170 {
22171 const struct psymtab_cu_index_map *map = item;
22172
22173 return htab_hash_pointer (map->psymtab);
22174 }
22175
22176 static int
22177 eq_psymtab_cu_index (const void *item_lhs, const void *item_rhs)
22178 {
22179 const struct psymtab_cu_index_map *lhs = item_lhs;
22180 const struct psymtab_cu_index_map *rhs = item_rhs;
22181
22182 return lhs->psymtab == rhs->psymtab;
22183 }
22184
22185 /* Helper struct for building the address table. */
22186 struct addrmap_index_data
22187 {
22188 struct objfile *objfile;
22189 struct obstack *addr_obstack;
22190 htab_t cu_index_htab;
22191
22192 /* Non-zero if the previous_* fields are valid.
22193 We can't write an entry until we see the next entry (since it is only then
22194 that we know the end of the entry). */
22195 int previous_valid;
22196 /* Index of the CU in the table of all CUs in the index file. */
22197 unsigned int previous_cu_index;
22198 /* Start address of the CU. */
22199 CORE_ADDR previous_cu_start;
22200 };
22201
22202 /* Write an address entry to OBSTACK. */
22203
22204 static void
22205 add_address_entry (struct objfile *objfile, struct obstack *obstack,
22206 CORE_ADDR start, CORE_ADDR end, unsigned int cu_index)
22207 {
22208 offset_type cu_index_to_write;
22209 gdb_byte addr[8];
22210 CORE_ADDR baseaddr;
22211
22212 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
22213
22214 store_unsigned_integer (addr, 8, BFD_ENDIAN_LITTLE, start - baseaddr);
22215 obstack_grow (obstack, addr, 8);
22216 store_unsigned_integer (addr, 8, BFD_ENDIAN_LITTLE, end - baseaddr);
22217 obstack_grow (obstack, addr, 8);
22218 cu_index_to_write = MAYBE_SWAP (cu_index);
22219 obstack_grow (obstack, &cu_index_to_write, sizeof (offset_type));
22220 }
22221
22222 /* Worker function for traversing an addrmap to build the address table. */
22223
22224 static int
22225 add_address_entry_worker (void *datap, CORE_ADDR start_addr, void *obj)
22226 {
22227 struct addrmap_index_data *data = datap;
22228 struct partial_symtab *pst = obj;
22229
22230 if (data->previous_valid)
22231 add_address_entry (data->objfile, data->addr_obstack,
22232 data->previous_cu_start, start_addr,
22233 data->previous_cu_index);
22234
22235 data->previous_cu_start = start_addr;
22236 if (pst != NULL)
22237 {
22238 struct psymtab_cu_index_map find_map, *map;
22239 find_map.psymtab = pst;
22240 map = htab_find (data->cu_index_htab, &find_map);
22241 gdb_assert (map != NULL);
22242 data->previous_cu_index = map->cu_index;
22243 data->previous_valid = 1;
22244 }
22245 else
22246 data->previous_valid = 0;
22247
22248 return 0;
22249 }
22250
22251 /* Write OBJFILE's address map to OBSTACK.
22252 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
22253 in the index file. */
22254
22255 static void
22256 write_address_map (struct objfile *objfile, struct obstack *obstack,
22257 htab_t cu_index_htab)
22258 {
22259 struct addrmap_index_data addrmap_index_data;
22260
22261 /* When writing the address table, we have to cope with the fact that
22262 the addrmap iterator only provides the start of a region; we have to
22263 wait until the next invocation to get the start of the next region. */
22264
22265 addrmap_index_data.objfile = objfile;
22266 addrmap_index_data.addr_obstack = obstack;
22267 addrmap_index_data.cu_index_htab = cu_index_htab;
22268 addrmap_index_data.previous_valid = 0;
22269
22270 addrmap_foreach (objfile->psymtabs_addrmap, add_address_entry_worker,
22271 &addrmap_index_data);
22272
22273 /* It's highly unlikely the last entry (end address = 0xff...ff)
22274 is valid, but we should still handle it.
22275 The end address is recorded as the start of the next region, but that
22276 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
22277 anyway. */
22278 if (addrmap_index_data.previous_valid)
22279 add_address_entry (objfile, obstack,
22280 addrmap_index_data.previous_cu_start, (CORE_ADDR) -1,
22281 addrmap_index_data.previous_cu_index);
22282 }
22283
22284 /* Return the symbol kind of PSYM. */
22285
22286 static gdb_index_symbol_kind
22287 symbol_kind (struct partial_symbol *psym)
22288 {
22289 domain_enum domain = PSYMBOL_DOMAIN (psym);
22290 enum address_class aclass = PSYMBOL_CLASS (psym);
22291
22292 switch (domain)
22293 {
22294 case VAR_DOMAIN:
22295 switch (aclass)
22296 {
22297 case LOC_BLOCK:
22298 return GDB_INDEX_SYMBOL_KIND_FUNCTION;
22299 case LOC_TYPEDEF:
22300 return GDB_INDEX_SYMBOL_KIND_TYPE;
22301 case LOC_COMPUTED:
22302 case LOC_CONST_BYTES:
22303 case LOC_OPTIMIZED_OUT:
22304 case LOC_STATIC:
22305 return GDB_INDEX_SYMBOL_KIND_VARIABLE;
22306 case LOC_CONST:
22307 /* Note: It's currently impossible to recognize psyms as enum values
22308 short of reading the type info. For now punt. */
22309 return GDB_INDEX_SYMBOL_KIND_VARIABLE;
22310 default:
22311 /* There are other LOC_FOO values that one might want to classify
22312 as variables, but dwarf2read.c doesn't currently use them. */
22313 return GDB_INDEX_SYMBOL_KIND_OTHER;
22314 }
22315 case STRUCT_DOMAIN:
22316 return GDB_INDEX_SYMBOL_KIND_TYPE;
22317 default:
22318 return GDB_INDEX_SYMBOL_KIND_OTHER;
22319 }
22320 }
22321
22322 /* Add a list of partial symbols to SYMTAB. */
22323
22324 static void
22325 write_psymbols (struct mapped_symtab *symtab,
22326 htab_t psyms_seen,
22327 struct partial_symbol **psymp,
22328 int count,
22329 offset_type cu_index,
22330 int is_static)
22331 {
22332 for (; count-- > 0; ++psymp)
22333 {
22334 struct partial_symbol *psym = *psymp;
22335 void **slot;
22336
22337 if (SYMBOL_LANGUAGE (psym) == language_ada)
22338 error (_("Ada is not currently supported by the index"));
22339
22340 /* Only add a given psymbol once. */
22341 slot = htab_find_slot (psyms_seen, psym, INSERT);
22342 if (!*slot)
22343 {
22344 gdb_index_symbol_kind kind = symbol_kind (psym);
22345
22346 *slot = psym;
22347 add_index_entry (symtab, SYMBOL_SEARCH_NAME (psym),
22348 is_static, kind, cu_index);
22349 }
22350 }
22351 }
22352
22353 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
22354 exception if there is an error. */
22355
22356 static void
22357 write_obstack (FILE *file, struct obstack *obstack)
22358 {
22359 if (fwrite (obstack_base (obstack), 1, obstack_object_size (obstack),
22360 file)
22361 != obstack_object_size (obstack))
22362 error (_("couldn't data write to file"));
22363 }
22364
22365 /* Unlink a file if the argument is not NULL. */
22366
22367 static void
22368 unlink_if_set (void *p)
22369 {
22370 char **filename = p;
22371 if (*filename)
22372 unlink (*filename);
22373 }
22374
22375 /* A helper struct used when iterating over debug_types. */
22376 struct signatured_type_index_data
22377 {
22378 struct objfile *objfile;
22379 struct mapped_symtab *symtab;
22380 struct obstack *types_list;
22381 htab_t psyms_seen;
22382 int cu_index;
22383 };
22384
22385 /* A helper function that writes a single signatured_type to an
22386 obstack. */
22387
22388 static int
22389 write_one_signatured_type (void **slot, void *d)
22390 {
22391 struct signatured_type_index_data *info = d;
22392 struct signatured_type *entry = (struct signatured_type *) *slot;
22393 struct partial_symtab *psymtab = entry->per_cu.v.psymtab;
22394 gdb_byte val[8];
22395
22396 write_psymbols (info->symtab,
22397 info->psyms_seen,
22398 info->objfile->global_psymbols.list
22399 + psymtab->globals_offset,
22400 psymtab->n_global_syms, info->cu_index,
22401 0);
22402 write_psymbols (info->symtab,
22403 info->psyms_seen,
22404 info->objfile->static_psymbols.list
22405 + psymtab->statics_offset,
22406 psymtab->n_static_syms, info->cu_index,
22407 1);
22408
22409 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE,
22410 entry->per_cu.offset.sect_off);
22411 obstack_grow (info->types_list, val, 8);
22412 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE,
22413 entry->type_offset_in_tu.cu_off);
22414 obstack_grow (info->types_list, val, 8);
22415 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, entry->signature);
22416 obstack_grow (info->types_list, val, 8);
22417
22418 ++info->cu_index;
22419
22420 return 1;
22421 }
22422
22423 /* Recurse into all "included" dependencies and write their symbols as
22424 if they appeared in this psymtab. */
22425
22426 static void
22427 recursively_write_psymbols (struct objfile *objfile,
22428 struct partial_symtab *psymtab,
22429 struct mapped_symtab *symtab,
22430 htab_t psyms_seen,
22431 offset_type cu_index)
22432 {
22433 int i;
22434
22435 for (i = 0; i < psymtab->number_of_dependencies; ++i)
22436 if (psymtab->dependencies[i]->user != NULL)
22437 recursively_write_psymbols (objfile, psymtab->dependencies[i],
22438 symtab, psyms_seen, cu_index);
22439
22440 write_psymbols (symtab,
22441 psyms_seen,
22442 objfile->global_psymbols.list + psymtab->globals_offset,
22443 psymtab->n_global_syms, cu_index,
22444 0);
22445 write_psymbols (symtab,
22446 psyms_seen,
22447 objfile->static_psymbols.list + psymtab->statics_offset,
22448 psymtab->n_static_syms, cu_index,
22449 1);
22450 }
22451
22452 /* Create an index file for OBJFILE in the directory DIR. */
22453
22454 static void
22455 write_psymtabs_to_index (struct objfile *objfile, const char *dir)
22456 {
22457 struct cleanup *cleanup;
22458 char *filename, *cleanup_filename;
22459 struct obstack contents, addr_obstack, constant_pool, symtab_obstack;
22460 struct obstack cu_list, types_cu_list;
22461 int i;
22462 FILE *out_file;
22463 struct mapped_symtab *symtab;
22464 offset_type val, size_of_contents, total_len;
22465 struct stat st;
22466 htab_t psyms_seen;
22467 htab_t cu_index_htab;
22468 struct psymtab_cu_index_map *psymtab_cu_index_map;
22469
22470 if (dwarf2_per_objfile->using_index)
22471 error (_("Cannot use an index to create the index"));
22472
22473 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) > 1)
22474 error (_("Cannot make an index when the file has multiple .debug_types sections"));
22475
22476 if (!objfile->psymtabs || !objfile->psymtabs_addrmap)
22477 return;
22478
22479 if (stat (objfile_name (objfile), &st) < 0)
22480 perror_with_name (objfile_name (objfile));
22481
22482 filename = concat (dir, SLASH_STRING, lbasename (objfile_name (objfile)),
22483 INDEX_SUFFIX, (char *) NULL);
22484 cleanup = make_cleanup (xfree, filename);
22485
22486 out_file = gdb_fopen_cloexec (filename, "wb");
22487 if (!out_file)
22488 error (_("Can't open `%s' for writing"), filename);
22489
22490 cleanup_filename = filename;
22491 make_cleanup (unlink_if_set, &cleanup_filename);
22492
22493 symtab = create_mapped_symtab ();
22494 make_cleanup (cleanup_mapped_symtab, symtab);
22495
22496 obstack_init (&addr_obstack);
22497 make_cleanup_obstack_free (&addr_obstack);
22498
22499 obstack_init (&cu_list);
22500 make_cleanup_obstack_free (&cu_list);
22501
22502 obstack_init (&types_cu_list);
22503 make_cleanup_obstack_free (&types_cu_list);
22504
22505 psyms_seen = htab_create_alloc (100, htab_hash_pointer, htab_eq_pointer,
22506 NULL, xcalloc, xfree);
22507 make_cleanup_htab_delete (psyms_seen);
22508
22509 /* While we're scanning CU's create a table that maps a psymtab pointer
22510 (which is what addrmap records) to its index (which is what is recorded
22511 in the index file). This will later be needed to write the address
22512 table. */
22513 cu_index_htab = htab_create_alloc (100,
22514 hash_psymtab_cu_index,
22515 eq_psymtab_cu_index,
22516 NULL, xcalloc, xfree);
22517 make_cleanup_htab_delete (cu_index_htab);
22518 psymtab_cu_index_map = (struct psymtab_cu_index_map *)
22519 xmalloc (sizeof (struct psymtab_cu_index_map)
22520 * dwarf2_per_objfile->n_comp_units);
22521 make_cleanup (xfree, psymtab_cu_index_map);
22522
22523 /* The CU list is already sorted, so we don't need to do additional
22524 work here. Also, the debug_types entries do not appear in
22525 all_comp_units, but only in their own hash table. */
22526 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
22527 {
22528 struct dwarf2_per_cu_data *per_cu
22529 = dwarf2_per_objfile->all_comp_units[i];
22530 struct partial_symtab *psymtab = per_cu->v.psymtab;
22531 gdb_byte val[8];
22532 struct psymtab_cu_index_map *map;
22533 void **slot;
22534
22535 /* CU of a shared file from 'dwz -m' may be unused by this main file.
22536 It may be referenced from a local scope but in such case it does not
22537 need to be present in .gdb_index. */
22538 if (psymtab == NULL)
22539 continue;
22540
22541 if (psymtab->user == NULL)
22542 recursively_write_psymbols (objfile, psymtab, symtab, psyms_seen, i);
22543
22544 map = &psymtab_cu_index_map[i];
22545 map->psymtab = psymtab;
22546 map->cu_index = i;
22547 slot = htab_find_slot (cu_index_htab, map, INSERT);
22548 gdb_assert (slot != NULL);
22549 gdb_assert (*slot == NULL);
22550 *slot = map;
22551
22552 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE,
22553 per_cu->offset.sect_off);
22554 obstack_grow (&cu_list, val, 8);
22555 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, per_cu->length);
22556 obstack_grow (&cu_list, val, 8);
22557 }
22558
22559 /* Dump the address map. */
22560 write_address_map (objfile, &addr_obstack, cu_index_htab);
22561
22562 /* Write out the .debug_type entries, if any. */
22563 if (dwarf2_per_objfile->signatured_types)
22564 {
22565 struct signatured_type_index_data sig_data;
22566
22567 sig_data.objfile = objfile;
22568 sig_data.symtab = symtab;
22569 sig_data.types_list = &types_cu_list;
22570 sig_data.psyms_seen = psyms_seen;
22571 sig_data.cu_index = dwarf2_per_objfile->n_comp_units;
22572 htab_traverse_noresize (dwarf2_per_objfile->signatured_types,
22573 write_one_signatured_type, &sig_data);
22574 }
22575
22576 /* Now that we've processed all symbols we can shrink their cu_indices
22577 lists. */
22578 uniquify_cu_indices (symtab);
22579
22580 obstack_init (&constant_pool);
22581 make_cleanup_obstack_free (&constant_pool);
22582 obstack_init (&symtab_obstack);
22583 make_cleanup_obstack_free (&symtab_obstack);
22584 write_hash_table (symtab, &symtab_obstack, &constant_pool);
22585
22586 obstack_init (&contents);
22587 make_cleanup_obstack_free (&contents);
22588 size_of_contents = 6 * sizeof (offset_type);
22589 total_len = size_of_contents;
22590
22591 /* The version number. */
22592 val = MAYBE_SWAP (8);
22593 obstack_grow (&contents, &val, sizeof (val));
22594
22595 /* The offset of the CU list from the start of the file. */
22596 val = MAYBE_SWAP (total_len);
22597 obstack_grow (&contents, &val, sizeof (val));
22598 total_len += obstack_object_size (&cu_list);
22599
22600 /* The offset of the types CU list from the start of the file. */
22601 val = MAYBE_SWAP (total_len);
22602 obstack_grow (&contents, &val, sizeof (val));
22603 total_len += obstack_object_size (&types_cu_list);
22604
22605 /* The offset of the address table from the start of the file. */
22606 val = MAYBE_SWAP (total_len);
22607 obstack_grow (&contents, &val, sizeof (val));
22608 total_len += obstack_object_size (&addr_obstack);
22609
22610 /* The offset of the symbol table from the start of the file. */
22611 val = MAYBE_SWAP (total_len);
22612 obstack_grow (&contents, &val, sizeof (val));
22613 total_len += obstack_object_size (&symtab_obstack);
22614
22615 /* The offset of the constant pool from the start of the file. */
22616 val = MAYBE_SWAP (total_len);
22617 obstack_grow (&contents, &val, sizeof (val));
22618 total_len += obstack_object_size (&constant_pool);
22619
22620 gdb_assert (obstack_object_size (&contents) == size_of_contents);
22621
22622 write_obstack (out_file, &contents);
22623 write_obstack (out_file, &cu_list);
22624 write_obstack (out_file, &types_cu_list);
22625 write_obstack (out_file, &addr_obstack);
22626 write_obstack (out_file, &symtab_obstack);
22627 write_obstack (out_file, &constant_pool);
22628
22629 fclose (out_file);
22630
22631 /* We want to keep the file, so we set cleanup_filename to NULL
22632 here. See unlink_if_set. */
22633 cleanup_filename = NULL;
22634
22635 do_cleanups (cleanup);
22636 }
22637
22638 /* Implementation of the `save gdb-index' command.
22639
22640 Note that the file format used by this command is documented in the
22641 GDB manual. Any changes here must be documented there. */
22642
22643 static void
22644 save_gdb_index_command (char *arg, int from_tty)
22645 {
22646 struct objfile *objfile;
22647
22648 if (!arg || !*arg)
22649 error (_("usage: save gdb-index DIRECTORY"));
22650
22651 ALL_OBJFILES (objfile)
22652 {
22653 struct stat st;
22654
22655 /* If the objfile does not correspond to an actual file, skip it. */
22656 if (stat (objfile_name (objfile), &st) < 0)
22657 continue;
22658
22659 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
22660 if (dwarf2_per_objfile)
22661 {
22662 volatile struct gdb_exception except;
22663
22664 TRY_CATCH (except, RETURN_MASK_ERROR)
22665 {
22666 write_psymtabs_to_index (objfile, arg);
22667 }
22668 if (except.reason < 0)
22669 exception_fprintf (gdb_stderr, except,
22670 _("Error while writing index for `%s': "),
22671 objfile_name (objfile));
22672 }
22673 }
22674 }
22675
22676 \f
22677
22678 int dwarf2_always_disassemble;
22679
22680 static void
22681 show_dwarf2_always_disassemble (struct ui_file *file, int from_tty,
22682 struct cmd_list_element *c, const char *value)
22683 {
22684 fprintf_filtered (file,
22685 _("Whether to always disassemble "
22686 "DWARF expressions is %s.\n"),
22687 value);
22688 }
22689
22690 static void
22691 show_check_physname (struct ui_file *file, int from_tty,
22692 struct cmd_list_element *c, const char *value)
22693 {
22694 fprintf_filtered (file,
22695 _("Whether to check \"physname\" is %s.\n"),
22696 value);
22697 }
22698
22699 void _initialize_dwarf2_read (void);
22700
22701 void
22702 _initialize_dwarf2_read (void)
22703 {
22704 struct cmd_list_element *c;
22705
22706 dwarf2_objfile_data_key
22707 = register_objfile_data_with_cleanup (NULL, dwarf2_per_objfile_free);
22708
22709 add_prefix_cmd ("dwarf2", class_maintenance, set_dwarf2_cmd, _("\
22710 Set DWARF 2 specific variables.\n\
22711 Configure DWARF 2 variables such as the cache size"),
22712 &set_dwarf2_cmdlist, "maintenance set dwarf2 ",
22713 0/*allow-unknown*/, &maintenance_set_cmdlist);
22714
22715 add_prefix_cmd ("dwarf2", class_maintenance, show_dwarf2_cmd, _("\
22716 Show DWARF 2 specific variables\n\
22717 Show DWARF 2 variables such as the cache size"),
22718 &show_dwarf2_cmdlist, "maintenance show dwarf2 ",
22719 0/*allow-unknown*/, &maintenance_show_cmdlist);
22720
22721 add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
22722 &dwarf2_max_cache_age, _("\
22723 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
22724 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
22725 A higher limit means that cached compilation units will be stored\n\
22726 in memory longer, and more total memory will be used. Zero disables\n\
22727 caching, which can slow down startup."),
22728 NULL,
22729 show_dwarf2_max_cache_age,
22730 &set_dwarf2_cmdlist,
22731 &show_dwarf2_cmdlist);
22732
22733 add_setshow_boolean_cmd ("always-disassemble", class_obscure,
22734 &dwarf2_always_disassemble, _("\
22735 Set whether `info address' always disassembles DWARF expressions."), _("\
22736 Show whether `info address' always disassembles DWARF expressions."), _("\
22737 When enabled, DWARF expressions are always printed in an assembly-like\n\
22738 syntax. When disabled, expressions will be printed in a more\n\
22739 conversational style, when possible."),
22740 NULL,
22741 show_dwarf2_always_disassemble,
22742 &set_dwarf2_cmdlist,
22743 &show_dwarf2_cmdlist);
22744
22745 add_setshow_zuinteger_cmd ("dwarf2-read", no_class, &dwarf2_read_debug, _("\
22746 Set debugging of the dwarf2 reader."), _("\
22747 Show debugging of the dwarf2 reader."), _("\
22748 When enabled (non-zero), debugging messages are printed during dwarf2\n\
22749 reading and symtab expansion. A value of 1 (one) provides basic\n\
22750 information. A value greater than 1 provides more verbose information."),
22751 NULL,
22752 NULL,
22753 &setdebuglist, &showdebuglist);
22754
22755 add_setshow_zuinteger_cmd ("dwarf2-die", no_class, &dwarf2_die_debug, _("\
22756 Set debugging of the dwarf2 DIE reader."), _("\
22757 Show debugging of the dwarf2 DIE reader."), _("\
22758 When enabled (non-zero), DIEs are dumped after they are read in.\n\
22759 The value is the maximum depth to print."),
22760 NULL,
22761 NULL,
22762 &setdebuglist, &showdebuglist);
22763
22764 add_setshow_boolean_cmd ("check-physname", no_class, &check_physname, _("\
22765 Set cross-checking of \"physname\" code against demangler."), _("\
22766 Show cross-checking of \"physname\" code against demangler."), _("\
22767 When enabled, GDB's internal \"physname\" code is checked against\n\
22768 the demangler."),
22769 NULL, show_check_physname,
22770 &setdebuglist, &showdebuglist);
22771
22772 add_setshow_boolean_cmd ("use-deprecated-index-sections",
22773 no_class, &use_deprecated_index_sections, _("\
22774 Set whether to use deprecated gdb_index sections."), _("\
22775 Show whether to use deprecated gdb_index sections."), _("\
22776 When enabled, deprecated .gdb_index sections are used anyway.\n\
22777 Normally they are ignored either because of a missing feature or\n\
22778 performance issue.\n\
22779 Warning: This option must be enabled before gdb reads the file."),
22780 NULL,
22781 NULL,
22782 &setlist, &showlist);
22783
22784 c = add_cmd ("gdb-index", class_files, save_gdb_index_command,
22785 _("\
22786 Save a gdb-index file.\n\
22787 Usage: save gdb-index DIRECTORY"),
22788 &save_cmdlist);
22789 set_cmd_completer (c, filename_completer);
22790
22791 dwarf2_locexpr_index = register_symbol_computed_impl (LOC_COMPUTED,
22792 &dwarf2_locexpr_funcs);
22793 dwarf2_loclist_index = register_symbol_computed_impl (LOC_COMPUTED,
22794 &dwarf2_loclist_funcs);
22795
22796 dwarf2_locexpr_block_index = register_symbol_block_impl (LOC_BLOCK,
22797 &dwarf2_block_frame_base_locexpr_funcs);
22798 dwarf2_loclist_block_index = register_symbol_block_impl (LOC_BLOCK,
22799 &dwarf2_block_frame_base_loclist_funcs);
22800 }
This page took 0.615484 seconds and 4 git commands to generate.