dwarf2read.c (dwarf_record_line): Fix typo.
[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 <sys/types.h>
76
77 typedef struct symbol *symbolp;
78 DEF_VEC_P (symbolp);
79
80 /* When == 1, print basic high level tracing messages.
81 When > 1, be more verbose.
82 This is in contrast to the low level DIE reading of dwarf2_die_debug. */
83 static unsigned int dwarf2_read_debug = 0;
84
85 /* When non-zero, dump DIEs after they are read in. */
86 static unsigned int dwarf2_die_debug = 0;
87
88 /* When non-zero, cross-check physname against demangler. */
89 static int check_physname = 0;
90
91 /* When non-zero, do not reject deprecated .gdb_index sections. */
92 static int use_deprecated_index_sections = 0;
93
94 static const struct objfile_data *dwarf2_objfile_data_key;
95
96 /* The "aclass" indices for various kinds of computed DWARF symbols. */
97
98 static int dwarf2_locexpr_index;
99 static int dwarf2_loclist_index;
100 static int dwarf2_locexpr_block_index;
101 static int dwarf2_loclist_block_index;
102
103 /* A descriptor for dwarf sections.
104
105 S.ASECTION, SIZE are typically initialized when the objfile is first
106 scanned. BUFFER, READIN are filled in later when the section is read.
107 If the section contained compressed data then SIZE is updated to record
108 the uncompressed size of the section.
109
110 DWP file format V2 introduces a wrinkle that is easiest to handle by
111 creating the concept of virtual sections contained within a real section.
112 In DWP V2 the sections of the input DWO files are concatenated together
113 into one section, but section offsets are kept relative to the original
114 input section.
115 If this is a virtual dwp-v2 section, S.CONTAINING_SECTION is a backlink to
116 the real section this "virtual" section is contained in, and BUFFER,SIZE
117 describe the virtual section. */
118
119 struct dwarf2_section_info
120 {
121 union
122 {
123 /* If this is a real section, the bfd section. */
124 asection *asection;
125 /* If this is a virtual section, pointer to the containing ("real")
126 section. */
127 struct dwarf2_section_info *containing_section;
128 } s;
129 /* Pointer to section data, only valid if readin. */
130 const gdb_byte *buffer;
131 /* The size of the section, real or virtual. */
132 bfd_size_type size;
133 /* If this is a virtual section, the offset in the real section.
134 Only valid if is_virtual. */
135 bfd_size_type virtual_offset;
136 /* True if we have tried to read this section. */
137 char readin;
138 /* True if this is a virtual section, False otherwise.
139 This specifies which of s.asection and s.containing_section to use. */
140 char is_virtual;
141 };
142
143 typedef struct dwarf2_section_info dwarf2_section_info_def;
144 DEF_VEC_O (dwarf2_section_info_def);
145
146 /* All offsets in the index are of this type. It must be
147 architecture-independent. */
148 typedef uint32_t offset_type;
149
150 DEF_VEC_I (offset_type);
151
152 /* Ensure only legit values are used. */
153 #define DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE(cu_index, value) \
154 do { \
155 gdb_assert ((unsigned int) (value) <= 1); \
156 GDB_INDEX_SYMBOL_STATIC_SET_VALUE((cu_index), (value)); \
157 } while (0)
158
159 /* Ensure only legit values are used. */
160 #define DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE(cu_index, value) \
161 do { \
162 gdb_assert ((value) >= GDB_INDEX_SYMBOL_KIND_TYPE \
163 && (value) <= GDB_INDEX_SYMBOL_KIND_OTHER); \
164 GDB_INDEX_SYMBOL_KIND_SET_VALUE((cu_index), (value)); \
165 } while (0)
166
167 /* Ensure we don't use more than the alloted nuber of bits for the CU. */
168 #define DW2_GDB_INDEX_CU_SET_VALUE(cu_index, value) \
169 do { \
170 gdb_assert (((value) & ~GDB_INDEX_CU_MASK) == 0); \
171 GDB_INDEX_CU_SET_VALUE((cu_index), (value)); \
172 } while (0)
173
174 /* A description of the mapped index. The file format is described in
175 a comment by the code that writes the index. */
176 struct mapped_index
177 {
178 /* Index data format version. */
179 int version;
180
181 /* The total length of the buffer. */
182 off_t total_size;
183
184 /* A pointer to the address table data. */
185 const gdb_byte *address_table;
186
187 /* Size of the address table data in bytes. */
188 offset_type address_table_size;
189
190 /* The symbol table, implemented as a hash table. */
191 const offset_type *symbol_table;
192
193 /* Size in slots, each slot is 2 offset_types. */
194 offset_type symbol_table_slots;
195
196 /* A pointer to the constant pool. */
197 const char *constant_pool;
198 };
199
200 typedef struct dwarf2_per_cu_data *dwarf2_per_cu_ptr;
201 DEF_VEC_P (dwarf2_per_cu_ptr);
202
203 /* Collection of data recorded per objfile.
204 This hangs off of dwarf2_objfile_data_key. */
205
206 struct dwarf2_per_objfile
207 {
208 struct dwarf2_section_info info;
209 struct dwarf2_section_info abbrev;
210 struct dwarf2_section_info line;
211 struct dwarf2_section_info loc;
212 struct dwarf2_section_info macinfo;
213 struct dwarf2_section_info macro;
214 struct dwarf2_section_info str;
215 struct dwarf2_section_info ranges;
216 struct dwarf2_section_info addr;
217 struct dwarf2_section_info frame;
218 struct dwarf2_section_info eh_frame;
219 struct dwarf2_section_info gdb_index;
220
221 VEC (dwarf2_section_info_def) *types;
222
223 /* Back link. */
224 struct objfile *objfile;
225
226 /* Table of all the compilation units. This is used to locate
227 the target compilation unit of a particular reference. */
228 struct dwarf2_per_cu_data **all_comp_units;
229
230 /* The number of compilation units in ALL_COMP_UNITS. */
231 int n_comp_units;
232
233 /* The number of .debug_types-related CUs. */
234 int n_type_units;
235
236 /* The number of elements allocated in all_type_units.
237 If there are skeleton-less TUs, we add them to all_type_units lazily. */
238 int n_allocated_type_units;
239
240 /* The .debug_types-related CUs (TUs).
241 This is stored in malloc space because we may realloc it. */
242 struct signatured_type **all_type_units;
243
244 /* Table of struct type_unit_group objects.
245 The hash key is the DW_AT_stmt_list value. */
246 htab_t type_unit_groups;
247
248 /* A table mapping .debug_types signatures to its signatured_type entry.
249 This is NULL if the .debug_types section hasn't been read in yet. */
250 htab_t signatured_types;
251
252 /* Type unit statistics, to see how well the scaling improvements
253 are doing. */
254 struct tu_stats
255 {
256 int nr_uniq_abbrev_tables;
257 int nr_symtabs;
258 int nr_symtab_sharers;
259 int nr_stmt_less_type_units;
260 int nr_all_type_units_reallocs;
261 } tu_stats;
262
263 /* A chain of compilation units that are currently read in, so that
264 they can be freed later. */
265 struct dwarf2_per_cu_data *read_in_chain;
266
267 /* A table mapping DW_AT_dwo_name values to struct dwo_file objects.
268 This is NULL if the table hasn't been allocated yet. */
269 htab_t dwo_files;
270
271 /* Non-zero if we've check for whether there is a DWP file. */
272 int dwp_checked;
273
274 /* The DWP file if there is one, or NULL. */
275 struct dwp_file *dwp_file;
276
277 /* The shared '.dwz' file, if one exists. This is used when the
278 original data was compressed using 'dwz -m'. */
279 struct dwz_file *dwz_file;
280
281 /* A flag indicating wether this objfile has a section loaded at a
282 VMA of 0. */
283 int has_section_at_zero;
284
285 /* True if we are using the mapped index,
286 or we are faking it for OBJF_READNOW's sake. */
287 unsigned char using_index;
288
289 /* The mapped index, or NULL if .gdb_index is missing or not being used. */
290 struct mapped_index *index_table;
291
292 /* When using index_table, this keeps track of all quick_file_names entries.
293 TUs typically share line table entries with a CU, so we maintain a
294 separate table of all line table entries to support the sharing.
295 Note that while there can be way more TUs than CUs, we've already
296 sorted all the TUs into "type unit groups", grouped by their
297 DW_AT_stmt_list value. Therefore the only sharing done here is with a
298 CU and its associated TU group if there is one. */
299 htab_t quick_file_names_table;
300
301 /* Set during partial symbol reading, to prevent queueing of full
302 symbols. */
303 int reading_partial_symbols;
304
305 /* Table mapping type DIEs to their struct type *.
306 This is NULL if not allocated yet.
307 The mapping is done via (CU/TU + DIE offset) -> type. */
308 htab_t die_type_hash;
309
310 /* The CUs we recently read. */
311 VEC (dwarf2_per_cu_ptr) *just_read_cus;
312 };
313
314 static struct dwarf2_per_objfile *dwarf2_per_objfile;
315
316 /* Default names of the debugging sections. */
317
318 /* Note that if the debugging section has been compressed, it might
319 have a name like .zdebug_info. */
320
321 static const struct dwarf2_debug_sections dwarf2_elf_names =
322 {
323 { ".debug_info", ".zdebug_info" },
324 { ".debug_abbrev", ".zdebug_abbrev" },
325 { ".debug_line", ".zdebug_line" },
326 { ".debug_loc", ".zdebug_loc" },
327 { ".debug_macinfo", ".zdebug_macinfo" },
328 { ".debug_macro", ".zdebug_macro" },
329 { ".debug_str", ".zdebug_str" },
330 { ".debug_ranges", ".zdebug_ranges" },
331 { ".debug_types", ".zdebug_types" },
332 { ".debug_addr", ".zdebug_addr" },
333 { ".debug_frame", ".zdebug_frame" },
334 { ".eh_frame", NULL },
335 { ".gdb_index", ".zgdb_index" },
336 23
337 };
338
339 /* List of DWO/DWP sections. */
340
341 static const struct dwop_section_names
342 {
343 struct dwarf2_section_names abbrev_dwo;
344 struct dwarf2_section_names info_dwo;
345 struct dwarf2_section_names line_dwo;
346 struct dwarf2_section_names loc_dwo;
347 struct dwarf2_section_names macinfo_dwo;
348 struct dwarf2_section_names macro_dwo;
349 struct dwarf2_section_names str_dwo;
350 struct dwarf2_section_names str_offsets_dwo;
351 struct dwarf2_section_names types_dwo;
352 struct dwarf2_section_names cu_index;
353 struct dwarf2_section_names tu_index;
354 }
355 dwop_section_names =
356 {
357 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
358 { ".debug_info.dwo", ".zdebug_info.dwo" },
359 { ".debug_line.dwo", ".zdebug_line.dwo" },
360 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
361 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
362 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
363 { ".debug_str.dwo", ".zdebug_str.dwo" },
364 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
365 { ".debug_types.dwo", ".zdebug_types.dwo" },
366 { ".debug_cu_index", ".zdebug_cu_index" },
367 { ".debug_tu_index", ".zdebug_tu_index" },
368 };
369
370 /* local data types */
371
372 /* The data in a compilation unit header, after target2host
373 translation, looks like this. */
374 struct comp_unit_head
375 {
376 unsigned int length;
377 short version;
378 unsigned char addr_size;
379 unsigned char signed_addr_p;
380 sect_offset abbrev_offset;
381
382 /* Size of file offsets; either 4 or 8. */
383 unsigned int offset_size;
384
385 /* Size of the length field; either 4 or 12. */
386 unsigned int initial_length_size;
387
388 /* Offset to the first byte of this compilation unit header in the
389 .debug_info section, for resolving relative reference dies. */
390 sect_offset offset;
391
392 /* Offset to first die in this cu from the start of the cu.
393 This will be the first byte following the compilation unit header. */
394 cu_offset first_die_offset;
395 };
396
397 /* Type used for delaying computation of method physnames.
398 See comments for compute_delayed_physnames. */
399 struct delayed_method_info
400 {
401 /* The type to which the method is attached, i.e., its parent class. */
402 struct type *type;
403
404 /* The index of the method in the type's function fieldlists. */
405 int fnfield_index;
406
407 /* The index of the method in the fieldlist. */
408 int index;
409
410 /* The name of the DIE. */
411 const char *name;
412
413 /* The DIE associated with this method. */
414 struct die_info *die;
415 };
416
417 typedef struct delayed_method_info delayed_method_info;
418 DEF_VEC_O (delayed_method_info);
419
420 /* Internal state when decoding a particular compilation unit. */
421 struct dwarf2_cu
422 {
423 /* The objfile containing this compilation unit. */
424 struct objfile *objfile;
425
426 /* The header of the compilation unit. */
427 struct comp_unit_head header;
428
429 /* Base address of this compilation unit. */
430 CORE_ADDR base_address;
431
432 /* Non-zero if base_address has been set. */
433 int base_known;
434
435 /* The language we are debugging. */
436 enum language language;
437 const struct language_defn *language_defn;
438
439 const char *producer;
440
441 /* The generic symbol table building routines have separate lists for
442 file scope symbols and all all other scopes (local scopes). So
443 we need to select the right one to pass to add_symbol_to_list().
444 We do it by keeping a pointer to the correct list in list_in_scope.
445
446 FIXME: The original dwarf code just treated the file scope as the
447 first local scope, and all other local scopes as nested local
448 scopes, and worked fine. Check to see if we really need to
449 distinguish these in buildsym.c. */
450 struct pending **list_in_scope;
451
452 /* The abbrev table for this CU.
453 Normally this points to the abbrev table in the objfile.
454 But if DWO_UNIT is non-NULL this is the abbrev table in the DWO file. */
455 struct abbrev_table *abbrev_table;
456
457 /* Hash table holding all the loaded partial DIEs
458 with partial_die->offset.SECT_OFF as hash. */
459 htab_t partial_dies;
460
461 /* Storage for things with the same lifetime as this read-in compilation
462 unit, including partial DIEs. */
463 struct obstack comp_unit_obstack;
464
465 /* When multiple dwarf2_cu structures are living in memory, this field
466 chains them all together, so that they can be released efficiently.
467 We will probably also want a generation counter so that most-recently-used
468 compilation units are cached... */
469 struct dwarf2_per_cu_data *read_in_chain;
470
471 /* Backlink to our per_cu entry. */
472 struct dwarf2_per_cu_data *per_cu;
473
474 /* How many compilation units ago was this CU last referenced? */
475 int last_used;
476
477 /* A hash table of DIE cu_offset for following references with
478 die_info->offset.sect_off as hash. */
479 htab_t die_hash;
480
481 /* Full DIEs if read in. */
482 struct die_info *dies;
483
484 /* A set of pointers to dwarf2_per_cu_data objects for compilation
485 units referenced by this one. Only set during full symbol processing;
486 partial symbol tables do not have dependencies. */
487 htab_t dependencies;
488
489 /* Header data from the line table, during full symbol processing. */
490 struct line_header *line_header;
491
492 /* A list of methods which need to have physnames computed
493 after all type information has been read. */
494 VEC (delayed_method_info) *method_list;
495
496 /* To be copied to symtab->call_site_htab. */
497 htab_t call_site_htab;
498
499 /* Non-NULL if this CU came from a DWO file.
500 There is an invariant here that is important to remember:
501 Except for attributes copied from the top level DIE in the "main"
502 (or "stub") file in preparation for reading the DWO file
503 (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
504 Either there isn't a DWO file (in which case this is NULL and the point
505 is moot), or there is and either we're not going to read it (in which
506 case this is NULL) or there is and we are reading it (in which case this
507 is non-NULL). */
508 struct dwo_unit *dwo_unit;
509
510 /* The DW_AT_addr_base attribute if present, zero otherwise
511 (zero is a valid value though).
512 Note this value comes from the Fission stub CU/TU's DIE. */
513 ULONGEST addr_base;
514
515 /* The DW_AT_ranges_base attribute if present, zero otherwise
516 (zero is a valid value though).
517 Note this value comes from the Fission stub CU/TU's DIE.
518 Also note that the value is zero in the non-DWO case so this value can
519 be used without needing to know whether DWO files are in use or not.
520 N.B. This does not apply to DW_AT_ranges appearing in
521 DW_TAG_compile_unit dies. This is a bit of a wart, consider if ever
522 DW_AT_ranges appeared in the DW_TAG_compile_unit of DWO DIEs: then
523 DW_AT_ranges_base *would* have to be applied, and we'd have to care
524 whether the DW_AT_ranges attribute came from the skeleton or DWO. */
525 ULONGEST ranges_base;
526
527 /* Mark used when releasing cached dies. */
528 unsigned int mark : 1;
529
530 /* This CU references .debug_loc. See the symtab->locations_valid field.
531 This test is imperfect as there may exist optimized debug code not using
532 any location list and still facing inlining issues if handled as
533 unoptimized code. For a future better test see GCC PR other/32998. */
534 unsigned int has_loclist : 1;
535
536 /* These cache the results for producer_is_* fields. CHECKED_PRODUCER is set
537 if all the producer_is_* fields are valid. This information is cached
538 because profiling CU expansion showed excessive time spent in
539 producer_is_gxx_lt_4_6. */
540 unsigned int checked_producer : 1;
541 unsigned int producer_is_gxx_lt_4_6 : 1;
542 unsigned int producer_is_gcc_lt_4_3 : 1;
543 unsigned int producer_is_icc : 1;
544
545 /* When set, the file that we're processing is known to have
546 debugging info for C++ namespaces. GCC 3.3.x did not produce
547 this information, but later versions do. */
548
549 unsigned int processing_has_namespace_info : 1;
550 };
551
552 /* Persistent data held for a compilation unit, even when not
553 processing it. We put a pointer to this structure in the
554 read_symtab_private field of the psymtab. */
555
556 struct dwarf2_per_cu_data
557 {
558 /* The start offset and length of this compilation unit.
559 NOTE: Unlike comp_unit_head.length, this length includes
560 initial_length_size.
561 If the DIE refers to a DWO file, this is always of the original die,
562 not the DWO file. */
563 sect_offset offset;
564 unsigned int length;
565
566 /* Flag indicating this compilation unit will be read in before
567 any of the current compilation units are processed. */
568 unsigned int queued : 1;
569
570 /* This flag will be set when reading partial DIEs if we need to load
571 absolutely all DIEs for this compilation unit, instead of just the ones
572 we think are interesting. It gets set if we look for a DIE in the
573 hash table and don't find it. */
574 unsigned int load_all_dies : 1;
575
576 /* Non-zero if this CU is from .debug_types.
577 Struct dwarf2_per_cu_data is contained in struct signatured_type iff
578 this is non-zero. */
579 unsigned int is_debug_types : 1;
580
581 /* Non-zero if this CU is from the .dwz file. */
582 unsigned int is_dwz : 1;
583
584 /* Non-zero if reading a TU directly from a DWO file, bypassing the stub.
585 This flag is only valid if is_debug_types is true.
586 We can't read a CU directly from a DWO file: There are required
587 attributes in the stub. */
588 unsigned int reading_dwo_directly : 1;
589
590 /* Non-zero if the TU has been read.
591 This is used to assist the "Stay in DWO Optimization" for Fission:
592 When reading a DWO, it's faster to read TUs from the DWO instead of
593 fetching them from random other DWOs (due to comdat folding).
594 If the TU has already been read, the optimization is unnecessary
595 (and unwise - we don't want to change where gdb thinks the TU lives
596 "midflight").
597 This flag is only valid if is_debug_types is true. */
598 unsigned int tu_read : 1;
599
600 /* The section this CU/TU lives in.
601 If the DIE refers to a DWO file, this is always the original die,
602 not the DWO file. */
603 struct dwarf2_section_info *section;
604
605 /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
606 of the CU cache it gets reset to NULL again. */
607 struct dwarf2_cu *cu;
608
609 /* The corresponding objfile.
610 Normally we can get the objfile from dwarf2_per_objfile.
611 However we can enter this file with just a "per_cu" handle. */
612 struct objfile *objfile;
613
614 /* When dwarf2_per_objfile->using_index is true, the 'quick' field
615 is active. Otherwise, the 'psymtab' field is active. */
616 union
617 {
618 /* The partial symbol table associated with this compilation unit,
619 or NULL for unread partial units. */
620 struct partial_symtab *psymtab;
621
622 /* Data needed by the "quick" functions. */
623 struct dwarf2_per_cu_quick_data *quick;
624 } v;
625
626 /* The CUs we import using DW_TAG_imported_unit. This is filled in
627 while reading psymtabs, used to compute the psymtab dependencies,
628 and then cleared. Then it is filled in again while reading full
629 symbols, and only deleted when the objfile is destroyed.
630
631 This is also used to work around a difference between the way gold
632 generates .gdb_index version <=7 and the way gdb does. Arguably this
633 is a gold bug. For symbols coming from TUs, gold records in the index
634 the CU that includes the TU instead of the TU itself. This breaks
635 dw2_lookup_symbol: It assumes that if the index says symbol X lives
636 in CU/TU Y, then one need only expand Y and a subsequent lookup in Y
637 will find X. Alas TUs live in their own symtab, so after expanding CU Y
638 we need to look in TU Z to find X. Fortunately, this is akin to
639 DW_TAG_imported_unit, so we just use the same mechanism: For
640 .gdb_index version <=7 this also records the TUs that the CU referred
641 to. Concurrently with this change gdb was modified to emit version 8
642 indices so we only pay a price for gold generated indices.
643 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
644 VEC (dwarf2_per_cu_ptr) *imported_symtabs;
645 };
646
647 /* Entry in the signatured_types hash table. */
648
649 struct signatured_type
650 {
651 /* The "per_cu" object of this type.
652 This struct is used iff per_cu.is_debug_types.
653 N.B.: This is the first member so that it's easy to convert pointers
654 between them. */
655 struct dwarf2_per_cu_data per_cu;
656
657 /* The type's signature. */
658 ULONGEST signature;
659
660 /* Offset in the TU of the type's DIE, as read from the TU header.
661 If this TU is a DWO stub and the definition lives in a DWO file
662 (specified by DW_AT_GNU_dwo_name), this value is unusable. */
663 cu_offset type_offset_in_tu;
664
665 /* Offset in the section of the type's DIE.
666 If the definition lives in a DWO file, this is the offset in the
667 .debug_types.dwo section.
668 The value is zero until the actual value is known.
669 Zero is otherwise not a valid section offset. */
670 sect_offset type_offset_in_section;
671
672 /* Type units are grouped by their DW_AT_stmt_list entry so that they
673 can share them. This points to the containing symtab. */
674 struct type_unit_group *type_unit_group;
675
676 /* The type.
677 The first time we encounter this type we fully read it in and install it
678 in the symbol tables. Subsequent times we only need the type. */
679 struct type *type;
680
681 /* Containing DWO unit.
682 This field is valid iff per_cu.reading_dwo_directly. */
683 struct dwo_unit *dwo_unit;
684 };
685
686 typedef struct signatured_type *sig_type_ptr;
687 DEF_VEC_P (sig_type_ptr);
688
689 /* A struct that can be used as a hash key for tables based on DW_AT_stmt_list.
690 This includes type_unit_group and quick_file_names. */
691
692 struct stmt_list_hash
693 {
694 /* The DWO unit this table is from or NULL if there is none. */
695 struct dwo_unit *dwo_unit;
696
697 /* Offset in .debug_line or .debug_line.dwo. */
698 sect_offset line_offset;
699 };
700
701 /* Each element of dwarf2_per_objfile->type_unit_groups is a pointer to
702 an object of this type. */
703
704 struct type_unit_group
705 {
706 /* dwarf2read.c's main "handle" on a TU symtab.
707 To simplify things we create an artificial CU that "includes" all the
708 type units using this stmt_list so that the rest of the code still has
709 a "per_cu" handle on the symtab.
710 This PER_CU is recognized by having no section. */
711 #define IS_TYPE_UNIT_GROUP(per_cu) ((per_cu)->section == NULL)
712 struct dwarf2_per_cu_data per_cu;
713
714 /* The TUs that share this DW_AT_stmt_list entry.
715 This is added to while parsing type units to build partial symtabs,
716 and is deleted afterwards and not used again. */
717 VEC (sig_type_ptr) *tus;
718
719 /* The primary symtab.
720 Type units in a group needn't all be defined in the same source file,
721 so we create an essentially anonymous symtab as the primary symtab. */
722 struct symtab *primary_symtab;
723
724 /* The data used to construct the hash key. */
725 struct stmt_list_hash hash;
726
727 /* The number of symtabs from the line header.
728 The value here must match line_header.num_file_names. */
729 unsigned int num_symtabs;
730
731 /* The symbol tables for this TU (obtained from the files listed in
732 DW_AT_stmt_list).
733 WARNING: The order of entries here must match the order of entries
734 in the line header. After the first TU using this type_unit_group, the
735 line header for the subsequent TUs is recreated from this. This is done
736 because we need to use the same symtabs for each TU using the same
737 DW_AT_stmt_list value. Also note that symtabs may be repeated here,
738 there's no guarantee the line header doesn't have duplicate entries. */
739 struct symtab **symtabs;
740 };
741
742 /* These sections are what may appear in a (real or virtual) DWO file. */
743
744 struct dwo_sections
745 {
746 struct dwarf2_section_info abbrev;
747 struct dwarf2_section_info line;
748 struct dwarf2_section_info loc;
749 struct dwarf2_section_info macinfo;
750 struct dwarf2_section_info macro;
751 struct dwarf2_section_info str;
752 struct dwarf2_section_info str_offsets;
753 /* In the case of a virtual DWO file, these two are unused. */
754 struct dwarf2_section_info info;
755 VEC (dwarf2_section_info_def) *types;
756 };
757
758 /* CUs/TUs in DWP/DWO files. */
759
760 struct dwo_unit
761 {
762 /* Backlink to the containing struct dwo_file. */
763 struct dwo_file *dwo_file;
764
765 /* The "id" that distinguishes this CU/TU.
766 .debug_info calls this "dwo_id", .debug_types calls this "signature".
767 Since signatures came first, we stick with it for consistency. */
768 ULONGEST signature;
769
770 /* The section this CU/TU lives in, in the DWO file. */
771 struct dwarf2_section_info *section;
772
773 /* Same as dwarf2_per_cu_data:{offset,length} but in the DWO section. */
774 sect_offset offset;
775 unsigned int length;
776
777 /* For types, offset in the type's DIE of the type defined by this TU. */
778 cu_offset type_offset_in_tu;
779 };
780
781 /* include/dwarf2.h defines the DWP section codes.
782 It defines a max value but it doesn't define a min value, which we
783 use for error checking, so provide one. */
784
785 enum dwp_v2_section_ids
786 {
787 DW_SECT_MIN = 1
788 };
789
790 /* Data for one DWO file.
791
792 This includes virtual DWO files (a virtual DWO file is a DWO file as it
793 appears in a DWP file). DWP files don't really have DWO files per se -
794 comdat folding of types "loses" the DWO file they came from, and from
795 a high level view DWP files appear to contain a mass of random types.
796 However, to maintain consistency with the non-DWP case we pretend DWP
797 files contain virtual DWO files, and we assign each TU with one virtual
798 DWO file (generally based on the line and abbrev section offsets -
799 a heuristic that seems to work in practice). */
800
801 struct dwo_file
802 {
803 /* The DW_AT_GNU_dwo_name attribute.
804 For virtual DWO files the name is constructed from the section offsets
805 of abbrev,line,loc,str_offsets so that we combine virtual DWO files
806 from related CU+TUs. */
807 const char *dwo_name;
808
809 /* The DW_AT_comp_dir attribute. */
810 const char *comp_dir;
811
812 /* The bfd, when the file is open. Otherwise this is NULL.
813 This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */
814 bfd *dbfd;
815
816 /* The sections that make up this DWO file.
817 Remember that for virtual DWO files in DWP V2, these are virtual
818 sections (for lack of a better name). */
819 struct dwo_sections sections;
820
821 /* The CU in the file.
822 We only support one because having more than one requires hacking the
823 dwo_name of each to match, which is highly unlikely to happen.
824 Doing this means all TUs can share comp_dir: We also assume that
825 DW_AT_comp_dir across all TUs in a DWO file will be identical. */
826 struct dwo_unit *cu;
827
828 /* Table of TUs in the file.
829 Each element is a struct dwo_unit. */
830 htab_t tus;
831 };
832
833 /* These sections are what may appear in a DWP file. */
834
835 struct dwp_sections
836 {
837 /* These are used by both DWP version 1 and 2. */
838 struct dwarf2_section_info str;
839 struct dwarf2_section_info cu_index;
840 struct dwarf2_section_info tu_index;
841
842 /* These are only used by DWP version 2 files.
843 In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other
844 sections are referenced by section number, and are not recorded here.
845 In DWP version 2 there is at most one copy of all these sections, each
846 section being (effectively) comprised of the concatenation of all of the
847 individual sections that exist in the version 1 format.
848 To keep the code simple we treat each of these concatenated pieces as a
849 section itself (a virtual section?). */
850 struct dwarf2_section_info abbrev;
851 struct dwarf2_section_info info;
852 struct dwarf2_section_info line;
853 struct dwarf2_section_info loc;
854 struct dwarf2_section_info macinfo;
855 struct dwarf2_section_info macro;
856 struct dwarf2_section_info str_offsets;
857 struct dwarf2_section_info types;
858 };
859
860 /* These sections are what may appear in a virtual DWO file in DWP version 1.
861 A virtual DWO file is a DWO file as it appears in a DWP file. */
862
863 struct virtual_v1_dwo_sections
864 {
865 struct dwarf2_section_info abbrev;
866 struct dwarf2_section_info line;
867 struct dwarf2_section_info loc;
868 struct dwarf2_section_info macinfo;
869 struct dwarf2_section_info macro;
870 struct dwarf2_section_info str_offsets;
871 /* Each DWP hash table entry records one CU or one TU.
872 That is recorded here, and copied to dwo_unit.section. */
873 struct dwarf2_section_info info_or_types;
874 };
875
876 /* Similar to virtual_v1_dwo_sections, but for DWP version 2.
877 In version 2, the sections of the DWO files are concatenated together
878 and stored in one section of that name. Thus each ELF section contains
879 several "virtual" sections. */
880
881 struct virtual_v2_dwo_sections
882 {
883 bfd_size_type abbrev_offset;
884 bfd_size_type abbrev_size;
885
886 bfd_size_type line_offset;
887 bfd_size_type line_size;
888
889 bfd_size_type loc_offset;
890 bfd_size_type loc_size;
891
892 bfd_size_type macinfo_offset;
893 bfd_size_type macinfo_size;
894
895 bfd_size_type macro_offset;
896 bfd_size_type macro_size;
897
898 bfd_size_type str_offsets_offset;
899 bfd_size_type str_offsets_size;
900
901 /* Each DWP hash table entry records one CU or one TU.
902 That is recorded here, and copied to dwo_unit.section. */
903 bfd_size_type info_or_types_offset;
904 bfd_size_type info_or_types_size;
905 };
906
907 /* Contents of DWP hash tables. */
908
909 struct dwp_hash_table
910 {
911 uint32_t version, nr_columns;
912 uint32_t nr_units, nr_slots;
913 const gdb_byte *hash_table, *unit_table;
914 union
915 {
916 struct
917 {
918 const gdb_byte *indices;
919 } v1;
920 struct
921 {
922 /* This is indexed by column number and gives the id of the section
923 in that column. */
924 #define MAX_NR_V2_DWO_SECTIONS \
925 (1 /* .debug_info or .debug_types */ \
926 + 1 /* .debug_abbrev */ \
927 + 1 /* .debug_line */ \
928 + 1 /* .debug_loc */ \
929 + 1 /* .debug_str_offsets */ \
930 + 1 /* .debug_macro or .debug_macinfo */)
931 int section_ids[MAX_NR_V2_DWO_SECTIONS];
932 const gdb_byte *offsets;
933 const gdb_byte *sizes;
934 } v2;
935 } section_pool;
936 };
937
938 /* Data for one DWP file. */
939
940 struct dwp_file
941 {
942 /* Name of the file. */
943 const char *name;
944
945 /* File format version. */
946 int version;
947
948 /* The bfd. */
949 bfd *dbfd;
950
951 /* Section info for this file. */
952 struct dwp_sections sections;
953
954 /* Table of CUs in the file. */
955 const struct dwp_hash_table *cus;
956
957 /* Table of TUs in the file. */
958 const struct dwp_hash_table *tus;
959
960 /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
961 htab_t loaded_cus;
962 htab_t loaded_tus;
963
964 /* Table to map ELF section numbers to their sections.
965 This is only needed for the DWP V1 file format. */
966 unsigned int num_sections;
967 asection **elf_sections;
968 };
969
970 /* This represents a '.dwz' file. */
971
972 struct dwz_file
973 {
974 /* A dwz file can only contain a few sections. */
975 struct dwarf2_section_info abbrev;
976 struct dwarf2_section_info info;
977 struct dwarf2_section_info str;
978 struct dwarf2_section_info line;
979 struct dwarf2_section_info macro;
980 struct dwarf2_section_info gdb_index;
981
982 /* The dwz's BFD. */
983 bfd *dwz_bfd;
984 };
985
986 /* Struct used to pass misc. parameters to read_die_and_children, et
987 al. which are used for both .debug_info and .debug_types dies.
988 All parameters here are unchanging for the life of the call. This
989 struct exists to abstract away the constant parameters of die reading. */
990
991 struct die_reader_specs
992 {
993 /* The bfd of die_section. */
994 bfd* abfd;
995
996 /* The CU of the DIE we are parsing. */
997 struct dwarf2_cu *cu;
998
999 /* Non-NULL if reading a DWO file (including one packaged into a DWP). */
1000 struct dwo_file *dwo_file;
1001
1002 /* The section the die comes from.
1003 This is either .debug_info or .debug_types, or the .dwo variants. */
1004 struct dwarf2_section_info *die_section;
1005
1006 /* die_section->buffer. */
1007 const gdb_byte *buffer;
1008
1009 /* The end of the buffer. */
1010 const gdb_byte *buffer_end;
1011
1012 /* The value of the DW_AT_comp_dir attribute. */
1013 const char *comp_dir;
1014 };
1015
1016 /* Type of function passed to init_cutu_and_read_dies, et.al. */
1017 typedef void (die_reader_func_ftype) (const struct die_reader_specs *reader,
1018 const gdb_byte *info_ptr,
1019 struct die_info *comp_unit_die,
1020 int has_children,
1021 void *data);
1022
1023 /* The line number information for a compilation unit (found in the
1024 .debug_line section) begins with a "statement program header",
1025 which contains the following information. */
1026 struct line_header
1027 {
1028 unsigned int total_length;
1029 unsigned short version;
1030 unsigned int header_length;
1031 unsigned char minimum_instruction_length;
1032 unsigned char maximum_ops_per_instruction;
1033 unsigned char default_is_stmt;
1034 int line_base;
1035 unsigned char line_range;
1036 unsigned char opcode_base;
1037
1038 /* standard_opcode_lengths[i] is the number of operands for the
1039 standard opcode whose value is i. This means that
1040 standard_opcode_lengths[0] is unused, and the last meaningful
1041 element is standard_opcode_lengths[opcode_base - 1]. */
1042 unsigned char *standard_opcode_lengths;
1043
1044 /* The include_directories table. NOTE! These strings are not
1045 allocated with xmalloc; instead, they are pointers into
1046 debug_line_buffer. If you try to free them, `free' will get
1047 indigestion. */
1048 unsigned int num_include_dirs, include_dirs_size;
1049 const char **include_dirs;
1050
1051 /* The file_names table. NOTE! These strings are not allocated
1052 with xmalloc; instead, they are pointers into debug_line_buffer.
1053 Don't try to free them directly. */
1054 unsigned int num_file_names, file_names_size;
1055 struct file_entry
1056 {
1057 const char *name;
1058 unsigned int dir_index;
1059 unsigned int mod_time;
1060 unsigned int length;
1061 int included_p; /* Non-zero if referenced by the Line Number Program. */
1062 struct symtab *symtab; /* The associated symbol table, if any. */
1063 } *file_names;
1064
1065 /* The start and end of the statement program following this
1066 header. These point into dwarf2_per_objfile->line_buffer. */
1067 const gdb_byte *statement_program_start, *statement_program_end;
1068 };
1069
1070 /* When we construct a partial symbol table entry we only
1071 need this much information. */
1072 struct partial_die_info
1073 {
1074 /* Offset of this DIE. */
1075 sect_offset offset;
1076
1077 /* DWARF-2 tag for this DIE. */
1078 ENUM_BITFIELD(dwarf_tag) tag : 16;
1079
1080 /* Assorted flags describing the data found in this DIE. */
1081 unsigned int has_children : 1;
1082 unsigned int is_external : 1;
1083 unsigned int is_declaration : 1;
1084 unsigned int has_type : 1;
1085 unsigned int has_specification : 1;
1086 unsigned int has_pc_info : 1;
1087 unsigned int may_be_inlined : 1;
1088
1089 /* Flag set if the SCOPE field of this structure has been
1090 computed. */
1091 unsigned int scope_set : 1;
1092
1093 /* Flag set if the DIE has a byte_size attribute. */
1094 unsigned int has_byte_size : 1;
1095
1096 /* Flag set if any of the DIE's children are template arguments. */
1097 unsigned int has_template_arguments : 1;
1098
1099 /* Flag set if fixup_partial_die has been called on this die. */
1100 unsigned int fixup_called : 1;
1101
1102 /* Flag set if DW_TAG_imported_unit uses DW_FORM_GNU_ref_alt. */
1103 unsigned int is_dwz : 1;
1104
1105 /* Flag set if spec_offset uses DW_FORM_GNU_ref_alt. */
1106 unsigned int spec_is_dwz : 1;
1107
1108 /* The name of this DIE. Normally the value of DW_AT_name, but
1109 sometimes a default name for unnamed DIEs. */
1110 const char *name;
1111
1112 /* The linkage name, if present. */
1113 const char *linkage_name;
1114
1115 /* The scope to prepend to our children. This is generally
1116 allocated on the comp_unit_obstack, so will disappear
1117 when this compilation unit leaves the cache. */
1118 const char *scope;
1119
1120 /* Some data associated with the partial DIE. The tag determines
1121 which field is live. */
1122 union
1123 {
1124 /* The location description associated with this DIE, if any. */
1125 struct dwarf_block *locdesc;
1126 /* The offset of an import, for DW_TAG_imported_unit. */
1127 sect_offset offset;
1128 } d;
1129
1130 /* If HAS_PC_INFO, the PC range associated with this DIE. */
1131 CORE_ADDR lowpc;
1132 CORE_ADDR highpc;
1133
1134 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
1135 DW_AT_sibling, if any. */
1136 /* NOTE: This member isn't strictly necessary, read_partial_die could
1137 return DW_AT_sibling values to its caller load_partial_dies. */
1138 const gdb_byte *sibling;
1139
1140 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
1141 DW_AT_specification (or DW_AT_abstract_origin or
1142 DW_AT_extension). */
1143 sect_offset spec_offset;
1144
1145 /* Pointers to this DIE's parent, first child, and next sibling,
1146 if any. */
1147 struct partial_die_info *die_parent, *die_child, *die_sibling;
1148 };
1149
1150 /* This data structure holds the information of an abbrev. */
1151 struct abbrev_info
1152 {
1153 unsigned int number; /* number identifying abbrev */
1154 enum dwarf_tag tag; /* dwarf tag */
1155 unsigned short has_children; /* boolean */
1156 unsigned short num_attrs; /* number of attributes */
1157 struct attr_abbrev *attrs; /* an array of attribute descriptions */
1158 struct abbrev_info *next; /* next in chain */
1159 };
1160
1161 struct attr_abbrev
1162 {
1163 ENUM_BITFIELD(dwarf_attribute) name : 16;
1164 ENUM_BITFIELD(dwarf_form) form : 16;
1165 };
1166
1167 /* Size of abbrev_table.abbrev_hash_table. */
1168 #define ABBREV_HASH_SIZE 121
1169
1170 /* Top level data structure to contain an abbreviation table. */
1171
1172 struct abbrev_table
1173 {
1174 /* Where the abbrev table came from.
1175 This is used as a sanity check when the table is used. */
1176 sect_offset offset;
1177
1178 /* Storage for the abbrev table. */
1179 struct obstack abbrev_obstack;
1180
1181 /* Hash table of abbrevs.
1182 This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
1183 It could be statically allocated, but the previous code didn't so we
1184 don't either. */
1185 struct abbrev_info **abbrevs;
1186 };
1187
1188 /* Attributes have a name and a value. */
1189 struct attribute
1190 {
1191 ENUM_BITFIELD(dwarf_attribute) name : 16;
1192 ENUM_BITFIELD(dwarf_form) form : 15;
1193
1194 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
1195 field should be in u.str (existing only for DW_STRING) but it is kept
1196 here for better struct attribute alignment. */
1197 unsigned int string_is_canonical : 1;
1198
1199 union
1200 {
1201 const char *str;
1202 struct dwarf_block *blk;
1203 ULONGEST unsnd;
1204 LONGEST snd;
1205 CORE_ADDR addr;
1206 ULONGEST signature;
1207 }
1208 u;
1209 };
1210
1211 /* This data structure holds a complete die structure. */
1212 struct die_info
1213 {
1214 /* DWARF-2 tag for this DIE. */
1215 ENUM_BITFIELD(dwarf_tag) tag : 16;
1216
1217 /* Number of attributes */
1218 unsigned char num_attrs;
1219
1220 /* True if we're presently building the full type name for the
1221 type derived from this DIE. */
1222 unsigned char building_fullname : 1;
1223
1224 /* True if this die is in process. PR 16581. */
1225 unsigned char in_process : 1;
1226
1227 /* Abbrev number */
1228 unsigned int abbrev;
1229
1230 /* Offset in .debug_info or .debug_types section. */
1231 sect_offset offset;
1232
1233 /* The dies in a compilation unit form an n-ary tree. PARENT
1234 points to this die's parent; CHILD points to the first child of
1235 this node; and all the children of a given node are chained
1236 together via their SIBLING fields. */
1237 struct die_info *child; /* Its first child, if any. */
1238 struct die_info *sibling; /* Its next sibling, if any. */
1239 struct die_info *parent; /* Its parent, if any. */
1240
1241 /* An array of attributes, with NUM_ATTRS elements. There may be
1242 zero, but it's not common and zero-sized arrays are not
1243 sufficiently portable C. */
1244 struct attribute attrs[1];
1245 };
1246
1247 /* Get at parts of an attribute structure. */
1248
1249 #define DW_STRING(attr) ((attr)->u.str)
1250 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
1251 #define DW_UNSND(attr) ((attr)->u.unsnd)
1252 #define DW_BLOCK(attr) ((attr)->u.blk)
1253 #define DW_SND(attr) ((attr)->u.snd)
1254 #define DW_ADDR(attr) ((attr)->u.addr)
1255 #define DW_SIGNATURE(attr) ((attr)->u.signature)
1256
1257 /* Blocks are a bunch of untyped bytes. */
1258 struct dwarf_block
1259 {
1260 size_t size;
1261
1262 /* Valid only if SIZE is not zero. */
1263 const gdb_byte *data;
1264 };
1265
1266 #ifndef ATTR_ALLOC_CHUNK
1267 #define ATTR_ALLOC_CHUNK 4
1268 #endif
1269
1270 /* Allocate fields for structs, unions and enums in this size. */
1271 #ifndef DW_FIELD_ALLOC_CHUNK
1272 #define DW_FIELD_ALLOC_CHUNK 4
1273 #endif
1274
1275 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
1276 but this would require a corresponding change in unpack_field_as_long
1277 and friends. */
1278 static int bits_per_byte = 8;
1279
1280 /* The routines that read and process dies for a C struct or C++ class
1281 pass lists of data member fields and lists of member function fields
1282 in an instance of a field_info structure, as defined below. */
1283 struct field_info
1284 {
1285 /* List of data member and baseclasses fields. */
1286 struct nextfield
1287 {
1288 struct nextfield *next;
1289 int accessibility;
1290 int virtuality;
1291 struct field field;
1292 }
1293 *fields, *baseclasses;
1294
1295 /* Number of fields (including baseclasses). */
1296 int nfields;
1297
1298 /* Number of baseclasses. */
1299 int nbaseclasses;
1300
1301 /* Set if the accesibility of one of the fields is not public. */
1302 int non_public_fields;
1303
1304 /* Member function fields array, entries are allocated in the order they
1305 are encountered in the object file. */
1306 struct nextfnfield
1307 {
1308 struct nextfnfield *next;
1309 struct fn_field fnfield;
1310 }
1311 *fnfields;
1312
1313 /* Member function fieldlist array, contains name of possibly overloaded
1314 member function, number of overloaded member functions and a pointer
1315 to the head of the member function field chain. */
1316 struct fnfieldlist
1317 {
1318 const char *name;
1319 int length;
1320 struct nextfnfield *head;
1321 }
1322 *fnfieldlists;
1323
1324 /* Number of entries in the fnfieldlists array. */
1325 int nfnfields;
1326
1327 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
1328 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
1329 struct typedef_field_list
1330 {
1331 struct typedef_field field;
1332 struct typedef_field_list *next;
1333 }
1334 *typedef_field_list;
1335 unsigned typedef_field_list_count;
1336 };
1337
1338 /* One item on the queue of compilation units to read in full symbols
1339 for. */
1340 struct dwarf2_queue_item
1341 {
1342 struct dwarf2_per_cu_data *per_cu;
1343 enum language pretend_language;
1344 struct dwarf2_queue_item *next;
1345 };
1346
1347 /* The current queue. */
1348 static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail;
1349
1350 /* Loaded secondary compilation units are kept in memory until they
1351 have not been referenced for the processing of this many
1352 compilation units. Set this to zero to disable caching. Cache
1353 sizes of up to at least twenty will improve startup time for
1354 typical inter-CU-reference binaries, at an obvious memory cost. */
1355 static int dwarf2_max_cache_age = 5;
1356 static void
1357 show_dwarf2_max_cache_age (struct ui_file *file, int from_tty,
1358 struct cmd_list_element *c, const char *value)
1359 {
1360 fprintf_filtered (file, _("The upper bound on the age of cached "
1361 "dwarf2 compilation units is %s.\n"),
1362 value);
1363 }
1364 \f
1365 /* local function prototypes */
1366
1367 static const char *get_section_name (const struct dwarf2_section_info *);
1368
1369 static const char *get_section_file_name (const struct dwarf2_section_info *);
1370
1371 static void dwarf2_locate_sections (bfd *, asection *, void *);
1372
1373 static void dwarf2_find_base_address (struct die_info *die,
1374 struct dwarf2_cu *cu);
1375
1376 static struct partial_symtab *create_partial_symtab
1377 (struct dwarf2_per_cu_data *per_cu, const char *name);
1378
1379 static void dwarf2_build_psymtabs_hard (struct objfile *);
1380
1381 static void scan_partial_symbols (struct partial_die_info *,
1382 CORE_ADDR *, CORE_ADDR *,
1383 int, struct dwarf2_cu *);
1384
1385 static void add_partial_symbol (struct partial_die_info *,
1386 struct dwarf2_cu *);
1387
1388 static void add_partial_namespace (struct partial_die_info *pdi,
1389 CORE_ADDR *lowpc, CORE_ADDR *highpc,
1390 int set_addrmap, struct dwarf2_cu *cu);
1391
1392 static void add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
1393 CORE_ADDR *highpc, int set_addrmap,
1394 struct dwarf2_cu *cu);
1395
1396 static void add_partial_enumeration (struct partial_die_info *enum_pdi,
1397 struct dwarf2_cu *cu);
1398
1399 static void add_partial_subprogram (struct partial_die_info *pdi,
1400 CORE_ADDR *lowpc, CORE_ADDR *highpc,
1401 int need_pc, struct dwarf2_cu *cu);
1402
1403 static void dwarf2_read_symtab (struct partial_symtab *,
1404 struct objfile *);
1405
1406 static void psymtab_to_symtab_1 (struct partial_symtab *);
1407
1408 static struct abbrev_info *abbrev_table_lookup_abbrev
1409 (const struct abbrev_table *, unsigned int);
1410
1411 static struct abbrev_table *abbrev_table_read_table
1412 (struct dwarf2_section_info *, sect_offset);
1413
1414 static void abbrev_table_free (struct abbrev_table *);
1415
1416 static void abbrev_table_free_cleanup (void *);
1417
1418 static void dwarf2_read_abbrevs (struct dwarf2_cu *,
1419 struct dwarf2_section_info *);
1420
1421 static void dwarf2_free_abbrev_table (void *);
1422
1423 static unsigned int peek_abbrev_code (bfd *, const gdb_byte *);
1424
1425 static struct partial_die_info *load_partial_dies
1426 (const struct die_reader_specs *, const gdb_byte *, int);
1427
1428 static const gdb_byte *read_partial_die (const struct die_reader_specs *,
1429 struct partial_die_info *,
1430 struct abbrev_info *,
1431 unsigned int,
1432 const gdb_byte *);
1433
1434 static struct partial_die_info *find_partial_die (sect_offset, int,
1435 struct dwarf2_cu *);
1436
1437 static void fixup_partial_die (struct partial_die_info *,
1438 struct dwarf2_cu *);
1439
1440 static const gdb_byte *read_attribute (const struct die_reader_specs *,
1441 struct attribute *, struct attr_abbrev *,
1442 const gdb_byte *);
1443
1444 static unsigned int read_1_byte (bfd *, const gdb_byte *);
1445
1446 static int read_1_signed_byte (bfd *, const gdb_byte *);
1447
1448 static unsigned int read_2_bytes (bfd *, const gdb_byte *);
1449
1450 static unsigned int read_4_bytes (bfd *, const gdb_byte *);
1451
1452 static ULONGEST read_8_bytes (bfd *, const gdb_byte *);
1453
1454 static CORE_ADDR read_address (bfd *, const gdb_byte *ptr, struct dwarf2_cu *,
1455 unsigned int *);
1456
1457 static LONGEST read_initial_length (bfd *, const gdb_byte *, unsigned int *);
1458
1459 static LONGEST read_checked_initial_length_and_offset
1460 (bfd *, const gdb_byte *, const struct comp_unit_head *,
1461 unsigned int *, unsigned int *);
1462
1463 static LONGEST read_offset (bfd *, const gdb_byte *,
1464 const struct comp_unit_head *,
1465 unsigned int *);
1466
1467 static LONGEST read_offset_1 (bfd *, const gdb_byte *, unsigned int);
1468
1469 static sect_offset read_abbrev_offset (struct dwarf2_section_info *,
1470 sect_offset);
1471
1472 static const gdb_byte *read_n_bytes (bfd *, const gdb_byte *, unsigned int);
1473
1474 static const char *read_direct_string (bfd *, const gdb_byte *, unsigned int *);
1475
1476 static const char *read_indirect_string (bfd *, const gdb_byte *,
1477 const struct comp_unit_head *,
1478 unsigned int *);
1479
1480 static const char *read_indirect_string_from_dwz (struct dwz_file *, LONGEST);
1481
1482 static ULONGEST read_unsigned_leb128 (bfd *, const gdb_byte *, unsigned int *);
1483
1484 static LONGEST read_signed_leb128 (bfd *, const gdb_byte *, unsigned int *);
1485
1486 static CORE_ADDR read_addr_index_from_leb128 (struct dwarf2_cu *,
1487 const gdb_byte *,
1488 unsigned int *);
1489
1490 static const char *read_str_index (const struct die_reader_specs *reader,
1491 ULONGEST str_index);
1492
1493 static void set_cu_language (unsigned int, struct dwarf2_cu *);
1494
1495 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
1496 struct dwarf2_cu *);
1497
1498 static struct attribute *dwarf2_attr_no_follow (struct die_info *,
1499 unsigned int);
1500
1501 static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
1502 struct dwarf2_cu *cu);
1503
1504 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
1505
1506 static struct die_info *die_specification (struct die_info *die,
1507 struct dwarf2_cu **);
1508
1509 static void free_line_header (struct line_header *lh);
1510
1511 static struct line_header *dwarf_decode_line_header (unsigned int offset,
1512 struct dwarf2_cu *cu);
1513
1514 static void dwarf_decode_lines (struct line_header *, const char *,
1515 struct dwarf2_cu *, struct partial_symtab *,
1516 int);
1517
1518 static void dwarf2_start_subfile (const char *, const char *, const char *);
1519
1520 static void dwarf2_start_symtab (struct dwarf2_cu *,
1521 const char *, const char *, CORE_ADDR);
1522
1523 static struct symbol *new_symbol (struct die_info *, struct type *,
1524 struct dwarf2_cu *);
1525
1526 static struct symbol *new_symbol_full (struct die_info *, struct type *,
1527 struct dwarf2_cu *, struct symbol *);
1528
1529 static void dwarf2_const_value (const struct attribute *, struct symbol *,
1530 struct dwarf2_cu *);
1531
1532 static void dwarf2_const_value_attr (const struct attribute *attr,
1533 struct type *type,
1534 const char *name,
1535 struct obstack *obstack,
1536 struct dwarf2_cu *cu, LONGEST *value,
1537 const gdb_byte **bytes,
1538 struct dwarf2_locexpr_baton **baton);
1539
1540 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
1541
1542 static int need_gnat_info (struct dwarf2_cu *);
1543
1544 static struct type *die_descriptive_type (struct die_info *,
1545 struct dwarf2_cu *);
1546
1547 static void set_descriptive_type (struct type *, struct die_info *,
1548 struct dwarf2_cu *);
1549
1550 static struct type *die_containing_type (struct die_info *,
1551 struct dwarf2_cu *);
1552
1553 static struct type *lookup_die_type (struct die_info *, const struct attribute *,
1554 struct dwarf2_cu *);
1555
1556 static struct type *read_type_die (struct die_info *, struct dwarf2_cu *);
1557
1558 static struct type *read_type_die_1 (struct die_info *, struct dwarf2_cu *);
1559
1560 static const char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
1561
1562 static char *typename_concat (struct obstack *obs, const char *prefix,
1563 const char *suffix, int physname,
1564 struct dwarf2_cu *cu);
1565
1566 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
1567
1568 static void read_type_unit_scope (struct die_info *, struct dwarf2_cu *);
1569
1570 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
1571
1572 static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
1573
1574 static void read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu);
1575
1576 static int dwarf2_ranges_read (unsigned, CORE_ADDR *, CORE_ADDR *,
1577 struct dwarf2_cu *, struct partial_symtab *);
1578
1579 static int dwarf2_get_pc_bounds (struct die_info *,
1580 CORE_ADDR *, CORE_ADDR *, struct dwarf2_cu *,
1581 struct partial_symtab *);
1582
1583 static void get_scope_pc_bounds (struct die_info *,
1584 CORE_ADDR *, CORE_ADDR *,
1585 struct dwarf2_cu *);
1586
1587 static void dwarf2_record_block_ranges (struct die_info *, struct block *,
1588 CORE_ADDR, struct dwarf2_cu *);
1589
1590 static void dwarf2_add_field (struct field_info *, struct die_info *,
1591 struct dwarf2_cu *);
1592
1593 static void dwarf2_attach_fields_to_type (struct field_info *,
1594 struct type *, struct dwarf2_cu *);
1595
1596 static void dwarf2_add_member_fn (struct field_info *,
1597 struct die_info *, struct type *,
1598 struct dwarf2_cu *);
1599
1600 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
1601 struct type *,
1602 struct dwarf2_cu *);
1603
1604 static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
1605
1606 static void read_common_block (struct die_info *, struct dwarf2_cu *);
1607
1608 static void read_namespace (struct die_info *die, struct dwarf2_cu *);
1609
1610 static void read_module (struct die_info *die, struct dwarf2_cu *cu);
1611
1612 static void read_import_statement (struct die_info *die, struct dwarf2_cu *);
1613
1614 static int read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu);
1615
1616 static struct type *read_module_type (struct die_info *die,
1617 struct dwarf2_cu *cu);
1618
1619 static const char *namespace_name (struct die_info *die,
1620 int *is_anonymous, struct dwarf2_cu *);
1621
1622 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
1623
1624 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
1625
1626 static enum dwarf_array_dim_ordering read_array_order (struct die_info *,
1627 struct dwarf2_cu *);
1628
1629 static struct die_info *read_die_and_siblings_1
1630 (const struct die_reader_specs *, const gdb_byte *, const gdb_byte **,
1631 struct die_info *);
1632
1633 static struct die_info *read_die_and_siblings (const struct die_reader_specs *,
1634 const gdb_byte *info_ptr,
1635 const gdb_byte **new_info_ptr,
1636 struct die_info *parent);
1637
1638 static const gdb_byte *read_full_die_1 (const struct die_reader_specs *,
1639 struct die_info **, const gdb_byte *,
1640 int *, int);
1641
1642 static const gdb_byte *read_full_die (const struct die_reader_specs *,
1643 struct die_info **, const gdb_byte *,
1644 int *);
1645
1646 static void process_die (struct die_info *, struct dwarf2_cu *);
1647
1648 static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu *,
1649 struct obstack *);
1650
1651 static const char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
1652
1653 static const char *dwarf2_full_name (const char *name,
1654 struct die_info *die,
1655 struct dwarf2_cu *cu);
1656
1657 static const char *dwarf2_physname (const char *name, struct die_info *die,
1658 struct dwarf2_cu *cu);
1659
1660 static struct die_info *dwarf2_extension (struct die_info *die,
1661 struct dwarf2_cu **);
1662
1663 static const char *dwarf_tag_name (unsigned int);
1664
1665 static const char *dwarf_attr_name (unsigned int);
1666
1667 static const char *dwarf_form_name (unsigned int);
1668
1669 static char *dwarf_bool_name (unsigned int);
1670
1671 static const char *dwarf_type_encoding_name (unsigned int);
1672
1673 static struct die_info *sibling_die (struct die_info *);
1674
1675 static void dump_die_shallow (struct ui_file *, int indent, struct die_info *);
1676
1677 static void dump_die_for_error (struct die_info *);
1678
1679 static void dump_die_1 (struct ui_file *, int level, int max_level,
1680 struct die_info *);
1681
1682 /*static*/ void dump_die (struct die_info *, int max_level);
1683
1684 static void store_in_ref_table (struct die_info *,
1685 struct dwarf2_cu *);
1686
1687 static sect_offset dwarf2_get_ref_die_offset (const struct attribute *);
1688
1689 static LONGEST dwarf2_get_attr_constant_value (const struct attribute *, int);
1690
1691 static struct die_info *follow_die_ref_or_sig (struct die_info *,
1692 const struct attribute *,
1693 struct dwarf2_cu **);
1694
1695 static struct die_info *follow_die_ref (struct die_info *,
1696 const struct attribute *,
1697 struct dwarf2_cu **);
1698
1699 static struct die_info *follow_die_sig (struct die_info *,
1700 const struct attribute *,
1701 struct dwarf2_cu **);
1702
1703 static struct type *get_signatured_type (struct die_info *, ULONGEST,
1704 struct dwarf2_cu *);
1705
1706 static struct type *get_DW_AT_signature_type (struct die_info *,
1707 const struct attribute *,
1708 struct dwarf2_cu *);
1709
1710 static void load_full_type_unit (struct dwarf2_per_cu_data *per_cu);
1711
1712 static void read_signatured_type (struct signatured_type *);
1713
1714 /* memory allocation interface */
1715
1716 static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
1717
1718 static struct die_info *dwarf_alloc_die (struct dwarf2_cu *, int);
1719
1720 static void dwarf_decode_macros (struct dwarf2_cu *, unsigned int,
1721 const char *, int);
1722
1723 static int attr_form_is_block (const struct attribute *);
1724
1725 static int attr_form_is_section_offset (const struct attribute *);
1726
1727 static int attr_form_is_constant (const struct attribute *);
1728
1729 static int attr_form_is_ref (const struct attribute *);
1730
1731 static void fill_in_loclist_baton (struct dwarf2_cu *cu,
1732 struct dwarf2_loclist_baton *baton,
1733 const struct attribute *attr);
1734
1735 static void dwarf2_symbol_mark_computed (const struct attribute *attr,
1736 struct symbol *sym,
1737 struct dwarf2_cu *cu,
1738 int is_block);
1739
1740 static const gdb_byte *skip_one_die (const struct die_reader_specs *reader,
1741 const gdb_byte *info_ptr,
1742 struct abbrev_info *abbrev);
1743
1744 static void free_stack_comp_unit (void *);
1745
1746 static hashval_t partial_die_hash (const void *item);
1747
1748 static int partial_die_eq (const void *item_lhs, const void *item_rhs);
1749
1750 static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit
1751 (sect_offset offset, unsigned int offset_in_dwz, struct objfile *objfile);
1752
1753 static void init_one_comp_unit (struct dwarf2_cu *cu,
1754 struct dwarf2_per_cu_data *per_cu);
1755
1756 static void prepare_one_comp_unit (struct dwarf2_cu *cu,
1757 struct die_info *comp_unit_die,
1758 enum language pretend_language);
1759
1760 static void free_heap_comp_unit (void *);
1761
1762 static void free_cached_comp_units (void *);
1763
1764 static void age_cached_comp_units (void);
1765
1766 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data *);
1767
1768 static struct type *set_die_type (struct die_info *, struct type *,
1769 struct dwarf2_cu *);
1770
1771 static void create_all_comp_units (struct objfile *);
1772
1773 static int create_all_type_units (struct objfile *);
1774
1775 static void load_full_comp_unit (struct dwarf2_per_cu_data *,
1776 enum language);
1777
1778 static void process_full_comp_unit (struct dwarf2_per_cu_data *,
1779 enum language);
1780
1781 static void process_full_type_unit (struct dwarf2_per_cu_data *,
1782 enum language);
1783
1784 static void dwarf2_add_dependence (struct dwarf2_cu *,
1785 struct dwarf2_per_cu_data *);
1786
1787 static void dwarf2_mark (struct dwarf2_cu *);
1788
1789 static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
1790
1791 static struct type *get_die_type_at_offset (sect_offset,
1792 struct dwarf2_per_cu_data *);
1793
1794 static struct type *get_die_type (struct die_info *die, struct dwarf2_cu *cu);
1795
1796 static void dwarf2_release_queue (void *dummy);
1797
1798 static void queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
1799 enum language pretend_language);
1800
1801 static void process_queue (void);
1802
1803 static void find_file_and_directory (struct die_info *die,
1804 struct dwarf2_cu *cu,
1805 const char **name, const char **comp_dir);
1806
1807 static char *file_full_name (int file, struct line_header *lh,
1808 const char *comp_dir);
1809
1810 static const gdb_byte *read_and_check_comp_unit_head
1811 (struct comp_unit_head *header,
1812 struct dwarf2_section_info *section,
1813 struct dwarf2_section_info *abbrev_section, const gdb_byte *info_ptr,
1814 int is_debug_types_section);
1815
1816 static void init_cutu_and_read_dies
1817 (struct dwarf2_per_cu_data *this_cu, struct abbrev_table *abbrev_table,
1818 int use_existing_cu, int keep,
1819 die_reader_func_ftype *die_reader_func, void *data);
1820
1821 static void init_cutu_and_read_dies_simple
1822 (struct dwarf2_per_cu_data *this_cu,
1823 die_reader_func_ftype *die_reader_func, void *data);
1824
1825 static htab_t allocate_signatured_type_table (struct objfile *objfile);
1826
1827 static htab_t allocate_dwo_unit_table (struct objfile *objfile);
1828
1829 static struct dwo_unit *lookup_dwo_unit_in_dwp
1830 (struct dwp_file *dwp_file, const char *comp_dir,
1831 ULONGEST signature, int is_debug_types);
1832
1833 static struct dwp_file *get_dwp_file (void);
1834
1835 static struct dwo_unit *lookup_dwo_comp_unit
1836 (struct dwarf2_per_cu_data *, const char *, const char *, ULONGEST);
1837
1838 static struct dwo_unit *lookup_dwo_type_unit
1839 (struct signatured_type *, const char *, const char *);
1840
1841 static void queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *);
1842
1843 static void free_dwo_file_cleanup (void *);
1844
1845 static void process_cu_includes (void);
1846
1847 static void check_producer (struct dwarf2_cu *cu);
1848 \f
1849 /* Various complaints about symbol reading that don't abort the process. */
1850
1851 static void
1852 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
1853 {
1854 complaint (&symfile_complaints,
1855 _("statement list doesn't fit in .debug_line section"));
1856 }
1857
1858 static void
1859 dwarf2_debug_line_missing_file_complaint (void)
1860 {
1861 complaint (&symfile_complaints,
1862 _(".debug_line section has line data without a file"));
1863 }
1864
1865 static void
1866 dwarf2_debug_line_missing_end_sequence_complaint (void)
1867 {
1868 complaint (&symfile_complaints,
1869 _(".debug_line section has line "
1870 "program sequence without an end"));
1871 }
1872
1873 static void
1874 dwarf2_complex_location_expr_complaint (void)
1875 {
1876 complaint (&symfile_complaints, _("location expression too complex"));
1877 }
1878
1879 static void
1880 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
1881 int arg3)
1882 {
1883 complaint (&symfile_complaints,
1884 _("const value length mismatch for '%s', got %d, expected %d"),
1885 arg1, arg2, arg3);
1886 }
1887
1888 static void
1889 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info *section)
1890 {
1891 complaint (&symfile_complaints,
1892 _("debug info runs off end of %s section"
1893 " [in module %s]"),
1894 get_section_name (section),
1895 get_section_file_name (section));
1896 }
1897
1898 static void
1899 dwarf2_macro_malformed_definition_complaint (const char *arg1)
1900 {
1901 complaint (&symfile_complaints,
1902 _("macro debug info contains a "
1903 "malformed macro definition:\n`%s'"),
1904 arg1);
1905 }
1906
1907 static void
1908 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
1909 {
1910 complaint (&symfile_complaints,
1911 _("invalid attribute class or form for '%s' in '%s'"),
1912 arg1, arg2);
1913 }
1914 \f
1915 #if WORDS_BIGENDIAN
1916
1917 /* Convert VALUE between big- and little-endian. */
1918 static offset_type
1919 byte_swap (offset_type value)
1920 {
1921 offset_type result;
1922
1923 result = (value & 0xff) << 24;
1924 result |= (value & 0xff00) << 8;
1925 result |= (value & 0xff0000) >> 8;
1926 result |= (value & 0xff000000) >> 24;
1927 return result;
1928 }
1929
1930 #define MAYBE_SWAP(V) byte_swap (V)
1931
1932 #else
1933 #define MAYBE_SWAP(V) (V)
1934 #endif /* WORDS_BIGENDIAN */
1935
1936 /* Read the given attribute value as an address, taking the attribute's
1937 form into account. */
1938
1939 static CORE_ADDR
1940 attr_value_as_address (struct attribute *attr)
1941 {
1942 CORE_ADDR addr;
1943
1944 if (attr->form != DW_FORM_addr && attr->form != DW_FORM_GNU_addr_index)
1945 {
1946 /* Aside from a few clearly defined exceptions, attributes that
1947 contain an address must always be in DW_FORM_addr form.
1948 Unfortunately, some compilers happen to be violating this
1949 requirement by encoding addresses using other forms, such
1950 as DW_FORM_data4 for example. For those broken compilers,
1951 we try to do our best, without any guarantee of success,
1952 to interpret the address correctly. It would also be nice
1953 to generate a complaint, but that would require us to maintain
1954 a list of legitimate cases where a non-address form is allowed,
1955 as well as update callers to pass in at least the CU's DWARF
1956 version. This is more overhead than what we're willing to
1957 expand for a pretty rare case. */
1958 addr = DW_UNSND (attr);
1959 }
1960 else
1961 addr = DW_ADDR (attr);
1962
1963 return addr;
1964 }
1965
1966 /* The suffix for an index file. */
1967 #define INDEX_SUFFIX ".gdb-index"
1968
1969 /* Try to locate the sections we need for DWARF 2 debugging
1970 information and return true if we have enough to do something.
1971 NAMES points to the dwarf2 section names, or is NULL if the standard
1972 ELF names are used. */
1973
1974 int
1975 dwarf2_has_info (struct objfile *objfile,
1976 const struct dwarf2_debug_sections *names)
1977 {
1978 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
1979 if (!dwarf2_per_objfile)
1980 {
1981 /* Initialize per-objfile state. */
1982 struct dwarf2_per_objfile *data
1983 = obstack_alloc (&objfile->objfile_obstack, sizeof (*data));
1984
1985 memset (data, 0, sizeof (*data));
1986 set_objfile_data (objfile, dwarf2_objfile_data_key, data);
1987 dwarf2_per_objfile = data;
1988
1989 bfd_map_over_sections (objfile->obfd, dwarf2_locate_sections,
1990 (void *) names);
1991 dwarf2_per_objfile->objfile = objfile;
1992 }
1993 return (!dwarf2_per_objfile->info.is_virtual
1994 && dwarf2_per_objfile->info.s.asection != NULL
1995 && !dwarf2_per_objfile->abbrev.is_virtual
1996 && dwarf2_per_objfile->abbrev.s.asection != NULL);
1997 }
1998
1999 /* Return the containing section of virtual section SECTION. */
2000
2001 static struct dwarf2_section_info *
2002 get_containing_section (const struct dwarf2_section_info *section)
2003 {
2004 gdb_assert (section->is_virtual);
2005 return section->s.containing_section;
2006 }
2007
2008 /* Return the bfd owner of SECTION. */
2009
2010 static struct bfd *
2011 get_section_bfd_owner (const struct dwarf2_section_info *section)
2012 {
2013 if (section->is_virtual)
2014 {
2015 section = get_containing_section (section);
2016 gdb_assert (!section->is_virtual);
2017 }
2018 return section->s.asection->owner;
2019 }
2020
2021 /* Return the bfd section of SECTION.
2022 Returns NULL if the section is not present. */
2023
2024 static asection *
2025 get_section_bfd_section (const struct dwarf2_section_info *section)
2026 {
2027 if (section->is_virtual)
2028 {
2029 section = get_containing_section (section);
2030 gdb_assert (!section->is_virtual);
2031 }
2032 return section->s.asection;
2033 }
2034
2035 /* Return the name of SECTION. */
2036
2037 static const char *
2038 get_section_name (const struct dwarf2_section_info *section)
2039 {
2040 asection *sectp = get_section_bfd_section (section);
2041
2042 gdb_assert (sectp != NULL);
2043 return bfd_section_name (get_section_bfd_owner (section), sectp);
2044 }
2045
2046 /* Return the name of the file SECTION is in. */
2047
2048 static const char *
2049 get_section_file_name (const struct dwarf2_section_info *section)
2050 {
2051 bfd *abfd = get_section_bfd_owner (section);
2052
2053 return bfd_get_filename (abfd);
2054 }
2055
2056 /* Return the id of SECTION.
2057 Returns 0 if SECTION doesn't exist. */
2058
2059 static int
2060 get_section_id (const struct dwarf2_section_info *section)
2061 {
2062 asection *sectp = get_section_bfd_section (section);
2063
2064 if (sectp == NULL)
2065 return 0;
2066 return sectp->id;
2067 }
2068
2069 /* Return the flags of SECTION.
2070 SECTION (or containing section if this is a virtual section) must exist. */
2071
2072 static int
2073 get_section_flags (const struct dwarf2_section_info *section)
2074 {
2075 asection *sectp = get_section_bfd_section (section);
2076
2077 gdb_assert (sectp != NULL);
2078 return bfd_get_section_flags (sectp->owner, sectp);
2079 }
2080
2081 /* When loading sections, we look either for uncompressed section or for
2082 compressed section names. */
2083
2084 static int
2085 section_is_p (const char *section_name,
2086 const struct dwarf2_section_names *names)
2087 {
2088 if (names->normal != NULL
2089 && strcmp (section_name, names->normal) == 0)
2090 return 1;
2091 if (names->compressed != NULL
2092 && strcmp (section_name, names->compressed) == 0)
2093 return 1;
2094 return 0;
2095 }
2096
2097 /* This function is mapped across the sections and remembers the
2098 offset and size of each of the debugging sections we are interested
2099 in. */
2100
2101 static void
2102 dwarf2_locate_sections (bfd *abfd, asection *sectp, void *vnames)
2103 {
2104 const struct dwarf2_debug_sections *names;
2105 flagword aflag = bfd_get_section_flags (abfd, sectp);
2106
2107 if (vnames == NULL)
2108 names = &dwarf2_elf_names;
2109 else
2110 names = (const struct dwarf2_debug_sections *) vnames;
2111
2112 if ((aflag & SEC_HAS_CONTENTS) == 0)
2113 {
2114 }
2115 else if (section_is_p (sectp->name, &names->info))
2116 {
2117 dwarf2_per_objfile->info.s.asection = sectp;
2118 dwarf2_per_objfile->info.size = bfd_get_section_size (sectp);
2119 }
2120 else if (section_is_p (sectp->name, &names->abbrev))
2121 {
2122 dwarf2_per_objfile->abbrev.s.asection = sectp;
2123 dwarf2_per_objfile->abbrev.size = bfd_get_section_size (sectp);
2124 }
2125 else if (section_is_p (sectp->name, &names->line))
2126 {
2127 dwarf2_per_objfile->line.s.asection = sectp;
2128 dwarf2_per_objfile->line.size = bfd_get_section_size (sectp);
2129 }
2130 else if (section_is_p (sectp->name, &names->loc))
2131 {
2132 dwarf2_per_objfile->loc.s.asection = sectp;
2133 dwarf2_per_objfile->loc.size = bfd_get_section_size (sectp);
2134 }
2135 else if (section_is_p (sectp->name, &names->macinfo))
2136 {
2137 dwarf2_per_objfile->macinfo.s.asection = sectp;
2138 dwarf2_per_objfile->macinfo.size = bfd_get_section_size (sectp);
2139 }
2140 else if (section_is_p (sectp->name, &names->macro))
2141 {
2142 dwarf2_per_objfile->macro.s.asection = sectp;
2143 dwarf2_per_objfile->macro.size = bfd_get_section_size (sectp);
2144 }
2145 else if (section_is_p (sectp->name, &names->str))
2146 {
2147 dwarf2_per_objfile->str.s.asection = sectp;
2148 dwarf2_per_objfile->str.size = bfd_get_section_size (sectp);
2149 }
2150 else if (section_is_p (sectp->name, &names->addr))
2151 {
2152 dwarf2_per_objfile->addr.s.asection = sectp;
2153 dwarf2_per_objfile->addr.size = bfd_get_section_size (sectp);
2154 }
2155 else if (section_is_p (sectp->name, &names->frame))
2156 {
2157 dwarf2_per_objfile->frame.s.asection = sectp;
2158 dwarf2_per_objfile->frame.size = bfd_get_section_size (sectp);
2159 }
2160 else if (section_is_p (sectp->name, &names->eh_frame))
2161 {
2162 dwarf2_per_objfile->eh_frame.s.asection = sectp;
2163 dwarf2_per_objfile->eh_frame.size = bfd_get_section_size (sectp);
2164 }
2165 else if (section_is_p (sectp->name, &names->ranges))
2166 {
2167 dwarf2_per_objfile->ranges.s.asection = sectp;
2168 dwarf2_per_objfile->ranges.size = bfd_get_section_size (sectp);
2169 }
2170 else if (section_is_p (sectp->name, &names->types))
2171 {
2172 struct dwarf2_section_info type_section;
2173
2174 memset (&type_section, 0, sizeof (type_section));
2175 type_section.s.asection = sectp;
2176 type_section.size = bfd_get_section_size (sectp);
2177
2178 VEC_safe_push (dwarf2_section_info_def, dwarf2_per_objfile->types,
2179 &type_section);
2180 }
2181 else if (section_is_p (sectp->name, &names->gdb_index))
2182 {
2183 dwarf2_per_objfile->gdb_index.s.asection = sectp;
2184 dwarf2_per_objfile->gdb_index.size = bfd_get_section_size (sectp);
2185 }
2186
2187 if ((bfd_get_section_flags (abfd, sectp) & SEC_LOAD)
2188 && bfd_section_vma (abfd, sectp) == 0)
2189 dwarf2_per_objfile->has_section_at_zero = 1;
2190 }
2191
2192 /* A helper function that decides whether a section is empty,
2193 or not present. */
2194
2195 static int
2196 dwarf2_section_empty_p (const struct dwarf2_section_info *section)
2197 {
2198 if (section->is_virtual)
2199 return section->size == 0;
2200 return section->s.asection == NULL || section->size == 0;
2201 }
2202
2203 /* Read the contents of the section INFO.
2204 OBJFILE is the main object file, but not necessarily the file where
2205 the section comes from. E.g., for DWO files the bfd of INFO is the bfd
2206 of the DWO file.
2207 If the section is compressed, uncompress it before returning. */
2208
2209 static void
2210 dwarf2_read_section (struct objfile *objfile, struct dwarf2_section_info *info)
2211 {
2212 asection *sectp;
2213 bfd *abfd;
2214 gdb_byte *buf, *retbuf;
2215
2216 if (info->readin)
2217 return;
2218 info->buffer = NULL;
2219 info->readin = 1;
2220
2221 if (dwarf2_section_empty_p (info))
2222 return;
2223
2224 sectp = get_section_bfd_section (info);
2225
2226 /* If this is a virtual section we need to read in the real one first. */
2227 if (info->is_virtual)
2228 {
2229 struct dwarf2_section_info *containing_section =
2230 get_containing_section (info);
2231
2232 gdb_assert (sectp != NULL);
2233 if ((sectp->flags & SEC_RELOC) != 0)
2234 {
2235 error (_("Dwarf Error: DWP format V2 with relocations is not"
2236 " supported in section %s [in module %s]"),
2237 get_section_name (info), get_section_file_name (info));
2238 }
2239 dwarf2_read_section (objfile, containing_section);
2240 /* Other code should have already caught virtual sections that don't
2241 fit. */
2242 gdb_assert (info->virtual_offset + info->size
2243 <= containing_section->size);
2244 /* If the real section is empty or there was a problem reading the
2245 section we shouldn't get here. */
2246 gdb_assert (containing_section->buffer != NULL);
2247 info->buffer = containing_section->buffer + info->virtual_offset;
2248 return;
2249 }
2250
2251 /* If the section has relocations, we must read it ourselves.
2252 Otherwise we attach it to the BFD. */
2253 if ((sectp->flags & SEC_RELOC) == 0)
2254 {
2255 info->buffer = gdb_bfd_map_section (sectp, &info->size);
2256 return;
2257 }
2258
2259 buf = obstack_alloc (&objfile->objfile_obstack, info->size);
2260 info->buffer = buf;
2261
2262 /* When debugging .o files, we may need to apply relocations; see
2263 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
2264 We never compress sections in .o files, so we only need to
2265 try this when the section is not compressed. */
2266 retbuf = symfile_relocate_debug_section (objfile, sectp, buf);
2267 if (retbuf != NULL)
2268 {
2269 info->buffer = retbuf;
2270 return;
2271 }
2272
2273 abfd = get_section_bfd_owner (info);
2274 gdb_assert (abfd != NULL);
2275
2276 if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
2277 || bfd_bread (buf, info->size, abfd) != info->size)
2278 {
2279 error (_("Dwarf Error: Can't read DWARF data"
2280 " in section %s [in module %s]"),
2281 bfd_section_name (abfd, sectp), bfd_get_filename (abfd));
2282 }
2283 }
2284
2285 /* A helper function that returns the size of a section in a safe way.
2286 If you are positive that the section has been read before using the
2287 size, then it is safe to refer to the dwarf2_section_info object's
2288 "size" field directly. In other cases, you must call this
2289 function, because for compressed sections the size field is not set
2290 correctly until the section has been read. */
2291
2292 static bfd_size_type
2293 dwarf2_section_size (struct objfile *objfile,
2294 struct dwarf2_section_info *info)
2295 {
2296 if (!info->readin)
2297 dwarf2_read_section (objfile, info);
2298 return info->size;
2299 }
2300
2301 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
2302 SECTION_NAME. */
2303
2304 void
2305 dwarf2_get_section_info (struct objfile *objfile,
2306 enum dwarf2_section_enum sect,
2307 asection **sectp, const gdb_byte **bufp,
2308 bfd_size_type *sizep)
2309 {
2310 struct dwarf2_per_objfile *data
2311 = objfile_data (objfile, dwarf2_objfile_data_key);
2312 struct dwarf2_section_info *info;
2313
2314 /* We may see an objfile without any DWARF, in which case we just
2315 return nothing. */
2316 if (data == NULL)
2317 {
2318 *sectp = NULL;
2319 *bufp = NULL;
2320 *sizep = 0;
2321 return;
2322 }
2323 switch (sect)
2324 {
2325 case DWARF2_DEBUG_FRAME:
2326 info = &data->frame;
2327 break;
2328 case DWARF2_EH_FRAME:
2329 info = &data->eh_frame;
2330 break;
2331 default:
2332 gdb_assert_not_reached ("unexpected section");
2333 }
2334
2335 dwarf2_read_section (objfile, info);
2336
2337 *sectp = get_section_bfd_section (info);
2338 *bufp = info->buffer;
2339 *sizep = info->size;
2340 }
2341
2342 /* A helper function to find the sections for a .dwz file. */
2343
2344 static void
2345 locate_dwz_sections (bfd *abfd, asection *sectp, void *arg)
2346 {
2347 struct dwz_file *dwz_file = arg;
2348
2349 /* Note that we only support the standard ELF names, because .dwz
2350 is ELF-only (at the time of writing). */
2351 if (section_is_p (sectp->name, &dwarf2_elf_names.abbrev))
2352 {
2353 dwz_file->abbrev.s.asection = sectp;
2354 dwz_file->abbrev.size = bfd_get_section_size (sectp);
2355 }
2356 else if (section_is_p (sectp->name, &dwarf2_elf_names.info))
2357 {
2358 dwz_file->info.s.asection = sectp;
2359 dwz_file->info.size = bfd_get_section_size (sectp);
2360 }
2361 else if (section_is_p (sectp->name, &dwarf2_elf_names.str))
2362 {
2363 dwz_file->str.s.asection = sectp;
2364 dwz_file->str.size = bfd_get_section_size (sectp);
2365 }
2366 else if (section_is_p (sectp->name, &dwarf2_elf_names.line))
2367 {
2368 dwz_file->line.s.asection = sectp;
2369 dwz_file->line.size = bfd_get_section_size (sectp);
2370 }
2371 else if (section_is_p (sectp->name, &dwarf2_elf_names.macro))
2372 {
2373 dwz_file->macro.s.asection = sectp;
2374 dwz_file->macro.size = bfd_get_section_size (sectp);
2375 }
2376 else if (section_is_p (sectp->name, &dwarf2_elf_names.gdb_index))
2377 {
2378 dwz_file->gdb_index.s.asection = sectp;
2379 dwz_file->gdb_index.size = bfd_get_section_size (sectp);
2380 }
2381 }
2382
2383 /* Open the separate '.dwz' debug file, if needed. Return NULL if
2384 there is no .gnu_debugaltlink section in the file. Error if there
2385 is such a section but the file cannot be found. */
2386
2387 static struct dwz_file *
2388 dwarf2_get_dwz_file (void)
2389 {
2390 bfd *dwz_bfd;
2391 char *data;
2392 struct cleanup *cleanup;
2393 const char *filename;
2394 struct dwz_file *result;
2395 bfd_size_type buildid_len_arg;
2396 size_t buildid_len;
2397 bfd_byte *buildid;
2398
2399 if (dwarf2_per_objfile->dwz_file != NULL)
2400 return dwarf2_per_objfile->dwz_file;
2401
2402 bfd_set_error (bfd_error_no_error);
2403 data = bfd_get_alt_debug_link_info (dwarf2_per_objfile->objfile->obfd,
2404 &buildid_len_arg, &buildid);
2405 if (data == NULL)
2406 {
2407 if (bfd_get_error () == bfd_error_no_error)
2408 return NULL;
2409 error (_("could not read '.gnu_debugaltlink' section: %s"),
2410 bfd_errmsg (bfd_get_error ()));
2411 }
2412 cleanup = make_cleanup (xfree, data);
2413 make_cleanup (xfree, buildid);
2414
2415 buildid_len = (size_t) buildid_len_arg;
2416
2417 filename = (const char *) data;
2418 if (!IS_ABSOLUTE_PATH (filename))
2419 {
2420 char *abs = gdb_realpath (objfile_name (dwarf2_per_objfile->objfile));
2421 char *rel;
2422
2423 make_cleanup (xfree, abs);
2424 abs = ldirname (abs);
2425 make_cleanup (xfree, abs);
2426
2427 rel = concat (abs, SLASH_STRING, filename, (char *) NULL);
2428 make_cleanup (xfree, rel);
2429 filename = rel;
2430 }
2431
2432 /* First try the file name given in the section. If that doesn't
2433 work, try to use the build-id instead. */
2434 dwz_bfd = gdb_bfd_open (filename, gnutarget, -1);
2435 if (dwz_bfd != NULL)
2436 {
2437 if (!build_id_verify (dwz_bfd, buildid_len, buildid))
2438 {
2439 gdb_bfd_unref (dwz_bfd);
2440 dwz_bfd = NULL;
2441 }
2442 }
2443
2444 if (dwz_bfd == NULL)
2445 dwz_bfd = build_id_to_debug_bfd (buildid_len, buildid);
2446
2447 if (dwz_bfd == NULL)
2448 error (_("could not find '.gnu_debugaltlink' file for %s"),
2449 objfile_name (dwarf2_per_objfile->objfile));
2450
2451 result = OBSTACK_ZALLOC (&dwarf2_per_objfile->objfile->objfile_obstack,
2452 struct dwz_file);
2453 result->dwz_bfd = dwz_bfd;
2454
2455 bfd_map_over_sections (dwz_bfd, locate_dwz_sections, result);
2456
2457 do_cleanups (cleanup);
2458
2459 gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd, dwz_bfd);
2460 dwarf2_per_objfile->dwz_file = result;
2461 return result;
2462 }
2463 \f
2464 /* DWARF quick_symbols_functions support. */
2465
2466 /* TUs can share .debug_line entries, and there can be a lot more TUs than
2467 unique line tables, so we maintain a separate table of all .debug_line
2468 derived entries to support the sharing.
2469 All the quick functions need is the list of file names. We discard the
2470 line_header when we're done and don't need to record it here. */
2471 struct quick_file_names
2472 {
2473 /* The data used to construct the hash key. */
2474 struct stmt_list_hash hash;
2475
2476 /* The number of entries in file_names, real_names. */
2477 unsigned int num_file_names;
2478
2479 /* The file names from the line table, after being run through
2480 file_full_name. */
2481 const char **file_names;
2482
2483 /* The file names from the line table after being run through
2484 gdb_realpath. These are computed lazily. */
2485 const char **real_names;
2486 };
2487
2488 /* When using the index (and thus not using psymtabs), each CU has an
2489 object of this type. This is used to hold information needed by
2490 the various "quick" methods. */
2491 struct dwarf2_per_cu_quick_data
2492 {
2493 /* The file table. This can be NULL if there was no file table
2494 or it's currently not read in.
2495 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
2496 struct quick_file_names *file_names;
2497
2498 /* The corresponding symbol table. This is NULL if symbols for this
2499 CU have not yet been read. */
2500 struct symtab *symtab;
2501
2502 /* A temporary mark bit used when iterating over all CUs in
2503 expand_symtabs_matching. */
2504 unsigned int mark : 1;
2505
2506 /* True if we've tried to read the file table and found there isn't one.
2507 There will be no point in trying to read it again next time. */
2508 unsigned int no_file_data : 1;
2509 };
2510
2511 /* Utility hash function for a stmt_list_hash. */
2512
2513 static hashval_t
2514 hash_stmt_list_entry (const struct stmt_list_hash *stmt_list_hash)
2515 {
2516 hashval_t v = 0;
2517
2518 if (stmt_list_hash->dwo_unit != NULL)
2519 v += (uintptr_t) stmt_list_hash->dwo_unit->dwo_file;
2520 v += stmt_list_hash->line_offset.sect_off;
2521 return v;
2522 }
2523
2524 /* Utility equality function for a stmt_list_hash. */
2525
2526 static int
2527 eq_stmt_list_entry (const struct stmt_list_hash *lhs,
2528 const struct stmt_list_hash *rhs)
2529 {
2530 if ((lhs->dwo_unit != NULL) != (rhs->dwo_unit != NULL))
2531 return 0;
2532 if (lhs->dwo_unit != NULL
2533 && lhs->dwo_unit->dwo_file != rhs->dwo_unit->dwo_file)
2534 return 0;
2535
2536 return lhs->line_offset.sect_off == rhs->line_offset.sect_off;
2537 }
2538
2539 /* Hash function for a quick_file_names. */
2540
2541 static hashval_t
2542 hash_file_name_entry (const void *e)
2543 {
2544 const struct quick_file_names *file_data = e;
2545
2546 return hash_stmt_list_entry (&file_data->hash);
2547 }
2548
2549 /* Equality function for a quick_file_names. */
2550
2551 static int
2552 eq_file_name_entry (const void *a, const void *b)
2553 {
2554 const struct quick_file_names *ea = a;
2555 const struct quick_file_names *eb = b;
2556
2557 return eq_stmt_list_entry (&ea->hash, &eb->hash);
2558 }
2559
2560 /* Delete function for a quick_file_names. */
2561
2562 static void
2563 delete_file_name_entry (void *e)
2564 {
2565 struct quick_file_names *file_data = e;
2566 int i;
2567
2568 for (i = 0; i < file_data->num_file_names; ++i)
2569 {
2570 xfree ((void*) file_data->file_names[i]);
2571 if (file_data->real_names)
2572 xfree ((void*) file_data->real_names[i]);
2573 }
2574
2575 /* The space for the struct itself lives on objfile_obstack,
2576 so we don't free it here. */
2577 }
2578
2579 /* Create a quick_file_names hash table. */
2580
2581 static htab_t
2582 create_quick_file_names_table (unsigned int nr_initial_entries)
2583 {
2584 return htab_create_alloc (nr_initial_entries,
2585 hash_file_name_entry, eq_file_name_entry,
2586 delete_file_name_entry, xcalloc, xfree);
2587 }
2588
2589 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
2590 have to be created afterwards. You should call age_cached_comp_units after
2591 processing PER_CU->CU. dw2_setup must have been already called. */
2592
2593 static void
2594 load_cu (struct dwarf2_per_cu_data *per_cu)
2595 {
2596 if (per_cu->is_debug_types)
2597 load_full_type_unit (per_cu);
2598 else
2599 load_full_comp_unit (per_cu, language_minimal);
2600
2601 gdb_assert (per_cu->cu != NULL);
2602
2603 dwarf2_find_base_address (per_cu->cu->dies, per_cu->cu);
2604 }
2605
2606 /* Read in the symbols for PER_CU. */
2607
2608 static void
2609 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data *per_cu)
2610 {
2611 struct cleanup *back_to;
2612
2613 /* Skip type_unit_groups, reading the type units they contain
2614 is handled elsewhere. */
2615 if (IS_TYPE_UNIT_GROUP (per_cu))
2616 return;
2617
2618 back_to = make_cleanup (dwarf2_release_queue, NULL);
2619
2620 if (dwarf2_per_objfile->using_index
2621 ? per_cu->v.quick->symtab == NULL
2622 : (per_cu->v.psymtab == NULL || !per_cu->v.psymtab->readin))
2623 {
2624 queue_comp_unit (per_cu, language_minimal);
2625 load_cu (per_cu);
2626
2627 /* If we just loaded a CU from a DWO, and we're working with an index
2628 that may badly handle TUs, load all the TUs in that DWO as well.
2629 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
2630 if (!per_cu->is_debug_types
2631 && per_cu->cu->dwo_unit != NULL
2632 && dwarf2_per_objfile->index_table != NULL
2633 && dwarf2_per_objfile->index_table->version <= 7
2634 /* DWP files aren't supported yet. */
2635 && get_dwp_file () == NULL)
2636 queue_and_load_all_dwo_tus (per_cu);
2637 }
2638
2639 process_queue ();
2640
2641 /* Age the cache, releasing compilation units that have not
2642 been used recently. */
2643 age_cached_comp_units ();
2644
2645 do_cleanups (back_to);
2646 }
2647
2648 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2649 the objfile from which this CU came. Returns the resulting symbol
2650 table. */
2651
2652 static struct symtab *
2653 dw2_instantiate_symtab (struct dwarf2_per_cu_data *per_cu)
2654 {
2655 gdb_assert (dwarf2_per_objfile->using_index);
2656 if (!per_cu->v.quick->symtab)
2657 {
2658 struct cleanup *back_to = make_cleanup (free_cached_comp_units, NULL);
2659 increment_reading_symtab ();
2660 dw2_do_instantiate_symtab (per_cu);
2661 process_cu_includes ();
2662 do_cleanups (back_to);
2663 }
2664 return per_cu->v.quick->symtab;
2665 }
2666
2667 /* Return the CU/TU given its index.
2668
2669 This is intended for loops like:
2670
2671 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2672 + dwarf2_per_objfile->n_type_units); ++i)
2673 {
2674 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
2675
2676 ...;
2677 }
2678 */
2679
2680 static struct dwarf2_per_cu_data *
2681 dw2_get_cutu (int index)
2682 {
2683 if (index >= dwarf2_per_objfile->n_comp_units)
2684 {
2685 index -= dwarf2_per_objfile->n_comp_units;
2686 gdb_assert (index < dwarf2_per_objfile->n_type_units);
2687 return &dwarf2_per_objfile->all_type_units[index]->per_cu;
2688 }
2689
2690 return dwarf2_per_objfile->all_comp_units[index];
2691 }
2692
2693 /* Return the CU given its index.
2694 This differs from dw2_get_cutu in that it's for when you know INDEX
2695 refers to a CU. */
2696
2697 static struct dwarf2_per_cu_data *
2698 dw2_get_cu (int index)
2699 {
2700 gdb_assert (index >= 0 && index < dwarf2_per_objfile->n_comp_units);
2701
2702 return dwarf2_per_objfile->all_comp_units[index];
2703 }
2704
2705 /* A helper for create_cus_from_index that handles a given list of
2706 CUs. */
2707
2708 static void
2709 create_cus_from_index_list (struct objfile *objfile,
2710 const gdb_byte *cu_list, offset_type n_elements,
2711 struct dwarf2_section_info *section,
2712 int is_dwz,
2713 int base_offset)
2714 {
2715 offset_type i;
2716
2717 for (i = 0; i < n_elements; i += 2)
2718 {
2719 struct dwarf2_per_cu_data *the_cu;
2720 ULONGEST offset, length;
2721
2722 gdb_static_assert (sizeof (ULONGEST) >= 8);
2723 offset = extract_unsigned_integer (cu_list, 8, BFD_ENDIAN_LITTLE);
2724 length = extract_unsigned_integer (cu_list + 8, 8, BFD_ENDIAN_LITTLE);
2725 cu_list += 2 * 8;
2726
2727 the_cu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2728 struct dwarf2_per_cu_data);
2729 the_cu->offset.sect_off = offset;
2730 the_cu->length = length;
2731 the_cu->objfile = objfile;
2732 the_cu->section = section;
2733 the_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2734 struct dwarf2_per_cu_quick_data);
2735 the_cu->is_dwz = is_dwz;
2736 dwarf2_per_objfile->all_comp_units[base_offset + i / 2] = the_cu;
2737 }
2738 }
2739
2740 /* Read the CU list from the mapped index, and use it to create all
2741 the CU objects for this objfile. */
2742
2743 static void
2744 create_cus_from_index (struct objfile *objfile,
2745 const gdb_byte *cu_list, offset_type cu_list_elements,
2746 const gdb_byte *dwz_list, offset_type dwz_elements)
2747 {
2748 struct dwz_file *dwz;
2749
2750 dwarf2_per_objfile->n_comp_units = (cu_list_elements + dwz_elements) / 2;
2751 dwarf2_per_objfile->all_comp_units
2752 = obstack_alloc (&objfile->objfile_obstack,
2753 dwarf2_per_objfile->n_comp_units
2754 * sizeof (struct dwarf2_per_cu_data *));
2755
2756 create_cus_from_index_list (objfile, cu_list, cu_list_elements,
2757 &dwarf2_per_objfile->info, 0, 0);
2758
2759 if (dwz_elements == 0)
2760 return;
2761
2762 dwz = dwarf2_get_dwz_file ();
2763 create_cus_from_index_list (objfile, dwz_list, dwz_elements, &dwz->info, 1,
2764 cu_list_elements / 2);
2765 }
2766
2767 /* Create the signatured type hash table from the index. */
2768
2769 static void
2770 create_signatured_type_table_from_index (struct objfile *objfile,
2771 struct dwarf2_section_info *section,
2772 const gdb_byte *bytes,
2773 offset_type elements)
2774 {
2775 offset_type i;
2776 htab_t sig_types_hash;
2777
2778 dwarf2_per_objfile->n_type_units
2779 = dwarf2_per_objfile->n_allocated_type_units
2780 = elements / 3;
2781 dwarf2_per_objfile->all_type_units
2782 = xmalloc (dwarf2_per_objfile->n_type_units
2783 * sizeof (struct signatured_type *));
2784
2785 sig_types_hash = allocate_signatured_type_table (objfile);
2786
2787 for (i = 0; i < elements; i += 3)
2788 {
2789 struct signatured_type *sig_type;
2790 ULONGEST offset, type_offset_in_tu, signature;
2791 void **slot;
2792
2793 gdb_static_assert (sizeof (ULONGEST) >= 8);
2794 offset = extract_unsigned_integer (bytes, 8, BFD_ENDIAN_LITTLE);
2795 type_offset_in_tu = extract_unsigned_integer (bytes + 8, 8,
2796 BFD_ENDIAN_LITTLE);
2797 signature = extract_unsigned_integer (bytes + 16, 8, BFD_ENDIAN_LITTLE);
2798 bytes += 3 * 8;
2799
2800 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2801 struct signatured_type);
2802 sig_type->signature = signature;
2803 sig_type->type_offset_in_tu.cu_off = type_offset_in_tu;
2804 sig_type->per_cu.is_debug_types = 1;
2805 sig_type->per_cu.section = section;
2806 sig_type->per_cu.offset.sect_off = offset;
2807 sig_type->per_cu.objfile = objfile;
2808 sig_type->per_cu.v.quick
2809 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2810 struct dwarf2_per_cu_quick_data);
2811
2812 slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
2813 *slot = sig_type;
2814
2815 dwarf2_per_objfile->all_type_units[i / 3] = sig_type;
2816 }
2817
2818 dwarf2_per_objfile->signatured_types = sig_types_hash;
2819 }
2820
2821 /* Read the address map data from the mapped index, and use it to
2822 populate the objfile's psymtabs_addrmap. */
2823
2824 static void
2825 create_addrmap_from_index (struct objfile *objfile, struct mapped_index *index)
2826 {
2827 const gdb_byte *iter, *end;
2828 struct obstack temp_obstack;
2829 struct addrmap *mutable_map;
2830 struct cleanup *cleanup;
2831 CORE_ADDR baseaddr;
2832
2833 obstack_init (&temp_obstack);
2834 cleanup = make_cleanup_obstack_free (&temp_obstack);
2835 mutable_map = addrmap_create_mutable (&temp_obstack);
2836
2837 iter = index->address_table;
2838 end = iter + index->address_table_size;
2839
2840 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2841
2842 while (iter < end)
2843 {
2844 ULONGEST hi, lo, cu_index;
2845 lo = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
2846 iter += 8;
2847 hi = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
2848 iter += 8;
2849 cu_index = extract_unsigned_integer (iter, 4, BFD_ENDIAN_LITTLE);
2850 iter += 4;
2851
2852 if (lo > hi)
2853 {
2854 complaint (&symfile_complaints,
2855 _(".gdb_index address table has invalid range (%s - %s)"),
2856 hex_string (lo), hex_string (hi));
2857 continue;
2858 }
2859
2860 if (cu_index >= dwarf2_per_objfile->n_comp_units)
2861 {
2862 complaint (&symfile_complaints,
2863 _(".gdb_index address table has invalid CU number %u"),
2864 (unsigned) cu_index);
2865 continue;
2866 }
2867
2868 addrmap_set_empty (mutable_map, lo + baseaddr, hi + baseaddr - 1,
2869 dw2_get_cutu (cu_index));
2870 }
2871
2872 objfile->psymtabs_addrmap = addrmap_create_fixed (mutable_map,
2873 &objfile->objfile_obstack);
2874 do_cleanups (cleanup);
2875 }
2876
2877 /* The hash function for strings in the mapped index. This is the same as
2878 SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
2879 implementation. This is necessary because the hash function is tied to the
2880 format of the mapped index file. The hash values do not have to match with
2881 SYMBOL_HASH_NEXT.
2882
2883 Use INT_MAX for INDEX_VERSION if you generate the current index format. */
2884
2885 static hashval_t
2886 mapped_index_string_hash (int index_version, const void *p)
2887 {
2888 const unsigned char *str = (const unsigned char *) p;
2889 hashval_t r = 0;
2890 unsigned char c;
2891
2892 while ((c = *str++) != 0)
2893 {
2894 if (index_version >= 5)
2895 c = tolower (c);
2896 r = r * 67 + c - 113;
2897 }
2898
2899 return r;
2900 }
2901
2902 /* Find a slot in the mapped index INDEX for the object named NAME.
2903 If NAME is found, set *VEC_OUT to point to the CU vector in the
2904 constant pool and return 1. If NAME cannot be found, return 0. */
2905
2906 static int
2907 find_slot_in_mapped_hash (struct mapped_index *index, const char *name,
2908 offset_type **vec_out)
2909 {
2910 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
2911 offset_type hash;
2912 offset_type slot, step;
2913 int (*cmp) (const char *, const char *);
2914
2915 if (current_language->la_language == language_cplus
2916 || current_language->la_language == language_java
2917 || current_language->la_language == language_fortran)
2918 {
2919 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2920 not contain any. */
2921 const char *paren = strchr (name, '(');
2922
2923 if (paren)
2924 {
2925 char *dup;
2926
2927 dup = xmalloc (paren - name + 1);
2928 memcpy (dup, name, paren - name);
2929 dup[paren - name] = 0;
2930
2931 make_cleanup (xfree, dup);
2932 name = dup;
2933 }
2934 }
2935
2936 /* Index version 4 did not support case insensitive searches. But the
2937 indices for case insensitive languages are built in lowercase, therefore
2938 simulate our NAME being searched is also lowercased. */
2939 hash = mapped_index_string_hash ((index->version == 4
2940 && case_sensitivity == case_sensitive_off
2941 ? 5 : index->version),
2942 name);
2943
2944 slot = hash & (index->symbol_table_slots - 1);
2945 step = ((hash * 17) & (index->symbol_table_slots - 1)) | 1;
2946 cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
2947
2948 for (;;)
2949 {
2950 /* Convert a slot number to an offset into the table. */
2951 offset_type i = 2 * slot;
2952 const char *str;
2953 if (index->symbol_table[i] == 0 && index->symbol_table[i + 1] == 0)
2954 {
2955 do_cleanups (back_to);
2956 return 0;
2957 }
2958
2959 str = index->constant_pool + MAYBE_SWAP (index->symbol_table[i]);
2960 if (!cmp (name, str))
2961 {
2962 *vec_out = (offset_type *) (index->constant_pool
2963 + MAYBE_SWAP (index->symbol_table[i + 1]));
2964 do_cleanups (back_to);
2965 return 1;
2966 }
2967
2968 slot = (slot + step) & (index->symbol_table_slots - 1);
2969 }
2970 }
2971
2972 /* A helper function that reads the .gdb_index from SECTION and fills
2973 in MAP. FILENAME is the name of the file containing the section;
2974 it is used for error reporting. DEPRECATED_OK is nonzero if it is
2975 ok to use deprecated sections.
2976
2977 CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
2978 out parameters that are filled in with information about the CU and
2979 TU lists in the section.
2980
2981 Returns 1 if all went well, 0 otherwise. */
2982
2983 static int
2984 read_index_from_section (struct objfile *objfile,
2985 const char *filename,
2986 int deprecated_ok,
2987 struct dwarf2_section_info *section,
2988 struct mapped_index *map,
2989 const gdb_byte **cu_list,
2990 offset_type *cu_list_elements,
2991 const gdb_byte **types_list,
2992 offset_type *types_list_elements)
2993 {
2994 const gdb_byte *addr;
2995 offset_type version;
2996 offset_type *metadata;
2997 int i;
2998
2999 if (dwarf2_section_empty_p (section))
3000 return 0;
3001
3002 /* Older elfutils strip versions could keep the section in the main
3003 executable while splitting it for the separate debug info file. */
3004 if ((get_section_flags (section) & SEC_HAS_CONTENTS) == 0)
3005 return 0;
3006
3007 dwarf2_read_section (objfile, section);
3008
3009 addr = section->buffer;
3010 /* Version check. */
3011 version = MAYBE_SWAP (*(offset_type *) addr);
3012 /* Versions earlier than 3 emitted every copy of a psymbol. This
3013 causes the index to behave very poorly for certain requests. Version 3
3014 contained incomplete addrmap. So, it seems better to just ignore such
3015 indices. */
3016 if (version < 4)
3017 {
3018 static int warning_printed = 0;
3019 if (!warning_printed)
3020 {
3021 warning (_("Skipping obsolete .gdb_index section in %s."),
3022 filename);
3023 warning_printed = 1;
3024 }
3025 return 0;
3026 }
3027 /* Index version 4 uses a different hash function than index version
3028 5 and later.
3029
3030 Versions earlier than 6 did not emit psymbols for inlined
3031 functions. Using these files will cause GDB not to be able to
3032 set breakpoints on inlined functions by name, so we ignore these
3033 indices unless the user has done
3034 "set use-deprecated-index-sections on". */
3035 if (version < 6 && !deprecated_ok)
3036 {
3037 static int warning_printed = 0;
3038 if (!warning_printed)
3039 {
3040 warning (_("\
3041 Skipping deprecated .gdb_index section in %s.\n\
3042 Do \"set use-deprecated-index-sections on\" before the file is read\n\
3043 to use the section anyway."),
3044 filename);
3045 warning_printed = 1;
3046 }
3047 return 0;
3048 }
3049 /* Version 7 indices generated by gold refer to the CU for a symbol instead
3050 of the TU (for symbols coming from TUs),
3051 http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
3052 Plus gold-generated indices can have duplicate entries for global symbols,
3053 http://sourceware.org/bugzilla/show_bug.cgi?id=15646.
3054 These are just performance bugs, and we can't distinguish gdb-generated
3055 indices from gold-generated ones, so issue no warning here. */
3056
3057 /* Indexes with higher version than the one supported by GDB may be no
3058 longer backward compatible. */
3059 if (version > 8)
3060 return 0;
3061
3062 map->version = version;
3063 map->total_size = section->size;
3064
3065 metadata = (offset_type *) (addr + sizeof (offset_type));
3066
3067 i = 0;
3068 *cu_list = addr + MAYBE_SWAP (metadata[i]);
3069 *cu_list_elements = ((MAYBE_SWAP (metadata[i + 1]) - MAYBE_SWAP (metadata[i]))
3070 / 8);
3071 ++i;
3072
3073 *types_list = addr + MAYBE_SWAP (metadata[i]);
3074 *types_list_elements = ((MAYBE_SWAP (metadata[i + 1])
3075 - MAYBE_SWAP (metadata[i]))
3076 / 8);
3077 ++i;
3078
3079 map->address_table = addr + MAYBE_SWAP (metadata[i]);
3080 map->address_table_size = (MAYBE_SWAP (metadata[i + 1])
3081 - MAYBE_SWAP (metadata[i]));
3082 ++i;
3083
3084 map->symbol_table = (offset_type *) (addr + MAYBE_SWAP (metadata[i]));
3085 map->symbol_table_slots = ((MAYBE_SWAP (metadata[i + 1])
3086 - MAYBE_SWAP (metadata[i]))
3087 / (2 * sizeof (offset_type)));
3088 ++i;
3089
3090 map->constant_pool = (char *) (addr + MAYBE_SWAP (metadata[i]));
3091
3092 return 1;
3093 }
3094
3095
3096 /* Read the index file. If everything went ok, initialize the "quick"
3097 elements of all the CUs and return 1. Otherwise, return 0. */
3098
3099 static int
3100 dwarf2_read_index (struct objfile *objfile)
3101 {
3102 struct mapped_index local_map, *map;
3103 const gdb_byte *cu_list, *types_list, *dwz_list = NULL;
3104 offset_type cu_list_elements, types_list_elements, dwz_list_elements = 0;
3105 struct dwz_file *dwz;
3106
3107 if (!read_index_from_section (objfile, objfile_name (objfile),
3108 use_deprecated_index_sections,
3109 &dwarf2_per_objfile->gdb_index, &local_map,
3110 &cu_list, &cu_list_elements,
3111 &types_list, &types_list_elements))
3112 return 0;
3113
3114 /* Don't use the index if it's empty. */
3115 if (local_map.symbol_table_slots == 0)
3116 return 0;
3117
3118 /* If there is a .dwz file, read it so we can get its CU list as
3119 well. */
3120 dwz = dwarf2_get_dwz_file ();
3121 if (dwz != NULL)
3122 {
3123 struct mapped_index dwz_map;
3124 const gdb_byte *dwz_types_ignore;
3125 offset_type dwz_types_elements_ignore;
3126
3127 if (!read_index_from_section (objfile, bfd_get_filename (dwz->dwz_bfd),
3128 1,
3129 &dwz->gdb_index, &dwz_map,
3130 &dwz_list, &dwz_list_elements,
3131 &dwz_types_ignore,
3132 &dwz_types_elements_ignore))
3133 {
3134 warning (_("could not read '.gdb_index' section from %s; skipping"),
3135 bfd_get_filename (dwz->dwz_bfd));
3136 return 0;
3137 }
3138 }
3139
3140 create_cus_from_index (objfile, cu_list, cu_list_elements, dwz_list,
3141 dwz_list_elements);
3142
3143 if (types_list_elements)
3144 {
3145 struct dwarf2_section_info *section;
3146
3147 /* We can only handle a single .debug_types when we have an
3148 index. */
3149 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) != 1)
3150 return 0;
3151
3152 section = VEC_index (dwarf2_section_info_def,
3153 dwarf2_per_objfile->types, 0);
3154
3155 create_signatured_type_table_from_index (objfile, section, types_list,
3156 types_list_elements);
3157 }
3158
3159 create_addrmap_from_index (objfile, &local_map);
3160
3161 map = obstack_alloc (&objfile->objfile_obstack, sizeof (struct mapped_index));
3162 *map = local_map;
3163
3164 dwarf2_per_objfile->index_table = map;
3165 dwarf2_per_objfile->using_index = 1;
3166 dwarf2_per_objfile->quick_file_names_table =
3167 create_quick_file_names_table (dwarf2_per_objfile->n_comp_units);
3168
3169 return 1;
3170 }
3171
3172 /* A helper for the "quick" functions which sets the global
3173 dwarf2_per_objfile according to OBJFILE. */
3174
3175 static void
3176 dw2_setup (struct objfile *objfile)
3177 {
3178 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
3179 gdb_assert (dwarf2_per_objfile);
3180 }
3181
3182 /* die_reader_func for dw2_get_file_names. */
3183
3184 static void
3185 dw2_get_file_names_reader (const struct die_reader_specs *reader,
3186 const gdb_byte *info_ptr,
3187 struct die_info *comp_unit_die,
3188 int has_children,
3189 void *data)
3190 {
3191 struct dwarf2_cu *cu = reader->cu;
3192 struct dwarf2_per_cu_data *this_cu = cu->per_cu;
3193 struct objfile *objfile = dwarf2_per_objfile->objfile;
3194 struct dwarf2_per_cu_data *lh_cu;
3195 struct line_header *lh;
3196 struct attribute *attr;
3197 int i;
3198 const char *name, *comp_dir;
3199 void **slot;
3200 struct quick_file_names *qfn;
3201 unsigned int line_offset;
3202
3203 gdb_assert (! this_cu->is_debug_types);
3204
3205 /* Our callers never want to match partial units -- instead they
3206 will match the enclosing full CU. */
3207 if (comp_unit_die->tag == DW_TAG_partial_unit)
3208 {
3209 this_cu->v.quick->no_file_data = 1;
3210 return;
3211 }
3212
3213 lh_cu = this_cu;
3214 lh = NULL;
3215 slot = NULL;
3216 line_offset = 0;
3217
3218 attr = dwarf2_attr (comp_unit_die, DW_AT_stmt_list, cu);
3219 if (attr)
3220 {
3221 struct quick_file_names find_entry;
3222
3223 line_offset = DW_UNSND (attr);
3224
3225 /* We may have already read in this line header (TU line header sharing).
3226 If we have we're done. */
3227 find_entry.hash.dwo_unit = cu->dwo_unit;
3228 find_entry.hash.line_offset.sect_off = line_offset;
3229 slot = htab_find_slot (dwarf2_per_objfile->quick_file_names_table,
3230 &find_entry, INSERT);
3231 if (*slot != NULL)
3232 {
3233 lh_cu->v.quick->file_names = *slot;
3234 return;
3235 }
3236
3237 lh = dwarf_decode_line_header (line_offset, cu);
3238 }
3239 if (lh == NULL)
3240 {
3241 lh_cu->v.quick->no_file_data = 1;
3242 return;
3243 }
3244
3245 qfn = obstack_alloc (&objfile->objfile_obstack, sizeof (*qfn));
3246 qfn->hash.dwo_unit = cu->dwo_unit;
3247 qfn->hash.line_offset.sect_off = line_offset;
3248 gdb_assert (slot != NULL);
3249 *slot = qfn;
3250
3251 find_file_and_directory (comp_unit_die, cu, &name, &comp_dir);
3252
3253 qfn->num_file_names = lh->num_file_names;
3254 qfn->file_names = obstack_alloc (&objfile->objfile_obstack,
3255 lh->num_file_names * sizeof (char *));
3256 for (i = 0; i < lh->num_file_names; ++i)
3257 qfn->file_names[i] = file_full_name (i + 1, lh, comp_dir);
3258 qfn->real_names = NULL;
3259
3260 free_line_header (lh);
3261
3262 lh_cu->v.quick->file_names = qfn;
3263 }
3264
3265 /* A helper for the "quick" functions which attempts to read the line
3266 table for THIS_CU. */
3267
3268 static struct quick_file_names *
3269 dw2_get_file_names (struct dwarf2_per_cu_data *this_cu)
3270 {
3271 /* This should never be called for TUs. */
3272 gdb_assert (! this_cu->is_debug_types);
3273 /* Nor type unit groups. */
3274 gdb_assert (! IS_TYPE_UNIT_GROUP (this_cu));
3275
3276 if (this_cu->v.quick->file_names != NULL)
3277 return this_cu->v.quick->file_names;
3278 /* If we know there is no line data, no point in looking again. */
3279 if (this_cu->v.quick->no_file_data)
3280 return NULL;
3281
3282 init_cutu_and_read_dies_simple (this_cu, dw2_get_file_names_reader, NULL);
3283
3284 if (this_cu->v.quick->no_file_data)
3285 return NULL;
3286 return this_cu->v.quick->file_names;
3287 }
3288
3289 /* A helper for the "quick" functions which computes and caches the
3290 real path for a given file name from the line table. */
3291
3292 static const char *
3293 dw2_get_real_path (struct objfile *objfile,
3294 struct quick_file_names *qfn, int index)
3295 {
3296 if (qfn->real_names == NULL)
3297 qfn->real_names = OBSTACK_CALLOC (&objfile->objfile_obstack,
3298 qfn->num_file_names, const char *);
3299
3300 if (qfn->real_names[index] == NULL)
3301 qfn->real_names[index] = gdb_realpath (qfn->file_names[index]);
3302
3303 return qfn->real_names[index];
3304 }
3305
3306 static struct symtab *
3307 dw2_find_last_source_symtab (struct objfile *objfile)
3308 {
3309 int index;
3310
3311 dw2_setup (objfile);
3312 index = dwarf2_per_objfile->n_comp_units - 1;
3313 return dw2_instantiate_symtab (dw2_get_cutu (index));
3314 }
3315
3316 /* Traversal function for dw2_forget_cached_source_info. */
3317
3318 static int
3319 dw2_free_cached_file_names (void **slot, void *info)
3320 {
3321 struct quick_file_names *file_data = (struct quick_file_names *) *slot;
3322
3323 if (file_data->real_names)
3324 {
3325 int i;
3326
3327 for (i = 0; i < file_data->num_file_names; ++i)
3328 {
3329 xfree ((void*) file_data->real_names[i]);
3330 file_data->real_names[i] = NULL;
3331 }
3332 }
3333
3334 return 1;
3335 }
3336
3337 static void
3338 dw2_forget_cached_source_info (struct objfile *objfile)
3339 {
3340 dw2_setup (objfile);
3341
3342 htab_traverse_noresize (dwarf2_per_objfile->quick_file_names_table,
3343 dw2_free_cached_file_names, NULL);
3344 }
3345
3346 /* Helper function for dw2_map_symtabs_matching_filename that expands
3347 the symtabs and calls the iterator. */
3348
3349 static int
3350 dw2_map_expand_apply (struct objfile *objfile,
3351 struct dwarf2_per_cu_data *per_cu,
3352 const char *name, const char *real_path,
3353 int (*callback) (struct symtab *, void *),
3354 void *data)
3355 {
3356 struct symtab *last_made = objfile->symtabs;
3357
3358 /* Don't visit already-expanded CUs. */
3359 if (per_cu->v.quick->symtab)
3360 return 0;
3361
3362 /* This may expand more than one symtab, and we want to iterate over
3363 all of them. */
3364 dw2_instantiate_symtab (per_cu);
3365
3366 return iterate_over_some_symtabs (name, real_path, callback, data,
3367 objfile->symtabs, last_made);
3368 }
3369
3370 /* Implementation of the map_symtabs_matching_filename method. */
3371
3372 static int
3373 dw2_map_symtabs_matching_filename (struct objfile *objfile, const char *name,
3374 const char *real_path,
3375 int (*callback) (struct symtab *, void *),
3376 void *data)
3377 {
3378 int i;
3379 const char *name_basename = lbasename (name);
3380
3381 dw2_setup (objfile);
3382
3383 /* The rule is CUs specify all the files, including those used by
3384 any TU, so there's no need to scan TUs here. */
3385
3386 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
3387 {
3388 int j;
3389 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
3390 struct quick_file_names *file_data;
3391
3392 /* We only need to look at symtabs not already expanded. */
3393 if (per_cu->v.quick->symtab)
3394 continue;
3395
3396 file_data = dw2_get_file_names (per_cu);
3397 if (file_data == NULL)
3398 continue;
3399
3400 for (j = 0; j < file_data->num_file_names; ++j)
3401 {
3402 const char *this_name = file_data->file_names[j];
3403 const char *this_real_name;
3404
3405 if (compare_filenames_for_search (this_name, name))
3406 {
3407 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3408 callback, data))
3409 return 1;
3410 continue;
3411 }
3412
3413 /* Before we invoke realpath, which can get expensive when many
3414 files are involved, do a quick comparison of the basenames. */
3415 if (! basenames_may_differ
3416 && FILENAME_CMP (lbasename (this_name), name_basename) != 0)
3417 continue;
3418
3419 this_real_name = dw2_get_real_path (objfile, file_data, j);
3420 if (compare_filenames_for_search (this_real_name, name))
3421 {
3422 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3423 callback, data))
3424 return 1;
3425 continue;
3426 }
3427
3428 if (real_path != NULL)
3429 {
3430 gdb_assert (IS_ABSOLUTE_PATH (real_path));
3431 gdb_assert (IS_ABSOLUTE_PATH (name));
3432 if (this_real_name != NULL
3433 && FILENAME_CMP (real_path, this_real_name) == 0)
3434 {
3435 if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
3436 callback, data))
3437 return 1;
3438 continue;
3439 }
3440 }
3441 }
3442 }
3443
3444 return 0;
3445 }
3446
3447 /* Struct used to manage iterating over all CUs looking for a symbol. */
3448
3449 struct dw2_symtab_iterator
3450 {
3451 /* The internalized form of .gdb_index. */
3452 struct mapped_index *index;
3453 /* If non-zero, only look for symbols that match BLOCK_INDEX. */
3454 int want_specific_block;
3455 /* One of GLOBAL_BLOCK or STATIC_BLOCK.
3456 Unused if !WANT_SPECIFIC_BLOCK. */
3457 int block_index;
3458 /* The kind of symbol we're looking for. */
3459 domain_enum domain;
3460 /* The list of CUs from the index entry of the symbol,
3461 or NULL if not found. */
3462 offset_type *vec;
3463 /* The next element in VEC to look at. */
3464 int next;
3465 /* The number of elements in VEC, or zero if there is no match. */
3466 int length;
3467 /* Have we seen a global version of the symbol?
3468 If so we can ignore all further global instances.
3469 This is to work around gold/15646, inefficient gold-generated
3470 indices. */
3471 int global_seen;
3472 };
3473
3474 /* Initialize the index symtab iterator ITER.
3475 If WANT_SPECIFIC_BLOCK is non-zero, only look for symbols
3476 in block BLOCK_INDEX. Otherwise BLOCK_INDEX is ignored. */
3477
3478 static void
3479 dw2_symtab_iter_init (struct dw2_symtab_iterator *iter,
3480 struct mapped_index *index,
3481 int want_specific_block,
3482 int block_index,
3483 domain_enum domain,
3484 const char *name)
3485 {
3486 iter->index = index;
3487 iter->want_specific_block = want_specific_block;
3488 iter->block_index = block_index;
3489 iter->domain = domain;
3490 iter->next = 0;
3491 iter->global_seen = 0;
3492
3493 if (find_slot_in_mapped_hash (index, name, &iter->vec))
3494 iter->length = MAYBE_SWAP (*iter->vec);
3495 else
3496 {
3497 iter->vec = NULL;
3498 iter->length = 0;
3499 }
3500 }
3501
3502 /* Return the next matching CU or NULL if there are no more. */
3503
3504 static struct dwarf2_per_cu_data *
3505 dw2_symtab_iter_next (struct dw2_symtab_iterator *iter)
3506 {
3507 for ( ; iter->next < iter->length; ++iter->next)
3508 {
3509 offset_type cu_index_and_attrs =
3510 MAYBE_SWAP (iter->vec[iter->next + 1]);
3511 offset_type cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
3512 struct dwarf2_per_cu_data *per_cu;
3513 int want_static = iter->block_index != GLOBAL_BLOCK;
3514 /* This value is only valid for index versions >= 7. */
3515 int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
3516 gdb_index_symbol_kind symbol_kind =
3517 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
3518 /* Only check the symbol attributes if they're present.
3519 Indices prior to version 7 don't record them,
3520 and indices >= 7 may elide them for certain symbols
3521 (gold does this). */
3522 int attrs_valid =
3523 (iter->index->version >= 7
3524 && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
3525
3526 /* Don't crash on bad data. */
3527 if (cu_index >= (dwarf2_per_objfile->n_comp_units
3528 + dwarf2_per_objfile->n_type_units))
3529 {
3530 complaint (&symfile_complaints,
3531 _(".gdb_index entry has bad CU index"
3532 " [in module %s]"),
3533 objfile_name (dwarf2_per_objfile->objfile));
3534 continue;
3535 }
3536
3537 per_cu = dw2_get_cutu (cu_index);
3538
3539 /* Skip if already read in. */
3540 if (per_cu->v.quick->symtab)
3541 continue;
3542
3543 /* Check static vs global. */
3544 if (attrs_valid)
3545 {
3546 if (iter->want_specific_block
3547 && want_static != is_static)
3548 continue;
3549 /* Work around gold/15646. */
3550 if (!is_static && iter->global_seen)
3551 continue;
3552 if (!is_static)
3553 iter->global_seen = 1;
3554 }
3555
3556 /* Only check the symbol's kind if it has one. */
3557 if (attrs_valid)
3558 {
3559 switch (iter->domain)
3560 {
3561 case VAR_DOMAIN:
3562 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE
3563 && symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION
3564 /* Some types are also in VAR_DOMAIN. */
3565 && symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
3566 continue;
3567 break;
3568 case STRUCT_DOMAIN:
3569 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
3570 continue;
3571 break;
3572 case LABEL_DOMAIN:
3573 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_OTHER)
3574 continue;
3575 break;
3576 default:
3577 break;
3578 }
3579 }
3580
3581 ++iter->next;
3582 return per_cu;
3583 }
3584
3585 return NULL;
3586 }
3587
3588 static struct symtab *
3589 dw2_lookup_symbol (struct objfile *objfile, int block_index,
3590 const char *name, domain_enum domain)
3591 {
3592 struct symtab *stab_best = NULL;
3593 struct mapped_index *index;
3594
3595 dw2_setup (objfile);
3596
3597 index = dwarf2_per_objfile->index_table;
3598
3599 /* index is NULL if OBJF_READNOW. */
3600 if (index)
3601 {
3602 struct dw2_symtab_iterator iter;
3603 struct dwarf2_per_cu_data *per_cu;
3604
3605 dw2_symtab_iter_init (&iter, index, 1, block_index, domain, name);
3606
3607 while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
3608 {
3609 struct symbol *sym = NULL;
3610 struct symtab *stab = dw2_instantiate_symtab (per_cu);
3611
3612 /* Some caution must be observed with overloaded functions
3613 and methods, since the index will not contain any overload
3614 information (but NAME might contain it). */
3615 if (stab->primary)
3616 {
3617 const struct blockvector *bv = BLOCKVECTOR (stab);
3618 struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
3619
3620 sym = lookup_block_symbol (block, name, domain);
3621 }
3622
3623 if (sym && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
3624 {
3625 if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
3626 return stab;
3627
3628 stab_best = stab;
3629 }
3630
3631 /* Keep looking through other CUs. */
3632 }
3633 }
3634
3635 return stab_best;
3636 }
3637
3638 static void
3639 dw2_print_stats (struct objfile *objfile)
3640 {
3641 int i, total, count;
3642
3643 dw2_setup (objfile);
3644 total = dwarf2_per_objfile->n_comp_units + dwarf2_per_objfile->n_type_units;
3645 count = 0;
3646 for (i = 0; i < total; ++i)
3647 {
3648 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
3649
3650 if (!per_cu->v.quick->symtab)
3651 ++count;
3652 }
3653 printf_filtered (_(" Number of read CUs: %d\n"), total - count);
3654 printf_filtered (_(" Number of unread CUs: %d\n"), count);
3655 }
3656
3657 /* This dumps minimal information about the index.
3658 It is called via "mt print objfiles".
3659 One use is to verify .gdb_index has been loaded by the
3660 gdb.dwarf2/gdb-index.exp testcase. */
3661
3662 static void
3663 dw2_dump (struct objfile *objfile)
3664 {
3665 dw2_setup (objfile);
3666 gdb_assert (dwarf2_per_objfile->using_index);
3667 printf_filtered (".gdb_index:");
3668 if (dwarf2_per_objfile->index_table != NULL)
3669 {
3670 printf_filtered (" version %d\n",
3671 dwarf2_per_objfile->index_table->version);
3672 }
3673 else
3674 printf_filtered (" faked for \"readnow\"\n");
3675 printf_filtered ("\n");
3676 }
3677
3678 static void
3679 dw2_relocate (struct objfile *objfile,
3680 const struct section_offsets *new_offsets,
3681 const struct section_offsets *delta)
3682 {
3683 /* There's nothing to relocate here. */
3684 }
3685
3686 static void
3687 dw2_expand_symtabs_for_function (struct objfile *objfile,
3688 const char *func_name)
3689 {
3690 struct mapped_index *index;
3691
3692 dw2_setup (objfile);
3693
3694 index = dwarf2_per_objfile->index_table;
3695
3696 /* index is NULL if OBJF_READNOW. */
3697 if (index)
3698 {
3699 struct dw2_symtab_iterator iter;
3700 struct dwarf2_per_cu_data *per_cu;
3701
3702 /* Note: It doesn't matter what we pass for block_index here. */
3703 dw2_symtab_iter_init (&iter, index, 0, GLOBAL_BLOCK, VAR_DOMAIN,
3704 func_name);
3705
3706 while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
3707 dw2_instantiate_symtab (per_cu);
3708 }
3709 }
3710
3711 static void
3712 dw2_expand_all_symtabs (struct objfile *objfile)
3713 {
3714 int i;
3715
3716 dw2_setup (objfile);
3717
3718 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
3719 + dwarf2_per_objfile->n_type_units); ++i)
3720 {
3721 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
3722
3723 dw2_instantiate_symtab (per_cu);
3724 }
3725 }
3726
3727 static void
3728 dw2_expand_symtabs_with_fullname (struct objfile *objfile,
3729 const char *fullname)
3730 {
3731 int i;
3732
3733 dw2_setup (objfile);
3734
3735 /* We don't need to consider type units here.
3736 This is only called for examining code, e.g. expand_line_sal.
3737 There can be an order of magnitude (or more) more type units
3738 than comp units, and we avoid them if we can. */
3739
3740 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
3741 {
3742 int j;
3743 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
3744 struct quick_file_names *file_data;
3745
3746 /* We only need to look at symtabs not already expanded. */
3747 if (per_cu->v.quick->symtab)
3748 continue;
3749
3750 file_data = dw2_get_file_names (per_cu);
3751 if (file_data == NULL)
3752 continue;
3753
3754 for (j = 0; j < file_data->num_file_names; ++j)
3755 {
3756 const char *this_fullname = file_data->file_names[j];
3757
3758 if (filename_cmp (this_fullname, fullname) == 0)
3759 {
3760 dw2_instantiate_symtab (per_cu);
3761 break;
3762 }
3763 }
3764 }
3765 }
3766
3767 static void
3768 dw2_map_matching_symbols (struct objfile *objfile,
3769 const char * name, domain_enum namespace,
3770 int global,
3771 int (*callback) (struct block *,
3772 struct symbol *, void *),
3773 void *data, symbol_compare_ftype *match,
3774 symbol_compare_ftype *ordered_compare)
3775 {
3776 /* Currently unimplemented; used for Ada. The function can be called if the
3777 current language is Ada for a non-Ada objfile using GNU index. As Ada
3778 does not look for non-Ada symbols this function should just return. */
3779 }
3780
3781 static void
3782 dw2_expand_symtabs_matching
3783 (struct objfile *objfile,
3784 expand_symtabs_file_matcher_ftype *file_matcher,
3785 expand_symtabs_symbol_matcher_ftype *symbol_matcher,
3786 enum search_domain kind,
3787 void *data)
3788 {
3789 int i;
3790 offset_type iter;
3791 struct mapped_index *index;
3792
3793 dw2_setup (objfile);
3794
3795 /* index_table is NULL if OBJF_READNOW. */
3796 if (!dwarf2_per_objfile->index_table)
3797 return;
3798 index = dwarf2_per_objfile->index_table;
3799
3800 if (file_matcher != NULL)
3801 {
3802 struct cleanup *cleanup;
3803 htab_t visited_found, visited_not_found;
3804
3805 visited_found = htab_create_alloc (10,
3806 htab_hash_pointer, htab_eq_pointer,
3807 NULL, xcalloc, xfree);
3808 cleanup = make_cleanup_htab_delete (visited_found);
3809 visited_not_found = htab_create_alloc (10,
3810 htab_hash_pointer, htab_eq_pointer,
3811 NULL, xcalloc, xfree);
3812 make_cleanup_htab_delete (visited_not_found);
3813
3814 /* The rule is CUs specify all the files, including those used by
3815 any TU, so there's no need to scan TUs here. */
3816
3817 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
3818 {
3819 int j;
3820 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
3821 struct quick_file_names *file_data;
3822 void **slot;
3823
3824 per_cu->v.quick->mark = 0;
3825
3826 /* We only need to look at symtabs not already expanded. */
3827 if (per_cu->v.quick->symtab)
3828 continue;
3829
3830 file_data = dw2_get_file_names (per_cu);
3831 if (file_data == NULL)
3832 continue;
3833
3834 if (htab_find (visited_not_found, file_data) != NULL)
3835 continue;
3836 else if (htab_find (visited_found, file_data) != NULL)
3837 {
3838 per_cu->v.quick->mark = 1;
3839 continue;
3840 }
3841
3842 for (j = 0; j < file_data->num_file_names; ++j)
3843 {
3844 const char *this_real_name;
3845
3846 if (file_matcher (file_data->file_names[j], data, 0))
3847 {
3848 per_cu->v.quick->mark = 1;
3849 break;
3850 }
3851
3852 /* Before we invoke realpath, which can get expensive when many
3853 files are involved, do a quick comparison of the basenames. */
3854 if (!basenames_may_differ
3855 && !file_matcher (lbasename (file_data->file_names[j]),
3856 data, 1))
3857 continue;
3858
3859 this_real_name = dw2_get_real_path (objfile, file_data, j);
3860 if (file_matcher (this_real_name, data, 0))
3861 {
3862 per_cu->v.quick->mark = 1;
3863 break;
3864 }
3865 }
3866
3867 slot = htab_find_slot (per_cu->v.quick->mark
3868 ? visited_found
3869 : visited_not_found,
3870 file_data, INSERT);
3871 *slot = file_data;
3872 }
3873
3874 do_cleanups (cleanup);
3875 }
3876
3877 for (iter = 0; iter < index->symbol_table_slots; ++iter)
3878 {
3879 offset_type idx = 2 * iter;
3880 const char *name;
3881 offset_type *vec, vec_len, vec_idx;
3882 int global_seen = 0;
3883
3884 if (index->symbol_table[idx] == 0 && index->symbol_table[idx + 1] == 0)
3885 continue;
3886
3887 name = index->constant_pool + MAYBE_SWAP (index->symbol_table[idx]);
3888
3889 if (! (*symbol_matcher) (name, data))
3890 continue;
3891
3892 /* The name was matched, now expand corresponding CUs that were
3893 marked. */
3894 vec = (offset_type *) (index->constant_pool
3895 + MAYBE_SWAP (index->symbol_table[idx + 1]));
3896 vec_len = MAYBE_SWAP (vec[0]);
3897 for (vec_idx = 0; vec_idx < vec_len; ++vec_idx)
3898 {
3899 struct dwarf2_per_cu_data *per_cu;
3900 offset_type cu_index_and_attrs = MAYBE_SWAP (vec[vec_idx + 1]);
3901 /* This value is only valid for index versions >= 7. */
3902 int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
3903 gdb_index_symbol_kind symbol_kind =
3904 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
3905 int cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
3906 /* Only check the symbol attributes if they're present.
3907 Indices prior to version 7 don't record them,
3908 and indices >= 7 may elide them for certain symbols
3909 (gold does this). */
3910 int attrs_valid =
3911 (index->version >= 7
3912 && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
3913
3914 /* Work around gold/15646. */
3915 if (attrs_valid)
3916 {
3917 if (!is_static && global_seen)
3918 continue;
3919 if (!is_static)
3920 global_seen = 1;
3921 }
3922
3923 /* Only check the symbol's kind if it has one. */
3924 if (attrs_valid)
3925 {
3926 switch (kind)
3927 {
3928 case VARIABLES_DOMAIN:
3929 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE)
3930 continue;
3931 break;
3932 case FUNCTIONS_DOMAIN:
3933 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION)
3934 continue;
3935 break;
3936 case TYPES_DOMAIN:
3937 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
3938 continue;
3939 break;
3940 default:
3941 break;
3942 }
3943 }
3944
3945 /* Don't crash on bad data. */
3946 if (cu_index >= (dwarf2_per_objfile->n_comp_units
3947 + dwarf2_per_objfile->n_type_units))
3948 {
3949 complaint (&symfile_complaints,
3950 _(".gdb_index entry has bad CU index"
3951 " [in module %s]"), objfile_name (objfile));
3952 continue;
3953 }
3954
3955 per_cu = dw2_get_cutu (cu_index);
3956 if (file_matcher == NULL || per_cu->v.quick->mark)
3957 dw2_instantiate_symtab (per_cu);
3958 }
3959 }
3960 }
3961
3962 /* A helper for dw2_find_pc_sect_symtab which finds the most specific
3963 symtab. */
3964
3965 static struct symtab *
3966 recursively_find_pc_sect_symtab (struct symtab *symtab, CORE_ADDR pc)
3967 {
3968 int i;
3969
3970 if (BLOCKVECTOR (symtab) != NULL
3971 && blockvector_contains_pc (BLOCKVECTOR (symtab), pc))
3972 return symtab;
3973
3974 if (symtab->includes == NULL)
3975 return NULL;
3976
3977 for (i = 0; symtab->includes[i]; ++i)
3978 {
3979 struct symtab *s = symtab->includes[i];
3980
3981 s = recursively_find_pc_sect_symtab (s, pc);
3982 if (s != NULL)
3983 return s;
3984 }
3985
3986 return NULL;
3987 }
3988
3989 static struct symtab *
3990 dw2_find_pc_sect_symtab (struct objfile *objfile,
3991 struct bound_minimal_symbol msymbol,
3992 CORE_ADDR pc,
3993 struct obj_section *section,
3994 int warn_if_readin)
3995 {
3996 struct dwarf2_per_cu_data *data;
3997 struct symtab *result;
3998
3999 dw2_setup (objfile);
4000
4001 if (!objfile->psymtabs_addrmap)
4002 return NULL;
4003
4004 data = addrmap_find (objfile->psymtabs_addrmap, pc);
4005 if (!data)
4006 return NULL;
4007
4008 if (warn_if_readin && data->v.quick->symtab)
4009 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
4010 paddress (get_objfile_arch (objfile), pc));
4011
4012 result = recursively_find_pc_sect_symtab (dw2_instantiate_symtab (data), pc);
4013 gdb_assert (result != NULL);
4014 return result;
4015 }
4016
4017 static void
4018 dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun,
4019 void *data, int need_fullname)
4020 {
4021 int i;
4022 struct cleanup *cleanup;
4023 htab_t visited = htab_create_alloc (10, htab_hash_pointer, htab_eq_pointer,
4024 NULL, xcalloc, xfree);
4025
4026 cleanup = make_cleanup_htab_delete (visited);
4027 dw2_setup (objfile);
4028
4029 /* The rule is CUs specify all the files, including those used by
4030 any TU, so there's no need to scan TUs here.
4031 We can ignore file names coming from already-expanded CUs. */
4032
4033 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
4034 {
4035 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
4036
4037 if (per_cu->v.quick->symtab)
4038 {
4039 void **slot = htab_find_slot (visited, per_cu->v.quick->file_names,
4040 INSERT);
4041
4042 *slot = per_cu->v.quick->file_names;
4043 }
4044 }
4045
4046 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
4047 {
4048 int j;
4049 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
4050 struct quick_file_names *file_data;
4051 void **slot;
4052
4053 /* We only need to look at symtabs not already expanded. */
4054 if (per_cu->v.quick->symtab)
4055 continue;
4056
4057 file_data = dw2_get_file_names (per_cu);
4058 if (file_data == NULL)
4059 continue;
4060
4061 slot = htab_find_slot (visited, file_data, INSERT);
4062 if (*slot)
4063 {
4064 /* Already visited. */
4065 continue;
4066 }
4067 *slot = file_data;
4068
4069 for (j = 0; j < file_data->num_file_names; ++j)
4070 {
4071 const char *this_real_name;
4072
4073 if (need_fullname)
4074 this_real_name = dw2_get_real_path (objfile, file_data, j);
4075 else
4076 this_real_name = NULL;
4077 (*fun) (file_data->file_names[j], this_real_name, data);
4078 }
4079 }
4080
4081 do_cleanups (cleanup);
4082 }
4083
4084 static int
4085 dw2_has_symbols (struct objfile *objfile)
4086 {
4087 return 1;
4088 }
4089
4090 const struct quick_symbol_functions dwarf2_gdb_index_functions =
4091 {
4092 dw2_has_symbols,
4093 dw2_find_last_source_symtab,
4094 dw2_forget_cached_source_info,
4095 dw2_map_symtabs_matching_filename,
4096 dw2_lookup_symbol,
4097 dw2_print_stats,
4098 dw2_dump,
4099 dw2_relocate,
4100 dw2_expand_symtabs_for_function,
4101 dw2_expand_all_symtabs,
4102 dw2_expand_symtabs_with_fullname,
4103 dw2_map_matching_symbols,
4104 dw2_expand_symtabs_matching,
4105 dw2_find_pc_sect_symtab,
4106 dw2_map_symbol_filenames
4107 };
4108
4109 /* Initialize for reading DWARF for this objfile. Return 0 if this
4110 file will use psymtabs, or 1 if using the GNU index. */
4111
4112 int
4113 dwarf2_initialize_objfile (struct objfile *objfile)
4114 {
4115 /* If we're about to read full symbols, don't bother with the
4116 indices. In this case we also don't care if some other debug
4117 format is making psymtabs, because they are all about to be
4118 expanded anyway. */
4119 if ((objfile->flags & OBJF_READNOW))
4120 {
4121 int i;
4122
4123 dwarf2_per_objfile->using_index = 1;
4124 create_all_comp_units (objfile);
4125 create_all_type_units (objfile);
4126 dwarf2_per_objfile->quick_file_names_table =
4127 create_quick_file_names_table (dwarf2_per_objfile->n_comp_units);
4128
4129 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
4130 + dwarf2_per_objfile->n_type_units); ++i)
4131 {
4132 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
4133
4134 per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
4135 struct dwarf2_per_cu_quick_data);
4136 }
4137
4138 /* Return 1 so that gdb sees the "quick" functions. However,
4139 these functions will be no-ops because we will have expanded
4140 all symtabs. */
4141 return 1;
4142 }
4143
4144 if (dwarf2_read_index (objfile))
4145 return 1;
4146
4147 return 0;
4148 }
4149
4150 \f
4151
4152 /* Build a partial symbol table. */
4153
4154 void
4155 dwarf2_build_psymtabs (struct objfile *objfile)
4156 {
4157 volatile struct gdb_exception except;
4158
4159 if (objfile->global_psymbols.size == 0 && objfile->static_psymbols.size == 0)
4160 {
4161 init_psymbol_list (objfile, 1024);
4162 }
4163
4164 TRY_CATCH (except, RETURN_MASK_ERROR)
4165 {
4166 /* This isn't really ideal: all the data we allocate on the
4167 objfile's obstack is still uselessly kept around. However,
4168 freeing it seems unsafe. */
4169 struct cleanup *cleanups = make_cleanup_discard_psymtabs (objfile);
4170
4171 dwarf2_build_psymtabs_hard (objfile);
4172 discard_cleanups (cleanups);
4173 }
4174 if (except.reason < 0)
4175 exception_print (gdb_stderr, except);
4176 }
4177
4178 /* Return the total length of the CU described by HEADER. */
4179
4180 static unsigned int
4181 get_cu_length (const struct comp_unit_head *header)
4182 {
4183 return header->initial_length_size + header->length;
4184 }
4185
4186 /* Return TRUE if OFFSET is within CU_HEADER. */
4187
4188 static inline int
4189 offset_in_cu_p (const struct comp_unit_head *cu_header, sect_offset offset)
4190 {
4191 sect_offset bottom = { cu_header->offset.sect_off };
4192 sect_offset top = { cu_header->offset.sect_off + get_cu_length (cu_header) };
4193
4194 return (offset.sect_off >= bottom.sect_off && offset.sect_off < top.sect_off);
4195 }
4196
4197 /* Find the base address of the compilation unit for range lists and
4198 location lists. It will normally be specified by DW_AT_low_pc.
4199 In DWARF-3 draft 4, the base address could be overridden by
4200 DW_AT_entry_pc. It's been removed, but GCC still uses this for
4201 compilation units with discontinuous ranges. */
4202
4203 static void
4204 dwarf2_find_base_address (struct die_info *die, struct dwarf2_cu *cu)
4205 {
4206 struct attribute *attr;
4207
4208 cu->base_known = 0;
4209 cu->base_address = 0;
4210
4211 attr = dwarf2_attr (die, DW_AT_entry_pc, cu);
4212 if (attr)
4213 {
4214 cu->base_address = attr_value_as_address (attr);
4215 cu->base_known = 1;
4216 }
4217 else
4218 {
4219 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
4220 if (attr)
4221 {
4222 cu->base_address = attr_value_as_address (attr);
4223 cu->base_known = 1;
4224 }
4225 }
4226 }
4227
4228 /* Read in the comp unit header information from the debug_info at info_ptr.
4229 NOTE: This leaves members offset, first_die_offset to be filled in
4230 by the caller. */
4231
4232 static const gdb_byte *
4233 read_comp_unit_head (struct comp_unit_head *cu_header,
4234 const gdb_byte *info_ptr, bfd *abfd)
4235 {
4236 int signed_addr;
4237 unsigned int bytes_read;
4238
4239 cu_header->length = read_initial_length (abfd, info_ptr, &bytes_read);
4240 cu_header->initial_length_size = bytes_read;
4241 cu_header->offset_size = (bytes_read == 4) ? 4 : 8;
4242 info_ptr += bytes_read;
4243 cu_header->version = read_2_bytes (abfd, info_ptr);
4244 info_ptr += 2;
4245 cu_header->abbrev_offset.sect_off = read_offset (abfd, info_ptr, cu_header,
4246 &bytes_read);
4247 info_ptr += bytes_read;
4248 cu_header->addr_size = read_1_byte (abfd, info_ptr);
4249 info_ptr += 1;
4250 signed_addr = bfd_get_sign_extend_vma (abfd);
4251 if (signed_addr < 0)
4252 internal_error (__FILE__, __LINE__,
4253 _("read_comp_unit_head: dwarf from non elf file"));
4254 cu_header->signed_addr_p = signed_addr;
4255
4256 return info_ptr;
4257 }
4258
4259 /* Helper function that returns the proper abbrev section for
4260 THIS_CU. */
4261
4262 static struct dwarf2_section_info *
4263 get_abbrev_section_for_cu (struct dwarf2_per_cu_data *this_cu)
4264 {
4265 struct dwarf2_section_info *abbrev;
4266
4267 if (this_cu->is_dwz)
4268 abbrev = &dwarf2_get_dwz_file ()->abbrev;
4269 else
4270 abbrev = &dwarf2_per_objfile->abbrev;
4271
4272 return abbrev;
4273 }
4274
4275 /* Subroutine of read_and_check_comp_unit_head and
4276 read_and_check_type_unit_head to simplify them.
4277 Perform various error checking on the header. */
4278
4279 static void
4280 error_check_comp_unit_head (struct comp_unit_head *header,
4281 struct dwarf2_section_info *section,
4282 struct dwarf2_section_info *abbrev_section)
4283 {
4284 bfd *abfd = get_section_bfd_owner (section);
4285 const char *filename = get_section_file_name (section);
4286
4287 if (header->version != 2 && header->version != 3 && header->version != 4)
4288 error (_("Dwarf Error: wrong version in compilation unit header "
4289 "(is %d, should be 2, 3, or 4) [in module %s]"), header->version,
4290 filename);
4291
4292 if (header->abbrev_offset.sect_off
4293 >= dwarf2_section_size (dwarf2_per_objfile->objfile, abbrev_section))
4294 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
4295 "(offset 0x%lx + 6) [in module %s]"),
4296 (long) header->abbrev_offset.sect_off, (long) header->offset.sect_off,
4297 filename);
4298
4299 /* Cast to unsigned long to use 64-bit arithmetic when possible to
4300 avoid potential 32-bit overflow. */
4301 if (((unsigned long) header->offset.sect_off + get_cu_length (header))
4302 > section->size)
4303 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
4304 "(offset 0x%lx + 0) [in module %s]"),
4305 (long) header->length, (long) header->offset.sect_off,
4306 filename);
4307 }
4308
4309 /* Read in a CU/TU header and perform some basic error checking.
4310 The contents of the header are stored in HEADER.
4311 The result is a pointer to the start of the first DIE. */
4312
4313 static const gdb_byte *
4314 read_and_check_comp_unit_head (struct comp_unit_head *header,
4315 struct dwarf2_section_info *section,
4316 struct dwarf2_section_info *abbrev_section,
4317 const gdb_byte *info_ptr,
4318 int is_debug_types_section)
4319 {
4320 const gdb_byte *beg_of_comp_unit = info_ptr;
4321 bfd *abfd = get_section_bfd_owner (section);
4322
4323 header->offset.sect_off = beg_of_comp_unit - section->buffer;
4324
4325 info_ptr = read_comp_unit_head (header, info_ptr, abfd);
4326
4327 /* If we're reading a type unit, skip over the signature and
4328 type_offset fields. */
4329 if (is_debug_types_section)
4330 info_ptr += 8 /*signature*/ + header->offset_size;
4331
4332 header->first_die_offset.cu_off = info_ptr - beg_of_comp_unit;
4333
4334 error_check_comp_unit_head (header, section, abbrev_section);
4335
4336 return info_ptr;
4337 }
4338
4339 /* Read in the types comp unit header information from .debug_types entry at
4340 types_ptr. The result is a pointer to one past the end of the header. */
4341
4342 static const gdb_byte *
4343 read_and_check_type_unit_head (struct comp_unit_head *header,
4344 struct dwarf2_section_info *section,
4345 struct dwarf2_section_info *abbrev_section,
4346 const gdb_byte *info_ptr,
4347 ULONGEST *signature,
4348 cu_offset *type_offset_in_tu)
4349 {
4350 const gdb_byte *beg_of_comp_unit = info_ptr;
4351 bfd *abfd = get_section_bfd_owner (section);
4352
4353 header->offset.sect_off = beg_of_comp_unit - section->buffer;
4354
4355 info_ptr = read_comp_unit_head (header, info_ptr, abfd);
4356
4357 /* If we're reading a type unit, skip over the signature and
4358 type_offset fields. */
4359 if (signature != NULL)
4360 *signature = read_8_bytes (abfd, info_ptr);
4361 info_ptr += 8;
4362 if (type_offset_in_tu != NULL)
4363 type_offset_in_tu->cu_off = read_offset_1 (abfd, info_ptr,
4364 header->offset_size);
4365 info_ptr += header->offset_size;
4366
4367 header->first_die_offset.cu_off = info_ptr - beg_of_comp_unit;
4368
4369 error_check_comp_unit_head (header, section, abbrev_section);
4370
4371 return info_ptr;
4372 }
4373
4374 /* Fetch the abbreviation table offset from a comp or type unit header. */
4375
4376 static sect_offset
4377 read_abbrev_offset (struct dwarf2_section_info *section,
4378 sect_offset offset)
4379 {
4380 bfd *abfd = get_section_bfd_owner (section);
4381 const gdb_byte *info_ptr;
4382 unsigned int length, initial_length_size, offset_size;
4383 sect_offset abbrev_offset;
4384
4385 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
4386 info_ptr = section->buffer + offset.sect_off;
4387 length = read_initial_length (abfd, info_ptr, &initial_length_size);
4388 offset_size = initial_length_size == 4 ? 4 : 8;
4389 info_ptr += initial_length_size + 2 /*version*/;
4390 abbrev_offset.sect_off = read_offset_1 (abfd, info_ptr, offset_size);
4391 return abbrev_offset;
4392 }
4393
4394 /* Allocate a new partial symtab for file named NAME and mark this new
4395 partial symtab as being an include of PST. */
4396
4397 static void
4398 dwarf2_create_include_psymtab (const char *name, struct partial_symtab *pst,
4399 struct objfile *objfile)
4400 {
4401 struct partial_symtab *subpst = allocate_psymtab (name, objfile);
4402
4403 if (!IS_ABSOLUTE_PATH (subpst->filename))
4404 {
4405 /* It shares objfile->objfile_obstack. */
4406 subpst->dirname = pst->dirname;
4407 }
4408
4409 subpst->section_offsets = pst->section_offsets;
4410 subpst->textlow = 0;
4411 subpst->texthigh = 0;
4412
4413 subpst->dependencies = (struct partial_symtab **)
4414 obstack_alloc (&objfile->objfile_obstack,
4415 sizeof (struct partial_symtab *));
4416 subpst->dependencies[0] = pst;
4417 subpst->number_of_dependencies = 1;
4418
4419 subpst->globals_offset = 0;
4420 subpst->n_global_syms = 0;
4421 subpst->statics_offset = 0;
4422 subpst->n_static_syms = 0;
4423 subpst->symtab = NULL;
4424 subpst->read_symtab = pst->read_symtab;
4425 subpst->readin = 0;
4426
4427 /* No private part is necessary for include psymtabs. This property
4428 can be used to differentiate between such include psymtabs and
4429 the regular ones. */
4430 subpst->read_symtab_private = NULL;
4431 }
4432
4433 /* Read the Line Number Program data and extract the list of files
4434 included by the source file represented by PST. Build an include
4435 partial symtab for each of these included files. */
4436
4437 static void
4438 dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
4439 struct die_info *die,
4440 struct partial_symtab *pst)
4441 {
4442 struct line_header *lh = NULL;
4443 struct attribute *attr;
4444
4445 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
4446 if (attr)
4447 lh = dwarf_decode_line_header (DW_UNSND (attr), cu);
4448 if (lh == NULL)
4449 return; /* No linetable, so no includes. */
4450
4451 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
4452 dwarf_decode_lines (lh, pst->dirname, cu, pst, 1);
4453
4454 free_line_header (lh);
4455 }
4456
4457 static hashval_t
4458 hash_signatured_type (const void *item)
4459 {
4460 const struct signatured_type *sig_type = item;
4461
4462 /* This drops the top 32 bits of the signature, but is ok for a hash. */
4463 return sig_type->signature;
4464 }
4465
4466 static int
4467 eq_signatured_type (const void *item_lhs, const void *item_rhs)
4468 {
4469 const struct signatured_type *lhs = item_lhs;
4470 const struct signatured_type *rhs = item_rhs;
4471
4472 return lhs->signature == rhs->signature;
4473 }
4474
4475 /* Allocate a hash table for signatured types. */
4476
4477 static htab_t
4478 allocate_signatured_type_table (struct objfile *objfile)
4479 {
4480 return htab_create_alloc_ex (41,
4481 hash_signatured_type,
4482 eq_signatured_type,
4483 NULL,
4484 &objfile->objfile_obstack,
4485 hashtab_obstack_allocate,
4486 dummy_obstack_deallocate);
4487 }
4488
4489 /* A helper function to add a signatured type CU to a table. */
4490
4491 static int
4492 add_signatured_type_cu_to_table (void **slot, void *datum)
4493 {
4494 struct signatured_type *sigt = *slot;
4495 struct signatured_type ***datap = datum;
4496
4497 **datap = sigt;
4498 ++*datap;
4499
4500 return 1;
4501 }
4502
4503 /* Create the hash table of all entries in the .debug_types
4504 (or .debug_types.dwo) section(s).
4505 If reading a DWO file, then DWO_FILE is a pointer to the DWO file object,
4506 otherwise it is NULL.
4507
4508 The result is a pointer to the hash table or NULL if there are no types.
4509
4510 Note: This function processes DWO files only, not DWP files. */
4511
4512 static htab_t
4513 create_debug_types_hash_table (struct dwo_file *dwo_file,
4514 VEC (dwarf2_section_info_def) *types)
4515 {
4516 struct objfile *objfile = dwarf2_per_objfile->objfile;
4517 htab_t types_htab = NULL;
4518 int ix;
4519 struct dwarf2_section_info *section;
4520 struct dwarf2_section_info *abbrev_section;
4521
4522 if (VEC_empty (dwarf2_section_info_def, types))
4523 return NULL;
4524
4525 abbrev_section = (dwo_file != NULL
4526 ? &dwo_file->sections.abbrev
4527 : &dwarf2_per_objfile->abbrev);
4528
4529 if (dwarf2_read_debug)
4530 fprintf_unfiltered (gdb_stdlog, "Reading .debug_types%s for %s:\n",
4531 dwo_file ? ".dwo" : "",
4532 get_section_file_name (abbrev_section));
4533
4534 for (ix = 0;
4535 VEC_iterate (dwarf2_section_info_def, types, ix, section);
4536 ++ix)
4537 {
4538 bfd *abfd;
4539 const gdb_byte *info_ptr, *end_ptr;
4540
4541 dwarf2_read_section (objfile, section);
4542 info_ptr = section->buffer;
4543
4544 if (info_ptr == NULL)
4545 continue;
4546
4547 /* We can't set abfd until now because the section may be empty or
4548 not present, in which case the bfd is unknown. */
4549 abfd = get_section_bfd_owner (section);
4550
4551 /* We don't use init_cutu_and_read_dies_simple, or some such, here
4552 because we don't need to read any dies: the signature is in the
4553 header. */
4554
4555 end_ptr = info_ptr + section->size;
4556 while (info_ptr < end_ptr)
4557 {
4558 sect_offset offset;
4559 cu_offset type_offset_in_tu;
4560 ULONGEST signature;
4561 struct signatured_type *sig_type;
4562 struct dwo_unit *dwo_tu;
4563 void **slot;
4564 const gdb_byte *ptr = info_ptr;
4565 struct comp_unit_head header;
4566 unsigned int length;
4567
4568 offset.sect_off = ptr - section->buffer;
4569
4570 /* We need to read the type's signature in order to build the hash
4571 table, but we don't need anything else just yet. */
4572
4573 ptr = read_and_check_type_unit_head (&header, section,
4574 abbrev_section, ptr,
4575 &signature, &type_offset_in_tu);
4576
4577 length = get_cu_length (&header);
4578
4579 /* Skip dummy type units. */
4580 if (ptr >= info_ptr + length
4581 || peek_abbrev_code (abfd, ptr) == 0)
4582 {
4583 info_ptr += length;
4584 continue;
4585 }
4586
4587 if (types_htab == NULL)
4588 {
4589 if (dwo_file)
4590 types_htab = allocate_dwo_unit_table (objfile);
4591 else
4592 types_htab = allocate_signatured_type_table (objfile);
4593 }
4594
4595 if (dwo_file)
4596 {
4597 sig_type = NULL;
4598 dwo_tu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
4599 struct dwo_unit);
4600 dwo_tu->dwo_file = dwo_file;
4601 dwo_tu->signature = signature;
4602 dwo_tu->type_offset_in_tu = type_offset_in_tu;
4603 dwo_tu->section = section;
4604 dwo_tu->offset = offset;
4605 dwo_tu->length = length;
4606 }
4607 else
4608 {
4609 /* N.B.: type_offset is not usable if this type uses a DWO file.
4610 The real type_offset is in the DWO file. */
4611 dwo_tu = NULL;
4612 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
4613 struct signatured_type);
4614 sig_type->signature = signature;
4615 sig_type->type_offset_in_tu = type_offset_in_tu;
4616 sig_type->per_cu.objfile = objfile;
4617 sig_type->per_cu.is_debug_types = 1;
4618 sig_type->per_cu.section = section;
4619 sig_type->per_cu.offset = offset;
4620 sig_type->per_cu.length = length;
4621 }
4622
4623 slot = htab_find_slot (types_htab,
4624 dwo_file ? (void*) dwo_tu : (void *) sig_type,
4625 INSERT);
4626 gdb_assert (slot != NULL);
4627 if (*slot != NULL)
4628 {
4629 sect_offset dup_offset;
4630
4631 if (dwo_file)
4632 {
4633 const struct dwo_unit *dup_tu = *slot;
4634
4635 dup_offset = dup_tu->offset;
4636 }
4637 else
4638 {
4639 const struct signatured_type *dup_tu = *slot;
4640
4641 dup_offset = dup_tu->per_cu.offset;
4642 }
4643
4644 complaint (&symfile_complaints,
4645 _("debug type entry at offset 0x%x is duplicate to"
4646 " the entry at offset 0x%x, signature %s"),
4647 offset.sect_off, dup_offset.sect_off,
4648 hex_string (signature));
4649 }
4650 *slot = dwo_file ? (void *) dwo_tu : (void *) sig_type;
4651
4652 if (dwarf2_read_debug > 1)
4653 fprintf_unfiltered (gdb_stdlog, " offset 0x%x, signature %s\n",
4654 offset.sect_off,
4655 hex_string (signature));
4656
4657 info_ptr += length;
4658 }
4659 }
4660
4661 return types_htab;
4662 }
4663
4664 /* Create the hash table of all entries in the .debug_types section,
4665 and initialize all_type_units.
4666 The result is zero if there is an error (e.g. missing .debug_types section),
4667 otherwise non-zero. */
4668
4669 static int
4670 create_all_type_units (struct objfile *objfile)
4671 {
4672 htab_t types_htab;
4673 struct signatured_type **iter;
4674
4675 types_htab = create_debug_types_hash_table (NULL, dwarf2_per_objfile->types);
4676 if (types_htab == NULL)
4677 {
4678 dwarf2_per_objfile->signatured_types = NULL;
4679 return 0;
4680 }
4681
4682 dwarf2_per_objfile->signatured_types = types_htab;
4683
4684 dwarf2_per_objfile->n_type_units
4685 = dwarf2_per_objfile->n_allocated_type_units
4686 = htab_elements (types_htab);
4687 dwarf2_per_objfile->all_type_units
4688 = xmalloc (dwarf2_per_objfile->n_type_units
4689 * sizeof (struct signatured_type *));
4690 iter = &dwarf2_per_objfile->all_type_units[0];
4691 htab_traverse_noresize (types_htab, add_signatured_type_cu_to_table, &iter);
4692 gdb_assert (iter - &dwarf2_per_objfile->all_type_units[0]
4693 == dwarf2_per_objfile->n_type_units);
4694
4695 return 1;
4696 }
4697
4698 /* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types.
4699 If SLOT is non-NULL, it is the entry to use in the hash table.
4700 Otherwise we find one. */
4701
4702 static struct signatured_type *
4703 add_type_unit (ULONGEST sig, void **slot)
4704 {
4705 struct objfile *objfile = dwarf2_per_objfile->objfile;
4706 int n_type_units = dwarf2_per_objfile->n_type_units;
4707 struct signatured_type *sig_type;
4708
4709 gdb_assert (n_type_units <= dwarf2_per_objfile->n_allocated_type_units);
4710 ++n_type_units;
4711 if (n_type_units > dwarf2_per_objfile->n_allocated_type_units)
4712 {
4713 if (dwarf2_per_objfile->n_allocated_type_units == 0)
4714 dwarf2_per_objfile->n_allocated_type_units = 1;
4715 dwarf2_per_objfile->n_allocated_type_units *= 2;
4716 dwarf2_per_objfile->all_type_units
4717 = xrealloc (dwarf2_per_objfile->all_type_units,
4718 dwarf2_per_objfile->n_allocated_type_units
4719 * sizeof (struct signatured_type *));
4720 ++dwarf2_per_objfile->tu_stats.nr_all_type_units_reallocs;
4721 }
4722 dwarf2_per_objfile->n_type_units = n_type_units;
4723
4724 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
4725 struct signatured_type);
4726 dwarf2_per_objfile->all_type_units[n_type_units - 1] = sig_type;
4727 sig_type->signature = sig;
4728 sig_type->per_cu.is_debug_types = 1;
4729 if (dwarf2_per_objfile->using_index)
4730 {
4731 sig_type->per_cu.v.quick =
4732 OBSTACK_ZALLOC (&objfile->objfile_obstack,
4733 struct dwarf2_per_cu_quick_data);
4734 }
4735
4736 if (slot == NULL)
4737 {
4738 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
4739 sig_type, INSERT);
4740 }
4741 gdb_assert (*slot == NULL);
4742 *slot = sig_type;
4743 /* The rest of sig_type must be filled in by the caller. */
4744 return sig_type;
4745 }
4746
4747 /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type.
4748 Fill in SIG_ENTRY with DWO_ENTRY. */
4749
4750 static void
4751 fill_in_sig_entry_from_dwo_entry (struct objfile *objfile,
4752 struct signatured_type *sig_entry,
4753 struct dwo_unit *dwo_entry)
4754 {
4755 /* Make sure we're not clobbering something we don't expect to. */
4756 gdb_assert (! sig_entry->per_cu.queued);
4757 gdb_assert (sig_entry->per_cu.cu == NULL);
4758 if (dwarf2_per_objfile->using_index)
4759 {
4760 gdb_assert (sig_entry->per_cu.v.quick != NULL);
4761 gdb_assert (sig_entry->per_cu.v.quick->symtab == NULL);
4762 }
4763 else
4764 gdb_assert (sig_entry->per_cu.v.psymtab == NULL);
4765 gdb_assert (sig_entry->signature == dwo_entry->signature);
4766 gdb_assert (sig_entry->type_offset_in_section.sect_off == 0);
4767 gdb_assert (sig_entry->type_unit_group == NULL);
4768 gdb_assert (sig_entry->dwo_unit == NULL);
4769
4770 sig_entry->per_cu.section = dwo_entry->section;
4771 sig_entry->per_cu.offset = dwo_entry->offset;
4772 sig_entry->per_cu.length = dwo_entry->length;
4773 sig_entry->per_cu.reading_dwo_directly = 1;
4774 sig_entry->per_cu.objfile = objfile;
4775 sig_entry->type_offset_in_tu = dwo_entry->type_offset_in_tu;
4776 sig_entry->dwo_unit = dwo_entry;
4777 }
4778
4779 /* Subroutine of lookup_signatured_type.
4780 If we haven't read the TU yet, create the signatured_type data structure
4781 for a TU to be read in directly from a DWO file, bypassing the stub.
4782 This is the "Stay in DWO Optimization": When there is no DWP file and we're
4783 using .gdb_index, then when reading a CU we want to stay in the DWO file
4784 containing that CU. Otherwise we could end up reading several other DWO
4785 files (due to comdat folding) to process the transitive closure of all the
4786 mentioned TUs, and that can be slow. The current DWO file will have every
4787 type signature that it needs.
4788 We only do this for .gdb_index because in the psymtab case we already have
4789 to read all the DWOs to build the type unit groups. */
4790
4791 static struct signatured_type *
4792 lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
4793 {
4794 struct objfile *objfile = dwarf2_per_objfile->objfile;
4795 struct dwo_file *dwo_file;
4796 struct dwo_unit find_dwo_entry, *dwo_entry;
4797 struct signatured_type find_sig_entry, *sig_entry;
4798 void **slot;
4799
4800 gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
4801
4802 /* If TU skeletons have been removed then we may not have read in any
4803 TUs yet. */
4804 if (dwarf2_per_objfile->signatured_types == NULL)
4805 {
4806 dwarf2_per_objfile->signatured_types
4807 = allocate_signatured_type_table (objfile);
4808 }
4809
4810 /* We only ever need to read in one copy of a signatured type.
4811 Use the global signatured_types array to do our own comdat-folding
4812 of types. If this is the first time we're reading this TU, and
4813 the TU has an entry in .gdb_index, replace the recorded data from
4814 .gdb_index with this TU. */
4815
4816 find_sig_entry.signature = sig;
4817 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
4818 &find_sig_entry, INSERT);
4819 sig_entry = *slot;
4820
4821 /* We can get here with the TU already read, *or* in the process of being
4822 read. Don't reassign the global entry to point to this DWO if that's
4823 the case. Also note that if the TU is already being read, it may not
4824 have come from a DWO, the program may be a mix of Fission-compiled
4825 code and non-Fission-compiled code. */
4826
4827 /* Have we already tried to read this TU?
4828 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
4829 needn't exist in the global table yet). */
4830 if (sig_entry != NULL && sig_entry->per_cu.tu_read)
4831 return sig_entry;
4832
4833 /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the
4834 dwo_unit of the TU itself. */
4835 dwo_file = cu->dwo_unit->dwo_file;
4836
4837 /* Ok, this is the first time we're reading this TU. */
4838 if (dwo_file->tus == NULL)
4839 return NULL;
4840 find_dwo_entry.signature = sig;
4841 dwo_entry = htab_find (dwo_file->tus, &find_dwo_entry);
4842 if (dwo_entry == NULL)
4843 return NULL;
4844
4845 /* If the global table doesn't have an entry for this TU, add one. */
4846 if (sig_entry == NULL)
4847 sig_entry = add_type_unit (sig, slot);
4848
4849 fill_in_sig_entry_from_dwo_entry (objfile, sig_entry, dwo_entry);
4850 sig_entry->per_cu.tu_read = 1;
4851 return sig_entry;
4852 }
4853
4854 /* Subroutine of lookup_signatured_type.
4855 Look up the type for signature SIG, and if we can't find SIG in .gdb_index
4856 then try the DWP file. If the TU stub (skeleton) has been removed then
4857 it won't be in .gdb_index. */
4858
4859 static struct signatured_type *
4860 lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
4861 {
4862 struct objfile *objfile = dwarf2_per_objfile->objfile;
4863 struct dwp_file *dwp_file = get_dwp_file ();
4864 struct dwo_unit *dwo_entry;
4865 struct signatured_type find_sig_entry, *sig_entry;
4866 void **slot;
4867
4868 gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index);
4869 gdb_assert (dwp_file != NULL);
4870
4871 /* If TU skeletons have been removed then we may not have read in any
4872 TUs yet. */
4873 if (dwarf2_per_objfile->signatured_types == NULL)
4874 {
4875 dwarf2_per_objfile->signatured_types
4876 = allocate_signatured_type_table (objfile);
4877 }
4878
4879 find_sig_entry.signature = sig;
4880 slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
4881 &find_sig_entry, INSERT);
4882 sig_entry = *slot;
4883
4884 /* Have we already tried to read this TU?
4885 Note: sig_entry can be NULL if the skeleton TU was removed (thus it
4886 needn't exist in the global table yet). */
4887 if (sig_entry != NULL)
4888 return sig_entry;
4889
4890 if (dwp_file->tus == NULL)
4891 return NULL;
4892 dwo_entry = lookup_dwo_unit_in_dwp (dwp_file, NULL,
4893 sig, 1 /* is_debug_types */);
4894 if (dwo_entry == NULL)
4895 return NULL;
4896
4897 sig_entry = add_type_unit (sig, slot);
4898 fill_in_sig_entry_from_dwo_entry (objfile, sig_entry, dwo_entry);
4899
4900 return sig_entry;
4901 }
4902
4903 /* Lookup a signature based type for DW_FORM_ref_sig8.
4904 Returns NULL if signature SIG is not present in the table.
4905 It is up to the caller to complain about this. */
4906
4907 static struct signatured_type *
4908 lookup_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
4909 {
4910 if (cu->dwo_unit
4911 && dwarf2_per_objfile->using_index)
4912 {
4913 /* We're in a DWO/DWP file, and we're using .gdb_index.
4914 These cases require special processing. */
4915 if (get_dwp_file () == NULL)
4916 return lookup_dwo_signatured_type (cu, sig);
4917 else
4918 return lookup_dwp_signatured_type (cu, sig);
4919 }
4920 else
4921 {
4922 struct signatured_type find_entry, *entry;
4923
4924 if (dwarf2_per_objfile->signatured_types == NULL)
4925 return NULL;
4926 find_entry.signature = sig;
4927 entry = htab_find (dwarf2_per_objfile->signatured_types, &find_entry);
4928 return entry;
4929 }
4930 }
4931 \f
4932 /* Low level DIE reading support. */
4933
4934 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
4935
4936 static void
4937 init_cu_die_reader (struct die_reader_specs *reader,
4938 struct dwarf2_cu *cu,
4939 struct dwarf2_section_info *section,
4940 struct dwo_file *dwo_file)
4941 {
4942 gdb_assert (section->readin && section->buffer != NULL);
4943 reader->abfd = get_section_bfd_owner (section);
4944 reader->cu = cu;
4945 reader->dwo_file = dwo_file;
4946 reader->die_section = section;
4947 reader->buffer = section->buffer;
4948 reader->buffer_end = section->buffer + section->size;
4949 reader->comp_dir = NULL;
4950 }
4951
4952 /* Subroutine of init_cutu_and_read_dies to simplify it.
4953 Read in the rest of a CU/TU top level DIE from DWO_UNIT.
4954 There's just a lot of work to do, and init_cutu_and_read_dies is big enough
4955 already.
4956
4957 STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes
4958 from it to the DIE in the DWO. If NULL we are skipping the stub.
4959 STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly
4960 from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir
4961 attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and
4962 STUB_COMP_DIR may be non-NULL.
4963 *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN
4964 are filled in with the info of the DIE from the DWO file.
4965 ABBREV_TABLE_PROVIDED is non-zero if the caller of init_cutu_and_read_dies
4966 provided an abbrev table to use.
4967 The result is non-zero if a valid (non-dummy) DIE was found. */
4968
4969 static int
4970 read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu,
4971 struct dwo_unit *dwo_unit,
4972 int abbrev_table_provided,
4973 struct die_info *stub_comp_unit_die,
4974 const char *stub_comp_dir,
4975 struct die_reader_specs *result_reader,
4976 const gdb_byte **result_info_ptr,
4977 struct die_info **result_comp_unit_die,
4978 int *result_has_children)
4979 {
4980 struct objfile *objfile = dwarf2_per_objfile->objfile;
4981 struct dwarf2_cu *cu = this_cu->cu;
4982 struct dwarf2_section_info *section;
4983 bfd *abfd;
4984 const gdb_byte *begin_info_ptr, *info_ptr;
4985 ULONGEST signature; /* Or dwo_id. */
4986 struct attribute *comp_dir, *stmt_list, *low_pc, *high_pc, *ranges;
4987 int i,num_extra_attrs;
4988 struct dwarf2_section_info *dwo_abbrev_section;
4989 struct attribute *attr;
4990 struct die_info *comp_unit_die;
4991
4992 /* At most one of these may be provided. */
4993 gdb_assert ((stub_comp_unit_die != NULL) + (stub_comp_dir != NULL) <= 1);
4994
4995 /* These attributes aren't processed until later:
4996 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
4997 DW_AT_comp_dir is used now, to find the DWO file, but it is also
4998 referenced later. However, these attributes are found in the stub
4999 which we won't have later. In order to not impose this complication
5000 on the rest of the code, we read them here and copy them to the
5001 DWO CU/TU die. */
5002
5003 stmt_list = NULL;
5004 low_pc = NULL;
5005 high_pc = NULL;
5006 ranges = NULL;
5007 comp_dir = NULL;
5008
5009 if (stub_comp_unit_die != NULL)
5010 {
5011 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
5012 DWO file. */
5013 if (! this_cu->is_debug_types)
5014 stmt_list = dwarf2_attr (stub_comp_unit_die, DW_AT_stmt_list, cu);
5015 low_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_low_pc, cu);
5016 high_pc = dwarf2_attr (stub_comp_unit_die, DW_AT_high_pc, cu);
5017 ranges = dwarf2_attr (stub_comp_unit_die, DW_AT_ranges, cu);
5018 comp_dir = dwarf2_attr (stub_comp_unit_die, DW_AT_comp_dir, cu);
5019
5020 /* There should be a DW_AT_addr_base attribute here (if needed).
5021 We need the value before we can process DW_FORM_GNU_addr_index. */
5022 cu->addr_base = 0;
5023 attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_addr_base, cu);
5024 if (attr)
5025 cu->addr_base = DW_UNSND (attr);
5026
5027 /* There should be a DW_AT_ranges_base attribute here (if needed).
5028 We need the value before we can process DW_AT_ranges. */
5029 cu->ranges_base = 0;
5030 attr = dwarf2_attr (stub_comp_unit_die, DW_AT_GNU_ranges_base, cu);
5031 if (attr)
5032 cu->ranges_base = DW_UNSND (attr);
5033 }
5034 else if (stub_comp_dir != NULL)
5035 {
5036 /* Reconstruct the comp_dir attribute to simplify the code below. */
5037 comp_dir = (struct attribute *)
5038 obstack_alloc (&cu->comp_unit_obstack, sizeof (*comp_dir));
5039 comp_dir->name = DW_AT_comp_dir;
5040 comp_dir->form = DW_FORM_string;
5041 DW_STRING_IS_CANONICAL (comp_dir) = 0;
5042 DW_STRING (comp_dir) = stub_comp_dir;
5043 }
5044
5045 /* Set up for reading the DWO CU/TU. */
5046 cu->dwo_unit = dwo_unit;
5047 section = dwo_unit->section;
5048 dwarf2_read_section (objfile, section);
5049 abfd = get_section_bfd_owner (section);
5050 begin_info_ptr = info_ptr = section->buffer + dwo_unit->offset.sect_off;
5051 dwo_abbrev_section = &dwo_unit->dwo_file->sections.abbrev;
5052 init_cu_die_reader (result_reader, cu, section, dwo_unit->dwo_file);
5053
5054 if (this_cu->is_debug_types)
5055 {
5056 ULONGEST header_signature;
5057 cu_offset type_offset_in_tu;
5058 struct signatured_type *sig_type = (struct signatured_type *) this_cu;
5059
5060 info_ptr = read_and_check_type_unit_head (&cu->header, section,
5061 dwo_abbrev_section,
5062 info_ptr,
5063 &header_signature,
5064 &type_offset_in_tu);
5065 /* This is not an assert because it can be caused by bad debug info. */
5066 if (sig_type->signature != header_signature)
5067 {
5068 error (_("Dwarf Error: signature mismatch %s vs %s while reading"
5069 " TU at offset 0x%x [in module %s]"),
5070 hex_string (sig_type->signature),
5071 hex_string (header_signature),
5072 dwo_unit->offset.sect_off,
5073 bfd_get_filename (abfd));
5074 }
5075 gdb_assert (dwo_unit->offset.sect_off == cu->header.offset.sect_off);
5076 /* For DWOs coming from DWP files, we don't know the CU length
5077 nor the type's offset in the TU until now. */
5078 dwo_unit->length = get_cu_length (&cu->header);
5079 dwo_unit->type_offset_in_tu = type_offset_in_tu;
5080
5081 /* Establish the type offset that can be used to lookup the type.
5082 For DWO files, we don't know it until now. */
5083 sig_type->type_offset_in_section.sect_off =
5084 dwo_unit->offset.sect_off + dwo_unit->type_offset_in_tu.cu_off;
5085 }
5086 else
5087 {
5088 info_ptr = read_and_check_comp_unit_head (&cu->header, section,
5089 dwo_abbrev_section,
5090 info_ptr, 0);
5091 gdb_assert (dwo_unit->offset.sect_off == cu->header.offset.sect_off);
5092 /* For DWOs coming from DWP files, we don't know the CU length
5093 until now. */
5094 dwo_unit->length = get_cu_length (&cu->header);
5095 }
5096
5097 /* Replace the CU's original abbrev table with the DWO's.
5098 Reminder: We can't read the abbrev table until we've read the header. */
5099 if (abbrev_table_provided)
5100 {
5101 /* Don't free the provided abbrev table, the caller of
5102 init_cutu_and_read_dies owns it. */
5103 dwarf2_read_abbrevs (cu, dwo_abbrev_section);
5104 /* Ensure the DWO abbrev table gets freed. */
5105 make_cleanup (dwarf2_free_abbrev_table, cu);
5106 }
5107 else
5108 {
5109 dwarf2_free_abbrev_table (cu);
5110 dwarf2_read_abbrevs (cu, dwo_abbrev_section);
5111 /* Leave any existing abbrev table cleanup as is. */
5112 }
5113
5114 /* Read in the die, but leave space to copy over the attributes
5115 from the stub. This has the benefit of simplifying the rest of
5116 the code - all the work to maintain the illusion of a single
5117 DW_TAG_{compile,type}_unit DIE is done here. */
5118 num_extra_attrs = ((stmt_list != NULL)
5119 + (low_pc != NULL)
5120 + (high_pc != NULL)
5121 + (ranges != NULL)
5122 + (comp_dir != NULL));
5123 info_ptr = read_full_die_1 (result_reader, result_comp_unit_die, info_ptr,
5124 result_has_children, num_extra_attrs);
5125
5126 /* Copy over the attributes from the stub to the DIE we just read in. */
5127 comp_unit_die = *result_comp_unit_die;
5128 i = comp_unit_die->num_attrs;
5129 if (stmt_list != NULL)
5130 comp_unit_die->attrs[i++] = *stmt_list;
5131 if (low_pc != NULL)
5132 comp_unit_die->attrs[i++] = *low_pc;
5133 if (high_pc != NULL)
5134 comp_unit_die->attrs[i++] = *high_pc;
5135 if (ranges != NULL)
5136 comp_unit_die->attrs[i++] = *ranges;
5137 if (comp_dir != NULL)
5138 comp_unit_die->attrs[i++] = *comp_dir;
5139 comp_unit_die->num_attrs += num_extra_attrs;
5140
5141 if (dwarf2_die_debug)
5142 {
5143 fprintf_unfiltered (gdb_stdlog,
5144 "Read die from %s@0x%x of %s:\n",
5145 get_section_name (section),
5146 (unsigned) (begin_info_ptr - section->buffer),
5147 bfd_get_filename (abfd));
5148 dump_die (comp_unit_die, dwarf2_die_debug);
5149 }
5150
5151 /* Save the comp_dir attribute. If there is no DWP file then we'll read
5152 TUs by skipping the stub and going directly to the entry in the DWO file.
5153 However, skipping the stub means we won't get DW_AT_comp_dir, so we have
5154 to get it via circuitous means. Blech. */
5155 if (comp_dir != NULL)
5156 result_reader->comp_dir = DW_STRING (comp_dir);
5157
5158 /* Skip dummy compilation units. */
5159 if (info_ptr >= begin_info_ptr + dwo_unit->length
5160 || peek_abbrev_code (abfd, info_ptr) == 0)
5161 return 0;
5162
5163 *result_info_ptr = info_ptr;
5164 return 1;
5165 }
5166
5167 /* Subroutine of init_cutu_and_read_dies to simplify it.
5168 Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU.
5169 Returns NULL if the specified DWO unit cannot be found. */
5170
5171 static struct dwo_unit *
5172 lookup_dwo_unit (struct dwarf2_per_cu_data *this_cu,
5173 struct die_info *comp_unit_die)
5174 {
5175 struct dwarf2_cu *cu = this_cu->cu;
5176 struct attribute *attr;
5177 ULONGEST signature;
5178 struct dwo_unit *dwo_unit;
5179 const char *comp_dir, *dwo_name;
5180
5181 gdb_assert (cu != NULL);
5182
5183 /* Yeah, we look dwo_name up again, but it simplifies the code. */
5184 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
5185 gdb_assert (attr != NULL);
5186 dwo_name = DW_STRING (attr);
5187 comp_dir = NULL;
5188 attr = dwarf2_attr (comp_unit_die, DW_AT_comp_dir, cu);
5189 if (attr)
5190 comp_dir = DW_STRING (attr);
5191
5192 if (this_cu->is_debug_types)
5193 {
5194 struct signatured_type *sig_type;
5195
5196 /* Since this_cu is the first member of struct signatured_type,
5197 we can go from a pointer to one to a pointer to the other. */
5198 sig_type = (struct signatured_type *) this_cu;
5199 signature = sig_type->signature;
5200 dwo_unit = lookup_dwo_type_unit (sig_type, dwo_name, comp_dir);
5201 }
5202 else
5203 {
5204 struct attribute *attr;
5205
5206 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
5207 if (! attr)
5208 error (_("Dwarf Error: missing dwo_id for dwo_name %s"
5209 " [in module %s]"),
5210 dwo_name, objfile_name (this_cu->objfile));
5211 signature = DW_UNSND (attr);
5212 dwo_unit = lookup_dwo_comp_unit (this_cu, dwo_name, comp_dir,
5213 signature);
5214 }
5215
5216 return dwo_unit;
5217 }
5218
5219 /* Subroutine of init_cutu_and_read_dies to simplify it.
5220 See it for a description of the parameters.
5221 Read a TU directly from a DWO file, bypassing the stub.
5222
5223 Note: This function could be a little bit simpler if we shared cleanups
5224 with our caller, init_cutu_and_read_dies. That's generally a fragile thing
5225 to do, so we keep this function self-contained. Or we could move this
5226 into our caller, but it's complex enough already. */
5227
5228 static void
5229 init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data *this_cu,
5230 int use_existing_cu, int keep,
5231 die_reader_func_ftype *die_reader_func,
5232 void *data)
5233 {
5234 struct dwarf2_cu *cu;
5235 struct signatured_type *sig_type;
5236 struct cleanup *cleanups, *free_cu_cleanup = NULL;
5237 struct die_reader_specs reader;
5238 const gdb_byte *info_ptr;
5239 struct die_info *comp_unit_die;
5240 int has_children;
5241
5242 /* Verify we can do the following downcast, and that we have the
5243 data we need. */
5244 gdb_assert (this_cu->is_debug_types && this_cu->reading_dwo_directly);
5245 sig_type = (struct signatured_type *) this_cu;
5246 gdb_assert (sig_type->dwo_unit != NULL);
5247
5248 cleanups = make_cleanup (null_cleanup, NULL);
5249
5250 if (use_existing_cu && this_cu->cu != NULL)
5251 {
5252 gdb_assert (this_cu->cu->dwo_unit == sig_type->dwo_unit);
5253 cu = this_cu->cu;
5254 /* There's no need to do the rereading_dwo_cu handling that
5255 init_cutu_and_read_dies does since we don't read the stub. */
5256 }
5257 else
5258 {
5259 /* If !use_existing_cu, this_cu->cu must be NULL. */
5260 gdb_assert (this_cu->cu == NULL);
5261 cu = xmalloc (sizeof (*cu));
5262 init_one_comp_unit (cu, this_cu);
5263 /* If an error occurs while loading, release our storage. */
5264 free_cu_cleanup = make_cleanup (free_heap_comp_unit, cu);
5265 }
5266
5267 /* A future optimization, if needed, would be to use an existing
5268 abbrev table. When reading DWOs with skeletonless TUs, all the TUs
5269 could share abbrev tables. */
5270
5271 if (read_cutu_die_from_dwo (this_cu, sig_type->dwo_unit,
5272 0 /* abbrev_table_provided */,
5273 NULL /* stub_comp_unit_die */,
5274 sig_type->dwo_unit->dwo_file->comp_dir,
5275 &reader, &info_ptr,
5276 &comp_unit_die, &has_children) == 0)
5277 {
5278 /* Dummy die. */
5279 do_cleanups (cleanups);
5280 return;
5281 }
5282
5283 /* All the "real" work is done here. */
5284 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
5285
5286 /* This duplicates the code in init_cutu_and_read_dies,
5287 but the alternative is making the latter more complex.
5288 This function is only for the special case of using DWO files directly:
5289 no point in overly complicating the general case just to handle this. */
5290 if (free_cu_cleanup != NULL)
5291 {
5292 if (keep)
5293 {
5294 /* We've successfully allocated this compilation unit. Let our
5295 caller clean it up when finished with it. */
5296 discard_cleanups (free_cu_cleanup);
5297
5298 /* We can only discard free_cu_cleanup and all subsequent cleanups.
5299 So we have to manually free the abbrev table. */
5300 dwarf2_free_abbrev_table (cu);
5301
5302 /* Link this CU into read_in_chain. */
5303 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
5304 dwarf2_per_objfile->read_in_chain = this_cu;
5305 }
5306 else
5307 do_cleanups (free_cu_cleanup);
5308 }
5309
5310 do_cleanups (cleanups);
5311 }
5312
5313 /* Initialize a CU (or TU) and read its DIEs.
5314 If the CU defers to a DWO file, read the DWO file as well.
5315
5316 ABBREV_TABLE, if non-NULL, is the abbreviation table to use.
5317 Otherwise the table specified in the comp unit header is read in and used.
5318 This is an optimization for when we already have the abbrev table.
5319
5320 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
5321 Otherwise, a new CU is allocated with xmalloc.
5322
5323 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
5324 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
5325
5326 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
5327 linker) then DIE_READER_FUNC will not get called. */
5328
5329 static void
5330 init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu,
5331 struct abbrev_table *abbrev_table,
5332 int use_existing_cu, int keep,
5333 die_reader_func_ftype *die_reader_func,
5334 void *data)
5335 {
5336 struct objfile *objfile = dwarf2_per_objfile->objfile;
5337 struct dwarf2_section_info *section = this_cu->section;
5338 bfd *abfd = get_section_bfd_owner (section);
5339 struct dwarf2_cu *cu;
5340 const gdb_byte *begin_info_ptr, *info_ptr;
5341 struct die_reader_specs reader;
5342 struct die_info *comp_unit_die;
5343 int has_children;
5344 struct attribute *attr;
5345 struct cleanup *cleanups, *free_cu_cleanup = NULL;
5346 struct signatured_type *sig_type = NULL;
5347 struct dwarf2_section_info *abbrev_section;
5348 /* Non-zero if CU currently points to a DWO file and we need to
5349 reread it. When this happens we need to reread the skeleton die
5350 before we can reread the DWO file (this only applies to CUs, not TUs). */
5351 int rereading_dwo_cu = 0;
5352
5353 if (dwarf2_die_debug)
5354 fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset 0x%x\n",
5355 this_cu->is_debug_types ? "type" : "comp",
5356 this_cu->offset.sect_off);
5357
5358 if (use_existing_cu)
5359 gdb_assert (keep);
5360
5361 /* If we're reading a TU directly from a DWO file, including a virtual DWO
5362 file (instead of going through the stub), short-circuit all of this. */
5363 if (this_cu->reading_dwo_directly)
5364 {
5365 /* Narrow down the scope of possibilities to have to understand. */
5366 gdb_assert (this_cu->is_debug_types);
5367 gdb_assert (abbrev_table == NULL);
5368 init_tu_and_read_dwo_dies (this_cu, use_existing_cu, keep,
5369 die_reader_func, data);
5370 return;
5371 }
5372
5373 cleanups = make_cleanup (null_cleanup, NULL);
5374
5375 /* This is cheap if the section is already read in. */
5376 dwarf2_read_section (objfile, section);
5377
5378 begin_info_ptr = info_ptr = section->buffer + this_cu->offset.sect_off;
5379
5380 abbrev_section = get_abbrev_section_for_cu (this_cu);
5381
5382 if (use_existing_cu && this_cu->cu != NULL)
5383 {
5384 cu = this_cu->cu;
5385 /* If this CU is from a DWO file we need to start over, we need to
5386 refetch the attributes from the skeleton CU.
5387 This could be optimized by retrieving those attributes from when we
5388 were here the first time: the previous comp_unit_die was stored in
5389 comp_unit_obstack. But there's no data yet that we need this
5390 optimization. */
5391 if (cu->dwo_unit != NULL)
5392 rereading_dwo_cu = 1;
5393 }
5394 else
5395 {
5396 /* If !use_existing_cu, this_cu->cu must be NULL. */
5397 gdb_assert (this_cu->cu == NULL);
5398 cu = xmalloc (sizeof (*cu));
5399 init_one_comp_unit (cu, this_cu);
5400 /* If an error occurs while loading, release our storage. */
5401 free_cu_cleanup = make_cleanup (free_heap_comp_unit, cu);
5402 }
5403
5404 /* Get the header. */
5405 if (cu->header.first_die_offset.cu_off != 0 && ! rereading_dwo_cu)
5406 {
5407 /* We already have the header, there's no need to read it in again. */
5408 info_ptr += cu->header.first_die_offset.cu_off;
5409 }
5410 else
5411 {
5412 if (this_cu->is_debug_types)
5413 {
5414 ULONGEST signature;
5415 cu_offset type_offset_in_tu;
5416
5417 info_ptr = read_and_check_type_unit_head (&cu->header, section,
5418 abbrev_section, info_ptr,
5419 &signature,
5420 &type_offset_in_tu);
5421
5422 /* Since per_cu is the first member of struct signatured_type,
5423 we can go from a pointer to one to a pointer to the other. */
5424 sig_type = (struct signatured_type *) this_cu;
5425 gdb_assert (sig_type->signature == signature);
5426 gdb_assert (sig_type->type_offset_in_tu.cu_off
5427 == type_offset_in_tu.cu_off);
5428 gdb_assert (this_cu->offset.sect_off == cu->header.offset.sect_off);
5429
5430 /* LENGTH has not been set yet for type units if we're
5431 using .gdb_index. */
5432 this_cu->length = get_cu_length (&cu->header);
5433
5434 /* Establish the type offset that can be used to lookup the type. */
5435 sig_type->type_offset_in_section.sect_off =
5436 this_cu->offset.sect_off + sig_type->type_offset_in_tu.cu_off;
5437 }
5438 else
5439 {
5440 info_ptr = read_and_check_comp_unit_head (&cu->header, section,
5441 abbrev_section,
5442 info_ptr, 0);
5443
5444 gdb_assert (this_cu->offset.sect_off == cu->header.offset.sect_off);
5445 gdb_assert (this_cu->length == get_cu_length (&cu->header));
5446 }
5447 }
5448
5449 /* Skip dummy compilation units. */
5450 if (info_ptr >= begin_info_ptr + this_cu->length
5451 || peek_abbrev_code (abfd, info_ptr) == 0)
5452 {
5453 do_cleanups (cleanups);
5454 return;
5455 }
5456
5457 /* If we don't have them yet, read the abbrevs for this compilation unit.
5458 And if we need to read them now, make sure they're freed when we're
5459 done. Note that it's important that if the CU had an abbrev table
5460 on entry we don't free it when we're done: Somewhere up the call stack
5461 it may be in use. */
5462 if (abbrev_table != NULL)
5463 {
5464 gdb_assert (cu->abbrev_table == NULL);
5465 gdb_assert (cu->header.abbrev_offset.sect_off
5466 == abbrev_table->offset.sect_off);
5467 cu->abbrev_table = abbrev_table;
5468 }
5469 else if (cu->abbrev_table == NULL)
5470 {
5471 dwarf2_read_abbrevs (cu, abbrev_section);
5472 make_cleanup (dwarf2_free_abbrev_table, cu);
5473 }
5474 else if (rereading_dwo_cu)
5475 {
5476 dwarf2_free_abbrev_table (cu);
5477 dwarf2_read_abbrevs (cu, abbrev_section);
5478 }
5479
5480 /* Read the top level CU/TU die. */
5481 init_cu_die_reader (&reader, cu, section, NULL);
5482 info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
5483
5484 /* If we are in a DWO stub, process it and then read in the "real" CU/TU
5485 from the DWO file.
5486 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains a
5487 DWO CU, that this test will fail (the attribute will not be present). */
5488 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
5489 if (attr)
5490 {
5491 struct dwo_unit *dwo_unit;
5492 struct die_info *dwo_comp_unit_die;
5493
5494 if (has_children)
5495 {
5496 complaint (&symfile_complaints,
5497 _("compilation unit with DW_AT_GNU_dwo_name"
5498 " has children (offset 0x%x) [in module %s]"),
5499 this_cu->offset.sect_off, bfd_get_filename (abfd));
5500 }
5501 dwo_unit = lookup_dwo_unit (this_cu, comp_unit_die);
5502 if (dwo_unit != NULL)
5503 {
5504 if (read_cutu_die_from_dwo (this_cu, dwo_unit,
5505 abbrev_table != NULL,
5506 comp_unit_die, NULL,
5507 &reader, &info_ptr,
5508 &dwo_comp_unit_die, &has_children) == 0)
5509 {
5510 /* Dummy die. */
5511 do_cleanups (cleanups);
5512 return;
5513 }
5514 comp_unit_die = dwo_comp_unit_die;
5515 }
5516 else
5517 {
5518 /* Yikes, we couldn't find the rest of the DIE, we only have
5519 the stub. A complaint has already been logged. There's
5520 not much more we can do except pass on the stub DIE to
5521 die_reader_func. We don't want to throw an error on bad
5522 debug info. */
5523 }
5524 }
5525
5526 /* All of the above is setup for this call. Yikes. */
5527 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
5528
5529 /* Done, clean up. */
5530 if (free_cu_cleanup != NULL)
5531 {
5532 if (keep)
5533 {
5534 /* We've successfully allocated this compilation unit. Let our
5535 caller clean it up when finished with it. */
5536 discard_cleanups (free_cu_cleanup);
5537
5538 /* We can only discard free_cu_cleanup and all subsequent cleanups.
5539 So we have to manually free the abbrev table. */
5540 dwarf2_free_abbrev_table (cu);
5541
5542 /* Link this CU into read_in_chain. */
5543 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
5544 dwarf2_per_objfile->read_in_chain = this_cu;
5545 }
5546 else
5547 do_cleanups (free_cu_cleanup);
5548 }
5549
5550 do_cleanups (cleanups);
5551 }
5552
5553 /* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present.
5554 DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed
5555 to have already done the lookup to find the DWO file).
5556
5557 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
5558 THIS_CU->is_debug_types, but nothing else.
5559
5560 We fill in THIS_CU->length.
5561
5562 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
5563 linker) then DIE_READER_FUNC will not get called.
5564
5565 THIS_CU->cu is always freed when done.
5566 This is done in order to not leave THIS_CU->cu in a state where we have
5567 to care whether it refers to the "main" CU or the DWO CU. */
5568
5569 static void
5570 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data *this_cu,
5571 struct dwo_file *dwo_file,
5572 die_reader_func_ftype *die_reader_func,
5573 void *data)
5574 {
5575 struct objfile *objfile = dwarf2_per_objfile->objfile;
5576 struct dwarf2_section_info *section = this_cu->section;
5577 bfd *abfd = get_section_bfd_owner (section);
5578 struct dwarf2_section_info *abbrev_section;
5579 struct dwarf2_cu cu;
5580 const gdb_byte *begin_info_ptr, *info_ptr;
5581 struct die_reader_specs reader;
5582 struct cleanup *cleanups;
5583 struct die_info *comp_unit_die;
5584 int has_children;
5585
5586 if (dwarf2_die_debug)
5587 fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset 0x%x\n",
5588 this_cu->is_debug_types ? "type" : "comp",
5589 this_cu->offset.sect_off);
5590
5591 gdb_assert (this_cu->cu == NULL);
5592
5593 abbrev_section = (dwo_file != NULL
5594 ? &dwo_file->sections.abbrev
5595 : get_abbrev_section_for_cu (this_cu));
5596
5597 /* This is cheap if the section is already read in. */
5598 dwarf2_read_section (objfile, section);
5599
5600 init_one_comp_unit (&cu, this_cu);
5601
5602 cleanups = make_cleanup (free_stack_comp_unit, &cu);
5603
5604 begin_info_ptr = info_ptr = section->buffer + this_cu->offset.sect_off;
5605 info_ptr = read_and_check_comp_unit_head (&cu.header, section,
5606 abbrev_section, info_ptr,
5607 this_cu->is_debug_types);
5608
5609 this_cu->length = get_cu_length (&cu.header);
5610
5611 /* Skip dummy compilation units. */
5612 if (info_ptr >= begin_info_ptr + this_cu->length
5613 || peek_abbrev_code (abfd, info_ptr) == 0)
5614 {
5615 do_cleanups (cleanups);
5616 return;
5617 }
5618
5619 dwarf2_read_abbrevs (&cu, abbrev_section);
5620 make_cleanup (dwarf2_free_abbrev_table, &cu);
5621
5622 init_cu_die_reader (&reader, &cu, section, dwo_file);
5623 info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
5624
5625 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
5626
5627 do_cleanups (cleanups);
5628 }
5629
5630 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
5631 does not lookup the specified DWO file.
5632 This cannot be used to read DWO files.
5633
5634 THIS_CU->cu is always freed when done.
5635 This is done in order to not leave THIS_CU->cu in a state where we have
5636 to care whether it refers to the "main" CU or the DWO CU.
5637 We can revisit this if the data shows there's a performance issue. */
5638
5639 static void
5640 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data *this_cu,
5641 die_reader_func_ftype *die_reader_func,
5642 void *data)
5643 {
5644 init_cutu_and_read_dies_no_follow (this_cu, NULL, die_reader_func, data);
5645 }
5646 \f
5647 /* Type Unit Groups.
5648
5649 Type Unit Groups are a way to collapse the set of all TUs (type units) into
5650 a more manageable set. The grouping is done by DW_AT_stmt_list entry
5651 so that all types coming from the same compilation (.o file) are grouped
5652 together. A future step could be to put the types in the same symtab as
5653 the CU the types ultimately came from. */
5654
5655 static hashval_t
5656 hash_type_unit_group (const void *item)
5657 {
5658 const struct type_unit_group *tu_group = item;
5659
5660 return hash_stmt_list_entry (&tu_group->hash);
5661 }
5662
5663 static int
5664 eq_type_unit_group (const void *item_lhs, const void *item_rhs)
5665 {
5666 const struct type_unit_group *lhs = item_lhs;
5667 const struct type_unit_group *rhs = item_rhs;
5668
5669 return eq_stmt_list_entry (&lhs->hash, &rhs->hash);
5670 }
5671
5672 /* Allocate a hash table for type unit groups. */
5673
5674 static htab_t
5675 allocate_type_unit_groups_table (void)
5676 {
5677 return htab_create_alloc_ex (3,
5678 hash_type_unit_group,
5679 eq_type_unit_group,
5680 NULL,
5681 &dwarf2_per_objfile->objfile->objfile_obstack,
5682 hashtab_obstack_allocate,
5683 dummy_obstack_deallocate);
5684 }
5685
5686 /* Type units that don't have DW_AT_stmt_list are grouped into their own
5687 partial symtabs. We combine several TUs per psymtab to not let the size
5688 of any one psymtab grow too big. */
5689 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB (1 << 31)
5690 #define NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE 10
5691
5692 /* Helper routine for get_type_unit_group.
5693 Create the type_unit_group object used to hold one or more TUs. */
5694
5695 static struct type_unit_group *
5696 create_type_unit_group (struct dwarf2_cu *cu, sect_offset line_offset_struct)
5697 {
5698 struct objfile *objfile = dwarf2_per_objfile->objfile;
5699 struct dwarf2_per_cu_data *per_cu;
5700 struct type_unit_group *tu_group;
5701
5702 tu_group = OBSTACK_ZALLOC (&objfile->objfile_obstack,
5703 struct type_unit_group);
5704 per_cu = &tu_group->per_cu;
5705 per_cu->objfile = objfile;
5706
5707 if (dwarf2_per_objfile->using_index)
5708 {
5709 per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
5710 struct dwarf2_per_cu_quick_data);
5711 }
5712 else
5713 {
5714 unsigned int line_offset = line_offset_struct.sect_off;
5715 struct partial_symtab *pst;
5716 char *name;
5717
5718 /* Give the symtab a useful name for debug purposes. */
5719 if ((line_offset & NO_STMT_LIST_TYPE_UNIT_PSYMTAB) != 0)
5720 name = xstrprintf ("<type_units_%d>",
5721 (line_offset & ~NO_STMT_LIST_TYPE_UNIT_PSYMTAB));
5722 else
5723 name = xstrprintf ("<type_units_at_0x%x>", line_offset);
5724
5725 pst = create_partial_symtab (per_cu, name);
5726 pst->anonymous = 1;
5727
5728 xfree (name);
5729 }
5730
5731 tu_group->hash.dwo_unit = cu->dwo_unit;
5732 tu_group->hash.line_offset = line_offset_struct;
5733
5734 return tu_group;
5735 }
5736
5737 /* Look up the type_unit_group for type unit CU, and create it if necessary.
5738 STMT_LIST is a DW_AT_stmt_list attribute. */
5739
5740 static struct type_unit_group *
5741 get_type_unit_group (struct dwarf2_cu *cu, const struct attribute *stmt_list)
5742 {
5743 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
5744 struct type_unit_group *tu_group;
5745 void **slot;
5746 unsigned int line_offset;
5747 struct type_unit_group type_unit_group_for_lookup;
5748
5749 if (dwarf2_per_objfile->type_unit_groups == NULL)
5750 {
5751 dwarf2_per_objfile->type_unit_groups =
5752 allocate_type_unit_groups_table ();
5753 }
5754
5755 /* Do we need to create a new group, or can we use an existing one? */
5756
5757 if (stmt_list)
5758 {
5759 line_offset = DW_UNSND (stmt_list);
5760 ++tu_stats->nr_symtab_sharers;
5761 }
5762 else
5763 {
5764 /* Ugh, no stmt_list. Rare, but we have to handle it.
5765 We can do various things here like create one group per TU or
5766 spread them over multiple groups to split up the expansion work.
5767 To avoid worst case scenarios (too many groups or too large groups)
5768 we, umm, group them in bunches. */
5769 line_offset = (NO_STMT_LIST_TYPE_UNIT_PSYMTAB
5770 | (tu_stats->nr_stmt_less_type_units
5771 / NO_STMT_LIST_TYPE_UNIT_PSYMTAB_SIZE));
5772 ++tu_stats->nr_stmt_less_type_units;
5773 }
5774
5775 type_unit_group_for_lookup.hash.dwo_unit = cu->dwo_unit;
5776 type_unit_group_for_lookup.hash.line_offset.sect_off = line_offset;
5777 slot = htab_find_slot (dwarf2_per_objfile->type_unit_groups,
5778 &type_unit_group_for_lookup, INSERT);
5779 if (*slot != NULL)
5780 {
5781 tu_group = *slot;
5782 gdb_assert (tu_group != NULL);
5783 }
5784 else
5785 {
5786 sect_offset line_offset_struct;
5787
5788 line_offset_struct.sect_off = line_offset;
5789 tu_group = create_type_unit_group (cu, line_offset_struct);
5790 *slot = tu_group;
5791 ++tu_stats->nr_symtabs;
5792 }
5793
5794 return tu_group;
5795 }
5796 \f
5797 /* Partial symbol tables. */
5798
5799 /* Create a psymtab named NAME and assign it to PER_CU.
5800
5801 The caller must fill in the following details:
5802 dirname, textlow, texthigh. */
5803
5804 static struct partial_symtab *
5805 create_partial_symtab (struct dwarf2_per_cu_data *per_cu, const char *name)
5806 {
5807 struct objfile *objfile = per_cu->objfile;
5808 struct partial_symtab *pst;
5809
5810 pst = start_psymtab_common (objfile, objfile->section_offsets,
5811 name, 0,
5812 objfile->global_psymbols.next,
5813 objfile->static_psymbols.next);
5814
5815 pst->psymtabs_addrmap_supported = 1;
5816
5817 /* This is the glue that links PST into GDB's symbol API. */
5818 pst->read_symtab_private = per_cu;
5819 pst->read_symtab = dwarf2_read_symtab;
5820 per_cu->v.psymtab = pst;
5821
5822 return pst;
5823 }
5824
5825 /* The DATA object passed to process_psymtab_comp_unit_reader has this
5826 type. */
5827
5828 struct process_psymtab_comp_unit_data
5829 {
5830 /* True if we are reading a DW_TAG_partial_unit. */
5831
5832 int want_partial_unit;
5833
5834 /* The "pretend" language that is used if the CU doesn't declare a
5835 language. */
5836
5837 enum language pretend_language;
5838 };
5839
5840 /* die_reader_func for process_psymtab_comp_unit. */
5841
5842 static void
5843 process_psymtab_comp_unit_reader (const struct die_reader_specs *reader,
5844 const gdb_byte *info_ptr,
5845 struct die_info *comp_unit_die,
5846 int has_children,
5847 void *data)
5848 {
5849 struct dwarf2_cu *cu = reader->cu;
5850 struct objfile *objfile = cu->objfile;
5851 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
5852 struct attribute *attr;
5853 CORE_ADDR baseaddr;
5854 CORE_ADDR best_lowpc = 0, best_highpc = 0;
5855 struct partial_symtab *pst;
5856 int has_pc_info;
5857 const char *filename;
5858 struct process_psymtab_comp_unit_data *info = data;
5859
5860 if (comp_unit_die->tag == DW_TAG_partial_unit && !info->want_partial_unit)
5861 return;
5862
5863 gdb_assert (! per_cu->is_debug_types);
5864
5865 prepare_one_comp_unit (cu, comp_unit_die, info->pretend_language);
5866
5867 cu->list_in_scope = &file_symbols;
5868
5869 /* Allocate a new partial symbol table structure. */
5870 attr = dwarf2_attr (comp_unit_die, DW_AT_name, cu);
5871 if (attr == NULL || !DW_STRING (attr))
5872 filename = "";
5873 else
5874 filename = DW_STRING (attr);
5875
5876 pst = create_partial_symtab (per_cu, filename);
5877
5878 /* This must be done before calling dwarf2_build_include_psymtabs. */
5879 attr = dwarf2_attr (comp_unit_die, DW_AT_comp_dir, cu);
5880 if (attr != NULL)
5881 pst->dirname = DW_STRING (attr);
5882
5883 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
5884
5885 dwarf2_find_base_address (comp_unit_die, cu);
5886
5887 /* Possibly set the default values of LOWPC and HIGHPC from
5888 `DW_AT_ranges'. */
5889 has_pc_info = dwarf2_get_pc_bounds (comp_unit_die, &best_lowpc,
5890 &best_highpc, cu, pst);
5891 if (has_pc_info == 1 && best_lowpc < best_highpc)
5892 /* Store the contiguous range if it is not empty; it can be empty for
5893 CUs with no code. */
5894 addrmap_set_empty (objfile->psymtabs_addrmap,
5895 best_lowpc + baseaddr,
5896 best_highpc + baseaddr - 1, pst);
5897
5898 /* Check if comp unit has_children.
5899 If so, read the rest of the partial symbols from this comp unit.
5900 If not, there's no more debug_info for this comp unit. */
5901 if (has_children)
5902 {
5903 struct partial_die_info *first_die;
5904 CORE_ADDR lowpc, highpc;
5905
5906 lowpc = ((CORE_ADDR) -1);
5907 highpc = ((CORE_ADDR) 0);
5908
5909 first_die = load_partial_dies (reader, info_ptr, 1);
5910
5911 scan_partial_symbols (first_die, &lowpc, &highpc,
5912 ! has_pc_info, cu);
5913
5914 /* If we didn't find a lowpc, set it to highpc to avoid
5915 complaints from `maint check'. */
5916 if (lowpc == ((CORE_ADDR) -1))
5917 lowpc = highpc;
5918
5919 /* If the compilation unit didn't have an explicit address range,
5920 then use the information extracted from its child dies. */
5921 if (! has_pc_info)
5922 {
5923 best_lowpc = lowpc;
5924 best_highpc = highpc;
5925 }
5926 }
5927 pst->textlow = best_lowpc + baseaddr;
5928 pst->texthigh = best_highpc + baseaddr;
5929
5930 pst->n_global_syms = objfile->global_psymbols.next -
5931 (objfile->global_psymbols.list + pst->globals_offset);
5932 pst->n_static_syms = objfile->static_psymbols.next -
5933 (objfile->static_psymbols.list + pst->statics_offset);
5934 sort_pst_symbols (objfile, pst);
5935
5936 if (!VEC_empty (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs))
5937 {
5938 int i;
5939 int len = VEC_length (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
5940 struct dwarf2_per_cu_data *iter;
5941
5942 /* Fill in 'dependencies' here; we fill in 'users' in a
5943 post-pass. */
5944 pst->number_of_dependencies = len;
5945 pst->dependencies = obstack_alloc (&objfile->objfile_obstack,
5946 len * sizeof (struct symtab *));
5947 for (i = 0;
5948 VEC_iterate (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
5949 i, iter);
5950 ++i)
5951 pst->dependencies[i] = iter->v.psymtab;
5952
5953 VEC_free (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
5954 }
5955
5956 /* Get the list of files included in the current compilation unit,
5957 and build a psymtab for each of them. */
5958 dwarf2_build_include_psymtabs (cu, comp_unit_die, pst);
5959
5960 if (dwarf2_read_debug)
5961 {
5962 struct gdbarch *gdbarch = get_objfile_arch (objfile);
5963
5964 fprintf_unfiltered (gdb_stdlog,
5965 "Psymtab for %s unit @0x%x: %s - %s"
5966 ", %d global, %d static syms\n",
5967 per_cu->is_debug_types ? "type" : "comp",
5968 per_cu->offset.sect_off,
5969 paddress (gdbarch, pst->textlow),
5970 paddress (gdbarch, pst->texthigh),
5971 pst->n_global_syms, pst->n_static_syms);
5972 }
5973 }
5974
5975 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
5976 Process compilation unit THIS_CU for a psymtab. */
5977
5978 static void
5979 process_psymtab_comp_unit (struct dwarf2_per_cu_data *this_cu,
5980 int want_partial_unit,
5981 enum language pretend_language)
5982 {
5983 struct process_psymtab_comp_unit_data info;
5984
5985 /* If this compilation unit was already read in, free the
5986 cached copy in order to read it in again. This is
5987 necessary because we skipped some symbols when we first
5988 read in the compilation unit (see load_partial_dies).
5989 This problem could be avoided, but the benefit is unclear. */
5990 if (this_cu->cu != NULL)
5991 free_one_cached_comp_unit (this_cu);
5992
5993 gdb_assert (! this_cu->is_debug_types);
5994 info.want_partial_unit = want_partial_unit;
5995 info.pretend_language = pretend_language;
5996 init_cutu_and_read_dies (this_cu, NULL, 0, 0,
5997 process_psymtab_comp_unit_reader,
5998 &info);
5999
6000 /* Age out any secondary CUs. */
6001 age_cached_comp_units ();
6002 }
6003
6004 /* Reader function for build_type_psymtabs. */
6005
6006 static void
6007 build_type_psymtabs_reader (const struct die_reader_specs *reader,
6008 const gdb_byte *info_ptr,
6009 struct die_info *type_unit_die,
6010 int has_children,
6011 void *data)
6012 {
6013 struct objfile *objfile = dwarf2_per_objfile->objfile;
6014 struct dwarf2_cu *cu = reader->cu;
6015 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
6016 struct signatured_type *sig_type;
6017 struct type_unit_group *tu_group;
6018 struct attribute *attr;
6019 struct partial_die_info *first_die;
6020 CORE_ADDR lowpc, highpc;
6021 struct partial_symtab *pst;
6022
6023 gdb_assert (data == NULL);
6024 gdb_assert (per_cu->is_debug_types);
6025 sig_type = (struct signatured_type *) per_cu;
6026
6027 if (! has_children)
6028 return;
6029
6030 attr = dwarf2_attr_no_follow (type_unit_die, DW_AT_stmt_list);
6031 tu_group = get_type_unit_group (cu, attr);
6032
6033 VEC_safe_push (sig_type_ptr, tu_group->tus, sig_type);
6034
6035 prepare_one_comp_unit (cu, type_unit_die, language_minimal);
6036 cu->list_in_scope = &file_symbols;
6037 pst = create_partial_symtab (per_cu, "");
6038 pst->anonymous = 1;
6039
6040 first_die = load_partial_dies (reader, info_ptr, 1);
6041
6042 lowpc = (CORE_ADDR) -1;
6043 highpc = (CORE_ADDR) 0;
6044 scan_partial_symbols (first_die, &lowpc, &highpc, 0, cu);
6045
6046 pst->n_global_syms = objfile->global_psymbols.next -
6047 (objfile->global_psymbols.list + pst->globals_offset);
6048 pst->n_static_syms = objfile->static_psymbols.next -
6049 (objfile->static_psymbols.list + pst->statics_offset);
6050 sort_pst_symbols (objfile, pst);
6051 }
6052
6053 /* Struct used to sort TUs by their abbreviation table offset. */
6054
6055 struct tu_abbrev_offset
6056 {
6057 struct signatured_type *sig_type;
6058 sect_offset abbrev_offset;
6059 };
6060
6061 /* Helper routine for build_type_psymtabs_1, passed to qsort. */
6062
6063 static int
6064 sort_tu_by_abbrev_offset (const void *ap, const void *bp)
6065 {
6066 const struct tu_abbrev_offset * const *a = ap;
6067 const struct tu_abbrev_offset * const *b = bp;
6068 unsigned int aoff = (*a)->abbrev_offset.sect_off;
6069 unsigned int boff = (*b)->abbrev_offset.sect_off;
6070
6071 return (aoff > boff) - (aoff < boff);
6072 }
6073
6074 /* Efficiently read all the type units.
6075 This does the bulk of the work for build_type_psymtabs.
6076
6077 The efficiency is because we sort TUs by the abbrev table they use and
6078 only read each abbrev table once. In one program there are 200K TUs
6079 sharing 8K abbrev tables.
6080
6081 The main purpose of this function is to support building the
6082 dwarf2_per_objfile->type_unit_groups table.
6083 TUs typically share the DW_AT_stmt_list of the CU they came from, so we
6084 can collapse the search space by grouping them by stmt_list.
6085 The savings can be significant, in the same program from above the 200K TUs
6086 share 8K stmt_list tables.
6087
6088 FUNC is expected to call get_type_unit_group, which will create the
6089 struct type_unit_group if necessary and add it to
6090 dwarf2_per_objfile->type_unit_groups. */
6091
6092 static void
6093 build_type_psymtabs_1 (void)
6094 {
6095 struct objfile *objfile = dwarf2_per_objfile->objfile;
6096 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
6097 struct cleanup *cleanups;
6098 struct abbrev_table *abbrev_table;
6099 sect_offset abbrev_offset;
6100 struct tu_abbrev_offset *sorted_by_abbrev;
6101 struct type_unit_group **iter;
6102 int i;
6103
6104 /* It's up to the caller to not call us multiple times. */
6105 gdb_assert (dwarf2_per_objfile->type_unit_groups == NULL);
6106
6107 if (dwarf2_per_objfile->n_type_units == 0)
6108 return;
6109
6110 /* TUs typically share abbrev tables, and there can be way more TUs than
6111 abbrev tables. Sort by abbrev table to reduce the number of times we
6112 read each abbrev table in.
6113 Alternatives are to punt or to maintain a cache of abbrev tables.
6114 This is simpler and efficient enough for now.
6115
6116 Later we group TUs by their DW_AT_stmt_list value (as this defines the
6117 symtab to use). Typically TUs with the same abbrev offset have the same
6118 stmt_list value too so in practice this should work well.
6119
6120 The basic algorithm here is:
6121
6122 sort TUs by abbrev table
6123 for each TU with same abbrev table:
6124 read abbrev table if first user
6125 read TU top level DIE
6126 [IWBN if DWO skeletons had DW_AT_stmt_list]
6127 call FUNC */
6128
6129 if (dwarf2_read_debug)
6130 fprintf_unfiltered (gdb_stdlog, "Building type unit groups ...\n");
6131
6132 /* Sort in a separate table to maintain the order of all_type_units
6133 for .gdb_index: TU indices directly index all_type_units. */
6134 sorted_by_abbrev = XNEWVEC (struct tu_abbrev_offset,
6135 dwarf2_per_objfile->n_type_units);
6136 for (i = 0; i < dwarf2_per_objfile->n_type_units; ++i)
6137 {
6138 struct signatured_type *sig_type = dwarf2_per_objfile->all_type_units[i];
6139
6140 sorted_by_abbrev[i].sig_type = sig_type;
6141 sorted_by_abbrev[i].abbrev_offset =
6142 read_abbrev_offset (sig_type->per_cu.section,
6143 sig_type->per_cu.offset);
6144 }
6145 cleanups = make_cleanup (xfree, sorted_by_abbrev);
6146 qsort (sorted_by_abbrev, dwarf2_per_objfile->n_type_units,
6147 sizeof (struct tu_abbrev_offset), sort_tu_by_abbrev_offset);
6148
6149 abbrev_offset.sect_off = ~(unsigned) 0;
6150 abbrev_table = NULL;
6151 make_cleanup (abbrev_table_free_cleanup, &abbrev_table);
6152
6153 for (i = 0; i < dwarf2_per_objfile->n_type_units; ++i)
6154 {
6155 const struct tu_abbrev_offset *tu = &sorted_by_abbrev[i];
6156
6157 /* Switch to the next abbrev table if necessary. */
6158 if (abbrev_table == NULL
6159 || tu->abbrev_offset.sect_off != abbrev_offset.sect_off)
6160 {
6161 if (abbrev_table != NULL)
6162 {
6163 abbrev_table_free (abbrev_table);
6164 /* Reset to NULL in case abbrev_table_read_table throws
6165 an error: abbrev_table_free_cleanup will get called. */
6166 abbrev_table = NULL;
6167 }
6168 abbrev_offset = tu->abbrev_offset;
6169 abbrev_table =
6170 abbrev_table_read_table (&dwarf2_per_objfile->abbrev,
6171 abbrev_offset);
6172 ++tu_stats->nr_uniq_abbrev_tables;
6173 }
6174
6175 init_cutu_and_read_dies (&tu->sig_type->per_cu, abbrev_table, 0, 0,
6176 build_type_psymtabs_reader, NULL);
6177 }
6178
6179 do_cleanups (cleanups);
6180 }
6181
6182 /* Print collected type unit statistics. */
6183
6184 static void
6185 print_tu_stats (void)
6186 {
6187 struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
6188
6189 fprintf_unfiltered (gdb_stdlog, "Type unit statistics:\n");
6190 fprintf_unfiltered (gdb_stdlog, " %d TUs\n",
6191 dwarf2_per_objfile->n_type_units);
6192 fprintf_unfiltered (gdb_stdlog, " %d uniq abbrev tables\n",
6193 tu_stats->nr_uniq_abbrev_tables);
6194 fprintf_unfiltered (gdb_stdlog, " %d symtabs from stmt_list entries\n",
6195 tu_stats->nr_symtabs);
6196 fprintf_unfiltered (gdb_stdlog, " %d symtab sharers\n",
6197 tu_stats->nr_symtab_sharers);
6198 fprintf_unfiltered (gdb_stdlog, " %d type units without a stmt_list\n",
6199 tu_stats->nr_stmt_less_type_units);
6200 fprintf_unfiltered (gdb_stdlog, " %d all_type_units reallocs\n",
6201 tu_stats->nr_all_type_units_reallocs);
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_psymtabs_1 ();
6247 }
6248
6249 /* Traversal function for process_skeletonless_type_unit.
6250 Read a TU in a DWO file and build partial symbols for it. */
6251
6252 static int
6253 process_skeletonless_type_unit (void **slot, void *info)
6254 {
6255 struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
6256 struct objfile *objfile = info;
6257 struct signatured_type find_entry, *entry;
6258
6259 /* If this TU doesn't exist in the global table, add it and read it in. */
6260
6261 if (dwarf2_per_objfile->signatured_types == NULL)
6262 {
6263 dwarf2_per_objfile->signatured_types
6264 = allocate_signatured_type_table (objfile);
6265 }
6266
6267 find_entry.signature = dwo_unit->signature;
6268 slot = htab_find_slot (dwarf2_per_objfile->signatured_types, &find_entry,
6269 INSERT);
6270 /* If we've already seen this type there's nothing to do. What's happening
6271 is we're doing our own version of comdat-folding here. */
6272 if (*slot != NULL)
6273 return 1;
6274
6275 /* This does the job that create_all_type_units would have done for
6276 this TU. */
6277 entry = add_type_unit (dwo_unit->signature, slot);
6278 fill_in_sig_entry_from_dwo_entry (objfile, entry, dwo_unit);
6279 *slot = entry;
6280
6281 /* This does the job that build_type_psymtabs_1 would have done. */
6282 init_cutu_and_read_dies (&entry->per_cu, NULL, 0, 0,
6283 build_type_psymtabs_reader, NULL);
6284
6285 return 1;
6286 }
6287
6288 /* Traversal function for process_skeletonless_type_units. */
6289
6290 static int
6291 process_dwo_file_for_skeletonless_type_units (void **slot, void *info)
6292 {
6293 struct dwo_file *dwo_file = (struct dwo_file *) *slot;
6294
6295 if (dwo_file->tus != NULL)
6296 {
6297 htab_traverse_noresize (dwo_file->tus,
6298 process_skeletonless_type_unit, info);
6299 }
6300
6301 return 1;
6302 }
6303
6304 /* Scan all TUs of DWO files, verifying we've processed them.
6305 This is needed in case a TU was emitted without its skeleton.
6306 Note: This can't be done until we know what all the DWO files are. */
6307
6308 static void
6309 process_skeletonless_type_units (struct objfile *objfile)
6310 {
6311 /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */
6312 if (get_dwp_file () == NULL
6313 && dwarf2_per_objfile->dwo_files != NULL)
6314 {
6315 htab_traverse_noresize (dwarf2_per_objfile->dwo_files,
6316 process_dwo_file_for_skeletonless_type_units,
6317 objfile);
6318 }
6319 }
6320
6321 /* A cleanup function that clears objfile's psymtabs_addrmap field. */
6322
6323 static void
6324 psymtabs_addrmap_cleanup (void *o)
6325 {
6326 struct objfile *objfile = o;
6327
6328 objfile->psymtabs_addrmap = NULL;
6329 }
6330
6331 /* Compute the 'user' field for each psymtab in OBJFILE. */
6332
6333 static void
6334 set_partial_user (struct objfile *objfile)
6335 {
6336 int i;
6337
6338 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
6339 {
6340 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
6341 struct partial_symtab *pst = per_cu->v.psymtab;
6342 int j;
6343
6344 if (pst == NULL)
6345 continue;
6346
6347 for (j = 0; j < pst->number_of_dependencies; ++j)
6348 {
6349 /* Set the 'user' field only if it is not already set. */
6350 if (pst->dependencies[j]->user == NULL)
6351 pst->dependencies[j]->user = pst;
6352 }
6353 }
6354 }
6355
6356 /* Build the partial symbol table by doing a quick pass through the
6357 .debug_info and .debug_abbrev sections. */
6358
6359 static void
6360 dwarf2_build_psymtabs_hard (struct objfile *objfile)
6361 {
6362 struct cleanup *back_to, *addrmap_cleanup;
6363 struct obstack temp_obstack;
6364 int i;
6365
6366 if (dwarf2_read_debug)
6367 {
6368 fprintf_unfiltered (gdb_stdlog, "Building psymtabs of objfile %s ...\n",
6369 objfile_name (objfile));
6370 }
6371
6372 dwarf2_per_objfile->reading_partial_symbols = 1;
6373
6374 dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
6375
6376 /* Any cached compilation units will be linked by the per-objfile
6377 read_in_chain. Make sure to free them when we're done. */
6378 back_to = make_cleanup (free_cached_comp_units, NULL);
6379
6380 build_type_psymtabs (objfile);
6381
6382 create_all_comp_units (objfile);
6383
6384 /* Create a temporary address map on a temporary obstack. We later
6385 copy this to the final obstack. */
6386 obstack_init (&temp_obstack);
6387 make_cleanup_obstack_free (&temp_obstack);
6388 objfile->psymtabs_addrmap = addrmap_create_mutable (&temp_obstack);
6389 addrmap_cleanup = make_cleanup (psymtabs_addrmap_cleanup, objfile);
6390
6391 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
6392 {
6393 struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
6394
6395 process_psymtab_comp_unit (per_cu, 0, language_minimal);
6396 }
6397
6398 /* This has to wait until we read the CUs, we need the list of DWOs. */
6399 process_skeletonless_type_units (objfile);
6400
6401 /* Now that all TUs have been processed we can fill in the dependencies. */
6402 if (dwarf2_per_objfile->type_unit_groups != NULL)
6403 {
6404 htab_traverse_noresize (dwarf2_per_objfile->type_unit_groups,
6405 build_type_psymtab_dependencies, NULL);
6406 }
6407
6408 if (dwarf2_read_debug)
6409 print_tu_stats ();
6410
6411 set_partial_user (objfile);
6412
6413 objfile->psymtabs_addrmap = addrmap_create_fixed (objfile->psymtabs_addrmap,
6414 &objfile->objfile_obstack);
6415 discard_cleanups (addrmap_cleanup);
6416
6417 do_cleanups (back_to);
6418
6419 if (dwarf2_read_debug)
6420 fprintf_unfiltered (gdb_stdlog, "Done building psymtabs of %s\n",
6421 objfile_name (objfile));
6422 }
6423
6424 /* die_reader_func for load_partial_comp_unit. */
6425
6426 static void
6427 load_partial_comp_unit_reader (const struct die_reader_specs *reader,
6428 const gdb_byte *info_ptr,
6429 struct die_info *comp_unit_die,
6430 int has_children,
6431 void *data)
6432 {
6433 struct dwarf2_cu *cu = reader->cu;
6434
6435 prepare_one_comp_unit (cu, comp_unit_die, language_minimal);
6436
6437 /* Check if comp unit has_children.
6438 If so, read the rest of the partial symbols from this comp unit.
6439 If not, there's no more debug_info for this comp unit. */
6440 if (has_children)
6441 load_partial_dies (reader, info_ptr, 0);
6442 }
6443
6444 /* Load the partial DIEs for a secondary CU into memory.
6445 This is also used when rereading a primary CU with load_all_dies. */
6446
6447 static void
6448 load_partial_comp_unit (struct dwarf2_per_cu_data *this_cu)
6449 {
6450 init_cutu_and_read_dies (this_cu, NULL, 1, 1,
6451 load_partial_comp_unit_reader, NULL);
6452 }
6453
6454 static void
6455 read_comp_units_from_section (struct objfile *objfile,
6456 struct dwarf2_section_info *section,
6457 unsigned int is_dwz,
6458 int *n_allocated,
6459 int *n_comp_units,
6460 struct dwarf2_per_cu_data ***all_comp_units)
6461 {
6462 const gdb_byte *info_ptr;
6463 bfd *abfd = get_section_bfd_owner (section);
6464
6465 if (dwarf2_read_debug)
6466 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s\n",
6467 get_section_name (section),
6468 get_section_file_name (section));
6469
6470 dwarf2_read_section (objfile, section);
6471
6472 info_ptr = section->buffer;
6473
6474 while (info_ptr < section->buffer + section->size)
6475 {
6476 unsigned int length, initial_length_size;
6477 struct dwarf2_per_cu_data *this_cu;
6478 sect_offset offset;
6479
6480 offset.sect_off = info_ptr - section->buffer;
6481
6482 /* Read just enough information to find out where the next
6483 compilation unit is. */
6484 length = read_initial_length (abfd, info_ptr, &initial_length_size);
6485
6486 /* Save the compilation unit for later lookup. */
6487 this_cu = obstack_alloc (&objfile->objfile_obstack,
6488 sizeof (struct dwarf2_per_cu_data));
6489 memset (this_cu, 0, sizeof (*this_cu));
6490 this_cu->offset = offset;
6491 this_cu->length = length + initial_length_size;
6492 this_cu->is_dwz = is_dwz;
6493 this_cu->objfile = objfile;
6494 this_cu->section = section;
6495
6496 if (*n_comp_units == *n_allocated)
6497 {
6498 *n_allocated *= 2;
6499 *all_comp_units = xrealloc (*all_comp_units,
6500 *n_allocated
6501 * sizeof (struct dwarf2_per_cu_data *));
6502 }
6503 (*all_comp_units)[*n_comp_units] = this_cu;
6504 ++*n_comp_units;
6505
6506 info_ptr = info_ptr + this_cu->length;
6507 }
6508 }
6509
6510 /* Create a list of all compilation units in OBJFILE.
6511 This is only done for -readnow and building partial symtabs. */
6512
6513 static void
6514 create_all_comp_units (struct objfile *objfile)
6515 {
6516 int n_allocated;
6517 int n_comp_units;
6518 struct dwarf2_per_cu_data **all_comp_units;
6519 struct dwz_file *dwz;
6520
6521 n_comp_units = 0;
6522 n_allocated = 10;
6523 all_comp_units = xmalloc (n_allocated
6524 * sizeof (struct dwarf2_per_cu_data *));
6525
6526 read_comp_units_from_section (objfile, &dwarf2_per_objfile->info, 0,
6527 &n_allocated, &n_comp_units, &all_comp_units);
6528
6529 dwz = dwarf2_get_dwz_file ();
6530 if (dwz != NULL)
6531 read_comp_units_from_section (objfile, &dwz->info, 1,
6532 &n_allocated, &n_comp_units,
6533 &all_comp_units);
6534
6535 dwarf2_per_objfile->all_comp_units
6536 = obstack_alloc (&objfile->objfile_obstack,
6537 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
6538 memcpy (dwarf2_per_objfile->all_comp_units, all_comp_units,
6539 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
6540 xfree (all_comp_units);
6541 dwarf2_per_objfile->n_comp_units = n_comp_units;
6542 }
6543
6544 /* Process all loaded DIEs for compilation unit CU, starting at
6545 FIRST_DIE. The caller should pass SET_ADDRMAP == 1 if the compilation
6546 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
6547 DW_AT_ranges). See the comments of add_partial_subprogram on how
6548 SET_ADDRMAP is used and how *LOWPC and *HIGHPC are updated. */
6549
6550 static void
6551 scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
6552 CORE_ADDR *highpc, int set_addrmap,
6553 struct dwarf2_cu *cu)
6554 {
6555 struct partial_die_info *pdi;
6556
6557 /* Now, march along the PDI's, descending into ones which have
6558 interesting children but skipping the children of the other ones,
6559 until we reach the end of the compilation unit. */
6560
6561 pdi = first_die;
6562
6563 while (pdi != NULL)
6564 {
6565 fixup_partial_die (pdi, cu);
6566
6567 /* Anonymous namespaces or modules have no name but have interesting
6568 children, so we need to look at them. Ditto for anonymous
6569 enums. */
6570
6571 if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
6572 || pdi->tag == DW_TAG_module || pdi->tag == DW_TAG_enumeration_type
6573 || pdi->tag == DW_TAG_imported_unit)
6574 {
6575 switch (pdi->tag)
6576 {
6577 case DW_TAG_subprogram:
6578 add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
6579 break;
6580 case DW_TAG_constant:
6581 case DW_TAG_variable:
6582 case DW_TAG_typedef:
6583 case DW_TAG_union_type:
6584 if (!pdi->is_declaration)
6585 {
6586 add_partial_symbol (pdi, cu);
6587 }
6588 break;
6589 case DW_TAG_class_type:
6590 case DW_TAG_interface_type:
6591 case DW_TAG_structure_type:
6592 if (!pdi->is_declaration)
6593 {
6594 add_partial_symbol (pdi, cu);
6595 }
6596 break;
6597 case DW_TAG_enumeration_type:
6598 if (!pdi->is_declaration)
6599 add_partial_enumeration (pdi, cu);
6600 break;
6601 case DW_TAG_base_type:
6602 case DW_TAG_subrange_type:
6603 /* File scope base type definitions are added to the partial
6604 symbol table. */
6605 add_partial_symbol (pdi, cu);
6606 break;
6607 case DW_TAG_namespace:
6608 add_partial_namespace (pdi, lowpc, highpc, set_addrmap, cu);
6609 break;
6610 case DW_TAG_module:
6611 add_partial_module (pdi, lowpc, highpc, set_addrmap, cu);
6612 break;
6613 case DW_TAG_imported_unit:
6614 {
6615 struct dwarf2_per_cu_data *per_cu;
6616
6617 /* For now we don't handle imported units in type units. */
6618 if (cu->per_cu->is_debug_types)
6619 {
6620 error (_("Dwarf Error: DW_TAG_imported_unit is not"
6621 " supported in type units [in module %s]"),
6622 objfile_name (cu->objfile));
6623 }
6624
6625 per_cu = dwarf2_find_containing_comp_unit (pdi->d.offset,
6626 pdi->is_dwz,
6627 cu->objfile);
6628
6629 /* Go read the partial unit, if needed. */
6630 if (per_cu->v.psymtab == NULL)
6631 process_psymtab_comp_unit (per_cu, 1, cu->language);
6632
6633 VEC_safe_push (dwarf2_per_cu_ptr,
6634 cu->per_cu->imported_symtabs, per_cu);
6635 }
6636 break;
6637 case DW_TAG_imported_declaration:
6638 add_partial_symbol (pdi, cu);
6639 break;
6640 default:
6641 break;
6642 }
6643 }
6644
6645 /* If the die has a sibling, skip to the sibling. */
6646
6647 pdi = pdi->die_sibling;
6648 }
6649 }
6650
6651 /* Functions used to compute the fully scoped name of a partial DIE.
6652
6653 Normally, this is simple. For C++, the parent DIE's fully scoped
6654 name is concatenated with "::" and the partial DIE's name. For
6655 Java, the same thing occurs except that "." is used instead of "::".
6656 Enumerators are an exception; they use the scope of their parent
6657 enumeration type, i.e. the name of the enumeration type is not
6658 prepended to the enumerator.
6659
6660 There are two complexities. One is DW_AT_specification; in this
6661 case "parent" means the parent of the target of the specification,
6662 instead of the direct parent of the DIE. The other is compilers
6663 which do not emit DW_TAG_namespace; in this case we try to guess
6664 the fully qualified name of structure types from their members'
6665 linkage names. This must be done using the DIE's children rather
6666 than the children of any DW_AT_specification target. We only need
6667 to do this for structures at the top level, i.e. if the target of
6668 any DW_AT_specification (if any; otherwise the DIE itself) does not
6669 have a parent. */
6670
6671 /* Compute the scope prefix associated with PDI's parent, in
6672 compilation unit CU. The result will be allocated on CU's
6673 comp_unit_obstack, or a copy of the already allocated PDI->NAME
6674 field. NULL is returned if no prefix is necessary. */
6675 static const char *
6676 partial_die_parent_scope (struct partial_die_info *pdi,
6677 struct dwarf2_cu *cu)
6678 {
6679 const char *grandparent_scope;
6680 struct partial_die_info *parent, *real_pdi;
6681
6682 /* We need to look at our parent DIE; if we have a DW_AT_specification,
6683 then this means the parent of the specification DIE. */
6684
6685 real_pdi = pdi;
6686 while (real_pdi->has_specification)
6687 real_pdi = find_partial_die (real_pdi->spec_offset,
6688 real_pdi->spec_is_dwz, cu);
6689
6690 parent = real_pdi->die_parent;
6691 if (parent == NULL)
6692 return NULL;
6693
6694 if (parent->scope_set)
6695 return parent->scope;
6696
6697 fixup_partial_die (parent, cu);
6698
6699 grandparent_scope = partial_die_parent_scope (parent, cu);
6700
6701 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
6702 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
6703 Work around this problem here. */
6704 if (cu->language == language_cplus
6705 && parent->tag == DW_TAG_namespace
6706 && strcmp (parent->name, "::") == 0
6707 && grandparent_scope == NULL)
6708 {
6709 parent->scope = NULL;
6710 parent->scope_set = 1;
6711 return NULL;
6712 }
6713
6714 if (pdi->tag == DW_TAG_enumerator)
6715 /* Enumerators should not get the name of the enumeration as a prefix. */
6716 parent->scope = grandparent_scope;
6717 else if (parent->tag == DW_TAG_namespace
6718 || parent->tag == DW_TAG_module
6719 || parent->tag == DW_TAG_structure_type
6720 || parent->tag == DW_TAG_class_type
6721 || parent->tag == DW_TAG_interface_type
6722 || parent->tag == DW_TAG_union_type
6723 || parent->tag == DW_TAG_enumeration_type)
6724 {
6725 if (grandparent_scope == NULL)
6726 parent->scope = parent->name;
6727 else
6728 parent->scope = typename_concat (&cu->comp_unit_obstack,
6729 grandparent_scope,
6730 parent->name, 0, cu);
6731 }
6732 else
6733 {
6734 /* FIXME drow/2004-04-01: What should we be doing with
6735 function-local names? For partial symbols, we should probably be
6736 ignoring them. */
6737 complaint (&symfile_complaints,
6738 _("unhandled containing DIE tag %d for DIE at %d"),
6739 parent->tag, pdi->offset.sect_off);
6740 parent->scope = grandparent_scope;
6741 }
6742
6743 parent->scope_set = 1;
6744 return parent->scope;
6745 }
6746
6747 /* Return the fully scoped name associated with PDI, from compilation unit
6748 CU. The result will be allocated with malloc. */
6749
6750 static char *
6751 partial_die_full_name (struct partial_die_info *pdi,
6752 struct dwarf2_cu *cu)
6753 {
6754 const char *parent_scope;
6755
6756 /* If this is a template instantiation, we can not work out the
6757 template arguments from partial DIEs. So, unfortunately, we have
6758 to go through the full DIEs. At least any work we do building
6759 types here will be reused if full symbols are loaded later. */
6760 if (pdi->has_template_arguments)
6761 {
6762 fixup_partial_die (pdi, cu);
6763
6764 if (pdi->name != NULL && strchr (pdi->name, '<') == NULL)
6765 {
6766 struct die_info *die;
6767 struct attribute attr;
6768 struct dwarf2_cu *ref_cu = cu;
6769
6770 /* DW_FORM_ref_addr is using section offset. */
6771 attr.name = 0;
6772 attr.form = DW_FORM_ref_addr;
6773 attr.u.unsnd = pdi->offset.sect_off;
6774 die = follow_die_ref (NULL, &attr, &ref_cu);
6775
6776 return xstrdup (dwarf2_full_name (NULL, die, ref_cu));
6777 }
6778 }
6779
6780 parent_scope = partial_die_parent_scope (pdi, cu);
6781 if (parent_scope == NULL)
6782 return NULL;
6783 else
6784 return typename_concat (NULL, parent_scope, pdi->name, 0, cu);
6785 }
6786
6787 static void
6788 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
6789 {
6790 struct objfile *objfile = cu->objfile;
6791 CORE_ADDR addr = 0;
6792 const char *actual_name = NULL;
6793 CORE_ADDR baseaddr;
6794 char *built_actual_name;
6795
6796 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6797
6798 built_actual_name = partial_die_full_name (pdi, cu);
6799 if (built_actual_name != NULL)
6800 actual_name = built_actual_name;
6801
6802 if (actual_name == NULL)
6803 actual_name = pdi->name;
6804
6805 switch (pdi->tag)
6806 {
6807 case DW_TAG_subprogram:
6808 if (pdi->is_external || cu->language == language_ada)
6809 {
6810 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
6811 of the global scope. But in Ada, we want to be able to access
6812 nested procedures globally. So all Ada subprograms are stored
6813 in the global scope. */
6814 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
6815 mst_text, objfile); */
6816 add_psymbol_to_list (actual_name, strlen (actual_name),
6817 built_actual_name != NULL,
6818 VAR_DOMAIN, LOC_BLOCK,
6819 &objfile->global_psymbols,
6820 0, pdi->lowpc + baseaddr,
6821 cu->language, objfile);
6822 }
6823 else
6824 {
6825 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
6826 mst_file_text, objfile); */
6827 add_psymbol_to_list (actual_name, strlen (actual_name),
6828 built_actual_name != NULL,
6829 VAR_DOMAIN, LOC_BLOCK,
6830 &objfile->static_psymbols,
6831 0, pdi->lowpc + baseaddr,
6832 cu->language, objfile);
6833 }
6834 break;
6835 case DW_TAG_constant:
6836 {
6837 struct psymbol_allocation_list *list;
6838
6839 if (pdi->is_external)
6840 list = &objfile->global_psymbols;
6841 else
6842 list = &objfile->static_psymbols;
6843 add_psymbol_to_list (actual_name, strlen (actual_name),
6844 built_actual_name != NULL, VAR_DOMAIN, LOC_STATIC,
6845 list, 0, 0, cu->language, objfile);
6846 }
6847 break;
6848 case DW_TAG_variable:
6849 if (pdi->d.locdesc)
6850 addr = decode_locdesc (pdi->d.locdesc, cu);
6851
6852 if (pdi->d.locdesc
6853 && addr == 0
6854 && !dwarf2_per_objfile->has_section_at_zero)
6855 {
6856 /* A global or static variable may also have been stripped
6857 out by the linker if unused, in which case its address
6858 will be nullified; do not add such variables into partial
6859 symbol table then. */
6860 }
6861 else if (pdi->is_external)
6862 {
6863 /* Global Variable.
6864 Don't enter into the minimal symbol tables as there is
6865 a minimal symbol table entry from the ELF symbols already.
6866 Enter into partial symbol table if it has a location
6867 descriptor or a type.
6868 If the location descriptor is missing, new_symbol will create
6869 a LOC_UNRESOLVED symbol, the address of the variable will then
6870 be determined from the minimal symbol table whenever the variable
6871 is referenced.
6872 The address for the partial symbol table entry is not
6873 used by GDB, but it comes in handy for debugging partial symbol
6874 table building. */
6875
6876 if (pdi->d.locdesc || pdi->has_type)
6877 add_psymbol_to_list (actual_name, strlen (actual_name),
6878 built_actual_name != NULL,
6879 VAR_DOMAIN, LOC_STATIC,
6880 &objfile->global_psymbols,
6881 0, addr + baseaddr,
6882 cu->language, objfile);
6883 }
6884 else
6885 {
6886 /* Static Variable. Skip symbols without location descriptors. */
6887 if (pdi->d.locdesc == NULL)
6888 {
6889 xfree (built_actual_name);
6890 return;
6891 }
6892 /* prim_record_minimal_symbol (actual_name, addr + baseaddr,
6893 mst_file_data, objfile); */
6894 add_psymbol_to_list (actual_name, strlen (actual_name),
6895 built_actual_name != NULL,
6896 VAR_DOMAIN, LOC_STATIC,
6897 &objfile->static_psymbols,
6898 0, addr + baseaddr,
6899 cu->language, objfile);
6900 }
6901 break;
6902 case DW_TAG_typedef:
6903 case DW_TAG_base_type:
6904 case DW_TAG_subrange_type:
6905 add_psymbol_to_list (actual_name, strlen (actual_name),
6906 built_actual_name != NULL,
6907 VAR_DOMAIN, LOC_TYPEDEF,
6908 &objfile->static_psymbols,
6909 0, (CORE_ADDR) 0, cu->language, objfile);
6910 break;
6911 case DW_TAG_imported_declaration:
6912 case DW_TAG_namespace:
6913 add_psymbol_to_list (actual_name, strlen (actual_name),
6914 built_actual_name != NULL,
6915 VAR_DOMAIN, LOC_TYPEDEF,
6916 &objfile->global_psymbols,
6917 0, (CORE_ADDR) 0, cu->language, objfile);
6918 break;
6919 case DW_TAG_module:
6920 add_psymbol_to_list (actual_name, strlen (actual_name),
6921 built_actual_name != NULL,
6922 MODULE_DOMAIN, LOC_TYPEDEF,
6923 &objfile->global_psymbols,
6924 0, (CORE_ADDR) 0, cu->language, objfile);
6925 break;
6926 case DW_TAG_class_type:
6927 case DW_TAG_interface_type:
6928 case DW_TAG_structure_type:
6929 case DW_TAG_union_type:
6930 case DW_TAG_enumeration_type:
6931 /* Skip external references. The DWARF standard says in the section
6932 about "Structure, Union, and Class Type Entries": "An incomplete
6933 structure, union or class type is represented by a structure,
6934 union or class entry that does not have a byte size attribute
6935 and that has a DW_AT_declaration attribute." */
6936 if (!pdi->has_byte_size && pdi->is_declaration)
6937 {
6938 xfree (built_actual_name);
6939 return;
6940 }
6941
6942 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
6943 static vs. global. */
6944 add_psymbol_to_list (actual_name, strlen (actual_name),
6945 built_actual_name != NULL,
6946 STRUCT_DOMAIN, LOC_TYPEDEF,
6947 (cu->language == language_cplus
6948 || cu->language == language_java)
6949 ? &objfile->global_psymbols
6950 : &objfile->static_psymbols,
6951 0, (CORE_ADDR) 0, cu->language, objfile);
6952
6953 break;
6954 case DW_TAG_enumerator:
6955 add_psymbol_to_list (actual_name, strlen (actual_name),
6956 built_actual_name != NULL,
6957 VAR_DOMAIN, LOC_CONST,
6958 (cu->language == language_cplus
6959 || cu->language == language_java)
6960 ? &objfile->global_psymbols
6961 : &objfile->static_psymbols,
6962 0, (CORE_ADDR) 0, cu->language, objfile);
6963 break;
6964 default:
6965 break;
6966 }
6967
6968 xfree (built_actual_name);
6969 }
6970
6971 /* Read a partial die corresponding to a namespace; also, add a symbol
6972 corresponding to that namespace to the symbol table. NAMESPACE is
6973 the name of the enclosing namespace. */
6974
6975 static void
6976 add_partial_namespace (struct partial_die_info *pdi,
6977 CORE_ADDR *lowpc, CORE_ADDR *highpc,
6978 int set_addrmap, struct dwarf2_cu *cu)
6979 {
6980 /* Add a symbol for the namespace. */
6981
6982 add_partial_symbol (pdi, cu);
6983
6984 /* Now scan partial symbols in that namespace. */
6985
6986 if (pdi->has_children)
6987 scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
6988 }
6989
6990 /* Read a partial die corresponding to a Fortran module. */
6991
6992 static void
6993 add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
6994 CORE_ADDR *highpc, int set_addrmap, struct dwarf2_cu *cu)
6995 {
6996 /* Add a symbol for the namespace. */
6997
6998 add_partial_symbol (pdi, cu);
6999
7000 /* Now scan partial symbols in that module. */
7001
7002 if (pdi->has_children)
7003 scan_partial_symbols (pdi->die_child, lowpc, highpc, set_addrmap, cu);
7004 }
7005
7006 /* Read a partial die corresponding to a subprogram and create a partial
7007 symbol for that subprogram. When the CU language allows it, this
7008 routine also defines a partial symbol for each nested subprogram
7009 that this subprogram contains. If SET_ADDRMAP is true, record the
7010 covered ranges in the addrmap. Set *LOWPC and *HIGHPC to the lowest
7011 and highest PC values found in PDI.
7012
7013 PDI may also be a lexical block, in which case we simply search
7014 recursively for subprograms defined inside that lexical block.
7015 Again, this is only performed when the CU language allows this
7016 type of definitions. */
7017
7018 static void
7019 add_partial_subprogram (struct partial_die_info *pdi,
7020 CORE_ADDR *lowpc, CORE_ADDR *highpc,
7021 int set_addrmap, struct dwarf2_cu *cu)
7022 {
7023 if (pdi->tag == DW_TAG_subprogram)
7024 {
7025 if (pdi->has_pc_info)
7026 {
7027 if (pdi->lowpc < *lowpc)
7028 *lowpc = pdi->lowpc;
7029 if (pdi->highpc > *highpc)
7030 *highpc = pdi->highpc;
7031 if (set_addrmap)
7032 {
7033 CORE_ADDR baseaddr;
7034 struct objfile *objfile = cu->objfile;
7035
7036 baseaddr = ANOFFSET (objfile->section_offsets,
7037 SECT_OFF_TEXT (objfile));
7038 addrmap_set_empty (objfile->psymtabs_addrmap,
7039 pdi->lowpc + baseaddr,
7040 pdi->highpc - 1 + baseaddr,
7041 cu->per_cu->v.psymtab);
7042 }
7043 }
7044
7045 if (pdi->has_pc_info || (!pdi->is_external && pdi->may_be_inlined))
7046 {
7047 if (!pdi->is_declaration)
7048 /* Ignore subprogram DIEs that do not have a name, they are
7049 illegal. Do not emit a complaint at this point, we will
7050 do so when we convert this psymtab into a symtab. */
7051 if (pdi->name)
7052 add_partial_symbol (pdi, cu);
7053 }
7054 }
7055
7056 if (! pdi->has_children)
7057 return;
7058
7059 if (cu->language == language_ada)
7060 {
7061 pdi = pdi->die_child;
7062 while (pdi != NULL)
7063 {
7064 fixup_partial_die (pdi, cu);
7065 if (pdi->tag == DW_TAG_subprogram
7066 || pdi->tag == DW_TAG_lexical_block)
7067 add_partial_subprogram (pdi, lowpc, highpc, set_addrmap, cu);
7068 pdi = pdi->die_sibling;
7069 }
7070 }
7071 }
7072
7073 /* Read a partial die corresponding to an enumeration type. */
7074
7075 static void
7076 add_partial_enumeration (struct partial_die_info *enum_pdi,
7077 struct dwarf2_cu *cu)
7078 {
7079 struct partial_die_info *pdi;
7080
7081 if (enum_pdi->name != NULL)
7082 add_partial_symbol (enum_pdi, cu);
7083
7084 pdi = enum_pdi->die_child;
7085 while (pdi)
7086 {
7087 if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
7088 complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
7089 else
7090 add_partial_symbol (pdi, cu);
7091 pdi = pdi->die_sibling;
7092 }
7093 }
7094
7095 /* Return the initial uleb128 in the die at INFO_PTR. */
7096
7097 static unsigned int
7098 peek_abbrev_code (bfd *abfd, const gdb_byte *info_ptr)
7099 {
7100 unsigned int bytes_read;
7101
7102 return read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
7103 }
7104
7105 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
7106 Return the corresponding abbrev, or NULL if the number is zero (indicating
7107 an empty DIE). In either case *BYTES_READ will be set to the length of
7108 the initial number. */
7109
7110 static struct abbrev_info *
7111 peek_die_abbrev (const gdb_byte *info_ptr, unsigned int *bytes_read,
7112 struct dwarf2_cu *cu)
7113 {
7114 bfd *abfd = cu->objfile->obfd;
7115 unsigned int abbrev_number;
7116 struct abbrev_info *abbrev;
7117
7118 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
7119
7120 if (abbrev_number == 0)
7121 return NULL;
7122
7123 abbrev = abbrev_table_lookup_abbrev (cu->abbrev_table, abbrev_number);
7124 if (!abbrev)
7125 {
7126 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"),
7127 abbrev_number, bfd_get_filename (abfd));
7128 }
7129
7130 return abbrev;
7131 }
7132
7133 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
7134 Returns a pointer to the end of a series of DIEs, terminated by an empty
7135 DIE. Any children of the skipped DIEs will also be skipped. */
7136
7137 static const gdb_byte *
7138 skip_children (const struct die_reader_specs *reader, const gdb_byte *info_ptr)
7139 {
7140 struct dwarf2_cu *cu = reader->cu;
7141 struct abbrev_info *abbrev;
7142 unsigned int bytes_read;
7143
7144 while (1)
7145 {
7146 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
7147 if (abbrev == NULL)
7148 return info_ptr + bytes_read;
7149 else
7150 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
7151 }
7152 }
7153
7154 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
7155 INFO_PTR should point just after the initial uleb128 of a DIE, and the
7156 abbrev corresponding to that skipped uleb128 should be passed in
7157 ABBREV. Returns a pointer to this DIE's sibling, skipping any
7158 children. */
7159
7160 static const gdb_byte *
7161 skip_one_die (const struct die_reader_specs *reader, const gdb_byte *info_ptr,
7162 struct abbrev_info *abbrev)
7163 {
7164 unsigned int bytes_read;
7165 struct attribute attr;
7166 bfd *abfd = reader->abfd;
7167 struct dwarf2_cu *cu = reader->cu;
7168 const gdb_byte *buffer = reader->buffer;
7169 const gdb_byte *buffer_end = reader->buffer_end;
7170 const gdb_byte *start_info_ptr = info_ptr;
7171 unsigned int form, i;
7172
7173 for (i = 0; i < abbrev->num_attrs; i++)
7174 {
7175 /* The only abbrev we care about is DW_AT_sibling. */
7176 if (abbrev->attrs[i].name == DW_AT_sibling)
7177 {
7178 read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
7179 if (attr.form == DW_FORM_ref_addr)
7180 complaint (&symfile_complaints,
7181 _("ignoring absolute DW_AT_sibling"));
7182 else
7183 {
7184 unsigned int off = dwarf2_get_ref_die_offset (&attr).sect_off;
7185 const gdb_byte *sibling_ptr = buffer + off;
7186
7187 if (sibling_ptr < info_ptr)
7188 complaint (&symfile_complaints,
7189 _("DW_AT_sibling points backwards"));
7190 else if (sibling_ptr > reader->buffer_end)
7191 dwarf2_section_buffer_overflow_complaint (reader->die_section);
7192 else
7193 return sibling_ptr;
7194 }
7195 }
7196
7197 /* If it isn't DW_AT_sibling, skip this attribute. */
7198 form = abbrev->attrs[i].form;
7199 skip_attribute:
7200 switch (form)
7201 {
7202 case DW_FORM_ref_addr:
7203 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
7204 and later it is offset sized. */
7205 if (cu->header.version == 2)
7206 info_ptr += cu->header.addr_size;
7207 else
7208 info_ptr += cu->header.offset_size;
7209 break;
7210 case DW_FORM_GNU_ref_alt:
7211 info_ptr += cu->header.offset_size;
7212 break;
7213 case DW_FORM_addr:
7214 info_ptr += cu->header.addr_size;
7215 break;
7216 case DW_FORM_data1:
7217 case DW_FORM_ref1:
7218 case DW_FORM_flag:
7219 info_ptr += 1;
7220 break;
7221 case DW_FORM_flag_present:
7222 break;
7223 case DW_FORM_data2:
7224 case DW_FORM_ref2:
7225 info_ptr += 2;
7226 break;
7227 case DW_FORM_data4:
7228 case DW_FORM_ref4:
7229 info_ptr += 4;
7230 break;
7231 case DW_FORM_data8:
7232 case DW_FORM_ref8:
7233 case DW_FORM_ref_sig8:
7234 info_ptr += 8;
7235 break;
7236 case DW_FORM_string:
7237 read_direct_string (abfd, info_ptr, &bytes_read);
7238 info_ptr += bytes_read;
7239 break;
7240 case DW_FORM_sec_offset:
7241 case DW_FORM_strp:
7242 case DW_FORM_GNU_strp_alt:
7243 info_ptr += cu->header.offset_size;
7244 break;
7245 case DW_FORM_exprloc:
7246 case DW_FORM_block:
7247 info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
7248 info_ptr += bytes_read;
7249 break;
7250 case DW_FORM_block1:
7251 info_ptr += 1 + read_1_byte (abfd, info_ptr);
7252 break;
7253 case DW_FORM_block2:
7254 info_ptr += 2 + read_2_bytes (abfd, info_ptr);
7255 break;
7256 case DW_FORM_block4:
7257 info_ptr += 4 + read_4_bytes (abfd, info_ptr);
7258 break;
7259 case DW_FORM_sdata:
7260 case DW_FORM_udata:
7261 case DW_FORM_ref_udata:
7262 case DW_FORM_GNU_addr_index:
7263 case DW_FORM_GNU_str_index:
7264 info_ptr = safe_skip_leb128 (info_ptr, buffer_end);
7265 break;
7266 case DW_FORM_indirect:
7267 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
7268 info_ptr += bytes_read;
7269 /* We need to continue parsing from here, so just go back to
7270 the top. */
7271 goto skip_attribute;
7272
7273 default:
7274 error (_("Dwarf Error: Cannot handle %s "
7275 "in DWARF reader [in module %s]"),
7276 dwarf_form_name (form),
7277 bfd_get_filename (abfd));
7278 }
7279 }
7280
7281 if (abbrev->has_children)
7282 return skip_children (reader, info_ptr);
7283 else
7284 return info_ptr;
7285 }
7286
7287 /* Locate ORIG_PDI's sibling.
7288 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
7289
7290 static const gdb_byte *
7291 locate_pdi_sibling (const struct die_reader_specs *reader,
7292 struct partial_die_info *orig_pdi,
7293 const gdb_byte *info_ptr)
7294 {
7295 /* Do we know the sibling already? */
7296
7297 if (orig_pdi->sibling)
7298 return orig_pdi->sibling;
7299
7300 /* Are there any children to deal with? */
7301
7302 if (!orig_pdi->has_children)
7303 return info_ptr;
7304
7305 /* Skip the children the long way. */
7306
7307 return skip_children (reader, info_ptr);
7308 }
7309
7310 /* Expand this partial symbol table into a full symbol table. SELF is
7311 not NULL. */
7312
7313 static void
7314 dwarf2_read_symtab (struct partial_symtab *self,
7315 struct objfile *objfile)
7316 {
7317 if (self->readin)
7318 {
7319 warning (_("bug: psymtab for %s is already read in."),
7320 self->filename);
7321 }
7322 else
7323 {
7324 if (info_verbose)
7325 {
7326 printf_filtered (_("Reading in symbols for %s..."),
7327 self->filename);
7328 gdb_flush (gdb_stdout);
7329 }
7330
7331 /* Restore our global data. */
7332 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
7333
7334 /* If this psymtab is constructed from a debug-only objfile, the
7335 has_section_at_zero flag will not necessarily be correct. We
7336 can get the correct value for this flag by looking at the data
7337 associated with the (presumably stripped) associated objfile. */
7338 if (objfile->separate_debug_objfile_backlink)
7339 {
7340 struct dwarf2_per_objfile *dpo_backlink
7341 = objfile_data (objfile->separate_debug_objfile_backlink,
7342 dwarf2_objfile_data_key);
7343
7344 dwarf2_per_objfile->has_section_at_zero
7345 = dpo_backlink->has_section_at_zero;
7346 }
7347
7348 dwarf2_per_objfile->reading_partial_symbols = 0;
7349
7350 psymtab_to_symtab_1 (self);
7351
7352 /* Finish up the debug error message. */
7353 if (info_verbose)
7354 printf_filtered (_("done.\n"));
7355 }
7356
7357 process_cu_includes ();
7358 }
7359 \f
7360 /* Reading in full CUs. */
7361
7362 /* Add PER_CU to the queue. */
7363
7364 static void
7365 queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
7366 enum language pretend_language)
7367 {
7368 struct dwarf2_queue_item *item;
7369
7370 per_cu->queued = 1;
7371 item = xmalloc (sizeof (*item));
7372 item->per_cu = per_cu;
7373 item->pretend_language = pretend_language;
7374 item->next = NULL;
7375
7376 if (dwarf2_queue == NULL)
7377 dwarf2_queue = item;
7378 else
7379 dwarf2_queue_tail->next = item;
7380
7381 dwarf2_queue_tail = item;
7382 }
7383
7384 /* If PER_CU is not yet queued, add it to the queue.
7385 If DEPENDENT_CU is non-NULL, it has a reference to PER_CU so add a
7386 dependency.
7387 The result is non-zero if PER_CU was queued, otherwise the result is zero
7388 meaning either PER_CU is already queued or it is already loaded.
7389
7390 N.B. There is an invariant here that if a CU is queued then it is loaded.
7391 The caller is required to load PER_CU if we return non-zero. */
7392
7393 static int
7394 maybe_queue_comp_unit (struct dwarf2_cu *dependent_cu,
7395 struct dwarf2_per_cu_data *per_cu,
7396 enum language pretend_language)
7397 {
7398 /* We may arrive here during partial symbol reading, if we need full
7399 DIEs to process an unusual case (e.g. template arguments). Do
7400 not queue PER_CU, just tell our caller to load its DIEs. */
7401 if (dwarf2_per_objfile->reading_partial_symbols)
7402 {
7403 if (per_cu->cu == NULL || per_cu->cu->dies == NULL)
7404 return 1;
7405 return 0;
7406 }
7407
7408 /* Mark the dependence relation so that we don't flush PER_CU
7409 too early. */
7410 if (dependent_cu != NULL)
7411 dwarf2_add_dependence (dependent_cu, per_cu);
7412
7413 /* If it's already on the queue, we have nothing to do. */
7414 if (per_cu->queued)
7415 return 0;
7416
7417 /* If the compilation unit is already loaded, just mark it as
7418 used. */
7419 if (per_cu->cu != NULL)
7420 {
7421 per_cu->cu->last_used = 0;
7422 return 0;
7423 }
7424
7425 /* Add it to the queue. */
7426 queue_comp_unit (per_cu, pretend_language);
7427
7428 return 1;
7429 }
7430
7431 /* Process the queue. */
7432
7433 static void
7434 process_queue (void)
7435 {
7436 struct dwarf2_queue_item *item, *next_item;
7437
7438 if (dwarf2_read_debug)
7439 {
7440 fprintf_unfiltered (gdb_stdlog,
7441 "Expanding one or more symtabs of objfile %s ...\n",
7442 objfile_name (dwarf2_per_objfile->objfile));
7443 }
7444
7445 /* The queue starts out with one item, but following a DIE reference
7446 may load a new CU, adding it to the end of the queue. */
7447 for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
7448 {
7449 if (dwarf2_per_objfile->using_index
7450 ? !item->per_cu->v.quick->symtab
7451 : (item->per_cu->v.psymtab && !item->per_cu->v.psymtab->readin))
7452 {
7453 struct dwarf2_per_cu_data *per_cu = item->per_cu;
7454 unsigned int debug_print_threshold;
7455 char buf[100];
7456
7457 if (per_cu->is_debug_types)
7458 {
7459 struct signatured_type *sig_type =
7460 (struct signatured_type *) per_cu;
7461
7462 sprintf (buf, "TU %s at offset 0x%x",
7463 hex_string (sig_type->signature),
7464 per_cu->offset.sect_off);
7465 /* There can be 100s of TUs.
7466 Only print them in verbose mode. */
7467 debug_print_threshold = 2;
7468 }
7469 else
7470 {
7471 sprintf (buf, "CU at offset 0x%x", per_cu->offset.sect_off);
7472 debug_print_threshold = 1;
7473 }
7474
7475 if (dwarf2_read_debug >= debug_print_threshold)
7476 fprintf_unfiltered (gdb_stdlog, "Expanding symtab of %s\n", buf);
7477
7478 if (per_cu->is_debug_types)
7479 process_full_type_unit (per_cu, item->pretend_language);
7480 else
7481 process_full_comp_unit (per_cu, item->pretend_language);
7482
7483 if (dwarf2_read_debug >= debug_print_threshold)
7484 fprintf_unfiltered (gdb_stdlog, "Done expanding %s\n", buf);
7485 }
7486
7487 item->per_cu->queued = 0;
7488 next_item = item->next;
7489 xfree (item);
7490 }
7491
7492 dwarf2_queue_tail = NULL;
7493
7494 if (dwarf2_read_debug)
7495 {
7496 fprintf_unfiltered (gdb_stdlog, "Done expanding symtabs of %s.\n",
7497 objfile_name (dwarf2_per_objfile->objfile));
7498 }
7499 }
7500
7501 /* Free all allocated queue entries. This function only releases anything if
7502 an error was thrown; if the queue was processed then it would have been
7503 freed as we went along. */
7504
7505 static void
7506 dwarf2_release_queue (void *dummy)
7507 {
7508 struct dwarf2_queue_item *item, *last;
7509
7510 item = dwarf2_queue;
7511 while (item)
7512 {
7513 /* Anything still marked queued is likely to be in an
7514 inconsistent state, so discard it. */
7515 if (item->per_cu->queued)
7516 {
7517 if (item->per_cu->cu != NULL)
7518 free_one_cached_comp_unit (item->per_cu);
7519 item->per_cu->queued = 0;
7520 }
7521
7522 last = item;
7523 item = item->next;
7524 xfree (last);
7525 }
7526
7527 dwarf2_queue = dwarf2_queue_tail = NULL;
7528 }
7529
7530 /* Read in full symbols for PST, and anything it depends on. */
7531
7532 static void
7533 psymtab_to_symtab_1 (struct partial_symtab *pst)
7534 {
7535 struct dwarf2_per_cu_data *per_cu;
7536 int i;
7537
7538 if (pst->readin)
7539 return;
7540
7541 for (i = 0; i < pst->number_of_dependencies; i++)
7542 if (!pst->dependencies[i]->readin
7543 && pst->dependencies[i]->user == NULL)
7544 {
7545 /* Inform about additional files that need to be read in. */
7546 if (info_verbose)
7547 {
7548 /* FIXME: i18n: Need to make this a single string. */
7549 fputs_filtered (" ", gdb_stdout);
7550 wrap_here ("");
7551 fputs_filtered ("and ", gdb_stdout);
7552 wrap_here ("");
7553 printf_filtered ("%s...", pst->dependencies[i]->filename);
7554 wrap_here (""); /* Flush output. */
7555 gdb_flush (gdb_stdout);
7556 }
7557 psymtab_to_symtab_1 (pst->dependencies[i]);
7558 }
7559
7560 per_cu = pst->read_symtab_private;
7561
7562 if (per_cu == NULL)
7563 {
7564 /* It's an include file, no symbols to read for it.
7565 Everything is in the parent symtab. */
7566 pst->readin = 1;
7567 return;
7568 }
7569
7570 dw2_do_instantiate_symtab (per_cu);
7571 }
7572
7573 /* Trivial hash function for die_info: the hash value of a DIE
7574 is its offset in .debug_info for this objfile. */
7575
7576 static hashval_t
7577 die_hash (const void *item)
7578 {
7579 const struct die_info *die = item;
7580
7581 return die->offset.sect_off;
7582 }
7583
7584 /* Trivial comparison function for die_info structures: two DIEs
7585 are equal if they have the same offset. */
7586
7587 static int
7588 die_eq (const void *item_lhs, const void *item_rhs)
7589 {
7590 const struct die_info *die_lhs = item_lhs;
7591 const struct die_info *die_rhs = item_rhs;
7592
7593 return die_lhs->offset.sect_off == die_rhs->offset.sect_off;
7594 }
7595
7596 /* die_reader_func for load_full_comp_unit.
7597 This is identical to read_signatured_type_reader,
7598 but is kept separate for now. */
7599
7600 static void
7601 load_full_comp_unit_reader (const struct die_reader_specs *reader,
7602 const gdb_byte *info_ptr,
7603 struct die_info *comp_unit_die,
7604 int has_children,
7605 void *data)
7606 {
7607 struct dwarf2_cu *cu = reader->cu;
7608 enum language *language_ptr = data;
7609
7610 gdb_assert (cu->die_hash == NULL);
7611 cu->die_hash =
7612 htab_create_alloc_ex (cu->header.length / 12,
7613 die_hash,
7614 die_eq,
7615 NULL,
7616 &cu->comp_unit_obstack,
7617 hashtab_obstack_allocate,
7618 dummy_obstack_deallocate);
7619
7620 if (has_children)
7621 comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
7622 &info_ptr, comp_unit_die);
7623 cu->dies = comp_unit_die;
7624 /* comp_unit_die is not stored in die_hash, no need. */
7625
7626 /* We try not to read any attributes in this function, because not
7627 all CUs needed for references have been loaded yet, and symbol
7628 table processing isn't initialized. But we have to set the CU language,
7629 or we won't be able to build types correctly.
7630 Similarly, if we do not read the producer, we can not apply
7631 producer-specific interpretation. */
7632 prepare_one_comp_unit (cu, cu->dies, *language_ptr);
7633 }
7634
7635 /* Load the DIEs associated with PER_CU into memory. */
7636
7637 static void
7638 load_full_comp_unit (struct dwarf2_per_cu_data *this_cu,
7639 enum language pretend_language)
7640 {
7641 gdb_assert (! this_cu->is_debug_types);
7642
7643 init_cutu_and_read_dies (this_cu, NULL, 1, 1,
7644 load_full_comp_unit_reader, &pretend_language);
7645 }
7646
7647 /* Add a DIE to the delayed physname list. */
7648
7649 static void
7650 add_to_method_list (struct type *type, int fnfield_index, int index,
7651 const char *name, struct die_info *die,
7652 struct dwarf2_cu *cu)
7653 {
7654 struct delayed_method_info mi;
7655 mi.type = type;
7656 mi.fnfield_index = fnfield_index;
7657 mi.index = index;
7658 mi.name = name;
7659 mi.die = die;
7660 VEC_safe_push (delayed_method_info, cu->method_list, &mi);
7661 }
7662
7663 /* A cleanup for freeing the delayed method list. */
7664
7665 static void
7666 free_delayed_list (void *ptr)
7667 {
7668 struct dwarf2_cu *cu = (struct dwarf2_cu *) ptr;
7669 if (cu->method_list != NULL)
7670 {
7671 VEC_free (delayed_method_info, cu->method_list);
7672 cu->method_list = NULL;
7673 }
7674 }
7675
7676 /* Compute the physnames of any methods on the CU's method list.
7677
7678 The computation of method physnames is delayed in order to avoid the
7679 (bad) condition that one of the method's formal parameters is of an as yet
7680 incomplete type. */
7681
7682 static void
7683 compute_delayed_physnames (struct dwarf2_cu *cu)
7684 {
7685 int i;
7686 struct delayed_method_info *mi;
7687 for (i = 0; VEC_iterate (delayed_method_info, cu->method_list, i, mi) ; ++i)
7688 {
7689 const char *physname;
7690 struct fn_fieldlist *fn_flp
7691 = &TYPE_FN_FIELDLIST (mi->type, mi->fnfield_index);
7692 physname = dwarf2_physname (mi->name, mi->die, cu);
7693 fn_flp->fn_fields[mi->index].physname = physname ? physname : "";
7694 }
7695 }
7696
7697 /* Go objects should be embedded in a DW_TAG_module DIE,
7698 and it's not clear if/how imported objects will appear.
7699 To keep Go support simple until that's worked out,
7700 go back through what we've read and create something usable.
7701 We could do this while processing each DIE, and feels kinda cleaner,
7702 but that way is more invasive.
7703 This is to, for example, allow the user to type "p var" or "b main"
7704 without having to specify the package name, and allow lookups
7705 of module.object to work in contexts that use the expression
7706 parser. */
7707
7708 static void
7709 fixup_go_packaging (struct dwarf2_cu *cu)
7710 {
7711 char *package_name = NULL;
7712 struct pending *list;
7713 int i;
7714
7715 for (list = global_symbols; list != NULL; list = list->next)
7716 {
7717 for (i = 0; i < list->nsyms; ++i)
7718 {
7719 struct symbol *sym = list->symbol[i];
7720
7721 if (SYMBOL_LANGUAGE (sym) == language_go
7722 && SYMBOL_CLASS (sym) == LOC_BLOCK)
7723 {
7724 char *this_package_name = go_symbol_package_name (sym);
7725
7726 if (this_package_name == NULL)
7727 continue;
7728 if (package_name == NULL)
7729 package_name = this_package_name;
7730 else
7731 {
7732 if (strcmp (package_name, this_package_name) != 0)
7733 complaint (&symfile_complaints,
7734 _("Symtab %s has objects from two different Go packages: %s and %s"),
7735 (SYMBOL_SYMTAB (sym)
7736 ? symtab_to_filename_for_display (SYMBOL_SYMTAB (sym))
7737 : objfile_name (cu->objfile)),
7738 this_package_name, package_name);
7739 xfree (this_package_name);
7740 }
7741 }
7742 }
7743 }
7744
7745 if (package_name != NULL)
7746 {
7747 struct objfile *objfile = cu->objfile;
7748 const char *saved_package_name
7749 = obstack_copy0 (&objfile->per_bfd->storage_obstack,
7750 package_name,
7751 strlen (package_name));
7752 struct type *type = init_type (TYPE_CODE_MODULE, 0, 0,
7753 saved_package_name, objfile);
7754 struct symbol *sym;
7755
7756 TYPE_TAG_NAME (type) = TYPE_NAME (type);
7757
7758 sym = allocate_symbol (objfile);
7759 SYMBOL_SET_LANGUAGE (sym, language_go, &objfile->objfile_obstack);
7760 SYMBOL_SET_NAMES (sym, saved_package_name,
7761 strlen (saved_package_name), 0, objfile);
7762 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
7763 e.g., "main" finds the "main" module and not C's main(). */
7764 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
7765 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
7766 SYMBOL_TYPE (sym) = type;
7767
7768 add_symbol_to_list (sym, &global_symbols);
7769
7770 xfree (package_name);
7771 }
7772 }
7773
7774 /* Return the symtab for PER_CU. This works properly regardless of
7775 whether we're using the index or psymtabs. */
7776
7777 static struct symtab *
7778 get_symtab (struct dwarf2_per_cu_data *per_cu)
7779 {
7780 return (dwarf2_per_objfile->using_index
7781 ? per_cu->v.quick->symtab
7782 : per_cu->v.psymtab->symtab);
7783 }
7784
7785 /* A helper function for computing the list of all symbol tables
7786 included by PER_CU. */
7787
7788 static void
7789 recursively_compute_inclusions (VEC (symtab_ptr) **result,
7790 htab_t all_children, htab_t all_type_symtabs,
7791 struct dwarf2_per_cu_data *per_cu,
7792 struct symtab *immediate_parent)
7793 {
7794 void **slot;
7795 int ix;
7796 struct symtab *symtab;
7797 struct dwarf2_per_cu_data *iter;
7798
7799 slot = htab_find_slot (all_children, per_cu, INSERT);
7800 if (*slot != NULL)
7801 {
7802 /* This inclusion and its children have been processed. */
7803 return;
7804 }
7805
7806 *slot = per_cu;
7807 /* Only add a CU if it has a symbol table. */
7808 symtab = get_symtab (per_cu);
7809 if (symtab != NULL)
7810 {
7811 /* If this is a type unit only add its symbol table if we haven't
7812 seen it yet (type unit per_cu's can share symtabs). */
7813 if (per_cu->is_debug_types)
7814 {
7815 slot = htab_find_slot (all_type_symtabs, symtab, INSERT);
7816 if (*slot == NULL)
7817 {
7818 *slot = symtab;
7819 VEC_safe_push (symtab_ptr, *result, symtab);
7820 if (symtab->user == NULL)
7821 symtab->user = immediate_parent;
7822 }
7823 }
7824 else
7825 {
7826 VEC_safe_push (symtab_ptr, *result, symtab);
7827 if (symtab->user == NULL)
7828 symtab->user = immediate_parent;
7829 }
7830 }
7831
7832 for (ix = 0;
7833 VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs, ix, iter);
7834 ++ix)
7835 {
7836 recursively_compute_inclusions (result, all_children,
7837 all_type_symtabs, iter, symtab);
7838 }
7839 }
7840
7841 /* Compute the symtab 'includes' fields for the symtab related to
7842 PER_CU. */
7843
7844 static void
7845 compute_symtab_includes (struct dwarf2_per_cu_data *per_cu)
7846 {
7847 gdb_assert (! per_cu->is_debug_types);
7848
7849 if (!VEC_empty (dwarf2_per_cu_ptr, per_cu->imported_symtabs))
7850 {
7851 int ix, len;
7852 struct dwarf2_per_cu_data *per_cu_iter;
7853 struct symtab *symtab_iter;
7854 VEC (symtab_ptr) *result_symtabs = NULL;
7855 htab_t all_children, all_type_symtabs;
7856 struct symtab *symtab = get_symtab (per_cu);
7857
7858 /* If we don't have a symtab, we can just skip this case. */
7859 if (symtab == NULL)
7860 return;
7861
7862 all_children = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
7863 NULL, xcalloc, xfree);
7864 all_type_symtabs = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
7865 NULL, xcalloc, xfree);
7866
7867 for (ix = 0;
7868 VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs,
7869 ix, per_cu_iter);
7870 ++ix)
7871 {
7872 recursively_compute_inclusions (&result_symtabs, all_children,
7873 all_type_symtabs, per_cu_iter,
7874 symtab);
7875 }
7876
7877 /* Now we have a transitive closure of all the included symtabs. */
7878 len = VEC_length (symtab_ptr, result_symtabs);
7879 symtab->includes
7880 = obstack_alloc (&dwarf2_per_objfile->objfile->objfile_obstack,
7881 (len + 1) * sizeof (struct symtab *));
7882 for (ix = 0;
7883 VEC_iterate (symtab_ptr, result_symtabs, ix, symtab_iter);
7884 ++ix)
7885 symtab->includes[ix] = symtab_iter;
7886 symtab->includes[len] = NULL;
7887
7888 VEC_free (symtab_ptr, result_symtabs);
7889 htab_delete (all_children);
7890 htab_delete (all_type_symtabs);
7891 }
7892 }
7893
7894 /* Compute the 'includes' field for the symtabs of all the CUs we just
7895 read. */
7896
7897 static void
7898 process_cu_includes (void)
7899 {
7900 int ix;
7901 struct dwarf2_per_cu_data *iter;
7902
7903 for (ix = 0;
7904 VEC_iterate (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus,
7905 ix, iter);
7906 ++ix)
7907 {
7908 if (! iter->is_debug_types)
7909 compute_symtab_includes (iter);
7910 }
7911
7912 VEC_free (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus);
7913 }
7914
7915 /* Generate full symbol information for PER_CU, whose DIEs have
7916 already been loaded into memory. */
7917
7918 static void
7919 process_full_comp_unit (struct dwarf2_per_cu_data *per_cu,
7920 enum language pretend_language)
7921 {
7922 struct dwarf2_cu *cu = per_cu->cu;
7923 struct objfile *objfile = per_cu->objfile;
7924 CORE_ADDR lowpc, highpc;
7925 struct symtab *symtab;
7926 struct cleanup *back_to, *delayed_list_cleanup;
7927 CORE_ADDR baseaddr;
7928 struct block *static_block;
7929
7930 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
7931
7932 buildsym_init ();
7933 back_to = make_cleanup (really_free_pendings, NULL);
7934 delayed_list_cleanup = make_cleanup (free_delayed_list, cu);
7935
7936 cu->list_in_scope = &file_symbols;
7937
7938 cu->language = pretend_language;
7939 cu->language_defn = language_def (cu->language);
7940
7941 /* Do line number decoding in read_file_scope () */
7942 process_die (cu->dies, cu);
7943
7944 /* For now fudge the Go package. */
7945 if (cu->language == language_go)
7946 fixup_go_packaging (cu);
7947
7948 /* Now that we have processed all the DIEs in the CU, all the types
7949 should be complete, and it should now be safe to compute all of the
7950 physnames. */
7951 compute_delayed_physnames (cu);
7952 do_cleanups (delayed_list_cleanup);
7953
7954 /* Some compilers don't define a DW_AT_high_pc attribute for the
7955 compilation unit. If the DW_AT_high_pc is missing, synthesize
7956 it, by scanning the DIE's below the compilation unit. */
7957 get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
7958
7959 static_block
7960 = end_symtab_get_static_block (highpc + baseaddr, objfile, 0, 1);
7961
7962 /* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
7963 Also, DW_AT_ranges may record ranges not belonging to any child DIEs
7964 (such as virtual method tables). Record the ranges in STATIC_BLOCK's
7965 addrmap to help ensure it has an accurate map of pc values belonging to
7966 this comp unit. */
7967 dwarf2_record_block_ranges (cu->dies, static_block, baseaddr, cu);
7968
7969 symtab = end_symtab_from_static_block (static_block, objfile,
7970 SECT_OFF_TEXT (objfile), 0);
7971
7972 if (symtab != NULL)
7973 {
7974 int gcc_4_minor = producer_is_gcc_ge_4 (cu->producer);
7975
7976 /* Set symtab language to language from DW_AT_language. If the
7977 compilation is from a C file generated by language preprocessors, do
7978 not set the language if it was already deduced by start_subfile. */
7979 if (!(cu->language == language_c && symtab->language != language_c))
7980 symtab->language = cu->language;
7981
7982 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
7983 produce DW_AT_location with location lists but it can be possibly
7984 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
7985 there were bugs in prologue debug info, fixed later in GCC-4.5
7986 by "unwind info for epilogues" patch (which is not directly related).
7987
7988 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
7989 needed, it would be wrong due to missing DW_AT_producer there.
7990
7991 Still one can confuse GDB by using non-standard GCC compilation
7992 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
7993 */
7994 if (cu->has_loclist && gcc_4_minor >= 5)
7995 symtab->locations_valid = 1;
7996
7997 if (gcc_4_minor >= 5)
7998 symtab->epilogue_unwind_valid = 1;
7999
8000 symtab->call_site_htab = cu->call_site_htab;
8001 }
8002
8003 if (dwarf2_per_objfile->using_index)
8004 per_cu->v.quick->symtab = symtab;
8005 else
8006 {
8007 struct partial_symtab *pst = per_cu->v.psymtab;
8008 pst->symtab = symtab;
8009 pst->readin = 1;
8010 }
8011
8012 /* Push it for inclusion processing later. */
8013 VEC_safe_push (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus, per_cu);
8014
8015 do_cleanups (back_to);
8016 }
8017
8018 /* Generate full symbol information for type unit PER_CU, whose DIEs have
8019 already been loaded into memory. */
8020
8021 static void
8022 process_full_type_unit (struct dwarf2_per_cu_data *per_cu,
8023 enum language pretend_language)
8024 {
8025 struct dwarf2_cu *cu = per_cu->cu;
8026 struct objfile *objfile = per_cu->objfile;
8027 struct symtab *symtab;
8028 struct cleanup *back_to, *delayed_list_cleanup;
8029 struct signatured_type *sig_type;
8030
8031 gdb_assert (per_cu->is_debug_types);
8032 sig_type = (struct signatured_type *) per_cu;
8033
8034 buildsym_init ();
8035 back_to = make_cleanup (really_free_pendings, NULL);
8036 delayed_list_cleanup = make_cleanup (free_delayed_list, cu);
8037
8038 cu->list_in_scope = &file_symbols;
8039
8040 cu->language = pretend_language;
8041 cu->language_defn = language_def (cu->language);
8042
8043 /* The symbol tables are set up in read_type_unit_scope. */
8044 process_die (cu->dies, cu);
8045
8046 /* For now fudge the Go package. */
8047 if (cu->language == language_go)
8048 fixup_go_packaging (cu);
8049
8050 /* Now that we have processed all the DIEs in the CU, all the types
8051 should be complete, and it should now be safe to compute all of the
8052 physnames. */
8053 compute_delayed_physnames (cu);
8054 do_cleanups (delayed_list_cleanup);
8055
8056 /* TUs share symbol tables.
8057 If this is the first TU to use this symtab, complete the construction
8058 of it with end_expandable_symtab. Otherwise, complete the addition of
8059 this TU's symbols to the existing symtab. */
8060 if (sig_type->type_unit_group->primary_symtab == NULL)
8061 {
8062 symtab = end_expandable_symtab (0, objfile, SECT_OFF_TEXT (objfile));
8063 sig_type->type_unit_group->primary_symtab = symtab;
8064
8065 if (symtab != NULL)
8066 {
8067 /* Set symtab language to language from DW_AT_language. If the
8068 compilation is from a C file generated by language preprocessors,
8069 do not set the language if it was already deduced by
8070 start_subfile. */
8071 if (!(cu->language == language_c && symtab->language != language_c))
8072 symtab->language = cu->language;
8073 }
8074 }
8075 else
8076 {
8077 augment_type_symtab (objfile,
8078 sig_type->type_unit_group->primary_symtab);
8079 symtab = sig_type->type_unit_group->primary_symtab;
8080 }
8081
8082 if (dwarf2_per_objfile->using_index)
8083 per_cu->v.quick->symtab = symtab;
8084 else
8085 {
8086 struct partial_symtab *pst = per_cu->v.psymtab;
8087 pst->symtab = symtab;
8088 pst->readin = 1;
8089 }
8090
8091 do_cleanups (back_to);
8092 }
8093
8094 /* Process an imported unit DIE. */
8095
8096 static void
8097 process_imported_unit_die (struct die_info *die, struct dwarf2_cu *cu)
8098 {
8099 struct attribute *attr;
8100
8101 /* For now we don't handle imported units in type units. */
8102 if (cu->per_cu->is_debug_types)
8103 {
8104 error (_("Dwarf Error: DW_TAG_imported_unit is not"
8105 " supported in type units [in module %s]"),
8106 objfile_name (cu->objfile));
8107 }
8108
8109 attr = dwarf2_attr (die, DW_AT_import, cu);
8110 if (attr != NULL)
8111 {
8112 struct dwarf2_per_cu_data *per_cu;
8113 struct symtab *imported_symtab;
8114 sect_offset offset;
8115 int is_dwz;
8116
8117 offset = dwarf2_get_ref_die_offset (attr);
8118 is_dwz = (attr->form == DW_FORM_GNU_ref_alt || cu->per_cu->is_dwz);
8119 per_cu = dwarf2_find_containing_comp_unit (offset, is_dwz, cu->objfile);
8120
8121 /* If necessary, add it to the queue and load its DIEs. */
8122 if (maybe_queue_comp_unit (cu, per_cu, cu->language))
8123 load_full_comp_unit (per_cu, cu->language);
8124
8125 VEC_safe_push (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
8126 per_cu);
8127 }
8128 }
8129
8130 /* Reset the in_process bit of a die. */
8131
8132 static void
8133 reset_die_in_process (void *arg)
8134 {
8135 struct die_info *die = arg;
8136
8137 die->in_process = 0;
8138 }
8139
8140 /* Process a die and its children. */
8141
8142 static void
8143 process_die (struct die_info *die, struct dwarf2_cu *cu)
8144 {
8145 struct cleanup *in_process;
8146
8147 /* We should only be processing those not already in process. */
8148 gdb_assert (!die->in_process);
8149
8150 die->in_process = 1;
8151 in_process = make_cleanup (reset_die_in_process,die);
8152
8153 switch (die->tag)
8154 {
8155 case DW_TAG_padding:
8156 break;
8157 case DW_TAG_compile_unit:
8158 case DW_TAG_partial_unit:
8159 read_file_scope (die, cu);
8160 break;
8161 case DW_TAG_type_unit:
8162 read_type_unit_scope (die, cu);
8163 break;
8164 case DW_TAG_subprogram:
8165 case DW_TAG_inlined_subroutine:
8166 read_func_scope (die, cu);
8167 break;
8168 case DW_TAG_lexical_block:
8169 case DW_TAG_try_block:
8170 case DW_TAG_catch_block:
8171 read_lexical_block_scope (die, cu);
8172 break;
8173 case DW_TAG_GNU_call_site:
8174 read_call_site_scope (die, cu);
8175 break;
8176 case DW_TAG_class_type:
8177 case DW_TAG_interface_type:
8178 case DW_TAG_structure_type:
8179 case DW_TAG_union_type:
8180 process_structure_scope (die, cu);
8181 break;
8182 case DW_TAG_enumeration_type:
8183 process_enumeration_scope (die, cu);
8184 break;
8185
8186 /* These dies have a type, but processing them does not create
8187 a symbol or recurse to process the children. Therefore we can
8188 read them on-demand through read_type_die. */
8189 case DW_TAG_subroutine_type:
8190 case DW_TAG_set_type:
8191 case DW_TAG_array_type:
8192 case DW_TAG_pointer_type:
8193 case DW_TAG_ptr_to_member_type:
8194 case DW_TAG_reference_type:
8195 case DW_TAG_string_type:
8196 break;
8197
8198 case DW_TAG_base_type:
8199 case DW_TAG_subrange_type:
8200 case DW_TAG_typedef:
8201 /* Add a typedef symbol for the type definition, if it has a
8202 DW_AT_name. */
8203 new_symbol (die, read_type_die (die, cu), cu);
8204 break;
8205 case DW_TAG_common_block:
8206 read_common_block (die, cu);
8207 break;
8208 case DW_TAG_common_inclusion:
8209 break;
8210 case DW_TAG_namespace:
8211 cu->processing_has_namespace_info = 1;
8212 read_namespace (die, cu);
8213 break;
8214 case DW_TAG_module:
8215 cu->processing_has_namespace_info = 1;
8216 read_module (die, cu);
8217 break;
8218 case DW_TAG_imported_declaration:
8219 cu->processing_has_namespace_info = 1;
8220 if (read_namespace_alias (die, cu))
8221 break;
8222 /* The declaration is not a global namespace alias: fall through. */
8223 case DW_TAG_imported_module:
8224 cu->processing_has_namespace_info = 1;
8225 if (die->child != NULL && (die->tag == DW_TAG_imported_declaration
8226 || cu->language != language_fortran))
8227 complaint (&symfile_complaints, _("Tag '%s' has unexpected children"),
8228 dwarf_tag_name (die->tag));
8229 read_import_statement (die, cu);
8230 break;
8231
8232 case DW_TAG_imported_unit:
8233 process_imported_unit_die (die, cu);
8234 break;
8235
8236 default:
8237 new_symbol (die, NULL, cu);
8238 break;
8239 }
8240
8241 do_cleanups (in_process);
8242 }
8243 \f
8244 /* DWARF name computation. */
8245
8246 /* A helper function for dwarf2_compute_name which determines whether DIE
8247 needs to have the name of the scope prepended to the name listed in the
8248 die. */
8249
8250 static int
8251 die_needs_namespace (struct die_info *die, struct dwarf2_cu *cu)
8252 {
8253 struct attribute *attr;
8254
8255 switch (die->tag)
8256 {
8257 case DW_TAG_namespace:
8258 case DW_TAG_typedef:
8259 case DW_TAG_class_type:
8260 case DW_TAG_interface_type:
8261 case DW_TAG_structure_type:
8262 case DW_TAG_union_type:
8263 case DW_TAG_enumeration_type:
8264 case DW_TAG_enumerator:
8265 case DW_TAG_subprogram:
8266 case DW_TAG_member:
8267 case DW_TAG_imported_declaration:
8268 return 1;
8269
8270 case DW_TAG_variable:
8271 case DW_TAG_constant:
8272 /* We only need to prefix "globally" visible variables. These include
8273 any variable marked with DW_AT_external or any variable that
8274 lives in a namespace. [Variables in anonymous namespaces
8275 require prefixing, but they are not DW_AT_external.] */
8276
8277 if (dwarf2_attr (die, DW_AT_specification, cu))
8278 {
8279 struct dwarf2_cu *spec_cu = cu;
8280
8281 return die_needs_namespace (die_specification (die, &spec_cu),
8282 spec_cu);
8283 }
8284
8285 attr = dwarf2_attr (die, DW_AT_external, cu);
8286 if (attr == NULL && die->parent->tag != DW_TAG_namespace
8287 && die->parent->tag != DW_TAG_module)
8288 return 0;
8289 /* A variable in a lexical block of some kind does not need a
8290 namespace, even though in C++ such variables may be external
8291 and have a mangled name. */
8292 if (die->parent->tag == DW_TAG_lexical_block
8293 || die->parent->tag == DW_TAG_try_block
8294 || die->parent->tag == DW_TAG_catch_block
8295 || die->parent->tag == DW_TAG_subprogram)
8296 return 0;
8297 return 1;
8298
8299 default:
8300 return 0;
8301 }
8302 }
8303
8304 /* Retrieve the last character from a mem_file. */
8305
8306 static void
8307 do_ui_file_peek_last (void *object, const char *buffer, long length)
8308 {
8309 char *last_char_p = (char *) object;
8310
8311 if (length > 0)
8312 *last_char_p = buffer[length - 1];
8313 }
8314
8315 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
8316 compute the physname for the object, which include a method's:
8317 - formal parameters (C++/Java),
8318 - receiver type (Go),
8319 - return type (Java).
8320
8321 The term "physname" is a bit confusing.
8322 For C++, for example, it is the demangled name.
8323 For Go, for example, it's the mangled name.
8324
8325 For Ada, return the DIE's linkage name rather than the fully qualified
8326 name. PHYSNAME is ignored..
8327
8328 The result is allocated on the objfile_obstack and canonicalized. */
8329
8330 static const char *
8331 dwarf2_compute_name (const char *name,
8332 struct die_info *die, struct dwarf2_cu *cu,
8333 int physname)
8334 {
8335 struct objfile *objfile = cu->objfile;
8336
8337 if (name == NULL)
8338 name = dwarf2_name (die, cu);
8339
8340 /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
8341 compute it by typename_concat inside GDB. */
8342 if (cu->language == language_ada
8343 || (cu->language == language_fortran && physname))
8344 {
8345 /* For Ada unit, we prefer the linkage name over the name, as
8346 the former contains the exported name, which the user expects
8347 to be able to reference. Ideally, we want the user to be able
8348 to reference this entity using either natural or linkage name,
8349 but we haven't started looking at this enhancement yet. */
8350 struct attribute *attr;
8351
8352 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
8353 if (attr == NULL)
8354 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
8355 if (attr && DW_STRING (attr))
8356 return DW_STRING (attr);
8357 }
8358
8359 /* These are the only languages we know how to qualify names in. */
8360 if (name != NULL
8361 && (cu->language == language_cplus || cu->language == language_java
8362 || cu->language == language_fortran))
8363 {
8364 if (die_needs_namespace (die, cu))
8365 {
8366 long length;
8367 const char *prefix;
8368 struct ui_file *buf;
8369 char *intermediate_name;
8370 const char *canonical_name = NULL;
8371
8372 prefix = determine_prefix (die, cu);
8373 buf = mem_fileopen ();
8374 if (*prefix != '\0')
8375 {
8376 char *prefixed_name = typename_concat (NULL, prefix, name,
8377 physname, cu);
8378
8379 fputs_unfiltered (prefixed_name, buf);
8380 xfree (prefixed_name);
8381 }
8382 else
8383 fputs_unfiltered (name, buf);
8384
8385 /* Template parameters may be specified in the DIE's DW_AT_name, or
8386 as children with DW_TAG_template_type_param or
8387 DW_TAG_value_type_param. If the latter, add them to the name
8388 here. If the name already has template parameters, then
8389 skip this step; some versions of GCC emit both, and
8390 it is more efficient to use the pre-computed name.
8391
8392 Something to keep in mind about this process: it is very
8393 unlikely, or in some cases downright impossible, to produce
8394 something that will match the mangled name of a function.
8395 If the definition of the function has the same debug info,
8396 we should be able to match up with it anyway. But fallbacks
8397 using the minimal symbol, for instance to find a method
8398 implemented in a stripped copy of libstdc++, will not work.
8399 If we do not have debug info for the definition, we will have to
8400 match them up some other way.
8401
8402 When we do name matching there is a related problem with function
8403 templates; two instantiated function templates are allowed to
8404 differ only by their return types, which we do not add here. */
8405
8406 if (cu->language == language_cplus && strchr (name, '<') == NULL)
8407 {
8408 struct attribute *attr;
8409 struct die_info *child;
8410 int first = 1;
8411
8412 die->building_fullname = 1;
8413
8414 for (child = die->child; child != NULL; child = child->sibling)
8415 {
8416 struct type *type;
8417 LONGEST value;
8418 const gdb_byte *bytes;
8419 struct dwarf2_locexpr_baton *baton;
8420 struct value *v;
8421
8422 if (child->tag != DW_TAG_template_type_param
8423 && child->tag != DW_TAG_template_value_param)
8424 continue;
8425
8426 if (first)
8427 {
8428 fputs_unfiltered ("<", buf);
8429 first = 0;
8430 }
8431 else
8432 fputs_unfiltered (", ", buf);
8433
8434 attr = dwarf2_attr (child, DW_AT_type, cu);
8435 if (attr == NULL)
8436 {
8437 complaint (&symfile_complaints,
8438 _("template parameter missing DW_AT_type"));
8439 fputs_unfiltered ("UNKNOWN_TYPE", buf);
8440 continue;
8441 }
8442 type = die_type (child, cu);
8443
8444 if (child->tag == DW_TAG_template_type_param)
8445 {
8446 c_print_type (type, "", buf, -1, 0, &type_print_raw_options);
8447 continue;
8448 }
8449
8450 attr = dwarf2_attr (child, DW_AT_const_value, cu);
8451 if (attr == NULL)
8452 {
8453 complaint (&symfile_complaints,
8454 _("template parameter missing "
8455 "DW_AT_const_value"));
8456 fputs_unfiltered ("UNKNOWN_VALUE", buf);
8457 continue;
8458 }
8459
8460 dwarf2_const_value_attr (attr, type, name,
8461 &cu->comp_unit_obstack, cu,
8462 &value, &bytes, &baton);
8463
8464 if (TYPE_NOSIGN (type))
8465 /* GDB prints characters as NUMBER 'CHAR'. If that's
8466 changed, this can use value_print instead. */
8467 c_printchar (value, type, buf);
8468 else
8469 {
8470 struct value_print_options opts;
8471
8472 if (baton != NULL)
8473 v = dwarf2_evaluate_loc_desc (type, NULL,
8474 baton->data,
8475 baton->size,
8476 baton->per_cu);
8477 else if (bytes != NULL)
8478 {
8479 v = allocate_value (type);
8480 memcpy (value_contents_writeable (v), bytes,
8481 TYPE_LENGTH (type));
8482 }
8483 else
8484 v = value_from_longest (type, value);
8485
8486 /* Specify decimal so that we do not depend on
8487 the radix. */
8488 get_formatted_print_options (&opts, 'd');
8489 opts.raw = 1;
8490 value_print (v, buf, &opts);
8491 release_value (v);
8492 value_free (v);
8493 }
8494 }
8495
8496 die->building_fullname = 0;
8497
8498 if (!first)
8499 {
8500 /* Close the argument list, with a space if necessary
8501 (nested templates). */
8502 char last_char = '\0';
8503 ui_file_put (buf, do_ui_file_peek_last, &last_char);
8504 if (last_char == '>')
8505 fputs_unfiltered (" >", buf);
8506 else
8507 fputs_unfiltered (">", buf);
8508 }
8509 }
8510
8511 /* For Java and C++ methods, append formal parameter type
8512 information, if PHYSNAME. */
8513
8514 if (physname && die->tag == DW_TAG_subprogram
8515 && (cu->language == language_cplus
8516 || cu->language == language_java))
8517 {
8518 struct type *type = read_type_die (die, cu);
8519
8520 c_type_print_args (type, buf, 1, cu->language,
8521 &type_print_raw_options);
8522
8523 if (cu->language == language_java)
8524 {
8525 /* For java, we must append the return type to method
8526 names. */
8527 if (die->tag == DW_TAG_subprogram)
8528 java_print_type (TYPE_TARGET_TYPE (type), "", buf,
8529 0, 0, &type_print_raw_options);
8530 }
8531 else if (cu->language == language_cplus)
8532 {
8533 /* Assume that an artificial first parameter is
8534 "this", but do not crash if it is not. RealView
8535 marks unnamed (and thus unused) parameters as
8536 artificial; there is no way to differentiate
8537 the two cases. */
8538 if (TYPE_NFIELDS (type) > 0
8539 && TYPE_FIELD_ARTIFICIAL (type, 0)
8540 && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_PTR
8541 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type,
8542 0))))
8543 fputs_unfiltered (" const", buf);
8544 }
8545 }
8546
8547 intermediate_name = ui_file_xstrdup (buf, &length);
8548 ui_file_delete (buf);
8549
8550 if (cu->language == language_cplus)
8551 canonical_name
8552 = dwarf2_canonicalize_name (intermediate_name, cu,
8553 &objfile->per_bfd->storage_obstack);
8554
8555 /* If we only computed INTERMEDIATE_NAME, or if
8556 INTERMEDIATE_NAME is already canonical, then we need to
8557 copy it to the appropriate obstack. */
8558 if (canonical_name == NULL || canonical_name == intermediate_name)
8559 name = obstack_copy0 (&objfile->per_bfd->storage_obstack,
8560 intermediate_name,
8561 strlen (intermediate_name));
8562 else
8563 name = canonical_name;
8564
8565 xfree (intermediate_name);
8566 }
8567 }
8568
8569 return name;
8570 }
8571
8572 /* Return the fully qualified name of DIE, based on its DW_AT_name.
8573 If scope qualifiers are appropriate they will be added. The result
8574 will be allocated on the storage_obstack, or NULL if the DIE does
8575 not have a name. NAME may either be from a previous call to
8576 dwarf2_name or NULL.
8577
8578 The output string will be canonicalized (if C++/Java). */
8579
8580 static const char *
8581 dwarf2_full_name (const char *name, struct die_info *die, struct dwarf2_cu *cu)
8582 {
8583 return dwarf2_compute_name (name, die, cu, 0);
8584 }
8585
8586 /* Construct a physname for the given DIE in CU. NAME may either be
8587 from a previous call to dwarf2_name or NULL. The result will be
8588 allocated on the objfile_objstack or NULL if the DIE does not have a
8589 name.
8590
8591 The output string will be canonicalized (if C++/Java). */
8592
8593 static const char *
8594 dwarf2_physname (const char *name, struct die_info *die, struct dwarf2_cu *cu)
8595 {
8596 struct objfile *objfile = cu->objfile;
8597 struct attribute *attr;
8598 const char *retval, *mangled = NULL, *canon = NULL;
8599 struct cleanup *back_to;
8600 int need_copy = 1;
8601
8602 /* In this case dwarf2_compute_name is just a shortcut not building anything
8603 on its own. */
8604 if (!die_needs_namespace (die, cu))
8605 return dwarf2_compute_name (name, die, cu, 1);
8606
8607 back_to = make_cleanup (null_cleanup, NULL);
8608
8609 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
8610 if (!attr)
8611 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
8612
8613 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
8614 has computed. */
8615 if (attr && DW_STRING (attr))
8616 {
8617 char *demangled;
8618
8619 mangled = DW_STRING (attr);
8620
8621 /* Use DMGL_RET_DROP for C++ template functions to suppress their return
8622 type. It is easier for GDB users to search for such functions as
8623 `name(params)' than `long name(params)'. In such case the minimal
8624 symbol names do not match the full symbol names but for template
8625 functions there is never a need to look up their definition from their
8626 declaration so the only disadvantage remains the minimal symbol
8627 variant `long name(params)' does not have the proper inferior type.
8628 */
8629
8630 if (cu->language == language_go)
8631 {
8632 /* This is a lie, but we already lie to the caller new_symbol_full.
8633 new_symbol_full assumes we return the mangled name.
8634 This just undoes that lie until things are cleaned up. */
8635 demangled = NULL;
8636 }
8637 else
8638 {
8639 demangled = gdb_demangle (mangled,
8640 (DMGL_PARAMS | DMGL_ANSI
8641 | (cu->language == language_java
8642 ? DMGL_JAVA | DMGL_RET_POSTFIX
8643 : DMGL_RET_DROP)));
8644 }
8645 if (demangled)
8646 {
8647 make_cleanup (xfree, demangled);
8648 canon = demangled;
8649 }
8650 else
8651 {
8652 canon = mangled;
8653 need_copy = 0;
8654 }
8655 }
8656
8657 if (canon == NULL || check_physname)
8658 {
8659 const char *physname = dwarf2_compute_name (name, die, cu, 1);
8660
8661 if (canon != NULL && strcmp (physname, canon) != 0)
8662 {
8663 /* It may not mean a bug in GDB. The compiler could also
8664 compute DW_AT_linkage_name incorrectly. But in such case
8665 GDB would need to be bug-to-bug compatible. */
8666
8667 complaint (&symfile_complaints,
8668 _("Computed physname <%s> does not match demangled <%s> "
8669 "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
8670 physname, canon, mangled, die->offset.sect_off,
8671 objfile_name (objfile));
8672
8673 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
8674 is available here - over computed PHYSNAME. It is safer
8675 against both buggy GDB and buggy compilers. */
8676
8677 retval = canon;
8678 }
8679 else
8680 {
8681 retval = physname;
8682 need_copy = 0;
8683 }
8684 }
8685 else
8686 retval = canon;
8687
8688 if (need_copy)
8689 retval = obstack_copy0 (&objfile->per_bfd->storage_obstack,
8690 retval, strlen (retval));
8691
8692 do_cleanups (back_to);
8693 return retval;
8694 }
8695
8696 /* Inspect DIE in CU for a namespace alias. If one exists, record
8697 a new symbol for it.
8698
8699 Returns 1 if a namespace alias was recorded, 0 otherwise. */
8700
8701 static int
8702 read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu)
8703 {
8704 struct attribute *attr;
8705
8706 /* If the die does not have a name, this is not a namespace
8707 alias. */
8708 attr = dwarf2_attr (die, DW_AT_name, cu);
8709 if (attr != NULL)
8710 {
8711 int num;
8712 struct die_info *d = die;
8713 struct dwarf2_cu *imported_cu = cu;
8714
8715 /* If the compiler has nested DW_AT_imported_declaration DIEs,
8716 keep inspecting DIEs until we hit the underlying import. */
8717 #define MAX_NESTED_IMPORTED_DECLARATIONS 100
8718 for (num = 0; num < MAX_NESTED_IMPORTED_DECLARATIONS; ++num)
8719 {
8720 attr = dwarf2_attr (d, DW_AT_import, cu);
8721 if (attr == NULL)
8722 break;
8723
8724 d = follow_die_ref (d, attr, &imported_cu);
8725 if (d->tag != DW_TAG_imported_declaration)
8726 break;
8727 }
8728
8729 if (num == MAX_NESTED_IMPORTED_DECLARATIONS)
8730 {
8731 complaint (&symfile_complaints,
8732 _("DIE at 0x%x has too many recursively imported "
8733 "declarations"), d->offset.sect_off);
8734 return 0;
8735 }
8736
8737 if (attr != NULL)
8738 {
8739 struct type *type;
8740 sect_offset offset = dwarf2_get_ref_die_offset (attr);
8741
8742 type = get_die_type_at_offset (offset, cu->per_cu);
8743 if (type != NULL && TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
8744 {
8745 /* This declaration is a global namespace alias. Add
8746 a symbol for it whose type is the aliased namespace. */
8747 new_symbol (die, type, cu);
8748 return 1;
8749 }
8750 }
8751 }
8752
8753 return 0;
8754 }
8755
8756 /* Read the import statement specified by the given die and record it. */
8757
8758 static void
8759 read_import_statement (struct die_info *die, struct dwarf2_cu *cu)
8760 {
8761 struct objfile *objfile = cu->objfile;
8762 struct attribute *import_attr;
8763 struct die_info *imported_die, *child_die;
8764 struct dwarf2_cu *imported_cu;
8765 const char *imported_name;
8766 const char *imported_name_prefix;
8767 const char *canonical_name;
8768 const char *import_alias;
8769 const char *imported_declaration = NULL;
8770 const char *import_prefix;
8771 VEC (const_char_ptr) *excludes = NULL;
8772 struct cleanup *cleanups;
8773
8774 import_attr = dwarf2_attr (die, DW_AT_import, cu);
8775 if (import_attr == NULL)
8776 {
8777 complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
8778 dwarf_tag_name (die->tag));
8779 return;
8780 }
8781
8782 imported_cu = cu;
8783 imported_die = follow_die_ref_or_sig (die, import_attr, &imported_cu);
8784 imported_name = dwarf2_name (imported_die, imported_cu);
8785 if (imported_name == NULL)
8786 {
8787 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
8788
8789 The import in the following code:
8790 namespace A
8791 {
8792 typedef int B;
8793 }
8794
8795 int main ()
8796 {
8797 using A::B;
8798 B b;
8799 return b;
8800 }
8801
8802 ...
8803 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
8804 <52> DW_AT_decl_file : 1
8805 <53> DW_AT_decl_line : 6
8806 <54> DW_AT_import : <0x75>
8807 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
8808 <59> DW_AT_name : B
8809 <5b> DW_AT_decl_file : 1
8810 <5c> DW_AT_decl_line : 2
8811 <5d> DW_AT_type : <0x6e>
8812 ...
8813 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
8814 <76> DW_AT_byte_size : 4
8815 <77> DW_AT_encoding : 5 (signed)
8816
8817 imports the wrong die ( 0x75 instead of 0x58 ).
8818 This case will be ignored until the gcc bug is fixed. */
8819 return;
8820 }
8821
8822 /* Figure out the local name after import. */
8823 import_alias = dwarf2_name (die, cu);
8824
8825 /* Figure out where the statement is being imported to. */
8826 import_prefix = determine_prefix (die, cu);
8827
8828 /* Figure out what the scope of the imported die is and prepend it
8829 to the name of the imported die. */
8830 imported_name_prefix = determine_prefix (imported_die, imported_cu);
8831
8832 if (imported_die->tag != DW_TAG_namespace
8833 && imported_die->tag != DW_TAG_module)
8834 {
8835 imported_declaration = imported_name;
8836 canonical_name = imported_name_prefix;
8837 }
8838 else if (strlen (imported_name_prefix) > 0)
8839 canonical_name = obconcat (&objfile->objfile_obstack,
8840 imported_name_prefix, "::", imported_name,
8841 (char *) NULL);
8842 else
8843 canonical_name = imported_name;
8844
8845 cleanups = make_cleanup (VEC_cleanup (const_char_ptr), &excludes);
8846
8847 if (die->tag == DW_TAG_imported_module && cu->language == language_fortran)
8848 for (child_die = die->child; child_die && child_die->tag;
8849 child_die = sibling_die (child_die))
8850 {
8851 /* DWARF-4: A Fortran use statement with a “rename list” may be
8852 represented by an imported module entry with an import attribute
8853 referring to the module and owned entries corresponding to those
8854 entities that are renamed as part of being imported. */
8855
8856 if (child_die->tag != DW_TAG_imported_declaration)
8857 {
8858 complaint (&symfile_complaints,
8859 _("child DW_TAG_imported_declaration expected "
8860 "- DIE at 0x%x [in module %s]"),
8861 child_die->offset.sect_off, objfile_name (objfile));
8862 continue;
8863 }
8864
8865 import_attr = dwarf2_attr (child_die, DW_AT_import, cu);
8866 if (import_attr == NULL)
8867 {
8868 complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
8869 dwarf_tag_name (child_die->tag));
8870 continue;
8871 }
8872
8873 imported_cu = cu;
8874 imported_die = follow_die_ref_or_sig (child_die, import_attr,
8875 &imported_cu);
8876 imported_name = dwarf2_name (imported_die, imported_cu);
8877 if (imported_name == NULL)
8878 {
8879 complaint (&symfile_complaints,
8880 _("child DW_TAG_imported_declaration has unknown "
8881 "imported name - DIE at 0x%x [in module %s]"),
8882 child_die->offset.sect_off, objfile_name (objfile));
8883 continue;
8884 }
8885
8886 VEC_safe_push (const_char_ptr, excludes, imported_name);
8887
8888 process_die (child_die, cu);
8889 }
8890
8891 cp_add_using_directive (import_prefix,
8892 canonical_name,
8893 import_alias,
8894 imported_declaration,
8895 excludes,
8896 0,
8897 &objfile->objfile_obstack);
8898
8899 do_cleanups (cleanups);
8900 }
8901
8902 /* Cleanup function for handle_DW_AT_stmt_list. */
8903
8904 static void
8905 free_cu_line_header (void *arg)
8906 {
8907 struct dwarf2_cu *cu = arg;
8908
8909 free_line_header (cu->line_header);
8910 cu->line_header = NULL;
8911 }
8912
8913 /* Check for possibly missing DW_AT_comp_dir with relative .debug_line
8914 directory paths. GCC SVN r127613 (new option -fdebug-prefix-map) fixed
8915 this, it was first present in GCC release 4.3.0. */
8916
8917 static int
8918 producer_is_gcc_lt_4_3 (struct dwarf2_cu *cu)
8919 {
8920 if (!cu->checked_producer)
8921 check_producer (cu);
8922
8923 return cu->producer_is_gcc_lt_4_3;
8924 }
8925
8926 static void
8927 find_file_and_directory (struct die_info *die, struct dwarf2_cu *cu,
8928 const char **name, const char **comp_dir)
8929 {
8930 struct attribute *attr;
8931
8932 *name = NULL;
8933 *comp_dir = NULL;
8934
8935 /* Find the filename. Do not use dwarf2_name here, since the filename
8936 is not a source language identifier. */
8937 attr = dwarf2_attr (die, DW_AT_name, cu);
8938 if (attr)
8939 {
8940 *name = DW_STRING (attr);
8941 }
8942
8943 attr = dwarf2_attr (die, DW_AT_comp_dir, cu);
8944 if (attr)
8945 *comp_dir = DW_STRING (attr);
8946 else if (producer_is_gcc_lt_4_3 (cu) && *name != NULL
8947 && IS_ABSOLUTE_PATH (*name))
8948 {
8949 char *d = ldirname (*name);
8950
8951 *comp_dir = d;
8952 if (d != NULL)
8953 make_cleanup (xfree, d);
8954 }
8955 if (*comp_dir != NULL)
8956 {
8957 /* Irix 6.2 native cc prepends <machine>.: to the compilation
8958 directory, get rid of it. */
8959 char *cp = strchr (*comp_dir, ':');
8960
8961 if (cp && cp != *comp_dir && cp[-1] == '.' && cp[1] == '/')
8962 *comp_dir = cp + 1;
8963 }
8964
8965 if (*name == NULL)
8966 *name = "<unknown>";
8967 }
8968
8969 /* Handle DW_AT_stmt_list for a compilation unit.
8970 DIE is the DW_TAG_compile_unit die for CU.
8971 COMP_DIR is the compilation directory.
8972 WANT_LINE_INFO is non-zero if the pc/line-number mapping is needed. */
8973
8974 static void
8975 handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
8976 const char *comp_dir) /* ARI: editCase function */
8977 {
8978 struct attribute *attr;
8979
8980 gdb_assert (! cu->per_cu->is_debug_types);
8981
8982 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
8983 if (attr)
8984 {
8985 unsigned int line_offset = DW_UNSND (attr);
8986 struct line_header *line_header
8987 = dwarf_decode_line_header (line_offset, cu);
8988
8989 if (line_header)
8990 {
8991 cu->line_header = line_header;
8992 make_cleanup (free_cu_line_header, cu);
8993 dwarf_decode_lines (line_header, comp_dir, cu, NULL, 1);
8994 }
8995 }
8996 }
8997
8998 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
8999
9000 static void
9001 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
9002 {
9003 struct objfile *objfile = dwarf2_per_objfile->objfile;
9004 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
9005 CORE_ADDR lowpc = ((CORE_ADDR) -1);
9006 CORE_ADDR highpc = ((CORE_ADDR) 0);
9007 struct attribute *attr;
9008 const char *name = NULL;
9009 const char *comp_dir = NULL;
9010 struct die_info *child_die;
9011 bfd *abfd = objfile->obfd;
9012 CORE_ADDR baseaddr;
9013
9014 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
9015
9016 get_scope_pc_bounds (die, &lowpc, &highpc, cu);
9017
9018 /* If we didn't find a lowpc, set it to highpc to avoid complaints
9019 from finish_block. */
9020 if (lowpc == ((CORE_ADDR) -1))
9021 lowpc = highpc;
9022 lowpc += baseaddr;
9023 highpc += baseaddr;
9024
9025 find_file_and_directory (die, cu, &name, &comp_dir);
9026
9027 prepare_one_comp_unit (cu, die, cu->language);
9028
9029 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
9030 standardised yet. As a workaround for the language detection we fall
9031 back to the DW_AT_producer string. */
9032 if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL") != NULL)
9033 cu->language = language_opencl;
9034
9035 /* Similar hack for Go. */
9036 if (cu->producer && strstr (cu->producer, "GNU Go ") != NULL)
9037 set_cu_language (DW_LANG_Go, cu);
9038
9039 dwarf2_start_symtab (cu, name, comp_dir, lowpc);
9040
9041 /* Decode line number information if present. We do this before
9042 processing child DIEs, so that the line header table is available
9043 for DW_AT_decl_file. */
9044 handle_DW_AT_stmt_list (die, cu, comp_dir);
9045
9046 /* Process all dies in compilation unit. */
9047 if (die->child != NULL)
9048 {
9049 child_die = die->child;
9050 while (child_die && child_die->tag)
9051 {
9052 process_die (child_die, cu);
9053 child_die = sibling_die (child_die);
9054 }
9055 }
9056
9057 /* Decode macro information, if present. Dwarf 2 macro information
9058 refers to information in the line number info statement program
9059 header, so we can only read it if we've read the header
9060 successfully. */
9061 attr = dwarf2_attr (die, DW_AT_GNU_macros, cu);
9062 if (attr && cu->line_header)
9063 {
9064 if (dwarf2_attr (die, DW_AT_macro_info, cu))
9065 complaint (&symfile_complaints,
9066 _("CU refers to both DW_AT_GNU_macros and DW_AT_macro_info"));
9067
9068 dwarf_decode_macros (cu, DW_UNSND (attr), comp_dir, 1);
9069 }
9070 else
9071 {
9072 attr = dwarf2_attr (die, DW_AT_macro_info, cu);
9073 if (attr && cu->line_header)
9074 {
9075 unsigned int macro_offset = DW_UNSND (attr);
9076
9077 dwarf_decode_macros (cu, macro_offset, comp_dir, 0);
9078 }
9079 }
9080
9081 do_cleanups (back_to);
9082 }
9083
9084 /* TU version of handle_DW_AT_stmt_list for read_type_unit_scope.
9085 Create the set of symtabs used by this TU, or if this TU is sharing
9086 symtabs with another TU and the symtabs have already been created
9087 then restore those symtabs in the line header.
9088 We don't need the pc/line-number mapping for type units. */
9089
9090 static void
9091 setup_type_unit_groups (struct die_info *die, struct dwarf2_cu *cu)
9092 {
9093 struct objfile *objfile = dwarf2_per_objfile->objfile;
9094 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
9095 struct type_unit_group *tu_group;
9096 int first_time;
9097 struct line_header *lh;
9098 struct attribute *attr;
9099 unsigned int i, line_offset;
9100 struct signatured_type *sig_type;
9101
9102 gdb_assert (per_cu->is_debug_types);
9103 sig_type = (struct signatured_type *) per_cu;
9104
9105 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
9106
9107 /* If we're using .gdb_index (includes -readnow) then
9108 per_cu->type_unit_group may not have been set up yet. */
9109 if (sig_type->type_unit_group == NULL)
9110 sig_type->type_unit_group = get_type_unit_group (cu, attr);
9111 tu_group = sig_type->type_unit_group;
9112
9113 /* If we've already processed this stmt_list there's no real need to
9114 do it again, we could fake it and just recreate the part we need
9115 (file name,index -> symtab mapping). If data shows this optimization
9116 is useful we can do it then. */
9117 first_time = tu_group->primary_symtab == NULL;
9118
9119 /* We have to handle the case of both a missing DW_AT_stmt_list or bad
9120 debug info. */
9121 lh = NULL;
9122 if (attr != NULL)
9123 {
9124 line_offset = DW_UNSND (attr);
9125 lh = dwarf_decode_line_header (line_offset, cu);
9126 }
9127 if (lh == NULL)
9128 {
9129 if (first_time)
9130 dwarf2_start_symtab (cu, "", NULL, 0);
9131 else
9132 {
9133 gdb_assert (tu_group->symtabs == NULL);
9134 restart_symtab (0);
9135 }
9136 /* Note: The primary symtab will get allocated at the end. */
9137 return;
9138 }
9139
9140 cu->line_header = lh;
9141 make_cleanup (free_cu_line_header, cu);
9142
9143 if (first_time)
9144 {
9145 dwarf2_start_symtab (cu, "", NULL, 0);
9146
9147 tu_group->num_symtabs = lh->num_file_names;
9148 tu_group->symtabs = XNEWVEC (struct symtab *, lh->num_file_names);
9149
9150 for (i = 0; i < lh->num_file_names; ++i)
9151 {
9152 const char *dir = NULL;
9153 struct file_entry *fe = &lh->file_names[i];
9154
9155 if (fe->dir_index)
9156 dir = lh->include_dirs[fe->dir_index - 1];
9157 dwarf2_start_subfile (fe->name, dir, NULL);
9158
9159 /* Note: We don't have to watch for the main subfile here, type units
9160 don't have DW_AT_name. */
9161
9162 if (current_subfile->symtab == NULL)
9163 {
9164 /* NOTE: start_subfile will recognize when it's been passed
9165 a file it has already seen. So we can't assume there's a
9166 simple mapping from lh->file_names to subfiles,
9167 lh->file_names may contain dups. */
9168 current_subfile->symtab = allocate_symtab (current_subfile->name,
9169 objfile);
9170 }
9171
9172 fe->symtab = current_subfile->symtab;
9173 tu_group->symtabs[i] = fe->symtab;
9174 }
9175 }
9176 else
9177 {
9178 restart_symtab (0);
9179
9180 for (i = 0; i < lh->num_file_names; ++i)
9181 {
9182 struct file_entry *fe = &lh->file_names[i];
9183
9184 fe->symtab = tu_group->symtabs[i];
9185 }
9186 }
9187
9188 /* The main symtab is allocated last. Type units don't have DW_AT_name
9189 so they don't have a "real" (so to speak) symtab anyway.
9190 There is later code that will assign the main symtab to all symbols
9191 that don't have one. We need to handle the case of a symbol with a
9192 missing symtab (DW_AT_decl_file) anyway. */
9193 }
9194
9195 /* Process DW_TAG_type_unit.
9196 For TUs we want to skip the first top level sibling if it's not the
9197 actual type being defined by this TU. In this case the first top
9198 level sibling is there to provide context only. */
9199
9200 static void
9201 read_type_unit_scope (struct die_info *die, struct dwarf2_cu *cu)
9202 {
9203 struct die_info *child_die;
9204
9205 prepare_one_comp_unit (cu, die, language_minimal);
9206
9207 /* Initialize (or reinitialize) the machinery for building symtabs.
9208 We do this before processing child DIEs, so that the line header table
9209 is available for DW_AT_decl_file. */
9210 setup_type_unit_groups (die, cu);
9211
9212 if (die->child != NULL)
9213 {
9214 child_die = die->child;
9215 while (child_die && child_die->tag)
9216 {
9217 process_die (child_die, cu);
9218 child_die = sibling_die (child_die);
9219 }
9220 }
9221 }
9222 \f
9223 /* DWO/DWP files.
9224
9225 http://gcc.gnu.org/wiki/DebugFission
9226 http://gcc.gnu.org/wiki/DebugFissionDWP
9227
9228 To simplify handling of both DWO files ("object" files with the DWARF info)
9229 and DWP files (a file with the DWOs packaged up into one file), we treat
9230 DWP files as having a collection of virtual DWO files. */
9231
9232 static hashval_t
9233 hash_dwo_file (const void *item)
9234 {
9235 const struct dwo_file *dwo_file = item;
9236 hashval_t hash;
9237
9238 hash = htab_hash_string (dwo_file->dwo_name);
9239 if (dwo_file->comp_dir != NULL)
9240 hash += htab_hash_string (dwo_file->comp_dir);
9241 return hash;
9242 }
9243
9244 static int
9245 eq_dwo_file (const void *item_lhs, const void *item_rhs)
9246 {
9247 const struct dwo_file *lhs = item_lhs;
9248 const struct dwo_file *rhs = item_rhs;
9249
9250 if (strcmp (lhs->dwo_name, rhs->dwo_name) != 0)
9251 return 0;
9252 if (lhs->comp_dir == NULL || rhs->comp_dir == NULL)
9253 return lhs->comp_dir == rhs->comp_dir;
9254 return strcmp (lhs->comp_dir, rhs->comp_dir) == 0;
9255 }
9256
9257 /* Allocate a hash table for DWO files. */
9258
9259 static htab_t
9260 allocate_dwo_file_hash_table (void)
9261 {
9262 struct objfile *objfile = dwarf2_per_objfile->objfile;
9263
9264 return htab_create_alloc_ex (41,
9265 hash_dwo_file,
9266 eq_dwo_file,
9267 NULL,
9268 &objfile->objfile_obstack,
9269 hashtab_obstack_allocate,
9270 dummy_obstack_deallocate);
9271 }
9272
9273 /* Lookup DWO file DWO_NAME. */
9274
9275 static void **
9276 lookup_dwo_file_slot (const char *dwo_name, const char *comp_dir)
9277 {
9278 struct dwo_file find_entry;
9279 void **slot;
9280
9281 if (dwarf2_per_objfile->dwo_files == NULL)
9282 dwarf2_per_objfile->dwo_files = allocate_dwo_file_hash_table ();
9283
9284 memset (&find_entry, 0, sizeof (find_entry));
9285 find_entry.dwo_name = dwo_name;
9286 find_entry.comp_dir = comp_dir;
9287 slot = htab_find_slot (dwarf2_per_objfile->dwo_files, &find_entry, INSERT);
9288
9289 return slot;
9290 }
9291
9292 static hashval_t
9293 hash_dwo_unit (const void *item)
9294 {
9295 const struct dwo_unit *dwo_unit = item;
9296
9297 /* This drops the top 32 bits of the id, but is ok for a hash. */
9298 return dwo_unit->signature;
9299 }
9300
9301 static int
9302 eq_dwo_unit (const void *item_lhs, const void *item_rhs)
9303 {
9304 const struct dwo_unit *lhs = item_lhs;
9305 const struct dwo_unit *rhs = item_rhs;
9306
9307 /* The signature is assumed to be unique within the DWO file.
9308 So while object file CU dwo_id's always have the value zero,
9309 that's OK, assuming each object file DWO file has only one CU,
9310 and that's the rule for now. */
9311 return lhs->signature == rhs->signature;
9312 }
9313
9314 /* Allocate a hash table for DWO CUs,TUs.
9315 There is one of these tables for each of CUs,TUs for each DWO file. */
9316
9317 static htab_t
9318 allocate_dwo_unit_table (struct objfile *objfile)
9319 {
9320 /* Start out with a pretty small number.
9321 Generally DWO files contain only one CU and maybe some TUs. */
9322 return htab_create_alloc_ex (3,
9323 hash_dwo_unit,
9324 eq_dwo_unit,
9325 NULL,
9326 &objfile->objfile_obstack,
9327 hashtab_obstack_allocate,
9328 dummy_obstack_deallocate);
9329 }
9330
9331 /* Structure used to pass data to create_dwo_debug_info_hash_table_reader. */
9332
9333 struct create_dwo_cu_data
9334 {
9335 struct dwo_file *dwo_file;
9336 struct dwo_unit dwo_unit;
9337 };
9338
9339 /* die_reader_func for create_dwo_cu. */
9340
9341 static void
9342 create_dwo_cu_reader (const struct die_reader_specs *reader,
9343 const gdb_byte *info_ptr,
9344 struct die_info *comp_unit_die,
9345 int has_children,
9346 void *datap)
9347 {
9348 struct dwarf2_cu *cu = reader->cu;
9349 struct objfile *objfile = dwarf2_per_objfile->objfile;
9350 sect_offset offset = cu->per_cu->offset;
9351 struct dwarf2_section_info *section = cu->per_cu->section;
9352 struct create_dwo_cu_data *data = datap;
9353 struct dwo_file *dwo_file = data->dwo_file;
9354 struct dwo_unit *dwo_unit = &data->dwo_unit;
9355 struct attribute *attr;
9356
9357 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
9358 if (attr == NULL)
9359 {
9360 complaint (&symfile_complaints,
9361 _("Dwarf Error: debug entry at offset 0x%x is missing"
9362 " its dwo_id [in module %s]"),
9363 offset.sect_off, dwo_file->dwo_name);
9364 return;
9365 }
9366
9367 dwo_unit->dwo_file = dwo_file;
9368 dwo_unit->signature = DW_UNSND (attr);
9369 dwo_unit->section = section;
9370 dwo_unit->offset = offset;
9371 dwo_unit->length = cu->per_cu->length;
9372
9373 if (dwarf2_read_debug)
9374 fprintf_unfiltered (gdb_stdlog, " offset 0x%x, dwo_id %s\n",
9375 offset.sect_off, hex_string (dwo_unit->signature));
9376 }
9377
9378 /* Create the dwo_unit for the lone CU in DWO_FILE.
9379 Note: This function processes DWO files only, not DWP files. */
9380
9381 static struct dwo_unit *
9382 create_dwo_cu (struct dwo_file *dwo_file)
9383 {
9384 struct objfile *objfile = dwarf2_per_objfile->objfile;
9385 struct dwarf2_section_info *section = &dwo_file->sections.info;
9386 bfd *abfd;
9387 htab_t cu_htab;
9388 const gdb_byte *info_ptr, *end_ptr;
9389 struct create_dwo_cu_data create_dwo_cu_data;
9390 struct dwo_unit *dwo_unit;
9391
9392 dwarf2_read_section (objfile, section);
9393 info_ptr = section->buffer;
9394
9395 if (info_ptr == NULL)
9396 return NULL;
9397
9398 /* We can't set abfd until now because the section may be empty or
9399 not present, in which case section->asection will be NULL. */
9400 abfd = get_section_bfd_owner (section);
9401
9402 if (dwarf2_read_debug)
9403 {
9404 fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
9405 get_section_name (section),
9406 get_section_file_name (section));
9407 }
9408
9409 create_dwo_cu_data.dwo_file = dwo_file;
9410 dwo_unit = NULL;
9411
9412 end_ptr = info_ptr + section->size;
9413 while (info_ptr < end_ptr)
9414 {
9415 struct dwarf2_per_cu_data per_cu;
9416
9417 memset (&create_dwo_cu_data.dwo_unit, 0,
9418 sizeof (create_dwo_cu_data.dwo_unit));
9419 memset (&per_cu, 0, sizeof (per_cu));
9420 per_cu.objfile = objfile;
9421 per_cu.is_debug_types = 0;
9422 per_cu.offset.sect_off = info_ptr - section->buffer;
9423 per_cu.section = section;
9424
9425 init_cutu_and_read_dies_no_follow (&per_cu, dwo_file,
9426 create_dwo_cu_reader,
9427 &create_dwo_cu_data);
9428
9429 if (create_dwo_cu_data.dwo_unit.dwo_file != NULL)
9430 {
9431 /* If we've already found one, complain. We only support one
9432 because having more than one requires hacking the dwo_name of
9433 each to match, which is highly unlikely to happen. */
9434 if (dwo_unit != NULL)
9435 {
9436 complaint (&symfile_complaints,
9437 _("Multiple CUs in DWO file %s [in module %s]"),
9438 dwo_file->dwo_name, objfile_name (objfile));
9439 break;
9440 }
9441
9442 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
9443 *dwo_unit = create_dwo_cu_data.dwo_unit;
9444 }
9445
9446 info_ptr += per_cu.length;
9447 }
9448
9449 return dwo_unit;
9450 }
9451
9452 /* DWP file .debug_{cu,tu}_index section format:
9453 [ref: http://gcc.gnu.org/wiki/DebugFissionDWP]
9454
9455 DWP Version 1:
9456
9457 Both index sections have the same format, and serve to map a 64-bit
9458 signature to a set of section numbers. Each section begins with a header,
9459 followed by a hash table of 64-bit signatures, a parallel table of 32-bit
9460 indexes, and a pool of 32-bit section numbers. The index sections will be
9461 aligned at 8-byte boundaries in the file.
9462
9463 The index section header consists of:
9464
9465 V, 32 bit version number
9466 -, 32 bits unused
9467 N, 32 bit number of compilation units or type units in the index
9468 M, 32 bit number of slots in the hash table
9469
9470 Numbers are recorded using the byte order of the application binary.
9471
9472 The hash table begins at offset 16 in the section, and consists of an array
9473 of M 64-bit slots. Each slot contains a 64-bit signature (using the byte
9474 order of the application binary). Unused slots in the hash table are 0.
9475 (We rely on the extreme unlikeliness of a signature being exactly 0.)
9476
9477 The parallel table begins immediately after the hash table
9478 (at offset 16 + 8 * M from the beginning of the section), and consists of an
9479 array of 32-bit indexes (using the byte order of the application binary),
9480 corresponding 1-1 with slots in the hash table. Each entry in the parallel
9481 table contains a 32-bit index into the pool of section numbers. For unused
9482 hash table slots, the corresponding entry in the parallel table will be 0.
9483
9484 The pool of section numbers begins immediately following the hash table
9485 (at offset 16 + 12 * M from the beginning of the section). The pool of
9486 section numbers consists of an array of 32-bit words (using the byte order
9487 of the application binary). Each item in the array is indexed starting
9488 from 0. The hash table entry provides the index of the first section
9489 number in the set. Additional section numbers in the set follow, and the
9490 set is terminated by a 0 entry (section number 0 is not used in ELF).
9491
9492 In each set of section numbers, the .debug_info.dwo or .debug_types.dwo
9493 section must be the first entry in the set, and the .debug_abbrev.dwo must
9494 be the second entry. Other members of the set may follow in any order.
9495
9496 ---
9497
9498 DWP Version 2:
9499
9500 DWP Version 2 combines all the .debug_info, etc. sections into one,
9501 and the entries in the index tables are now offsets into these sections.
9502 CU offsets begin at 0. TU offsets begin at the size of the .debug_info
9503 section.
9504
9505 Index Section Contents:
9506 Header
9507 Hash Table of Signatures dwp_hash_table.hash_table
9508 Parallel Table of Indices dwp_hash_table.unit_table
9509 Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets}
9510 Table of Section Sizes dwp_hash_table.v2.sizes
9511
9512 The index section header consists of:
9513
9514 V, 32 bit version number
9515 L, 32 bit number of columns in the table of section offsets
9516 N, 32 bit number of compilation units or type units in the index
9517 M, 32 bit number of slots in the hash table
9518
9519 Numbers are recorded using the byte order of the application binary.
9520
9521 The hash table has the same format as version 1.
9522 The parallel table of indices has the same format as version 1,
9523 except that the entries are origin-1 indices into the table of sections
9524 offsets and the table of section sizes.
9525
9526 The table of offsets begins immediately following the parallel table
9527 (at offset 16 + 12 * M from the beginning of the section). The table is
9528 a two-dimensional array of 32-bit words (using the byte order of the
9529 application binary), with L columns and N+1 rows, in row-major order.
9530 Each row in the array is indexed starting from 0. The first row provides
9531 a key to the remaining rows: each column in this row provides an identifier
9532 for a debug section, and the offsets in the same column of subsequent rows
9533 refer to that section. The section identifiers are:
9534
9535 DW_SECT_INFO 1 .debug_info.dwo
9536 DW_SECT_TYPES 2 .debug_types.dwo
9537 DW_SECT_ABBREV 3 .debug_abbrev.dwo
9538 DW_SECT_LINE 4 .debug_line.dwo
9539 DW_SECT_LOC 5 .debug_loc.dwo
9540 DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo
9541 DW_SECT_MACINFO 7 .debug_macinfo.dwo
9542 DW_SECT_MACRO 8 .debug_macro.dwo
9543
9544 The offsets provided by the CU and TU index sections are the base offsets
9545 for the contributions made by each CU or TU to the corresponding section
9546 in the package file. Each CU and TU header contains an abbrev_offset
9547 field, used to find the abbreviations table for that CU or TU within the
9548 contribution to the .debug_abbrev.dwo section for that CU or TU, and should
9549 be interpreted as relative to the base offset given in the index section.
9550 Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes
9551 should be interpreted as relative to the base offset for .debug_line.dwo,
9552 and offsets into other debug sections obtained from DWARF attributes should
9553 also be interpreted as relative to the corresponding base offset.
9554
9555 The table of sizes begins immediately following the table of offsets.
9556 Like the table of offsets, it is a two-dimensional array of 32-bit words,
9557 with L columns and N rows, in row-major order. Each row in the array is
9558 indexed starting from 1 (row 0 is shared by the two tables).
9559
9560 ---
9561
9562 Hash table lookup is handled the same in version 1 and 2:
9563
9564 We assume that N and M will not exceed 2^32 - 1.
9565 The size of the hash table, M, must be 2^k such that 2^k > 3*N/2.
9566
9567 Given a 64-bit compilation unit signature or a type signature S, an entry
9568 in the hash table is located as follows:
9569
9570 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with
9571 the low-order k bits all set to 1.
9572
9573 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1).
9574
9575 3) If the hash table entry at index H matches the signature, use that
9576 entry. If the hash table entry at index H is unused (all zeroes),
9577 terminate the search: the signature is not present in the table.
9578
9579 4) Let H = (H + H') modulo M. Repeat at Step 3.
9580
9581 Because M > N and H' and M are relatively prime, the search is guaranteed
9582 to stop at an unused slot or find the match. */
9583
9584 /* Create a hash table to map DWO IDs to their CU/TU entry in
9585 .debug_{info,types}.dwo in DWP_FILE.
9586 Returns NULL if there isn't one.
9587 Note: This function processes DWP files only, not DWO files. */
9588
9589 static struct dwp_hash_table *
9590 create_dwp_hash_table (struct dwp_file *dwp_file, int is_debug_types)
9591 {
9592 struct objfile *objfile = dwarf2_per_objfile->objfile;
9593 bfd *dbfd = dwp_file->dbfd;
9594 const gdb_byte *index_ptr, *index_end;
9595 struct dwarf2_section_info *index;
9596 uint32_t version, nr_columns, nr_units, nr_slots;
9597 struct dwp_hash_table *htab;
9598
9599 if (is_debug_types)
9600 index = &dwp_file->sections.tu_index;
9601 else
9602 index = &dwp_file->sections.cu_index;
9603
9604 if (dwarf2_section_empty_p (index))
9605 return NULL;
9606 dwarf2_read_section (objfile, index);
9607
9608 index_ptr = index->buffer;
9609 index_end = index_ptr + index->size;
9610
9611 version = read_4_bytes (dbfd, index_ptr);
9612 index_ptr += 4;
9613 if (version == 2)
9614 nr_columns = read_4_bytes (dbfd, index_ptr);
9615 else
9616 nr_columns = 0;
9617 index_ptr += 4;
9618 nr_units = read_4_bytes (dbfd, index_ptr);
9619 index_ptr += 4;
9620 nr_slots = read_4_bytes (dbfd, index_ptr);
9621 index_ptr += 4;
9622
9623 if (version != 1 && version != 2)
9624 {
9625 error (_("Dwarf Error: unsupported DWP file version (%s)"
9626 " [in module %s]"),
9627 pulongest (version), dwp_file->name);
9628 }
9629 if (nr_slots != (nr_slots & -nr_slots))
9630 {
9631 error (_("Dwarf Error: number of slots in DWP hash table (%s)"
9632 " is not power of 2 [in module %s]"),
9633 pulongest (nr_slots), dwp_file->name);
9634 }
9635
9636 htab = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_hash_table);
9637 htab->version = version;
9638 htab->nr_columns = nr_columns;
9639 htab->nr_units = nr_units;
9640 htab->nr_slots = nr_slots;
9641 htab->hash_table = index_ptr;
9642 htab->unit_table = htab->hash_table + sizeof (uint64_t) * nr_slots;
9643
9644 /* Exit early if the table is empty. */
9645 if (nr_slots == 0 || nr_units == 0
9646 || (version == 2 && nr_columns == 0))
9647 {
9648 /* All must be zero. */
9649 if (nr_slots != 0 || nr_units != 0
9650 || (version == 2 && nr_columns != 0))
9651 {
9652 complaint (&symfile_complaints,
9653 _("Empty DWP but nr_slots,nr_units,nr_columns not"
9654 " all zero [in modules %s]"),
9655 dwp_file->name);
9656 }
9657 return htab;
9658 }
9659
9660 if (version == 1)
9661 {
9662 htab->section_pool.v1.indices =
9663 htab->unit_table + sizeof (uint32_t) * nr_slots;
9664 /* It's harder to decide whether the section is too small in v1.
9665 V1 is deprecated anyway so we punt. */
9666 }
9667 else
9668 {
9669 const gdb_byte *ids_ptr = htab->unit_table + sizeof (uint32_t) * nr_slots;
9670 int *ids = htab->section_pool.v2.section_ids;
9671 /* Reverse map for error checking. */
9672 int ids_seen[DW_SECT_MAX + 1];
9673 int i;
9674
9675 if (nr_columns < 2)
9676 {
9677 error (_("Dwarf Error: bad DWP hash table, too few columns"
9678 " in section table [in module %s]"),
9679 dwp_file->name);
9680 }
9681 if (nr_columns > MAX_NR_V2_DWO_SECTIONS)
9682 {
9683 error (_("Dwarf Error: bad DWP hash table, too many columns"
9684 " in section table [in module %s]"),
9685 dwp_file->name);
9686 }
9687 memset (ids, 255, (DW_SECT_MAX + 1) * sizeof (int32_t));
9688 memset (ids_seen, 255, (DW_SECT_MAX + 1) * sizeof (int32_t));
9689 for (i = 0; i < nr_columns; ++i)
9690 {
9691 int id = read_4_bytes (dbfd, ids_ptr + i * sizeof (uint32_t));
9692
9693 if (id < DW_SECT_MIN || id > DW_SECT_MAX)
9694 {
9695 error (_("Dwarf Error: bad DWP hash table, bad section id %d"
9696 " in section table [in module %s]"),
9697 id, dwp_file->name);
9698 }
9699 if (ids_seen[id] != -1)
9700 {
9701 error (_("Dwarf Error: bad DWP hash table, duplicate section"
9702 " id %d in section table [in module %s]"),
9703 id, dwp_file->name);
9704 }
9705 ids_seen[id] = i;
9706 ids[i] = id;
9707 }
9708 /* Must have exactly one info or types section. */
9709 if (((ids_seen[DW_SECT_INFO] != -1)
9710 + (ids_seen[DW_SECT_TYPES] != -1))
9711 != 1)
9712 {
9713 error (_("Dwarf Error: bad DWP hash table, missing/duplicate"
9714 " DWO info/types section [in module %s]"),
9715 dwp_file->name);
9716 }
9717 /* Must have an abbrev section. */
9718 if (ids_seen[DW_SECT_ABBREV] == -1)
9719 {
9720 error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev"
9721 " section [in module %s]"),
9722 dwp_file->name);
9723 }
9724 htab->section_pool.v2.offsets = ids_ptr + sizeof (uint32_t) * nr_columns;
9725 htab->section_pool.v2.sizes =
9726 htab->section_pool.v2.offsets + (sizeof (uint32_t)
9727 * nr_units * nr_columns);
9728 if ((htab->section_pool.v2.sizes + (sizeof (uint32_t)
9729 * nr_units * nr_columns))
9730 > index_end)
9731 {
9732 error (_("Dwarf Error: DWP index section is corrupt (too small)"
9733 " [in module %s]"),
9734 dwp_file->name);
9735 }
9736 }
9737
9738 return htab;
9739 }
9740
9741 /* Update SECTIONS with the data from SECTP.
9742
9743 This function is like the other "locate" section routines that are
9744 passed to bfd_map_over_sections, but in this context the sections to
9745 read comes from the DWP V1 hash table, not the full ELF section table.
9746
9747 The result is non-zero for success, or zero if an error was found. */
9748
9749 static int
9750 locate_v1_virtual_dwo_sections (asection *sectp,
9751 struct virtual_v1_dwo_sections *sections)
9752 {
9753 const struct dwop_section_names *names = &dwop_section_names;
9754
9755 if (section_is_p (sectp->name, &names->abbrev_dwo))
9756 {
9757 /* There can be only one. */
9758 if (sections->abbrev.s.asection != NULL)
9759 return 0;
9760 sections->abbrev.s.asection = sectp;
9761 sections->abbrev.size = bfd_get_section_size (sectp);
9762 }
9763 else if (section_is_p (sectp->name, &names->info_dwo)
9764 || section_is_p (sectp->name, &names->types_dwo))
9765 {
9766 /* There can be only one. */
9767 if (sections->info_or_types.s.asection != NULL)
9768 return 0;
9769 sections->info_or_types.s.asection = sectp;
9770 sections->info_or_types.size = bfd_get_section_size (sectp);
9771 }
9772 else if (section_is_p (sectp->name, &names->line_dwo))
9773 {
9774 /* There can be only one. */
9775 if (sections->line.s.asection != NULL)
9776 return 0;
9777 sections->line.s.asection = sectp;
9778 sections->line.size = bfd_get_section_size (sectp);
9779 }
9780 else if (section_is_p (sectp->name, &names->loc_dwo))
9781 {
9782 /* There can be only one. */
9783 if (sections->loc.s.asection != NULL)
9784 return 0;
9785 sections->loc.s.asection = sectp;
9786 sections->loc.size = bfd_get_section_size (sectp);
9787 }
9788 else if (section_is_p (sectp->name, &names->macinfo_dwo))
9789 {
9790 /* There can be only one. */
9791 if (sections->macinfo.s.asection != NULL)
9792 return 0;
9793 sections->macinfo.s.asection = sectp;
9794 sections->macinfo.size = bfd_get_section_size (sectp);
9795 }
9796 else if (section_is_p (sectp->name, &names->macro_dwo))
9797 {
9798 /* There can be only one. */
9799 if (sections->macro.s.asection != NULL)
9800 return 0;
9801 sections->macro.s.asection = sectp;
9802 sections->macro.size = bfd_get_section_size (sectp);
9803 }
9804 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
9805 {
9806 /* There can be only one. */
9807 if (sections->str_offsets.s.asection != NULL)
9808 return 0;
9809 sections->str_offsets.s.asection = sectp;
9810 sections->str_offsets.size = bfd_get_section_size (sectp);
9811 }
9812 else
9813 {
9814 /* No other kind of section is valid. */
9815 return 0;
9816 }
9817
9818 return 1;
9819 }
9820
9821 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
9822 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
9823 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
9824 This is for DWP version 1 files. */
9825
9826 static struct dwo_unit *
9827 create_dwo_unit_in_dwp_v1 (struct dwp_file *dwp_file,
9828 uint32_t unit_index,
9829 const char *comp_dir,
9830 ULONGEST signature, int is_debug_types)
9831 {
9832 struct objfile *objfile = dwarf2_per_objfile->objfile;
9833 const struct dwp_hash_table *dwp_htab =
9834 is_debug_types ? dwp_file->tus : dwp_file->cus;
9835 bfd *dbfd = dwp_file->dbfd;
9836 const char *kind = is_debug_types ? "TU" : "CU";
9837 struct dwo_file *dwo_file;
9838 struct dwo_unit *dwo_unit;
9839 struct virtual_v1_dwo_sections sections;
9840 void **dwo_file_slot;
9841 char *virtual_dwo_name;
9842 struct dwarf2_section_info *cutu;
9843 struct cleanup *cleanups;
9844 int i;
9845
9846 gdb_assert (dwp_file->version == 1);
9847
9848 if (dwarf2_read_debug)
9849 {
9850 fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V1 file: %s\n",
9851 kind,
9852 pulongest (unit_index), hex_string (signature),
9853 dwp_file->name);
9854 }
9855
9856 /* Fetch the sections of this DWO unit.
9857 Put a limit on the number of sections we look for so that bad data
9858 doesn't cause us to loop forever. */
9859
9860 #define MAX_NR_V1_DWO_SECTIONS \
9861 (1 /* .debug_info or .debug_types */ \
9862 + 1 /* .debug_abbrev */ \
9863 + 1 /* .debug_line */ \
9864 + 1 /* .debug_loc */ \
9865 + 1 /* .debug_str_offsets */ \
9866 + 1 /* .debug_macro or .debug_macinfo */ \
9867 + 1 /* trailing zero */)
9868
9869 memset (&sections, 0, sizeof (sections));
9870 cleanups = make_cleanup (null_cleanup, 0);
9871
9872 for (i = 0; i < MAX_NR_V1_DWO_SECTIONS; ++i)
9873 {
9874 asection *sectp;
9875 uint32_t section_nr =
9876 read_4_bytes (dbfd,
9877 dwp_htab->section_pool.v1.indices
9878 + (unit_index + i) * sizeof (uint32_t));
9879
9880 if (section_nr == 0)
9881 break;
9882 if (section_nr >= dwp_file->num_sections)
9883 {
9884 error (_("Dwarf Error: bad DWP hash table, section number too large"
9885 " [in module %s]"),
9886 dwp_file->name);
9887 }
9888
9889 sectp = dwp_file->elf_sections[section_nr];
9890 if (! locate_v1_virtual_dwo_sections (sectp, &sections))
9891 {
9892 error (_("Dwarf Error: bad DWP hash table, invalid section found"
9893 " [in module %s]"),
9894 dwp_file->name);
9895 }
9896 }
9897
9898 if (i < 2
9899 || dwarf2_section_empty_p (&sections.info_or_types)
9900 || dwarf2_section_empty_p (&sections.abbrev))
9901 {
9902 error (_("Dwarf Error: bad DWP hash table, missing DWO sections"
9903 " [in module %s]"),
9904 dwp_file->name);
9905 }
9906 if (i == MAX_NR_V1_DWO_SECTIONS)
9907 {
9908 error (_("Dwarf Error: bad DWP hash table, too many DWO sections"
9909 " [in module %s]"),
9910 dwp_file->name);
9911 }
9912
9913 /* It's easier for the rest of the code if we fake a struct dwo_file and
9914 have dwo_unit "live" in that. At least for now.
9915
9916 The DWP file can be made up of a random collection of CUs and TUs.
9917 However, for each CU + set of TUs that came from the same original DWO
9918 file, we can combine them back into a virtual DWO file to save space
9919 (fewer struct dwo_file objects to allocate). Remember that for really
9920 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
9921
9922 virtual_dwo_name =
9923 xstrprintf ("virtual-dwo/%d-%d-%d-%d",
9924 get_section_id (&sections.abbrev),
9925 get_section_id (&sections.line),
9926 get_section_id (&sections.loc),
9927 get_section_id (&sections.str_offsets));
9928 make_cleanup (xfree, virtual_dwo_name);
9929 /* Can we use an existing virtual DWO file? */
9930 dwo_file_slot = lookup_dwo_file_slot (virtual_dwo_name, comp_dir);
9931 /* Create one if necessary. */
9932 if (*dwo_file_slot == NULL)
9933 {
9934 if (dwarf2_read_debug)
9935 {
9936 fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
9937 virtual_dwo_name);
9938 }
9939 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
9940 dwo_file->dwo_name = obstack_copy0 (&objfile->objfile_obstack,
9941 virtual_dwo_name,
9942 strlen (virtual_dwo_name));
9943 dwo_file->comp_dir = comp_dir;
9944 dwo_file->sections.abbrev = sections.abbrev;
9945 dwo_file->sections.line = sections.line;
9946 dwo_file->sections.loc = sections.loc;
9947 dwo_file->sections.macinfo = sections.macinfo;
9948 dwo_file->sections.macro = sections.macro;
9949 dwo_file->sections.str_offsets = sections.str_offsets;
9950 /* The "str" section is global to the entire DWP file. */
9951 dwo_file->sections.str = dwp_file->sections.str;
9952 /* The info or types section is assigned below to dwo_unit,
9953 there's no need to record it in dwo_file.
9954 Also, we can't simply record type sections in dwo_file because
9955 we record a pointer into the vector in dwo_unit. As we collect more
9956 types we'll grow the vector and eventually have to reallocate space
9957 for it, invalidating all copies of pointers into the previous
9958 contents. */
9959 *dwo_file_slot = dwo_file;
9960 }
9961 else
9962 {
9963 if (dwarf2_read_debug)
9964 {
9965 fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
9966 virtual_dwo_name);
9967 }
9968 dwo_file = *dwo_file_slot;
9969 }
9970 do_cleanups (cleanups);
9971
9972 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
9973 dwo_unit->dwo_file = dwo_file;
9974 dwo_unit->signature = signature;
9975 dwo_unit->section = obstack_alloc (&objfile->objfile_obstack,
9976 sizeof (struct dwarf2_section_info));
9977 *dwo_unit->section = sections.info_or_types;
9978 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
9979
9980 return dwo_unit;
9981 }
9982
9983 /* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it.
9984 Given a pointer to the containing section SECTION, and OFFSET,SIZE of the
9985 piece within that section used by a TU/CU, return a virtual section
9986 of just that piece. */
9987
9988 static struct dwarf2_section_info
9989 create_dwp_v2_section (struct dwarf2_section_info *section,
9990 bfd_size_type offset, bfd_size_type size)
9991 {
9992 struct dwarf2_section_info result;
9993 asection *sectp;
9994
9995 gdb_assert (section != NULL);
9996 gdb_assert (!section->is_virtual);
9997
9998 memset (&result, 0, sizeof (result));
9999 result.s.containing_section = section;
10000 result.is_virtual = 1;
10001
10002 if (size == 0)
10003 return result;
10004
10005 sectp = get_section_bfd_section (section);
10006
10007 /* Flag an error if the piece denoted by OFFSET,SIZE is outside the
10008 bounds of the real section. This is a pretty-rare event, so just
10009 flag an error (easier) instead of a warning and trying to cope. */
10010 if (sectp == NULL
10011 || offset + size > bfd_get_section_size (sectp))
10012 {
10013 bfd *abfd = sectp->owner;
10014
10015 error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit"
10016 " in section %s [in module %s]"),
10017 sectp ? bfd_section_name (abfd, sectp) : "<unknown>",
10018 objfile_name (dwarf2_per_objfile->objfile));
10019 }
10020
10021 result.virtual_offset = offset;
10022 result.size = size;
10023 return result;
10024 }
10025
10026 /* Create a dwo_unit object for the DWO unit with signature SIGNATURE.
10027 UNIT_INDEX is the index of the DWO unit in the DWP hash table.
10028 COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU.
10029 This is for DWP version 2 files. */
10030
10031 static struct dwo_unit *
10032 create_dwo_unit_in_dwp_v2 (struct dwp_file *dwp_file,
10033 uint32_t unit_index,
10034 const char *comp_dir,
10035 ULONGEST signature, int is_debug_types)
10036 {
10037 struct objfile *objfile = dwarf2_per_objfile->objfile;
10038 const struct dwp_hash_table *dwp_htab =
10039 is_debug_types ? dwp_file->tus : dwp_file->cus;
10040 bfd *dbfd = dwp_file->dbfd;
10041 const char *kind = is_debug_types ? "TU" : "CU";
10042 struct dwo_file *dwo_file;
10043 struct dwo_unit *dwo_unit;
10044 struct virtual_v2_dwo_sections sections;
10045 void **dwo_file_slot;
10046 char *virtual_dwo_name;
10047 struct dwarf2_section_info *cutu;
10048 struct cleanup *cleanups;
10049 int i;
10050
10051 gdb_assert (dwp_file->version == 2);
10052
10053 if (dwarf2_read_debug)
10054 {
10055 fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V2 file: %s\n",
10056 kind,
10057 pulongest (unit_index), hex_string (signature),
10058 dwp_file->name);
10059 }
10060
10061 /* Fetch the section offsets of this DWO unit. */
10062
10063 memset (&sections, 0, sizeof (sections));
10064 cleanups = make_cleanup (null_cleanup, 0);
10065
10066 for (i = 0; i < dwp_htab->nr_columns; ++i)
10067 {
10068 uint32_t offset = read_4_bytes (dbfd,
10069 dwp_htab->section_pool.v2.offsets
10070 + (((unit_index - 1) * dwp_htab->nr_columns
10071 + i)
10072 * sizeof (uint32_t)));
10073 uint32_t size = read_4_bytes (dbfd,
10074 dwp_htab->section_pool.v2.sizes
10075 + (((unit_index - 1) * dwp_htab->nr_columns
10076 + i)
10077 * sizeof (uint32_t)));
10078
10079 switch (dwp_htab->section_pool.v2.section_ids[i])
10080 {
10081 case DW_SECT_INFO:
10082 case DW_SECT_TYPES:
10083 sections.info_or_types_offset = offset;
10084 sections.info_or_types_size = size;
10085 break;
10086 case DW_SECT_ABBREV:
10087 sections.abbrev_offset = offset;
10088 sections.abbrev_size = size;
10089 break;
10090 case DW_SECT_LINE:
10091 sections.line_offset = offset;
10092 sections.line_size = size;
10093 break;
10094 case DW_SECT_LOC:
10095 sections.loc_offset = offset;
10096 sections.loc_size = size;
10097 break;
10098 case DW_SECT_STR_OFFSETS:
10099 sections.str_offsets_offset = offset;
10100 sections.str_offsets_size = size;
10101 break;
10102 case DW_SECT_MACINFO:
10103 sections.macinfo_offset = offset;
10104 sections.macinfo_size = size;
10105 break;
10106 case DW_SECT_MACRO:
10107 sections.macro_offset = offset;
10108 sections.macro_size = size;
10109 break;
10110 }
10111 }
10112
10113 /* It's easier for the rest of the code if we fake a struct dwo_file and
10114 have dwo_unit "live" in that. At least for now.
10115
10116 The DWP file can be made up of a random collection of CUs and TUs.
10117 However, for each CU + set of TUs that came from the same original DWO
10118 file, we can combine them back into a virtual DWO file to save space
10119 (fewer struct dwo_file objects to allocate). Remember that for really
10120 large apps there can be on the order of 8K CUs and 200K TUs, or more. */
10121
10122 virtual_dwo_name =
10123 xstrprintf ("virtual-dwo/%ld-%ld-%ld-%ld",
10124 (long) (sections.abbrev_size ? sections.abbrev_offset : 0),
10125 (long) (sections.line_size ? sections.line_offset : 0),
10126 (long) (sections.loc_size ? sections.loc_offset : 0),
10127 (long) (sections.str_offsets_size
10128 ? sections.str_offsets_offset : 0));
10129 make_cleanup (xfree, virtual_dwo_name);
10130 /* Can we use an existing virtual DWO file? */
10131 dwo_file_slot = lookup_dwo_file_slot (virtual_dwo_name, comp_dir);
10132 /* Create one if necessary. */
10133 if (*dwo_file_slot == NULL)
10134 {
10135 if (dwarf2_read_debug)
10136 {
10137 fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n",
10138 virtual_dwo_name);
10139 }
10140 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
10141 dwo_file->dwo_name = obstack_copy0 (&objfile->objfile_obstack,
10142 virtual_dwo_name,
10143 strlen (virtual_dwo_name));
10144 dwo_file->comp_dir = comp_dir;
10145 dwo_file->sections.abbrev =
10146 create_dwp_v2_section (&dwp_file->sections.abbrev,
10147 sections.abbrev_offset, sections.abbrev_size);
10148 dwo_file->sections.line =
10149 create_dwp_v2_section (&dwp_file->sections.line,
10150 sections.line_offset, sections.line_size);
10151 dwo_file->sections.loc =
10152 create_dwp_v2_section (&dwp_file->sections.loc,
10153 sections.loc_offset, sections.loc_size);
10154 dwo_file->sections.macinfo =
10155 create_dwp_v2_section (&dwp_file->sections.macinfo,
10156 sections.macinfo_offset, sections.macinfo_size);
10157 dwo_file->sections.macro =
10158 create_dwp_v2_section (&dwp_file->sections.macro,
10159 sections.macro_offset, sections.macro_size);
10160 dwo_file->sections.str_offsets =
10161 create_dwp_v2_section (&dwp_file->sections.str_offsets,
10162 sections.str_offsets_offset,
10163 sections.str_offsets_size);
10164 /* The "str" section is global to the entire DWP file. */
10165 dwo_file->sections.str = dwp_file->sections.str;
10166 /* The info or types section is assigned below to dwo_unit,
10167 there's no need to record it in dwo_file.
10168 Also, we can't simply record type sections in dwo_file because
10169 we record a pointer into the vector in dwo_unit. As we collect more
10170 types we'll grow the vector and eventually have to reallocate space
10171 for it, invalidating all copies of pointers into the previous
10172 contents. */
10173 *dwo_file_slot = dwo_file;
10174 }
10175 else
10176 {
10177 if (dwarf2_read_debug)
10178 {
10179 fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
10180 virtual_dwo_name);
10181 }
10182 dwo_file = *dwo_file_slot;
10183 }
10184 do_cleanups (cleanups);
10185
10186 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
10187 dwo_unit->dwo_file = dwo_file;
10188 dwo_unit->signature = signature;
10189 dwo_unit->section = obstack_alloc (&objfile->objfile_obstack,
10190 sizeof (struct dwarf2_section_info));
10191 *dwo_unit->section = create_dwp_v2_section (is_debug_types
10192 ? &dwp_file->sections.types
10193 : &dwp_file->sections.info,
10194 sections.info_or_types_offset,
10195 sections.info_or_types_size);
10196 /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
10197
10198 return dwo_unit;
10199 }
10200
10201 /* Lookup the DWO unit with SIGNATURE in DWP_FILE.
10202 Returns NULL if the signature isn't found. */
10203
10204 static struct dwo_unit *
10205 lookup_dwo_unit_in_dwp (struct dwp_file *dwp_file, const char *comp_dir,
10206 ULONGEST signature, int is_debug_types)
10207 {
10208 const struct dwp_hash_table *dwp_htab =
10209 is_debug_types ? dwp_file->tus : dwp_file->cus;
10210 bfd *dbfd = dwp_file->dbfd;
10211 uint32_t mask = dwp_htab->nr_slots - 1;
10212 uint32_t hash = signature & mask;
10213 uint32_t hash2 = ((signature >> 32) & mask) | 1;
10214 unsigned int i;
10215 void **slot;
10216 struct dwo_unit find_dwo_cu, *dwo_cu;
10217
10218 memset (&find_dwo_cu, 0, sizeof (find_dwo_cu));
10219 find_dwo_cu.signature = signature;
10220 slot = htab_find_slot (is_debug_types
10221 ? dwp_file->loaded_tus
10222 : dwp_file->loaded_cus,
10223 &find_dwo_cu, INSERT);
10224
10225 if (*slot != NULL)
10226 return *slot;
10227
10228 /* Use a for loop so that we don't loop forever on bad debug info. */
10229 for (i = 0; i < dwp_htab->nr_slots; ++i)
10230 {
10231 ULONGEST signature_in_table;
10232
10233 signature_in_table =
10234 read_8_bytes (dbfd, dwp_htab->hash_table + hash * sizeof (uint64_t));
10235 if (signature_in_table == signature)
10236 {
10237 uint32_t unit_index =
10238 read_4_bytes (dbfd,
10239 dwp_htab->unit_table + hash * sizeof (uint32_t));
10240
10241 if (dwp_file->version == 1)
10242 {
10243 *slot = create_dwo_unit_in_dwp_v1 (dwp_file, unit_index,
10244 comp_dir, signature,
10245 is_debug_types);
10246 }
10247 else
10248 {
10249 *slot = create_dwo_unit_in_dwp_v2 (dwp_file, unit_index,
10250 comp_dir, signature,
10251 is_debug_types);
10252 }
10253 return *slot;
10254 }
10255 if (signature_in_table == 0)
10256 return NULL;
10257 hash = (hash + hash2) & mask;
10258 }
10259
10260 error (_("Dwarf Error: bad DWP hash table, lookup didn't terminate"
10261 " [in module %s]"),
10262 dwp_file->name);
10263 }
10264
10265 /* Subroutine of open_dwo_file,open_dwp_file to simplify them.
10266 Open the file specified by FILE_NAME and hand it off to BFD for
10267 preliminary analysis. Return a newly initialized bfd *, which
10268 includes a canonicalized copy of FILE_NAME.
10269 If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file.
10270 SEARCH_CWD is true if the current directory is to be searched.
10271 It will be searched before debug-file-directory.
10272 If successful, the file is added to the bfd include table of the
10273 objfile's bfd (see gdb_bfd_record_inclusion).
10274 If unable to find/open the file, return NULL.
10275 NOTE: This function is derived from symfile_bfd_open. */
10276
10277 static bfd *
10278 try_open_dwop_file (const char *file_name, int is_dwp, int search_cwd)
10279 {
10280 bfd *sym_bfd;
10281 int desc, flags;
10282 char *absolute_name;
10283 /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if
10284 FILE_NAME contains a '/'. So we can't use it. Instead prepend "."
10285 to debug_file_directory. */
10286 char *search_path;
10287 static const char dirname_separator_string[] = { DIRNAME_SEPARATOR, '\0' };
10288
10289 if (search_cwd)
10290 {
10291 if (*debug_file_directory != '\0')
10292 search_path = concat (".", dirname_separator_string,
10293 debug_file_directory, NULL);
10294 else
10295 search_path = xstrdup (".");
10296 }
10297 else
10298 search_path = xstrdup (debug_file_directory);
10299
10300 flags = OPF_RETURN_REALPATH;
10301 if (is_dwp)
10302 flags |= OPF_SEARCH_IN_PATH;
10303 desc = openp (search_path, flags, file_name,
10304 O_RDONLY | O_BINARY, &absolute_name);
10305 xfree (search_path);
10306 if (desc < 0)
10307 return NULL;
10308
10309 sym_bfd = gdb_bfd_open (absolute_name, gnutarget, desc);
10310 xfree (absolute_name);
10311 if (sym_bfd == NULL)
10312 return NULL;
10313 bfd_set_cacheable (sym_bfd, 1);
10314
10315 if (!bfd_check_format (sym_bfd, bfd_object))
10316 {
10317 gdb_bfd_unref (sym_bfd); /* This also closes desc. */
10318 return NULL;
10319 }
10320
10321 /* Success. Record the bfd as having been included by the objfile's bfd.
10322 This is important because things like demangled_names_hash lives in the
10323 objfile's per_bfd space and may have references to things like symbol
10324 names that live in the DWO/DWP file's per_bfd space. PR 16426. */
10325 gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd, sym_bfd);
10326
10327 return sym_bfd;
10328 }
10329
10330 /* Try to open DWO file FILE_NAME.
10331 COMP_DIR is the DW_AT_comp_dir attribute.
10332 The result is the bfd handle of the file.
10333 If there is a problem finding or opening the file, return NULL.
10334 Upon success, the canonicalized path of the file is stored in the bfd,
10335 same as symfile_bfd_open. */
10336
10337 static bfd *
10338 open_dwo_file (const char *file_name, const char *comp_dir)
10339 {
10340 bfd *abfd;
10341
10342 if (IS_ABSOLUTE_PATH (file_name))
10343 return try_open_dwop_file (file_name, 0 /*is_dwp*/, 0 /*search_cwd*/);
10344
10345 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
10346
10347 if (comp_dir != NULL)
10348 {
10349 char *path_to_try = concat (comp_dir, SLASH_STRING, file_name, NULL);
10350
10351 /* NOTE: If comp_dir is a relative path, this will also try the
10352 search path, which seems useful. */
10353 abfd = try_open_dwop_file (path_to_try, 0 /*is_dwp*/, 1 /*search_cwd*/);
10354 xfree (path_to_try);
10355 if (abfd != NULL)
10356 return abfd;
10357 }
10358
10359 /* That didn't work, try debug-file-directory, which, despite its name,
10360 is a list of paths. */
10361
10362 if (*debug_file_directory == '\0')
10363 return NULL;
10364
10365 return try_open_dwop_file (file_name, 0 /*is_dwp*/, 1 /*search_cwd*/);
10366 }
10367
10368 /* This function is mapped across the sections and remembers the offset and
10369 size of each of the DWO debugging sections we are interested in. */
10370
10371 static void
10372 dwarf2_locate_dwo_sections (bfd *abfd, asection *sectp, void *dwo_sections_ptr)
10373 {
10374 struct dwo_sections *dwo_sections = dwo_sections_ptr;
10375 const struct dwop_section_names *names = &dwop_section_names;
10376
10377 if (section_is_p (sectp->name, &names->abbrev_dwo))
10378 {
10379 dwo_sections->abbrev.s.asection = sectp;
10380 dwo_sections->abbrev.size = bfd_get_section_size (sectp);
10381 }
10382 else if (section_is_p (sectp->name, &names->info_dwo))
10383 {
10384 dwo_sections->info.s.asection = sectp;
10385 dwo_sections->info.size = bfd_get_section_size (sectp);
10386 }
10387 else if (section_is_p (sectp->name, &names->line_dwo))
10388 {
10389 dwo_sections->line.s.asection = sectp;
10390 dwo_sections->line.size = bfd_get_section_size (sectp);
10391 }
10392 else if (section_is_p (sectp->name, &names->loc_dwo))
10393 {
10394 dwo_sections->loc.s.asection = sectp;
10395 dwo_sections->loc.size = bfd_get_section_size (sectp);
10396 }
10397 else if (section_is_p (sectp->name, &names->macinfo_dwo))
10398 {
10399 dwo_sections->macinfo.s.asection = sectp;
10400 dwo_sections->macinfo.size = bfd_get_section_size (sectp);
10401 }
10402 else if (section_is_p (sectp->name, &names->macro_dwo))
10403 {
10404 dwo_sections->macro.s.asection = sectp;
10405 dwo_sections->macro.size = bfd_get_section_size (sectp);
10406 }
10407 else if (section_is_p (sectp->name, &names->str_dwo))
10408 {
10409 dwo_sections->str.s.asection = sectp;
10410 dwo_sections->str.size = bfd_get_section_size (sectp);
10411 }
10412 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
10413 {
10414 dwo_sections->str_offsets.s.asection = sectp;
10415 dwo_sections->str_offsets.size = bfd_get_section_size (sectp);
10416 }
10417 else if (section_is_p (sectp->name, &names->types_dwo))
10418 {
10419 struct dwarf2_section_info type_section;
10420
10421 memset (&type_section, 0, sizeof (type_section));
10422 type_section.s.asection = sectp;
10423 type_section.size = bfd_get_section_size (sectp);
10424 VEC_safe_push (dwarf2_section_info_def, dwo_sections->types,
10425 &type_section);
10426 }
10427 }
10428
10429 /* Initialize the use of the DWO file specified by DWO_NAME and referenced
10430 by PER_CU. This is for the non-DWP case.
10431 The result is NULL if DWO_NAME can't be found. */
10432
10433 static struct dwo_file *
10434 open_and_init_dwo_file (struct dwarf2_per_cu_data *per_cu,
10435 const char *dwo_name, const char *comp_dir)
10436 {
10437 struct objfile *objfile = dwarf2_per_objfile->objfile;
10438 struct dwo_file *dwo_file;
10439 bfd *dbfd;
10440 struct cleanup *cleanups;
10441
10442 dbfd = open_dwo_file (dwo_name, comp_dir);
10443 if (dbfd == NULL)
10444 {
10445 if (dwarf2_read_debug)
10446 fprintf_unfiltered (gdb_stdlog, "DWO file not found: %s\n", dwo_name);
10447 return NULL;
10448 }
10449 dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
10450 dwo_file->dwo_name = dwo_name;
10451 dwo_file->comp_dir = comp_dir;
10452 dwo_file->dbfd = dbfd;
10453
10454 cleanups = make_cleanup (free_dwo_file_cleanup, dwo_file);
10455
10456 bfd_map_over_sections (dbfd, dwarf2_locate_dwo_sections, &dwo_file->sections);
10457
10458 dwo_file->cu = create_dwo_cu (dwo_file);
10459
10460 dwo_file->tus = create_debug_types_hash_table (dwo_file,
10461 dwo_file->sections.types);
10462
10463 discard_cleanups (cleanups);
10464
10465 if (dwarf2_read_debug)
10466 fprintf_unfiltered (gdb_stdlog, "DWO file found: %s\n", dwo_name);
10467
10468 return dwo_file;
10469 }
10470
10471 /* This function is mapped across the sections and remembers the offset and
10472 size of each of the DWP debugging sections common to version 1 and 2 that
10473 we are interested in. */
10474
10475 static void
10476 dwarf2_locate_common_dwp_sections (bfd *abfd, asection *sectp,
10477 void *dwp_file_ptr)
10478 {
10479 struct dwp_file *dwp_file = dwp_file_ptr;
10480 const struct dwop_section_names *names = &dwop_section_names;
10481 unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
10482
10483 /* Record the ELF section number for later lookup: this is what the
10484 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
10485 gdb_assert (elf_section_nr < dwp_file->num_sections);
10486 dwp_file->elf_sections[elf_section_nr] = sectp;
10487
10488 /* Look for specific sections that we need. */
10489 if (section_is_p (sectp->name, &names->str_dwo))
10490 {
10491 dwp_file->sections.str.s.asection = sectp;
10492 dwp_file->sections.str.size = bfd_get_section_size (sectp);
10493 }
10494 else if (section_is_p (sectp->name, &names->cu_index))
10495 {
10496 dwp_file->sections.cu_index.s.asection = sectp;
10497 dwp_file->sections.cu_index.size = bfd_get_section_size (sectp);
10498 }
10499 else if (section_is_p (sectp->name, &names->tu_index))
10500 {
10501 dwp_file->sections.tu_index.s.asection = sectp;
10502 dwp_file->sections.tu_index.size = bfd_get_section_size (sectp);
10503 }
10504 }
10505
10506 /* This function is mapped across the sections and remembers the offset and
10507 size of each of the DWP version 2 debugging sections that we are interested
10508 in. This is split into a separate function because we don't know if we
10509 have version 1 or 2 until we parse the cu_index/tu_index sections. */
10510
10511 static void
10512 dwarf2_locate_v2_dwp_sections (bfd *abfd, asection *sectp, void *dwp_file_ptr)
10513 {
10514 struct dwp_file *dwp_file = dwp_file_ptr;
10515 const struct dwop_section_names *names = &dwop_section_names;
10516 unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
10517
10518 /* Record the ELF section number for later lookup: this is what the
10519 .debug_cu_index,.debug_tu_index tables use in DWP V1. */
10520 gdb_assert (elf_section_nr < dwp_file->num_sections);
10521 dwp_file->elf_sections[elf_section_nr] = sectp;
10522
10523 /* Look for specific sections that we need. */
10524 if (section_is_p (sectp->name, &names->abbrev_dwo))
10525 {
10526 dwp_file->sections.abbrev.s.asection = sectp;
10527 dwp_file->sections.abbrev.size = bfd_get_section_size (sectp);
10528 }
10529 else if (section_is_p (sectp->name, &names->info_dwo))
10530 {
10531 dwp_file->sections.info.s.asection = sectp;
10532 dwp_file->sections.info.size = bfd_get_section_size (sectp);
10533 }
10534 else if (section_is_p (sectp->name, &names->line_dwo))
10535 {
10536 dwp_file->sections.line.s.asection = sectp;
10537 dwp_file->sections.line.size = bfd_get_section_size (sectp);
10538 }
10539 else if (section_is_p (sectp->name, &names->loc_dwo))
10540 {
10541 dwp_file->sections.loc.s.asection = sectp;
10542 dwp_file->sections.loc.size = bfd_get_section_size (sectp);
10543 }
10544 else if (section_is_p (sectp->name, &names->macinfo_dwo))
10545 {
10546 dwp_file->sections.macinfo.s.asection = sectp;
10547 dwp_file->sections.macinfo.size = bfd_get_section_size (sectp);
10548 }
10549 else if (section_is_p (sectp->name, &names->macro_dwo))
10550 {
10551 dwp_file->sections.macro.s.asection = sectp;
10552 dwp_file->sections.macro.size = bfd_get_section_size (sectp);
10553 }
10554 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
10555 {
10556 dwp_file->sections.str_offsets.s.asection = sectp;
10557 dwp_file->sections.str_offsets.size = bfd_get_section_size (sectp);
10558 }
10559 else if (section_is_p (sectp->name, &names->types_dwo))
10560 {
10561 dwp_file->sections.types.s.asection = sectp;
10562 dwp_file->sections.types.size = bfd_get_section_size (sectp);
10563 }
10564 }
10565
10566 /* Hash function for dwp_file loaded CUs/TUs. */
10567
10568 static hashval_t
10569 hash_dwp_loaded_cutus (const void *item)
10570 {
10571 const struct dwo_unit *dwo_unit = item;
10572
10573 /* This drops the top 32 bits of the signature, but is ok for a hash. */
10574 return dwo_unit->signature;
10575 }
10576
10577 /* Equality function for dwp_file loaded CUs/TUs. */
10578
10579 static int
10580 eq_dwp_loaded_cutus (const void *a, const void *b)
10581 {
10582 const struct dwo_unit *dua = a;
10583 const struct dwo_unit *dub = b;
10584
10585 return dua->signature == dub->signature;
10586 }
10587
10588 /* Allocate a hash table for dwp_file loaded CUs/TUs. */
10589
10590 static htab_t
10591 allocate_dwp_loaded_cutus_table (struct objfile *objfile)
10592 {
10593 return htab_create_alloc_ex (3,
10594 hash_dwp_loaded_cutus,
10595 eq_dwp_loaded_cutus,
10596 NULL,
10597 &objfile->objfile_obstack,
10598 hashtab_obstack_allocate,
10599 dummy_obstack_deallocate);
10600 }
10601
10602 /* Try to open DWP file FILE_NAME.
10603 The result is the bfd handle of the file.
10604 If there is a problem finding or opening the file, return NULL.
10605 Upon success, the canonicalized path of the file is stored in the bfd,
10606 same as symfile_bfd_open. */
10607
10608 static bfd *
10609 open_dwp_file (const char *file_name)
10610 {
10611 bfd *abfd;
10612
10613 abfd = try_open_dwop_file (file_name, 1 /*is_dwp*/, 1 /*search_cwd*/);
10614 if (abfd != NULL)
10615 return abfd;
10616
10617 /* Work around upstream bug 15652.
10618 http://sourceware.org/bugzilla/show_bug.cgi?id=15652
10619 [Whether that's a "bug" is debatable, but it is getting in our way.]
10620 We have no real idea where the dwp file is, because gdb's realpath-ing
10621 of the executable's path may have discarded the needed info.
10622 [IWBN if the dwp file name was recorded in the executable, akin to
10623 .gnu_debuglink, but that doesn't exist yet.]
10624 Strip the directory from FILE_NAME and search again. */
10625 if (*debug_file_directory != '\0')
10626 {
10627 /* Don't implicitly search the current directory here.
10628 If the user wants to search "." to handle this case,
10629 it must be added to debug-file-directory. */
10630 return try_open_dwop_file (lbasename (file_name), 1 /*is_dwp*/,
10631 0 /*search_cwd*/);
10632 }
10633
10634 return NULL;
10635 }
10636
10637 /* Initialize the use of the DWP file for the current objfile.
10638 By convention the name of the DWP file is ${objfile}.dwp.
10639 The result is NULL if it can't be found. */
10640
10641 static struct dwp_file *
10642 open_and_init_dwp_file (void)
10643 {
10644 struct objfile *objfile = dwarf2_per_objfile->objfile;
10645 struct dwp_file *dwp_file;
10646 char *dwp_name;
10647 bfd *dbfd;
10648 struct cleanup *cleanups;
10649
10650 /* Try to find first .dwp for the binary file before any symbolic links
10651 resolving. */
10652 dwp_name = xstrprintf ("%s.dwp", objfile->original_name);
10653 cleanups = make_cleanup (xfree, dwp_name);
10654
10655 dbfd = open_dwp_file (dwp_name);
10656 if (dbfd == NULL
10657 && strcmp (objfile->original_name, objfile_name (objfile)) != 0)
10658 {
10659 /* Try to find .dwp for the binary file after gdb_realpath resolving. */
10660 dwp_name = xstrprintf ("%s.dwp", objfile_name (objfile));
10661 make_cleanup (xfree, dwp_name);
10662 dbfd = open_dwp_file (dwp_name);
10663 }
10664
10665 if (dbfd == NULL)
10666 {
10667 if (dwarf2_read_debug)
10668 fprintf_unfiltered (gdb_stdlog, "DWP file not found: %s\n", dwp_name);
10669 do_cleanups (cleanups);
10670 return NULL;
10671 }
10672 dwp_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_file);
10673 dwp_file->name = bfd_get_filename (dbfd);
10674 dwp_file->dbfd = dbfd;
10675 do_cleanups (cleanups);
10676
10677 /* +1: section 0 is unused */
10678 dwp_file->num_sections = bfd_count_sections (dbfd) + 1;
10679 dwp_file->elf_sections =
10680 OBSTACK_CALLOC (&objfile->objfile_obstack,
10681 dwp_file->num_sections, asection *);
10682
10683 bfd_map_over_sections (dbfd, dwarf2_locate_common_dwp_sections, dwp_file);
10684
10685 dwp_file->cus = create_dwp_hash_table (dwp_file, 0);
10686
10687 dwp_file->tus = create_dwp_hash_table (dwp_file, 1);
10688
10689 /* The DWP file version is stored in the hash table. Oh well. */
10690 if (dwp_file->cus->version != dwp_file->tus->version)
10691 {
10692 /* Technically speaking, we should try to limp along, but this is
10693 pretty bizarre. We use pulongest here because that's the established
10694 portability solution (e.g, we cannot use %u for uint32_t). */
10695 error (_("Dwarf Error: DWP file CU version %s doesn't match"
10696 " TU version %s [in DWP file %s]"),
10697 pulongest (dwp_file->cus->version),
10698 pulongest (dwp_file->tus->version), dwp_name);
10699 }
10700 dwp_file->version = dwp_file->cus->version;
10701
10702 if (dwp_file->version == 2)
10703 bfd_map_over_sections (dbfd, dwarf2_locate_v2_dwp_sections, dwp_file);
10704
10705 dwp_file->loaded_cus = allocate_dwp_loaded_cutus_table (objfile);
10706 dwp_file->loaded_tus = allocate_dwp_loaded_cutus_table (objfile);
10707
10708 if (dwarf2_read_debug)
10709 {
10710 fprintf_unfiltered (gdb_stdlog, "DWP file found: %s\n", dwp_file->name);
10711 fprintf_unfiltered (gdb_stdlog,
10712 " %s CUs, %s TUs\n",
10713 pulongest (dwp_file->cus ? dwp_file->cus->nr_units : 0),
10714 pulongest (dwp_file->tus ? dwp_file->tus->nr_units : 0));
10715 }
10716
10717 return dwp_file;
10718 }
10719
10720 /* Wrapper around open_and_init_dwp_file, only open it once. */
10721
10722 static struct dwp_file *
10723 get_dwp_file (void)
10724 {
10725 if (! dwarf2_per_objfile->dwp_checked)
10726 {
10727 dwarf2_per_objfile->dwp_file = open_and_init_dwp_file ();
10728 dwarf2_per_objfile->dwp_checked = 1;
10729 }
10730 return dwarf2_per_objfile->dwp_file;
10731 }
10732
10733 /* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
10734 Look up the CU/TU with signature SIGNATURE, either in DWO file DWO_NAME
10735 or in the DWP file for the objfile, referenced by THIS_UNIT.
10736 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
10737 IS_DEBUG_TYPES is non-zero if reading a TU, otherwise read a CU.
10738
10739 This is called, for example, when wanting to read a variable with a
10740 complex location. Therefore we don't want to do file i/o for every call.
10741 Therefore we don't want to look for a DWO file on every call.
10742 Therefore we first see if we've already seen SIGNATURE in a DWP file,
10743 then we check if we've already seen DWO_NAME, and only THEN do we check
10744 for a DWO file.
10745
10746 The result is a pointer to the dwo_unit object or NULL if we didn't find it
10747 (dwo_id mismatch or couldn't find the DWO/DWP file). */
10748
10749 static struct dwo_unit *
10750 lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit,
10751 const char *dwo_name, const char *comp_dir,
10752 ULONGEST signature, int is_debug_types)
10753 {
10754 struct objfile *objfile = dwarf2_per_objfile->objfile;
10755 const char *kind = is_debug_types ? "TU" : "CU";
10756 void **dwo_file_slot;
10757 struct dwo_file *dwo_file;
10758 struct dwp_file *dwp_file;
10759
10760 /* First see if there's a DWP file.
10761 If we have a DWP file but didn't find the DWO inside it, don't
10762 look for the original DWO file. It makes gdb behave differently
10763 depending on whether one is debugging in the build tree. */
10764
10765 dwp_file = get_dwp_file ();
10766 if (dwp_file != NULL)
10767 {
10768 const struct dwp_hash_table *dwp_htab =
10769 is_debug_types ? dwp_file->tus : dwp_file->cus;
10770
10771 if (dwp_htab != NULL)
10772 {
10773 struct dwo_unit *dwo_cutu =
10774 lookup_dwo_unit_in_dwp (dwp_file, comp_dir,
10775 signature, is_debug_types);
10776
10777 if (dwo_cutu != NULL)
10778 {
10779 if (dwarf2_read_debug)
10780 {
10781 fprintf_unfiltered (gdb_stdlog,
10782 "Virtual DWO %s %s found: @%s\n",
10783 kind, hex_string (signature),
10784 host_address_to_string (dwo_cutu));
10785 }
10786 return dwo_cutu;
10787 }
10788 }
10789 }
10790 else
10791 {
10792 /* No DWP file, look for the DWO file. */
10793
10794 dwo_file_slot = lookup_dwo_file_slot (dwo_name, comp_dir);
10795 if (*dwo_file_slot == NULL)
10796 {
10797 /* Read in the file and build a table of the CUs/TUs it contains. */
10798 *dwo_file_slot = open_and_init_dwo_file (this_unit, dwo_name, comp_dir);
10799 }
10800 /* NOTE: This will be NULL if unable to open the file. */
10801 dwo_file = *dwo_file_slot;
10802
10803 if (dwo_file != NULL)
10804 {
10805 struct dwo_unit *dwo_cutu = NULL;
10806
10807 if (is_debug_types && dwo_file->tus)
10808 {
10809 struct dwo_unit find_dwo_cutu;
10810
10811 memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
10812 find_dwo_cutu.signature = signature;
10813 dwo_cutu = htab_find (dwo_file->tus, &find_dwo_cutu);
10814 }
10815 else if (!is_debug_types && dwo_file->cu)
10816 {
10817 if (signature == dwo_file->cu->signature)
10818 dwo_cutu = dwo_file->cu;
10819 }
10820
10821 if (dwo_cutu != NULL)
10822 {
10823 if (dwarf2_read_debug)
10824 {
10825 fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) found: @%s\n",
10826 kind, dwo_name, hex_string (signature),
10827 host_address_to_string (dwo_cutu));
10828 }
10829 return dwo_cutu;
10830 }
10831 }
10832 }
10833
10834 /* We didn't find it. This could mean a dwo_id mismatch, or
10835 someone deleted the DWO/DWP file, or the search path isn't set up
10836 correctly to find the file. */
10837
10838 if (dwarf2_read_debug)
10839 {
10840 fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) not found\n",
10841 kind, dwo_name, hex_string (signature));
10842 }
10843
10844 /* This is a warning and not a complaint because it can be caused by
10845 pilot error (e.g., user accidentally deleting the DWO). */
10846 {
10847 /* Print the name of the DWP file if we looked there, helps the user
10848 better diagnose the problem. */
10849 char *dwp_text = NULL;
10850 struct cleanup *cleanups;
10851
10852 if (dwp_file != NULL)
10853 dwp_text = xstrprintf (" [in DWP file %s]", lbasename (dwp_file->name));
10854 cleanups = make_cleanup (xfree, dwp_text);
10855
10856 warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset 0x%x"
10857 " [in module %s]"),
10858 kind, dwo_name, hex_string (signature),
10859 dwp_text != NULL ? dwp_text : "",
10860 this_unit->is_debug_types ? "TU" : "CU",
10861 this_unit->offset.sect_off, objfile_name (objfile));
10862
10863 do_cleanups (cleanups);
10864 }
10865 return NULL;
10866 }
10867
10868 /* Lookup the DWO CU DWO_NAME/SIGNATURE referenced from THIS_CU.
10869 See lookup_dwo_cutu_unit for details. */
10870
10871 static struct dwo_unit *
10872 lookup_dwo_comp_unit (struct dwarf2_per_cu_data *this_cu,
10873 const char *dwo_name, const char *comp_dir,
10874 ULONGEST signature)
10875 {
10876 return lookup_dwo_cutu (this_cu, dwo_name, comp_dir, signature, 0);
10877 }
10878
10879 /* Lookup the DWO TU DWO_NAME/SIGNATURE referenced from THIS_TU.
10880 See lookup_dwo_cutu_unit for details. */
10881
10882 static struct dwo_unit *
10883 lookup_dwo_type_unit (struct signatured_type *this_tu,
10884 const char *dwo_name, const char *comp_dir)
10885 {
10886 return lookup_dwo_cutu (&this_tu->per_cu, dwo_name, comp_dir, this_tu->signature, 1);
10887 }
10888
10889 /* Traversal function for queue_and_load_all_dwo_tus. */
10890
10891 static int
10892 queue_and_load_dwo_tu (void **slot, void *info)
10893 {
10894 struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
10895 struct dwarf2_per_cu_data *per_cu = (struct dwarf2_per_cu_data *) info;
10896 ULONGEST signature = dwo_unit->signature;
10897 struct signatured_type *sig_type =
10898 lookup_dwo_signatured_type (per_cu->cu, signature);
10899
10900 if (sig_type != NULL)
10901 {
10902 struct dwarf2_per_cu_data *sig_cu = &sig_type->per_cu;
10903
10904 /* We pass NULL for DEPENDENT_CU because we don't yet know if there's
10905 a real dependency of PER_CU on SIG_TYPE. That is detected later
10906 while processing PER_CU. */
10907 if (maybe_queue_comp_unit (NULL, sig_cu, per_cu->cu->language))
10908 load_full_type_unit (sig_cu);
10909 VEC_safe_push (dwarf2_per_cu_ptr, per_cu->imported_symtabs, sig_cu);
10910 }
10911
10912 return 1;
10913 }
10914
10915 /* Queue all TUs contained in the DWO of PER_CU to be read in.
10916 The DWO may have the only definition of the type, though it may not be
10917 referenced anywhere in PER_CU. Thus we have to load *all* its TUs.
10918 http://sourceware.org/bugzilla/show_bug.cgi?id=15021 */
10919
10920 static void
10921 queue_and_load_all_dwo_tus (struct dwarf2_per_cu_data *per_cu)
10922 {
10923 struct dwo_unit *dwo_unit;
10924 struct dwo_file *dwo_file;
10925
10926 gdb_assert (!per_cu->is_debug_types);
10927 gdb_assert (get_dwp_file () == NULL);
10928 gdb_assert (per_cu->cu != NULL);
10929
10930 dwo_unit = per_cu->cu->dwo_unit;
10931 gdb_assert (dwo_unit != NULL);
10932
10933 dwo_file = dwo_unit->dwo_file;
10934 if (dwo_file->tus != NULL)
10935 htab_traverse_noresize (dwo_file->tus, queue_and_load_dwo_tu, per_cu);
10936 }
10937
10938 /* Free all resources associated with DWO_FILE.
10939 Close the DWO file and munmap the sections.
10940 All memory should be on the objfile obstack. */
10941
10942 static void
10943 free_dwo_file (struct dwo_file *dwo_file, struct objfile *objfile)
10944 {
10945 int ix;
10946 struct dwarf2_section_info *section;
10947
10948 /* Note: dbfd is NULL for virtual DWO files. */
10949 gdb_bfd_unref (dwo_file->dbfd);
10950
10951 VEC_free (dwarf2_section_info_def, dwo_file->sections.types);
10952 }
10953
10954 /* Wrapper for free_dwo_file for use in cleanups. */
10955
10956 static void
10957 free_dwo_file_cleanup (void *arg)
10958 {
10959 struct dwo_file *dwo_file = (struct dwo_file *) arg;
10960 struct objfile *objfile = dwarf2_per_objfile->objfile;
10961
10962 free_dwo_file (dwo_file, objfile);
10963 }
10964
10965 /* Traversal function for free_dwo_files. */
10966
10967 static int
10968 free_dwo_file_from_slot (void **slot, void *info)
10969 {
10970 struct dwo_file *dwo_file = (struct dwo_file *) *slot;
10971 struct objfile *objfile = (struct objfile *) info;
10972
10973 free_dwo_file (dwo_file, objfile);
10974
10975 return 1;
10976 }
10977
10978 /* Free all resources associated with DWO_FILES. */
10979
10980 static void
10981 free_dwo_files (htab_t dwo_files, struct objfile *objfile)
10982 {
10983 htab_traverse_noresize (dwo_files, free_dwo_file_from_slot, objfile);
10984 }
10985 \f
10986 /* Read in various DIEs. */
10987
10988 /* qsort helper for inherit_abstract_dies. */
10989
10990 static int
10991 unsigned_int_compar (const void *ap, const void *bp)
10992 {
10993 unsigned int a = *(unsigned int *) ap;
10994 unsigned int b = *(unsigned int *) bp;
10995
10996 return (a > b) - (b > a);
10997 }
10998
10999 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
11000 Inherit only the children of the DW_AT_abstract_origin DIE not being
11001 already referenced by DW_AT_abstract_origin from the children of the
11002 current DIE. */
11003
11004 static void
11005 inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu)
11006 {
11007 struct die_info *child_die;
11008 unsigned die_children_count;
11009 /* CU offsets which were referenced by children of the current DIE. */
11010 sect_offset *offsets;
11011 sect_offset *offsets_end, *offsetp;
11012 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
11013 struct die_info *origin_die;
11014 /* Iterator of the ORIGIN_DIE children. */
11015 struct die_info *origin_child_die;
11016 struct cleanup *cleanups;
11017 struct attribute *attr;
11018 struct dwarf2_cu *origin_cu;
11019 struct pending **origin_previous_list_in_scope;
11020
11021 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
11022 if (!attr)
11023 return;
11024
11025 /* Note that following die references may follow to a die in a
11026 different cu. */
11027
11028 origin_cu = cu;
11029 origin_die = follow_die_ref (die, attr, &origin_cu);
11030
11031 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
11032 symbols in. */
11033 origin_previous_list_in_scope = origin_cu->list_in_scope;
11034 origin_cu->list_in_scope = cu->list_in_scope;
11035
11036 if (die->tag != origin_die->tag
11037 && !(die->tag == DW_TAG_inlined_subroutine
11038 && origin_die->tag == DW_TAG_subprogram))
11039 complaint (&symfile_complaints,
11040 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
11041 die->offset.sect_off, origin_die->offset.sect_off);
11042
11043 child_die = die->child;
11044 die_children_count = 0;
11045 while (child_die && child_die->tag)
11046 {
11047 child_die = sibling_die (child_die);
11048 die_children_count++;
11049 }
11050 offsets = xmalloc (sizeof (*offsets) * die_children_count);
11051 cleanups = make_cleanup (xfree, offsets);
11052
11053 offsets_end = offsets;
11054 child_die = die->child;
11055 while (child_die && child_die->tag)
11056 {
11057 /* For each CHILD_DIE, find the corresponding child of
11058 ORIGIN_DIE. If there is more than one layer of
11059 DW_AT_abstract_origin, follow them all; there shouldn't be,
11060 but GCC versions at least through 4.4 generate this (GCC PR
11061 40573). */
11062 struct die_info *child_origin_die = child_die;
11063 struct dwarf2_cu *child_origin_cu = cu;
11064
11065 while (1)
11066 {
11067 attr = dwarf2_attr (child_origin_die, DW_AT_abstract_origin,
11068 child_origin_cu);
11069 if (attr == NULL)
11070 break;
11071 child_origin_die = follow_die_ref (child_origin_die, attr,
11072 &child_origin_cu);
11073 }
11074
11075 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
11076 counterpart may exist. */
11077 if (child_origin_die != child_die)
11078 {
11079 if (child_die->tag != child_origin_die->tag
11080 && !(child_die->tag == DW_TAG_inlined_subroutine
11081 && child_origin_die->tag == DW_TAG_subprogram))
11082 complaint (&symfile_complaints,
11083 _("Child DIE 0x%x and its abstract origin 0x%x have "
11084 "different tags"), child_die->offset.sect_off,
11085 child_origin_die->offset.sect_off);
11086 if (child_origin_die->parent != origin_die)
11087 complaint (&symfile_complaints,
11088 _("Child DIE 0x%x and its abstract origin 0x%x have "
11089 "different parents"), child_die->offset.sect_off,
11090 child_origin_die->offset.sect_off);
11091 else
11092 *offsets_end++ = child_origin_die->offset;
11093 }
11094 child_die = sibling_die (child_die);
11095 }
11096 qsort (offsets, offsets_end - offsets, sizeof (*offsets),
11097 unsigned_int_compar);
11098 for (offsetp = offsets + 1; offsetp < offsets_end; offsetp++)
11099 if (offsetp[-1].sect_off == offsetp->sect_off)
11100 complaint (&symfile_complaints,
11101 _("Multiple children of DIE 0x%x refer "
11102 "to DIE 0x%x as their abstract origin"),
11103 die->offset.sect_off, offsetp->sect_off);
11104
11105 offsetp = offsets;
11106 origin_child_die = origin_die->child;
11107 while (origin_child_die && origin_child_die->tag)
11108 {
11109 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
11110 while (offsetp < offsets_end
11111 && offsetp->sect_off < origin_child_die->offset.sect_off)
11112 offsetp++;
11113 if (offsetp >= offsets_end
11114 || offsetp->sect_off > origin_child_die->offset.sect_off)
11115 {
11116 /* Found that ORIGIN_CHILD_DIE is really not referenced.
11117 Check whether we're already processing ORIGIN_CHILD_DIE.
11118 This can happen with mutually referenced abstract_origins.
11119 PR 16581. */
11120 if (!origin_child_die->in_process)
11121 process_die (origin_child_die, origin_cu);
11122 }
11123 origin_child_die = sibling_die (origin_child_die);
11124 }
11125 origin_cu->list_in_scope = origin_previous_list_in_scope;
11126
11127 do_cleanups (cleanups);
11128 }
11129
11130 static void
11131 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
11132 {
11133 struct objfile *objfile = cu->objfile;
11134 struct context_stack *new;
11135 CORE_ADDR lowpc;
11136 CORE_ADDR highpc;
11137 struct die_info *child_die;
11138 struct attribute *attr, *call_line, *call_file;
11139 const char *name;
11140 CORE_ADDR baseaddr;
11141 struct block *block;
11142 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
11143 VEC (symbolp) *template_args = NULL;
11144 struct template_symbol *templ_func = NULL;
11145
11146 if (inlined_func)
11147 {
11148 /* If we do not have call site information, we can't show the
11149 caller of this inlined function. That's too confusing, so
11150 only use the scope for local variables. */
11151 call_line = dwarf2_attr (die, DW_AT_call_line, cu);
11152 call_file = dwarf2_attr (die, DW_AT_call_file, cu);
11153 if (call_line == NULL || call_file == NULL)
11154 {
11155 read_lexical_block_scope (die, cu);
11156 return;
11157 }
11158 }
11159
11160 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11161
11162 name = dwarf2_name (die, cu);
11163
11164 /* Ignore functions with missing or empty names. These are actually
11165 illegal according to the DWARF standard. */
11166 if (name == NULL)
11167 {
11168 complaint (&symfile_complaints,
11169 _("missing name for subprogram DIE at %d"),
11170 die->offset.sect_off);
11171 return;
11172 }
11173
11174 /* Ignore functions with missing or invalid low and high pc attributes. */
11175 if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
11176 {
11177 attr = dwarf2_attr (die, DW_AT_external, cu);
11178 if (!attr || !DW_UNSND (attr))
11179 complaint (&symfile_complaints,
11180 _("cannot get low and high bounds "
11181 "for subprogram DIE at %d"),
11182 die->offset.sect_off);
11183 return;
11184 }
11185
11186 lowpc += baseaddr;
11187 highpc += baseaddr;
11188
11189 /* If we have any template arguments, then we must allocate a
11190 different sort of symbol. */
11191 for (child_die = die->child; child_die; child_die = sibling_die (child_die))
11192 {
11193 if (child_die->tag == DW_TAG_template_type_param
11194 || child_die->tag == DW_TAG_template_value_param)
11195 {
11196 templ_func = allocate_template_symbol (objfile);
11197 templ_func->base.is_cplus_template_function = 1;
11198 break;
11199 }
11200 }
11201
11202 new = push_context (0, lowpc);
11203 new->name = new_symbol_full (die, read_type_die (die, cu), cu,
11204 (struct symbol *) templ_func);
11205
11206 /* If there is a location expression for DW_AT_frame_base, record
11207 it. */
11208 attr = dwarf2_attr (die, DW_AT_frame_base, cu);
11209 if (attr)
11210 dwarf2_symbol_mark_computed (attr, new->name, cu, 1);
11211
11212 cu->list_in_scope = &local_symbols;
11213
11214 if (die->child != NULL)
11215 {
11216 child_die = die->child;
11217 while (child_die && child_die->tag)
11218 {
11219 if (child_die->tag == DW_TAG_template_type_param
11220 || child_die->tag == DW_TAG_template_value_param)
11221 {
11222 struct symbol *arg = new_symbol (child_die, NULL, cu);
11223
11224 if (arg != NULL)
11225 VEC_safe_push (symbolp, template_args, arg);
11226 }
11227 else
11228 process_die (child_die, cu);
11229 child_die = sibling_die (child_die);
11230 }
11231 }
11232
11233 inherit_abstract_dies (die, cu);
11234
11235 /* If we have a DW_AT_specification, we might need to import using
11236 directives from the context of the specification DIE. See the
11237 comment in determine_prefix. */
11238 if (cu->language == language_cplus
11239 && dwarf2_attr (die, DW_AT_specification, cu))
11240 {
11241 struct dwarf2_cu *spec_cu = cu;
11242 struct die_info *spec_die = die_specification (die, &spec_cu);
11243
11244 while (spec_die)
11245 {
11246 child_die = spec_die->child;
11247 while (child_die && child_die->tag)
11248 {
11249 if (child_die->tag == DW_TAG_imported_module)
11250 process_die (child_die, spec_cu);
11251 child_die = sibling_die (child_die);
11252 }
11253
11254 /* In some cases, GCC generates specification DIEs that
11255 themselves contain DW_AT_specification attributes. */
11256 spec_die = die_specification (spec_die, &spec_cu);
11257 }
11258 }
11259
11260 new = pop_context ();
11261 /* Make a block for the local symbols within. */
11262 block = finish_block (new->name, &local_symbols, new->old_blocks,
11263 lowpc, highpc, objfile);
11264
11265 /* For C++, set the block's scope. */
11266 if ((cu->language == language_cplus || cu->language == language_fortran)
11267 && cu->processing_has_namespace_info)
11268 block_set_scope (block, determine_prefix (die, cu),
11269 &objfile->objfile_obstack);
11270
11271 /* If we have address ranges, record them. */
11272 dwarf2_record_block_ranges (die, block, baseaddr, cu);
11273
11274 /* Attach template arguments to function. */
11275 if (! VEC_empty (symbolp, template_args))
11276 {
11277 gdb_assert (templ_func != NULL);
11278
11279 templ_func->n_template_arguments = VEC_length (symbolp, template_args);
11280 templ_func->template_arguments
11281 = obstack_alloc (&objfile->objfile_obstack,
11282 (templ_func->n_template_arguments
11283 * sizeof (struct symbol *)));
11284 memcpy (templ_func->template_arguments,
11285 VEC_address (symbolp, template_args),
11286 (templ_func->n_template_arguments * sizeof (struct symbol *)));
11287 VEC_free (symbolp, template_args);
11288 }
11289
11290 /* In C++, we can have functions nested inside functions (e.g., when
11291 a function declares a class that has methods). This means that
11292 when we finish processing a function scope, we may need to go
11293 back to building a containing block's symbol lists. */
11294 local_symbols = new->locals;
11295 using_directives = new->using_directives;
11296
11297 /* If we've finished processing a top-level function, subsequent
11298 symbols go in the file symbol list. */
11299 if (outermost_context_p ())
11300 cu->list_in_scope = &file_symbols;
11301 }
11302
11303 /* Process all the DIES contained within a lexical block scope. Start
11304 a new scope, process the dies, and then close the scope. */
11305
11306 static void
11307 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
11308 {
11309 struct objfile *objfile = cu->objfile;
11310 struct context_stack *new;
11311 CORE_ADDR lowpc, highpc;
11312 struct die_info *child_die;
11313 CORE_ADDR baseaddr;
11314
11315 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11316
11317 /* Ignore blocks with missing or invalid low and high pc attributes. */
11318 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
11319 as multiple lexical blocks? Handling children in a sane way would
11320 be nasty. Might be easier to properly extend generic blocks to
11321 describe ranges. */
11322 if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
11323 return;
11324 lowpc += baseaddr;
11325 highpc += baseaddr;
11326
11327 push_context (0, lowpc);
11328 if (die->child != NULL)
11329 {
11330 child_die = die->child;
11331 while (child_die && child_die->tag)
11332 {
11333 process_die (child_die, cu);
11334 child_die = sibling_die (child_die);
11335 }
11336 }
11337 new = pop_context ();
11338
11339 if (local_symbols != NULL || using_directives != NULL)
11340 {
11341 struct block *block
11342 = finish_block (0, &local_symbols, new->old_blocks, new->start_addr,
11343 highpc, objfile);
11344
11345 /* Note that recording ranges after traversing children, as we
11346 do here, means that recording a parent's ranges entails
11347 walking across all its children's ranges as they appear in
11348 the address map, which is quadratic behavior.
11349
11350 It would be nicer to record the parent's ranges before
11351 traversing its children, simply overriding whatever you find
11352 there. But since we don't even decide whether to create a
11353 block until after we've traversed its children, that's hard
11354 to do. */
11355 dwarf2_record_block_ranges (die, block, baseaddr, cu);
11356 }
11357 local_symbols = new->locals;
11358 using_directives = new->using_directives;
11359 }
11360
11361 /* Read in DW_TAG_GNU_call_site and insert it to CU->call_site_htab. */
11362
11363 static void
11364 read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
11365 {
11366 struct objfile *objfile = cu->objfile;
11367 struct gdbarch *gdbarch = get_objfile_arch (objfile);
11368 CORE_ADDR pc, baseaddr;
11369 struct attribute *attr;
11370 struct call_site *call_site, call_site_local;
11371 void **slot;
11372 int nparams;
11373 struct die_info *child_die;
11374
11375 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11376
11377 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
11378 if (!attr)
11379 {
11380 complaint (&symfile_complaints,
11381 _("missing DW_AT_low_pc for DW_TAG_GNU_call_site "
11382 "DIE 0x%x [in module %s]"),
11383 die->offset.sect_off, objfile_name (objfile));
11384 return;
11385 }
11386 pc = attr_value_as_address (attr) + baseaddr;
11387
11388 if (cu->call_site_htab == NULL)
11389 cu->call_site_htab = htab_create_alloc_ex (16, core_addr_hash, core_addr_eq,
11390 NULL, &objfile->objfile_obstack,
11391 hashtab_obstack_allocate, NULL);
11392 call_site_local.pc = pc;
11393 slot = htab_find_slot (cu->call_site_htab, &call_site_local, INSERT);
11394 if (*slot != NULL)
11395 {
11396 complaint (&symfile_complaints,
11397 _("Duplicate PC %s for DW_TAG_GNU_call_site "
11398 "DIE 0x%x [in module %s]"),
11399 paddress (gdbarch, pc), die->offset.sect_off,
11400 objfile_name (objfile));
11401 return;
11402 }
11403
11404 /* Count parameters at the caller. */
11405
11406 nparams = 0;
11407 for (child_die = die->child; child_die && child_die->tag;
11408 child_die = sibling_die (child_die))
11409 {
11410 if (child_die->tag != DW_TAG_GNU_call_site_parameter)
11411 {
11412 complaint (&symfile_complaints,
11413 _("Tag %d is not DW_TAG_GNU_call_site_parameter in "
11414 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11415 child_die->tag, child_die->offset.sect_off,
11416 objfile_name (objfile));
11417 continue;
11418 }
11419
11420 nparams++;
11421 }
11422
11423 call_site = obstack_alloc (&objfile->objfile_obstack,
11424 (sizeof (*call_site)
11425 + (sizeof (*call_site->parameter)
11426 * (nparams - 1))));
11427 *slot = call_site;
11428 memset (call_site, 0, sizeof (*call_site) - sizeof (*call_site->parameter));
11429 call_site->pc = pc;
11430
11431 if (dwarf2_flag_true_p (die, DW_AT_GNU_tail_call, cu))
11432 {
11433 struct die_info *func_die;
11434
11435 /* Skip also over DW_TAG_inlined_subroutine. */
11436 for (func_die = die->parent;
11437 func_die && func_die->tag != DW_TAG_subprogram
11438 && func_die->tag != DW_TAG_subroutine_type;
11439 func_die = func_die->parent);
11440
11441 /* DW_AT_GNU_all_call_sites is a superset
11442 of DW_AT_GNU_all_tail_call_sites. */
11443 if (func_die
11444 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_call_sites, cu)
11445 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_tail_call_sites, cu))
11446 {
11447 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
11448 not complete. But keep CALL_SITE for look ups via call_site_htab,
11449 both the initial caller containing the real return address PC and
11450 the final callee containing the current PC of a chain of tail
11451 calls do not need to have the tail call list complete. But any
11452 function candidate for a virtual tail call frame searched via
11453 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
11454 determined unambiguously. */
11455 }
11456 else
11457 {
11458 struct type *func_type = NULL;
11459
11460 if (func_die)
11461 func_type = get_die_type (func_die, cu);
11462 if (func_type != NULL)
11463 {
11464 gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC);
11465
11466 /* Enlist this call site to the function. */
11467 call_site->tail_call_next = TYPE_TAIL_CALL_LIST (func_type);
11468 TYPE_TAIL_CALL_LIST (func_type) = call_site;
11469 }
11470 else
11471 complaint (&symfile_complaints,
11472 _("Cannot find function owning DW_TAG_GNU_call_site "
11473 "DIE 0x%x [in module %s]"),
11474 die->offset.sect_off, objfile_name (objfile));
11475 }
11476 }
11477
11478 attr = dwarf2_attr (die, DW_AT_GNU_call_site_target, cu);
11479 if (attr == NULL)
11480 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
11481 SET_FIELD_DWARF_BLOCK (call_site->target, NULL);
11482 if (!attr || (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0))
11483 /* Keep NULL DWARF_BLOCK. */;
11484 else if (attr_form_is_block (attr))
11485 {
11486 struct dwarf2_locexpr_baton *dlbaton;
11487
11488 dlbaton = obstack_alloc (&objfile->objfile_obstack, sizeof (*dlbaton));
11489 dlbaton->data = DW_BLOCK (attr)->data;
11490 dlbaton->size = DW_BLOCK (attr)->size;
11491 dlbaton->per_cu = cu->per_cu;
11492
11493 SET_FIELD_DWARF_BLOCK (call_site->target, dlbaton);
11494 }
11495 else if (attr_form_is_ref (attr))
11496 {
11497 struct dwarf2_cu *target_cu = cu;
11498 struct die_info *target_die;
11499
11500 target_die = follow_die_ref (die, attr, &target_cu);
11501 gdb_assert (target_cu->objfile == objfile);
11502 if (die_is_declaration (target_die, target_cu))
11503 {
11504 const char *target_physname = NULL;
11505 struct attribute *target_attr;
11506
11507 /* Prefer the mangled name; otherwise compute the demangled one. */
11508 target_attr = dwarf2_attr (target_die, DW_AT_linkage_name, target_cu);
11509 if (target_attr == NULL)
11510 target_attr = dwarf2_attr (target_die, DW_AT_MIPS_linkage_name,
11511 target_cu);
11512 if (target_attr != NULL && DW_STRING (target_attr) != NULL)
11513 target_physname = DW_STRING (target_attr);
11514 else
11515 target_physname = dwarf2_physname (NULL, target_die, target_cu);
11516 if (target_physname == NULL)
11517 complaint (&symfile_complaints,
11518 _("DW_AT_GNU_call_site_target target DIE has invalid "
11519 "physname, for referencing DIE 0x%x [in module %s]"),
11520 die->offset.sect_off, objfile_name (objfile));
11521 else
11522 SET_FIELD_PHYSNAME (call_site->target, target_physname);
11523 }
11524 else
11525 {
11526 CORE_ADDR lowpc;
11527
11528 /* DW_AT_entry_pc should be preferred. */
11529 if (!dwarf2_get_pc_bounds (target_die, &lowpc, NULL, target_cu, NULL))
11530 complaint (&symfile_complaints,
11531 _("DW_AT_GNU_call_site_target target DIE has invalid "
11532 "low pc, for referencing DIE 0x%x [in module %s]"),
11533 die->offset.sect_off, objfile_name (objfile));
11534 else
11535 SET_FIELD_PHYSADDR (call_site->target, lowpc + baseaddr);
11536 }
11537 }
11538 else
11539 complaint (&symfile_complaints,
11540 _("DW_TAG_GNU_call_site DW_AT_GNU_call_site_target is neither "
11541 "block nor reference, for DIE 0x%x [in module %s]"),
11542 die->offset.sect_off, objfile_name (objfile));
11543
11544 call_site->per_cu = cu->per_cu;
11545
11546 for (child_die = die->child;
11547 child_die && child_die->tag;
11548 child_die = sibling_die (child_die))
11549 {
11550 struct call_site_parameter *parameter;
11551 struct attribute *loc, *origin;
11552
11553 if (child_die->tag != DW_TAG_GNU_call_site_parameter)
11554 {
11555 /* Already printed the complaint above. */
11556 continue;
11557 }
11558
11559 gdb_assert (call_site->parameter_count < nparams);
11560 parameter = &call_site->parameter[call_site->parameter_count];
11561
11562 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
11563 specifies DW_TAG_formal_parameter. Value of the data assumed for the
11564 register is contained in DW_AT_GNU_call_site_value. */
11565
11566 loc = dwarf2_attr (child_die, DW_AT_location, cu);
11567 origin = dwarf2_attr (child_die, DW_AT_abstract_origin, cu);
11568 if (loc == NULL && origin != NULL && attr_form_is_ref (origin))
11569 {
11570 sect_offset offset;
11571
11572 parameter->kind = CALL_SITE_PARAMETER_PARAM_OFFSET;
11573 offset = dwarf2_get_ref_die_offset (origin);
11574 if (!offset_in_cu_p (&cu->header, offset))
11575 {
11576 /* As DW_OP_GNU_parameter_ref uses CU-relative offset this
11577 binding can be done only inside one CU. Such referenced DIE
11578 therefore cannot be even moved to DW_TAG_partial_unit. */
11579 complaint (&symfile_complaints,
11580 _("DW_AT_abstract_origin offset is not in CU for "
11581 "DW_TAG_GNU_call_site child DIE 0x%x "
11582 "[in module %s]"),
11583 child_die->offset.sect_off, objfile_name (objfile));
11584 continue;
11585 }
11586 parameter->u.param_offset.cu_off = (offset.sect_off
11587 - cu->header.offset.sect_off);
11588 }
11589 else if (loc == NULL || origin != NULL || !attr_form_is_block (loc))
11590 {
11591 complaint (&symfile_complaints,
11592 _("No DW_FORM_block* DW_AT_location for "
11593 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11594 child_die->offset.sect_off, objfile_name (objfile));
11595 continue;
11596 }
11597 else
11598 {
11599 parameter->u.dwarf_reg = dwarf_block_to_dwarf_reg
11600 (DW_BLOCK (loc)->data, &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size]);
11601 if (parameter->u.dwarf_reg != -1)
11602 parameter->kind = CALL_SITE_PARAMETER_DWARF_REG;
11603 else if (dwarf_block_to_sp_offset (gdbarch, DW_BLOCK (loc)->data,
11604 &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size],
11605 &parameter->u.fb_offset))
11606 parameter->kind = CALL_SITE_PARAMETER_FB_OFFSET;
11607 else
11608 {
11609 complaint (&symfile_complaints,
11610 _("Only single DW_OP_reg or DW_OP_fbreg is supported "
11611 "for DW_FORM_block* DW_AT_location is supported for "
11612 "DW_TAG_GNU_call_site child DIE 0x%x "
11613 "[in module %s]"),
11614 child_die->offset.sect_off, objfile_name (objfile));
11615 continue;
11616 }
11617 }
11618
11619 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_value, cu);
11620 if (!attr_form_is_block (attr))
11621 {
11622 complaint (&symfile_complaints,
11623 _("No DW_FORM_block* DW_AT_GNU_call_site_value for "
11624 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11625 child_die->offset.sect_off, objfile_name (objfile));
11626 continue;
11627 }
11628 parameter->value = DW_BLOCK (attr)->data;
11629 parameter->value_size = DW_BLOCK (attr)->size;
11630
11631 /* Parameters are not pre-cleared by memset above. */
11632 parameter->data_value = NULL;
11633 parameter->data_value_size = 0;
11634 call_site->parameter_count++;
11635
11636 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_data_value, cu);
11637 if (attr)
11638 {
11639 if (!attr_form_is_block (attr))
11640 complaint (&symfile_complaints,
11641 _("No DW_FORM_block* DW_AT_GNU_call_site_data_value for "
11642 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
11643 child_die->offset.sect_off, objfile_name (objfile));
11644 else
11645 {
11646 parameter->data_value = DW_BLOCK (attr)->data;
11647 parameter->data_value_size = DW_BLOCK (attr)->size;
11648 }
11649 }
11650 }
11651 }
11652
11653 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
11654 Return 1 if the attributes are present and valid, otherwise, return 0.
11655 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
11656
11657 static int
11658 dwarf2_ranges_read (unsigned offset, CORE_ADDR *low_return,
11659 CORE_ADDR *high_return, struct dwarf2_cu *cu,
11660 struct partial_symtab *ranges_pst)
11661 {
11662 struct objfile *objfile = cu->objfile;
11663 struct comp_unit_head *cu_header = &cu->header;
11664 bfd *obfd = objfile->obfd;
11665 unsigned int addr_size = cu_header->addr_size;
11666 CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
11667 /* Base address selection entry. */
11668 CORE_ADDR base;
11669 int found_base;
11670 unsigned int dummy;
11671 const gdb_byte *buffer;
11672 CORE_ADDR marker;
11673 int low_set;
11674 CORE_ADDR low = 0;
11675 CORE_ADDR high = 0;
11676 CORE_ADDR baseaddr;
11677
11678 found_base = cu->base_known;
11679 base = cu->base_address;
11680
11681 dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
11682 if (offset >= dwarf2_per_objfile->ranges.size)
11683 {
11684 complaint (&symfile_complaints,
11685 _("Offset %d out of bounds for DW_AT_ranges attribute"),
11686 offset);
11687 return 0;
11688 }
11689 buffer = dwarf2_per_objfile->ranges.buffer + offset;
11690
11691 /* Read in the largest possible address. */
11692 marker = read_address (obfd, buffer, cu, &dummy);
11693 if ((marker & mask) == mask)
11694 {
11695 /* If we found the largest possible address, then
11696 read the base address. */
11697 base = read_address (obfd, buffer + addr_size, cu, &dummy);
11698 buffer += 2 * addr_size;
11699 offset += 2 * addr_size;
11700 found_base = 1;
11701 }
11702
11703 low_set = 0;
11704
11705 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
11706
11707 while (1)
11708 {
11709 CORE_ADDR range_beginning, range_end;
11710
11711 range_beginning = read_address (obfd, buffer, cu, &dummy);
11712 buffer += addr_size;
11713 range_end = read_address (obfd, buffer, cu, &dummy);
11714 buffer += addr_size;
11715 offset += 2 * addr_size;
11716
11717 /* An end of list marker is a pair of zero addresses. */
11718 if (range_beginning == 0 && range_end == 0)
11719 /* Found the end of list entry. */
11720 break;
11721
11722 /* Each base address selection entry is a pair of 2 values.
11723 The first is the largest possible address, the second is
11724 the base address. Check for a base address here. */
11725 if ((range_beginning & mask) == mask)
11726 {
11727 /* If we found the largest possible address, then
11728 read the base address. */
11729 base = read_address (obfd, buffer + addr_size, cu, &dummy);
11730 found_base = 1;
11731 continue;
11732 }
11733
11734 if (!found_base)
11735 {
11736 /* We have no valid base address for the ranges
11737 data. */
11738 complaint (&symfile_complaints,
11739 _("Invalid .debug_ranges data (no base address)"));
11740 return 0;
11741 }
11742
11743 if (range_beginning > range_end)
11744 {
11745 /* Inverted range entries are invalid. */
11746 complaint (&symfile_complaints,
11747 _("Invalid .debug_ranges data (inverted range)"));
11748 return 0;
11749 }
11750
11751 /* Empty range entries have no effect. */
11752 if (range_beginning == range_end)
11753 continue;
11754
11755 range_beginning += base;
11756 range_end += base;
11757
11758 /* A not-uncommon case of bad debug info.
11759 Don't pollute the addrmap with bad data. */
11760 if (range_beginning + baseaddr == 0
11761 && !dwarf2_per_objfile->has_section_at_zero)
11762 {
11763 complaint (&symfile_complaints,
11764 _(".debug_ranges entry has start address of zero"
11765 " [in module %s]"), objfile_name (objfile));
11766 continue;
11767 }
11768
11769 if (ranges_pst != NULL)
11770 addrmap_set_empty (objfile->psymtabs_addrmap,
11771 range_beginning + baseaddr,
11772 range_end - 1 + baseaddr,
11773 ranges_pst);
11774
11775 /* FIXME: This is recording everything as a low-high
11776 segment of consecutive addresses. We should have a
11777 data structure for discontiguous block ranges
11778 instead. */
11779 if (! low_set)
11780 {
11781 low = range_beginning;
11782 high = range_end;
11783 low_set = 1;
11784 }
11785 else
11786 {
11787 if (range_beginning < low)
11788 low = range_beginning;
11789 if (range_end > high)
11790 high = range_end;
11791 }
11792 }
11793
11794 if (! low_set)
11795 /* If the first entry is an end-of-list marker, the range
11796 describes an empty scope, i.e. no instructions. */
11797 return 0;
11798
11799 if (low_return)
11800 *low_return = low;
11801 if (high_return)
11802 *high_return = high;
11803 return 1;
11804 }
11805
11806 /* Get low and high pc attributes from a die. Return 1 if the attributes
11807 are present and valid, otherwise, return 0. Return -1 if the range is
11808 discontinuous, i.e. derived from DW_AT_ranges information. */
11809
11810 static int
11811 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
11812 CORE_ADDR *highpc, struct dwarf2_cu *cu,
11813 struct partial_symtab *pst)
11814 {
11815 struct attribute *attr;
11816 struct attribute *attr_high;
11817 CORE_ADDR low = 0;
11818 CORE_ADDR high = 0;
11819 int ret = 0;
11820
11821 attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
11822 if (attr_high)
11823 {
11824 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
11825 if (attr)
11826 {
11827 low = attr_value_as_address (attr);
11828 high = attr_value_as_address (attr_high);
11829 if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
11830 high += low;
11831 }
11832 else
11833 /* Found high w/o low attribute. */
11834 return 0;
11835
11836 /* Found consecutive range of addresses. */
11837 ret = 1;
11838 }
11839 else
11840 {
11841 attr = dwarf2_attr (die, DW_AT_ranges, cu);
11842 if (attr != NULL)
11843 {
11844 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
11845 We take advantage of the fact that DW_AT_ranges does not appear
11846 in DW_TAG_compile_unit of DWO files. */
11847 int need_ranges_base = die->tag != DW_TAG_compile_unit;
11848 unsigned int ranges_offset = (DW_UNSND (attr)
11849 + (need_ranges_base
11850 ? cu->ranges_base
11851 : 0));
11852
11853 /* Value of the DW_AT_ranges attribute is the offset in the
11854 .debug_ranges section. */
11855 if (!dwarf2_ranges_read (ranges_offset, &low, &high, cu, pst))
11856 return 0;
11857 /* Found discontinuous range of addresses. */
11858 ret = -1;
11859 }
11860 }
11861
11862 /* read_partial_die has also the strict LOW < HIGH requirement. */
11863 if (high <= low)
11864 return 0;
11865
11866 /* When using the GNU linker, .gnu.linkonce. sections are used to
11867 eliminate duplicate copies of functions and vtables and such.
11868 The linker will arbitrarily choose one and discard the others.
11869 The AT_*_pc values for such functions refer to local labels in
11870 these sections. If the section from that file was discarded, the
11871 labels are not in the output, so the relocs get a value of 0.
11872 If this is a discarded function, mark the pc bounds as invalid,
11873 so that GDB will ignore it. */
11874 if (low == 0 && !dwarf2_per_objfile->has_section_at_zero)
11875 return 0;
11876
11877 *lowpc = low;
11878 if (highpc)
11879 *highpc = high;
11880 return ret;
11881 }
11882
11883 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
11884 its low and high PC addresses. Do nothing if these addresses could not
11885 be determined. Otherwise, set LOWPC to the low address if it is smaller,
11886 and HIGHPC to the high address if greater than HIGHPC. */
11887
11888 static void
11889 dwarf2_get_subprogram_pc_bounds (struct die_info *die,
11890 CORE_ADDR *lowpc, CORE_ADDR *highpc,
11891 struct dwarf2_cu *cu)
11892 {
11893 CORE_ADDR low, high;
11894 struct die_info *child = die->child;
11895
11896 if (dwarf2_get_pc_bounds (die, &low, &high, cu, NULL))
11897 {
11898 *lowpc = min (*lowpc, low);
11899 *highpc = max (*highpc, high);
11900 }
11901
11902 /* If the language does not allow nested subprograms (either inside
11903 subprograms or lexical blocks), we're done. */
11904 if (cu->language != language_ada)
11905 return;
11906
11907 /* Check all the children of the given DIE. If it contains nested
11908 subprograms, then check their pc bounds. Likewise, we need to
11909 check lexical blocks as well, as they may also contain subprogram
11910 definitions. */
11911 while (child && child->tag)
11912 {
11913 if (child->tag == DW_TAG_subprogram
11914 || child->tag == DW_TAG_lexical_block)
11915 dwarf2_get_subprogram_pc_bounds (child, lowpc, highpc, cu);
11916 child = sibling_die (child);
11917 }
11918 }
11919
11920 /* Get the low and high pc's represented by the scope DIE, and store
11921 them in *LOWPC and *HIGHPC. If the correct values can't be
11922 determined, set *LOWPC to -1 and *HIGHPC to 0. */
11923
11924 static void
11925 get_scope_pc_bounds (struct die_info *die,
11926 CORE_ADDR *lowpc, CORE_ADDR *highpc,
11927 struct dwarf2_cu *cu)
11928 {
11929 CORE_ADDR best_low = (CORE_ADDR) -1;
11930 CORE_ADDR best_high = (CORE_ADDR) 0;
11931 CORE_ADDR current_low, current_high;
11932
11933 if (dwarf2_get_pc_bounds (die, &current_low, &current_high, cu, NULL))
11934 {
11935 best_low = current_low;
11936 best_high = current_high;
11937 }
11938 else
11939 {
11940 struct die_info *child = die->child;
11941
11942 while (child && child->tag)
11943 {
11944 switch (child->tag) {
11945 case DW_TAG_subprogram:
11946 dwarf2_get_subprogram_pc_bounds (child, &best_low, &best_high, cu);
11947 break;
11948 case DW_TAG_namespace:
11949 case DW_TAG_module:
11950 /* FIXME: carlton/2004-01-16: Should we do this for
11951 DW_TAG_class_type/DW_TAG_structure_type, too? I think
11952 that current GCC's always emit the DIEs corresponding
11953 to definitions of methods of classes as children of a
11954 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
11955 the DIEs giving the declarations, which could be
11956 anywhere). But I don't see any reason why the
11957 standards says that they have to be there. */
11958 get_scope_pc_bounds (child, &current_low, &current_high, cu);
11959
11960 if (current_low != ((CORE_ADDR) -1))
11961 {
11962 best_low = min (best_low, current_low);
11963 best_high = max (best_high, current_high);
11964 }
11965 break;
11966 default:
11967 /* Ignore. */
11968 break;
11969 }
11970
11971 child = sibling_die (child);
11972 }
11973 }
11974
11975 *lowpc = best_low;
11976 *highpc = best_high;
11977 }
11978
11979 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
11980 in DIE. */
11981
11982 static void
11983 dwarf2_record_block_ranges (struct die_info *die, struct block *block,
11984 CORE_ADDR baseaddr, struct dwarf2_cu *cu)
11985 {
11986 struct objfile *objfile = cu->objfile;
11987 struct attribute *attr;
11988 struct attribute *attr_high;
11989
11990 attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
11991 if (attr_high)
11992 {
11993 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
11994 if (attr)
11995 {
11996 CORE_ADDR low = attr_value_as_address (attr);
11997 CORE_ADDR high = attr_value_as_address (attr_high);
11998
11999 if (cu->header.version >= 4 && attr_form_is_constant (attr_high))
12000 high += low;
12001
12002 record_block_range (block, baseaddr + low, baseaddr + high - 1);
12003 }
12004 }
12005
12006 attr = dwarf2_attr (die, DW_AT_ranges, cu);
12007 if (attr)
12008 {
12009 bfd *obfd = objfile->obfd;
12010 /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton.
12011 We take advantage of the fact that DW_AT_ranges does not appear
12012 in DW_TAG_compile_unit of DWO files. */
12013 int need_ranges_base = die->tag != DW_TAG_compile_unit;
12014
12015 /* The value of the DW_AT_ranges attribute is the offset of the
12016 address range list in the .debug_ranges section. */
12017 unsigned long offset = (DW_UNSND (attr)
12018 + (need_ranges_base ? cu->ranges_base : 0));
12019 const gdb_byte *buffer;
12020
12021 /* For some target architectures, but not others, the
12022 read_address function sign-extends the addresses it returns.
12023 To recognize base address selection entries, we need a
12024 mask. */
12025 unsigned int addr_size = cu->header.addr_size;
12026 CORE_ADDR base_select_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
12027
12028 /* The base address, to which the next pair is relative. Note
12029 that this 'base' is a DWARF concept: most entries in a range
12030 list are relative, to reduce the number of relocs against the
12031 debugging information. This is separate from this function's
12032 'baseaddr' argument, which GDB uses to relocate debugging
12033 information from a shared library based on the address at
12034 which the library was loaded. */
12035 CORE_ADDR base = cu->base_address;
12036 int base_known = cu->base_known;
12037
12038 dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
12039 if (offset >= dwarf2_per_objfile->ranges.size)
12040 {
12041 complaint (&symfile_complaints,
12042 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
12043 offset);
12044 return;
12045 }
12046 buffer = dwarf2_per_objfile->ranges.buffer + offset;
12047
12048 for (;;)
12049 {
12050 unsigned int bytes_read;
12051 CORE_ADDR start, end;
12052
12053 start = read_address (obfd, buffer, cu, &bytes_read);
12054 buffer += bytes_read;
12055 end = read_address (obfd, buffer, cu, &bytes_read);
12056 buffer += bytes_read;
12057
12058 /* Did we find the end of the range list? */
12059 if (start == 0 && end == 0)
12060 break;
12061
12062 /* Did we find a base address selection entry? */
12063 else if ((start & base_select_mask) == base_select_mask)
12064 {
12065 base = end;
12066 base_known = 1;
12067 }
12068
12069 /* We found an ordinary address range. */
12070 else
12071 {
12072 if (!base_known)
12073 {
12074 complaint (&symfile_complaints,
12075 _("Invalid .debug_ranges data "
12076 "(no base address)"));
12077 return;
12078 }
12079
12080 if (start > end)
12081 {
12082 /* Inverted range entries are invalid. */
12083 complaint (&symfile_complaints,
12084 _("Invalid .debug_ranges data "
12085 "(inverted range)"));
12086 return;
12087 }
12088
12089 /* Empty range entries have no effect. */
12090 if (start == end)
12091 continue;
12092
12093 start += base + baseaddr;
12094 end += base + baseaddr;
12095
12096 /* A not-uncommon case of bad debug info.
12097 Don't pollute the addrmap with bad data. */
12098 if (start == 0 && !dwarf2_per_objfile->has_section_at_zero)
12099 {
12100 complaint (&symfile_complaints,
12101 _(".debug_ranges entry has start address of zero"
12102 " [in module %s]"), objfile_name (objfile));
12103 continue;
12104 }
12105
12106 record_block_range (block, start, end - 1);
12107 }
12108 }
12109 }
12110 }
12111
12112 /* Check whether the producer field indicates either of GCC < 4.6, or the
12113 Intel C/C++ compiler, and cache the result in CU. */
12114
12115 static void
12116 check_producer (struct dwarf2_cu *cu)
12117 {
12118 const char *cs;
12119 int major, minor, release;
12120
12121 if (cu->producer == NULL)
12122 {
12123 /* For unknown compilers expect their behavior is DWARF version
12124 compliant.
12125
12126 GCC started to support .debug_types sections by -gdwarf-4 since
12127 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
12128 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
12129 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
12130 interpreted incorrectly by GDB now - GCC PR debug/48229. */
12131 }
12132 else if (strncmp (cu->producer, "GNU ", strlen ("GNU ")) == 0)
12133 {
12134 /* Skip any identifier after "GNU " - such as "C++" or "Java". */
12135
12136 cs = &cu->producer[strlen ("GNU ")];
12137 while (*cs && !isdigit (*cs))
12138 cs++;
12139 if (sscanf (cs, "%d.%d.%d", &major, &minor, &release) != 3)
12140 {
12141 /* Not recognized as GCC. */
12142 }
12143 else
12144 {
12145 cu->producer_is_gxx_lt_4_6 = major < 4 || (major == 4 && minor < 6);
12146 cu->producer_is_gcc_lt_4_3 = major < 4 || (major == 4 && minor < 3);
12147 }
12148 }
12149 else if (strncmp (cu->producer, "Intel(R) C", strlen ("Intel(R) C")) == 0)
12150 cu->producer_is_icc = 1;
12151 else
12152 {
12153 /* For other non-GCC compilers, expect their behavior is DWARF version
12154 compliant. */
12155 }
12156
12157 cu->checked_producer = 1;
12158 }
12159
12160 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
12161 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
12162 during 4.6.0 experimental. */
12163
12164 static int
12165 producer_is_gxx_lt_4_6 (struct dwarf2_cu *cu)
12166 {
12167 if (!cu->checked_producer)
12168 check_producer (cu);
12169
12170 return cu->producer_is_gxx_lt_4_6;
12171 }
12172
12173 /* Return the default accessibility type if it is not overriden by
12174 DW_AT_accessibility. */
12175
12176 static enum dwarf_access_attribute
12177 dwarf2_default_access_attribute (struct die_info *die, struct dwarf2_cu *cu)
12178 {
12179 if (cu->header.version < 3 || producer_is_gxx_lt_4_6 (cu))
12180 {
12181 /* The default DWARF 2 accessibility for members is public, the default
12182 accessibility for inheritance is private. */
12183
12184 if (die->tag != DW_TAG_inheritance)
12185 return DW_ACCESS_public;
12186 else
12187 return DW_ACCESS_private;
12188 }
12189 else
12190 {
12191 /* DWARF 3+ defines the default accessibility a different way. The same
12192 rules apply now for DW_TAG_inheritance as for the members and it only
12193 depends on the container kind. */
12194
12195 if (die->parent->tag == DW_TAG_class_type)
12196 return DW_ACCESS_private;
12197 else
12198 return DW_ACCESS_public;
12199 }
12200 }
12201
12202 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
12203 offset. If the attribute was not found return 0, otherwise return
12204 1. If it was found but could not properly be handled, set *OFFSET
12205 to 0. */
12206
12207 static int
12208 handle_data_member_location (struct die_info *die, struct dwarf2_cu *cu,
12209 LONGEST *offset)
12210 {
12211 struct attribute *attr;
12212
12213 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
12214 if (attr != NULL)
12215 {
12216 *offset = 0;
12217
12218 /* Note that we do not check for a section offset first here.
12219 This is because DW_AT_data_member_location is new in DWARF 4,
12220 so if we see it, we can assume that a constant form is really
12221 a constant and not a section offset. */
12222 if (attr_form_is_constant (attr))
12223 *offset = dwarf2_get_attr_constant_value (attr, 0);
12224 else if (attr_form_is_section_offset (attr))
12225 dwarf2_complex_location_expr_complaint ();
12226 else if (attr_form_is_block (attr))
12227 *offset = decode_locdesc (DW_BLOCK (attr), cu);
12228 else
12229 dwarf2_complex_location_expr_complaint ();
12230
12231 return 1;
12232 }
12233
12234 return 0;
12235 }
12236
12237 /* Add an aggregate field to the field list. */
12238
12239 static void
12240 dwarf2_add_field (struct field_info *fip, struct die_info *die,
12241 struct dwarf2_cu *cu)
12242 {
12243 struct objfile *objfile = cu->objfile;
12244 struct gdbarch *gdbarch = get_objfile_arch (objfile);
12245 struct nextfield *new_field;
12246 struct attribute *attr;
12247 struct field *fp;
12248 const char *fieldname = "";
12249
12250 /* Allocate a new field list entry and link it in. */
12251 new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield));
12252 make_cleanup (xfree, new_field);
12253 memset (new_field, 0, sizeof (struct nextfield));
12254
12255 if (die->tag == DW_TAG_inheritance)
12256 {
12257 new_field->next = fip->baseclasses;
12258 fip->baseclasses = new_field;
12259 }
12260 else
12261 {
12262 new_field->next = fip->fields;
12263 fip->fields = new_field;
12264 }
12265 fip->nfields++;
12266
12267 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
12268 if (attr)
12269 new_field->accessibility = DW_UNSND (attr);
12270 else
12271 new_field->accessibility = dwarf2_default_access_attribute (die, cu);
12272 if (new_field->accessibility != DW_ACCESS_public)
12273 fip->non_public_fields = 1;
12274
12275 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
12276 if (attr)
12277 new_field->virtuality = DW_UNSND (attr);
12278 else
12279 new_field->virtuality = DW_VIRTUALITY_none;
12280
12281 fp = &new_field->field;
12282
12283 if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
12284 {
12285 LONGEST offset;
12286
12287 /* Data member other than a C++ static data member. */
12288
12289 /* Get type of field. */
12290 fp->type = die_type (die, cu);
12291
12292 SET_FIELD_BITPOS (*fp, 0);
12293
12294 /* Get bit size of field (zero if none). */
12295 attr = dwarf2_attr (die, DW_AT_bit_size, cu);
12296 if (attr)
12297 {
12298 FIELD_BITSIZE (*fp) = DW_UNSND (attr);
12299 }
12300 else
12301 {
12302 FIELD_BITSIZE (*fp) = 0;
12303 }
12304
12305 /* Get bit offset of field. */
12306 if (handle_data_member_location (die, cu, &offset))
12307 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
12308 attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
12309 if (attr)
12310 {
12311 if (gdbarch_bits_big_endian (gdbarch))
12312 {
12313 /* For big endian bits, the DW_AT_bit_offset gives the
12314 additional bit offset from the MSB of the containing
12315 anonymous object to the MSB of the field. We don't
12316 have to do anything special since we don't need to
12317 know the size of the anonymous object. */
12318 SET_FIELD_BITPOS (*fp, FIELD_BITPOS (*fp) + DW_UNSND (attr));
12319 }
12320 else
12321 {
12322 /* For little endian bits, compute the bit offset to the
12323 MSB of the anonymous object, subtract off the number of
12324 bits from the MSB of the field to the MSB of the
12325 object, and then subtract off the number of bits of
12326 the field itself. The result is the bit offset of
12327 the LSB of the field. */
12328 int anonymous_size;
12329 int bit_offset = DW_UNSND (attr);
12330
12331 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
12332 if (attr)
12333 {
12334 /* The size of the anonymous object containing
12335 the bit field is explicit, so use the
12336 indicated size (in bytes). */
12337 anonymous_size = DW_UNSND (attr);
12338 }
12339 else
12340 {
12341 /* The size of the anonymous object containing
12342 the bit field must be inferred from the type
12343 attribute of the data member containing the
12344 bit field. */
12345 anonymous_size = TYPE_LENGTH (fp->type);
12346 }
12347 SET_FIELD_BITPOS (*fp,
12348 (FIELD_BITPOS (*fp)
12349 + anonymous_size * bits_per_byte
12350 - bit_offset - FIELD_BITSIZE (*fp)));
12351 }
12352 }
12353
12354 /* Get name of field. */
12355 fieldname = dwarf2_name (die, cu);
12356 if (fieldname == NULL)
12357 fieldname = "";
12358
12359 /* The name is already allocated along with this objfile, so we don't
12360 need to duplicate it for the type. */
12361 fp->name = fieldname;
12362
12363 /* Change accessibility for artificial fields (e.g. virtual table
12364 pointer or virtual base class pointer) to private. */
12365 if (dwarf2_attr (die, DW_AT_artificial, cu))
12366 {
12367 FIELD_ARTIFICIAL (*fp) = 1;
12368 new_field->accessibility = DW_ACCESS_private;
12369 fip->non_public_fields = 1;
12370 }
12371 }
12372 else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
12373 {
12374 /* C++ static member. */
12375
12376 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
12377 is a declaration, but all versions of G++ as of this writing
12378 (so through at least 3.2.1) incorrectly generate
12379 DW_TAG_variable tags. */
12380
12381 const char *physname;
12382
12383 /* Get name of field. */
12384 fieldname = dwarf2_name (die, cu);
12385 if (fieldname == NULL)
12386 return;
12387
12388 attr = dwarf2_attr (die, DW_AT_const_value, cu);
12389 if (attr
12390 /* Only create a symbol if this is an external value.
12391 new_symbol checks this and puts the value in the global symbol
12392 table, which we want. If it is not external, new_symbol
12393 will try to put the value in cu->list_in_scope which is wrong. */
12394 && dwarf2_flag_true_p (die, DW_AT_external, cu))
12395 {
12396 /* A static const member, not much different than an enum as far as
12397 we're concerned, except that we can support more types. */
12398 new_symbol (die, NULL, cu);
12399 }
12400
12401 /* Get physical name. */
12402 physname = dwarf2_physname (fieldname, die, cu);
12403
12404 /* The name is already allocated along with this objfile, so we don't
12405 need to duplicate it for the type. */
12406 SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
12407 FIELD_TYPE (*fp) = die_type (die, cu);
12408 FIELD_NAME (*fp) = fieldname;
12409 }
12410 else if (die->tag == DW_TAG_inheritance)
12411 {
12412 LONGEST offset;
12413
12414 /* C++ base class field. */
12415 if (handle_data_member_location (die, cu, &offset))
12416 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
12417 FIELD_BITSIZE (*fp) = 0;
12418 FIELD_TYPE (*fp) = die_type (die, cu);
12419 FIELD_NAME (*fp) = type_name_no_tag (fp->type);
12420 fip->nbaseclasses++;
12421 }
12422 }
12423
12424 /* Add a typedef defined in the scope of the FIP's class. */
12425
12426 static void
12427 dwarf2_add_typedef (struct field_info *fip, struct die_info *die,
12428 struct dwarf2_cu *cu)
12429 {
12430 struct objfile *objfile = cu->objfile;
12431 struct typedef_field_list *new_field;
12432 struct attribute *attr;
12433 struct typedef_field *fp;
12434 char *fieldname = "";
12435
12436 /* Allocate a new field list entry and link it in. */
12437 new_field = xzalloc (sizeof (*new_field));
12438 make_cleanup (xfree, new_field);
12439
12440 gdb_assert (die->tag == DW_TAG_typedef);
12441
12442 fp = &new_field->field;
12443
12444 /* Get name of field. */
12445 fp->name = dwarf2_name (die, cu);
12446 if (fp->name == NULL)
12447 return;
12448
12449 fp->type = read_type_die (die, cu);
12450
12451 new_field->next = fip->typedef_field_list;
12452 fip->typedef_field_list = new_field;
12453 fip->typedef_field_list_count++;
12454 }
12455
12456 /* Create the vector of fields, and attach it to the type. */
12457
12458 static void
12459 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
12460 struct dwarf2_cu *cu)
12461 {
12462 int nfields = fip->nfields;
12463
12464 /* Record the field count, allocate space for the array of fields,
12465 and create blank accessibility bitfields if necessary. */
12466 TYPE_NFIELDS (type) = nfields;
12467 TYPE_FIELDS (type) = (struct field *)
12468 TYPE_ALLOC (type, sizeof (struct field) * nfields);
12469 memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
12470
12471 if (fip->non_public_fields && cu->language != language_ada)
12472 {
12473 ALLOCATE_CPLUS_STRUCT_TYPE (type);
12474
12475 TYPE_FIELD_PRIVATE_BITS (type) =
12476 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
12477 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
12478
12479 TYPE_FIELD_PROTECTED_BITS (type) =
12480 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
12481 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
12482
12483 TYPE_FIELD_IGNORE_BITS (type) =
12484 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
12485 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
12486 }
12487
12488 /* If the type has baseclasses, allocate and clear a bit vector for
12489 TYPE_FIELD_VIRTUAL_BITS. */
12490 if (fip->nbaseclasses && cu->language != language_ada)
12491 {
12492 int num_bytes = B_BYTES (fip->nbaseclasses);
12493 unsigned char *pointer;
12494
12495 ALLOCATE_CPLUS_STRUCT_TYPE (type);
12496 pointer = TYPE_ALLOC (type, num_bytes);
12497 TYPE_FIELD_VIRTUAL_BITS (type) = pointer;
12498 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->nbaseclasses);
12499 TYPE_N_BASECLASSES (type) = fip->nbaseclasses;
12500 }
12501
12502 /* Copy the saved-up fields into the field vector. Start from the head of
12503 the list, adding to the tail of the field array, so that they end up in
12504 the same order in the array in which they were added to the list. */
12505 while (nfields-- > 0)
12506 {
12507 struct nextfield *fieldp;
12508
12509 if (fip->fields)
12510 {
12511 fieldp = fip->fields;
12512 fip->fields = fieldp->next;
12513 }
12514 else
12515 {
12516 fieldp = fip->baseclasses;
12517 fip->baseclasses = fieldp->next;
12518 }
12519
12520 TYPE_FIELD (type, nfields) = fieldp->field;
12521 switch (fieldp->accessibility)
12522 {
12523 case DW_ACCESS_private:
12524 if (cu->language != language_ada)
12525 SET_TYPE_FIELD_PRIVATE (type, nfields);
12526 break;
12527
12528 case DW_ACCESS_protected:
12529 if (cu->language != language_ada)
12530 SET_TYPE_FIELD_PROTECTED (type, nfields);
12531 break;
12532
12533 case DW_ACCESS_public:
12534 break;
12535
12536 default:
12537 /* Unknown accessibility. Complain and treat it as public. */
12538 {
12539 complaint (&symfile_complaints, _("unsupported accessibility %d"),
12540 fieldp->accessibility);
12541 }
12542 break;
12543 }
12544 if (nfields < fip->nbaseclasses)
12545 {
12546 switch (fieldp->virtuality)
12547 {
12548 case DW_VIRTUALITY_virtual:
12549 case DW_VIRTUALITY_pure_virtual:
12550 if (cu->language == language_ada)
12551 error (_("unexpected virtuality in component of Ada type"));
12552 SET_TYPE_FIELD_VIRTUAL (type, nfields);
12553 break;
12554 }
12555 }
12556 }
12557 }
12558
12559 /* Return true if this member function is a constructor, false
12560 otherwise. */
12561
12562 static int
12563 dwarf2_is_constructor (struct die_info *die, struct dwarf2_cu *cu)
12564 {
12565 const char *fieldname;
12566 const char *typename;
12567 int len;
12568
12569 if (die->parent == NULL)
12570 return 0;
12571
12572 if (die->parent->tag != DW_TAG_structure_type
12573 && die->parent->tag != DW_TAG_union_type
12574 && die->parent->tag != DW_TAG_class_type)
12575 return 0;
12576
12577 fieldname = dwarf2_name (die, cu);
12578 typename = dwarf2_name (die->parent, cu);
12579 if (fieldname == NULL || typename == NULL)
12580 return 0;
12581
12582 len = strlen (fieldname);
12583 return (strncmp (fieldname, typename, len) == 0
12584 && (typename[len] == '\0' || typename[len] == '<'));
12585 }
12586
12587 /* Add a member function to the proper fieldlist. */
12588
12589 static void
12590 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
12591 struct type *type, struct dwarf2_cu *cu)
12592 {
12593 struct objfile *objfile = cu->objfile;
12594 struct attribute *attr;
12595 struct fnfieldlist *flp;
12596 int i;
12597 struct fn_field *fnp;
12598 const char *fieldname;
12599 struct nextfnfield *new_fnfield;
12600 struct type *this_type;
12601 enum dwarf_access_attribute accessibility;
12602
12603 if (cu->language == language_ada)
12604 error (_("unexpected member function in Ada type"));
12605
12606 /* Get name of member function. */
12607 fieldname = dwarf2_name (die, cu);
12608 if (fieldname == NULL)
12609 return;
12610
12611 /* Look up member function name in fieldlist. */
12612 for (i = 0; i < fip->nfnfields; i++)
12613 {
12614 if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
12615 break;
12616 }
12617
12618 /* Create new list element if necessary. */
12619 if (i < fip->nfnfields)
12620 flp = &fip->fnfieldlists[i];
12621 else
12622 {
12623 if ((fip->nfnfields % DW_FIELD_ALLOC_CHUNK) == 0)
12624 {
12625 fip->fnfieldlists = (struct fnfieldlist *)
12626 xrealloc (fip->fnfieldlists,
12627 (fip->nfnfields + DW_FIELD_ALLOC_CHUNK)
12628 * sizeof (struct fnfieldlist));
12629 if (fip->nfnfields == 0)
12630 make_cleanup (free_current_contents, &fip->fnfieldlists);
12631 }
12632 flp = &fip->fnfieldlists[fip->nfnfields];
12633 flp->name = fieldname;
12634 flp->length = 0;
12635 flp->head = NULL;
12636 i = fip->nfnfields++;
12637 }
12638
12639 /* Create a new member function field and chain it to the field list
12640 entry. */
12641 new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield));
12642 make_cleanup (xfree, new_fnfield);
12643 memset (new_fnfield, 0, sizeof (struct nextfnfield));
12644 new_fnfield->next = flp->head;
12645 flp->head = new_fnfield;
12646 flp->length++;
12647
12648 /* Fill in the member function field info. */
12649 fnp = &new_fnfield->fnfield;
12650
12651 /* Delay processing of the physname until later. */
12652 if (cu->language == language_cplus || cu->language == language_java)
12653 {
12654 add_to_method_list (type, i, flp->length - 1, fieldname,
12655 die, cu);
12656 }
12657 else
12658 {
12659 const char *physname = dwarf2_physname (fieldname, die, cu);
12660 fnp->physname = physname ? physname : "";
12661 }
12662
12663 fnp->type = alloc_type (objfile);
12664 this_type = read_type_die (die, cu);
12665 if (this_type && TYPE_CODE (this_type) == TYPE_CODE_FUNC)
12666 {
12667 int nparams = TYPE_NFIELDS (this_type);
12668
12669 /* TYPE is the domain of this method, and THIS_TYPE is the type
12670 of the method itself (TYPE_CODE_METHOD). */
12671 smash_to_method_type (fnp->type, type,
12672 TYPE_TARGET_TYPE (this_type),
12673 TYPE_FIELDS (this_type),
12674 TYPE_NFIELDS (this_type),
12675 TYPE_VARARGS (this_type));
12676
12677 /* Handle static member functions.
12678 Dwarf2 has no clean way to discern C++ static and non-static
12679 member functions. G++ helps GDB by marking the first
12680 parameter for non-static member functions (which is the this
12681 pointer) as artificial. We obtain this information from
12682 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
12683 if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (this_type, 0) == 0)
12684 fnp->voffset = VOFFSET_STATIC;
12685 }
12686 else
12687 complaint (&symfile_complaints, _("member function type missing for '%s'"),
12688 dwarf2_full_name (fieldname, die, cu));
12689
12690 /* Get fcontext from DW_AT_containing_type if present. */
12691 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
12692 fnp->fcontext = die_containing_type (die, cu);
12693
12694 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
12695 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
12696
12697 /* Get accessibility. */
12698 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
12699 if (attr)
12700 accessibility = DW_UNSND (attr);
12701 else
12702 accessibility = dwarf2_default_access_attribute (die, cu);
12703 switch (accessibility)
12704 {
12705 case DW_ACCESS_private:
12706 fnp->is_private = 1;
12707 break;
12708 case DW_ACCESS_protected:
12709 fnp->is_protected = 1;
12710 break;
12711 }
12712
12713 /* Check for artificial methods. */
12714 attr = dwarf2_attr (die, DW_AT_artificial, cu);
12715 if (attr && DW_UNSND (attr) != 0)
12716 fnp->is_artificial = 1;
12717
12718 fnp->is_constructor = dwarf2_is_constructor (die, cu);
12719
12720 /* Get index in virtual function table if it is a virtual member
12721 function. For older versions of GCC, this is an offset in the
12722 appropriate virtual table, as specified by DW_AT_containing_type.
12723 For everyone else, it is an expression to be evaluated relative
12724 to the object address. */
12725
12726 attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
12727 if (attr)
12728 {
12729 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size > 0)
12730 {
12731 if (DW_BLOCK (attr)->data[0] == DW_OP_constu)
12732 {
12733 /* Old-style GCC. */
12734 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
12735 }
12736 else if (DW_BLOCK (attr)->data[0] == DW_OP_deref
12737 || (DW_BLOCK (attr)->size > 1
12738 && DW_BLOCK (attr)->data[0] == DW_OP_deref_size
12739 && DW_BLOCK (attr)->data[1] == cu->header.addr_size))
12740 {
12741 struct dwarf_block blk;
12742 int offset;
12743
12744 offset = (DW_BLOCK (attr)->data[0] == DW_OP_deref
12745 ? 1 : 2);
12746 blk.size = DW_BLOCK (attr)->size - offset;
12747 blk.data = DW_BLOCK (attr)->data + offset;
12748 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu);
12749 if ((fnp->voffset % cu->header.addr_size) != 0)
12750 dwarf2_complex_location_expr_complaint ();
12751 else
12752 fnp->voffset /= cu->header.addr_size;
12753 fnp->voffset += 2;
12754 }
12755 else
12756 dwarf2_complex_location_expr_complaint ();
12757
12758 if (!fnp->fcontext)
12759 fnp->fcontext = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type, 0));
12760 }
12761 else if (attr_form_is_section_offset (attr))
12762 {
12763 dwarf2_complex_location_expr_complaint ();
12764 }
12765 else
12766 {
12767 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
12768 fieldname);
12769 }
12770 }
12771 else
12772 {
12773 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
12774 if (attr && DW_UNSND (attr))
12775 {
12776 /* GCC does this, as of 2008-08-25; PR debug/37237. */
12777 complaint (&symfile_complaints,
12778 _("Member function \"%s\" (offset %d) is virtual "
12779 "but the vtable offset is not specified"),
12780 fieldname, die->offset.sect_off);
12781 ALLOCATE_CPLUS_STRUCT_TYPE (type);
12782 TYPE_CPLUS_DYNAMIC (type) = 1;
12783 }
12784 }
12785 }
12786
12787 /* Create the vector of member function fields, and attach it to the type. */
12788
12789 static void
12790 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
12791 struct dwarf2_cu *cu)
12792 {
12793 struct fnfieldlist *flp;
12794 int i;
12795
12796 if (cu->language == language_ada)
12797 error (_("unexpected member functions in Ada type"));
12798
12799 ALLOCATE_CPLUS_STRUCT_TYPE (type);
12800 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
12801 TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * fip->nfnfields);
12802
12803 for (i = 0, flp = fip->fnfieldlists; i < fip->nfnfields; i++, flp++)
12804 {
12805 struct nextfnfield *nfp = flp->head;
12806 struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
12807 int k;
12808
12809 TYPE_FN_FIELDLIST_NAME (type, i) = flp->name;
12810 TYPE_FN_FIELDLIST_LENGTH (type, i) = flp->length;
12811 fn_flp->fn_fields = (struct fn_field *)
12812 TYPE_ALLOC (type, sizeof (struct fn_field) * flp->length);
12813 for (k = flp->length; (k--, nfp); nfp = nfp->next)
12814 fn_flp->fn_fields[k] = nfp->fnfield;
12815 }
12816
12817 TYPE_NFN_FIELDS (type) = fip->nfnfields;
12818 }
12819
12820 /* Returns non-zero if NAME is the name of a vtable member in CU's
12821 language, zero otherwise. */
12822 static int
12823 is_vtable_name (const char *name, struct dwarf2_cu *cu)
12824 {
12825 static const char vptr[] = "_vptr";
12826 static const char vtable[] = "vtable";
12827
12828 /* Look for the C++ and Java forms of the vtable. */
12829 if ((cu->language == language_java
12830 && strncmp (name, vtable, sizeof (vtable) - 1) == 0)
12831 || (strncmp (name, vptr, sizeof (vptr) - 1) == 0
12832 && is_cplus_marker (name[sizeof (vptr) - 1])))
12833 return 1;
12834
12835 return 0;
12836 }
12837
12838 /* GCC outputs unnamed structures that are really pointers to member
12839 functions, with the ABI-specified layout. If TYPE describes
12840 such a structure, smash it into a member function type.
12841
12842 GCC shouldn't do this; it should just output pointer to member DIEs.
12843 This is GCC PR debug/28767. */
12844
12845 static void
12846 quirk_gcc_member_function_pointer (struct type *type, struct objfile *objfile)
12847 {
12848 struct type *pfn_type, *domain_type, *new_type;
12849
12850 /* Check for a structure with no name and two children. */
12851 if (TYPE_CODE (type) != TYPE_CODE_STRUCT || TYPE_NFIELDS (type) != 2)
12852 return;
12853
12854 /* Check for __pfn and __delta members. */
12855 if (TYPE_FIELD_NAME (type, 0) == NULL
12856 || strcmp (TYPE_FIELD_NAME (type, 0), "__pfn") != 0
12857 || TYPE_FIELD_NAME (type, 1) == NULL
12858 || strcmp (TYPE_FIELD_NAME (type, 1), "__delta") != 0)
12859 return;
12860
12861 /* Find the type of the method. */
12862 pfn_type = TYPE_FIELD_TYPE (type, 0);
12863 if (pfn_type == NULL
12864 || TYPE_CODE (pfn_type) != TYPE_CODE_PTR
12865 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type)) != TYPE_CODE_FUNC)
12866 return;
12867
12868 /* Look for the "this" argument. */
12869 pfn_type = TYPE_TARGET_TYPE (pfn_type);
12870 if (TYPE_NFIELDS (pfn_type) == 0
12871 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
12872 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type, 0)) != TYPE_CODE_PTR)
12873 return;
12874
12875 domain_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0));
12876 new_type = alloc_type (objfile);
12877 smash_to_method_type (new_type, domain_type, TYPE_TARGET_TYPE (pfn_type),
12878 TYPE_FIELDS (pfn_type), TYPE_NFIELDS (pfn_type),
12879 TYPE_VARARGS (pfn_type));
12880 smash_to_methodptr_type (type, new_type);
12881 }
12882
12883 /* Return non-zero if the CU's PRODUCER string matches the Intel C/C++ compiler
12884 (icc). */
12885
12886 static int
12887 producer_is_icc (struct dwarf2_cu *cu)
12888 {
12889 if (!cu->checked_producer)
12890 check_producer (cu);
12891
12892 return cu->producer_is_icc;
12893 }
12894
12895 /* Called when we find the DIE that starts a structure or union scope
12896 (definition) to create a type for the structure or union. Fill in
12897 the type's name and general properties; the members will not be
12898 processed until process_structure_scope. A symbol table entry for
12899 the type will also not be done until process_structure_scope (assuming
12900 the type has a name).
12901
12902 NOTE: we need to call these functions regardless of whether or not the
12903 DIE has a DW_AT_name attribute, since it might be an anonymous
12904 structure or union. This gets the type entered into our set of
12905 user defined types. */
12906
12907 static struct type *
12908 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
12909 {
12910 struct objfile *objfile = cu->objfile;
12911 struct type *type;
12912 struct attribute *attr;
12913 const char *name;
12914
12915 /* If the definition of this type lives in .debug_types, read that type.
12916 Don't follow DW_AT_specification though, that will take us back up
12917 the chain and we want to go down. */
12918 attr = dwarf2_attr_no_follow (die, DW_AT_signature);
12919 if (attr)
12920 {
12921 type = get_DW_AT_signature_type (die, attr, cu);
12922
12923 /* The type's CU may not be the same as CU.
12924 Ensure TYPE is recorded with CU in die_type_hash. */
12925 return set_die_type (die, type, cu);
12926 }
12927
12928 type = alloc_type (objfile);
12929 INIT_CPLUS_SPECIFIC (type);
12930
12931 name = dwarf2_name (die, cu);
12932 if (name != NULL)
12933 {
12934 if (cu->language == language_cplus
12935 || cu->language == language_java)
12936 {
12937 const char *full_name = dwarf2_full_name (name, die, cu);
12938
12939 /* dwarf2_full_name might have already finished building the DIE's
12940 type. If so, there is no need to continue. */
12941 if (get_die_type (die, cu) != NULL)
12942 return get_die_type (die, cu);
12943
12944 TYPE_TAG_NAME (type) = full_name;
12945 if (die->tag == DW_TAG_structure_type
12946 || die->tag == DW_TAG_class_type)
12947 TYPE_NAME (type) = TYPE_TAG_NAME (type);
12948 }
12949 else
12950 {
12951 /* The name is already allocated along with this objfile, so
12952 we don't need to duplicate it for the type. */
12953 TYPE_TAG_NAME (type) = name;
12954 if (die->tag == DW_TAG_class_type)
12955 TYPE_NAME (type) = TYPE_TAG_NAME (type);
12956 }
12957 }
12958
12959 if (die->tag == DW_TAG_structure_type)
12960 {
12961 TYPE_CODE (type) = TYPE_CODE_STRUCT;
12962 }
12963 else if (die->tag == DW_TAG_union_type)
12964 {
12965 TYPE_CODE (type) = TYPE_CODE_UNION;
12966 }
12967 else
12968 {
12969 TYPE_CODE (type) = TYPE_CODE_CLASS;
12970 }
12971
12972 if (cu->language == language_cplus && die->tag == DW_TAG_class_type)
12973 TYPE_DECLARED_CLASS (type) = 1;
12974
12975 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
12976 if (attr)
12977 {
12978 TYPE_LENGTH (type) = DW_UNSND (attr);
12979 }
12980 else
12981 {
12982 TYPE_LENGTH (type) = 0;
12983 }
12984
12985 if (producer_is_icc (cu) && (TYPE_LENGTH (type) == 0))
12986 {
12987 /* ICC does not output the required DW_AT_declaration
12988 on incomplete types, but gives them a size of zero. */
12989 TYPE_STUB (type) = 1;
12990 }
12991 else
12992 TYPE_STUB_SUPPORTED (type) = 1;
12993
12994 if (die_is_declaration (die, cu))
12995 TYPE_STUB (type) = 1;
12996 else if (attr == NULL && die->child == NULL
12997 && producer_is_realview (cu->producer))
12998 /* RealView does not output the required DW_AT_declaration
12999 on incomplete types. */
13000 TYPE_STUB (type) = 1;
13001
13002 /* We need to add the type field to the die immediately so we don't
13003 infinitely recurse when dealing with pointers to the structure
13004 type within the structure itself. */
13005 set_die_type (die, type, cu);
13006
13007 /* set_die_type should be already done. */
13008 set_descriptive_type (type, die, cu);
13009
13010 return type;
13011 }
13012
13013 /* Finish creating a structure or union type, including filling in
13014 its members and creating a symbol for it. */
13015
13016 static void
13017 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
13018 {
13019 struct objfile *objfile = cu->objfile;
13020 struct die_info *child_die = die->child;
13021 struct type *type;
13022
13023 type = get_die_type (die, cu);
13024 if (type == NULL)
13025 type = read_structure_type (die, cu);
13026
13027 if (die->child != NULL && ! die_is_declaration (die, cu))
13028 {
13029 struct field_info fi;
13030 struct die_info *child_die;
13031 VEC (symbolp) *template_args = NULL;
13032 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
13033
13034 memset (&fi, 0, sizeof (struct field_info));
13035
13036 child_die = die->child;
13037
13038 while (child_die && child_die->tag)
13039 {
13040 if (child_die->tag == DW_TAG_member
13041 || child_die->tag == DW_TAG_variable)
13042 {
13043 /* NOTE: carlton/2002-11-05: A C++ static data member
13044 should be a DW_TAG_member that is a declaration, but
13045 all versions of G++ as of this writing (so through at
13046 least 3.2.1) incorrectly generate DW_TAG_variable
13047 tags for them instead. */
13048 dwarf2_add_field (&fi, child_die, cu);
13049 }
13050 else if (child_die->tag == DW_TAG_subprogram)
13051 {
13052 /* C++ member function. */
13053 dwarf2_add_member_fn (&fi, child_die, type, cu);
13054 }
13055 else if (child_die->tag == DW_TAG_inheritance)
13056 {
13057 /* C++ base class field. */
13058 dwarf2_add_field (&fi, child_die, cu);
13059 }
13060 else if (child_die->tag == DW_TAG_typedef)
13061 dwarf2_add_typedef (&fi, child_die, cu);
13062 else if (child_die->tag == DW_TAG_template_type_param
13063 || child_die->tag == DW_TAG_template_value_param)
13064 {
13065 struct symbol *arg = new_symbol (child_die, NULL, cu);
13066
13067 if (arg != NULL)
13068 VEC_safe_push (symbolp, template_args, arg);
13069 }
13070
13071 child_die = sibling_die (child_die);
13072 }
13073
13074 /* Attach template arguments to type. */
13075 if (! VEC_empty (symbolp, template_args))
13076 {
13077 ALLOCATE_CPLUS_STRUCT_TYPE (type);
13078 TYPE_N_TEMPLATE_ARGUMENTS (type)
13079 = VEC_length (symbolp, template_args);
13080 TYPE_TEMPLATE_ARGUMENTS (type)
13081 = obstack_alloc (&objfile->objfile_obstack,
13082 (TYPE_N_TEMPLATE_ARGUMENTS (type)
13083 * sizeof (struct symbol *)));
13084 memcpy (TYPE_TEMPLATE_ARGUMENTS (type),
13085 VEC_address (symbolp, template_args),
13086 (TYPE_N_TEMPLATE_ARGUMENTS (type)
13087 * sizeof (struct symbol *)));
13088 VEC_free (symbolp, template_args);
13089 }
13090
13091 /* Attach fields and member functions to the type. */
13092 if (fi.nfields)
13093 dwarf2_attach_fields_to_type (&fi, type, cu);
13094 if (fi.nfnfields)
13095 {
13096 dwarf2_attach_fn_fields_to_type (&fi, type, cu);
13097
13098 /* Get the type which refers to the base class (possibly this
13099 class itself) which contains the vtable pointer for the current
13100 class from the DW_AT_containing_type attribute. This use of
13101 DW_AT_containing_type is a GNU extension. */
13102
13103 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
13104 {
13105 struct type *t = die_containing_type (die, cu);
13106
13107 TYPE_VPTR_BASETYPE (type) = t;
13108 if (type == t)
13109 {
13110 int i;
13111
13112 /* Our own class provides vtbl ptr. */
13113 for (i = TYPE_NFIELDS (t) - 1;
13114 i >= TYPE_N_BASECLASSES (t);
13115 --i)
13116 {
13117 const char *fieldname = TYPE_FIELD_NAME (t, i);
13118
13119 if (is_vtable_name (fieldname, cu))
13120 {
13121 TYPE_VPTR_FIELDNO (type) = i;
13122 break;
13123 }
13124 }
13125
13126 /* Complain if virtual function table field not found. */
13127 if (i < TYPE_N_BASECLASSES (t))
13128 complaint (&symfile_complaints,
13129 _("virtual function table pointer "
13130 "not found when defining class '%s'"),
13131 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) :
13132 "");
13133 }
13134 else
13135 {
13136 TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
13137 }
13138 }
13139 else if (cu->producer
13140 && strncmp (cu->producer,
13141 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
13142 {
13143 /* The IBM XLC compiler does not provide direct indication
13144 of the containing type, but the vtable pointer is
13145 always named __vfp. */
13146
13147 int i;
13148
13149 for (i = TYPE_NFIELDS (type) - 1;
13150 i >= TYPE_N_BASECLASSES (type);
13151 --i)
13152 {
13153 if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
13154 {
13155 TYPE_VPTR_FIELDNO (type) = i;
13156 TYPE_VPTR_BASETYPE (type) = type;
13157 break;
13158 }
13159 }
13160 }
13161 }
13162
13163 /* Copy fi.typedef_field_list linked list elements content into the
13164 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
13165 if (fi.typedef_field_list)
13166 {
13167 int i = fi.typedef_field_list_count;
13168
13169 ALLOCATE_CPLUS_STRUCT_TYPE (type);
13170 TYPE_TYPEDEF_FIELD_ARRAY (type)
13171 = TYPE_ALLOC (type, sizeof (TYPE_TYPEDEF_FIELD (type, 0)) * i);
13172 TYPE_TYPEDEF_FIELD_COUNT (type) = i;
13173
13174 /* Reverse the list order to keep the debug info elements order. */
13175 while (--i >= 0)
13176 {
13177 struct typedef_field *dest, *src;
13178
13179 dest = &TYPE_TYPEDEF_FIELD (type, i);
13180 src = &fi.typedef_field_list->field;
13181 fi.typedef_field_list = fi.typedef_field_list->next;
13182 *dest = *src;
13183 }
13184 }
13185
13186 do_cleanups (back_to);
13187
13188 if (HAVE_CPLUS_STRUCT (type))
13189 TYPE_CPLUS_REALLY_JAVA (type) = cu->language == language_java;
13190 }
13191
13192 quirk_gcc_member_function_pointer (type, objfile);
13193
13194 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
13195 snapshots) has been known to create a die giving a declaration
13196 for a class that has, as a child, a die giving a definition for a
13197 nested class. So we have to process our children even if the
13198 current die is a declaration. Normally, of course, a declaration
13199 won't have any children at all. */
13200
13201 while (child_die != NULL && child_die->tag)
13202 {
13203 if (child_die->tag == DW_TAG_member
13204 || child_die->tag == DW_TAG_variable
13205 || child_die->tag == DW_TAG_inheritance
13206 || child_die->tag == DW_TAG_template_value_param
13207 || child_die->tag == DW_TAG_template_type_param)
13208 {
13209 /* Do nothing. */
13210 }
13211 else
13212 process_die (child_die, cu);
13213
13214 child_die = sibling_die (child_die);
13215 }
13216
13217 /* Do not consider external references. According to the DWARF standard,
13218 these DIEs are identified by the fact that they have no byte_size
13219 attribute, and a declaration attribute. */
13220 if (dwarf2_attr (die, DW_AT_byte_size, cu) != NULL
13221 || !die_is_declaration (die, cu))
13222 new_symbol (die, type, cu);
13223 }
13224
13225 /* Assuming DIE is an enumeration type, and TYPE is its associated type,
13226 update TYPE using some information only available in DIE's children. */
13227
13228 static void
13229 update_enumeration_type_from_children (struct die_info *die,
13230 struct type *type,
13231 struct dwarf2_cu *cu)
13232 {
13233 struct obstack obstack;
13234 struct die_info *child_die = die->child;
13235 int unsigned_enum = 1;
13236 int flag_enum = 1;
13237 ULONGEST mask = 0;
13238 struct cleanup *old_chain;
13239
13240 obstack_init (&obstack);
13241 old_chain = make_cleanup_obstack_free (&obstack);
13242
13243 while (child_die != NULL && child_die->tag)
13244 {
13245 struct attribute *attr;
13246 LONGEST value;
13247 const gdb_byte *bytes;
13248 struct dwarf2_locexpr_baton *baton;
13249 const char *name;
13250 if (child_die->tag != DW_TAG_enumerator)
13251 continue;
13252
13253 attr = dwarf2_attr (child_die, DW_AT_const_value, cu);
13254 if (attr == NULL)
13255 continue;
13256
13257 name = dwarf2_name (child_die, cu);
13258 if (name == NULL)
13259 name = "<anonymous enumerator>";
13260
13261 dwarf2_const_value_attr (attr, type, name, &obstack, cu,
13262 &value, &bytes, &baton);
13263 if (value < 0)
13264 {
13265 unsigned_enum = 0;
13266 flag_enum = 0;
13267 }
13268 else if ((mask & value) != 0)
13269 flag_enum = 0;
13270 else
13271 mask |= value;
13272
13273 /* If we already know that the enum type is neither unsigned, nor
13274 a flag type, no need to look at the rest of the enumerates. */
13275 if (!unsigned_enum && !flag_enum)
13276 break;
13277 child_die = sibling_die (child_die);
13278 }
13279
13280 if (unsigned_enum)
13281 TYPE_UNSIGNED (type) = 1;
13282 if (flag_enum)
13283 TYPE_FLAG_ENUM (type) = 1;
13284
13285 do_cleanups (old_chain);
13286 }
13287
13288 /* Given a DW_AT_enumeration_type die, set its type. We do not
13289 complete the type's fields yet, or create any symbols. */
13290
13291 static struct type *
13292 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
13293 {
13294 struct objfile *objfile = cu->objfile;
13295 struct type *type;
13296 struct attribute *attr;
13297 const char *name;
13298
13299 /* If the definition of this type lives in .debug_types, read that type.
13300 Don't follow DW_AT_specification though, that will take us back up
13301 the chain and we want to go down. */
13302 attr = dwarf2_attr_no_follow (die, DW_AT_signature);
13303 if (attr)
13304 {
13305 type = get_DW_AT_signature_type (die, attr, cu);
13306
13307 /* The type's CU may not be the same as CU.
13308 Ensure TYPE is recorded with CU in die_type_hash. */
13309 return set_die_type (die, type, cu);
13310 }
13311
13312 type = alloc_type (objfile);
13313
13314 TYPE_CODE (type) = TYPE_CODE_ENUM;
13315 name = dwarf2_full_name (NULL, die, cu);
13316 if (name != NULL)
13317 TYPE_TAG_NAME (type) = name;
13318
13319 attr = dwarf2_attr (die, DW_AT_type, cu);
13320 if (attr != NULL)
13321 {
13322 struct type *underlying_type = die_type (die, cu);
13323
13324 TYPE_TARGET_TYPE (type) = underlying_type;
13325 }
13326
13327 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
13328 if (attr)
13329 {
13330 TYPE_LENGTH (type) = DW_UNSND (attr);
13331 }
13332 else
13333 {
13334 TYPE_LENGTH (type) = 0;
13335 }
13336
13337 /* The enumeration DIE can be incomplete. In Ada, any type can be
13338 declared as private in the package spec, and then defined only
13339 inside the package body. Such types are known as Taft Amendment
13340 Types. When another package uses such a type, an incomplete DIE
13341 may be generated by the compiler. */
13342 if (die_is_declaration (die, cu))
13343 TYPE_STUB (type) = 1;
13344
13345 /* Finish the creation of this type by using the enum's children.
13346 We must call this even when the underlying type has been provided
13347 so that we can determine if we're looking at a "flag" enum. */
13348 update_enumeration_type_from_children (die, type, cu);
13349
13350 /* If this type has an underlying type that is not a stub, then we
13351 may use its attributes. We always use the "unsigned" attribute
13352 in this situation, because ordinarily we guess whether the type
13353 is unsigned -- but the guess can be wrong and the underlying type
13354 can tell us the reality. However, we defer to a local size
13355 attribute if one exists, because this lets the compiler override
13356 the underlying type if needed. */
13357 if (TYPE_TARGET_TYPE (type) != NULL && !TYPE_STUB (TYPE_TARGET_TYPE (type)))
13358 {
13359 TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type));
13360 if (TYPE_LENGTH (type) == 0)
13361 TYPE_LENGTH (type) = TYPE_LENGTH (TYPE_TARGET_TYPE (type));
13362 }
13363
13364 TYPE_DECLARED_CLASS (type) = dwarf2_flag_true_p (die, DW_AT_enum_class, cu);
13365
13366 return set_die_type (die, type, cu);
13367 }
13368
13369 /* Given a pointer to a die which begins an enumeration, process all
13370 the dies that define the members of the enumeration, and create the
13371 symbol for the enumeration type.
13372
13373 NOTE: We reverse the order of the element list. */
13374
13375 static void
13376 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
13377 {
13378 struct type *this_type;
13379
13380 this_type = get_die_type (die, cu);
13381 if (this_type == NULL)
13382 this_type = read_enumeration_type (die, cu);
13383
13384 if (die->child != NULL)
13385 {
13386 struct die_info *child_die;
13387 struct symbol *sym;
13388 struct field *fields = NULL;
13389 int num_fields = 0;
13390 const char *name;
13391
13392 child_die = die->child;
13393 while (child_die && child_die->tag)
13394 {
13395 if (child_die->tag != DW_TAG_enumerator)
13396 {
13397 process_die (child_die, cu);
13398 }
13399 else
13400 {
13401 name = dwarf2_name (child_die, cu);
13402 if (name)
13403 {
13404 sym = new_symbol (child_die, this_type, cu);
13405
13406 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
13407 {
13408 fields = (struct field *)
13409 xrealloc (fields,
13410 (num_fields + DW_FIELD_ALLOC_CHUNK)
13411 * sizeof (struct field));
13412 }
13413
13414 FIELD_NAME (fields[num_fields]) = SYMBOL_LINKAGE_NAME (sym);
13415 FIELD_TYPE (fields[num_fields]) = NULL;
13416 SET_FIELD_ENUMVAL (fields[num_fields], SYMBOL_VALUE (sym));
13417 FIELD_BITSIZE (fields[num_fields]) = 0;
13418
13419 num_fields++;
13420 }
13421 }
13422
13423 child_die = sibling_die (child_die);
13424 }
13425
13426 if (num_fields)
13427 {
13428 TYPE_NFIELDS (this_type) = num_fields;
13429 TYPE_FIELDS (this_type) = (struct field *)
13430 TYPE_ALLOC (this_type, sizeof (struct field) * num_fields);
13431 memcpy (TYPE_FIELDS (this_type), fields,
13432 sizeof (struct field) * num_fields);
13433 xfree (fields);
13434 }
13435 }
13436
13437 /* If we are reading an enum from a .debug_types unit, and the enum
13438 is a declaration, and the enum is not the signatured type in the
13439 unit, then we do not want to add a symbol for it. Adding a
13440 symbol would in some cases obscure the true definition of the
13441 enum, giving users an incomplete type when the definition is
13442 actually available. Note that we do not want to do this for all
13443 enums which are just declarations, because C++0x allows forward
13444 enum declarations. */
13445 if (cu->per_cu->is_debug_types
13446 && die_is_declaration (die, cu))
13447 {
13448 struct signatured_type *sig_type;
13449
13450 sig_type = (struct signatured_type *) cu->per_cu;
13451 gdb_assert (sig_type->type_offset_in_section.sect_off != 0);
13452 if (sig_type->type_offset_in_section.sect_off != die->offset.sect_off)
13453 return;
13454 }
13455
13456 new_symbol (die, this_type, cu);
13457 }
13458
13459 /* Extract all information from a DW_TAG_array_type DIE and put it in
13460 the DIE's type field. For now, this only handles one dimensional
13461 arrays. */
13462
13463 static struct type *
13464 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
13465 {
13466 struct objfile *objfile = cu->objfile;
13467 struct die_info *child_die;
13468 struct type *type;
13469 struct type *element_type, *range_type, *index_type;
13470 struct type **range_types = NULL;
13471 struct attribute *attr;
13472 int ndim = 0;
13473 struct cleanup *back_to;
13474 const char *name;
13475 unsigned int bit_stride = 0;
13476
13477 element_type = die_type (die, cu);
13478
13479 /* The die_type call above may have already set the type for this DIE. */
13480 type = get_die_type (die, cu);
13481 if (type)
13482 return type;
13483
13484 attr = dwarf2_attr (die, DW_AT_byte_stride, cu);
13485 if (attr != NULL)
13486 bit_stride = DW_UNSND (attr) * 8;
13487
13488 attr = dwarf2_attr (die, DW_AT_bit_stride, cu);
13489 if (attr != NULL)
13490 bit_stride = DW_UNSND (attr);
13491
13492 /* Irix 6.2 native cc creates array types without children for
13493 arrays with unspecified length. */
13494 if (die->child == NULL)
13495 {
13496 index_type = objfile_type (objfile)->builtin_int;
13497 range_type = create_static_range_type (NULL, index_type, 0, -1);
13498 type = create_array_type_with_stride (NULL, element_type, range_type,
13499 bit_stride);
13500 return set_die_type (die, type, cu);
13501 }
13502
13503 back_to = make_cleanup (null_cleanup, NULL);
13504 child_die = die->child;
13505 while (child_die && child_die->tag)
13506 {
13507 if (child_die->tag == DW_TAG_subrange_type)
13508 {
13509 struct type *child_type = read_type_die (child_die, cu);
13510
13511 if (child_type != NULL)
13512 {
13513 /* The range type was succesfully read. Save it for the
13514 array type creation. */
13515 if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0)
13516 {
13517 range_types = (struct type **)
13518 xrealloc (range_types, (ndim + DW_FIELD_ALLOC_CHUNK)
13519 * sizeof (struct type *));
13520 if (ndim == 0)
13521 make_cleanup (free_current_contents, &range_types);
13522 }
13523 range_types[ndim++] = child_type;
13524 }
13525 }
13526 child_die = sibling_die (child_die);
13527 }
13528
13529 /* Dwarf2 dimensions are output from left to right, create the
13530 necessary array types in backwards order. */
13531
13532 type = element_type;
13533
13534 if (read_array_order (die, cu) == DW_ORD_col_major)
13535 {
13536 int i = 0;
13537
13538 while (i < ndim)
13539 type = create_array_type_with_stride (NULL, type, range_types[i++],
13540 bit_stride);
13541 }
13542 else
13543 {
13544 while (ndim-- > 0)
13545 type = create_array_type_with_stride (NULL, type, range_types[ndim],
13546 bit_stride);
13547 }
13548
13549 /* Understand Dwarf2 support for vector types (like they occur on
13550 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
13551 array type. This is not part of the Dwarf2/3 standard yet, but a
13552 custom vendor extension. The main difference between a regular
13553 array and the vector variant is that vectors are passed by value
13554 to functions. */
13555 attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
13556 if (attr)
13557 make_vector_type (type);
13558
13559 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
13560 implementation may choose to implement triple vectors using this
13561 attribute. */
13562 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
13563 if (attr)
13564 {
13565 if (DW_UNSND (attr) >= TYPE_LENGTH (type))
13566 TYPE_LENGTH (type) = DW_UNSND (attr);
13567 else
13568 complaint (&symfile_complaints,
13569 _("DW_AT_byte_size for array type smaller "
13570 "than the total size of elements"));
13571 }
13572
13573 name = dwarf2_name (die, cu);
13574 if (name)
13575 TYPE_NAME (type) = name;
13576
13577 /* Install the type in the die. */
13578 set_die_type (die, type, cu);
13579
13580 /* set_die_type should be already done. */
13581 set_descriptive_type (type, die, cu);
13582
13583 do_cleanups (back_to);
13584
13585 return type;
13586 }
13587
13588 static enum dwarf_array_dim_ordering
13589 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
13590 {
13591 struct attribute *attr;
13592
13593 attr = dwarf2_attr (die, DW_AT_ordering, cu);
13594
13595 if (attr) return DW_SND (attr);
13596
13597 /* GNU F77 is a special case, as at 08/2004 array type info is the
13598 opposite order to the dwarf2 specification, but data is still
13599 laid out as per normal fortran.
13600
13601 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
13602 version checking. */
13603
13604 if (cu->language == language_fortran
13605 && cu->producer && strstr (cu->producer, "GNU F77"))
13606 {
13607 return DW_ORD_row_major;
13608 }
13609
13610 switch (cu->language_defn->la_array_ordering)
13611 {
13612 case array_column_major:
13613 return DW_ORD_col_major;
13614 case array_row_major:
13615 default:
13616 return DW_ORD_row_major;
13617 };
13618 }
13619
13620 /* Extract all information from a DW_TAG_set_type DIE and put it in
13621 the DIE's type field. */
13622
13623 static struct type *
13624 read_set_type (struct die_info *die, struct dwarf2_cu *cu)
13625 {
13626 struct type *domain_type, *set_type;
13627 struct attribute *attr;
13628
13629 domain_type = die_type (die, cu);
13630
13631 /* The die_type call above may have already set the type for this DIE. */
13632 set_type = get_die_type (die, cu);
13633 if (set_type)
13634 return set_type;
13635
13636 set_type = create_set_type (NULL, domain_type);
13637
13638 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
13639 if (attr)
13640 TYPE_LENGTH (set_type) = DW_UNSND (attr);
13641
13642 return set_die_type (die, set_type, cu);
13643 }
13644
13645 /* A helper for read_common_block that creates a locexpr baton.
13646 SYM is the symbol which we are marking as computed.
13647 COMMON_DIE is the DIE for the common block.
13648 COMMON_LOC is the location expression attribute for the common
13649 block itself.
13650 MEMBER_LOC is the location expression attribute for the particular
13651 member of the common block that we are processing.
13652 CU is the CU from which the above come. */
13653
13654 static void
13655 mark_common_block_symbol_computed (struct symbol *sym,
13656 struct die_info *common_die,
13657 struct attribute *common_loc,
13658 struct attribute *member_loc,
13659 struct dwarf2_cu *cu)
13660 {
13661 struct objfile *objfile = dwarf2_per_objfile->objfile;
13662 struct dwarf2_locexpr_baton *baton;
13663 gdb_byte *ptr;
13664 unsigned int cu_off;
13665 enum bfd_endian byte_order = gdbarch_byte_order (get_objfile_arch (objfile));
13666 LONGEST offset = 0;
13667
13668 gdb_assert (common_loc && member_loc);
13669 gdb_assert (attr_form_is_block (common_loc));
13670 gdb_assert (attr_form_is_block (member_loc)
13671 || attr_form_is_constant (member_loc));
13672
13673 baton = obstack_alloc (&objfile->objfile_obstack,
13674 sizeof (struct dwarf2_locexpr_baton));
13675 baton->per_cu = cu->per_cu;
13676 gdb_assert (baton->per_cu);
13677
13678 baton->size = 5 /* DW_OP_call4 */ + 1 /* DW_OP_plus */;
13679
13680 if (attr_form_is_constant (member_loc))
13681 {
13682 offset = dwarf2_get_attr_constant_value (member_loc, 0);
13683 baton->size += 1 /* DW_OP_addr */ + cu->header.addr_size;
13684 }
13685 else
13686 baton->size += DW_BLOCK (member_loc)->size;
13687
13688 ptr = obstack_alloc (&objfile->objfile_obstack, baton->size);
13689 baton->data = ptr;
13690
13691 *ptr++ = DW_OP_call4;
13692 cu_off = common_die->offset.sect_off - cu->per_cu->offset.sect_off;
13693 store_unsigned_integer (ptr, 4, byte_order, cu_off);
13694 ptr += 4;
13695
13696 if (attr_form_is_constant (member_loc))
13697 {
13698 *ptr++ = DW_OP_addr;
13699 store_unsigned_integer (ptr, cu->header.addr_size, byte_order, offset);
13700 ptr += cu->header.addr_size;
13701 }
13702 else
13703 {
13704 /* We have to copy the data here, because DW_OP_call4 will only
13705 use a DW_AT_location attribute. */
13706 memcpy (ptr, DW_BLOCK (member_loc)->data, DW_BLOCK (member_loc)->size);
13707 ptr += DW_BLOCK (member_loc)->size;
13708 }
13709
13710 *ptr++ = DW_OP_plus;
13711 gdb_assert (ptr - baton->data == baton->size);
13712
13713 SYMBOL_LOCATION_BATON (sym) = baton;
13714 SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
13715 }
13716
13717 /* Create appropriate locally-scoped variables for all the
13718 DW_TAG_common_block entries. Also create a struct common_block
13719 listing all such variables for `info common'. COMMON_BLOCK_DOMAIN
13720 is used to sepate the common blocks name namespace from regular
13721 variable names. */
13722
13723 static void
13724 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
13725 {
13726 struct attribute *attr;
13727
13728 attr = dwarf2_attr (die, DW_AT_location, cu);
13729 if (attr)
13730 {
13731 /* Support the .debug_loc offsets. */
13732 if (attr_form_is_block (attr))
13733 {
13734 /* Ok. */
13735 }
13736 else if (attr_form_is_section_offset (attr))
13737 {
13738 dwarf2_complex_location_expr_complaint ();
13739 attr = NULL;
13740 }
13741 else
13742 {
13743 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
13744 "common block member");
13745 attr = NULL;
13746 }
13747 }
13748
13749 if (die->child != NULL)
13750 {
13751 struct objfile *objfile = cu->objfile;
13752 struct die_info *child_die;
13753 size_t n_entries = 0, size;
13754 struct common_block *common_block;
13755 struct symbol *sym;
13756
13757 for (child_die = die->child;
13758 child_die && child_die->tag;
13759 child_die = sibling_die (child_die))
13760 ++n_entries;
13761
13762 size = (sizeof (struct common_block)
13763 + (n_entries - 1) * sizeof (struct symbol *));
13764 common_block = obstack_alloc (&objfile->objfile_obstack, size);
13765 memset (common_block->contents, 0, n_entries * sizeof (struct symbol *));
13766 common_block->n_entries = 0;
13767
13768 for (child_die = die->child;
13769 child_die && child_die->tag;
13770 child_die = sibling_die (child_die))
13771 {
13772 /* Create the symbol in the DW_TAG_common_block block in the current
13773 symbol scope. */
13774 sym = new_symbol (child_die, NULL, cu);
13775 if (sym != NULL)
13776 {
13777 struct attribute *member_loc;
13778
13779 common_block->contents[common_block->n_entries++] = sym;
13780
13781 member_loc = dwarf2_attr (child_die, DW_AT_data_member_location,
13782 cu);
13783 if (member_loc)
13784 {
13785 /* GDB has handled this for a long time, but it is
13786 not specified by DWARF. It seems to have been
13787 emitted by gfortran at least as recently as:
13788 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
13789 complaint (&symfile_complaints,
13790 _("Variable in common block has "
13791 "DW_AT_data_member_location "
13792 "- DIE at 0x%x [in module %s]"),
13793 child_die->offset.sect_off,
13794 objfile_name (cu->objfile));
13795
13796 if (attr_form_is_section_offset (member_loc))
13797 dwarf2_complex_location_expr_complaint ();
13798 else if (attr_form_is_constant (member_loc)
13799 || attr_form_is_block (member_loc))
13800 {
13801 if (attr)
13802 mark_common_block_symbol_computed (sym, die, attr,
13803 member_loc, cu);
13804 }
13805 else
13806 dwarf2_complex_location_expr_complaint ();
13807 }
13808 }
13809 }
13810
13811 sym = new_symbol (die, objfile_type (objfile)->builtin_void, cu);
13812 SYMBOL_VALUE_COMMON_BLOCK (sym) = common_block;
13813 }
13814 }
13815
13816 /* Create a type for a C++ namespace. */
13817
13818 static struct type *
13819 read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
13820 {
13821 struct objfile *objfile = cu->objfile;
13822 const char *previous_prefix, *name;
13823 int is_anonymous;
13824 struct type *type;
13825
13826 /* For extensions, reuse the type of the original namespace. */
13827 if (dwarf2_attr (die, DW_AT_extension, cu) != NULL)
13828 {
13829 struct die_info *ext_die;
13830 struct dwarf2_cu *ext_cu = cu;
13831
13832 ext_die = dwarf2_extension (die, &ext_cu);
13833 type = read_type_die (ext_die, ext_cu);
13834
13835 /* EXT_CU may not be the same as CU.
13836 Ensure TYPE is recorded with CU in die_type_hash. */
13837 return set_die_type (die, type, cu);
13838 }
13839
13840 name = namespace_name (die, &is_anonymous, cu);
13841
13842 /* Now build the name of the current namespace. */
13843
13844 previous_prefix = determine_prefix (die, cu);
13845 if (previous_prefix[0] != '\0')
13846 name = typename_concat (&objfile->objfile_obstack,
13847 previous_prefix, name, 0, cu);
13848
13849 /* Create the type. */
13850 type = init_type (TYPE_CODE_NAMESPACE, 0, 0, NULL,
13851 objfile);
13852 TYPE_NAME (type) = name;
13853 TYPE_TAG_NAME (type) = TYPE_NAME (type);
13854
13855 return set_die_type (die, type, cu);
13856 }
13857
13858 /* Read a C++ namespace. */
13859
13860 static void
13861 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
13862 {
13863 struct objfile *objfile = cu->objfile;
13864 int is_anonymous;
13865
13866 /* Add a symbol associated to this if we haven't seen the namespace
13867 before. Also, add a using directive if it's an anonymous
13868 namespace. */
13869
13870 if (dwarf2_attr (die, DW_AT_extension, cu) == NULL)
13871 {
13872 struct type *type;
13873
13874 type = read_type_die (die, cu);
13875 new_symbol (die, type, cu);
13876
13877 namespace_name (die, &is_anonymous, cu);
13878 if (is_anonymous)
13879 {
13880 const char *previous_prefix = determine_prefix (die, cu);
13881
13882 cp_add_using_directive (previous_prefix, TYPE_NAME (type), NULL,
13883 NULL, NULL, 0, &objfile->objfile_obstack);
13884 }
13885 }
13886
13887 if (die->child != NULL)
13888 {
13889 struct die_info *child_die = die->child;
13890
13891 while (child_die && child_die->tag)
13892 {
13893 process_die (child_die, cu);
13894 child_die = sibling_die (child_die);
13895 }
13896 }
13897 }
13898
13899 /* Read a Fortran module as type. This DIE can be only a declaration used for
13900 imported module. Still we need that type as local Fortran "use ... only"
13901 declaration imports depend on the created type in determine_prefix. */
13902
13903 static struct type *
13904 read_module_type (struct die_info *die, struct dwarf2_cu *cu)
13905 {
13906 struct objfile *objfile = cu->objfile;
13907 const char *module_name;
13908 struct type *type;
13909
13910 module_name = dwarf2_name (die, cu);
13911 if (!module_name)
13912 complaint (&symfile_complaints,
13913 _("DW_TAG_module has no name, offset 0x%x"),
13914 die->offset.sect_off);
13915 type = init_type (TYPE_CODE_MODULE, 0, 0, module_name, objfile);
13916
13917 /* determine_prefix uses TYPE_TAG_NAME. */
13918 TYPE_TAG_NAME (type) = TYPE_NAME (type);
13919
13920 return set_die_type (die, type, cu);
13921 }
13922
13923 /* Read a Fortran module. */
13924
13925 static void
13926 read_module (struct die_info *die, struct dwarf2_cu *cu)
13927 {
13928 struct die_info *child_die = die->child;
13929 struct type *type;
13930
13931 type = read_type_die (die, cu);
13932 new_symbol (die, type, cu);
13933
13934 while (child_die && child_die->tag)
13935 {
13936 process_die (child_die, cu);
13937 child_die = sibling_die (child_die);
13938 }
13939 }
13940
13941 /* Return the name of the namespace represented by DIE. Set
13942 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
13943 namespace. */
13944
13945 static const char *
13946 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
13947 {
13948 struct die_info *current_die;
13949 const char *name = NULL;
13950
13951 /* Loop through the extensions until we find a name. */
13952
13953 for (current_die = die;
13954 current_die != NULL;
13955 current_die = dwarf2_extension (die, &cu))
13956 {
13957 name = dwarf2_name (current_die, cu);
13958 if (name != NULL)
13959 break;
13960 }
13961
13962 /* Is it an anonymous namespace? */
13963
13964 *is_anonymous = (name == NULL);
13965 if (*is_anonymous)
13966 name = CP_ANONYMOUS_NAMESPACE_STR;
13967
13968 return name;
13969 }
13970
13971 /* Extract all information from a DW_TAG_pointer_type DIE and add to
13972 the user defined type vector. */
13973
13974 static struct type *
13975 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
13976 {
13977 struct gdbarch *gdbarch = get_objfile_arch (cu->objfile);
13978 struct comp_unit_head *cu_header = &cu->header;
13979 struct type *type;
13980 struct attribute *attr_byte_size;
13981 struct attribute *attr_address_class;
13982 int byte_size, addr_class;
13983 struct type *target_type;
13984
13985 target_type = die_type (die, cu);
13986
13987 /* The die_type call above may have already set the type for this DIE. */
13988 type = get_die_type (die, cu);
13989 if (type)
13990 return type;
13991
13992 type = lookup_pointer_type (target_type);
13993
13994 attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
13995 if (attr_byte_size)
13996 byte_size = DW_UNSND (attr_byte_size);
13997 else
13998 byte_size = cu_header->addr_size;
13999
14000 attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
14001 if (attr_address_class)
14002 addr_class = DW_UNSND (attr_address_class);
14003 else
14004 addr_class = DW_ADDR_none;
14005
14006 /* If the pointer size or address class is different than the
14007 default, create a type variant marked as such and set the
14008 length accordingly. */
14009 if (TYPE_LENGTH (type) != byte_size || addr_class != DW_ADDR_none)
14010 {
14011 if (gdbarch_address_class_type_flags_p (gdbarch))
14012 {
14013 int type_flags;
14014
14015 type_flags = gdbarch_address_class_type_flags
14016 (gdbarch, byte_size, addr_class);
14017 gdb_assert ((type_flags & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
14018 == 0);
14019 type = make_type_with_address_space (type, type_flags);
14020 }
14021 else if (TYPE_LENGTH (type) != byte_size)
14022 {
14023 complaint (&symfile_complaints,
14024 _("invalid pointer size %d"), byte_size);
14025 }
14026 else
14027 {
14028 /* Should we also complain about unhandled address classes? */
14029 }
14030 }
14031
14032 TYPE_LENGTH (type) = byte_size;
14033 return set_die_type (die, type, cu);
14034 }
14035
14036 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
14037 the user defined type vector. */
14038
14039 static struct type *
14040 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
14041 {
14042 struct type *type;
14043 struct type *to_type;
14044 struct type *domain;
14045
14046 to_type = die_type (die, cu);
14047 domain = die_containing_type (die, cu);
14048
14049 /* The calls above may have already set the type for this DIE. */
14050 type = get_die_type (die, cu);
14051 if (type)
14052 return type;
14053
14054 if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_METHOD)
14055 type = lookup_methodptr_type (to_type);
14056 else if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_FUNC)
14057 {
14058 struct type *new_type = alloc_type (cu->objfile);
14059
14060 smash_to_method_type (new_type, domain, TYPE_TARGET_TYPE (to_type),
14061 TYPE_FIELDS (to_type), TYPE_NFIELDS (to_type),
14062 TYPE_VARARGS (to_type));
14063 type = lookup_methodptr_type (new_type);
14064 }
14065 else
14066 type = lookup_memberptr_type (to_type, domain);
14067
14068 return set_die_type (die, type, cu);
14069 }
14070
14071 /* Extract all information from a DW_TAG_reference_type DIE and add to
14072 the user defined type vector. */
14073
14074 static struct type *
14075 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu)
14076 {
14077 struct comp_unit_head *cu_header = &cu->header;
14078 struct type *type, *target_type;
14079 struct attribute *attr;
14080
14081 target_type = die_type (die, cu);
14082
14083 /* The die_type call above may have already set the type for this DIE. */
14084 type = get_die_type (die, cu);
14085 if (type)
14086 return type;
14087
14088 type = lookup_reference_type (target_type);
14089 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
14090 if (attr)
14091 {
14092 TYPE_LENGTH (type) = DW_UNSND (attr);
14093 }
14094 else
14095 {
14096 TYPE_LENGTH (type) = cu_header->addr_size;
14097 }
14098 return set_die_type (die, type, cu);
14099 }
14100
14101 /* Add the given cv-qualifiers to the element type of the array. GCC
14102 outputs DWARF type qualifiers that apply to an array, not the
14103 element type. But GDB relies on the array element type to carry
14104 the cv-qualifiers. This mimics section 6.7.3 of the C99
14105 specification. */
14106
14107 static struct type *
14108 add_array_cv_type (struct die_info *die, struct dwarf2_cu *cu,
14109 struct type *base_type, int cnst, int voltl)
14110 {
14111 struct type *el_type, *inner_array;
14112
14113 base_type = copy_type (base_type);
14114 inner_array = base_type;
14115
14116 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
14117 {
14118 TYPE_TARGET_TYPE (inner_array) =
14119 copy_type (TYPE_TARGET_TYPE (inner_array));
14120 inner_array = TYPE_TARGET_TYPE (inner_array);
14121 }
14122
14123 el_type = TYPE_TARGET_TYPE (inner_array);
14124 cnst |= TYPE_CONST (el_type);
14125 voltl |= TYPE_VOLATILE (el_type);
14126 TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, NULL);
14127
14128 return set_die_type (die, base_type, cu);
14129 }
14130
14131 static struct type *
14132 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
14133 {
14134 struct type *base_type, *cv_type;
14135
14136 base_type = die_type (die, cu);
14137
14138 /* The die_type call above may have already set the type for this DIE. */
14139 cv_type = get_die_type (die, cu);
14140 if (cv_type)
14141 return cv_type;
14142
14143 /* In case the const qualifier is applied to an array type, the element type
14144 is so qualified, not the array type (section 6.7.3 of C99). */
14145 if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
14146 return add_array_cv_type (die, cu, base_type, 1, 0);
14147
14148 cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
14149 return set_die_type (die, cv_type, cu);
14150 }
14151
14152 static struct type *
14153 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
14154 {
14155 struct type *base_type, *cv_type;
14156
14157 base_type = die_type (die, cu);
14158
14159 /* The die_type call above may have already set the type for this DIE. */
14160 cv_type = get_die_type (die, cu);
14161 if (cv_type)
14162 return cv_type;
14163
14164 /* In case the volatile qualifier is applied to an array type, the
14165 element type is so qualified, not the array type (section 6.7.3
14166 of C99). */
14167 if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
14168 return add_array_cv_type (die, cu, base_type, 0, 1);
14169
14170 cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
14171 return set_die_type (die, cv_type, cu);
14172 }
14173
14174 /* Handle DW_TAG_restrict_type. */
14175
14176 static struct type *
14177 read_tag_restrict_type (struct die_info *die, struct dwarf2_cu *cu)
14178 {
14179 struct type *base_type, *cv_type;
14180
14181 base_type = die_type (die, cu);
14182
14183 /* The die_type call above may have already set the type for this DIE. */
14184 cv_type = get_die_type (die, cu);
14185 if (cv_type)
14186 return cv_type;
14187
14188 cv_type = make_restrict_type (base_type);
14189 return set_die_type (die, cv_type, cu);
14190 }
14191
14192 /* Extract all information from a DW_TAG_string_type DIE and add to
14193 the user defined type vector. It isn't really a user defined type,
14194 but it behaves like one, with other DIE's using an AT_user_def_type
14195 attribute to reference it. */
14196
14197 static struct type *
14198 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
14199 {
14200 struct objfile *objfile = cu->objfile;
14201 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14202 struct type *type, *range_type, *index_type, *char_type;
14203 struct attribute *attr;
14204 unsigned int length;
14205
14206 attr = dwarf2_attr (die, DW_AT_string_length, cu);
14207 if (attr)
14208 {
14209 length = DW_UNSND (attr);
14210 }
14211 else
14212 {
14213 /* Check for the DW_AT_byte_size attribute. */
14214 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
14215 if (attr)
14216 {
14217 length = DW_UNSND (attr);
14218 }
14219 else
14220 {
14221 length = 1;
14222 }
14223 }
14224
14225 index_type = objfile_type (objfile)->builtin_int;
14226 range_type = create_static_range_type (NULL, index_type, 1, length);
14227 char_type = language_string_char_type (cu->language_defn, gdbarch);
14228 type = create_string_type (NULL, char_type, range_type);
14229
14230 return set_die_type (die, type, cu);
14231 }
14232
14233 /* Assuming that DIE corresponds to a function, returns nonzero
14234 if the function is prototyped. */
14235
14236 static int
14237 prototyped_function_p (struct die_info *die, struct dwarf2_cu *cu)
14238 {
14239 struct attribute *attr;
14240
14241 attr = dwarf2_attr (die, DW_AT_prototyped, cu);
14242 if (attr && (DW_UNSND (attr) != 0))
14243 return 1;
14244
14245 /* The DWARF standard implies that the DW_AT_prototyped attribute
14246 is only meaninful for C, but the concept also extends to other
14247 languages that allow unprototyped functions (Eg: Objective C).
14248 For all other languages, assume that functions are always
14249 prototyped. */
14250 if (cu->language != language_c
14251 && cu->language != language_objc
14252 && cu->language != language_opencl)
14253 return 1;
14254
14255 /* RealView does not emit DW_AT_prototyped. We can not distinguish
14256 prototyped and unprototyped functions; default to prototyped,
14257 since that is more common in modern code (and RealView warns
14258 about unprototyped functions). */
14259 if (producer_is_realview (cu->producer))
14260 return 1;
14261
14262 return 0;
14263 }
14264
14265 /* Handle DIES due to C code like:
14266
14267 struct foo
14268 {
14269 int (*funcp)(int a, long l);
14270 int b;
14271 };
14272
14273 ('funcp' generates a DW_TAG_subroutine_type DIE). */
14274
14275 static struct type *
14276 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
14277 {
14278 struct objfile *objfile = cu->objfile;
14279 struct type *type; /* Type that this function returns. */
14280 struct type *ftype; /* Function that returns above type. */
14281 struct attribute *attr;
14282
14283 type = die_type (die, cu);
14284
14285 /* The die_type call above may have already set the type for this DIE. */
14286 ftype = get_die_type (die, cu);
14287 if (ftype)
14288 return ftype;
14289
14290 ftype = lookup_function_type (type);
14291
14292 if (prototyped_function_p (die, cu))
14293 TYPE_PROTOTYPED (ftype) = 1;
14294
14295 /* Store the calling convention in the type if it's available in
14296 the subroutine die. Otherwise set the calling convention to
14297 the default value DW_CC_normal. */
14298 attr = dwarf2_attr (die, DW_AT_calling_convention, cu);
14299 if (attr)
14300 TYPE_CALLING_CONVENTION (ftype) = DW_UNSND (attr);
14301 else if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL"))
14302 TYPE_CALLING_CONVENTION (ftype) = DW_CC_GDB_IBM_OpenCL;
14303 else
14304 TYPE_CALLING_CONVENTION (ftype) = DW_CC_normal;
14305
14306 /* We need to add the subroutine type to the die immediately so
14307 we don't infinitely recurse when dealing with parameters
14308 declared as the same subroutine type. */
14309 set_die_type (die, ftype, cu);
14310
14311 if (die->child != NULL)
14312 {
14313 struct type *void_type = objfile_type (objfile)->builtin_void;
14314 struct die_info *child_die;
14315 int nparams, iparams;
14316
14317 /* Count the number of parameters.
14318 FIXME: GDB currently ignores vararg functions, but knows about
14319 vararg member functions. */
14320 nparams = 0;
14321 child_die = die->child;
14322 while (child_die && child_die->tag)
14323 {
14324 if (child_die->tag == DW_TAG_formal_parameter)
14325 nparams++;
14326 else if (child_die->tag == DW_TAG_unspecified_parameters)
14327 TYPE_VARARGS (ftype) = 1;
14328 child_die = sibling_die (child_die);
14329 }
14330
14331 /* Allocate storage for parameters and fill them in. */
14332 TYPE_NFIELDS (ftype) = nparams;
14333 TYPE_FIELDS (ftype) = (struct field *)
14334 TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
14335
14336 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
14337 even if we error out during the parameters reading below. */
14338 for (iparams = 0; iparams < nparams; iparams++)
14339 TYPE_FIELD_TYPE (ftype, iparams) = void_type;
14340
14341 iparams = 0;
14342 child_die = die->child;
14343 while (child_die && child_die->tag)
14344 {
14345 if (child_die->tag == DW_TAG_formal_parameter)
14346 {
14347 struct type *arg_type;
14348
14349 /* DWARF version 2 has no clean way to discern C++
14350 static and non-static member functions. G++ helps
14351 GDB by marking the first parameter for non-static
14352 member functions (which is the this pointer) as
14353 artificial. We pass this information to
14354 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
14355
14356 DWARF version 3 added DW_AT_object_pointer, which GCC
14357 4.5 does not yet generate. */
14358 attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
14359 if (attr)
14360 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
14361 else
14362 {
14363 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
14364
14365 /* GCC/43521: In java, the formal parameter
14366 "this" is sometimes not marked with DW_AT_artificial. */
14367 if (cu->language == language_java)
14368 {
14369 const char *name = dwarf2_name (child_die, cu);
14370
14371 if (name && !strcmp (name, "this"))
14372 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 1;
14373 }
14374 }
14375 arg_type = die_type (child_die, cu);
14376
14377 /* RealView does not mark THIS as const, which the testsuite
14378 expects. GCC marks THIS as const in method definitions,
14379 but not in the class specifications (GCC PR 43053). */
14380 if (cu->language == language_cplus && !TYPE_CONST (arg_type)
14381 && TYPE_FIELD_ARTIFICIAL (ftype, iparams))
14382 {
14383 int is_this = 0;
14384 struct dwarf2_cu *arg_cu = cu;
14385 const char *name = dwarf2_name (child_die, cu);
14386
14387 attr = dwarf2_attr (die, DW_AT_object_pointer, cu);
14388 if (attr)
14389 {
14390 /* If the compiler emits this, use it. */
14391 if (follow_die_ref (die, attr, &arg_cu) == child_die)
14392 is_this = 1;
14393 }
14394 else if (name && strcmp (name, "this") == 0)
14395 /* Function definitions will have the argument names. */
14396 is_this = 1;
14397 else if (name == NULL && iparams == 0)
14398 /* Declarations may not have the names, so like
14399 elsewhere in GDB, assume an artificial first
14400 argument is "this". */
14401 is_this = 1;
14402
14403 if (is_this)
14404 arg_type = make_cv_type (1, TYPE_VOLATILE (arg_type),
14405 arg_type, 0);
14406 }
14407
14408 TYPE_FIELD_TYPE (ftype, iparams) = arg_type;
14409 iparams++;
14410 }
14411 child_die = sibling_die (child_die);
14412 }
14413 }
14414
14415 return ftype;
14416 }
14417
14418 static struct type *
14419 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
14420 {
14421 struct objfile *objfile = cu->objfile;
14422 const char *name = NULL;
14423 struct type *this_type, *target_type;
14424
14425 name = dwarf2_full_name (NULL, die, cu);
14426 this_type = init_type (TYPE_CODE_TYPEDEF, 0,
14427 TYPE_FLAG_TARGET_STUB, NULL, objfile);
14428 TYPE_NAME (this_type) = name;
14429 set_die_type (die, this_type, cu);
14430 target_type = die_type (die, cu);
14431 if (target_type != this_type)
14432 TYPE_TARGET_TYPE (this_type) = target_type;
14433 else
14434 {
14435 /* Self-referential typedefs are, it seems, not allowed by the DWARF
14436 spec and cause infinite loops in GDB. */
14437 complaint (&symfile_complaints,
14438 _("Self-referential DW_TAG_typedef "
14439 "- DIE at 0x%x [in module %s]"),
14440 die->offset.sect_off, objfile_name (objfile));
14441 TYPE_TARGET_TYPE (this_type) = NULL;
14442 }
14443 return this_type;
14444 }
14445
14446 /* Find a representation of a given base type and install
14447 it in the TYPE field of the die. */
14448
14449 static struct type *
14450 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
14451 {
14452 struct objfile *objfile = cu->objfile;
14453 struct type *type;
14454 struct attribute *attr;
14455 int encoding = 0, size = 0;
14456 const char *name;
14457 enum type_code code = TYPE_CODE_INT;
14458 int type_flags = 0;
14459 struct type *target_type = NULL;
14460
14461 attr = dwarf2_attr (die, DW_AT_encoding, cu);
14462 if (attr)
14463 {
14464 encoding = DW_UNSND (attr);
14465 }
14466 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
14467 if (attr)
14468 {
14469 size = DW_UNSND (attr);
14470 }
14471 name = dwarf2_name (die, cu);
14472 if (!name)
14473 {
14474 complaint (&symfile_complaints,
14475 _("DW_AT_name missing from DW_TAG_base_type"));
14476 }
14477
14478 switch (encoding)
14479 {
14480 case DW_ATE_address:
14481 /* Turn DW_ATE_address into a void * pointer. */
14482 code = TYPE_CODE_PTR;
14483 type_flags |= TYPE_FLAG_UNSIGNED;
14484 target_type = init_type (TYPE_CODE_VOID, 1, 0, NULL, objfile);
14485 break;
14486 case DW_ATE_boolean:
14487 code = TYPE_CODE_BOOL;
14488 type_flags |= TYPE_FLAG_UNSIGNED;
14489 break;
14490 case DW_ATE_complex_float:
14491 code = TYPE_CODE_COMPLEX;
14492 target_type = init_type (TYPE_CODE_FLT, size / 2, 0, NULL, objfile);
14493 break;
14494 case DW_ATE_decimal_float:
14495 code = TYPE_CODE_DECFLOAT;
14496 break;
14497 case DW_ATE_float:
14498 code = TYPE_CODE_FLT;
14499 break;
14500 case DW_ATE_signed:
14501 break;
14502 case DW_ATE_unsigned:
14503 type_flags |= TYPE_FLAG_UNSIGNED;
14504 if (cu->language == language_fortran
14505 && name
14506 && strncmp (name, "character(", sizeof ("character(") - 1) == 0)
14507 code = TYPE_CODE_CHAR;
14508 break;
14509 case DW_ATE_signed_char:
14510 if (cu->language == language_ada || cu->language == language_m2
14511 || cu->language == language_pascal
14512 || cu->language == language_fortran)
14513 code = TYPE_CODE_CHAR;
14514 break;
14515 case DW_ATE_unsigned_char:
14516 if (cu->language == language_ada || cu->language == language_m2
14517 || cu->language == language_pascal
14518 || cu->language == language_fortran)
14519 code = TYPE_CODE_CHAR;
14520 type_flags |= TYPE_FLAG_UNSIGNED;
14521 break;
14522 case DW_ATE_UTF:
14523 /* We just treat this as an integer and then recognize the
14524 type by name elsewhere. */
14525 break;
14526
14527 default:
14528 complaint (&symfile_complaints, _("unsupported DW_AT_encoding: '%s'"),
14529 dwarf_type_encoding_name (encoding));
14530 break;
14531 }
14532
14533 type = init_type (code, size, type_flags, NULL, objfile);
14534 TYPE_NAME (type) = name;
14535 TYPE_TARGET_TYPE (type) = target_type;
14536
14537 if (name && strcmp (name, "char") == 0)
14538 TYPE_NOSIGN (type) = 1;
14539
14540 return set_die_type (die, type, cu);
14541 }
14542
14543 /* Parse dwarf attribute if it's a block, reference or constant and put the
14544 resulting value of the attribute into struct bound_prop.
14545 Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */
14546
14547 static int
14548 attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die,
14549 struct dwarf2_cu *cu, struct dynamic_prop *prop)
14550 {
14551 struct dwarf2_property_baton *baton;
14552 struct obstack *obstack = &cu->objfile->objfile_obstack;
14553
14554 if (attr == NULL || prop == NULL)
14555 return 0;
14556
14557 if (attr_form_is_block (attr))
14558 {
14559 baton = obstack_alloc (obstack, sizeof (*baton));
14560 baton->referenced_type = NULL;
14561 baton->locexpr.per_cu = cu->per_cu;
14562 baton->locexpr.size = DW_BLOCK (attr)->size;
14563 baton->locexpr.data = DW_BLOCK (attr)->data;
14564 prop->data.baton = baton;
14565 prop->kind = PROP_LOCEXPR;
14566 gdb_assert (prop->data.baton != NULL);
14567 }
14568 else if (attr_form_is_ref (attr))
14569 {
14570 struct dwarf2_cu *target_cu = cu;
14571 struct die_info *target_die;
14572 struct attribute *target_attr;
14573
14574 target_die = follow_die_ref (die, attr, &target_cu);
14575 target_attr = dwarf2_attr (target_die, DW_AT_location, target_cu);
14576 if (target_attr == NULL)
14577 return 0;
14578
14579 if (attr_form_is_section_offset (target_attr))
14580 {
14581 baton = obstack_alloc (obstack, sizeof (*baton));
14582 baton->referenced_type = die_type (target_die, target_cu);
14583 fill_in_loclist_baton (cu, &baton->loclist, target_attr);
14584 prop->data.baton = baton;
14585 prop->kind = PROP_LOCLIST;
14586 gdb_assert (prop->data.baton != NULL);
14587 }
14588 else if (attr_form_is_block (target_attr))
14589 {
14590 baton = obstack_alloc (obstack, sizeof (*baton));
14591 baton->referenced_type = die_type (target_die, target_cu);
14592 baton->locexpr.per_cu = cu->per_cu;
14593 baton->locexpr.size = DW_BLOCK (target_attr)->size;
14594 baton->locexpr.data = DW_BLOCK (target_attr)->data;
14595 prop->data.baton = baton;
14596 prop->kind = PROP_LOCEXPR;
14597 gdb_assert (prop->data.baton != NULL);
14598 }
14599 else
14600 {
14601 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
14602 "dynamic property");
14603 return 0;
14604 }
14605 }
14606 else if (attr_form_is_constant (attr))
14607 {
14608 prop->data.const_val = dwarf2_get_attr_constant_value (attr, 0);
14609 prop->kind = PROP_CONST;
14610 }
14611 else
14612 {
14613 dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr->form),
14614 dwarf2_name (die, cu));
14615 return 0;
14616 }
14617
14618 return 1;
14619 }
14620
14621 /* Read the given DW_AT_subrange DIE. */
14622
14623 static struct type *
14624 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
14625 {
14626 struct type *base_type, *orig_base_type;
14627 struct type *range_type;
14628 struct attribute *attr;
14629 struct dynamic_prop low, high;
14630 int low_default_is_valid;
14631 int high_bound_is_count = 0;
14632 const char *name;
14633 LONGEST negative_mask;
14634
14635 orig_base_type = die_type (die, cu);
14636 /* If ORIG_BASE_TYPE is a typedef, it will not be TYPE_UNSIGNED,
14637 whereas the real type might be. So, we use ORIG_BASE_TYPE when
14638 creating the range type, but we use the result of check_typedef
14639 when examining properties of the type. */
14640 base_type = check_typedef (orig_base_type);
14641
14642 /* The die_type call above may have already set the type for this DIE. */
14643 range_type = get_die_type (die, cu);
14644 if (range_type)
14645 return range_type;
14646
14647 low.kind = PROP_CONST;
14648 high.kind = PROP_CONST;
14649 high.data.const_val = 0;
14650
14651 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
14652 omitting DW_AT_lower_bound. */
14653 switch (cu->language)
14654 {
14655 case language_c:
14656 case language_cplus:
14657 low.data.const_val = 0;
14658 low_default_is_valid = 1;
14659 break;
14660 case language_fortran:
14661 low.data.const_val = 1;
14662 low_default_is_valid = 1;
14663 break;
14664 case language_d:
14665 case language_java:
14666 case language_objc:
14667 low.data.const_val = 0;
14668 low_default_is_valid = (cu->header.version >= 4);
14669 break;
14670 case language_ada:
14671 case language_m2:
14672 case language_pascal:
14673 low.data.const_val = 1;
14674 low_default_is_valid = (cu->header.version >= 4);
14675 break;
14676 default:
14677 low.data.const_val = 0;
14678 low_default_is_valid = 0;
14679 break;
14680 }
14681
14682 attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
14683 if (attr)
14684 attr_to_dynamic_prop (attr, die, cu, &low);
14685 else if (!low_default_is_valid)
14686 complaint (&symfile_complaints, _("Missing DW_AT_lower_bound "
14687 "- DIE at 0x%x [in module %s]"),
14688 die->offset.sect_off, objfile_name (cu->objfile));
14689
14690 attr = dwarf2_attr (die, DW_AT_upper_bound, cu);
14691 if (!attr_to_dynamic_prop (attr, die, cu, &high))
14692 {
14693 attr = dwarf2_attr (die, DW_AT_count, cu);
14694 if (attr_to_dynamic_prop (attr, die, cu, &high))
14695 {
14696 /* If bounds are constant do the final calculation here. */
14697 if (low.kind == PROP_CONST && high.kind == PROP_CONST)
14698 high.data.const_val = low.data.const_val + high.data.const_val - 1;
14699 else
14700 high_bound_is_count = 1;
14701 }
14702 }
14703
14704 /* Dwarf-2 specifications explicitly allows to create subrange types
14705 without specifying a base type.
14706 In that case, the base type must be set to the type of
14707 the lower bound, upper bound or count, in that order, if any of these
14708 three attributes references an object that has a type.
14709 If no base type is found, the Dwarf-2 specifications say that
14710 a signed integer type of size equal to the size of an address should
14711 be used.
14712 For the following C code: `extern char gdb_int [];'
14713 GCC produces an empty range DIE.
14714 FIXME: muller/2010-05-28: Possible references to object for low bound,
14715 high bound or count are not yet handled by this code. */
14716 if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
14717 {
14718 struct objfile *objfile = cu->objfile;
14719 struct gdbarch *gdbarch = get_objfile_arch (objfile);
14720 int addr_size = gdbarch_addr_bit (gdbarch) /8;
14721 struct type *int_type = objfile_type (objfile)->builtin_int;
14722
14723 /* Test "int", "long int", and "long long int" objfile types,
14724 and select the first one having a size above or equal to the
14725 architecture address size. */
14726 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
14727 base_type = int_type;
14728 else
14729 {
14730 int_type = objfile_type (objfile)->builtin_long;
14731 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
14732 base_type = int_type;
14733 else
14734 {
14735 int_type = objfile_type (objfile)->builtin_long_long;
14736 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
14737 base_type = int_type;
14738 }
14739 }
14740 }
14741
14742 /* Normally, the DWARF producers are expected to use a signed
14743 constant form (Eg. DW_FORM_sdata) to express negative bounds.
14744 But this is unfortunately not always the case, as witnessed
14745 with GCC, for instance, where the ambiguous DW_FORM_dataN form
14746 is used instead. To work around that ambiguity, we treat
14747 the bounds as signed, and thus sign-extend their values, when
14748 the base type is signed. */
14749 negative_mask =
14750 (LONGEST) -1 << (TYPE_LENGTH (base_type) * TARGET_CHAR_BIT - 1);
14751 if (low.kind == PROP_CONST
14752 && !TYPE_UNSIGNED (base_type) && (low.data.const_val & negative_mask))
14753 low.data.const_val |= negative_mask;
14754 if (high.kind == PROP_CONST
14755 && !TYPE_UNSIGNED (base_type) && (high.data.const_val & negative_mask))
14756 high.data.const_val |= negative_mask;
14757
14758 range_type = create_range_type (NULL, orig_base_type, &low, &high);
14759
14760 if (high_bound_is_count)
14761 TYPE_RANGE_DATA (range_type)->flag_upper_bound_is_count = 1;
14762
14763 /* Ada expects an empty array on no boundary attributes. */
14764 if (attr == NULL && cu->language != language_ada)
14765 TYPE_HIGH_BOUND_KIND (range_type) = PROP_UNDEFINED;
14766
14767 name = dwarf2_name (die, cu);
14768 if (name)
14769 TYPE_NAME (range_type) = name;
14770
14771 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
14772 if (attr)
14773 TYPE_LENGTH (range_type) = DW_UNSND (attr);
14774
14775 set_die_type (die, range_type, cu);
14776
14777 /* set_die_type should be already done. */
14778 set_descriptive_type (range_type, die, cu);
14779
14780 return range_type;
14781 }
14782
14783 static struct type *
14784 read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
14785 {
14786 struct type *type;
14787
14788 /* For now, we only support the C meaning of an unspecified type: void. */
14789
14790 type = init_type (TYPE_CODE_VOID, 0, 0, NULL, cu->objfile);
14791 TYPE_NAME (type) = dwarf2_name (die, cu);
14792
14793 return set_die_type (die, type, cu);
14794 }
14795
14796 /* Read a single die and all its descendents. Set the die's sibling
14797 field to NULL; set other fields in the die correctly, and set all
14798 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
14799 location of the info_ptr after reading all of those dies. PARENT
14800 is the parent of the die in question. */
14801
14802 static struct die_info *
14803 read_die_and_children (const struct die_reader_specs *reader,
14804 const gdb_byte *info_ptr,
14805 const gdb_byte **new_info_ptr,
14806 struct die_info *parent)
14807 {
14808 struct die_info *die;
14809 const gdb_byte *cur_ptr;
14810 int has_children;
14811
14812 cur_ptr = read_full_die_1 (reader, &die, info_ptr, &has_children, 0);
14813 if (die == NULL)
14814 {
14815 *new_info_ptr = cur_ptr;
14816 return NULL;
14817 }
14818 store_in_ref_table (die, reader->cu);
14819
14820 if (has_children)
14821 die->child = read_die_and_siblings_1 (reader, cur_ptr, new_info_ptr, die);
14822 else
14823 {
14824 die->child = NULL;
14825 *new_info_ptr = cur_ptr;
14826 }
14827
14828 die->sibling = NULL;
14829 die->parent = parent;
14830 return die;
14831 }
14832
14833 /* Read a die, all of its descendents, and all of its siblings; set
14834 all of the fields of all of the dies correctly. Arguments are as
14835 in read_die_and_children. */
14836
14837 static struct die_info *
14838 read_die_and_siblings_1 (const struct die_reader_specs *reader,
14839 const gdb_byte *info_ptr,
14840 const gdb_byte **new_info_ptr,
14841 struct die_info *parent)
14842 {
14843 struct die_info *first_die, *last_sibling;
14844 const gdb_byte *cur_ptr;
14845
14846 cur_ptr = info_ptr;
14847 first_die = last_sibling = NULL;
14848
14849 while (1)
14850 {
14851 struct die_info *die
14852 = read_die_and_children (reader, cur_ptr, &cur_ptr, parent);
14853
14854 if (die == NULL)
14855 {
14856 *new_info_ptr = cur_ptr;
14857 return first_die;
14858 }
14859
14860 if (!first_die)
14861 first_die = die;
14862 else
14863 last_sibling->sibling = die;
14864
14865 last_sibling = die;
14866 }
14867 }
14868
14869 /* Read a die, all of its descendents, and all of its siblings; set
14870 all of the fields of all of the dies correctly. Arguments are as
14871 in read_die_and_children.
14872 This the main entry point for reading a DIE and all its children. */
14873
14874 static struct die_info *
14875 read_die_and_siblings (const struct die_reader_specs *reader,
14876 const gdb_byte *info_ptr,
14877 const gdb_byte **new_info_ptr,
14878 struct die_info *parent)
14879 {
14880 struct die_info *die = read_die_and_siblings_1 (reader, info_ptr,
14881 new_info_ptr, parent);
14882
14883 if (dwarf2_die_debug)
14884 {
14885 fprintf_unfiltered (gdb_stdlog,
14886 "Read die from %s@0x%x of %s:\n",
14887 get_section_name (reader->die_section),
14888 (unsigned) (info_ptr - reader->die_section->buffer),
14889 bfd_get_filename (reader->abfd));
14890 dump_die (die, dwarf2_die_debug);
14891 }
14892
14893 return die;
14894 }
14895
14896 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
14897 attributes.
14898 The caller is responsible for filling in the extra attributes
14899 and updating (*DIEP)->num_attrs.
14900 Set DIEP to point to a newly allocated die with its information,
14901 except for its child, sibling, and parent fields.
14902 Set HAS_CHILDREN to tell whether the die has children or not. */
14903
14904 static const gdb_byte *
14905 read_full_die_1 (const struct die_reader_specs *reader,
14906 struct die_info **diep, const gdb_byte *info_ptr,
14907 int *has_children, int num_extra_attrs)
14908 {
14909 unsigned int abbrev_number, bytes_read, i;
14910 sect_offset offset;
14911 struct abbrev_info *abbrev;
14912 struct die_info *die;
14913 struct dwarf2_cu *cu = reader->cu;
14914 bfd *abfd = reader->abfd;
14915
14916 offset.sect_off = info_ptr - reader->buffer;
14917 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
14918 info_ptr += bytes_read;
14919 if (!abbrev_number)
14920 {
14921 *diep = NULL;
14922 *has_children = 0;
14923 return info_ptr;
14924 }
14925
14926 abbrev = abbrev_table_lookup_abbrev (cu->abbrev_table, abbrev_number);
14927 if (!abbrev)
14928 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
14929 abbrev_number,
14930 bfd_get_filename (abfd));
14931
14932 die = dwarf_alloc_die (cu, abbrev->num_attrs + num_extra_attrs);
14933 die->offset = offset;
14934 die->tag = abbrev->tag;
14935 die->abbrev = abbrev_number;
14936
14937 /* Make the result usable.
14938 The caller needs to update num_attrs after adding the extra
14939 attributes. */
14940 die->num_attrs = abbrev->num_attrs;
14941
14942 for (i = 0; i < abbrev->num_attrs; ++i)
14943 info_ptr = read_attribute (reader, &die->attrs[i], &abbrev->attrs[i],
14944 info_ptr);
14945
14946 *diep = die;
14947 *has_children = abbrev->has_children;
14948 return info_ptr;
14949 }
14950
14951 /* Read a die and all its attributes.
14952 Set DIEP to point to a newly allocated die with its information,
14953 except for its child, sibling, and parent fields.
14954 Set HAS_CHILDREN to tell whether the die has children or not. */
14955
14956 static const gdb_byte *
14957 read_full_die (const struct die_reader_specs *reader,
14958 struct die_info **diep, const gdb_byte *info_ptr,
14959 int *has_children)
14960 {
14961 const gdb_byte *result;
14962
14963 result = read_full_die_1 (reader, diep, info_ptr, has_children, 0);
14964
14965 if (dwarf2_die_debug)
14966 {
14967 fprintf_unfiltered (gdb_stdlog,
14968 "Read die from %s@0x%x of %s:\n",
14969 get_section_name (reader->die_section),
14970 (unsigned) (info_ptr - reader->die_section->buffer),
14971 bfd_get_filename (reader->abfd));
14972 dump_die (*diep, dwarf2_die_debug);
14973 }
14974
14975 return result;
14976 }
14977 \f
14978 /* Abbreviation tables.
14979
14980 In DWARF version 2, the description of the debugging information is
14981 stored in a separate .debug_abbrev section. Before we read any
14982 dies from a section we read in all abbreviations and install them
14983 in a hash table. */
14984
14985 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
14986
14987 static struct abbrev_info *
14988 abbrev_table_alloc_abbrev (struct abbrev_table *abbrev_table)
14989 {
14990 struct abbrev_info *abbrev;
14991
14992 abbrev = (struct abbrev_info *)
14993 obstack_alloc (&abbrev_table->abbrev_obstack, sizeof (struct abbrev_info));
14994 memset (abbrev, 0, sizeof (struct abbrev_info));
14995 return abbrev;
14996 }
14997
14998 /* Add an abbreviation to the table. */
14999
15000 static void
15001 abbrev_table_add_abbrev (struct abbrev_table *abbrev_table,
15002 unsigned int abbrev_number,
15003 struct abbrev_info *abbrev)
15004 {
15005 unsigned int hash_number;
15006
15007 hash_number = abbrev_number % ABBREV_HASH_SIZE;
15008 abbrev->next = abbrev_table->abbrevs[hash_number];
15009 abbrev_table->abbrevs[hash_number] = abbrev;
15010 }
15011
15012 /* Look up an abbrev in the table.
15013 Returns NULL if the abbrev is not found. */
15014
15015 static struct abbrev_info *
15016 abbrev_table_lookup_abbrev (const struct abbrev_table *abbrev_table,
15017 unsigned int abbrev_number)
15018 {
15019 unsigned int hash_number;
15020 struct abbrev_info *abbrev;
15021
15022 hash_number = abbrev_number % ABBREV_HASH_SIZE;
15023 abbrev = abbrev_table->abbrevs[hash_number];
15024
15025 while (abbrev)
15026 {
15027 if (abbrev->number == abbrev_number)
15028 return abbrev;
15029 abbrev = abbrev->next;
15030 }
15031 return NULL;
15032 }
15033
15034 /* Read in an abbrev table. */
15035
15036 static struct abbrev_table *
15037 abbrev_table_read_table (struct dwarf2_section_info *section,
15038 sect_offset offset)
15039 {
15040 struct objfile *objfile = dwarf2_per_objfile->objfile;
15041 bfd *abfd = get_section_bfd_owner (section);
15042 struct abbrev_table *abbrev_table;
15043 const gdb_byte *abbrev_ptr;
15044 struct abbrev_info *cur_abbrev;
15045 unsigned int abbrev_number, bytes_read, abbrev_name;
15046 unsigned int abbrev_form;
15047 struct attr_abbrev *cur_attrs;
15048 unsigned int allocated_attrs;
15049
15050 abbrev_table = XNEW (struct abbrev_table);
15051 abbrev_table->offset = offset;
15052 obstack_init (&abbrev_table->abbrev_obstack);
15053 abbrev_table->abbrevs = obstack_alloc (&abbrev_table->abbrev_obstack,
15054 (ABBREV_HASH_SIZE
15055 * sizeof (struct abbrev_info *)));
15056 memset (abbrev_table->abbrevs, 0,
15057 ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
15058
15059 dwarf2_read_section (objfile, section);
15060 abbrev_ptr = section->buffer + offset.sect_off;
15061 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
15062 abbrev_ptr += bytes_read;
15063
15064 allocated_attrs = ATTR_ALLOC_CHUNK;
15065 cur_attrs = xmalloc (allocated_attrs * sizeof (struct attr_abbrev));
15066
15067 /* Loop until we reach an abbrev number of 0. */
15068 while (abbrev_number)
15069 {
15070 cur_abbrev = abbrev_table_alloc_abbrev (abbrev_table);
15071
15072 /* read in abbrev header */
15073 cur_abbrev->number = abbrev_number;
15074 cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
15075 abbrev_ptr += bytes_read;
15076 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
15077 abbrev_ptr += 1;
15078
15079 /* now read in declarations */
15080 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
15081 abbrev_ptr += bytes_read;
15082 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
15083 abbrev_ptr += bytes_read;
15084 while (abbrev_name)
15085 {
15086 if (cur_abbrev->num_attrs == allocated_attrs)
15087 {
15088 allocated_attrs += ATTR_ALLOC_CHUNK;
15089 cur_attrs
15090 = xrealloc (cur_attrs, (allocated_attrs
15091 * sizeof (struct attr_abbrev)));
15092 }
15093
15094 cur_attrs[cur_abbrev->num_attrs].name = abbrev_name;
15095 cur_attrs[cur_abbrev->num_attrs++].form = abbrev_form;
15096 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
15097 abbrev_ptr += bytes_read;
15098 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
15099 abbrev_ptr += bytes_read;
15100 }
15101
15102 cur_abbrev->attrs = obstack_alloc (&abbrev_table->abbrev_obstack,
15103 (cur_abbrev->num_attrs
15104 * sizeof (struct attr_abbrev)));
15105 memcpy (cur_abbrev->attrs, cur_attrs,
15106 cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
15107
15108 abbrev_table_add_abbrev (abbrev_table, abbrev_number, cur_abbrev);
15109
15110 /* Get next abbreviation.
15111 Under Irix6 the abbreviations for a compilation unit are not
15112 always properly terminated with an abbrev number of 0.
15113 Exit loop if we encounter an abbreviation which we have
15114 already read (which means we are about to read the abbreviations
15115 for the next compile unit) or if the end of the abbreviation
15116 table is reached. */
15117 if ((unsigned int) (abbrev_ptr - section->buffer) >= section->size)
15118 break;
15119 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
15120 abbrev_ptr += bytes_read;
15121 if (abbrev_table_lookup_abbrev (abbrev_table, abbrev_number) != NULL)
15122 break;
15123 }
15124
15125 xfree (cur_attrs);
15126 return abbrev_table;
15127 }
15128
15129 /* Free the resources held by ABBREV_TABLE. */
15130
15131 static void
15132 abbrev_table_free (struct abbrev_table *abbrev_table)
15133 {
15134 obstack_free (&abbrev_table->abbrev_obstack, NULL);
15135 xfree (abbrev_table);
15136 }
15137
15138 /* Same as abbrev_table_free but as a cleanup.
15139 We pass in a pointer to the pointer to the table so that we can
15140 set the pointer to NULL when we're done. It also simplifies
15141 build_type_psymtabs_1. */
15142
15143 static void
15144 abbrev_table_free_cleanup (void *table_ptr)
15145 {
15146 struct abbrev_table **abbrev_table_ptr = table_ptr;
15147
15148 if (*abbrev_table_ptr != NULL)
15149 abbrev_table_free (*abbrev_table_ptr);
15150 *abbrev_table_ptr = NULL;
15151 }
15152
15153 /* Read the abbrev table for CU from ABBREV_SECTION. */
15154
15155 static void
15156 dwarf2_read_abbrevs (struct dwarf2_cu *cu,
15157 struct dwarf2_section_info *abbrev_section)
15158 {
15159 cu->abbrev_table =
15160 abbrev_table_read_table (abbrev_section, cu->header.abbrev_offset);
15161 }
15162
15163 /* Release the memory used by the abbrev table for a compilation unit. */
15164
15165 static void
15166 dwarf2_free_abbrev_table (void *ptr_to_cu)
15167 {
15168 struct dwarf2_cu *cu = ptr_to_cu;
15169
15170 if (cu->abbrev_table != NULL)
15171 abbrev_table_free (cu->abbrev_table);
15172 /* Set this to NULL so that we SEGV if we try to read it later,
15173 and also because free_comp_unit verifies this is NULL. */
15174 cu->abbrev_table = NULL;
15175 }
15176 \f
15177 /* Returns nonzero if TAG represents a type that we might generate a partial
15178 symbol for. */
15179
15180 static int
15181 is_type_tag_for_partial (int tag)
15182 {
15183 switch (tag)
15184 {
15185 #if 0
15186 /* Some types that would be reasonable to generate partial symbols for,
15187 that we don't at present. */
15188 case DW_TAG_array_type:
15189 case DW_TAG_file_type:
15190 case DW_TAG_ptr_to_member_type:
15191 case DW_TAG_set_type:
15192 case DW_TAG_string_type:
15193 case DW_TAG_subroutine_type:
15194 #endif
15195 case DW_TAG_base_type:
15196 case DW_TAG_class_type:
15197 case DW_TAG_interface_type:
15198 case DW_TAG_enumeration_type:
15199 case DW_TAG_structure_type:
15200 case DW_TAG_subrange_type:
15201 case DW_TAG_typedef:
15202 case DW_TAG_union_type:
15203 return 1;
15204 default:
15205 return 0;
15206 }
15207 }
15208
15209 /* Load all DIEs that are interesting for partial symbols into memory. */
15210
15211 static struct partial_die_info *
15212 load_partial_dies (const struct die_reader_specs *reader,
15213 const gdb_byte *info_ptr, int building_psymtab)
15214 {
15215 struct dwarf2_cu *cu = reader->cu;
15216 struct objfile *objfile = cu->objfile;
15217 struct partial_die_info *part_die;
15218 struct partial_die_info *parent_die, *last_die, *first_die = NULL;
15219 struct abbrev_info *abbrev;
15220 unsigned int bytes_read;
15221 unsigned int load_all = 0;
15222 int nesting_level = 1;
15223
15224 parent_die = NULL;
15225 last_die = NULL;
15226
15227 gdb_assert (cu->per_cu != NULL);
15228 if (cu->per_cu->load_all_dies)
15229 load_all = 1;
15230
15231 cu->partial_dies
15232 = htab_create_alloc_ex (cu->header.length / 12,
15233 partial_die_hash,
15234 partial_die_eq,
15235 NULL,
15236 &cu->comp_unit_obstack,
15237 hashtab_obstack_allocate,
15238 dummy_obstack_deallocate);
15239
15240 part_die = obstack_alloc (&cu->comp_unit_obstack,
15241 sizeof (struct partial_die_info));
15242
15243 while (1)
15244 {
15245 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
15246
15247 /* A NULL abbrev means the end of a series of children. */
15248 if (abbrev == NULL)
15249 {
15250 if (--nesting_level == 0)
15251 {
15252 /* PART_DIE was probably the last thing allocated on the
15253 comp_unit_obstack, so we could call obstack_free
15254 here. We don't do that because the waste is small,
15255 and will be cleaned up when we're done with this
15256 compilation unit. This way, we're also more robust
15257 against other users of the comp_unit_obstack. */
15258 return first_die;
15259 }
15260 info_ptr += bytes_read;
15261 last_die = parent_die;
15262 parent_die = parent_die->die_parent;
15263 continue;
15264 }
15265
15266 /* Check for template arguments. We never save these; if
15267 they're seen, we just mark the parent, and go on our way. */
15268 if (parent_die != NULL
15269 && cu->language == language_cplus
15270 && (abbrev->tag == DW_TAG_template_type_param
15271 || abbrev->tag == DW_TAG_template_value_param))
15272 {
15273 parent_die->has_template_arguments = 1;
15274
15275 if (!load_all)
15276 {
15277 /* We don't need a partial DIE for the template argument. */
15278 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
15279 continue;
15280 }
15281 }
15282
15283 /* We only recurse into c++ subprograms looking for template arguments.
15284 Skip their other children. */
15285 if (!load_all
15286 && cu->language == language_cplus
15287 && parent_die != NULL
15288 && parent_die->tag == DW_TAG_subprogram)
15289 {
15290 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
15291 continue;
15292 }
15293
15294 /* Check whether this DIE is interesting enough to save. Normally
15295 we would not be interested in members here, but there may be
15296 later variables referencing them via DW_AT_specification (for
15297 static members). */
15298 if (!load_all
15299 && !is_type_tag_for_partial (abbrev->tag)
15300 && abbrev->tag != DW_TAG_constant
15301 && abbrev->tag != DW_TAG_enumerator
15302 && abbrev->tag != DW_TAG_subprogram
15303 && abbrev->tag != DW_TAG_lexical_block
15304 && abbrev->tag != DW_TAG_variable
15305 && abbrev->tag != DW_TAG_namespace
15306 && abbrev->tag != DW_TAG_module
15307 && abbrev->tag != DW_TAG_member
15308 && abbrev->tag != DW_TAG_imported_unit
15309 && abbrev->tag != DW_TAG_imported_declaration)
15310 {
15311 /* Otherwise we skip to the next sibling, if any. */
15312 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
15313 continue;
15314 }
15315
15316 info_ptr = read_partial_die (reader, part_die, abbrev, bytes_read,
15317 info_ptr);
15318
15319 /* This two-pass algorithm for processing partial symbols has a
15320 high cost in cache pressure. Thus, handle some simple cases
15321 here which cover the majority of C partial symbols. DIEs
15322 which neither have specification tags in them, nor could have
15323 specification tags elsewhere pointing at them, can simply be
15324 processed and discarded.
15325
15326 This segment is also optional; scan_partial_symbols and
15327 add_partial_symbol will handle these DIEs if we chain
15328 them in normally. When compilers which do not emit large
15329 quantities of duplicate debug information are more common,
15330 this code can probably be removed. */
15331
15332 /* Any complete simple types at the top level (pretty much all
15333 of them, for a language without namespaces), can be processed
15334 directly. */
15335 if (parent_die == NULL
15336 && part_die->has_specification == 0
15337 && part_die->is_declaration == 0
15338 && ((part_die->tag == DW_TAG_typedef && !part_die->has_children)
15339 || part_die->tag == DW_TAG_base_type
15340 || part_die->tag == DW_TAG_subrange_type))
15341 {
15342 if (building_psymtab && part_die->name != NULL)
15343 add_psymbol_to_list (part_die->name, strlen (part_die->name), 0,
15344 VAR_DOMAIN, LOC_TYPEDEF,
15345 &objfile->static_psymbols,
15346 0, (CORE_ADDR) 0, cu->language, objfile);
15347 info_ptr = locate_pdi_sibling (reader, part_die, info_ptr);
15348 continue;
15349 }
15350
15351 /* The exception for DW_TAG_typedef with has_children above is
15352 a workaround of GCC PR debug/47510. In the case of this complaint
15353 type_name_no_tag_or_error will error on such types later.
15354
15355 GDB skipped children of DW_TAG_typedef by the shortcut above and then
15356 it could not find the child DIEs referenced later, this is checked
15357 above. In correct DWARF DW_TAG_typedef should have no children. */
15358
15359 if (part_die->tag == DW_TAG_typedef && part_die->has_children)
15360 complaint (&symfile_complaints,
15361 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
15362 "- DIE at 0x%x [in module %s]"),
15363 part_die->offset.sect_off, objfile_name (objfile));
15364
15365 /* If we're at the second level, and we're an enumerator, and
15366 our parent has no specification (meaning possibly lives in a
15367 namespace elsewhere), then we can add the partial symbol now
15368 instead of queueing it. */
15369 if (part_die->tag == DW_TAG_enumerator
15370 && parent_die != NULL
15371 && parent_die->die_parent == NULL
15372 && parent_die->tag == DW_TAG_enumeration_type
15373 && parent_die->has_specification == 0)
15374 {
15375 if (part_die->name == NULL)
15376 complaint (&symfile_complaints,
15377 _("malformed enumerator DIE ignored"));
15378 else if (building_psymtab)
15379 add_psymbol_to_list (part_die->name, strlen (part_die->name), 0,
15380 VAR_DOMAIN, LOC_CONST,
15381 (cu->language == language_cplus
15382 || cu->language == language_java)
15383 ? &objfile->global_psymbols
15384 : &objfile->static_psymbols,
15385 0, (CORE_ADDR) 0, cu->language, objfile);
15386
15387 info_ptr = locate_pdi_sibling (reader, part_die, info_ptr);
15388 continue;
15389 }
15390
15391 /* We'll save this DIE so link it in. */
15392 part_die->die_parent = parent_die;
15393 part_die->die_sibling = NULL;
15394 part_die->die_child = NULL;
15395
15396 if (last_die && last_die == parent_die)
15397 last_die->die_child = part_die;
15398 else if (last_die)
15399 last_die->die_sibling = part_die;
15400
15401 last_die = part_die;
15402
15403 if (first_die == NULL)
15404 first_die = part_die;
15405
15406 /* Maybe add the DIE to the hash table. Not all DIEs that we
15407 find interesting need to be in the hash table, because we
15408 also have the parent/sibling/child chains; only those that we
15409 might refer to by offset later during partial symbol reading.
15410
15411 For now this means things that might have be the target of a
15412 DW_AT_specification, DW_AT_abstract_origin, or
15413 DW_AT_extension. DW_AT_extension will refer only to
15414 namespaces; DW_AT_abstract_origin refers to functions (and
15415 many things under the function DIE, but we do not recurse
15416 into function DIEs during partial symbol reading) and
15417 possibly variables as well; DW_AT_specification refers to
15418 declarations. Declarations ought to have the DW_AT_declaration
15419 flag. It happens that GCC forgets to put it in sometimes, but
15420 only for functions, not for types.
15421
15422 Adding more things than necessary to the hash table is harmless
15423 except for the performance cost. Adding too few will result in
15424 wasted time in find_partial_die, when we reread the compilation
15425 unit with load_all_dies set. */
15426
15427 if (load_all
15428 || abbrev->tag == DW_TAG_constant
15429 || abbrev->tag == DW_TAG_subprogram
15430 || abbrev->tag == DW_TAG_variable
15431 || abbrev->tag == DW_TAG_namespace
15432 || part_die->is_declaration)
15433 {
15434 void **slot;
15435
15436 slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
15437 part_die->offset.sect_off, INSERT);
15438 *slot = part_die;
15439 }
15440
15441 part_die = obstack_alloc (&cu->comp_unit_obstack,
15442 sizeof (struct partial_die_info));
15443
15444 /* For some DIEs we want to follow their children (if any). For C
15445 we have no reason to follow the children of structures; for other
15446 languages we have to, so that we can get at method physnames
15447 to infer fully qualified class names, for DW_AT_specification,
15448 and for C++ template arguments. For C++, we also look one level
15449 inside functions to find template arguments (if the name of the
15450 function does not already contain the template arguments).
15451
15452 For Ada, we need to scan the children of subprograms and lexical
15453 blocks as well because Ada allows the definition of nested
15454 entities that could be interesting for the debugger, such as
15455 nested subprograms for instance. */
15456 if (last_die->has_children
15457 && (load_all
15458 || last_die->tag == DW_TAG_namespace
15459 || last_die->tag == DW_TAG_module
15460 || last_die->tag == DW_TAG_enumeration_type
15461 || (cu->language == language_cplus
15462 && last_die->tag == DW_TAG_subprogram
15463 && (last_die->name == NULL
15464 || strchr (last_die->name, '<') == NULL))
15465 || (cu->language != language_c
15466 && (last_die->tag == DW_TAG_class_type
15467 || last_die->tag == DW_TAG_interface_type
15468 || last_die->tag == DW_TAG_structure_type
15469 || last_die->tag == DW_TAG_union_type))
15470 || (cu->language == language_ada
15471 && (last_die->tag == DW_TAG_subprogram
15472 || last_die->tag == DW_TAG_lexical_block))))
15473 {
15474 nesting_level++;
15475 parent_die = last_die;
15476 continue;
15477 }
15478
15479 /* Otherwise we skip to the next sibling, if any. */
15480 info_ptr = locate_pdi_sibling (reader, last_die, info_ptr);
15481
15482 /* Back to the top, do it again. */
15483 }
15484 }
15485
15486 /* Read a minimal amount of information into the minimal die structure. */
15487
15488 static const gdb_byte *
15489 read_partial_die (const struct die_reader_specs *reader,
15490 struct partial_die_info *part_die,
15491 struct abbrev_info *abbrev, unsigned int abbrev_len,
15492 const gdb_byte *info_ptr)
15493 {
15494 struct dwarf2_cu *cu = reader->cu;
15495 struct objfile *objfile = cu->objfile;
15496 const gdb_byte *buffer = reader->buffer;
15497 unsigned int i;
15498 struct attribute attr;
15499 int has_low_pc_attr = 0;
15500 int has_high_pc_attr = 0;
15501 int high_pc_relative = 0;
15502
15503 memset (part_die, 0, sizeof (struct partial_die_info));
15504
15505 part_die->offset.sect_off = info_ptr - buffer;
15506
15507 info_ptr += abbrev_len;
15508
15509 if (abbrev == NULL)
15510 return info_ptr;
15511
15512 part_die->tag = abbrev->tag;
15513 part_die->has_children = abbrev->has_children;
15514
15515 for (i = 0; i < abbrev->num_attrs; ++i)
15516 {
15517 info_ptr = read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
15518
15519 /* Store the data if it is of an attribute we want to keep in a
15520 partial symbol table. */
15521 switch (attr.name)
15522 {
15523 case DW_AT_name:
15524 switch (part_die->tag)
15525 {
15526 case DW_TAG_compile_unit:
15527 case DW_TAG_partial_unit:
15528 case DW_TAG_type_unit:
15529 /* Compilation units have a DW_AT_name that is a filename, not
15530 a source language identifier. */
15531 case DW_TAG_enumeration_type:
15532 case DW_TAG_enumerator:
15533 /* These tags always have simple identifiers already; no need
15534 to canonicalize them. */
15535 part_die->name = DW_STRING (&attr);
15536 break;
15537 default:
15538 part_die->name
15539 = dwarf2_canonicalize_name (DW_STRING (&attr), cu,
15540 &objfile->per_bfd->storage_obstack);
15541 break;
15542 }
15543 break;
15544 case DW_AT_linkage_name:
15545 case DW_AT_MIPS_linkage_name:
15546 /* Note that both forms of linkage name might appear. We
15547 assume they will be the same, and we only store the last
15548 one we see. */
15549 if (cu->language == language_ada)
15550 part_die->name = DW_STRING (&attr);
15551 part_die->linkage_name = DW_STRING (&attr);
15552 break;
15553 case DW_AT_low_pc:
15554 has_low_pc_attr = 1;
15555 part_die->lowpc = attr_value_as_address (&attr);
15556 break;
15557 case DW_AT_high_pc:
15558 has_high_pc_attr = 1;
15559 part_die->highpc = attr_value_as_address (&attr);
15560 if (cu->header.version >= 4 && attr_form_is_constant (&attr))
15561 high_pc_relative = 1;
15562 break;
15563 case DW_AT_location:
15564 /* Support the .debug_loc offsets. */
15565 if (attr_form_is_block (&attr))
15566 {
15567 part_die->d.locdesc = DW_BLOCK (&attr);
15568 }
15569 else if (attr_form_is_section_offset (&attr))
15570 {
15571 dwarf2_complex_location_expr_complaint ();
15572 }
15573 else
15574 {
15575 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
15576 "partial symbol information");
15577 }
15578 break;
15579 case DW_AT_external:
15580 part_die->is_external = DW_UNSND (&attr);
15581 break;
15582 case DW_AT_declaration:
15583 part_die->is_declaration = DW_UNSND (&attr);
15584 break;
15585 case DW_AT_type:
15586 part_die->has_type = 1;
15587 break;
15588 case DW_AT_abstract_origin:
15589 case DW_AT_specification:
15590 case DW_AT_extension:
15591 part_die->has_specification = 1;
15592 part_die->spec_offset = dwarf2_get_ref_die_offset (&attr);
15593 part_die->spec_is_dwz = (attr.form == DW_FORM_GNU_ref_alt
15594 || cu->per_cu->is_dwz);
15595 break;
15596 case DW_AT_sibling:
15597 /* Ignore absolute siblings, they might point outside of
15598 the current compile unit. */
15599 if (attr.form == DW_FORM_ref_addr)
15600 complaint (&symfile_complaints,
15601 _("ignoring absolute DW_AT_sibling"));
15602 else
15603 {
15604 unsigned int off = dwarf2_get_ref_die_offset (&attr).sect_off;
15605 const gdb_byte *sibling_ptr = buffer + off;
15606
15607 if (sibling_ptr < info_ptr)
15608 complaint (&symfile_complaints,
15609 _("DW_AT_sibling points backwards"));
15610 else if (sibling_ptr > reader->buffer_end)
15611 dwarf2_section_buffer_overflow_complaint (reader->die_section);
15612 else
15613 part_die->sibling = sibling_ptr;
15614 }
15615 break;
15616 case DW_AT_byte_size:
15617 part_die->has_byte_size = 1;
15618 break;
15619 case DW_AT_calling_convention:
15620 /* DWARF doesn't provide a way to identify a program's source-level
15621 entry point. DW_AT_calling_convention attributes are only meant
15622 to describe functions' calling conventions.
15623
15624 However, because it's a necessary piece of information in
15625 Fortran, and because DW_CC_program is the only piece of debugging
15626 information whose definition refers to a 'main program' at all,
15627 several compilers have begun marking Fortran main programs with
15628 DW_CC_program --- even when those functions use the standard
15629 calling conventions.
15630
15631 So until DWARF specifies a way to provide this information and
15632 compilers pick up the new representation, we'll support this
15633 practice. */
15634 if (DW_UNSND (&attr) == DW_CC_program
15635 && cu->language == language_fortran)
15636 set_objfile_main_name (objfile, part_die->name, language_fortran);
15637 break;
15638 case DW_AT_inline:
15639 if (DW_UNSND (&attr) == DW_INL_inlined
15640 || DW_UNSND (&attr) == DW_INL_declared_inlined)
15641 part_die->may_be_inlined = 1;
15642 break;
15643
15644 case DW_AT_import:
15645 if (part_die->tag == DW_TAG_imported_unit)
15646 {
15647 part_die->d.offset = dwarf2_get_ref_die_offset (&attr);
15648 part_die->is_dwz = (attr.form == DW_FORM_GNU_ref_alt
15649 || cu->per_cu->is_dwz);
15650 }
15651 break;
15652
15653 default:
15654 break;
15655 }
15656 }
15657
15658 if (high_pc_relative)
15659 part_die->highpc += part_die->lowpc;
15660
15661 if (has_low_pc_attr && has_high_pc_attr)
15662 {
15663 /* When using the GNU linker, .gnu.linkonce. sections are used to
15664 eliminate duplicate copies of functions and vtables and such.
15665 The linker will arbitrarily choose one and discard the others.
15666 The AT_*_pc values for such functions refer to local labels in
15667 these sections. If the section from that file was discarded, the
15668 labels are not in the output, so the relocs get a value of 0.
15669 If this is a discarded function, mark the pc bounds as invalid,
15670 so that GDB will ignore it. */
15671 if (part_die->lowpc == 0 && !dwarf2_per_objfile->has_section_at_zero)
15672 {
15673 struct gdbarch *gdbarch = get_objfile_arch (objfile);
15674
15675 complaint (&symfile_complaints,
15676 _("DW_AT_low_pc %s is zero "
15677 "for DIE at 0x%x [in module %s]"),
15678 paddress (gdbarch, part_die->lowpc),
15679 part_die->offset.sect_off, objfile_name (objfile));
15680 }
15681 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
15682 else if (part_die->lowpc >= part_die->highpc)
15683 {
15684 struct gdbarch *gdbarch = get_objfile_arch (objfile);
15685
15686 complaint (&symfile_complaints,
15687 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
15688 "for DIE at 0x%x [in module %s]"),
15689 paddress (gdbarch, part_die->lowpc),
15690 paddress (gdbarch, part_die->highpc),
15691 part_die->offset.sect_off, objfile_name (objfile));
15692 }
15693 else
15694 part_die->has_pc_info = 1;
15695 }
15696
15697 return info_ptr;
15698 }
15699
15700 /* Find a cached partial DIE at OFFSET in CU. */
15701
15702 static struct partial_die_info *
15703 find_partial_die_in_comp_unit (sect_offset offset, struct dwarf2_cu *cu)
15704 {
15705 struct partial_die_info *lookup_die = NULL;
15706 struct partial_die_info part_die;
15707
15708 part_die.offset = offset;
15709 lookup_die = htab_find_with_hash (cu->partial_dies, &part_die,
15710 offset.sect_off);
15711
15712 return lookup_die;
15713 }
15714
15715 /* Find a partial DIE at OFFSET, which may or may not be in CU,
15716 except in the case of .debug_types DIEs which do not reference
15717 outside their CU (they do however referencing other types via
15718 DW_FORM_ref_sig8). */
15719
15720 static struct partial_die_info *
15721 find_partial_die (sect_offset offset, int offset_in_dwz, struct dwarf2_cu *cu)
15722 {
15723 struct objfile *objfile = cu->objfile;
15724 struct dwarf2_per_cu_data *per_cu = NULL;
15725 struct partial_die_info *pd = NULL;
15726
15727 if (offset_in_dwz == cu->per_cu->is_dwz
15728 && offset_in_cu_p (&cu->header, offset))
15729 {
15730 pd = find_partial_die_in_comp_unit (offset, cu);
15731 if (pd != NULL)
15732 return pd;
15733 /* We missed recording what we needed.
15734 Load all dies and try again. */
15735 per_cu = cu->per_cu;
15736 }
15737 else
15738 {
15739 /* TUs don't reference other CUs/TUs (except via type signatures). */
15740 if (cu->per_cu->is_debug_types)
15741 {
15742 error (_("Dwarf Error: Type Unit at offset 0x%lx contains"
15743 " external reference to offset 0x%lx [in module %s].\n"),
15744 (long) cu->header.offset.sect_off, (long) offset.sect_off,
15745 bfd_get_filename (objfile->obfd));
15746 }
15747 per_cu = dwarf2_find_containing_comp_unit (offset, offset_in_dwz,
15748 objfile);
15749
15750 if (per_cu->cu == NULL || per_cu->cu->partial_dies == NULL)
15751 load_partial_comp_unit (per_cu);
15752
15753 per_cu->cu->last_used = 0;
15754 pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
15755 }
15756
15757 /* If we didn't find it, and not all dies have been loaded,
15758 load them all and try again. */
15759
15760 if (pd == NULL && per_cu->load_all_dies == 0)
15761 {
15762 per_cu->load_all_dies = 1;
15763
15764 /* This is nasty. When we reread the DIEs, somewhere up the call chain
15765 THIS_CU->cu may already be in use. So we can't just free it and
15766 replace its DIEs with the ones we read in. Instead, we leave those
15767 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
15768 and clobber THIS_CU->cu->partial_dies with the hash table for the new
15769 set. */
15770 load_partial_comp_unit (per_cu);
15771
15772 pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
15773 }
15774
15775 if (pd == NULL)
15776 internal_error (__FILE__, __LINE__,
15777 _("could not find partial DIE 0x%x "
15778 "in cache [from module %s]\n"),
15779 offset.sect_off, bfd_get_filename (objfile->obfd));
15780 return pd;
15781 }
15782
15783 /* See if we can figure out if the class lives in a namespace. We do
15784 this by looking for a member function; its demangled name will
15785 contain namespace info, if there is any. */
15786
15787 static void
15788 guess_partial_die_structure_name (struct partial_die_info *struct_pdi,
15789 struct dwarf2_cu *cu)
15790 {
15791 /* NOTE: carlton/2003-10-07: Getting the info this way changes
15792 what template types look like, because the demangler
15793 frequently doesn't give the same name as the debug info. We
15794 could fix this by only using the demangled name to get the
15795 prefix (but see comment in read_structure_type). */
15796
15797 struct partial_die_info *real_pdi;
15798 struct partial_die_info *child_pdi;
15799
15800 /* If this DIE (this DIE's specification, if any) has a parent, then
15801 we should not do this. We'll prepend the parent's fully qualified
15802 name when we create the partial symbol. */
15803
15804 real_pdi = struct_pdi;
15805 while (real_pdi->has_specification)
15806 real_pdi = find_partial_die (real_pdi->spec_offset,
15807 real_pdi->spec_is_dwz, cu);
15808
15809 if (real_pdi->die_parent != NULL)
15810 return;
15811
15812 for (child_pdi = struct_pdi->die_child;
15813 child_pdi != NULL;
15814 child_pdi = child_pdi->die_sibling)
15815 {
15816 if (child_pdi->tag == DW_TAG_subprogram
15817 && child_pdi->linkage_name != NULL)
15818 {
15819 char *actual_class_name
15820 = language_class_name_from_physname (cu->language_defn,
15821 child_pdi->linkage_name);
15822 if (actual_class_name != NULL)
15823 {
15824 struct_pdi->name
15825 = obstack_copy0 (&cu->objfile->per_bfd->storage_obstack,
15826 actual_class_name,
15827 strlen (actual_class_name));
15828 xfree (actual_class_name);
15829 }
15830 break;
15831 }
15832 }
15833 }
15834
15835 /* Adjust PART_DIE before generating a symbol for it. This function
15836 may set the is_external flag or change the DIE's name. */
15837
15838 static void
15839 fixup_partial_die (struct partial_die_info *part_die,
15840 struct dwarf2_cu *cu)
15841 {
15842 /* Once we've fixed up a die, there's no point in doing so again.
15843 This also avoids a memory leak if we were to call
15844 guess_partial_die_structure_name multiple times. */
15845 if (part_die->fixup_called)
15846 return;
15847
15848 /* If we found a reference attribute and the DIE has no name, try
15849 to find a name in the referred to DIE. */
15850
15851 if (part_die->name == NULL && part_die->has_specification)
15852 {
15853 struct partial_die_info *spec_die;
15854
15855 spec_die = find_partial_die (part_die->spec_offset,
15856 part_die->spec_is_dwz, cu);
15857
15858 fixup_partial_die (spec_die, cu);
15859
15860 if (spec_die->name)
15861 {
15862 part_die->name = spec_die->name;
15863
15864 /* Copy DW_AT_external attribute if it is set. */
15865 if (spec_die->is_external)
15866 part_die->is_external = spec_die->is_external;
15867 }
15868 }
15869
15870 /* Set default names for some unnamed DIEs. */
15871
15872 if (part_die->name == NULL && part_die->tag == DW_TAG_namespace)
15873 part_die->name = CP_ANONYMOUS_NAMESPACE_STR;
15874
15875 /* If there is no parent die to provide a namespace, and there are
15876 children, see if we can determine the namespace from their linkage
15877 name. */
15878 if (cu->language == language_cplus
15879 && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
15880 && part_die->die_parent == NULL
15881 && part_die->has_children
15882 && (part_die->tag == DW_TAG_class_type
15883 || part_die->tag == DW_TAG_structure_type
15884 || part_die->tag == DW_TAG_union_type))
15885 guess_partial_die_structure_name (part_die, cu);
15886
15887 /* GCC might emit a nameless struct or union that has a linkage
15888 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
15889 if (part_die->name == NULL
15890 && (part_die->tag == DW_TAG_class_type
15891 || part_die->tag == DW_TAG_interface_type
15892 || part_die->tag == DW_TAG_structure_type
15893 || part_die->tag == DW_TAG_union_type)
15894 && part_die->linkage_name != NULL)
15895 {
15896 char *demangled;
15897
15898 demangled = gdb_demangle (part_die->linkage_name, DMGL_TYPES);
15899 if (demangled)
15900 {
15901 const char *base;
15902
15903 /* Strip any leading namespaces/classes, keep only the base name.
15904 DW_AT_name for named DIEs does not contain the prefixes. */
15905 base = strrchr (demangled, ':');
15906 if (base && base > demangled && base[-1] == ':')
15907 base++;
15908 else
15909 base = demangled;
15910
15911 part_die->name
15912 = obstack_copy0 (&cu->objfile->per_bfd->storage_obstack,
15913 base, strlen (base));
15914 xfree (demangled);
15915 }
15916 }
15917
15918 part_die->fixup_called = 1;
15919 }
15920
15921 /* Read an attribute value described by an attribute form. */
15922
15923 static const gdb_byte *
15924 read_attribute_value (const struct die_reader_specs *reader,
15925 struct attribute *attr, unsigned form,
15926 const gdb_byte *info_ptr)
15927 {
15928 struct dwarf2_cu *cu = reader->cu;
15929 bfd *abfd = reader->abfd;
15930 struct comp_unit_head *cu_header = &cu->header;
15931 unsigned int bytes_read;
15932 struct dwarf_block *blk;
15933
15934 attr->form = form;
15935 switch (form)
15936 {
15937 case DW_FORM_ref_addr:
15938 if (cu->header.version == 2)
15939 DW_UNSND (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
15940 else
15941 DW_UNSND (attr) = read_offset (abfd, info_ptr,
15942 &cu->header, &bytes_read);
15943 info_ptr += bytes_read;
15944 break;
15945 case DW_FORM_GNU_ref_alt:
15946 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
15947 info_ptr += bytes_read;
15948 break;
15949 case DW_FORM_addr:
15950 DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
15951 info_ptr += bytes_read;
15952 break;
15953 case DW_FORM_block2:
15954 blk = dwarf_alloc_block (cu);
15955 blk->size = read_2_bytes (abfd, info_ptr);
15956 info_ptr += 2;
15957 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
15958 info_ptr += blk->size;
15959 DW_BLOCK (attr) = blk;
15960 break;
15961 case DW_FORM_block4:
15962 blk = dwarf_alloc_block (cu);
15963 blk->size = read_4_bytes (abfd, info_ptr);
15964 info_ptr += 4;
15965 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
15966 info_ptr += blk->size;
15967 DW_BLOCK (attr) = blk;
15968 break;
15969 case DW_FORM_data2:
15970 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
15971 info_ptr += 2;
15972 break;
15973 case DW_FORM_data4:
15974 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
15975 info_ptr += 4;
15976 break;
15977 case DW_FORM_data8:
15978 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
15979 info_ptr += 8;
15980 break;
15981 case DW_FORM_sec_offset:
15982 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
15983 info_ptr += bytes_read;
15984 break;
15985 case DW_FORM_string:
15986 DW_STRING (attr) = read_direct_string (abfd, info_ptr, &bytes_read);
15987 DW_STRING_IS_CANONICAL (attr) = 0;
15988 info_ptr += bytes_read;
15989 break;
15990 case DW_FORM_strp:
15991 if (!cu->per_cu->is_dwz)
15992 {
15993 DW_STRING (attr) = read_indirect_string (abfd, info_ptr, cu_header,
15994 &bytes_read);
15995 DW_STRING_IS_CANONICAL (attr) = 0;
15996 info_ptr += bytes_read;
15997 break;
15998 }
15999 /* FALLTHROUGH */
16000 case DW_FORM_GNU_strp_alt:
16001 {
16002 struct dwz_file *dwz = dwarf2_get_dwz_file ();
16003 LONGEST str_offset = read_offset (abfd, info_ptr, cu_header,
16004 &bytes_read);
16005
16006 DW_STRING (attr) = read_indirect_string_from_dwz (dwz, str_offset);
16007 DW_STRING_IS_CANONICAL (attr) = 0;
16008 info_ptr += bytes_read;
16009 }
16010 break;
16011 case DW_FORM_exprloc:
16012 case DW_FORM_block:
16013 blk = dwarf_alloc_block (cu);
16014 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
16015 info_ptr += bytes_read;
16016 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
16017 info_ptr += blk->size;
16018 DW_BLOCK (attr) = blk;
16019 break;
16020 case DW_FORM_block1:
16021 blk = dwarf_alloc_block (cu);
16022 blk->size = read_1_byte (abfd, info_ptr);
16023 info_ptr += 1;
16024 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
16025 info_ptr += blk->size;
16026 DW_BLOCK (attr) = blk;
16027 break;
16028 case DW_FORM_data1:
16029 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
16030 info_ptr += 1;
16031 break;
16032 case DW_FORM_flag:
16033 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
16034 info_ptr += 1;
16035 break;
16036 case DW_FORM_flag_present:
16037 DW_UNSND (attr) = 1;
16038 break;
16039 case DW_FORM_sdata:
16040 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
16041 info_ptr += bytes_read;
16042 break;
16043 case DW_FORM_udata:
16044 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
16045 info_ptr += bytes_read;
16046 break;
16047 case DW_FORM_ref1:
16048 DW_UNSND (attr) = (cu->header.offset.sect_off
16049 + read_1_byte (abfd, info_ptr));
16050 info_ptr += 1;
16051 break;
16052 case DW_FORM_ref2:
16053 DW_UNSND (attr) = (cu->header.offset.sect_off
16054 + read_2_bytes (abfd, info_ptr));
16055 info_ptr += 2;
16056 break;
16057 case DW_FORM_ref4:
16058 DW_UNSND (attr) = (cu->header.offset.sect_off
16059 + read_4_bytes (abfd, info_ptr));
16060 info_ptr += 4;
16061 break;
16062 case DW_FORM_ref8:
16063 DW_UNSND (attr) = (cu->header.offset.sect_off
16064 + read_8_bytes (abfd, info_ptr));
16065 info_ptr += 8;
16066 break;
16067 case DW_FORM_ref_sig8:
16068 DW_SIGNATURE (attr) = read_8_bytes (abfd, info_ptr);
16069 info_ptr += 8;
16070 break;
16071 case DW_FORM_ref_udata:
16072 DW_UNSND (attr) = (cu->header.offset.sect_off
16073 + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
16074 info_ptr += bytes_read;
16075 break;
16076 case DW_FORM_indirect:
16077 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
16078 info_ptr += bytes_read;
16079 info_ptr = read_attribute_value (reader, attr, form, info_ptr);
16080 break;
16081 case DW_FORM_GNU_addr_index:
16082 if (reader->dwo_file == NULL)
16083 {
16084 /* For now flag a hard error.
16085 Later we can turn this into a complaint. */
16086 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
16087 dwarf_form_name (form),
16088 bfd_get_filename (abfd));
16089 }
16090 DW_ADDR (attr) = read_addr_index_from_leb128 (cu, info_ptr, &bytes_read);
16091 info_ptr += bytes_read;
16092 break;
16093 case DW_FORM_GNU_str_index:
16094 if (reader->dwo_file == NULL)
16095 {
16096 /* For now flag a hard error.
16097 Later we can turn this into a complaint if warranted. */
16098 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
16099 dwarf_form_name (form),
16100 bfd_get_filename (abfd));
16101 }
16102 {
16103 ULONGEST str_index =
16104 read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
16105
16106 DW_STRING (attr) = read_str_index (reader, str_index);
16107 DW_STRING_IS_CANONICAL (attr) = 0;
16108 info_ptr += bytes_read;
16109 }
16110 break;
16111 default:
16112 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
16113 dwarf_form_name (form),
16114 bfd_get_filename (abfd));
16115 }
16116
16117 /* Super hack. */
16118 if (cu->per_cu->is_dwz && attr_form_is_ref (attr))
16119 attr->form = DW_FORM_GNU_ref_alt;
16120
16121 /* We have seen instances where the compiler tried to emit a byte
16122 size attribute of -1 which ended up being encoded as an unsigned
16123 0xffffffff. Although 0xffffffff is technically a valid size value,
16124 an object of this size seems pretty unlikely so we can relatively
16125 safely treat these cases as if the size attribute was invalid and
16126 treat them as zero by default. */
16127 if (attr->name == DW_AT_byte_size
16128 && form == DW_FORM_data4
16129 && DW_UNSND (attr) >= 0xffffffff)
16130 {
16131 complaint
16132 (&symfile_complaints,
16133 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
16134 hex_string (DW_UNSND (attr)));
16135 DW_UNSND (attr) = 0;
16136 }
16137
16138 return info_ptr;
16139 }
16140
16141 /* Read an attribute described by an abbreviated attribute. */
16142
16143 static const gdb_byte *
16144 read_attribute (const struct die_reader_specs *reader,
16145 struct attribute *attr, struct attr_abbrev *abbrev,
16146 const gdb_byte *info_ptr)
16147 {
16148 attr->name = abbrev->name;
16149 return read_attribute_value (reader, attr, abbrev->form, info_ptr);
16150 }
16151
16152 /* Read dwarf information from a buffer. */
16153
16154 static unsigned int
16155 read_1_byte (bfd *abfd, const gdb_byte *buf)
16156 {
16157 return bfd_get_8 (abfd, buf);
16158 }
16159
16160 static int
16161 read_1_signed_byte (bfd *abfd, const gdb_byte *buf)
16162 {
16163 return bfd_get_signed_8 (abfd, buf);
16164 }
16165
16166 static unsigned int
16167 read_2_bytes (bfd *abfd, const gdb_byte *buf)
16168 {
16169 return bfd_get_16 (abfd, buf);
16170 }
16171
16172 static int
16173 read_2_signed_bytes (bfd *abfd, const gdb_byte *buf)
16174 {
16175 return bfd_get_signed_16 (abfd, buf);
16176 }
16177
16178 static unsigned int
16179 read_4_bytes (bfd *abfd, const gdb_byte *buf)
16180 {
16181 return bfd_get_32 (abfd, buf);
16182 }
16183
16184 static int
16185 read_4_signed_bytes (bfd *abfd, const gdb_byte *buf)
16186 {
16187 return bfd_get_signed_32 (abfd, buf);
16188 }
16189
16190 static ULONGEST
16191 read_8_bytes (bfd *abfd, const gdb_byte *buf)
16192 {
16193 return bfd_get_64 (abfd, buf);
16194 }
16195
16196 static CORE_ADDR
16197 read_address (bfd *abfd, const gdb_byte *buf, struct dwarf2_cu *cu,
16198 unsigned int *bytes_read)
16199 {
16200 struct comp_unit_head *cu_header = &cu->header;
16201 CORE_ADDR retval = 0;
16202
16203 if (cu_header->signed_addr_p)
16204 {
16205 switch (cu_header->addr_size)
16206 {
16207 case 2:
16208 retval = bfd_get_signed_16 (abfd, buf);
16209 break;
16210 case 4:
16211 retval = bfd_get_signed_32 (abfd, buf);
16212 break;
16213 case 8:
16214 retval = bfd_get_signed_64 (abfd, buf);
16215 break;
16216 default:
16217 internal_error (__FILE__, __LINE__,
16218 _("read_address: bad switch, signed [in module %s]"),
16219 bfd_get_filename (abfd));
16220 }
16221 }
16222 else
16223 {
16224 switch (cu_header->addr_size)
16225 {
16226 case 2:
16227 retval = bfd_get_16 (abfd, buf);
16228 break;
16229 case 4:
16230 retval = bfd_get_32 (abfd, buf);
16231 break;
16232 case 8:
16233 retval = bfd_get_64 (abfd, buf);
16234 break;
16235 default:
16236 internal_error (__FILE__, __LINE__,
16237 _("read_address: bad switch, "
16238 "unsigned [in module %s]"),
16239 bfd_get_filename (abfd));
16240 }
16241 }
16242
16243 *bytes_read = cu_header->addr_size;
16244 return retval;
16245 }
16246
16247 /* Read the initial length from a section. The (draft) DWARF 3
16248 specification allows the initial length to take up either 4 bytes
16249 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
16250 bytes describe the length and all offsets will be 8 bytes in length
16251 instead of 4.
16252
16253 An older, non-standard 64-bit format is also handled by this
16254 function. The older format in question stores the initial length
16255 as an 8-byte quantity without an escape value. Lengths greater
16256 than 2^32 aren't very common which means that the initial 4 bytes
16257 is almost always zero. Since a length value of zero doesn't make
16258 sense for the 32-bit format, this initial zero can be considered to
16259 be an escape value which indicates the presence of the older 64-bit
16260 format. As written, the code can't detect (old format) lengths
16261 greater than 4GB. If it becomes necessary to handle lengths
16262 somewhat larger than 4GB, we could allow other small values (such
16263 as the non-sensical values of 1, 2, and 3) to also be used as
16264 escape values indicating the presence of the old format.
16265
16266 The value returned via bytes_read should be used to increment the
16267 relevant pointer after calling read_initial_length().
16268
16269 [ Note: read_initial_length() and read_offset() are based on the
16270 document entitled "DWARF Debugging Information Format", revision
16271 3, draft 8, dated November 19, 2001. This document was obtained
16272 from:
16273
16274 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
16275
16276 This document is only a draft and is subject to change. (So beware.)
16277
16278 Details regarding the older, non-standard 64-bit format were
16279 determined empirically by examining 64-bit ELF files produced by
16280 the SGI toolchain on an IRIX 6.5 machine.
16281
16282 - Kevin, July 16, 2002
16283 ] */
16284
16285 static LONGEST
16286 read_initial_length (bfd *abfd, const gdb_byte *buf, unsigned int *bytes_read)
16287 {
16288 LONGEST length = bfd_get_32 (abfd, buf);
16289
16290 if (length == 0xffffffff)
16291 {
16292 length = bfd_get_64 (abfd, buf + 4);
16293 *bytes_read = 12;
16294 }
16295 else if (length == 0)
16296 {
16297 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
16298 length = bfd_get_64 (abfd, buf);
16299 *bytes_read = 8;
16300 }
16301 else
16302 {
16303 *bytes_read = 4;
16304 }
16305
16306 return length;
16307 }
16308
16309 /* Cover function for read_initial_length.
16310 Returns the length of the object at BUF, and stores the size of the
16311 initial length in *BYTES_READ and stores the size that offsets will be in
16312 *OFFSET_SIZE.
16313 If the initial length size is not equivalent to that specified in
16314 CU_HEADER then issue a complaint.
16315 This is useful when reading non-comp-unit headers. */
16316
16317 static LONGEST
16318 read_checked_initial_length_and_offset (bfd *abfd, const gdb_byte *buf,
16319 const struct comp_unit_head *cu_header,
16320 unsigned int *bytes_read,
16321 unsigned int *offset_size)
16322 {
16323 LONGEST length = read_initial_length (abfd, buf, bytes_read);
16324
16325 gdb_assert (cu_header->initial_length_size == 4
16326 || cu_header->initial_length_size == 8
16327 || cu_header->initial_length_size == 12);
16328
16329 if (cu_header->initial_length_size != *bytes_read)
16330 complaint (&symfile_complaints,
16331 _("intermixed 32-bit and 64-bit DWARF sections"));
16332
16333 *offset_size = (*bytes_read == 4) ? 4 : 8;
16334 return length;
16335 }
16336
16337 /* Read an offset from the data stream. The size of the offset is
16338 given by cu_header->offset_size. */
16339
16340 static LONGEST
16341 read_offset (bfd *abfd, const gdb_byte *buf,
16342 const struct comp_unit_head *cu_header,
16343 unsigned int *bytes_read)
16344 {
16345 LONGEST offset = read_offset_1 (abfd, buf, cu_header->offset_size);
16346
16347 *bytes_read = cu_header->offset_size;
16348 return offset;
16349 }
16350
16351 /* Read an offset from the data stream. */
16352
16353 static LONGEST
16354 read_offset_1 (bfd *abfd, const gdb_byte *buf, unsigned int offset_size)
16355 {
16356 LONGEST retval = 0;
16357
16358 switch (offset_size)
16359 {
16360 case 4:
16361 retval = bfd_get_32 (abfd, buf);
16362 break;
16363 case 8:
16364 retval = bfd_get_64 (abfd, buf);
16365 break;
16366 default:
16367 internal_error (__FILE__, __LINE__,
16368 _("read_offset_1: bad switch [in module %s]"),
16369 bfd_get_filename (abfd));
16370 }
16371
16372 return retval;
16373 }
16374
16375 static const gdb_byte *
16376 read_n_bytes (bfd *abfd, const gdb_byte *buf, unsigned int size)
16377 {
16378 /* If the size of a host char is 8 bits, we can return a pointer
16379 to the buffer, otherwise we have to copy the data to a buffer
16380 allocated on the temporary obstack. */
16381 gdb_assert (HOST_CHAR_BIT == 8);
16382 return buf;
16383 }
16384
16385 static const char *
16386 read_direct_string (bfd *abfd, const gdb_byte *buf,
16387 unsigned int *bytes_read_ptr)
16388 {
16389 /* If the size of a host char is 8 bits, we can return a pointer
16390 to the string, otherwise we have to copy the string to a buffer
16391 allocated on the temporary obstack. */
16392 gdb_assert (HOST_CHAR_BIT == 8);
16393 if (*buf == '\0')
16394 {
16395 *bytes_read_ptr = 1;
16396 return NULL;
16397 }
16398 *bytes_read_ptr = strlen ((const char *) buf) + 1;
16399 return (const char *) buf;
16400 }
16401
16402 static const char *
16403 read_indirect_string_at_offset (bfd *abfd, LONGEST str_offset)
16404 {
16405 dwarf2_read_section (dwarf2_per_objfile->objfile, &dwarf2_per_objfile->str);
16406 if (dwarf2_per_objfile->str.buffer == NULL)
16407 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
16408 bfd_get_filename (abfd));
16409 if (str_offset >= dwarf2_per_objfile->str.size)
16410 error (_("DW_FORM_strp pointing outside of "
16411 ".debug_str section [in module %s]"),
16412 bfd_get_filename (abfd));
16413 gdb_assert (HOST_CHAR_BIT == 8);
16414 if (dwarf2_per_objfile->str.buffer[str_offset] == '\0')
16415 return NULL;
16416 return (const char *) (dwarf2_per_objfile->str.buffer + str_offset);
16417 }
16418
16419 /* Read a string at offset STR_OFFSET in the .debug_str section from
16420 the .dwz file DWZ. Throw an error if the offset is too large. If
16421 the string consists of a single NUL byte, return NULL; otherwise
16422 return a pointer to the string. */
16423
16424 static const char *
16425 read_indirect_string_from_dwz (struct dwz_file *dwz, LONGEST str_offset)
16426 {
16427 dwarf2_read_section (dwarf2_per_objfile->objfile, &dwz->str);
16428
16429 if (dwz->str.buffer == NULL)
16430 error (_("DW_FORM_GNU_strp_alt used without .debug_str "
16431 "section [in module %s]"),
16432 bfd_get_filename (dwz->dwz_bfd));
16433 if (str_offset >= dwz->str.size)
16434 error (_("DW_FORM_GNU_strp_alt pointing outside of "
16435 ".debug_str section [in module %s]"),
16436 bfd_get_filename (dwz->dwz_bfd));
16437 gdb_assert (HOST_CHAR_BIT == 8);
16438 if (dwz->str.buffer[str_offset] == '\0')
16439 return NULL;
16440 return (const char *) (dwz->str.buffer + str_offset);
16441 }
16442
16443 static const char *
16444 read_indirect_string (bfd *abfd, const gdb_byte *buf,
16445 const struct comp_unit_head *cu_header,
16446 unsigned int *bytes_read_ptr)
16447 {
16448 LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
16449
16450 return read_indirect_string_at_offset (abfd, str_offset);
16451 }
16452
16453 static ULONGEST
16454 read_unsigned_leb128 (bfd *abfd, const gdb_byte *buf,
16455 unsigned int *bytes_read_ptr)
16456 {
16457 ULONGEST result;
16458 unsigned int num_read;
16459 int i, shift;
16460 unsigned char byte;
16461
16462 result = 0;
16463 shift = 0;
16464 num_read = 0;
16465 i = 0;
16466 while (1)
16467 {
16468 byte = bfd_get_8 (abfd, buf);
16469 buf++;
16470 num_read++;
16471 result |= ((ULONGEST) (byte & 127) << shift);
16472 if ((byte & 128) == 0)
16473 {
16474 break;
16475 }
16476 shift += 7;
16477 }
16478 *bytes_read_ptr = num_read;
16479 return result;
16480 }
16481
16482 static LONGEST
16483 read_signed_leb128 (bfd *abfd, const gdb_byte *buf,
16484 unsigned int *bytes_read_ptr)
16485 {
16486 LONGEST result;
16487 int i, shift, num_read;
16488 unsigned char byte;
16489
16490 result = 0;
16491 shift = 0;
16492 num_read = 0;
16493 i = 0;
16494 while (1)
16495 {
16496 byte = bfd_get_8 (abfd, buf);
16497 buf++;
16498 num_read++;
16499 result |= ((LONGEST) (byte & 127) << shift);
16500 shift += 7;
16501 if ((byte & 128) == 0)
16502 {
16503 break;
16504 }
16505 }
16506 if ((shift < 8 * sizeof (result)) && (byte & 0x40))
16507 result |= -(((LONGEST) 1) << shift);
16508 *bytes_read_ptr = num_read;
16509 return result;
16510 }
16511
16512 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
16513 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
16514 ADDR_SIZE is the size of addresses from the CU header. */
16515
16516 static CORE_ADDR
16517 read_addr_index_1 (unsigned int addr_index, ULONGEST addr_base, int addr_size)
16518 {
16519 struct objfile *objfile = dwarf2_per_objfile->objfile;
16520 bfd *abfd = objfile->obfd;
16521 const gdb_byte *info_ptr;
16522
16523 dwarf2_read_section (objfile, &dwarf2_per_objfile->addr);
16524 if (dwarf2_per_objfile->addr.buffer == NULL)
16525 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
16526 objfile_name (objfile));
16527 if (addr_base + addr_index * addr_size >= dwarf2_per_objfile->addr.size)
16528 error (_("DW_FORM_addr_index pointing outside of "
16529 ".debug_addr section [in module %s]"),
16530 objfile_name (objfile));
16531 info_ptr = (dwarf2_per_objfile->addr.buffer
16532 + addr_base + addr_index * addr_size);
16533 if (addr_size == 4)
16534 return bfd_get_32 (abfd, info_ptr);
16535 else
16536 return bfd_get_64 (abfd, info_ptr);
16537 }
16538
16539 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
16540
16541 static CORE_ADDR
16542 read_addr_index (struct dwarf2_cu *cu, unsigned int addr_index)
16543 {
16544 return read_addr_index_1 (addr_index, cu->addr_base, cu->header.addr_size);
16545 }
16546
16547 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
16548
16549 static CORE_ADDR
16550 read_addr_index_from_leb128 (struct dwarf2_cu *cu, const gdb_byte *info_ptr,
16551 unsigned int *bytes_read)
16552 {
16553 bfd *abfd = cu->objfile->obfd;
16554 unsigned int addr_index = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
16555
16556 return read_addr_index (cu, addr_index);
16557 }
16558
16559 /* Data structure to pass results from dwarf2_read_addr_index_reader
16560 back to dwarf2_read_addr_index. */
16561
16562 struct dwarf2_read_addr_index_data
16563 {
16564 ULONGEST addr_base;
16565 int addr_size;
16566 };
16567
16568 /* die_reader_func for dwarf2_read_addr_index. */
16569
16570 static void
16571 dwarf2_read_addr_index_reader (const struct die_reader_specs *reader,
16572 const gdb_byte *info_ptr,
16573 struct die_info *comp_unit_die,
16574 int has_children,
16575 void *data)
16576 {
16577 struct dwarf2_cu *cu = reader->cu;
16578 struct dwarf2_read_addr_index_data *aidata =
16579 (struct dwarf2_read_addr_index_data *) data;
16580
16581 aidata->addr_base = cu->addr_base;
16582 aidata->addr_size = cu->header.addr_size;
16583 }
16584
16585 /* Given an index in .debug_addr, fetch the value.
16586 NOTE: This can be called during dwarf expression evaluation,
16587 long after the debug information has been read, and thus per_cu->cu
16588 may no longer exist. */
16589
16590 CORE_ADDR
16591 dwarf2_read_addr_index (struct dwarf2_per_cu_data *per_cu,
16592 unsigned int addr_index)
16593 {
16594 struct objfile *objfile = per_cu->objfile;
16595 struct dwarf2_cu *cu = per_cu->cu;
16596 ULONGEST addr_base;
16597 int addr_size;
16598
16599 /* This is intended to be called from outside this file. */
16600 dw2_setup (objfile);
16601
16602 /* We need addr_base and addr_size.
16603 If we don't have PER_CU->cu, we have to get it.
16604 Nasty, but the alternative is storing the needed info in PER_CU,
16605 which at this point doesn't seem justified: it's not clear how frequently
16606 it would get used and it would increase the size of every PER_CU.
16607 Entry points like dwarf2_per_cu_addr_size do a similar thing
16608 so we're not in uncharted territory here.
16609 Alas we need to be a bit more complicated as addr_base is contained
16610 in the DIE.
16611
16612 We don't need to read the entire CU(/TU).
16613 We just need the header and top level die.
16614
16615 IWBN to use the aging mechanism to let us lazily later discard the CU.
16616 For now we skip this optimization. */
16617
16618 if (cu != NULL)
16619 {
16620 addr_base = cu->addr_base;
16621 addr_size = cu->header.addr_size;
16622 }
16623 else
16624 {
16625 struct dwarf2_read_addr_index_data aidata;
16626
16627 /* Note: We can't use init_cutu_and_read_dies_simple here,
16628 we need addr_base. */
16629 init_cutu_and_read_dies (per_cu, NULL, 0, 0,
16630 dwarf2_read_addr_index_reader, &aidata);
16631 addr_base = aidata.addr_base;
16632 addr_size = aidata.addr_size;
16633 }
16634
16635 return read_addr_index_1 (addr_index, addr_base, addr_size);
16636 }
16637
16638 /* Given a DW_FORM_GNU_str_index, fetch the string.
16639 This is only used by the Fission support. */
16640
16641 static const char *
16642 read_str_index (const struct die_reader_specs *reader, ULONGEST str_index)
16643 {
16644 struct objfile *objfile = dwarf2_per_objfile->objfile;
16645 const char *objf_name = objfile_name (objfile);
16646 bfd *abfd = objfile->obfd;
16647 struct dwarf2_cu *cu = reader->cu;
16648 struct dwarf2_section_info *str_section = &reader->dwo_file->sections.str;
16649 struct dwarf2_section_info *str_offsets_section =
16650 &reader->dwo_file->sections.str_offsets;
16651 const gdb_byte *info_ptr;
16652 ULONGEST str_offset;
16653 static const char form_name[] = "DW_FORM_GNU_str_index";
16654
16655 dwarf2_read_section (objfile, str_section);
16656 dwarf2_read_section (objfile, str_offsets_section);
16657 if (str_section->buffer == NULL)
16658 error (_("%s used without .debug_str.dwo section"
16659 " in CU at offset 0x%lx [in module %s]"),
16660 form_name, (long) cu->header.offset.sect_off, objf_name);
16661 if (str_offsets_section->buffer == NULL)
16662 error (_("%s used without .debug_str_offsets.dwo section"
16663 " in CU at offset 0x%lx [in module %s]"),
16664 form_name, (long) cu->header.offset.sect_off, objf_name);
16665 if (str_index * cu->header.offset_size >= str_offsets_section->size)
16666 error (_("%s pointing outside of .debug_str_offsets.dwo"
16667 " section in CU at offset 0x%lx [in module %s]"),
16668 form_name, (long) cu->header.offset.sect_off, objf_name);
16669 info_ptr = (str_offsets_section->buffer
16670 + str_index * cu->header.offset_size);
16671 if (cu->header.offset_size == 4)
16672 str_offset = bfd_get_32 (abfd, info_ptr);
16673 else
16674 str_offset = bfd_get_64 (abfd, info_ptr);
16675 if (str_offset >= str_section->size)
16676 error (_("Offset from %s pointing outside of"
16677 " .debug_str.dwo section in CU at offset 0x%lx [in module %s]"),
16678 form_name, (long) cu->header.offset.sect_off, objf_name);
16679 return (const char *) (str_section->buffer + str_offset);
16680 }
16681
16682 /* Return the length of an LEB128 number in BUF. */
16683
16684 static int
16685 leb128_size (const gdb_byte *buf)
16686 {
16687 const gdb_byte *begin = buf;
16688 gdb_byte byte;
16689
16690 while (1)
16691 {
16692 byte = *buf++;
16693 if ((byte & 128) == 0)
16694 return buf - begin;
16695 }
16696 }
16697
16698 static void
16699 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
16700 {
16701 switch (lang)
16702 {
16703 case DW_LANG_C89:
16704 case DW_LANG_C99:
16705 case DW_LANG_C:
16706 case DW_LANG_UPC:
16707 cu->language = language_c;
16708 break;
16709 case DW_LANG_C_plus_plus:
16710 cu->language = language_cplus;
16711 break;
16712 case DW_LANG_D:
16713 cu->language = language_d;
16714 break;
16715 case DW_LANG_Fortran77:
16716 case DW_LANG_Fortran90:
16717 case DW_LANG_Fortran95:
16718 cu->language = language_fortran;
16719 break;
16720 case DW_LANG_Go:
16721 cu->language = language_go;
16722 break;
16723 case DW_LANG_Mips_Assembler:
16724 cu->language = language_asm;
16725 break;
16726 case DW_LANG_Java:
16727 cu->language = language_java;
16728 break;
16729 case DW_LANG_Ada83:
16730 case DW_LANG_Ada95:
16731 cu->language = language_ada;
16732 break;
16733 case DW_LANG_Modula2:
16734 cu->language = language_m2;
16735 break;
16736 case DW_LANG_Pascal83:
16737 cu->language = language_pascal;
16738 break;
16739 case DW_LANG_ObjC:
16740 cu->language = language_objc;
16741 break;
16742 case DW_LANG_Cobol74:
16743 case DW_LANG_Cobol85:
16744 default:
16745 cu->language = language_minimal;
16746 break;
16747 }
16748 cu->language_defn = language_def (cu->language);
16749 }
16750
16751 /* Return the named attribute or NULL if not there. */
16752
16753 static struct attribute *
16754 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
16755 {
16756 for (;;)
16757 {
16758 unsigned int i;
16759 struct attribute *spec = NULL;
16760
16761 for (i = 0; i < die->num_attrs; ++i)
16762 {
16763 if (die->attrs[i].name == name)
16764 return &die->attrs[i];
16765 if (die->attrs[i].name == DW_AT_specification
16766 || die->attrs[i].name == DW_AT_abstract_origin)
16767 spec = &die->attrs[i];
16768 }
16769
16770 if (!spec)
16771 break;
16772
16773 die = follow_die_ref (die, spec, &cu);
16774 }
16775
16776 return NULL;
16777 }
16778
16779 /* Return the named attribute or NULL if not there,
16780 but do not follow DW_AT_specification, etc.
16781 This is for use in contexts where we're reading .debug_types dies.
16782 Following DW_AT_specification, DW_AT_abstract_origin will take us
16783 back up the chain, and we want to go down. */
16784
16785 static struct attribute *
16786 dwarf2_attr_no_follow (struct die_info *die, unsigned int name)
16787 {
16788 unsigned int i;
16789
16790 for (i = 0; i < die->num_attrs; ++i)
16791 if (die->attrs[i].name == name)
16792 return &die->attrs[i];
16793
16794 return NULL;
16795 }
16796
16797 /* Return non-zero iff the attribute NAME is defined for the given DIE,
16798 and holds a non-zero value. This function should only be used for
16799 DW_FORM_flag or DW_FORM_flag_present attributes. */
16800
16801 static int
16802 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
16803 {
16804 struct attribute *attr = dwarf2_attr (die, name, cu);
16805
16806 return (attr && DW_UNSND (attr));
16807 }
16808
16809 static int
16810 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
16811 {
16812 /* A DIE is a declaration if it has a DW_AT_declaration attribute
16813 which value is non-zero. However, we have to be careful with
16814 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
16815 (via dwarf2_flag_true_p) follows this attribute. So we may
16816 end up accidently finding a declaration attribute that belongs
16817 to a different DIE referenced by the specification attribute,
16818 even though the given DIE does not have a declaration attribute. */
16819 return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
16820 && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
16821 }
16822
16823 /* Return the die giving the specification for DIE, if there is
16824 one. *SPEC_CU is the CU containing DIE on input, and the CU
16825 containing the return value on output. If there is no
16826 specification, but there is an abstract origin, that is
16827 returned. */
16828
16829 static struct die_info *
16830 die_specification (struct die_info *die, struct dwarf2_cu **spec_cu)
16831 {
16832 struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification,
16833 *spec_cu);
16834
16835 if (spec_attr == NULL)
16836 spec_attr = dwarf2_attr (die, DW_AT_abstract_origin, *spec_cu);
16837
16838 if (spec_attr == NULL)
16839 return NULL;
16840 else
16841 return follow_die_ref (die, spec_attr, spec_cu);
16842 }
16843
16844 /* Free the line_header structure *LH, and any arrays and strings it
16845 refers to.
16846 NOTE: This is also used as a "cleanup" function. */
16847
16848 static void
16849 free_line_header (struct line_header *lh)
16850 {
16851 if (lh->standard_opcode_lengths)
16852 xfree (lh->standard_opcode_lengths);
16853
16854 /* Remember that all the lh->file_names[i].name pointers are
16855 pointers into debug_line_buffer, and don't need to be freed. */
16856 if (lh->file_names)
16857 xfree (lh->file_names);
16858
16859 /* Similarly for the include directory names. */
16860 if (lh->include_dirs)
16861 xfree (lh->include_dirs);
16862
16863 xfree (lh);
16864 }
16865
16866 /* Add an entry to LH's include directory table. */
16867
16868 static void
16869 add_include_dir (struct line_header *lh, const char *include_dir)
16870 {
16871 /* Grow the array if necessary. */
16872 if (lh->include_dirs_size == 0)
16873 {
16874 lh->include_dirs_size = 1; /* for testing */
16875 lh->include_dirs = xmalloc (lh->include_dirs_size
16876 * sizeof (*lh->include_dirs));
16877 }
16878 else if (lh->num_include_dirs >= lh->include_dirs_size)
16879 {
16880 lh->include_dirs_size *= 2;
16881 lh->include_dirs = xrealloc (lh->include_dirs,
16882 (lh->include_dirs_size
16883 * sizeof (*lh->include_dirs)));
16884 }
16885
16886 lh->include_dirs[lh->num_include_dirs++] = include_dir;
16887 }
16888
16889 /* Add an entry to LH's file name table. */
16890
16891 static void
16892 add_file_name (struct line_header *lh,
16893 const char *name,
16894 unsigned int dir_index,
16895 unsigned int mod_time,
16896 unsigned int length)
16897 {
16898 struct file_entry *fe;
16899
16900 /* Grow the array if necessary. */
16901 if (lh->file_names_size == 0)
16902 {
16903 lh->file_names_size = 1; /* for testing */
16904 lh->file_names = xmalloc (lh->file_names_size
16905 * sizeof (*lh->file_names));
16906 }
16907 else if (lh->num_file_names >= lh->file_names_size)
16908 {
16909 lh->file_names_size *= 2;
16910 lh->file_names = xrealloc (lh->file_names,
16911 (lh->file_names_size
16912 * sizeof (*lh->file_names)));
16913 }
16914
16915 fe = &lh->file_names[lh->num_file_names++];
16916 fe->name = name;
16917 fe->dir_index = dir_index;
16918 fe->mod_time = mod_time;
16919 fe->length = length;
16920 fe->included_p = 0;
16921 fe->symtab = NULL;
16922 }
16923
16924 /* A convenience function to find the proper .debug_line section for a
16925 CU. */
16926
16927 static struct dwarf2_section_info *
16928 get_debug_line_section (struct dwarf2_cu *cu)
16929 {
16930 struct dwarf2_section_info *section;
16931
16932 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
16933 DWO file. */
16934 if (cu->dwo_unit && cu->per_cu->is_debug_types)
16935 section = &cu->dwo_unit->dwo_file->sections.line;
16936 else if (cu->per_cu->is_dwz)
16937 {
16938 struct dwz_file *dwz = dwarf2_get_dwz_file ();
16939
16940 section = &dwz->line;
16941 }
16942 else
16943 section = &dwarf2_per_objfile->line;
16944
16945 return section;
16946 }
16947
16948 /* Read the statement program header starting at OFFSET in
16949 .debug_line, or .debug_line.dwo. Return a pointer
16950 to a struct line_header, allocated using xmalloc.
16951
16952 NOTE: the strings in the include directory and file name tables of
16953 the returned object point into the dwarf line section buffer,
16954 and must not be freed. */
16955
16956 static struct line_header *
16957 dwarf_decode_line_header (unsigned int offset, struct dwarf2_cu *cu)
16958 {
16959 struct cleanup *back_to;
16960 struct line_header *lh;
16961 const gdb_byte *line_ptr;
16962 unsigned int bytes_read, offset_size;
16963 int i;
16964 const char *cur_dir, *cur_file;
16965 struct dwarf2_section_info *section;
16966 bfd *abfd;
16967
16968 section = get_debug_line_section (cu);
16969 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
16970 if (section->buffer == NULL)
16971 {
16972 if (cu->dwo_unit && cu->per_cu->is_debug_types)
16973 complaint (&symfile_complaints, _("missing .debug_line.dwo section"));
16974 else
16975 complaint (&symfile_complaints, _("missing .debug_line section"));
16976 return 0;
16977 }
16978
16979 /* We can't do this until we know the section is non-empty.
16980 Only then do we know we have such a section. */
16981 abfd = get_section_bfd_owner (section);
16982
16983 /* Make sure that at least there's room for the total_length field.
16984 That could be 12 bytes long, but we're just going to fudge that. */
16985 if (offset + 4 >= section->size)
16986 {
16987 dwarf2_statement_list_fits_in_line_number_section_complaint ();
16988 return 0;
16989 }
16990
16991 lh = xmalloc (sizeof (*lh));
16992 memset (lh, 0, sizeof (*lh));
16993 back_to = make_cleanup ((make_cleanup_ftype *) free_line_header,
16994 (void *) lh);
16995
16996 line_ptr = section->buffer + offset;
16997
16998 /* Read in the header. */
16999 lh->total_length =
17000 read_checked_initial_length_and_offset (abfd, line_ptr, &cu->header,
17001 &bytes_read, &offset_size);
17002 line_ptr += bytes_read;
17003 if (line_ptr + lh->total_length > (section->buffer + section->size))
17004 {
17005 dwarf2_statement_list_fits_in_line_number_section_complaint ();
17006 do_cleanups (back_to);
17007 return 0;
17008 }
17009 lh->statement_program_end = line_ptr + lh->total_length;
17010 lh->version = read_2_bytes (abfd, line_ptr);
17011 line_ptr += 2;
17012 lh->header_length = read_offset_1 (abfd, line_ptr, offset_size);
17013 line_ptr += offset_size;
17014 lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
17015 line_ptr += 1;
17016 if (lh->version >= 4)
17017 {
17018 lh->maximum_ops_per_instruction = read_1_byte (abfd, line_ptr);
17019 line_ptr += 1;
17020 }
17021 else
17022 lh->maximum_ops_per_instruction = 1;
17023
17024 if (lh->maximum_ops_per_instruction == 0)
17025 {
17026 lh->maximum_ops_per_instruction = 1;
17027 complaint (&symfile_complaints,
17028 _("invalid maximum_ops_per_instruction "
17029 "in `.debug_line' section"));
17030 }
17031
17032 lh->default_is_stmt = read_1_byte (abfd, line_ptr);
17033 line_ptr += 1;
17034 lh->line_base = read_1_signed_byte (abfd, line_ptr);
17035 line_ptr += 1;
17036 lh->line_range = read_1_byte (abfd, line_ptr);
17037 line_ptr += 1;
17038 lh->opcode_base = read_1_byte (abfd, line_ptr);
17039 line_ptr += 1;
17040 lh->standard_opcode_lengths
17041 = xmalloc (lh->opcode_base * sizeof (lh->standard_opcode_lengths[0]));
17042
17043 lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
17044 for (i = 1; i < lh->opcode_base; ++i)
17045 {
17046 lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
17047 line_ptr += 1;
17048 }
17049
17050 /* Read directory table. */
17051 while ((cur_dir = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
17052 {
17053 line_ptr += bytes_read;
17054 add_include_dir (lh, cur_dir);
17055 }
17056 line_ptr += bytes_read;
17057
17058 /* Read file name table. */
17059 while ((cur_file = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
17060 {
17061 unsigned int dir_index, mod_time, length;
17062
17063 line_ptr += bytes_read;
17064 dir_index = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17065 line_ptr += bytes_read;
17066 mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17067 line_ptr += bytes_read;
17068 length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17069 line_ptr += bytes_read;
17070
17071 add_file_name (lh, cur_file, dir_index, mod_time, length);
17072 }
17073 line_ptr += bytes_read;
17074 lh->statement_program_start = line_ptr;
17075
17076 if (line_ptr > (section->buffer + section->size))
17077 complaint (&symfile_complaints,
17078 _("line number info header doesn't "
17079 "fit in `.debug_line' section"));
17080
17081 discard_cleanups (back_to);
17082 return lh;
17083 }
17084
17085 /* Subroutine of dwarf_decode_lines to simplify it.
17086 Return the file name of the psymtab for included file FILE_INDEX
17087 in line header LH of PST.
17088 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
17089 If space for the result is malloc'd, it will be freed by a cleanup.
17090 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename.
17091
17092 The function creates dangling cleanup registration. */
17093
17094 static const char *
17095 psymtab_include_file_name (const struct line_header *lh, int file_index,
17096 const struct partial_symtab *pst,
17097 const char *comp_dir)
17098 {
17099 const struct file_entry fe = lh->file_names [file_index];
17100 const char *include_name = fe.name;
17101 const char *include_name_to_compare = include_name;
17102 const char *dir_name = NULL;
17103 const char *pst_filename;
17104 char *copied_name = NULL;
17105 int file_is_pst;
17106
17107 if (fe.dir_index)
17108 dir_name = lh->include_dirs[fe.dir_index - 1];
17109
17110 if (!IS_ABSOLUTE_PATH (include_name)
17111 && (dir_name != NULL || comp_dir != NULL))
17112 {
17113 /* Avoid creating a duplicate psymtab for PST.
17114 We do this by comparing INCLUDE_NAME and PST_FILENAME.
17115 Before we do the comparison, however, we need to account
17116 for DIR_NAME and COMP_DIR.
17117 First prepend dir_name (if non-NULL). If we still don't
17118 have an absolute path prepend comp_dir (if non-NULL).
17119 However, the directory we record in the include-file's
17120 psymtab does not contain COMP_DIR (to match the
17121 corresponding symtab(s)).
17122
17123 Example:
17124
17125 bash$ cd /tmp
17126 bash$ gcc -g ./hello.c
17127 include_name = "hello.c"
17128 dir_name = "."
17129 DW_AT_comp_dir = comp_dir = "/tmp"
17130 DW_AT_name = "./hello.c"
17131
17132 */
17133
17134 if (dir_name != NULL)
17135 {
17136 char *tem = concat (dir_name, SLASH_STRING,
17137 include_name, (char *)NULL);
17138
17139 make_cleanup (xfree, tem);
17140 include_name = tem;
17141 include_name_to_compare = include_name;
17142 }
17143 if (!IS_ABSOLUTE_PATH (include_name) && comp_dir != NULL)
17144 {
17145 char *tem = concat (comp_dir, SLASH_STRING,
17146 include_name, (char *)NULL);
17147
17148 make_cleanup (xfree, tem);
17149 include_name_to_compare = tem;
17150 }
17151 }
17152
17153 pst_filename = pst->filename;
17154 if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
17155 {
17156 copied_name = concat (pst->dirname, SLASH_STRING,
17157 pst_filename, (char *)NULL);
17158 pst_filename = copied_name;
17159 }
17160
17161 file_is_pst = FILENAME_CMP (include_name_to_compare, pst_filename) == 0;
17162
17163 if (copied_name != NULL)
17164 xfree (copied_name);
17165
17166 if (file_is_pst)
17167 return NULL;
17168 return include_name;
17169 }
17170
17171 /* Ignore this record_line request. */
17172
17173 static void
17174 noop_record_line (struct subfile *subfile, int line, CORE_ADDR pc)
17175 {
17176 return;
17177 }
17178
17179 /* Return non-zero if we should add LINE to the line number table.
17180 LINE is the line to add, LAST_LINE is the last line that was added,
17181 LAST_SUBFILE is the subfile for LAST_LINE.
17182 LINE_HAS_NON_ZERO_DISCRIMINATOR is non-zero if LINE has ever
17183 had a non-zero discriminator.
17184
17185 We have to be careful in the presence of discriminators.
17186 E.g., for this line:
17187
17188 for (i = 0; i < 100000; i++);
17189
17190 clang can emit four line number entries for that one line,
17191 each with a different discriminator.
17192 See gdb.dwarf2/dw2-single-line-discriminators.exp for an example.
17193
17194 However, we want gdb to coalesce all four entries into one.
17195 Otherwise the user could stepi into the middle of the line and
17196 gdb would get confused about whether the pc really was in the
17197 middle of the line.
17198
17199 Things are further complicated by the fact that two consecutive
17200 line number entries for the same line is a heuristic used by gcc
17201 to denote the end of the prologue. So we can't just discard duplicate
17202 entries, we have to be selective about it. The heuristic we use is
17203 that we only collapse consecutive entries for the same line if at least
17204 one of those entries has a non-zero discriminator. PR 17276.
17205
17206 Note: Addresses in the line number state machine can never go backwards
17207 within one sequence, thus this coalescing is ok. */
17208
17209 static int
17210 dwarf_record_line_p (unsigned int line, unsigned int last_line,
17211 int line_has_non_zero_discriminator,
17212 struct subfile *last_subfile)
17213 {
17214 if (current_subfile != last_subfile)
17215 return 1;
17216 if (line != last_line)
17217 return 1;
17218 /* Same line for the same file that we've seen already.
17219 As a last check, for pr 17276, only record the line if the line
17220 has never had a non-zero discriminator. */
17221 if (!line_has_non_zero_discriminator)
17222 return 1;
17223 return 0;
17224 }
17225
17226 /* Use P_RECORD_LINE to record line number LINE beginning at address ADDRESS
17227 in the line table of subfile SUBFILE. */
17228
17229 static void
17230 dwarf_record_line (struct gdbarch *gdbarch, struct subfile *subfile,
17231 unsigned int line, CORE_ADDR address,
17232 record_line_ftype p_record_line)
17233 {
17234 CORE_ADDR addr = gdbarch_addr_bits_remove (gdbarch, address);
17235
17236 (*p_record_line) (subfile, line, addr);
17237 }
17238
17239 /* Subroutine of dwarf_decode_lines_1 to simplify it.
17240 Mark the end of a set of line number records.
17241 The arguments are the same as for dwarf_record_line.
17242 If SUBFILE is NULL the request is ignored. */
17243
17244 static void
17245 dwarf_finish_line (struct gdbarch *gdbarch, struct subfile *subfile,
17246 CORE_ADDR address, record_line_ftype p_record_line)
17247 {
17248 if (subfile != NULL)
17249 dwarf_record_line (gdbarch, subfile, 0, address, p_record_line);
17250 }
17251
17252 /* Subroutine of dwarf_decode_lines to simplify it.
17253 Process the line number information in LH. */
17254
17255 static void
17256 dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir,
17257 struct dwarf2_cu *cu, const int decode_for_pst_p)
17258 {
17259 const gdb_byte *line_ptr, *extended_end;
17260 const gdb_byte *line_end;
17261 unsigned int bytes_read, extended_len;
17262 unsigned char op_code, extended_op;
17263 CORE_ADDR baseaddr;
17264 struct objfile *objfile = cu->objfile;
17265 bfd *abfd = objfile->obfd;
17266 struct gdbarch *gdbarch = get_objfile_arch (objfile);
17267 struct subfile *last_subfile = NULL;
17268 void (*p_record_line) (struct subfile *subfile, int line, CORE_ADDR pc)
17269 = record_line;
17270
17271 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
17272
17273 line_ptr = lh->statement_program_start;
17274 line_end = lh->statement_program_end;
17275
17276 /* Read the statement sequences until there's nothing left. */
17277 while (line_ptr < line_end)
17278 {
17279 /* state machine registers */
17280 CORE_ADDR address = 0;
17281 unsigned int file = 1;
17282 unsigned int line = 1;
17283 int is_stmt = lh->default_is_stmt;
17284 int end_sequence = 0;
17285 unsigned char op_index = 0;
17286 unsigned int discriminator = 0;
17287 /* The last line number that was recorded, used to coalesce
17288 consecutive entries for the same line. This can happen, for
17289 example, when discriminators are present. PR 17276. */
17290 unsigned int last_line = 0;
17291 int line_has_non_zero_discriminator = 0;
17292
17293 if (!decode_for_pst_p && lh->num_file_names >= file)
17294 {
17295 /* Start a subfile for the current file of the state machine. */
17296 /* lh->include_dirs and lh->file_names are 0-based, but the
17297 directory and file name numbers in the statement program
17298 are 1-based. */
17299 struct file_entry *fe = &lh->file_names[file - 1];
17300 const char *dir = NULL;
17301
17302 if (fe->dir_index)
17303 dir = lh->include_dirs[fe->dir_index - 1];
17304
17305 dwarf2_start_subfile (fe->name, dir, comp_dir);
17306 }
17307
17308 /* Decode the table. */
17309 while (!end_sequence)
17310 {
17311 op_code = read_1_byte (abfd, line_ptr);
17312 line_ptr += 1;
17313 if (line_ptr > line_end)
17314 {
17315 dwarf2_debug_line_missing_end_sequence_complaint ();
17316 break;
17317 }
17318
17319 if (op_code >= lh->opcode_base)
17320 {
17321 /* Special opcode. */
17322 unsigned char adj_opcode;
17323 int line_delta;
17324
17325 adj_opcode = op_code - lh->opcode_base;
17326 address += (((op_index + (adj_opcode / lh->line_range))
17327 / lh->maximum_ops_per_instruction)
17328 * lh->minimum_instruction_length);
17329 op_index = ((op_index + (adj_opcode / lh->line_range))
17330 % lh->maximum_ops_per_instruction);
17331 line_delta = lh->line_base + (adj_opcode % lh->line_range);
17332 line += line_delta;
17333 if (line_delta != 0)
17334 line_has_non_zero_discriminator = discriminator != 0;
17335 if (lh->num_file_names < file || file == 0)
17336 dwarf2_debug_line_missing_file_complaint ();
17337 /* For now we ignore lines not starting on an
17338 instruction boundary. */
17339 else if (op_index == 0)
17340 {
17341 lh->file_names[file - 1].included_p = 1;
17342 if (!decode_for_pst_p && is_stmt)
17343 {
17344 if (last_subfile != current_subfile)
17345 {
17346 dwarf_finish_line (gdbarch, last_subfile,
17347 address, p_record_line);
17348 }
17349 if (dwarf_record_line_p (line, last_line,
17350 line_has_non_zero_discriminator,
17351 last_subfile))
17352 {
17353 dwarf_record_line (gdbarch, current_subfile,
17354 line, address, p_record_line);
17355 }
17356 last_subfile = current_subfile;
17357 last_line = line;
17358 }
17359 }
17360 discriminator = 0;
17361 }
17362 else switch (op_code)
17363 {
17364 case DW_LNS_extended_op:
17365 extended_len = read_unsigned_leb128 (abfd, line_ptr,
17366 &bytes_read);
17367 line_ptr += bytes_read;
17368 extended_end = line_ptr + extended_len;
17369 extended_op = read_1_byte (abfd, line_ptr);
17370 line_ptr += 1;
17371 switch (extended_op)
17372 {
17373 case DW_LNE_end_sequence:
17374 p_record_line = record_line;
17375 end_sequence = 1;
17376 break;
17377 case DW_LNE_set_address:
17378 address = read_address (abfd, line_ptr, cu, &bytes_read);
17379
17380 if (address == 0 && !dwarf2_per_objfile->has_section_at_zero)
17381 {
17382 /* This line table is for a function which has been
17383 GCd by the linker. Ignore it. PR gdb/12528 */
17384
17385 long line_offset
17386 = line_ptr - get_debug_line_section (cu)->buffer;
17387
17388 complaint (&symfile_complaints,
17389 _(".debug_line address at offset 0x%lx is 0 "
17390 "[in module %s]"),
17391 line_offset, objfile_name (objfile));
17392 p_record_line = noop_record_line;
17393 /* Note: p_record_line is left as noop_record_line
17394 until we see DW_LNE_end_sequence. */
17395 }
17396
17397 op_index = 0;
17398 line_ptr += bytes_read;
17399 address += baseaddr;
17400 break;
17401 case DW_LNE_define_file:
17402 {
17403 const char *cur_file;
17404 unsigned int dir_index, mod_time, length;
17405
17406 cur_file = read_direct_string (abfd, line_ptr,
17407 &bytes_read);
17408 line_ptr += bytes_read;
17409 dir_index =
17410 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17411 line_ptr += bytes_read;
17412 mod_time =
17413 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17414 line_ptr += bytes_read;
17415 length =
17416 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17417 line_ptr += bytes_read;
17418 add_file_name (lh, cur_file, dir_index, mod_time, length);
17419 }
17420 break;
17421 case DW_LNE_set_discriminator:
17422 /* The discriminator is not interesting to the debugger;
17423 just ignore it. We still need to check its value though:
17424 if there are consecutive entries for the same
17425 (non-prologue) line we want to coalesce them.
17426 PR 17276. */
17427 discriminator = read_unsigned_leb128 (abfd, line_ptr,
17428 &bytes_read);
17429 line_has_non_zero_discriminator |= discriminator != 0;
17430 line_ptr += bytes_read;
17431 break;
17432 default:
17433 complaint (&symfile_complaints,
17434 _("mangled .debug_line section"));
17435 return;
17436 }
17437 /* Make sure that we parsed the extended op correctly. If e.g.
17438 we expected a different address size than the producer used,
17439 we may have read the wrong number of bytes. */
17440 if (line_ptr != extended_end)
17441 {
17442 complaint (&symfile_complaints,
17443 _("mangled .debug_line section"));
17444 return;
17445 }
17446 break;
17447 case DW_LNS_copy:
17448 if (lh->num_file_names < file || file == 0)
17449 dwarf2_debug_line_missing_file_complaint ();
17450 else
17451 {
17452 lh->file_names[file - 1].included_p = 1;
17453 if (!decode_for_pst_p && is_stmt)
17454 {
17455 if (last_subfile != current_subfile)
17456 {
17457 dwarf_finish_line (gdbarch, last_subfile,
17458 address, p_record_line);
17459 }
17460 if (dwarf_record_line_p (line, last_line,
17461 line_has_non_zero_discriminator,
17462 last_subfile))
17463 {
17464 dwarf_record_line (gdbarch, current_subfile,
17465 line, address, p_record_line);
17466 }
17467 last_subfile = current_subfile;
17468 last_line = line;
17469 }
17470 }
17471 discriminator = 0;
17472 break;
17473 case DW_LNS_advance_pc:
17474 {
17475 CORE_ADDR adjust
17476 = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17477
17478 address += (((op_index + adjust)
17479 / lh->maximum_ops_per_instruction)
17480 * lh->minimum_instruction_length);
17481 op_index = ((op_index + adjust)
17482 % lh->maximum_ops_per_instruction);
17483 line_ptr += bytes_read;
17484 }
17485 break;
17486 case DW_LNS_advance_line:
17487 {
17488 int line_delta
17489 = read_signed_leb128 (abfd, line_ptr, &bytes_read);
17490
17491 line += line_delta;
17492 if (line_delta != 0)
17493 line_has_non_zero_discriminator = discriminator != 0;
17494 line_ptr += bytes_read;
17495 }
17496 break;
17497 case DW_LNS_set_file:
17498 {
17499 /* The arrays lh->include_dirs and lh->file_names are
17500 0-based, but the directory and file name numbers in
17501 the statement program are 1-based. */
17502 struct file_entry *fe;
17503 const char *dir = NULL;
17504
17505 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17506 line_ptr += bytes_read;
17507 if (lh->num_file_names < file || file == 0)
17508 dwarf2_debug_line_missing_file_complaint ();
17509 else
17510 {
17511 fe = &lh->file_names[file - 1];
17512 if (fe->dir_index)
17513 dir = lh->include_dirs[fe->dir_index - 1];
17514 if (!decode_for_pst_p)
17515 {
17516 last_subfile = current_subfile;
17517 line_has_non_zero_discriminator = discriminator != 0;
17518 dwarf2_start_subfile (fe->name, dir, comp_dir);
17519 }
17520 }
17521 }
17522 break;
17523 case DW_LNS_set_column:
17524 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17525 line_ptr += bytes_read;
17526 break;
17527 case DW_LNS_negate_stmt:
17528 is_stmt = (!is_stmt);
17529 break;
17530 case DW_LNS_set_basic_block:
17531 break;
17532 /* Add to the address register of the state machine the
17533 address increment value corresponding to special opcode
17534 255. I.e., this value is scaled by the minimum
17535 instruction length since special opcode 255 would have
17536 scaled the increment. */
17537 case DW_LNS_const_add_pc:
17538 {
17539 CORE_ADDR adjust = (255 - lh->opcode_base) / lh->line_range;
17540
17541 address += (((op_index + adjust)
17542 / lh->maximum_ops_per_instruction)
17543 * lh->minimum_instruction_length);
17544 op_index = ((op_index + adjust)
17545 % lh->maximum_ops_per_instruction);
17546 }
17547 break;
17548 case DW_LNS_fixed_advance_pc:
17549 address += read_2_bytes (abfd, line_ptr);
17550 op_index = 0;
17551 line_ptr += 2;
17552 break;
17553 default:
17554 {
17555 /* Unknown standard opcode, ignore it. */
17556 int i;
17557
17558 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
17559 {
17560 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
17561 line_ptr += bytes_read;
17562 }
17563 }
17564 }
17565 }
17566 if (lh->num_file_names < file || file == 0)
17567 dwarf2_debug_line_missing_file_complaint ();
17568 else
17569 {
17570 lh->file_names[file - 1].included_p = 1;
17571 if (!decode_for_pst_p)
17572 {
17573 dwarf_finish_line (gdbarch, current_subfile, address,
17574 p_record_line);
17575 }
17576 }
17577 }
17578 }
17579
17580 /* Decode the Line Number Program (LNP) for the given line_header
17581 structure and CU. The actual information extracted and the type
17582 of structures created from the LNP depends on the value of PST.
17583
17584 1. If PST is NULL, then this procedure uses the data from the program
17585 to create all necessary symbol tables, and their linetables.
17586
17587 2. If PST is not NULL, this procedure reads the program to determine
17588 the list of files included by the unit represented by PST, and
17589 builds all the associated partial symbol tables.
17590
17591 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
17592 It is used for relative paths in the line table.
17593 NOTE: When processing partial symtabs (pst != NULL),
17594 comp_dir == pst->dirname.
17595
17596 NOTE: It is important that psymtabs have the same file name (via strcmp)
17597 as the corresponding symtab. Since COMP_DIR is not used in the name of the
17598 symtab we don't use it in the name of the psymtabs we create.
17599 E.g. expand_line_sal requires this when finding psymtabs to expand.
17600 A good testcase for this is mb-inline.exp. */
17601
17602 static void
17603 dwarf_decode_lines (struct line_header *lh, const char *comp_dir,
17604 struct dwarf2_cu *cu, struct partial_symtab *pst,
17605 int want_line_info)
17606 {
17607 struct objfile *objfile = cu->objfile;
17608 const int decode_for_pst_p = (pst != NULL);
17609 struct subfile *first_subfile = current_subfile;
17610
17611 if (want_line_info)
17612 dwarf_decode_lines_1 (lh, comp_dir, cu, decode_for_pst_p);
17613
17614 if (decode_for_pst_p)
17615 {
17616 int file_index;
17617
17618 /* Now that we're done scanning the Line Header Program, we can
17619 create the psymtab of each included file. */
17620 for (file_index = 0; file_index < lh->num_file_names; file_index++)
17621 if (lh->file_names[file_index].included_p == 1)
17622 {
17623 const char *include_name =
17624 psymtab_include_file_name (lh, file_index, pst, comp_dir);
17625 if (include_name != NULL)
17626 dwarf2_create_include_psymtab (include_name, pst, objfile);
17627 }
17628 }
17629 else
17630 {
17631 /* Make sure a symtab is created for every file, even files
17632 which contain only variables (i.e. no code with associated
17633 line numbers). */
17634 int i;
17635
17636 for (i = 0; i < lh->num_file_names; i++)
17637 {
17638 const char *dir = NULL;
17639 struct file_entry *fe;
17640
17641 fe = &lh->file_names[i];
17642 if (fe->dir_index)
17643 dir = lh->include_dirs[fe->dir_index - 1];
17644 dwarf2_start_subfile (fe->name, dir, comp_dir);
17645
17646 /* Skip the main file; we don't need it, and it must be
17647 allocated last, so that it will show up before the
17648 non-primary symtabs in the objfile's symtab list. */
17649 if (current_subfile == first_subfile)
17650 continue;
17651
17652 if (current_subfile->symtab == NULL)
17653 current_subfile->symtab = allocate_symtab (current_subfile->name,
17654 objfile);
17655 fe->symtab = current_subfile->symtab;
17656 }
17657 }
17658 }
17659
17660 /* Start a subfile for DWARF. FILENAME is the name of the file and
17661 DIRNAME the name of the source directory which contains FILENAME
17662 or NULL if not known. COMP_DIR is the compilation directory for the
17663 linetable's compilation unit or NULL if not known.
17664 This routine tries to keep line numbers from identical absolute and
17665 relative file names in a common subfile.
17666
17667 Using the `list' example from the GDB testsuite, which resides in
17668 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
17669 of /srcdir/list0.c yields the following debugging information for list0.c:
17670
17671 DW_AT_name: /srcdir/list0.c
17672 DW_AT_comp_dir: /compdir
17673 files.files[0].name: list0.h
17674 files.files[0].dir: /srcdir
17675 files.files[1].name: list0.c
17676 files.files[1].dir: /srcdir
17677
17678 The line number information for list0.c has to end up in a single
17679 subfile, so that `break /srcdir/list0.c:1' works as expected.
17680 start_subfile will ensure that this happens provided that we pass the
17681 concatenation of files.files[1].dir and files.files[1].name as the
17682 subfile's name. */
17683
17684 static void
17685 dwarf2_start_subfile (const char *filename, const char *dirname,
17686 const char *comp_dir)
17687 {
17688 char *copy = NULL;
17689
17690 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
17691 `start_symtab' will always pass the contents of DW_AT_comp_dir as
17692 second argument to start_subfile. To be consistent, we do the
17693 same here. In order not to lose the line information directory,
17694 we concatenate it to the filename when it makes sense.
17695 Note that the Dwarf3 standard says (speaking of filenames in line
17696 information): ``The directory index is ignored for file names
17697 that represent full path names''. Thus ignoring dirname in the
17698 `else' branch below isn't an issue. */
17699
17700 if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
17701 {
17702 copy = concat (dirname, SLASH_STRING, filename, (char *)NULL);
17703 filename = copy;
17704 }
17705
17706 start_subfile (filename, comp_dir);
17707
17708 if (copy != NULL)
17709 xfree (copy);
17710 }
17711
17712 /* Start a symtab for DWARF.
17713 NAME, COMP_DIR, LOW_PC are passed to start_symtab. */
17714
17715 static void
17716 dwarf2_start_symtab (struct dwarf2_cu *cu,
17717 const char *name, const char *comp_dir, CORE_ADDR low_pc)
17718 {
17719 start_symtab (name, comp_dir, low_pc);
17720 record_debugformat ("DWARF 2");
17721 record_producer (cu->producer);
17722
17723 /* We assume that we're processing GCC output. */
17724 processing_gcc_compilation = 2;
17725
17726 cu->processing_has_namespace_info = 0;
17727 }
17728
17729 static void
17730 var_decode_location (struct attribute *attr, struct symbol *sym,
17731 struct dwarf2_cu *cu)
17732 {
17733 struct objfile *objfile = cu->objfile;
17734 struct comp_unit_head *cu_header = &cu->header;
17735
17736 /* NOTE drow/2003-01-30: There used to be a comment and some special
17737 code here to turn a symbol with DW_AT_external and a
17738 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
17739 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
17740 with some versions of binutils) where shared libraries could have
17741 relocations against symbols in their debug information - the
17742 minimal symbol would have the right address, but the debug info
17743 would not. It's no longer necessary, because we will explicitly
17744 apply relocations when we read in the debug information now. */
17745
17746 /* A DW_AT_location attribute with no contents indicates that a
17747 variable has been optimized away. */
17748 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
17749 {
17750 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
17751 return;
17752 }
17753
17754 /* Handle one degenerate form of location expression specially, to
17755 preserve GDB's previous behavior when section offsets are
17756 specified. If this is just a DW_OP_addr or DW_OP_GNU_addr_index
17757 then mark this symbol as LOC_STATIC. */
17758
17759 if (attr_form_is_block (attr)
17760 && ((DW_BLOCK (attr)->data[0] == DW_OP_addr
17761 && DW_BLOCK (attr)->size == 1 + cu_header->addr_size)
17762 || (DW_BLOCK (attr)->data[0] == DW_OP_GNU_addr_index
17763 && (DW_BLOCK (attr)->size
17764 == 1 + leb128_size (&DW_BLOCK (attr)->data[1])))))
17765 {
17766 unsigned int dummy;
17767
17768 if (DW_BLOCK (attr)->data[0] == DW_OP_addr)
17769 SYMBOL_VALUE_ADDRESS (sym) =
17770 read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
17771 else
17772 SYMBOL_VALUE_ADDRESS (sym) =
17773 read_addr_index_from_leb128 (cu, DW_BLOCK (attr)->data + 1, &dummy);
17774 SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
17775 fixup_symbol_section (sym, objfile);
17776 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
17777 SYMBOL_SECTION (sym));
17778 return;
17779 }
17780
17781 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
17782 expression evaluator, and use LOC_COMPUTED only when necessary
17783 (i.e. when the value of a register or memory location is
17784 referenced, or a thread-local block, etc.). Then again, it might
17785 not be worthwhile. I'm assuming that it isn't unless performance
17786 or memory numbers show me otherwise. */
17787
17788 dwarf2_symbol_mark_computed (attr, sym, cu, 0);
17789
17790 if (SYMBOL_COMPUTED_OPS (sym)->location_has_loclist)
17791 cu->has_loclist = 1;
17792 }
17793
17794 /* Given a pointer to a DWARF information entry, figure out if we need
17795 to make a symbol table entry for it, and if so, create a new entry
17796 and return a pointer to it.
17797 If TYPE is NULL, determine symbol type from the die, otherwise
17798 used the passed type.
17799 If SPACE is not NULL, use it to hold the new symbol. If it is
17800 NULL, allocate a new symbol on the objfile's obstack. */
17801
17802 static struct symbol *
17803 new_symbol_full (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
17804 struct symbol *space)
17805 {
17806 struct objfile *objfile = cu->objfile;
17807 struct symbol *sym = NULL;
17808 const char *name;
17809 struct attribute *attr = NULL;
17810 struct attribute *attr2 = NULL;
17811 CORE_ADDR baseaddr;
17812 struct pending **list_to_add = NULL;
17813
17814 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
17815
17816 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
17817
17818 name = dwarf2_name (die, cu);
17819 if (name)
17820 {
17821 const char *linkagename;
17822 int suppress_add = 0;
17823
17824 if (space)
17825 sym = space;
17826 else
17827 sym = allocate_symbol (objfile);
17828 OBJSTAT (objfile, n_syms++);
17829
17830 /* Cache this symbol's name and the name's demangled form (if any). */
17831 SYMBOL_SET_LANGUAGE (sym, cu->language, &objfile->objfile_obstack);
17832 linkagename = dwarf2_physname (name, die, cu);
17833 SYMBOL_SET_NAMES (sym, linkagename, strlen (linkagename), 0, objfile);
17834
17835 /* Fortran does not have mangling standard and the mangling does differ
17836 between gfortran, iFort etc. */
17837 if (cu->language == language_fortran
17838 && symbol_get_demangled_name (&(sym->ginfo)) == NULL)
17839 symbol_set_demangled_name (&(sym->ginfo),
17840 dwarf2_full_name (name, die, cu),
17841 NULL);
17842
17843 /* Default assumptions.
17844 Use the passed type or decode it from the die. */
17845 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
17846 SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
17847 if (type != NULL)
17848 SYMBOL_TYPE (sym) = type;
17849 else
17850 SYMBOL_TYPE (sym) = die_type (die, cu);
17851 attr = dwarf2_attr (die,
17852 inlined_func ? DW_AT_call_line : DW_AT_decl_line,
17853 cu);
17854 if (attr)
17855 {
17856 SYMBOL_LINE (sym) = DW_UNSND (attr);
17857 }
17858
17859 attr = dwarf2_attr (die,
17860 inlined_func ? DW_AT_call_file : DW_AT_decl_file,
17861 cu);
17862 if (attr)
17863 {
17864 int file_index = DW_UNSND (attr);
17865
17866 if (cu->line_header == NULL
17867 || file_index > cu->line_header->num_file_names)
17868 complaint (&symfile_complaints,
17869 _("file index out of range"));
17870 else if (file_index > 0)
17871 {
17872 struct file_entry *fe;
17873
17874 fe = &cu->line_header->file_names[file_index - 1];
17875 SYMBOL_SYMTAB (sym) = fe->symtab;
17876 }
17877 }
17878
17879 switch (die->tag)
17880 {
17881 case DW_TAG_label:
17882 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
17883 if (attr)
17884 SYMBOL_VALUE_ADDRESS (sym)
17885 = attr_value_as_address (attr) + baseaddr;
17886 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_core_addr;
17887 SYMBOL_DOMAIN (sym) = LABEL_DOMAIN;
17888 SYMBOL_ACLASS_INDEX (sym) = LOC_LABEL;
17889 add_symbol_to_list (sym, cu->list_in_scope);
17890 break;
17891 case DW_TAG_subprogram:
17892 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
17893 finish_block. */
17894 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
17895 attr2 = dwarf2_attr (die, DW_AT_external, cu);
17896 if ((attr2 && (DW_UNSND (attr2) != 0))
17897 || cu->language == language_ada)
17898 {
17899 /* Subprograms marked external are stored as a global symbol.
17900 Ada subprograms, whether marked external or not, are always
17901 stored as a global symbol, because we want to be able to
17902 access them globally. For instance, we want to be able
17903 to break on a nested subprogram without having to
17904 specify the context. */
17905 list_to_add = &global_symbols;
17906 }
17907 else
17908 {
17909 list_to_add = cu->list_in_scope;
17910 }
17911 break;
17912 case DW_TAG_inlined_subroutine:
17913 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
17914 finish_block. */
17915 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
17916 SYMBOL_INLINED (sym) = 1;
17917 list_to_add = cu->list_in_scope;
17918 break;
17919 case DW_TAG_template_value_param:
17920 suppress_add = 1;
17921 /* Fall through. */
17922 case DW_TAG_constant:
17923 case DW_TAG_variable:
17924 case DW_TAG_member:
17925 /* Compilation with minimal debug info may result in
17926 variables with missing type entries. Change the
17927 misleading `void' type to something sensible. */
17928 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
17929 SYMBOL_TYPE (sym)
17930 = objfile_type (objfile)->nodebug_data_symbol;
17931
17932 attr = dwarf2_attr (die, DW_AT_const_value, cu);
17933 /* In the case of DW_TAG_member, we should only be called for
17934 static const members. */
17935 if (die->tag == DW_TAG_member)
17936 {
17937 /* dwarf2_add_field uses die_is_declaration,
17938 so we do the same. */
17939 gdb_assert (die_is_declaration (die, cu));
17940 gdb_assert (attr);
17941 }
17942 if (attr)
17943 {
17944 dwarf2_const_value (attr, sym, cu);
17945 attr2 = dwarf2_attr (die, DW_AT_external, cu);
17946 if (!suppress_add)
17947 {
17948 if (attr2 && (DW_UNSND (attr2) != 0))
17949 list_to_add = &global_symbols;
17950 else
17951 list_to_add = cu->list_in_scope;
17952 }
17953 break;
17954 }
17955 attr = dwarf2_attr (die, DW_AT_location, cu);
17956 if (attr)
17957 {
17958 var_decode_location (attr, sym, cu);
17959 attr2 = dwarf2_attr (die, DW_AT_external, cu);
17960
17961 /* Fortran explicitly imports any global symbols to the local
17962 scope by DW_TAG_common_block. */
17963 if (cu->language == language_fortran && die->parent
17964 && die->parent->tag == DW_TAG_common_block)
17965 attr2 = NULL;
17966
17967 if (SYMBOL_CLASS (sym) == LOC_STATIC
17968 && SYMBOL_VALUE_ADDRESS (sym) == 0
17969 && !dwarf2_per_objfile->has_section_at_zero)
17970 {
17971 /* When a static variable is eliminated by the linker,
17972 the corresponding debug information is not stripped
17973 out, but the variable address is set to null;
17974 do not add such variables into symbol table. */
17975 }
17976 else if (attr2 && (DW_UNSND (attr2) != 0))
17977 {
17978 /* Workaround gfortran PR debug/40040 - it uses
17979 DW_AT_location for variables in -fPIC libraries which may
17980 get overriden by other libraries/executable and get
17981 a different address. Resolve it by the minimal symbol
17982 which may come from inferior's executable using copy
17983 relocation. Make this workaround only for gfortran as for
17984 other compilers GDB cannot guess the minimal symbol
17985 Fortran mangling kind. */
17986 if (cu->language == language_fortran && die->parent
17987 && die->parent->tag == DW_TAG_module
17988 && cu->producer
17989 && strncmp (cu->producer, "GNU Fortran ", 12) == 0)
17990 SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
17991
17992 /* A variable with DW_AT_external is never static,
17993 but it may be block-scoped. */
17994 list_to_add = (cu->list_in_scope == &file_symbols
17995 ? &global_symbols : cu->list_in_scope);
17996 }
17997 else
17998 list_to_add = cu->list_in_scope;
17999 }
18000 else
18001 {
18002 /* We do not know the address of this symbol.
18003 If it is an external symbol and we have type information
18004 for it, enter the symbol as a LOC_UNRESOLVED symbol.
18005 The address of the variable will then be determined from
18006 the minimal symbol table whenever the variable is
18007 referenced. */
18008 attr2 = dwarf2_attr (die, DW_AT_external, cu);
18009
18010 /* Fortran explicitly imports any global symbols to the local
18011 scope by DW_TAG_common_block. */
18012 if (cu->language == language_fortran && die->parent
18013 && die->parent->tag == DW_TAG_common_block)
18014 {
18015 /* SYMBOL_CLASS doesn't matter here because
18016 read_common_block is going to reset it. */
18017 if (!suppress_add)
18018 list_to_add = cu->list_in_scope;
18019 }
18020 else if (attr2 && (DW_UNSND (attr2) != 0)
18021 && dwarf2_attr (die, DW_AT_type, cu) != NULL)
18022 {
18023 /* A variable with DW_AT_external is never static, but it
18024 may be block-scoped. */
18025 list_to_add = (cu->list_in_scope == &file_symbols
18026 ? &global_symbols : cu->list_in_scope);
18027
18028 SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
18029 }
18030 else if (!die_is_declaration (die, cu))
18031 {
18032 /* Use the default LOC_OPTIMIZED_OUT class. */
18033 gdb_assert (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT);
18034 if (!suppress_add)
18035 list_to_add = cu->list_in_scope;
18036 }
18037 }
18038 break;
18039 case DW_TAG_formal_parameter:
18040 /* If we are inside a function, mark this as an argument. If
18041 not, we might be looking at an argument to an inlined function
18042 when we do not have enough information to show inlined frames;
18043 pretend it's a local variable in that case so that the user can
18044 still see it. */
18045 if (context_stack_depth > 0
18046 && context_stack[context_stack_depth - 1].name != NULL)
18047 SYMBOL_IS_ARGUMENT (sym) = 1;
18048 attr = dwarf2_attr (die, DW_AT_location, cu);
18049 if (attr)
18050 {
18051 var_decode_location (attr, sym, cu);
18052 }
18053 attr = dwarf2_attr (die, DW_AT_const_value, cu);
18054 if (attr)
18055 {
18056 dwarf2_const_value (attr, sym, cu);
18057 }
18058
18059 list_to_add = cu->list_in_scope;
18060 break;
18061 case DW_TAG_unspecified_parameters:
18062 /* From varargs functions; gdb doesn't seem to have any
18063 interest in this information, so just ignore it for now.
18064 (FIXME?) */
18065 break;
18066 case DW_TAG_template_type_param:
18067 suppress_add = 1;
18068 /* Fall through. */
18069 case DW_TAG_class_type:
18070 case DW_TAG_interface_type:
18071 case DW_TAG_structure_type:
18072 case DW_TAG_union_type:
18073 case DW_TAG_set_type:
18074 case DW_TAG_enumeration_type:
18075 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
18076 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
18077
18078 {
18079 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
18080 really ever be static objects: otherwise, if you try
18081 to, say, break of a class's method and you're in a file
18082 which doesn't mention that class, it won't work unless
18083 the check for all static symbols in lookup_symbol_aux
18084 saves you. See the OtherFileClass tests in
18085 gdb.c++/namespace.exp. */
18086
18087 if (!suppress_add)
18088 {
18089 list_to_add = (cu->list_in_scope == &file_symbols
18090 && (cu->language == language_cplus
18091 || cu->language == language_java)
18092 ? &global_symbols : cu->list_in_scope);
18093
18094 /* The semantics of C++ state that "struct foo {
18095 ... }" also defines a typedef for "foo". A Java
18096 class declaration also defines a typedef for the
18097 class. */
18098 if (cu->language == language_cplus
18099 || cu->language == language_java
18100 || cu->language == language_ada)
18101 {
18102 /* The symbol's name is already allocated along
18103 with this objfile, so we don't need to
18104 duplicate it for the type. */
18105 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
18106 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
18107 }
18108 }
18109 }
18110 break;
18111 case DW_TAG_typedef:
18112 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
18113 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
18114 list_to_add = cu->list_in_scope;
18115 break;
18116 case DW_TAG_base_type:
18117 case DW_TAG_subrange_type:
18118 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
18119 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
18120 list_to_add = cu->list_in_scope;
18121 break;
18122 case DW_TAG_enumerator:
18123 attr = dwarf2_attr (die, DW_AT_const_value, cu);
18124 if (attr)
18125 {
18126 dwarf2_const_value (attr, sym, cu);
18127 }
18128 {
18129 /* NOTE: carlton/2003-11-10: See comment above in the
18130 DW_TAG_class_type, etc. block. */
18131
18132 list_to_add = (cu->list_in_scope == &file_symbols
18133 && (cu->language == language_cplus
18134 || cu->language == language_java)
18135 ? &global_symbols : cu->list_in_scope);
18136 }
18137 break;
18138 case DW_TAG_imported_declaration:
18139 case DW_TAG_namespace:
18140 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
18141 list_to_add = &global_symbols;
18142 break;
18143 case DW_TAG_module:
18144 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
18145 SYMBOL_DOMAIN (sym) = MODULE_DOMAIN;
18146 list_to_add = &global_symbols;
18147 break;
18148 case DW_TAG_common_block:
18149 SYMBOL_ACLASS_INDEX (sym) = LOC_COMMON_BLOCK;
18150 SYMBOL_DOMAIN (sym) = COMMON_BLOCK_DOMAIN;
18151 add_symbol_to_list (sym, cu->list_in_scope);
18152 break;
18153 default:
18154 /* Not a tag we recognize. Hopefully we aren't processing
18155 trash data, but since we must specifically ignore things
18156 we don't recognize, there is nothing else we should do at
18157 this point. */
18158 complaint (&symfile_complaints, _("unsupported tag: '%s'"),
18159 dwarf_tag_name (die->tag));
18160 break;
18161 }
18162
18163 if (suppress_add)
18164 {
18165 sym->hash_next = objfile->template_symbols;
18166 objfile->template_symbols = sym;
18167 list_to_add = NULL;
18168 }
18169
18170 if (list_to_add != NULL)
18171 add_symbol_to_list (sym, list_to_add);
18172
18173 /* For the benefit of old versions of GCC, check for anonymous
18174 namespaces based on the demangled name. */
18175 if (!cu->processing_has_namespace_info
18176 && cu->language == language_cplus)
18177 cp_scan_for_anonymous_namespaces (sym, objfile);
18178 }
18179 return (sym);
18180 }
18181
18182 /* A wrapper for new_symbol_full that always allocates a new symbol. */
18183
18184 static struct symbol *
18185 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
18186 {
18187 return new_symbol_full (die, type, cu, NULL);
18188 }
18189
18190 /* Given an attr with a DW_FORM_dataN value in host byte order,
18191 zero-extend it as appropriate for the symbol's type. The DWARF
18192 standard (v4) is not entirely clear about the meaning of using
18193 DW_FORM_dataN for a constant with a signed type, where the type is
18194 wider than the data. The conclusion of a discussion on the DWARF
18195 list was that this is unspecified. We choose to always zero-extend
18196 because that is the interpretation long in use by GCC. */
18197
18198 static gdb_byte *
18199 dwarf2_const_value_data (const struct attribute *attr, struct obstack *obstack,
18200 struct dwarf2_cu *cu, LONGEST *value, int bits)
18201 {
18202 struct objfile *objfile = cu->objfile;
18203 enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ?
18204 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
18205 LONGEST l = DW_UNSND (attr);
18206
18207 if (bits < sizeof (*value) * 8)
18208 {
18209 l &= ((LONGEST) 1 << bits) - 1;
18210 *value = l;
18211 }
18212 else if (bits == sizeof (*value) * 8)
18213 *value = l;
18214 else
18215 {
18216 gdb_byte *bytes = obstack_alloc (obstack, bits / 8);
18217 store_unsigned_integer (bytes, bits / 8, byte_order, l);
18218 return bytes;
18219 }
18220
18221 return NULL;
18222 }
18223
18224 /* Read a constant value from an attribute. Either set *VALUE, or if
18225 the value does not fit in *VALUE, set *BYTES - either already
18226 allocated on the objfile obstack, or newly allocated on OBSTACK,
18227 or, set *BATON, if we translated the constant to a location
18228 expression. */
18229
18230 static void
18231 dwarf2_const_value_attr (const struct attribute *attr, struct type *type,
18232 const char *name, struct obstack *obstack,
18233 struct dwarf2_cu *cu,
18234 LONGEST *value, const gdb_byte **bytes,
18235 struct dwarf2_locexpr_baton **baton)
18236 {
18237 struct objfile *objfile = cu->objfile;
18238 struct comp_unit_head *cu_header = &cu->header;
18239 struct dwarf_block *blk;
18240 enum bfd_endian byte_order = (bfd_big_endian (objfile->obfd) ?
18241 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
18242
18243 *value = 0;
18244 *bytes = NULL;
18245 *baton = NULL;
18246
18247 switch (attr->form)
18248 {
18249 case DW_FORM_addr:
18250 case DW_FORM_GNU_addr_index:
18251 {
18252 gdb_byte *data;
18253
18254 if (TYPE_LENGTH (type) != cu_header->addr_size)
18255 dwarf2_const_value_length_mismatch_complaint (name,
18256 cu_header->addr_size,
18257 TYPE_LENGTH (type));
18258 /* Symbols of this form are reasonably rare, so we just
18259 piggyback on the existing location code rather than writing
18260 a new implementation of symbol_computed_ops. */
18261 *baton = obstack_alloc (obstack, sizeof (struct dwarf2_locexpr_baton));
18262 (*baton)->per_cu = cu->per_cu;
18263 gdb_assert ((*baton)->per_cu);
18264
18265 (*baton)->size = 2 + cu_header->addr_size;
18266 data = obstack_alloc (obstack, (*baton)->size);
18267 (*baton)->data = data;
18268
18269 data[0] = DW_OP_addr;
18270 store_unsigned_integer (&data[1], cu_header->addr_size,
18271 byte_order, DW_ADDR (attr));
18272 data[cu_header->addr_size + 1] = DW_OP_stack_value;
18273 }
18274 break;
18275 case DW_FORM_string:
18276 case DW_FORM_strp:
18277 case DW_FORM_GNU_str_index:
18278 case DW_FORM_GNU_strp_alt:
18279 /* DW_STRING is already allocated on the objfile obstack, point
18280 directly to it. */
18281 *bytes = (const gdb_byte *) DW_STRING (attr);
18282 break;
18283 case DW_FORM_block1:
18284 case DW_FORM_block2:
18285 case DW_FORM_block4:
18286 case DW_FORM_block:
18287 case DW_FORM_exprloc:
18288 blk = DW_BLOCK (attr);
18289 if (TYPE_LENGTH (type) != blk->size)
18290 dwarf2_const_value_length_mismatch_complaint (name, blk->size,
18291 TYPE_LENGTH (type));
18292 *bytes = blk->data;
18293 break;
18294
18295 /* The DW_AT_const_value attributes are supposed to carry the
18296 symbol's value "represented as it would be on the target
18297 architecture." By the time we get here, it's already been
18298 converted to host endianness, so we just need to sign- or
18299 zero-extend it as appropriate. */
18300 case DW_FORM_data1:
18301 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 8);
18302 break;
18303 case DW_FORM_data2:
18304 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 16);
18305 break;
18306 case DW_FORM_data4:
18307 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 32);
18308 break;
18309 case DW_FORM_data8:
18310 *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 64);
18311 break;
18312
18313 case DW_FORM_sdata:
18314 *value = DW_SND (attr);
18315 break;
18316
18317 case DW_FORM_udata:
18318 *value = DW_UNSND (attr);
18319 break;
18320
18321 default:
18322 complaint (&symfile_complaints,
18323 _("unsupported const value attribute form: '%s'"),
18324 dwarf_form_name (attr->form));
18325 *value = 0;
18326 break;
18327 }
18328 }
18329
18330
18331 /* Copy constant value from an attribute to a symbol. */
18332
18333 static void
18334 dwarf2_const_value (const struct attribute *attr, struct symbol *sym,
18335 struct dwarf2_cu *cu)
18336 {
18337 struct objfile *objfile = cu->objfile;
18338 struct comp_unit_head *cu_header = &cu->header;
18339 LONGEST value;
18340 const gdb_byte *bytes;
18341 struct dwarf2_locexpr_baton *baton;
18342
18343 dwarf2_const_value_attr (attr, SYMBOL_TYPE (sym),
18344 SYMBOL_PRINT_NAME (sym),
18345 &objfile->objfile_obstack, cu,
18346 &value, &bytes, &baton);
18347
18348 if (baton != NULL)
18349 {
18350 SYMBOL_LOCATION_BATON (sym) = baton;
18351 SYMBOL_ACLASS_INDEX (sym) = dwarf2_locexpr_index;
18352 }
18353 else if (bytes != NULL)
18354 {
18355 SYMBOL_VALUE_BYTES (sym) = bytes;
18356 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST_BYTES;
18357 }
18358 else
18359 {
18360 SYMBOL_VALUE (sym) = value;
18361 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
18362 }
18363 }
18364
18365 /* Return the type of the die in question using its DW_AT_type attribute. */
18366
18367 static struct type *
18368 die_type (struct die_info *die, struct dwarf2_cu *cu)
18369 {
18370 struct attribute *type_attr;
18371
18372 type_attr = dwarf2_attr (die, DW_AT_type, cu);
18373 if (!type_attr)
18374 {
18375 /* A missing DW_AT_type represents a void type. */
18376 return objfile_type (cu->objfile)->builtin_void;
18377 }
18378
18379 return lookup_die_type (die, type_attr, cu);
18380 }
18381
18382 /* True iff CU's producer generates GNAT Ada auxiliary information
18383 that allows to find parallel types through that information instead
18384 of having to do expensive parallel lookups by type name. */
18385
18386 static int
18387 need_gnat_info (struct dwarf2_cu *cu)
18388 {
18389 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
18390 of GNAT produces this auxiliary information, without any indication
18391 that it is produced. Part of enhancing the FSF version of GNAT
18392 to produce that information will be to put in place an indicator
18393 that we can use in order to determine whether the descriptive type
18394 info is available or not. One suggestion that has been made is
18395 to use a new attribute, attached to the CU die. For now, assume
18396 that the descriptive type info is not available. */
18397 return 0;
18398 }
18399
18400 /* Return the auxiliary type of the die in question using its
18401 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
18402 attribute is not present. */
18403
18404 static struct type *
18405 die_descriptive_type (struct die_info *die, struct dwarf2_cu *cu)
18406 {
18407 struct attribute *type_attr;
18408
18409 type_attr = dwarf2_attr (die, DW_AT_GNAT_descriptive_type, cu);
18410 if (!type_attr)
18411 return NULL;
18412
18413 return lookup_die_type (die, type_attr, cu);
18414 }
18415
18416 /* If DIE has a descriptive_type attribute, then set the TYPE's
18417 descriptive type accordingly. */
18418
18419 static void
18420 set_descriptive_type (struct type *type, struct die_info *die,
18421 struct dwarf2_cu *cu)
18422 {
18423 struct type *descriptive_type = die_descriptive_type (die, cu);
18424
18425 if (descriptive_type)
18426 {
18427 ALLOCATE_GNAT_AUX_TYPE (type);
18428 TYPE_DESCRIPTIVE_TYPE (type) = descriptive_type;
18429 }
18430 }
18431
18432 /* Return the containing type of the die in question using its
18433 DW_AT_containing_type attribute. */
18434
18435 static struct type *
18436 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
18437 {
18438 struct attribute *type_attr;
18439
18440 type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
18441 if (!type_attr)
18442 error (_("Dwarf Error: Problem turning containing type into gdb type "
18443 "[in module %s]"), objfile_name (cu->objfile));
18444
18445 return lookup_die_type (die, type_attr, cu);
18446 }
18447
18448 /* Return an error marker type to use for the ill formed type in DIE/CU. */
18449
18450 static struct type *
18451 build_error_marker_type (struct dwarf2_cu *cu, struct die_info *die)
18452 {
18453 struct objfile *objfile = dwarf2_per_objfile->objfile;
18454 char *message, *saved;
18455
18456 message = xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
18457 objfile_name (objfile),
18458 cu->header.offset.sect_off,
18459 die->offset.sect_off);
18460 saved = obstack_copy0 (&objfile->objfile_obstack,
18461 message, strlen (message));
18462 xfree (message);
18463
18464 return init_type (TYPE_CODE_ERROR, 0, 0, saved, objfile);
18465 }
18466
18467 /* Look up the type of DIE in CU using its type attribute ATTR.
18468 ATTR must be one of: DW_AT_type, DW_AT_GNAT_descriptive_type,
18469 DW_AT_containing_type.
18470 If there is no type substitute an error marker. */
18471
18472 static struct type *
18473 lookup_die_type (struct die_info *die, const struct attribute *attr,
18474 struct dwarf2_cu *cu)
18475 {
18476 struct objfile *objfile = cu->objfile;
18477 struct type *this_type;
18478
18479 gdb_assert (attr->name == DW_AT_type
18480 || attr->name == DW_AT_GNAT_descriptive_type
18481 || attr->name == DW_AT_containing_type);
18482
18483 /* First see if we have it cached. */
18484
18485 if (attr->form == DW_FORM_GNU_ref_alt)
18486 {
18487 struct dwarf2_per_cu_data *per_cu;
18488 sect_offset offset = dwarf2_get_ref_die_offset (attr);
18489
18490 per_cu = dwarf2_find_containing_comp_unit (offset, 1, cu->objfile);
18491 this_type = get_die_type_at_offset (offset, per_cu);
18492 }
18493 else if (attr_form_is_ref (attr))
18494 {
18495 sect_offset offset = dwarf2_get_ref_die_offset (attr);
18496
18497 this_type = get_die_type_at_offset (offset, cu->per_cu);
18498 }
18499 else if (attr->form == DW_FORM_ref_sig8)
18500 {
18501 ULONGEST signature = DW_SIGNATURE (attr);
18502
18503 return get_signatured_type (die, signature, cu);
18504 }
18505 else
18506 {
18507 complaint (&symfile_complaints,
18508 _("Dwarf Error: Bad type attribute %s in DIE"
18509 " at 0x%x [in module %s]"),
18510 dwarf_attr_name (attr->name), die->offset.sect_off,
18511 objfile_name (objfile));
18512 return build_error_marker_type (cu, die);
18513 }
18514
18515 /* If not cached we need to read it in. */
18516
18517 if (this_type == NULL)
18518 {
18519 struct die_info *type_die = NULL;
18520 struct dwarf2_cu *type_cu = cu;
18521
18522 if (attr_form_is_ref (attr))
18523 type_die = follow_die_ref (die, attr, &type_cu);
18524 if (type_die == NULL)
18525 return build_error_marker_type (cu, die);
18526 /* If we find the type now, it's probably because the type came
18527 from an inter-CU reference and the type's CU got expanded before
18528 ours. */
18529 this_type = read_type_die (type_die, type_cu);
18530 }
18531
18532 /* If we still don't have a type use an error marker. */
18533
18534 if (this_type == NULL)
18535 return build_error_marker_type (cu, die);
18536
18537 return this_type;
18538 }
18539
18540 /* Return the type in DIE, CU.
18541 Returns NULL for invalid types.
18542
18543 This first does a lookup in die_type_hash,
18544 and only reads the die in if necessary.
18545
18546 NOTE: This can be called when reading in partial or full symbols. */
18547
18548 static struct type *
18549 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
18550 {
18551 struct type *this_type;
18552
18553 this_type = get_die_type (die, cu);
18554 if (this_type)
18555 return this_type;
18556
18557 return read_type_die_1 (die, cu);
18558 }
18559
18560 /* Read the type in DIE, CU.
18561 Returns NULL for invalid types. */
18562
18563 static struct type *
18564 read_type_die_1 (struct die_info *die, struct dwarf2_cu *cu)
18565 {
18566 struct type *this_type = NULL;
18567
18568 switch (die->tag)
18569 {
18570 case DW_TAG_class_type:
18571 case DW_TAG_interface_type:
18572 case DW_TAG_structure_type:
18573 case DW_TAG_union_type:
18574 this_type = read_structure_type (die, cu);
18575 break;
18576 case DW_TAG_enumeration_type:
18577 this_type = read_enumeration_type (die, cu);
18578 break;
18579 case DW_TAG_subprogram:
18580 case DW_TAG_subroutine_type:
18581 case DW_TAG_inlined_subroutine:
18582 this_type = read_subroutine_type (die, cu);
18583 break;
18584 case DW_TAG_array_type:
18585 this_type = read_array_type (die, cu);
18586 break;
18587 case DW_TAG_set_type:
18588 this_type = read_set_type (die, cu);
18589 break;
18590 case DW_TAG_pointer_type:
18591 this_type = read_tag_pointer_type (die, cu);
18592 break;
18593 case DW_TAG_ptr_to_member_type:
18594 this_type = read_tag_ptr_to_member_type (die, cu);
18595 break;
18596 case DW_TAG_reference_type:
18597 this_type = read_tag_reference_type (die, cu);
18598 break;
18599 case DW_TAG_const_type:
18600 this_type = read_tag_const_type (die, cu);
18601 break;
18602 case DW_TAG_volatile_type:
18603 this_type = read_tag_volatile_type (die, cu);
18604 break;
18605 case DW_TAG_restrict_type:
18606 this_type = read_tag_restrict_type (die, cu);
18607 break;
18608 case DW_TAG_string_type:
18609 this_type = read_tag_string_type (die, cu);
18610 break;
18611 case DW_TAG_typedef:
18612 this_type = read_typedef (die, cu);
18613 break;
18614 case DW_TAG_subrange_type:
18615 this_type = read_subrange_type (die, cu);
18616 break;
18617 case DW_TAG_base_type:
18618 this_type = read_base_type (die, cu);
18619 break;
18620 case DW_TAG_unspecified_type:
18621 this_type = read_unspecified_type (die, cu);
18622 break;
18623 case DW_TAG_namespace:
18624 this_type = read_namespace_type (die, cu);
18625 break;
18626 case DW_TAG_module:
18627 this_type = read_module_type (die, cu);
18628 break;
18629 default:
18630 complaint (&symfile_complaints,
18631 _("unexpected tag in read_type_die: '%s'"),
18632 dwarf_tag_name (die->tag));
18633 break;
18634 }
18635
18636 return this_type;
18637 }
18638
18639 /* See if we can figure out if the class lives in a namespace. We do
18640 this by looking for a member function; its demangled name will
18641 contain namespace info, if there is any.
18642 Return the computed name or NULL.
18643 Space for the result is allocated on the objfile's obstack.
18644 This is the full-die version of guess_partial_die_structure_name.
18645 In this case we know DIE has no useful parent. */
18646
18647 static char *
18648 guess_full_die_structure_name (struct die_info *die, struct dwarf2_cu *cu)
18649 {
18650 struct die_info *spec_die;
18651 struct dwarf2_cu *spec_cu;
18652 struct die_info *child;
18653
18654 spec_cu = cu;
18655 spec_die = die_specification (die, &spec_cu);
18656 if (spec_die != NULL)
18657 {
18658 die = spec_die;
18659 cu = spec_cu;
18660 }
18661
18662 for (child = die->child;
18663 child != NULL;
18664 child = child->sibling)
18665 {
18666 if (child->tag == DW_TAG_subprogram)
18667 {
18668 struct attribute *attr;
18669
18670 attr = dwarf2_attr (child, DW_AT_linkage_name, cu);
18671 if (attr == NULL)
18672 attr = dwarf2_attr (child, DW_AT_MIPS_linkage_name, cu);
18673 if (attr != NULL)
18674 {
18675 char *actual_name
18676 = language_class_name_from_physname (cu->language_defn,
18677 DW_STRING (attr));
18678 char *name = NULL;
18679
18680 if (actual_name != NULL)
18681 {
18682 const char *die_name = dwarf2_name (die, cu);
18683
18684 if (die_name != NULL
18685 && strcmp (die_name, actual_name) != 0)
18686 {
18687 /* Strip off the class name from the full name.
18688 We want the prefix. */
18689 int die_name_len = strlen (die_name);
18690 int actual_name_len = strlen (actual_name);
18691
18692 /* Test for '::' as a sanity check. */
18693 if (actual_name_len > die_name_len + 2
18694 && actual_name[actual_name_len
18695 - die_name_len - 1] == ':')
18696 name =
18697 obstack_copy0 (&cu->objfile->per_bfd->storage_obstack,
18698 actual_name,
18699 actual_name_len - die_name_len - 2);
18700 }
18701 }
18702 xfree (actual_name);
18703 return name;
18704 }
18705 }
18706 }
18707
18708 return NULL;
18709 }
18710
18711 /* GCC might emit a nameless typedef that has a linkage name. Determine the
18712 prefix part in such case. See
18713 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
18714
18715 static char *
18716 anonymous_struct_prefix (struct die_info *die, struct dwarf2_cu *cu)
18717 {
18718 struct attribute *attr;
18719 char *base;
18720
18721 if (die->tag != DW_TAG_class_type && die->tag != DW_TAG_interface_type
18722 && die->tag != DW_TAG_structure_type && die->tag != DW_TAG_union_type)
18723 return NULL;
18724
18725 attr = dwarf2_attr (die, DW_AT_name, cu);
18726 if (attr != NULL && DW_STRING (attr) != NULL)
18727 return NULL;
18728
18729 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
18730 if (attr == NULL)
18731 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
18732 if (attr == NULL || DW_STRING (attr) == NULL)
18733 return NULL;
18734
18735 /* dwarf2_name had to be already called. */
18736 gdb_assert (DW_STRING_IS_CANONICAL (attr));
18737
18738 /* Strip the base name, keep any leading namespaces/classes. */
18739 base = strrchr (DW_STRING (attr), ':');
18740 if (base == NULL || base == DW_STRING (attr) || base[-1] != ':')
18741 return "";
18742
18743 return obstack_copy0 (&cu->objfile->per_bfd->storage_obstack,
18744 DW_STRING (attr), &base[-1] - DW_STRING (attr));
18745 }
18746
18747 /* Return the name of the namespace/class that DIE is defined within,
18748 or "" if we can't tell. The caller should not xfree the result.
18749
18750 For example, if we're within the method foo() in the following
18751 code:
18752
18753 namespace N {
18754 class C {
18755 void foo () {
18756 }
18757 };
18758 }
18759
18760 then determine_prefix on foo's die will return "N::C". */
18761
18762 static const char *
18763 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
18764 {
18765 struct die_info *parent, *spec_die;
18766 struct dwarf2_cu *spec_cu;
18767 struct type *parent_type;
18768 char *retval;
18769
18770 if (cu->language != language_cplus && cu->language != language_java
18771 && cu->language != language_fortran)
18772 return "";
18773
18774 retval = anonymous_struct_prefix (die, cu);
18775 if (retval)
18776 return retval;
18777
18778 /* We have to be careful in the presence of DW_AT_specification.
18779 For example, with GCC 3.4, given the code
18780
18781 namespace N {
18782 void foo() {
18783 // Definition of N::foo.
18784 }
18785 }
18786
18787 then we'll have a tree of DIEs like this:
18788
18789 1: DW_TAG_compile_unit
18790 2: DW_TAG_namespace // N
18791 3: DW_TAG_subprogram // declaration of N::foo
18792 4: DW_TAG_subprogram // definition of N::foo
18793 DW_AT_specification // refers to die #3
18794
18795 Thus, when processing die #4, we have to pretend that we're in
18796 the context of its DW_AT_specification, namely the contex of die
18797 #3. */
18798 spec_cu = cu;
18799 spec_die = die_specification (die, &spec_cu);
18800 if (spec_die == NULL)
18801 parent = die->parent;
18802 else
18803 {
18804 parent = spec_die->parent;
18805 cu = spec_cu;
18806 }
18807
18808 if (parent == NULL)
18809 return "";
18810 else if (parent->building_fullname)
18811 {
18812 const char *name;
18813 const char *parent_name;
18814
18815 /* It has been seen on RealView 2.2 built binaries,
18816 DW_TAG_template_type_param types actually _defined_ as
18817 children of the parent class:
18818
18819 enum E {};
18820 template class <class Enum> Class{};
18821 Class<enum E> class_e;
18822
18823 1: DW_TAG_class_type (Class)
18824 2: DW_TAG_enumeration_type (E)
18825 3: DW_TAG_enumerator (enum1:0)
18826 3: DW_TAG_enumerator (enum2:1)
18827 ...
18828 2: DW_TAG_template_type_param
18829 DW_AT_type DW_FORM_ref_udata (E)
18830
18831 Besides being broken debug info, it can put GDB into an
18832 infinite loop. Consider:
18833
18834 When we're building the full name for Class<E>, we'll start
18835 at Class, and go look over its template type parameters,
18836 finding E. We'll then try to build the full name of E, and
18837 reach here. We're now trying to build the full name of E,
18838 and look over the parent DIE for containing scope. In the
18839 broken case, if we followed the parent DIE of E, we'd again
18840 find Class, and once again go look at its template type
18841 arguments, etc., etc. Simply don't consider such parent die
18842 as source-level parent of this die (it can't be, the language
18843 doesn't allow it), and break the loop here. */
18844 name = dwarf2_name (die, cu);
18845 parent_name = dwarf2_name (parent, cu);
18846 complaint (&symfile_complaints,
18847 _("template param type '%s' defined within parent '%s'"),
18848 name ? name : "<unknown>",
18849 parent_name ? parent_name : "<unknown>");
18850 return "";
18851 }
18852 else
18853 switch (parent->tag)
18854 {
18855 case DW_TAG_namespace:
18856 parent_type = read_type_die (parent, cu);
18857 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
18858 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
18859 Work around this problem here. */
18860 if (cu->language == language_cplus
18861 && strcmp (TYPE_TAG_NAME (parent_type), "::") == 0)
18862 return "";
18863 /* We give a name to even anonymous namespaces. */
18864 return TYPE_TAG_NAME (parent_type);
18865 case DW_TAG_class_type:
18866 case DW_TAG_interface_type:
18867 case DW_TAG_structure_type:
18868 case DW_TAG_union_type:
18869 case DW_TAG_module:
18870 parent_type = read_type_die (parent, cu);
18871 if (TYPE_TAG_NAME (parent_type) != NULL)
18872 return TYPE_TAG_NAME (parent_type);
18873 else
18874 /* An anonymous structure is only allowed non-static data
18875 members; no typedefs, no member functions, et cetera.
18876 So it does not need a prefix. */
18877 return "";
18878 case DW_TAG_compile_unit:
18879 case DW_TAG_partial_unit:
18880 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
18881 if (cu->language == language_cplus
18882 && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
18883 && die->child != NULL
18884 && (die->tag == DW_TAG_class_type
18885 || die->tag == DW_TAG_structure_type
18886 || die->tag == DW_TAG_union_type))
18887 {
18888 char *name = guess_full_die_structure_name (die, cu);
18889 if (name != NULL)
18890 return name;
18891 }
18892 return "";
18893 case DW_TAG_enumeration_type:
18894 parent_type = read_type_die (parent, cu);
18895 if (TYPE_DECLARED_CLASS (parent_type))
18896 {
18897 if (TYPE_TAG_NAME (parent_type) != NULL)
18898 return TYPE_TAG_NAME (parent_type);
18899 return "";
18900 }
18901 /* Fall through. */
18902 default:
18903 return determine_prefix (parent, cu);
18904 }
18905 }
18906
18907 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
18908 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
18909 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
18910 an obconcat, otherwise allocate storage for the result. The CU argument is
18911 used to determine the language and hence, the appropriate separator. */
18912
18913 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
18914
18915 static char *
18916 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
18917 int physname, struct dwarf2_cu *cu)
18918 {
18919 const char *lead = "";
18920 const char *sep;
18921
18922 if (suffix == NULL || suffix[0] == '\0'
18923 || prefix == NULL || prefix[0] == '\0')
18924 sep = "";
18925 else if (cu->language == language_java)
18926 sep = ".";
18927 else if (cu->language == language_fortran && physname)
18928 {
18929 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
18930 DW_AT_MIPS_linkage_name is preferred and used instead. */
18931
18932 lead = "__";
18933 sep = "_MOD_";
18934 }
18935 else
18936 sep = "::";
18937
18938 if (prefix == NULL)
18939 prefix = "";
18940 if (suffix == NULL)
18941 suffix = "";
18942
18943 if (obs == NULL)
18944 {
18945 char *retval
18946 = xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1);
18947
18948 strcpy (retval, lead);
18949 strcat (retval, prefix);
18950 strcat (retval, sep);
18951 strcat (retval, suffix);
18952 return retval;
18953 }
18954 else
18955 {
18956 /* We have an obstack. */
18957 return obconcat (obs, lead, prefix, sep, suffix, (char *) NULL);
18958 }
18959 }
18960
18961 /* Return sibling of die, NULL if no sibling. */
18962
18963 static struct die_info *
18964 sibling_die (struct die_info *die)
18965 {
18966 return die->sibling;
18967 }
18968
18969 /* Get name of a die, return NULL if not found. */
18970
18971 static const char *
18972 dwarf2_canonicalize_name (const char *name, struct dwarf2_cu *cu,
18973 struct obstack *obstack)
18974 {
18975 if (name && cu->language == language_cplus)
18976 {
18977 char *canon_name = cp_canonicalize_string (name);
18978
18979 if (canon_name != NULL)
18980 {
18981 if (strcmp (canon_name, name) != 0)
18982 name = obstack_copy0 (obstack, canon_name, strlen (canon_name));
18983 xfree (canon_name);
18984 }
18985 }
18986
18987 return name;
18988 }
18989
18990 /* Get name of a die, return NULL if not found. */
18991
18992 static const char *
18993 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
18994 {
18995 struct attribute *attr;
18996
18997 attr = dwarf2_attr (die, DW_AT_name, cu);
18998 if ((!attr || !DW_STRING (attr))
18999 && die->tag != DW_TAG_class_type
19000 && die->tag != DW_TAG_interface_type
19001 && die->tag != DW_TAG_structure_type
19002 && die->tag != DW_TAG_union_type)
19003 return NULL;
19004
19005 switch (die->tag)
19006 {
19007 case DW_TAG_compile_unit:
19008 case DW_TAG_partial_unit:
19009 /* Compilation units have a DW_AT_name that is a filename, not
19010 a source language identifier. */
19011 case DW_TAG_enumeration_type:
19012 case DW_TAG_enumerator:
19013 /* These tags always have simple identifiers already; no need
19014 to canonicalize them. */
19015 return DW_STRING (attr);
19016
19017 case DW_TAG_subprogram:
19018 /* Java constructors will all be named "<init>", so return
19019 the class name when we see this special case. */
19020 if (cu->language == language_java
19021 && DW_STRING (attr) != NULL
19022 && strcmp (DW_STRING (attr), "<init>") == 0)
19023 {
19024 struct dwarf2_cu *spec_cu = cu;
19025 struct die_info *spec_die;
19026
19027 /* GCJ will output '<init>' for Java constructor names.
19028 For this special case, return the name of the parent class. */
19029
19030 /* GCJ may output subprogram DIEs with AT_specification set.
19031 If so, use the name of the specified DIE. */
19032 spec_die = die_specification (die, &spec_cu);
19033 if (spec_die != NULL)
19034 return dwarf2_name (spec_die, spec_cu);
19035
19036 do
19037 {
19038 die = die->parent;
19039 if (die->tag == DW_TAG_class_type)
19040 return dwarf2_name (die, cu);
19041 }
19042 while (die->tag != DW_TAG_compile_unit
19043 && die->tag != DW_TAG_partial_unit);
19044 }
19045 break;
19046
19047 case DW_TAG_class_type:
19048 case DW_TAG_interface_type:
19049 case DW_TAG_structure_type:
19050 case DW_TAG_union_type:
19051 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
19052 structures or unions. These were of the form "._%d" in GCC 4.1,
19053 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
19054 and GCC 4.4. We work around this problem by ignoring these. */
19055 if (attr && DW_STRING (attr)
19056 && (strncmp (DW_STRING (attr), "._", 2) == 0
19057 || strncmp (DW_STRING (attr), "<anonymous", 10) == 0))
19058 return NULL;
19059
19060 /* GCC might emit a nameless typedef that has a linkage name. See
19061 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
19062 if (!attr || DW_STRING (attr) == NULL)
19063 {
19064 char *demangled = NULL;
19065
19066 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
19067 if (attr == NULL)
19068 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
19069
19070 if (attr == NULL || DW_STRING (attr) == NULL)
19071 return NULL;
19072
19073 /* Avoid demangling DW_STRING (attr) the second time on a second
19074 call for the same DIE. */
19075 if (!DW_STRING_IS_CANONICAL (attr))
19076 demangled = gdb_demangle (DW_STRING (attr), DMGL_TYPES);
19077
19078 if (demangled)
19079 {
19080 char *base;
19081
19082 /* FIXME: we already did this for the partial symbol... */
19083 DW_STRING (attr)
19084 = obstack_copy0 (&cu->objfile->per_bfd->storage_obstack,
19085 demangled, strlen (demangled));
19086 DW_STRING_IS_CANONICAL (attr) = 1;
19087 xfree (demangled);
19088
19089 /* Strip any leading namespaces/classes, keep only the base name.
19090 DW_AT_name for named DIEs does not contain the prefixes. */
19091 base = strrchr (DW_STRING (attr), ':');
19092 if (base && base > DW_STRING (attr) && base[-1] == ':')
19093 return &base[1];
19094 else
19095 return DW_STRING (attr);
19096 }
19097 }
19098 break;
19099
19100 default:
19101 break;
19102 }
19103
19104 if (!DW_STRING_IS_CANONICAL (attr))
19105 {
19106 DW_STRING (attr)
19107 = dwarf2_canonicalize_name (DW_STRING (attr), cu,
19108 &cu->objfile->per_bfd->storage_obstack);
19109 DW_STRING_IS_CANONICAL (attr) = 1;
19110 }
19111 return DW_STRING (attr);
19112 }
19113
19114 /* Return the die that this die in an extension of, or NULL if there
19115 is none. *EXT_CU is the CU containing DIE on input, and the CU
19116 containing the return value on output. */
19117
19118 static struct die_info *
19119 dwarf2_extension (struct die_info *die, struct dwarf2_cu **ext_cu)
19120 {
19121 struct attribute *attr;
19122
19123 attr = dwarf2_attr (die, DW_AT_extension, *ext_cu);
19124 if (attr == NULL)
19125 return NULL;
19126
19127 return follow_die_ref (die, attr, ext_cu);
19128 }
19129
19130 /* Convert a DIE tag into its string name. */
19131
19132 static const char *
19133 dwarf_tag_name (unsigned tag)
19134 {
19135 const char *name = get_DW_TAG_name (tag);
19136
19137 if (name == NULL)
19138 return "DW_TAG_<unknown>";
19139
19140 return name;
19141 }
19142
19143 /* Convert a DWARF attribute code into its string name. */
19144
19145 static const char *
19146 dwarf_attr_name (unsigned attr)
19147 {
19148 const char *name;
19149
19150 #ifdef MIPS /* collides with DW_AT_HP_block_index */
19151 if (attr == DW_AT_MIPS_fde)
19152 return "DW_AT_MIPS_fde";
19153 #else
19154 if (attr == DW_AT_HP_block_index)
19155 return "DW_AT_HP_block_index";
19156 #endif
19157
19158 name = get_DW_AT_name (attr);
19159
19160 if (name == NULL)
19161 return "DW_AT_<unknown>";
19162
19163 return name;
19164 }
19165
19166 /* Convert a DWARF value form code into its string name. */
19167
19168 static const char *
19169 dwarf_form_name (unsigned form)
19170 {
19171 const char *name = get_DW_FORM_name (form);
19172
19173 if (name == NULL)
19174 return "DW_FORM_<unknown>";
19175
19176 return name;
19177 }
19178
19179 static char *
19180 dwarf_bool_name (unsigned mybool)
19181 {
19182 if (mybool)
19183 return "TRUE";
19184 else
19185 return "FALSE";
19186 }
19187
19188 /* Convert a DWARF type code into its string name. */
19189
19190 static const char *
19191 dwarf_type_encoding_name (unsigned enc)
19192 {
19193 const char *name = get_DW_ATE_name (enc);
19194
19195 if (name == NULL)
19196 return "DW_ATE_<unknown>";
19197
19198 return name;
19199 }
19200
19201 static void
19202 dump_die_shallow (struct ui_file *f, int indent, struct die_info *die)
19203 {
19204 unsigned int i;
19205
19206 print_spaces (indent, f);
19207 fprintf_unfiltered (f, "Die: %s (abbrev %d, offset 0x%x)\n",
19208 dwarf_tag_name (die->tag), die->abbrev, die->offset.sect_off);
19209
19210 if (die->parent != NULL)
19211 {
19212 print_spaces (indent, f);
19213 fprintf_unfiltered (f, " parent at offset: 0x%x\n",
19214 die->parent->offset.sect_off);
19215 }
19216
19217 print_spaces (indent, f);
19218 fprintf_unfiltered (f, " has children: %s\n",
19219 dwarf_bool_name (die->child != NULL));
19220
19221 print_spaces (indent, f);
19222 fprintf_unfiltered (f, " attributes:\n");
19223
19224 for (i = 0; i < die->num_attrs; ++i)
19225 {
19226 print_spaces (indent, f);
19227 fprintf_unfiltered (f, " %s (%s) ",
19228 dwarf_attr_name (die->attrs[i].name),
19229 dwarf_form_name (die->attrs[i].form));
19230
19231 switch (die->attrs[i].form)
19232 {
19233 case DW_FORM_addr:
19234 case DW_FORM_GNU_addr_index:
19235 fprintf_unfiltered (f, "address: ");
19236 fputs_filtered (hex_string (DW_ADDR (&die->attrs[i])), f);
19237 break;
19238 case DW_FORM_block2:
19239 case DW_FORM_block4:
19240 case DW_FORM_block:
19241 case DW_FORM_block1:
19242 fprintf_unfiltered (f, "block: size %s",
19243 pulongest (DW_BLOCK (&die->attrs[i])->size));
19244 break;
19245 case DW_FORM_exprloc:
19246 fprintf_unfiltered (f, "expression: size %s",
19247 pulongest (DW_BLOCK (&die->attrs[i])->size));
19248 break;
19249 case DW_FORM_ref_addr:
19250 fprintf_unfiltered (f, "ref address: ");
19251 fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
19252 break;
19253 case DW_FORM_GNU_ref_alt:
19254 fprintf_unfiltered (f, "alt ref address: ");
19255 fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
19256 break;
19257 case DW_FORM_ref1:
19258 case DW_FORM_ref2:
19259 case DW_FORM_ref4:
19260 case DW_FORM_ref8:
19261 case DW_FORM_ref_udata:
19262 fprintf_unfiltered (f, "constant ref: 0x%lx (adjusted)",
19263 (long) (DW_UNSND (&die->attrs[i])));
19264 break;
19265 case DW_FORM_data1:
19266 case DW_FORM_data2:
19267 case DW_FORM_data4:
19268 case DW_FORM_data8:
19269 case DW_FORM_udata:
19270 case DW_FORM_sdata:
19271 fprintf_unfiltered (f, "constant: %s",
19272 pulongest (DW_UNSND (&die->attrs[i])));
19273 break;
19274 case DW_FORM_sec_offset:
19275 fprintf_unfiltered (f, "section offset: %s",
19276 pulongest (DW_UNSND (&die->attrs[i])));
19277 break;
19278 case DW_FORM_ref_sig8:
19279 fprintf_unfiltered (f, "signature: %s",
19280 hex_string (DW_SIGNATURE (&die->attrs[i])));
19281 break;
19282 case DW_FORM_string:
19283 case DW_FORM_strp:
19284 case DW_FORM_GNU_str_index:
19285 case DW_FORM_GNU_strp_alt:
19286 fprintf_unfiltered (f, "string: \"%s\" (%s canonicalized)",
19287 DW_STRING (&die->attrs[i])
19288 ? DW_STRING (&die->attrs[i]) : "",
19289 DW_STRING_IS_CANONICAL (&die->attrs[i]) ? "is" : "not");
19290 break;
19291 case DW_FORM_flag:
19292 if (DW_UNSND (&die->attrs[i]))
19293 fprintf_unfiltered (f, "flag: TRUE");
19294 else
19295 fprintf_unfiltered (f, "flag: FALSE");
19296 break;
19297 case DW_FORM_flag_present:
19298 fprintf_unfiltered (f, "flag: TRUE");
19299 break;
19300 case DW_FORM_indirect:
19301 /* The reader will have reduced the indirect form to
19302 the "base form" so this form should not occur. */
19303 fprintf_unfiltered (f,
19304 "unexpected attribute form: DW_FORM_indirect");
19305 break;
19306 default:
19307 fprintf_unfiltered (f, "unsupported attribute form: %d.",
19308 die->attrs[i].form);
19309 break;
19310 }
19311 fprintf_unfiltered (f, "\n");
19312 }
19313 }
19314
19315 static void
19316 dump_die_for_error (struct die_info *die)
19317 {
19318 dump_die_shallow (gdb_stderr, 0, die);
19319 }
19320
19321 static void
19322 dump_die_1 (struct ui_file *f, int level, int max_level, struct die_info *die)
19323 {
19324 int indent = level * 4;
19325
19326 gdb_assert (die != NULL);
19327
19328 if (level >= max_level)
19329 return;
19330
19331 dump_die_shallow (f, indent, die);
19332
19333 if (die->child != NULL)
19334 {
19335 print_spaces (indent, f);
19336 fprintf_unfiltered (f, " Children:");
19337 if (level + 1 < max_level)
19338 {
19339 fprintf_unfiltered (f, "\n");
19340 dump_die_1 (f, level + 1, max_level, die->child);
19341 }
19342 else
19343 {
19344 fprintf_unfiltered (f,
19345 " [not printed, max nesting level reached]\n");
19346 }
19347 }
19348
19349 if (die->sibling != NULL && level > 0)
19350 {
19351 dump_die_1 (f, level, max_level, die->sibling);
19352 }
19353 }
19354
19355 /* This is called from the pdie macro in gdbinit.in.
19356 It's not static so gcc will keep a copy callable from gdb. */
19357
19358 void
19359 dump_die (struct die_info *die, int max_level)
19360 {
19361 dump_die_1 (gdb_stdlog, 0, max_level, die);
19362 }
19363
19364 static void
19365 store_in_ref_table (struct die_info *die, struct dwarf2_cu *cu)
19366 {
19367 void **slot;
19368
19369 slot = htab_find_slot_with_hash (cu->die_hash, die, die->offset.sect_off,
19370 INSERT);
19371
19372 *slot = die;
19373 }
19374
19375 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
19376 required kind. */
19377
19378 static sect_offset
19379 dwarf2_get_ref_die_offset (const struct attribute *attr)
19380 {
19381 sect_offset retval = { DW_UNSND (attr) };
19382
19383 if (attr_form_is_ref (attr))
19384 return retval;
19385
19386 retval.sect_off = 0;
19387 complaint (&symfile_complaints,
19388 _("unsupported die ref attribute form: '%s'"),
19389 dwarf_form_name (attr->form));
19390 return retval;
19391 }
19392
19393 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
19394 * the value held by the attribute is not constant. */
19395
19396 static LONGEST
19397 dwarf2_get_attr_constant_value (const struct attribute *attr, int default_value)
19398 {
19399 if (attr->form == DW_FORM_sdata)
19400 return DW_SND (attr);
19401 else if (attr->form == DW_FORM_udata
19402 || attr->form == DW_FORM_data1
19403 || attr->form == DW_FORM_data2
19404 || attr->form == DW_FORM_data4
19405 || attr->form == DW_FORM_data8)
19406 return DW_UNSND (attr);
19407 else
19408 {
19409 complaint (&symfile_complaints,
19410 _("Attribute value is not a constant (%s)"),
19411 dwarf_form_name (attr->form));
19412 return default_value;
19413 }
19414 }
19415
19416 /* Follow reference or signature attribute ATTR of SRC_DIE.
19417 On entry *REF_CU is the CU of SRC_DIE.
19418 On exit *REF_CU is the CU of the result. */
19419
19420 static struct die_info *
19421 follow_die_ref_or_sig (struct die_info *src_die, const struct attribute *attr,
19422 struct dwarf2_cu **ref_cu)
19423 {
19424 struct die_info *die;
19425
19426 if (attr_form_is_ref (attr))
19427 die = follow_die_ref (src_die, attr, ref_cu);
19428 else if (attr->form == DW_FORM_ref_sig8)
19429 die = follow_die_sig (src_die, attr, ref_cu);
19430 else
19431 {
19432 dump_die_for_error (src_die);
19433 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
19434 objfile_name ((*ref_cu)->objfile));
19435 }
19436
19437 return die;
19438 }
19439
19440 /* Follow reference OFFSET.
19441 On entry *REF_CU is the CU of the source die referencing OFFSET.
19442 On exit *REF_CU is the CU of the result.
19443 Returns NULL if OFFSET is invalid. */
19444
19445 static struct die_info *
19446 follow_die_offset (sect_offset offset, int offset_in_dwz,
19447 struct dwarf2_cu **ref_cu)
19448 {
19449 struct die_info temp_die;
19450 struct dwarf2_cu *target_cu, *cu = *ref_cu;
19451
19452 gdb_assert (cu->per_cu != NULL);
19453
19454 target_cu = cu;
19455
19456 if (cu->per_cu->is_debug_types)
19457 {
19458 /* .debug_types CUs cannot reference anything outside their CU.
19459 If they need to, they have to reference a signatured type via
19460 DW_FORM_ref_sig8. */
19461 if (! offset_in_cu_p (&cu->header, offset))
19462 return NULL;
19463 }
19464 else if (offset_in_dwz != cu->per_cu->is_dwz
19465 || ! offset_in_cu_p (&cu->header, offset))
19466 {
19467 struct dwarf2_per_cu_data *per_cu;
19468
19469 per_cu = dwarf2_find_containing_comp_unit (offset, offset_in_dwz,
19470 cu->objfile);
19471
19472 /* If necessary, add it to the queue and load its DIEs. */
19473 if (maybe_queue_comp_unit (cu, per_cu, cu->language))
19474 load_full_comp_unit (per_cu, cu->language);
19475
19476 target_cu = per_cu->cu;
19477 }
19478 else if (cu->dies == NULL)
19479 {
19480 /* We're loading full DIEs during partial symbol reading. */
19481 gdb_assert (dwarf2_per_objfile->reading_partial_symbols);
19482 load_full_comp_unit (cu->per_cu, language_minimal);
19483 }
19484
19485 *ref_cu = target_cu;
19486 temp_die.offset = offset;
19487 return htab_find_with_hash (target_cu->die_hash, &temp_die, offset.sect_off);
19488 }
19489
19490 /* Follow reference attribute ATTR of SRC_DIE.
19491 On entry *REF_CU is the CU of SRC_DIE.
19492 On exit *REF_CU is the CU of the result. */
19493
19494 static struct die_info *
19495 follow_die_ref (struct die_info *src_die, const struct attribute *attr,
19496 struct dwarf2_cu **ref_cu)
19497 {
19498 sect_offset offset = dwarf2_get_ref_die_offset (attr);
19499 struct dwarf2_cu *cu = *ref_cu;
19500 struct die_info *die;
19501
19502 die = follow_die_offset (offset,
19503 (attr->form == DW_FORM_GNU_ref_alt
19504 || cu->per_cu->is_dwz),
19505 ref_cu);
19506 if (!die)
19507 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
19508 "at 0x%x [in module %s]"),
19509 offset.sect_off, src_die->offset.sect_off,
19510 objfile_name (cu->objfile));
19511
19512 return die;
19513 }
19514
19515 /* Return DWARF block referenced by DW_AT_location of DIE at OFFSET at PER_CU.
19516 Returned value is intended for DW_OP_call*. Returned
19517 dwarf2_locexpr_baton->data has lifetime of PER_CU->OBJFILE. */
19518
19519 struct dwarf2_locexpr_baton
19520 dwarf2_fetch_die_loc_sect_off (sect_offset offset,
19521 struct dwarf2_per_cu_data *per_cu,
19522 CORE_ADDR (*get_frame_pc) (void *baton),
19523 void *baton)
19524 {
19525 struct dwarf2_cu *cu;
19526 struct die_info *die;
19527 struct attribute *attr;
19528 struct dwarf2_locexpr_baton retval;
19529
19530 dw2_setup (per_cu->objfile);
19531
19532 if (per_cu->cu == NULL)
19533 load_cu (per_cu);
19534 cu = per_cu->cu;
19535
19536 die = follow_die_offset (offset, per_cu->is_dwz, &cu);
19537 if (!die)
19538 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
19539 offset.sect_off, objfile_name (per_cu->objfile));
19540
19541 attr = dwarf2_attr (die, DW_AT_location, cu);
19542 if (!attr)
19543 {
19544 /* DWARF: "If there is no such attribute, then there is no effect.".
19545 DATA is ignored if SIZE is 0. */
19546
19547 retval.data = NULL;
19548 retval.size = 0;
19549 }
19550 else if (attr_form_is_section_offset (attr))
19551 {
19552 struct dwarf2_loclist_baton loclist_baton;
19553 CORE_ADDR pc = (*get_frame_pc) (baton);
19554 size_t size;
19555
19556 fill_in_loclist_baton (cu, &loclist_baton, attr);
19557
19558 retval.data = dwarf2_find_location_expression (&loclist_baton,
19559 &size, pc);
19560 retval.size = size;
19561 }
19562 else
19563 {
19564 if (!attr_form_is_block (attr))
19565 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
19566 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
19567 offset.sect_off, objfile_name (per_cu->objfile));
19568
19569 retval.data = DW_BLOCK (attr)->data;
19570 retval.size = DW_BLOCK (attr)->size;
19571 }
19572 retval.per_cu = cu->per_cu;
19573
19574 age_cached_comp_units ();
19575
19576 return retval;
19577 }
19578
19579 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
19580 offset. */
19581
19582 struct dwarf2_locexpr_baton
19583 dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu,
19584 struct dwarf2_per_cu_data *per_cu,
19585 CORE_ADDR (*get_frame_pc) (void *baton),
19586 void *baton)
19587 {
19588 sect_offset offset = { per_cu->offset.sect_off + offset_in_cu.cu_off };
19589
19590 return dwarf2_fetch_die_loc_sect_off (offset, per_cu, get_frame_pc, baton);
19591 }
19592
19593 /* Write a constant of a given type as target-ordered bytes into
19594 OBSTACK. */
19595
19596 static const gdb_byte *
19597 write_constant_as_bytes (struct obstack *obstack,
19598 enum bfd_endian byte_order,
19599 struct type *type,
19600 ULONGEST value,
19601 LONGEST *len)
19602 {
19603 gdb_byte *result;
19604
19605 *len = TYPE_LENGTH (type);
19606 result = obstack_alloc (obstack, *len);
19607 store_unsigned_integer (result, *len, byte_order, value);
19608
19609 return result;
19610 }
19611
19612 /* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a
19613 pointer to the constant bytes and set LEN to the length of the
19614 data. If memory is needed, allocate it on OBSTACK. If the DIE
19615 does not have a DW_AT_const_value, return NULL. */
19616
19617 const gdb_byte *
19618 dwarf2_fetch_constant_bytes (sect_offset offset,
19619 struct dwarf2_per_cu_data *per_cu,
19620 struct obstack *obstack,
19621 LONGEST *len)
19622 {
19623 struct dwarf2_cu *cu;
19624 struct die_info *die;
19625 struct attribute *attr;
19626 const gdb_byte *result = NULL;
19627 struct type *type;
19628 LONGEST value;
19629 enum bfd_endian byte_order;
19630
19631 dw2_setup (per_cu->objfile);
19632
19633 if (per_cu->cu == NULL)
19634 load_cu (per_cu);
19635 cu = per_cu->cu;
19636
19637 die = follow_die_offset (offset, per_cu->is_dwz, &cu);
19638 if (!die)
19639 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
19640 offset.sect_off, objfile_name (per_cu->objfile));
19641
19642
19643 attr = dwarf2_attr (die, DW_AT_const_value, cu);
19644 if (attr == NULL)
19645 return NULL;
19646
19647 byte_order = (bfd_big_endian (per_cu->objfile->obfd)
19648 ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
19649
19650 switch (attr->form)
19651 {
19652 case DW_FORM_addr:
19653 case DW_FORM_GNU_addr_index:
19654 {
19655 gdb_byte *tem;
19656
19657 *len = cu->header.addr_size;
19658 tem = obstack_alloc (obstack, *len);
19659 store_unsigned_integer (tem, *len, byte_order, DW_ADDR (attr));
19660 result = tem;
19661 }
19662 break;
19663 case DW_FORM_string:
19664 case DW_FORM_strp:
19665 case DW_FORM_GNU_str_index:
19666 case DW_FORM_GNU_strp_alt:
19667 /* DW_STRING is already allocated on the objfile obstack, point
19668 directly to it. */
19669 result = (const gdb_byte *) DW_STRING (attr);
19670 *len = strlen (DW_STRING (attr));
19671 break;
19672 case DW_FORM_block1:
19673 case DW_FORM_block2:
19674 case DW_FORM_block4:
19675 case DW_FORM_block:
19676 case DW_FORM_exprloc:
19677 result = DW_BLOCK (attr)->data;
19678 *len = DW_BLOCK (attr)->size;
19679 break;
19680
19681 /* The DW_AT_const_value attributes are supposed to carry the
19682 symbol's value "represented as it would be on the target
19683 architecture." By the time we get here, it's already been
19684 converted to host endianness, so we just need to sign- or
19685 zero-extend it as appropriate. */
19686 case DW_FORM_data1:
19687 type = die_type (die, cu);
19688 result = dwarf2_const_value_data (attr, obstack, cu, &value, 8);
19689 if (result == NULL)
19690 result = write_constant_as_bytes (obstack, byte_order,
19691 type, value, len);
19692 break;
19693 case DW_FORM_data2:
19694 type = die_type (die, cu);
19695 result = dwarf2_const_value_data (attr, obstack, cu, &value, 16);
19696 if (result == NULL)
19697 result = write_constant_as_bytes (obstack, byte_order,
19698 type, value, len);
19699 break;
19700 case DW_FORM_data4:
19701 type = die_type (die, cu);
19702 result = dwarf2_const_value_data (attr, obstack, cu, &value, 32);
19703 if (result == NULL)
19704 result = write_constant_as_bytes (obstack, byte_order,
19705 type, value, len);
19706 break;
19707 case DW_FORM_data8:
19708 type = die_type (die, cu);
19709 result = dwarf2_const_value_data (attr, obstack, cu, &value, 64);
19710 if (result == NULL)
19711 result = write_constant_as_bytes (obstack, byte_order,
19712 type, value, len);
19713 break;
19714
19715 case DW_FORM_sdata:
19716 type = die_type (die, cu);
19717 result = write_constant_as_bytes (obstack, byte_order,
19718 type, DW_SND (attr), len);
19719 break;
19720
19721 case DW_FORM_udata:
19722 type = die_type (die, cu);
19723 result = write_constant_as_bytes (obstack, byte_order,
19724 type, DW_UNSND (attr), len);
19725 break;
19726
19727 default:
19728 complaint (&symfile_complaints,
19729 _("unsupported const value attribute form: '%s'"),
19730 dwarf_form_name (attr->form));
19731 break;
19732 }
19733
19734 return result;
19735 }
19736
19737 /* Return the type of the DIE at DIE_OFFSET in the CU named by
19738 PER_CU. */
19739
19740 struct type *
19741 dwarf2_get_die_type (cu_offset die_offset,
19742 struct dwarf2_per_cu_data *per_cu)
19743 {
19744 sect_offset die_offset_sect;
19745
19746 dw2_setup (per_cu->objfile);
19747
19748 die_offset_sect.sect_off = per_cu->offset.sect_off + die_offset.cu_off;
19749 return get_die_type_at_offset (die_offset_sect, per_cu);
19750 }
19751
19752 /* Follow type unit SIG_TYPE referenced by SRC_DIE.
19753 On entry *REF_CU is the CU of SRC_DIE.
19754 On exit *REF_CU is the CU of the result.
19755 Returns NULL if the referenced DIE isn't found. */
19756
19757 static struct die_info *
19758 follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type,
19759 struct dwarf2_cu **ref_cu)
19760 {
19761 struct objfile *objfile = (*ref_cu)->objfile;
19762 struct die_info temp_die;
19763 struct dwarf2_cu *sig_cu;
19764 struct die_info *die;
19765
19766 /* While it might be nice to assert sig_type->type == NULL here,
19767 we can get here for DW_AT_imported_declaration where we need
19768 the DIE not the type. */
19769
19770 /* If necessary, add it to the queue and load its DIEs. */
19771
19772 if (maybe_queue_comp_unit (*ref_cu, &sig_type->per_cu, language_minimal))
19773 read_signatured_type (sig_type);
19774
19775 sig_cu = sig_type->per_cu.cu;
19776 gdb_assert (sig_cu != NULL);
19777 gdb_assert (sig_type->type_offset_in_section.sect_off != 0);
19778 temp_die.offset = sig_type->type_offset_in_section;
19779 die = htab_find_with_hash (sig_cu->die_hash, &temp_die,
19780 temp_die.offset.sect_off);
19781 if (die)
19782 {
19783 /* For .gdb_index version 7 keep track of included TUs.
19784 http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
19785 if (dwarf2_per_objfile->index_table != NULL
19786 && dwarf2_per_objfile->index_table->version <= 7)
19787 {
19788 VEC_safe_push (dwarf2_per_cu_ptr,
19789 (*ref_cu)->per_cu->imported_symtabs,
19790 sig_cu->per_cu);
19791 }
19792
19793 *ref_cu = sig_cu;
19794 return die;
19795 }
19796
19797 return NULL;
19798 }
19799
19800 /* Follow signatured type referenced by ATTR in SRC_DIE.
19801 On entry *REF_CU is the CU of SRC_DIE.
19802 On exit *REF_CU is the CU of the result.
19803 The result is the DIE of the type.
19804 If the referenced type cannot be found an error is thrown. */
19805
19806 static struct die_info *
19807 follow_die_sig (struct die_info *src_die, const struct attribute *attr,
19808 struct dwarf2_cu **ref_cu)
19809 {
19810 ULONGEST signature = DW_SIGNATURE (attr);
19811 struct signatured_type *sig_type;
19812 struct die_info *die;
19813
19814 gdb_assert (attr->form == DW_FORM_ref_sig8);
19815
19816 sig_type = lookup_signatured_type (*ref_cu, signature);
19817 /* sig_type will be NULL if the signatured type is missing from
19818 the debug info. */
19819 if (sig_type == NULL)
19820 {
19821 error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
19822 " from DIE at 0x%x [in module %s]"),
19823 hex_string (signature), src_die->offset.sect_off,
19824 objfile_name ((*ref_cu)->objfile));
19825 }
19826
19827 die = follow_die_sig_1 (src_die, sig_type, ref_cu);
19828 if (die == NULL)
19829 {
19830 dump_die_for_error (src_die);
19831 error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
19832 " from DIE at 0x%x [in module %s]"),
19833 hex_string (signature), src_die->offset.sect_off,
19834 objfile_name ((*ref_cu)->objfile));
19835 }
19836
19837 return die;
19838 }
19839
19840 /* Get the type specified by SIGNATURE referenced in DIE/CU,
19841 reading in and processing the type unit if necessary. */
19842
19843 static struct type *
19844 get_signatured_type (struct die_info *die, ULONGEST signature,
19845 struct dwarf2_cu *cu)
19846 {
19847 struct signatured_type *sig_type;
19848 struct dwarf2_cu *type_cu;
19849 struct die_info *type_die;
19850 struct type *type;
19851
19852 sig_type = lookup_signatured_type (cu, signature);
19853 /* sig_type will be NULL if the signatured type is missing from
19854 the debug info. */
19855 if (sig_type == NULL)
19856 {
19857 complaint (&symfile_complaints,
19858 _("Dwarf Error: Cannot find signatured DIE %s referenced"
19859 " from DIE at 0x%x [in module %s]"),
19860 hex_string (signature), die->offset.sect_off,
19861 objfile_name (dwarf2_per_objfile->objfile));
19862 return build_error_marker_type (cu, die);
19863 }
19864
19865 /* If we already know the type we're done. */
19866 if (sig_type->type != NULL)
19867 return sig_type->type;
19868
19869 type_cu = cu;
19870 type_die = follow_die_sig_1 (die, sig_type, &type_cu);
19871 if (type_die != NULL)
19872 {
19873 /* N.B. We need to call get_die_type to ensure only one type for this DIE
19874 is created. This is important, for example, because for c++ classes
19875 we need TYPE_NAME set which is only done by new_symbol. Blech. */
19876 type = read_type_die (type_die, type_cu);
19877 if (type == NULL)
19878 {
19879 complaint (&symfile_complaints,
19880 _("Dwarf Error: Cannot build signatured type %s"
19881 " referenced from DIE at 0x%x [in module %s]"),
19882 hex_string (signature), die->offset.sect_off,
19883 objfile_name (dwarf2_per_objfile->objfile));
19884 type = build_error_marker_type (cu, die);
19885 }
19886 }
19887 else
19888 {
19889 complaint (&symfile_complaints,
19890 _("Dwarf Error: Problem reading signatured DIE %s referenced"
19891 " from DIE at 0x%x [in module %s]"),
19892 hex_string (signature), die->offset.sect_off,
19893 objfile_name (dwarf2_per_objfile->objfile));
19894 type = build_error_marker_type (cu, die);
19895 }
19896 sig_type->type = type;
19897
19898 return type;
19899 }
19900
19901 /* Get the type specified by the DW_AT_signature ATTR in DIE/CU,
19902 reading in and processing the type unit if necessary. */
19903
19904 static struct type *
19905 get_DW_AT_signature_type (struct die_info *die, const struct attribute *attr,
19906 struct dwarf2_cu *cu) /* ARI: editCase function */
19907 {
19908 /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */
19909 if (attr_form_is_ref (attr))
19910 {
19911 struct dwarf2_cu *type_cu = cu;
19912 struct die_info *type_die = follow_die_ref (die, attr, &type_cu);
19913
19914 return read_type_die (type_die, type_cu);
19915 }
19916 else if (attr->form == DW_FORM_ref_sig8)
19917 {
19918 return get_signatured_type (die, DW_SIGNATURE (attr), cu);
19919 }
19920 else
19921 {
19922 complaint (&symfile_complaints,
19923 _("Dwarf Error: DW_AT_signature has bad form %s in DIE"
19924 " at 0x%x [in module %s]"),
19925 dwarf_form_name (attr->form), die->offset.sect_off,
19926 objfile_name (dwarf2_per_objfile->objfile));
19927 return build_error_marker_type (cu, die);
19928 }
19929 }
19930
19931 /* Load the DIEs associated with type unit PER_CU into memory. */
19932
19933 static void
19934 load_full_type_unit (struct dwarf2_per_cu_data *per_cu)
19935 {
19936 struct signatured_type *sig_type;
19937
19938 /* Caller is responsible for ensuring type_unit_groups don't get here. */
19939 gdb_assert (! IS_TYPE_UNIT_GROUP (per_cu));
19940
19941 /* We have the per_cu, but we need the signatured_type.
19942 Fortunately this is an easy translation. */
19943 gdb_assert (per_cu->is_debug_types);
19944 sig_type = (struct signatured_type *) per_cu;
19945
19946 gdb_assert (per_cu->cu == NULL);
19947
19948 read_signatured_type (sig_type);
19949
19950 gdb_assert (per_cu->cu != NULL);
19951 }
19952
19953 /* die_reader_func for read_signatured_type.
19954 This is identical to load_full_comp_unit_reader,
19955 but is kept separate for now. */
19956
19957 static void
19958 read_signatured_type_reader (const struct die_reader_specs *reader,
19959 const gdb_byte *info_ptr,
19960 struct die_info *comp_unit_die,
19961 int has_children,
19962 void *data)
19963 {
19964 struct dwarf2_cu *cu = reader->cu;
19965
19966 gdb_assert (cu->die_hash == NULL);
19967 cu->die_hash =
19968 htab_create_alloc_ex (cu->header.length / 12,
19969 die_hash,
19970 die_eq,
19971 NULL,
19972 &cu->comp_unit_obstack,
19973 hashtab_obstack_allocate,
19974 dummy_obstack_deallocate);
19975
19976 if (has_children)
19977 comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
19978 &info_ptr, comp_unit_die);
19979 cu->dies = comp_unit_die;
19980 /* comp_unit_die is not stored in die_hash, no need. */
19981
19982 /* We try not to read any attributes in this function, because not
19983 all CUs needed for references have been loaded yet, and symbol
19984 table processing isn't initialized. But we have to set the CU language,
19985 or we won't be able to build types correctly.
19986 Similarly, if we do not read the producer, we can not apply
19987 producer-specific interpretation. */
19988 prepare_one_comp_unit (cu, cu->dies, language_minimal);
19989 }
19990
19991 /* Read in a signatured type and build its CU and DIEs.
19992 If the type is a stub for the real type in a DWO file,
19993 read in the real type from the DWO file as well. */
19994
19995 static void
19996 read_signatured_type (struct signatured_type *sig_type)
19997 {
19998 struct dwarf2_per_cu_data *per_cu = &sig_type->per_cu;
19999
20000 gdb_assert (per_cu->is_debug_types);
20001 gdb_assert (per_cu->cu == NULL);
20002
20003 init_cutu_and_read_dies (per_cu, NULL, 0, 1,
20004 read_signatured_type_reader, NULL);
20005 sig_type->per_cu.tu_read = 1;
20006 }
20007
20008 /* Decode simple location descriptions.
20009 Given a pointer to a dwarf block that defines a location, compute
20010 the location and return the value.
20011
20012 NOTE drow/2003-11-18: This function is called in two situations
20013 now: for the address of static or global variables (partial symbols
20014 only) and for offsets into structures which are expected to be
20015 (more or less) constant. The partial symbol case should go away,
20016 and only the constant case should remain. That will let this
20017 function complain more accurately. A few special modes are allowed
20018 without complaint for global variables (for instance, global
20019 register values and thread-local values).
20020
20021 A location description containing no operations indicates that the
20022 object is optimized out. The return value is 0 for that case.
20023 FIXME drow/2003-11-16: No callers check for this case any more; soon all
20024 callers will only want a very basic result and this can become a
20025 complaint.
20026
20027 Note that stack[0] is unused except as a default error return. */
20028
20029 static CORE_ADDR
20030 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
20031 {
20032 struct objfile *objfile = cu->objfile;
20033 size_t i;
20034 size_t size = blk->size;
20035 const gdb_byte *data = blk->data;
20036 CORE_ADDR stack[64];
20037 int stacki;
20038 unsigned int bytes_read, unsnd;
20039 gdb_byte op;
20040
20041 i = 0;
20042 stacki = 0;
20043 stack[stacki] = 0;
20044 stack[++stacki] = 0;
20045
20046 while (i < size)
20047 {
20048 op = data[i++];
20049 switch (op)
20050 {
20051 case DW_OP_lit0:
20052 case DW_OP_lit1:
20053 case DW_OP_lit2:
20054 case DW_OP_lit3:
20055 case DW_OP_lit4:
20056 case DW_OP_lit5:
20057 case DW_OP_lit6:
20058 case DW_OP_lit7:
20059 case DW_OP_lit8:
20060 case DW_OP_lit9:
20061 case DW_OP_lit10:
20062 case DW_OP_lit11:
20063 case DW_OP_lit12:
20064 case DW_OP_lit13:
20065 case DW_OP_lit14:
20066 case DW_OP_lit15:
20067 case DW_OP_lit16:
20068 case DW_OP_lit17:
20069 case DW_OP_lit18:
20070 case DW_OP_lit19:
20071 case DW_OP_lit20:
20072 case DW_OP_lit21:
20073 case DW_OP_lit22:
20074 case DW_OP_lit23:
20075 case DW_OP_lit24:
20076 case DW_OP_lit25:
20077 case DW_OP_lit26:
20078 case DW_OP_lit27:
20079 case DW_OP_lit28:
20080 case DW_OP_lit29:
20081 case DW_OP_lit30:
20082 case DW_OP_lit31:
20083 stack[++stacki] = op - DW_OP_lit0;
20084 break;
20085
20086 case DW_OP_reg0:
20087 case DW_OP_reg1:
20088 case DW_OP_reg2:
20089 case DW_OP_reg3:
20090 case DW_OP_reg4:
20091 case DW_OP_reg5:
20092 case DW_OP_reg6:
20093 case DW_OP_reg7:
20094 case DW_OP_reg8:
20095 case DW_OP_reg9:
20096 case DW_OP_reg10:
20097 case DW_OP_reg11:
20098 case DW_OP_reg12:
20099 case DW_OP_reg13:
20100 case DW_OP_reg14:
20101 case DW_OP_reg15:
20102 case DW_OP_reg16:
20103 case DW_OP_reg17:
20104 case DW_OP_reg18:
20105 case DW_OP_reg19:
20106 case DW_OP_reg20:
20107 case DW_OP_reg21:
20108 case DW_OP_reg22:
20109 case DW_OP_reg23:
20110 case DW_OP_reg24:
20111 case DW_OP_reg25:
20112 case DW_OP_reg26:
20113 case DW_OP_reg27:
20114 case DW_OP_reg28:
20115 case DW_OP_reg29:
20116 case DW_OP_reg30:
20117 case DW_OP_reg31:
20118 stack[++stacki] = op - DW_OP_reg0;
20119 if (i < size)
20120 dwarf2_complex_location_expr_complaint ();
20121 break;
20122
20123 case DW_OP_regx:
20124 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
20125 i += bytes_read;
20126 stack[++stacki] = unsnd;
20127 if (i < size)
20128 dwarf2_complex_location_expr_complaint ();
20129 break;
20130
20131 case DW_OP_addr:
20132 stack[++stacki] = read_address (objfile->obfd, &data[i],
20133 cu, &bytes_read);
20134 i += bytes_read;
20135 break;
20136
20137 case DW_OP_const1u:
20138 stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
20139 i += 1;
20140 break;
20141
20142 case DW_OP_const1s:
20143 stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
20144 i += 1;
20145 break;
20146
20147 case DW_OP_const2u:
20148 stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
20149 i += 2;
20150 break;
20151
20152 case DW_OP_const2s:
20153 stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
20154 i += 2;
20155 break;
20156
20157 case DW_OP_const4u:
20158 stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
20159 i += 4;
20160 break;
20161
20162 case DW_OP_const4s:
20163 stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
20164 i += 4;
20165 break;
20166
20167 case DW_OP_const8u:
20168 stack[++stacki] = read_8_bytes (objfile->obfd, &data[i]);
20169 i += 8;
20170 break;
20171
20172 case DW_OP_constu:
20173 stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
20174 &bytes_read);
20175 i += bytes_read;
20176 break;
20177
20178 case DW_OP_consts:
20179 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
20180 i += bytes_read;
20181 break;
20182
20183 case DW_OP_dup:
20184 stack[stacki + 1] = stack[stacki];
20185 stacki++;
20186 break;
20187
20188 case DW_OP_plus:
20189 stack[stacki - 1] += stack[stacki];
20190 stacki--;
20191 break;
20192
20193 case DW_OP_plus_uconst:
20194 stack[stacki] += read_unsigned_leb128 (NULL, (data + i),
20195 &bytes_read);
20196 i += bytes_read;
20197 break;
20198
20199 case DW_OP_minus:
20200 stack[stacki - 1] -= stack[stacki];
20201 stacki--;
20202 break;
20203
20204 case DW_OP_deref:
20205 /* If we're not the last op, then we definitely can't encode
20206 this using GDB's address_class enum. This is valid for partial
20207 global symbols, although the variable's address will be bogus
20208 in the psymtab. */
20209 if (i < size)
20210 dwarf2_complex_location_expr_complaint ();
20211 break;
20212
20213 case DW_OP_GNU_push_tls_address:
20214 /* The top of the stack has the offset from the beginning
20215 of the thread control block at which the variable is located. */
20216 /* Nothing should follow this operator, so the top of stack would
20217 be returned. */
20218 /* This is valid for partial global symbols, but the variable's
20219 address will be bogus in the psymtab. Make it always at least
20220 non-zero to not look as a variable garbage collected by linker
20221 which have DW_OP_addr 0. */
20222 if (i < size)
20223 dwarf2_complex_location_expr_complaint ();
20224 stack[stacki]++;
20225 break;
20226
20227 case DW_OP_GNU_uninit:
20228 break;
20229
20230 case DW_OP_GNU_addr_index:
20231 case DW_OP_GNU_const_index:
20232 stack[++stacki] = read_addr_index_from_leb128 (cu, &data[i],
20233 &bytes_read);
20234 i += bytes_read;
20235 break;
20236
20237 default:
20238 {
20239 const char *name = get_DW_OP_name (op);
20240
20241 if (name)
20242 complaint (&symfile_complaints, _("unsupported stack op: '%s'"),
20243 name);
20244 else
20245 complaint (&symfile_complaints, _("unsupported stack op: '%02x'"),
20246 op);
20247 }
20248
20249 return (stack[stacki]);
20250 }
20251
20252 /* Enforce maximum stack depth of SIZE-1 to avoid writing
20253 outside of the allocated space. Also enforce minimum>0. */
20254 if (stacki >= ARRAY_SIZE (stack) - 1)
20255 {
20256 complaint (&symfile_complaints,
20257 _("location description stack overflow"));
20258 return 0;
20259 }
20260
20261 if (stacki <= 0)
20262 {
20263 complaint (&symfile_complaints,
20264 _("location description stack underflow"));
20265 return 0;
20266 }
20267 }
20268 return (stack[stacki]);
20269 }
20270
20271 /* memory allocation interface */
20272
20273 static struct dwarf_block *
20274 dwarf_alloc_block (struct dwarf2_cu *cu)
20275 {
20276 struct dwarf_block *blk;
20277
20278 blk = (struct dwarf_block *)
20279 obstack_alloc (&cu->comp_unit_obstack, sizeof (struct dwarf_block));
20280 return (blk);
20281 }
20282
20283 static struct die_info *
20284 dwarf_alloc_die (struct dwarf2_cu *cu, int num_attrs)
20285 {
20286 struct die_info *die;
20287 size_t size = sizeof (struct die_info);
20288
20289 if (num_attrs > 1)
20290 size += (num_attrs - 1) * sizeof (struct attribute);
20291
20292 die = (struct die_info *) obstack_alloc (&cu->comp_unit_obstack, size);
20293 memset (die, 0, sizeof (struct die_info));
20294 return (die);
20295 }
20296
20297 \f
20298 /* Macro support. */
20299
20300 /* Return file name relative to the compilation directory of file number I in
20301 *LH's file name table. The result is allocated using xmalloc; the caller is
20302 responsible for freeing it. */
20303
20304 static char *
20305 file_file_name (int file, struct line_header *lh)
20306 {
20307 /* Is the file number a valid index into the line header's file name
20308 table? Remember that file numbers start with one, not zero. */
20309 if (1 <= file && file <= lh->num_file_names)
20310 {
20311 struct file_entry *fe = &lh->file_names[file - 1];
20312
20313 if (IS_ABSOLUTE_PATH (fe->name) || fe->dir_index == 0)
20314 return xstrdup (fe->name);
20315 return concat (lh->include_dirs[fe->dir_index - 1], SLASH_STRING,
20316 fe->name, NULL);
20317 }
20318 else
20319 {
20320 /* The compiler produced a bogus file number. We can at least
20321 record the macro definitions made in the file, even if we
20322 won't be able to find the file by name. */
20323 char fake_name[80];
20324
20325 xsnprintf (fake_name, sizeof (fake_name),
20326 "<bad macro file number %d>", file);
20327
20328 complaint (&symfile_complaints,
20329 _("bad file number in macro information (%d)"),
20330 file);
20331
20332 return xstrdup (fake_name);
20333 }
20334 }
20335
20336 /* Return the full name of file number I in *LH's file name table.
20337 Use COMP_DIR as the name of the current directory of the
20338 compilation. The result is allocated using xmalloc; the caller is
20339 responsible for freeing it. */
20340 static char *
20341 file_full_name (int file, struct line_header *lh, const char *comp_dir)
20342 {
20343 /* Is the file number a valid index into the line header's file name
20344 table? Remember that file numbers start with one, not zero. */
20345 if (1 <= file && file <= lh->num_file_names)
20346 {
20347 char *relative = file_file_name (file, lh);
20348
20349 if (IS_ABSOLUTE_PATH (relative) || comp_dir == NULL)
20350 return relative;
20351 return reconcat (relative, comp_dir, SLASH_STRING, relative, NULL);
20352 }
20353 else
20354 return file_file_name (file, lh);
20355 }
20356
20357
20358 static struct macro_source_file *
20359 macro_start_file (int file, int line,
20360 struct macro_source_file *current_file,
20361 const char *comp_dir,
20362 struct line_header *lh, struct objfile *objfile)
20363 {
20364 /* File name relative to the compilation directory of this source file. */
20365 char *file_name = file_file_name (file, lh);
20366
20367 if (! current_file)
20368 {
20369 /* Note: We don't create a macro table for this compilation unit
20370 at all until we actually get a filename. */
20371 struct macro_table *macro_table = get_macro_table (objfile, comp_dir);
20372
20373 /* If we have no current file, then this must be the start_file
20374 directive for the compilation unit's main source file. */
20375 current_file = macro_set_main (macro_table, file_name);
20376 macro_define_special (macro_table);
20377 }
20378 else
20379 current_file = macro_include (current_file, line, file_name);
20380
20381 xfree (file_name);
20382
20383 return current_file;
20384 }
20385
20386
20387 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
20388 followed by a null byte. */
20389 static char *
20390 copy_string (const char *buf, int len)
20391 {
20392 char *s = xmalloc (len + 1);
20393
20394 memcpy (s, buf, len);
20395 s[len] = '\0';
20396 return s;
20397 }
20398
20399
20400 static const char *
20401 consume_improper_spaces (const char *p, const char *body)
20402 {
20403 if (*p == ' ')
20404 {
20405 complaint (&symfile_complaints,
20406 _("macro definition contains spaces "
20407 "in formal argument list:\n`%s'"),
20408 body);
20409
20410 while (*p == ' ')
20411 p++;
20412 }
20413
20414 return p;
20415 }
20416
20417
20418 static void
20419 parse_macro_definition (struct macro_source_file *file, int line,
20420 const char *body)
20421 {
20422 const char *p;
20423
20424 /* The body string takes one of two forms. For object-like macro
20425 definitions, it should be:
20426
20427 <macro name> " " <definition>
20428
20429 For function-like macro definitions, it should be:
20430
20431 <macro name> "() " <definition>
20432 or
20433 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
20434
20435 Spaces may appear only where explicitly indicated, and in the
20436 <definition>.
20437
20438 The Dwarf 2 spec says that an object-like macro's name is always
20439 followed by a space, but versions of GCC around March 2002 omit
20440 the space when the macro's definition is the empty string.
20441
20442 The Dwarf 2 spec says that there should be no spaces between the
20443 formal arguments in a function-like macro's formal argument list,
20444 but versions of GCC around March 2002 include spaces after the
20445 commas. */
20446
20447
20448 /* Find the extent of the macro name. The macro name is terminated
20449 by either a space or null character (for an object-like macro) or
20450 an opening paren (for a function-like macro). */
20451 for (p = body; *p; p++)
20452 if (*p == ' ' || *p == '(')
20453 break;
20454
20455 if (*p == ' ' || *p == '\0')
20456 {
20457 /* It's an object-like macro. */
20458 int name_len = p - body;
20459 char *name = copy_string (body, name_len);
20460 const char *replacement;
20461
20462 if (*p == ' ')
20463 replacement = body + name_len + 1;
20464 else
20465 {
20466 dwarf2_macro_malformed_definition_complaint (body);
20467 replacement = body + name_len;
20468 }
20469
20470 macro_define_object (file, line, name, replacement);
20471
20472 xfree (name);
20473 }
20474 else if (*p == '(')
20475 {
20476 /* It's a function-like macro. */
20477 char *name = copy_string (body, p - body);
20478 int argc = 0;
20479 int argv_size = 1;
20480 char **argv = xmalloc (argv_size * sizeof (*argv));
20481
20482 p++;
20483
20484 p = consume_improper_spaces (p, body);
20485
20486 /* Parse the formal argument list. */
20487 while (*p && *p != ')')
20488 {
20489 /* Find the extent of the current argument name. */
20490 const char *arg_start = p;
20491
20492 while (*p && *p != ',' && *p != ')' && *p != ' ')
20493 p++;
20494
20495 if (! *p || p == arg_start)
20496 dwarf2_macro_malformed_definition_complaint (body);
20497 else
20498 {
20499 /* Make sure argv has room for the new argument. */
20500 if (argc >= argv_size)
20501 {
20502 argv_size *= 2;
20503 argv = xrealloc (argv, argv_size * sizeof (*argv));
20504 }
20505
20506 argv[argc++] = copy_string (arg_start, p - arg_start);
20507 }
20508
20509 p = consume_improper_spaces (p, body);
20510
20511 /* Consume the comma, if present. */
20512 if (*p == ',')
20513 {
20514 p++;
20515
20516 p = consume_improper_spaces (p, body);
20517 }
20518 }
20519
20520 if (*p == ')')
20521 {
20522 p++;
20523
20524 if (*p == ' ')
20525 /* Perfectly formed definition, no complaints. */
20526 macro_define_function (file, line, name,
20527 argc, (const char **) argv,
20528 p + 1);
20529 else if (*p == '\0')
20530 {
20531 /* Complain, but do define it. */
20532 dwarf2_macro_malformed_definition_complaint (body);
20533 macro_define_function (file, line, name,
20534 argc, (const char **) argv,
20535 p);
20536 }
20537 else
20538 /* Just complain. */
20539 dwarf2_macro_malformed_definition_complaint (body);
20540 }
20541 else
20542 /* Just complain. */
20543 dwarf2_macro_malformed_definition_complaint (body);
20544
20545 xfree (name);
20546 {
20547 int i;
20548
20549 for (i = 0; i < argc; i++)
20550 xfree (argv[i]);
20551 }
20552 xfree (argv);
20553 }
20554 else
20555 dwarf2_macro_malformed_definition_complaint (body);
20556 }
20557
20558 /* Skip some bytes from BYTES according to the form given in FORM.
20559 Returns the new pointer. */
20560
20561 static const gdb_byte *
20562 skip_form_bytes (bfd *abfd, const gdb_byte *bytes, const gdb_byte *buffer_end,
20563 enum dwarf_form form,
20564 unsigned int offset_size,
20565 struct dwarf2_section_info *section)
20566 {
20567 unsigned int bytes_read;
20568
20569 switch (form)
20570 {
20571 case DW_FORM_data1:
20572 case DW_FORM_flag:
20573 ++bytes;
20574 break;
20575
20576 case DW_FORM_data2:
20577 bytes += 2;
20578 break;
20579
20580 case DW_FORM_data4:
20581 bytes += 4;
20582 break;
20583
20584 case DW_FORM_data8:
20585 bytes += 8;
20586 break;
20587
20588 case DW_FORM_string:
20589 read_direct_string (abfd, bytes, &bytes_read);
20590 bytes += bytes_read;
20591 break;
20592
20593 case DW_FORM_sec_offset:
20594 case DW_FORM_strp:
20595 case DW_FORM_GNU_strp_alt:
20596 bytes += offset_size;
20597 break;
20598
20599 case DW_FORM_block:
20600 bytes += read_unsigned_leb128 (abfd, bytes, &bytes_read);
20601 bytes += bytes_read;
20602 break;
20603
20604 case DW_FORM_block1:
20605 bytes += 1 + read_1_byte (abfd, bytes);
20606 break;
20607 case DW_FORM_block2:
20608 bytes += 2 + read_2_bytes (abfd, bytes);
20609 break;
20610 case DW_FORM_block4:
20611 bytes += 4 + read_4_bytes (abfd, bytes);
20612 break;
20613
20614 case DW_FORM_sdata:
20615 case DW_FORM_udata:
20616 case DW_FORM_GNU_addr_index:
20617 case DW_FORM_GNU_str_index:
20618 bytes = gdb_skip_leb128 (bytes, buffer_end);
20619 if (bytes == NULL)
20620 {
20621 dwarf2_section_buffer_overflow_complaint (section);
20622 return NULL;
20623 }
20624 break;
20625
20626 default:
20627 {
20628 complain:
20629 complaint (&symfile_complaints,
20630 _("invalid form 0x%x in `%s'"),
20631 form, get_section_name (section));
20632 return NULL;
20633 }
20634 }
20635
20636 return bytes;
20637 }
20638
20639 /* A helper for dwarf_decode_macros that handles skipping an unknown
20640 opcode. Returns an updated pointer to the macro data buffer; or,
20641 on error, issues a complaint and returns NULL. */
20642
20643 static const gdb_byte *
20644 skip_unknown_opcode (unsigned int opcode,
20645 const gdb_byte **opcode_definitions,
20646 const gdb_byte *mac_ptr, const gdb_byte *mac_end,
20647 bfd *abfd,
20648 unsigned int offset_size,
20649 struct dwarf2_section_info *section)
20650 {
20651 unsigned int bytes_read, i;
20652 unsigned long arg;
20653 const gdb_byte *defn;
20654
20655 if (opcode_definitions[opcode] == NULL)
20656 {
20657 complaint (&symfile_complaints,
20658 _("unrecognized DW_MACFINO opcode 0x%x"),
20659 opcode);
20660 return NULL;
20661 }
20662
20663 defn = opcode_definitions[opcode];
20664 arg = read_unsigned_leb128 (abfd, defn, &bytes_read);
20665 defn += bytes_read;
20666
20667 for (i = 0; i < arg; ++i)
20668 {
20669 mac_ptr = skip_form_bytes (abfd, mac_ptr, mac_end, defn[i], offset_size,
20670 section);
20671 if (mac_ptr == NULL)
20672 {
20673 /* skip_form_bytes already issued the complaint. */
20674 return NULL;
20675 }
20676 }
20677
20678 return mac_ptr;
20679 }
20680
20681 /* A helper function which parses the header of a macro section.
20682 If the macro section is the extended (for now called "GNU") type,
20683 then this updates *OFFSET_SIZE. Returns a pointer to just after
20684 the header, or issues a complaint and returns NULL on error. */
20685
20686 static const gdb_byte *
20687 dwarf_parse_macro_header (const gdb_byte **opcode_definitions,
20688 bfd *abfd,
20689 const gdb_byte *mac_ptr,
20690 unsigned int *offset_size,
20691 int section_is_gnu)
20692 {
20693 memset (opcode_definitions, 0, 256 * sizeof (gdb_byte *));
20694
20695 if (section_is_gnu)
20696 {
20697 unsigned int version, flags;
20698
20699 version = read_2_bytes (abfd, mac_ptr);
20700 if (version != 4)
20701 {
20702 complaint (&symfile_complaints,
20703 _("unrecognized version `%d' in .debug_macro section"),
20704 version);
20705 return NULL;
20706 }
20707 mac_ptr += 2;
20708
20709 flags = read_1_byte (abfd, mac_ptr);
20710 ++mac_ptr;
20711 *offset_size = (flags & 1) ? 8 : 4;
20712
20713 if ((flags & 2) != 0)
20714 /* We don't need the line table offset. */
20715 mac_ptr += *offset_size;
20716
20717 /* Vendor opcode descriptions. */
20718 if ((flags & 4) != 0)
20719 {
20720 unsigned int i, count;
20721
20722 count = read_1_byte (abfd, mac_ptr);
20723 ++mac_ptr;
20724 for (i = 0; i < count; ++i)
20725 {
20726 unsigned int opcode, bytes_read;
20727 unsigned long arg;
20728
20729 opcode = read_1_byte (abfd, mac_ptr);
20730 ++mac_ptr;
20731 opcode_definitions[opcode] = mac_ptr;
20732 arg = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20733 mac_ptr += bytes_read;
20734 mac_ptr += arg;
20735 }
20736 }
20737 }
20738
20739 return mac_ptr;
20740 }
20741
20742 /* A helper for dwarf_decode_macros that handles the GNU extensions,
20743 including DW_MACRO_GNU_transparent_include. */
20744
20745 static void
20746 dwarf_decode_macro_bytes (bfd *abfd,
20747 const gdb_byte *mac_ptr, const gdb_byte *mac_end,
20748 struct macro_source_file *current_file,
20749 struct line_header *lh, const char *comp_dir,
20750 struct dwarf2_section_info *section,
20751 int section_is_gnu, int section_is_dwz,
20752 unsigned int offset_size,
20753 struct objfile *objfile,
20754 htab_t include_hash)
20755 {
20756 enum dwarf_macro_record_type macinfo_type;
20757 int at_commandline;
20758 const gdb_byte *opcode_definitions[256];
20759
20760 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
20761 &offset_size, section_is_gnu);
20762 if (mac_ptr == NULL)
20763 {
20764 /* We already issued a complaint. */
20765 return;
20766 }
20767
20768 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
20769 GDB is still reading the definitions from command line. First
20770 DW_MACINFO_start_file will need to be ignored as it was already executed
20771 to create CURRENT_FILE for the main source holding also the command line
20772 definitions. On first met DW_MACINFO_start_file this flag is reset to
20773 normally execute all the remaining DW_MACINFO_start_file macinfos. */
20774
20775 at_commandline = 1;
20776
20777 do
20778 {
20779 /* Do we at least have room for a macinfo type byte? */
20780 if (mac_ptr >= mac_end)
20781 {
20782 dwarf2_section_buffer_overflow_complaint (section);
20783 break;
20784 }
20785
20786 macinfo_type = read_1_byte (abfd, mac_ptr);
20787 mac_ptr++;
20788
20789 /* Note that we rely on the fact that the corresponding GNU and
20790 DWARF constants are the same. */
20791 switch (macinfo_type)
20792 {
20793 /* A zero macinfo type indicates the end of the macro
20794 information. */
20795 case 0:
20796 break;
20797
20798 case DW_MACRO_GNU_define:
20799 case DW_MACRO_GNU_undef:
20800 case DW_MACRO_GNU_define_indirect:
20801 case DW_MACRO_GNU_undef_indirect:
20802 case DW_MACRO_GNU_define_indirect_alt:
20803 case DW_MACRO_GNU_undef_indirect_alt:
20804 {
20805 unsigned int bytes_read;
20806 int line;
20807 const char *body;
20808 int is_define;
20809
20810 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20811 mac_ptr += bytes_read;
20812
20813 if (macinfo_type == DW_MACRO_GNU_define
20814 || macinfo_type == DW_MACRO_GNU_undef)
20815 {
20816 body = read_direct_string (abfd, mac_ptr, &bytes_read);
20817 mac_ptr += bytes_read;
20818 }
20819 else
20820 {
20821 LONGEST str_offset;
20822
20823 str_offset = read_offset_1 (abfd, mac_ptr, offset_size);
20824 mac_ptr += offset_size;
20825
20826 if (macinfo_type == DW_MACRO_GNU_define_indirect_alt
20827 || macinfo_type == DW_MACRO_GNU_undef_indirect_alt
20828 || section_is_dwz)
20829 {
20830 struct dwz_file *dwz = dwarf2_get_dwz_file ();
20831
20832 body = read_indirect_string_from_dwz (dwz, str_offset);
20833 }
20834 else
20835 body = read_indirect_string_at_offset (abfd, str_offset);
20836 }
20837
20838 is_define = (macinfo_type == DW_MACRO_GNU_define
20839 || macinfo_type == DW_MACRO_GNU_define_indirect
20840 || macinfo_type == DW_MACRO_GNU_define_indirect_alt);
20841 if (! current_file)
20842 {
20843 /* DWARF violation as no main source is present. */
20844 complaint (&symfile_complaints,
20845 _("debug info with no main source gives macro %s "
20846 "on line %d: %s"),
20847 is_define ? _("definition") : _("undefinition"),
20848 line, body);
20849 break;
20850 }
20851 if ((line == 0 && !at_commandline)
20852 || (line != 0 && at_commandline))
20853 complaint (&symfile_complaints,
20854 _("debug info gives %s macro %s with %s line %d: %s"),
20855 at_commandline ? _("command-line") : _("in-file"),
20856 is_define ? _("definition") : _("undefinition"),
20857 line == 0 ? _("zero") : _("non-zero"), line, body);
20858
20859 if (is_define)
20860 parse_macro_definition (current_file, line, body);
20861 else
20862 {
20863 gdb_assert (macinfo_type == DW_MACRO_GNU_undef
20864 || macinfo_type == DW_MACRO_GNU_undef_indirect
20865 || macinfo_type == DW_MACRO_GNU_undef_indirect_alt);
20866 macro_undef (current_file, line, body);
20867 }
20868 }
20869 break;
20870
20871 case DW_MACRO_GNU_start_file:
20872 {
20873 unsigned int bytes_read;
20874 int line, file;
20875
20876 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20877 mac_ptr += bytes_read;
20878 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
20879 mac_ptr += bytes_read;
20880
20881 if ((line == 0 && !at_commandline)
20882 || (line != 0 && at_commandline))
20883 complaint (&symfile_complaints,
20884 _("debug info gives source %d included "
20885 "from %s at %s line %d"),
20886 file, at_commandline ? _("command-line") : _("file"),
20887 line == 0 ? _("zero") : _("non-zero"), line);
20888
20889 if (at_commandline)
20890 {
20891 /* This DW_MACRO_GNU_start_file was executed in the
20892 pass one. */
20893 at_commandline = 0;
20894 }
20895 else
20896 current_file = macro_start_file (file, line,
20897 current_file, comp_dir,
20898 lh, objfile);
20899 }
20900 break;
20901
20902 case DW_MACRO_GNU_end_file:
20903 if (! current_file)
20904 complaint (&symfile_complaints,
20905 _("macro debug info has an unmatched "
20906 "`close_file' directive"));
20907 else
20908 {
20909 current_file = current_file->included_by;
20910 if (! current_file)
20911 {
20912 enum dwarf_macro_record_type next_type;
20913
20914 /* GCC circa March 2002 doesn't produce the zero
20915 type byte marking the end of the compilation
20916 unit. Complain if it's not there, but exit no
20917 matter what. */
20918
20919 /* Do we at least have room for a macinfo type byte? */
20920 if (mac_ptr >= mac_end)
20921 {
20922 dwarf2_section_buffer_overflow_complaint (section);
20923 return;
20924 }
20925
20926 /* We don't increment mac_ptr here, so this is just
20927 a look-ahead. */
20928 next_type = read_1_byte (abfd, mac_ptr);
20929 if (next_type != 0)
20930 complaint (&symfile_complaints,
20931 _("no terminating 0-type entry for "
20932 "macros in `.debug_macinfo' section"));
20933
20934 return;
20935 }
20936 }
20937 break;
20938
20939 case DW_MACRO_GNU_transparent_include:
20940 case DW_MACRO_GNU_transparent_include_alt:
20941 {
20942 LONGEST offset;
20943 void **slot;
20944 bfd *include_bfd = abfd;
20945 struct dwarf2_section_info *include_section = section;
20946 struct dwarf2_section_info alt_section;
20947 const gdb_byte *include_mac_end = mac_end;
20948 int is_dwz = section_is_dwz;
20949 const gdb_byte *new_mac_ptr;
20950
20951 offset = read_offset_1 (abfd, mac_ptr, offset_size);
20952 mac_ptr += offset_size;
20953
20954 if (macinfo_type == DW_MACRO_GNU_transparent_include_alt)
20955 {
20956 struct dwz_file *dwz = dwarf2_get_dwz_file ();
20957
20958 dwarf2_read_section (dwarf2_per_objfile->objfile,
20959 &dwz->macro);
20960
20961 include_section = &dwz->macro;
20962 include_bfd = get_section_bfd_owner (include_section);
20963 include_mac_end = dwz->macro.buffer + dwz->macro.size;
20964 is_dwz = 1;
20965 }
20966
20967 new_mac_ptr = include_section->buffer + offset;
20968 slot = htab_find_slot (include_hash, new_mac_ptr, INSERT);
20969
20970 if (*slot != NULL)
20971 {
20972 /* This has actually happened; see
20973 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
20974 complaint (&symfile_complaints,
20975 _("recursive DW_MACRO_GNU_transparent_include in "
20976 ".debug_macro section"));
20977 }
20978 else
20979 {
20980 *slot = (void *) new_mac_ptr;
20981
20982 dwarf_decode_macro_bytes (include_bfd, new_mac_ptr,
20983 include_mac_end, current_file,
20984 lh, comp_dir,
20985 section, section_is_gnu, is_dwz,
20986 offset_size, objfile, include_hash);
20987
20988 htab_remove_elt (include_hash, (void *) new_mac_ptr);
20989 }
20990 }
20991 break;
20992
20993 case DW_MACINFO_vendor_ext:
20994 if (!section_is_gnu)
20995 {
20996 unsigned int bytes_read;
20997 int constant;
20998
20999 constant = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
21000 mac_ptr += bytes_read;
21001 read_direct_string (abfd, mac_ptr, &bytes_read);
21002 mac_ptr += bytes_read;
21003
21004 /* We don't recognize any vendor extensions. */
21005 break;
21006 }
21007 /* FALLTHROUGH */
21008
21009 default:
21010 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
21011 mac_ptr, mac_end, abfd, offset_size,
21012 section);
21013 if (mac_ptr == NULL)
21014 return;
21015 break;
21016 }
21017 } while (macinfo_type != 0);
21018 }
21019
21020 static void
21021 dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset,
21022 const char *comp_dir, int section_is_gnu)
21023 {
21024 struct objfile *objfile = dwarf2_per_objfile->objfile;
21025 struct line_header *lh = cu->line_header;
21026 bfd *abfd;
21027 const gdb_byte *mac_ptr, *mac_end;
21028 struct macro_source_file *current_file = 0;
21029 enum dwarf_macro_record_type macinfo_type;
21030 unsigned int offset_size = cu->header.offset_size;
21031 const gdb_byte *opcode_definitions[256];
21032 struct cleanup *cleanup;
21033 htab_t include_hash;
21034 void **slot;
21035 struct dwarf2_section_info *section;
21036 const char *section_name;
21037
21038 if (cu->dwo_unit != NULL)
21039 {
21040 if (section_is_gnu)
21041 {
21042 section = &cu->dwo_unit->dwo_file->sections.macro;
21043 section_name = ".debug_macro.dwo";
21044 }
21045 else
21046 {
21047 section = &cu->dwo_unit->dwo_file->sections.macinfo;
21048 section_name = ".debug_macinfo.dwo";
21049 }
21050 }
21051 else
21052 {
21053 if (section_is_gnu)
21054 {
21055 section = &dwarf2_per_objfile->macro;
21056 section_name = ".debug_macro";
21057 }
21058 else
21059 {
21060 section = &dwarf2_per_objfile->macinfo;
21061 section_name = ".debug_macinfo";
21062 }
21063 }
21064
21065 dwarf2_read_section (objfile, section);
21066 if (section->buffer == NULL)
21067 {
21068 complaint (&symfile_complaints, _("missing %s section"), section_name);
21069 return;
21070 }
21071 abfd = get_section_bfd_owner (section);
21072
21073 /* First pass: Find the name of the base filename.
21074 This filename is needed in order to process all macros whose definition
21075 (or undefinition) comes from the command line. These macros are defined
21076 before the first DW_MACINFO_start_file entry, and yet still need to be
21077 associated to the base file.
21078
21079 To determine the base file name, we scan the macro definitions until we
21080 reach the first DW_MACINFO_start_file entry. We then initialize
21081 CURRENT_FILE accordingly so that any macro definition found before the
21082 first DW_MACINFO_start_file can still be associated to the base file. */
21083
21084 mac_ptr = section->buffer + offset;
21085 mac_end = section->buffer + section->size;
21086
21087 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
21088 &offset_size, section_is_gnu);
21089 if (mac_ptr == NULL)
21090 {
21091 /* We already issued a complaint. */
21092 return;
21093 }
21094
21095 do
21096 {
21097 /* Do we at least have room for a macinfo type byte? */
21098 if (mac_ptr >= mac_end)
21099 {
21100 /* Complaint is printed during the second pass as GDB will probably
21101 stop the first pass earlier upon finding
21102 DW_MACINFO_start_file. */
21103 break;
21104 }
21105
21106 macinfo_type = read_1_byte (abfd, mac_ptr);
21107 mac_ptr++;
21108
21109 /* Note that we rely on the fact that the corresponding GNU and
21110 DWARF constants are the same. */
21111 switch (macinfo_type)
21112 {
21113 /* A zero macinfo type indicates the end of the macro
21114 information. */
21115 case 0:
21116 break;
21117
21118 case DW_MACRO_GNU_define:
21119 case DW_MACRO_GNU_undef:
21120 /* Only skip the data by MAC_PTR. */
21121 {
21122 unsigned int bytes_read;
21123
21124 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
21125 mac_ptr += bytes_read;
21126 read_direct_string (abfd, mac_ptr, &bytes_read);
21127 mac_ptr += bytes_read;
21128 }
21129 break;
21130
21131 case DW_MACRO_GNU_start_file:
21132 {
21133 unsigned int bytes_read;
21134 int line, file;
21135
21136 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
21137 mac_ptr += bytes_read;
21138 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
21139 mac_ptr += bytes_read;
21140
21141 current_file = macro_start_file (file, line, current_file,
21142 comp_dir, lh, objfile);
21143 }
21144 break;
21145
21146 case DW_MACRO_GNU_end_file:
21147 /* No data to skip by MAC_PTR. */
21148 break;
21149
21150 case DW_MACRO_GNU_define_indirect:
21151 case DW_MACRO_GNU_undef_indirect:
21152 case DW_MACRO_GNU_define_indirect_alt:
21153 case DW_MACRO_GNU_undef_indirect_alt:
21154 {
21155 unsigned int bytes_read;
21156
21157 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
21158 mac_ptr += bytes_read;
21159 mac_ptr += offset_size;
21160 }
21161 break;
21162
21163 case DW_MACRO_GNU_transparent_include:
21164 case DW_MACRO_GNU_transparent_include_alt:
21165 /* Note that, according to the spec, a transparent include
21166 chain cannot call DW_MACRO_GNU_start_file. So, we can just
21167 skip this opcode. */
21168 mac_ptr += offset_size;
21169 break;
21170
21171 case DW_MACINFO_vendor_ext:
21172 /* Only skip the data by MAC_PTR. */
21173 if (!section_is_gnu)
21174 {
21175 unsigned int bytes_read;
21176
21177 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
21178 mac_ptr += bytes_read;
21179 read_direct_string (abfd, mac_ptr, &bytes_read);
21180 mac_ptr += bytes_read;
21181 }
21182 /* FALLTHROUGH */
21183
21184 default:
21185 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
21186 mac_ptr, mac_end, abfd, offset_size,
21187 section);
21188 if (mac_ptr == NULL)
21189 return;
21190 break;
21191 }
21192 } while (macinfo_type != 0 && current_file == NULL);
21193
21194 /* Second pass: Process all entries.
21195
21196 Use the AT_COMMAND_LINE flag to determine whether we are still processing
21197 command-line macro definitions/undefinitions. This flag is unset when we
21198 reach the first DW_MACINFO_start_file entry. */
21199
21200 include_hash = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
21201 NULL, xcalloc, xfree);
21202 cleanup = make_cleanup_htab_delete (include_hash);
21203 mac_ptr = section->buffer + offset;
21204 slot = htab_find_slot (include_hash, mac_ptr, INSERT);
21205 *slot = (void *) mac_ptr;
21206 dwarf_decode_macro_bytes (abfd, mac_ptr, mac_end,
21207 current_file, lh, comp_dir, section,
21208 section_is_gnu, 0,
21209 offset_size, objfile, include_hash);
21210 do_cleanups (cleanup);
21211 }
21212
21213 /* Check if the attribute's form is a DW_FORM_block*
21214 if so return true else false. */
21215
21216 static int
21217 attr_form_is_block (const struct attribute *attr)
21218 {
21219 return (attr == NULL ? 0 :
21220 attr->form == DW_FORM_block1
21221 || attr->form == DW_FORM_block2
21222 || attr->form == DW_FORM_block4
21223 || attr->form == DW_FORM_block
21224 || attr->form == DW_FORM_exprloc);
21225 }
21226
21227 /* Return non-zero if ATTR's value is a section offset --- classes
21228 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
21229 You may use DW_UNSND (attr) to retrieve such offsets.
21230
21231 Section 7.5.4, "Attribute Encodings", explains that no attribute
21232 may have a value that belongs to more than one of these classes; it
21233 would be ambiguous if we did, because we use the same forms for all
21234 of them. */
21235
21236 static int
21237 attr_form_is_section_offset (const struct attribute *attr)
21238 {
21239 return (attr->form == DW_FORM_data4
21240 || attr->form == DW_FORM_data8
21241 || attr->form == DW_FORM_sec_offset);
21242 }
21243
21244 /* Return non-zero if ATTR's value falls in the 'constant' class, or
21245 zero otherwise. When this function returns true, you can apply
21246 dwarf2_get_attr_constant_value to it.
21247
21248 However, note that for some attributes you must check
21249 attr_form_is_section_offset before using this test. DW_FORM_data4
21250 and DW_FORM_data8 are members of both the constant class, and of
21251 the classes that contain offsets into other debug sections
21252 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
21253 that, if an attribute's can be either a constant or one of the
21254 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
21255 taken as section offsets, not constants. */
21256
21257 static int
21258 attr_form_is_constant (const struct attribute *attr)
21259 {
21260 switch (attr->form)
21261 {
21262 case DW_FORM_sdata:
21263 case DW_FORM_udata:
21264 case DW_FORM_data1:
21265 case DW_FORM_data2:
21266 case DW_FORM_data4:
21267 case DW_FORM_data8:
21268 return 1;
21269 default:
21270 return 0;
21271 }
21272 }
21273
21274
21275 /* DW_ADDR is always stored already as sect_offset; despite for the forms
21276 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
21277
21278 static int
21279 attr_form_is_ref (const struct attribute *attr)
21280 {
21281 switch (attr->form)
21282 {
21283 case DW_FORM_ref_addr:
21284 case DW_FORM_ref1:
21285 case DW_FORM_ref2:
21286 case DW_FORM_ref4:
21287 case DW_FORM_ref8:
21288 case DW_FORM_ref_udata:
21289 case DW_FORM_GNU_ref_alt:
21290 return 1;
21291 default:
21292 return 0;
21293 }
21294 }
21295
21296 /* Return the .debug_loc section to use for CU.
21297 For DWO files use .debug_loc.dwo. */
21298
21299 static struct dwarf2_section_info *
21300 cu_debug_loc_section (struct dwarf2_cu *cu)
21301 {
21302 if (cu->dwo_unit)
21303 return &cu->dwo_unit->dwo_file->sections.loc;
21304 return &dwarf2_per_objfile->loc;
21305 }
21306
21307 /* A helper function that fills in a dwarf2_loclist_baton. */
21308
21309 static void
21310 fill_in_loclist_baton (struct dwarf2_cu *cu,
21311 struct dwarf2_loclist_baton *baton,
21312 const struct attribute *attr)
21313 {
21314 struct dwarf2_section_info *section = cu_debug_loc_section (cu);
21315
21316 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
21317
21318 baton->per_cu = cu->per_cu;
21319 gdb_assert (baton->per_cu);
21320 /* We don't know how long the location list is, but make sure we
21321 don't run off the edge of the section. */
21322 baton->size = section->size - DW_UNSND (attr);
21323 baton->data = section->buffer + DW_UNSND (attr);
21324 baton->base_address = cu->base_address;
21325 baton->from_dwo = cu->dwo_unit != NULL;
21326 }
21327
21328 static void
21329 dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym,
21330 struct dwarf2_cu *cu, int is_block)
21331 {
21332 struct objfile *objfile = dwarf2_per_objfile->objfile;
21333 struct dwarf2_section_info *section = cu_debug_loc_section (cu);
21334
21335 if (attr_form_is_section_offset (attr)
21336 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
21337 the section. If so, fall through to the complaint in the
21338 other branch. */
21339 && DW_UNSND (attr) < dwarf2_section_size (objfile, section))
21340 {
21341 struct dwarf2_loclist_baton *baton;
21342
21343 baton = obstack_alloc (&objfile->objfile_obstack,
21344 sizeof (struct dwarf2_loclist_baton));
21345
21346 fill_in_loclist_baton (cu, baton, attr);
21347
21348 if (cu->base_known == 0)
21349 complaint (&symfile_complaints,
21350 _("Location list used without "
21351 "specifying the CU base address."));
21352
21353 SYMBOL_ACLASS_INDEX (sym) = (is_block
21354 ? dwarf2_loclist_block_index
21355 : dwarf2_loclist_index);
21356 SYMBOL_LOCATION_BATON (sym) = baton;
21357 }
21358 else
21359 {
21360 struct dwarf2_locexpr_baton *baton;
21361
21362 baton = obstack_alloc (&objfile->objfile_obstack,
21363 sizeof (struct dwarf2_locexpr_baton));
21364 baton->per_cu = cu->per_cu;
21365 gdb_assert (baton->per_cu);
21366
21367 if (attr_form_is_block (attr))
21368 {
21369 /* Note that we're just copying the block's data pointer
21370 here, not the actual data. We're still pointing into the
21371 info_buffer for SYM's objfile; right now we never release
21372 that buffer, but when we do clean up properly this may
21373 need to change. */
21374 baton->size = DW_BLOCK (attr)->size;
21375 baton->data = DW_BLOCK (attr)->data;
21376 }
21377 else
21378 {
21379 dwarf2_invalid_attrib_class_complaint ("location description",
21380 SYMBOL_NATURAL_NAME (sym));
21381 baton->size = 0;
21382 }
21383
21384 SYMBOL_ACLASS_INDEX (sym) = (is_block
21385 ? dwarf2_locexpr_block_index
21386 : dwarf2_locexpr_index);
21387 SYMBOL_LOCATION_BATON (sym) = baton;
21388 }
21389 }
21390
21391 /* Return the OBJFILE associated with the compilation unit CU. If CU
21392 came from a separate debuginfo file, then the master objfile is
21393 returned. */
21394
21395 struct objfile *
21396 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data *per_cu)
21397 {
21398 struct objfile *objfile = per_cu->objfile;
21399
21400 /* Return the master objfile, so that we can report and look up the
21401 correct file containing this variable. */
21402 if (objfile->separate_debug_objfile_backlink)
21403 objfile = objfile->separate_debug_objfile_backlink;
21404
21405 return objfile;
21406 }
21407
21408 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
21409 (CU_HEADERP is unused in such case) or prepare a temporary copy at
21410 CU_HEADERP first. */
21411
21412 static const struct comp_unit_head *
21413 per_cu_header_read_in (struct comp_unit_head *cu_headerp,
21414 struct dwarf2_per_cu_data *per_cu)
21415 {
21416 const gdb_byte *info_ptr;
21417
21418 if (per_cu->cu)
21419 return &per_cu->cu->header;
21420
21421 info_ptr = per_cu->section->buffer + per_cu->offset.sect_off;
21422
21423 memset (cu_headerp, 0, sizeof (*cu_headerp));
21424 read_comp_unit_head (cu_headerp, info_ptr, per_cu->objfile->obfd);
21425
21426 return cu_headerp;
21427 }
21428
21429 /* Return the address size given in the compilation unit header for CU. */
21430
21431 int
21432 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data *per_cu)
21433 {
21434 struct comp_unit_head cu_header_local;
21435 const struct comp_unit_head *cu_headerp;
21436
21437 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
21438
21439 return cu_headerp->addr_size;
21440 }
21441
21442 /* Return the offset size given in the compilation unit header for CU. */
21443
21444 int
21445 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data *per_cu)
21446 {
21447 struct comp_unit_head cu_header_local;
21448 const struct comp_unit_head *cu_headerp;
21449
21450 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
21451
21452 return cu_headerp->offset_size;
21453 }
21454
21455 /* See its dwarf2loc.h declaration. */
21456
21457 int
21458 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data *per_cu)
21459 {
21460 struct comp_unit_head cu_header_local;
21461 const struct comp_unit_head *cu_headerp;
21462
21463 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
21464
21465 if (cu_headerp->version == 2)
21466 return cu_headerp->addr_size;
21467 else
21468 return cu_headerp->offset_size;
21469 }
21470
21471 /* Return the text offset of the CU. The returned offset comes from
21472 this CU's objfile. If this objfile came from a separate debuginfo
21473 file, then the offset may be different from the corresponding
21474 offset in the parent objfile. */
21475
21476 CORE_ADDR
21477 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data *per_cu)
21478 {
21479 struct objfile *objfile = per_cu->objfile;
21480
21481 return ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
21482 }
21483
21484 /* Locate the .debug_info compilation unit from CU's objfile which contains
21485 the DIE at OFFSET. Raises an error on failure. */
21486
21487 static struct dwarf2_per_cu_data *
21488 dwarf2_find_containing_comp_unit (sect_offset offset,
21489 unsigned int offset_in_dwz,
21490 struct objfile *objfile)
21491 {
21492 struct dwarf2_per_cu_data *this_cu;
21493 int low, high;
21494 const sect_offset *cu_off;
21495
21496 low = 0;
21497 high = dwarf2_per_objfile->n_comp_units - 1;
21498 while (high > low)
21499 {
21500 struct dwarf2_per_cu_data *mid_cu;
21501 int mid = low + (high - low) / 2;
21502
21503 mid_cu = dwarf2_per_objfile->all_comp_units[mid];
21504 cu_off = &mid_cu->offset;
21505 if (mid_cu->is_dwz > offset_in_dwz
21506 || (mid_cu->is_dwz == offset_in_dwz
21507 && cu_off->sect_off >= offset.sect_off))
21508 high = mid;
21509 else
21510 low = mid + 1;
21511 }
21512 gdb_assert (low == high);
21513 this_cu = dwarf2_per_objfile->all_comp_units[low];
21514 cu_off = &this_cu->offset;
21515 if (this_cu->is_dwz != offset_in_dwz || cu_off->sect_off > offset.sect_off)
21516 {
21517 if (low == 0 || this_cu->is_dwz != offset_in_dwz)
21518 error (_("Dwarf Error: could not find partial DIE containing "
21519 "offset 0x%lx [in module %s]"),
21520 (long) offset.sect_off, bfd_get_filename (objfile->obfd));
21521
21522 gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->offset.sect_off
21523 <= offset.sect_off);
21524 return dwarf2_per_objfile->all_comp_units[low-1];
21525 }
21526 else
21527 {
21528 this_cu = dwarf2_per_objfile->all_comp_units[low];
21529 if (low == dwarf2_per_objfile->n_comp_units - 1
21530 && offset.sect_off >= this_cu->offset.sect_off + this_cu->length)
21531 error (_("invalid dwarf2 offset %u"), offset.sect_off);
21532 gdb_assert (offset.sect_off < this_cu->offset.sect_off + this_cu->length);
21533 return this_cu;
21534 }
21535 }
21536
21537 /* Initialize dwarf2_cu CU, owned by PER_CU. */
21538
21539 static void
21540 init_one_comp_unit (struct dwarf2_cu *cu, struct dwarf2_per_cu_data *per_cu)
21541 {
21542 memset (cu, 0, sizeof (*cu));
21543 per_cu->cu = cu;
21544 cu->per_cu = per_cu;
21545 cu->objfile = per_cu->objfile;
21546 obstack_init (&cu->comp_unit_obstack);
21547 }
21548
21549 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
21550
21551 static void
21552 prepare_one_comp_unit (struct dwarf2_cu *cu, struct die_info *comp_unit_die,
21553 enum language pretend_language)
21554 {
21555 struct attribute *attr;
21556
21557 /* Set the language we're debugging. */
21558 attr = dwarf2_attr (comp_unit_die, DW_AT_language, cu);
21559 if (attr)
21560 set_cu_language (DW_UNSND (attr), cu);
21561 else
21562 {
21563 cu->language = pretend_language;
21564 cu->language_defn = language_def (cu->language);
21565 }
21566
21567 attr = dwarf2_attr (comp_unit_die, DW_AT_producer, cu);
21568 if (attr)
21569 cu->producer = DW_STRING (attr);
21570 }
21571
21572 /* Release one cached compilation unit, CU. We unlink it from the tree
21573 of compilation units, but we don't remove it from the read_in_chain;
21574 the caller is responsible for that.
21575 NOTE: DATA is a void * because this function is also used as a
21576 cleanup routine. */
21577
21578 static void
21579 free_heap_comp_unit (void *data)
21580 {
21581 struct dwarf2_cu *cu = data;
21582
21583 gdb_assert (cu->per_cu != NULL);
21584 cu->per_cu->cu = NULL;
21585 cu->per_cu = NULL;
21586
21587 obstack_free (&cu->comp_unit_obstack, NULL);
21588
21589 xfree (cu);
21590 }
21591
21592 /* This cleanup function is passed the address of a dwarf2_cu on the stack
21593 when we're finished with it. We can't free the pointer itself, but be
21594 sure to unlink it from the cache. Also release any associated storage. */
21595
21596 static void
21597 free_stack_comp_unit (void *data)
21598 {
21599 struct dwarf2_cu *cu = data;
21600
21601 gdb_assert (cu->per_cu != NULL);
21602 cu->per_cu->cu = NULL;
21603 cu->per_cu = NULL;
21604
21605 obstack_free (&cu->comp_unit_obstack, NULL);
21606 cu->partial_dies = NULL;
21607 }
21608
21609 /* Free all cached compilation units. */
21610
21611 static void
21612 free_cached_comp_units (void *data)
21613 {
21614 struct dwarf2_per_cu_data *per_cu, **last_chain;
21615
21616 per_cu = dwarf2_per_objfile->read_in_chain;
21617 last_chain = &dwarf2_per_objfile->read_in_chain;
21618 while (per_cu != NULL)
21619 {
21620 struct dwarf2_per_cu_data *next_cu;
21621
21622 next_cu = per_cu->cu->read_in_chain;
21623
21624 free_heap_comp_unit (per_cu->cu);
21625 *last_chain = next_cu;
21626
21627 per_cu = next_cu;
21628 }
21629 }
21630
21631 /* Increase the age counter on each cached compilation unit, and free
21632 any that are too old. */
21633
21634 static void
21635 age_cached_comp_units (void)
21636 {
21637 struct dwarf2_per_cu_data *per_cu, **last_chain;
21638
21639 dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
21640 per_cu = dwarf2_per_objfile->read_in_chain;
21641 while (per_cu != NULL)
21642 {
21643 per_cu->cu->last_used ++;
21644 if (per_cu->cu->last_used <= dwarf2_max_cache_age)
21645 dwarf2_mark (per_cu->cu);
21646 per_cu = per_cu->cu->read_in_chain;
21647 }
21648
21649 per_cu = dwarf2_per_objfile->read_in_chain;
21650 last_chain = &dwarf2_per_objfile->read_in_chain;
21651 while (per_cu != NULL)
21652 {
21653 struct dwarf2_per_cu_data *next_cu;
21654
21655 next_cu = per_cu->cu->read_in_chain;
21656
21657 if (!per_cu->cu->mark)
21658 {
21659 free_heap_comp_unit (per_cu->cu);
21660 *last_chain = next_cu;
21661 }
21662 else
21663 last_chain = &per_cu->cu->read_in_chain;
21664
21665 per_cu = next_cu;
21666 }
21667 }
21668
21669 /* Remove a single compilation unit from the cache. */
21670
21671 static void
21672 free_one_cached_comp_unit (struct dwarf2_per_cu_data *target_per_cu)
21673 {
21674 struct dwarf2_per_cu_data *per_cu, **last_chain;
21675
21676 per_cu = dwarf2_per_objfile->read_in_chain;
21677 last_chain = &dwarf2_per_objfile->read_in_chain;
21678 while (per_cu != NULL)
21679 {
21680 struct dwarf2_per_cu_data *next_cu;
21681
21682 next_cu = per_cu->cu->read_in_chain;
21683
21684 if (per_cu == target_per_cu)
21685 {
21686 free_heap_comp_unit (per_cu->cu);
21687 per_cu->cu = NULL;
21688 *last_chain = next_cu;
21689 break;
21690 }
21691 else
21692 last_chain = &per_cu->cu->read_in_chain;
21693
21694 per_cu = next_cu;
21695 }
21696 }
21697
21698 /* Release all extra memory associated with OBJFILE. */
21699
21700 void
21701 dwarf2_free_objfile (struct objfile *objfile)
21702 {
21703 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
21704
21705 if (dwarf2_per_objfile == NULL)
21706 return;
21707
21708 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
21709 free_cached_comp_units (NULL);
21710
21711 if (dwarf2_per_objfile->quick_file_names_table)
21712 htab_delete (dwarf2_per_objfile->quick_file_names_table);
21713
21714 /* Everything else should be on the objfile obstack. */
21715 }
21716
21717 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
21718 We store these in a hash table separate from the DIEs, and preserve them
21719 when the DIEs are flushed out of cache.
21720
21721 The CU "per_cu" pointer is needed because offset alone is not enough to
21722 uniquely identify the type. A file may have multiple .debug_types sections,
21723 or the type may come from a DWO file. Furthermore, while it's more logical
21724 to use per_cu->section+offset, with Fission the section with the data is in
21725 the DWO file but we don't know that section at the point we need it.
21726 We have to use something in dwarf2_per_cu_data (or the pointer to it)
21727 because we can enter the lookup routine, get_die_type_at_offset, from
21728 outside this file, and thus won't necessarily have PER_CU->cu.
21729 Fortunately, PER_CU is stable for the life of the objfile. */
21730
21731 struct dwarf2_per_cu_offset_and_type
21732 {
21733 const struct dwarf2_per_cu_data *per_cu;
21734 sect_offset offset;
21735 struct type *type;
21736 };
21737
21738 /* Hash function for a dwarf2_per_cu_offset_and_type. */
21739
21740 static hashval_t
21741 per_cu_offset_and_type_hash (const void *item)
21742 {
21743 const struct dwarf2_per_cu_offset_and_type *ofs = item;
21744
21745 return (uintptr_t) ofs->per_cu + ofs->offset.sect_off;
21746 }
21747
21748 /* Equality function for a dwarf2_per_cu_offset_and_type. */
21749
21750 static int
21751 per_cu_offset_and_type_eq (const void *item_lhs, const void *item_rhs)
21752 {
21753 const struct dwarf2_per_cu_offset_and_type *ofs_lhs = item_lhs;
21754 const struct dwarf2_per_cu_offset_and_type *ofs_rhs = item_rhs;
21755
21756 return (ofs_lhs->per_cu == ofs_rhs->per_cu
21757 && ofs_lhs->offset.sect_off == ofs_rhs->offset.sect_off);
21758 }
21759
21760 /* Set the type associated with DIE to TYPE. Save it in CU's hash
21761 table if necessary. For convenience, return TYPE.
21762
21763 The DIEs reading must have careful ordering to:
21764 * Not cause infite loops trying to read in DIEs as a prerequisite for
21765 reading current DIE.
21766 * Not trying to dereference contents of still incompletely read in types
21767 while reading in other DIEs.
21768 * Enable referencing still incompletely read in types just by a pointer to
21769 the type without accessing its fields.
21770
21771 Therefore caller should follow these rules:
21772 * Try to fetch any prerequisite types we may need to build this DIE type
21773 before building the type and calling set_die_type.
21774 * After building type call set_die_type for current DIE as soon as
21775 possible before fetching more types to complete the current type.
21776 * Make the type as complete as possible before fetching more types. */
21777
21778 static struct type *
21779 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
21780 {
21781 struct dwarf2_per_cu_offset_and_type **slot, ofs;
21782 struct objfile *objfile = cu->objfile;
21783 struct attribute *attr;
21784 struct dynamic_prop prop;
21785
21786 /* For Ada types, make sure that the gnat-specific data is always
21787 initialized (if not already set). There are a few types where
21788 we should not be doing so, because the type-specific area is
21789 already used to hold some other piece of info (eg: TYPE_CODE_FLT
21790 where the type-specific area is used to store the floatformat).
21791 But this is not a problem, because the gnat-specific information
21792 is actually not needed for these types. */
21793 if (need_gnat_info (cu)
21794 && TYPE_CODE (type) != TYPE_CODE_FUNC
21795 && TYPE_CODE (type) != TYPE_CODE_FLT
21796 && !HAVE_GNAT_AUX_INFO (type))
21797 INIT_GNAT_SPECIFIC (type);
21798
21799 /* Read DW_AT_data_location and set in type. */
21800 attr = dwarf2_attr (die, DW_AT_data_location, cu);
21801 if (attr_to_dynamic_prop (attr, die, cu, &prop))
21802 {
21803 TYPE_DATA_LOCATION (type)
21804 = obstack_alloc (&objfile->objfile_obstack, sizeof (prop));
21805 *TYPE_DATA_LOCATION (type) = prop;
21806 }
21807
21808 if (dwarf2_per_objfile->die_type_hash == NULL)
21809 {
21810 dwarf2_per_objfile->die_type_hash =
21811 htab_create_alloc_ex (127,
21812 per_cu_offset_and_type_hash,
21813 per_cu_offset_and_type_eq,
21814 NULL,
21815 &objfile->objfile_obstack,
21816 hashtab_obstack_allocate,
21817 dummy_obstack_deallocate);
21818 }
21819
21820 ofs.per_cu = cu->per_cu;
21821 ofs.offset = die->offset;
21822 ofs.type = type;
21823 slot = (struct dwarf2_per_cu_offset_and_type **)
21824 htab_find_slot (dwarf2_per_objfile->die_type_hash, &ofs, INSERT);
21825 if (*slot)
21826 complaint (&symfile_complaints,
21827 _("A problem internal to GDB: DIE 0x%x has type already set"),
21828 die->offset.sect_off);
21829 *slot = obstack_alloc (&objfile->objfile_obstack, sizeof (**slot));
21830 **slot = ofs;
21831 return type;
21832 }
21833
21834 /* Look up the type for the die at OFFSET in PER_CU in die_type_hash,
21835 or return NULL if the die does not have a saved type. */
21836
21837 static struct type *
21838 get_die_type_at_offset (sect_offset offset,
21839 struct dwarf2_per_cu_data *per_cu)
21840 {
21841 struct dwarf2_per_cu_offset_and_type *slot, ofs;
21842
21843 if (dwarf2_per_objfile->die_type_hash == NULL)
21844 return NULL;
21845
21846 ofs.per_cu = per_cu;
21847 ofs.offset = offset;
21848 slot = htab_find (dwarf2_per_objfile->die_type_hash, &ofs);
21849 if (slot)
21850 return slot->type;
21851 else
21852 return NULL;
21853 }
21854
21855 /* Look up the type for DIE in CU in die_type_hash,
21856 or return NULL if DIE does not have a saved type. */
21857
21858 static struct type *
21859 get_die_type (struct die_info *die, struct dwarf2_cu *cu)
21860 {
21861 return get_die_type_at_offset (die->offset, cu->per_cu);
21862 }
21863
21864 /* Add a dependence relationship from CU to REF_PER_CU. */
21865
21866 static void
21867 dwarf2_add_dependence (struct dwarf2_cu *cu,
21868 struct dwarf2_per_cu_data *ref_per_cu)
21869 {
21870 void **slot;
21871
21872 if (cu->dependencies == NULL)
21873 cu->dependencies
21874 = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
21875 NULL, &cu->comp_unit_obstack,
21876 hashtab_obstack_allocate,
21877 dummy_obstack_deallocate);
21878
21879 slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
21880 if (*slot == NULL)
21881 *slot = ref_per_cu;
21882 }
21883
21884 /* Subroutine of dwarf2_mark to pass to htab_traverse.
21885 Set the mark field in every compilation unit in the
21886 cache that we must keep because we are keeping CU. */
21887
21888 static int
21889 dwarf2_mark_helper (void **slot, void *data)
21890 {
21891 struct dwarf2_per_cu_data *per_cu;
21892
21893 per_cu = (struct dwarf2_per_cu_data *) *slot;
21894
21895 /* cu->dependencies references may not yet have been ever read if QUIT aborts
21896 reading of the chain. As such dependencies remain valid it is not much
21897 useful to track and undo them during QUIT cleanups. */
21898 if (per_cu->cu == NULL)
21899 return 1;
21900
21901 if (per_cu->cu->mark)
21902 return 1;
21903 per_cu->cu->mark = 1;
21904
21905 if (per_cu->cu->dependencies != NULL)
21906 htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
21907
21908 return 1;
21909 }
21910
21911 /* Set the mark field in CU and in every other compilation unit in the
21912 cache that we must keep because we are keeping CU. */
21913
21914 static void
21915 dwarf2_mark (struct dwarf2_cu *cu)
21916 {
21917 if (cu->mark)
21918 return;
21919 cu->mark = 1;
21920 if (cu->dependencies != NULL)
21921 htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
21922 }
21923
21924 static void
21925 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
21926 {
21927 while (per_cu)
21928 {
21929 per_cu->cu->mark = 0;
21930 per_cu = per_cu->cu->read_in_chain;
21931 }
21932 }
21933
21934 /* Trivial hash function for partial_die_info: the hash value of a DIE
21935 is its offset in .debug_info for this objfile. */
21936
21937 static hashval_t
21938 partial_die_hash (const void *item)
21939 {
21940 const struct partial_die_info *part_die = item;
21941
21942 return part_die->offset.sect_off;
21943 }
21944
21945 /* Trivial comparison function for partial_die_info structures: two DIEs
21946 are equal if they have the same offset. */
21947
21948 static int
21949 partial_die_eq (const void *item_lhs, const void *item_rhs)
21950 {
21951 const struct partial_die_info *part_die_lhs = item_lhs;
21952 const struct partial_die_info *part_die_rhs = item_rhs;
21953
21954 return part_die_lhs->offset.sect_off == part_die_rhs->offset.sect_off;
21955 }
21956
21957 static struct cmd_list_element *set_dwarf2_cmdlist;
21958 static struct cmd_list_element *show_dwarf2_cmdlist;
21959
21960 static void
21961 set_dwarf2_cmd (char *args, int from_tty)
21962 {
21963 help_list (set_dwarf2_cmdlist, "maintenance set dwarf2 ", all_commands,
21964 gdb_stdout);
21965 }
21966
21967 static void
21968 show_dwarf2_cmd (char *args, int from_tty)
21969 {
21970 cmd_show_list (show_dwarf2_cmdlist, from_tty, "");
21971 }
21972
21973 /* Free data associated with OBJFILE, if necessary. */
21974
21975 static void
21976 dwarf2_per_objfile_free (struct objfile *objfile, void *d)
21977 {
21978 struct dwarf2_per_objfile *data = d;
21979 int ix;
21980
21981 /* Make sure we don't accidentally use dwarf2_per_objfile while
21982 cleaning up. */
21983 dwarf2_per_objfile = NULL;
21984
21985 for (ix = 0; ix < data->n_comp_units; ++ix)
21986 VEC_free (dwarf2_per_cu_ptr, data->all_comp_units[ix]->imported_symtabs);
21987
21988 for (ix = 0; ix < data->n_type_units; ++ix)
21989 VEC_free (dwarf2_per_cu_ptr,
21990 data->all_type_units[ix]->per_cu.imported_symtabs);
21991 xfree (data->all_type_units);
21992
21993 VEC_free (dwarf2_section_info_def, data->types);
21994
21995 if (data->dwo_files)
21996 free_dwo_files (data->dwo_files, objfile);
21997 if (data->dwp_file)
21998 gdb_bfd_unref (data->dwp_file->dbfd);
21999
22000 if (data->dwz_file && data->dwz_file->dwz_bfd)
22001 gdb_bfd_unref (data->dwz_file->dwz_bfd);
22002 }
22003
22004 \f
22005 /* The "save gdb-index" command. */
22006
22007 /* The contents of the hash table we create when building the string
22008 table. */
22009 struct strtab_entry
22010 {
22011 offset_type offset;
22012 const char *str;
22013 };
22014
22015 /* Hash function for a strtab_entry.
22016
22017 Function is used only during write_hash_table so no index format backward
22018 compatibility is needed. */
22019
22020 static hashval_t
22021 hash_strtab_entry (const void *e)
22022 {
22023 const struct strtab_entry *entry = e;
22024 return mapped_index_string_hash (INT_MAX, entry->str);
22025 }
22026
22027 /* Equality function for a strtab_entry. */
22028
22029 static int
22030 eq_strtab_entry (const void *a, const void *b)
22031 {
22032 const struct strtab_entry *ea = a;
22033 const struct strtab_entry *eb = b;
22034 return !strcmp (ea->str, eb->str);
22035 }
22036
22037 /* Create a strtab_entry hash table. */
22038
22039 static htab_t
22040 create_strtab (void)
22041 {
22042 return htab_create_alloc (100, hash_strtab_entry, eq_strtab_entry,
22043 xfree, xcalloc, xfree);
22044 }
22045
22046 /* Add a string to the constant pool. Return the string's offset in
22047 host order. */
22048
22049 static offset_type
22050 add_string (htab_t table, struct obstack *cpool, const char *str)
22051 {
22052 void **slot;
22053 struct strtab_entry entry;
22054 struct strtab_entry *result;
22055
22056 entry.str = str;
22057 slot = htab_find_slot (table, &entry, INSERT);
22058 if (*slot)
22059 result = *slot;
22060 else
22061 {
22062 result = XNEW (struct strtab_entry);
22063 result->offset = obstack_object_size (cpool);
22064 result->str = str;
22065 obstack_grow_str0 (cpool, str);
22066 *slot = result;
22067 }
22068 return result->offset;
22069 }
22070
22071 /* An entry in the symbol table. */
22072 struct symtab_index_entry
22073 {
22074 /* The name of the symbol. */
22075 const char *name;
22076 /* The offset of the name in the constant pool. */
22077 offset_type index_offset;
22078 /* A sorted vector of the indices of all the CUs that hold an object
22079 of this name. */
22080 VEC (offset_type) *cu_indices;
22081 };
22082
22083 /* The symbol table. This is a power-of-2-sized hash table. */
22084 struct mapped_symtab
22085 {
22086 offset_type n_elements;
22087 offset_type size;
22088 struct symtab_index_entry **data;
22089 };
22090
22091 /* Hash function for a symtab_index_entry. */
22092
22093 static hashval_t
22094 hash_symtab_entry (const void *e)
22095 {
22096 const struct symtab_index_entry *entry = e;
22097 return iterative_hash (VEC_address (offset_type, entry->cu_indices),
22098 sizeof (offset_type) * VEC_length (offset_type,
22099 entry->cu_indices),
22100 0);
22101 }
22102
22103 /* Equality function for a symtab_index_entry. */
22104
22105 static int
22106 eq_symtab_entry (const void *a, const void *b)
22107 {
22108 const struct symtab_index_entry *ea = a;
22109 const struct symtab_index_entry *eb = b;
22110 int len = VEC_length (offset_type, ea->cu_indices);
22111 if (len != VEC_length (offset_type, eb->cu_indices))
22112 return 0;
22113 return !memcmp (VEC_address (offset_type, ea->cu_indices),
22114 VEC_address (offset_type, eb->cu_indices),
22115 sizeof (offset_type) * len);
22116 }
22117
22118 /* Destroy a symtab_index_entry. */
22119
22120 static void
22121 delete_symtab_entry (void *p)
22122 {
22123 struct symtab_index_entry *entry = p;
22124 VEC_free (offset_type, entry->cu_indices);
22125 xfree (entry);
22126 }
22127
22128 /* Create a hash table holding symtab_index_entry objects. */
22129
22130 static htab_t
22131 create_symbol_hash_table (void)
22132 {
22133 return htab_create_alloc (100, hash_symtab_entry, eq_symtab_entry,
22134 delete_symtab_entry, xcalloc, xfree);
22135 }
22136
22137 /* Create a new mapped symtab object. */
22138
22139 static struct mapped_symtab *
22140 create_mapped_symtab (void)
22141 {
22142 struct mapped_symtab *symtab = XNEW (struct mapped_symtab);
22143 symtab->n_elements = 0;
22144 symtab->size = 1024;
22145 symtab->data = XCNEWVEC (struct symtab_index_entry *, symtab->size);
22146 return symtab;
22147 }
22148
22149 /* Destroy a mapped_symtab. */
22150
22151 static void
22152 cleanup_mapped_symtab (void *p)
22153 {
22154 struct mapped_symtab *symtab = p;
22155 /* The contents of the array are freed when the other hash table is
22156 destroyed. */
22157 xfree (symtab->data);
22158 xfree (symtab);
22159 }
22160
22161 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
22162 the slot.
22163
22164 Function is used only during write_hash_table so no index format backward
22165 compatibility is needed. */
22166
22167 static struct symtab_index_entry **
22168 find_slot (struct mapped_symtab *symtab, const char *name)
22169 {
22170 offset_type index, step, hash = mapped_index_string_hash (INT_MAX, name);
22171
22172 index = hash & (symtab->size - 1);
22173 step = ((hash * 17) & (symtab->size - 1)) | 1;
22174
22175 for (;;)
22176 {
22177 if (!symtab->data[index] || !strcmp (name, symtab->data[index]->name))
22178 return &symtab->data[index];
22179 index = (index + step) & (symtab->size - 1);
22180 }
22181 }
22182
22183 /* Expand SYMTAB's hash table. */
22184
22185 static void
22186 hash_expand (struct mapped_symtab *symtab)
22187 {
22188 offset_type old_size = symtab->size;
22189 offset_type i;
22190 struct symtab_index_entry **old_entries = symtab->data;
22191
22192 symtab->size *= 2;
22193 symtab->data = XCNEWVEC (struct symtab_index_entry *, symtab->size);
22194
22195 for (i = 0; i < old_size; ++i)
22196 {
22197 if (old_entries[i])
22198 {
22199 struct symtab_index_entry **slot = find_slot (symtab,
22200 old_entries[i]->name);
22201 *slot = old_entries[i];
22202 }
22203 }
22204
22205 xfree (old_entries);
22206 }
22207
22208 /* Add an entry to SYMTAB. NAME is the name of the symbol.
22209 CU_INDEX is the index of the CU in which the symbol appears.
22210 IS_STATIC is one if the symbol is static, otherwise zero (global). */
22211
22212 static void
22213 add_index_entry (struct mapped_symtab *symtab, const char *name,
22214 int is_static, gdb_index_symbol_kind kind,
22215 offset_type cu_index)
22216 {
22217 struct symtab_index_entry **slot;
22218 offset_type cu_index_and_attrs;
22219
22220 ++symtab->n_elements;
22221 if (4 * symtab->n_elements / 3 >= symtab->size)
22222 hash_expand (symtab);
22223
22224 slot = find_slot (symtab, name);
22225 if (!*slot)
22226 {
22227 *slot = XNEW (struct symtab_index_entry);
22228 (*slot)->name = name;
22229 /* index_offset is set later. */
22230 (*slot)->cu_indices = NULL;
22231 }
22232
22233 cu_index_and_attrs = 0;
22234 DW2_GDB_INDEX_CU_SET_VALUE (cu_index_and_attrs, cu_index);
22235 DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE (cu_index_and_attrs, is_static);
22236 DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE (cu_index_and_attrs, kind);
22237
22238 /* We don't want to record an index value twice as we want to avoid the
22239 duplication.
22240 We process all global symbols and then all static symbols
22241 (which would allow us to avoid the duplication by only having to check
22242 the last entry pushed), but a symbol could have multiple kinds in one CU.
22243 To keep things simple we don't worry about the duplication here and
22244 sort and uniqufy the list after we've processed all symbols. */
22245 VEC_safe_push (offset_type, (*slot)->cu_indices, cu_index_and_attrs);
22246 }
22247
22248 /* qsort helper routine for uniquify_cu_indices. */
22249
22250 static int
22251 offset_type_compare (const void *ap, const void *bp)
22252 {
22253 offset_type a = *(offset_type *) ap;
22254 offset_type b = *(offset_type *) bp;
22255
22256 return (a > b) - (b > a);
22257 }
22258
22259 /* Sort and remove duplicates of all symbols' cu_indices lists. */
22260
22261 static void
22262 uniquify_cu_indices (struct mapped_symtab *symtab)
22263 {
22264 int i;
22265
22266 for (i = 0; i < symtab->size; ++i)
22267 {
22268 struct symtab_index_entry *entry = symtab->data[i];
22269
22270 if (entry
22271 && entry->cu_indices != NULL)
22272 {
22273 unsigned int next_to_insert, next_to_check;
22274 offset_type last_value;
22275
22276 qsort (VEC_address (offset_type, entry->cu_indices),
22277 VEC_length (offset_type, entry->cu_indices),
22278 sizeof (offset_type), offset_type_compare);
22279
22280 last_value = VEC_index (offset_type, entry->cu_indices, 0);
22281 next_to_insert = 1;
22282 for (next_to_check = 1;
22283 next_to_check < VEC_length (offset_type, entry->cu_indices);
22284 ++next_to_check)
22285 {
22286 if (VEC_index (offset_type, entry->cu_indices, next_to_check)
22287 != last_value)
22288 {
22289 last_value = VEC_index (offset_type, entry->cu_indices,
22290 next_to_check);
22291 VEC_replace (offset_type, entry->cu_indices, next_to_insert,
22292 last_value);
22293 ++next_to_insert;
22294 }
22295 }
22296 VEC_truncate (offset_type, entry->cu_indices, next_to_insert);
22297 }
22298 }
22299 }
22300
22301 /* Add a vector of indices to the constant pool. */
22302
22303 static offset_type
22304 add_indices_to_cpool (htab_t symbol_hash_table, struct obstack *cpool,
22305 struct symtab_index_entry *entry)
22306 {
22307 void **slot;
22308
22309 slot = htab_find_slot (symbol_hash_table, entry, INSERT);
22310 if (!*slot)
22311 {
22312 offset_type len = VEC_length (offset_type, entry->cu_indices);
22313 offset_type val = MAYBE_SWAP (len);
22314 offset_type iter;
22315 int i;
22316
22317 *slot = entry;
22318 entry->index_offset = obstack_object_size (cpool);
22319
22320 obstack_grow (cpool, &val, sizeof (val));
22321 for (i = 0;
22322 VEC_iterate (offset_type, entry->cu_indices, i, iter);
22323 ++i)
22324 {
22325 val = MAYBE_SWAP (iter);
22326 obstack_grow (cpool, &val, sizeof (val));
22327 }
22328 }
22329 else
22330 {
22331 struct symtab_index_entry *old_entry = *slot;
22332 entry->index_offset = old_entry->index_offset;
22333 entry = old_entry;
22334 }
22335 return entry->index_offset;
22336 }
22337
22338 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
22339 constant pool entries going into the obstack CPOOL. */
22340
22341 static void
22342 write_hash_table (struct mapped_symtab *symtab,
22343 struct obstack *output, struct obstack *cpool)
22344 {
22345 offset_type i;
22346 htab_t symbol_hash_table;
22347 htab_t str_table;
22348
22349 symbol_hash_table = create_symbol_hash_table ();
22350 str_table = create_strtab ();
22351
22352 /* We add all the index vectors to the constant pool first, to
22353 ensure alignment is ok. */
22354 for (i = 0; i < symtab->size; ++i)
22355 {
22356 if (symtab->data[i])
22357 add_indices_to_cpool (symbol_hash_table, cpool, symtab->data[i]);
22358 }
22359
22360 /* Now write out the hash table. */
22361 for (i = 0; i < symtab->size; ++i)
22362 {
22363 offset_type str_off, vec_off;
22364
22365 if (symtab->data[i])
22366 {
22367 str_off = add_string (str_table, cpool, symtab->data[i]->name);
22368 vec_off = symtab->data[i]->index_offset;
22369 }
22370 else
22371 {
22372 /* While 0 is a valid constant pool index, it is not valid
22373 to have 0 for both offsets. */
22374 str_off = 0;
22375 vec_off = 0;
22376 }
22377
22378 str_off = MAYBE_SWAP (str_off);
22379 vec_off = MAYBE_SWAP (vec_off);
22380
22381 obstack_grow (output, &str_off, sizeof (str_off));
22382 obstack_grow (output, &vec_off, sizeof (vec_off));
22383 }
22384
22385 htab_delete (str_table);
22386 htab_delete (symbol_hash_table);
22387 }
22388
22389 /* Struct to map psymtab to CU index in the index file. */
22390 struct psymtab_cu_index_map
22391 {
22392 struct partial_symtab *psymtab;
22393 unsigned int cu_index;
22394 };
22395
22396 static hashval_t
22397 hash_psymtab_cu_index (const void *item)
22398 {
22399 const struct psymtab_cu_index_map *map = item;
22400
22401 return htab_hash_pointer (map->psymtab);
22402 }
22403
22404 static int
22405 eq_psymtab_cu_index (const void *item_lhs, const void *item_rhs)
22406 {
22407 const struct psymtab_cu_index_map *lhs = item_lhs;
22408 const struct psymtab_cu_index_map *rhs = item_rhs;
22409
22410 return lhs->psymtab == rhs->psymtab;
22411 }
22412
22413 /* Helper struct for building the address table. */
22414 struct addrmap_index_data
22415 {
22416 struct objfile *objfile;
22417 struct obstack *addr_obstack;
22418 htab_t cu_index_htab;
22419
22420 /* Non-zero if the previous_* fields are valid.
22421 We can't write an entry until we see the next entry (since it is only then
22422 that we know the end of the entry). */
22423 int previous_valid;
22424 /* Index of the CU in the table of all CUs in the index file. */
22425 unsigned int previous_cu_index;
22426 /* Start address of the CU. */
22427 CORE_ADDR previous_cu_start;
22428 };
22429
22430 /* Write an address entry to OBSTACK. */
22431
22432 static void
22433 add_address_entry (struct objfile *objfile, struct obstack *obstack,
22434 CORE_ADDR start, CORE_ADDR end, unsigned int cu_index)
22435 {
22436 offset_type cu_index_to_write;
22437 gdb_byte addr[8];
22438 CORE_ADDR baseaddr;
22439
22440 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
22441
22442 store_unsigned_integer (addr, 8, BFD_ENDIAN_LITTLE, start - baseaddr);
22443 obstack_grow (obstack, addr, 8);
22444 store_unsigned_integer (addr, 8, BFD_ENDIAN_LITTLE, end - baseaddr);
22445 obstack_grow (obstack, addr, 8);
22446 cu_index_to_write = MAYBE_SWAP (cu_index);
22447 obstack_grow (obstack, &cu_index_to_write, sizeof (offset_type));
22448 }
22449
22450 /* Worker function for traversing an addrmap to build the address table. */
22451
22452 static int
22453 add_address_entry_worker (void *datap, CORE_ADDR start_addr, void *obj)
22454 {
22455 struct addrmap_index_data *data = datap;
22456 struct partial_symtab *pst = obj;
22457
22458 if (data->previous_valid)
22459 add_address_entry (data->objfile, data->addr_obstack,
22460 data->previous_cu_start, start_addr,
22461 data->previous_cu_index);
22462
22463 data->previous_cu_start = start_addr;
22464 if (pst != NULL)
22465 {
22466 struct psymtab_cu_index_map find_map, *map;
22467 find_map.psymtab = pst;
22468 map = htab_find (data->cu_index_htab, &find_map);
22469 gdb_assert (map != NULL);
22470 data->previous_cu_index = map->cu_index;
22471 data->previous_valid = 1;
22472 }
22473 else
22474 data->previous_valid = 0;
22475
22476 return 0;
22477 }
22478
22479 /* Write OBJFILE's address map to OBSTACK.
22480 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
22481 in the index file. */
22482
22483 static void
22484 write_address_map (struct objfile *objfile, struct obstack *obstack,
22485 htab_t cu_index_htab)
22486 {
22487 struct addrmap_index_data addrmap_index_data;
22488
22489 /* When writing the address table, we have to cope with the fact that
22490 the addrmap iterator only provides the start of a region; we have to
22491 wait until the next invocation to get the start of the next region. */
22492
22493 addrmap_index_data.objfile = objfile;
22494 addrmap_index_data.addr_obstack = obstack;
22495 addrmap_index_data.cu_index_htab = cu_index_htab;
22496 addrmap_index_data.previous_valid = 0;
22497
22498 addrmap_foreach (objfile->psymtabs_addrmap, add_address_entry_worker,
22499 &addrmap_index_data);
22500
22501 /* It's highly unlikely the last entry (end address = 0xff...ff)
22502 is valid, but we should still handle it.
22503 The end address is recorded as the start of the next region, but that
22504 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
22505 anyway. */
22506 if (addrmap_index_data.previous_valid)
22507 add_address_entry (objfile, obstack,
22508 addrmap_index_data.previous_cu_start, (CORE_ADDR) -1,
22509 addrmap_index_data.previous_cu_index);
22510 }
22511
22512 /* Return the symbol kind of PSYM. */
22513
22514 static gdb_index_symbol_kind
22515 symbol_kind (struct partial_symbol *psym)
22516 {
22517 domain_enum domain = PSYMBOL_DOMAIN (psym);
22518 enum address_class aclass = PSYMBOL_CLASS (psym);
22519
22520 switch (domain)
22521 {
22522 case VAR_DOMAIN:
22523 switch (aclass)
22524 {
22525 case LOC_BLOCK:
22526 return GDB_INDEX_SYMBOL_KIND_FUNCTION;
22527 case LOC_TYPEDEF:
22528 return GDB_INDEX_SYMBOL_KIND_TYPE;
22529 case LOC_COMPUTED:
22530 case LOC_CONST_BYTES:
22531 case LOC_OPTIMIZED_OUT:
22532 case LOC_STATIC:
22533 return GDB_INDEX_SYMBOL_KIND_VARIABLE;
22534 case LOC_CONST:
22535 /* Note: It's currently impossible to recognize psyms as enum values
22536 short of reading the type info. For now punt. */
22537 return GDB_INDEX_SYMBOL_KIND_VARIABLE;
22538 default:
22539 /* There are other LOC_FOO values that one might want to classify
22540 as variables, but dwarf2read.c doesn't currently use them. */
22541 return GDB_INDEX_SYMBOL_KIND_OTHER;
22542 }
22543 case STRUCT_DOMAIN:
22544 return GDB_INDEX_SYMBOL_KIND_TYPE;
22545 default:
22546 return GDB_INDEX_SYMBOL_KIND_OTHER;
22547 }
22548 }
22549
22550 /* Add a list of partial symbols to SYMTAB. */
22551
22552 static void
22553 write_psymbols (struct mapped_symtab *symtab,
22554 htab_t psyms_seen,
22555 struct partial_symbol **psymp,
22556 int count,
22557 offset_type cu_index,
22558 int is_static)
22559 {
22560 for (; count-- > 0; ++psymp)
22561 {
22562 struct partial_symbol *psym = *psymp;
22563 void **slot;
22564
22565 if (SYMBOL_LANGUAGE (psym) == language_ada)
22566 error (_("Ada is not currently supported by the index"));
22567
22568 /* Only add a given psymbol once. */
22569 slot = htab_find_slot (psyms_seen, psym, INSERT);
22570 if (!*slot)
22571 {
22572 gdb_index_symbol_kind kind = symbol_kind (psym);
22573
22574 *slot = psym;
22575 add_index_entry (symtab, SYMBOL_SEARCH_NAME (psym),
22576 is_static, kind, cu_index);
22577 }
22578 }
22579 }
22580
22581 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
22582 exception if there is an error. */
22583
22584 static void
22585 write_obstack (FILE *file, struct obstack *obstack)
22586 {
22587 if (fwrite (obstack_base (obstack), 1, obstack_object_size (obstack),
22588 file)
22589 != obstack_object_size (obstack))
22590 error (_("couldn't data write to file"));
22591 }
22592
22593 /* Unlink a file if the argument is not NULL. */
22594
22595 static void
22596 unlink_if_set (void *p)
22597 {
22598 char **filename = p;
22599 if (*filename)
22600 unlink (*filename);
22601 }
22602
22603 /* A helper struct used when iterating over debug_types. */
22604 struct signatured_type_index_data
22605 {
22606 struct objfile *objfile;
22607 struct mapped_symtab *symtab;
22608 struct obstack *types_list;
22609 htab_t psyms_seen;
22610 int cu_index;
22611 };
22612
22613 /* A helper function that writes a single signatured_type to an
22614 obstack. */
22615
22616 static int
22617 write_one_signatured_type (void **slot, void *d)
22618 {
22619 struct signatured_type_index_data *info = d;
22620 struct signatured_type *entry = (struct signatured_type *) *slot;
22621 struct partial_symtab *psymtab = entry->per_cu.v.psymtab;
22622 gdb_byte val[8];
22623
22624 write_psymbols (info->symtab,
22625 info->psyms_seen,
22626 info->objfile->global_psymbols.list
22627 + psymtab->globals_offset,
22628 psymtab->n_global_syms, info->cu_index,
22629 0);
22630 write_psymbols (info->symtab,
22631 info->psyms_seen,
22632 info->objfile->static_psymbols.list
22633 + psymtab->statics_offset,
22634 psymtab->n_static_syms, info->cu_index,
22635 1);
22636
22637 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE,
22638 entry->per_cu.offset.sect_off);
22639 obstack_grow (info->types_list, val, 8);
22640 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE,
22641 entry->type_offset_in_tu.cu_off);
22642 obstack_grow (info->types_list, val, 8);
22643 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, entry->signature);
22644 obstack_grow (info->types_list, val, 8);
22645
22646 ++info->cu_index;
22647
22648 return 1;
22649 }
22650
22651 /* Recurse into all "included" dependencies and write their symbols as
22652 if they appeared in this psymtab. */
22653
22654 static void
22655 recursively_write_psymbols (struct objfile *objfile,
22656 struct partial_symtab *psymtab,
22657 struct mapped_symtab *symtab,
22658 htab_t psyms_seen,
22659 offset_type cu_index)
22660 {
22661 int i;
22662
22663 for (i = 0; i < psymtab->number_of_dependencies; ++i)
22664 if (psymtab->dependencies[i]->user != NULL)
22665 recursively_write_psymbols (objfile, psymtab->dependencies[i],
22666 symtab, psyms_seen, cu_index);
22667
22668 write_psymbols (symtab,
22669 psyms_seen,
22670 objfile->global_psymbols.list + psymtab->globals_offset,
22671 psymtab->n_global_syms, cu_index,
22672 0);
22673 write_psymbols (symtab,
22674 psyms_seen,
22675 objfile->static_psymbols.list + psymtab->statics_offset,
22676 psymtab->n_static_syms, cu_index,
22677 1);
22678 }
22679
22680 /* Create an index file for OBJFILE in the directory DIR. */
22681
22682 static void
22683 write_psymtabs_to_index (struct objfile *objfile, const char *dir)
22684 {
22685 struct cleanup *cleanup;
22686 char *filename, *cleanup_filename;
22687 struct obstack contents, addr_obstack, constant_pool, symtab_obstack;
22688 struct obstack cu_list, types_cu_list;
22689 int i;
22690 FILE *out_file;
22691 struct mapped_symtab *symtab;
22692 offset_type val, size_of_contents, total_len;
22693 struct stat st;
22694 htab_t psyms_seen;
22695 htab_t cu_index_htab;
22696 struct psymtab_cu_index_map *psymtab_cu_index_map;
22697
22698 if (dwarf2_per_objfile->using_index)
22699 error (_("Cannot use an index to create the index"));
22700
22701 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) > 1)
22702 error (_("Cannot make an index when the file has multiple .debug_types sections"));
22703
22704 if (!objfile->psymtabs || !objfile->psymtabs_addrmap)
22705 return;
22706
22707 if (stat (objfile_name (objfile), &st) < 0)
22708 perror_with_name (objfile_name (objfile));
22709
22710 filename = concat (dir, SLASH_STRING, lbasename (objfile_name (objfile)),
22711 INDEX_SUFFIX, (char *) NULL);
22712 cleanup = make_cleanup (xfree, filename);
22713
22714 out_file = gdb_fopen_cloexec (filename, "wb");
22715 if (!out_file)
22716 error (_("Can't open `%s' for writing"), filename);
22717
22718 cleanup_filename = filename;
22719 make_cleanup (unlink_if_set, &cleanup_filename);
22720
22721 symtab = create_mapped_symtab ();
22722 make_cleanup (cleanup_mapped_symtab, symtab);
22723
22724 obstack_init (&addr_obstack);
22725 make_cleanup_obstack_free (&addr_obstack);
22726
22727 obstack_init (&cu_list);
22728 make_cleanup_obstack_free (&cu_list);
22729
22730 obstack_init (&types_cu_list);
22731 make_cleanup_obstack_free (&types_cu_list);
22732
22733 psyms_seen = htab_create_alloc (100, htab_hash_pointer, htab_eq_pointer,
22734 NULL, xcalloc, xfree);
22735 make_cleanup_htab_delete (psyms_seen);
22736
22737 /* While we're scanning CU's create a table that maps a psymtab pointer
22738 (which is what addrmap records) to its index (which is what is recorded
22739 in the index file). This will later be needed to write the address
22740 table. */
22741 cu_index_htab = htab_create_alloc (100,
22742 hash_psymtab_cu_index,
22743 eq_psymtab_cu_index,
22744 NULL, xcalloc, xfree);
22745 make_cleanup_htab_delete (cu_index_htab);
22746 psymtab_cu_index_map = (struct psymtab_cu_index_map *)
22747 xmalloc (sizeof (struct psymtab_cu_index_map)
22748 * dwarf2_per_objfile->n_comp_units);
22749 make_cleanup (xfree, psymtab_cu_index_map);
22750
22751 /* The CU list is already sorted, so we don't need to do additional
22752 work here. Also, the debug_types entries do not appear in
22753 all_comp_units, but only in their own hash table. */
22754 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
22755 {
22756 struct dwarf2_per_cu_data *per_cu
22757 = dwarf2_per_objfile->all_comp_units[i];
22758 struct partial_symtab *psymtab = per_cu->v.psymtab;
22759 gdb_byte val[8];
22760 struct psymtab_cu_index_map *map;
22761 void **slot;
22762
22763 /* CU of a shared file from 'dwz -m' may be unused by this main file.
22764 It may be referenced from a local scope but in such case it does not
22765 need to be present in .gdb_index. */
22766 if (psymtab == NULL)
22767 continue;
22768
22769 if (psymtab->user == NULL)
22770 recursively_write_psymbols (objfile, psymtab, symtab, psyms_seen, i);
22771
22772 map = &psymtab_cu_index_map[i];
22773 map->psymtab = psymtab;
22774 map->cu_index = i;
22775 slot = htab_find_slot (cu_index_htab, map, INSERT);
22776 gdb_assert (slot != NULL);
22777 gdb_assert (*slot == NULL);
22778 *slot = map;
22779
22780 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE,
22781 per_cu->offset.sect_off);
22782 obstack_grow (&cu_list, val, 8);
22783 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, per_cu->length);
22784 obstack_grow (&cu_list, val, 8);
22785 }
22786
22787 /* Dump the address map. */
22788 write_address_map (objfile, &addr_obstack, cu_index_htab);
22789
22790 /* Write out the .debug_type entries, if any. */
22791 if (dwarf2_per_objfile->signatured_types)
22792 {
22793 struct signatured_type_index_data sig_data;
22794
22795 sig_data.objfile = objfile;
22796 sig_data.symtab = symtab;
22797 sig_data.types_list = &types_cu_list;
22798 sig_data.psyms_seen = psyms_seen;
22799 sig_data.cu_index = dwarf2_per_objfile->n_comp_units;
22800 htab_traverse_noresize (dwarf2_per_objfile->signatured_types,
22801 write_one_signatured_type, &sig_data);
22802 }
22803
22804 /* Now that we've processed all symbols we can shrink their cu_indices
22805 lists. */
22806 uniquify_cu_indices (symtab);
22807
22808 obstack_init (&constant_pool);
22809 make_cleanup_obstack_free (&constant_pool);
22810 obstack_init (&symtab_obstack);
22811 make_cleanup_obstack_free (&symtab_obstack);
22812 write_hash_table (symtab, &symtab_obstack, &constant_pool);
22813
22814 obstack_init (&contents);
22815 make_cleanup_obstack_free (&contents);
22816 size_of_contents = 6 * sizeof (offset_type);
22817 total_len = size_of_contents;
22818
22819 /* The version number. */
22820 val = MAYBE_SWAP (8);
22821 obstack_grow (&contents, &val, sizeof (val));
22822
22823 /* The offset of the CU list from the start of the file. */
22824 val = MAYBE_SWAP (total_len);
22825 obstack_grow (&contents, &val, sizeof (val));
22826 total_len += obstack_object_size (&cu_list);
22827
22828 /* The offset of the types CU list from the start of the file. */
22829 val = MAYBE_SWAP (total_len);
22830 obstack_grow (&contents, &val, sizeof (val));
22831 total_len += obstack_object_size (&types_cu_list);
22832
22833 /* The offset of the address table from the start of the file. */
22834 val = MAYBE_SWAP (total_len);
22835 obstack_grow (&contents, &val, sizeof (val));
22836 total_len += obstack_object_size (&addr_obstack);
22837
22838 /* The offset of the symbol table from the start of the file. */
22839 val = MAYBE_SWAP (total_len);
22840 obstack_grow (&contents, &val, sizeof (val));
22841 total_len += obstack_object_size (&symtab_obstack);
22842
22843 /* The offset of the constant pool from the start of the file. */
22844 val = MAYBE_SWAP (total_len);
22845 obstack_grow (&contents, &val, sizeof (val));
22846 total_len += obstack_object_size (&constant_pool);
22847
22848 gdb_assert (obstack_object_size (&contents) == size_of_contents);
22849
22850 write_obstack (out_file, &contents);
22851 write_obstack (out_file, &cu_list);
22852 write_obstack (out_file, &types_cu_list);
22853 write_obstack (out_file, &addr_obstack);
22854 write_obstack (out_file, &symtab_obstack);
22855 write_obstack (out_file, &constant_pool);
22856
22857 fclose (out_file);
22858
22859 /* We want to keep the file, so we set cleanup_filename to NULL
22860 here. See unlink_if_set. */
22861 cleanup_filename = NULL;
22862
22863 do_cleanups (cleanup);
22864 }
22865
22866 /* Implementation of the `save gdb-index' command.
22867
22868 Note that the file format used by this command is documented in the
22869 GDB manual. Any changes here must be documented there. */
22870
22871 static void
22872 save_gdb_index_command (char *arg, int from_tty)
22873 {
22874 struct objfile *objfile;
22875
22876 if (!arg || !*arg)
22877 error (_("usage: save gdb-index DIRECTORY"));
22878
22879 ALL_OBJFILES (objfile)
22880 {
22881 struct stat st;
22882
22883 /* If the objfile does not correspond to an actual file, skip it. */
22884 if (stat (objfile_name (objfile), &st) < 0)
22885 continue;
22886
22887 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
22888 if (dwarf2_per_objfile)
22889 {
22890 volatile struct gdb_exception except;
22891
22892 TRY_CATCH (except, RETURN_MASK_ERROR)
22893 {
22894 write_psymtabs_to_index (objfile, arg);
22895 }
22896 if (except.reason < 0)
22897 exception_fprintf (gdb_stderr, except,
22898 _("Error while writing index for `%s': "),
22899 objfile_name (objfile));
22900 }
22901 }
22902 }
22903
22904 \f
22905
22906 int dwarf2_always_disassemble;
22907
22908 static void
22909 show_dwarf2_always_disassemble (struct ui_file *file, int from_tty,
22910 struct cmd_list_element *c, const char *value)
22911 {
22912 fprintf_filtered (file,
22913 _("Whether to always disassemble "
22914 "DWARF expressions is %s.\n"),
22915 value);
22916 }
22917
22918 static void
22919 show_check_physname (struct ui_file *file, int from_tty,
22920 struct cmd_list_element *c, const char *value)
22921 {
22922 fprintf_filtered (file,
22923 _("Whether to check \"physname\" is %s.\n"),
22924 value);
22925 }
22926
22927 void _initialize_dwarf2_read (void);
22928
22929 void
22930 _initialize_dwarf2_read (void)
22931 {
22932 struct cmd_list_element *c;
22933
22934 dwarf2_objfile_data_key
22935 = register_objfile_data_with_cleanup (NULL, dwarf2_per_objfile_free);
22936
22937 add_prefix_cmd ("dwarf2", class_maintenance, set_dwarf2_cmd, _("\
22938 Set DWARF 2 specific variables.\n\
22939 Configure DWARF 2 variables such as the cache size"),
22940 &set_dwarf2_cmdlist, "maintenance set dwarf2 ",
22941 0/*allow-unknown*/, &maintenance_set_cmdlist);
22942
22943 add_prefix_cmd ("dwarf2", class_maintenance, show_dwarf2_cmd, _("\
22944 Show DWARF 2 specific variables\n\
22945 Show DWARF 2 variables such as the cache size"),
22946 &show_dwarf2_cmdlist, "maintenance show dwarf2 ",
22947 0/*allow-unknown*/, &maintenance_show_cmdlist);
22948
22949 add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
22950 &dwarf2_max_cache_age, _("\
22951 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
22952 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
22953 A higher limit means that cached compilation units will be stored\n\
22954 in memory longer, and more total memory will be used. Zero disables\n\
22955 caching, which can slow down startup."),
22956 NULL,
22957 show_dwarf2_max_cache_age,
22958 &set_dwarf2_cmdlist,
22959 &show_dwarf2_cmdlist);
22960
22961 add_setshow_boolean_cmd ("always-disassemble", class_obscure,
22962 &dwarf2_always_disassemble, _("\
22963 Set whether `info address' always disassembles DWARF expressions."), _("\
22964 Show whether `info address' always disassembles DWARF expressions."), _("\
22965 When enabled, DWARF expressions are always printed in an assembly-like\n\
22966 syntax. When disabled, expressions will be printed in a more\n\
22967 conversational style, when possible."),
22968 NULL,
22969 show_dwarf2_always_disassemble,
22970 &set_dwarf2_cmdlist,
22971 &show_dwarf2_cmdlist);
22972
22973 add_setshow_zuinteger_cmd ("dwarf2-read", no_class, &dwarf2_read_debug, _("\
22974 Set debugging of the dwarf2 reader."), _("\
22975 Show debugging of the dwarf2 reader."), _("\
22976 When enabled (non-zero), debugging messages are printed during dwarf2\n\
22977 reading and symtab expansion. A value of 1 (one) provides basic\n\
22978 information. A value greater than 1 provides more verbose information."),
22979 NULL,
22980 NULL,
22981 &setdebuglist, &showdebuglist);
22982
22983 add_setshow_zuinteger_cmd ("dwarf2-die", no_class, &dwarf2_die_debug, _("\
22984 Set debugging of the dwarf2 DIE reader."), _("\
22985 Show debugging of the dwarf2 DIE reader."), _("\
22986 When enabled (non-zero), DIEs are dumped after they are read in.\n\
22987 The value is the maximum depth to print."),
22988 NULL,
22989 NULL,
22990 &setdebuglist, &showdebuglist);
22991
22992 add_setshow_boolean_cmd ("check-physname", no_class, &check_physname, _("\
22993 Set cross-checking of \"physname\" code against demangler."), _("\
22994 Show cross-checking of \"physname\" code against demangler."), _("\
22995 When enabled, GDB's internal \"physname\" code is checked against\n\
22996 the demangler."),
22997 NULL, show_check_physname,
22998 &setdebuglist, &showdebuglist);
22999
23000 add_setshow_boolean_cmd ("use-deprecated-index-sections",
23001 no_class, &use_deprecated_index_sections, _("\
23002 Set whether to use deprecated gdb_index sections."), _("\
23003 Show whether to use deprecated gdb_index sections."), _("\
23004 When enabled, deprecated .gdb_index sections are used anyway.\n\
23005 Normally they are ignored either because of a missing feature or\n\
23006 performance issue.\n\
23007 Warning: This option must be enabled before gdb reads the file."),
23008 NULL,
23009 NULL,
23010 &setlist, &showlist);
23011
23012 c = add_cmd ("gdb-index", class_files, save_gdb_index_command,
23013 _("\
23014 Save a gdb-index file.\n\
23015 Usage: save gdb-index DIRECTORY"),
23016 &save_cmdlist);
23017 set_cmd_completer (c, filename_completer);
23018
23019 dwarf2_locexpr_index = register_symbol_computed_impl (LOC_COMPUTED,
23020 &dwarf2_locexpr_funcs);
23021 dwarf2_loclist_index = register_symbol_computed_impl (LOC_COMPUTED,
23022 &dwarf2_loclist_funcs);
23023
23024 dwarf2_locexpr_block_index = register_symbol_block_impl (LOC_BLOCK,
23025 &dwarf2_block_frame_base_locexpr_funcs);
23026 dwarf2_loclist_block_index = register_symbol_block_impl (LOC_BLOCK,
23027 &dwarf2_block_frame_base_loclist_funcs);
23028 }