* dwarf2read.c (dwarf2_per_objfile): Change type of all_type_units
[binutils-gdb.git] / gdb / dwarf2read.c
1 /* DWARF 2 debugging format support for GDB.
2
3 Copyright (C) 1994-2012 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 "symtab.h"
34 #include "gdbtypes.h"
35 #include "objfiles.h"
36 #include "dwarf2.h"
37 #include "buildsym.h"
38 #include "demangle.h"
39 #include "gdb-demangle.h"
40 #include "expression.h"
41 #include "filenames.h" /* for DOSish file names */
42 #include "macrotab.h"
43 #include "language.h"
44 #include "complaints.h"
45 #include "bcache.h"
46 #include "dwarf2expr.h"
47 #include "dwarf2loc.h"
48 #include "cp-support.h"
49 #include "hashtab.h"
50 #include "command.h"
51 #include "gdbcmd.h"
52 #include "block.h"
53 #include "addrmap.h"
54 #include "typeprint.h"
55 #include "jv-lang.h"
56 #include "psympriv.h"
57 #include "exceptions.h"
58 #include "gdb_stat.h"
59 #include "completer.h"
60 #include "vec.h"
61 #include "c-lang.h"
62 #include "go-lang.h"
63 #include "valprint.h"
64 #include "gdbcore.h" /* for gnutarget */
65 #include "gdb/gdb-index.h"
66 #include <ctype.h>
67
68 #include <fcntl.h>
69 #include "gdb_string.h"
70 #include "gdb_assert.h"
71 #include <sys/types.h>
72 #ifdef HAVE_ZLIB_H
73 #include <zlib.h>
74 #endif
75 #ifdef HAVE_MMAP
76 #include <sys/mman.h>
77 #ifndef MAP_FAILED
78 #define MAP_FAILED ((void *) -1)
79 #endif
80 #endif
81
82 typedef struct symbol *symbolp;
83 DEF_VEC_P (symbolp);
84
85 /* When non-zero, print basic high level tracing messages.
86 This is in contrast to the low level DIE reading of dwarf2_die_debug. */
87 static int dwarf2_read_debug = 0;
88
89 /* When non-zero, dump DIEs after they are read in. */
90 static int dwarf2_die_debug = 0;
91
92 /* When non-zero, cross-check physname against demangler. */
93 static int check_physname = 0;
94
95 /* When non-zero, do not reject deprecated .gdb_index sections. */
96 int use_deprecated_index_sections = 0;
97
98 static int pagesize;
99
100 /* When set, the file that we're processing is known to have debugging
101 info for C++ namespaces. GCC 3.3.x did not produce this information,
102 but later versions do. */
103
104 static int processing_has_namespace_info;
105
106 static const struct objfile_data *dwarf2_objfile_data_key;
107
108 struct dwarf2_section_info
109 {
110 asection *asection;
111 gdb_byte *buffer;
112 bfd_size_type size;
113 /* Not NULL if the section was actually mmapped. */
114 void *map_addr;
115 /* Page aligned size of mmapped area. */
116 bfd_size_type map_len;
117 /* True if we have tried to read this section. */
118 int readin;
119 };
120
121 typedef struct dwarf2_section_info dwarf2_section_info_def;
122 DEF_VEC_O (dwarf2_section_info_def);
123
124 /* All offsets in the index are of this type. It must be
125 architecture-independent. */
126 typedef uint32_t offset_type;
127
128 DEF_VEC_I (offset_type);
129
130 /* Ensure only legit values are used. */
131 #define DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE(cu_index, value) \
132 do { \
133 gdb_assert ((unsigned int) (value) <= 1); \
134 GDB_INDEX_SYMBOL_STATIC_SET_VALUE((cu_index), (value)); \
135 } while (0)
136
137 /* Ensure only legit values are used. */
138 #define DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE(cu_index, value) \
139 do { \
140 gdb_assert ((value) >= GDB_INDEX_SYMBOL_KIND_TYPE \
141 && (value) <= GDB_INDEX_SYMBOL_KIND_OTHER); \
142 GDB_INDEX_SYMBOL_KIND_SET_VALUE((cu_index), (value)); \
143 } while (0)
144
145 /* Ensure we don't use more than the alloted nuber of bits for the CU. */
146 #define DW2_GDB_INDEX_CU_SET_VALUE(cu_index, value) \
147 do { \
148 gdb_assert (((value) & ~GDB_INDEX_CU_MASK) == 0); \
149 GDB_INDEX_CU_SET_VALUE((cu_index), (value)); \
150 } while (0)
151
152 /* A description of the mapped index. The file format is described in
153 a comment by the code that writes the index. */
154 struct mapped_index
155 {
156 /* Index data format version. */
157 int version;
158
159 /* The total length of the buffer. */
160 off_t total_size;
161
162 /* A pointer to the address table data. */
163 const gdb_byte *address_table;
164
165 /* Size of the address table data in bytes. */
166 offset_type address_table_size;
167
168 /* The symbol table, implemented as a hash table. */
169 const offset_type *symbol_table;
170
171 /* Size in slots, each slot is 2 offset_types. */
172 offset_type symbol_table_slots;
173
174 /* A pointer to the constant pool. */
175 const char *constant_pool;
176 };
177
178 typedef struct dwarf2_per_cu_data *dwarf2_per_cu_ptr;
179 DEF_VEC_P (dwarf2_per_cu_ptr);
180
181 /* Collection of data recorded per objfile.
182 This hangs off of dwarf2_objfile_data_key. */
183
184 struct dwarf2_per_objfile
185 {
186 struct dwarf2_section_info info;
187 struct dwarf2_section_info abbrev;
188 struct dwarf2_section_info line;
189 struct dwarf2_section_info loc;
190 struct dwarf2_section_info macinfo;
191 struct dwarf2_section_info macro;
192 struct dwarf2_section_info str;
193 struct dwarf2_section_info ranges;
194 struct dwarf2_section_info addr;
195 struct dwarf2_section_info frame;
196 struct dwarf2_section_info eh_frame;
197 struct dwarf2_section_info gdb_index;
198
199 VEC (dwarf2_section_info_def) *types;
200
201 /* Back link. */
202 struct objfile *objfile;
203
204 /* Table of all the compilation units. This is used to locate
205 the target compilation unit of a particular reference. */
206 struct dwarf2_per_cu_data **all_comp_units;
207
208 /* The number of compilation units in ALL_COMP_UNITS. */
209 int n_comp_units;
210
211 /* The number of .debug_types-related CUs. */
212 int n_type_units;
213
214 /* The .debug_types-related CUs (TUs). */
215 struct signatured_type **all_type_units;
216
217 /* A chain of compilation units that are currently read in, so that
218 they can be freed later. */
219 struct dwarf2_per_cu_data *read_in_chain;
220
221 /* A table mapping .debug_types signatures to its signatured_type entry.
222 This is NULL if the .debug_types section hasn't been read in yet. */
223 htab_t signatured_types;
224
225 /* A table mapping DW_AT_dwo_name values to struct dwo_file objects.
226 This is NULL if the table hasn't been allocated yet. */
227 htab_t dwo_files;
228
229 /* A flag indicating wether this objfile has a section loaded at a
230 VMA of 0. */
231 int has_section_at_zero;
232
233 /* True if we are using the mapped index,
234 or we are faking it for OBJF_READNOW's sake. */
235 unsigned char using_index;
236
237 /* The mapped index, or NULL if .gdb_index is missing or not being used. */
238 struct mapped_index *index_table;
239
240 /* When using index_table, this keeps track of all quick_file_names entries.
241 TUs can share line table entries with CUs or other TUs, and there can be
242 a lot more TUs than unique line tables, so we maintain a separate table
243 of all line table entries to support the sharing. */
244 htab_t quick_file_names_table;
245
246 /* Set during partial symbol reading, to prevent queueing of full
247 symbols. */
248 int reading_partial_symbols;
249
250 /* Table mapping type DIEs to their struct type *.
251 This is NULL if not allocated yet.
252 The mapping is done via (CU/TU signature + DIE offset) -> type. */
253 htab_t die_type_hash;
254
255 /* The CUs we recently read. */
256 VEC (dwarf2_per_cu_ptr) *just_read_cus;
257 };
258
259 static struct dwarf2_per_objfile *dwarf2_per_objfile;
260
261 /* Default names of the debugging sections. */
262
263 /* Note that if the debugging section has been compressed, it might
264 have a name like .zdebug_info. */
265
266 static const struct dwarf2_debug_sections dwarf2_elf_names =
267 {
268 { ".debug_info", ".zdebug_info" },
269 { ".debug_abbrev", ".zdebug_abbrev" },
270 { ".debug_line", ".zdebug_line" },
271 { ".debug_loc", ".zdebug_loc" },
272 { ".debug_macinfo", ".zdebug_macinfo" },
273 { ".debug_macro", ".zdebug_macro" },
274 { ".debug_str", ".zdebug_str" },
275 { ".debug_ranges", ".zdebug_ranges" },
276 { ".debug_types", ".zdebug_types" },
277 { ".debug_addr", ".zdebug_addr" },
278 { ".debug_frame", ".zdebug_frame" },
279 { ".eh_frame", NULL },
280 { ".gdb_index", ".zgdb_index" },
281 23
282 };
283
284 /* List of DWO sections. */
285
286 static const struct dwo_section_names
287 {
288 struct dwarf2_section_names abbrev_dwo;
289 struct dwarf2_section_names info_dwo;
290 struct dwarf2_section_names line_dwo;
291 struct dwarf2_section_names loc_dwo;
292 struct dwarf2_section_names macinfo_dwo;
293 struct dwarf2_section_names macro_dwo;
294 struct dwarf2_section_names str_dwo;
295 struct dwarf2_section_names str_offsets_dwo;
296 struct dwarf2_section_names types_dwo;
297 }
298 dwo_section_names =
299 {
300 { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo" },
301 { ".debug_info.dwo", ".zdebug_info.dwo" },
302 { ".debug_line.dwo", ".zdebug_line.dwo" },
303 { ".debug_loc.dwo", ".zdebug_loc.dwo" },
304 { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo" },
305 { ".debug_macro.dwo", ".zdebug_macro.dwo" },
306 { ".debug_str.dwo", ".zdebug_str.dwo" },
307 { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo" },
308 { ".debug_types.dwo", ".zdebug_types.dwo" },
309 };
310
311 /* local data types */
312
313 /* The data in a compilation unit header, after target2host
314 translation, looks like this. */
315 struct comp_unit_head
316 {
317 unsigned int length;
318 short version;
319 unsigned char addr_size;
320 unsigned char signed_addr_p;
321 sect_offset abbrev_offset;
322
323 /* Size of file offsets; either 4 or 8. */
324 unsigned int offset_size;
325
326 /* Size of the length field; either 4 or 12. */
327 unsigned int initial_length_size;
328
329 /* Offset to the first byte of this compilation unit header in the
330 .debug_info section, for resolving relative reference dies. */
331 sect_offset offset;
332
333 /* Offset to first die in this cu from the start of the cu.
334 This will be the first byte following the compilation unit header. */
335 cu_offset first_die_offset;
336 };
337
338 /* Type used for delaying computation of method physnames.
339 See comments for compute_delayed_physnames. */
340 struct delayed_method_info
341 {
342 /* The type to which the method is attached, i.e., its parent class. */
343 struct type *type;
344
345 /* The index of the method in the type's function fieldlists. */
346 int fnfield_index;
347
348 /* The index of the method in the fieldlist. */
349 int index;
350
351 /* The name of the DIE. */
352 const char *name;
353
354 /* The DIE associated with this method. */
355 struct die_info *die;
356 };
357
358 typedef struct delayed_method_info delayed_method_info;
359 DEF_VEC_O (delayed_method_info);
360
361 /* Internal state when decoding a particular compilation unit. */
362 struct dwarf2_cu
363 {
364 /* The objfile containing this compilation unit. */
365 struct objfile *objfile;
366
367 /* The header of the compilation unit. */
368 struct comp_unit_head header;
369
370 /* Base address of this compilation unit. */
371 CORE_ADDR base_address;
372
373 /* Non-zero if base_address has been set. */
374 int base_known;
375
376 /* The language we are debugging. */
377 enum language language;
378 const struct language_defn *language_defn;
379
380 const char *producer;
381
382 /* The generic symbol table building routines have separate lists for
383 file scope symbols and all all other scopes (local scopes). So
384 we need to select the right one to pass to add_symbol_to_list().
385 We do it by keeping a pointer to the correct list in list_in_scope.
386
387 FIXME: The original dwarf code just treated the file scope as the
388 first local scope, and all other local scopes as nested local
389 scopes, and worked fine. Check to see if we really need to
390 distinguish these in buildsym.c. */
391 struct pending **list_in_scope;
392
393 /* The abbrev table for this CU.
394 Normally this points to the abbrev table in the objfile.
395 But if DWO_UNIT is non-NULL this is the abbrev table in the DWO file. */
396 struct abbrev_table *abbrev_table;
397
398 /* Hash table holding all the loaded partial DIEs
399 with partial_die->offset.SECT_OFF as hash. */
400 htab_t partial_dies;
401
402 /* Storage for things with the same lifetime as this read-in compilation
403 unit, including partial DIEs. */
404 struct obstack comp_unit_obstack;
405
406 /* When multiple dwarf2_cu structures are living in memory, this field
407 chains them all together, so that they can be released efficiently.
408 We will probably also want a generation counter so that most-recently-used
409 compilation units are cached... */
410 struct dwarf2_per_cu_data *read_in_chain;
411
412 /* Backchain to our per_cu entry if the tree has been built. */
413 struct dwarf2_per_cu_data *per_cu;
414
415 /* How many compilation units ago was this CU last referenced? */
416 int last_used;
417
418 /* A hash table of DIE cu_offset for following references with
419 die_info->offset.sect_off as hash. */
420 htab_t die_hash;
421
422 /* Full DIEs if read in. */
423 struct die_info *dies;
424
425 /* A set of pointers to dwarf2_per_cu_data objects for compilation
426 units referenced by this one. Only set during full symbol processing;
427 partial symbol tables do not have dependencies. */
428 htab_t dependencies;
429
430 /* Header data from the line table, during full symbol processing. */
431 struct line_header *line_header;
432
433 /* A list of methods which need to have physnames computed
434 after all type information has been read. */
435 VEC (delayed_method_info) *method_list;
436
437 /* To be copied to symtab->call_site_htab. */
438 htab_t call_site_htab;
439
440 /* Non-NULL if this CU came from a DWO file.
441 There is an invariant here that is important to remember:
442 Except for attributes copied from the top level DIE in the "main"
443 (or "stub") file in preparation for reading the DWO file
444 (e.g., DW_AT_GNU_addr_base), we KISS: there is only *one* CU.
445 Either there isn't a DWO file (in which case this is NULL and the point
446 is moot), or there is and either we're not going to read it (in which
447 case this is NULL) or there is and we are reading it (in which case this
448 is non-NULL). */
449 struct dwo_unit *dwo_unit;
450
451 /* The DW_AT_addr_base attribute if present, zero otherwise
452 (zero is a valid value though).
453 Note this value comes from the stub CU/TU's DIE. */
454 ULONGEST addr_base;
455
456 /* The DW_AT_ranges_base attribute if present, zero otherwise
457 (zero is a valid value though).
458 Note this value comes from the stub CU/TU's DIE.
459 Also note that the value is zero in the non-DWO case so this value can
460 be used without needing to know whether DWO files are in use or not. */
461 ULONGEST ranges_base;
462
463 /* Mark used when releasing cached dies. */
464 unsigned int mark : 1;
465
466 /* This CU references .debug_loc. See the symtab->locations_valid field.
467 This test is imperfect as there may exist optimized debug code not using
468 any location list and still facing inlining issues if handled as
469 unoptimized code. For a future better test see GCC PR other/32998. */
470 unsigned int has_loclist : 1;
471
472 /* These cache the results for producer_is_gxx_lt_4_6 and producer_is_icc.
473 CHECKED_PRODUCER is set if both PRODUCER_IS_GXX_LT_4_6 and PRODUCER_IS_ICC
474 are valid. This information is cached because profiling CU expansion
475 showed excessive time spent in producer_is_gxx_lt_4_6. */
476 unsigned int checked_producer : 1;
477 unsigned int producer_is_gxx_lt_4_6 : 1;
478 unsigned int producer_is_icc : 1;
479 };
480
481 /* Persistent data held for a compilation unit, even when not
482 processing it. We put a pointer to this structure in the
483 read_symtab_private field of the psymtab. */
484
485 struct dwarf2_per_cu_data
486 {
487 /* The start offset and length of this compilation unit. 2**29-1
488 bytes should suffice to store the length of any compilation unit
489 - if it doesn't, GDB will fall over anyway.
490 NOTE: Unlike comp_unit_head.length, this length includes
491 initial_length_size.
492 If the DIE refers to a DWO file, this is always of the original die,
493 not the DWO file. */
494 sect_offset offset;
495 unsigned int length : 29;
496
497 /* Flag indicating this compilation unit will be read in before
498 any of the current compilation units are processed. */
499 unsigned int queued : 1;
500
501 /* This flag will be set when reading partial DIEs if we need to load
502 absolutely all DIEs for this compilation unit, instead of just the ones
503 we think are interesting. It gets set if we look for a DIE in the
504 hash table and don't find it. */
505 unsigned int load_all_dies : 1;
506
507 /* Non-zero if this CU is from .debug_types. */
508 unsigned int is_debug_types : 1;
509
510 /* The section this CU/TU lives in.
511 If the DIE refers to a DWO file, this is always the original die,
512 not the DWO file. */
513 struct dwarf2_section_info *info_or_types_section;
514
515 /* Set to non-NULL iff this CU is currently loaded. When it gets freed out
516 of the CU cache it gets reset to NULL again. */
517 struct dwarf2_cu *cu;
518
519 /* The corresponding objfile.
520 Normally we can get the objfile from dwarf2_per_objfile.
521 However we can enter this file with just a "per_cu" handle. */
522 struct objfile *objfile;
523
524 /* When using partial symbol tables, the 'psymtab' field is active.
525 Otherwise the 'quick' field is active. */
526 union
527 {
528 /* The partial symbol table associated with this compilation unit,
529 or NULL for unread partial units. */
530 struct partial_symtab *psymtab;
531
532 /* Data needed by the "quick" functions. */
533 struct dwarf2_per_cu_quick_data *quick;
534 } v;
535
536 /* The CUs we import using DW_TAG_imported_unit. This is filled in
537 while reading psymtabs, used to compute the psymtab dependencies,
538 and then cleared. Then it is filled in again while reading full
539 symbols, and only deleted when the objfile is destroyed. */
540 VEC (dwarf2_per_cu_ptr) *imported_symtabs;
541 };
542
543 /* Entry in the signatured_types hash table. */
544
545 struct signatured_type
546 {
547 /* The "per_cu" object of this type.
548 N.B.: This is the first member so that it's easy to convert pointers
549 between them. */
550 struct dwarf2_per_cu_data per_cu;
551
552 /* The type's signature. */
553 ULONGEST signature;
554
555 /* Offset in the TU of the type's DIE, as read from the TU header.
556 If the definition lives in a DWO file, this value is unusable. */
557 cu_offset type_offset_in_tu;
558
559 /* Offset in the section of the type's DIE.
560 If the definition lives in a DWO file, this is the offset in the
561 .debug_types.dwo section.
562 The value is zero until the actual value is known.
563 Zero is otherwise not a valid section offset. */
564 sect_offset type_offset_in_section;
565 };
566
567 /* These sections are what may appear in a "dwo" file. */
568
569 struct dwo_sections
570 {
571 struct dwarf2_section_info abbrev;
572 struct dwarf2_section_info info;
573 struct dwarf2_section_info line;
574 struct dwarf2_section_info loc;
575 struct dwarf2_section_info macinfo;
576 struct dwarf2_section_info macro;
577 struct dwarf2_section_info str;
578 struct dwarf2_section_info str_offsets;
579 VEC (dwarf2_section_info_def) *types;
580 };
581
582 /* Common bits of DWO CUs/TUs. */
583
584 struct dwo_unit
585 {
586 /* Backlink to the containing struct dwo_file. */
587 struct dwo_file *dwo_file;
588
589 /* The "id" that distinguishes this CU/TU.
590 .debug_info calls this "dwo_id", .debug_types calls this "signature".
591 Since signatures came first, we stick with it for consistency. */
592 ULONGEST signature;
593
594 /* The section this CU/TU lives in, in the DWO file. */
595 struct dwarf2_section_info *info_or_types_section;
596
597 /* Same as dwarf2_per_cu_data:{offset,length} but for the DWO section. */
598 sect_offset offset;
599 unsigned int length;
600
601 /* For types, offset in the type's DIE of the type defined by this TU. */
602 cu_offset type_offset_in_tu;
603 };
604
605 /* Data for one DWO file. */
606
607 struct dwo_file
608 {
609 /* The DW_AT_GNU_dwo_name attribute.
610 We don't manage space for this, it's an attribute. */
611 const char *dwo_name;
612
613 /* The bfd, when the file is open. Otherwise this is NULL. */
614 bfd *dwo_bfd;
615
616 /* Section info for this file. */
617 struct dwo_sections sections;
618
619 /* Table of CUs in the file.
620 Each element is a struct dwo_unit. */
621 htab_t cus;
622
623 /* Table of TUs in the file.
624 Each element is a struct dwo_unit. */
625 htab_t tus;
626 };
627
628 /* Struct used to pass misc. parameters to read_die_and_children, et
629 al. which are used for both .debug_info and .debug_types dies.
630 All parameters here are unchanging for the life of the call. This
631 struct exists to abstract away the constant parameters of die reading. */
632
633 struct die_reader_specs
634 {
635 /* die_section->asection->owner. */
636 bfd* abfd;
637
638 /* The CU of the DIE we are parsing. */
639 struct dwarf2_cu *cu;
640
641 /* Non-NULL if reading a DWO file. */
642 struct dwo_file *dwo_file;
643
644 /* The section the die comes from.
645 This is either .debug_info or .debug_types, or the .dwo variants. */
646 struct dwarf2_section_info *die_section;
647
648 /* die_section->buffer. */
649 gdb_byte *buffer;
650
651 /* The end of the buffer. */
652 const gdb_byte *buffer_end;
653 };
654
655 /* Type of function passed to init_cutu_and_read_dies, et.al. */
656 typedef void (die_reader_func_ftype) (const struct die_reader_specs *reader,
657 gdb_byte *info_ptr,
658 struct die_info *comp_unit_die,
659 int has_children,
660 void *data);
661
662 /* The line number information for a compilation unit (found in the
663 .debug_line section) begins with a "statement program header",
664 which contains the following information. */
665 struct line_header
666 {
667 unsigned int total_length;
668 unsigned short version;
669 unsigned int header_length;
670 unsigned char minimum_instruction_length;
671 unsigned char maximum_ops_per_instruction;
672 unsigned char default_is_stmt;
673 int line_base;
674 unsigned char line_range;
675 unsigned char opcode_base;
676
677 /* standard_opcode_lengths[i] is the number of operands for the
678 standard opcode whose value is i. This means that
679 standard_opcode_lengths[0] is unused, and the last meaningful
680 element is standard_opcode_lengths[opcode_base - 1]. */
681 unsigned char *standard_opcode_lengths;
682
683 /* The include_directories table. NOTE! These strings are not
684 allocated with xmalloc; instead, they are pointers into
685 debug_line_buffer. If you try to free them, `free' will get
686 indigestion. */
687 unsigned int num_include_dirs, include_dirs_size;
688 char **include_dirs;
689
690 /* The file_names table. NOTE! These strings are not allocated
691 with xmalloc; instead, they are pointers into debug_line_buffer.
692 Don't try to free them directly. */
693 unsigned int num_file_names, file_names_size;
694 struct file_entry
695 {
696 char *name;
697 unsigned int dir_index;
698 unsigned int mod_time;
699 unsigned int length;
700 int included_p; /* Non-zero if referenced by the Line Number Program. */
701 struct symtab *symtab; /* The associated symbol table, if any. */
702 } *file_names;
703
704 /* The start and end of the statement program following this
705 header. These point into dwarf2_per_objfile->line_buffer. */
706 gdb_byte *statement_program_start, *statement_program_end;
707 };
708
709 /* When we construct a partial symbol table entry we only
710 need this much information. */
711 struct partial_die_info
712 {
713 /* Offset of this DIE. */
714 sect_offset offset;
715
716 /* DWARF-2 tag for this DIE. */
717 ENUM_BITFIELD(dwarf_tag) tag : 16;
718
719 /* Assorted flags describing the data found in this DIE. */
720 unsigned int has_children : 1;
721 unsigned int is_external : 1;
722 unsigned int is_declaration : 1;
723 unsigned int has_type : 1;
724 unsigned int has_specification : 1;
725 unsigned int has_pc_info : 1;
726 unsigned int may_be_inlined : 1;
727
728 /* Flag set if the SCOPE field of this structure has been
729 computed. */
730 unsigned int scope_set : 1;
731
732 /* Flag set if the DIE has a byte_size attribute. */
733 unsigned int has_byte_size : 1;
734
735 /* Flag set if any of the DIE's children are template arguments. */
736 unsigned int has_template_arguments : 1;
737
738 /* Flag set if fixup_partial_die has been called on this die. */
739 unsigned int fixup_called : 1;
740
741 /* The name of this DIE. Normally the value of DW_AT_name, but
742 sometimes a default name for unnamed DIEs. */
743 char *name;
744
745 /* The linkage name, if present. */
746 const char *linkage_name;
747
748 /* The scope to prepend to our children. This is generally
749 allocated on the comp_unit_obstack, so will disappear
750 when this compilation unit leaves the cache. */
751 char *scope;
752
753 /* Some data associated with the partial DIE. The tag determines
754 which field is live. */
755 union
756 {
757 /* The location description associated with this DIE, if any. */
758 struct dwarf_block *locdesc;
759 /* The offset of an import, for DW_TAG_imported_unit. */
760 sect_offset offset;
761 } d;
762
763 /* If HAS_PC_INFO, the PC range associated with this DIE. */
764 CORE_ADDR lowpc;
765 CORE_ADDR highpc;
766
767 /* Pointer into the info_buffer (or types_buffer) pointing at the target of
768 DW_AT_sibling, if any. */
769 /* NOTE: This member isn't strictly necessary, read_partial_die could
770 return DW_AT_sibling values to its caller load_partial_dies. */
771 gdb_byte *sibling;
772
773 /* If HAS_SPECIFICATION, the offset of the DIE referred to by
774 DW_AT_specification (or DW_AT_abstract_origin or
775 DW_AT_extension). */
776 sect_offset spec_offset;
777
778 /* Pointers to this DIE's parent, first child, and next sibling,
779 if any. */
780 struct partial_die_info *die_parent, *die_child, *die_sibling;
781 };
782
783 /* This data structure holds the information of an abbrev. */
784 struct abbrev_info
785 {
786 unsigned int number; /* number identifying abbrev */
787 enum dwarf_tag tag; /* dwarf tag */
788 unsigned short has_children; /* boolean */
789 unsigned short num_attrs; /* number of attributes */
790 struct attr_abbrev *attrs; /* an array of attribute descriptions */
791 struct abbrev_info *next; /* next in chain */
792 };
793
794 struct attr_abbrev
795 {
796 ENUM_BITFIELD(dwarf_attribute) name : 16;
797 ENUM_BITFIELD(dwarf_form) form : 16;
798 };
799
800 /* Size of abbrev_table.abbrev_hash_table. */
801 #define ABBREV_HASH_SIZE 121
802
803 /* Top level data structure to contain an abbreviation table. */
804
805 struct abbrev_table
806 {
807 /* Where the abbrev table came from. */
808 struct dwarf2_section_info *section;
809 sect_offset offset;
810
811 /* Storage for the abbrev table. */
812 struct obstack abbrev_obstack;
813
814 /* Hash table of abbrevs.
815 This is an array of size ABBREV_HASH_SIZE allocated in abbrev_obstack.
816 It could be statically allocated, but the previous code didn't so we
817 don't either. */
818 struct abbrev_info **abbrevs;
819 };
820
821 /* Attributes have a name and a value. */
822 struct attribute
823 {
824 ENUM_BITFIELD(dwarf_attribute) name : 16;
825 ENUM_BITFIELD(dwarf_form) form : 15;
826
827 /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
828 field should be in u.str (existing only for DW_STRING) but it is kept
829 here for better struct attribute alignment. */
830 unsigned int string_is_canonical : 1;
831
832 union
833 {
834 char *str;
835 struct dwarf_block *blk;
836 ULONGEST unsnd;
837 LONGEST snd;
838 CORE_ADDR addr;
839 struct signatured_type *signatured_type;
840 }
841 u;
842 };
843
844 /* This data structure holds a complete die structure. */
845 struct die_info
846 {
847 /* DWARF-2 tag for this DIE. */
848 ENUM_BITFIELD(dwarf_tag) tag : 16;
849
850 /* Number of attributes */
851 unsigned char num_attrs;
852
853 /* True if we're presently building the full type name for the
854 type derived from this DIE. */
855 unsigned char building_fullname : 1;
856
857 /* Abbrev number */
858 unsigned int abbrev;
859
860 /* Offset in .debug_info or .debug_types section. */
861 sect_offset offset;
862
863 /* The dies in a compilation unit form an n-ary tree. PARENT
864 points to this die's parent; CHILD points to the first child of
865 this node; and all the children of a given node are chained
866 together via their SIBLING fields. */
867 struct die_info *child; /* Its first child, if any. */
868 struct die_info *sibling; /* Its next sibling, if any. */
869 struct die_info *parent; /* Its parent, if any. */
870
871 /* An array of attributes, with NUM_ATTRS elements. There may be
872 zero, but it's not common and zero-sized arrays are not
873 sufficiently portable C. */
874 struct attribute attrs[1];
875 };
876
877 /* Get at parts of an attribute structure. */
878
879 #define DW_STRING(attr) ((attr)->u.str)
880 #define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
881 #define DW_UNSND(attr) ((attr)->u.unsnd)
882 #define DW_BLOCK(attr) ((attr)->u.blk)
883 #define DW_SND(attr) ((attr)->u.snd)
884 #define DW_ADDR(attr) ((attr)->u.addr)
885 #define DW_SIGNATURED_TYPE(attr) ((attr)->u.signatured_type)
886
887 /* Blocks are a bunch of untyped bytes. */
888 struct dwarf_block
889 {
890 unsigned int size;
891
892 /* Valid only if SIZE is not zero. */
893 gdb_byte *data;
894 };
895
896 #ifndef ATTR_ALLOC_CHUNK
897 #define ATTR_ALLOC_CHUNK 4
898 #endif
899
900 /* Allocate fields for structs, unions and enums in this size. */
901 #ifndef DW_FIELD_ALLOC_CHUNK
902 #define DW_FIELD_ALLOC_CHUNK 4
903 #endif
904
905 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
906 but this would require a corresponding change in unpack_field_as_long
907 and friends. */
908 static int bits_per_byte = 8;
909
910 /* The routines that read and process dies for a C struct or C++ class
911 pass lists of data member fields and lists of member function fields
912 in an instance of a field_info structure, as defined below. */
913 struct field_info
914 {
915 /* List of data member and baseclasses fields. */
916 struct nextfield
917 {
918 struct nextfield *next;
919 int accessibility;
920 int virtuality;
921 struct field field;
922 }
923 *fields, *baseclasses;
924
925 /* Number of fields (including baseclasses). */
926 int nfields;
927
928 /* Number of baseclasses. */
929 int nbaseclasses;
930
931 /* Set if the accesibility of one of the fields is not public. */
932 int non_public_fields;
933
934 /* Member function fields array, entries are allocated in the order they
935 are encountered in the object file. */
936 struct nextfnfield
937 {
938 struct nextfnfield *next;
939 struct fn_field fnfield;
940 }
941 *fnfields;
942
943 /* Member function fieldlist array, contains name of possibly overloaded
944 member function, number of overloaded member functions and a pointer
945 to the head of the member function field chain. */
946 struct fnfieldlist
947 {
948 char *name;
949 int length;
950 struct nextfnfield *head;
951 }
952 *fnfieldlists;
953
954 /* Number of entries in the fnfieldlists array. */
955 int nfnfields;
956
957 /* typedefs defined inside this class. TYPEDEF_FIELD_LIST contains head of
958 a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements. */
959 struct typedef_field_list
960 {
961 struct typedef_field field;
962 struct typedef_field_list *next;
963 }
964 *typedef_field_list;
965 unsigned typedef_field_list_count;
966 };
967
968 /* One item on the queue of compilation units to read in full symbols
969 for. */
970 struct dwarf2_queue_item
971 {
972 struct dwarf2_per_cu_data *per_cu;
973 enum language pretend_language;
974 struct dwarf2_queue_item *next;
975 };
976
977 /* The current queue. */
978 static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail;
979
980 /* Loaded secondary compilation units are kept in memory until they
981 have not been referenced for the processing of this many
982 compilation units. Set this to zero to disable caching. Cache
983 sizes of up to at least twenty will improve startup time for
984 typical inter-CU-reference binaries, at an obvious memory cost. */
985 static int dwarf2_max_cache_age = 5;
986 static void
987 show_dwarf2_max_cache_age (struct ui_file *file, int from_tty,
988 struct cmd_list_element *c, const char *value)
989 {
990 fprintf_filtered (file, _("The upper bound on the age of cached "
991 "dwarf2 compilation units is %s.\n"),
992 value);
993 }
994
995
996 /* Various complaints about symbol reading that don't abort the process. */
997
998 static void
999 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
1000 {
1001 complaint (&symfile_complaints,
1002 _("statement list doesn't fit in .debug_line section"));
1003 }
1004
1005 static void
1006 dwarf2_debug_line_missing_file_complaint (void)
1007 {
1008 complaint (&symfile_complaints,
1009 _(".debug_line section has line data without a file"));
1010 }
1011
1012 static void
1013 dwarf2_debug_line_missing_end_sequence_complaint (void)
1014 {
1015 complaint (&symfile_complaints,
1016 _(".debug_line section has line "
1017 "program sequence without an end"));
1018 }
1019
1020 static void
1021 dwarf2_complex_location_expr_complaint (void)
1022 {
1023 complaint (&symfile_complaints, _("location expression too complex"));
1024 }
1025
1026 static void
1027 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
1028 int arg3)
1029 {
1030 complaint (&symfile_complaints,
1031 _("const value length mismatch for '%s', got %d, expected %d"),
1032 arg1, arg2, arg3);
1033 }
1034
1035 static void
1036 dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info *section)
1037 {
1038 complaint (&symfile_complaints,
1039 _("debug info runs off end of %s section"
1040 " [in module %s]"),
1041 section->asection->name,
1042 bfd_get_filename (section->asection->owner));
1043 }
1044
1045 static void
1046 dwarf2_macro_malformed_definition_complaint (const char *arg1)
1047 {
1048 complaint (&symfile_complaints,
1049 _("macro debug info contains a "
1050 "malformed macro definition:\n`%s'"),
1051 arg1);
1052 }
1053
1054 static void
1055 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
1056 {
1057 complaint (&symfile_complaints,
1058 _("invalid attribute class or form for '%s' in '%s'"),
1059 arg1, arg2);
1060 }
1061
1062 /* local function prototypes */
1063
1064 static void dwarf2_locate_sections (bfd *, asection *, void *);
1065
1066 static void dwarf2_create_include_psymtab (char *, struct partial_symtab *,
1067 struct objfile *);
1068
1069 static void dwarf2_find_base_address (struct die_info *die,
1070 struct dwarf2_cu *cu);
1071
1072 static void dwarf2_build_psymtabs_hard (struct objfile *);
1073
1074 static void scan_partial_symbols (struct partial_die_info *,
1075 CORE_ADDR *, CORE_ADDR *,
1076 int, struct dwarf2_cu *);
1077
1078 static void add_partial_symbol (struct partial_die_info *,
1079 struct dwarf2_cu *);
1080
1081 static void add_partial_namespace (struct partial_die_info *pdi,
1082 CORE_ADDR *lowpc, CORE_ADDR *highpc,
1083 int need_pc, struct dwarf2_cu *cu);
1084
1085 static void add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
1086 CORE_ADDR *highpc, int need_pc,
1087 struct dwarf2_cu *cu);
1088
1089 static void add_partial_enumeration (struct partial_die_info *enum_pdi,
1090 struct dwarf2_cu *cu);
1091
1092 static void add_partial_subprogram (struct partial_die_info *pdi,
1093 CORE_ADDR *lowpc, CORE_ADDR *highpc,
1094 int need_pc, struct dwarf2_cu *cu);
1095
1096 static void dwarf2_psymtab_to_symtab (struct partial_symtab *);
1097
1098 static void psymtab_to_symtab_1 (struct partial_symtab *);
1099
1100 static struct abbrev_info *abbrev_table_lookup_abbrev
1101 (const struct abbrev_table *, unsigned int);
1102
1103 static struct abbrev_table *abbrev_table_read_table
1104 (struct dwarf2_section_info *, sect_offset);
1105
1106 static void abbrev_table_free (struct abbrev_table *);
1107
1108 static void dwarf2_read_abbrevs (struct dwarf2_cu *,
1109 struct dwarf2_section_info *);
1110
1111 static void dwarf2_free_abbrev_table (void *);
1112
1113 static unsigned int peek_abbrev_code (bfd *, gdb_byte *);
1114
1115 static struct partial_die_info *load_partial_dies
1116 (const struct die_reader_specs *, gdb_byte *, int);
1117
1118 static gdb_byte *read_partial_die (const struct die_reader_specs *,
1119 struct partial_die_info *,
1120 struct abbrev_info *,
1121 unsigned int,
1122 gdb_byte *);
1123
1124 static struct partial_die_info *find_partial_die (sect_offset,
1125 struct dwarf2_cu *);
1126
1127 static void fixup_partial_die (struct partial_die_info *,
1128 struct dwarf2_cu *);
1129
1130 static gdb_byte *read_attribute (const struct die_reader_specs *,
1131 struct attribute *, struct attr_abbrev *,
1132 gdb_byte *);
1133
1134 static unsigned int read_1_byte (bfd *, gdb_byte *);
1135
1136 static int read_1_signed_byte (bfd *, gdb_byte *);
1137
1138 static unsigned int read_2_bytes (bfd *, gdb_byte *);
1139
1140 static unsigned int read_4_bytes (bfd *, gdb_byte *);
1141
1142 static ULONGEST read_8_bytes (bfd *, gdb_byte *);
1143
1144 static CORE_ADDR read_address (bfd *, gdb_byte *ptr, struct dwarf2_cu *,
1145 unsigned int *);
1146
1147 static LONGEST read_initial_length (bfd *, gdb_byte *, unsigned int *);
1148
1149 static LONGEST read_checked_initial_length_and_offset
1150 (bfd *, gdb_byte *, const struct comp_unit_head *,
1151 unsigned int *, unsigned int *);
1152
1153 static LONGEST read_offset (bfd *, gdb_byte *, const struct comp_unit_head *,
1154 unsigned int *);
1155
1156 static LONGEST read_offset_1 (bfd *, gdb_byte *, unsigned int);
1157
1158 static gdb_byte *read_n_bytes (bfd *, gdb_byte *, unsigned int);
1159
1160 static char *read_direct_string (bfd *, gdb_byte *, unsigned int *);
1161
1162 static char *read_indirect_string (bfd *, gdb_byte *,
1163 const struct comp_unit_head *,
1164 unsigned int *);
1165
1166 static ULONGEST read_unsigned_leb128 (bfd *, gdb_byte *, unsigned int *);
1167
1168 static LONGEST read_signed_leb128 (bfd *, gdb_byte *, unsigned int *);
1169
1170 static CORE_ADDR read_addr_index_from_leb128 (struct dwarf2_cu *, gdb_byte *,
1171 unsigned int *);
1172
1173 static char *read_str_index (const struct die_reader_specs *reader,
1174 struct dwarf2_cu *cu, ULONGEST str_index);
1175
1176 static void set_cu_language (unsigned int, struct dwarf2_cu *);
1177
1178 static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
1179 struct dwarf2_cu *);
1180
1181 static struct attribute *dwarf2_attr_no_follow (struct die_info *,
1182 unsigned int);
1183
1184 static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
1185 struct dwarf2_cu *cu);
1186
1187 static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
1188
1189 static struct die_info *die_specification (struct die_info *die,
1190 struct dwarf2_cu **);
1191
1192 static void free_line_header (struct line_header *lh);
1193
1194 static void add_file_name (struct line_header *, char *, unsigned int,
1195 unsigned int, unsigned int);
1196
1197 static struct line_header *dwarf_decode_line_header (unsigned int offset,
1198 struct dwarf2_cu *cu);
1199
1200 static void dwarf_decode_lines (struct line_header *, const char *,
1201 struct dwarf2_cu *, struct partial_symtab *,
1202 int);
1203
1204 static void dwarf2_start_subfile (char *, const char *, const char *);
1205
1206 static struct symbol *new_symbol (struct die_info *, struct type *,
1207 struct dwarf2_cu *);
1208
1209 static struct symbol *new_symbol_full (struct die_info *, struct type *,
1210 struct dwarf2_cu *, struct symbol *);
1211
1212 static void dwarf2_const_value (struct attribute *, struct symbol *,
1213 struct dwarf2_cu *);
1214
1215 static void dwarf2_const_value_attr (struct attribute *attr,
1216 struct type *type,
1217 const char *name,
1218 struct obstack *obstack,
1219 struct dwarf2_cu *cu, LONGEST *value,
1220 gdb_byte **bytes,
1221 struct dwarf2_locexpr_baton **baton);
1222
1223 static struct type *die_type (struct die_info *, struct dwarf2_cu *);
1224
1225 static int need_gnat_info (struct dwarf2_cu *);
1226
1227 static struct type *die_descriptive_type (struct die_info *,
1228 struct dwarf2_cu *);
1229
1230 static void set_descriptive_type (struct type *, struct die_info *,
1231 struct dwarf2_cu *);
1232
1233 static struct type *die_containing_type (struct die_info *,
1234 struct dwarf2_cu *);
1235
1236 static struct type *lookup_die_type (struct die_info *, struct attribute *,
1237 struct dwarf2_cu *);
1238
1239 static struct type *read_type_die (struct die_info *, struct dwarf2_cu *);
1240
1241 static struct type *read_type_die_1 (struct die_info *, struct dwarf2_cu *);
1242
1243 static const char *determine_prefix (struct die_info *die, struct dwarf2_cu *);
1244
1245 static char *typename_concat (struct obstack *obs, const char *prefix,
1246 const char *suffix, int physname,
1247 struct dwarf2_cu *cu);
1248
1249 static void read_file_scope (struct die_info *, struct dwarf2_cu *);
1250
1251 static void read_type_unit_scope (struct die_info *, struct dwarf2_cu *);
1252
1253 static void read_func_scope (struct die_info *, struct dwarf2_cu *);
1254
1255 static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *);
1256
1257 static void read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu);
1258
1259 static int dwarf2_ranges_read (unsigned, CORE_ADDR *, CORE_ADDR *,
1260 struct dwarf2_cu *, struct partial_symtab *);
1261
1262 static int dwarf2_get_pc_bounds (struct die_info *,
1263 CORE_ADDR *, CORE_ADDR *, struct dwarf2_cu *,
1264 struct partial_symtab *);
1265
1266 static void get_scope_pc_bounds (struct die_info *,
1267 CORE_ADDR *, CORE_ADDR *,
1268 struct dwarf2_cu *);
1269
1270 static void dwarf2_record_block_ranges (struct die_info *, struct block *,
1271 CORE_ADDR, struct dwarf2_cu *);
1272
1273 static void dwarf2_add_field (struct field_info *, struct die_info *,
1274 struct dwarf2_cu *);
1275
1276 static void dwarf2_attach_fields_to_type (struct field_info *,
1277 struct type *, struct dwarf2_cu *);
1278
1279 static void dwarf2_add_member_fn (struct field_info *,
1280 struct die_info *, struct type *,
1281 struct dwarf2_cu *);
1282
1283 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
1284 struct type *,
1285 struct dwarf2_cu *);
1286
1287 static void process_structure_scope (struct die_info *, struct dwarf2_cu *);
1288
1289 static void read_common_block (struct die_info *, struct dwarf2_cu *);
1290
1291 static void read_namespace (struct die_info *die, struct dwarf2_cu *);
1292
1293 static void read_module (struct die_info *die, struct dwarf2_cu *cu);
1294
1295 static void read_import_statement (struct die_info *die, struct dwarf2_cu *);
1296
1297 static struct type *read_module_type (struct die_info *die,
1298 struct dwarf2_cu *cu);
1299
1300 static const char *namespace_name (struct die_info *die,
1301 int *is_anonymous, struct dwarf2_cu *);
1302
1303 static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *);
1304
1305 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *);
1306
1307 static enum dwarf_array_dim_ordering read_array_order (struct die_info *,
1308 struct dwarf2_cu *);
1309
1310 static struct die_info *read_die_and_children (const struct die_reader_specs *,
1311 gdb_byte *info_ptr,
1312 gdb_byte **new_info_ptr,
1313 struct die_info *parent);
1314
1315 static struct die_info *read_die_and_siblings (const struct die_reader_specs *,
1316 gdb_byte *info_ptr,
1317 gdb_byte **new_info_ptr,
1318 struct die_info *parent);
1319
1320 static gdb_byte *read_full_die_1 (const struct die_reader_specs *,
1321 struct die_info **, gdb_byte *, int *, int);
1322
1323 static gdb_byte *read_full_die (const struct die_reader_specs *,
1324 struct die_info **, gdb_byte *, int *);
1325
1326 static void process_die (struct die_info *, struct dwarf2_cu *);
1327
1328 static char *dwarf2_canonicalize_name (char *, struct dwarf2_cu *,
1329 struct obstack *);
1330
1331 static char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
1332
1333 static const char *dwarf2_full_name (char *name,
1334 struct die_info *die,
1335 struct dwarf2_cu *cu);
1336
1337 static struct die_info *dwarf2_extension (struct die_info *die,
1338 struct dwarf2_cu **);
1339
1340 static const char *dwarf_tag_name (unsigned int);
1341
1342 static const char *dwarf_attr_name (unsigned int);
1343
1344 static const char *dwarf_form_name (unsigned int);
1345
1346 static char *dwarf_bool_name (unsigned int);
1347
1348 static const char *dwarf_type_encoding_name (unsigned int);
1349
1350 static struct die_info *sibling_die (struct die_info *);
1351
1352 static void dump_die_shallow (struct ui_file *, int indent, struct die_info *);
1353
1354 static void dump_die_for_error (struct die_info *);
1355
1356 static void dump_die_1 (struct ui_file *, int level, int max_level,
1357 struct die_info *);
1358
1359 /*static*/ void dump_die (struct die_info *, int max_level);
1360
1361 static void store_in_ref_table (struct die_info *,
1362 struct dwarf2_cu *);
1363
1364 static int is_ref_attr (struct attribute *);
1365
1366 static sect_offset dwarf2_get_ref_die_offset (struct attribute *);
1367
1368 static LONGEST dwarf2_get_attr_constant_value (struct attribute *, int);
1369
1370 static struct die_info *follow_die_ref_or_sig (struct die_info *,
1371 struct attribute *,
1372 struct dwarf2_cu **);
1373
1374 static struct die_info *follow_die_ref (struct die_info *,
1375 struct attribute *,
1376 struct dwarf2_cu **);
1377
1378 static struct die_info *follow_die_sig (struct die_info *,
1379 struct attribute *,
1380 struct dwarf2_cu **);
1381
1382 static struct signatured_type *lookup_signatured_type_at_offset
1383 (struct objfile *objfile,
1384 struct dwarf2_section_info *section, sect_offset offset);
1385
1386 static void load_full_type_unit (struct dwarf2_per_cu_data *per_cu);
1387
1388 static void read_signatured_type (struct signatured_type *);
1389
1390 /* memory allocation interface */
1391
1392 static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
1393
1394 static struct die_info *dwarf_alloc_die (struct dwarf2_cu *, int);
1395
1396 static void dwarf_decode_macros (struct dwarf2_cu *, unsigned int,
1397 char *, int);
1398
1399 static int attr_form_is_block (struct attribute *);
1400
1401 static int attr_form_is_section_offset (struct attribute *);
1402
1403 static int attr_form_is_constant (struct attribute *);
1404
1405 static void fill_in_loclist_baton (struct dwarf2_cu *cu,
1406 struct dwarf2_loclist_baton *baton,
1407 struct attribute *attr);
1408
1409 static void dwarf2_symbol_mark_computed (struct attribute *attr,
1410 struct symbol *sym,
1411 struct dwarf2_cu *cu);
1412
1413 static gdb_byte *skip_one_die (const struct die_reader_specs *reader,
1414 gdb_byte *info_ptr,
1415 struct abbrev_info *abbrev);
1416
1417 static void free_stack_comp_unit (void *);
1418
1419 static hashval_t partial_die_hash (const void *item);
1420
1421 static int partial_die_eq (const void *item_lhs, const void *item_rhs);
1422
1423 static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit
1424 (sect_offset offset, struct objfile *objfile);
1425
1426 static void init_one_comp_unit (struct dwarf2_cu *cu,
1427 struct dwarf2_per_cu_data *per_cu);
1428
1429 static void prepare_one_comp_unit (struct dwarf2_cu *cu,
1430 struct die_info *comp_unit_die,
1431 enum language pretend_language);
1432
1433 static void free_heap_comp_unit (void *);
1434
1435 static void free_cached_comp_units (void *);
1436
1437 static void age_cached_comp_units (void);
1438
1439 static void free_one_cached_comp_unit (struct dwarf2_per_cu_data *);
1440
1441 static struct type *set_die_type (struct die_info *, struct type *,
1442 struct dwarf2_cu *);
1443
1444 static void create_all_comp_units (struct objfile *);
1445
1446 static int create_all_type_units (struct objfile *);
1447
1448 static void load_full_comp_unit (struct dwarf2_per_cu_data *,
1449 enum language);
1450
1451 static void process_full_comp_unit (struct dwarf2_per_cu_data *,
1452 enum language);
1453
1454 static void dwarf2_add_dependence (struct dwarf2_cu *,
1455 struct dwarf2_per_cu_data *);
1456
1457 static void dwarf2_mark (struct dwarf2_cu *);
1458
1459 static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
1460
1461 static struct type *get_die_type_at_offset (sect_offset,
1462 struct dwarf2_per_cu_data *per_cu);
1463
1464 static struct type *get_die_type (struct die_info *die, struct dwarf2_cu *cu);
1465
1466 static void dwarf2_release_queue (void *dummy);
1467
1468 static void queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
1469 enum language pretend_language);
1470
1471 static int maybe_queue_comp_unit (struct dwarf2_cu *this_cu,
1472 struct dwarf2_per_cu_data *per_cu,
1473 enum language pretend_language);
1474
1475 static void process_queue (void);
1476
1477 static void find_file_and_directory (struct die_info *die,
1478 struct dwarf2_cu *cu,
1479 char **name, char **comp_dir);
1480
1481 static char *file_full_name (int file, struct line_header *lh,
1482 const char *comp_dir);
1483
1484 static void init_cutu_and_read_dies
1485 (struct dwarf2_per_cu_data *this_cu, int use_existing_cu, int keep,
1486 die_reader_func_ftype *die_reader_func, void *data);
1487
1488 static void init_cutu_and_read_dies_simple
1489 (struct dwarf2_per_cu_data *this_cu,
1490 die_reader_func_ftype *die_reader_func, void *data);
1491
1492 static htab_t allocate_signatured_type_table (struct objfile *objfile);
1493
1494 static void process_psymtab_comp_unit (struct dwarf2_per_cu_data *, int);
1495
1496 static htab_t allocate_dwo_unit_table (struct objfile *objfile);
1497
1498 static struct dwo_unit *lookup_dwo_comp_unit
1499 (struct dwarf2_per_cu_data *, char *, const char *, ULONGEST);
1500
1501 static struct dwo_unit *lookup_dwo_type_unit
1502 (struct signatured_type *, char *, const char *);
1503
1504 static void free_dwo_file_cleanup (void *);
1505
1506 static void munmap_section_buffer (struct dwarf2_section_info *);
1507
1508 static void process_cu_includes (void);
1509
1510 #if WORDS_BIGENDIAN
1511
1512 /* Convert VALUE between big- and little-endian. */
1513 static offset_type
1514 byte_swap (offset_type value)
1515 {
1516 offset_type result;
1517
1518 result = (value & 0xff) << 24;
1519 result |= (value & 0xff00) << 8;
1520 result |= (value & 0xff0000) >> 8;
1521 result |= (value & 0xff000000) >> 24;
1522 return result;
1523 }
1524
1525 #define MAYBE_SWAP(V) byte_swap (V)
1526
1527 #else
1528 #define MAYBE_SWAP(V) (V)
1529 #endif /* WORDS_BIGENDIAN */
1530
1531 /* The suffix for an index file. */
1532 #define INDEX_SUFFIX ".gdb-index"
1533
1534 static const char *dwarf2_physname (char *name, struct die_info *die,
1535 struct dwarf2_cu *cu);
1536
1537 /* Try to locate the sections we need for DWARF 2 debugging
1538 information and return true if we have enough to do something.
1539 NAMES points to the dwarf2 section names, or is NULL if the standard
1540 ELF names are used. */
1541
1542 int
1543 dwarf2_has_info (struct objfile *objfile,
1544 const struct dwarf2_debug_sections *names)
1545 {
1546 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
1547 if (!dwarf2_per_objfile)
1548 {
1549 /* Initialize per-objfile state. */
1550 struct dwarf2_per_objfile *data
1551 = obstack_alloc (&objfile->objfile_obstack, sizeof (*data));
1552
1553 memset (data, 0, sizeof (*data));
1554 set_objfile_data (objfile, dwarf2_objfile_data_key, data);
1555 dwarf2_per_objfile = data;
1556
1557 bfd_map_over_sections (objfile->obfd, dwarf2_locate_sections,
1558 (void *) names);
1559 dwarf2_per_objfile->objfile = objfile;
1560 }
1561 return (dwarf2_per_objfile->info.asection != NULL
1562 && dwarf2_per_objfile->abbrev.asection != NULL);
1563 }
1564
1565 /* When loading sections, we look either for uncompressed section or for
1566 compressed section names. */
1567
1568 static int
1569 section_is_p (const char *section_name,
1570 const struct dwarf2_section_names *names)
1571 {
1572 if (names->normal != NULL
1573 && strcmp (section_name, names->normal) == 0)
1574 return 1;
1575 if (names->compressed != NULL
1576 && strcmp (section_name, names->compressed) == 0)
1577 return 1;
1578 return 0;
1579 }
1580
1581 /* This function is mapped across the sections and remembers the
1582 offset and size of each of the debugging sections we are interested
1583 in. */
1584
1585 static void
1586 dwarf2_locate_sections (bfd *abfd, asection *sectp, void *vnames)
1587 {
1588 const struct dwarf2_debug_sections *names;
1589
1590 if (vnames == NULL)
1591 names = &dwarf2_elf_names;
1592 else
1593 names = (const struct dwarf2_debug_sections *) vnames;
1594
1595 if (section_is_p (sectp->name, &names->info))
1596 {
1597 dwarf2_per_objfile->info.asection = sectp;
1598 dwarf2_per_objfile->info.size = bfd_get_section_size (sectp);
1599 }
1600 else if (section_is_p (sectp->name, &names->abbrev))
1601 {
1602 dwarf2_per_objfile->abbrev.asection = sectp;
1603 dwarf2_per_objfile->abbrev.size = bfd_get_section_size (sectp);
1604 }
1605 else if (section_is_p (sectp->name, &names->line))
1606 {
1607 dwarf2_per_objfile->line.asection = sectp;
1608 dwarf2_per_objfile->line.size = bfd_get_section_size (sectp);
1609 }
1610 else if (section_is_p (sectp->name, &names->loc))
1611 {
1612 dwarf2_per_objfile->loc.asection = sectp;
1613 dwarf2_per_objfile->loc.size = bfd_get_section_size (sectp);
1614 }
1615 else if (section_is_p (sectp->name, &names->macinfo))
1616 {
1617 dwarf2_per_objfile->macinfo.asection = sectp;
1618 dwarf2_per_objfile->macinfo.size = bfd_get_section_size (sectp);
1619 }
1620 else if (section_is_p (sectp->name, &names->macro))
1621 {
1622 dwarf2_per_objfile->macro.asection = sectp;
1623 dwarf2_per_objfile->macro.size = bfd_get_section_size (sectp);
1624 }
1625 else if (section_is_p (sectp->name, &names->str))
1626 {
1627 dwarf2_per_objfile->str.asection = sectp;
1628 dwarf2_per_objfile->str.size = bfd_get_section_size (sectp);
1629 }
1630 else if (section_is_p (sectp->name, &names->addr))
1631 {
1632 dwarf2_per_objfile->addr.asection = sectp;
1633 dwarf2_per_objfile->addr.size = bfd_get_section_size (sectp);
1634 }
1635 else if (section_is_p (sectp->name, &names->frame))
1636 {
1637 dwarf2_per_objfile->frame.asection = sectp;
1638 dwarf2_per_objfile->frame.size = bfd_get_section_size (sectp);
1639 }
1640 else if (section_is_p (sectp->name, &names->eh_frame))
1641 {
1642 flagword aflag = bfd_get_section_flags (abfd, sectp);
1643
1644 if (aflag & SEC_HAS_CONTENTS)
1645 {
1646 dwarf2_per_objfile->eh_frame.asection = sectp;
1647 dwarf2_per_objfile->eh_frame.size = bfd_get_section_size (sectp);
1648 }
1649 }
1650 else if (section_is_p (sectp->name, &names->ranges))
1651 {
1652 dwarf2_per_objfile->ranges.asection = sectp;
1653 dwarf2_per_objfile->ranges.size = bfd_get_section_size (sectp);
1654 }
1655 else if (section_is_p (sectp->name, &names->types))
1656 {
1657 struct dwarf2_section_info type_section;
1658
1659 memset (&type_section, 0, sizeof (type_section));
1660 type_section.asection = sectp;
1661 type_section.size = bfd_get_section_size (sectp);
1662
1663 VEC_safe_push (dwarf2_section_info_def, dwarf2_per_objfile->types,
1664 &type_section);
1665 }
1666 else if (section_is_p (sectp->name, &names->gdb_index))
1667 {
1668 dwarf2_per_objfile->gdb_index.asection = sectp;
1669 dwarf2_per_objfile->gdb_index.size = bfd_get_section_size (sectp);
1670 }
1671
1672 if ((bfd_get_section_flags (abfd, sectp) & SEC_LOAD)
1673 && bfd_section_vma (abfd, sectp) == 0)
1674 dwarf2_per_objfile->has_section_at_zero = 1;
1675 }
1676
1677 /* Decompress a section that was compressed using zlib. Store the
1678 decompressed buffer, and its size, in OUTBUF and OUTSIZE. */
1679
1680 static void
1681 zlib_decompress_section (struct objfile *objfile, asection *sectp,
1682 gdb_byte **outbuf, bfd_size_type *outsize)
1683 {
1684 bfd *abfd = sectp->owner;
1685 #ifndef HAVE_ZLIB_H
1686 error (_("Support for zlib-compressed DWARF data (from '%s') "
1687 "is disabled in this copy of GDB"),
1688 bfd_get_filename (abfd));
1689 #else
1690 bfd_size_type compressed_size = bfd_get_section_size (sectp);
1691 gdb_byte *compressed_buffer = xmalloc (compressed_size);
1692 struct cleanup *cleanup = make_cleanup (xfree, compressed_buffer);
1693 bfd_size_type uncompressed_size;
1694 gdb_byte *uncompressed_buffer;
1695 z_stream strm;
1696 int rc;
1697 int header_size = 12;
1698
1699 if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
1700 || bfd_bread (compressed_buffer,
1701 compressed_size, abfd) != compressed_size)
1702 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1703 bfd_get_filename (abfd));
1704
1705 /* Read the zlib header. In this case, it should be "ZLIB" followed
1706 by the uncompressed section size, 8 bytes in big-endian order. */
1707 if (compressed_size < header_size
1708 || strncmp (compressed_buffer, "ZLIB", 4) != 0)
1709 error (_("Dwarf Error: Corrupt DWARF ZLIB header from '%s'"),
1710 bfd_get_filename (abfd));
1711 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
1712 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
1713 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
1714 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
1715 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
1716 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
1717 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
1718 uncompressed_size += compressed_buffer[11];
1719
1720 /* It is possible the section consists of several compressed
1721 buffers concatenated together, so we uncompress in a loop. */
1722 strm.zalloc = NULL;
1723 strm.zfree = NULL;
1724 strm.opaque = NULL;
1725 strm.avail_in = compressed_size - header_size;
1726 strm.next_in = (Bytef*) compressed_buffer + header_size;
1727 strm.avail_out = uncompressed_size;
1728 uncompressed_buffer = obstack_alloc (&objfile->objfile_obstack,
1729 uncompressed_size);
1730 rc = inflateInit (&strm);
1731 while (strm.avail_in > 0)
1732 {
1733 if (rc != Z_OK)
1734 error (_("Dwarf Error: setting up DWARF uncompression in '%s': %d"),
1735 bfd_get_filename (abfd), rc);
1736 strm.next_out = ((Bytef*) uncompressed_buffer
1737 + (uncompressed_size - strm.avail_out));
1738 rc = inflate (&strm, Z_FINISH);
1739 if (rc != Z_STREAM_END)
1740 error (_("Dwarf Error: zlib error uncompressing from '%s': %d"),
1741 bfd_get_filename (abfd), rc);
1742 rc = inflateReset (&strm);
1743 }
1744 rc = inflateEnd (&strm);
1745 if (rc != Z_OK
1746 || strm.avail_out != 0)
1747 error (_("Dwarf Error: concluding DWARF uncompression in '%s': %d"),
1748 bfd_get_filename (abfd), rc);
1749
1750 do_cleanups (cleanup);
1751 *outbuf = uncompressed_buffer;
1752 *outsize = uncompressed_size;
1753 #endif
1754 }
1755
1756 /* A helper function that decides whether a section is empty,
1757 or not present. */
1758
1759 static int
1760 dwarf2_section_empty_p (struct dwarf2_section_info *info)
1761 {
1762 return info->asection == NULL || info->size == 0;
1763 }
1764
1765 /* Read the contents of the section INFO.
1766 OBJFILE is the main object file, but not necessarily the file where
1767 the section comes from. E.g., for DWO files INFO->asection->owner
1768 is the bfd of the DWO file.
1769 If the section is compressed, uncompress it before returning. */
1770
1771 static void
1772 dwarf2_read_section (struct objfile *objfile, struct dwarf2_section_info *info)
1773 {
1774 asection *sectp = info->asection;
1775 bfd *abfd;
1776 gdb_byte *buf, *retbuf;
1777 unsigned char header[4];
1778
1779 if (info->readin)
1780 return;
1781 info->buffer = NULL;
1782 info->map_addr = NULL;
1783 info->readin = 1;
1784
1785 if (dwarf2_section_empty_p (info))
1786 return;
1787
1788 /* Note that ABFD may not be from OBJFILE, e.g. a DWO section. */
1789 abfd = sectp->owner;
1790
1791 /* Check if the file has a 4-byte header indicating compression. */
1792 if (info->size > sizeof (header)
1793 && bfd_seek (abfd, sectp->filepos, SEEK_SET) == 0
1794 && bfd_bread (header, sizeof (header), abfd) == sizeof (header))
1795 {
1796 /* Upon decompression, update the buffer and its size. */
1797 if (strncmp (header, "ZLIB", sizeof (header)) == 0)
1798 {
1799 zlib_decompress_section (objfile, sectp, &info->buffer,
1800 &info->size);
1801 return;
1802 }
1803 }
1804
1805 #ifdef HAVE_MMAP
1806 if (pagesize == 0)
1807 pagesize = getpagesize ();
1808
1809 /* Only try to mmap sections which are large enough: we don't want to
1810 waste space due to fragmentation. Also, only try mmap for sections
1811 without relocations. */
1812
1813 if (info->size > 4 * pagesize && (sectp->flags & SEC_RELOC) == 0)
1814 {
1815 info->buffer = bfd_mmap (abfd, 0, info->size, PROT_READ,
1816 MAP_PRIVATE, sectp->filepos,
1817 &info->map_addr, &info->map_len);
1818
1819 if ((caddr_t)info->buffer != MAP_FAILED)
1820 {
1821 #if HAVE_POSIX_MADVISE
1822 posix_madvise (info->map_addr, info->map_len, POSIX_MADV_WILLNEED);
1823 #endif
1824 return;
1825 }
1826 }
1827 #endif
1828
1829 /* If we get here, we are a normal, not-compressed section. */
1830 info->buffer = buf
1831 = obstack_alloc (&objfile->objfile_obstack, info->size);
1832
1833 /* When debugging .o files, we may need to apply relocations; see
1834 http://sourceware.org/ml/gdb-patches/2002-04/msg00136.html .
1835 We never compress sections in .o files, so we only need to
1836 try this when the section is not compressed. */
1837 retbuf = symfile_relocate_debug_section (objfile, sectp, buf);
1838 if (retbuf != NULL)
1839 {
1840 info->buffer = retbuf;
1841 return;
1842 }
1843
1844 if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0
1845 || bfd_bread (buf, info->size, abfd) != info->size)
1846 error (_("Dwarf Error: Can't read DWARF data from '%s'"),
1847 bfd_get_filename (abfd));
1848 }
1849
1850 /* A helper function that returns the size of a section in a safe way.
1851 If you are positive that the section has been read before using the
1852 size, then it is safe to refer to the dwarf2_section_info object's
1853 "size" field directly. In other cases, you must call this
1854 function, because for compressed sections the size field is not set
1855 correctly until the section has been read. */
1856
1857 static bfd_size_type
1858 dwarf2_section_size (struct objfile *objfile,
1859 struct dwarf2_section_info *info)
1860 {
1861 if (!info->readin)
1862 dwarf2_read_section (objfile, info);
1863 return info->size;
1864 }
1865
1866 /* Fill in SECTP, BUFP and SIZEP with section info, given OBJFILE and
1867 SECTION_NAME. */
1868
1869 void
1870 dwarf2_get_section_info (struct objfile *objfile,
1871 enum dwarf2_section_enum sect,
1872 asection **sectp, gdb_byte **bufp,
1873 bfd_size_type *sizep)
1874 {
1875 struct dwarf2_per_objfile *data
1876 = objfile_data (objfile, dwarf2_objfile_data_key);
1877 struct dwarf2_section_info *info;
1878
1879 /* We may see an objfile without any DWARF, in which case we just
1880 return nothing. */
1881 if (data == NULL)
1882 {
1883 *sectp = NULL;
1884 *bufp = NULL;
1885 *sizep = 0;
1886 return;
1887 }
1888 switch (sect)
1889 {
1890 case DWARF2_DEBUG_FRAME:
1891 info = &data->frame;
1892 break;
1893 case DWARF2_EH_FRAME:
1894 info = &data->eh_frame;
1895 break;
1896 default:
1897 gdb_assert_not_reached ("unexpected section");
1898 }
1899
1900 dwarf2_read_section (objfile, info);
1901
1902 *sectp = info->asection;
1903 *bufp = info->buffer;
1904 *sizep = info->size;
1905 }
1906
1907 \f
1908 /* DWARF quick_symbols_functions support. */
1909
1910 /* TUs can share .debug_line entries, and there can be a lot more TUs than
1911 unique line tables, so we maintain a separate table of all .debug_line
1912 derived entries to support the sharing.
1913 All the quick functions need is the list of file names. We discard the
1914 line_header when we're done and don't need to record it here. */
1915 struct quick_file_names
1916 {
1917 /* The offset in .debug_line of the line table. We hash on this. */
1918 unsigned int offset;
1919
1920 /* The number of entries in file_names, real_names. */
1921 unsigned int num_file_names;
1922
1923 /* The file names from the line table, after being run through
1924 file_full_name. */
1925 const char **file_names;
1926
1927 /* The file names from the line table after being run through
1928 gdb_realpath. These are computed lazily. */
1929 const char **real_names;
1930 };
1931
1932 /* When using the index (and thus not using psymtabs), each CU has an
1933 object of this type. This is used to hold information needed by
1934 the various "quick" methods. */
1935 struct dwarf2_per_cu_quick_data
1936 {
1937 /* The file table. This can be NULL if there was no file table
1938 or it's currently not read in.
1939 NOTE: This points into dwarf2_per_objfile->quick_file_names_table. */
1940 struct quick_file_names *file_names;
1941
1942 /* The corresponding symbol table. This is NULL if symbols for this
1943 CU have not yet been read. */
1944 struct symtab *symtab;
1945
1946 /* A temporary mark bit used when iterating over all CUs in
1947 expand_symtabs_matching. */
1948 unsigned int mark : 1;
1949
1950 /* True if we've tried to read the file table and found there isn't one.
1951 There will be no point in trying to read it again next time. */
1952 unsigned int no_file_data : 1;
1953 };
1954
1955 /* Hash function for a quick_file_names. */
1956
1957 static hashval_t
1958 hash_file_name_entry (const void *e)
1959 {
1960 const struct quick_file_names *file_data = e;
1961
1962 return file_data->offset;
1963 }
1964
1965 /* Equality function for a quick_file_names. */
1966
1967 static int
1968 eq_file_name_entry (const void *a, const void *b)
1969 {
1970 const struct quick_file_names *ea = a;
1971 const struct quick_file_names *eb = b;
1972
1973 return ea->offset == eb->offset;
1974 }
1975
1976 /* Delete function for a quick_file_names. */
1977
1978 static void
1979 delete_file_name_entry (void *e)
1980 {
1981 struct quick_file_names *file_data = e;
1982 int i;
1983
1984 for (i = 0; i < file_data->num_file_names; ++i)
1985 {
1986 xfree ((void*) file_data->file_names[i]);
1987 if (file_data->real_names)
1988 xfree ((void*) file_data->real_names[i]);
1989 }
1990
1991 /* The space for the struct itself lives on objfile_obstack,
1992 so we don't free it here. */
1993 }
1994
1995 /* Create a quick_file_names hash table. */
1996
1997 static htab_t
1998 create_quick_file_names_table (unsigned int nr_initial_entries)
1999 {
2000 return htab_create_alloc (nr_initial_entries,
2001 hash_file_name_entry, eq_file_name_entry,
2002 delete_file_name_entry, xcalloc, xfree);
2003 }
2004
2005 /* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
2006 have to be created afterwards. You should call age_cached_comp_units after
2007 processing PER_CU->CU. dw2_setup must have been already called. */
2008
2009 static void
2010 load_cu (struct dwarf2_per_cu_data *per_cu)
2011 {
2012 if (per_cu->is_debug_types)
2013 load_full_type_unit (per_cu);
2014 else
2015 load_full_comp_unit (per_cu, language_minimal);
2016
2017 gdb_assert (per_cu->cu != NULL);
2018
2019 dwarf2_find_base_address (per_cu->cu->dies, per_cu->cu);
2020 }
2021
2022 /* Read in the symbols for PER_CU. */
2023
2024 static void
2025 dw2_do_instantiate_symtab (struct dwarf2_per_cu_data *per_cu)
2026 {
2027 struct cleanup *back_to;
2028
2029 back_to = make_cleanup (dwarf2_release_queue, NULL);
2030
2031 if (dwarf2_per_objfile->using_index
2032 ? per_cu->v.quick->symtab == NULL
2033 : (per_cu->v.psymtab == NULL || !per_cu->v.psymtab->readin))
2034 {
2035 queue_comp_unit (per_cu, language_minimal);
2036 load_cu (per_cu);
2037 }
2038
2039 process_queue ();
2040
2041 /* Age the cache, releasing compilation units that have not
2042 been used recently. */
2043 age_cached_comp_units ();
2044
2045 do_cleanups (back_to);
2046 }
2047
2048 /* Ensure that the symbols for PER_CU have been read in. OBJFILE is
2049 the objfile from which this CU came. Returns the resulting symbol
2050 table. */
2051
2052 static struct symtab *
2053 dw2_instantiate_symtab (struct dwarf2_per_cu_data *per_cu)
2054 {
2055 gdb_assert (dwarf2_per_objfile->using_index);
2056 if (!per_cu->v.quick->symtab)
2057 {
2058 struct cleanup *back_to = make_cleanup (free_cached_comp_units, NULL);
2059 increment_reading_symtab ();
2060 dw2_do_instantiate_symtab (per_cu);
2061 process_cu_includes ();
2062 do_cleanups (back_to);
2063 }
2064 return per_cu->v.quick->symtab;
2065 }
2066
2067 /* Return the CU given its index. */
2068
2069 static struct dwarf2_per_cu_data *
2070 dw2_get_cu (int index)
2071 {
2072 if (index >= dwarf2_per_objfile->n_comp_units)
2073 {
2074 index -= dwarf2_per_objfile->n_comp_units;
2075 return &dwarf2_per_objfile->all_type_units[index]->per_cu;
2076 }
2077 return dwarf2_per_objfile->all_comp_units[index];
2078 }
2079
2080 /* A helper function that knows how to read a 64-bit value in a way
2081 that doesn't make gdb die. Returns 1 if the conversion went ok, 0
2082 otherwise. */
2083
2084 static int
2085 extract_cu_value (const char *bytes, ULONGEST *result)
2086 {
2087 if (sizeof (ULONGEST) < 8)
2088 {
2089 int i;
2090
2091 /* Ignore the upper 4 bytes if they are all zero. */
2092 for (i = 0; i < 4; ++i)
2093 if (bytes[i + 4] != 0)
2094 return 0;
2095
2096 *result = extract_unsigned_integer (bytes, 4, BFD_ENDIAN_LITTLE);
2097 }
2098 else
2099 *result = extract_unsigned_integer (bytes, 8, BFD_ENDIAN_LITTLE);
2100 return 1;
2101 }
2102
2103 /* Read the CU list from the mapped index, and use it to create all
2104 the CU objects for this objfile. Return 0 if something went wrong,
2105 1 if everything went ok. */
2106
2107 static int
2108 create_cus_from_index (struct objfile *objfile, const gdb_byte *cu_list,
2109 offset_type cu_list_elements)
2110 {
2111 offset_type i;
2112
2113 dwarf2_per_objfile->n_comp_units = cu_list_elements / 2;
2114 dwarf2_per_objfile->all_comp_units
2115 = obstack_alloc (&objfile->objfile_obstack,
2116 dwarf2_per_objfile->n_comp_units
2117 * sizeof (struct dwarf2_per_cu_data *));
2118
2119 for (i = 0; i < cu_list_elements; i += 2)
2120 {
2121 struct dwarf2_per_cu_data *the_cu;
2122 ULONGEST offset, length;
2123
2124 if (!extract_cu_value (cu_list, &offset)
2125 || !extract_cu_value (cu_list + 8, &length))
2126 return 0;
2127 cu_list += 2 * 8;
2128
2129 the_cu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2130 struct dwarf2_per_cu_data);
2131 the_cu->offset.sect_off = offset;
2132 the_cu->length = length;
2133 the_cu->objfile = objfile;
2134 the_cu->info_or_types_section = &dwarf2_per_objfile->info;
2135 the_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2136 struct dwarf2_per_cu_quick_data);
2137 dwarf2_per_objfile->all_comp_units[i / 2] = the_cu;
2138 }
2139
2140 return 1;
2141 }
2142
2143 /* Create the signatured type hash table from the index. */
2144
2145 static int
2146 create_signatured_type_table_from_index (struct objfile *objfile,
2147 struct dwarf2_section_info *section,
2148 const gdb_byte *bytes,
2149 offset_type elements)
2150 {
2151 offset_type i;
2152 htab_t sig_types_hash;
2153
2154 dwarf2_per_objfile->n_type_units = elements / 3;
2155 dwarf2_per_objfile->all_type_units
2156 = obstack_alloc (&objfile->objfile_obstack,
2157 dwarf2_per_objfile->n_type_units
2158 * sizeof (struct signatured_type *));
2159
2160 sig_types_hash = allocate_signatured_type_table (objfile);
2161
2162 for (i = 0; i < elements; i += 3)
2163 {
2164 struct signatured_type *sig_type;
2165 ULONGEST offset, type_offset_in_tu, signature;
2166 void **slot;
2167
2168 if (!extract_cu_value (bytes, &offset)
2169 || !extract_cu_value (bytes + 8, &type_offset_in_tu))
2170 return 0;
2171 signature = extract_unsigned_integer (bytes + 16, 8, BFD_ENDIAN_LITTLE);
2172 bytes += 3 * 8;
2173
2174 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2175 struct signatured_type);
2176 sig_type->signature = signature;
2177 sig_type->type_offset_in_tu.cu_off = type_offset_in_tu;
2178 sig_type->per_cu.is_debug_types = 1;
2179 sig_type->per_cu.info_or_types_section = section;
2180 sig_type->per_cu.offset.sect_off = offset;
2181 sig_type->per_cu.objfile = objfile;
2182 sig_type->per_cu.v.quick
2183 = OBSTACK_ZALLOC (&objfile->objfile_obstack,
2184 struct dwarf2_per_cu_quick_data);
2185
2186 slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
2187 *slot = sig_type;
2188
2189 dwarf2_per_objfile->all_type_units[i / 3] = sig_type;
2190 }
2191
2192 dwarf2_per_objfile->signatured_types = sig_types_hash;
2193
2194 return 1;
2195 }
2196
2197 /* Read the address map data from the mapped index, and use it to
2198 populate the objfile's psymtabs_addrmap. */
2199
2200 static void
2201 create_addrmap_from_index (struct objfile *objfile, struct mapped_index *index)
2202 {
2203 const gdb_byte *iter, *end;
2204 struct obstack temp_obstack;
2205 struct addrmap *mutable_map;
2206 struct cleanup *cleanup;
2207 CORE_ADDR baseaddr;
2208
2209 obstack_init (&temp_obstack);
2210 cleanup = make_cleanup_obstack_free (&temp_obstack);
2211 mutable_map = addrmap_create_mutable (&temp_obstack);
2212
2213 iter = index->address_table;
2214 end = iter + index->address_table_size;
2215
2216 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2217
2218 while (iter < end)
2219 {
2220 ULONGEST hi, lo, cu_index;
2221 lo = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
2222 iter += 8;
2223 hi = extract_unsigned_integer (iter, 8, BFD_ENDIAN_LITTLE);
2224 iter += 8;
2225 cu_index = extract_unsigned_integer (iter, 4, BFD_ENDIAN_LITTLE);
2226 iter += 4;
2227
2228 addrmap_set_empty (mutable_map, lo + baseaddr, hi + baseaddr - 1,
2229 dw2_get_cu (cu_index));
2230 }
2231
2232 objfile->psymtabs_addrmap = addrmap_create_fixed (mutable_map,
2233 &objfile->objfile_obstack);
2234 do_cleanups (cleanup);
2235 }
2236
2237 /* The hash function for strings in the mapped index. This is the same as
2238 SYMBOL_HASH_NEXT, but we keep a separate copy to maintain control over the
2239 implementation. This is necessary because the hash function is tied to the
2240 format of the mapped index file. The hash values do not have to match with
2241 SYMBOL_HASH_NEXT.
2242
2243 Use INT_MAX for INDEX_VERSION if you generate the current index format. */
2244
2245 static hashval_t
2246 mapped_index_string_hash (int index_version, const void *p)
2247 {
2248 const unsigned char *str = (const unsigned char *) p;
2249 hashval_t r = 0;
2250 unsigned char c;
2251
2252 while ((c = *str++) != 0)
2253 {
2254 if (index_version >= 5)
2255 c = tolower (c);
2256 r = r * 67 + c - 113;
2257 }
2258
2259 return r;
2260 }
2261
2262 /* Find a slot in the mapped index INDEX for the object named NAME.
2263 If NAME is found, set *VEC_OUT to point to the CU vector in the
2264 constant pool and return 1. If NAME cannot be found, return 0. */
2265
2266 static int
2267 find_slot_in_mapped_hash (struct mapped_index *index, const char *name,
2268 offset_type **vec_out)
2269 {
2270 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
2271 offset_type hash;
2272 offset_type slot, step;
2273 int (*cmp) (const char *, const char *);
2274
2275 if (current_language->la_language == language_cplus
2276 || current_language->la_language == language_java
2277 || current_language->la_language == language_fortran)
2278 {
2279 /* NAME is already canonical. Drop any qualifiers as .gdb_index does
2280 not contain any. */
2281 const char *paren = strchr (name, '(');
2282
2283 if (paren)
2284 {
2285 char *dup;
2286
2287 dup = xmalloc (paren - name + 1);
2288 memcpy (dup, name, paren - name);
2289 dup[paren - name] = 0;
2290
2291 make_cleanup (xfree, dup);
2292 name = dup;
2293 }
2294 }
2295
2296 /* Index version 4 did not support case insensitive searches. But the
2297 indices for case insensitive languages are built in lowercase, therefore
2298 simulate our NAME being searched is also lowercased. */
2299 hash = mapped_index_string_hash ((index->version == 4
2300 && case_sensitivity == case_sensitive_off
2301 ? 5 : index->version),
2302 name);
2303
2304 slot = hash & (index->symbol_table_slots - 1);
2305 step = ((hash * 17) & (index->symbol_table_slots - 1)) | 1;
2306 cmp = (case_sensitivity == case_sensitive_on ? strcmp : strcasecmp);
2307
2308 for (;;)
2309 {
2310 /* Convert a slot number to an offset into the table. */
2311 offset_type i = 2 * slot;
2312 const char *str;
2313 if (index->symbol_table[i] == 0 && index->symbol_table[i + 1] == 0)
2314 {
2315 do_cleanups (back_to);
2316 return 0;
2317 }
2318
2319 str = index->constant_pool + MAYBE_SWAP (index->symbol_table[i]);
2320 if (!cmp (name, str))
2321 {
2322 *vec_out = (offset_type *) (index->constant_pool
2323 + MAYBE_SWAP (index->symbol_table[i + 1]));
2324 do_cleanups (back_to);
2325 return 1;
2326 }
2327
2328 slot = (slot + step) & (index->symbol_table_slots - 1);
2329 }
2330 }
2331
2332 /* Read the index file. If everything went ok, initialize the "quick"
2333 elements of all the CUs and return 1. Otherwise, return 0. */
2334
2335 static int
2336 dwarf2_read_index (struct objfile *objfile)
2337 {
2338 char *addr;
2339 struct mapped_index *map;
2340 offset_type *metadata;
2341 const gdb_byte *cu_list;
2342 const gdb_byte *types_list = NULL;
2343 offset_type version, cu_list_elements;
2344 offset_type types_list_elements = 0;
2345 int i;
2346
2347 if (dwarf2_section_empty_p (&dwarf2_per_objfile->gdb_index))
2348 return 0;
2349
2350 /* Older elfutils strip versions could keep the section in the main
2351 executable while splitting it for the separate debug info file. */
2352 if ((bfd_get_file_flags (dwarf2_per_objfile->gdb_index.asection)
2353 & SEC_HAS_CONTENTS) == 0)
2354 return 0;
2355
2356 dwarf2_read_section (objfile, &dwarf2_per_objfile->gdb_index);
2357
2358 addr = dwarf2_per_objfile->gdb_index.buffer;
2359 /* Version check. */
2360 version = MAYBE_SWAP (*(offset_type *) addr);
2361 /* Versions earlier than 3 emitted every copy of a psymbol. This
2362 causes the index to behave very poorly for certain requests. Version 3
2363 contained incomplete addrmap. So, it seems better to just ignore such
2364 indices. */
2365 if (version < 4)
2366 {
2367 static int warning_printed = 0;
2368 if (!warning_printed)
2369 {
2370 warning (_("Skipping obsolete .gdb_index section in %s."),
2371 objfile->name);
2372 warning_printed = 1;
2373 }
2374 return 0;
2375 }
2376 /* Index version 4 uses a different hash function than index version
2377 5 and later.
2378
2379 Versions earlier than 6 did not emit psymbols for inlined
2380 functions. Using these files will cause GDB not to be able to
2381 set breakpoints on inlined functions by name, so we ignore these
2382 indices unless the --use-deprecated-index-sections command line
2383 option was supplied. */
2384 if (version < 6 && !use_deprecated_index_sections)
2385 {
2386 static int warning_printed = 0;
2387 if (!warning_printed)
2388 {
2389 warning (_("Skipping deprecated .gdb_index section in %s, pass "
2390 "--use-deprecated-index-sections to use them anyway"),
2391 objfile->name);
2392 warning_printed = 1;
2393 }
2394 return 0;
2395 }
2396 /* Indexes with higher version than the one supported by GDB may be no
2397 longer backward compatible. */
2398 if (version > 7)
2399 return 0;
2400
2401 map = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct mapped_index);
2402 map->version = version;
2403 map->total_size = dwarf2_per_objfile->gdb_index.size;
2404
2405 metadata = (offset_type *) (addr + sizeof (offset_type));
2406
2407 i = 0;
2408 cu_list = addr + MAYBE_SWAP (metadata[i]);
2409 cu_list_elements = ((MAYBE_SWAP (metadata[i + 1]) - MAYBE_SWAP (metadata[i]))
2410 / 8);
2411 ++i;
2412
2413 types_list = addr + MAYBE_SWAP (metadata[i]);
2414 types_list_elements = ((MAYBE_SWAP (metadata[i + 1])
2415 - MAYBE_SWAP (metadata[i]))
2416 / 8);
2417 ++i;
2418
2419 map->address_table = addr + MAYBE_SWAP (metadata[i]);
2420 map->address_table_size = (MAYBE_SWAP (metadata[i + 1])
2421 - MAYBE_SWAP (metadata[i]));
2422 ++i;
2423
2424 map->symbol_table = (offset_type *) (addr + MAYBE_SWAP (metadata[i]));
2425 map->symbol_table_slots = ((MAYBE_SWAP (metadata[i + 1])
2426 - MAYBE_SWAP (metadata[i]))
2427 / (2 * sizeof (offset_type)));
2428 ++i;
2429
2430 map->constant_pool = addr + MAYBE_SWAP (metadata[i]);
2431
2432 /* Don't use the index if it's empty. */
2433 if (map->symbol_table_slots == 0)
2434 return 0;
2435
2436 if (!create_cus_from_index (objfile, cu_list, cu_list_elements))
2437 return 0;
2438
2439 if (types_list_elements)
2440 {
2441 struct dwarf2_section_info *section;
2442
2443 /* We can only handle a single .debug_types when we have an
2444 index. */
2445 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) != 1)
2446 return 0;
2447
2448 section = VEC_index (dwarf2_section_info_def,
2449 dwarf2_per_objfile->types, 0);
2450
2451 if (!create_signatured_type_table_from_index (objfile, section,
2452 types_list,
2453 types_list_elements))
2454 return 0;
2455 }
2456
2457 create_addrmap_from_index (objfile, map);
2458
2459 dwarf2_per_objfile->index_table = map;
2460 dwarf2_per_objfile->using_index = 1;
2461 dwarf2_per_objfile->quick_file_names_table =
2462 create_quick_file_names_table (dwarf2_per_objfile->n_comp_units);
2463
2464 return 1;
2465 }
2466
2467 /* A helper for the "quick" functions which sets the global
2468 dwarf2_per_objfile according to OBJFILE. */
2469
2470 static void
2471 dw2_setup (struct objfile *objfile)
2472 {
2473 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
2474 gdb_assert (dwarf2_per_objfile);
2475 }
2476
2477 /* die_reader_func for dw2_get_file_names. */
2478
2479 static void
2480 dw2_get_file_names_reader (const struct die_reader_specs *reader,
2481 gdb_byte *info_ptr,
2482 struct die_info *comp_unit_die,
2483 int has_children,
2484 void *data)
2485 {
2486 struct dwarf2_cu *cu = reader->cu;
2487 struct dwarf2_per_cu_data *this_cu = cu->per_cu;
2488 struct objfile *objfile = dwarf2_per_objfile->objfile;
2489 struct line_header *lh;
2490 struct attribute *attr;
2491 int i;
2492 char *name, *comp_dir;
2493 void **slot;
2494 struct quick_file_names *qfn;
2495 unsigned int line_offset;
2496
2497 /* Our callers never want to match partial units -- instead they
2498 will match the enclosing full CU. */
2499 if (comp_unit_die->tag == DW_TAG_partial_unit)
2500 {
2501 this_cu->v.quick->no_file_data = 1;
2502 return;
2503 }
2504
2505 lh = NULL;
2506 slot = NULL;
2507 line_offset = 0;
2508
2509 attr = dwarf2_attr (comp_unit_die, DW_AT_stmt_list, cu);
2510 if (attr)
2511 {
2512 struct quick_file_names find_entry;
2513
2514 line_offset = DW_UNSND (attr);
2515
2516 /* We may have already read in this line header (TU line header sharing).
2517 If we have we're done. */
2518 find_entry.offset = line_offset;
2519 slot = htab_find_slot (dwarf2_per_objfile->quick_file_names_table,
2520 &find_entry, INSERT);
2521 if (*slot != NULL)
2522 {
2523 this_cu->v.quick->file_names = *slot;
2524 return;
2525 }
2526
2527 lh = dwarf_decode_line_header (line_offset, cu);
2528 }
2529 if (lh == NULL)
2530 {
2531 this_cu->v.quick->no_file_data = 1;
2532 return;
2533 }
2534
2535 qfn = obstack_alloc (&objfile->objfile_obstack, sizeof (*qfn));
2536 qfn->offset = line_offset;
2537 gdb_assert (slot != NULL);
2538 *slot = qfn;
2539
2540 find_file_and_directory (comp_unit_die, cu, &name, &comp_dir);
2541
2542 qfn->num_file_names = lh->num_file_names;
2543 qfn->file_names = obstack_alloc (&objfile->objfile_obstack,
2544 lh->num_file_names * sizeof (char *));
2545 for (i = 0; i < lh->num_file_names; ++i)
2546 qfn->file_names[i] = file_full_name (i + 1, lh, comp_dir);
2547 qfn->real_names = NULL;
2548
2549 free_line_header (lh);
2550
2551 this_cu->v.quick->file_names = qfn;
2552 }
2553
2554 /* A helper for the "quick" functions which attempts to read the line
2555 table for THIS_CU. */
2556
2557 static struct quick_file_names *
2558 dw2_get_file_names (struct objfile *objfile,
2559 struct dwarf2_per_cu_data *this_cu)
2560 {
2561 if (this_cu->v.quick->file_names != NULL)
2562 return this_cu->v.quick->file_names;
2563 /* If we know there is no line data, no point in looking again. */
2564 if (this_cu->v.quick->no_file_data)
2565 return NULL;
2566
2567 /* If DWO files are in use, we can still find the DW_AT_stmt_list attribute
2568 in the stub for CUs, there's is no need to lookup the DWO file.
2569 However, that's not the case for TUs where DW_AT_stmt_list lives in the
2570 DWO file. */
2571 if (this_cu->is_debug_types)
2572 init_cutu_and_read_dies (this_cu, 0, 0, dw2_get_file_names_reader, NULL);
2573 else
2574 init_cutu_and_read_dies_simple (this_cu, dw2_get_file_names_reader, NULL);
2575
2576 if (this_cu->v.quick->no_file_data)
2577 return NULL;
2578 return this_cu->v.quick->file_names;
2579 }
2580
2581 /* A helper for the "quick" functions which computes and caches the
2582 real path for a given file name from the line table. */
2583
2584 static const char *
2585 dw2_get_real_path (struct objfile *objfile,
2586 struct quick_file_names *qfn, int index)
2587 {
2588 if (qfn->real_names == NULL)
2589 qfn->real_names = OBSTACK_CALLOC (&objfile->objfile_obstack,
2590 qfn->num_file_names, sizeof (char *));
2591
2592 if (qfn->real_names[index] == NULL)
2593 qfn->real_names[index] = gdb_realpath (qfn->file_names[index]);
2594
2595 return qfn->real_names[index];
2596 }
2597
2598 static struct symtab *
2599 dw2_find_last_source_symtab (struct objfile *objfile)
2600 {
2601 int index;
2602
2603 dw2_setup (objfile);
2604 index = dwarf2_per_objfile->n_comp_units - 1;
2605 return dw2_instantiate_symtab (dw2_get_cu (index));
2606 }
2607
2608 /* Traversal function for dw2_forget_cached_source_info. */
2609
2610 static int
2611 dw2_free_cached_file_names (void **slot, void *info)
2612 {
2613 struct quick_file_names *file_data = (struct quick_file_names *) *slot;
2614
2615 if (file_data->real_names)
2616 {
2617 int i;
2618
2619 for (i = 0; i < file_data->num_file_names; ++i)
2620 {
2621 xfree ((void*) file_data->real_names[i]);
2622 file_data->real_names[i] = NULL;
2623 }
2624 }
2625
2626 return 1;
2627 }
2628
2629 static void
2630 dw2_forget_cached_source_info (struct objfile *objfile)
2631 {
2632 dw2_setup (objfile);
2633
2634 htab_traverse_noresize (dwarf2_per_objfile->quick_file_names_table,
2635 dw2_free_cached_file_names, NULL);
2636 }
2637
2638 /* Helper function for dw2_map_symtabs_matching_filename that expands
2639 the symtabs and calls the iterator. */
2640
2641 static int
2642 dw2_map_expand_apply (struct objfile *objfile,
2643 struct dwarf2_per_cu_data *per_cu,
2644 const char *name,
2645 const char *full_path, const char *real_path,
2646 int (*callback) (struct symtab *, void *),
2647 void *data)
2648 {
2649 struct symtab *last_made = objfile->symtabs;
2650
2651 /* Don't visit already-expanded CUs. */
2652 if (per_cu->v.quick->symtab)
2653 return 0;
2654
2655 /* This may expand more than one symtab, and we want to iterate over
2656 all of them. */
2657 dw2_instantiate_symtab (per_cu);
2658
2659 return iterate_over_some_symtabs (name, full_path, real_path, callback, data,
2660 objfile->symtabs, last_made);
2661 }
2662
2663 /* Implementation of the map_symtabs_matching_filename method. */
2664
2665 static int
2666 dw2_map_symtabs_matching_filename (struct objfile *objfile, const char *name,
2667 const char *full_path, const char *real_path,
2668 int (*callback) (struct symtab *, void *),
2669 void *data)
2670 {
2671 int i;
2672 const char *name_basename = lbasename (name);
2673 int name_len = strlen (name);
2674 int is_abs = IS_ABSOLUTE_PATH (name);
2675
2676 dw2_setup (objfile);
2677
2678 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2679 + dwarf2_per_objfile->n_type_units); ++i)
2680 {
2681 int j;
2682 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
2683 struct quick_file_names *file_data;
2684
2685 /* We only need to look at symtabs not already expanded. */
2686 if (per_cu->v.quick->symtab)
2687 continue;
2688
2689 file_data = dw2_get_file_names (objfile, per_cu);
2690 if (file_data == NULL)
2691 continue;
2692
2693 for (j = 0; j < file_data->num_file_names; ++j)
2694 {
2695 const char *this_name = file_data->file_names[j];
2696
2697 if (FILENAME_CMP (name, this_name) == 0
2698 || (!is_abs && compare_filenames_for_search (this_name,
2699 name, name_len)))
2700 {
2701 if (dw2_map_expand_apply (objfile, per_cu,
2702 name, full_path, real_path,
2703 callback, data))
2704 return 1;
2705 }
2706
2707 /* Before we invoke realpath, which can get expensive when many
2708 files are involved, do a quick comparison of the basenames. */
2709 if (! basenames_may_differ
2710 && FILENAME_CMP (lbasename (this_name), name_basename) != 0)
2711 continue;
2712
2713 if (full_path != NULL)
2714 {
2715 const char *this_real_name = dw2_get_real_path (objfile,
2716 file_data, j);
2717
2718 if (this_real_name != NULL
2719 && (FILENAME_CMP (full_path, this_real_name) == 0
2720 || (!is_abs
2721 && compare_filenames_for_search (this_real_name,
2722 name, name_len))))
2723 {
2724 if (dw2_map_expand_apply (objfile, per_cu,
2725 name, full_path, real_path,
2726 callback, data))
2727 return 1;
2728 }
2729 }
2730
2731 if (real_path != NULL)
2732 {
2733 const char *this_real_name = dw2_get_real_path (objfile,
2734 file_data, j);
2735
2736 if (this_real_name != NULL
2737 && (FILENAME_CMP (real_path, this_real_name) == 0
2738 || (!is_abs
2739 && compare_filenames_for_search (this_real_name,
2740 name, name_len))))
2741 {
2742 if (dw2_map_expand_apply (objfile, per_cu,
2743 name, full_path, real_path,
2744 callback, data))
2745 return 1;
2746 }
2747 }
2748 }
2749 }
2750
2751 return 0;
2752 }
2753
2754 static struct symtab *
2755 dw2_lookup_symbol (struct objfile *objfile, int block_index,
2756 const char *name, domain_enum domain)
2757 {
2758 /* We do all the work in the pre_expand_symtabs_matching hook
2759 instead. */
2760 return NULL;
2761 }
2762
2763 /* A helper function that expands all symtabs that hold an object
2764 named NAME. If WANT_SPECIFIC_BLOCK is non-zero, only look for
2765 symbols in block BLOCK_KIND. */
2766
2767 static void
2768 dw2_do_expand_symtabs_matching (struct objfile *objfile,
2769 int want_specific_block,
2770 enum block_enum block_kind,
2771 const char *name, domain_enum domain)
2772 {
2773 struct mapped_index *index;
2774
2775 dw2_setup (objfile);
2776
2777 index = dwarf2_per_objfile->index_table;
2778
2779 /* index_table is NULL if OBJF_READNOW. */
2780 if (index)
2781 {
2782 offset_type *vec;
2783
2784 if (find_slot_in_mapped_hash (index, name, &vec))
2785 {
2786 offset_type i, len = MAYBE_SWAP (*vec);
2787 for (i = 0; i < len; ++i)
2788 {
2789 offset_type cu_index_and_attrs = MAYBE_SWAP (vec[i + 1]);
2790 offset_type cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
2791 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (cu_index);
2792 int want_static = block_kind != GLOBAL_BLOCK;
2793 /* This value is only valid for index versions >= 7. */
2794 int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
2795 gdb_index_symbol_kind symbol_kind =
2796 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
2797
2798 if (want_specific_block
2799 && index->version >= 7
2800 && want_static != is_static)
2801 continue;
2802
2803 /* Only check the symbol's kind if it has one.
2804 Indices prior to version 7 don't record it. */
2805 if (index->version >= 7)
2806 {
2807 switch (domain)
2808 {
2809 case VAR_DOMAIN:
2810 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE
2811 && symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION
2812 /* Some types are also in VAR_DOMAIN. */
2813 && symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
2814 continue;
2815 break;
2816 case STRUCT_DOMAIN:
2817 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
2818 continue;
2819 break;
2820 case LABEL_DOMAIN:
2821 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_OTHER)
2822 continue;
2823 break;
2824 default:
2825 break;
2826 }
2827 }
2828
2829 dw2_instantiate_symtab (per_cu);
2830 }
2831 }
2832 }
2833 }
2834
2835 static void
2836 dw2_pre_expand_symtabs_matching (struct objfile *objfile,
2837 enum block_enum block_kind, const char *name,
2838 domain_enum domain)
2839 {
2840 dw2_do_expand_symtabs_matching (objfile, 1, block_kind, name, domain);
2841 }
2842
2843 static void
2844 dw2_print_stats (struct objfile *objfile)
2845 {
2846 int i, count;
2847
2848 dw2_setup (objfile);
2849 count = 0;
2850 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2851 + dwarf2_per_objfile->n_type_units); ++i)
2852 {
2853 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
2854
2855 if (!per_cu->v.quick->symtab)
2856 ++count;
2857 }
2858 printf_filtered (_(" Number of unread CUs: %d\n"), count);
2859 }
2860
2861 static void
2862 dw2_dump (struct objfile *objfile)
2863 {
2864 /* Nothing worth printing. */
2865 }
2866
2867 static void
2868 dw2_relocate (struct objfile *objfile, struct section_offsets *new_offsets,
2869 struct section_offsets *delta)
2870 {
2871 /* There's nothing to relocate here. */
2872 }
2873
2874 static void
2875 dw2_expand_symtabs_for_function (struct objfile *objfile,
2876 const char *func_name)
2877 {
2878 /* Note: It doesn't matter what we pass for block_kind here. */
2879 dw2_do_expand_symtabs_matching (objfile, 0, GLOBAL_BLOCK, func_name,
2880 VAR_DOMAIN);
2881 }
2882
2883 static void
2884 dw2_expand_all_symtabs (struct objfile *objfile)
2885 {
2886 int i;
2887
2888 dw2_setup (objfile);
2889
2890 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
2891 + dwarf2_per_objfile->n_type_units); ++i)
2892 {
2893 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
2894
2895 dw2_instantiate_symtab (per_cu);
2896 }
2897 }
2898
2899 static void
2900 dw2_expand_symtabs_with_filename (struct objfile *objfile,
2901 const char *filename)
2902 {
2903 int i;
2904
2905 dw2_setup (objfile);
2906
2907 /* We don't need to consider type units here.
2908 This is only called for examining code, e.g. expand_line_sal.
2909 There can be an order of magnitude (or more) more type units
2910 than comp units, and we avoid them if we can. */
2911
2912 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
2913 {
2914 int j;
2915 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
2916 struct quick_file_names *file_data;
2917
2918 /* We only need to look at symtabs not already expanded. */
2919 if (per_cu->v.quick->symtab)
2920 continue;
2921
2922 file_data = dw2_get_file_names (objfile, per_cu);
2923 if (file_data == NULL)
2924 continue;
2925
2926 for (j = 0; j < file_data->num_file_names; ++j)
2927 {
2928 const char *this_name = file_data->file_names[j];
2929 if (FILENAME_CMP (this_name, filename) == 0)
2930 {
2931 dw2_instantiate_symtab (per_cu);
2932 break;
2933 }
2934 }
2935 }
2936 }
2937
2938 /* A helper function for dw2_find_symbol_file that finds the primary
2939 file name for a given CU. This is a die_reader_func. */
2940
2941 static void
2942 dw2_get_primary_filename_reader (const struct die_reader_specs *reader,
2943 gdb_byte *info_ptr,
2944 struct die_info *comp_unit_die,
2945 int has_children,
2946 void *data)
2947 {
2948 const char **result_ptr = data;
2949 struct dwarf2_cu *cu = reader->cu;
2950 struct attribute *attr;
2951
2952 attr = dwarf2_attr (comp_unit_die, DW_AT_name, cu);
2953 if (attr == NULL)
2954 *result_ptr = NULL;
2955 else
2956 *result_ptr = DW_STRING (attr);
2957 }
2958
2959 static const char *
2960 dw2_find_symbol_file (struct objfile *objfile, const char *name)
2961 {
2962 struct dwarf2_per_cu_data *per_cu;
2963 offset_type *vec;
2964 struct quick_file_names *file_data;
2965 const char *filename;
2966
2967 dw2_setup (objfile);
2968
2969 /* index_table is NULL if OBJF_READNOW. */
2970 if (!dwarf2_per_objfile->index_table)
2971 {
2972 struct symtab *s;
2973
2974 ALL_OBJFILE_PRIMARY_SYMTABS (objfile, s)
2975 {
2976 struct blockvector *bv = BLOCKVECTOR (s);
2977 const struct block *block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
2978 struct symbol *sym = lookup_block_symbol (block, name, VAR_DOMAIN);
2979
2980 if (sym)
2981 return sym->symtab->filename;
2982 }
2983 return NULL;
2984 }
2985
2986 if (!find_slot_in_mapped_hash (dwarf2_per_objfile->index_table,
2987 name, &vec))
2988 return NULL;
2989
2990 /* Note that this just looks at the very first one named NAME -- but
2991 actually we are looking for a function. find_main_filename
2992 should be rewritten so that it doesn't require a custom hook. It
2993 could just use the ordinary symbol tables. */
2994 /* vec[0] is the length, which must always be >0. */
2995 per_cu = dw2_get_cu (GDB_INDEX_CU_VALUE (MAYBE_SWAP (vec[1])));
2996
2997 if (per_cu->v.quick->symtab != NULL)
2998 return per_cu->v.quick->symtab->filename;
2999
3000 init_cutu_and_read_dies (per_cu, 0, 0, dw2_get_primary_filename_reader,
3001 &filename);
3002
3003 return filename;
3004 }
3005
3006 static void
3007 dw2_map_matching_symbols (const char * name, domain_enum namespace,
3008 struct objfile *objfile, int global,
3009 int (*callback) (struct block *,
3010 struct symbol *, void *),
3011 void *data, symbol_compare_ftype *match,
3012 symbol_compare_ftype *ordered_compare)
3013 {
3014 /* Currently unimplemented; used for Ada. The function can be called if the
3015 current language is Ada for a non-Ada objfile using GNU index. As Ada
3016 does not look for non-Ada symbols this function should just return. */
3017 }
3018
3019 static void
3020 dw2_expand_symtabs_matching
3021 (struct objfile *objfile,
3022 int (*file_matcher) (const char *, void *),
3023 int (*name_matcher) (const char *, void *),
3024 enum search_domain kind,
3025 void *data)
3026 {
3027 int i;
3028 offset_type iter;
3029 struct mapped_index *index;
3030
3031 dw2_setup (objfile);
3032
3033 /* index_table is NULL if OBJF_READNOW. */
3034 if (!dwarf2_per_objfile->index_table)
3035 return;
3036 index = dwarf2_per_objfile->index_table;
3037
3038 if (file_matcher != NULL)
3039 {
3040 struct cleanup *cleanup;
3041 htab_t visited_found, visited_not_found;
3042
3043 visited_found = htab_create_alloc (10,
3044 htab_hash_pointer, htab_eq_pointer,
3045 NULL, xcalloc, xfree);
3046 cleanup = make_cleanup_htab_delete (visited_found);
3047 visited_not_found = htab_create_alloc (10,
3048 htab_hash_pointer, htab_eq_pointer,
3049 NULL, xcalloc, xfree);
3050 make_cleanup_htab_delete (visited_not_found);
3051
3052 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
3053 + dwarf2_per_objfile->n_type_units); ++i)
3054 {
3055 int j;
3056 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
3057 struct quick_file_names *file_data;
3058 void **slot;
3059
3060 per_cu->v.quick->mark = 0;
3061
3062 /* We only need to look at symtabs not already expanded. */
3063 if (per_cu->v.quick->symtab)
3064 continue;
3065
3066 file_data = dw2_get_file_names (objfile, per_cu);
3067 if (file_data == NULL)
3068 continue;
3069
3070 if (htab_find (visited_not_found, file_data) != NULL)
3071 continue;
3072 else if (htab_find (visited_found, file_data) != NULL)
3073 {
3074 per_cu->v.quick->mark = 1;
3075 continue;
3076 }
3077
3078 for (j = 0; j < file_data->num_file_names; ++j)
3079 {
3080 if (file_matcher (file_data->file_names[j], data))
3081 {
3082 per_cu->v.quick->mark = 1;
3083 break;
3084 }
3085 }
3086
3087 slot = htab_find_slot (per_cu->v.quick->mark
3088 ? visited_found
3089 : visited_not_found,
3090 file_data, INSERT);
3091 *slot = file_data;
3092 }
3093
3094 do_cleanups (cleanup);
3095 }
3096
3097 for (iter = 0; iter < index->symbol_table_slots; ++iter)
3098 {
3099 offset_type idx = 2 * iter;
3100 const char *name;
3101 offset_type *vec, vec_len, vec_idx;
3102
3103 if (index->symbol_table[idx] == 0 && index->symbol_table[idx + 1] == 0)
3104 continue;
3105
3106 name = index->constant_pool + MAYBE_SWAP (index->symbol_table[idx]);
3107
3108 if (! (*name_matcher) (name, data))
3109 continue;
3110
3111 /* The name was matched, now expand corresponding CUs that were
3112 marked. */
3113 vec = (offset_type *) (index->constant_pool
3114 + MAYBE_SWAP (index->symbol_table[idx + 1]));
3115 vec_len = MAYBE_SWAP (vec[0]);
3116 for (vec_idx = 0; vec_idx < vec_len; ++vec_idx)
3117 {
3118 struct dwarf2_per_cu_data *per_cu;
3119 offset_type cu_index_and_attrs = MAYBE_SWAP (vec[vec_idx + 1]);
3120 gdb_index_symbol_kind symbol_kind =
3121 GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs);
3122 int cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
3123
3124 /* Don't crash on bad data. */
3125 if (cu_index >= (dwarf2_per_objfile->n_comp_units
3126 + dwarf2_per_objfile->n_type_units))
3127 continue;
3128
3129 /* Only check the symbol's kind if it has one.
3130 Indices prior to version 7 don't record it. */
3131 if (index->version >= 7)
3132 {
3133 switch (kind)
3134 {
3135 case VARIABLES_DOMAIN:
3136 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_VARIABLE)
3137 continue;
3138 break;
3139 case FUNCTIONS_DOMAIN:
3140 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_FUNCTION)
3141 continue;
3142 break;
3143 case TYPES_DOMAIN:
3144 if (symbol_kind != GDB_INDEX_SYMBOL_KIND_TYPE)
3145 continue;
3146 break;
3147 default:
3148 break;
3149 }
3150 }
3151
3152 per_cu = dw2_get_cu (cu_index);
3153 if (file_matcher == NULL || per_cu->v.quick->mark)
3154 dw2_instantiate_symtab (per_cu);
3155 }
3156 }
3157 }
3158
3159 /* A helper for dw2_find_pc_sect_symtab which finds the most specific
3160 symtab. */
3161
3162 static struct symtab *
3163 recursively_find_pc_sect_symtab (struct symtab *symtab, CORE_ADDR pc)
3164 {
3165 int i;
3166
3167 if (BLOCKVECTOR (symtab) != NULL
3168 && blockvector_contains_pc (BLOCKVECTOR (symtab), pc))
3169 return symtab;
3170
3171 if (symtab->includes == NULL)
3172 return NULL;
3173
3174 for (i = 0; symtab->includes[i]; ++i)
3175 {
3176 struct symtab *s = symtab->includes[i];
3177
3178 s = recursively_find_pc_sect_symtab (s, pc);
3179 if (s != NULL)
3180 return s;
3181 }
3182
3183 return NULL;
3184 }
3185
3186 static struct symtab *
3187 dw2_find_pc_sect_symtab (struct objfile *objfile,
3188 struct minimal_symbol *msymbol,
3189 CORE_ADDR pc,
3190 struct obj_section *section,
3191 int warn_if_readin)
3192 {
3193 struct dwarf2_per_cu_data *data;
3194 struct symtab *result;
3195
3196 dw2_setup (objfile);
3197
3198 if (!objfile->psymtabs_addrmap)
3199 return NULL;
3200
3201 data = addrmap_find (objfile->psymtabs_addrmap, pc);
3202 if (!data)
3203 return NULL;
3204
3205 if (warn_if_readin && data->v.quick->symtab)
3206 warning (_("(Internal error: pc %s in read in CU, but not in symtab.)"),
3207 paddress (get_objfile_arch (objfile), pc));
3208
3209 result = recursively_find_pc_sect_symtab (dw2_instantiate_symtab (data), pc);
3210 gdb_assert (result != NULL);
3211 return result;
3212 }
3213
3214 static void
3215 dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun,
3216 void *data, int need_fullname)
3217 {
3218 int i;
3219 struct cleanup *cleanup;
3220 htab_t visited = htab_create_alloc (10, htab_hash_pointer, htab_eq_pointer,
3221 NULL, xcalloc, xfree);
3222
3223 cleanup = make_cleanup_htab_delete (visited);
3224 dw2_setup (objfile);
3225
3226 /* We can ignore file names coming from already-expanded CUs. */
3227 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
3228 + dwarf2_per_objfile->n_type_units); ++i)
3229 {
3230 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
3231
3232 if (per_cu->v.quick->symtab)
3233 {
3234 void **slot = htab_find_slot (visited, per_cu->v.quick->file_names,
3235 INSERT);
3236
3237 *slot = per_cu->v.quick->file_names;
3238 }
3239 }
3240
3241 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
3242 + dwarf2_per_objfile->n_type_units); ++i)
3243 {
3244 int j;
3245 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
3246 struct quick_file_names *file_data;
3247 void **slot;
3248
3249 /* We only need to look at symtabs not already expanded. */
3250 if (per_cu->v.quick->symtab)
3251 continue;
3252
3253 file_data = dw2_get_file_names (objfile, per_cu);
3254 if (file_data == NULL)
3255 continue;
3256
3257 slot = htab_find_slot (visited, file_data, INSERT);
3258 if (*slot)
3259 {
3260 /* Already visited. */
3261 continue;
3262 }
3263 *slot = file_data;
3264
3265 for (j = 0; j < file_data->num_file_names; ++j)
3266 {
3267 const char *this_real_name;
3268
3269 if (need_fullname)
3270 this_real_name = dw2_get_real_path (objfile, file_data, j);
3271 else
3272 this_real_name = NULL;
3273 (*fun) (file_data->file_names[j], this_real_name, data);
3274 }
3275 }
3276
3277 do_cleanups (cleanup);
3278 }
3279
3280 static int
3281 dw2_has_symbols (struct objfile *objfile)
3282 {
3283 return 1;
3284 }
3285
3286 const struct quick_symbol_functions dwarf2_gdb_index_functions =
3287 {
3288 dw2_has_symbols,
3289 dw2_find_last_source_symtab,
3290 dw2_forget_cached_source_info,
3291 dw2_map_symtabs_matching_filename,
3292 dw2_lookup_symbol,
3293 dw2_pre_expand_symtabs_matching,
3294 dw2_print_stats,
3295 dw2_dump,
3296 dw2_relocate,
3297 dw2_expand_symtabs_for_function,
3298 dw2_expand_all_symtabs,
3299 dw2_expand_symtabs_with_filename,
3300 dw2_find_symbol_file,
3301 dw2_map_matching_symbols,
3302 dw2_expand_symtabs_matching,
3303 dw2_find_pc_sect_symtab,
3304 dw2_map_symbol_filenames
3305 };
3306
3307 /* Initialize for reading DWARF for this objfile. Return 0 if this
3308 file will use psymtabs, or 1 if using the GNU index. */
3309
3310 int
3311 dwarf2_initialize_objfile (struct objfile *objfile)
3312 {
3313 /* If we're about to read full symbols, don't bother with the
3314 indices. In this case we also don't care if some other debug
3315 format is making psymtabs, because they are all about to be
3316 expanded anyway. */
3317 if ((objfile->flags & OBJF_READNOW))
3318 {
3319 int i;
3320
3321 dwarf2_per_objfile->using_index = 1;
3322 create_all_comp_units (objfile);
3323 create_all_type_units (objfile);
3324 dwarf2_per_objfile->quick_file_names_table =
3325 create_quick_file_names_table (dwarf2_per_objfile->n_comp_units);
3326
3327 for (i = 0; i < (dwarf2_per_objfile->n_comp_units
3328 + dwarf2_per_objfile->n_type_units); ++i)
3329 {
3330 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
3331
3332 per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3333 struct dwarf2_per_cu_quick_data);
3334 }
3335
3336 /* Return 1 so that gdb sees the "quick" functions. However,
3337 these functions will be no-ops because we will have expanded
3338 all symtabs. */
3339 return 1;
3340 }
3341
3342 if (dwarf2_read_index (objfile))
3343 return 1;
3344
3345 return 0;
3346 }
3347
3348 \f
3349
3350 /* Build a partial symbol table. */
3351
3352 void
3353 dwarf2_build_psymtabs (struct objfile *objfile)
3354 {
3355 if (objfile->global_psymbols.size == 0 && objfile->static_psymbols.size == 0)
3356 {
3357 init_psymbol_list (objfile, 1024);
3358 }
3359
3360 dwarf2_build_psymtabs_hard (objfile);
3361 }
3362
3363 /* Return the total length of the CU described by HEADER. */
3364
3365 static unsigned int
3366 get_cu_length (const struct comp_unit_head *header)
3367 {
3368 return header->initial_length_size + header->length;
3369 }
3370
3371 /* Return TRUE if OFFSET is within CU_HEADER. */
3372
3373 static inline int
3374 offset_in_cu_p (const struct comp_unit_head *cu_header, sect_offset offset)
3375 {
3376 sect_offset bottom = { cu_header->offset.sect_off };
3377 sect_offset top = { cu_header->offset.sect_off + get_cu_length (cu_header) };
3378
3379 return (offset.sect_off >= bottom.sect_off && offset.sect_off < top.sect_off);
3380 }
3381
3382 /* Find the base address of the compilation unit for range lists and
3383 location lists. It will normally be specified by DW_AT_low_pc.
3384 In DWARF-3 draft 4, the base address could be overridden by
3385 DW_AT_entry_pc. It's been removed, but GCC still uses this for
3386 compilation units with discontinuous ranges. */
3387
3388 static void
3389 dwarf2_find_base_address (struct die_info *die, struct dwarf2_cu *cu)
3390 {
3391 struct attribute *attr;
3392
3393 cu->base_known = 0;
3394 cu->base_address = 0;
3395
3396 attr = dwarf2_attr (die, DW_AT_entry_pc, cu);
3397 if (attr)
3398 {
3399 cu->base_address = DW_ADDR (attr);
3400 cu->base_known = 1;
3401 }
3402 else
3403 {
3404 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
3405 if (attr)
3406 {
3407 cu->base_address = DW_ADDR (attr);
3408 cu->base_known = 1;
3409 }
3410 }
3411 }
3412
3413 /* Read in the comp unit header information from the debug_info at info_ptr.
3414 NOTE: This leaves members offset, first_die_offset to be filled in
3415 by the caller. */
3416
3417 static gdb_byte *
3418 read_comp_unit_head (struct comp_unit_head *cu_header,
3419 gdb_byte *info_ptr, bfd *abfd)
3420 {
3421 int signed_addr;
3422 unsigned int bytes_read;
3423
3424 cu_header->length = read_initial_length (abfd, info_ptr, &bytes_read);
3425 cu_header->initial_length_size = bytes_read;
3426 cu_header->offset_size = (bytes_read == 4) ? 4 : 8;
3427 info_ptr += bytes_read;
3428 cu_header->version = read_2_bytes (abfd, info_ptr);
3429 info_ptr += 2;
3430 cu_header->abbrev_offset.sect_off = read_offset (abfd, info_ptr, cu_header,
3431 &bytes_read);
3432 info_ptr += bytes_read;
3433 cu_header->addr_size = read_1_byte (abfd, info_ptr);
3434 info_ptr += 1;
3435 signed_addr = bfd_get_sign_extend_vma (abfd);
3436 if (signed_addr < 0)
3437 internal_error (__FILE__, __LINE__,
3438 _("read_comp_unit_head: dwarf from non elf file"));
3439 cu_header->signed_addr_p = signed_addr;
3440
3441 return info_ptr;
3442 }
3443
3444 /* Subroutine of read_and_check_comp_unit_head and
3445 read_and_check_type_unit_head to simplify them.
3446 Perform various error checking on the header. */
3447
3448 static void
3449 error_check_comp_unit_head (struct comp_unit_head *header,
3450 struct dwarf2_section_info *section,
3451 struct dwarf2_section_info *abbrev_section)
3452 {
3453 bfd *abfd = section->asection->owner;
3454 const char *filename = bfd_get_filename (abfd);
3455
3456 if (header->version != 2 && header->version != 3 && header->version != 4)
3457 error (_("Dwarf Error: wrong version in compilation unit header "
3458 "(is %d, should be 2, 3, or 4) [in module %s]"), header->version,
3459 filename);
3460
3461 if (header->abbrev_offset.sect_off
3462 >= dwarf2_section_size (dwarf2_per_objfile->objfile,
3463 &dwarf2_per_objfile->abbrev))
3464 error (_("Dwarf Error: bad offset (0x%lx) in compilation unit header "
3465 "(offset 0x%lx + 6) [in module %s]"),
3466 (long) header->abbrev_offset.sect_off, (long) header->offset.sect_off,
3467 filename);
3468
3469 /* Cast to unsigned long to use 64-bit arithmetic when possible to
3470 avoid potential 32-bit overflow. */
3471 if (((unsigned long) header->offset.sect_off + get_cu_length (header))
3472 > section->size)
3473 error (_("Dwarf Error: bad length (0x%lx) in compilation unit header "
3474 "(offset 0x%lx + 0) [in module %s]"),
3475 (long) header->length, (long) header->offset.sect_off,
3476 filename);
3477 }
3478
3479 /* Read in a CU/TU header and perform some basic error checking.
3480 The contents of the header are stored in HEADER.
3481 The result is a pointer to the start of the first DIE. */
3482
3483 static gdb_byte *
3484 read_and_check_comp_unit_head (struct comp_unit_head *header,
3485 struct dwarf2_section_info *section,
3486 struct dwarf2_section_info *abbrev_section,
3487 gdb_byte *info_ptr,
3488 int is_debug_types_section)
3489 {
3490 gdb_byte *beg_of_comp_unit = info_ptr;
3491 bfd *abfd = section->asection->owner;
3492
3493 header->offset.sect_off = beg_of_comp_unit - section->buffer;
3494
3495 info_ptr = read_comp_unit_head (header, info_ptr, abfd);
3496
3497 /* If we're reading a type unit, skip over the signature and
3498 type_offset fields. */
3499 if (is_debug_types_section)
3500 info_ptr += 8 /*signature*/ + header->offset_size;
3501
3502 header->first_die_offset.cu_off = info_ptr - beg_of_comp_unit;
3503
3504 error_check_comp_unit_head (header, section, abbrev_section);
3505
3506 return info_ptr;
3507 }
3508
3509 /* Read in the types comp unit header information from .debug_types entry at
3510 types_ptr. The result is a pointer to one past the end of the header. */
3511
3512 static gdb_byte *
3513 read_and_check_type_unit_head (struct comp_unit_head *header,
3514 struct dwarf2_section_info *section,
3515 struct dwarf2_section_info *abbrev_section,
3516 gdb_byte *info_ptr,
3517 ULONGEST *signature,
3518 cu_offset *type_offset_in_tu)
3519 {
3520 gdb_byte *beg_of_comp_unit = info_ptr;
3521 bfd *abfd = section->asection->owner;
3522
3523 header->offset.sect_off = beg_of_comp_unit - section->buffer;
3524
3525 info_ptr = read_comp_unit_head (header, info_ptr, abfd);
3526
3527 /* If we're reading a type unit, skip over the signature and
3528 type_offset fields. */
3529 if (signature != NULL)
3530 *signature = read_8_bytes (abfd, info_ptr);
3531 info_ptr += 8;
3532 if (type_offset_in_tu != NULL)
3533 type_offset_in_tu->cu_off = read_offset_1 (abfd, info_ptr,
3534 header->offset_size);
3535 info_ptr += header->offset_size;
3536
3537 header->first_die_offset.cu_off = info_ptr - beg_of_comp_unit;
3538
3539 error_check_comp_unit_head (header, section, abbrev_section);
3540
3541 return info_ptr;
3542 }
3543
3544 /* Allocate a new partial symtab for file named NAME and mark this new
3545 partial symtab as being an include of PST. */
3546
3547 static void
3548 dwarf2_create_include_psymtab (char *name, struct partial_symtab *pst,
3549 struct objfile *objfile)
3550 {
3551 struct partial_symtab *subpst = allocate_psymtab (name, objfile);
3552
3553 subpst->section_offsets = pst->section_offsets;
3554 subpst->textlow = 0;
3555 subpst->texthigh = 0;
3556
3557 subpst->dependencies = (struct partial_symtab **)
3558 obstack_alloc (&objfile->objfile_obstack,
3559 sizeof (struct partial_symtab *));
3560 subpst->dependencies[0] = pst;
3561 subpst->number_of_dependencies = 1;
3562
3563 subpst->globals_offset = 0;
3564 subpst->n_global_syms = 0;
3565 subpst->statics_offset = 0;
3566 subpst->n_static_syms = 0;
3567 subpst->symtab = NULL;
3568 subpst->read_symtab = pst->read_symtab;
3569 subpst->readin = 0;
3570
3571 /* No private part is necessary for include psymtabs. This property
3572 can be used to differentiate between such include psymtabs and
3573 the regular ones. */
3574 subpst->read_symtab_private = NULL;
3575 }
3576
3577 /* Read the Line Number Program data and extract the list of files
3578 included by the source file represented by PST. Build an include
3579 partial symtab for each of these included files. */
3580
3581 static void
3582 dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
3583 struct die_info *die,
3584 struct partial_symtab *pst)
3585 {
3586 struct line_header *lh = NULL;
3587 struct attribute *attr;
3588
3589 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
3590 if (attr)
3591 lh = dwarf_decode_line_header (DW_UNSND (attr), cu);
3592 if (lh == NULL)
3593 return; /* No linetable, so no includes. */
3594
3595 /* NOTE: pst->dirname is DW_AT_comp_dir (if present). */
3596 dwarf_decode_lines (lh, pst->dirname, cu, pst, 1);
3597
3598 free_line_header (lh);
3599 }
3600
3601 static hashval_t
3602 hash_signatured_type (const void *item)
3603 {
3604 const struct signatured_type *sig_type = item;
3605
3606 /* This drops the top 32 bits of the signature, but is ok for a hash. */
3607 return sig_type->signature;
3608 }
3609
3610 static int
3611 eq_signatured_type (const void *item_lhs, const void *item_rhs)
3612 {
3613 const struct signatured_type *lhs = item_lhs;
3614 const struct signatured_type *rhs = item_rhs;
3615
3616 return lhs->signature == rhs->signature;
3617 }
3618
3619 /* Allocate a hash table for signatured types. */
3620
3621 static htab_t
3622 allocate_signatured_type_table (struct objfile *objfile)
3623 {
3624 return htab_create_alloc_ex (41,
3625 hash_signatured_type,
3626 eq_signatured_type,
3627 NULL,
3628 &objfile->objfile_obstack,
3629 hashtab_obstack_allocate,
3630 dummy_obstack_deallocate);
3631 }
3632
3633 /* A helper function to add a signatured type CU to a table. */
3634
3635 static int
3636 add_signatured_type_cu_to_table (void **slot, void *datum)
3637 {
3638 struct signatured_type *sigt = *slot;
3639 struct signatured_type ***datap = datum;
3640
3641 **datap = sigt;
3642 ++*datap;
3643
3644 return 1;
3645 }
3646
3647 /* Create the hash table of all entries in the .debug_types section.
3648 DWO_FILE is a pointer to the DWO file for .debug_types.dwo, NULL otherwise.
3649 The result is a pointer to the hash table or NULL if there are
3650 no types. */
3651
3652 static htab_t
3653 create_debug_types_hash_table (struct dwo_file *dwo_file,
3654 VEC (dwarf2_section_info_def) *types)
3655 {
3656 struct objfile *objfile = dwarf2_per_objfile->objfile;
3657 htab_t types_htab = NULL;
3658 int ix;
3659 struct dwarf2_section_info *section;
3660 struct dwarf2_section_info *abbrev_section;
3661
3662 if (VEC_empty (dwarf2_section_info_def, types))
3663 return NULL;
3664
3665 abbrev_section = (dwo_file != NULL
3666 ? &dwo_file->sections.abbrev
3667 : &dwarf2_per_objfile->abbrev);
3668
3669 if (dwarf2_read_debug)
3670 fprintf_unfiltered (gdb_stdlog, "Reading .debug_types%s for %s:\n",
3671 dwo_file ? ".dwo" : "",
3672 bfd_get_filename (abbrev_section->asection->owner));
3673
3674 for (ix = 0;
3675 VEC_iterate (dwarf2_section_info_def, types, ix, section);
3676 ++ix)
3677 {
3678 bfd *abfd;
3679 gdb_byte *info_ptr, *end_ptr;
3680
3681 dwarf2_read_section (objfile, section);
3682 info_ptr = section->buffer;
3683
3684 if (info_ptr == NULL)
3685 continue;
3686
3687 /* We can't set abfd until now because the section may be empty or
3688 not present, in which case section->asection will be NULL. */
3689 abfd = section->asection->owner;
3690
3691 if (types_htab == NULL)
3692 {
3693 if (dwo_file)
3694 types_htab = allocate_dwo_unit_table (objfile);
3695 else
3696 types_htab = allocate_signatured_type_table (objfile);
3697 }
3698
3699 /* We don't use init_cutu_and_read_dies_simple, or some such, here
3700 because we don't need to read any dies: the signature is in the
3701 header. */
3702
3703 end_ptr = info_ptr + section->size;
3704 while (info_ptr < end_ptr)
3705 {
3706 sect_offset offset;
3707 cu_offset type_offset_in_tu;
3708 ULONGEST signature;
3709 struct signatured_type *sig_type;
3710 struct dwo_unit *dwo_tu;
3711 void **slot;
3712 gdb_byte *ptr = info_ptr;
3713 struct comp_unit_head header;
3714 unsigned int length;
3715
3716 offset.sect_off = ptr - section->buffer;
3717
3718 /* We need to read the type's signature in order to build the hash
3719 table, but we don't need anything else just yet. */
3720
3721 ptr = read_and_check_type_unit_head (&header, section,
3722 abbrev_section, ptr,
3723 &signature, &type_offset_in_tu);
3724
3725 length = get_cu_length (&header);
3726
3727 /* Skip dummy type units. */
3728 if (ptr >= info_ptr + length
3729 || peek_abbrev_code (abfd, ptr) == 0)
3730 {
3731 info_ptr += length;
3732 continue;
3733 }
3734
3735 if (dwo_file)
3736 {
3737 sig_type = NULL;
3738 dwo_tu = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3739 struct dwo_unit);
3740 dwo_tu->dwo_file = dwo_file;
3741 dwo_tu->signature = signature;
3742 dwo_tu->type_offset_in_tu = type_offset_in_tu;
3743 dwo_tu->info_or_types_section = section;
3744 dwo_tu->offset = offset;
3745 dwo_tu->length = length;
3746 }
3747 else
3748 {
3749 /* N.B.: type_offset is not usable if this type uses a DWO file.
3750 The real type_offset is in the DWO file. */
3751 dwo_tu = NULL;
3752 sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
3753 struct signatured_type);
3754 sig_type->signature = signature;
3755 sig_type->type_offset_in_tu = type_offset_in_tu;
3756 sig_type->per_cu.objfile = objfile;
3757 sig_type->per_cu.is_debug_types = 1;
3758 sig_type->per_cu.info_or_types_section = section;
3759 sig_type->per_cu.offset = offset;
3760 sig_type->per_cu.length = length;
3761 }
3762
3763 slot = htab_find_slot (types_htab,
3764 dwo_file ? (void*) dwo_tu : (void *) sig_type,
3765 INSERT);
3766 gdb_assert (slot != NULL);
3767 if (*slot != NULL)
3768 {
3769 sect_offset dup_offset;
3770
3771 if (dwo_file)
3772 {
3773 const struct dwo_unit *dup_tu = *slot;
3774
3775 dup_offset = dup_tu->offset;
3776 }
3777 else
3778 {
3779 const struct signatured_type *dup_tu = *slot;
3780
3781 dup_offset = dup_tu->per_cu.offset;
3782 }
3783
3784 complaint (&symfile_complaints,
3785 _("debug type entry at offset 0x%x is duplicate to the "
3786 "entry at offset 0x%x, signature 0x%s"),
3787 offset.sect_off, dup_offset.sect_off,
3788 phex (signature, sizeof (signature)));
3789 }
3790 *slot = dwo_file ? (void *) dwo_tu : (void *) sig_type;
3791
3792 if (dwarf2_read_debug)
3793 fprintf_unfiltered (gdb_stdlog, " offset 0x%x, signature 0x%s\n",
3794 offset.sect_off,
3795 phex (signature, sizeof (signature)));
3796
3797 info_ptr += length;
3798 }
3799 }
3800
3801 return types_htab;
3802 }
3803
3804 /* Create the hash table of all entries in the .debug_types section,
3805 and initialize all_type_units.
3806 The result is zero if there is an error (e.g. missing .debug_types section),
3807 otherwise non-zero. */
3808
3809 static int
3810 create_all_type_units (struct objfile *objfile)
3811 {
3812 htab_t types_htab;
3813 struct signatured_type **iter;
3814
3815 types_htab = create_debug_types_hash_table (NULL, dwarf2_per_objfile->types);
3816 if (types_htab == NULL)
3817 {
3818 dwarf2_per_objfile->signatured_types = NULL;
3819 return 0;
3820 }
3821
3822 dwarf2_per_objfile->signatured_types = types_htab;
3823
3824 dwarf2_per_objfile->n_type_units = htab_elements (types_htab);
3825 dwarf2_per_objfile->all_type_units
3826 = obstack_alloc (&objfile->objfile_obstack,
3827 dwarf2_per_objfile->n_type_units
3828 * sizeof (struct signatured_type *));
3829 iter = &dwarf2_per_objfile->all_type_units[0];
3830 htab_traverse_noresize (types_htab, add_signatured_type_cu_to_table, &iter);
3831 gdb_assert (iter - &dwarf2_per_objfile->all_type_units[0]
3832 == dwarf2_per_objfile->n_type_units);
3833
3834 return 1;
3835 }
3836
3837 /* Lookup a signature based type for DW_FORM_ref_sig8.
3838 Returns NULL if signature SIG is not present in the table. */
3839
3840 static struct signatured_type *
3841 lookup_signatured_type (ULONGEST sig)
3842 {
3843 struct signatured_type find_entry, *entry;
3844
3845 if (dwarf2_per_objfile->signatured_types == NULL)
3846 {
3847 complaint (&symfile_complaints,
3848 _("missing `.debug_types' section for DW_FORM_ref_sig8 die"));
3849 return NULL;
3850 }
3851
3852 find_entry.signature = sig;
3853 entry = htab_find (dwarf2_per_objfile->signatured_types, &find_entry);
3854 return entry;
3855 }
3856 \f
3857 /* Low level DIE reading support. */
3858
3859 /* Initialize a die_reader_specs struct from a dwarf2_cu struct. */
3860
3861 static void
3862 init_cu_die_reader (struct die_reader_specs *reader,
3863 struct dwarf2_cu *cu,
3864 struct dwarf2_section_info *section,
3865 struct dwo_file *dwo_file)
3866 {
3867 gdb_assert (section->readin && section->buffer != NULL);
3868 reader->abfd = section->asection->owner;
3869 reader->cu = cu;
3870 reader->dwo_file = dwo_file;
3871 reader->die_section = section;
3872 reader->buffer = section->buffer;
3873 reader->buffer_end = section->buffer + section->size;
3874 }
3875
3876 /* Initialize a CU (or TU) and read its DIEs.
3877 If the CU defers to a DWO file, read the DWO file as well.
3878
3879 If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
3880 Otherwise, a new CU is allocated with xmalloc.
3881
3882 If KEEP is non-zero, then if we allocated a dwarf2_cu we add it to
3883 read_in_chain. Otherwise the dwarf2_cu data is freed at the end.
3884
3885 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
3886 linker) then DIE_READER_FUNC will not get called. */
3887
3888 static void
3889 init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu,
3890 int use_existing_cu, int keep,
3891 die_reader_func_ftype *die_reader_func,
3892 void *data)
3893 {
3894 struct objfile *objfile = dwarf2_per_objfile->objfile;
3895 struct dwarf2_section_info *section = this_cu->info_or_types_section;
3896 bfd *abfd = section->asection->owner;
3897 struct dwarf2_cu *cu;
3898 gdb_byte *begin_info_ptr, *info_ptr;
3899 struct die_reader_specs reader;
3900 struct die_info *comp_unit_die;
3901 int has_children;
3902 struct attribute *attr;
3903 struct cleanup *cleanups, *free_cu_cleanup = NULL;
3904 struct signatured_type *sig_type = NULL;
3905 struct dwarf2_section_info *abbrev_section;
3906 /* Non-zero if CU currently points to a DWO file and we need to
3907 reread it. When this happens we need to reread the skeleton die
3908 before we can reread the DWO file. */
3909 int rereading_dwo_cu = 0;
3910
3911 if (dwarf2_die_debug)
3912 fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset 0x%x\n",
3913 this_cu->is_debug_types ? "type" : "comp",
3914 this_cu->offset.sect_off);
3915
3916 if (use_existing_cu)
3917 gdb_assert (keep);
3918
3919 cleanups = make_cleanup (null_cleanup, NULL);
3920
3921 /* This is cheap if the section is already read in. */
3922 dwarf2_read_section (objfile, section);
3923
3924 begin_info_ptr = info_ptr = section->buffer + this_cu->offset.sect_off;
3925 abbrev_section = &dwarf2_per_objfile->abbrev;
3926
3927 if (use_existing_cu && this_cu->cu != NULL)
3928 {
3929 cu = this_cu->cu;
3930
3931 /* If this CU is from a DWO file we need to start over, we need to
3932 refetch the attributes from the skeleton CU.
3933 This could be optimized by retrieving those attributes from when we
3934 were here the first time: the previous comp_unit_die was stored in
3935 comp_unit_obstack. But there's no data yet that we need this
3936 optimization. */
3937 if (cu->dwo_unit != NULL)
3938 rereading_dwo_cu = 1;
3939 }
3940 else
3941 {
3942 /* If !use_existing_cu, this_cu->cu must be NULL. */
3943 gdb_assert (this_cu->cu == NULL);
3944
3945 cu = xmalloc (sizeof (*cu));
3946 init_one_comp_unit (cu, this_cu);
3947
3948 /* If an error occurs while loading, release our storage. */
3949 free_cu_cleanup = make_cleanup (free_heap_comp_unit, cu);
3950 }
3951
3952 if (cu->header.first_die_offset.cu_off != 0 && ! rereading_dwo_cu)
3953 {
3954 /* We already have the header, there's no need to read it in again. */
3955 info_ptr += cu->header.first_die_offset.cu_off;
3956 }
3957 else
3958 {
3959 if (this_cu->is_debug_types)
3960 {
3961 ULONGEST signature;
3962 cu_offset type_offset_in_tu;
3963
3964 info_ptr = read_and_check_type_unit_head (&cu->header, section,
3965 abbrev_section, info_ptr,
3966 &signature,
3967 &type_offset_in_tu);
3968
3969 /* Since per_cu is the first member of struct signatured_type,
3970 we can go from a pointer to one to a pointer to the other. */
3971 sig_type = (struct signatured_type *) this_cu;
3972 gdb_assert (sig_type->signature == signature);
3973 gdb_assert (sig_type->type_offset_in_tu.cu_off
3974 == type_offset_in_tu.cu_off);
3975 gdb_assert (this_cu->offset.sect_off == cu->header.offset.sect_off);
3976
3977 /* LENGTH has not been set yet for type units if we're
3978 using .gdb_index. */
3979 this_cu->length = get_cu_length (&cu->header);
3980
3981 /* Establish the type offset that can be used to lookup the type. */
3982 sig_type->type_offset_in_section.sect_off =
3983 this_cu->offset.sect_off + sig_type->type_offset_in_tu.cu_off;
3984 }
3985 else
3986 {
3987 info_ptr = read_and_check_comp_unit_head (&cu->header, section,
3988 abbrev_section,
3989 info_ptr, 0);
3990
3991 gdb_assert (this_cu->offset.sect_off == cu->header.offset.sect_off);
3992 gdb_assert (this_cu->length == get_cu_length (&cu->header));
3993 }
3994 }
3995
3996 /* Skip dummy compilation units. */
3997 if (info_ptr >= begin_info_ptr + this_cu->length
3998 || peek_abbrev_code (abfd, info_ptr) == 0)
3999 {
4000 do_cleanups (cleanups);
4001 return;
4002 }
4003
4004 /* If we don't have them yet, read the abbrevs for this compilation unit.
4005 And if we need to read them now, make sure they're freed when we're
4006 done. Note that it's important that if the CU had an abbrev table
4007 on entry we don't free it when we're done: Somewhere up the call stack
4008 it may be in use. */
4009 if (cu->abbrev_table == NULL)
4010 {
4011 dwarf2_read_abbrevs (cu, abbrev_section);
4012 make_cleanup (dwarf2_free_abbrev_table, cu);
4013 }
4014 else if (rereading_dwo_cu)
4015 {
4016 dwarf2_free_abbrev_table (cu);
4017 dwarf2_read_abbrevs (cu, abbrev_section);
4018 }
4019
4020 /* Read the top level CU/TU die. */
4021 init_cu_die_reader (&reader, cu, section, NULL);
4022 info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
4023
4024 /* If we have a DWO stub, process it and then read in the DWO file.
4025 Note that if USE_EXISTING_OK != 0, and THIS_CU->cu already contains
4026 a DWO CU, that this test will fail. */
4027 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
4028 if (attr)
4029 {
4030 char *dwo_name = DW_STRING (attr);
4031 const char *comp_dir_string;
4032 struct dwo_unit *dwo_unit;
4033 ULONGEST signature; /* Or dwo_id. */
4034 struct attribute *comp_dir, *stmt_list, *low_pc, *high_pc, *ranges;
4035 int i,num_extra_attrs;
4036 struct dwarf2_section_info *dwo_abbrev_section;
4037
4038 if (has_children)
4039 error (_("Dwarf Error: compilation unit with DW_AT_GNU_dwo_name"
4040 " has children (offset 0x%x) [in module %s]"),
4041 this_cu->offset.sect_off, bfd_get_filename (abfd));
4042
4043 /* These attributes aren't processed until later:
4044 DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges.
4045 However, the attribute is found in the stub which we won't have later.
4046 In order to not impose this complication on the rest of the code,
4047 we read them here and copy them to the DWO CU/TU die. */
4048
4049 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
4050 DWO file. */
4051 stmt_list = NULL;
4052 if (! this_cu->is_debug_types)
4053 stmt_list = dwarf2_attr (comp_unit_die, DW_AT_stmt_list, cu);
4054 low_pc = dwarf2_attr (comp_unit_die, DW_AT_low_pc, cu);
4055 high_pc = dwarf2_attr (comp_unit_die, DW_AT_high_pc, cu);
4056 ranges = dwarf2_attr (comp_unit_die, DW_AT_ranges, cu);
4057 comp_dir = dwarf2_attr (comp_unit_die, DW_AT_comp_dir, cu);
4058
4059 /* There should be a DW_AT_addr_base attribute here (if needed).
4060 We need the value before we can process DW_FORM_GNU_addr_index. */
4061 cu->addr_base = 0;
4062 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_addr_base, cu);
4063 if (attr)
4064 cu->addr_base = DW_UNSND (attr);
4065
4066 /* There should be a DW_AT_ranges_base attribute here (if needed).
4067 We need the value before we can process DW_AT_ranges. */
4068 cu->ranges_base = 0;
4069 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_ranges_base, cu);
4070 if (attr)
4071 cu->ranges_base = DW_UNSND (attr);
4072
4073 if (this_cu->is_debug_types)
4074 {
4075 gdb_assert (sig_type != NULL);
4076 signature = sig_type->signature;
4077 }
4078 else
4079 {
4080 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
4081 if (! attr)
4082 error (_("Dwarf Error: missing dwo_id [in module %s]"),
4083 dwo_name);
4084 signature = DW_UNSND (attr);
4085 }
4086
4087 /* We may need the comp_dir in order to find the DWO file. */
4088 comp_dir_string = NULL;
4089 if (comp_dir)
4090 comp_dir_string = DW_STRING (comp_dir);
4091
4092 if (this_cu->is_debug_types)
4093 dwo_unit = lookup_dwo_type_unit (sig_type, dwo_name, comp_dir_string);
4094 else
4095 dwo_unit = lookup_dwo_comp_unit (this_cu, dwo_name, comp_dir_string,
4096 signature);
4097
4098 if (dwo_unit == NULL)
4099 {
4100 error (_("Dwarf Error: CU at offset 0x%x references unknown DWO"
4101 " with ID %s [in module %s]"),
4102 this_cu->offset.sect_off,
4103 phex (signature, sizeof (signature)),
4104 objfile->name);
4105 }
4106
4107 /* Set up for reading the DWO CU/TU. */
4108 cu->dwo_unit = dwo_unit;
4109 section = dwo_unit->info_or_types_section;
4110 begin_info_ptr = info_ptr = section->buffer + dwo_unit->offset.sect_off;
4111 dwo_abbrev_section = &dwo_unit->dwo_file->sections.abbrev;
4112 init_cu_die_reader (&reader, cu, section, dwo_unit->dwo_file);
4113
4114 if (this_cu->is_debug_types)
4115 {
4116 ULONGEST signature;
4117
4118 info_ptr = read_and_check_type_unit_head (&cu->header, section,
4119 dwo_abbrev_section,
4120 info_ptr,
4121 &signature, NULL);
4122 gdb_assert (sig_type->signature == signature);
4123 gdb_assert (dwo_unit->offset.sect_off == cu->header.offset.sect_off);
4124 gdb_assert (dwo_unit->length == get_cu_length (&cu->header));
4125
4126 /* Establish the type offset that can be used to lookup the type.
4127 For DWO files, we don't know it until now. */
4128 sig_type->type_offset_in_section.sect_off =
4129 dwo_unit->offset.sect_off + dwo_unit->type_offset_in_tu.cu_off;
4130 }
4131 else
4132 {
4133 info_ptr = read_and_check_comp_unit_head (&cu->header, section,
4134 dwo_abbrev_section,
4135 info_ptr, 0);
4136 gdb_assert (dwo_unit->offset.sect_off == cu->header.offset.sect_off);
4137 gdb_assert (dwo_unit->length == get_cu_length (&cu->header));
4138 }
4139
4140 /* Discard the original CU's abbrev table, and read the DWO's. */
4141 dwarf2_free_abbrev_table (cu);
4142 dwarf2_read_abbrevs (cu, dwo_abbrev_section);
4143
4144 /* Read in the die, but leave space to copy over the attributes
4145 from the stub. This has the benefit of simplifying the rest of
4146 the code - all the real work is done here. */
4147 num_extra_attrs = ((stmt_list != NULL)
4148 + (low_pc != NULL)
4149 + (high_pc != NULL)
4150 + (ranges != NULL)
4151 + (comp_dir != NULL));
4152 info_ptr = read_full_die_1 (&reader, &comp_unit_die, info_ptr,
4153 &has_children, num_extra_attrs);
4154
4155 /* Copy over the attributes from the stub to the DWO die. */
4156 i = comp_unit_die->num_attrs;
4157 if (stmt_list != NULL)
4158 comp_unit_die->attrs[i++] = *stmt_list;
4159 if (low_pc != NULL)
4160 comp_unit_die->attrs[i++] = *low_pc;
4161 if (high_pc != NULL)
4162 comp_unit_die->attrs[i++] = *high_pc;
4163 if (ranges != NULL)
4164 comp_unit_die->attrs[i++] = *ranges;
4165 if (comp_dir != NULL)
4166 comp_unit_die->attrs[i++] = *comp_dir;
4167 comp_unit_die->num_attrs += num_extra_attrs;
4168
4169 /* Skip dummy compilation units. */
4170 if (info_ptr >= begin_info_ptr + dwo_unit->length
4171 || peek_abbrev_code (abfd, info_ptr) == 0)
4172 {
4173 do_cleanups (cleanups);
4174 return;
4175 }
4176 }
4177
4178 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
4179
4180 if (free_cu_cleanup != NULL)
4181 {
4182 if (keep)
4183 {
4184 /* We've successfully allocated this compilation unit. Let our
4185 caller clean it up when finished with it. */
4186 discard_cleanups (free_cu_cleanup);
4187
4188 /* We can only discard free_cu_cleanup and all subsequent cleanups.
4189 So we have to manually free the abbrev table. */
4190 dwarf2_free_abbrev_table (cu);
4191
4192 /* Link this CU into read_in_chain. */
4193 this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
4194 dwarf2_per_objfile->read_in_chain = this_cu;
4195 }
4196 else
4197 do_cleanups (free_cu_cleanup);
4198 }
4199
4200 do_cleanups (cleanups);
4201 }
4202
4203 /* Read CU/TU THIS_CU in section SECTION,
4204 but do not follow DW_AT_GNU_dwo_name if present.
4205 DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed to
4206 have already done the lookup to find the DWO file).
4207
4208 The caller is required to fill in THIS_CU->section, THIS_CU->offset, and
4209 THIS_CU->is_debug_types, but nothing else.
4210
4211 We fill in THIS_CU->length.
4212
4213 WARNING: If THIS_CU is a "dummy CU" (used as filler by the incremental
4214 linker) then DIE_READER_FUNC will not get called.
4215
4216 THIS_CU->cu is always freed when done.
4217 This is done in order to not leave THIS_CU->cu in a state where we have
4218 to care whether it refers to the "main" CU or the DWO CU. */
4219
4220 static void
4221 init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data *this_cu,
4222 struct dwarf2_section_info *abbrev_section,
4223 struct dwo_file *dwo_file,
4224 die_reader_func_ftype *die_reader_func,
4225 void *data)
4226 {
4227 struct objfile *objfile = dwarf2_per_objfile->objfile;
4228 struct dwarf2_section_info *section = this_cu->info_or_types_section;
4229 bfd *abfd = section->asection->owner;
4230 struct dwarf2_cu cu;
4231 gdb_byte *begin_info_ptr, *info_ptr;
4232 struct die_reader_specs reader;
4233 struct cleanup *cleanups;
4234 struct die_info *comp_unit_die;
4235 int has_children;
4236
4237 if (dwarf2_die_debug)
4238 fprintf_unfiltered (gdb_stdlog, "Reading %s unit at offset 0x%x\n",
4239 this_cu->is_debug_types ? "type" : "comp",
4240 this_cu->offset.sect_off);
4241
4242 gdb_assert (this_cu->cu == NULL);
4243
4244 /* This is cheap if the section is already read in. */
4245 dwarf2_read_section (objfile, section);
4246
4247 init_one_comp_unit (&cu, this_cu);
4248
4249 cleanups = make_cleanup (free_stack_comp_unit, &cu);
4250
4251 begin_info_ptr = info_ptr = section->buffer + this_cu->offset.sect_off;
4252 info_ptr = read_and_check_comp_unit_head (&cu.header, section,
4253 abbrev_section, info_ptr,
4254 this_cu->is_debug_types);
4255
4256 this_cu->length = get_cu_length (&cu.header);
4257
4258 /* Skip dummy compilation units. */
4259 if (info_ptr >= begin_info_ptr + this_cu->length
4260 || peek_abbrev_code (abfd, info_ptr) == 0)
4261 {
4262 do_cleanups (cleanups);
4263 return;
4264 }
4265
4266 dwarf2_read_abbrevs (&cu, abbrev_section);
4267 make_cleanup (dwarf2_free_abbrev_table, &cu);
4268
4269 init_cu_die_reader (&reader, &cu, section, dwo_file);
4270 info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
4271
4272 die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data);
4273
4274 do_cleanups (cleanups);
4275 }
4276
4277 /* Read a CU/TU, except that this does not look for DW_AT_GNU_dwo_name and
4278 does not lookup the specified DWO file.
4279 This cannot be used to read DWO files.
4280
4281 THIS_CU->cu is always freed when done.
4282 This is done in order to not leave THIS_CU->cu in a state where we have
4283 to care whether it refers to the "main" CU or the DWO CU.
4284 We can revisit this if the data shows there's a performance issue. */
4285
4286 static void
4287 init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data *this_cu,
4288 die_reader_func_ftype *die_reader_func,
4289 void *data)
4290 {
4291 init_cutu_and_read_dies_no_follow (this_cu,
4292 &dwarf2_per_objfile->abbrev,
4293 NULL,
4294 die_reader_func, data);
4295 }
4296
4297 /* die_reader_func for process_psymtab_comp_unit. */
4298
4299 static void
4300 process_psymtab_comp_unit_reader (const struct die_reader_specs *reader,
4301 gdb_byte *info_ptr,
4302 struct die_info *comp_unit_die,
4303 int has_children,
4304 void *data)
4305 {
4306 struct dwarf2_cu *cu = reader->cu;
4307 struct objfile *objfile = cu->objfile;
4308 struct dwarf2_per_cu_data *per_cu = cu->per_cu;
4309 struct attribute *attr;
4310 CORE_ADDR baseaddr;
4311 CORE_ADDR best_lowpc = 0, best_highpc = 0;
4312 struct partial_symtab *pst;
4313 int has_pc_info;
4314 const char *filename;
4315 int *want_partial_unit_ptr = data;
4316
4317 if (comp_unit_die->tag == DW_TAG_partial_unit
4318 && (want_partial_unit_ptr == NULL
4319 || !*want_partial_unit_ptr))
4320 return;
4321
4322 prepare_one_comp_unit (cu, comp_unit_die, language_minimal);
4323
4324 cu->list_in_scope = &file_symbols;
4325
4326 /* Allocate a new partial symbol table structure. */
4327 attr = dwarf2_attr (comp_unit_die, DW_AT_name, cu);
4328 if (attr == NULL || !DW_STRING (attr))
4329 filename = "";
4330 else
4331 filename = DW_STRING (attr);
4332 pst = start_psymtab_common (objfile, objfile->section_offsets,
4333 filename,
4334 /* TEXTLOW and TEXTHIGH are set below. */
4335 0,
4336 objfile->global_psymbols.next,
4337 objfile->static_psymbols.next);
4338 pst->psymtabs_addrmap_supported = 1;
4339
4340 attr = dwarf2_attr (comp_unit_die, DW_AT_comp_dir, cu);
4341 if (attr != NULL)
4342 pst->dirname = DW_STRING (attr);
4343
4344 pst->read_symtab_private = per_cu;
4345
4346 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
4347
4348 /* Store the function that reads in the rest of the symbol table. */
4349 pst->read_symtab = dwarf2_psymtab_to_symtab;
4350
4351 per_cu->v.psymtab = pst;
4352
4353 dwarf2_find_base_address (comp_unit_die, cu);
4354
4355 /* Possibly set the default values of LOWPC and HIGHPC from
4356 `DW_AT_ranges'. */
4357 has_pc_info = dwarf2_get_pc_bounds (comp_unit_die, &best_lowpc,
4358 &best_highpc, cu, pst);
4359 if (has_pc_info == 1 && best_lowpc < best_highpc)
4360 /* Store the contiguous range if it is not empty; it can be empty for
4361 CUs with no code. */
4362 addrmap_set_empty (objfile->psymtabs_addrmap,
4363 best_lowpc + baseaddr,
4364 best_highpc + baseaddr - 1, pst);
4365
4366 /* Check if comp unit has_children.
4367 If so, read the rest of the partial symbols from this comp unit.
4368 If not, there's no more debug_info for this comp unit. */
4369 if (has_children)
4370 {
4371 struct partial_die_info *first_die;
4372 CORE_ADDR lowpc, highpc;
4373
4374 lowpc = ((CORE_ADDR) -1);
4375 highpc = ((CORE_ADDR) 0);
4376
4377 first_die = load_partial_dies (reader, info_ptr, 1);
4378
4379 scan_partial_symbols (first_die, &lowpc, &highpc,
4380 ! has_pc_info, cu);
4381
4382 /* If we didn't find a lowpc, set it to highpc to avoid
4383 complaints from `maint check'. */
4384 if (lowpc == ((CORE_ADDR) -1))
4385 lowpc = highpc;
4386
4387 /* If the compilation unit didn't have an explicit address range,
4388 then use the information extracted from its child dies. */
4389 if (! has_pc_info)
4390 {
4391 best_lowpc = lowpc;
4392 best_highpc = highpc;
4393 }
4394 }
4395 pst->textlow = best_lowpc + baseaddr;
4396 pst->texthigh = best_highpc + baseaddr;
4397
4398 pst->n_global_syms = objfile->global_psymbols.next -
4399 (objfile->global_psymbols.list + pst->globals_offset);
4400 pst->n_static_syms = objfile->static_psymbols.next -
4401 (objfile->static_psymbols.list + pst->statics_offset);
4402 sort_pst_symbols (pst);
4403
4404 if (!VEC_empty (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs))
4405 {
4406 int i;
4407 int len = VEC_length (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
4408 struct dwarf2_per_cu_data *iter;
4409
4410 /* Fill in 'dependencies' here; we fill in 'users' in a
4411 post-pass. */
4412 pst->number_of_dependencies = len;
4413 pst->dependencies = obstack_alloc (&objfile->objfile_obstack,
4414 len * sizeof (struct symtab *));
4415 for (i = 0;
4416 VEC_iterate (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
4417 i, iter);
4418 ++i)
4419 pst->dependencies[i] = iter->v.psymtab;
4420
4421 VEC_free (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
4422 }
4423
4424 if (per_cu->is_debug_types)
4425 {
4426 /* It's not clear we want to do anything with stmt lists here.
4427 Waiting to see what gcc ultimately does. */
4428 }
4429 else
4430 {
4431 /* Get the list of files included in the current compilation unit,
4432 and build a psymtab for each of them. */
4433 dwarf2_build_include_psymtabs (cu, comp_unit_die, pst);
4434 }
4435
4436 if (dwarf2_read_debug)
4437 {
4438 struct gdbarch *gdbarch = get_objfile_arch (objfile);
4439
4440 fprintf_unfiltered (gdb_stdlog,
4441 "Psymtab for %s unit @0x%x: 0x%s - 0x%s"
4442 ", %d global, %d static syms\n",
4443 per_cu->is_debug_types ? "type" : "comp",
4444 per_cu->offset.sect_off,
4445 paddress (gdbarch, pst->textlow),
4446 paddress (gdbarch, pst->texthigh),
4447 pst->n_global_syms, pst->n_static_syms);
4448 }
4449 }
4450
4451 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
4452 Process compilation unit THIS_CU for a psymtab. */
4453
4454 static void
4455 process_psymtab_comp_unit (struct dwarf2_per_cu_data *this_cu,
4456 int want_partial_unit)
4457 {
4458 /* If this compilation unit was already read in, free the
4459 cached copy in order to read it in again. This is
4460 necessary because we skipped some symbols when we first
4461 read in the compilation unit (see load_partial_dies).
4462 This problem could be avoided, but the benefit is unclear. */
4463 if (this_cu->cu != NULL)
4464 free_one_cached_comp_unit (this_cu);
4465
4466 gdb_assert (! this_cu->is_debug_types);
4467 init_cutu_and_read_dies (this_cu, 0, 0, process_psymtab_comp_unit_reader,
4468 &want_partial_unit);
4469
4470 /* Age out any secondary CUs. */
4471 age_cached_comp_units ();
4472 }
4473
4474 /* Traversal function for htab_traverse_noresize.
4475 Process one .debug_types comp-unit. */
4476
4477 static int
4478 process_psymtab_type_unit (void **slot, void *info)
4479 {
4480 struct signatured_type *sig_type = (struct signatured_type *) *slot;
4481 struct dwarf2_per_cu_data *per_cu = &sig_type->per_cu;
4482
4483 gdb_assert (per_cu->is_debug_types);
4484 gdb_assert (info == NULL);
4485
4486 /* If this compilation unit was already read in, free the
4487 cached copy in order to read it in again. This is
4488 necessary because we skipped some symbols when we first
4489 read in the compilation unit (see load_partial_dies).
4490 This problem could be avoided, but the benefit is unclear. */
4491 if (per_cu->cu != NULL)
4492 free_one_cached_comp_unit (per_cu);
4493
4494 init_cutu_and_read_dies (per_cu, 0, 0, process_psymtab_comp_unit_reader,
4495 NULL);
4496
4497 /* Age out any secondary CUs. */
4498 age_cached_comp_units ();
4499
4500 return 1;
4501 }
4502
4503 /* Subroutine of dwarf2_build_psymtabs_hard to simplify it.
4504 Build partial symbol tables for the .debug_types comp-units. */
4505
4506 static void
4507 build_type_psymtabs (struct objfile *objfile)
4508 {
4509 if (! create_all_type_units (objfile))
4510 return;
4511
4512 htab_traverse_noresize (dwarf2_per_objfile->signatured_types,
4513 process_psymtab_type_unit, NULL);
4514 }
4515
4516 /* A cleanup function that clears objfile's psymtabs_addrmap field. */
4517
4518 static void
4519 psymtabs_addrmap_cleanup (void *o)
4520 {
4521 struct objfile *objfile = o;
4522
4523 objfile->psymtabs_addrmap = NULL;
4524 }
4525
4526 /* Compute the 'user' field for each psymtab in OBJFILE. */
4527
4528 static void
4529 set_partial_user (struct objfile *objfile)
4530 {
4531 int i;
4532
4533 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
4534 {
4535 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
4536 struct partial_symtab *pst = per_cu->v.psymtab;
4537 int j;
4538
4539 for (j = 0; j < pst->number_of_dependencies; ++j)
4540 {
4541 /* Set the 'user' field only if it is not already set. */
4542 if (pst->dependencies[j]->user == NULL)
4543 pst->dependencies[j]->user = pst;
4544 }
4545 }
4546 }
4547
4548 /* Build the partial symbol table by doing a quick pass through the
4549 .debug_info and .debug_abbrev sections. */
4550
4551 static void
4552 dwarf2_build_psymtabs_hard (struct objfile *objfile)
4553 {
4554 struct cleanup *back_to, *addrmap_cleanup;
4555 struct obstack temp_obstack;
4556 int i;
4557
4558 if (dwarf2_read_debug)
4559 {
4560 fprintf_unfiltered (gdb_stdlog, "Building psymtabs of objfile %s ...\n",
4561 objfile->name);
4562 }
4563
4564 dwarf2_per_objfile->reading_partial_symbols = 1;
4565
4566 dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
4567
4568 /* Any cached compilation units will be linked by the per-objfile
4569 read_in_chain. Make sure to free them when we're done. */
4570 back_to = make_cleanup (free_cached_comp_units, NULL);
4571
4572 build_type_psymtabs (objfile);
4573
4574 create_all_comp_units (objfile);
4575
4576 /* Create a temporary address map on a temporary obstack. We later
4577 copy this to the final obstack. */
4578 obstack_init (&temp_obstack);
4579 make_cleanup_obstack_free (&temp_obstack);
4580 objfile->psymtabs_addrmap = addrmap_create_mutable (&temp_obstack);
4581 addrmap_cleanup = make_cleanup (psymtabs_addrmap_cleanup, objfile);
4582
4583 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
4584 {
4585 struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i);
4586
4587 process_psymtab_comp_unit (per_cu, 0);
4588 }
4589
4590 set_partial_user (objfile);
4591
4592 objfile->psymtabs_addrmap = addrmap_create_fixed (objfile->psymtabs_addrmap,
4593 &objfile->objfile_obstack);
4594 discard_cleanups (addrmap_cleanup);
4595
4596 do_cleanups (back_to);
4597
4598 if (dwarf2_read_debug)
4599 fprintf_unfiltered (gdb_stdlog, "Done building psymtabs of %s\n",
4600 objfile->name);
4601 }
4602
4603 /* die_reader_func for load_partial_comp_unit. */
4604
4605 static void
4606 load_partial_comp_unit_reader (const struct die_reader_specs *reader,
4607 gdb_byte *info_ptr,
4608 struct die_info *comp_unit_die,
4609 int has_children,
4610 void *data)
4611 {
4612 struct dwarf2_cu *cu = reader->cu;
4613
4614 prepare_one_comp_unit (cu, comp_unit_die, language_minimal);
4615
4616 /* Check if comp unit has_children.
4617 If so, read the rest of the partial symbols from this comp unit.
4618 If not, there's no more debug_info for this comp unit. */
4619 if (has_children)
4620 load_partial_dies (reader, info_ptr, 0);
4621 }
4622
4623 /* Load the partial DIEs for a secondary CU into memory.
4624 This is also used when rereading a primary CU with load_all_dies. */
4625
4626 static void
4627 load_partial_comp_unit (struct dwarf2_per_cu_data *this_cu)
4628 {
4629 init_cutu_and_read_dies (this_cu, 1, 1, load_partial_comp_unit_reader, NULL);
4630 }
4631
4632 /* Create a list of all compilation units in OBJFILE.
4633 This is only done for -readnow and building partial symtabs. */
4634
4635 static void
4636 create_all_comp_units (struct objfile *objfile)
4637 {
4638 int n_allocated;
4639 int n_comp_units;
4640 struct dwarf2_per_cu_data **all_comp_units;
4641 gdb_byte *info_ptr;
4642
4643 dwarf2_read_section (objfile, &dwarf2_per_objfile->info);
4644 info_ptr = dwarf2_per_objfile->info.buffer;
4645
4646 n_comp_units = 0;
4647 n_allocated = 10;
4648 all_comp_units = xmalloc (n_allocated
4649 * sizeof (struct dwarf2_per_cu_data *));
4650
4651 while (info_ptr < dwarf2_per_objfile->info.buffer
4652 + dwarf2_per_objfile->info.size)
4653 {
4654 unsigned int length, initial_length_size;
4655 struct dwarf2_per_cu_data *this_cu;
4656 sect_offset offset;
4657
4658 offset.sect_off = info_ptr - dwarf2_per_objfile->info.buffer;
4659
4660 /* Read just enough information to find out where the next
4661 compilation unit is. */
4662 length = read_initial_length (objfile->obfd, info_ptr,
4663 &initial_length_size);
4664
4665 /* Save the compilation unit for later lookup. */
4666 this_cu = obstack_alloc (&objfile->objfile_obstack,
4667 sizeof (struct dwarf2_per_cu_data));
4668 memset (this_cu, 0, sizeof (*this_cu));
4669 this_cu->offset = offset;
4670 this_cu->length = length + initial_length_size;
4671 this_cu->objfile = objfile;
4672 this_cu->info_or_types_section = &dwarf2_per_objfile->info;
4673
4674 if (n_comp_units == n_allocated)
4675 {
4676 n_allocated *= 2;
4677 all_comp_units = xrealloc (all_comp_units,
4678 n_allocated
4679 * sizeof (struct dwarf2_per_cu_data *));
4680 }
4681 all_comp_units[n_comp_units++] = this_cu;
4682
4683 info_ptr = info_ptr + this_cu->length;
4684 }
4685
4686 dwarf2_per_objfile->all_comp_units
4687 = obstack_alloc (&objfile->objfile_obstack,
4688 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
4689 memcpy (dwarf2_per_objfile->all_comp_units, all_comp_units,
4690 n_comp_units * sizeof (struct dwarf2_per_cu_data *));
4691 xfree (all_comp_units);
4692 dwarf2_per_objfile->n_comp_units = n_comp_units;
4693 }
4694
4695 /* Process all loaded DIEs for compilation unit CU, starting at
4696 FIRST_DIE. The caller should pass NEED_PC == 1 if the compilation
4697 unit DIE did not have PC info (DW_AT_low_pc and DW_AT_high_pc, or
4698 DW_AT_ranges). If NEED_PC is set, then this function will set
4699 *LOWPC and *HIGHPC to the lowest and highest PC values found in CU
4700 and record the covered ranges in the addrmap. */
4701
4702 static void
4703 scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc,
4704 CORE_ADDR *highpc, int need_pc, struct dwarf2_cu *cu)
4705 {
4706 struct partial_die_info *pdi;
4707
4708 /* Now, march along the PDI's, descending into ones which have
4709 interesting children but skipping the children of the other ones,
4710 until we reach the end of the compilation unit. */
4711
4712 pdi = first_die;
4713
4714 while (pdi != NULL)
4715 {
4716 fixup_partial_die (pdi, cu);
4717
4718 /* Anonymous namespaces or modules have no name but have interesting
4719 children, so we need to look at them. Ditto for anonymous
4720 enums. */
4721
4722 if (pdi->name != NULL || pdi->tag == DW_TAG_namespace
4723 || pdi->tag == DW_TAG_module || pdi->tag == DW_TAG_enumeration_type
4724 || pdi->tag == DW_TAG_imported_unit)
4725 {
4726 switch (pdi->tag)
4727 {
4728 case DW_TAG_subprogram:
4729 add_partial_subprogram (pdi, lowpc, highpc, need_pc, cu);
4730 break;
4731 case DW_TAG_constant:
4732 case DW_TAG_variable:
4733 case DW_TAG_typedef:
4734 case DW_TAG_union_type:
4735 if (!pdi->is_declaration)
4736 {
4737 add_partial_symbol (pdi, cu);
4738 }
4739 break;
4740 case DW_TAG_class_type:
4741 case DW_TAG_interface_type:
4742 case DW_TAG_structure_type:
4743 if (!pdi->is_declaration)
4744 {
4745 add_partial_symbol (pdi, cu);
4746 }
4747 break;
4748 case DW_TAG_enumeration_type:
4749 if (!pdi->is_declaration)
4750 add_partial_enumeration (pdi, cu);
4751 break;
4752 case DW_TAG_base_type:
4753 case DW_TAG_subrange_type:
4754 /* File scope base type definitions are added to the partial
4755 symbol table. */
4756 add_partial_symbol (pdi, cu);
4757 break;
4758 case DW_TAG_namespace:
4759 add_partial_namespace (pdi, lowpc, highpc, need_pc, cu);
4760 break;
4761 case DW_TAG_module:
4762 add_partial_module (pdi, lowpc, highpc, need_pc, cu);
4763 break;
4764 case DW_TAG_imported_unit:
4765 {
4766 struct dwarf2_per_cu_data *per_cu;
4767
4768 per_cu = dwarf2_find_containing_comp_unit (pdi->d.offset,
4769 cu->objfile);
4770
4771 /* Go read the partial unit, if needed. */
4772 if (per_cu->v.psymtab == NULL)
4773 process_psymtab_comp_unit (per_cu, 1);
4774
4775 VEC_safe_push (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
4776 per_cu);
4777 }
4778 break;
4779 default:
4780 break;
4781 }
4782 }
4783
4784 /* If the die has a sibling, skip to the sibling. */
4785
4786 pdi = pdi->die_sibling;
4787 }
4788 }
4789
4790 /* Functions used to compute the fully scoped name of a partial DIE.
4791
4792 Normally, this is simple. For C++, the parent DIE's fully scoped
4793 name is concatenated with "::" and the partial DIE's name. For
4794 Java, the same thing occurs except that "." is used instead of "::".
4795 Enumerators are an exception; they use the scope of their parent
4796 enumeration type, i.e. the name of the enumeration type is not
4797 prepended to the enumerator.
4798
4799 There are two complexities. One is DW_AT_specification; in this
4800 case "parent" means the parent of the target of the specification,
4801 instead of the direct parent of the DIE. The other is compilers
4802 which do not emit DW_TAG_namespace; in this case we try to guess
4803 the fully qualified name of structure types from their members'
4804 linkage names. This must be done using the DIE's children rather
4805 than the children of any DW_AT_specification target. We only need
4806 to do this for structures at the top level, i.e. if the target of
4807 any DW_AT_specification (if any; otherwise the DIE itself) does not
4808 have a parent. */
4809
4810 /* Compute the scope prefix associated with PDI's parent, in
4811 compilation unit CU. The result will be allocated on CU's
4812 comp_unit_obstack, or a copy of the already allocated PDI->NAME
4813 field. NULL is returned if no prefix is necessary. */
4814 static char *
4815 partial_die_parent_scope (struct partial_die_info *pdi,
4816 struct dwarf2_cu *cu)
4817 {
4818 char *grandparent_scope;
4819 struct partial_die_info *parent, *real_pdi;
4820
4821 /* We need to look at our parent DIE; if we have a DW_AT_specification,
4822 then this means the parent of the specification DIE. */
4823
4824 real_pdi = pdi;
4825 while (real_pdi->has_specification)
4826 real_pdi = find_partial_die (real_pdi->spec_offset, cu);
4827
4828 parent = real_pdi->die_parent;
4829 if (parent == NULL)
4830 return NULL;
4831
4832 if (parent->scope_set)
4833 return parent->scope;
4834
4835 fixup_partial_die (parent, cu);
4836
4837 grandparent_scope = partial_die_parent_scope (parent, cu);
4838
4839 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
4840 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
4841 Work around this problem here. */
4842 if (cu->language == language_cplus
4843 && parent->tag == DW_TAG_namespace
4844 && strcmp (parent->name, "::") == 0
4845 && grandparent_scope == NULL)
4846 {
4847 parent->scope = NULL;
4848 parent->scope_set = 1;
4849 return NULL;
4850 }
4851
4852 if (pdi->tag == DW_TAG_enumerator)
4853 /* Enumerators should not get the name of the enumeration as a prefix. */
4854 parent->scope = grandparent_scope;
4855 else if (parent->tag == DW_TAG_namespace
4856 || parent->tag == DW_TAG_module
4857 || parent->tag == DW_TAG_structure_type
4858 || parent->tag == DW_TAG_class_type
4859 || parent->tag == DW_TAG_interface_type
4860 || parent->tag == DW_TAG_union_type
4861 || parent->tag == DW_TAG_enumeration_type)
4862 {
4863 if (grandparent_scope == NULL)
4864 parent->scope = parent->name;
4865 else
4866 parent->scope = typename_concat (&cu->comp_unit_obstack,
4867 grandparent_scope,
4868 parent->name, 0, cu);
4869 }
4870 else
4871 {
4872 /* FIXME drow/2004-04-01: What should we be doing with
4873 function-local names? For partial symbols, we should probably be
4874 ignoring them. */
4875 complaint (&symfile_complaints,
4876 _("unhandled containing DIE tag %d for DIE at %d"),
4877 parent->tag, pdi->offset.sect_off);
4878 parent->scope = grandparent_scope;
4879 }
4880
4881 parent->scope_set = 1;
4882 return parent->scope;
4883 }
4884
4885 /* Return the fully scoped name associated with PDI, from compilation unit
4886 CU. The result will be allocated with malloc. */
4887
4888 static char *
4889 partial_die_full_name (struct partial_die_info *pdi,
4890 struct dwarf2_cu *cu)
4891 {
4892 char *parent_scope;
4893
4894 /* If this is a template instantiation, we can not work out the
4895 template arguments from partial DIEs. So, unfortunately, we have
4896 to go through the full DIEs. At least any work we do building
4897 types here will be reused if full symbols are loaded later. */
4898 if (pdi->has_template_arguments)
4899 {
4900 fixup_partial_die (pdi, cu);
4901
4902 if (pdi->name != NULL && strchr (pdi->name, '<') == NULL)
4903 {
4904 struct die_info *die;
4905 struct attribute attr;
4906 struct dwarf2_cu *ref_cu = cu;
4907
4908 /* DW_FORM_ref_addr is using section offset. */
4909 attr.name = 0;
4910 attr.form = DW_FORM_ref_addr;
4911 attr.u.unsnd = pdi->offset.sect_off;
4912 die = follow_die_ref (NULL, &attr, &ref_cu);
4913
4914 return xstrdup (dwarf2_full_name (NULL, die, ref_cu));
4915 }
4916 }
4917
4918 parent_scope = partial_die_parent_scope (pdi, cu);
4919 if (parent_scope == NULL)
4920 return NULL;
4921 else
4922 return typename_concat (NULL, parent_scope, pdi->name, 0, cu);
4923 }
4924
4925 static void
4926 add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
4927 {
4928 struct objfile *objfile = cu->objfile;
4929 CORE_ADDR addr = 0;
4930 char *actual_name = NULL;
4931 CORE_ADDR baseaddr;
4932 int built_actual_name = 0;
4933
4934 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
4935
4936 actual_name = partial_die_full_name (pdi, cu);
4937 if (actual_name)
4938 built_actual_name = 1;
4939
4940 if (actual_name == NULL)
4941 actual_name = pdi->name;
4942
4943 switch (pdi->tag)
4944 {
4945 case DW_TAG_subprogram:
4946 if (pdi->is_external || cu->language == language_ada)
4947 {
4948 /* brobecker/2007-12-26: Normally, only "external" DIEs are part
4949 of the global scope. But in Ada, we want to be able to access
4950 nested procedures globally. So all Ada subprograms are stored
4951 in the global scope. */
4952 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
4953 mst_text, objfile); */
4954 add_psymbol_to_list (actual_name, strlen (actual_name),
4955 built_actual_name,
4956 VAR_DOMAIN, LOC_BLOCK,
4957 &objfile->global_psymbols,
4958 0, pdi->lowpc + baseaddr,
4959 cu->language, objfile);
4960 }
4961 else
4962 {
4963 /* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
4964 mst_file_text, objfile); */
4965 add_psymbol_to_list (actual_name, strlen (actual_name),
4966 built_actual_name,
4967 VAR_DOMAIN, LOC_BLOCK,
4968 &objfile->static_psymbols,
4969 0, pdi->lowpc + baseaddr,
4970 cu->language, objfile);
4971 }
4972 break;
4973 case DW_TAG_constant:
4974 {
4975 struct psymbol_allocation_list *list;
4976
4977 if (pdi->is_external)
4978 list = &objfile->global_psymbols;
4979 else
4980 list = &objfile->static_psymbols;
4981 add_psymbol_to_list (actual_name, strlen (actual_name),
4982 built_actual_name, VAR_DOMAIN, LOC_STATIC,
4983 list, 0, 0, cu->language, objfile);
4984 }
4985 break;
4986 case DW_TAG_variable:
4987 if (pdi->d.locdesc)
4988 addr = decode_locdesc (pdi->d.locdesc, cu);
4989
4990 if (pdi->d.locdesc
4991 && addr == 0
4992 && !dwarf2_per_objfile->has_section_at_zero)
4993 {
4994 /* A global or static variable may also have been stripped
4995 out by the linker if unused, in which case its address
4996 will be nullified; do not add such variables into partial
4997 symbol table then. */
4998 }
4999 else if (pdi->is_external)
5000 {
5001 /* Global Variable.
5002 Don't enter into the minimal symbol tables as there is
5003 a minimal symbol table entry from the ELF symbols already.
5004 Enter into partial symbol table if it has a location
5005 descriptor or a type.
5006 If the location descriptor is missing, new_symbol will create
5007 a LOC_UNRESOLVED symbol, the address of the variable will then
5008 be determined from the minimal symbol table whenever the variable
5009 is referenced.
5010 The address for the partial symbol table entry is not
5011 used by GDB, but it comes in handy for debugging partial symbol
5012 table building. */
5013
5014 if (pdi->d.locdesc || pdi->has_type)
5015 add_psymbol_to_list (actual_name, strlen (actual_name),
5016 built_actual_name,
5017 VAR_DOMAIN, LOC_STATIC,
5018 &objfile->global_psymbols,
5019 0, addr + baseaddr,
5020 cu->language, objfile);
5021 }
5022 else
5023 {
5024 /* Static Variable. Skip symbols without location descriptors. */
5025 if (pdi->d.locdesc == NULL)
5026 {
5027 if (built_actual_name)
5028 xfree (actual_name);
5029 return;
5030 }
5031 /* prim_record_minimal_symbol (actual_name, addr + baseaddr,
5032 mst_file_data, objfile); */
5033 add_psymbol_to_list (actual_name, strlen (actual_name),
5034 built_actual_name,
5035 VAR_DOMAIN, LOC_STATIC,
5036 &objfile->static_psymbols,
5037 0, addr + baseaddr,
5038 cu->language, objfile);
5039 }
5040 break;
5041 case DW_TAG_typedef:
5042 case DW_TAG_base_type:
5043 case DW_TAG_subrange_type:
5044 add_psymbol_to_list (actual_name, strlen (actual_name),
5045 built_actual_name,
5046 VAR_DOMAIN, LOC_TYPEDEF,
5047 &objfile->static_psymbols,
5048 0, (CORE_ADDR) 0, cu->language, objfile);
5049 break;
5050 case DW_TAG_namespace:
5051 add_psymbol_to_list (actual_name, strlen (actual_name),
5052 built_actual_name,
5053 VAR_DOMAIN, LOC_TYPEDEF,
5054 &objfile->global_psymbols,
5055 0, (CORE_ADDR) 0, cu->language, objfile);
5056 break;
5057 case DW_TAG_class_type:
5058 case DW_TAG_interface_type:
5059 case DW_TAG_structure_type:
5060 case DW_TAG_union_type:
5061 case DW_TAG_enumeration_type:
5062 /* Skip external references. The DWARF standard says in the section
5063 about "Structure, Union, and Class Type Entries": "An incomplete
5064 structure, union or class type is represented by a structure,
5065 union or class entry that does not have a byte size attribute
5066 and that has a DW_AT_declaration attribute." */
5067 if (!pdi->has_byte_size && pdi->is_declaration)
5068 {
5069 if (built_actual_name)
5070 xfree (actual_name);
5071 return;
5072 }
5073
5074 /* NOTE: carlton/2003-10-07: See comment in new_symbol about
5075 static vs. global. */
5076 add_psymbol_to_list (actual_name, strlen (actual_name),
5077 built_actual_name,
5078 STRUCT_DOMAIN, LOC_TYPEDEF,
5079 (cu->language == language_cplus
5080 || cu->language == language_java)
5081 ? &objfile->global_psymbols
5082 : &objfile->static_psymbols,
5083 0, (CORE_ADDR) 0, cu->language, objfile);
5084
5085 break;
5086 case DW_TAG_enumerator:
5087 add_psymbol_to_list (actual_name, strlen (actual_name),
5088 built_actual_name,
5089 VAR_DOMAIN, LOC_CONST,
5090 (cu->language == language_cplus
5091 || cu->language == language_java)
5092 ? &objfile->global_psymbols
5093 : &objfile->static_psymbols,
5094 0, (CORE_ADDR) 0, cu->language, objfile);
5095 break;
5096 default:
5097 break;
5098 }
5099
5100 if (built_actual_name)
5101 xfree (actual_name);
5102 }
5103
5104 /* Read a partial die corresponding to a namespace; also, add a symbol
5105 corresponding to that namespace to the symbol table. NAMESPACE is
5106 the name of the enclosing namespace. */
5107
5108 static void
5109 add_partial_namespace (struct partial_die_info *pdi,
5110 CORE_ADDR *lowpc, CORE_ADDR *highpc,
5111 int need_pc, struct dwarf2_cu *cu)
5112 {
5113 /* Add a symbol for the namespace. */
5114
5115 add_partial_symbol (pdi, cu);
5116
5117 /* Now scan partial symbols in that namespace. */
5118
5119 if (pdi->has_children)
5120 scan_partial_symbols (pdi->die_child, lowpc, highpc, need_pc, cu);
5121 }
5122
5123 /* Read a partial die corresponding to a Fortran module. */
5124
5125 static void
5126 add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc,
5127 CORE_ADDR *highpc, int need_pc, struct dwarf2_cu *cu)
5128 {
5129 /* Now scan partial symbols in that module. */
5130
5131 if (pdi->has_children)
5132 scan_partial_symbols (pdi->die_child, lowpc, highpc, need_pc, cu);
5133 }
5134
5135 /* Read a partial die corresponding to a subprogram and create a partial
5136 symbol for that subprogram. When the CU language allows it, this
5137 routine also defines a partial symbol for each nested subprogram
5138 that this subprogram contains.
5139
5140 DIE my also be a lexical block, in which case we simply search
5141 recursively for suprograms defined inside that lexical block.
5142 Again, this is only performed when the CU language allows this
5143 type of definitions. */
5144
5145 static void
5146 add_partial_subprogram (struct partial_die_info *pdi,
5147 CORE_ADDR *lowpc, CORE_ADDR *highpc,
5148 int need_pc, struct dwarf2_cu *cu)
5149 {
5150 if (pdi->tag == DW_TAG_subprogram)
5151 {
5152 if (pdi->has_pc_info)
5153 {
5154 if (pdi->lowpc < *lowpc)
5155 *lowpc = pdi->lowpc;
5156 if (pdi->highpc > *highpc)
5157 *highpc = pdi->highpc;
5158 if (need_pc)
5159 {
5160 CORE_ADDR baseaddr;
5161 struct objfile *objfile = cu->objfile;
5162
5163 baseaddr = ANOFFSET (objfile->section_offsets,
5164 SECT_OFF_TEXT (objfile));
5165 addrmap_set_empty (objfile->psymtabs_addrmap,
5166 pdi->lowpc + baseaddr,
5167 pdi->highpc - 1 + baseaddr,
5168 cu->per_cu->v.psymtab);
5169 }
5170 }
5171
5172 if (pdi->has_pc_info || (!pdi->is_external && pdi->may_be_inlined))
5173 {
5174 if (!pdi->is_declaration)
5175 /* Ignore subprogram DIEs that do not have a name, they are
5176 illegal. Do not emit a complaint at this point, we will
5177 do so when we convert this psymtab into a symtab. */
5178 if (pdi->name)
5179 add_partial_symbol (pdi, cu);
5180 }
5181 }
5182
5183 if (! pdi->has_children)
5184 return;
5185
5186 if (cu->language == language_ada)
5187 {
5188 pdi = pdi->die_child;
5189 while (pdi != NULL)
5190 {
5191 fixup_partial_die (pdi, cu);
5192 if (pdi->tag == DW_TAG_subprogram
5193 || pdi->tag == DW_TAG_lexical_block)
5194 add_partial_subprogram (pdi, lowpc, highpc, need_pc, cu);
5195 pdi = pdi->die_sibling;
5196 }
5197 }
5198 }
5199
5200 /* Read a partial die corresponding to an enumeration type. */
5201
5202 static void
5203 add_partial_enumeration (struct partial_die_info *enum_pdi,
5204 struct dwarf2_cu *cu)
5205 {
5206 struct partial_die_info *pdi;
5207
5208 if (enum_pdi->name != NULL)
5209 add_partial_symbol (enum_pdi, cu);
5210
5211 pdi = enum_pdi->die_child;
5212 while (pdi)
5213 {
5214 if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
5215 complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
5216 else
5217 add_partial_symbol (pdi, cu);
5218 pdi = pdi->die_sibling;
5219 }
5220 }
5221
5222 /* Return the initial uleb128 in the die at INFO_PTR. */
5223
5224 static unsigned int
5225 peek_abbrev_code (bfd *abfd, gdb_byte *info_ptr)
5226 {
5227 unsigned int bytes_read;
5228
5229 return read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5230 }
5231
5232 /* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU.
5233 Return the corresponding abbrev, or NULL if the number is zero (indicating
5234 an empty DIE). In either case *BYTES_READ will be set to the length of
5235 the initial number. */
5236
5237 static struct abbrev_info *
5238 peek_die_abbrev (gdb_byte *info_ptr, unsigned int *bytes_read,
5239 struct dwarf2_cu *cu)
5240 {
5241 bfd *abfd = cu->objfile->obfd;
5242 unsigned int abbrev_number;
5243 struct abbrev_info *abbrev;
5244
5245 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
5246
5247 if (abbrev_number == 0)
5248 return NULL;
5249
5250 abbrev = abbrev_table_lookup_abbrev (cu->abbrev_table, abbrev_number);
5251 if (!abbrev)
5252 {
5253 error (_("Dwarf Error: Could not find abbrev number %d [in module %s]"),
5254 abbrev_number, bfd_get_filename (abfd));
5255 }
5256
5257 return abbrev;
5258 }
5259
5260 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
5261 Returns a pointer to the end of a series of DIEs, terminated by an empty
5262 DIE. Any children of the skipped DIEs will also be skipped. */
5263
5264 static gdb_byte *
5265 skip_children (const struct die_reader_specs *reader, gdb_byte *info_ptr)
5266 {
5267 struct dwarf2_cu *cu = reader->cu;
5268 struct abbrev_info *abbrev;
5269 unsigned int bytes_read;
5270
5271 while (1)
5272 {
5273 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
5274 if (abbrev == NULL)
5275 return info_ptr + bytes_read;
5276 else
5277 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
5278 }
5279 }
5280
5281 /* Scan the debug information for CU starting at INFO_PTR in buffer BUFFER.
5282 INFO_PTR should point just after the initial uleb128 of a DIE, and the
5283 abbrev corresponding to that skipped uleb128 should be passed in
5284 ABBREV. Returns a pointer to this DIE's sibling, skipping any
5285 children. */
5286
5287 static gdb_byte *
5288 skip_one_die (const struct die_reader_specs *reader, gdb_byte *info_ptr,
5289 struct abbrev_info *abbrev)
5290 {
5291 unsigned int bytes_read;
5292 struct attribute attr;
5293 bfd *abfd = reader->abfd;
5294 struct dwarf2_cu *cu = reader->cu;
5295 gdb_byte *buffer = reader->buffer;
5296 const gdb_byte *buffer_end = reader->buffer_end;
5297 gdb_byte *start_info_ptr = info_ptr;
5298 unsigned int form, i;
5299
5300 for (i = 0; i < abbrev->num_attrs; i++)
5301 {
5302 /* The only abbrev we care about is DW_AT_sibling. */
5303 if (abbrev->attrs[i].name == DW_AT_sibling)
5304 {
5305 read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
5306 if (attr.form == DW_FORM_ref_addr)
5307 complaint (&symfile_complaints,
5308 _("ignoring absolute DW_AT_sibling"));
5309 else
5310 return buffer + dwarf2_get_ref_die_offset (&attr).sect_off;
5311 }
5312
5313 /* If it isn't DW_AT_sibling, skip this attribute. */
5314 form = abbrev->attrs[i].form;
5315 skip_attribute:
5316 switch (form)
5317 {
5318 case DW_FORM_ref_addr:
5319 /* In DWARF 2, DW_FORM_ref_addr is address sized; in DWARF 3
5320 and later it is offset sized. */
5321 if (cu->header.version == 2)
5322 info_ptr += cu->header.addr_size;
5323 else
5324 info_ptr += cu->header.offset_size;
5325 break;
5326 case DW_FORM_addr:
5327 info_ptr += cu->header.addr_size;
5328 break;
5329 case DW_FORM_data1:
5330 case DW_FORM_ref1:
5331 case DW_FORM_flag:
5332 info_ptr += 1;
5333 break;
5334 case DW_FORM_flag_present:
5335 break;
5336 case DW_FORM_data2:
5337 case DW_FORM_ref2:
5338 info_ptr += 2;
5339 break;
5340 case DW_FORM_data4:
5341 case DW_FORM_ref4:
5342 info_ptr += 4;
5343 break;
5344 case DW_FORM_data8:
5345 case DW_FORM_ref8:
5346 case DW_FORM_ref_sig8:
5347 info_ptr += 8;
5348 break;
5349 case DW_FORM_string:
5350 read_direct_string (abfd, info_ptr, &bytes_read);
5351 info_ptr += bytes_read;
5352 break;
5353 case DW_FORM_sec_offset:
5354 case DW_FORM_strp:
5355 info_ptr += cu->header.offset_size;
5356 break;
5357 case DW_FORM_exprloc:
5358 case DW_FORM_block:
5359 info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5360 info_ptr += bytes_read;
5361 break;
5362 case DW_FORM_block1:
5363 info_ptr += 1 + read_1_byte (abfd, info_ptr);
5364 break;
5365 case DW_FORM_block2:
5366 info_ptr += 2 + read_2_bytes (abfd, info_ptr);
5367 break;
5368 case DW_FORM_block4:
5369 info_ptr += 4 + read_4_bytes (abfd, info_ptr);
5370 break;
5371 case DW_FORM_sdata:
5372 case DW_FORM_udata:
5373 case DW_FORM_ref_udata:
5374 case DW_FORM_GNU_addr_index:
5375 case DW_FORM_GNU_str_index:
5376 info_ptr = (gdb_byte *) safe_skip_leb128 (info_ptr, buffer_end);
5377 break;
5378 case DW_FORM_indirect:
5379 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
5380 info_ptr += bytes_read;
5381 /* We need to continue parsing from here, so just go back to
5382 the top. */
5383 goto skip_attribute;
5384
5385 default:
5386 error (_("Dwarf Error: Cannot handle %s "
5387 "in DWARF reader [in module %s]"),
5388 dwarf_form_name (form),
5389 bfd_get_filename (abfd));
5390 }
5391 }
5392
5393 if (abbrev->has_children)
5394 return skip_children (reader, info_ptr);
5395 else
5396 return info_ptr;
5397 }
5398
5399 /* Locate ORIG_PDI's sibling.
5400 INFO_PTR should point to the start of the next DIE after ORIG_PDI. */
5401
5402 static gdb_byte *
5403 locate_pdi_sibling (const struct die_reader_specs *reader,
5404 struct partial_die_info *orig_pdi,
5405 gdb_byte *info_ptr)
5406 {
5407 /* Do we know the sibling already? */
5408
5409 if (orig_pdi->sibling)
5410 return orig_pdi->sibling;
5411
5412 /* Are there any children to deal with? */
5413
5414 if (!orig_pdi->has_children)
5415 return info_ptr;
5416
5417 /* Skip the children the long way. */
5418
5419 return skip_children (reader, info_ptr);
5420 }
5421
5422 /* Expand this partial symbol table into a full symbol table. */
5423
5424 static void
5425 dwarf2_psymtab_to_symtab (struct partial_symtab *pst)
5426 {
5427 if (pst != NULL)
5428 {
5429 if (pst->readin)
5430 {
5431 warning (_("bug: psymtab for %s is already read in."),
5432 pst->filename);
5433 }
5434 else
5435 {
5436 if (info_verbose)
5437 {
5438 printf_filtered (_("Reading in symbols for %s..."),
5439 pst->filename);
5440 gdb_flush (gdb_stdout);
5441 }
5442
5443 /* Restore our global data. */
5444 dwarf2_per_objfile = objfile_data (pst->objfile,
5445 dwarf2_objfile_data_key);
5446
5447 /* If this psymtab is constructed from a debug-only objfile, the
5448 has_section_at_zero flag will not necessarily be correct. We
5449 can get the correct value for this flag by looking at the data
5450 associated with the (presumably stripped) associated objfile. */
5451 if (pst->objfile->separate_debug_objfile_backlink)
5452 {
5453 struct dwarf2_per_objfile *dpo_backlink
5454 = objfile_data (pst->objfile->separate_debug_objfile_backlink,
5455 dwarf2_objfile_data_key);
5456
5457 dwarf2_per_objfile->has_section_at_zero
5458 = dpo_backlink->has_section_at_zero;
5459 }
5460
5461 dwarf2_per_objfile->reading_partial_symbols = 0;
5462
5463 psymtab_to_symtab_1 (pst);
5464
5465 /* Finish up the debug error message. */
5466 if (info_verbose)
5467 printf_filtered (_("done.\n"));
5468 }
5469 }
5470
5471 process_cu_includes ();
5472 }
5473 \f
5474 /* Reading in full CUs. */
5475
5476 /* Add PER_CU to the queue. */
5477
5478 static void
5479 queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
5480 enum language pretend_language)
5481 {
5482 struct dwarf2_queue_item *item;
5483
5484 per_cu->queued = 1;
5485 item = xmalloc (sizeof (*item));
5486 item->per_cu = per_cu;
5487 item->pretend_language = pretend_language;
5488 item->next = NULL;
5489
5490 if (dwarf2_queue == NULL)
5491 dwarf2_queue = item;
5492 else
5493 dwarf2_queue_tail->next = item;
5494
5495 dwarf2_queue_tail = item;
5496 }
5497
5498 /* THIS_CU has a reference to PER_CU. If necessary, load the new compilation
5499 unit and add it to our queue.
5500 The result is non-zero if PER_CU was queued, otherwise the result is zero
5501 meaning either PER_CU is already queued or it is already loaded. */
5502
5503 static int
5504 maybe_queue_comp_unit (struct dwarf2_cu *this_cu,
5505 struct dwarf2_per_cu_data *per_cu,
5506 enum language pretend_language)
5507 {
5508 /* We may arrive here during partial symbol reading, if we need full
5509 DIEs to process an unusual case (e.g. template arguments). Do
5510 not queue PER_CU, just tell our caller to load its DIEs. */
5511 if (dwarf2_per_objfile->reading_partial_symbols)
5512 {
5513 if (per_cu->cu == NULL || per_cu->cu->dies == NULL)
5514 return 1;
5515 return 0;
5516 }
5517
5518 /* Mark the dependence relation so that we don't flush PER_CU
5519 too early. */
5520 dwarf2_add_dependence (this_cu, per_cu);
5521
5522 /* If it's already on the queue, we have nothing to do. */
5523 if (per_cu->queued)
5524 return 0;
5525
5526 /* If the compilation unit is already loaded, just mark it as
5527 used. */
5528 if (per_cu->cu != NULL)
5529 {
5530 per_cu->cu->last_used = 0;
5531 return 0;
5532 }
5533
5534 /* Add it to the queue. */
5535 queue_comp_unit (per_cu, pretend_language);
5536
5537 return 1;
5538 }
5539
5540 /* Process the queue. */
5541
5542 static void
5543 process_queue (void)
5544 {
5545 struct dwarf2_queue_item *item, *next_item;
5546
5547 if (dwarf2_read_debug)
5548 {
5549 fprintf_unfiltered (gdb_stdlog,
5550 "Expanding one or more symtabs of objfile %s ...\n",
5551 dwarf2_per_objfile->objfile->name);
5552 }
5553
5554 /* The queue starts out with one item, but following a DIE reference
5555 may load a new CU, adding it to the end of the queue. */
5556 for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item)
5557 {
5558 if (dwarf2_per_objfile->using_index
5559 ? !item->per_cu->v.quick->symtab
5560 : (item->per_cu->v.psymtab && !item->per_cu->v.psymtab->readin))
5561 process_full_comp_unit (item->per_cu, item->pretend_language);
5562
5563 item->per_cu->queued = 0;
5564 next_item = item->next;
5565 xfree (item);
5566 }
5567
5568 dwarf2_queue_tail = NULL;
5569
5570 if (dwarf2_read_debug)
5571 {
5572 fprintf_unfiltered (gdb_stdlog, "Done expanding symtabs of %s.\n",
5573 dwarf2_per_objfile->objfile->name);
5574 }
5575 }
5576
5577 /* Free all allocated queue entries. This function only releases anything if
5578 an error was thrown; if the queue was processed then it would have been
5579 freed as we went along. */
5580
5581 static void
5582 dwarf2_release_queue (void *dummy)
5583 {
5584 struct dwarf2_queue_item *item, *last;
5585
5586 item = dwarf2_queue;
5587 while (item)
5588 {
5589 /* Anything still marked queued is likely to be in an
5590 inconsistent state, so discard it. */
5591 if (item->per_cu->queued)
5592 {
5593 if (item->per_cu->cu != NULL)
5594 free_one_cached_comp_unit (item->per_cu);
5595 item->per_cu->queued = 0;
5596 }
5597
5598 last = item;
5599 item = item->next;
5600 xfree (last);
5601 }
5602
5603 dwarf2_queue = dwarf2_queue_tail = NULL;
5604 }
5605
5606 /* Read in full symbols for PST, and anything it depends on. */
5607
5608 static void
5609 psymtab_to_symtab_1 (struct partial_symtab *pst)
5610 {
5611 struct dwarf2_per_cu_data *per_cu;
5612 int i;
5613
5614 if (pst->readin)
5615 return;
5616
5617 for (i = 0; i < pst->number_of_dependencies; i++)
5618 if (!pst->dependencies[i]->readin
5619 && pst->dependencies[i]->user == NULL)
5620 {
5621 /* Inform about additional files that need to be read in. */
5622 if (info_verbose)
5623 {
5624 /* FIXME: i18n: Need to make this a single string. */
5625 fputs_filtered (" ", gdb_stdout);
5626 wrap_here ("");
5627 fputs_filtered ("and ", gdb_stdout);
5628 wrap_here ("");
5629 printf_filtered ("%s...", pst->dependencies[i]->filename);
5630 wrap_here (""); /* Flush output. */
5631 gdb_flush (gdb_stdout);
5632 }
5633 psymtab_to_symtab_1 (pst->dependencies[i]);
5634 }
5635
5636 per_cu = pst->read_symtab_private;
5637
5638 if (per_cu == NULL)
5639 {
5640 /* It's an include file, no symbols to read for it.
5641 Everything is in the parent symtab. */
5642 pst->readin = 1;
5643 return;
5644 }
5645
5646 dw2_do_instantiate_symtab (per_cu);
5647 }
5648
5649 /* Trivial hash function for die_info: the hash value of a DIE
5650 is its offset in .debug_info for this objfile. */
5651
5652 static hashval_t
5653 die_hash (const void *item)
5654 {
5655 const struct die_info *die = item;
5656
5657 return die->offset.sect_off;
5658 }
5659
5660 /* Trivial comparison function for die_info structures: two DIEs
5661 are equal if they have the same offset. */
5662
5663 static int
5664 die_eq (const void *item_lhs, const void *item_rhs)
5665 {
5666 const struct die_info *die_lhs = item_lhs;
5667 const struct die_info *die_rhs = item_rhs;
5668
5669 return die_lhs->offset.sect_off == die_rhs->offset.sect_off;
5670 }
5671
5672 /* die_reader_func for load_full_comp_unit.
5673 This is identical to read_signatured_type_reader,
5674 but is kept separate for now. */
5675
5676 static void
5677 load_full_comp_unit_reader (const struct die_reader_specs *reader,
5678 gdb_byte *info_ptr,
5679 struct die_info *comp_unit_die,
5680 int has_children,
5681 void *data)
5682 {
5683 struct dwarf2_cu *cu = reader->cu;
5684 enum language *language_ptr = data;
5685
5686 gdb_assert (cu->die_hash == NULL);
5687 cu->die_hash =
5688 htab_create_alloc_ex (cu->header.length / 12,
5689 die_hash,
5690 die_eq,
5691 NULL,
5692 &cu->comp_unit_obstack,
5693 hashtab_obstack_allocate,
5694 dummy_obstack_deallocate);
5695
5696 if (has_children)
5697 comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
5698 &info_ptr, comp_unit_die);
5699 cu->dies = comp_unit_die;
5700 /* comp_unit_die is not stored in die_hash, no need. */
5701
5702 /* We try not to read any attributes in this function, because not
5703 all CUs needed for references have been loaded yet, and symbol
5704 table processing isn't initialized. But we have to set the CU language,
5705 or we won't be able to build types correctly.
5706 Similarly, if we do not read the producer, we can not apply
5707 producer-specific interpretation. */
5708 prepare_one_comp_unit (cu, cu->dies, *language_ptr);
5709 }
5710
5711 /* Load the DIEs associated with PER_CU into memory. */
5712
5713 static void
5714 load_full_comp_unit (struct dwarf2_per_cu_data *this_cu,
5715 enum language pretend_language)
5716 {
5717 gdb_assert (! this_cu->is_debug_types);
5718
5719 init_cutu_and_read_dies (this_cu, 1, 1, load_full_comp_unit_reader,
5720 &pretend_language);
5721 }
5722
5723 /* Add a DIE to the delayed physname list. */
5724
5725 static void
5726 add_to_method_list (struct type *type, int fnfield_index, int index,
5727 const char *name, struct die_info *die,
5728 struct dwarf2_cu *cu)
5729 {
5730 struct delayed_method_info mi;
5731 mi.type = type;
5732 mi.fnfield_index = fnfield_index;
5733 mi.index = index;
5734 mi.name = name;
5735 mi.die = die;
5736 VEC_safe_push (delayed_method_info, cu->method_list, &mi);
5737 }
5738
5739 /* A cleanup for freeing the delayed method list. */
5740
5741 static void
5742 free_delayed_list (void *ptr)
5743 {
5744 struct dwarf2_cu *cu = (struct dwarf2_cu *) ptr;
5745 if (cu->method_list != NULL)
5746 {
5747 VEC_free (delayed_method_info, cu->method_list);
5748 cu->method_list = NULL;
5749 }
5750 }
5751
5752 /* Compute the physnames of any methods on the CU's method list.
5753
5754 The computation of method physnames is delayed in order to avoid the
5755 (bad) condition that one of the method's formal parameters is of an as yet
5756 incomplete type. */
5757
5758 static void
5759 compute_delayed_physnames (struct dwarf2_cu *cu)
5760 {
5761 int i;
5762 struct delayed_method_info *mi;
5763 for (i = 0; VEC_iterate (delayed_method_info, cu->method_list, i, mi) ; ++i)
5764 {
5765 const char *physname;
5766 struct fn_fieldlist *fn_flp
5767 = &TYPE_FN_FIELDLIST (mi->type, mi->fnfield_index);
5768 physname = dwarf2_physname ((char *) mi->name, mi->die, cu);
5769 fn_flp->fn_fields[mi->index].physname = physname ? physname : "";
5770 }
5771 }
5772
5773 /* Go objects should be embedded in a DW_TAG_module DIE,
5774 and it's not clear if/how imported objects will appear.
5775 To keep Go support simple until that's worked out,
5776 go back through what we've read and create something usable.
5777 We could do this while processing each DIE, and feels kinda cleaner,
5778 but that way is more invasive.
5779 This is to, for example, allow the user to type "p var" or "b main"
5780 without having to specify the package name, and allow lookups
5781 of module.object to work in contexts that use the expression
5782 parser. */
5783
5784 static void
5785 fixup_go_packaging (struct dwarf2_cu *cu)
5786 {
5787 char *package_name = NULL;
5788 struct pending *list;
5789 int i;
5790
5791 for (list = global_symbols; list != NULL; list = list->next)
5792 {
5793 for (i = 0; i < list->nsyms; ++i)
5794 {
5795 struct symbol *sym = list->symbol[i];
5796
5797 if (SYMBOL_LANGUAGE (sym) == language_go
5798 && SYMBOL_CLASS (sym) == LOC_BLOCK)
5799 {
5800 char *this_package_name = go_symbol_package_name (sym);
5801
5802 if (this_package_name == NULL)
5803 continue;
5804 if (package_name == NULL)
5805 package_name = this_package_name;
5806 else
5807 {
5808 if (strcmp (package_name, this_package_name) != 0)
5809 complaint (&symfile_complaints,
5810 _("Symtab %s has objects from two different Go packages: %s and %s"),
5811 (sym->symtab && sym->symtab->filename
5812 ? sym->symtab->filename
5813 : cu->objfile->name),
5814 this_package_name, package_name);
5815 xfree (this_package_name);
5816 }
5817 }
5818 }
5819 }
5820
5821 if (package_name != NULL)
5822 {
5823 struct objfile *objfile = cu->objfile;
5824 struct type *type = init_type (TYPE_CODE_MODULE, 0, 0,
5825 package_name, objfile);
5826 struct symbol *sym;
5827
5828 TYPE_TAG_NAME (type) = TYPE_NAME (type);
5829
5830 sym = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct symbol);
5831 SYMBOL_SET_LANGUAGE (sym, language_go);
5832 SYMBOL_SET_NAMES (sym, package_name, strlen (package_name), 1, objfile);
5833 /* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
5834 e.g., "main" finds the "main" module and not C's main(). */
5835 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
5836 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
5837 SYMBOL_TYPE (sym) = type;
5838
5839 add_symbol_to_list (sym, &global_symbols);
5840
5841 xfree (package_name);
5842 }
5843 }
5844
5845 static void compute_symtab_includes (struct dwarf2_per_cu_data *per_cu);
5846
5847 /* Return the symtab for PER_CU. This works properly regardless of
5848 whether we're using the index or psymtabs. */
5849
5850 static struct symtab *
5851 get_symtab (struct dwarf2_per_cu_data *per_cu)
5852 {
5853 return (dwarf2_per_objfile->using_index
5854 ? per_cu->v.quick->symtab
5855 : per_cu->v.psymtab->symtab);
5856 }
5857
5858 /* A helper function for computing the list of all symbol tables
5859 included by PER_CU. */
5860
5861 static void
5862 recursively_compute_inclusions (VEC (dwarf2_per_cu_ptr) **result,
5863 htab_t all_children,
5864 struct dwarf2_per_cu_data *per_cu)
5865 {
5866 void **slot;
5867 int ix;
5868 struct dwarf2_per_cu_data *iter;
5869
5870 slot = htab_find_slot (all_children, per_cu, INSERT);
5871 if (*slot != NULL)
5872 {
5873 /* This inclusion and its children have been processed. */
5874 return;
5875 }
5876
5877 *slot = per_cu;
5878 /* Only add a CU if it has a symbol table. */
5879 if (get_symtab (per_cu) != NULL)
5880 VEC_safe_push (dwarf2_per_cu_ptr, *result, per_cu);
5881
5882 for (ix = 0;
5883 VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs, ix, iter);
5884 ++ix)
5885 recursively_compute_inclusions (result, all_children, iter);
5886 }
5887
5888 /* Compute the symtab 'includes' fields for the symtab related to
5889 PER_CU. */
5890
5891 static void
5892 compute_symtab_includes (struct dwarf2_per_cu_data *per_cu)
5893 {
5894 if (!VEC_empty (dwarf2_per_cu_ptr, per_cu->imported_symtabs))
5895 {
5896 int ix, len;
5897 struct dwarf2_per_cu_data *iter;
5898 VEC (dwarf2_per_cu_ptr) *result_children = NULL;
5899 htab_t all_children;
5900 struct symtab *symtab = get_symtab (per_cu);
5901
5902 /* If we don't have a symtab, we can just skip this case. */
5903 if (symtab == NULL)
5904 return;
5905
5906 all_children = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
5907 NULL, xcalloc, xfree);
5908
5909 for (ix = 0;
5910 VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs,
5911 ix, iter);
5912 ++ix)
5913 recursively_compute_inclusions (&result_children, all_children, iter);
5914
5915 /* Now we have a transitive closure of all the included CUs, so
5916 we can convert it to a list of symtabs. */
5917 len = VEC_length (dwarf2_per_cu_ptr, result_children);
5918 symtab->includes
5919 = obstack_alloc (&dwarf2_per_objfile->objfile->objfile_obstack,
5920 (len + 1) * sizeof (struct symtab *));
5921 for (ix = 0;
5922 VEC_iterate (dwarf2_per_cu_ptr, result_children, ix, iter);
5923 ++ix)
5924 symtab->includes[ix] = get_symtab (iter);
5925 symtab->includes[len] = NULL;
5926
5927 VEC_free (dwarf2_per_cu_ptr, result_children);
5928 htab_delete (all_children);
5929 }
5930 }
5931
5932 /* Compute the 'includes' field for the symtabs of all the CUs we just
5933 read. */
5934
5935 static void
5936 process_cu_includes (void)
5937 {
5938 int ix;
5939 struct dwarf2_per_cu_data *iter;
5940
5941 for (ix = 0;
5942 VEC_iterate (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus,
5943 ix, iter);
5944 ++ix)
5945 compute_symtab_includes (iter);
5946
5947 VEC_free (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus);
5948 }
5949
5950 /* Generate full symbol information for PER_CU, whose DIEs have
5951 already been loaded into memory. */
5952
5953 static void
5954 process_full_comp_unit (struct dwarf2_per_cu_data *per_cu,
5955 enum language pretend_language)
5956 {
5957 struct dwarf2_cu *cu = per_cu->cu;
5958 struct objfile *objfile = per_cu->objfile;
5959 CORE_ADDR lowpc, highpc;
5960 struct symtab *symtab;
5961 struct cleanup *back_to, *delayed_list_cleanup;
5962 CORE_ADDR baseaddr;
5963
5964 if (dwarf2_read_debug)
5965 {
5966 fprintf_unfiltered (gdb_stdlog,
5967 "Expanding symtab of %s at offset 0x%x\n",
5968 per_cu->is_debug_types ? "TU" : "CU",
5969 per_cu->offset.sect_off);
5970 }
5971
5972 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
5973
5974 buildsym_init ();
5975 back_to = make_cleanup (really_free_pendings, NULL);
5976 delayed_list_cleanup = make_cleanup (free_delayed_list, cu);
5977
5978 cu->list_in_scope = &file_symbols;
5979
5980 cu->language = pretend_language;
5981 cu->language_defn = language_def (cu->language);
5982
5983 /* Do line number decoding in read_file_scope () */
5984 process_die (cu->dies, cu);
5985
5986 /* For now fudge the Go package. */
5987 if (cu->language == language_go)
5988 fixup_go_packaging (cu);
5989
5990 /* Now that we have processed all the DIEs in the CU, all the types
5991 should be complete, and it should now be safe to compute all of the
5992 physnames. */
5993 compute_delayed_physnames (cu);
5994 do_cleanups (delayed_list_cleanup);
5995
5996 /* Some compilers don't define a DW_AT_high_pc attribute for the
5997 compilation unit. If the DW_AT_high_pc is missing, synthesize
5998 it, by scanning the DIE's below the compilation unit. */
5999 get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
6000
6001 symtab = end_symtab (highpc + baseaddr, objfile, SECT_OFF_TEXT (objfile));
6002
6003 if (symtab != NULL)
6004 {
6005 int gcc_4_minor = producer_is_gcc_ge_4 (cu->producer);
6006
6007 /* Set symtab language to language from DW_AT_language. If the
6008 compilation is from a C file generated by language preprocessors, do
6009 not set the language if it was already deduced by start_subfile. */
6010 if (!(cu->language == language_c && symtab->language != language_c))
6011 symtab->language = cu->language;
6012
6013 /* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
6014 produce DW_AT_location with location lists but it can be possibly
6015 invalid without -fvar-tracking. Still up to GCC-4.4.x incl. 4.4.0
6016 there were bugs in prologue debug info, fixed later in GCC-4.5
6017 by "unwind info for epilogues" patch (which is not directly related).
6018
6019 For -gdwarf-4 type units LOCATIONS_VALID indication is fortunately not
6020 needed, it would be wrong due to missing DW_AT_producer there.
6021
6022 Still one can confuse GDB by using non-standard GCC compilation
6023 options - this waits on GCC PR other/32998 (-frecord-gcc-switches).
6024 */
6025 if (cu->has_loclist && gcc_4_minor >= 5)
6026 symtab->locations_valid = 1;
6027
6028 if (gcc_4_minor >= 5)
6029 symtab->epilogue_unwind_valid = 1;
6030
6031 symtab->call_site_htab = cu->call_site_htab;
6032 }
6033
6034 if (dwarf2_per_objfile->using_index)
6035 per_cu->v.quick->symtab = symtab;
6036 else
6037 {
6038 struct partial_symtab *pst = per_cu->v.psymtab;
6039 pst->symtab = symtab;
6040 pst->readin = 1;
6041 }
6042
6043 /* Push it for inclusion processing later. */
6044 VEC_safe_push (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus, per_cu);
6045
6046 do_cleanups (back_to);
6047
6048 if (dwarf2_read_debug)
6049 {
6050 fprintf_unfiltered (gdb_stdlog,
6051 "Done expanding symtab of %s at offset 0x%x\n",
6052 per_cu->is_debug_types ? "TU" : "CU",
6053 per_cu->offset.sect_off);
6054 }
6055 }
6056
6057 /* Process an imported unit DIE. */
6058
6059 static void
6060 process_imported_unit_die (struct die_info *die, struct dwarf2_cu *cu)
6061 {
6062 struct attribute *attr;
6063
6064 attr = dwarf2_attr (die, DW_AT_import, cu);
6065 if (attr != NULL)
6066 {
6067 struct dwarf2_per_cu_data *per_cu;
6068 struct symtab *imported_symtab;
6069 sect_offset offset;
6070
6071 offset = dwarf2_get_ref_die_offset (attr);
6072 per_cu = dwarf2_find_containing_comp_unit (offset, cu->objfile);
6073
6074 /* Queue the unit, if needed. */
6075 if (maybe_queue_comp_unit (cu, per_cu, cu->language))
6076 load_full_comp_unit (per_cu, cu->language);
6077
6078 VEC_safe_push (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
6079 per_cu);
6080 }
6081 }
6082
6083 /* Process a die and its children. */
6084
6085 static void
6086 process_die (struct die_info *die, struct dwarf2_cu *cu)
6087 {
6088 switch (die->tag)
6089 {
6090 case DW_TAG_padding:
6091 break;
6092 case DW_TAG_compile_unit:
6093 case DW_TAG_partial_unit:
6094 read_file_scope (die, cu);
6095 break;
6096 case DW_TAG_type_unit:
6097 read_type_unit_scope (die, cu);
6098 break;
6099 case DW_TAG_subprogram:
6100 case DW_TAG_inlined_subroutine:
6101 read_func_scope (die, cu);
6102 break;
6103 case DW_TAG_lexical_block:
6104 case DW_TAG_try_block:
6105 case DW_TAG_catch_block:
6106 read_lexical_block_scope (die, cu);
6107 break;
6108 case DW_TAG_GNU_call_site:
6109 read_call_site_scope (die, cu);
6110 break;
6111 case DW_TAG_class_type:
6112 case DW_TAG_interface_type:
6113 case DW_TAG_structure_type:
6114 case DW_TAG_union_type:
6115 process_structure_scope (die, cu);
6116 break;
6117 case DW_TAG_enumeration_type:
6118 process_enumeration_scope (die, cu);
6119 break;
6120
6121 /* These dies have a type, but processing them does not create
6122 a symbol or recurse to process the children. Therefore we can
6123 read them on-demand through read_type_die. */
6124 case DW_TAG_subroutine_type:
6125 case DW_TAG_set_type:
6126 case DW_TAG_array_type:
6127 case DW_TAG_pointer_type:
6128 case DW_TAG_ptr_to_member_type:
6129 case DW_TAG_reference_type:
6130 case DW_TAG_string_type:
6131 break;
6132
6133 case DW_TAG_base_type:
6134 case DW_TAG_subrange_type:
6135 case DW_TAG_typedef:
6136 /* Add a typedef symbol for the type definition, if it has a
6137 DW_AT_name. */
6138 new_symbol (die, read_type_die (die, cu), cu);
6139 break;
6140 case DW_TAG_common_block:
6141 read_common_block (die, cu);
6142 break;
6143 case DW_TAG_common_inclusion:
6144 break;
6145 case DW_TAG_namespace:
6146 processing_has_namespace_info = 1;
6147 read_namespace (die, cu);
6148 break;
6149 case DW_TAG_module:
6150 processing_has_namespace_info = 1;
6151 read_module (die, cu);
6152 break;
6153 case DW_TAG_imported_declaration:
6154 case DW_TAG_imported_module:
6155 processing_has_namespace_info = 1;
6156 if (die->child != NULL && (die->tag == DW_TAG_imported_declaration
6157 || cu->language != language_fortran))
6158 complaint (&symfile_complaints, _("Tag '%s' has unexpected children"),
6159 dwarf_tag_name (die->tag));
6160 read_import_statement (die, cu);
6161 break;
6162
6163 case DW_TAG_imported_unit:
6164 process_imported_unit_die (die, cu);
6165 break;
6166
6167 default:
6168 new_symbol (die, NULL, cu);
6169 break;
6170 }
6171 }
6172
6173 /* A helper function for dwarf2_compute_name which determines whether DIE
6174 needs to have the name of the scope prepended to the name listed in the
6175 die. */
6176
6177 static int
6178 die_needs_namespace (struct die_info *die, struct dwarf2_cu *cu)
6179 {
6180 struct attribute *attr;
6181
6182 switch (die->tag)
6183 {
6184 case DW_TAG_namespace:
6185 case DW_TAG_typedef:
6186 case DW_TAG_class_type:
6187 case DW_TAG_interface_type:
6188 case DW_TAG_structure_type:
6189 case DW_TAG_union_type:
6190 case DW_TAG_enumeration_type:
6191 case DW_TAG_enumerator:
6192 case DW_TAG_subprogram:
6193 case DW_TAG_member:
6194 return 1;
6195
6196 case DW_TAG_variable:
6197 case DW_TAG_constant:
6198 /* We only need to prefix "globally" visible variables. These include
6199 any variable marked with DW_AT_external or any variable that
6200 lives in a namespace. [Variables in anonymous namespaces
6201 require prefixing, but they are not DW_AT_external.] */
6202
6203 if (dwarf2_attr (die, DW_AT_specification, cu))
6204 {
6205 struct dwarf2_cu *spec_cu = cu;
6206
6207 return die_needs_namespace (die_specification (die, &spec_cu),
6208 spec_cu);
6209 }
6210
6211 attr = dwarf2_attr (die, DW_AT_external, cu);
6212 if (attr == NULL && die->parent->tag != DW_TAG_namespace
6213 && die->parent->tag != DW_TAG_module)
6214 return 0;
6215 /* A variable in a lexical block of some kind does not need a
6216 namespace, even though in C++ such variables may be external
6217 and have a mangled name. */
6218 if (die->parent->tag == DW_TAG_lexical_block
6219 || die->parent->tag == DW_TAG_try_block
6220 || die->parent->tag == DW_TAG_catch_block
6221 || die->parent->tag == DW_TAG_subprogram)
6222 return 0;
6223 return 1;
6224
6225 default:
6226 return 0;
6227 }
6228 }
6229
6230 /* Retrieve the last character from a mem_file. */
6231
6232 static void
6233 do_ui_file_peek_last (void *object, const char *buffer, long length)
6234 {
6235 char *last_char_p = (char *) object;
6236
6237 if (length > 0)
6238 *last_char_p = buffer[length - 1];
6239 }
6240
6241 /* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
6242 compute the physname for the object, which include a method's:
6243 - formal parameters (C++/Java),
6244 - receiver type (Go),
6245 - return type (Java).
6246
6247 The term "physname" is a bit confusing.
6248 For C++, for example, it is the demangled name.
6249 For Go, for example, it's the mangled name.
6250
6251 For Ada, return the DIE's linkage name rather than the fully qualified
6252 name. PHYSNAME is ignored..
6253
6254 The result is allocated on the objfile_obstack and canonicalized. */
6255
6256 static const char *
6257 dwarf2_compute_name (char *name, struct die_info *die, struct dwarf2_cu *cu,
6258 int physname)
6259 {
6260 struct objfile *objfile = cu->objfile;
6261
6262 if (name == NULL)
6263 name = dwarf2_name (die, cu);
6264
6265 /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
6266 compute it by typename_concat inside GDB. */
6267 if (cu->language == language_ada
6268 || (cu->language == language_fortran && physname))
6269 {
6270 /* For Ada unit, we prefer the linkage name over the name, as
6271 the former contains the exported name, which the user expects
6272 to be able to reference. Ideally, we want the user to be able
6273 to reference this entity using either natural or linkage name,
6274 but we haven't started looking at this enhancement yet. */
6275 struct attribute *attr;
6276
6277 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
6278 if (attr == NULL)
6279 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
6280 if (attr && DW_STRING (attr))
6281 return DW_STRING (attr);
6282 }
6283
6284 /* These are the only languages we know how to qualify names in. */
6285 if (name != NULL
6286 && (cu->language == language_cplus || cu->language == language_java
6287 || cu->language == language_fortran))
6288 {
6289 if (die_needs_namespace (die, cu))
6290 {
6291 long length;
6292 const char *prefix;
6293 struct ui_file *buf;
6294
6295 prefix = determine_prefix (die, cu);
6296 buf = mem_fileopen ();
6297 if (*prefix != '\0')
6298 {
6299 char *prefixed_name = typename_concat (NULL, prefix, name,
6300 physname, cu);
6301
6302 fputs_unfiltered (prefixed_name, buf);
6303 xfree (prefixed_name);
6304 }
6305 else
6306 fputs_unfiltered (name, buf);
6307
6308 /* Template parameters may be specified in the DIE's DW_AT_name, or
6309 as children with DW_TAG_template_type_param or
6310 DW_TAG_value_type_param. If the latter, add them to the name
6311 here. If the name already has template parameters, then
6312 skip this step; some versions of GCC emit both, and
6313 it is more efficient to use the pre-computed name.
6314
6315 Something to keep in mind about this process: it is very
6316 unlikely, or in some cases downright impossible, to produce
6317 something that will match the mangled name of a function.
6318 If the definition of the function has the same debug info,
6319 we should be able to match up with it anyway. But fallbacks
6320 using the minimal symbol, for instance to find a method
6321 implemented in a stripped copy of libstdc++, will not work.
6322 If we do not have debug info for the definition, we will have to
6323 match them up some other way.
6324
6325 When we do name matching there is a related problem with function
6326 templates; two instantiated function templates are allowed to
6327 differ only by their return types, which we do not add here. */
6328
6329 if (cu->language == language_cplus && strchr (name, '<') == NULL)
6330 {
6331 struct attribute *attr;
6332 struct die_info *child;
6333 int first = 1;
6334
6335 die->building_fullname = 1;
6336
6337 for (child = die->child; child != NULL; child = child->sibling)
6338 {
6339 struct type *type;
6340 LONGEST value;
6341 gdb_byte *bytes;
6342 struct dwarf2_locexpr_baton *baton;
6343 struct value *v;
6344
6345 if (child->tag != DW_TAG_template_type_param
6346 && child->tag != DW_TAG_template_value_param)
6347 continue;
6348
6349 if (first)
6350 {
6351 fputs_unfiltered ("<", buf);
6352 first = 0;
6353 }
6354 else
6355 fputs_unfiltered (", ", buf);
6356
6357 attr = dwarf2_attr (child, DW_AT_type, cu);
6358 if (attr == NULL)
6359 {
6360 complaint (&symfile_complaints,
6361 _("template parameter missing DW_AT_type"));
6362 fputs_unfiltered ("UNKNOWN_TYPE", buf);
6363 continue;
6364 }
6365 type = die_type (child, cu);
6366
6367 if (child->tag == DW_TAG_template_type_param)
6368 {
6369 c_print_type (type, "", buf, -1, 0);
6370 continue;
6371 }
6372
6373 attr = dwarf2_attr (child, DW_AT_const_value, cu);
6374 if (attr == NULL)
6375 {
6376 complaint (&symfile_complaints,
6377 _("template parameter missing "
6378 "DW_AT_const_value"));
6379 fputs_unfiltered ("UNKNOWN_VALUE", buf);
6380 continue;
6381 }
6382
6383 dwarf2_const_value_attr (attr, type, name,
6384 &cu->comp_unit_obstack, cu,
6385 &value, &bytes, &baton);
6386
6387 if (TYPE_NOSIGN (type))
6388 /* GDB prints characters as NUMBER 'CHAR'. If that's
6389 changed, this can use value_print instead. */
6390 c_printchar (value, type, buf);
6391 else
6392 {
6393 struct value_print_options opts;
6394
6395 if (baton != NULL)
6396 v = dwarf2_evaluate_loc_desc (type, NULL,
6397 baton->data,
6398 baton->size,
6399 baton->per_cu);
6400 else if (bytes != NULL)
6401 {
6402 v = allocate_value (type);
6403 memcpy (value_contents_writeable (v), bytes,
6404 TYPE_LENGTH (type));
6405 }
6406 else
6407 v = value_from_longest (type, value);
6408
6409 /* Specify decimal so that we do not depend on
6410 the radix. */
6411 get_formatted_print_options (&opts, 'd');
6412 opts.raw = 1;
6413 value_print (v, buf, &opts);
6414 release_value (v);
6415 value_free (v);
6416 }
6417 }
6418
6419 die->building_fullname = 0;
6420
6421 if (!first)
6422 {
6423 /* Close the argument list, with a space if necessary
6424 (nested templates). */
6425 char last_char = '\0';
6426 ui_file_put (buf, do_ui_file_peek_last, &last_char);
6427 if (last_char == '>')
6428 fputs_unfiltered (" >", buf);
6429 else
6430 fputs_unfiltered (">", buf);
6431 }
6432 }
6433
6434 /* For Java and C++ methods, append formal parameter type
6435 information, if PHYSNAME. */
6436
6437 if (physname && die->tag == DW_TAG_subprogram
6438 && (cu->language == language_cplus
6439 || cu->language == language_java))
6440 {
6441 struct type *type = read_type_die (die, cu);
6442
6443 c_type_print_args (type, buf, 1, cu->language);
6444
6445 if (cu->language == language_java)
6446 {
6447 /* For java, we must append the return type to method
6448 names. */
6449 if (die->tag == DW_TAG_subprogram)
6450 java_print_type (TYPE_TARGET_TYPE (type), "", buf,
6451 0, 0);
6452 }
6453 else if (cu->language == language_cplus)
6454 {
6455 /* Assume that an artificial first parameter is
6456 "this", but do not crash if it is not. RealView
6457 marks unnamed (and thus unused) parameters as
6458 artificial; there is no way to differentiate
6459 the two cases. */
6460 if (TYPE_NFIELDS (type) > 0
6461 && TYPE_FIELD_ARTIFICIAL (type, 0)
6462 && TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_PTR
6463 && TYPE_CONST (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type,
6464 0))))
6465 fputs_unfiltered (" const", buf);
6466 }
6467 }
6468
6469 name = ui_file_obsavestring (buf, &objfile->objfile_obstack,
6470 &length);
6471 ui_file_delete (buf);
6472
6473 if (cu->language == language_cplus)
6474 {
6475 char *cname
6476 = dwarf2_canonicalize_name (name, cu,
6477 &objfile->objfile_obstack);
6478
6479 if (cname != NULL)
6480 name = cname;
6481 }
6482 }
6483 }
6484
6485 return name;
6486 }
6487
6488 /* Return the fully qualified name of DIE, based on its DW_AT_name.
6489 If scope qualifiers are appropriate they will be added. The result
6490 will be allocated on the objfile_obstack, or NULL if the DIE does
6491 not have a name. NAME may either be from a previous call to
6492 dwarf2_name or NULL.
6493
6494 The output string will be canonicalized (if C++/Java). */
6495
6496 static const char *
6497 dwarf2_full_name (char *name, struct die_info *die, struct dwarf2_cu *cu)
6498 {
6499 return dwarf2_compute_name (name, die, cu, 0);
6500 }
6501
6502 /* Construct a physname for the given DIE in CU. NAME may either be
6503 from a previous call to dwarf2_name or NULL. The result will be
6504 allocated on the objfile_objstack or NULL if the DIE does not have a
6505 name.
6506
6507 The output string will be canonicalized (if C++/Java). */
6508
6509 static const char *
6510 dwarf2_physname (char *name, struct die_info *die, struct dwarf2_cu *cu)
6511 {
6512 struct objfile *objfile = cu->objfile;
6513 struct attribute *attr;
6514 const char *retval, *mangled = NULL, *canon = NULL;
6515 struct cleanup *back_to;
6516 int need_copy = 1;
6517
6518 /* In this case dwarf2_compute_name is just a shortcut not building anything
6519 on its own. */
6520 if (!die_needs_namespace (die, cu))
6521 return dwarf2_compute_name (name, die, cu, 1);
6522
6523 back_to = make_cleanup (null_cleanup, NULL);
6524
6525 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
6526 if (!attr)
6527 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
6528
6529 /* DW_AT_linkage_name is missing in some cases - depend on what GDB
6530 has computed. */
6531 if (attr && DW_STRING (attr))
6532 {
6533 char *demangled;
6534
6535 mangled = DW_STRING (attr);
6536
6537 /* Use DMGL_RET_DROP for C++ template functions to suppress their return
6538 type. It is easier for GDB users to search for such functions as
6539 `name(params)' than `long name(params)'. In such case the minimal
6540 symbol names do not match the full symbol names but for template
6541 functions there is never a need to look up their definition from their
6542 declaration so the only disadvantage remains the minimal symbol
6543 variant `long name(params)' does not have the proper inferior type.
6544 */
6545
6546 if (cu->language == language_go)
6547 {
6548 /* This is a lie, but we already lie to the caller new_symbol_full.
6549 new_symbol_full assumes we return the mangled name.
6550 This just undoes that lie until things are cleaned up. */
6551 demangled = NULL;
6552 }
6553 else
6554 {
6555 demangled = cplus_demangle (mangled,
6556 (DMGL_PARAMS | DMGL_ANSI
6557 | (cu->language == language_java
6558 ? DMGL_JAVA | DMGL_RET_POSTFIX
6559 : DMGL_RET_DROP)));
6560 }
6561 if (demangled)
6562 {
6563 make_cleanup (xfree, demangled);
6564 canon = demangled;
6565 }
6566 else
6567 {
6568 canon = mangled;
6569 need_copy = 0;
6570 }
6571 }
6572
6573 if (canon == NULL || check_physname)
6574 {
6575 const char *physname = dwarf2_compute_name (name, die, cu, 1);
6576
6577 if (canon != NULL && strcmp (physname, canon) != 0)
6578 {
6579 /* It may not mean a bug in GDB. The compiler could also
6580 compute DW_AT_linkage_name incorrectly. But in such case
6581 GDB would need to be bug-to-bug compatible. */
6582
6583 complaint (&symfile_complaints,
6584 _("Computed physname <%s> does not match demangled <%s> "
6585 "(from linkage <%s>) - DIE at 0x%x [in module %s]"),
6586 physname, canon, mangled, die->offset.sect_off, objfile->name);
6587
6588 /* Prefer DW_AT_linkage_name (in the CANON form) - when it
6589 is available here - over computed PHYSNAME. It is safer
6590 against both buggy GDB and buggy compilers. */
6591
6592 retval = canon;
6593 }
6594 else
6595 {
6596 retval = physname;
6597 need_copy = 0;
6598 }
6599 }
6600 else
6601 retval = canon;
6602
6603 if (need_copy)
6604 retval = obsavestring (retval, strlen (retval),
6605 &objfile->objfile_obstack);
6606
6607 do_cleanups (back_to);
6608 return retval;
6609 }
6610
6611 /* Read the import statement specified by the given die and record it. */
6612
6613 static void
6614 read_import_statement (struct die_info *die, struct dwarf2_cu *cu)
6615 {
6616 struct objfile *objfile = cu->objfile;
6617 struct attribute *import_attr;
6618 struct die_info *imported_die, *child_die;
6619 struct dwarf2_cu *imported_cu;
6620 const char *imported_name;
6621 const char *imported_name_prefix;
6622 const char *canonical_name;
6623 const char *import_alias;
6624 const char *imported_declaration = NULL;
6625 const char *import_prefix;
6626 VEC (const_char_ptr) *excludes = NULL;
6627 struct cleanup *cleanups;
6628
6629 char *temp;
6630
6631 import_attr = dwarf2_attr (die, DW_AT_import, cu);
6632 if (import_attr == NULL)
6633 {
6634 complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
6635 dwarf_tag_name (die->tag));
6636 return;
6637 }
6638
6639 imported_cu = cu;
6640 imported_die = follow_die_ref_or_sig (die, import_attr, &imported_cu);
6641 imported_name = dwarf2_name (imported_die, imported_cu);
6642 if (imported_name == NULL)
6643 {
6644 /* GCC bug: https://bugzilla.redhat.com/show_bug.cgi?id=506524
6645
6646 The import in the following code:
6647 namespace A
6648 {
6649 typedef int B;
6650 }
6651
6652 int main ()
6653 {
6654 using A::B;
6655 B b;
6656 return b;
6657 }
6658
6659 ...
6660 <2><51>: Abbrev Number: 3 (DW_TAG_imported_declaration)
6661 <52> DW_AT_decl_file : 1
6662 <53> DW_AT_decl_line : 6
6663 <54> DW_AT_import : <0x75>
6664 <2><58>: Abbrev Number: 4 (DW_TAG_typedef)
6665 <59> DW_AT_name : B
6666 <5b> DW_AT_decl_file : 1
6667 <5c> DW_AT_decl_line : 2
6668 <5d> DW_AT_type : <0x6e>
6669 ...
6670 <1><75>: Abbrev Number: 7 (DW_TAG_base_type)
6671 <76> DW_AT_byte_size : 4
6672 <77> DW_AT_encoding : 5 (signed)
6673
6674 imports the wrong die ( 0x75 instead of 0x58 ).
6675 This case will be ignored until the gcc bug is fixed. */
6676 return;
6677 }
6678
6679 /* Figure out the local name after import. */
6680 import_alias = dwarf2_name (die, cu);
6681
6682 /* Figure out where the statement is being imported to. */
6683 import_prefix = determine_prefix (die, cu);
6684
6685 /* Figure out what the scope of the imported die is and prepend it
6686 to the name of the imported die. */
6687 imported_name_prefix = determine_prefix (imported_die, imported_cu);
6688
6689 if (imported_die->tag != DW_TAG_namespace
6690 && imported_die->tag != DW_TAG_module)
6691 {
6692 imported_declaration = imported_name;
6693 canonical_name = imported_name_prefix;
6694 }
6695 else if (strlen (imported_name_prefix) > 0)
6696 {
6697 temp = alloca (strlen (imported_name_prefix)
6698 + 2 + strlen (imported_name) + 1);
6699 strcpy (temp, imported_name_prefix);
6700 strcat (temp, "::");
6701 strcat (temp, imported_name);
6702 canonical_name = temp;
6703 }
6704 else
6705 canonical_name = imported_name;
6706
6707 cleanups = make_cleanup (VEC_cleanup (const_char_ptr), &excludes);
6708
6709 if (die->tag == DW_TAG_imported_module && cu->language == language_fortran)
6710 for (child_die = die->child; child_die && child_die->tag;
6711 child_die = sibling_die (child_die))
6712 {
6713 /* DWARF-4: A Fortran use statement with a “rename list” may be
6714 represented by an imported module entry with an import attribute
6715 referring to the module and owned entries corresponding to those
6716 entities that are renamed as part of being imported. */
6717
6718 if (child_die->tag != DW_TAG_imported_declaration)
6719 {
6720 complaint (&symfile_complaints,
6721 _("child DW_TAG_imported_declaration expected "
6722 "- DIE at 0x%x [in module %s]"),
6723 child_die->offset.sect_off, objfile->name);
6724 continue;
6725 }
6726
6727 import_attr = dwarf2_attr (child_die, DW_AT_import, cu);
6728 if (import_attr == NULL)
6729 {
6730 complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
6731 dwarf_tag_name (child_die->tag));
6732 continue;
6733 }
6734
6735 imported_cu = cu;
6736 imported_die = follow_die_ref_or_sig (child_die, import_attr,
6737 &imported_cu);
6738 imported_name = dwarf2_name (imported_die, imported_cu);
6739 if (imported_name == NULL)
6740 {
6741 complaint (&symfile_complaints,
6742 _("child DW_TAG_imported_declaration has unknown "
6743 "imported name - DIE at 0x%x [in module %s]"),
6744 child_die->offset.sect_off, objfile->name);
6745 continue;
6746 }
6747
6748 VEC_safe_push (const_char_ptr, excludes, imported_name);
6749
6750 process_die (child_die, cu);
6751 }
6752
6753 cp_add_using_directive (import_prefix,
6754 canonical_name,
6755 import_alias,
6756 imported_declaration,
6757 excludes,
6758 &objfile->objfile_obstack);
6759
6760 do_cleanups (cleanups);
6761 }
6762
6763 /* Cleanup function for read_file_scope. */
6764
6765 static void
6766 free_cu_line_header (void *arg)
6767 {
6768 struct dwarf2_cu *cu = arg;
6769
6770 free_line_header (cu->line_header);
6771 cu->line_header = NULL;
6772 }
6773
6774 static void
6775 find_file_and_directory (struct die_info *die, struct dwarf2_cu *cu,
6776 char **name, char **comp_dir)
6777 {
6778 struct attribute *attr;
6779
6780 *name = NULL;
6781 *comp_dir = NULL;
6782
6783 /* Find the filename. Do not use dwarf2_name here, since the filename
6784 is not a source language identifier. */
6785 attr = dwarf2_attr (die, DW_AT_name, cu);
6786 if (attr)
6787 {
6788 *name = DW_STRING (attr);
6789 }
6790
6791 attr = dwarf2_attr (die, DW_AT_comp_dir, cu);
6792 if (attr)
6793 *comp_dir = DW_STRING (attr);
6794 else if (*name != NULL && IS_ABSOLUTE_PATH (*name))
6795 {
6796 *comp_dir = ldirname (*name);
6797 if (*comp_dir != NULL)
6798 make_cleanup (xfree, *comp_dir);
6799 }
6800 if (*comp_dir != NULL)
6801 {
6802 /* Irix 6.2 native cc prepends <machine>.: to the compilation
6803 directory, get rid of it. */
6804 char *cp = strchr (*comp_dir, ':');
6805
6806 if (cp && cp != *comp_dir && cp[-1] == '.' && cp[1] == '/')
6807 *comp_dir = cp + 1;
6808 }
6809
6810 if (*name == NULL)
6811 *name = "<unknown>";
6812 }
6813
6814 /* Handle DW_AT_stmt_list for a compilation unit or type unit.
6815 DIE is the DW_TAG_compile_unit or DW_TAG_type_unit die for CU.
6816 COMP_DIR is the compilation directory.
6817 WANT_LINE_INFO is non-zero if the pc/line-number mapping is needed. */
6818
6819 static void
6820 handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
6821 const char *comp_dir, int want_line_info)
6822 {
6823 struct attribute *attr;
6824
6825 attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
6826 if (attr)
6827 {
6828 unsigned int line_offset = DW_UNSND (attr);
6829 struct line_header *line_header
6830 = dwarf_decode_line_header (line_offset, cu);
6831
6832 if (line_header)
6833 {
6834 cu->line_header = line_header;
6835 make_cleanup (free_cu_line_header, cu);
6836 dwarf_decode_lines (line_header, comp_dir, cu, NULL, want_line_info);
6837 }
6838 }
6839 }
6840
6841 /* Process DW_TAG_compile_unit or DW_TAG_partial_unit. */
6842
6843 static void
6844 read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
6845 {
6846 struct objfile *objfile = dwarf2_per_objfile->objfile;
6847 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
6848 CORE_ADDR lowpc = ((CORE_ADDR) -1);
6849 CORE_ADDR highpc = ((CORE_ADDR) 0);
6850 struct attribute *attr;
6851 char *name = NULL;
6852 char *comp_dir = NULL;
6853 struct die_info *child_die;
6854 bfd *abfd = objfile->obfd;
6855 CORE_ADDR baseaddr;
6856
6857 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6858
6859 get_scope_pc_bounds (die, &lowpc, &highpc, cu);
6860
6861 /* If we didn't find a lowpc, set it to highpc to avoid complaints
6862 from finish_block. */
6863 if (lowpc == ((CORE_ADDR) -1))
6864 lowpc = highpc;
6865 lowpc += baseaddr;
6866 highpc += baseaddr;
6867
6868 find_file_and_directory (die, cu, &name, &comp_dir);
6869
6870 prepare_one_comp_unit (cu, die, cu->language);
6871
6872 /* The XLCL doesn't generate DW_LANG_OpenCL because this attribute is not
6873 standardised yet. As a workaround for the language detection we fall
6874 back to the DW_AT_producer string. */
6875 if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL") != NULL)
6876 cu->language = language_opencl;
6877
6878 /* Similar hack for Go. */
6879 if (cu->producer && strstr (cu->producer, "GNU Go ") != NULL)
6880 set_cu_language (DW_LANG_Go, cu);
6881
6882 /* We assume that we're processing GCC output. */
6883 processing_gcc_compilation = 2;
6884
6885 processing_has_namespace_info = 0;
6886
6887 start_symtab (name, comp_dir, lowpc);
6888 record_debugformat ("DWARF 2");
6889 record_producer (cu->producer);
6890
6891 /* Decode line number information if present. We do this before
6892 processing child DIEs, so that the line header table is available
6893 for DW_AT_decl_file. */
6894 handle_DW_AT_stmt_list (die, cu, comp_dir, 1);
6895
6896 /* Process all dies in compilation unit. */
6897 if (die->child != NULL)
6898 {
6899 child_die = die->child;
6900 while (child_die && child_die->tag)
6901 {
6902 process_die (child_die, cu);
6903 child_die = sibling_die (child_die);
6904 }
6905 }
6906
6907 /* Decode macro information, if present. Dwarf 2 macro information
6908 refers to information in the line number info statement program
6909 header, so we can only read it if we've read the header
6910 successfully. */
6911 attr = dwarf2_attr (die, DW_AT_GNU_macros, cu);
6912 if (attr && cu->line_header)
6913 {
6914 if (dwarf2_attr (die, DW_AT_macro_info, cu))
6915 complaint (&symfile_complaints,
6916 _("CU refers to both DW_AT_GNU_macros and DW_AT_macro_info"));
6917
6918 dwarf_decode_macros (cu, DW_UNSND (attr), comp_dir, 1);
6919 }
6920 else
6921 {
6922 attr = dwarf2_attr (die, DW_AT_macro_info, cu);
6923 if (attr && cu->line_header)
6924 {
6925 unsigned int macro_offset = DW_UNSND (attr);
6926
6927 dwarf_decode_macros (cu, macro_offset, comp_dir, 0);
6928 }
6929 }
6930
6931 do_cleanups (back_to);
6932 }
6933
6934 /* Process DW_TAG_type_unit.
6935 For TUs we want to skip the first top level sibling if it's not the
6936 actual type being defined by this TU. In this case the first top
6937 level sibling is there to provide context only. */
6938
6939 static void
6940 read_type_unit_scope (struct die_info *die, struct dwarf2_cu *cu)
6941 {
6942 struct objfile *objfile = cu->objfile;
6943 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
6944 CORE_ADDR lowpc;
6945 struct attribute *attr;
6946 char *name = NULL;
6947 char *comp_dir = NULL;
6948 struct die_info *child_die;
6949 bfd *abfd = objfile->obfd;
6950
6951 /* start_symtab needs a low pc, but we don't really have one.
6952 Do what read_file_scope would do in the absence of such info. */
6953 lowpc = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
6954
6955 /* Find the filename. Do not use dwarf2_name here, since the filename
6956 is not a source language identifier. */
6957 attr = dwarf2_attr (die, DW_AT_name, cu);
6958 if (attr)
6959 name = DW_STRING (attr);
6960
6961 attr = dwarf2_attr (die, DW_AT_comp_dir, cu);
6962 if (attr)
6963 comp_dir = DW_STRING (attr);
6964 else if (name != NULL && IS_ABSOLUTE_PATH (name))
6965 {
6966 comp_dir = ldirname (name);
6967 if (comp_dir != NULL)
6968 make_cleanup (xfree, comp_dir);
6969 }
6970
6971 if (name == NULL)
6972 name = "<unknown>";
6973
6974 prepare_one_comp_unit (cu, die, language_minimal);
6975
6976 /* We assume that we're processing GCC output. */
6977 processing_gcc_compilation = 2;
6978
6979 processing_has_namespace_info = 0;
6980
6981 start_symtab (name, comp_dir, lowpc);
6982 record_debugformat ("DWARF 2");
6983 record_producer (cu->producer);
6984
6985 /* Decode line number information if present. We do this before
6986 processing child DIEs, so that the line header table is available
6987 for DW_AT_decl_file.
6988 We don't need the pc/line-number mapping for type units. */
6989 handle_DW_AT_stmt_list (die, cu, comp_dir, 0);
6990
6991 /* Process the dies in the type unit. */
6992 if (die->child == NULL)
6993 {
6994 dump_die_for_error (die);
6995 error (_("Dwarf Error: Missing children for type unit [in module %s]"),
6996 bfd_get_filename (abfd));
6997 }
6998
6999 child_die = die->child;
7000
7001 while (child_die && child_die->tag)
7002 {
7003 process_die (child_die, cu);
7004
7005 child_die = sibling_die (child_die);
7006 }
7007
7008 do_cleanups (back_to);
7009 }
7010 \f
7011 /* DWO files. */
7012
7013 static hashval_t
7014 hash_dwo_file (const void *item)
7015 {
7016 const struct dwo_file *dwo_file = item;
7017
7018 return htab_hash_string (dwo_file->dwo_name);
7019 }
7020
7021 static int
7022 eq_dwo_file (const void *item_lhs, const void *item_rhs)
7023 {
7024 const struct dwo_file *lhs = item_lhs;
7025 const struct dwo_file *rhs = item_rhs;
7026
7027 return strcmp (lhs->dwo_name, rhs->dwo_name) == 0;
7028 }
7029
7030 /* Allocate a hash table for DWO files. */
7031
7032 static htab_t
7033 allocate_dwo_file_hash_table (void)
7034 {
7035 struct objfile *objfile = dwarf2_per_objfile->objfile;
7036
7037 return htab_create_alloc_ex (41,
7038 hash_dwo_file,
7039 eq_dwo_file,
7040 NULL,
7041 &objfile->objfile_obstack,
7042 hashtab_obstack_allocate,
7043 dummy_obstack_deallocate);
7044 }
7045
7046 static hashval_t
7047 hash_dwo_unit (const void *item)
7048 {
7049 const struct dwo_unit *dwo_unit = item;
7050
7051 /* This drops the top 32 bits of the id, but is ok for a hash. */
7052 return dwo_unit->signature;
7053 }
7054
7055 static int
7056 eq_dwo_unit (const void *item_lhs, const void *item_rhs)
7057 {
7058 const struct dwo_unit *lhs = item_lhs;
7059 const struct dwo_unit *rhs = item_rhs;
7060
7061 /* The signature is assumed to be unique within the DWO file.
7062 So while object file CU dwo_id's always have the value zero,
7063 that's OK, assuming each object file DWO file has only one CU,
7064 and that's the rule for now. */
7065 return lhs->signature == rhs->signature;
7066 }
7067
7068 /* Allocate a hash table for DWO CUs,TUs.
7069 There is one of these tables for each of CUs,TUs for each DWO file. */
7070
7071 static htab_t
7072 allocate_dwo_unit_table (struct objfile *objfile)
7073 {
7074 /* Start out with a pretty small number.
7075 Generally DWO files contain only one CU and maybe some TUs. */
7076 return htab_create_alloc_ex (3,
7077 hash_dwo_unit,
7078 eq_dwo_unit,
7079 NULL,
7080 &objfile->objfile_obstack,
7081 hashtab_obstack_allocate,
7082 dummy_obstack_deallocate);
7083 }
7084
7085 /* This function is mapped across the sections and remembers the offset and
7086 size of each of the DWO debugging sections we are interested in. */
7087
7088 static void
7089 dwarf2_locate_dwo_sections (bfd *abfd, asection *sectp, void *dwo_file_ptr)
7090 {
7091 struct dwo_file *dwo_file = dwo_file_ptr;
7092 const struct dwo_section_names *names = &dwo_section_names;
7093
7094 if (section_is_p (sectp->name, &names->abbrev_dwo))
7095 {
7096 dwo_file->sections.abbrev.asection = sectp;
7097 dwo_file->sections.abbrev.size = bfd_get_section_size (sectp);
7098 }
7099 else if (section_is_p (sectp->name, &names->info_dwo))
7100 {
7101 dwo_file->sections.info.asection = sectp;
7102 dwo_file->sections.info.size = bfd_get_section_size (sectp);
7103 }
7104 else if (section_is_p (sectp->name, &names->line_dwo))
7105 {
7106 dwo_file->sections.line.asection = sectp;
7107 dwo_file->sections.line.size = bfd_get_section_size (sectp);
7108 }
7109 else if (section_is_p (sectp->name, &names->loc_dwo))
7110 {
7111 dwo_file->sections.loc.asection = sectp;
7112 dwo_file->sections.loc.size = bfd_get_section_size (sectp);
7113 }
7114 else if (section_is_p (sectp->name, &names->macinfo_dwo))
7115 {
7116 dwo_file->sections.macinfo.asection = sectp;
7117 dwo_file->sections.macinfo.size = bfd_get_section_size (sectp);
7118 }
7119 else if (section_is_p (sectp->name, &names->macro_dwo))
7120 {
7121 dwo_file->sections.macro.asection = sectp;
7122 dwo_file->sections.macro.size = bfd_get_section_size (sectp);
7123 }
7124 else if (section_is_p (sectp->name, &names->str_dwo))
7125 {
7126 dwo_file->sections.str.asection = sectp;
7127 dwo_file->sections.str.size = bfd_get_section_size (sectp);
7128 }
7129 else if (section_is_p (sectp->name, &names->str_offsets_dwo))
7130 {
7131 dwo_file->sections.str_offsets.asection = sectp;
7132 dwo_file->sections.str_offsets.size = bfd_get_section_size (sectp);
7133 }
7134 else if (section_is_p (sectp->name, &names->types_dwo))
7135 {
7136 struct dwarf2_section_info type_section;
7137
7138 memset (&type_section, 0, sizeof (type_section));
7139 type_section.asection = sectp;
7140 type_section.size = bfd_get_section_size (sectp);
7141 VEC_safe_push (dwarf2_section_info_def, dwo_file->sections.types,
7142 &type_section);
7143 }
7144 }
7145
7146 /* Structure used to pass data to create_debug_info_hash_table_reader. */
7147
7148 struct create_dwo_info_table_data
7149 {
7150 struct dwo_file *dwo_file;
7151 htab_t cu_htab;
7152 };
7153
7154 /* die_reader_func for create_debug_info_hash_table. */
7155
7156 static void
7157 create_debug_info_hash_table_reader (const struct die_reader_specs *reader,
7158 gdb_byte *info_ptr,
7159 struct die_info *comp_unit_die,
7160 int has_children,
7161 void *datap)
7162 {
7163 struct dwarf2_cu *cu = reader->cu;
7164 struct objfile *objfile = dwarf2_per_objfile->objfile;
7165 sect_offset offset = cu->per_cu->offset;
7166 struct dwarf2_section_info *section = cu->per_cu->info_or_types_section;
7167 struct create_dwo_info_table_data *data = datap;
7168 struct dwo_file *dwo_file = data->dwo_file;
7169 htab_t cu_htab = data->cu_htab;
7170 void **slot;
7171 struct attribute *attr;
7172 struct dwo_unit *dwo_unit;
7173
7174 attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
7175 if (attr == NULL)
7176 {
7177 error (_("Dwarf Error: debug entry at offset 0x%x is missing"
7178 " its dwo_id [in module %s]"),
7179 offset.sect_off, dwo_file->dwo_name);
7180 return;
7181 }
7182
7183 dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
7184 dwo_unit->dwo_file = dwo_file;
7185 dwo_unit->signature = DW_UNSND (attr);
7186 dwo_unit->info_or_types_section = section;
7187 dwo_unit->offset = offset;
7188 dwo_unit->length = cu->per_cu->length;
7189
7190 slot = htab_find_slot (cu_htab, dwo_unit, INSERT);
7191 gdb_assert (slot != NULL);
7192 if (*slot != NULL)
7193 {
7194 const struct dwo_unit *dup_dwo_unit = *slot;
7195
7196 complaint (&symfile_complaints,
7197 _("debug entry at offset 0x%x is duplicate to the entry at"
7198 " offset 0x%x, dwo_id 0x%s [in module %s]"),
7199 offset.sect_off, dup_dwo_unit->offset.sect_off,
7200 phex (dwo_unit->signature, sizeof (dwo_unit->signature)),
7201 dwo_file->dwo_name);
7202 }
7203 else
7204 *slot = dwo_unit;
7205
7206 if (dwarf2_read_debug)
7207 fprintf_unfiltered (gdb_stdlog, " offset 0x%x, dwo_id 0x%s\n",
7208 offset.sect_off,
7209 phex (dwo_unit->signature,
7210 sizeof (dwo_unit->signature)));
7211 }
7212
7213 /* Create a hash table to map DWO IDs to their CU entry in .debug_info.dwo. */
7214
7215 static htab_t
7216 create_debug_info_hash_table (struct dwo_file *dwo_file)
7217 {
7218 struct objfile *objfile = dwarf2_per_objfile->objfile;
7219 struct dwarf2_section_info *section = &dwo_file->sections.info;
7220 bfd *abfd;
7221 htab_t cu_htab;
7222 gdb_byte *info_ptr, *end_ptr;
7223 struct create_dwo_info_table_data create_dwo_info_table_data;
7224
7225 dwarf2_read_section (objfile, section);
7226 info_ptr = section->buffer;
7227
7228 if (info_ptr == NULL)
7229 return NULL;
7230
7231 /* We can't set abfd until now because the section may be empty or
7232 not present, in which case section->asection will be NULL. */
7233 abfd = section->asection->owner;
7234
7235 if (dwarf2_read_debug)
7236 fprintf_unfiltered (gdb_stdlog, "Reading .debug_info.dwo for %s:\n",
7237 bfd_get_filename (abfd));
7238
7239 cu_htab = allocate_dwo_unit_table (objfile);
7240
7241 create_dwo_info_table_data.dwo_file = dwo_file;
7242 create_dwo_info_table_data.cu_htab = cu_htab;
7243
7244 end_ptr = info_ptr + section->size;
7245 while (info_ptr < end_ptr)
7246 {
7247 struct dwarf2_per_cu_data per_cu;
7248
7249 memset (&per_cu, 0, sizeof (per_cu));
7250 per_cu.objfile = objfile;
7251 per_cu.is_debug_types = 0;
7252 per_cu.offset.sect_off = info_ptr - section->buffer;
7253 per_cu.info_or_types_section = section;
7254
7255 init_cutu_and_read_dies_no_follow (&per_cu,
7256 &dwo_file->sections.abbrev,
7257 dwo_file,
7258 create_debug_info_hash_table_reader,
7259 &create_dwo_info_table_data);
7260
7261 info_ptr += per_cu.length;
7262 }
7263
7264 return cu_htab;
7265 }
7266
7267 /* Subroutine of open_dwo_file to simplify it.
7268 Open the file specified by FILE_NAME and hand it off to BFD for
7269 preliminary analysis. Return a newly initialized bfd *, which
7270 includes a canonicalized copy of FILE_NAME.
7271 In case of trouble, return NULL.
7272 NOTE: This function is derived from symfile_bfd_open. */
7273
7274 static bfd *
7275 try_open_dwo_file (const char *file_name)
7276 {
7277 bfd *sym_bfd;
7278 int desc;
7279 char *absolute_name;
7280
7281 desc = openp (debug_file_directory, OPF_TRY_CWD_FIRST, file_name,
7282 O_RDONLY | O_BINARY, &absolute_name);
7283 if (desc < 0)
7284 return NULL;
7285
7286 sym_bfd = bfd_fopen (absolute_name, gnutarget, FOPEN_RB, desc);
7287 if (!sym_bfd)
7288 {
7289 xfree (absolute_name);
7290 return NULL;
7291 }
7292 bfd_set_cacheable (sym_bfd, 1);
7293
7294 if (!bfd_check_format (sym_bfd, bfd_object))
7295 {
7296 bfd_close (sym_bfd); /* This also closes desc. */
7297 xfree (absolute_name);
7298 return NULL;
7299 }
7300
7301 /* bfd_usrdata exists for applications and libbfd must not touch it. */
7302 gdb_assert (bfd_usrdata (sym_bfd) == NULL);
7303
7304 return sym_bfd;
7305 }
7306
7307 /* Try to open DWO file DWO_NAME.
7308 COMP_DIR is the DW_AT_comp_dir attribute.
7309 The result is the bfd handle of the file.
7310 If there is a problem finding or opening the file, return NULL.
7311 Upon success, the canonicalized path of the file is stored in the bfd,
7312 same as symfile_bfd_open. */
7313
7314 static bfd *
7315 open_dwo_file (const char *dwo_name, const char *comp_dir)
7316 {
7317 bfd *abfd;
7318
7319 if (IS_ABSOLUTE_PATH (dwo_name))
7320 return try_open_dwo_file (dwo_name);
7321
7322 /* Before trying the search path, try DWO_NAME in COMP_DIR. */
7323
7324 if (comp_dir != NULL)
7325 {
7326 char *path_to_try = concat (comp_dir, SLASH_STRING, dwo_name, NULL);
7327
7328 /* NOTE: If comp_dir is a relative path, this will also try the
7329 search path, which seems useful. */
7330 abfd = try_open_dwo_file (path_to_try);
7331 xfree (path_to_try);
7332 if (abfd != NULL)
7333 return abfd;
7334 }
7335
7336 /* That didn't work, try debug-file-directory, which, despite its name,
7337 is a list of paths. */
7338
7339 if (*debug_file_directory == '\0')
7340 return NULL;
7341
7342 return try_open_dwo_file (dwo_name);
7343 }
7344
7345 /* Initialize the use of the DWO file specified by DWO_NAME. */
7346
7347 static struct dwo_file *
7348 init_dwo_file (const char *dwo_name, const char *comp_dir)
7349 {
7350 struct objfile *objfile = dwarf2_per_objfile->objfile;
7351 struct dwo_file *dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack,
7352 struct dwo_file);
7353 bfd *abfd;
7354 struct cleanup *cleanups;
7355
7356 if (dwarf2_read_debug)
7357 fprintf_unfiltered (gdb_stdlog, "Reading DWO file %s:\n", dwo_name);
7358
7359 abfd = open_dwo_file (dwo_name, comp_dir);
7360 if (abfd == NULL)
7361 return NULL;
7362 dwo_file->dwo_name = dwo_name;
7363 dwo_file->dwo_bfd = abfd;
7364
7365 cleanups = make_cleanup (free_dwo_file_cleanup, dwo_file);
7366
7367 bfd_map_over_sections (abfd, dwarf2_locate_dwo_sections, dwo_file);
7368
7369 dwo_file->cus = create_debug_info_hash_table (dwo_file);
7370
7371 dwo_file->tus = create_debug_types_hash_table (dwo_file,
7372 dwo_file->sections.types);
7373
7374 discard_cleanups (cleanups);
7375
7376 return dwo_file;
7377 }
7378
7379 /* Lookup DWO file DWO_NAME. */
7380
7381 static struct dwo_file *
7382 lookup_dwo_file (char *dwo_name, const char *comp_dir)
7383 {
7384 struct dwo_file *dwo_file;
7385 struct dwo_file find_entry;
7386 void **slot;
7387
7388 if (dwarf2_per_objfile->dwo_files == NULL)
7389 dwarf2_per_objfile->dwo_files = allocate_dwo_file_hash_table ();
7390
7391 /* Have we already seen this DWO file? */
7392 find_entry.dwo_name = dwo_name;
7393 slot = htab_find_slot (dwarf2_per_objfile->dwo_files, &find_entry, INSERT);
7394
7395 /* If not, read it in and build a table of the DWOs it contains. */
7396 if (*slot == NULL)
7397 *slot = init_dwo_file (dwo_name, comp_dir);
7398
7399 /* NOTE: This will be NULL if unable to open the file. */
7400 dwo_file = *slot;
7401
7402 return dwo_file;
7403 }
7404
7405 /* Lookup the DWO CU referenced from THIS_CU in DWO file DWO_NAME.
7406 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
7407 SIGNATURE is the "dwo_id" of the CU (for consistency we use the same
7408 nomenclature as TUs).
7409 The result is a pointer to the dwo_unit object or NULL if we didn't find it
7410 (dwo_id mismatch or couldn't find the DWO file). */
7411
7412 static struct dwo_unit *
7413 lookup_dwo_comp_unit (struct dwarf2_per_cu_data *this_cu,
7414 char *dwo_name, const char *comp_dir,
7415 ULONGEST signature)
7416 {
7417 struct objfile *objfile = dwarf2_per_objfile->objfile;
7418 struct dwo_file *dwo_file;
7419
7420 dwo_file = lookup_dwo_file (dwo_name, comp_dir);
7421 if (dwo_file == NULL)
7422 return NULL;
7423
7424 /* Look up the DWO using its signature(dwo_id). */
7425
7426 if (dwo_file->cus != NULL)
7427 {
7428 struct dwo_unit find_dwo_cu, *dwo_cu;
7429
7430 find_dwo_cu.signature = signature;
7431 dwo_cu = htab_find (dwo_file->cus, &find_dwo_cu);
7432
7433 if (dwo_cu != NULL)
7434 return dwo_cu;
7435 }
7436
7437 /* We didn't find it. This must mean a dwo_id mismatch. */
7438
7439 complaint (&symfile_complaints,
7440 _("Could not find DWO CU referenced by CU at offset 0x%x"
7441 " [in module %s]"),
7442 this_cu->offset.sect_off, objfile->name);
7443 return NULL;
7444 }
7445
7446 /* Lookup the DWO TU referenced from THIS_TU in DWO file DWO_NAME.
7447 If non-NULL, comp_dir is the DW_AT_comp_dir attribute.
7448 The result is a pointer to the dwo_unit object or NULL if we didn't find it
7449 (dwo_id mismatch or couldn't find the DWO file). */
7450
7451 static struct dwo_unit *
7452 lookup_dwo_type_unit (struct signatured_type *this_tu,
7453 char *dwo_name, const char *comp_dir)
7454 {
7455 struct objfile *objfile = dwarf2_per_objfile->objfile;
7456 struct dwo_file *dwo_file;
7457
7458 dwo_file = lookup_dwo_file (dwo_name, comp_dir);
7459 if (dwo_file == NULL)
7460 return NULL;
7461
7462 /* Look up the DWO using its signature(dwo_id). */
7463
7464 if (dwo_file->tus != NULL)
7465 {
7466 struct dwo_unit find_dwo_tu, *dwo_tu;
7467
7468 find_dwo_tu.signature = this_tu->signature;
7469 dwo_tu = htab_find (dwo_file->tus, &find_dwo_tu);
7470
7471 if (dwo_tu != NULL)
7472 return dwo_tu;
7473 }
7474
7475 /* We didn't find it. This must mean a dwo_id mismatch. */
7476
7477 complaint (&symfile_complaints,
7478 _("Could not find DWO TU referenced by TU at offset 0x%x"
7479 " [in module %s]"),
7480 this_tu->per_cu.offset.sect_off, objfile->name);
7481 return NULL;
7482 }
7483
7484 /* Free all resources associated with DWO_FILE.
7485 Close the DWO file and munmap the sections.
7486 All memory should be on the objfile obstack. */
7487
7488 static void
7489 free_dwo_file (struct dwo_file *dwo_file, struct objfile *objfile)
7490 {
7491 int ix;
7492 struct dwarf2_section_info *section;
7493
7494 gdb_assert (dwo_file->dwo_bfd != objfile->obfd);
7495 bfd_close (dwo_file->dwo_bfd);
7496
7497 munmap_section_buffer (&dwo_file->sections.abbrev);
7498 munmap_section_buffer (&dwo_file->sections.info);
7499 munmap_section_buffer (&dwo_file->sections.line);
7500 munmap_section_buffer (&dwo_file->sections.loc);
7501 munmap_section_buffer (&dwo_file->sections.str);
7502 munmap_section_buffer (&dwo_file->sections.str_offsets);
7503
7504 for (ix = 0;
7505 VEC_iterate (dwarf2_section_info_def, dwo_file->sections.types,
7506 ix, section);
7507 ++ix)
7508 munmap_section_buffer (section);
7509
7510 VEC_free (dwarf2_section_info_def, dwo_file->sections.types);
7511 }
7512
7513 /* Wrapper for free_dwo_file for use in cleanups. */
7514
7515 static void
7516 free_dwo_file_cleanup (void *arg)
7517 {
7518 struct dwo_file *dwo_file = (struct dwo_file *) arg;
7519 struct objfile *objfile = dwarf2_per_objfile->objfile;
7520
7521 free_dwo_file (dwo_file, objfile);
7522 }
7523
7524 /* Traversal function for free_dwo_files. */
7525
7526 static int
7527 free_dwo_file_from_slot (void **slot, void *info)
7528 {
7529 struct dwo_file *dwo_file = (struct dwo_file *) *slot;
7530 struct objfile *objfile = (struct objfile *) info;
7531
7532 free_dwo_file (dwo_file, objfile);
7533
7534 return 1;
7535 }
7536
7537 /* Free all resources associated with DWO_FILES. */
7538
7539 static void
7540 free_dwo_files (htab_t dwo_files, struct objfile *objfile)
7541 {
7542 htab_traverse_noresize (dwo_files, free_dwo_file_from_slot, objfile);
7543 }
7544 \f
7545 /* Read in various DIEs. */
7546
7547 /* qsort helper for inherit_abstract_dies. */
7548
7549 static int
7550 unsigned_int_compar (const void *ap, const void *bp)
7551 {
7552 unsigned int a = *(unsigned int *) ap;
7553 unsigned int b = *(unsigned int *) bp;
7554
7555 return (a > b) - (b > a);
7556 }
7557
7558 /* DW_AT_abstract_origin inherits whole DIEs (not just their attributes).
7559 Inherit only the children of the DW_AT_abstract_origin DIE not being
7560 already referenced by DW_AT_abstract_origin from the children of the
7561 current DIE. */
7562
7563 static void
7564 inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu)
7565 {
7566 struct die_info *child_die;
7567 unsigned die_children_count;
7568 /* CU offsets which were referenced by children of the current DIE. */
7569 sect_offset *offsets;
7570 sect_offset *offsets_end, *offsetp;
7571 /* Parent of DIE - referenced by DW_AT_abstract_origin. */
7572 struct die_info *origin_die;
7573 /* Iterator of the ORIGIN_DIE children. */
7574 struct die_info *origin_child_die;
7575 struct cleanup *cleanups;
7576 struct attribute *attr;
7577 struct dwarf2_cu *origin_cu;
7578 struct pending **origin_previous_list_in_scope;
7579
7580 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
7581 if (!attr)
7582 return;
7583
7584 /* Note that following die references may follow to a die in a
7585 different cu. */
7586
7587 origin_cu = cu;
7588 origin_die = follow_die_ref (die, attr, &origin_cu);
7589
7590 /* We're inheriting ORIGIN's children into the scope we'd put DIE's
7591 symbols in. */
7592 origin_previous_list_in_scope = origin_cu->list_in_scope;
7593 origin_cu->list_in_scope = cu->list_in_scope;
7594
7595 if (die->tag != origin_die->tag
7596 && !(die->tag == DW_TAG_inlined_subroutine
7597 && origin_die->tag == DW_TAG_subprogram))
7598 complaint (&symfile_complaints,
7599 _("DIE 0x%x and its abstract origin 0x%x have different tags"),
7600 die->offset.sect_off, origin_die->offset.sect_off);
7601
7602 child_die = die->child;
7603 die_children_count = 0;
7604 while (child_die && child_die->tag)
7605 {
7606 child_die = sibling_die (child_die);
7607 die_children_count++;
7608 }
7609 offsets = xmalloc (sizeof (*offsets) * die_children_count);
7610 cleanups = make_cleanup (xfree, offsets);
7611
7612 offsets_end = offsets;
7613 child_die = die->child;
7614 while (child_die && child_die->tag)
7615 {
7616 /* For each CHILD_DIE, find the corresponding child of
7617 ORIGIN_DIE. If there is more than one layer of
7618 DW_AT_abstract_origin, follow them all; there shouldn't be,
7619 but GCC versions at least through 4.4 generate this (GCC PR
7620 40573). */
7621 struct die_info *child_origin_die = child_die;
7622 struct dwarf2_cu *child_origin_cu = cu;
7623
7624 while (1)
7625 {
7626 attr = dwarf2_attr (child_origin_die, DW_AT_abstract_origin,
7627 child_origin_cu);
7628 if (attr == NULL)
7629 break;
7630 child_origin_die = follow_die_ref (child_origin_die, attr,
7631 &child_origin_cu);
7632 }
7633
7634 /* According to DWARF3 3.3.8.2 #3 new entries without their abstract
7635 counterpart may exist. */
7636 if (child_origin_die != child_die)
7637 {
7638 if (child_die->tag != child_origin_die->tag
7639 && !(child_die->tag == DW_TAG_inlined_subroutine
7640 && child_origin_die->tag == DW_TAG_subprogram))
7641 complaint (&symfile_complaints,
7642 _("Child DIE 0x%x and its abstract origin 0x%x have "
7643 "different tags"), child_die->offset.sect_off,
7644 child_origin_die->offset.sect_off);
7645 if (child_origin_die->parent != origin_die)
7646 complaint (&symfile_complaints,
7647 _("Child DIE 0x%x and its abstract origin 0x%x have "
7648 "different parents"), child_die->offset.sect_off,
7649 child_origin_die->offset.sect_off);
7650 else
7651 *offsets_end++ = child_origin_die->offset;
7652 }
7653 child_die = sibling_die (child_die);
7654 }
7655 qsort (offsets, offsets_end - offsets, sizeof (*offsets),
7656 unsigned_int_compar);
7657 for (offsetp = offsets + 1; offsetp < offsets_end; offsetp++)
7658 if (offsetp[-1].sect_off == offsetp->sect_off)
7659 complaint (&symfile_complaints,
7660 _("Multiple children of DIE 0x%x refer "
7661 "to DIE 0x%x as their abstract origin"),
7662 die->offset.sect_off, offsetp->sect_off);
7663
7664 offsetp = offsets;
7665 origin_child_die = origin_die->child;
7666 while (origin_child_die && origin_child_die->tag)
7667 {
7668 /* Is ORIGIN_CHILD_DIE referenced by any of the DIE children? */
7669 while (offsetp < offsets_end
7670 && offsetp->sect_off < origin_child_die->offset.sect_off)
7671 offsetp++;
7672 if (offsetp >= offsets_end
7673 || offsetp->sect_off > origin_child_die->offset.sect_off)
7674 {
7675 /* Found that ORIGIN_CHILD_DIE is really not referenced. */
7676 process_die (origin_child_die, origin_cu);
7677 }
7678 origin_child_die = sibling_die (origin_child_die);
7679 }
7680 origin_cu->list_in_scope = origin_previous_list_in_scope;
7681
7682 do_cleanups (cleanups);
7683 }
7684
7685 static void
7686 read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
7687 {
7688 struct objfile *objfile = cu->objfile;
7689 struct context_stack *new;
7690 CORE_ADDR lowpc;
7691 CORE_ADDR highpc;
7692 struct die_info *child_die;
7693 struct attribute *attr, *call_line, *call_file;
7694 char *name;
7695 CORE_ADDR baseaddr;
7696 struct block *block;
7697 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
7698 VEC (symbolp) *template_args = NULL;
7699 struct template_symbol *templ_func = NULL;
7700
7701 if (inlined_func)
7702 {
7703 /* If we do not have call site information, we can't show the
7704 caller of this inlined function. That's too confusing, so
7705 only use the scope for local variables. */
7706 call_line = dwarf2_attr (die, DW_AT_call_line, cu);
7707 call_file = dwarf2_attr (die, DW_AT_call_file, cu);
7708 if (call_line == NULL || call_file == NULL)
7709 {
7710 read_lexical_block_scope (die, cu);
7711 return;
7712 }
7713 }
7714
7715 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
7716
7717 name = dwarf2_name (die, cu);
7718
7719 /* Ignore functions with missing or empty names. These are actually
7720 illegal according to the DWARF standard. */
7721 if (name == NULL)
7722 {
7723 complaint (&symfile_complaints,
7724 _("missing name for subprogram DIE at %d"),
7725 die->offset.sect_off);
7726 return;
7727 }
7728
7729 /* Ignore functions with missing or invalid low and high pc attributes. */
7730 if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
7731 {
7732 attr = dwarf2_attr (die, DW_AT_external, cu);
7733 if (!attr || !DW_UNSND (attr))
7734 complaint (&symfile_complaints,
7735 _("cannot get low and high bounds "
7736 "for subprogram DIE at %d"),
7737 die->offset.sect_off);
7738 return;
7739 }
7740
7741 lowpc += baseaddr;
7742 highpc += baseaddr;
7743
7744 /* If we have any template arguments, then we must allocate a
7745 different sort of symbol. */
7746 for (child_die = die->child; child_die; child_die = sibling_die (child_die))
7747 {
7748 if (child_die->tag == DW_TAG_template_type_param
7749 || child_die->tag == DW_TAG_template_value_param)
7750 {
7751 templ_func = OBSTACK_ZALLOC (&objfile->objfile_obstack,
7752 struct template_symbol);
7753 templ_func->base.is_cplus_template_function = 1;
7754 break;
7755 }
7756 }
7757
7758 new = push_context (0, lowpc);
7759 new->name = new_symbol_full (die, read_type_die (die, cu), cu,
7760 (struct symbol *) templ_func);
7761
7762 /* If there is a location expression for DW_AT_frame_base, record
7763 it. */
7764 attr = dwarf2_attr (die, DW_AT_frame_base, cu);
7765 if (attr)
7766 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
7767 expression is being recorded directly in the function's symbol
7768 and not in a separate frame-base object. I guess this hack is
7769 to avoid adding some sort of frame-base adjunct/annex to the
7770 function's symbol :-(. The problem with doing this is that it
7771 results in a function symbol with a location expression that
7772 has nothing to do with the location of the function, ouch! The
7773 relationship should be: a function's symbol has-a frame base; a
7774 frame-base has-a location expression. */
7775 dwarf2_symbol_mark_computed (attr, new->name, cu);
7776
7777 cu->list_in_scope = &local_symbols;
7778
7779 if (die->child != NULL)
7780 {
7781 child_die = die->child;
7782 while (child_die && child_die->tag)
7783 {
7784 if (child_die->tag == DW_TAG_template_type_param
7785 || child_die->tag == DW_TAG_template_value_param)
7786 {
7787 struct symbol *arg = new_symbol (child_die, NULL, cu);
7788
7789 if (arg != NULL)
7790 VEC_safe_push (symbolp, template_args, arg);
7791 }
7792 else
7793 process_die (child_die, cu);
7794 child_die = sibling_die (child_die);
7795 }
7796 }
7797
7798 inherit_abstract_dies (die, cu);
7799
7800 /* If we have a DW_AT_specification, we might need to import using
7801 directives from the context of the specification DIE. See the
7802 comment in determine_prefix. */
7803 if (cu->language == language_cplus
7804 && dwarf2_attr (die, DW_AT_specification, cu))
7805 {
7806 struct dwarf2_cu *spec_cu = cu;
7807 struct die_info *spec_die = die_specification (die, &spec_cu);
7808
7809 while (spec_die)
7810 {
7811 child_die = spec_die->child;
7812 while (child_die && child_die->tag)
7813 {
7814 if (child_die->tag == DW_TAG_imported_module)
7815 process_die (child_die, spec_cu);
7816 child_die = sibling_die (child_die);
7817 }
7818
7819 /* In some cases, GCC generates specification DIEs that
7820 themselves contain DW_AT_specification attributes. */
7821 spec_die = die_specification (spec_die, &spec_cu);
7822 }
7823 }
7824
7825 new = pop_context ();
7826 /* Make a block for the local symbols within. */
7827 block = finish_block (new->name, &local_symbols, new->old_blocks,
7828 lowpc, highpc, objfile);
7829
7830 /* For C++, set the block's scope. */
7831 if (cu->language == language_cplus || cu->language == language_fortran)
7832 cp_set_block_scope (new->name, block, &objfile->objfile_obstack,
7833 determine_prefix (die, cu),
7834 processing_has_namespace_info);
7835
7836 /* If we have address ranges, record them. */
7837 dwarf2_record_block_ranges (die, block, baseaddr, cu);
7838
7839 /* Attach template arguments to function. */
7840 if (! VEC_empty (symbolp, template_args))
7841 {
7842 gdb_assert (templ_func != NULL);
7843
7844 templ_func->n_template_arguments = VEC_length (symbolp, template_args);
7845 templ_func->template_arguments
7846 = obstack_alloc (&objfile->objfile_obstack,
7847 (templ_func->n_template_arguments
7848 * sizeof (struct symbol *)));
7849 memcpy (templ_func->template_arguments,
7850 VEC_address (symbolp, template_args),
7851 (templ_func->n_template_arguments * sizeof (struct symbol *)));
7852 VEC_free (symbolp, template_args);
7853 }
7854
7855 /* In C++, we can have functions nested inside functions (e.g., when
7856 a function declares a class that has methods). This means that
7857 when we finish processing a function scope, we may need to go
7858 back to building a containing block's symbol lists. */
7859 local_symbols = new->locals;
7860 param_symbols = new->params;
7861 using_directives = new->using_directives;
7862
7863 /* If we've finished processing a top-level function, subsequent
7864 symbols go in the file symbol list. */
7865 if (outermost_context_p ())
7866 cu->list_in_scope = &file_symbols;
7867 }
7868
7869 /* Process all the DIES contained within a lexical block scope. Start
7870 a new scope, process the dies, and then close the scope. */
7871
7872 static void
7873 read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
7874 {
7875 struct objfile *objfile = cu->objfile;
7876 struct context_stack *new;
7877 CORE_ADDR lowpc, highpc;
7878 struct die_info *child_die;
7879 CORE_ADDR baseaddr;
7880
7881 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
7882
7883 /* Ignore blocks with missing or invalid low and high pc attributes. */
7884 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
7885 as multiple lexical blocks? Handling children in a sane way would
7886 be nasty. Might be easier to properly extend generic blocks to
7887 describe ranges. */
7888 if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
7889 return;
7890 lowpc += baseaddr;
7891 highpc += baseaddr;
7892
7893 push_context (0, lowpc);
7894 if (die->child != NULL)
7895 {
7896 child_die = die->child;
7897 while (child_die && child_die->tag)
7898 {
7899 process_die (child_die, cu);
7900 child_die = sibling_die (child_die);
7901 }
7902 }
7903 new = pop_context ();
7904
7905 if (local_symbols != NULL || using_directives != NULL)
7906 {
7907 struct block *block
7908 = finish_block (0, &local_symbols, new->old_blocks, new->start_addr,
7909 highpc, objfile);
7910
7911 /* Note that recording ranges after traversing children, as we
7912 do here, means that recording a parent's ranges entails
7913 walking across all its children's ranges as they appear in
7914 the address map, which is quadratic behavior.
7915
7916 It would be nicer to record the parent's ranges before
7917 traversing its children, simply overriding whatever you find
7918 there. But since we don't even decide whether to create a
7919 block until after we've traversed its children, that's hard
7920 to do. */
7921 dwarf2_record_block_ranges (die, block, baseaddr, cu);
7922 }
7923 local_symbols = new->locals;
7924 using_directives = new->using_directives;
7925 }
7926
7927 /* Read in DW_TAG_GNU_call_site and insert it to CU->call_site_htab. */
7928
7929 static void
7930 read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
7931 {
7932 struct objfile *objfile = cu->objfile;
7933 struct gdbarch *gdbarch = get_objfile_arch (objfile);
7934 CORE_ADDR pc, baseaddr;
7935 struct attribute *attr;
7936 struct call_site *call_site, call_site_local;
7937 void **slot;
7938 int nparams;
7939 struct die_info *child_die;
7940
7941 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
7942
7943 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
7944 if (!attr)
7945 {
7946 complaint (&symfile_complaints,
7947 _("missing DW_AT_low_pc for DW_TAG_GNU_call_site "
7948 "DIE 0x%x [in module %s]"),
7949 die->offset.sect_off, objfile->name);
7950 return;
7951 }
7952 pc = DW_ADDR (attr) + baseaddr;
7953
7954 if (cu->call_site_htab == NULL)
7955 cu->call_site_htab = htab_create_alloc_ex (16, core_addr_hash, core_addr_eq,
7956 NULL, &objfile->objfile_obstack,
7957 hashtab_obstack_allocate, NULL);
7958 call_site_local.pc = pc;
7959 slot = htab_find_slot (cu->call_site_htab, &call_site_local, INSERT);
7960 if (*slot != NULL)
7961 {
7962 complaint (&symfile_complaints,
7963 _("Duplicate PC %s for DW_TAG_GNU_call_site "
7964 "DIE 0x%x [in module %s]"),
7965 paddress (gdbarch, pc), die->offset.sect_off, objfile->name);
7966 return;
7967 }
7968
7969 /* Count parameters at the caller. */
7970
7971 nparams = 0;
7972 for (child_die = die->child; child_die && child_die->tag;
7973 child_die = sibling_die (child_die))
7974 {
7975 if (child_die->tag != DW_TAG_GNU_call_site_parameter)
7976 {
7977 complaint (&symfile_complaints,
7978 _("Tag %d is not DW_TAG_GNU_call_site_parameter in "
7979 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
7980 child_die->tag, child_die->offset.sect_off, objfile->name);
7981 continue;
7982 }
7983
7984 nparams++;
7985 }
7986
7987 call_site = obstack_alloc (&objfile->objfile_obstack,
7988 (sizeof (*call_site)
7989 + (sizeof (*call_site->parameter)
7990 * (nparams - 1))));
7991 *slot = call_site;
7992 memset (call_site, 0, sizeof (*call_site) - sizeof (*call_site->parameter));
7993 call_site->pc = pc;
7994
7995 if (dwarf2_flag_true_p (die, DW_AT_GNU_tail_call, cu))
7996 {
7997 struct die_info *func_die;
7998
7999 /* Skip also over DW_TAG_inlined_subroutine. */
8000 for (func_die = die->parent;
8001 func_die && func_die->tag != DW_TAG_subprogram
8002 && func_die->tag != DW_TAG_subroutine_type;
8003 func_die = func_die->parent);
8004
8005 /* DW_AT_GNU_all_call_sites is a superset
8006 of DW_AT_GNU_all_tail_call_sites. */
8007 if (func_die
8008 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_call_sites, cu)
8009 && !dwarf2_flag_true_p (func_die, DW_AT_GNU_all_tail_call_sites, cu))
8010 {
8011 /* TYPE_TAIL_CALL_LIST is not interesting in functions where it is
8012 not complete. But keep CALL_SITE for look ups via call_site_htab,
8013 both the initial caller containing the real return address PC and
8014 the final callee containing the current PC of a chain of tail
8015 calls do not need to have the tail call list complete. But any
8016 function candidate for a virtual tail call frame searched via
8017 TYPE_TAIL_CALL_LIST must have the tail call list complete to be
8018 determined unambiguously. */
8019 }
8020 else
8021 {
8022 struct type *func_type = NULL;
8023
8024 if (func_die)
8025 func_type = get_die_type (func_die, cu);
8026 if (func_type != NULL)
8027 {
8028 gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC);
8029
8030 /* Enlist this call site to the function. */
8031 call_site->tail_call_next = TYPE_TAIL_CALL_LIST (func_type);
8032 TYPE_TAIL_CALL_LIST (func_type) = call_site;
8033 }
8034 else
8035 complaint (&symfile_complaints,
8036 _("Cannot find function owning DW_TAG_GNU_call_site "
8037 "DIE 0x%x [in module %s]"),
8038 die->offset.sect_off, objfile->name);
8039 }
8040 }
8041
8042 attr = dwarf2_attr (die, DW_AT_GNU_call_site_target, cu);
8043 if (attr == NULL)
8044 attr = dwarf2_attr (die, DW_AT_abstract_origin, cu);
8045 SET_FIELD_DWARF_BLOCK (call_site->target, NULL);
8046 if (!attr || (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0))
8047 /* Keep NULL DWARF_BLOCK. */;
8048 else if (attr_form_is_block (attr))
8049 {
8050 struct dwarf2_locexpr_baton *dlbaton;
8051
8052 dlbaton = obstack_alloc (&objfile->objfile_obstack, sizeof (*dlbaton));
8053 dlbaton->data = DW_BLOCK (attr)->data;
8054 dlbaton->size = DW_BLOCK (attr)->size;
8055 dlbaton->per_cu = cu->per_cu;
8056
8057 SET_FIELD_DWARF_BLOCK (call_site->target, dlbaton);
8058 }
8059 else if (is_ref_attr (attr))
8060 {
8061 struct dwarf2_cu *target_cu = cu;
8062 struct die_info *target_die;
8063
8064 target_die = follow_die_ref_or_sig (die, attr, &target_cu);
8065 gdb_assert (target_cu->objfile == objfile);
8066 if (die_is_declaration (target_die, target_cu))
8067 {
8068 const char *target_physname;
8069
8070 target_physname = dwarf2_physname (NULL, target_die, target_cu);
8071 if (target_physname == NULL)
8072 complaint (&symfile_complaints,
8073 _("DW_AT_GNU_call_site_target target DIE has invalid "
8074 "physname, for referencing DIE 0x%x [in module %s]"),
8075 die->offset.sect_off, objfile->name);
8076 else
8077 SET_FIELD_PHYSNAME (call_site->target, (char *) target_physname);
8078 }
8079 else
8080 {
8081 CORE_ADDR lowpc;
8082
8083 /* DW_AT_entry_pc should be preferred. */
8084 if (!dwarf2_get_pc_bounds (target_die, &lowpc, NULL, target_cu, NULL))
8085 complaint (&symfile_complaints,
8086 _("DW_AT_GNU_call_site_target target DIE has invalid "
8087 "low pc, for referencing DIE 0x%x [in module %s]"),
8088 die->offset.sect_off, objfile->name);
8089 else
8090 SET_FIELD_PHYSADDR (call_site->target, lowpc + baseaddr);
8091 }
8092 }
8093 else
8094 complaint (&symfile_complaints,
8095 _("DW_TAG_GNU_call_site DW_AT_GNU_call_site_target is neither "
8096 "block nor reference, for DIE 0x%x [in module %s]"),
8097 die->offset.sect_off, objfile->name);
8098
8099 call_site->per_cu = cu->per_cu;
8100
8101 for (child_die = die->child;
8102 child_die && child_die->tag;
8103 child_die = sibling_die (child_die))
8104 {
8105 struct call_site_parameter *parameter;
8106 struct attribute *loc, *origin;
8107
8108 if (child_die->tag != DW_TAG_GNU_call_site_parameter)
8109 {
8110 /* Already printed the complaint above. */
8111 continue;
8112 }
8113
8114 gdb_assert (call_site->parameter_count < nparams);
8115 parameter = &call_site->parameter[call_site->parameter_count];
8116
8117 /* DW_AT_location specifies the register number or DW_AT_abstract_origin
8118 specifies DW_TAG_formal_parameter. Value of the data assumed for the
8119 register is contained in DW_AT_GNU_call_site_value. */
8120
8121 loc = dwarf2_attr (child_die, DW_AT_location, cu);
8122 origin = dwarf2_attr (child_die, DW_AT_abstract_origin, cu);
8123 if (loc == NULL && origin != NULL && is_ref_attr (origin))
8124 {
8125 sect_offset offset;
8126
8127 parameter->kind = CALL_SITE_PARAMETER_PARAM_OFFSET;
8128 offset = dwarf2_get_ref_die_offset (origin);
8129 gdb_assert (offset.sect_off >= cu->header.offset.sect_off);
8130 parameter->u.param_offset.cu_off = (offset.sect_off
8131 - cu->header.offset.sect_off);
8132 }
8133 else if (loc == NULL || origin != NULL || !attr_form_is_block (loc))
8134 {
8135 complaint (&symfile_complaints,
8136 _("No DW_FORM_block* DW_AT_location for "
8137 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
8138 child_die->offset.sect_off, objfile->name);
8139 continue;
8140 }
8141 else
8142 {
8143 parameter->u.dwarf_reg = dwarf_block_to_dwarf_reg
8144 (DW_BLOCK (loc)->data, &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size]);
8145 if (parameter->u.dwarf_reg != -1)
8146 parameter->kind = CALL_SITE_PARAMETER_DWARF_REG;
8147 else if (dwarf_block_to_sp_offset (gdbarch, DW_BLOCK (loc)->data,
8148 &DW_BLOCK (loc)->data[DW_BLOCK (loc)->size],
8149 &parameter->u.fb_offset))
8150 parameter->kind = CALL_SITE_PARAMETER_FB_OFFSET;
8151 else
8152 {
8153 complaint (&symfile_complaints,
8154 _("Only single DW_OP_reg or DW_OP_fbreg is supported "
8155 "for DW_FORM_block* DW_AT_location is supported for "
8156 "DW_TAG_GNU_call_site child DIE 0x%x "
8157 "[in module %s]"),
8158 child_die->offset.sect_off, objfile->name);
8159 continue;
8160 }
8161 }
8162
8163 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_value, cu);
8164 if (!attr_form_is_block (attr))
8165 {
8166 complaint (&symfile_complaints,
8167 _("No DW_FORM_block* DW_AT_GNU_call_site_value for "
8168 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
8169 child_die->offset.sect_off, objfile->name);
8170 continue;
8171 }
8172 parameter->value = DW_BLOCK (attr)->data;
8173 parameter->value_size = DW_BLOCK (attr)->size;
8174
8175 /* Parameters are not pre-cleared by memset above. */
8176 parameter->data_value = NULL;
8177 parameter->data_value_size = 0;
8178 call_site->parameter_count++;
8179
8180 attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_data_value, cu);
8181 if (attr)
8182 {
8183 if (!attr_form_is_block (attr))
8184 complaint (&symfile_complaints,
8185 _("No DW_FORM_block* DW_AT_GNU_call_site_data_value for "
8186 "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"),
8187 child_die->offset.sect_off, objfile->name);
8188 else
8189 {
8190 parameter->data_value = DW_BLOCK (attr)->data;
8191 parameter->data_value_size = DW_BLOCK (attr)->size;
8192 }
8193 }
8194 }
8195 }
8196
8197 /* Get low and high pc attributes from DW_AT_ranges attribute value OFFSET.
8198 Return 1 if the attributes are present and valid, otherwise, return 0.
8199 If RANGES_PST is not NULL we should setup `objfile->psymtabs_addrmap'. */
8200
8201 static int
8202 dwarf2_ranges_read (unsigned offset, CORE_ADDR *low_return,
8203 CORE_ADDR *high_return, struct dwarf2_cu *cu,
8204 struct partial_symtab *ranges_pst)
8205 {
8206 struct objfile *objfile = cu->objfile;
8207 struct comp_unit_head *cu_header = &cu->header;
8208 bfd *obfd = objfile->obfd;
8209 unsigned int addr_size = cu_header->addr_size;
8210 CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
8211 /* Base address selection entry. */
8212 CORE_ADDR base;
8213 int found_base;
8214 unsigned int dummy;
8215 gdb_byte *buffer;
8216 CORE_ADDR marker;
8217 int low_set;
8218 CORE_ADDR low = 0;
8219 CORE_ADDR high = 0;
8220 CORE_ADDR baseaddr;
8221
8222 found_base = cu->base_known;
8223 base = cu->base_address;
8224
8225 dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
8226 if (offset >= dwarf2_per_objfile->ranges.size)
8227 {
8228 complaint (&symfile_complaints,
8229 _("Offset %d out of bounds for DW_AT_ranges attribute"),
8230 offset);
8231 return 0;
8232 }
8233 buffer = dwarf2_per_objfile->ranges.buffer + offset;
8234
8235 /* Read in the largest possible address. */
8236 marker = read_address (obfd, buffer, cu, &dummy);
8237 if ((marker & mask) == mask)
8238 {
8239 /* If we found the largest possible address, then
8240 read the base address. */
8241 base = read_address (obfd, buffer + addr_size, cu, &dummy);
8242 buffer += 2 * addr_size;
8243 offset += 2 * addr_size;
8244 found_base = 1;
8245 }
8246
8247 low_set = 0;
8248
8249 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
8250
8251 while (1)
8252 {
8253 CORE_ADDR range_beginning, range_end;
8254
8255 range_beginning = read_address (obfd, buffer, cu, &dummy);
8256 buffer += addr_size;
8257 range_end = read_address (obfd, buffer, cu, &dummy);
8258 buffer += addr_size;
8259 offset += 2 * addr_size;
8260
8261 /* An end of list marker is a pair of zero addresses. */
8262 if (range_beginning == 0 && range_end == 0)
8263 /* Found the end of list entry. */
8264 break;
8265
8266 /* Each base address selection entry is a pair of 2 values.
8267 The first is the largest possible address, the second is
8268 the base address. Check for a base address here. */
8269 if ((range_beginning & mask) == mask)
8270 {
8271 /* If we found the largest possible address, then
8272 read the base address. */
8273 base = read_address (obfd, buffer + addr_size, cu, &dummy);
8274 found_base = 1;
8275 continue;
8276 }
8277
8278 if (!found_base)
8279 {
8280 /* We have no valid base address for the ranges
8281 data. */
8282 complaint (&symfile_complaints,
8283 _("Invalid .debug_ranges data (no base address)"));
8284 return 0;
8285 }
8286
8287 if (range_beginning > range_end)
8288 {
8289 /* Inverted range entries are invalid. */
8290 complaint (&symfile_complaints,
8291 _("Invalid .debug_ranges data (inverted range)"));
8292 return 0;
8293 }
8294
8295 /* Empty range entries have no effect. */
8296 if (range_beginning == range_end)
8297 continue;
8298
8299 range_beginning += base;
8300 range_end += base;
8301
8302 if (ranges_pst != NULL)
8303 addrmap_set_empty (objfile->psymtabs_addrmap,
8304 range_beginning + baseaddr,
8305 range_end - 1 + baseaddr,
8306 ranges_pst);
8307
8308 /* FIXME: This is recording everything as a low-high
8309 segment of consecutive addresses. We should have a
8310 data structure for discontiguous block ranges
8311 instead. */
8312 if (! low_set)
8313 {
8314 low = range_beginning;
8315 high = range_end;
8316 low_set = 1;
8317 }
8318 else
8319 {
8320 if (range_beginning < low)
8321 low = range_beginning;
8322 if (range_end > high)
8323 high = range_end;
8324 }
8325 }
8326
8327 if (! low_set)
8328 /* If the first entry is an end-of-list marker, the range
8329 describes an empty scope, i.e. no instructions. */
8330 return 0;
8331
8332 if (low_return)
8333 *low_return = low;
8334 if (high_return)
8335 *high_return = high;
8336 return 1;
8337 }
8338
8339 /* Get low and high pc attributes from a die. Return 1 if the attributes
8340 are present and valid, otherwise, return 0. Return -1 if the range is
8341 discontinuous, i.e. derived from DW_AT_ranges information. */
8342
8343 static int
8344 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
8345 CORE_ADDR *highpc, struct dwarf2_cu *cu,
8346 struct partial_symtab *pst)
8347 {
8348 struct attribute *attr;
8349 struct attribute *attr_high;
8350 CORE_ADDR low = 0;
8351 CORE_ADDR high = 0;
8352 int ret = 0;
8353
8354 attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
8355 if (attr_high)
8356 {
8357 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
8358 if (attr)
8359 {
8360 low = DW_ADDR (attr);
8361 if (attr_high->form == DW_FORM_addr
8362 || attr_high->form == DW_FORM_GNU_addr_index)
8363 high = DW_ADDR (attr_high);
8364 else
8365 high = low + DW_UNSND (attr_high);
8366 }
8367 else
8368 /* Found high w/o low attribute. */
8369 return 0;
8370
8371 /* Found consecutive range of addresses. */
8372 ret = 1;
8373 }
8374 else
8375 {
8376 attr = dwarf2_attr (die, DW_AT_ranges, cu);
8377 if (attr != NULL)
8378 {
8379 unsigned int ranges_offset = DW_UNSND (attr) + cu->ranges_base;
8380
8381 /* Value of the DW_AT_ranges attribute is the offset in the
8382 .debug_ranges section. */
8383 if (!dwarf2_ranges_read (ranges_offset, &low, &high, cu, pst))
8384 return 0;
8385 /* Found discontinuous range of addresses. */
8386 ret = -1;
8387 }
8388 }
8389
8390 /* read_partial_die has also the strict LOW < HIGH requirement. */
8391 if (high <= low)
8392 return 0;
8393
8394 /* When using the GNU linker, .gnu.linkonce. sections are used to
8395 eliminate duplicate copies of functions and vtables and such.
8396 The linker will arbitrarily choose one and discard the others.
8397 The AT_*_pc values for such functions refer to local labels in
8398 these sections. If the section from that file was discarded, the
8399 labels are not in the output, so the relocs get a value of 0.
8400 If this is a discarded function, mark the pc bounds as invalid,
8401 so that GDB will ignore it. */
8402 if (low == 0 && !dwarf2_per_objfile->has_section_at_zero)
8403 return 0;
8404
8405 *lowpc = low;
8406 if (highpc)
8407 *highpc = high;
8408 return ret;
8409 }
8410
8411 /* Assuming that DIE represents a subprogram DIE or a lexical block, get
8412 its low and high PC addresses. Do nothing if these addresses could not
8413 be determined. Otherwise, set LOWPC to the low address if it is smaller,
8414 and HIGHPC to the high address if greater than HIGHPC. */
8415
8416 static void
8417 dwarf2_get_subprogram_pc_bounds (struct die_info *die,
8418 CORE_ADDR *lowpc, CORE_ADDR *highpc,
8419 struct dwarf2_cu *cu)
8420 {
8421 CORE_ADDR low, high;
8422 struct die_info *child = die->child;
8423
8424 if (dwarf2_get_pc_bounds (die, &low, &high, cu, NULL))
8425 {
8426 *lowpc = min (*lowpc, low);
8427 *highpc = max (*highpc, high);
8428 }
8429
8430 /* If the language does not allow nested subprograms (either inside
8431 subprograms or lexical blocks), we're done. */
8432 if (cu->language != language_ada)
8433 return;
8434
8435 /* Check all the children of the given DIE. If it contains nested
8436 subprograms, then check their pc bounds. Likewise, we need to
8437 check lexical blocks as well, as they may also contain subprogram
8438 definitions. */
8439 while (child && child->tag)
8440 {
8441 if (child->tag == DW_TAG_subprogram
8442 || child->tag == DW_TAG_lexical_block)
8443 dwarf2_get_subprogram_pc_bounds (child, lowpc, highpc, cu);
8444 child = sibling_die (child);
8445 }
8446 }
8447
8448 /* Get the low and high pc's represented by the scope DIE, and store
8449 them in *LOWPC and *HIGHPC. If the correct values can't be
8450 determined, set *LOWPC to -1 and *HIGHPC to 0. */
8451
8452 static void
8453 get_scope_pc_bounds (struct die_info *die,
8454 CORE_ADDR *lowpc, CORE_ADDR *highpc,
8455 struct dwarf2_cu *cu)
8456 {
8457 CORE_ADDR best_low = (CORE_ADDR) -1;
8458 CORE_ADDR best_high = (CORE_ADDR) 0;
8459 CORE_ADDR current_low, current_high;
8460
8461 if (dwarf2_get_pc_bounds (die, &current_low, &current_high, cu, NULL))
8462 {
8463 best_low = current_low;
8464 best_high = current_high;
8465 }
8466 else
8467 {
8468 struct die_info *child = die->child;
8469
8470 while (child && child->tag)
8471 {
8472 switch (child->tag) {
8473 case DW_TAG_subprogram:
8474 dwarf2_get_subprogram_pc_bounds (child, &best_low, &best_high, cu);
8475 break;
8476 case DW_TAG_namespace:
8477 case DW_TAG_module:
8478 /* FIXME: carlton/2004-01-16: Should we do this for
8479 DW_TAG_class_type/DW_TAG_structure_type, too? I think
8480 that current GCC's always emit the DIEs corresponding
8481 to definitions of methods of classes as children of a
8482 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to
8483 the DIEs giving the declarations, which could be
8484 anywhere). But I don't see any reason why the
8485 standards says that they have to be there. */
8486 get_scope_pc_bounds (child, &current_low, &current_high, cu);
8487
8488 if (current_low != ((CORE_ADDR) -1))
8489 {
8490 best_low = min (best_low, current_low);
8491 best_high = max (best_high, current_high);
8492 }
8493 break;
8494 default:
8495 /* Ignore. */
8496 break;
8497 }
8498
8499 child = sibling_die (child);
8500 }
8501 }
8502
8503 *lowpc = best_low;
8504 *highpc = best_high;
8505 }
8506
8507 /* Record the address ranges for BLOCK, offset by BASEADDR, as given
8508 in DIE. */
8509
8510 static void
8511 dwarf2_record_block_ranges (struct die_info *die, struct block *block,
8512 CORE_ADDR baseaddr, struct dwarf2_cu *cu)
8513 {
8514 struct objfile *objfile = cu->objfile;
8515 struct attribute *attr;
8516 struct attribute *attr_high;
8517
8518 attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
8519 if (attr_high)
8520 {
8521 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
8522 if (attr)
8523 {
8524 CORE_ADDR low = DW_ADDR (attr);
8525 CORE_ADDR high;
8526 if (attr_high->form == DW_FORM_addr
8527 || attr_high->form == DW_FORM_GNU_addr_index)
8528 high = DW_ADDR (attr_high);
8529 else
8530 high = low + DW_UNSND (attr_high);
8531
8532 record_block_range (block, baseaddr + low, baseaddr + high - 1);
8533 }
8534 }
8535
8536 attr = dwarf2_attr (die, DW_AT_ranges, cu);
8537 if (attr)
8538 {
8539 bfd *obfd = objfile->obfd;
8540
8541 /* The value of the DW_AT_ranges attribute is the offset of the
8542 address range list in the .debug_ranges section. */
8543 unsigned long offset = DW_UNSND (attr) + cu->ranges_base;
8544 gdb_byte *buffer = dwarf2_per_objfile->ranges.buffer + offset;
8545
8546 /* For some target architectures, but not others, the
8547 read_address function sign-extends the addresses it returns.
8548 To recognize base address selection entries, we need a
8549 mask. */
8550 unsigned int addr_size = cu->header.addr_size;
8551 CORE_ADDR base_select_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
8552
8553 /* The base address, to which the next pair is relative. Note
8554 that this 'base' is a DWARF concept: most entries in a range
8555 list are relative, to reduce the number of relocs against the
8556 debugging information. This is separate from this function's
8557 'baseaddr' argument, which GDB uses to relocate debugging
8558 information from a shared library based on the address at
8559 which the library was loaded. */
8560 CORE_ADDR base = cu->base_address;
8561 int base_known = cu->base_known;
8562
8563 gdb_assert (dwarf2_per_objfile->ranges.readin);
8564 if (offset >= dwarf2_per_objfile->ranges.size)
8565 {
8566 complaint (&symfile_complaints,
8567 _("Offset %lu out of bounds for DW_AT_ranges attribute"),
8568 offset);
8569 return;
8570 }
8571
8572 for (;;)
8573 {
8574 unsigned int bytes_read;
8575 CORE_ADDR start, end;
8576
8577 start = read_address (obfd, buffer, cu, &bytes_read);
8578 buffer += bytes_read;
8579 end = read_address (obfd, buffer, cu, &bytes_read);
8580 buffer += bytes_read;
8581
8582 /* Did we find the end of the range list? */
8583 if (start == 0 && end == 0)
8584 break;
8585
8586 /* Did we find a base address selection entry? */
8587 else if ((start & base_select_mask) == base_select_mask)
8588 {
8589 base = end;
8590 base_known = 1;
8591 }
8592
8593 /* We found an ordinary address range. */
8594 else
8595 {
8596 if (!base_known)
8597 {
8598 complaint (&symfile_complaints,
8599 _("Invalid .debug_ranges data "
8600 "(no base address)"));
8601 return;
8602 }
8603
8604 if (start > end)
8605 {
8606 /* Inverted range entries are invalid. */
8607 complaint (&symfile_complaints,
8608 _("Invalid .debug_ranges data "
8609 "(inverted range)"));
8610 return;
8611 }
8612
8613 /* Empty range entries have no effect. */
8614 if (start == end)
8615 continue;
8616
8617 record_block_range (block,
8618 baseaddr + base + start,
8619 baseaddr + base + end - 1);
8620 }
8621 }
8622 }
8623 }
8624
8625 /* Check whether the producer field indicates either of GCC < 4.6, or the
8626 Intel C/C++ compiler, and cache the result in CU. */
8627
8628 static void
8629 check_producer (struct dwarf2_cu *cu)
8630 {
8631 const char *cs;
8632 int major, minor, release;
8633
8634 if (cu->producer == NULL)
8635 {
8636 /* For unknown compilers expect their behavior is DWARF version
8637 compliant.
8638
8639 GCC started to support .debug_types sections by -gdwarf-4 since
8640 gcc-4.5.x. As the .debug_types sections are missing DW_AT_producer
8641 for their space efficiency GDB cannot workaround gcc-4.5.x -gdwarf-4
8642 combination. gcc-4.5.x -gdwarf-4 binaries have DW_AT_accessibility
8643 interpreted incorrectly by GDB now - GCC PR debug/48229. */
8644 }
8645 else if (strncmp (cu->producer, "GNU ", strlen ("GNU ")) == 0)
8646 {
8647 /* Skip any identifier after "GNU " - such as "C++" or "Java". */
8648
8649 cs = &cu->producer[strlen ("GNU ")];
8650 while (*cs && !isdigit (*cs))
8651 cs++;
8652 if (sscanf (cs, "%d.%d.%d", &major, &minor, &release) != 3)
8653 {
8654 /* Not recognized as GCC. */
8655 }
8656 else
8657 cu->producer_is_gxx_lt_4_6 = major < 4 || (major == 4 && minor < 6);
8658 }
8659 else if (strncmp (cu->producer, "Intel(R) C", strlen ("Intel(R) C")) == 0)
8660 cu->producer_is_icc = 1;
8661 else
8662 {
8663 /* For other non-GCC compilers, expect their behavior is DWARF version
8664 compliant. */
8665 }
8666
8667 cu->checked_producer = 1;
8668 }
8669
8670 /* Check for GCC PR debug/45124 fix which is not present in any G++ version up
8671 to 4.5.any while it is present already in G++ 4.6.0 - the PR has been fixed
8672 during 4.6.0 experimental. */
8673
8674 static int
8675 producer_is_gxx_lt_4_6 (struct dwarf2_cu *cu)
8676 {
8677 if (!cu->checked_producer)
8678 check_producer (cu);
8679
8680 return cu->producer_is_gxx_lt_4_6;
8681 }
8682
8683 /* Return the default accessibility type if it is not overriden by
8684 DW_AT_accessibility. */
8685
8686 static enum dwarf_access_attribute
8687 dwarf2_default_access_attribute (struct die_info *die, struct dwarf2_cu *cu)
8688 {
8689 if (cu->header.version < 3 || producer_is_gxx_lt_4_6 (cu))
8690 {
8691 /* The default DWARF 2 accessibility for members is public, the default
8692 accessibility for inheritance is private. */
8693
8694 if (die->tag != DW_TAG_inheritance)
8695 return DW_ACCESS_public;
8696 else
8697 return DW_ACCESS_private;
8698 }
8699 else
8700 {
8701 /* DWARF 3+ defines the default accessibility a different way. The same
8702 rules apply now for DW_TAG_inheritance as for the members and it only
8703 depends on the container kind. */
8704
8705 if (die->parent->tag == DW_TAG_class_type)
8706 return DW_ACCESS_private;
8707 else
8708 return DW_ACCESS_public;
8709 }
8710 }
8711
8712 /* Look for DW_AT_data_member_location. Set *OFFSET to the byte
8713 offset. If the attribute was not found return 0, otherwise return
8714 1. If it was found but could not properly be handled, set *OFFSET
8715 to 0. */
8716
8717 static int
8718 handle_data_member_location (struct die_info *die, struct dwarf2_cu *cu,
8719 LONGEST *offset)
8720 {
8721 struct attribute *attr;
8722
8723 attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
8724 if (attr != NULL)
8725 {
8726 *offset = 0;
8727
8728 /* Note that we do not check for a section offset first here.
8729 This is because DW_AT_data_member_location is new in DWARF 4,
8730 so if we see it, we can assume that a constant form is really
8731 a constant and not a section offset. */
8732 if (attr_form_is_constant (attr))
8733 *offset = dwarf2_get_attr_constant_value (attr, 0);
8734 else if (attr_form_is_section_offset (attr))
8735 dwarf2_complex_location_expr_complaint ();
8736 else if (attr_form_is_block (attr))
8737 *offset = decode_locdesc (DW_BLOCK (attr), cu);
8738 else
8739 dwarf2_complex_location_expr_complaint ();
8740
8741 return 1;
8742 }
8743
8744 return 0;
8745 }
8746
8747 /* Add an aggregate field to the field list. */
8748
8749 static void
8750 dwarf2_add_field (struct field_info *fip, struct die_info *die,
8751 struct dwarf2_cu *cu)
8752 {
8753 struct objfile *objfile = cu->objfile;
8754 struct gdbarch *gdbarch = get_objfile_arch (objfile);
8755 struct nextfield *new_field;
8756 struct attribute *attr;
8757 struct field *fp;
8758 char *fieldname = "";
8759
8760 /* Allocate a new field list entry and link it in. */
8761 new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield));
8762 make_cleanup (xfree, new_field);
8763 memset (new_field, 0, sizeof (struct nextfield));
8764
8765 if (die->tag == DW_TAG_inheritance)
8766 {
8767 new_field->next = fip->baseclasses;
8768 fip->baseclasses = new_field;
8769 }
8770 else
8771 {
8772 new_field->next = fip->fields;
8773 fip->fields = new_field;
8774 }
8775 fip->nfields++;
8776
8777 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
8778 if (attr)
8779 new_field->accessibility = DW_UNSND (attr);
8780 else
8781 new_field->accessibility = dwarf2_default_access_attribute (die, cu);
8782 if (new_field->accessibility != DW_ACCESS_public)
8783 fip->non_public_fields = 1;
8784
8785 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
8786 if (attr)
8787 new_field->virtuality = DW_UNSND (attr);
8788 else
8789 new_field->virtuality = DW_VIRTUALITY_none;
8790
8791 fp = &new_field->field;
8792
8793 if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
8794 {
8795 LONGEST offset;
8796
8797 /* Data member other than a C++ static data member. */
8798
8799 /* Get type of field. */
8800 fp->type = die_type (die, cu);
8801
8802 SET_FIELD_BITPOS (*fp, 0);
8803
8804 /* Get bit size of field (zero if none). */
8805 attr = dwarf2_attr (die, DW_AT_bit_size, cu);
8806 if (attr)
8807 {
8808 FIELD_BITSIZE (*fp) = DW_UNSND (attr);
8809 }
8810 else
8811 {
8812 FIELD_BITSIZE (*fp) = 0;
8813 }
8814
8815 /* Get bit offset of field. */
8816 if (handle_data_member_location (die, cu, &offset))
8817 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
8818 attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
8819 if (attr)
8820 {
8821 if (gdbarch_bits_big_endian (gdbarch))
8822 {
8823 /* For big endian bits, the DW_AT_bit_offset gives the
8824 additional bit offset from the MSB of the containing
8825 anonymous object to the MSB of the field. We don't
8826 have to do anything special since we don't need to
8827 know the size of the anonymous object. */
8828 SET_FIELD_BITPOS (*fp, FIELD_BITPOS (*fp) + DW_UNSND (attr));
8829 }
8830 else
8831 {
8832 /* For little endian bits, compute the bit offset to the
8833 MSB of the anonymous object, subtract off the number of
8834 bits from the MSB of the field to the MSB of the
8835 object, and then subtract off the number of bits of
8836 the field itself. The result is the bit offset of
8837 the LSB of the field. */
8838 int anonymous_size;
8839 int bit_offset = DW_UNSND (attr);
8840
8841 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
8842 if (attr)
8843 {
8844 /* The size of the anonymous object containing
8845 the bit field is explicit, so use the
8846 indicated size (in bytes). */
8847 anonymous_size = DW_UNSND (attr);
8848 }
8849 else
8850 {
8851 /* The size of the anonymous object containing
8852 the bit field must be inferred from the type
8853 attribute of the data member containing the
8854 bit field. */
8855 anonymous_size = TYPE_LENGTH (fp->type);
8856 }
8857 SET_FIELD_BITPOS (*fp,
8858 (FIELD_BITPOS (*fp)
8859 + anonymous_size * bits_per_byte
8860 - bit_offset - FIELD_BITSIZE (*fp)));
8861 }
8862 }
8863
8864 /* Get name of field. */
8865 fieldname = dwarf2_name (die, cu);
8866 if (fieldname == NULL)
8867 fieldname = "";
8868
8869 /* The name is already allocated along with this objfile, so we don't
8870 need to duplicate it for the type. */
8871 fp->name = fieldname;
8872
8873 /* Change accessibility for artificial fields (e.g. virtual table
8874 pointer or virtual base class pointer) to private. */
8875 if (dwarf2_attr (die, DW_AT_artificial, cu))
8876 {
8877 FIELD_ARTIFICIAL (*fp) = 1;
8878 new_field->accessibility = DW_ACCESS_private;
8879 fip->non_public_fields = 1;
8880 }
8881 }
8882 else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
8883 {
8884 /* C++ static member. */
8885
8886 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
8887 is a declaration, but all versions of G++ as of this writing
8888 (so through at least 3.2.1) incorrectly generate
8889 DW_TAG_variable tags. */
8890
8891 const char *physname;
8892
8893 /* Get name of field. */
8894 fieldname = dwarf2_name (die, cu);
8895 if (fieldname == NULL)
8896 return;
8897
8898 attr = dwarf2_attr (die, DW_AT_const_value, cu);
8899 if (attr
8900 /* Only create a symbol if this is an external value.
8901 new_symbol checks this and puts the value in the global symbol
8902 table, which we want. If it is not external, new_symbol
8903 will try to put the value in cu->list_in_scope which is wrong. */
8904 && dwarf2_flag_true_p (die, DW_AT_external, cu))
8905 {
8906 /* A static const member, not much different than an enum as far as
8907 we're concerned, except that we can support more types. */
8908 new_symbol (die, NULL, cu);
8909 }
8910
8911 /* Get physical name. */
8912 physname = dwarf2_physname (fieldname, die, cu);
8913
8914 /* The name is already allocated along with this objfile, so we don't
8915 need to duplicate it for the type. */
8916 SET_FIELD_PHYSNAME (*fp, physname ? physname : "");
8917 FIELD_TYPE (*fp) = die_type (die, cu);
8918 FIELD_NAME (*fp) = fieldname;
8919 }
8920 else if (die->tag == DW_TAG_inheritance)
8921 {
8922 LONGEST offset;
8923
8924 /* C++ base class field. */
8925 if (handle_data_member_location (die, cu, &offset))
8926 SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
8927 FIELD_BITSIZE (*fp) = 0;
8928 FIELD_TYPE (*fp) = die_type (die, cu);
8929 FIELD_NAME (*fp) = type_name_no_tag (fp->type);
8930 fip->nbaseclasses++;
8931 }
8932 }
8933
8934 /* Add a typedef defined in the scope of the FIP's class. */
8935
8936 static void
8937 dwarf2_add_typedef (struct field_info *fip, struct die_info *die,
8938 struct dwarf2_cu *cu)
8939 {
8940 struct objfile *objfile = cu->objfile;
8941 struct typedef_field_list *new_field;
8942 struct attribute *attr;
8943 struct typedef_field *fp;
8944 char *fieldname = "";
8945
8946 /* Allocate a new field list entry and link it in. */
8947 new_field = xzalloc (sizeof (*new_field));
8948 make_cleanup (xfree, new_field);
8949
8950 gdb_assert (die->tag == DW_TAG_typedef);
8951
8952 fp = &new_field->field;
8953
8954 /* Get name of field. */
8955 fp->name = dwarf2_name (die, cu);
8956 if (fp->name == NULL)
8957 return;
8958
8959 fp->type = read_type_die (die, cu);
8960
8961 new_field->next = fip->typedef_field_list;
8962 fip->typedef_field_list = new_field;
8963 fip->typedef_field_list_count++;
8964 }
8965
8966 /* Create the vector of fields, and attach it to the type. */
8967
8968 static void
8969 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
8970 struct dwarf2_cu *cu)
8971 {
8972 int nfields = fip->nfields;
8973
8974 /* Record the field count, allocate space for the array of fields,
8975 and create blank accessibility bitfields if necessary. */
8976 TYPE_NFIELDS (type) = nfields;
8977 TYPE_FIELDS (type) = (struct field *)
8978 TYPE_ALLOC (type, sizeof (struct field) * nfields);
8979 memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
8980
8981 if (fip->non_public_fields && cu->language != language_ada)
8982 {
8983 ALLOCATE_CPLUS_STRUCT_TYPE (type);
8984
8985 TYPE_FIELD_PRIVATE_BITS (type) =
8986 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
8987 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
8988
8989 TYPE_FIELD_PROTECTED_BITS (type) =
8990 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
8991 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
8992
8993 TYPE_FIELD_IGNORE_BITS (type) =
8994 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
8995 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
8996 }
8997
8998 /* If the type has baseclasses, allocate and clear a bit vector for
8999 TYPE_FIELD_VIRTUAL_BITS. */
9000 if (fip->nbaseclasses && cu->language != language_ada)
9001 {
9002 int num_bytes = B_BYTES (fip->nbaseclasses);
9003 unsigned char *pointer;
9004
9005 ALLOCATE_CPLUS_STRUCT_TYPE (type);
9006 pointer = TYPE_ALLOC (type, num_bytes);
9007 TYPE_FIELD_VIRTUAL_BITS (type) = pointer;
9008 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->nbaseclasses);
9009 TYPE_N_BASECLASSES (type) = fip->nbaseclasses;
9010 }
9011
9012 /* Copy the saved-up fields into the field vector. Start from the head of
9013 the list, adding to the tail of the field array, so that they end up in
9014 the same order in the array in which they were added to the list. */
9015 while (nfields-- > 0)
9016 {
9017 struct nextfield *fieldp;
9018
9019 if (fip->fields)
9020 {
9021 fieldp = fip->fields;
9022 fip->fields = fieldp->next;
9023 }
9024 else
9025 {
9026 fieldp = fip->baseclasses;
9027 fip->baseclasses = fieldp->next;
9028 }
9029
9030 TYPE_FIELD (type, nfields) = fieldp->field;
9031 switch (fieldp->accessibility)
9032 {
9033 case DW_ACCESS_private:
9034 if (cu->language != language_ada)
9035 SET_TYPE_FIELD_PRIVATE (type, nfields);
9036 break;
9037
9038 case DW_ACCESS_protected:
9039 if (cu->language != language_ada)
9040 SET_TYPE_FIELD_PROTECTED (type, nfields);
9041 break;
9042
9043 case DW_ACCESS_public:
9044 break;
9045
9046 default:
9047 /* Unknown accessibility. Complain and treat it as public. */
9048 {
9049 complaint (&symfile_complaints, _("unsupported accessibility %d"),
9050 fieldp->accessibility);
9051 }
9052 break;
9053 }
9054 if (nfields < fip->nbaseclasses)
9055 {
9056 switch (fieldp->virtuality)
9057 {
9058 case DW_VIRTUALITY_virtual:
9059 case DW_VIRTUALITY_pure_virtual:
9060 if (cu->language == language_ada)
9061 error (_("unexpected virtuality in component of Ada type"));
9062 SET_TYPE_FIELD_VIRTUAL (type, nfields);
9063 break;
9064 }
9065 }
9066 }
9067 }
9068
9069 /* Add a member function to the proper fieldlist. */
9070
9071 static void
9072 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
9073 struct type *type, struct dwarf2_cu *cu)
9074 {
9075 struct objfile *objfile = cu->objfile;
9076 struct attribute *attr;
9077 struct fnfieldlist *flp;
9078 int i;
9079 struct fn_field *fnp;
9080 char *fieldname;
9081 struct nextfnfield *new_fnfield;
9082 struct type *this_type;
9083 enum dwarf_access_attribute accessibility;
9084
9085 if (cu->language == language_ada)
9086 error (_("unexpected member function in Ada type"));
9087
9088 /* Get name of member function. */
9089 fieldname = dwarf2_name (die, cu);
9090 if (fieldname == NULL)
9091 return;
9092
9093 /* Look up member function name in fieldlist. */
9094 for (i = 0; i < fip->nfnfields; i++)
9095 {
9096 if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0)
9097 break;
9098 }
9099
9100 /* Create new list element if necessary. */
9101 if (i < fip->nfnfields)
9102 flp = &fip->fnfieldlists[i];
9103 else
9104 {
9105 if ((fip->nfnfields % DW_FIELD_ALLOC_CHUNK) == 0)
9106 {
9107 fip->fnfieldlists = (struct fnfieldlist *)
9108 xrealloc (fip->fnfieldlists,
9109 (fip->nfnfields + DW_FIELD_ALLOC_CHUNK)
9110 * sizeof (struct fnfieldlist));
9111 if (fip->nfnfields == 0)
9112 make_cleanup (free_current_contents, &fip->fnfieldlists);
9113 }
9114 flp = &fip->fnfieldlists[fip->nfnfields];
9115 flp->name = fieldname;
9116 flp->length = 0;
9117 flp->head = NULL;
9118 i = fip->nfnfields++;
9119 }
9120
9121 /* Create a new member function field and chain it to the field list
9122 entry. */
9123 new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield));
9124 make_cleanup (xfree, new_fnfield);
9125 memset (new_fnfield, 0, sizeof (struct nextfnfield));
9126 new_fnfield->next = flp->head;
9127 flp->head = new_fnfield;
9128 flp->length++;
9129
9130 /* Fill in the member function field info. */
9131 fnp = &new_fnfield->fnfield;
9132
9133 /* Delay processing of the physname until later. */
9134 if (cu->language == language_cplus || cu->language == language_java)
9135 {
9136 add_to_method_list (type, i, flp->length - 1, fieldname,
9137 die, cu);
9138 }
9139 else
9140 {
9141 const char *physname = dwarf2_physname (fieldname, die, cu);
9142 fnp->physname = physname ? physname : "";
9143 }
9144
9145 fnp->type = alloc_type (objfile);
9146 this_type = read_type_die (die, cu);
9147 if (this_type && TYPE_CODE (this_type) == TYPE_CODE_FUNC)
9148 {
9149 int nparams = TYPE_NFIELDS (this_type);
9150
9151 /* TYPE is the domain of this method, and THIS_TYPE is the type
9152 of the method itself (TYPE_CODE_METHOD). */
9153 smash_to_method_type (fnp->type, type,
9154 TYPE_TARGET_TYPE (this_type),
9155 TYPE_FIELDS (this_type),
9156 TYPE_NFIELDS (this_type),
9157 TYPE_VARARGS (this_type));
9158
9159 /* Handle static member functions.
9160 Dwarf2 has no clean way to discern C++ static and non-static
9161 member functions. G++ helps GDB by marking the first
9162 parameter for non-static member functions (which is the this
9163 pointer) as artificial. We obtain this information from
9164 read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
9165 if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (this_type, 0) == 0)
9166 fnp->voffset = VOFFSET_STATIC;
9167 }
9168 else
9169 complaint (&symfile_complaints, _("member function type missing for '%s'"),
9170 dwarf2_full_name (fieldname, die, cu));
9171
9172 /* Get fcontext from DW_AT_containing_type if present. */
9173 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
9174 fnp->fcontext = die_containing_type (die, cu);
9175
9176 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const and
9177 is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
9178
9179 /* Get accessibility. */
9180 attr = dwarf2_attr (die, DW_AT_accessibility, cu);
9181 if (attr)
9182 accessibility = DW_UNSND (attr);
9183 else
9184 accessibility = dwarf2_default_access_attribute (die, cu);
9185 switch (accessibility)
9186 {
9187 case DW_ACCESS_private:
9188 fnp->is_private = 1;
9189 break;
9190 case DW_ACCESS_protected:
9191 fnp->is_protected = 1;
9192 break;
9193 }
9194
9195 /* Check for artificial methods. */
9196 attr = dwarf2_attr (die, DW_AT_artificial, cu);
9197 if (attr && DW_UNSND (attr) != 0)
9198 fnp->is_artificial = 1;
9199
9200 /* Get index in virtual function table if it is a virtual member
9201 function. For older versions of GCC, this is an offset in the
9202 appropriate virtual table, as specified by DW_AT_containing_type.
9203 For everyone else, it is an expression to be evaluated relative
9204 to the object address. */
9205
9206 attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
9207 if (attr)
9208 {
9209 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size > 0)
9210 {
9211 if (DW_BLOCK (attr)->data[0] == DW_OP_constu)
9212 {
9213 /* Old-style GCC. */
9214 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2;
9215 }
9216 else if (DW_BLOCK (attr)->data[0] == DW_OP_deref
9217 || (DW_BLOCK (attr)->size > 1
9218 && DW_BLOCK (attr)->data[0] == DW_OP_deref_size
9219 && DW_BLOCK (attr)->data[1] == cu->header.addr_size))
9220 {
9221 struct dwarf_block blk;
9222 int offset;
9223
9224 offset = (DW_BLOCK (attr)->data[0] == DW_OP_deref
9225 ? 1 : 2);
9226 blk.size = DW_BLOCK (attr)->size - offset;
9227 blk.data = DW_BLOCK (attr)->data + offset;
9228 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu);
9229 if ((fnp->voffset % cu->header.addr_size) != 0)
9230 dwarf2_complex_location_expr_complaint ();
9231 else
9232 fnp->voffset /= cu->header.addr_size;
9233 fnp->voffset += 2;
9234 }
9235 else
9236 dwarf2_complex_location_expr_complaint ();
9237
9238 if (!fnp->fcontext)
9239 fnp->fcontext = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (this_type, 0));
9240 }
9241 else if (attr_form_is_section_offset (attr))
9242 {
9243 dwarf2_complex_location_expr_complaint ();
9244 }
9245 else
9246 {
9247 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
9248 fieldname);
9249 }
9250 }
9251 else
9252 {
9253 attr = dwarf2_attr (die, DW_AT_virtuality, cu);
9254 if (attr && DW_UNSND (attr))
9255 {
9256 /* GCC does this, as of 2008-08-25; PR debug/37237. */
9257 complaint (&symfile_complaints,
9258 _("Member function \"%s\" (offset %d) is virtual "
9259 "but the vtable offset is not specified"),
9260 fieldname, die->offset.sect_off);
9261 ALLOCATE_CPLUS_STRUCT_TYPE (type);
9262 TYPE_CPLUS_DYNAMIC (type) = 1;
9263 }
9264 }
9265 }
9266
9267 /* Create the vector of member function fields, and attach it to the type. */
9268
9269 static void
9270 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
9271 struct dwarf2_cu *cu)
9272 {
9273 struct fnfieldlist *flp;
9274 int i;
9275
9276 if (cu->language == language_ada)
9277 error (_("unexpected member functions in Ada type"));
9278
9279 ALLOCATE_CPLUS_STRUCT_TYPE (type);
9280 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
9281 TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * fip->nfnfields);
9282
9283 for (i = 0, flp = fip->fnfieldlists; i < fip->nfnfields; i++, flp++)
9284 {
9285 struct nextfnfield *nfp = flp->head;
9286 struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
9287 int k;
9288
9289 TYPE_FN_FIELDLIST_NAME (type, i) = flp->name;
9290 TYPE_FN_FIELDLIST_LENGTH (type, i) = flp->length;
9291 fn_flp->fn_fields = (struct fn_field *)
9292 TYPE_ALLOC (type, sizeof (struct fn_field) * flp->length);
9293 for (k = flp->length; (k--, nfp); nfp = nfp->next)
9294 fn_flp->fn_fields[k] = nfp->fnfield;
9295 }
9296
9297 TYPE_NFN_FIELDS (type) = fip->nfnfields;
9298 }
9299
9300 /* Returns non-zero if NAME is the name of a vtable member in CU's
9301 language, zero otherwise. */
9302 static int
9303 is_vtable_name (const char *name, struct dwarf2_cu *cu)
9304 {
9305 static const char vptr[] = "_vptr";
9306 static const char vtable[] = "vtable";
9307
9308 /* Look for the C++ and Java forms of the vtable. */
9309 if ((cu->language == language_java
9310 && strncmp (name, vtable, sizeof (vtable) - 1) == 0)
9311 || (strncmp (name, vptr, sizeof (vptr) - 1) == 0
9312 && is_cplus_marker (name[sizeof (vptr) - 1])))
9313 return 1;
9314
9315 return 0;
9316 }
9317
9318 /* GCC outputs unnamed structures that are really pointers to member
9319 functions, with the ABI-specified layout. If TYPE describes
9320 such a structure, smash it into a member function type.
9321
9322 GCC shouldn't do this; it should just output pointer to member DIEs.
9323 This is GCC PR debug/28767. */
9324
9325 static void
9326 quirk_gcc_member_function_pointer (struct type *type, struct objfile *objfile)
9327 {
9328 struct type *pfn_type, *domain_type, *new_type;
9329
9330 /* Check for a structure with no name and two children. */
9331 if (TYPE_CODE (type) != TYPE_CODE_STRUCT || TYPE_NFIELDS (type) != 2)
9332 return;
9333
9334 /* Check for __pfn and __delta members. */
9335 if (TYPE_FIELD_NAME (type, 0) == NULL
9336 || strcmp (TYPE_FIELD_NAME (type, 0), "__pfn") != 0
9337 || TYPE_FIELD_NAME (type, 1) == NULL
9338 || strcmp (TYPE_FIELD_NAME (type, 1), "__delta") != 0)
9339 return;
9340
9341 /* Find the type of the method. */
9342 pfn_type = TYPE_FIELD_TYPE (type, 0);
9343 if (pfn_type == NULL
9344 || TYPE_CODE (pfn_type) != TYPE_CODE_PTR
9345 || TYPE_CODE (TYPE_TARGET_TYPE (pfn_type)) != TYPE_CODE_FUNC)
9346 return;
9347
9348 /* Look for the "this" argument. */
9349 pfn_type = TYPE_TARGET_TYPE (pfn_type);
9350 if (TYPE_NFIELDS (pfn_type) == 0
9351 /* || TYPE_FIELD_TYPE (pfn_type, 0) == NULL */
9352 || TYPE_CODE (TYPE_FIELD_TYPE (pfn_type, 0)) != TYPE_CODE_PTR)
9353 return;
9354
9355 domain_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (pfn_type, 0));
9356 new_type = alloc_type (objfile);
9357 smash_to_method_type (new_type, domain_type, TYPE_TARGET_TYPE (pfn_type),
9358 TYPE_FIELDS (pfn_type), TYPE_NFIELDS (pfn_type),
9359 TYPE_VARARGS (pfn_type));
9360 smash_to_methodptr_type (type, new_type);
9361 }
9362
9363 /* Return non-zero if the CU's PRODUCER string matches the Intel C/C++ compiler
9364 (icc). */
9365
9366 static int
9367 producer_is_icc (struct dwarf2_cu *cu)
9368 {
9369 if (!cu->checked_producer)
9370 check_producer (cu);
9371
9372 return cu->producer_is_icc;
9373 }
9374
9375 /* Called when we find the DIE that starts a structure or union scope
9376 (definition) to create a type for the structure or union. Fill in
9377 the type's name and general properties; the members will not be
9378 processed until process_structure_type.
9379
9380 NOTE: we need to call these functions regardless of whether or not the
9381 DIE has a DW_AT_name attribute, since it might be an anonymous
9382 structure or union. This gets the type entered into our set of
9383 user defined types.
9384
9385 However, if the structure is incomplete (an opaque struct/union)
9386 then suppress creating a symbol table entry for it since gdb only
9387 wants to find the one with the complete definition. Note that if
9388 it is complete, we just call new_symbol, which does it's own
9389 checking about whether the struct/union is anonymous or not (and
9390 suppresses creating a symbol table entry itself). */
9391
9392 static struct type *
9393 read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
9394 {
9395 struct objfile *objfile = cu->objfile;
9396 struct type *type;
9397 struct attribute *attr;
9398 char *name;
9399
9400 /* If the definition of this type lives in .debug_types, read that type.
9401 Don't follow DW_AT_specification though, that will take us back up
9402 the chain and we want to go down. */
9403 attr = dwarf2_attr_no_follow (die, DW_AT_signature);
9404 if (attr)
9405 {
9406 struct dwarf2_cu *type_cu = cu;
9407 struct die_info *type_die = follow_die_ref_or_sig (die, attr, &type_cu);
9408
9409 /* We could just recurse on read_structure_type, but we need to call
9410 get_die_type to ensure only one type for this DIE is created.
9411 This is important, for example, because for c++ classes we need
9412 TYPE_NAME set which is only done by new_symbol. Blech. */
9413 type = read_type_die (type_die, type_cu);
9414
9415 /* TYPE_CU may not be the same as CU.
9416 Ensure TYPE is recorded in CU's type_hash table. */
9417 return set_die_type (die, type, cu);
9418 }
9419
9420 type = alloc_type (objfile);
9421 INIT_CPLUS_SPECIFIC (type);
9422
9423 name = dwarf2_name (die, cu);
9424 if (name != NULL)
9425 {
9426 if (cu->language == language_cplus
9427 || cu->language == language_java)
9428 {
9429 char *full_name = (char *) dwarf2_full_name (name, die, cu);
9430
9431 /* dwarf2_full_name might have already finished building the DIE's
9432 type. If so, there is no need to continue. */
9433 if (get_die_type (die, cu) != NULL)
9434 return get_die_type (die, cu);
9435
9436 TYPE_TAG_NAME (type) = full_name;
9437 if (die->tag == DW_TAG_structure_type
9438 || die->tag == DW_TAG_class_type)
9439 TYPE_NAME (type) = TYPE_TAG_NAME (type);
9440 }
9441 else
9442 {
9443 /* The name is already allocated along with this objfile, so
9444 we don't need to duplicate it for the type. */
9445 TYPE_TAG_NAME (type) = (char *) name;
9446 if (die->tag == DW_TAG_class_type)
9447 TYPE_NAME (type) = TYPE_TAG_NAME (type);
9448 }
9449 }
9450
9451 if (die->tag == DW_TAG_structure_type)
9452 {
9453 TYPE_CODE (type) = TYPE_CODE_STRUCT;
9454 }
9455 else if (die->tag == DW_TAG_union_type)
9456 {
9457 TYPE_CODE (type) = TYPE_CODE_UNION;
9458 }
9459 else
9460 {
9461 TYPE_CODE (type) = TYPE_CODE_CLASS;
9462 }
9463
9464 if (cu->language == language_cplus && die->tag == DW_TAG_class_type)
9465 TYPE_DECLARED_CLASS (type) = 1;
9466
9467 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
9468 if (attr)
9469 {
9470 TYPE_LENGTH (type) = DW_UNSND (attr);
9471 }
9472 else
9473 {
9474 TYPE_LENGTH (type) = 0;
9475 }
9476
9477 if (producer_is_icc (cu))
9478 {
9479 /* ICC does not output the required DW_AT_declaration
9480 on incomplete types, but gives them a size of zero. */
9481 }
9482 else
9483 TYPE_STUB_SUPPORTED (type) = 1;
9484
9485 if (die_is_declaration (die, cu))
9486 TYPE_STUB (type) = 1;
9487 else if (attr == NULL && die->child == NULL
9488 && producer_is_realview (cu->producer))
9489 /* RealView does not output the required DW_AT_declaration
9490 on incomplete types. */
9491 TYPE_STUB (type) = 1;
9492
9493 /* We need to add the type field to the die immediately so we don't
9494 infinitely recurse when dealing with pointers to the structure
9495 type within the structure itself. */
9496 set_die_type (die, type, cu);
9497
9498 /* set_die_type should be already done. */
9499 set_descriptive_type (type, die, cu);
9500
9501 return type;
9502 }
9503
9504 /* Finish creating a structure or union type, including filling in
9505 its members and creating a symbol for it. */
9506
9507 static void
9508 process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
9509 {
9510 struct objfile *objfile = cu->objfile;
9511 struct die_info *child_die = die->child;
9512 struct type *type;
9513
9514 type = get_die_type (die, cu);
9515 if (type == NULL)
9516 type = read_structure_type (die, cu);
9517
9518 if (die->child != NULL && ! die_is_declaration (die, cu))
9519 {
9520 struct field_info fi;
9521 struct die_info *child_die;
9522 VEC (symbolp) *template_args = NULL;
9523 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
9524
9525 memset (&fi, 0, sizeof (struct field_info));
9526
9527 child_die = die->child;
9528
9529 while (child_die && child_die->tag)
9530 {
9531 if (child_die->tag == DW_TAG_member
9532 || child_die->tag == DW_TAG_variable)
9533 {
9534 /* NOTE: carlton/2002-11-05: A C++ static data member
9535 should be a DW_TAG_member that is a declaration, but
9536 all versions of G++ as of this writing (so through at
9537 least 3.2.1) incorrectly generate DW_TAG_variable
9538 tags for them instead. */
9539 dwarf2_add_field (&fi, child_die, cu);
9540 }
9541 else if (child_die->tag == DW_TAG_subprogram)
9542 {
9543 /* C++ member function. */
9544 dwarf2_add_member_fn (&fi, child_die, type, cu);
9545 }
9546 else if (child_die->tag == DW_TAG_inheritance)
9547 {
9548 /* C++ base class field. */
9549 dwarf2_add_field (&fi, child_die, cu);
9550 }
9551 else if (child_die->tag == DW_TAG_typedef)
9552 dwarf2_add_typedef (&fi, child_die, cu);
9553 else if (child_die->tag == DW_TAG_template_type_param
9554 || child_die->tag == DW_TAG_template_value_param)
9555 {
9556 struct symbol *arg = new_symbol (child_die, NULL, cu);
9557
9558 if (arg != NULL)
9559 VEC_safe_push (symbolp, template_args, arg);
9560 }
9561
9562 child_die = sibling_die (child_die);
9563 }
9564
9565 /* Attach template arguments to type. */
9566 if (! VEC_empty (symbolp, template_args))
9567 {
9568 ALLOCATE_CPLUS_STRUCT_TYPE (type);
9569 TYPE_N_TEMPLATE_ARGUMENTS (type)
9570 = VEC_length (symbolp, template_args);
9571 TYPE_TEMPLATE_ARGUMENTS (type)
9572 = obstack_alloc (&objfile->objfile_obstack,
9573 (TYPE_N_TEMPLATE_ARGUMENTS (type)
9574 * sizeof (struct symbol *)));
9575 memcpy (TYPE_TEMPLATE_ARGUMENTS (type),
9576 VEC_address (symbolp, template_args),
9577 (TYPE_N_TEMPLATE_ARGUMENTS (type)
9578 * sizeof (struct symbol *)));
9579 VEC_free (symbolp, template_args);
9580 }
9581
9582 /* Attach fields and member functions to the type. */
9583 if (fi.nfields)
9584 dwarf2_attach_fields_to_type (&fi, type, cu);
9585 if (fi.nfnfields)
9586 {
9587 dwarf2_attach_fn_fields_to_type (&fi, type, cu);
9588
9589 /* Get the type which refers to the base class (possibly this
9590 class itself) which contains the vtable pointer for the current
9591 class from the DW_AT_containing_type attribute. This use of
9592 DW_AT_containing_type is a GNU extension. */
9593
9594 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
9595 {
9596 struct type *t = die_containing_type (die, cu);
9597
9598 TYPE_VPTR_BASETYPE (type) = t;
9599 if (type == t)
9600 {
9601 int i;
9602
9603 /* Our own class provides vtbl ptr. */
9604 for (i = TYPE_NFIELDS (t) - 1;
9605 i >= TYPE_N_BASECLASSES (t);
9606 --i)
9607 {
9608 const char *fieldname = TYPE_FIELD_NAME (t, i);
9609
9610 if (is_vtable_name (fieldname, cu))
9611 {
9612 TYPE_VPTR_FIELDNO (type) = i;
9613 break;
9614 }
9615 }
9616
9617 /* Complain if virtual function table field not found. */
9618 if (i < TYPE_N_BASECLASSES (t))
9619 complaint (&symfile_complaints,
9620 _("virtual function table pointer "
9621 "not found when defining class '%s'"),
9622 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) :
9623 "");
9624 }
9625 else
9626 {
9627 TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
9628 }
9629 }
9630 else if (cu->producer
9631 && strncmp (cu->producer,
9632 "IBM(R) XL C/C++ Advanced Edition", 32) == 0)
9633 {
9634 /* The IBM XLC compiler does not provide direct indication
9635 of the containing type, but the vtable pointer is
9636 always named __vfp. */
9637
9638 int i;
9639
9640 for (i = TYPE_NFIELDS (type) - 1;
9641 i >= TYPE_N_BASECLASSES (type);
9642 --i)
9643 {
9644 if (strcmp (TYPE_FIELD_NAME (type, i), "__vfp") == 0)
9645 {
9646 TYPE_VPTR_FIELDNO (type) = i;
9647 TYPE_VPTR_BASETYPE (type) = type;
9648 break;
9649 }
9650 }
9651 }
9652 }
9653
9654 /* Copy fi.typedef_field_list linked list elements content into the
9655 allocated array TYPE_TYPEDEF_FIELD_ARRAY (type). */
9656 if (fi.typedef_field_list)
9657 {
9658 int i = fi.typedef_field_list_count;
9659
9660 ALLOCATE_CPLUS_STRUCT_TYPE (type);
9661 TYPE_TYPEDEF_FIELD_ARRAY (type)
9662 = TYPE_ALLOC (type, sizeof (TYPE_TYPEDEF_FIELD (type, 0)) * i);
9663 TYPE_TYPEDEF_FIELD_COUNT (type) = i;
9664
9665 /* Reverse the list order to keep the debug info elements order. */
9666 while (--i >= 0)
9667 {
9668 struct typedef_field *dest, *src;
9669
9670 dest = &TYPE_TYPEDEF_FIELD (type, i);
9671 src = &fi.typedef_field_list->field;
9672 fi.typedef_field_list = fi.typedef_field_list->next;
9673 *dest = *src;
9674 }
9675 }
9676
9677 do_cleanups (back_to);
9678
9679 if (HAVE_CPLUS_STRUCT (type))
9680 TYPE_CPLUS_REALLY_JAVA (type) = cu->language == language_java;
9681 }
9682
9683 quirk_gcc_member_function_pointer (type, objfile);
9684
9685 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its
9686 snapshots) has been known to create a die giving a declaration
9687 for a class that has, as a child, a die giving a definition for a
9688 nested class. So we have to process our children even if the
9689 current die is a declaration. Normally, of course, a declaration
9690 won't have any children at all. */
9691
9692 while (child_die != NULL && child_die->tag)
9693 {
9694 if (child_die->tag == DW_TAG_member
9695 || child_die->tag == DW_TAG_variable
9696 || child_die->tag == DW_TAG_inheritance
9697 || child_die->tag == DW_TAG_template_value_param
9698 || child_die->tag == DW_TAG_template_type_param)
9699 {
9700 /* Do nothing. */
9701 }
9702 else
9703 process_die (child_die, cu);
9704
9705 child_die = sibling_die (child_die);
9706 }
9707
9708 /* Do not consider external references. According to the DWARF standard,
9709 these DIEs are identified by the fact that they have no byte_size
9710 attribute, and a declaration attribute. */
9711 if (dwarf2_attr (die, DW_AT_byte_size, cu) != NULL
9712 || !die_is_declaration (die, cu))
9713 new_symbol (die, type, cu);
9714 }
9715
9716 /* Given a DW_AT_enumeration_type die, set its type. We do not
9717 complete the type's fields yet, or create any symbols. */
9718
9719 static struct type *
9720 read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
9721 {
9722 struct objfile *objfile = cu->objfile;
9723 struct type *type;
9724 struct attribute *attr;
9725 const char *name;
9726
9727 /* If the definition of this type lives in .debug_types, read that type.
9728 Don't follow DW_AT_specification though, that will take us back up
9729 the chain and we want to go down. */
9730 attr = dwarf2_attr_no_follow (die, DW_AT_signature);
9731 if (attr)
9732 {
9733 struct dwarf2_cu *type_cu = cu;
9734 struct die_info *type_die = follow_die_ref_or_sig (die, attr, &type_cu);
9735
9736 type = read_type_die (type_die, type_cu);
9737
9738 /* TYPE_CU may not be the same as CU.
9739 Ensure TYPE is recorded in CU's type_hash table. */
9740 return set_die_type (die, type, cu);
9741 }
9742
9743 type = alloc_type (objfile);
9744
9745 TYPE_CODE (type) = TYPE_CODE_ENUM;
9746 name = dwarf2_full_name (NULL, die, cu);
9747 if (name != NULL)
9748 TYPE_TAG_NAME (type) = (char *) name;
9749
9750 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
9751 if (attr)
9752 {
9753 TYPE_LENGTH (type) = DW_UNSND (attr);
9754 }
9755 else
9756 {
9757 TYPE_LENGTH (type) = 0;
9758 }
9759
9760 /* The enumeration DIE can be incomplete. In Ada, any type can be
9761 declared as private in the package spec, and then defined only
9762 inside the package body. Such types are known as Taft Amendment
9763 Types. When another package uses such a type, an incomplete DIE
9764 may be generated by the compiler. */
9765 if (die_is_declaration (die, cu))
9766 TYPE_STUB (type) = 1;
9767
9768 return set_die_type (die, type, cu);
9769 }
9770
9771 /* Given a pointer to a die which begins an enumeration, process all
9772 the dies that define the members of the enumeration, and create the
9773 symbol for the enumeration type.
9774
9775 NOTE: We reverse the order of the element list. */
9776
9777 static void
9778 process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu)
9779 {
9780 struct type *this_type;
9781
9782 this_type = get_die_type (die, cu);
9783 if (this_type == NULL)
9784 this_type = read_enumeration_type (die, cu);
9785
9786 if (die->child != NULL)
9787 {
9788 struct die_info *child_die;
9789 struct symbol *sym;
9790 struct field *fields = NULL;
9791 int num_fields = 0;
9792 int unsigned_enum = 1;
9793 char *name;
9794 int flag_enum = 1;
9795 ULONGEST mask = 0;
9796
9797 child_die = die->child;
9798 while (child_die && child_die->tag)
9799 {
9800 if (child_die->tag != DW_TAG_enumerator)
9801 {
9802 process_die (child_die, cu);
9803 }
9804 else
9805 {
9806 name = dwarf2_name (child_die, cu);
9807 if (name)
9808 {
9809 sym = new_symbol (child_die, this_type, cu);
9810 if (SYMBOL_VALUE (sym) < 0)
9811 {
9812 unsigned_enum = 0;
9813 flag_enum = 0;
9814 }
9815 else if ((mask & SYMBOL_VALUE (sym)) != 0)
9816 flag_enum = 0;
9817 else
9818 mask |= SYMBOL_VALUE (sym);
9819
9820 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
9821 {
9822 fields = (struct field *)
9823 xrealloc (fields,
9824 (num_fields + DW_FIELD_ALLOC_CHUNK)
9825 * sizeof (struct field));
9826 }
9827
9828 FIELD_NAME (fields[num_fields]) = SYMBOL_LINKAGE_NAME (sym);
9829 FIELD_TYPE (fields[num_fields]) = NULL;
9830 SET_FIELD_ENUMVAL (fields[num_fields], SYMBOL_VALUE (sym));
9831 FIELD_BITSIZE (fields[num_fields]) = 0;
9832
9833 num_fields++;
9834 }
9835 }
9836
9837 child_die = sibling_die (child_die);
9838 }
9839
9840 if (num_fields)
9841 {
9842 TYPE_NFIELDS (this_type) = num_fields;
9843 TYPE_FIELDS (this_type) = (struct field *)
9844 TYPE_ALLOC (this_type, sizeof (struct field) * num_fields);
9845 memcpy (TYPE_FIELDS (this_type), fields,
9846 sizeof (struct field) * num_fields);
9847 xfree (fields);
9848 }
9849 if (unsigned_enum)
9850 TYPE_UNSIGNED (this_type) = 1;
9851 if (flag_enum)
9852 TYPE_FLAG_ENUM (this_type) = 1;
9853 }
9854
9855 /* If we are reading an enum from a .debug_types unit, and the enum
9856 is a declaration, and the enum is not the signatured type in the
9857 unit, then we do not want to add a symbol for it. Adding a
9858 symbol would in some cases obscure the true definition of the
9859 enum, giving users an incomplete type when the definition is
9860 actually available. Note that we do not want to do this for all
9861 enums which are just declarations, because C++0x allows forward
9862 enum declarations. */
9863 if (cu->per_cu->is_debug_types
9864 && die_is_declaration (die, cu))
9865 {
9866 struct signatured_type *sig_type;
9867
9868 sig_type
9869 = lookup_signatured_type_at_offset (dwarf2_per_objfile->objfile,
9870 cu->per_cu->info_or_types_section,
9871 cu->per_cu->offset);
9872 gdb_assert (sig_type->type_offset_in_section.sect_off != 0);
9873 if (sig_type->type_offset_in_section.sect_off != die->offset.sect_off)
9874 return;
9875 }
9876
9877 new_symbol (die, this_type, cu);
9878 }
9879
9880 /* Extract all information from a DW_TAG_array_type DIE and put it in
9881 the DIE's type field. For now, this only handles one dimensional
9882 arrays. */
9883
9884 static struct type *
9885 read_array_type (struct die_info *die, struct dwarf2_cu *cu)
9886 {
9887 struct objfile *objfile = cu->objfile;
9888 struct die_info *child_die;
9889 struct type *type;
9890 struct type *element_type, *range_type, *index_type;
9891 struct type **range_types = NULL;
9892 struct attribute *attr;
9893 int ndim = 0;
9894 struct cleanup *back_to;
9895 char *name;
9896
9897 element_type = die_type (die, cu);
9898
9899 /* The die_type call above may have already set the type for this DIE. */
9900 type = get_die_type (die, cu);
9901 if (type)
9902 return type;
9903
9904 /* Irix 6.2 native cc creates array types without children for
9905 arrays with unspecified length. */
9906 if (die->child == NULL)
9907 {
9908 index_type = objfile_type (objfile)->builtin_int;
9909 range_type = create_range_type (NULL, index_type, 0, -1);
9910 type = create_array_type (NULL, element_type, range_type);
9911 return set_die_type (die, type, cu);
9912 }
9913
9914 back_to = make_cleanup (null_cleanup, NULL);
9915 child_die = die->child;
9916 while (child_die && child_die->tag)
9917 {
9918 if (child_die->tag == DW_TAG_subrange_type)
9919 {
9920 struct type *child_type = read_type_die (child_die, cu);
9921
9922 if (child_type != NULL)
9923 {
9924 /* The range type was succesfully read. Save it for the
9925 array type creation. */
9926 if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0)
9927 {
9928 range_types = (struct type **)
9929 xrealloc (range_types, (ndim + DW_FIELD_ALLOC_CHUNK)
9930 * sizeof (struct type *));
9931 if (ndim == 0)
9932 make_cleanup (free_current_contents, &range_types);
9933 }
9934 range_types[ndim++] = child_type;
9935 }
9936 }
9937 child_die = sibling_die (child_die);
9938 }
9939
9940 /* Dwarf2 dimensions are output from left to right, create the
9941 necessary array types in backwards order. */
9942
9943 type = element_type;
9944
9945 if (read_array_order (die, cu) == DW_ORD_col_major)
9946 {
9947 int i = 0;
9948
9949 while (i < ndim)
9950 type = create_array_type (NULL, type, range_types[i++]);
9951 }
9952 else
9953 {
9954 while (ndim-- > 0)
9955 type = create_array_type (NULL, type, range_types[ndim]);
9956 }
9957
9958 /* Understand Dwarf2 support for vector types (like they occur on
9959 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
9960 array type. This is not part of the Dwarf2/3 standard yet, but a
9961 custom vendor extension. The main difference between a regular
9962 array and the vector variant is that vectors are passed by value
9963 to functions. */
9964 attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
9965 if (attr)
9966 make_vector_type (type);
9967
9968 /* The DIE may have DW_AT_byte_size set. For example an OpenCL
9969 implementation may choose to implement triple vectors using this
9970 attribute. */
9971 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
9972 if (attr)
9973 {
9974 if (DW_UNSND (attr) >= TYPE_LENGTH (type))
9975 TYPE_LENGTH (type) = DW_UNSND (attr);
9976 else
9977 complaint (&symfile_complaints,
9978 _("DW_AT_byte_size for array type smaller "
9979 "than the total size of elements"));
9980 }
9981
9982 name = dwarf2_name (die, cu);
9983 if (name)
9984 TYPE_NAME (type) = name;
9985
9986 /* Install the type in the die. */
9987 set_die_type (die, type, cu);
9988
9989 /* set_die_type should be already done. */
9990 set_descriptive_type (type, die, cu);
9991
9992 do_cleanups (back_to);
9993
9994 return type;
9995 }
9996
9997 static enum dwarf_array_dim_ordering
9998 read_array_order (struct die_info *die, struct dwarf2_cu *cu)
9999 {
10000 struct attribute *attr;
10001
10002 attr = dwarf2_attr (die, DW_AT_ordering, cu);
10003
10004 if (attr) return DW_SND (attr);
10005
10006 /* GNU F77 is a special case, as at 08/2004 array type info is the
10007 opposite order to the dwarf2 specification, but data is still
10008 laid out as per normal fortran.
10009
10010 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need
10011 version checking. */
10012
10013 if (cu->language == language_fortran
10014 && cu->producer && strstr (cu->producer, "GNU F77"))
10015 {
10016 return DW_ORD_row_major;
10017 }
10018
10019 switch (cu->language_defn->la_array_ordering)
10020 {
10021 case array_column_major:
10022 return DW_ORD_col_major;
10023 case array_row_major:
10024 default:
10025 return DW_ORD_row_major;
10026 };
10027 }
10028
10029 /* Extract all information from a DW_TAG_set_type DIE and put it in
10030 the DIE's type field. */
10031
10032 static struct type *
10033 read_set_type (struct die_info *die, struct dwarf2_cu *cu)
10034 {
10035 struct type *domain_type, *set_type;
10036 struct attribute *attr;
10037
10038 domain_type = die_type (die, cu);
10039
10040 /* The die_type call above may have already set the type for this DIE. */
10041 set_type = get_die_type (die, cu);
10042 if (set_type)
10043 return set_type;
10044
10045 set_type = create_set_type (NULL, domain_type);
10046
10047 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
10048 if (attr)
10049 TYPE_LENGTH (set_type) = DW_UNSND (attr);
10050
10051 return set_die_type (die, set_type, cu);
10052 }
10053
10054 /* First cut: install each common block member as a global variable. */
10055
10056 static void
10057 read_common_block (struct die_info *die, struct dwarf2_cu *cu)
10058 {
10059 struct die_info *child_die;
10060 struct attribute *attr;
10061 struct symbol *sym;
10062 CORE_ADDR base = (CORE_ADDR) 0;
10063
10064 attr = dwarf2_attr (die, DW_AT_location, cu);
10065 if (attr)
10066 {
10067 /* Support the .debug_loc offsets. */
10068 if (attr_form_is_block (attr))
10069 {
10070 base = decode_locdesc (DW_BLOCK (attr), cu);
10071 }
10072 else if (attr_form_is_section_offset (attr))
10073 {
10074 dwarf2_complex_location_expr_complaint ();
10075 }
10076 else
10077 {
10078 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
10079 "common block member");
10080 }
10081 }
10082 if (die->child != NULL)
10083 {
10084 child_die = die->child;
10085 while (child_die && child_die->tag)
10086 {
10087 LONGEST offset;
10088
10089 sym = new_symbol (child_die, NULL, cu);
10090 if (sym != NULL
10091 && handle_data_member_location (child_die, cu, &offset))
10092 {
10093 SYMBOL_VALUE_ADDRESS (sym) = base + offset;
10094 add_symbol_to_list (sym, &global_symbols);
10095 }
10096 child_die = sibling_die (child_die);
10097 }
10098 }
10099 }
10100
10101 /* Create a type for a C++ namespace. */
10102
10103 static struct type *
10104 read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
10105 {
10106 struct objfile *objfile = cu->objfile;
10107 const char *previous_prefix, *name;
10108 int is_anonymous;
10109 struct type *type;
10110
10111 /* For extensions, reuse the type of the original namespace. */
10112 if (dwarf2_attr (die, DW_AT_extension, cu) != NULL)
10113 {
10114 struct die_info *ext_die;
10115 struct dwarf2_cu *ext_cu = cu;
10116
10117 ext_die = dwarf2_extension (die, &ext_cu);
10118 type = read_type_die (ext_die, ext_cu);
10119
10120 /* EXT_CU may not be the same as CU.
10121 Ensure TYPE is recorded in CU's type_hash table. */
10122 return set_die_type (die, type, cu);
10123 }
10124
10125 name = namespace_name (die, &is_anonymous, cu);
10126
10127 /* Now build the name of the current namespace. */
10128
10129 previous_prefix = determine_prefix (die, cu);
10130 if (previous_prefix[0] != '\0')
10131 name = typename_concat (&objfile->objfile_obstack,
10132 previous_prefix, name, 0, cu);
10133
10134 /* Create the type. */
10135 type = init_type (TYPE_CODE_NAMESPACE, 0, 0, NULL,
10136 objfile);
10137 TYPE_NAME (type) = (char *) name;
10138 TYPE_TAG_NAME (type) = TYPE_NAME (type);
10139
10140 return set_die_type (die, type, cu);
10141 }
10142
10143 /* Read a C++ namespace. */
10144
10145 static void
10146 read_namespace (struct die_info *die, struct dwarf2_cu *cu)
10147 {
10148 struct objfile *objfile = cu->objfile;
10149 int is_anonymous;
10150
10151 /* Add a symbol associated to this if we haven't seen the namespace
10152 before. Also, add a using directive if it's an anonymous
10153 namespace. */
10154
10155 if (dwarf2_attr (die, DW_AT_extension, cu) == NULL)
10156 {
10157 struct type *type;
10158
10159 type = read_type_die (die, cu);
10160 new_symbol (die, type, cu);
10161
10162 namespace_name (die, &is_anonymous, cu);
10163 if (is_anonymous)
10164 {
10165 const char *previous_prefix = determine_prefix (die, cu);
10166
10167 cp_add_using_directive (previous_prefix, TYPE_NAME (type), NULL,
10168 NULL, NULL, &objfile->objfile_obstack);
10169 }
10170 }
10171
10172 if (die->child != NULL)
10173 {
10174 struct die_info *child_die = die->child;
10175
10176 while (child_die && child_die->tag)
10177 {
10178 process_die (child_die, cu);
10179 child_die = sibling_die (child_die);
10180 }
10181 }
10182 }
10183
10184 /* Read a Fortran module as type. This DIE can be only a declaration used for
10185 imported module. Still we need that type as local Fortran "use ... only"
10186 declaration imports depend on the created type in determine_prefix. */
10187
10188 static struct type *
10189 read_module_type (struct die_info *die, struct dwarf2_cu *cu)
10190 {
10191 struct objfile *objfile = cu->objfile;
10192 char *module_name;
10193 struct type *type;
10194
10195 module_name = dwarf2_name (die, cu);
10196 if (!module_name)
10197 complaint (&symfile_complaints,
10198 _("DW_TAG_module has no name, offset 0x%x"),
10199 die->offset.sect_off);
10200 type = init_type (TYPE_CODE_MODULE, 0, 0, module_name, objfile);
10201
10202 /* determine_prefix uses TYPE_TAG_NAME. */
10203 TYPE_TAG_NAME (type) = TYPE_NAME (type);
10204
10205 return set_die_type (die, type, cu);
10206 }
10207
10208 /* Read a Fortran module. */
10209
10210 static void
10211 read_module (struct die_info *die, struct dwarf2_cu *cu)
10212 {
10213 struct die_info *child_die = die->child;
10214
10215 while (child_die && child_die->tag)
10216 {
10217 process_die (child_die, cu);
10218 child_die = sibling_die (child_die);
10219 }
10220 }
10221
10222 /* Return the name of the namespace represented by DIE. Set
10223 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous
10224 namespace. */
10225
10226 static const char *
10227 namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
10228 {
10229 struct die_info *current_die;
10230 const char *name = NULL;
10231
10232 /* Loop through the extensions until we find a name. */
10233
10234 for (current_die = die;
10235 current_die != NULL;
10236 current_die = dwarf2_extension (die, &cu))
10237 {
10238 name = dwarf2_name (current_die, cu);
10239 if (name != NULL)
10240 break;
10241 }
10242
10243 /* Is it an anonymous namespace? */
10244
10245 *is_anonymous = (name == NULL);
10246 if (*is_anonymous)
10247 name = CP_ANONYMOUS_NAMESPACE_STR;
10248
10249 return name;
10250 }
10251
10252 /* Extract all information from a DW_TAG_pointer_type DIE and add to
10253 the user defined type vector. */
10254
10255 static struct type *
10256 read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
10257 {
10258 struct gdbarch *gdbarch = get_objfile_arch (cu->objfile);
10259 struct comp_unit_head *cu_header = &cu->header;
10260 struct type *type;
10261 struct attribute *attr_byte_size;
10262 struct attribute *attr_address_class;
10263 int byte_size, addr_class;
10264 struct type *target_type;
10265
10266 target_type = die_type (die, cu);
10267
10268 /* The die_type call above may have already set the type for this DIE. */
10269 type = get_die_type (die, cu);
10270 if (type)
10271 return type;
10272
10273 type = lookup_pointer_type (target_type);
10274
10275 attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
10276 if (attr_byte_size)
10277 byte_size = DW_UNSND (attr_byte_size);
10278 else
10279 byte_size = cu_header->addr_size;
10280
10281 attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
10282 if (attr_address_class)
10283 addr_class = DW_UNSND (attr_address_class);
10284 else
10285 addr_class = DW_ADDR_none;
10286
10287 /* If the pointer size or address class is different than the
10288 default, create a type variant marked as such and set the
10289 length accordingly. */
10290 if (TYPE_LENGTH (type) != byte_size || addr_class != DW_ADDR_none)
10291 {
10292 if (gdbarch_address_class_type_flags_p (gdbarch))
10293 {
10294 int type_flags;
10295
10296 type_flags = gdbarch_address_class_type_flags
10297 (gdbarch, byte_size, addr_class);
10298 gdb_assert ((type_flags & ~TYPE_INSTANCE_FLAG_ADDRESS_CLASS_ALL)
10299 == 0);
10300 type = make_type_with_address_space (type, type_flags);
10301 }
10302 else if (TYPE_LENGTH (type) != byte_size)
10303 {
10304 complaint (&symfile_complaints,
10305 _("invalid pointer size %d"), byte_size);
10306 }
10307 else
10308 {
10309 /* Should we also complain about unhandled address classes? */
10310 }
10311 }
10312
10313 TYPE_LENGTH (type) = byte_size;
10314 return set_die_type (die, type, cu);
10315 }
10316
10317 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
10318 the user defined type vector. */
10319
10320 static struct type *
10321 read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
10322 {
10323 struct type *type;
10324 struct type *to_type;
10325 struct type *domain;
10326
10327 to_type = die_type (die, cu);
10328 domain = die_containing_type (die, cu);
10329
10330 /* The calls above may have already set the type for this DIE. */
10331 type = get_die_type (die, cu);
10332 if (type)
10333 return type;
10334
10335 if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_METHOD)
10336 type = lookup_methodptr_type (to_type);
10337 else
10338 type = lookup_memberptr_type (to_type, domain);
10339
10340 return set_die_type (die, type, cu);
10341 }
10342
10343 /* Extract all information from a DW_TAG_reference_type DIE and add to
10344 the user defined type vector. */
10345
10346 static struct type *
10347 read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu)
10348 {
10349 struct comp_unit_head *cu_header = &cu->header;
10350 struct type *type, *target_type;
10351 struct attribute *attr;
10352
10353 target_type = die_type (die, cu);
10354
10355 /* The die_type call above may have already set the type for this DIE. */
10356 type = get_die_type (die, cu);
10357 if (type)
10358 return type;
10359
10360 type = lookup_reference_type (target_type);
10361 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
10362 if (attr)
10363 {
10364 TYPE_LENGTH (type) = DW_UNSND (attr);
10365 }
10366 else
10367 {
10368 TYPE_LENGTH (type) = cu_header->addr_size;
10369 }
10370 return set_die_type (die, type, cu);
10371 }
10372
10373 static struct type *
10374 read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu)
10375 {
10376 struct type *base_type, *cv_type;
10377
10378 base_type = die_type (die, cu);
10379
10380 /* The die_type call above may have already set the type for this DIE. */
10381 cv_type = get_die_type (die, cu);
10382 if (cv_type)
10383 return cv_type;
10384
10385 /* In case the const qualifier is applied to an array type, the element type
10386 is so qualified, not the array type (section 6.7.3 of C99). */
10387 if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY)
10388 {
10389 struct type *el_type, *inner_array;
10390
10391 base_type = copy_type (base_type);
10392 inner_array = base_type;
10393
10394 while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
10395 {
10396 TYPE_TARGET_TYPE (inner_array) =
10397 copy_type (TYPE_TARGET_TYPE (inner_array));
10398 inner_array = TYPE_TARGET_TYPE (inner_array);
10399 }
10400
10401 el_type = TYPE_TARGET_TYPE (inner_array);
10402 TYPE_TARGET_TYPE (inner_array) =
10403 make_cv_type (1, TYPE_VOLATILE (el_type), el_type, NULL);
10404
10405 return set_die_type (die, base_type, cu);
10406 }
10407
10408 cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
10409 return set_die_type (die, cv_type, cu);
10410 }
10411
10412 static struct type *
10413 read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu)
10414 {
10415 struct type *base_type, *cv_type;
10416
10417 base_type = die_type (die, cu);
10418
10419 /* The die_type call above may have already set the type for this DIE. */
10420 cv_type = get_die_type (die, cu);
10421 if (cv_type)
10422 return cv_type;
10423
10424 cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
10425 return set_die_type (die, cv_type, cu);
10426 }
10427
10428 /* Extract all information from a DW_TAG_string_type DIE and add to
10429 the user defined type vector. It isn't really a user defined type,
10430 but it behaves like one, with other DIE's using an AT_user_def_type
10431 attribute to reference it. */
10432
10433 static struct type *
10434 read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
10435 {
10436 struct objfile *objfile = cu->objfile;
10437 struct gdbarch *gdbarch = get_objfile_arch (objfile);
10438 struct type *type, *range_type, *index_type, *char_type;
10439 struct attribute *attr;
10440 unsigned int length;
10441
10442 attr = dwarf2_attr (die, DW_AT_string_length, cu);
10443 if (attr)
10444 {
10445 length = DW_UNSND (attr);
10446 }
10447 else
10448 {
10449 /* Check for the DW_AT_byte_size attribute. */
10450 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
10451 if (attr)
10452 {
10453 length = DW_UNSND (attr);
10454 }
10455 else
10456 {
10457 length = 1;
10458 }
10459 }
10460
10461 index_type = objfile_type (objfile)->builtin_int;
10462 range_type = create_range_type (NULL, index_type, 1, length);
10463 char_type = language_string_char_type (cu->language_defn, gdbarch);
10464 type = create_string_type (NULL, char_type, range_type);
10465
10466 return set_die_type (die, type, cu);
10467 }
10468
10469 /* Handle DIES due to C code like:
10470
10471 struct foo
10472 {
10473 int (*funcp)(int a, long l);
10474 int b;
10475 };
10476
10477 ('funcp' generates a DW_TAG_subroutine_type DIE). */
10478
10479 static struct type *
10480 read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
10481 {
10482 struct objfile *objfile = cu->objfile;
10483 struct type *type; /* Type that this function returns. */
10484 struct type *ftype; /* Function that returns above type. */
10485 struct attribute *attr;
10486
10487 type = die_type (die, cu);
10488
10489 /* The die_type call above may have already set the type for this DIE. */
10490 ftype = get_die_type (die, cu);
10491 if (ftype)
10492 return ftype;
10493
10494 ftype = lookup_function_type (type);
10495
10496 /* All functions in C++, Pascal and Java have prototypes. */
10497 attr = dwarf2_attr (die, DW_AT_prototyped, cu);
10498 if ((attr && (DW_UNSND (attr) != 0))
10499 || cu->language == language_cplus
10500 || cu->language == language_java
10501 || cu->language == language_pascal)
10502 TYPE_PROTOTYPED (ftype) = 1;
10503 else if (producer_is_realview (cu->producer))
10504 /* RealView does not emit DW_AT_prototyped. We can not
10505 distinguish prototyped and unprototyped functions; default to
10506 prototyped, since that is more common in modern code (and
10507 RealView warns about unprototyped functions). */
10508 TYPE_PROTOTYPED (ftype) = 1;
10509
10510 /* Store the calling convention in the type if it's available in
10511 the subroutine die. Otherwise set the calling convention to
10512 the default value DW_CC_normal. */
10513 attr = dwarf2_attr (die, DW_AT_calling_convention, cu);
10514 if (attr)
10515 TYPE_CALLING_CONVENTION (ftype) = DW_UNSND (attr);
10516 else if (cu->producer && strstr (cu->producer, "IBM XL C for OpenCL"))
10517 TYPE_CALLING_CONVENTION (ftype) = DW_CC_GDB_IBM_OpenCL;
10518 else
10519 TYPE_CALLING_CONVENTION (ftype) = DW_CC_normal;
10520
10521 /* We need to add the subroutine type to the die immediately so
10522 we don't infinitely recurse when dealing with parameters
10523 declared as the same subroutine type. */
10524 set_die_type (die, ftype, cu);
10525
10526 if (die->child != NULL)
10527 {
10528 struct type *void_type = objfile_type (objfile)->builtin_void;
10529 struct die_info *child_die;
10530 int nparams, iparams;
10531
10532 /* Count the number of parameters.
10533 FIXME: GDB currently ignores vararg functions, but knows about
10534 vararg member functions. */
10535 nparams = 0;
10536 child_die = die->child;
10537 while (child_die && child_die->tag)
10538 {
10539 if (child_die->tag == DW_TAG_formal_parameter)
10540 nparams++;
10541 else if (child_die->tag == DW_TAG_unspecified_parameters)
10542 TYPE_VARARGS (ftype) = 1;
10543 child_die = sibling_die (child_die);
10544 }
10545
10546 /* Allocate storage for parameters and fill them in. */
10547 TYPE_NFIELDS (ftype) = nparams;
10548 TYPE_FIELDS (ftype) = (struct field *)
10549 TYPE_ZALLOC (ftype, nparams * sizeof (struct field));
10550
10551 /* TYPE_FIELD_TYPE must never be NULL. Pre-fill the array to ensure it
10552 even if we error out during the parameters reading below. */
10553 for (iparams = 0; iparams < nparams; iparams++)
10554 TYPE_FIELD_TYPE (ftype, iparams) = void_type;
10555
10556 iparams = 0;
10557 child_die = die->child;
10558 while (child_die && child_die->tag)
10559 {
10560 if (child_die->tag == DW_TAG_formal_parameter)
10561 {
10562 struct type *arg_type;
10563
10564 /* DWARF version 2 has no clean way to discern C++
10565 static and non-static member functions. G++ helps
10566 GDB by marking the first parameter for non-static
10567 member functions (which is the this pointer) as
10568 artificial. We pass this information to
10569 dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL.
10570
10571 DWARF version 3 added DW_AT_object_pointer, which GCC
10572 4.5 does not yet generate. */
10573 attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
10574 if (attr)
10575 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
10576 else
10577 {
10578 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
10579
10580 /* GCC/43521: In java, the formal parameter
10581 "this" is sometimes not marked with DW_AT_artificial. */
10582 if (cu->language == language_java)
10583 {
10584 const char *name = dwarf2_name (child_die, cu);
10585
10586 if (name && !strcmp (name, "this"))
10587 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 1;
10588 }
10589 }
10590 arg_type = die_type (child_die, cu);
10591
10592 /* RealView does not mark THIS as const, which the testsuite
10593 expects. GCC marks THIS as const in method definitions,
10594 but not in the class specifications (GCC PR 43053). */
10595 if (cu->language == language_cplus && !TYPE_CONST (arg_type)
10596 && TYPE_FIELD_ARTIFICIAL (ftype, iparams))
10597 {
10598 int is_this = 0;
10599 struct dwarf2_cu *arg_cu = cu;
10600 const char *name = dwarf2_name (child_die, cu);
10601
10602 attr = dwarf2_attr (die, DW_AT_object_pointer, cu);
10603 if (attr)
10604 {
10605 /* If the compiler emits this, use it. */
10606 if (follow_die_ref (die, attr, &arg_cu) == child_die)
10607 is_this = 1;
10608 }
10609 else if (name && strcmp (name, "this") == 0)
10610 /* Function definitions will have the argument names. */
10611 is_this = 1;
10612 else if (name == NULL && iparams == 0)
10613 /* Declarations may not have the names, so like
10614 elsewhere in GDB, assume an artificial first
10615 argument is "this". */
10616 is_this = 1;
10617
10618 if (is_this)
10619 arg_type = make_cv_type (1, TYPE_VOLATILE (arg_type),
10620 arg_type, 0);
10621 }
10622
10623 TYPE_FIELD_TYPE (ftype, iparams) = arg_type;
10624 iparams++;
10625 }
10626 child_die = sibling_die (child_die);
10627 }
10628 }
10629
10630 return ftype;
10631 }
10632
10633 static struct type *
10634 read_typedef (struct die_info *die, struct dwarf2_cu *cu)
10635 {
10636 struct objfile *objfile = cu->objfile;
10637 const char *name = NULL;
10638 struct type *this_type, *target_type;
10639
10640 name = dwarf2_full_name (NULL, die, cu);
10641 this_type = init_type (TYPE_CODE_TYPEDEF, 0,
10642 TYPE_FLAG_TARGET_STUB, NULL, objfile);
10643 TYPE_NAME (this_type) = (char *) name;
10644 set_die_type (die, this_type, cu);
10645 target_type = die_type (die, cu);
10646 if (target_type != this_type)
10647 TYPE_TARGET_TYPE (this_type) = target_type;
10648 else
10649 {
10650 /* Self-referential typedefs are, it seems, not allowed by the DWARF
10651 spec and cause infinite loops in GDB. */
10652 complaint (&symfile_complaints,
10653 _("Self-referential DW_TAG_typedef "
10654 "- DIE at 0x%x [in module %s]"),
10655 die->offset.sect_off, objfile->name);
10656 TYPE_TARGET_TYPE (this_type) = NULL;
10657 }
10658 return this_type;
10659 }
10660
10661 /* Find a representation of a given base type and install
10662 it in the TYPE field of the die. */
10663
10664 static struct type *
10665 read_base_type (struct die_info *die, struct dwarf2_cu *cu)
10666 {
10667 struct objfile *objfile = cu->objfile;
10668 struct type *type;
10669 struct attribute *attr;
10670 int encoding = 0, size = 0;
10671 char *name;
10672 enum type_code code = TYPE_CODE_INT;
10673 int type_flags = 0;
10674 struct type *target_type = NULL;
10675
10676 attr = dwarf2_attr (die, DW_AT_encoding, cu);
10677 if (attr)
10678 {
10679 encoding = DW_UNSND (attr);
10680 }
10681 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
10682 if (attr)
10683 {
10684 size = DW_UNSND (attr);
10685 }
10686 name = dwarf2_name (die, cu);
10687 if (!name)
10688 {
10689 complaint (&symfile_complaints,
10690 _("DW_AT_name missing from DW_TAG_base_type"));
10691 }
10692
10693 switch (encoding)
10694 {
10695 case DW_ATE_address:
10696 /* Turn DW_ATE_address into a void * pointer. */
10697 code = TYPE_CODE_PTR;
10698 type_flags |= TYPE_FLAG_UNSIGNED;
10699 target_type = init_type (TYPE_CODE_VOID, 1, 0, NULL, objfile);
10700 break;
10701 case DW_ATE_boolean:
10702 code = TYPE_CODE_BOOL;
10703 type_flags |= TYPE_FLAG_UNSIGNED;
10704 break;
10705 case DW_ATE_complex_float:
10706 code = TYPE_CODE_COMPLEX;
10707 target_type = init_type (TYPE_CODE_FLT, size / 2, 0, NULL, objfile);
10708 break;
10709 case DW_ATE_decimal_float:
10710 code = TYPE_CODE_DECFLOAT;
10711 break;
10712 case DW_ATE_float:
10713 code = TYPE_CODE_FLT;
10714 break;
10715 case DW_ATE_signed:
10716 break;
10717 case DW_ATE_unsigned:
10718 type_flags |= TYPE_FLAG_UNSIGNED;
10719 if (cu->language == language_fortran
10720 && name
10721 && strncmp (name, "character(", sizeof ("character(") - 1) == 0)
10722 code = TYPE_CODE_CHAR;
10723 break;
10724 case DW_ATE_signed_char:
10725 if (cu->language == language_ada || cu->language == language_m2
10726 || cu->language == language_pascal
10727 || cu->language == language_fortran)
10728 code = TYPE_CODE_CHAR;
10729 break;
10730 case DW_ATE_unsigned_char:
10731 if (cu->language == language_ada || cu->language == language_m2
10732 || cu->language == language_pascal
10733 || cu->language == language_fortran)
10734 code = TYPE_CODE_CHAR;
10735 type_flags |= TYPE_FLAG_UNSIGNED;
10736 break;
10737 case DW_ATE_UTF:
10738 /* We just treat this as an integer and then recognize the
10739 type by name elsewhere. */
10740 break;
10741
10742 default:
10743 complaint (&symfile_complaints, _("unsupported DW_AT_encoding: '%s'"),
10744 dwarf_type_encoding_name (encoding));
10745 break;
10746 }
10747
10748 type = init_type (code, size, type_flags, NULL, objfile);
10749 TYPE_NAME (type) = name;
10750 TYPE_TARGET_TYPE (type) = target_type;
10751
10752 if (name && strcmp (name, "char") == 0)
10753 TYPE_NOSIGN (type) = 1;
10754
10755 return set_die_type (die, type, cu);
10756 }
10757
10758 /* Read the given DW_AT_subrange DIE. */
10759
10760 static struct type *
10761 read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
10762 {
10763 struct type *base_type;
10764 struct type *range_type;
10765 struct attribute *attr;
10766 LONGEST low, high;
10767 int low_default_is_valid;
10768 char *name;
10769 LONGEST negative_mask;
10770
10771 base_type = die_type (die, cu);
10772 /* Preserve BASE_TYPE's original type, just set its LENGTH. */
10773 check_typedef (base_type);
10774
10775 /* The die_type call above may have already set the type for this DIE. */
10776 range_type = get_die_type (die, cu);
10777 if (range_type)
10778 return range_type;
10779
10780 /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
10781 omitting DW_AT_lower_bound. */
10782 switch (cu->language)
10783 {
10784 case language_c:
10785 case language_cplus:
10786 low = 0;
10787 low_default_is_valid = 1;
10788 break;
10789 case language_fortran:
10790 low = 1;
10791 low_default_is_valid = 1;
10792 break;
10793 case language_d:
10794 case language_java:
10795 case language_objc:
10796 low = 0;
10797 low_default_is_valid = (cu->header.version >= 4);
10798 break;
10799 case language_ada:
10800 case language_m2:
10801 case language_pascal:
10802 low = 1;
10803 low_default_is_valid = (cu->header.version >= 4);
10804 break;
10805 default:
10806 low = 0;
10807 low_default_is_valid = 0;
10808 break;
10809 }
10810
10811 /* FIXME: For variable sized arrays either of these could be
10812 a variable rather than a constant value. We'll allow it,
10813 but we don't know how to handle it. */
10814 attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
10815 if (attr)
10816 low = dwarf2_get_attr_constant_value (attr, low);
10817 else if (!low_default_is_valid)
10818 complaint (&symfile_complaints, _("Missing DW_AT_lower_bound "
10819 "- DIE at 0x%x [in module %s]"),
10820 die->offset.sect_off, cu->objfile->name);
10821
10822 attr = dwarf2_attr (die, DW_AT_upper_bound, cu);
10823 if (attr)
10824 {
10825 if (attr_form_is_block (attr) || is_ref_attr (attr))
10826 {
10827 /* GCC encodes arrays with unspecified or dynamic length
10828 with a DW_FORM_block1 attribute or a reference attribute.
10829 FIXME: GDB does not yet know how to handle dynamic
10830 arrays properly, treat them as arrays with unspecified
10831 length for now.
10832
10833 FIXME: jimb/2003-09-22: GDB does not really know
10834 how to handle arrays of unspecified length
10835 either; we just represent them as zero-length
10836 arrays. Choose an appropriate upper bound given
10837 the lower bound we've computed above. */
10838 high = low - 1;
10839 }
10840 else
10841 high = dwarf2_get_attr_constant_value (attr, 1);
10842 }
10843 else
10844 {
10845 attr = dwarf2_attr (die, DW_AT_count, cu);
10846 if (attr)
10847 {
10848 int count = dwarf2_get_attr_constant_value (attr, 1);
10849 high = low + count - 1;
10850 }
10851 else
10852 {
10853 /* Unspecified array length. */
10854 high = low - 1;
10855 }
10856 }
10857
10858 /* Dwarf-2 specifications explicitly allows to create subrange types
10859 without specifying a base type.
10860 In that case, the base type must be set to the type of
10861 the lower bound, upper bound or count, in that order, if any of these
10862 three attributes references an object that has a type.
10863 If no base type is found, the Dwarf-2 specifications say that
10864 a signed integer type of size equal to the size of an address should
10865 be used.
10866 For the following C code: `extern char gdb_int [];'
10867 GCC produces an empty range DIE.
10868 FIXME: muller/2010-05-28: Possible references to object for low bound,
10869 high bound or count are not yet handled by this code. */
10870 if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
10871 {
10872 struct objfile *objfile = cu->objfile;
10873 struct gdbarch *gdbarch = get_objfile_arch (objfile);
10874 int addr_size = gdbarch_addr_bit (gdbarch) /8;
10875 struct type *int_type = objfile_type (objfile)->builtin_int;
10876
10877 /* Test "int", "long int", and "long long int" objfile types,
10878 and select the first one having a size above or equal to the
10879 architecture address size. */
10880 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
10881 base_type = int_type;
10882 else
10883 {
10884 int_type = objfile_type (objfile)->builtin_long;
10885 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
10886 base_type = int_type;
10887 else
10888 {
10889 int_type = objfile_type (objfile)->builtin_long_long;
10890 if (int_type && TYPE_LENGTH (int_type) >= addr_size)
10891 base_type = int_type;
10892 }
10893 }
10894 }
10895
10896 negative_mask =
10897 (LONGEST) -1 << (TYPE_LENGTH (base_type) * TARGET_CHAR_BIT - 1);
10898 if (!TYPE_UNSIGNED (base_type) && (low & negative_mask))
10899 low |= negative_mask;
10900 if (!TYPE_UNSIGNED (base_type) && (high & negative_mask))
10901 high |= negative_mask;
10902
10903 range_type = create_range_type (NULL, base_type, low, high);
10904
10905 /* Mark arrays with dynamic length at least as an array of unspecified
10906 length. GDB could check the boundary but before it gets implemented at
10907 least allow accessing the array elements. */
10908 if (attr && attr_form_is_block (attr))
10909 TYPE_HIGH_BOUND_UNDEFINED (range_type) = 1;
10910
10911 /* Ada expects an empty array on no boundary attributes. */
10912 if (attr == NULL && cu->language != language_ada)
10913 TYPE_HIGH_BOUND_UNDEFINED (range_type) = 1;
10914
10915 name = dwarf2_name (die, cu);
10916 if (name)
10917 TYPE_NAME (range_type) = name;
10918
10919 attr = dwarf2_attr (die, DW_AT_byte_size, cu);
10920 if (attr)
10921 TYPE_LENGTH (range_type) = DW_UNSND (attr);
10922
10923 set_die_type (die, range_type, cu);
10924
10925 /* set_die_type should be already done. */
10926 set_descriptive_type (range_type, die, cu);
10927
10928 return range_type;
10929 }
10930
10931 static struct type *
10932 read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
10933 {
10934 struct type *type;
10935
10936 /* For now, we only support the C meaning of an unspecified type: void. */
10937
10938 type = init_type (TYPE_CODE_VOID, 0, 0, NULL, cu->objfile);
10939 TYPE_NAME (type) = dwarf2_name (die, cu);
10940
10941 return set_die_type (die, type, cu);
10942 }
10943
10944 /* Read a single die and all its descendents. Set the die's sibling
10945 field to NULL; set other fields in the die correctly, and set all
10946 of the descendents' fields correctly. Set *NEW_INFO_PTR to the
10947 location of the info_ptr after reading all of those dies. PARENT
10948 is the parent of the die in question. */
10949
10950 static struct die_info *
10951 read_die_and_children (const struct die_reader_specs *reader,
10952 gdb_byte *info_ptr,
10953 gdb_byte **new_info_ptr,
10954 struct die_info *parent)
10955 {
10956 struct die_info *die;
10957 gdb_byte *cur_ptr;
10958 int has_children;
10959
10960 cur_ptr = read_full_die (reader, &die, info_ptr, &has_children);
10961 if (die == NULL)
10962 {
10963 *new_info_ptr = cur_ptr;
10964 return NULL;
10965 }
10966 store_in_ref_table (die, reader->cu);
10967
10968 if (has_children)
10969 die->child = read_die_and_siblings (reader, cur_ptr, new_info_ptr, die);
10970 else
10971 {
10972 die->child = NULL;
10973 *new_info_ptr = cur_ptr;
10974 }
10975
10976 die->sibling = NULL;
10977 die->parent = parent;
10978 return die;
10979 }
10980
10981 /* Read a die, all of its descendents, and all of its siblings; set
10982 all of the fields of all of the dies correctly. Arguments are as
10983 in read_die_and_children. */
10984
10985 static struct die_info *
10986 read_die_and_siblings (const struct die_reader_specs *reader,
10987 gdb_byte *info_ptr,
10988 gdb_byte **new_info_ptr,
10989 struct die_info *parent)
10990 {
10991 struct die_info *first_die, *last_sibling;
10992 gdb_byte *cur_ptr;
10993
10994 cur_ptr = info_ptr;
10995 first_die = last_sibling = NULL;
10996
10997 while (1)
10998 {
10999 struct die_info *die
11000 = read_die_and_children (reader, cur_ptr, &cur_ptr, parent);
11001
11002 if (die == NULL)
11003 {
11004 *new_info_ptr = cur_ptr;
11005 return first_die;
11006 }
11007
11008 if (!first_die)
11009 first_die = die;
11010 else
11011 last_sibling->sibling = die;
11012
11013 last_sibling = die;
11014 }
11015 }
11016
11017 /* Read a die and all its attributes, leave space for NUM_EXTRA_ATTRS
11018 attributes.
11019 The caller is responsible for filling in the extra attributes
11020 and updating (*DIEP)->num_attrs.
11021 Set DIEP to point to a newly allocated die with its information,
11022 except for its child, sibling, and parent fields.
11023 Set HAS_CHILDREN to tell whether the die has children or not. */
11024
11025 static gdb_byte *
11026 read_full_die_1 (const struct die_reader_specs *reader,
11027 struct die_info **diep, gdb_byte *info_ptr,
11028 int *has_children, int num_extra_attrs)
11029 {
11030 unsigned int abbrev_number, bytes_read, i;
11031 sect_offset offset;
11032 struct abbrev_info *abbrev;
11033 struct die_info *die;
11034 struct dwarf2_cu *cu = reader->cu;
11035 bfd *abfd = reader->abfd;
11036
11037 offset.sect_off = info_ptr - reader->buffer;
11038 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
11039 info_ptr += bytes_read;
11040 if (!abbrev_number)
11041 {
11042 *diep = NULL;
11043 *has_children = 0;
11044 return info_ptr;
11045 }
11046
11047 abbrev = abbrev_table_lookup_abbrev (cu->abbrev_table, abbrev_number);
11048 if (!abbrev)
11049 error (_("Dwarf Error: could not find abbrev number %d [in module %s]"),
11050 abbrev_number,
11051 bfd_get_filename (abfd));
11052
11053 die = dwarf_alloc_die (cu, abbrev->num_attrs + num_extra_attrs);
11054 die->offset = offset;
11055 die->tag = abbrev->tag;
11056 die->abbrev = abbrev_number;
11057
11058 /* Make the result usable.
11059 The caller needs to update num_attrs after adding the extra
11060 attributes. */
11061 die->num_attrs = abbrev->num_attrs;
11062
11063 for (i = 0; i < abbrev->num_attrs; ++i)
11064 info_ptr = read_attribute (reader, &die->attrs[i], &abbrev->attrs[i],
11065 info_ptr);
11066
11067 *diep = die;
11068 *has_children = abbrev->has_children;
11069 return info_ptr;
11070 }
11071
11072 /* Read a die and all its attributes.
11073 Set DIEP to point to a newly allocated die with its information,
11074 except for its child, sibling, and parent fields.
11075 Set HAS_CHILDREN to tell whether the die has children or not. */
11076
11077 static gdb_byte *
11078 read_full_die (const struct die_reader_specs *reader,
11079 struct die_info **diep, gdb_byte *info_ptr,
11080 int *has_children)
11081 {
11082 return read_full_die_1 (reader, diep, info_ptr, has_children, 0);
11083 }
11084 \f
11085 /* Abbreviation tables.
11086
11087 In DWARF version 2, the description of the debugging information is
11088 stored in a separate .debug_abbrev section. Before we read any
11089 dies from a section we read in all abbreviations and install them
11090 in a hash table. */
11091
11092 /* Allocate space for a struct abbrev_info object in ABBREV_TABLE. */
11093
11094 static struct abbrev_info *
11095 abbrev_table_alloc_abbrev (struct abbrev_table *abbrev_table)
11096 {
11097 struct abbrev_info *abbrev;
11098
11099 abbrev = (struct abbrev_info *)
11100 obstack_alloc (&abbrev_table->abbrev_obstack, sizeof (struct abbrev_info));
11101 memset (abbrev, 0, sizeof (struct abbrev_info));
11102 return abbrev;
11103 }
11104
11105 /* Add an abbreviation to the table. */
11106
11107 static void
11108 abbrev_table_add_abbrev (struct abbrev_table *abbrev_table,
11109 unsigned int abbrev_number,
11110 struct abbrev_info *abbrev)
11111 {
11112 unsigned int hash_number;
11113
11114 hash_number = abbrev_number % ABBREV_HASH_SIZE;
11115 abbrev->next = abbrev_table->abbrevs[hash_number];
11116 abbrev_table->abbrevs[hash_number] = abbrev;
11117 }
11118
11119 /* Look up an abbrev in the table.
11120 Returns NULL if the abbrev is not found. */
11121
11122 static struct abbrev_info *
11123 abbrev_table_lookup_abbrev (const struct abbrev_table *abbrev_table,
11124 unsigned int abbrev_number)
11125 {
11126 unsigned int hash_number;
11127 struct abbrev_info *abbrev;
11128
11129 hash_number = abbrev_number % ABBREV_HASH_SIZE;
11130 abbrev = abbrev_table->abbrevs[hash_number];
11131
11132 while (abbrev)
11133 {
11134 if (abbrev->number == abbrev_number)
11135 return abbrev;
11136 abbrev = abbrev->next;
11137 }
11138 return NULL;
11139 }
11140
11141 /* Read in an abbrev table. */
11142
11143 static struct abbrev_table *
11144 abbrev_table_read_table (struct dwarf2_section_info *section,
11145 sect_offset offset)
11146 {
11147 struct objfile *objfile = dwarf2_per_objfile->objfile;
11148 bfd *abfd = section->asection->owner;
11149 struct abbrev_table *abbrev_table;
11150 gdb_byte *abbrev_ptr;
11151 struct abbrev_info *cur_abbrev;
11152 unsigned int abbrev_number, bytes_read, abbrev_name;
11153 unsigned int abbrev_form;
11154 struct attr_abbrev *cur_attrs;
11155 unsigned int allocated_attrs;
11156
11157 abbrev_table = XMALLOC (struct abbrev_table);
11158 obstack_init (&abbrev_table->abbrev_obstack);
11159 abbrev_table->abbrevs = obstack_alloc (&abbrev_table->abbrev_obstack,
11160 (ABBREV_HASH_SIZE
11161 * sizeof (struct abbrev_info *)));
11162 memset (abbrev_table->abbrevs, 0,
11163 ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
11164
11165 dwarf2_read_section (objfile, section);
11166 abbrev_ptr = section->buffer + offset.sect_off;
11167 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
11168 abbrev_ptr += bytes_read;
11169
11170 allocated_attrs = ATTR_ALLOC_CHUNK;
11171 cur_attrs = xmalloc (allocated_attrs * sizeof (struct attr_abbrev));
11172
11173 /* Loop until we reach an abbrev number of 0. */
11174 while (abbrev_number)
11175 {
11176 cur_abbrev = abbrev_table_alloc_abbrev (abbrev_table);
11177
11178 /* read in abbrev header */
11179 cur_abbrev->number = abbrev_number;
11180 cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
11181 abbrev_ptr += bytes_read;
11182 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
11183 abbrev_ptr += 1;
11184
11185 /* now read in declarations */
11186 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
11187 abbrev_ptr += bytes_read;
11188 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
11189 abbrev_ptr += bytes_read;
11190 while (abbrev_name)
11191 {
11192 if (cur_abbrev->num_attrs == allocated_attrs)
11193 {
11194 allocated_attrs += ATTR_ALLOC_CHUNK;
11195 cur_attrs
11196 = xrealloc (cur_attrs, (allocated_attrs
11197 * sizeof (struct attr_abbrev)));
11198 }
11199
11200 cur_attrs[cur_abbrev->num_attrs].name = abbrev_name;
11201 cur_attrs[cur_abbrev->num_attrs++].form = abbrev_form;
11202 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
11203 abbrev_ptr += bytes_read;
11204 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
11205 abbrev_ptr += bytes_read;
11206 }
11207
11208 cur_abbrev->attrs = obstack_alloc (&abbrev_table->abbrev_obstack,
11209 (cur_abbrev->num_attrs
11210 * sizeof (struct attr_abbrev)));
11211 memcpy (cur_abbrev->attrs, cur_attrs,
11212 cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
11213
11214 abbrev_table_add_abbrev (abbrev_table, abbrev_number, cur_abbrev);
11215
11216 /* Get next abbreviation.
11217 Under Irix6 the abbreviations for a compilation unit are not
11218 always properly terminated with an abbrev number of 0.
11219 Exit loop if we encounter an abbreviation which we have
11220 already read (which means we are about to read the abbreviations
11221 for the next compile unit) or if the end of the abbreviation
11222 table is reached. */
11223 if ((unsigned int) (abbrev_ptr - section->buffer) >= section->size)
11224 break;
11225 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
11226 abbrev_ptr += bytes_read;
11227 if (abbrev_table_lookup_abbrev (abbrev_table, abbrev_number) != NULL)
11228 break;
11229 }
11230
11231 xfree (cur_attrs);
11232 return abbrev_table;
11233 }
11234
11235 /* Free the resources held by ABBREV_TABLE. */
11236
11237 static void
11238 abbrev_table_free (struct abbrev_table *abbrev_table)
11239 {
11240 obstack_free (&abbrev_table->abbrev_obstack, NULL);
11241 xfree (abbrev_table);
11242 }
11243
11244 /* Read the abbrev table for CU from ABBREV_SECTION. */
11245
11246 static void
11247 dwarf2_read_abbrevs (struct dwarf2_cu *cu,
11248 struct dwarf2_section_info *abbrev_section)
11249 {
11250 cu->abbrev_table =
11251 abbrev_table_read_table (abbrev_section, cu->header.abbrev_offset);
11252 }
11253
11254 /* Release the memory used by the abbrev table for a compilation unit. */
11255
11256 static void
11257 dwarf2_free_abbrev_table (void *ptr_to_cu)
11258 {
11259 struct dwarf2_cu *cu = ptr_to_cu;
11260
11261 abbrev_table_free (cu->abbrev_table);
11262 /* Set this to NULL so that we SEGV if we try to read it later,
11263 and also because free_comp_unit verifies this is NULL. */
11264 cu->abbrev_table = NULL;
11265 }
11266 \f
11267 /* Returns nonzero if TAG represents a type that we might generate a partial
11268 symbol for. */
11269
11270 static int
11271 is_type_tag_for_partial (int tag)
11272 {
11273 switch (tag)
11274 {
11275 #if 0
11276 /* Some types that would be reasonable to generate partial symbols for,
11277 that we don't at present. */
11278 case DW_TAG_array_type:
11279 case DW_TAG_file_type:
11280 case DW_TAG_ptr_to_member_type:
11281 case DW_TAG_set_type:
11282 case DW_TAG_string_type:
11283 case DW_TAG_subroutine_type:
11284 #endif
11285 case DW_TAG_base_type:
11286 case DW_TAG_class_type:
11287 case DW_TAG_interface_type:
11288 case DW_TAG_enumeration_type:
11289 case DW_TAG_structure_type:
11290 case DW_TAG_subrange_type:
11291 case DW_TAG_typedef:
11292 case DW_TAG_union_type:
11293 return 1;
11294 default:
11295 return 0;
11296 }
11297 }
11298
11299 /* Load all DIEs that are interesting for partial symbols into memory. */
11300
11301 static struct partial_die_info *
11302 load_partial_dies (const struct die_reader_specs *reader,
11303 gdb_byte *info_ptr, int building_psymtab)
11304 {
11305 struct dwarf2_cu *cu = reader->cu;
11306 struct objfile *objfile = cu->objfile;
11307 struct partial_die_info *part_die;
11308 struct partial_die_info *parent_die, *last_die, *first_die = NULL;
11309 struct abbrev_info *abbrev;
11310 unsigned int bytes_read;
11311 unsigned int load_all = 0;
11312 int nesting_level = 1;
11313
11314 parent_die = NULL;
11315 last_die = NULL;
11316
11317 gdb_assert (cu->per_cu != NULL);
11318 if (cu->per_cu->load_all_dies)
11319 load_all = 1;
11320
11321 cu->partial_dies
11322 = htab_create_alloc_ex (cu->header.length / 12,
11323 partial_die_hash,
11324 partial_die_eq,
11325 NULL,
11326 &cu->comp_unit_obstack,
11327 hashtab_obstack_allocate,
11328 dummy_obstack_deallocate);
11329
11330 part_die = obstack_alloc (&cu->comp_unit_obstack,
11331 sizeof (struct partial_die_info));
11332
11333 while (1)
11334 {
11335 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu);
11336
11337 /* A NULL abbrev means the end of a series of children. */
11338 if (abbrev == NULL)
11339 {
11340 if (--nesting_level == 0)
11341 {
11342 /* PART_DIE was probably the last thing allocated on the
11343 comp_unit_obstack, so we could call obstack_free
11344 here. We don't do that because the waste is small,
11345 and will be cleaned up when we're done with this
11346 compilation unit. This way, we're also more robust
11347 against other users of the comp_unit_obstack. */
11348 return first_die;
11349 }
11350 info_ptr += bytes_read;
11351 last_die = parent_die;
11352 parent_die = parent_die->die_parent;
11353 continue;
11354 }
11355
11356 /* Check for template arguments. We never save these; if
11357 they're seen, we just mark the parent, and go on our way. */
11358 if (parent_die != NULL
11359 && cu->language == language_cplus
11360 && (abbrev->tag == DW_TAG_template_type_param
11361 || abbrev->tag == DW_TAG_template_value_param))
11362 {
11363 parent_die->has_template_arguments = 1;
11364
11365 if (!load_all)
11366 {
11367 /* We don't need a partial DIE for the template argument. */
11368 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
11369 continue;
11370 }
11371 }
11372
11373 /* We only recurse into c++ subprograms looking for template arguments.
11374 Skip their other children. */
11375 if (!load_all
11376 && cu->language == language_cplus
11377 && parent_die != NULL
11378 && parent_die->tag == DW_TAG_subprogram)
11379 {
11380 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
11381 continue;
11382 }
11383
11384 /* Check whether this DIE is interesting enough to save. Normally
11385 we would not be interested in members here, but there may be
11386 later variables referencing them via DW_AT_specification (for
11387 static members). */
11388 if (!load_all
11389 && !is_type_tag_for_partial (abbrev->tag)
11390 && abbrev->tag != DW_TAG_constant
11391 && abbrev->tag != DW_TAG_enumerator
11392 && abbrev->tag != DW_TAG_subprogram
11393 && abbrev->tag != DW_TAG_lexical_block
11394 && abbrev->tag != DW_TAG_variable
11395 && abbrev->tag != DW_TAG_namespace
11396 && abbrev->tag != DW_TAG_module
11397 && abbrev->tag != DW_TAG_member
11398 && abbrev->tag != DW_TAG_imported_unit)
11399 {
11400 /* Otherwise we skip to the next sibling, if any. */
11401 info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev);
11402 continue;
11403 }
11404
11405 info_ptr = read_partial_die (reader, part_die, abbrev, bytes_read,
11406 info_ptr);
11407
11408 /* This two-pass algorithm for processing partial symbols has a
11409 high cost in cache pressure. Thus, handle some simple cases
11410 here which cover the majority of C partial symbols. DIEs
11411 which neither have specification tags in them, nor could have
11412 specification tags elsewhere pointing at them, can simply be
11413 processed and discarded.
11414
11415 This segment is also optional; scan_partial_symbols and
11416 add_partial_symbol will handle these DIEs if we chain
11417 them in normally. When compilers which do not emit large
11418 quantities of duplicate debug information are more common,
11419 this code can probably be removed. */
11420
11421 /* Any complete simple types at the top level (pretty much all
11422 of them, for a language without namespaces), can be processed
11423 directly. */
11424 if (parent_die == NULL
11425 && part_die->has_specification == 0
11426 && part_die->is_declaration == 0
11427 && ((part_die->tag == DW_TAG_typedef && !part_die->has_children)
11428 || part_die->tag == DW_TAG_base_type
11429 || part_die->tag == DW_TAG_subrange_type))
11430 {
11431 if (building_psymtab && part_die->name != NULL)
11432 add_psymbol_to_list (part_die->name, strlen (part_die->name), 0,
11433 VAR_DOMAIN, LOC_TYPEDEF,
11434 &objfile->static_psymbols,
11435 0, (CORE_ADDR) 0, cu->language, objfile);
11436 info_ptr = locate_pdi_sibling (reader, part_die, info_ptr);
11437 continue;
11438 }
11439
11440 /* The exception for DW_TAG_typedef with has_children above is
11441 a workaround of GCC PR debug/47510. In the case of this complaint
11442 type_name_no_tag_or_error will error on such types later.
11443
11444 GDB skipped children of DW_TAG_typedef by the shortcut above and then
11445 it could not find the child DIEs referenced later, this is checked
11446 above. In correct DWARF DW_TAG_typedef should have no children. */
11447
11448 if (part_die->tag == DW_TAG_typedef && part_die->has_children)
11449 complaint (&symfile_complaints,
11450 _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
11451 "- DIE at 0x%x [in module %s]"),
11452 part_die->offset.sect_off, objfile->name);
11453
11454 /* If we're at the second level, and we're an enumerator, and
11455 our parent has no specification (meaning possibly lives in a
11456 namespace elsewhere), then we can add the partial symbol now
11457 instead of queueing it. */
11458 if (part_die->tag == DW_TAG_enumerator
11459 && parent_die != NULL
11460 && parent_die->die_parent == NULL
11461 && parent_die->tag == DW_TAG_enumeration_type
11462 && parent_die->has_specification == 0)
11463 {
11464 if (part_die->name == NULL)
11465 complaint (&symfile_complaints,
11466 _("malformed enumerator DIE ignored"));
11467 else if (building_psymtab)
11468 add_psymbol_to_list (part_die->name, strlen (part_die->name), 0,
11469 VAR_DOMAIN, LOC_CONST,
11470 (cu->language == language_cplus
11471 || cu->language == language_java)
11472 ? &objfile->global_psymbols
11473 : &objfile->static_psymbols,
11474 0, (CORE_ADDR) 0, cu->language, objfile);
11475
11476 info_ptr = locate_pdi_sibling (reader, part_die, info_ptr);
11477 continue;
11478 }
11479
11480 /* We'll save this DIE so link it in. */
11481 part_die->die_parent = parent_die;
11482 part_die->die_sibling = NULL;
11483 part_die->die_child = NULL;
11484
11485 if (last_die && last_die == parent_die)
11486 last_die->die_child = part_die;
11487 else if (last_die)
11488 last_die->die_sibling = part_die;
11489
11490 last_die = part_die;
11491
11492 if (first_die == NULL)
11493 first_die = part_die;
11494
11495 /* Maybe add the DIE to the hash table. Not all DIEs that we
11496 find interesting need to be in the hash table, because we
11497 also have the parent/sibling/child chains; only those that we
11498 might refer to by offset later during partial symbol reading.
11499
11500 For now this means things that might have be the target of a
11501 DW_AT_specification, DW_AT_abstract_origin, or
11502 DW_AT_extension. DW_AT_extension will refer only to
11503 namespaces; DW_AT_abstract_origin refers to functions (and
11504 many things under the function DIE, but we do not recurse
11505 into function DIEs during partial symbol reading) and
11506 possibly variables as well; DW_AT_specification refers to
11507 declarations. Declarations ought to have the DW_AT_declaration
11508 flag. It happens that GCC forgets to put it in sometimes, but
11509 only for functions, not for types.
11510
11511 Adding more things than necessary to the hash table is harmless
11512 except for the performance cost. Adding too few will result in
11513 wasted time in find_partial_die, when we reread the compilation
11514 unit with load_all_dies set. */
11515
11516 if (load_all
11517 || abbrev->tag == DW_TAG_constant
11518 || abbrev->tag == DW_TAG_subprogram
11519 || abbrev->tag == DW_TAG_variable
11520 || abbrev->tag == DW_TAG_namespace
11521 || part_die->is_declaration)
11522 {
11523 void **slot;
11524
11525 slot = htab_find_slot_with_hash (cu->partial_dies, part_die,
11526 part_die->offset.sect_off, INSERT);
11527 *slot = part_die;
11528 }
11529
11530 part_die = obstack_alloc (&cu->comp_unit_obstack,
11531 sizeof (struct partial_die_info));
11532
11533 /* For some DIEs we want to follow their children (if any). For C
11534 we have no reason to follow the children of structures; for other
11535 languages we have to, so that we can get at method physnames
11536 to infer fully qualified class names, for DW_AT_specification,
11537 and for C++ template arguments. For C++, we also look one level
11538 inside functions to find template arguments (if the name of the
11539 function does not already contain the template arguments).
11540
11541 For Ada, we need to scan the children of subprograms and lexical
11542 blocks as well because Ada allows the definition of nested
11543 entities that could be interesting for the debugger, such as
11544 nested subprograms for instance. */
11545 if (last_die->has_children
11546 && (load_all
11547 || last_die->tag == DW_TAG_namespace
11548 || last_die->tag == DW_TAG_module
11549 || last_die->tag == DW_TAG_enumeration_type
11550 || (cu->language == language_cplus
11551 && last_die->tag == DW_TAG_subprogram
11552 && (last_die->name == NULL
11553 || strchr (last_die->name, '<') == NULL))
11554 || (cu->language != language_c
11555 && (last_die->tag == DW_TAG_class_type
11556 || last_die->tag == DW_TAG_interface_type
11557 || last_die->tag == DW_TAG_structure_type
11558 || last_die->tag == DW_TAG_union_type))
11559 || (cu->language == language_ada
11560 && (last_die->tag == DW_TAG_subprogram
11561 || last_die->tag == DW_TAG_lexical_block))))
11562 {
11563 nesting_level++;
11564 parent_die = last_die;
11565 continue;
11566 }
11567
11568 /* Otherwise we skip to the next sibling, if any. */
11569 info_ptr = locate_pdi_sibling (reader, last_die, info_ptr);
11570
11571 /* Back to the top, do it again. */
11572 }
11573 }
11574
11575 /* Read a minimal amount of information into the minimal die structure. */
11576
11577 static gdb_byte *
11578 read_partial_die (const struct die_reader_specs *reader,
11579 struct partial_die_info *part_die,
11580 struct abbrev_info *abbrev, unsigned int abbrev_len,
11581 gdb_byte *info_ptr)
11582 {
11583 struct dwarf2_cu *cu = reader->cu;
11584 struct objfile *objfile = cu->objfile;
11585 gdb_byte *buffer = reader->buffer;
11586 unsigned int i;
11587 struct attribute attr;
11588 int has_low_pc_attr = 0;
11589 int has_high_pc_attr = 0;
11590 int high_pc_relative = 0;
11591
11592 memset (part_die, 0, sizeof (struct partial_die_info));
11593
11594 part_die->offset.sect_off = info_ptr - buffer;
11595
11596 info_ptr += abbrev_len;
11597
11598 if (abbrev == NULL)
11599 return info_ptr;
11600
11601 part_die->tag = abbrev->tag;
11602 part_die->has_children = abbrev->has_children;
11603
11604 for (i = 0; i < abbrev->num_attrs; ++i)
11605 {
11606 info_ptr = read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
11607
11608 /* Store the data if it is of an attribute we want to keep in a
11609 partial symbol table. */
11610 switch (attr.name)
11611 {
11612 case DW_AT_name:
11613 switch (part_die->tag)
11614 {
11615 case DW_TAG_compile_unit:
11616 case DW_TAG_partial_unit:
11617 case DW_TAG_type_unit:
11618 /* Compilation units have a DW_AT_name that is a filename, not
11619 a source language identifier. */
11620 case DW_TAG_enumeration_type:
11621 case DW_TAG_enumerator:
11622 /* These tags always have simple identifiers already; no need
11623 to canonicalize them. */
11624 part_die->name = DW_STRING (&attr);
11625 break;
11626 default:
11627 part_die->name
11628 = dwarf2_canonicalize_name (DW_STRING (&attr), cu,
11629 &objfile->objfile_obstack);
11630 break;
11631 }
11632 break;
11633 case DW_AT_linkage_name:
11634 case DW_AT_MIPS_linkage_name:
11635 /* Note that both forms of linkage name might appear. We
11636 assume they will be the same, and we only store the last
11637 one we see. */
11638 if (cu->language == language_ada)
11639 part_die->name = DW_STRING (&attr);
11640 part_die->linkage_name = DW_STRING (&attr);
11641 break;
11642 case DW_AT_low_pc:
11643 has_low_pc_attr = 1;
11644 part_die->lowpc = DW_ADDR (&attr);
11645 break;
11646 case DW_AT_high_pc:
11647 has_high_pc_attr = 1;
11648 if (attr.form == DW_FORM_addr
11649 || attr.form == DW_FORM_GNU_addr_index)
11650 part_die->highpc = DW_ADDR (&attr);
11651 else
11652 {
11653 high_pc_relative = 1;
11654 part_die->highpc = DW_UNSND (&attr);
11655 }
11656 break;
11657 case DW_AT_location:
11658 /* Support the .debug_loc offsets. */
11659 if (attr_form_is_block (&attr))
11660 {
11661 part_die->d.locdesc = DW_BLOCK (&attr);
11662 }
11663 else if (attr_form_is_section_offset (&attr))
11664 {
11665 dwarf2_complex_location_expr_complaint ();
11666 }
11667 else
11668 {
11669 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
11670 "partial symbol information");
11671 }
11672 break;
11673 case DW_AT_external:
11674 part_die->is_external = DW_UNSND (&attr);
11675 break;
11676 case DW_AT_declaration:
11677 part_die->is_declaration = DW_UNSND (&attr);
11678 break;
11679 case DW_AT_type:
11680 part_die->has_type = 1;
11681 break;
11682 case DW_AT_abstract_origin:
11683 case DW_AT_specification:
11684 case DW_AT_extension:
11685 part_die->has_specification = 1;
11686 part_die->spec_offset = dwarf2_get_ref_die_offset (&attr);
11687 break;
11688 case DW_AT_sibling:
11689 /* Ignore absolute siblings, they might point outside of
11690 the current compile unit. */
11691 if (attr.form == DW_FORM_ref_addr)
11692 complaint (&symfile_complaints,
11693 _("ignoring absolute DW_AT_sibling"));
11694 else
11695 part_die->sibling = buffer + dwarf2_get_ref_die_offset (&attr).sect_off;
11696 break;
11697 case DW_AT_byte_size:
11698 part_die->has_byte_size = 1;
11699 break;
11700 case DW_AT_calling_convention:
11701 /* DWARF doesn't provide a way to identify a program's source-level
11702 entry point. DW_AT_calling_convention attributes are only meant
11703 to describe functions' calling conventions.
11704
11705 However, because it's a necessary piece of information in
11706 Fortran, and because DW_CC_program is the only piece of debugging
11707 information whose definition refers to a 'main program' at all,
11708 several compilers have begun marking Fortran main programs with
11709 DW_CC_program --- even when those functions use the standard
11710 calling conventions.
11711
11712 So until DWARF specifies a way to provide this information and
11713 compilers pick up the new representation, we'll support this
11714 practice. */
11715 if (DW_UNSND (&attr) == DW_CC_program
11716 && cu->language == language_fortran)
11717 {
11718 set_main_name (part_die->name);
11719
11720 /* As this DIE has a static linkage the name would be difficult
11721 to look up later. */
11722 language_of_main = language_fortran;
11723 }
11724 break;
11725 case DW_AT_inline:
11726 if (DW_UNSND (&attr) == DW_INL_inlined
11727 || DW_UNSND (&attr) == DW_INL_declared_inlined)
11728 part_die->may_be_inlined = 1;
11729 break;
11730
11731 case DW_AT_import:
11732 if (part_die->tag == DW_TAG_imported_unit)
11733 part_die->d.offset = dwarf2_get_ref_die_offset (&attr);
11734 break;
11735
11736 default:
11737 break;
11738 }
11739 }
11740
11741 if (high_pc_relative)
11742 part_die->highpc += part_die->lowpc;
11743
11744 if (has_low_pc_attr && has_high_pc_attr)
11745 {
11746 /* When using the GNU linker, .gnu.linkonce. sections are used to
11747 eliminate duplicate copies of functions and vtables and such.
11748 The linker will arbitrarily choose one and discard the others.
11749 The AT_*_pc values for such functions refer to local labels in
11750 these sections. If the section from that file was discarded, the
11751 labels are not in the output, so the relocs get a value of 0.
11752 If this is a discarded function, mark the pc bounds as invalid,
11753 so that GDB will ignore it. */
11754 if (part_die->lowpc == 0 && !dwarf2_per_objfile->has_section_at_zero)
11755 {
11756 struct gdbarch *gdbarch = get_objfile_arch (objfile);
11757
11758 complaint (&symfile_complaints,
11759 _("DW_AT_low_pc %s is zero "
11760 "for DIE at 0x%x [in module %s]"),
11761 paddress (gdbarch, part_die->lowpc),
11762 part_die->offset.sect_off, objfile->name);
11763 }
11764 /* dwarf2_get_pc_bounds has also the strict low < high requirement. */
11765 else if (part_die->lowpc >= part_die->highpc)
11766 {
11767 struct gdbarch *gdbarch = get_objfile_arch (objfile);
11768
11769 complaint (&symfile_complaints,
11770 _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
11771 "for DIE at 0x%x [in module %s]"),
11772 paddress (gdbarch, part_die->lowpc),
11773 paddress (gdbarch, part_die->highpc),
11774 part_die->offset.sect_off, objfile->name);
11775 }
11776 else
11777 part_die->has_pc_info = 1;
11778 }
11779
11780 return info_ptr;
11781 }
11782
11783 /* Find a cached partial DIE at OFFSET in CU. */
11784
11785 static struct partial_die_info *
11786 find_partial_die_in_comp_unit (sect_offset offset, struct dwarf2_cu *cu)
11787 {
11788 struct partial_die_info *lookup_die = NULL;
11789 struct partial_die_info part_die;
11790
11791 part_die.offset = offset;
11792 lookup_die = htab_find_with_hash (cu->partial_dies, &part_die,
11793 offset.sect_off);
11794
11795 return lookup_die;
11796 }
11797
11798 /* Find a partial DIE at OFFSET, which may or may not be in CU,
11799 except in the case of .debug_types DIEs which do not reference
11800 outside their CU (they do however referencing other types via
11801 DW_FORM_ref_sig8). */
11802
11803 static struct partial_die_info *
11804 find_partial_die (sect_offset offset, struct dwarf2_cu *cu)
11805 {
11806 struct objfile *objfile = cu->objfile;
11807 struct dwarf2_per_cu_data *per_cu = NULL;
11808 struct partial_die_info *pd = NULL;
11809
11810 if (offset_in_cu_p (&cu->header, offset))
11811 {
11812 pd = find_partial_die_in_comp_unit (offset, cu);
11813 if (pd != NULL)
11814 return pd;
11815 /* We missed recording what we needed.
11816 Load all dies and try again. */
11817 per_cu = cu->per_cu;
11818 }
11819 else
11820 {
11821 /* TUs don't reference other CUs/TUs (except via type signatures). */
11822 if (cu->per_cu->is_debug_types)
11823 {
11824 error (_("Dwarf Error: Type Unit at offset 0x%lx contains"
11825 " external reference to offset 0x%lx [in module %s].\n"),
11826 (long) cu->header.offset.sect_off, (long) offset.sect_off,
11827 bfd_get_filename (objfile->obfd));
11828 }
11829 per_cu = dwarf2_find_containing_comp_unit (offset, objfile);
11830
11831 if (per_cu->cu == NULL || per_cu->cu->partial_dies == NULL)
11832 load_partial_comp_unit (per_cu);
11833
11834 per_cu->cu->last_used = 0;
11835 pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
11836 }
11837
11838 /* If we didn't find it, and not all dies have been loaded,
11839 load them all and try again. */
11840
11841 if (pd == NULL && per_cu->load_all_dies == 0)
11842 {
11843 per_cu->load_all_dies = 1;
11844
11845 /* This is nasty. When we reread the DIEs, somewhere up the call chain
11846 THIS_CU->cu may already be in use. So we can't just free it and
11847 replace its DIEs with the ones we read in. Instead, we leave those
11848 DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
11849 and clobber THIS_CU->cu->partial_dies with the hash table for the new
11850 set. */
11851 load_partial_comp_unit (per_cu);
11852
11853 pd = find_partial_die_in_comp_unit (offset, per_cu->cu);
11854 }
11855
11856 if (pd == NULL)
11857 internal_error (__FILE__, __LINE__,
11858 _("could not find partial DIE 0x%x "
11859 "in cache [from module %s]\n"),
11860 offset.sect_off, bfd_get_filename (objfile->obfd));
11861 return pd;
11862 }
11863
11864 /* See if we can figure out if the class lives in a namespace. We do
11865 this by looking for a member function; its demangled name will
11866 contain namespace info, if there is any. */
11867
11868 static void
11869 guess_partial_die_structure_name (struct partial_die_info *struct_pdi,
11870 struct dwarf2_cu *cu)
11871 {
11872 /* NOTE: carlton/2003-10-07: Getting the info this way changes
11873 what template types look like, because the demangler
11874 frequently doesn't give the same name as the debug info. We
11875 could fix this by only using the demangled name to get the
11876 prefix (but see comment in read_structure_type). */
11877
11878 struct partial_die_info *real_pdi;
11879 struct partial_die_info *child_pdi;
11880
11881 /* If this DIE (this DIE's specification, if any) has a parent, then
11882 we should not do this. We'll prepend the parent's fully qualified
11883 name when we create the partial symbol. */
11884
11885 real_pdi = struct_pdi;
11886 while (real_pdi->has_specification)
11887 real_pdi = find_partial_die (real_pdi->spec_offset, cu);
11888
11889 if (real_pdi->die_parent != NULL)
11890 return;
11891
11892 for (child_pdi = struct_pdi->die_child;
11893 child_pdi != NULL;
11894 child_pdi = child_pdi->die_sibling)
11895 {
11896 if (child_pdi->tag == DW_TAG_subprogram
11897 && child_pdi->linkage_name != NULL)
11898 {
11899 char *actual_class_name
11900 = language_class_name_from_physname (cu->language_defn,
11901 child_pdi->linkage_name);
11902 if (actual_class_name != NULL)
11903 {
11904 struct_pdi->name
11905 = obsavestring (actual_class_name,
11906 strlen (actual_class_name),
11907 &cu->objfile->objfile_obstack);
11908 xfree (actual_class_name);
11909 }
11910 break;
11911 }
11912 }
11913 }
11914
11915 /* Adjust PART_DIE before generating a symbol for it. This function
11916 may set the is_external flag or change the DIE's name. */
11917
11918 static void
11919 fixup_partial_die (struct partial_die_info *part_die,
11920 struct dwarf2_cu *cu)
11921 {
11922 /* Once we've fixed up a die, there's no point in doing so again.
11923 This also avoids a memory leak if we were to call
11924 guess_partial_die_structure_name multiple times. */
11925 if (part_die->fixup_called)
11926 return;
11927
11928 /* If we found a reference attribute and the DIE has no name, try
11929 to find a name in the referred to DIE. */
11930
11931 if (part_die->name == NULL && part_die->has_specification)
11932 {
11933 struct partial_die_info *spec_die;
11934
11935 spec_die = find_partial_die (part_die->spec_offset, cu);
11936
11937 fixup_partial_die (spec_die, cu);
11938
11939 if (spec_die->name)
11940 {
11941 part_die->name = spec_die->name;
11942
11943 /* Copy DW_AT_external attribute if it is set. */
11944 if (spec_die->is_external)
11945 part_die->is_external = spec_die->is_external;
11946 }
11947 }
11948
11949 /* Set default names for some unnamed DIEs. */
11950
11951 if (part_die->name == NULL && part_die->tag == DW_TAG_namespace)
11952 part_die->name = CP_ANONYMOUS_NAMESPACE_STR;
11953
11954 /* If there is no parent die to provide a namespace, and there are
11955 children, see if we can determine the namespace from their linkage
11956 name. */
11957 if (cu->language == language_cplus
11958 && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
11959 && part_die->die_parent == NULL
11960 && part_die->has_children
11961 && (part_die->tag == DW_TAG_class_type
11962 || part_die->tag == DW_TAG_structure_type
11963 || part_die->tag == DW_TAG_union_type))
11964 guess_partial_die_structure_name (part_die, cu);
11965
11966 /* GCC might emit a nameless struct or union that has a linkage
11967 name. See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
11968 if (part_die->name == NULL
11969 && (part_die->tag == DW_TAG_class_type
11970 || part_die->tag == DW_TAG_interface_type
11971 || part_die->tag == DW_TAG_structure_type
11972 || part_die->tag == DW_TAG_union_type)
11973 && part_die->linkage_name != NULL)
11974 {
11975 char *demangled;
11976
11977 demangled = cplus_demangle (part_die->linkage_name, DMGL_TYPES);
11978 if (demangled)
11979 {
11980 const char *base;
11981
11982 /* Strip any leading namespaces/classes, keep only the base name.
11983 DW_AT_name for named DIEs does not contain the prefixes. */
11984 base = strrchr (demangled, ':');
11985 if (base && base > demangled && base[-1] == ':')
11986 base++;
11987 else
11988 base = demangled;
11989
11990 part_die->name = obsavestring (base, strlen (base),
11991 &cu->objfile->objfile_obstack);
11992 xfree (demangled);
11993 }
11994 }
11995
11996 part_die->fixup_called = 1;
11997 }
11998
11999 /* Read an attribute value described by an attribute form. */
12000
12001 static gdb_byte *
12002 read_attribute_value (const struct die_reader_specs *reader,
12003 struct attribute *attr, unsigned form,
12004 gdb_byte *info_ptr)
12005 {
12006 struct dwarf2_cu *cu = reader->cu;
12007 bfd *abfd = reader->abfd;
12008 struct comp_unit_head *cu_header = &cu->header;
12009 unsigned int bytes_read;
12010 struct dwarf_block *blk;
12011
12012 attr->form = form;
12013 switch (form)
12014 {
12015 case DW_FORM_ref_addr:
12016 if (cu->header.version == 2)
12017 DW_UNSND (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
12018 else
12019 DW_UNSND (attr) = read_offset (abfd, info_ptr,
12020 &cu->header, &bytes_read);
12021 info_ptr += bytes_read;
12022 break;
12023 case DW_FORM_addr:
12024 DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read);
12025 info_ptr += bytes_read;
12026 break;
12027 case DW_FORM_block2:
12028 blk = dwarf_alloc_block (cu);
12029 blk->size = read_2_bytes (abfd, info_ptr);
12030 info_ptr += 2;
12031 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
12032 info_ptr += blk->size;
12033 DW_BLOCK (attr) = blk;
12034 break;
12035 case DW_FORM_block4:
12036 blk = dwarf_alloc_block (cu);
12037 blk->size = read_4_bytes (abfd, info_ptr);
12038 info_ptr += 4;
12039 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
12040 info_ptr += blk->size;
12041 DW_BLOCK (attr) = blk;
12042 break;
12043 case DW_FORM_data2:
12044 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
12045 info_ptr += 2;
12046 break;
12047 case DW_FORM_data4:
12048 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
12049 info_ptr += 4;
12050 break;
12051 case DW_FORM_data8:
12052 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
12053 info_ptr += 8;
12054 break;
12055 case DW_FORM_sec_offset:
12056 DW_UNSND (attr) = read_offset (abfd, info_ptr, &cu->header, &bytes_read);
12057 info_ptr += bytes_read;
12058 break;
12059 case DW_FORM_string:
12060 DW_STRING (attr) = read_direct_string (abfd, info_ptr, &bytes_read);
12061 DW_STRING_IS_CANONICAL (attr) = 0;
12062 info_ptr += bytes_read;
12063 break;
12064 case DW_FORM_strp:
12065 DW_STRING (attr) = read_indirect_string (abfd, info_ptr, cu_header,
12066 &bytes_read);
12067 DW_STRING_IS_CANONICAL (attr) = 0;
12068 info_ptr += bytes_read;
12069 break;
12070 case DW_FORM_exprloc:
12071 case DW_FORM_block:
12072 blk = dwarf_alloc_block (cu);
12073 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
12074 info_ptr += bytes_read;
12075 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
12076 info_ptr += blk->size;
12077 DW_BLOCK (attr) = blk;
12078 break;
12079 case DW_FORM_block1:
12080 blk = dwarf_alloc_block (cu);
12081 blk->size = read_1_byte (abfd, info_ptr);
12082 info_ptr += 1;
12083 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
12084 info_ptr += blk->size;
12085 DW_BLOCK (attr) = blk;
12086 break;
12087 case DW_FORM_data1:
12088 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
12089 info_ptr += 1;
12090 break;
12091 case DW_FORM_flag:
12092 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
12093 info_ptr += 1;
12094 break;
12095 case DW_FORM_flag_present:
12096 DW_UNSND (attr) = 1;
12097 break;
12098 case DW_FORM_sdata:
12099 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
12100 info_ptr += bytes_read;
12101 break;
12102 case DW_FORM_udata:
12103 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
12104 info_ptr += bytes_read;
12105 break;
12106 case DW_FORM_ref1:
12107 DW_UNSND (attr) = (cu->header.offset.sect_off
12108 + read_1_byte (abfd, info_ptr));
12109 info_ptr += 1;
12110 break;
12111 case DW_FORM_ref2:
12112 DW_UNSND (attr) = (cu->header.offset.sect_off
12113 + read_2_bytes (abfd, info_ptr));
12114 info_ptr += 2;
12115 break;
12116 case DW_FORM_ref4:
12117 DW_UNSND (attr) = (cu->header.offset.sect_off
12118 + read_4_bytes (abfd, info_ptr));
12119 info_ptr += 4;
12120 break;
12121 case DW_FORM_ref8:
12122 DW_UNSND (attr) = (cu->header.offset.sect_off
12123 + read_8_bytes (abfd, info_ptr));
12124 info_ptr += 8;
12125 break;
12126 case DW_FORM_ref_sig8:
12127 /* Convert the signature to something we can record in DW_UNSND
12128 for later lookup.
12129 NOTE: This is NULL if the type wasn't found. */
12130 DW_SIGNATURED_TYPE (attr) =
12131 lookup_signatured_type (read_8_bytes (abfd, info_ptr));
12132 info_ptr += 8;
12133 break;
12134 case DW_FORM_ref_udata:
12135 DW_UNSND (attr) = (cu->header.offset.sect_off
12136 + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
12137 info_ptr += bytes_read;
12138 break;
12139 case DW_FORM_indirect:
12140 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
12141 info_ptr += bytes_read;
12142 info_ptr = read_attribute_value (reader, attr, form, info_ptr);
12143 break;
12144 case DW_FORM_GNU_addr_index:
12145 if (reader->dwo_file == NULL)
12146 {
12147 /* For now flag a hard error.
12148 Later we can turn this into a complaint. */
12149 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
12150 dwarf_form_name (form),
12151 bfd_get_filename (abfd));
12152 }
12153 DW_ADDR (attr) = read_addr_index_from_leb128 (cu, info_ptr, &bytes_read);
12154 info_ptr += bytes_read;
12155 break;
12156 case DW_FORM_GNU_str_index:
12157 if (reader->dwo_file == NULL)
12158 {
12159 /* For now flag a hard error.
12160 Later we can turn this into a complaint if warranted. */
12161 error (_("Dwarf Error: %s found in non-DWO CU [in module %s]"),
12162 dwarf_form_name (form),
12163 bfd_get_filename (abfd));
12164 }
12165 {
12166 ULONGEST str_index =
12167 read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
12168
12169 DW_STRING (attr) = read_str_index (reader, cu, str_index);
12170 DW_STRING_IS_CANONICAL (attr) = 0;
12171 info_ptr += bytes_read;
12172 }
12173 break;
12174 default:
12175 error (_("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]"),
12176 dwarf_form_name (form),
12177 bfd_get_filename (abfd));
12178 }
12179
12180 /* We have seen instances where the compiler tried to emit a byte
12181 size attribute of -1 which ended up being encoded as an unsigned
12182 0xffffffff. Although 0xffffffff is technically a valid size value,
12183 an object of this size seems pretty unlikely so we can relatively
12184 safely treat these cases as if the size attribute was invalid and
12185 treat them as zero by default. */
12186 if (attr->name == DW_AT_byte_size
12187 && form == DW_FORM_data4
12188 && DW_UNSND (attr) >= 0xffffffff)
12189 {
12190 complaint
12191 (&symfile_complaints,
12192 _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
12193 hex_string (DW_UNSND (attr)));
12194 DW_UNSND (attr) = 0;
12195 }
12196
12197 return info_ptr;
12198 }
12199
12200 /* Read an attribute described by an abbreviated attribute. */
12201
12202 static gdb_byte *
12203 read_attribute (const struct die_reader_specs *reader,
12204 struct attribute *attr, struct attr_abbrev *abbrev,
12205 gdb_byte *info_ptr)
12206 {
12207 attr->name = abbrev->name;
12208 return read_attribute_value (reader, attr, abbrev->form, info_ptr);
12209 }
12210
12211 /* Read dwarf information from a buffer. */
12212
12213 static unsigned int
12214 read_1_byte (bfd *abfd, gdb_byte *buf)
12215 {
12216 return bfd_get_8 (abfd, buf);
12217 }
12218
12219 static int
12220 read_1_signed_byte (bfd *abfd, gdb_byte *buf)
12221 {
12222 return bfd_get_signed_8 (abfd, buf);
12223 }
12224
12225 static unsigned int
12226 read_2_bytes (bfd *abfd, gdb_byte *buf)
12227 {
12228 return bfd_get_16 (abfd, buf);
12229 }
12230
12231 static int
12232 read_2_signed_bytes (bfd *abfd, gdb_byte *buf)
12233 {
12234 return bfd_get_signed_16 (abfd, buf);
12235 }
12236
12237 static unsigned int
12238 read_4_bytes (bfd *abfd, gdb_byte *buf)
12239 {
12240 return bfd_get_32 (abfd, buf);
12241 }
12242
12243 static int
12244 read_4_signed_bytes (bfd *abfd, gdb_byte *buf)
12245 {
12246 return bfd_get_signed_32 (abfd, buf);
12247 }
12248
12249 static ULONGEST
12250 read_8_bytes (bfd *abfd, gdb_byte *buf)
12251 {
12252 return bfd_get_64 (abfd, buf);
12253 }
12254
12255 static CORE_ADDR
12256 read_address (bfd *abfd, gdb_byte *buf, struct dwarf2_cu *cu,
12257 unsigned int *bytes_read)
12258 {
12259 struct comp_unit_head *cu_header = &cu->header;
12260 CORE_ADDR retval = 0;
12261
12262 if (cu_header->signed_addr_p)
12263 {
12264 switch (cu_header->addr_size)
12265 {
12266 case 2:
12267 retval = bfd_get_signed_16 (abfd, buf);
12268 break;
12269 case 4:
12270 retval = bfd_get_signed_32 (abfd, buf);
12271 break;
12272 case 8:
12273 retval = bfd_get_signed_64 (abfd, buf);
12274 break;
12275 default:
12276 internal_error (__FILE__, __LINE__,
12277 _("read_address: bad switch, signed [in module %s]"),
12278 bfd_get_filename (abfd));
12279 }
12280 }
12281 else
12282 {
12283 switch (cu_header->addr_size)
12284 {
12285 case 2:
12286 retval = bfd_get_16 (abfd, buf);
12287 break;
12288 case 4:
12289 retval = bfd_get_32 (abfd, buf);
12290 break;
12291 case 8:
12292 retval = bfd_get_64 (abfd, buf);
12293 break;
12294 default:
12295 internal_error (__FILE__, __LINE__,
12296 _("read_address: bad switch, "
12297 "unsigned [in module %s]"),
12298 bfd_get_filename (abfd));
12299 }
12300 }
12301
12302 *bytes_read = cu_header->addr_size;
12303 return retval;
12304 }
12305
12306 /* Read the initial length from a section. The (draft) DWARF 3
12307 specification allows the initial length to take up either 4 bytes
12308 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
12309 bytes describe the length and all offsets will be 8 bytes in length
12310 instead of 4.
12311
12312 An older, non-standard 64-bit format is also handled by this
12313 function. The older format in question stores the initial length
12314 as an 8-byte quantity without an escape value. Lengths greater
12315 than 2^32 aren't very common which means that the initial 4 bytes
12316 is almost always zero. Since a length value of zero doesn't make
12317 sense for the 32-bit format, this initial zero can be considered to
12318 be an escape value which indicates the presence of the older 64-bit
12319 format. As written, the code can't detect (old format) lengths
12320 greater than 4GB. If it becomes necessary to handle lengths
12321 somewhat larger than 4GB, we could allow other small values (such
12322 as the non-sensical values of 1, 2, and 3) to also be used as
12323 escape values indicating the presence of the old format.
12324
12325 The value returned via bytes_read should be used to increment the
12326 relevant pointer after calling read_initial_length().
12327
12328 [ Note: read_initial_length() and read_offset() are based on the
12329 document entitled "DWARF Debugging Information Format", revision
12330 3, draft 8, dated November 19, 2001. This document was obtained
12331 from:
12332
12333 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
12334
12335 This document is only a draft and is subject to change. (So beware.)
12336
12337 Details regarding the older, non-standard 64-bit format were
12338 determined empirically by examining 64-bit ELF files produced by
12339 the SGI toolchain on an IRIX 6.5 machine.
12340
12341 - Kevin, July 16, 2002
12342 ] */
12343
12344 static LONGEST
12345 read_initial_length (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read)
12346 {
12347 LONGEST length = bfd_get_32 (abfd, buf);
12348
12349 if (length == 0xffffffff)
12350 {
12351 length = bfd_get_64 (abfd, buf + 4);
12352 *bytes_read = 12;
12353 }
12354 else if (length == 0)
12355 {
12356 /* Handle the (non-standard) 64-bit DWARF2 format used by IRIX. */
12357 length = bfd_get_64 (abfd, buf);
12358 *bytes_read = 8;
12359 }
12360 else
12361 {
12362 *bytes_read = 4;
12363 }
12364
12365 return length;
12366 }
12367
12368 /* Cover function for read_initial_length.
12369 Returns the length of the object at BUF, and stores the size of the
12370 initial length in *BYTES_READ and stores the size that offsets will be in
12371 *OFFSET_SIZE.
12372 If the initial length size is not equivalent to that specified in
12373 CU_HEADER then issue a complaint.
12374 This is useful when reading non-comp-unit headers. */
12375
12376 static LONGEST
12377 read_checked_initial_length_and_offset (bfd *abfd, gdb_byte *buf,
12378 const struct comp_unit_head *cu_header,
12379 unsigned int *bytes_read,
12380 unsigned int *offset_size)
12381 {
12382 LONGEST length = read_initial_length (abfd, buf, bytes_read);
12383
12384 gdb_assert (cu_header->initial_length_size == 4
12385 || cu_header->initial_length_size == 8
12386 || cu_header->initial_length_size == 12);
12387
12388 if (cu_header->initial_length_size != *bytes_read)
12389 complaint (&symfile_complaints,
12390 _("intermixed 32-bit and 64-bit DWARF sections"));
12391
12392 *offset_size = (*bytes_read == 4) ? 4 : 8;
12393 return length;
12394 }
12395
12396 /* Read an offset from the data stream. The size of the offset is
12397 given by cu_header->offset_size. */
12398
12399 static LONGEST
12400 read_offset (bfd *abfd, gdb_byte *buf, const struct comp_unit_head *cu_header,
12401 unsigned int *bytes_read)
12402 {
12403 LONGEST offset = read_offset_1 (abfd, buf, cu_header->offset_size);
12404
12405 *bytes_read = cu_header->offset_size;
12406 return offset;
12407 }
12408
12409 /* Read an offset from the data stream. */
12410
12411 static LONGEST
12412 read_offset_1 (bfd *abfd, gdb_byte *buf, unsigned int offset_size)
12413 {
12414 LONGEST retval = 0;
12415
12416 switch (offset_size)
12417 {
12418 case 4:
12419 retval = bfd_get_32 (abfd, buf);
12420 break;
12421 case 8:
12422 retval = bfd_get_64 (abfd, buf);
12423 break;
12424 default:
12425 internal_error (__FILE__, __LINE__,
12426 _("read_offset_1: bad switch [in module %s]"),
12427 bfd_get_filename (abfd));
12428 }
12429
12430 return retval;
12431 }
12432
12433 static gdb_byte *
12434 read_n_bytes (bfd *abfd, gdb_byte *buf, unsigned int size)
12435 {
12436 /* If the size of a host char is 8 bits, we can return a pointer
12437 to the buffer, otherwise we have to copy the data to a buffer
12438 allocated on the temporary obstack. */
12439 gdb_assert (HOST_CHAR_BIT == 8);
12440 return buf;
12441 }
12442
12443 static char *
12444 read_direct_string (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
12445 {
12446 /* If the size of a host char is 8 bits, we can return a pointer
12447 to the string, otherwise we have to copy the string to a buffer
12448 allocated on the temporary obstack. */
12449 gdb_assert (HOST_CHAR_BIT == 8);
12450 if (*buf == '\0')
12451 {
12452 *bytes_read_ptr = 1;
12453 return NULL;
12454 }
12455 *bytes_read_ptr = strlen ((char *) buf) + 1;
12456 return (char *) buf;
12457 }
12458
12459 static char *
12460 read_indirect_string_at_offset (bfd *abfd, LONGEST str_offset)
12461 {
12462 dwarf2_read_section (dwarf2_per_objfile->objfile, &dwarf2_per_objfile->str);
12463 if (dwarf2_per_objfile->str.buffer == NULL)
12464 error (_("DW_FORM_strp used without .debug_str section [in module %s]"),
12465 bfd_get_filename (abfd));
12466 if (str_offset >= dwarf2_per_objfile->str.size)
12467 error (_("DW_FORM_strp pointing outside of "
12468 ".debug_str section [in module %s]"),
12469 bfd_get_filename (abfd));
12470 gdb_assert (HOST_CHAR_BIT == 8);
12471 if (dwarf2_per_objfile->str.buffer[str_offset] == '\0')
12472 return NULL;
12473 return (char *) (dwarf2_per_objfile->str.buffer + str_offset);
12474 }
12475
12476 static char *
12477 read_indirect_string (bfd *abfd, gdb_byte *buf,
12478 const struct comp_unit_head *cu_header,
12479 unsigned int *bytes_read_ptr)
12480 {
12481 LONGEST str_offset = read_offset (abfd, buf, cu_header, bytes_read_ptr);
12482
12483 return read_indirect_string_at_offset (abfd, str_offset);
12484 }
12485
12486 static ULONGEST
12487 read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
12488 {
12489 ULONGEST result;
12490 unsigned int num_read;
12491 int i, shift;
12492 unsigned char byte;
12493
12494 result = 0;
12495 shift = 0;
12496 num_read = 0;
12497 i = 0;
12498 while (1)
12499 {
12500 byte = bfd_get_8 (abfd, buf);
12501 buf++;
12502 num_read++;
12503 result |= ((ULONGEST) (byte & 127) << shift);
12504 if ((byte & 128) == 0)
12505 {
12506 break;
12507 }
12508 shift += 7;
12509 }
12510 *bytes_read_ptr = num_read;
12511 return result;
12512 }
12513
12514 static LONGEST
12515 read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
12516 {
12517 LONGEST result;
12518 int i, shift, num_read;
12519 unsigned char byte;
12520
12521 result = 0;
12522 shift = 0;
12523 num_read = 0;
12524 i = 0;
12525 while (1)
12526 {
12527 byte = bfd_get_8 (abfd, buf);
12528 buf++;
12529 num_read++;
12530 result |= ((LONGEST) (byte & 127) << shift);
12531 shift += 7;
12532 if ((byte & 128) == 0)
12533 {
12534 break;
12535 }
12536 }
12537 if ((shift < 8 * sizeof (result)) && (byte & 0x40))
12538 result |= -(((LONGEST) 1) << shift);
12539 *bytes_read_ptr = num_read;
12540 return result;
12541 }
12542
12543 /* Given index ADDR_INDEX in .debug_addr, fetch the value.
12544 ADDR_BASE is the DW_AT_GNU_addr_base attribute or zero.
12545 ADDR_SIZE is the size of addresses from the CU header. */
12546
12547 static CORE_ADDR
12548 read_addr_index_1 (unsigned int addr_index, ULONGEST addr_base, int addr_size)
12549 {
12550 struct objfile *objfile = dwarf2_per_objfile->objfile;
12551 bfd *abfd = objfile->obfd;
12552 const gdb_byte *info_ptr;
12553
12554 dwarf2_read_section (objfile, &dwarf2_per_objfile->addr);
12555 if (dwarf2_per_objfile->addr.buffer == NULL)
12556 error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"),
12557 objfile->name);
12558 if (addr_base + addr_index * addr_size >= dwarf2_per_objfile->addr.size)
12559 error (_("DW_FORM_addr_index pointing outside of "
12560 ".debug_addr section [in module %s]"),
12561 objfile->name);
12562 info_ptr = (dwarf2_per_objfile->addr.buffer
12563 + addr_base + addr_index * addr_size);
12564 if (addr_size == 4)
12565 return bfd_get_32 (abfd, info_ptr);
12566 else
12567 return bfd_get_64 (abfd, info_ptr);
12568 }
12569
12570 /* Given index ADDR_INDEX in .debug_addr, fetch the value. */
12571
12572 static CORE_ADDR
12573 read_addr_index (struct dwarf2_cu *cu, unsigned int addr_index)
12574 {
12575 return read_addr_index_1 (addr_index, cu->addr_base, cu->header.addr_size);
12576 }
12577
12578 /* Given a pointer to an leb128 value, fetch the value from .debug_addr. */
12579
12580 static CORE_ADDR
12581 read_addr_index_from_leb128 (struct dwarf2_cu *cu, gdb_byte *info_ptr,
12582 unsigned int *bytes_read)
12583 {
12584 bfd *abfd = cu->objfile->obfd;
12585 unsigned int addr_index = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
12586
12587 return read_addr_index (cu, addr_index);
12588 }
12589
12590 /* Data structure to pass results from dwarf2_read_addr_index_reader
12591 back to dwarf2_read_addr_index. */
12592
12593 struct dwarf2_read_addr_index_data
12594 {
12595 ULONGEST addr_base;
12596 int addr_size;
12597 };
12598
12599 /* die_reader_func for dwarf2_read_addr_index. */
12600
12601 static void
12602 dwarf2_read_addr_index_reader (const struct die_reader_specs *reader,
12603 gdb_byte *info_ptr,
12604 struct die_info *comp_unit_die,
12605 int has_children,
12606 void *data)
12607 {
12608 struct dwarf2_cu *cu = reader->cu;
12609 struct dwarf2_read_addr_index_data *aidata =
12610 (struct dwarf2_read_addr_index_data *) data;
12611
12612 aidata->addr_base = cu->addr_base;
12613 aidata->addr_size = cu->header.addr_size;
12614 }
12615
12616 /* Given an index in .debug_addr, fetch the value.
12617 NOTE: This can be called during dwarf expression evaluation,
12618 long after the debug information has been read, and thus per_cu->cu
12619 may no longer exist. */
12620
12621 CORE_ADDR
12622 dwarf2_read_addr_index (struct dwarf2_per_cu_data *per_cu,
12623 unsigned int addr_index)
12624 {
12625 struct objfile *objfile = per_cu->objfile;
12626 struct dwarf2_cu *cu = per_cu->cu;
12627 ULONGEST addr_base;
12628 int addr_size;
12629
12630 /* This is intended to be called from outside this file. */
12631 dw2_setup (objfile);
12632
12633 /* We need addr_base and addr_size.
12634 If we don't have PER_CU->cu, we have to get it.
12635 Nasty, but the alternative is storing the needed info in PER_CU,
12636 which at this point doesn't seem justified: it's not clear how frequently
12637 it would get used and it would increase the size of every PER_CU.
12638 Entry points like dwarf2_per_cu_addr_size do a similar thing
12639 so we're not in uncharted territory here.
12640 Alas we need to be a bit more complicated as addr_base is contained
12641 in the DIE.
12642
12643 We don't need to read the entire CU(/TU).
12644 We just need the header and top level die.
12645 IWBN to use the aging mechanism to let us lazily later discard the CU.
12646 See however init_cutu_and_read_dies_simple. */
12647
12648 if (cu != NULL)
12649 {
12650 addr_base = cu->addr_base;
12651 addr_size = cu->header.addr_size;
12652 }
12653 else
12654 {
12655 struct dwarf2_read_addr_index_data aidata;
12656
12657 init_cutu_and_read_dies_simple (per_cu, dwarf2_read_addr_index_reader,
12658 &aidata);
12659 addr_base = aidata.addr_base;
12660 addr_size = aidata.addr_size;
12661 }
12662
12663 return read_addr_index_1 (addr_index, addr_base, addr_size);
12664 }
12665
12666 /* Given a DW_AT_str_index, fetch the string. */
12667
12668 static char *
12669 read_str_index (const struct die_reader_specs *reader,
12670 struct dwarf2_cu *cu, ULONGEST str_index)
12671 {
12672 struct objfile *objfile = dwarf2_per_objfile->objfile;
12673 const char *dwo_name = objfile->name;
12674 bfd *abfd = objfile->obfd;
12675 struct dwo_sections *sections = &reader->dwo_file->sections;
12676 gdb_byte *info_ptr;
12677 ULONGEST str_offset;
12678
12679 dwarf2_read_section (objfile, &sections->str);
12680 dwarf2_read_section (objfile, &sections->str_offsets);
12681 if (sections->str.buffer == NULL)
12682 error (_("DW_FORM_str_index used without .debug_str.dwo section"
12683 " in CU at offset 0x%lx [in module %s]"),
12684 (long) cu->header.offset.sect_off, dwo_name);
12685 if (sections->str_offsets.buffer == NULL)
12686 error (_("DW_FORM_str_index used without .debug_str_offsets.dwo section"
12687 " in CU at offset 0x%lx [in module %s]"),
12688 (long) cu->header.offset.sect_off, dwo_name);
12689 if (str_index * cu->header.offset_size >= sections->str_offsets.size)
12690 error (_("DW_FORM_str_index pointing outside of .debug_str_offsets.dwo"
12691 " section in CU at offset 0x%lx [in module %s]"),
12692 (long) cu->header.offset.sect_off, dwo_name);
12693 info_ptr = (sections->str_offsets.buffer
12694 + str_index * cu->header.offset_size);
12695 if (cu->header.offset_size == 4)
12696 str_offset = bfd_get_32 (abfd, info_ptr);
12697 else
12698 str_offset = bfd_get_64 (abfd, info_ptr);
12699 if (str_offset >= sections->str.size)
12700 error (_("Offset from DW_FORM_str_index pointing outside of"
12701 " .debug_str.dwo section in CU at offset 0x%lx [in module %s]"),
12702 (long) cu->header.offset.sect_off, dwo_name);
12703 return (char *) (sections->str.buffer + str_offset);
12704 }
12705
12706 /* Return the length of an LEB128 number in BUF. */
12707
12708 static int
12709 leb128_size (const gdb_byte *buf)
12710 {
12711 const gdb_byte *begin = buf;
12712 gdb_byte byte;
12713
12714 while (1)
12715 {
12716 byte = *buf++;
12717 if ((byte & 128) == 0)
12718 return buf - begin;
12719 }
12720 }
12721
12722 static void
12723 set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
12724 {
12725 switch (lang)
12726 {
12727 case DW_LANG_C89:
12728 case DW_LANG_C99:
12729 case DW_LANG_C:
12730 cu->language = language_c;
12731 break;
12732 case DW_LANG_C_plus_plus:
12733 cu->language = language_cplus;
12734 break;
12735 case DW_LANG_D:
12736 cu->language = language_d;
12737 break;
12738 case DW_LANG_Fortran77:
12739 case DW_LANG_Fortran90:
12740 case DW_LANG_Fortran95:
12741 cu->language = language_fortran;
12742 break;
12743 case DW_LANG_Go:
12744 cu->language = language_go;
12745 break;
12746 case DW_LANG_Mips_Assembler:
12747 cu->language = language_asm;
12748 break;
12749 case DW_LANG_Java:
12750 cu->language = language_java;
12751 break;
12752 case DW_LANG_Ada83:
12753 case DW_LANG_Ada95:
12754 cu->language = language_ada;
12755 break;
12756 case DW_LANG_Modula2:
12757 cu->language = language_m2;
12758 break;
12759 case DW_LANG_Pascal83:
12760 cu->language = language_pascal;
12761 break;
12762 case DW_LANG_ObjC:
12763 cu->language = language_objc;
12764 break;
12765 case DW_LANG_Cobol74:
12766 case DW_LANG_Cobol85:
12767 default:
12768 cu->language = language_minimal;
12769 break;
12770 }
12771 cu->language_defn = language_def (cu->language);
12772 }
12773
12774 /* Return the named attribute or NULL if not there. */
12775
12776 static struct attribute *
12777 dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
12778 {
12779 for (;;)
12780 {
12781 unsigned int i;
12782 struct attribute *spec = NULL;
12783
12784 for (i = 0; i < die->num_attrs; ++i)
12785 {
12786 if (die->attrs[i].name == name)
12787 return &die->attrs[i];
12788 if (die->attrs[i].name == DW_AT_specification
12789 || die->attrs[i].name == DW_AT_abstract_origin)
12790 spec = &die->attrs[i];
12791 }
12792
12793 if (!spec)
12794 break;
12795
12796 die = follow_die_ref (die, spec, &cu);
12797 }
12798
12799 return NULL;
12800 }
12801
12802 /* Return the named attribute or NULL if not there,
12803 but do not follow DW_AT_specification, etc.
12804 This is for use in contexts where we're reading .debug_types dies.
12805 Following DW_AT_specification, DW_AT_abstract_origin will take us
12806 back up the chain, and we want to go down. */
12807
12808 static struct attribute *
12809 dwarf2_attr_no_follow (struct die_info *die, unsigned int name)
12810 {
12811 unsigned int i;
12812
12813 for (i = 0; i < die->num_attrs; ++i)
12814 if (die->attrs[i].name == name)
12815 return &die->attrs[i];
12816
12817 return NULL;
12818 }
12819
12820 /* Return non-zero iff the attribute NAME is defined for the given DIE,
12821 and holds a non-zero value. This function should only be used for
12822 DW_FORM_flag or DW_FORM_flag_present attributes. */
12823
12824 static int
12825 dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu)
12826 {
12827 struct attribute *attr = dwarf2_attr (die, name, cu);
12828
12829 return (attr && DW_UNSND (attr));
12830 }
12831
12832 static int
12833 die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
12834 {
12835 /* A DIE is a declaration if it has a DW_AT_declaration attribute
12836 which value is non-zero. However, we have to be careful with
12837 DIEs having a DW_AT_specification attribute, because dwarf2_attr()
12838 (via dwarf2_flag_true_p) follows this attribute. So we may
12839 end up accidently finding a declaration attribute that belongs
12840 to a different DIE referenced by the specification attribute,
12841 even though the given DIE does not have a declaration attribute. */
12842 return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
12843 && dwarf2_attr (die, DW_AT_specification, cu) == NULL);
12844 }
12845
12846 /* Return the die giving the specification for DIE, if there is
12847 one. *SPEC_CU is the CU containing DIE on input, and the CU
12848 containing the return value on output. If there is no
12849 specification, but there is an abstract origin, that is
12850 returned. */
12851
12852 static struct die_info *
12853 die_specification (struct die_info *die, struct dwarf2_cu **spec_cu)
12854 {
12855 struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification,
12856 *spec_cu);
12857
12858 if (spec_attr == NULL)
12859 spec_attr = dwarf2_attr (die, DW_AT_abstract_origin, *spec_cu);
12860
12861 if (spec_attr == NULL)
12862 return NULL;
12863 else
12864 return follow_die_ref (die, spec_attr, spec_cu);
12865 }
12866
12867 /* Free the line_header structure *LH, and any arrays and strings it
12868 refers to.
12869 NOTE: This is also used as a "cleanup" function. */
12870
12871 static void
12872 free_line_header (struct line_header *lh)
12873 {
12874 if (lh->standard_opcode_lengths)
12875 xfree (lh->standard_opcode_lengths);
12876
12877 /* Remember that all the lh->file_names[i].name pointers are
12878 pointers into debug_line_buffer, and don't need to be freed. */
12879 if (lh->file_names)
12880 xfree (lh->file_names);
12881
12882 /* Similarly for the include directory names. */
12883 if (lh->include_dirs)
12884 xfree (lh->include_dirs);
12885
12886 xfree (lh);
12887 }
12888
12889 /* Add an entry to LH's include directory table. */
12890
12891 static void
12892 add_include_dir (struct line_header *lh, char *include_dir)
12893 {
12894 /* Grow the array if necessary. */
12895 if (lh->include_dirs_size == 0)
12896 {
12897 lh->include_dirs_size = 1; /* for testing */
12898 lh->include_dirs = xmalloc (lh->include_dirs_size
12899 * sizeof (*lh->include_dirs));
12900 }
12901 else if (lh->num_include_dirs >= lh->include_dirs_size)
12902 {
12903 lh->include_dirs_size *= 2;
12904 lh->include_dirs = xrealloc (lh->include_dirs,
12905 (lh->include_dirs_size
12906 * sizeof (*lh->include_dirs)));
12907 }
12908
12909 lh->include_dirs[lh->num_include_dirs++] = include_dir;
12910 }
12911
12912 /* Add an entry to LH's file name table. */
12913
12914 static void
12915 add_file_name (struct line_header *lh,
12916 char *name,
12917 unsigned int dir_index,
12918 unsigned int mod_time,
12919 unsigned int length)
12920 {
12921 struct file_entry *fe;
12922
12923 /* Grow the array if necessary. */
12924 if (lh->file_names_size == 0)
12925 {
12926 lh->file_names_size = 1; /* for testing */
12927 lh->file_names = xmalloc (lh->file_names_size
12928 * sizeof (*lh->file_names));
12929 }
12930 else if (lh->num_file_names >= lh->file_names_size)
12931 {
12932 lh->file_names_size *= 2;
12933 lh->file_names = xrealloc (lh->file_names,
12934 (lh->file_names_size
12935 * sizeof (*lh->file_names)));
12936 }
12937
12938 fe = &lh->file_names[lh->num_file_names++];
12939 fe->name = name;
12940 fe->dir_index = dir_index;
12941 fe->mod_time = mod_time;
12942 fe->length = length;
12943 fe->included_p = 0;
12944 fe->symtab = NULL;
12945 }
12946
12947 /* Read the statement program header starting at OFFSET in
12948 .debug_line, or .debug_line.dwo. Return a pointer
12949 to a struct line_header, allocated using xmalloc.
12950
12951 NOTE: the strings in the include directory and file name tables of
12952 the returned object point into the dwarf line section buffer,
12953 and must not be freed. */
12954
12955 static struct line_header *
12956 dwarf_decode_line_header (unsigned int offset, struct dwarf2_cu *cu)
12957 {
12958 struct cleanup *back_to;
12959 struct line_header *lh;
12960 gdb_byte *line_ptr;
12961 unsigned int bytes_read, offset_size;
12962 int i;
12963 char *cur_dir, *cur_file;
12964 struct dwarf2_section_info *section;
12965 bfd *abfd;
12966
12967 /* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
12968 DWO file. */
12969 if (cu->dwo_unit && cu->per_cu->is_debug_types)
12970 section = &cu->dwo_unit->dwo_file->sections.line;
12971 else
12972 section = &dwarf2_per_objfile->line;
12973
12974 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
12975 if (section->buffer == NULL)
12976 {
12977 if (cu->dwo_unit && cu->per_cu->is_debug_types)
12978 complaint (&symfile_complaints, _("missing .debug_line.dwo section"));
12979 else
12980 complaint (&symfile_complaints, _("missing .debug_line section"));
12981 return 0;
12982 }
12983
12984 /* We can't do this until we know the section is non-empty.
12985 Only then do we know we have such a section. */
12986 abfd = section->asection->owner;
12987
12988 /* Make sure that at least there's room for the total_length field.
12989 That could be 12 bytes long, but we're just going to fudge that. */
12990 if (offset + 4 >= section->size)
12991 {
12992 dwarf2_statement_list_fits_in_line_number_section_complaint ();
12993 return 0;
12994 }
12995
12996 lh = xmalloc (sizeof (*lh));
12997 memset (lh, 0, sizeof (*lh));
12998 back_to = make_cleanup ((make_cleanup_ftype *) free_line_header,
12999 (void *) lh);
13000
13001 line_ptr = section->buffer + offset;
13002
13003 /* Read in the header. */
13004 lh->total_length =
13005 read_checked_initial_length_and_offset (abfd, line_ptr, &cu->header,
13006 &bytes_read, &offset_size);
13007 line_ptr += bytes_read;
13008 if (line_ptr + lh->total_length > (section->buffer + section->size))
13009 {
13010 dwarf2_statement_list_fits_in_line_number_section_complaint ();
13011 return 0;
13012 }
13013 lh->statement_program_end = line_ptr + lh->total_length;
13014 lh->version = read_2_bytes (abfd, line_ptr);
13015 line_ptr += 2;
13016 lh->header_length = read_offset_1 (abfd, line_ptr, offset_size);
13017 line_ptr += offset_size;
13018 lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
13019 line_ptr += 1;
13020 if (lh->version >= 4)
13021 {
13022 lh->maximum_ops_per_instruction = read_1_byte (abfd, line_ptr);
13023 line_ptr += 1;
13024 }
13025 else
13026 lh->maximum_ops_per_instruction = 1;
13027
13028 if (lh->maximum_ops_per_instruction == 0)
13029 {
13030 lh->maximum_ops_per_instruction = 1;
13031 complaint (&symfile_complaints,
13032 _("invalid maximum_ops_per_instruction "
13033 "in `.debug_line' section"));
13034 }
13035
13036 lh->default_is_stmt = read_1_byte (abfd, line_ptr);
13037 line_ptr += 1;
13038 lh->line_base = read_1_signed_byte (abfd, line_ptr);
13039 line_ptr += 1;
13040 lh->line_range = read_1_byte (abfd, line_ptr);
13041 line_ptr += 1;
13042 lh->opcode_base = read_1_byte (abfd, line_ptr);
13043 line_ptr += 1;
13044 lh->standard_opcode_lengths
13045 = xmalloc (lh->opcode_base * sizeof (lh->standard_opcode_lengths[0]));
13046
13047 lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
13048 for (i = 1; i < lh->opcode_base; ++i)
13049 {
13050 lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
13051 line_ptr += 1;
13052 }
13053
13054 /* Read directory table. */
13055 while ((cur_dir = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
13056 {
13057 line_ptr += bytes_read;
13058 add_include_dir (lh, cur_dir);
13059 }
13060 line_ptr += bytes_read;
13061
13062 /* Read file name table. */
13063 while ((cur_file = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
13064 {
13065 unsigned int dir_index, mod_time, length;
13066
13067 line_ptr += bytes_read;
13068 dir_index = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
13069 line_ptr += bytes_read;
13070 mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
13071 line_ptr += bytes_read;
13072 length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
13073 line_ptr += bytes_read;
13074
13075 add_file_name (lh, cur_file, dir_index, mod_time, length);
13076 }
13077 line_ptr += bytes_read;
13078 lh->statement_program_start = line_ptr;
13079
13080 if (line_ptr > (section->buffer + section->size))
13081 complaint (&symfile_complaints,
13082 _("line number info header doesn't "
13083 "fit in `.debug_line' section"));
13084
13085 discard_cleanups (back_to);
13086 return lh;
13087 }
13088
13089 /* Subroutine of dwarf_decode_lines to simplify it.
13090 Return the file name of the psymtab for included file FILE_INDEX
13091 in line header LH of PST.
13092 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
13093 If space for the result is malloc'd, it will be freed by a cleanup.
13094 Returns NULL if FILE_INDEX should be ignored, i.e., it is pst->filename. */
13095
13096 static char *
13097 psymtab_include_file_name (const struct line_header *lh, int file_index,
13098 const struct partial_symtab *pst,
13099 const char *comp_dir)
13100 {
13101 const struct file_entry fe = lh->file_names [file_index];
13102 char *include_name = fe.name;
13103 char *include_name_to_compare = include_name;
13104 char *dir_name = NULL;
13105 const char *pst_filename;
13106 char *copied_name = NULL;
13107 int file_is_pst;
13108
13109 if (fe.dir_index)
13110 dir_name = lh->include_dirs[fe.dir_index - 1];
13111
13112 if (!IS_ABSOLUTE_PATH (include_name)
13113 && (dir_name != NULL || comp_dir != NULL))
13114 {
13115 /* Avoid creating a duplicate psymtab for PST.
13116 We do this by comparing INCLUDE_NAME and PST_FILENAME.
13117 Before we do the comparison, however, we need to account
13118 for DIR_NAME and COMP_DIR.
13119 First prepend dir_name (if non-NULL). If we still don't
13120 have an absolute path prepend comp_dir (if non-NULL).
13121 However, the directory we record in the include-file's
13122 psymtab does not contain COMP_DIR (to match the
13123 corresponding symtab(s)).
13124
13125 Example:
13126
13127 bash$ cd /tmp
13128 bash$ gcc -g ./hello.c
13129 include_name = "hello.c"
13130 dir_name = "."
13131 DW_AT_comp_dir = comp_dir = "/tmp"
13132 DW_AT_name = "./hello.c" */
13133
13134 if (dir_name != NULL)
13135 {
13136 include_name = concat (dir_name, SLASH_STRING,
13137 include_name, (char *)NULL);
13138 include_name_to_compare = include_name;
13139 make_cleanup (xfree, include_name);
13140 }
13141 if (!IS_ABSOLUTE_PATH (include_name) && comp_dir != NULL)
13142 {
13143 include_name_to_compare = concat (comp_dir, SLASH_STRING,
13144 include_name, (char *)NULL);
13145 }
13146 }
13147
13148 pst_filename = pst->filename;
13149 if (!IS_ABSOLUTE_PATH (pst_filename) && pst->dirname != NULL)
13150 {
13151 copied_name = concat (pst->dirname, SLASH_STRING,
13152 pst_filename, (char *)NULL);
13153 pst_filename = copied_name;
13154 }
13155
13156 file_is_pst = FILENAME_CMP (include_name_to_compare, pst_filename) == 0;
13157
13158 if (include_name_to_compare != include_name)
13159 xfree (include_name_to_compare);
13160 if (copied_name != NULL)
13161 xfree (copied_name);
13162
13163 if (file_is_pst)
13164 return NULL;
13165 return include_name;
13166 }
13167
13168 /* Ignore this record_line request. */
13169
13170 static void
13171 noop_record_line (struct subfile *subfile, int line, CORE_ADDR pc)
13172 {
13173 return;
13174 }
13175
13176 /* Subroutine of dwarf_decode_lines to simplify it.
13177 Process the line number information in LH. */
13178
13179 static void
13180 dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir,
13181 struct dwarf2_cu *cu, struct partial_symtab *pst)
13182 {
13183 gdb_byte *line_ptr, *extended_end;
13184 gdb_byte *line_end;
13185 unsigned int bytes_read, extended_len;
13186 unsigned char op_code, extended_op, adj_opcode;
13187 CORE_ADDR baseaddr;
13188 struct objfile *objfile = cu->objfile;
13189 bfd *abfd = objfile->obfd;
13190 struct gdbarch *gdbarch = get_objfile_arch (objfile);
13191 const int decode_for_pst_p = (pst != NULL);
13192 struct subfile *last_subfile = NULL;
13193 void (*p_record_line) (struct subfile *subfile, int line, CORE_ADDR pc)
13194 = record_line;
13195
13196 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13197
13198 line_ptr = lh->statement_program_start;
13199 line_end = lh->statement_program_end;
13200
13201 /* Read the statement sequences until there's nothing left. */
13202 while (line_ptr < line_end)
13203 {
13204 /* state machine registers */
13205 CORE_ADDR address = 0;
13206 unsigned int file = 1;
13207 unsigned int line = 1;
13208 unsigned int column = 0;
13209 int is_stmt = lh->default_is_stmt;
13210 int basic_block = 0;
13211 int end_sequence = 0;
13212 CORE_ADDR addr;
13213 unsigned char op_index = 0;
13214
13215 if (!decode_for_pst_p && lh->num_file_names >= file)
13216 {
13217 /* Start a subfile for the current file of the state machine. */
13218 /* lh->include_dirs and lh->file_names are 0-based, but the
13219 directory and file name numbers in the statement program
13220 are 1-based. */
13221 struct file_entry *fe = &lh->file_names[file - 1];
13222 char *dir = NULL;
13223
13224 if (fe->dir_index)
13225 dir = lh->include_dirs[fe->dir_index - 1];
13226
13227 dwarf2_start_subfile (fe->name, dir, comp_dir);
13228 }
13229
13230 /* Decode the table. */
13231 while (!end_sequence)
13232 {
13233 op_code = read_1_byte (abfd, line_ptr);
13234 line_ptr += 1;
13235 if (line_ptr > line_end)
13236 {
13237 dwarf2_debug_line_missing_end_sequence_complaint ();
13238 break;
13239 }
13240
13241 if (op_code >= lh->opcode_base)
13242 {
13243 /* Special operand. */
13244 adj_opcode = op_code - lh->opcode_base;
13245 address += (((op_index + (adj_opcode / lh->line_range))
13246 / lh->maximum_ops_per_instruction)
13247 * lh->minimum_instruction_length);
13248 op_index = ((op_index + (adj_opcode / lh->line_range))
13249 % lh->maximum_ops_per_instruction);
13250 line += lh->line_base + (adj_opcode % lh->line_range);
13251 if (lh->num_file_names < file || file == 0)
13252 dwarf2_debug_line_missing_file_complaint ();
13253 /* For now we ignore lines not starting on an
13254 instruction boundary. */
13255 else if (op_index == 0)
13256 {
13257 lh->file_names[file - 1].included_p = 1;
13258 if (!decode_for_pst_p && is_stmt)
13259 {
13260 if (last_subfile != current_subfile)
13261 {
13262 addr = gdbarch_addr_bits_remove (gdbarch, address);
13263 if (last_subfile)
13264 (*p_record_line) (last_subfile, 0, addr);
13265 last_subfile = current_subfile;
13266 }
13267 /* Append row to matrix using current values. */
13268 addr = gdbarch_addr_bits_remove (gdbarch, address);
13269 (*p_record_line) (current_subfile, line, addr);
13270 }
13271 }
13272 basic_block = 0;
13273 }
13274 else switch (op_code)
13275 {
13276 case DW_LNS_extended_op:
13277 extended_len = read_unsigned_leb128 (abfd, line_ptr,
13278 &bytes_read);
13279 line_ptr += bytes_read;
13280 extended_end = line_ptr + extended_len;
13281 extended_op = read_1_byte (abfd, line_ptr);
13282 line_ptr += 1;
13283 switch (extended_op)
13284 {
13285 case DW_LNE_end_sequence:
13286 p_record_line = record_line;
13287 end_sequence = 1;
13288 break;
13289 case DW_LNE_set_address:
13290 address = read_address (abfd, line_ptr, cu, &bytes_read);
13291
13292 if (address == 0 && !dwarf2_per_objfile->has_section_at_zero)
13293 {
13294 /* This line table is for a function which has been
13295 GCd by the linker. Ignore it. PR gdb/12528 */
13296
13297 long line_offset
13298 = line_ptr - dwarf2_per_objfile->line.buffer;
13299
13300 complaint (&symfile_complaints,
13301 _(".debug_line address at offset 0x%lx is 0 "
13302 "[in module %s]"),
13303 line_offset, objfile->name);
13304 p_record_line = noop_record_line;
13305 }
13306
13307 op_index = 0;
13308 line_ptr += bytes_read;
13309 address += baseaddr;
13310 break;
13311 case DW_LNE_define_file:
13312 {
13313 char *cur_file;
13314 unsigned int dir_index, mod_time, length;
13315
13316 cur_file = read_direct_string (abfd, line_ptr,
13317 &bytes_read);
13318 line_ptr += bytes_read;
13319 dir_index =
13320 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
13321 line_ptr += bytes_read;
13322 mod_time =
13323 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
13324 line_ptr += bytes_read;
13325 length =
13326 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
13327 line_ptr += bytes_read;
13328 add_file_name (lh, cur_file, dir_index, mod_time, length);
13329 }
13330 break;
13331 case DW_LNE_set_discriminator:
13332 /* The discriminator is not interesting to the debugger;
13333 just ignore it. */
13334 line_ptr = extended_end;
13335 break;
13336 default:
13337 complaint (&symfile_complaints,
13338 _("mangled .debug_line section"));
13339 return;
13340 }
13341 /* Make sure that we parsed the extended op correctly. If e.g.
13342 we expected a different address size than the producer used,
13343 we may have read the wrong number of bytes. */
13344 if (line_ptr != extended_end)
13345 {
13346 complaint (&symfile_complaints,
13347 _("mangled .debug_line section"));
13348 return;
13349 }
13350 break;
13351 case DW_LNS_copy:
13352 if (lh->num_file_names < file || file == 0)
13353 dwarf2_debug_line_missing_file_complaint ();
13354 else
13355 {
13356 lh->file_names[file - 1].included_p = 1;
13357 if (!decode_for_pst_p && is_stmt)
13358 {
13359 if (last_subfile != current_subfile)
13360 {
13361 addr = gdbarch_addr_bits_remove (gdbarch, address);
13362 if (last_subfile)
13363 (*p_record_line) (last_subfile, 0, addr);
13364 last_subfile = current_subfile;
13365 }
13366 addr = gdbarch_addr_bits_remove (gdbarch, address);
13367 (*p_record_line) (current_subfile, line, addr);
13368 }
13369 }
13370 basic_block = 0;
13371 break;
13372 case DW_LNS_advance_pc:
13373 {
13374 CORE_ADDR adjust
13375 = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
13376
13377 address += (((op_index + adjust)
13378 / lh->maximum_ops_per_instruction)
13379 * lh->minimum_instruction_length);
13380 op_index = ((op_index + adjust)
13381 % lh->maximum_ops_per_instruction);
13382 line_ptr += bytes_read;
13383 }
13384 break;
13385 case DW_LNS_advance_line:
13386 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
13387 line_ptr += bytes_read;
13388 break;
13389 case DW_LNS_set_file:
13390 {
13391 /* The arrays lh->include_dirs and lh->file_names are
13392 0-based, but the directory and file name numbers in
13393 the statement program are 1-based. */
13394 struct file_entry *fe;
13395 char *dir = NULL;
13396
13397 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
13398 line_ptr += bytes_read;
13399 if (lh->num_file_names < file || file == 0)
13400 dwarf2_debug_line_missing_file_complaint ();
13401 else
13402 {
13403 fe = &lh->file_names[file - 1];
13404 if (fe->dir_index)
13405 dir = lh->include_dirs[fe->dir_index - 1];
13406 if (!decode_for_pst_p)
13407 {
13408 last_subfile = current_subfile;
13409 dwarf2_start_subfile (fe->name, dir, comp_dir);
13410 }
13411 }
13412 }
13413 break;
13414 case DW_LNS_set_column:
13415 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
13416 line_ptr += bytes_read;
13417 break;
13418 case DW_LNS_negate_stmt:
13419 is_stmt = (!is_stmt);
13420 break;
13421 case DW_LNS_set_basic_block:
13422 basic_block = 1;
13423 break;
13424 /* Add to the address register of the state machine the
13425 address increment value corresponding to special opcode
13426 255. I.e., this value is scaled by the minimum
13427 instruction length since special opcode 255 would have
13428 scaled the increment. */
13429 case DW_LNS_const_add_pc:
13430 {
13431 CORE_ADDR adjust = (255 - lh->opcode_base) / lh->line_range;
13432
13433 address += (((op_index + adjust)
13434 / lh->maximum_ops_per_instruction)
13435 * lh->minimum_instruction_length);
13436 op_index = ((op_index + adjust)
13437 % lh->maximum_ops_per_instruction);
13438 }
13439 break;
13440 case DW_LNS_fixed_advance_pc:
13441 address += read_2_bytes (abfd, line_ptr);
13442 op_index = 0;
13443 line_ptr += 2;
13444 break;
13445 default:
13446 {
13447 /* Unknown standard opcode, ignore it. */
13448 int i;
13449
13450 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
13451 {
13452 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
13453 line_ptr += bytes_read;
13454 }
13455 }
13456 }
13457 }
13458 if (lh->num_file_names < file || file == 0)
13459 dwarf2_debug_line_missing_file_complaint ();
13460 else
13461 {
13462 lh->file_names[file - 1].included_p = 1;
13463 if (!decode_for_pst_p)
13464 {
13465 addr = gdbarch_addr_bits_remove (gdbarch, address);
13466 (*p_record_line) (current_subfile, 0, addr);
13467 }
13468 }
13469 }
13470 }
13471
13472 /* Decode the Line Number Program (LNP) for the given line_header
13473 structure and CU. The actual information extracted and the type
13474 of structures created from the LNP depends on the value of PST.
13475
13476 1. If PST is NULL, then this procedure uses the data from the program
13477 to create all necessary symbol tables, and their linetables.
13478
13479 2. If PST is not NULL, this procedure reads the program to determine
13480 the list of files included by the unit represented by PST, and
13481 builds all the associated partial symbol tables.
13482
13483 COMP_DIR is the compilation directory (DW_AT_comp_dir) or NULL if unknown.
13484 It is used for relative paths in the line table.
13485 NOTE: When processing partial symtabs (pst != NULL),
13486 comp_dir == pst->dirname.
13487
13488 NOTE: It is important that psymtabs have the same file name (via strcmp)
13489 as the corresponding symtab. Since COMP_DIR is not used in the name of the
13490 symtab we don't use it in the name of the psymtabs we create.
13491 E.g. expand_line_sal requires this when finding psymtabs to expand.
13492 A good testcase for this is mb-inline.exp. */
13493
13494 static void
13495 dwarf_decode_lines (struct line_header *lh, const char *comp_dir,
13496 struct dwarf2_cu *cu, struct partial_symtab *pst,
13497 int want_line_info)
13498 {
13499 struct objfile *objfile = cu->objfile;
13500 const int decode_for_pst_p = (pst != NULL);
13501 struct subfile *first_subfile = current_subfile;
13502
13503 if (want_line_info)
13504 dwarf_decode_lines_1 (lh, comp_dir, cu, pst);
13505
13506 if (decode_for_pst_p)
13507 {
13508 int file_index;
13509
13510 /* Now that we're done scanning the Line Header Program, we can
13511 create the psymtab of each included file. */
13512 for (file_index = 0; file_index < lh->num_file_names; file_index++)
13513 if (lh->file_names[file_index].included_p == 1)
13514 {
13515 char *include_name =
13516 psymtab_include_file_name (lh, file_index, pst, comp_dir);
13517 if (include_name != NULL)
13518 dwarf2_create_include_psymtab (include_name, pst, objfile);
13519 }
13520 }
13521 else
13522 {
13523 /* Make sure a symtab is created for every file, even files
13524 which contain only variables (i.e. no code with associated
13525 line numbers). */
13526 int i;
13527
13528 for (i = 0; i < lh->num_file_names; i++)
13529 {
13530 char *dir = NULL;
13531 struct file_entry *fe;
13532
13533 fe = &lh->file_names[i];
13534 if (fe->dir_index)
13535 dir = lh->include_dirs[fe->dir_index - 1];
13536 dwarf2_start_subfile (fe->name, dir, comp_dir);
13537
13538 /* Skip the main file; we don't need it, and it must be
13539 allocated last, so that it will show up before the
13540 non-primary symtabs in the objfile's symtab list. */
13541 if (current_subfile == first_subfile)
13542 continue;
13543
13544 if (current_subfile->symtab == NULL)
13545 current_subfile->symtab = allocate_symtab (current_subfile->name,
13546 objfile);
13547 fe->symtab = current_subfile->symtab;
13548 }
13549 }
13550 }
13551
13552 /* Start a subfile for DWARF. FILENAME is the name of the file and
13553 DIRNAME the name of the source directory which contains FILENAME
13554 or NULL if not known. COMP_DIR is the compilation directory for the
13555 linetable's compilation unit or NULL if not known.
13556 This routine tries to keep line numbers from identical absolute and
13557 relative file names in a common subfile.
13558
13559 Using the `list' example from the GDB testsuite, which resides in
13560 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
13561 of /srcdir/list0.c yields the following debugging information for list0.c:
13562
13563 DW_AT_name: /srcdir/list0.c
13564 DW_AT_comp_dir: /compdir
13565 files.files[0].name: list0.h
13566 files.files[0].dir: /srcdir
13567 files.files[1].name: list0.c
13568 files.files[1].dir: /srcdir
13569
13570 The line number information for list0.c has to end up in a single
13571 subfile, so that `break /srcdir/list0.c:1' works as expected.
13572 start_subfile will ensure that this happens provided that we pass the
13573 concatenation of files.files[1].dir and files.files[1].name as the
13574 subfile's name. */
13575
13576 static void
13577 dwarf2_start_subfile (char *filename, const char *dirname,
13578 const char *comp_dir)
13579 {
13580 char *fullname;
13581
13582 /* While reading the DIEs, we call start_symtab(DW_AT_name, DW_AT_comp_dir).
13583 `start_symtab' will always pass the contents of DW_AT_comp_dir as
13584 second argument to start_subfile. To be consistent, we do the
13585 same here. In order not to lose the line information directory,
13586 we concatenate it to the filename when it makes sense.
13587 Note that the Dwarf3 standard says (speaking of filenames in line
13588 information): ``The directory index is ignored for file names
13589 that represent full path names''. Thus ignoring dirname in the
13590 `else' branch below isn't an issue. */
13591
13592 if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
13593 fullname = concat (dirname, SLASH_STRING, filename, (char *)NULL);
13594 else
13595 fullname = filename;
13596
13597 start_subfile (fullname, comp_dir);
13598
13599 if (fullname != filename)
13600 xfree (fullname);
13601 }
13602
13603 static void
13604 var_decode_location (struct attribute *attr, struct symbol *sym,
13605 struct dwarf2_cu *cu)
13606 {
13607 struct objfile *objfile = cu->objfile;
13608 struct comp_unit_head *cu_header = &cu->header;
13609
13610 /* NOTE drow/2003-01-30: There used to be a comment and some special
13611 code here to turn a symbol with DW_AT_external and a
13612 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
13613 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
13614 with some versions of binutils) where shared libraries could have
13615 relocations against symbols in their debug information - the
13616 minimal symbol would have the right address, but the debug info
13617 would not. It's no longer necessary, because we will explicitly
13618 apply relocations when we read in the debug information now. */
13619
13620 /* A DW_AT_location attribute with no contents indicates that a
13621 variable has been optimized away. */
13622 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
13623 {
13624 SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
13625 return;
13626 }
13627
13628 /* Handle one degenerate form of location expression specially, to
13629 preserve GDB's previous behavior when section offsets are
13630 specified. If this is just a DW_OP_addr or DW_OP_GNU_addr_index
13631 then mark this symbol as LOC_STATIC. */
13632
13633 if (attr_form_is_block (attr)
13634 && ((DW_BLOCK (attr)->data[0] == DW_OP_addr
13635 && DW_BLOCK (attr)->size == 1 + cu_header->addr_size)
13636 || (DW_BLOCK (attr)->data[0] == DW_OP_GNU_addr_index
13637 && (DW_BLOCK (attr)->size
13638 == 1 + leb128_size (&DW_BLOCK (attr)->data[1])))))
13639 {
13640 unsigned int dummy;
13641
13642 if (DW_BLOCK (attr)->data[0] == DW_OP_addr)
13643 SYMBOL_VALUE_ADDRESS (sym) =
13644 read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy);
13645 else
13646 SYMBOL_VALUE_ADDRESS (sym) =
13647 read_addr_index_from_leb128 (cu, DW_BLOCK (attr)->data + 1, &dummy);
13648 SYMBOL_CLASS (sym) = LOC_STATIC;
13649 fixup_symbol_section (sym, objfile);
13650 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
13651 SYMBOL_SECTION (sym));
13652 return;
13653 }
13654
13655 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
13656 expression evaluator, and use LOC_COMPUTED only when necessary
13657 (i.e. when the value of a register or memory location is
13658 referenced, or a thread-local block, etc.). Then again, it might
13659 not be worthwhile. I'm assuming that it isn't unless performance
13660 or memory numbers show me otherwise. */
13661
13662 dwarf2_symbol_mark_computed (attr, sym, cu);
13663 SYMBOL_CLASS (sym) = LOC_COMPUTED;
13664
13665 if (SYMBOL_COMPUTED_OPS (sym) == &dwarf2_loclist_funcs)
13666 cu->has_loclist = 1;
13667 }
13668
13669 /* Given a pointer to a DWARF information entry, figure out if we need
13670 to make a symbol table entry for it, and if so, create a new entry
13671 and return a pointer to it.
13672 If TYPE is NULL, determine symbol type from the die, otherwise
13673 used the passed type.
13674 If SPACE is not NULL, use it to hold the new symbol. If it is
13675 NULL, allocate a new symbol on the objfile's obstack. */
13676
13677 static struct symbol *
13678 new_symbol_full (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
13679 struct symbol *space)
13680 {
13681 struct objfile *objfile = cu->objfile;
13682 struct symbol *sym = NULL;
13683 char *name;
13684 struct attribute *attr = NULL;
13685 struct attribute *attr2 = NULL;
13686 CORE_ADDR baseaddr;
13687 struct pending **list_to_add = NULL;
13688
13689 int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
13690
13691 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
13692
13693 name = dwarf2_name (die, cu);
13694 if (name)
13695 {
13696 const char *linkagename;
13697 int suppress_add = 0;
13698
13699 if (space)
13700 sym = space;
13701 else
13702 sym = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct symbol);
13703 OBJSTAT (objfile, n_syms++);
13704
13705 /* Cache this symbol's name and the name's demangled form (if any). */
13706 SYMBOL_SET_LANGUAGE (sym, cu->language);
13707 linkagename = dwarf2_physname (name, die, cu);
13708 SYMBOL_SET_NAMES (sym, linkagename, strlen (linkagename), 0, objfile);
13709
13710 /* Fortran does not have mangling standard and the mangling does differ
13711 between gfortran, iFort etc. */
13712 if (cu->language == language_fortran
13713 && symbol_get_demangled_name (&(sym->ginfo)) == NULL)
13714 symbol_set_demangled_name (&(sym->ginfo),
13715 (char *) dwarf2_full_name (name, die, cu),
13716 NULL);
13717
13718 /* Default assumptions.
13719 Use the passed type or decode it from the die. */
13720 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
13721 SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
13722 if (type != NULL)
13723 SYMBOL_TYPE (sym) = type;
13724 else
13725 SYMBOL_TYPE (sym) = die_type (die, cu);
13726 attr = dwarf2_attr (die,
13727 inlined_func ? DW_AT_call_line : DW_AT_decl_line,
13728 cu);
13729 if (attr)
13730 {
13731 SYMBOL_LINE (sym) = DW_UNSND (attr);
13732 }
13733
13734 attr = dwarf2_attr (die,
13735 inlined_func ? DW_AT_call_file : DW_AT_decl_file,
13736 cu);
13737 if (attr)
13738 {
13739 int file_index = DW_UNSND (attr);
13740
13741 if (cu->line_header == NULL
13742 || file_index > cu->line_header->num_file_names)
13743 complaint (&symfile_complaints,
13744 _("file index out of range"));
13745 else if (file_index > 0)
13746 {
13747 struct file_entry *fe;
13748
13749 fe = &cu->line_header->file_names[file_index - 1];
13750 SYMBOL_SYMTAB (sym) = fe->symtab;
13751 }
13752 }
13753
13754 switch (die->tag)
13755 {
13756 case DW_TAG_label:
13757 attr = dwarf2_attr (die, DW_AT_low_pc, cu);
13758 if (attr)
13759 {
13760 SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr) + baseaddr;
13761 }
13762 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_core_addr;
13763 SYMBOL_DOMAIN (sym) = LABEL_DOMAIN;
13764 SYMBOL_CLASS (sym) = LOC_LABEL;
13765 add_symbol_to_list (sym, cu->list_in_scope);
13766 break;
13767 case DW_TAG_subprogram:
13768 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
13769 finish_block. */
13770 SYMBOL_CLASS (sym) = LOC_BLOCK;
13771 attr2 = dwarf2_attr (die, DW_AT_external, cu);
13772 if ((attr2 && (DW_UNSND (attr2) != 0))
13773 || cu->language == language_ada)
13774 {
13775 /* Subprograms marked external are stored as a global symbol.
13776 Ada subprograms, whether marked external or not, are always
13777 stored as a global symbol, because we want to be able to
13778 access them globally. For instance, we want to be able
13779 to break on a nested subprogram without having to
13780 specify the context. */
13781 list_to_add = &global_symbols;
13782 }
13783 else
13784 {
13785 list_to_add = cu->list_in_scope;
13786 }
13787 break;
13788 case DW_TAG_inlined_subroutine:
13789 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
13790 finish_block. */
13791 SYMBOL_CLASS (sym) = LOC_BLOCK;
13792 SYMBOL_INLINED (sym) = 1;
13793 list_to_add = cu->list_in_scope;
13794 break;
13795 case DW_TAG_template_value_param:
13796 suppress_add = 1;
13797 /* Fall through. */
13798 case DW_TAG_constant:
13799 case DW_TAG_variable:
13800 case DW_TAG_member:
13801 /* Compilation with minimal debug info may result in
13802 variables with missing type entries. Change the
13803 misleading `void' type to something sensible. */
13804 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
13805 SYMBOL_TYPE (sym)
13806 = objfile_type (objfile)->nodebug_data_symbol;
13807
13808 attr = dwarf2_attr (die, DW_AT_const_value, cu);
13809 /* In the case of DW_TAG_member, we should only be called for
13810 static const members. */
13811 if (die->tag == DW_TAG_member)
13812 {
13813 /* dwarf2_add_field uses die_is_declaration,
13814 so we do the same. */
13815 gdb_assert (die_is_declaration (die, cu));
13816 gdb_assert (attr);
13817 }
13818 if (attr)
13819 {
13820 dwarf2_const_value (attr, sym, cu);
13821 attr2 = dwarf2_attr (die, DW_AT_external, cu);
13822 if (!suppress_add)
13823 {
13824 if (attr2 && (DW_UNSND (attr2) != 0))
13825 list_to_add = &global_symbols;
13826 else
13827 list_to_add = cu->list_in_scope;
13828 }
13829 break;
13830 }
13831 attr = dwarf2_attr (die, DW_AT_location, cu);
13832 if (attr)
13833 {
13834 var_decode_location (attr, sym, cu);
13835 attr2 = dwarf2_attr (die, DW_AT_external, cu);
13836 if (SYMBOL_CLASS (sym) == LOC_STATIC
13837 && SYMBOL_VALUE_ADDRESS (sym) == 0
13838 && !dwarf2_per_objfile->has_section_at_zero)
13839 {
13840 /* When a static variable is eliminated by the linker,
13841 the corresponding debug information is not stripped
13842 out, but the variable address is set to null;
13843 do not add such variables into symbol table. */
13844 }
13845 else if (attr2 && (DW_UNSND (attr2) != 0))
13846 {
13847 /* Workaround gfortran PR debug/40040 - it uses
13848 DW_AT_location for variables in -fPIC libraries which may
13849 get overriden by other libraries/executable and get
13850 a different address. Resolve it by the minimal symbol
13851 which may come from inferior's executable using copy
13852 relocation. Make this workaround only for gfortran as for
13853 other compilers GDB cannot guess the minimal symbol
13854 Fortran mangling kind. */
13855 if (cu->language == language_fortran && die->parent
13856 && die->parent->tag == DW_TAG_module
13857 && cu->producer
13858 && strncmp (cu->producer, "GNU Fortran ", 12) == 0)
13859 SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
13860
13861 /* A variable with DW_AT_external is never static,
13862 but it may be block-scoped. */
13863 list_to_add = (cu->list_in_scope == &file_symbols
13864 ? &global_symbols : cu->list_in_scope);
13865 }
13866 else
13867 list_to_add = cu->list_in_scope;
13868 }
13869 else
13870 {
13871 /* We do not know the address of this symbol.
13872 If it is an external symbol and we have type information
13873 for it, enter the symbol as a LOC_UNRESOLVED symbol.
13874 The address of the variable will then be determined from
13875 the minimal symbol table whenever the variable is
13876 referenced. */
13877 attr2 = dwarf2_attr (die, DW_AT_external, cu);
13878 if (attr2 && (DW_UNSND (attr2) != 0)
13879 && dwarf2_attr (die, DW_AT_type, cu) != NULL)
13880 {
13881 /* A variable with DW_AT_external is never static, but it
13882 may be block-scoped. */
13883 list_to_add = (cu->list_in_scope == &file_symbols
13884 ? &global_symbols : cu->list_in_scope);
13885
13886 SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
13887 }
13888 else if (!die_is_declaration (die, cu))
13889 {
13890 /* Use the default LOC_OPTIMIZED_OUT class. */
13891 gdb_assert (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT);
13892 if (!suppress_add)
13893 list_to_add = cu->list_in_scope;
13894 }
13895 }
13896 break;
13897 case DW_TAG_formal_parameter:
13898 /* If we are inside a function, mark this as an argument. If
13899 not, we might be looking at an argument to an inlined function
13900 when we do not have enough information to show inlined frames;
13901 pretend it's a local variable in that case so that the user can
13902 still see it. */
13903 if (context_stack_depth > 0
13904 && context_stack[context_stack_depth - 1].name != NULL)
13905 SYMBOL_IS_ARGUMENT (sym) = 1;
13906 attr = dwarf2_attr (die, DW_AT_location, cu);
13907 if (attr)
13908 {
13909 var_decode_location (attr, sym, cu);
13910 }
13911 attr = dwarf2_attr (die, DW_AT_const_value, cu);
13912 if (attr)
13913 {
13914 dwarf2_const_value (attr, sym, cu);
13915 }
13916
13917 list_to_add = cu->list_in_scope;
13918 break;
13919 case DW_TAG_unspecified_parameters:
13920 /* From varargs functions; gdb doesn't seem to have any
13921 interest in this information, so just ignore it for now.
13922 (FIXME?) */
13923 break;
13924 case DW_TAG_template_type_param:
13925 suppress_add = 1;
13926 /* Fall through. */
13927 case DW_TAG_class_type:
13928 case DW_TAG_interface_type:
13929 case DW_TAG_structure_type:
13930 case DW_TAG_union_type:
13931 case DW_TAG_set_type:
13932 case DW_TAG_enumeration_type:
13933 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
13934 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
13935
13936 {
13937 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
13938 really ever be static objects: otherwise, if you try
13939 to, say, break of a class's method and you're in a file
13940 which doesn't mention that class, it won't work unless
13941 the check for all static symbols in lookup_symbol_aux
13942 saves you. See the OtherFileClass tests in
13943 gdb.c++/namespace.exp. */
13944
13945 if (!suppress_add)
13946 {
13947 list_to_add = (cu->list_in_scope == &file_symbols
13948 && (cu->language == language_cplus
13949 || cu->language == language_java)
13950 ? &global_symbols : cu->list_in_scope);
13951
13952 /* The semantics of C++ state that "struct foo {
13953 ... }" also defines a typedef for "foo". A Java
13954 class declaration also defines a typedef for the
13955 class. */
13956 if (cu->language == language_cplus
13957 || cu->language == language_java
13958 || cu->language == language_ada)
13959 {
13960 /* The symbol's name is already allocated along
13961 with this objfile, so we don't need to
13962 duplicate it for the type. */
13963 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
13964 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_SEARCH_NAME (sym);
13965 }
13966 }
13967 }
13968 break;
13969 case DW_TAG_typedef:
13970 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
13971 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
13972 list_to_add = cu->list_in_scope;
13973 break;
13974 case DW_TAG_base_type:
13975 case DW_TAG_subrange_type:
13976 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
13977 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
13978 list_to_add = cu->list_in_scope;
13979 break;
13980 case DW_TAG_enumerator:
13981 attr = dwarf2_attr (die, DW_AT_const_value, cu);
13982 if (attr)
13983 {
13984 dwarf2_const_value (attr, sym, cu);
13985 }
13986 {
13987 /* NOTE: carlton/2003-11-10: See comment above in the
13988 DW_TAG_class_type, etc. block. */
13989
13990 list_to_add = (cu->list_in_scope == &file_symbols
13991 && (cu->language == language_cplus
13992 || cu->language == language_java)
13993 ? &global_symbols : cu->list_in_scope);
13994 }
13995 break;
13996 case DW_TAG_namespace:
13997 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
13998 list_to_add = &global_symbols;
13999 break;
14000 default:
14001 /* Not a tag we recognize. Hopefully we aren't processing
14002 trash data, but since we must specifically ignore things
14003 we don't recognize, there is nothing else we should do at
14004 this point. */
14005 complaint (&symfile_complaints, _("unsupported tag: '%s'"),
14006 dwarf_tag_name (die->tag));
14007 break;
14008 }
14009
14010 if (suppress_add)
14011 {
14012 sym->hash_next = objfile->template_symbols;
14013 objfile->template_symbols = sym;
14014 list_to_add = NULL;
14015 }
14016
14017 if (list_to_add != NULL)
14018 add_symbol_to_list (sym, list_to_add);
14019
14020 /* For the benefit of old versions of GCC, check for anonymous
14021 namespaces based on the demangled name. */
14022 if (!processing_has_namespace_info
14023 && cu->language == language_cplus)
14024 cp_scan_for_anonymous_namespaces (sym, objfile);
14025 }
14026 return (sym);
14027 }
14028
14029 /* A wrapper for new_symbol_full that always allocates a new symbol. */
14030
14031 static struct symbol *
14032 new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
14033 {
14034 return new_symbol_full (die, type, cu, NULL);
14035 }
14036
14037 /* Given an attr with a DW_FORM_dataN value in host byte order,
14038 zero-extend it as appropriate for the symbol's type. The DWARF
14039 standard (v4) is not entirely clear about the meaning of using
14040 DW_FORM_dataN for a constant with a signed type, where the type is
14041 wider than the data. The conclusion of a discussion on the DWARF
14042 list was that this is unspecified. We choose to always zero-extend
14043 because that is the interpretation long in use by GCC. */
14044
14045 static gdb_byte *
14046 dwarf2_const_value_data (struct attribute *attr, struct type *type,
14047 const char *name, struct obstack *obstack,
14048 struct dwarf2_cu *cu, LONGEST *value, int bits)
14049 {
14050 struct objfile *objfile = cu->objfile;
14051 enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ?
14052 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
14053 LONGEST l = DW_UNSND (attr);
14054
14055 if (bits < sizeof (*value) * 8)
14056 {
14057 l &= ((LONGEST) 1 << bits) - 1;
14058 *value = l;
14059 }
14060 else if (bits == sizeof (*value) * 8)
14061 *value = l;
14062 else
14063 {
14064 gdb_byte *bytes = obstack_alloc (obstack, bits / 8);
14065 store_unsigned_integer (bytes, bits / 8, byte_order, l);
14066 return bytes;
14067 }
14068
14069 return NULL;
14070 }
14071
14072 /* Read a constant value from an attribute. Either set *VALUE, or if
14073 the value does not fit in *VALUE, set *BYTES - either already
14074 allocated on the objfile obstack, or newly allocated on OBSTACK,
14075 or, set *BATON, if we translated the constant to a location
14076 expression. */
14077
14078 static void
14079 dwarf2_const_value_attr (struct attribute *attr, struct type *type,
14080 const char *name, struct obstack *obstack,
14081 struct dwarf2_cu *cu,
14082 LONGEST *value, gdb_byte **bytes,
14083 struct dwarf2_locexpr_baton **baton)
14084 {
14085 struct objfile *objfile = cu->objfile;
14086 struct comp_unit_head *cu_header = &cu->header;
14087 struct dwarf_block *blk;
14088 enum bfd_endian byte_order = (bfd_big_endian (objfile->obfd) ?
14089 BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE);
14090
14091 *value = 0;
14092 *bytes = NULL;
14093 *baton = NULL;
14094
14095 switch (attr->form)
14096 {
14097 case DW_FORM_addr:
14098 case DW_FORM_GNU_addr_index:
14099 {
14100 gdb_byte *data;
14101
14102 if (TYPE_LENGTH (type) != cu_header->addr_size)
14103 dwarf2_const_value_length_mismatch_complaint (name,
14104 cu_header->addr_size,
14105 TYPE_LENGTH (type));
14106 /* Symbols of this form are reasonably rare, so we just
14107 piggyback on the existing location code rather than writing
14108 a new implementation of symbol_computed_ops. */
14109 *baton = obstack_alloc (&objfile->objfile_obstack,
14110 sizeof (struct dwarf2_locexpr_baton));
14111 (*baton)->per_cu = cu->per_cu;
14112 gdb_assert ((*baton)->per_cu);
14113
14114 (*baton)->size = 2 + cu_header->addr_size;
14115 data = obstack_alloc (&objfile->objfile_obstack, (*baton)->size);
14116 (*baton)->data = data;
14117
14118 data[0] = DW_OP_addr;
14119 store_unsigned_integer (&data[1], cu_header->addr_size,
14120 byte_order, DW_ADDR (attr));
14121 data[cu_header->addr_size + 1] = DW_OP_stack_value;
14122 }
14123 break;
14124 case DW_FORM_string:
14125 case DW_FORM_strp:
14126 case DW_FORM_GNU_str_index:
14127 /* DW_STRING is already allocated on the objfile obstack, point
14128 directly to it. */
14129 *bytes = (gdb_byte *) DW_STRING (attr);
14130 break;
14131 case DW_FORM_block1:
14132 case DW_FORM_block2:
14133 case DW_FORM_block4:
14134 case DW_FORM_block:
14135 case DW_FORM_exprloc:
14136 blk = DW_BLOCK (attr);
14137 if (TYPE_LENGTH (type) != blk->size)
14138 dwarf2_const_value_length_mismatch_complaint (name, blk->size,
14139 TYPE_LENGTH (type));
14140 *bytes = blk->data;
14141 break;
14142
14143 /* The DW_AT_const_value attributes are supposed to carry the
14144 symbol's value "represented as it would be on the target
14145 architecture." By the time we get here, it's already been
14146 converted to host endianness, so we just need to sign- or
14147 zero-extend it as appropriate. */
14148 case DW_FORM_data1:
14149 *bytes = dwarf2_const_value_data (attr, type, name,
14150 obstack, cu, value, 8);
14151 break;
14152 case DW_FORM_data2:
14153 *bytes = dwarf2_const_value_data (attr, type, name,
14154 obstack, cu, value, 16);
14155 break;
14156 case DW_FORM_data4:
14157 *bytes = dwarf2_const_value_data (attr, type, name,
14158 obstack, cu, value, 32);
14159 break;
14160 case DW_FORM_data8:
14161 *bytes = dwarf2_const_value_data (attr, type, name,
14162 obstack, cu, value, 64);
14163 break;
14164
14165 case DW_FORM_sdata:
14166 *value = DW_SND (attr);
14167 break;
14168
14169 case DW_FORM_udata:
14170 *value = DW_UNSND (attr);
14171 break;
14172
14173 default:
14174 complaint (&symfile_complaints,
14175 _("unsupported const value attribute form: '%s'"),
14176 dwarf_form_name (attr->form));
14177 *value = 0;
14178 break;
14179 }
14180 }
14181
14182
14183 /* Copy constant value from an attribute to a symbol. */
14184
14185 static void
14186 dwarf2_const_value (struct attribute *attr, struct symbol *sym,
14187 struct dwarf2_cu *cu)
14188 {
14189 struct objfile *objfile = cu->objfile;
14190 struct comp_unit_head *cu_header = &cu->header;
14191 LONGEST value;
14192 gdb_byte *bytes;
14193 struct dwarf2_locexpr_baton *baton;
14194
14195 dwarf2_const_value_attr (attr, SYMBOL_TYPE (sym),
14196 SYMBOL_PRINT_NAME (sym),
14197 &objfile->objfile_obstack, cu,
14198 &value, &bytes, &baton);
14199
14200 if (baton != NULL)
14201 {
14202 SYMBOL_COMPUTED_OPS (sym) = &dwarf2_locexpr_funcs;
14203 SYMBOL_LOCATION_BATON (sym) = baton;
14204 SYMBOL_CLASS (sym) = LOC_COMPUTED;
14205 }
14206 else if (bytes != NULL)
14207 {
14208 SYMBOL_VALUE_BYTES (sym) = bytes;
14209 SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
14210 }
14211 else
14212 {
14213 SYMBOL_VALUE (sym) = value;
14214 SYMBOL_CLASS (sym) = LOC_CONST;
14215 }
14216 }
14217
14218 /* Return the type of the die in question using its DW_AT_type attribute. */
14219
14220 static struct type *
14221 die_type (struct die_info *die, struct dwarf2_cu *cu)
14222 {
14223 struct attribute *type_attr;
14224
14225 type_attr = dwarf2_attr (die, DW_AT_type, cu);
14226 if (!type_attr)
14227 {
14228 /* A missing DW_AT_type represents a void type. */
14229 return objfile_type (cu->objfile)->builtin_void;
14230 }
14231
14232 return lookup_die_type (die, type_attr, cu);
14233 }
14234
14235 /* True iff CU's producer generates GNAT Ada auxiliary information
14236 that allows to find parallel types through that information instead
14237 of having to do expensive parallel lookups by type name. */
14238
14239 static int
14240 need_gnat_info (struct dwarf2_cu *cu)
14241 {
14242 /* FIXME: brobecker/2010-10-12: As of now, only the AdaCore version
14243 of GNAT produces this auxiliary information, without any indication
14244 that it is produced. Part of enhancing the FSF version of GNAT
14245 to produce that information will be to put in place an indicator
14246 that we can use in order to determine whether the descriptive type
14247 info is available or not. One suggestion that has been made is
14248 to use a new attribute, attached to the CU die. For now, assume
14249 that the descriptive type info is not available. */
14250 return 0;
14251 }
14252
14253 /* Return the auxiliary type of the die in question using its
14254 DW_AT_GNAT_descriptive_type attribute. Returns NULL if the
14255 attribute is not present. */
14256
14257 static struct type *
14258 die_descriptive_type (struct die_info *die, struct dwarf2_cu *cu)
14259 {
14260 struct attribute *type_attr;
14261
14262 type_attr = dwarf2_attr (die, DW_AT_GNAT_descriptive_type, cu);
14263 if (!type_attr)
14264 return NULL;
14265
14266 return lookup_die_type (die, type_attr, cu);
14267 }
14268
14269 /* If DIE has a descriptive_type attribute, then set the TYPE's
14270 descriptive type accordingly. */
14271
14272 static void
14273 set_descriptive_type (struct type *type, struct die_info *die,
14274 struct dwarf2_cu *cu)
14275 {
14276 struct type *descriptive_type = die_descriptive_type (die, cu);
14277
14278 if (descriptive_type)
14279 {
14280 ALLOCATE_GNAT_AUX_TYPE (type);
14281 TYPE_DESCRIPTIVE_TYPE (type) = descriptive_type;
14282 }
14283 }
14284
14285 /* Return the containing type of the die in question using its
14286 DW_AT_containing_type attribute. */
14287
14288 static struct type *
14289 die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
14290 {
14291 struct attribute *type_attr;
14292
14293 type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
14294 if (!type_attr)
14295 error (_("Dwarf Error: Problem turning containing type into gdb type "
14296 "[in module %s]"), cu->objfile->name);
14297
14298 return lookup_die_type (die, type_attr, cu);
14299 }
14300
14301 /* Look up the type of DIE in CU using its type attribute ATTR.
14302 If there is no type substitute an error marker. */
14303
14304 static struct type *
14305 lookup_die_type (struct die_info *die, struct attribute *attr,
14306 struct dwarf2_cu *cu)
14307 {
14308 struct objfile *objfile = cu->objfile;
14309 struct type *this_type;
14310
14311 /* First see if we have it cached. */
14312
14313 if (is_ref_attr (attr))
14314 {
14315 sect_offset offset = dwarf2_get_ref_die_offset (attr);
14316
14317 this_type = get_die_type_at_offset (offset, cu->per_cu);
14318 }
14319 else if (attr->form == DW_FORM_ref_sig8)
14320 {
14321 struct signatured_type *sig_type = DW_SIGNATURED_TYPE (attr);
14322
14323 /* sig_type will be NULL if the signatured type is missing from
14324 the debug info. */
14325 if (sig_type == NULL)
14326 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
14327 "at 0x%x [in module %s]"),
14328 die->offset.sect_off, objfile->name);
14329
14330 gdb_assert (sig_type->per_cu.is_debug_types);
14331 /* If we haven't filled in type_offset_in_section yet, then we
14332 haven't read the type in yet. */
14333 this_type = NULL;
14334 if (sig_type->type_offset_in_section.sect_off != 0)
14335 {
14336 this_type =
14337 get_die_type_at_offset (sig_type->type_offset_in_section,
14338 &sig_type->per_cu);
14339 }
14340 }
14341 else
14342 {
14343 dump_die_for_error (die);
14344 error (_("Dwarf Error: Bad type attribute %s [in module %s]"),
14345 dwarf_attr_name (attr->name), objfile->name);
14346 }
14347
14348 /* If not cached we need to read it in. */
14349
14350 if (this_type == NULL)
14351 {
14352 struct die_info *type_die;
14353 struct dwarf2_cu *type_cu = cu;
14354
14355 type_die = follow_die_ref_or_sig (die, attr, &type_cu);
14356 /* If we found the type now, it's probably because the type came
14357 from an inter-CU reference and the type's CU got expanded before
14358 ours. */
14359 this_type = get_die_type (type_die, type_cu);
14360 if (this_type == NULL)
14361 this_type = read_type_die_1 (type_die, type_cu);
14362 }
14363
14364 /* If we still don't have a type use an error marker. */
14365
14366 if (this_type == NULL)
14367 {
14368 char *message, *saved;
14369
14370 /* read_type_die already issued a complaint. */
14371 message = xstrprintf (_("<unknown type in %s, CU 0x%x, DIE 0x%x>"),
14372 objfile->name,
14373 cu->header.offset.sect_off,
14374 die->offset.sect_off);
14375 saved = obstack_copy0 (&objfile->objfile_obstack,
14376 message, strlen (message));
14377 xfree (message);
14378
14379 this_type = init_type (TYPE_CODE_ERROR, 0, 0, saved, objfile);
14380 }
14381
14382 return this_type;
14383 }
14384
14385 /* Return the type in DIE, CU.
14386 Returns NULL for invalid types.
14387
14388 This first does a lookup in the appropriate type_hash table,
14389 and only reads the die in if necessary.
14390
14391 NOTE: This can be called when reading in partial or full symbols. */
14392
14393 static struct type *
14394 read_type_die (struct die_info *die, struct dwarf2_cu *cu)
14395 {
14396 struct type *this_type;
14397
14398 this_type = get_die_type (die, cu);
14399 if (this_type)
14400 return this_type;
14401
14402 return read_type_die_1 (die, cu);
14403 }
14404
14405 /* Read the type in DIE, CU.
14406 Returns NULL for invalid types. */
14407
14408 static struct type *
14409 read_type_die_1 (struct die_info *die, struct dwarf2_cu *cu)
14410 {
14411 struct type *this_type = NULL;
14412
14413 switch (die->tag)
14414 {
14415 case DW_TAG_class_type:
14416 case DW_TAG_interface_type:
14417 case DW_TAG_structure_type:
14418 case DW_TAG_union_type:
14419 this_type = read_structure_type (die, cu);
14420 break;
14421 case DW_TAG_enumeration_type:
14422 this_type = read_enumeration_type (die, cu);
14423 break;
14424 case DW_TAG_subprogram:
14425 case DW_TAG_subroutine_type:
14426 case DW_TAG_inlined_subroutine:
14427 this_type = read_subroutine_type (die, cu);
14428 break;
14429 case DW_TAG_array_type:
14430 this_type = read_array_type (die, cu);
14431 break;
14432 case DW_TAG_set_type:
14433 this_type = read_set_type (die, cu);
14434 break;
14435 case DW_TAG_pointer_type:
14436 this_type = read_tag_pointer_type (die, cu);
14437 break;
14438 case DW_TAG_ptr_to_member_type:
14439 this_type = read_tag_ptr_to_member_type (die, cu);
14440 break;
14441 case DW_TAG_reference_type:
14442 this_type = read_tag_reference_type (die, cu);
14443 break;
14444 case DW_TAG_const_type:
14445 this_type = read_tag_const_type (die, cu);
14446 break;
14447 case DW_TAG_volatile_type:
14448 this_type = read_tag_volatile_type (die, cu);
14449 break;
14450 case DW_TAG_string_type:
14451 this_type = read_tag_string_type (die, cu);
14452 break;
14453 case DW_TAG_typedef:
14454 this_type = read_typedef (die, cu);
14455 break;
14456 case DW_TAG_subrange_type:
14457 this_type = read_subrange_type (die, cu);
14458 break;
14459 case DW_TAG_base_type:
14460 this_type = read_base_type (die, cu);
14461 break;
14462 case DW_TAG_unspecified_type:
14463 this_type = read_unspecified_type (die, cu);
14464 break;
14465 case DW_TAG_namespace:
14466 this_type = read_namespace_type (die, cu);
14467 break;
14468 case DW_TAG_module:
14469 this_type = read_module_type (die, cu);
14470 break;
14471 default:
14472 complaint (&symfile_complaints,
14473 _("unexpected tag in read_type_die: '%s'"),
14474 dwarf_tag_name (die->tag));
14475 break;
14476 }
14477
14478 return this_type;
14479 }
14480
14481 /* See if we can figure out if the class lives in a namespace. We do
14482 this by looking for a member function; its demangled name will
14483 contain namespace info, if there is any.
14484 Return the computed name or NULL.
14485 Space for the result is allocated on the objfile's obstack.
14486 This is the full-die version of guess_partial_die_structure_name.
14487 In this case we know DIE has no useful parent. */
14488
14489 static char *
14490 guess_full_die_structure_name (struct die_info *die, struct dwarf2_cu *cu)
14491 {
14492 struct die_info *spec_die;
14493 struct dwarf2_cu *spec_cu;
14494 struct die_info *child;
14495
14496 spec_cu = cu;
14497 spec_die = die_specification (die, &spec_cu);
14498 if (spec_die != NULL)
14499 {
14500 die = spec_die;
14501 cu = spec_cu;
14502 }
14503
14504 for (child = die->child;
14505 child != NULL;
14506 child = child->sibling)
14507 {
14508 if (child->tag == DW_TAG_subprogram)
14509 {
14510 struct attribute *attr;
14511
14512 attr = dwarf2_attr (child, DW_AT_linkage_name, cu);
14513 if (attr == NULL)
14514 attr = dwarf2_attr (child, DW_AT_MIPS_linkage_name, cu);
14515 if (attr != NULL)
14516 {
14517 char *actual_name
14518 = language_class_name_from_physname (cu->language_defn,
14519 DW_STRING (attr));
14520 char *name = NULL;
14521
14522 if (actual_name != NULL)
14523 {
14524 char *die_name = dwarf2_name (die, cu);
14525
14526 if (die_name != NULL
14527 && strcmp (die_name, actual_name) != 0)
14528 {
14529 /* Strip off the class name from the full name.
14530 We want the prefix. */
14531 int die_name_len = strlen (die_name);
14532 int actual_name_len = strlen (actual_name);
14533
14534 /* Test for '::' as a sanity check. */
14535 if (actual_name_len > die_name_len + 2
14536 && actual_name[actual_name_len
14537 - die_name_len - 1] == ':')
14538 name =
14539 obsavestring (actual_name,
14540 actual_name_len - die_name_len - 2,
14541 &cu->objfile->objfile_obstack);
14542 }
14543 }
14544 xfree (actual_name);
14545 return name;
14546 }
14547 }
14548 }
14549
14550 return NULL;
14551 }
14552
14553 /* GCC might emit a nameless typedef that has a linkage name. Determine the
14554 prefix part in such case. See
14555 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
14556
14557 static char *
14558 anonymous_struct_prefix (struct die_info *die, struct dwarf2_cu *cu)
14559 {
14560 struct attribute *attr;
14561 char *base;
14562
14563 if (die->tag != DW_TAG_class_type && die->tag != DW_TAG_interface_type
14564 && die->tag != DW_TAG_structure_type && die->tag != DW_TAG_union_type)
14565 return NULL;
14566
14567 attr = dwarf2_attr (die, DW_AT_name, cu);
14568 if (attr != NULL && DW_STRING (attr) != NULL)
14569 return NULL;
14570
14571 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
14572 if (attr == NULL)
14573 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
14574 if (attr == NULL || DW_STRING (attr) == NULL)
14575 return NULL;
14576
14577 /* dwarf2_name had to be already called. */
14578 gdb_assert (DW_STRING_IS_CANONICAL (attr));
14579
14580 /* Strip the base name, keep any leading namespaces/classes. */
14581 base = strrchr (DW_STRING (attr), ':');
14582 if (base == NULL || base == DW_STRING (attr) || base[-1] != ':')
14583 return "";
14584
14585 return obsavestring (DW_STRING (attr), &base[-1] - DW_STRING (attr),
14586 &cu->objfile->objfile_obstack);
14587 }
14588
14589 /* Return the name of the namespace/class that DIE is defined within,
14590 or "" if we can't tell. The caller should not xfree the result.
14591
14592 For example, if we're within the method foo() in the following
14593 code:
14594
14595 namespace N {
14596 class C {
14597 void foo () {
14598 }
14599 };
14600 }
14601
14602 then determine_prefix on foo's die will return "N::C". */
14603
14604 static const char *
14605 determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
14606 {
14607 struct die_info *parent, *spec_die;
14608 struct dwarf2_cu *spec_cu;
14609 struct type *parent_type;
14610 char *retval;
14611
14612 if (cu->language != language_cplus && cu->language != language_java
14613 && cu->language != language_fortran)
14614 return "";
14615
14616 retval = anonymous_struct_prefix (die, cu);
14617 if (retval)
14618 return retval;
14619
14620 /* We have to be careful in the presence of DW_AT_specification.
14621 For example, with GCC 3.4, given the code
14622
14623 namespace N {
14624 void foo() {
14625 // Definition of N::foo.
14626 }
14627 }
14628
14629 then we'll have a tree of DIEs like this:
14630
14631 1: DW_TAG_compile_unit
14632 2: DW_TAG_namespace // N
14633 3: DW_TAG_subprogram // declaration of N::foo
14634 4: DW_TAG_subprogram // definition of N::foo
14635 DW_AT_specification // refers to die #3
14636
14637 Thus, when processing die #4, we have to pretend that we're in
14638 the context of its DW_AT_specification, namely the contex of die
14639 #3. */
14640 spec_cu = cu;
14641 spec_die = die_specification (die, &spec_cu);
14642 if (spec_die == NULL)
14643 parent = die->parent;
14644 else
14645 {
14646 parent = spec_die->parent;
14647 cu = spec_cu;
14648 }
14649
14650 if (parent == NULL)
14651 return "";
14652 else if (parent->building_fullname)
14653 {
14654 const char *name;
14655 const char *parent_name;
14656
14657 /* It has been seen on RealView 2.2 built binaries,
14658 DW_TAG_template_type_param types actually _defined_ as
14659 children of the parent class:
14660
14661 enum E {};
14662 template class <class Enum> Class{};
14663 Class<enum E> class_e;
14664
14665 1: DW_TAG_class_type (Class)
14666 2: DW_TAG_enumeration_type (E)
14667 3: DW_TAG_enumerator (enum1:0)
14668 3: DW_TAG_enumerator (enum2:1)
14669 ...
14670 2: DW_TAG_template_type_param
14671 DW_AT_type DW_FORM_ref_udata (E)
14672
14673 Besides being broken debug info, it can put GDB into an
14674 infinite loop. Consider:
14675
14676 When we're building the full name for Class<E>, we'll start
14677 at Class, and go look over its template type parameters,
14678 finding E. We'll then try to build the full name of E, and
14679 reach here. We're now trying to build the full name of E,
14680 and look over the parent DIE for containing scope. In the
14681 broken case, if we followed the parent DIE of E, we'd again
14682 find Class, and once again go look at its template type
14683 arguments, etc., etc. Simply don't consider such parent die
14684 as source-level parent of this die (it can't be, the language
14685 doesn't allow it), and break the loop here. */
14686 name = dwarf2_name (die, cu);
14687 parent_name = dwarf2_name (parent, cu);
14688 complaint (&symfile_complaints,
14689 _("template param type '%s' defined within parent '%s'"),
14690 name ? name : "<unknown>",
14691 parent_name ? parent_name : "<unknown>");
14692 return "";
14693 }
14694 else
14695 switch (parent->tag)
14696 {
14697 case DW_TAG_namespace:
14698 parent_type = read_type_die (parent, cu);
14699 /* GCC 4.0 and 4.1 had a bug (PR c++/28460) where they generated bogus
14700 DW_TAG_namespace DIEs with a name of "::" for the global namespace.
14701 Work around this problem here. */
14702 if (cu->language == language_cplus
14703 && strcmp (TYPE_TAG_NAME (parent_type), "::") == 0)
14704 return "";
14705 /* We give a name to even anonymous namespaces. */
14706 return TYPE_TAG_NAME (parent_type);
14707 case DW_TAG_class_type:
14708 case DW_TAG_interface_type:
14709 case DW_TAG_structure_type:
14710 case DW_TAG_union_type:
14711 case DW_TAG_module:
14712 parent_type = read_type_die (parent, cu);
14713 if (TYPE_TAG_NAME (parent_type) != NULL)
14714 return TYPE_TAG_NAME (parent_type);
14715 else
14716 /* An anonymous structure is only allowed non-static data
14717 members; no typedefs, no member functions, et cetera.
14718 So it does not need a prefix. */
14719 return "";
14720 case DW_TAG_compile_unit:
14721 case DW_TAG_partial_unit:
14722 /* gcc-4.5 -gdwarf-4 can drop the enclosing namespace. Cope. */
14723 if (cu->language == language_cplus
14724 && !VEC_empty (dwarf2_section_info_def, dwarf2_per_objfile->types)
14725 && die->child != NULL
14726 && (die->tag == DW_TAG_class_type
14727 || die->tag == DW_TAG_structure_type
14728 || die->tag == DW_TAG_union_type))
14729 {
14730 char *name = guess_full_die_structure_name (die, cu);
14731 if (name != NULL)
14732 return name;
14733 }
14734 return "";
14735 default:
14736 return determine_prefix (parent, cu);
14737 }
14738 }
14739
14740 /* Return a newly-allocated string formed by concatenating PREFIX and SUFFIX
14741 with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then
14742 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, perform
14743 an obconcat, otherwise allocate storage for the result. The CU argument is
14744 used to determine the language and hence, the appropriate separator. */
14745
14746 #define MAX_SEP_LEN 7 /* strlen ("__") + strlen ("_MOD_") */
14747
14748 static char *
14749 typename_concat (struct obstack *obs, const char *prefix, const char *suffix,
14750 int physname, struct dwarf2_cu *cu)
14751 {
14752 const char *lead = "";
14753 const char *sep;
14754
14755 if (suffix == NULL || suffix[0] == '\0'
14756 || prefix == NULL || prefix[0] == '\0')
14757 sep = "";
14758 else if (cu->language == language_java)
14759 sep = ".";
14760 else if (cu->language == language_fortran && physname)
14761 {
14762 /* This is gfortran specific mangling. Normally DW_AT_linkage_name or
14763 DW_AT_MIPS_linkage_name is preferred and used instead. */
14764
14765 lead = "__";
14766 sep = "_MOD_";
14767 }
14768 else
14769 sep = "::";
14770
14771 if (prefix == NULL)
14772 prefix = "";
14773 if (suffix == NULL)
14774 suffix = "";
14775
14776 if (obs == NULL)
14777 {
14778 char *retval
14779 = xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1);
14780
14781 strcpy (retval, lead);
14782 strcat (retval, prefix);
14783 strcat (retval, sep);
14784 strcat (retval, suffix);
14785 return retval;
14786 }
14787 else
14788 {
14789 /* We have an obstack. */
14790 return obconcat (obs, lead, prefix, sep, suffix, (char *) NULL);
14791 }
14792 }
14793
14794 /* Return sibling of die, NULL if no sibling. */
14795
14796 static struct die_info *
14797 sibling_die (struct die_info *die)
14798 {
14799 return die->sibling;
14800 }
14801
14802 /* Get name of a die, return NULL if not found. */
14803
14804 static char *
14805 dwarf2_canonicalize_name (char *name, struct dwarf2_cu *cu,
14806 struct obstack *obstack)
14807 {
14808 if (name && cu->language == language_cplus)
14809 {
14810 char *canon_name = cp_canonicalize_string (name);
14811
14812 if (canon_name != NULL)
14813 {
14814 if (strcmp (canon_name, name) != 0)
14815 name = obsavestring (canon_name, strlen (canon_name),
14816 obstack);
14817 xfree (canon_name);
14818 }
14819 }
14820
14821 return name;
14822 }
14823
14824 /* Get name of a die, return NULL if not found. */
14825
14826 static char *
14827 dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
14828 {
14829 struct attribute *attr;
14830
14831 attr = dwarf2_attr (die, DW_AT_name, cu);
14832 if ((!attr || !DW_STRING (attr))
14833 && die->tag != DW_TAG_class_type
14834 && die->tag != DW_TAG_interface_type
14835 && die->tag != DW_TAG_structure_type
14836 && die->tag != DW_TAG_union_type)
14837 return NULL;
14838
14839 switch (die->tag)
14840 {
14841 case DW_TAG_compile_unit:
14842 case DW_TAG_partial_unit:
14843 /* Compilation units have a DW_AT_name that is a filename, not
14844 a source language identifier. */
14845 case DW_TAG_enumeration_type:
14846 case DW_TAG_enumerator:
14847 /* These tags always have simple identifiers already; no need
14848 to canonicalize them. */
14849 return DW_STRING (attr);
14850
14851 case DW_TAG_subprogram:
14852 /* Java constructors will all be named "<init>", so return
14853 the class name when we see this special case. */
14854 if (cu->language == language_java
14855 && DW_STRING (attr) != NULL
14856 && strcmp (DW_STRING (attr), "<init>") == 0)
14857 {
14858 struct dwarf2_cu *spec_cu = cu;
14859 struct die_info *spec_die;
14860
14861 /* GCJ will output '<init>' for Java constructor names.
14862 For this special case, return the name of the parent class. */
14863
14864 /* GCJ may output suprogram DIEs with AT_specification set.
14865 If so, use the name of the specified DIE. */
14866 spec_die = die_specification (die, &spec_cu);
14867 if (spec_die != NULL)
14868 return dwarf2_name (spec_die, spec_cu);
14869
14870 do
14871 {
14872 die = die->parent;
14873 if (die->tag == DW_TAG_class_type)
14874 return dwarf2_name (die, cu);
14875 }
14876 while (die->tag != DW_TAG_compile_unit
14877 && die->tag != DW_TAG_partial_unit);
14878 }
14879 break;
14880
14881 case DW_TAG_class_type:
14882 case DW_TAG_interface_type:
14883 case DW_TAG_structure_type:
14884 case DW_TAG_union_type:
14885 /* Some GCC versions emit spurious DW_AT_name attributes for unnamed
14886 structures or unions. These were of the form "._%d" in GCC 4.1,
14887 or simply "<anonymous struct>" or "<anonymous union>" in GCC 4.3
14888 and GCC 4.4. We work around this problem by ignoring these. */
14889 if (attr && DW_STRING (attr)
14890 && (strncmp (DW_STRING (attr), "._", 2) == 0
14891 || strncmp (DW_STRING (attr), "<anonymous", 10) == 0))
14892 return NULL;
14893
14894 /* GCC might emit a nameless typedef that has a linkage name. See
14895 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47510. */
14896 if (!attr || DW_STRING (attr) == NULL)
14897 {
14898 char *demangled = NULL;
14899
14900 attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
14901 if (attr == NULL)
14902 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
14903
14904 if (attr == NULL || DW_STRING (attr) == NULL)
14905 return NULL;
14906
14907 /* Avoid demangling DW_STRING (attr) the second time on a second
14908 call for the same DIE. */
14909 if (!DW_STRING_IS_CANONICAL (attr))
14910 demangled = cplus_demangle (DW_STRING (attr), DMGL_TYPES);
14911
14912 if (demangled)
14913 {
14914 char *base;
14915
14916 /* FIXME: we already did this for the partial symbol... */
14917 DW_STRING (attr) = obsavestring (demangled, strlen (demangled),
14918 &cu->objfile->objfile_obstack);
14919 DW_STRING_IS_CANONICAL (attr) = 1;
14920 xfree (demangled);
14921
14922 /* Strip any leading namespaces/classes, keep only the base name.
14923 DW_AT_name for named DIEs does not contain the prefixes. */
14924 base = strrchr (DW_STRING (attr), ':');
14925 if (base && base > DW_STRING (attr) && base[-1] == ':')
14926 return &base[1];
14927 else
14928 return DW_STRING (attr);
14929 }
14930 }
14931 break;
14932
14933 default:
14934 break;
14935 }
14936
14937 if (!DW_STRING_IS_CANONICAL (attr))
14938 {
14939 DW_STRING (attr)
14940 = dwarf2_canonicalize_name (DW_STRING (attr), cu,
14941 &cu->objfile->objfile_obstack);
14942 DW_STRING_IS_CANONICAL (attr) = 1;
14943 }
14944 return DW_STRING (attr);
14945 }
14946
14947 /* Return the die that this die in an extension of, or NULL if there
14948 is none. *EXT_CU is the CU containing DIE on input, and the CU
14949 containing the return value on output. */
14950
14951 static struct die_info *
14952 dwarf2_extension (struct die_info *die, struct dwarf2_cu **ext_cu)
14953 {
14954 struct attribute *attr;
14955
14956 attr = dwarf2_attr (die, DW_AT_extension, *ext_cu);
14957 if (attr == NULL)
14958 return NULL;
14959
14960 return follow_die_ref (die, attr, ext_cu);
14961 }
14962
14963 /* Convert a DIE tag into its string name. */
14964
14965 static const char *
14966 dwarf_tag_name (unsigned tag)
14967 {
14968 const char *name = get_DW_TAG_name (tag);
14969
14970 if (name == NULL)
14971 return "DW_TAG_<unknown>";
14972
14973 return name;
14974 }
14975
14976 /* Convert a DWARF attribute code into its string name. */
14977
14978 static const char *
14979 dwarf_attr_name (unsigned attr)
14980 {
14981 const char *name;
14982
14983 #ifdef MIPS /* collides with DW_AT_HP_block_index */
14984 if (attr == DW_AT_MIPS_fde)
14985 return "DW_AT_MIPS_fde";
14986 #else
14987 if (attr == DW_AT_HP_block_index)
14988 return "DW_AT_HP_block_index";
14989 #endif
14990
14991 name = get_DW_AT_name (attr);
14992
14993 if (name == NULL)
14994 return "DW_AT_<unknown>";
14995
14996 return name;
14997 }
14998
14999 /* Convert a DWARF value form code into its string name. */
15000
15001 static const char *
15002 dwarf_form_name (unsigned form)
15003 {
15004 const char *name = get_DW_FORM_name (form);
15005
15006 if (name == NULL)
15007 return "DW_FORM_<unknown>";
15008
15009 return name;
15010 }
15011
15012 static char *
15013 dwarf_bool_name (unsigned mybool)
15014 {
15015 if (mybool)
15016 return "TRUE";
15017 else
15018 return "FALSE";
15019 }
15020
15021 /* Convert a DWARF type code into its string name. */
15022
15023 static const char *
15024 dwarf_type_encoding_name (unsigned enc)
15025 {
15026 const char *name = get_DW_ATE_name (enc);
15027
15028 if (name == NULL)
15029 return "DW_ATE_<unknown>";
15030
15031 return name;
15032 }
15033
15034 static void
15035 dump_die_shallow (struct ui_file *f, int indent, struct die_info *die)
15036 {
15037 unsigned int i;
15038
15039 print_spaces (indent, f);
15040 fprintf_unfiltered (f, "Die: %s (abbrev %d, offset 0x%x)\n",
15041 dwarf_tag_name (die->tag), die->abbrev, die->offset.sect_off);
15042
15043 if (die->parent != NULL)
15044 {
15045 print_spaces (indent, f);
15046 fprintf_unfiltered (f, " parent at offset: 0x%x\n",
15047 die->parent->offset.sect_off);
15048 }
15049
15050 print_spaces (indent, f);
15051 fprintf_unfiltered (f, " has children: %s\n",
15052 dwarf_bool_name (die->child != NULL));
15053
15054 print_spaces (indent, f);
15055 fprintf_unfiltered (f, " attributes:\n");
15056
15057 for (i = 0; i < die->num_attrs; ++i)
15058 {
15059 print_spaces (indent, f);
15060 fprintf_unfiltered (f, " %s (%s) ",
15061 dwarf_attr_name (die->attrs[i].name),
15062 dwarf_form_name (die->attrs[i].form));
15063
15064 switch (die->attrs[i].form)
15065 {
15066 case DW_FORM_addr:
15067 case DW_FORM_GNU_addr_index:
15068 fprintf_unfiltered (f, "address: ");
15069 fputs_filtered (hex_string (DW_ADDR (&die->attrs[i])), f);
15070 break;
15071 case DW_FORM_block2:
15072 case DW_FORM_block4:
15073 case DW_FORM_block:
15074 case DW_FORM_block1:
15075 fprintf_unfiltered (f, "block: size %d",
15076 DW_BLOCK (&die->attrs[i])->size);
15077 break;
15078 case DW_FORM_exprloc:
15079 fprintf_unfiltered (f, "expression: size %u",
15080 DW_BLOCK (&die->attrs[i])->size);
15081 break;
15082 case DW_FORM_ref_addr:
15083 fprintf_unfiltered (f, "ref address: ");
15084 fputs_filtered (hex_string (DW_UNSND (&die->attrs[i])), f);
15085 break;
15086 case DW_FORM_ref1:
15087 case DW_FORM_ref2:
15088 case DW_FORM_ref4:
15089 case DW_FORM_ref8:
15090 case DW_FORM_ref_udata:
15091 fprintf_unfiltered (f, "constant ref: 0x%lx (adjusted)",
15092 (long) (DW_UNSND (&die->attrs[i])));
15093 break;
15094 case DW_FORM_data1:
15095 case DW_FORM_data2:
15096 case DW_FORM_data4:
15097 case DW_FORM_data8:
15098 case DW_FORM_udata:
15099 case DW_FORM_sdata:
15100 fprintf_unfiltered (f, "constant: %s",
15101 pulongest (DW_UNSND (&die->attrs[i])));
15102 break;
15103 case DW_FORM_sec_offset:
15104 fprintf_unfiltered (f, "section offset: %s",
15105 pulongest (DW_UNSND (&die->attrs[i])));
15106 break;
15107 case DW_FORM_ref_sig8:
15108 if (DW_SIGNATURED_TYPE (&die->attrs[i]) != NULL)
15109 fprintf_unfiltered (f, "signatured type, offset: 0x%x",
15110 DW_SIGNATURED_TYPE (&die->attrs[i])->per_cu.offset.sect_off);
15111 else
15112 fprintf_unfiltered (f, "signatured type, offset: unknown");
15113 break;
15114 case DW_FORM_string:
15115 case DW_FORM_strp:
15116 case DW_FORM_GNU_str_index:
15117 fprintf_unfiltered (f, "string: \"%s\" (%s canonicalized)",
15118 DW_STRING (&die->attrs[i])
15119 ? DW_STRING (&die->attrs[i]) : "",
15120 DW_STRING_IS_CANONICAL (&die->attrs[i]) ? "is" : "not");
15121 break;
15122 case DW_FORM_flag:
15123 if (DW_UNSND (&die->attrs[i]))
15124 fprintf_unfiltered (f, "flag: TRUE");
15125 else
15126 fprintf_unfiltered (f, "flag: FALSE");
15127 break;
15128 case DW_FORM_flag_present:
15129 fprintf_unfiltered (f, "flag: TRUE");
15130 break;
15131 case DW_FORM_indirect:
15132 /* The reader will have reduced the indirect form to
15133 the "base form" so this form should not occur. */
15134 fprintf_unfiltered (f,
15135 "unexpected attribute form: DW_FORM_indirect");
15136 break;
15137 default:
15138 fprintf_unfiltered (f, "unsupported attribute form: %d.",
15139 die->attrs[i].form);
15140 break;
15141 }
15142 fprintf_unfiltered (f, "\n");
15143 }
15144 }
15145
15146 static void
15147 dump_die_for_error (struct die_info *die)
15148 {
15149 dump_die_shallow (gdb_stderr, 0, die);
15150 }
15151
15152 static void
15153 dump_die_1 (struct ui_file *f, int level, int max_level, struct die_info *die)
15154 {
15155 int indent = level * 4;
15156
15157 gdb_assert (die != NULL);
15158
15159 if (level >= max_level)
15160 return;
15161
15162 dump_die_shallow (f, indent, die);
15163
15164 if (die->child != NULL)
15165 {
15166 print_spaces (indent, f);
15167 fprintf_unfiltered (f, " Children:");
15168 if (level + 1 < max_level)
15169 {
15170 fprintf_unfiltered (f, "\n");
15171 dump_die_1 (f, level + 1, max_level, die->child);
15172 }
15173 else
15174 {
15175 fprintf_unfiltered (f,
15176 " [not printed, max nesting level reached]\n");
15177 }
15178 }
15179
15180 if (die->sibling != NULL && level > 0)
15181 {
15182 dump_die_1 (f, level, max_level, die->sibling);
15183 }
15184 }
15185
15186 /* This is called from the pdie macro in gdbinit.in.
15187 It's not static so gcc will keep a copy callable from gdb. */
15188
15189 void
15190 dump_die (struct die_info *die, int max_level)
15191 {
15192 dump_die_1 (gdb_stdlog, 0, max_level, die);
15193 }
15194
15195 static void
15196 store_in_ref_table (struct die_info *die, struct dwarf2_cu *cu)
15197 {
15198 void **slot;
15199
15200 slot = htab_find_slot_with_hash (cu->die_hash, die, die->offset.sect_off,
15201 INSERT);
15202
15203 *slot = die;
15204 }
15205
15206 /* DW_ADDR is always stored already as sect_offset; despite for the forms
15207 besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */
15208
15209 static int
15210 is_ref_attr (struct attribute *attr)
15211 {
15212 switch (attr->form)
15213 {
15214 case DW_FORM_ref_addr:
15215 case DW_FORM_ref1:
15216 case DW_FORM_ref2:
15217 case DW_FORM_ref4:
15218 case DW_FORM_ref8:
15219 case DW_FORM_ref_udata:
15220 return 1;
15221 default:
15222 return 0;
15223 }
15224 }
15225
15226 /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the
15227 required kind. */
15228
15229 static sect_offset
15230 dwarf2_get_ref_die_offset (struct attribute *attr)
15231 {
15232 sect_offset retval = { DW_UNSND (attr) };
15233
15234 if (is_ref_attr (attr))
15235 return retval;
15236
15237 retval.sect_off = 0;
15238 complaint (&symfile_complaints,
15239 _("unsupported die ref attribute form: '%s'"),
15240 dwarf_form_name (attr->form));
15241 return retval;
15242 }
15243
15244 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
15245 * the value held by the attribute is not constant. */
15246
15247 static LONGEST
15248 dwarf2_get_attr_constant_value (struct attribute *attr, int default_value)
15249 {
15250 if (attr->form == DW_FORM_sdata)
15251 return DW_SND (attr);
15252 else if (attr->form == DW_FORM_udata
15253 || attr->form == DW_FORM_data1
15254 || attr->form == DW_FORM_data2
15255 || attr->form == DW_FORM_data4
15256 || attr->form == DW_FORM_data8)
15257 return DW_UNSND (attr);
15258 else
15259 {
15260 complaint (&symfile_complaints,
15261 _("Attribute value is not a constant (%s)"),
15262 dwarf_form_name (attr->form));
15263 return default_value;
15264 }
15265 }
15266
15267 /* Follow reference or signature attribute ATTR of SRC_DIE.
15268 On entry *REF_CU is the CU of SRC_DIE.
15269 On exit *REF_CU is the CU of the result. */
15270
15271 static struct die_info *
15272 follow_die_ref_or_sig (struct die_info *src_die, struct attribute *attr,
15273 struct dwarf2_cu **ref_cu)
15274 {
15275 struct die_info *die;
15276
15277 if (is_ref_attr (attr))
15278 die = follow_die_ref (src_die, attr, ref_cu);
15279 else if (attr->form == DW_FORM_ref_sig8)
15280 die = follow_die_sig (src_die, attr, ref_cu);
15281 else
15282 {
15283 dump_die_for_error (src_die);
15284 error (_("Dwarf Error: Expected reference attribute [in module %s]"),
15285 (*ref_cu)->objfile->name);
15286 }
15287
15288 return die;
15289 }
15290
15291 /* Follow reference OFFSET.
15292 On entry *REF_CU is the CU of the source die referencing OFFSET.
15293 On exit *REF_CU is the CU of the result.
15294 Returns NULL if OFFSET is invalid. */
15295
15296 static struct die_info *
15297 follow_die_offset (sect_offset offset, struct dwarf2_cu **ref_cu)
15298 {
15299 struct die_info temp_die;
15300 struct dwarf2_cu *target_cu, *cu = *ref_cu;
15301
15302 gdb_assert (cu->per_cu != NULL);
15303
15304 target_cu = cu;
15305
15306 if (cu->per_cu->is_debug_types)
15307 {
15308 /* .debug_types CUs cannot reference anything outside their CU.
15309 If they need to, they have to reference a signatured type via
15310 DW_FORM_ref_sig8. */
15311 if (! offset_in_cu_p (&cu->header, offset))
15312 return NULL;
15313 }
15314 else if (! offset_in_cu_p (&cu->header, offset))
15315 {
15316 struct dwarf2_per_cu_data *per_cu;
15317
15318 per_cu = dwarf2_find_containing_comp_unit (offset, cu->objfile);
15319
15320 /* If necessary, add it to the queue and load its DIEs. */
15321 if (maybe_queue_comp_unit (cu, per_cu, cu->language))
15322 load_full_comp_unit (per_cu, cu->language);
15323
15324 target_cu = per_cu->cu;
15325 }
15326 else if (cu->dies == NULL)
15327 {
15328 /* We're loading full DIEs during partial symbol reading. */
15329 gdb_assert (dwarf2_per_objfile->reading_partial_symbols);
15330 load_full_comp_unit (cu->per_cu, language_minimal);
15331 }
15332
15333 *ref_cu = target_cu;
15334 temp_die.offset = offset;
15335 return htab_find_with_hash (target_cu->die_hash, &temp_die, offset.sect_off);
15336 }
15337
15338 /* Follow reference attribute ATTR of SRC_DIE.
15339 On entry *REF_CU is the CU of SRC_DIE.
15340 On exit *REF_CU is the CU of the result. */
15341
15342 static struct die_info *
15343 follow_die_ref (struct die_info *src_die, struct attribute *attr,
15344 struct dwarf2_cu **ref_cu)
15345 {
15346 sect_offset offset = dwarf2_get_ref_die_offset (attr);
15347 struct dwarf2_cu *cu = *ref_cu;
15348 struct die_info *die;
15349
15350 die = follow_die_offset (offset, ref_cu);
15351 if (!die)
15352 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE "
15353 "at 0x%x [in module %s]"),
15354 offset.sect_off, src_die->offset.sect_off, cu->objfile->name);
15355
15356 return die;
15357 }
15358
15359 /* Return DWARF block referenced by DW_AT_location of DIE at OFFSET at PER_CU.
15360 Returned value is intended for DW_OP_call*. Returned
15361 dwarf2_locexpr_baton->data has lifetime of PER_CU->OBJFILE. */
15362
15363 struct dwarf2_locexpr_baton
15364 dwarf2_fetch_die_location_block (cu_offset offset_in_cu,
15365 struct dwarf2_per_cu_data *per_cu,
15366 CORE_ADDR (*get_frame_pc) (void *baton),
15367 void *baton)
15368 {
15369 sect_offset offset = { per_cu->offset.sect_off + offset_in_cu.cu_off };
15370 struct dwarf2_cu *cu;
15371 struct die_info *die;
15372 struct attribute *attr;
15373 struct dwarf2_locexpr_baton retval;
15374
15375 dw2_setup (per_cu->objfile);
15376
15377 if (per_cu->cu == NULL)
15378 load_cu (per_cu);
15379 cu = per_cu->cu;
15380
15381 die = follow_die_offset (offset, &cu);
15382 if (!die)
15383 error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
15384 offset.sect_off, per_cu->objfile->name);
15385
15386 attr = dwarf2_attr (die, DW_AT_location, cu);
15387 if (!attr)
15388 {
15389 /* DWARF: "If there is no such attribute, then there is no effect.".
15390 DATA is ignored if SIZE is 0. */
15391
15392 retval.data = NULL;
15393 retval.size = 0;
15394 }
15395 else if (attr_form_is_section_offset (attr))
15396 {
15397 struct dwarf2_loclist_baton loclist_baton;
15398 CORE_ADDR pc = (*get_frame_pc) (baton);
15399 size_t size;
15400
15401 fill_in_loclist_baton (cu, &loclist_baton, attr);
15402
15403 retval.data = dwarf2_find_location_expression (&loclist_baton,
15404 &size, pc);
15405 retval.size = size;
15406 }
15407 else
15408 {
15409 if (!attr_form_is_block (attr))
15410 error (_("Dwarf Error: DIE at 0x%x referenced in module %s "
15411 "is neither DW_FORM_block* nor DW_FORM_exprloc"),
15412 offset.sect_off, per_cu->objfile->name);
15413
15414 retval.data = DW_BLOCK (attr)->data;
15415 retval.size = DW_BLOCK (attr)->size;
15416 }
15417 retval.per_cu = cu->per_cu;
15418
15419 age_cached_comp_units ();
15420
15421 return retval;
15422 }
15423
15424 /* Return the type of the DIE at DIE_OFFSET in the CU named by
15425 PER_CU. */
15426
15427 struct type *
15428 dwarf2_get_die_type (cu_offset die_offset,
15429 struct dwarf2_per_cu_data *per_cu)
15430 {
15431 sect_offset die_offset_sect;
15432
15433 dw2_setup (per_cu->objfile);
15434
15435 die_offset_sect.sect_off = per_cu->offset.sect_off + die_offset.cu_off;
15436 return get_die_type_at_offset (die_offset_sect, per_cu);
15437 }
15438
15439 /* Follow the signature attribute ATTR in SRC_DIE.
15440 On entry *REF_CU is the CU of SRC_DIE.
15441 On exit *REF_CU is the CU of the result. */
15442
15443 static struct die_info *
15444 follow_die_sig (struct die_info *src_die, struct attribute *attr,
15445 struct dwarf2_cu **ref_cu)
15446 {
15447 struct objfile *objfile = (*ref_cu)->objfile;
15448 struct die_info temp_die;
15449 struct signatured_type *sig_type = DW_SIGNATURED_TYPE (attr);
15450 struct dwarf2_cu *sig_cu;
15451 struct die_info *die;
15452
15453 /* sig_type will be NULL if the signatured type is missing from
15454 the debug info. */
15455 if (sig_type == NULL)
15456 error (_("Dwarf Error: Cannot find signatured DIE referenced from DIE "
15457 "at 0x%x [in module %s]"),
15458 src_die->offset.sect_off, objfile->name);
15459
15460 /* If necessary, add it to the queue and load its DIEs. */
15461
15462 if (maybe_queue_comp_unit (*ref_cu, &sig_type->per_cu, language_minimal))
15463 read_signatured_type (sig_type);
15464
15465 gdb_assert (sig_type->per_cu.cu != NULL);
15466
15467 sig_cu = sig_type->per_cu.cu;
15468 gdb_assert (sig_type->type_offset_in_section.sect_off != 0);
15469 temp_die.offset = sig_type->type_offset_in_section;
15470 die = htab_find_with_hash (sig_cu->die_hash, &temp_die,
15471 temp_die.offset.sect_off);
15472 if (die)
15473 {
15474 *ref_cu = sig_cu;
15475 return die;
15476 }
15477
15478 error (_("Dwarf Error: Cannot find signatured DIE at 0x%x referenced "
15479 "from DIE at 0x%x [in module %s]"),
15480 temp_die.offset.sect_off, src_die->offset.sect_off, objfile->name);
15481 }
15482
15483 /* Given an offset of a signatured type, return its signatured_type. */
15484
15485 static struct signatured_type *
15486 lookup_signatured_type_at_offset (struct objfile *objfile,
15487 struct dwarf2_section_info *section,
15488 sect_offset offset)
15489 {
15490 gdb_byte *info_ptr = section->buffer + offset.sect_off;
15491 unsigned int length, initial_length_size;
15492 unsigned int sig_offset;
15493 struct signatured_type find_entry, *sig_type;
15494
15495 length = read_initial_length (objfile->obfd, info_ptr, &initial_length_size);
15496 sig_offset = (initial_length_size
15497 + 2 /*version*/
15498 + (initial_length_size == 4 ? 4 : 8) /*debug_abbrev_offset*/
15499 + 1 /*address_size*/);
15500 find_entry.signature = bfd_get_64 (objfile->obfd, info_ptr + sig_offset);
15501 sig_type = htab_find (dwarf2_per_objfile->signatured_types, &find_entry);
15502
15503 /* This is only used to lookup previously recorded types.
15504 If we didn't find it, it's our bug. */
15505 gdb_assert (sig_type != NULL);
15506 gdb_assert (offset.sect_off == sig_type->per_cu.offset.sect_off);
15507
15508 return sig_type;
15509 }
15510
15511 /* Load the DIEs associated with type unit PER_CU into memory. */
15512
15513 static void
15514 load_full_type_unit (struct dwarf2_per_cu_data *per_cu)
15515 {
15516 struct objfile *objfile = per_cu->objfile;
15517 struct dwarf2_section_info *sect = per_cu->info_or_types_section;
15518 sect_offset offset = per_cu->offset;
15519 struct signatured_type *sig_type;
15520
15521 dwarf2_read_section (objfile, sect);
15522
15523 /* We have the section offset, but we need the signature to do the
15524 hash table lookup. */
15525 /* FIXME: This is sorta unnecessary, read_signatured_type only uses
15526 the signature to assert we found the right one.
15527 Ok, but it's a lot of work. We should simplify things so any needed
15528 assert doesn't require all this clumsiness. */
15529 sig_type = lookup_signatured_type_at_offset (objfile, sect, offset);
15530
15531 gdb_assert (&sig_type->per_cu == per_cu);
15532 gdb_assert (sig_type->per_cu.cu == NULL);
15533
15534 read_signatured_type (sig_type);
15535
15536 gdb_assert (sig_type->per_cu.cu != NULL);
15537 }
15538
15539 /* die_reader_func for read_signatured_type.
15540 This is identical to load_full_comp_unit_reader,
15541 but is kept separate for now. */
15542
15543 static void
15544 read_signatured_type_reader (const struct die_reader_specs *reader,
15545 gdb_byte *info_ptr,
15546 struct die_info *comp_unit_die,
15547 int has_children,
15548 void *data)
15549 {
15550 struct dwarf2_cu *cu = reader->cu;
15551
15552 gdb_assert (cu->die_hash == NULL);
15553 cu->die_hash =
15554 htab_create_alloc_ex (cu->header.length / 12,
15555 die_hash,
15556 die_eq,
15557 NULL,
15558 &cu->comp_unit_obstack,
15559 hashtab_obstack_allocate,
15560 dummy_obstack_deallocate);
15561
15562 if (has_children)
15563 comp_unit_die->child = read_die_and_siblings (reader, info_ptr,
15564 &info_ptr, comp_unit_die);
15565 cu->dies = comp_unit_die;
15566 /* comp_unit_die is not stored in die_hash, no need. */
15567
15568 /* We try not to read any attributes in this function, because not
15569 all CUs needed for references have been loaded yet, and symbol
15570 table processing isn't initialized. But we have to set the CU language,
15571 or we won't be able to build types correctly.
15572 Similarly, if we do not read the producer, we can not apply
15573 producer-specific interpretation. */
15574 prepare_one_comp_unit (cu, cu->dies, language_minimal);
15575 }
15576
15577 /* Read in a signatured type and build its CU and DIEs.
15578 If the type is a stub for the real type in a DWO file,
15579 read in the real type from the DWO file as well. */
15580
15581 static void
15582 read_signatured_type (struct signatured_type *sig_type)
15583 {
15584 struct dwarf2_per_cu_data *per_cu = &sig_type->per_cu;
15585
15586 gdb_assert (per_cu->is_debug_types);
15587 gdb_assert (per_cu->cu == NULL);
15588
15589 init_cutu_and_read_dies (per_cu, 0, 1, read_signatured_type_reader, NULL);
15590 }
15591
15592 /* Decode simple location descriptions.
15593 Given a pointer to a dwarf block that defines a location, compute
15594 the location and return the value.
15595
15596 NOTE drow/2003-11-18: This function is called in two situations
15597 now: for the address of static or global variables (partial symbols
15598 only) and for offsets into structures which are expected to be
15599 (more or less) constant. The partial symbol case should go away,
15600 and only the constant case should remain. That will let this
15601 function complain more accurately. A few special modes are allowed
15602 without complaint for global variables (for instance, global
15603 register values and thread-local values).
15604
15605 A location description containing no operations indicates that the
15606 object is optimized out. The return value is 0 for that case.
15607 FIXME drow/2003-11-16: No callers check for this case any more; soon all
15608 callers will only want a very basic result and this can become a
15609 complaint.
15610
15611 Note that stack[0] is unused except as a default error return. */
15612
15613 static CORE_ADDR
15614 decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
15615 {
15616 struct objfile *objfile = cu->objfile;
15617 int i;
15618 int size = blk->size;
15619 gdb_byte *data = blk->data;
15620 CORE_ADDR stack[64];
15621 int stacki;
15622 unsigned int bytes_read, unsnd;
15623 gdb_byte op;
15624
15625 i = 0;
15626 stacki = 0;
15627 stack[stacki] = 0;
15628 stack[++stacki] = 0;
15629
15630 while (i < size)
15631 {
15632 op = data[i++];
15633 switch (op)
15634 {
15635 case DW_OP_lit0:
15636 case DW_OP_lit1:
15637 case DW_OP_lit2:
15638 case DW_OP_lit3:
15639 case DW_OP_lit4:
15640 case DW_OP_lit5:
15641 case DW_OP_lit6:
15642 case DW_OP_lit7:
15643 case DW_OP_lit8:
15644 case DW_OP_lit9:
15645 case DW_OP_lit10:
15646 case DW_OP_lit11:
15647 case DW_OP_lit12:
15648 case DW_OP_lit13:
15649 case DW_OP_lit14:
15650 case DW_OP_lit15:
15651 case DW_OP_lit16:
15652 case DW_OP_lit17:
15653 case DW_OP_lit18:
15654 case DW_OP_lit19:
15655 case DW_OP_lit20:
15656 case DW_OP_lit21:
15657 case DW_OP_lit22:
15658 case DW_OP_lit23:
15659 case DW_OP_lit24:
15660 case DW_OP_lit25:
15661 case DW_OP_lit26:
15662 case DW_OP_lit27:
15663 case DW_OP_lit28:
15664 case DW_OP_lit29:
15665 case DW_OP_lit30:
15666 case DW_OP_lit31:
15667 stack[++stacki] = op - DW_OP_lit0;
15668 break;
15669
15670 case DW_OP_reg0:
15671 case DW_OP_reg1:
15672 case DW_OP_reg2:
15673 case DW_OP_reg3:
15674 case DW_OP_reg4:
15675 case DW_OP_reg5:
15676 case DW_OP_reg6:
15677 case DW_OP_reg7:
15678 case DW_OP_reg8:
15679 case DW_OP_reg9:
15680 case DW_OP_reg10:
15681 case DW_OP_reg11:
15682 case DW_OP_reg12:
15683 case DW_OP_reg13:
15684 case DW_OP_reg14:
15685 case DW_OP_reg15:
15686 case DW_OP_reg16:
15687 case DW_OP_reg17:
15688 case DW_OP_reg18:
15689 case DW_OP_reg19:
15690 case DW_OP_reg20:
15691 case DW_OP_reg21:
15692 case DW_OP_reg22:
15693 case DW_OP_reg23:
15694 case DW_OP_reg24:
15695 case DW_OP_reg25:
15696 case DW_OP_reg26:
15697 case DW_OP_reg27:
15698 case DW_OP_reg28:
15699 case DW_OP_reg29:
15700 case DW_OP_reg30:
15701 case DW_OP_reg31:
15702 stack[++stacki] = op - DW_OP_reg0;
15703 if (i < size)
15704 dwarf2_complex_location_expr_complaint ();
15705 break;
15706
15707 case DW_OP_regx:
15708 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
15709 i += bytes_read;
15710 stack[++stacki] = unsnd;
15711 if (i < size)
15712 dwarf2_complex_location_expr_complaint ();
15713 break;
15714
15715 case DW_OP_addr:
15716 stack[++stacki] = read_address (objfile->obfd, &data[i],
15717 cu, &bytes_read);
15718 i += bytes_read;
15719 break;
15720
15721 case DW_OP_const1u:
15722 stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
15723 i += 1;
15724 break;
15725
15726 case DW_OP_const1s:
15727 stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
15728 i += 1;
15729 break;
15730
15731 case DW_OP_const2u:
15732 stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
15733 i += 2;
15734 break;
15735
15736 case DW_OP_const2s:
15737 stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
15738 i += 2;
15739 break;
15740
15741 case DW_OP_const4u:
15742 stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
15743 i += 4;
15744 break;
15745
15746 case DW_OP_const4s:
15747 stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
15748 i += 4;
15749 break;
15750
15751 case DW_OP_const8u:
15752 stack[++stacki] = read_8_bytes (objfile->obfd, &data[i]);
15753 i += 8;
15754 break;
15755
15756 case DW_OP_constu:
15757 stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
15758 &bytes_read);
15759 i += bytes_read;
15760 break;
15761
15762 case DW_OP_consts:
15763 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
15764 i += bytes_read;
15765 break;
15766
15767 case DW_OP_dup:
15768 stack[stacki + 1] = stack[stacki];
15769 stacki++;
15770 break;
15771
15772 case DW_OP_plus:
15773 stack[stacki - 1] += stack[stacki];
15774 stacki--;
15775 break;
15776
15777 case DW_OP_plus_uconst:
15778 stack[stacki] += read_unsigned_leb128 (NULL, (data + i),
15779 &bytes_read);
15780 i += bytes_read;
15781 break;
15782
15783 case DW_OP_minus:
15784 stack[stacki - 1] -= stack[stacki];
15785 stacki--;
15786 break;
15787
15788 case DW_OP_deref:
15789 /* If we're not the last op, then we definitely can't encode
15790 this using GDB's address_class enum. This is valid for partial
15791 global symbols, although the variable's address will be bogus
15792 in the psymtab. */
15793 if (i < size)
15794 dwarf2_complex_location_expr_complaint ();
15795 break;
15796
15797 case DW_OP_GNU_push_tls_address:
15798 /* The top of the stack has the offset from the beginning
15799 of the thread control block at which the variable is located. */
15800 /* Nothing should follow this operator, so the top of stack would
15801 be returned. */
15802 /* This is valid for partial global symbols, but the variable's
15803 address will be bogus in the psymtab. Make it always at least
15804 non-zero to not look as a variable garbage collected by linker
15805 which have DW_OP_addr 0. */
15806 if (i < size)
15807 dwarf2_complex_location_expr_complaint ();
15808 stack[stacki]++;
15809 break;
15810
15811 case DW_OP_GNU_uninit:
15812 break;
15813
15814 case DW_OP_GNU_addr_index:
15815 case DW_OP_GNU_const_index:
15816 stack[++stacki] = read_addr_index_from_leb128 (cu, &data[i],
15817 &bytes_read);
15818 i += bytes_read;
15819 break;
15820
15821 default:
15822 {
15823 const char *name = get_DW_OP_name (op);
15824
15825 if (name)
15826 complaint (&symfile_complaints, _("unsupported stack op: '%s'"),
15827 name);
15828 else
15829 complaint (&symfile_complaints, _("unsupported stack op: '%02x'"),
15830 op);
15831 }
15832
15833 return (stack[stacki]);
15834 }
15835
15836 /* Enforce maximum stack depth of SIZE-1 to avoid writing
15837 outside of the allocated space. Also enforce minimum>0. */
15838 if (stacki >= ARRAY_SIZE (stack) - 1)
15839 {
15840 complaint (&symfile_complaints,
15841 _("location description stack overflow"));
15842 return 0;
15843 }
15844
15845 if (stacki <= 0)
15846 {
15847 complaint (&symfile_complaints,
15848 _("location description stack underflow"));
15849 return 0;
15850 }
15851 }
15852 return (stack[stacki]);
15853 }
15854
15855 /* memory allocation interface */
15856
15857 static struct dwarf_block *
15858 dwarf_alloc_block (struct dwarf2_cu *cu)
15859 {
15860 struct dwarf_block *blk;
15861
15862 blk = (struct dwarf_block *)
15863 obstack_alloc (&cu->comp_unit_obstack, sizeof (struct dwarf_block));
15864 return (blk);
15865 }
15866
15867 static struct die_info *
15868 dwarf_alloc_die (struct dwarf2_cu *cu, int num_attrs)
15869 {
15870 struct die_info *die;
15871 size_t size = sizeof (struct die_info);
15872
15873 if (num_attrs > 1)
15874 size += (num_attrs - 1) * sizeof (struct attribute);
15875
15876 die = (struct die_info *) obstack_alloc (&cu->comp_unit_obstack, size);
15877 memset (die, 0, sizeof (struct die_info));
15878 return (die);
15879 }
15880
15881 \f
15882 /* Macro support. */
15883
15884 /* Return the full name of file number I in *LH's file name table.
15885 Use COMP_DIR as the name of the current directory of the
15886 compilation. The result is allocated using xmalloc; the caller is
15887 responsible for freeing it. */
15888 static char *
15889 file_full_name (int file, struct line_header *lh, const char *comp_dir)
15890 {
15891 /* Is the file number a valid index into the line header's file name
15892 table? Remember that file numbers start with one, not zero. */
15893 if (1 <= file && file <= lh->num_file_names)
15894 {
15895 struct file_entry *fe = &lh->file_names[file - 1];
15896
15897 if (IS_ABSOLUTE_PATH (fe->name))
15898 return xstrdup (fe->name);
15899 else
15900 {
15901 const char *dir;
15902 int dir_len;
15903 char *full_name;
15904
15905 if (fe->dir_index)
15906 dir = lh->include_dirs[fe->dir_index - 1];
15907 else
15908 dir = comp_dir;
15909
15910 if (dir)
15911 {
15912 dir_len = strlen (dir);
15913 full_name = xmalloc (dir_len + 1 + strlen (fe->name) + 1);
15914 strcpy (full_name, dir);
15915 full_name[dir_len] = '/';
15916 strcpy (full_name + dir_len + 1, fe->name);
15917 return full_name;
15918 }
15919 else
15920 return xstrdup (fe->name);
15921 }
15922 }
15923 else
15924 {
15925 /* The compiler produced a bogus file number. We can at least
15926 record the macro definitions made in the file, even if we
15927 won't be able to find the file by name. */
15928 char fake_name[80];
15929
15930 sprintf (fake_name, "<bad macro file number %d>", file);
15931
15932 complaint (&symfile_complaints,
15933 _("bad file number in macro information (%d)"),
15934 file);
15935
15936 return xstrdup (fake_name);
15937 }
15938 }
15939
15940
15941 static struct macro_source_file *
15942 macro_start_file (int file, int line,
15943 struct macro_source_file *current_file,
15944 const char *comp_dir,
15945 struct line_header *lh, struct objfile *objfile)
15946 {
15947 /* The full name of this source file. */
15948 char *full_name = file_full_name (file, lh, comp_dir);
15949
15950 /* We don't create a macro table for this compilation unit
15951 at all until we actually get a filename. */
15952 if (! pending_macros)
15953 pending_macros = new_macro_table (&objfile->objfile_obstack,
15954 objfile->macro_cache);
15955
15956 if (! current_file)
15957 {
15958 /* If we have no current file, then this must be the start_file
15959 directive for the compilation unit's main source file. */
15960 current_file = macro_set_main (pending_macros, full_name);
15961 macro_define_special (pending_macros);
15962 }
15963 else
15964 current_file = macro_include (current_file, line, full_name);
15965
15966 xfree (full_name);
15967
15968 return current_file;
15969 }
15970
15971
15972 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
15973 followed by a null byte. */
15974 static char *
15975 copy_string (const char *buf, int len)
15976 {
15977 char *s = xmalloc (len + 1);
15978
15979 memcpy (s, buf, len);
15980 s[len] = '\0';
15981 return s;
15982 }
15983
15984
15985 static const char *
15986 consume_improper_spaces (const char *p, const char *body)
15987 {
15988 if (*p == ' ')
15989 {
15990 complaint (&symfile_complaints,
15991 _("macro definition contains spaces "
15992 "in formal argument list:\n`%s'"),
15993 body);
15994
15995 while (*p == ' ')
15996 p++;
15997 }
15998
15999 return p;
16000 }
16001
16002
16003 static void
16004 parse_macro_definition (struct macro_source_file *file, int line,
16005 const char *body)
16006 {
16007 const char *p;
16008
16009 /* The body string takes one of two forms. For object-like macro
16010 definitions, it should be:
16011
16012 <macro name> " " <definition>
16013
16014 For function-like macro definitions, it should be:
16015
16016 <macro name> "() " <definition>
16017 or
16018 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
16019
16020 Spaces may appear only where explicitly indicated, and in the
16021 <definition>.
16022
16023 The Dwarf 2 spec says that an object-like macro's name is always
16024 followed by a space, but versions of GCC around March 2002 omit
16025 the space when the macro's definition is the empty string.
16026
16027 The Dwarf 2 spec says that there should be no spaces between the
16028 formal arguments in a function-like macro's formal argument list,
16029 but versions of GCC around March 2002 include spaces after the
16030 commas. */
16031
16032
16033 /* Find the extent of the macro name. The macro name is terminated
16034 by either a space or null character (for an object-like macro) or
16035 an opening paren (for a function-like macro). */
16036 for (p = body; *p; p++)
16037 if (*p == ' ' || *p == '(')
16038 break;
16039
16040 if (*p == ' ' || *p == '\0')
16041 {
16042 /* It's an object-like macro. */
16043 int name_len = p - body;
16044 char *name = copy_string (body, name_len);
16045 const char *replacement;
16046
16047 if (*p == ' ')
16048 replacement = body + name_len + 1;
16049 else
16050 {
16051 dwarf2_macro_malformed_definition_complaint (body);
16052 replacement = body + name_len;
16053 }
16054
16055 macro_define_object (file, line, name, replacement);
16056
16057 xfree (name);
16058 }
16059 else if (*p == '(')
16060 {
16061 /* It's a function-like macro. */
16062 char *name = copy_string (body, p - body);
16063 int argc = 0;
16064 int argv_size = 1;
16065 char **argv = xmalloc (argv_size * sizeof (*argv));
16066
16067 p++;
16068
16069 p = consume_improper_spaces (p, body);
16070
16071 /* Parse the formal argument list. */
16072 while (*p && *p != ')')
16073 {
16074 /* Find the extent of the current argument name. */
16075 const char *arg_start = p;
16076
16077 while (*p && *p != ',' && *p != ')' && *p != ' ')
16078 p++;
16079
16080 if (! *p || p == arg_start)
16081 dwarf2_macro_malformed_definition_complaint (body);
16082 else
16083 {
16084 /* Make sure argv has room for the new argument. */
16085 if (argc >= argv_size)
16086 {
16087 argv_size *= 2;
16088 argv = xrealloc (argv, argv_size * sizeof (*argv));
16089 }
16090
16091 argv[argc++] = copy_string (arg_start, p - arg_start);
16092 }
16093
16094 p = consume_improper_spaces (p, body);
16095
16096 /* Consume the comma, if present. */
16097 if (*p == ',')
16098 {
16099 p++;
16100
16101 p = consume_improper_spaces (p, body);
16102 }
16103 }
16104
16105 if (*p == ')')
16106 {
16107 p++;
16108
16109 if (*p == ' ')
16110 /* Perfectly formed definition, no complaints. */
16111 macro_define_function (file, line, name,
16112 argc, (const char **) argv,
16113 p + 1);
16114 else if (*p == '\0')
16115 {
16116 /* Complain, but do define it. */
16117 dwarf2_macro_malformed_definition_complaint (body);
16118 macro_define_function (file, line, name,
16119 argc, (const char **) argv,
16120 p);
16121 }
16122 else
16123 /* Just complain. */
16124 dwarf2_macro_malformed_definition_complaint (body);
16125 }
16126 else
16127 /* Just complain. */
16128 dwarf2_macro_malformed_definition_complaint (body);
16129
16130 xfree (name);
16131 {
16132 int i;
16133
16134 for (i = 0; i < argc; i++)
16135 xfree (argv[i]);
16136 }
16137 xfree (argv);
16138 }
16139 else
16140 dwarf2_macro_malformed_definition_complaint (body);
16141 }
16142
16143 /* Skip some bytes from BYTES according to the form given in FORM.
16144 Returns the new pointer. */
16145
16146 static gdb_byte *
16147 skip_form_bytes (bfd *abfd, gdb_byte *bytes, gdb_byte *buffer_end,
16148 enum dwarf_form form,
16149 unsigned int offset_size,
16150 struct dwarf2_section_info *section)
16151 {
16152 unsigned int bytes_read;
16153
16154 switch (form)
16155 {
16156 case DW_FORM_data1:
16157 case DW_FORM_flag:
16158 ++bytes;
16159 break;
16160
16161 case DW_FORM_data2:
16162 bytes += 2;
16163 break;
16164
16165 case DW_FORM_data4:
16166 bytes += 4;
16167 break;
16168
16169 case DW_FORM_data8:
16170 bytes += 8;
16171 break;
16172
16173 case DW_FORM_string:
16174 read_direct_string (abfd, bytes, &bytes_read);
16175 bytes += bytes_read;
16176 break;
16177
16178 case DW_FORM_sec_offset:
16179 case DW_FORM_strp:
16180 bytes += offset_size;
16181 break;
16182
16183 case DW_FORM_block:
16184 bytes += read_unsigned_leb128 (abfd, bytes, &bytes_read);
16185 bytes += bytes_read;
16186 break;
16187
16188 case DW_FORM_block1:
16189 bytes += 1 + read_1_byte (abfd, bytes);
16190 break;
16191 case DW_FORM_block2:
16192 bytes += 2 + read_2_bytes (abfd, bytes);
16193 break;
16194 case DW_FORM_block4:
16195 bytes += 4 + read_4_bytes (abfd, bytes);
16196 break;
16197
16198 case DW_FORM_sdata:
16199 case DW_FORM_udata:
16200 case DW_FORM_GNU_addr_index:
16201 case DW_FORM_GNU_str_index:
16202 bytes = (gdb_byte *) gdb_skip_leb128 (bytes, buffer_end);
16203 if (bytes == NULL)
16204 {
16205 dwarf2_section_buffer_overflow_complaint (section);
16206 return NULL;
16207 }
16208 break;
16209
16210 default:
16211 {
16212 complain:
16213 complaint (&symfile_complaints,
16214 _("invalid form 0x%x in `%s'"),
16215 form,
16216 section->asection->name);
16217 return NULL;
16218 }
16219 }
16220
16221 return bytes;
16222 }
16223
16224 /* A helper for dwarf_decode_macros that handles skipping an unknown
16225 opcode. Returns an updated pointer to the macro data buffer; or,
16226 on error, issues a complaint and returns NULL. */
16227
16228 static gdb_byte *
16229 skip_unknown_opcode (unsigned int opcode,
16230 gdb_byte **opcode_definitions,
16231 gdb_byte *mac_ptr, gdb_byte *mac_end,
16232 bfd *abfd,
16233 unsigned int offset_size,
16234 struct dwarf2_section_info *section)
16235 {
16236 unsigned int bytes_read, i;
16237 unsigned long arg;
16238 gdb_byte *defn;
16239
16240 if (opcode_definitions[opcode] == NULL)
16241 {
16242 complaint (&symfile_complaints,
16243 _("unrecognized DW_MACFINO opcode 0x%x"),
16244 opcode);
16245 return NULL;
16246 }
16247
16248 defn = opcode_definitions[opcode];
16249 arg = read_unsigned_leb128 (abfd, defn, &bytes_read);
16250 defn += bytes_read;
16251
16252 for (i = 0; i < arg; ++i)
16253 {
16254 mac_ptr = skip_form_bytes (abfd, mac_ptr, mac_end, defn[i], offset_size,
16255 section);
16256 if (mac_ptr == NULL)
16257 {
16258 /* skip_form_bytes already issued the complaint. */
16259 return NULL;
16260 }
16261 }
16262
16263 return mac_ptr;
16264 }
16265
16266 /* A helper function which parses the header of a macro section.
16267 If the macro section is the extended (for now called "GNU") type,
16268 then this updates *OFFSET_SIZE. Returns a pointer to just after
16269 the header, or issues a complaint and returns NULL on error. */
16270
16271 static gdb_byte *
16272 dwarf_parse_macro_header (gdb_byte **opcode_definitions,
16273 bfd *abfd,
16274 gdb_byte *mac_ptr,
16275 unsigned int *offset_size,
16276 int section_is_gnu)
16277 {
16278 memset (opcode_definitions, 0, 256 * sizeof (gdb_byte *));
16279
16280 if (section_is_gnu)
16281 {
16282 unsigned int version, flags;
16283
16284 version = read_2_bytes (abfd, mac_ptr);
16285 if (version != 4)
16286 {
16287 complaint (&symfile_complaints,
16288 _("unrecognized version `%d' in .debug_macro section"),
16289 version);
16290 return NULL;
16291 }
16292 mac_ptr += 2;
16293
16294 flags = read_1_byte (abfd, mac_ptr);
16295 ++mac_ptr;
16296 *offset_size = (flags & 1) ? 8 : 4;
16297
16298 if ((flags & 2) != 0)
16299 /* We don't need the line table offset. */
16300 mac_ptr += *offset_size;
16301
16302 /* Vendor opcode descriptions. */
16303 if ((flags & 4) != 0)
16304 {
16305 unsigned int i, count;
16306
16307 count = read_1_byte (abfd, mac_ptr);
16308 ++mac_ptr;
16309 for (i = 0; i < count; ++i)
16310 {
16311 unsigned int opcode, bytes_read;
16312 unsigned long arg;
16313
16314 opcode = read_1_byte (abfd, mac_ptr);
16315 ++mac_ptr;
16316 opcode_definitions[opcode] = mac_ptr;
16317 arg = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
16318 mac_ptr += bytes_read;
16319 mac_ptr += arg;
16320 }
16321 }
16322 }
16323
16324 return mac_ptr;
16325 }
16326
16327 /* A helper for dwarf_decode_macros that handles the GNU extensions,
16328 including DW_MACRO_GNU_transparent_include. */
16329
16330 static void
16331 dwarf_decode_macro_bytes (bfd *abfd, gdb_byte *mac_ptr, gdb_byte *mac_end,
16332 struct macro_source_file *current_file,
16333 struct line_header *lh, char *comp_dir,
16334 struct dwarf2_section_info *section,
16335 int section_is_gnu,
16336 unsigned int offset_size,
16337 struct objfile *objfile,
16338 htab_t include_hash)
16339 {
16340 enum dwarf_macro_record_type macinfo_type;
16341 int at_commandline;
16342 gdb_byte *opcode_definitions[256];
16343
16344 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
16345 &offset_size, section_is_gnu);
16346 if (mac_ptr == NULL)
16347 {
16348 /* We already issued a complaint. */
16349 return;
16350 }
16351
16352 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
16353 GDB is still reading the definitions from command line. First
16354 DW_MACINFO_start_file will need to be ignored as it was already executed
16355 to create CURRENT_FILE for the main source holding also the command line
16356 definitions. On first met DW_MACINFO_start_file this flag is reset to
16357 normally execute all the remaining DW_MACINFO_start_file macinfos. */
16358
16359 at_commandline = 1;
16360
16361 do
16362 {
16363 /* Do we at least have room for a macinfo type byte? */
16364 if (mac_ptr >= mac_end)
16365 {
16366 dwarf2_section_buffer_overflow_complaint (section);
16367 break;
16368 }
16369
16370 macinfo_type = read_1_byte (abfd, mac_ptr);
16371 mac_ptr++;
16372
16373 /* Note that we rely on the fact that the corresponding GNU and
16374 DWARF constants are the same. */
16375 switch (macinfo_type)
16376 {
16377 /* A zero macinfo type indicates the end of the macro
16378 information. */
16379 case 0:
16380 break;
16381
16382 case DW_MACRO_GNU_define:
16383 case DW_MACRO_GNU_undef:
16384 case DW_MACRO_GNU_define_indirect:
16385 case DW_MACRO_GNU_undef_indirect:
16386 {
16387 unsigned int bytes_read;
16388 int line;
16389 char *body;
16390 int is_define;
16391
16392 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
16393 mac_ptr += bytes_read;
16394
16395 if (macinfo_type == DW_MACRO_GNU_define
16396 || macinfo_type == DW_MACRO_GNU_undef)
16397 {
16398 body = read_direct_string (abfd, mac_ptr, &bytes_read);
16399 mac_ptr += bytes_read;
16400 }
16401 else
16402 {
16403 LONGEST str_offset;
16404
16405 str_offset = read_offset_1 (abfd, mac_ptr, offset_size);
16406 mac_ptr += offset_size;
16407
16408 body = read_indirect_string_at_offset (abfd, str_offset);
16409 }
16410
16411 is_define = (macinfo_type == DW_MACRO_GNU_define
16412 || macinfo_type == DW_MACRO_GNU_define_indirect);
16413 if (! current_file)
16414 {
16415 /* DWARF violation as no main source is present. */
16416 complaint (&symfile_complaints,
16417 _("debug info with no main source gives macro %s "
16418 "on line %d: %s"),
16419 is_define ? _("definition") : _("undefinition"),
16420 line, body);
16421 break;
16422 }
16423 if ((line == 0 && !at_commandline)
16424 || (line != 0 && at_commandline))
16425 complaint (&symfile_complaints,
16426 _("debug info gives %s macro %s with %s line %d: %s"),
16427 at_commandline ? _("command-line") : _("in-file"),
16428 is_define ? _("definition") : _("undefinition"),
16429 line == 0 ? _("zero") : _("non-zero"), line, body);
16430
16431 if (is_define)
16432 parse_macro_definition (current_file, line, body);
16433 else
16434 {
16435 gdb_assert (macinfo_type == DW_MACRO_GNU_undef
16436 || macinfo_type == DW_MACRO_GNU_undef_indirect);
16437 macro_undef (current_file, line, body);
16438 }
16439 }
16440 break;
16441
16442 case DW_MACRO_GNU_start_file:
16443 {
16444 unsigned int bytes_read;
16445 int line, file;
16446
16447 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
16448 mac_ptr += bytes_read;
16449 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
16450 mac_ptr += bytes_read;
16451
16452 if ((line == 0 && !at_commandline)
16453 || (line != 0 && at_commandline))
16454 complaint (&symfile_complaints,
16455 _("debug info gives source %d included "
16456 "from %s at %s line %d"),
16457 file, at_commandline ? _("command-line") : _("file"),
16458 line == 0 ? _("zero") : _("non-zero"), line);
16459
16460 if (at_commandline)
16461 {
16462 /* This DW_MACRO_GNU_start_file was executed in the
16463 pass one. */
16464 at_commandline = 0;
16465 }
16466 else
16467 current_file = macro_start_file (file, line,
16468 current_file, comp_dir,
16469 lh, objfile);
16470 }
16471 break;
16472
16473 case DW_MACRO_GNU_end_file:
16474 if (! current_file)
16475 complaint (&symfile_complaints,
16476 _("macro debug info has an unmatched "
16477 "`close_file' directive"));
16478 else
16479 {
16480 current_file = current_file->included_by;
16481 if (! current_file)
16482 {
16483 enum dwarf_macro_record_type next_type;
16484
16485 /* GCC circa March 2002 doesn't produce the zero
16486 type byte marking the end of the compilation
16487 unit. Complain if it's not there, but exit no
16488 matter what. */
16489
16490 /* Do we at least have room for a macinfo type byte? */
16491 if (mac_ptr >= mac_end)
16492 {
16493 dwarf2_section_buffer_overflow_complaint (section);
16494 return;
16495 }
16496
16497 /* We don't increment mac_ptr here, so this is just
16498 a look-ahead. */
16499 next_type = read_1_byte (abfd, mac_ptr);
16500 if (next_type != 0)
16501 complaint (&symfile_complaints,
16502 _("no terminating 0-type entry for "
16503 "macros in `.debug_macinfo' section"));
16504
16505 return;
16506 }
16507 }
16508 break;
16509
16510 case DW_MACRO_GNU_transparent_include:
16511 {
16512 LONGEST offset;
16513 void **slot;
16514
16515 offset = read_offset_1 (abfd, mac_ptr, offset_size);
16516 mac_ptr += offset_size;
16517
16518 slot = htab_find_slot (include_hash, mac_ptr, INSERT);
16519 if (*slot != NULL)
16520 {
16521 /* This has actually happened; see
16522 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
16523 complaint (&symfile_complaints,
16524 _("recursive DW_MACRO_GNU_transparent_include in "
16525 ".debug_macro section"));
16526 }
16527 else
16528 {
16529 *slot = mac_ptr;
16530
16531 dwarf_decode_macro_bytes (abfd,
16532 section->buffer + offset,
16533 mac_end, current_file,
16534 lh, comp_dir,
16535 section, section_is_gnu,
16536 offset_size, objfile, include_hash);
16537
16538 htab_remove_elt (include_hash, mac_ptr);
16539 }
16540 }
16541 break;
16542
16543 case DW_MACINFO_vendor_ext:
16544 if (!section_is_gnu)
16545 {
16546 unsigned int bytes_read;
16547 int constant;
16548
16549 constant = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
16550 mac_ptr += bytes_read;
16551 read_direct_string (abfd, mac_ptr, &bytes_read);
16552 mac_ptr += bytes_read;
16553
16554 /* We don't recognize any vendor extensions. */
16555 break;
16556 }
16557 /* FALLTHROUGH */
16558
16559 default:
16560 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
16561 mac_ptr, mac_end, abfd, offset_size,
16562 section);
16563 if (mac_ptr == NULL)
16564 return;
16565 break;
16566 }
16567 } while (macinfo_type != 0);
16568 }
16569
16570 static void
16571 dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset,
16572 char *comp_dir, int section_is_gnu)
16573 {
16574 struct objfile *objfile = dwarf2_per_objfile->objfile;
16575 struct line_header *lh = cu->line_header;
16576 bfd *abfd;
16577 gdb_byte *mac_ptr, *mac_end;
16578 struct macro_source_file *current_file = 0;
16579 enum dwarf_macro_record_type macinfo_type;
16580 unsigned int offset_size = cu->header.offset_size;
16581 gdb_byte *opcode_definitions[256];
16582 struct cleanup *cleanup;
16583 htab_t include_hash;
16584 void **slot;
16585 struct dwarf2_section_info *section;
16586 const char *section_name;
16587
16588 if (cu->dwo_unit != NULL)
16589 {
16590 if (section_is_gnu)
16591 {
16592 section = &cu->dwo_unit->dwo_file->sections.macro;
16593 section_name = ".debug_macro.dwo";
16594 }
16595 else
16596 {
16597 section = &cu->dwo_unit->dwo_file->sections.macinfo;
16598 section_name = ".debug_macinfo.dwo";
16599 }
16600 }
16601 else
16602 {
16603 if (section_is_gnu)
16604 {
16605 section = &dwarf2_per_objfile->macro;
16606 section_name = ".debug_macro";
16607 }
16608 else
16609 {
16610 section = &dwarf2_per_objfile->macinfo;
16611 section_name = ".debug_macinfo";
16612 }
16613 }
16614
16615 dwarf2_read_section (objfile, section);
16616 if (section->buffer == NULL)
16617 {
16618 complaint (&symfile_complaints, _("missing %s section"), section_name);
16619 return;
16620 }
16621 abfd = section->asection->owner;
16622
16623 /* First pass: Find the name of the base filename.
16624 This filename is needed in order to process all macros whose definition
16625 (or undefinition) comes from the command line. These macros are defined
16626 before the first DW_MACINFO_start_file entry, and yet still need to be
16627 associated to the base file.
16628
16629 To determine the base file name, we scan the macro definitions until we
16630 reach the first DW_MACINFO_start_file entry. We then initialize
16631 CURRENT_FILE accordingly so that any macro definition found before the
16632 first DW_MACINFO_start_file can still be associated to the base file. */
16633
16634 mac_ptr = section->buffer + offset;
16635 mac_end = section->buffer + section->size;
16636
16637 mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr,
16638 &offset_size, section_is_gnu);
16639 if (mac_ptr == NULL)
16640 {
16641 /* We already issued a complaint. */
16642 return;
16643 }
16644
16645 do
16646 {
16647 /* Do we at least have room for a macinfo type byte? */
16648 if (mac_ptr >= mac_end)
16649 {
16650 /* Complaint is printed during the second pass as GDB will probably
16651 stop the first pass earlier upon finding
16652 DW_MACINFO_start_file. */
16653 break;
16654 }
16655
16656 macinfo_type = read_1_byte (abfd, mac_ptr);
16657 mac_ptr++;
16658
16659 /* Note that we rely on the fact that the corresponding GNU and
16660 DWARF constants are the same. */
16661 switch (macinfo_type)
16662 {
16663 /* A zero macinfo type indicates the end of the macro
16664 information. */
16665 case 0:
16666 break;
16667
16668 case DW_MACRO_GNU_define:
16669 case DW_MACRO_GNU_undef:
16670 /* Only skip the data by MAC_PTR. */
16671 {
16672 unsigned int bytes_read;
16673
16674 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
16675 mac_ptr += bytes_read;
16676 read_direct_string (abfd, mac_ptr, &bytes_read);
16677 mac_ptr += bytes_read;
16678 }
16679 break;
16680
16681 case DW_MACRO_GNU_start_file:
16682 {
16683 unsigned int bytes_read;
16684 int line, file;
16685
16686 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
16687 mac_ptr += bytes_read;
16688 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
16689 mac_ptr += bytes_read;
16690
16691 current_file = macro_start_file (file, line, current_file,
16692 comp_dir, lh, objfile);
16693 }
16694 break;
16695
16696 case DW_MACRO_GNU_end_file:
16697 /* No data to skip by MAC_PTR. */
16698 break;
16699
16700 case DW_MACRO_GNU_define_indirect:
16701 case DW_MACRO_GNU_undef_indirect:
16702 {
16703 unsigned int bytes_read;
16704
16705 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
16706 mac_ptr += bytes_read;
16707 mac_ptr += offset_size;
16708 }
16709 break;
16710
16711 case DW_MACRO_GNU_transparent_include:
16712 /* Note that, according to the spec, a transparent include
16713 chain cannot call DW_MACRO_GNU_start_file. So, we can just
16714 skip this opcode. */
16715 mac_ptr += offset_size;
16716 break;
16717
16718 case DW_MACINFO_vendor_ext:
16719 /* Only skip the data by MAC_PTR. */
16720 if (!section_is_gnu)
16721 {
16722 unsigned int bytes_read;
16723
16724 read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
16725 mac_ptr += bytes_read;
16726 read_direct_string (abfd, mac_ptr, &bytes_read);
16727 mac_ptr += bytes_read;
16728 }
16729 /* FALLTHROUGH */
16730
16731 default:
16732 mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions,
16733 mac_ptr, mac_end, abfd, offset_size,
16734 section);
16735 if (mac_ptr == NULL)
16736 return;
16737 break;
16738 }
16739 } while (macinfo_type != 0 && current_file == NULL);
16740
16741 /* Second pass: Process all entries.
16742
16743 Use the AT_COMMAND_LINE flag to determine whether we are still processing
16744 command-line macro definitions/undefinitions. This flag is unset when we
16745 reach the first DW_MACINFO_start_file entry. */
16746
16747 include_hash = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer,
16748 NULL, xcalloc, xfree);
16749 cleanup = make_cleanup_htab_delete (include_hash);
16750 mac_ptr = section->buffer + offset;
16751 slot = htab_find_slot (include_hash, mac_ptr, INSERT);
16752 *slot = mac_ptr;
16753 dwarf_decode_macro_bytes (abfd, mac_ptr, mac_end,
16754 current_file, lh, comp_dir, section, section_is_gnu,
16755 offset_size, objfile, include_hash);
16756 do_cleanups (cleanup);
16757 }
16758
16759 /* Check if the attribute's form is a DW_FORM_block*
16760 if so return true else false. */
16761
16762 static int
16763 attr_form_is_block (struct attribute *attr)
16764 {
16765 return (attr == NULL ? 0 :
16766 attr->form == DW_FORM_block1
16767 || attr->form == DW_FORM_block2
16768 || attr->form == DW_FORM_block4
16769 || attr->form == DW_FORM_block
16770 || attr->form == DW_FORM_exprloc);
16771 }
16772
16773 /* Return non-zero if ATTR's value is a section offset --- classes
16774 lineptr, loclistptr, macptr or rangelistptr --- or zero, otherwise.
16775 You may use DW_UNSND (attr) to retrieve such offsets.
16776
16777 Section 7.5.4, "Attribute Encodings", explains that no attribute
16778 may have a value that belongs to more than one of these classes; it
16779 would be ambiguous if we did, because we use the same forms for all
16780 of them. */
16781
16782 static int
16783 attr_form_is_section_offset (struct attribute *attr)
16784 {
16785 return (attr->form == DW_FORM_data4
16786 || attr->form == DW_FORM_data8
16787 || attr->form == DW_FORM_sec_offset);
16788 }
16789
16790 /* Return non-zero if ATTR's value falls in the 'constant' class, or
16791 zero otherwise. When this function returns true, you can apply
16792 dwarf2_get_attr_constant_value to it.
16793
16794 However, note that for some attributes you must check
16795 attr_form_is_section_offset before using this test. DW_FORM_data4
16796 and DW_FORM_data8 are members of both the constant class, and of
16797 the classes that contain offsets into other debug sections
16798 (lineptr, loclistptr, macptr or rangelistptr). The DWARF spec says
16799 that, if an attribute's can be either a constant or one of the
16800 section offset classes, DW_FORM_data4 and DW_FORM_data8 should be
16801 taken as section offsets, not constants. */
16802
16803 static int
16804 attr_form_is_constant (struct attribute *attr)
16805 {
16806 switch (attr->form)
16807 {
16808 case DW_FORM_sdata:
16809 case DW_FORM_udata:
16810 case DW_FORM_data1:
16811 case DW_FORM_data2:
16812 case DW_FORM_data4:
16813 case DW_FORM_data8:
16814 return 1;
16815 default:
16816 return 0;
16817 }
16818 }
16819
16820 /* Return the .debug_loc section to use for CU.
16821 For DWO files use .debug_loc.dwo. */
16822
16823 static struct dwarf2_section_info *
16824 cu_debug_loc_section (struct dwarf2_cu *cu)
16825 {
16826 if (cu->dwo_unit)
16827 return &cu->dwo_unit->dwo_file->sections.loc;
16828 return &dwarf2_per_objfile->loc;
16829 }
16830
16831 /* A helper function that fills in a dwarf2_loclist_baton. */
16832
16833 static void
16834 fill_in_loclist_baton (struct dwarf2_cu *cu,
16835 struct dwarf2_loclist_baton *baton,
16836 struct attribute *attr)
16837 {
16838 struct dwarf2_section_info *section = cu_debug_loc_section (cu);
16839
16840 dwarf2_read_section (dwarf2_per_objfile->objfile, section);
16841
16842 baton->per_cu = cu->per_cu;
16843 gdb_assert (baton->per_cu);
16844 /* We don't know how long the location list is, but make sure we
16845 don't run off the edge of the section. */
16846 baton->size = section->size - DW_UNSND (attr);
16847 baton->data = section->buffer + DW_UNSND (attr);
16848 baton->base_address = cu->base_address;
16849 baton->from_dwo = cu->dwo_unit != NULL;
16850 }
16851
16852 static void
16853 dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
16854 struct dwarf2_cu *cu)
16855 {
16856 struct objfile *objfile = dwarf2_per_objfile->objfile;
16857 struct dwarf2_section_info *section = cu_debug_loc_section (cu);
16858
16859 if (attr_form_is_section_offset (attr)
16860 /* .debug_loc{,.dwo} may not exist at all, or the offset may be outside
16861 the section. If so, fall through to the complaint in the
16862 other branch. */
16863 && DW_UNSND (attr) < dwarf2_section_size (objfile, section))
16864 {
16865 struct dwarf2_loclist_baton *baton;
16866
16867 baton = obstack_alloc (&objfile->objfile_obstack,
16868 sizeof (struct dwarf2_loclist_baton));
16869
16870 fill_in_loclist_baton (cu, baton, attr);
16871
16872 if (cu->base_known == 0)
16873 complaint (&symfile_complaints,
16874 _("Location list used without "
16875 "specifying the CU base address."));
16876
16877 SYMBOL_COMPUTED_OPS (sym) = &dwarf2_loclist_funcs;
16878 SYMBOL_LOCATION_BATON (sym) = baton;
16879 }
16880 else
16881 {
16882 struct dwarf2_locexpr_baton *baton;
16883
16884 baton = obstack_alloc (&objfile->objfile_obstack,
16885 sizeof (struct dwarf2_locexpr_baton));
16886 baton->per_cu = cu->per_cu;
16887 gdb_assert (baton->per_cu);
16888
16889 if (attr_form_is_block (attr))
16890 {
16891 /* Note that we're just copying the block's data pointer
16892 here, not the actual data. We're still pointing into the
16893 info_buffer for SYM's objfile; right now we never release
16894 that buffer, but when we do clean up properly this may
16895 need to change. */
16896 baton->size = DW_BLOCK (attr)->size;
16897 baton->data = DW_BLOCK (attr)->data;
16898 }
16899 else
16900 {
16901 dwarf2_invalid_attrib_class_complaint ("location description",
16902 SYMBOL_NATURAL_NAME (sym));
16903 baton->size = 0;
16904 }
16905
16906 SYMBOL_COMPUTED_OPS (sym) = &dwarf2_locexpr_funcs;
16907 SYMBOL_LOCATION_BATON (sym) = baton;
16908 }
16909 }
16910
16911 /* Return the OBJFILE associated with the compilation unit CU. If CU
16912 came from a separate debuginfo file, then the master objfile is
16913 returned. */
16914
16915 struct objfile *
16916 dwarf2_per_cu_objfile (struct dwarf2_per_cu_data *per_cu)
16917 {
16918 struct objfile *objfile = per_cu->objfile;
16919
16920 /* Return the master objfile, so that we can report and look up the
16921 correct file containing this variable. */
16922 if (objfile->separate_debug_objfile_backlink)
16923 objfile = objfile->separate_debug_objfile_backlink;
16924
16925 return objfile;
16926 }
16927
16928 /* Return comp_unit_head for PER_CU, either already available in PER_CU->CU
16929 (CU_HEADERP is unused in such case) or prepare a temporary copy at
16930 CU_HEADERP first. */
16931
16932 static const struct comp_unit_head *
16933 per_cu_header_read_in (struct comp_unit_head *cu_headerp,
16934 struct dwarf2_per_cu_data *per_cu)
16935 {
16936 gdb_byte *info_ptr;
16937
16938 if (per_cu->cu)
16939 return &per_cu->cu->header;
16940
16941 info_ptr = per_cu->info_or_types_section->buffer + per_cu->offset.sect_off;
16942
16943 memset (cu_headerp, 0, sizeof (*cu_headerp));
16944 read_comp_unit_head (cu_headerp, info_ptr, per_cu->objfile->obfd);
16945
16946 return cu_headerp;
16947 }
16948
16949 /* Return the address size given in the compilation unit header for CU. */
16950
16951 int
16952 dwarf2_per_cu_addr_size (struct dwarf2_per_cu_data *per_cu)
16953 {
16954 struct comp_unit_head cu_header_local;
16955 const struct comp_unit_head *cu_headerp;
16956
16957 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
16958
16959 return cu_headerp->addr_size;
16960 }
16961
16962 /* Return the offset size given in the compilation unit header for CU. */
16963
16964 int
16965 dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data *per_cu)
16966 {
16967 struct comp_unit_head cu_header_local;
16968 const struct comp_unit_head *cu_headerp;
16969
16970 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
16971
16972 return cu_headerp->offset_size;
16973 }
16974
16975 /* See its dwarf2loc.h declaration. */
16976
16977 int
16978 dwarf2_per_cu_ref_addr_size (struct dwarf2_per_cu_data *per_cu)
16979 {
16980 struct comp_unit_head cu_header_local;
16981 const struct comp_unit_head *cu_headerp;
16982
16983 cu_headerp = per_cu_header_read_in (&cu_header_local, per_cu);
16984
16985 if (cu_headerp->version == 2)
16986 return cu_headerp->addr_size;
16987 else
16988 return cu_headerp->offset_size;
16989 }
16990
16991 /* Return the text offset of the CU. The returned offset comes from
16992 this CU's objfile. If this objfile came from a separate debuginfo
16993 file, then the offset may be different from the corresponding
16994 offset in the parent objfile. */
16995
16996 CORE_ADDR
16997 dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data *per_cu)
16998 {
16999 struct objfile *objfile = per_cu->objfile;
17000
17001 return ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
17002 }
17003
17004 /* Locate the .debug_info compilation unit from CU's objfile which contains
17005 the DIE at OFFSET. Raises an error on failure. */
17006
17007 static struct dwarf2_per_cu_data *
17008 dwarf2_find_containing_comp_unit (sect_offset offset,
17009 struct objfile *objfile)
17010 {
17011 struct dwarf2_per_cu_data *this_cu;
17012 int low, high;
17013
17014 low = 0;
17015 high = dwarf2_per_objfile->n_comp_units - 1;
17016 while (high > low)
17017 {
17018 int mid = low + (high - low) / 2;
17019
17020 if (dwarf2_per_objfile->all_comp_units[mid]->offset.sect_off
17021 >= offset.sect_off)
17022 high = mid;
17023 else
17024 low = mid + 1;
17025 }
17026 gdb_assert (low == high);
17027 if (dwarf2_per_objfile->all_comp_units[low]->offset.sect_off
17028 > offset.sect_off)
17029 {
17030 if (low == 0)
17031 error (_("Dwarf Error: could not find partial DIE containing "
17032 "offset 0x%lx [in module %s]"),
17033 (long) offset.sect_off, bfd_get_filename (objfile->obfd));
17034
17035 gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->offset.sect_off
17036 <= offset.sect_off);
17037 return dwarf2_per_objfile->all_comp_units[low-1];
17038 }
17039 else
17040 {
17041 this_cu = dwarf2_per_objfile->all_comp_units[low];
17042 if (low == dwarf2_per_objfile->n_comp_units - 1
17043 && offset.sect_off >= this_cu->offset.sect_off + this_cu->length)
17044 error (_("invalid dwarf2 offset %u"), offset.sect_off);
17045 gdb_assert (offset.sect_off < this_cu->offset.sect_off + this_cu->length);
17046 return this_cu;
17047 }
17048 }
17049
17050 /* Initialize dwarf2_cu CU, owned by PER_CU. */
17051
17052 static void
17053 init_one_comp_unit (struct dwarf2_cu *cu, struct dwarf2_per_cu_data *per_cu)
17054 {
17055 memset (cu, 0, sizeof (*cu));
17056 per_cu->cu = cu;
17057 cu->per_cu = per_cu;
17058 cu->objfile = per_cu->objfile;
17059 obstack_init (&cu->comp_unit_obstack);
17060 }
17061
17062 /* Initialize basic fields of dwarf_cu CU according to DIE COMP_UNIT_DIE. */
17063
17064 static void
17065 prepare_one_comp_unit (struct dwarf2_cu *cu, struct die_info *comp_unit_die,
17066 enum language pretend_language)
17067 {
17068 struct attribute *attr;
17069
17070 /* Set the language we're debugging. */
17071 attr = dwarf2_attr (comp_unit_die, DW_AT_language, cu);
17072 if (attr)
17073 set_cu_language (DW_UNSND (attr), cu);
17074 else
17075 {
17076 cu->language = pretend_language;
17077 cu->language_defn = language_def (cu->language);
17078 }
17079
17080 attr = dwarf2_attr (comp_unit_die, DW_AT_producer, cu);
17081 if (attr)
17082 cu->producer = DW_STRING (attr);
17083 }
17084
17085 /* Release one cached compilation unit, CU. We unlink it from the tree
17086 of compilation units, but we don't remove it from the read_in_chain;
17087 the caller is responsible for that.
17088 NOTE: DATA is a void * because this function is also used as a
17089 cleanup routine. */
17090
17091 static void
17092 free_heap_comp_unit (void *data)
17093 {
17094 struct dwarf2_cu *cu = data;
17095
17096 gdb_assert (cu->per_cu != NULL);
17097 cu->per_cu->cu = NULL;
17098 cu->per_cu = NULL;
17099
17100 obstack_free (&cu->comp_unit_obstack, NULL);
17101
17102 xfree (cu);
17103 }
17104
17105 /* This cleanup function is passed the address of a dwarf2_cu on the stack
17106 when we're finished with it. We can't free the pointer itself, but be
17107 sure to unlink it from the cache. Also release any associated storage. */
17108
17109 static void
17110 free_stack_comp_unit (void *data)
17111 {
17112 struct dwarf2_cu *cu = data;
17113
17114 gdb_assert (cu->per_cu != NULL);
17115 cu->per_cu->cu = NULL;
17116 cu->per_cu = NULL;
17117
17118 obstack_free (&cu->comp_unit_obstack, NULL);
17119 cu->partial_dies = NULL;
17120 }
17121
17122 /* Free all cached compilation units. */
17123
17124 static void
17125 free_cached_comp_units (void *data)
17126 {
17127 struct dwarf2_per_cu_data *per_cu, **last_chain;
17128
17129 per_cu = dwarf2_per_objfile->read_in_chain;
17130 last_chain = &dwarf2_per_objfile->read_in_chain;
17131 while (per_cu != NULL)
17132 {
17133 struct dwarf2_per_cu_data *next_cu;
17134
17135 next_cu = per_cu->cu->read_in_chain;
17136
17137 free_heap_comp_unit (per_cu->cu);
17138 *last_chain = next_cu;
17139
17140 per_cu = next_cu;
17141 }
17142 }
17143
17144 /* Increase the age counter on each cached compilation unit, and free
17145 any that are too old. */
17146
17147 static void
17148 age_cached_comp_units (void)
17149 {
17150 struct dwarf2_per_cu_data *per_cu, **last_chain;
17151
17152 dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain);
17153 per_cu = dwarf2_per_objfile->read_in_chain;
17154 while (per_cu != NULL)
17155 {
17156 per_cu->cu->last_used ++;
17157 if (per_cu->cu->last_used <= dwarf2_max_cache_age)
17158 dwarf2_mark (per_cu->cu);
17159 per_cu = per_cu->cu->read_in_chain;
17160 }
17161
17162 per_cu = dwarf2_per_objfile->read_in_chain;
17163 last_chain = &dwarf2_per_objfile->read_in_chain;
17164 while (per_cu != NULL)
17165 {
17166 struct dwarf2_per_cu_data *next_cu;
17167
17168 next_cu = per_cu->cu->read_in_chain;
17169
17170 if (!per_cu->cu->mark)
17171 {
17172 free_heap_comp_unit (per_cu->cu);
17173 *last_chain = next_cu;
17174 }
17175 else
17176 last_chain = &per_cu->cu->read_in_chain;
17177
17178 per_cu = next_cu;
17179 }
17180 }
17181
17182 /* Remove a single compilation unit from the cache. */
17183
17184 static void
17185 free_one_cached_comp_unit (struct dwarf2_per_cu_data *target_per_cu)
17186 {
17187 struct dwarf2_per_cu_data *per_cu, **last_chain;
17188
17189 per_cu = dwarf2_per_objfile->read_in_chain;
17190 last_chain = &dwarf2_per_objfile->read_in_chain;
17191 while (per_cu != NULL)
17192 {
17193 struct dwarf2_per_cu_data *next_cu;
17194
17195 next_cu = per_cu->cu->read_in_chain;
17196
17197 if (per_cu == target_per_cu)
17198 {
17199 free_heap_comp_unit (per_cu->cu);
17200 per_cu->cu = NULL;
17201 *last_chain = next_cu;
17202 break;
17203 }
17204 else
17205 last_chain = &per_cu->cu->read_in_chain;
17206
17207 per_cu = next_cu;
17208 }
17209 }
17210
17211 /* Release all extra memory associated with OBJFILE. */
17212
17213 void
17214 dwarf2_free_objfile (struct objfile *objfile)
17215 {
17216 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
17217
17218 if (dwarf2_per_objfile == NULL)
17219 return;
17220
17221 /* Cached DIE trees use xmalloc and the comp_unit_obstack. */
17222 free_cached_comp_units (NULL);
17223
17224 if (dwarf2_per_objfile->quick_file_names_table)
17225 htab_delete (dwarf2_per_objfile->quick_file_names_table);
17226
17227 /* Everything else should be on the objfile obstack. */
17228 }
17229
17230 /* A set of CU "per_cu" pointer, DIE offset, and GDB type pointer.
17231 We store these in a hash table separate from the DIEs, and preserve them
17232 when the DIEs are flushed out of cache.
17233
17234 The CU "per_cu" pointer is needed because offset alone is not enough to
17235 uniquely identify the type. A file may have multiple .debug_types sections,
17236 or the type may come from a DWO file. We have to use something in
17237 dwarf2_per_cu_data (or the pointer to it) because we can enter the lookup
17238 routine, get_die_type_at_offset, from outside this file, and thus won't
17239 necessarily have PER_CU->cu. Fortunately, PER_CU is stable for the life
17240 of the objfile. */
17241
17242 struct dwarf2_per_cu_offset_and_type
17243 {
17244 const struct dwarf2_per_cu_data *per_cu;
17245 sect_offset offset;
17246 struct type *type;
17247 };
17248
17249 /* Hash function for a dwarf2_per_cu_offset_and_type. */
17250
17251 static hashval_t
17252 per_cu_offset_and_type_hash (const void *item)
17253 {
17254 const struct dwarf2_per_cu_offset_and_type *ofs = item;
17255
17256 return (uintptr_t) ofs->per_cu + ofs->offset.sect_off;
17257 }
17258
17259 /* Equality function for a dwarf2_per_cu_offset_and_type. */
17260
17261 static int
17262 per_cu_offset_and_type_eq (const void *item_lhs, const void *item_rhs)
17263 {
17264 const struct dwarf2_per_cu_offset_and_type *ofs_lhs = item_lhs;
17265 const struct dwarf2_per_cu_offset_and_type *ofs_rhs = item_rhs;
17266
17267 return (ofs_lhs->per_cu == ofs_rhs->per_cu
17268 && ofs_lhs->offset.sect_off == ofs_rhs->offset.sect_off);
17269 }
17270
17271 /* Set the type associated with DIE to TYPE. Save it in CU's hash
17272 table if necessary. For convenience, return TYPE.
17273
17274 The DIEs reading must have careful ordering to:
17275 * Not cause infite loops trying to read in DIEs as a prerequisite for
17276 reading current DIE.
17277 * Not trying to dereference contents of still incompletely read in types
17278 while reading in other DIEs.
17279 * Enable referencing still incompletely read in types just by a pointer to
17280 the type without accessing its fields.
17281
17282 Therefore caller should follow these rules:
17283 * Try to fetch any prerequisite types we may need to build this DIE type
17284 before building the type and calling set_die_type.
17285 * After building type call set_die_type for current DIE as soon as
17286 possible before fetching more types to complete the current type.
17287 * Make the type as complete as possible before fetching more types. */
17288
17289 static struct type *
17290 set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
17291 {
17292 struct dwarf2_per_cu_offset_and_type **slot, ofs;
17293 struct objfile *objfile = cu->objfile;
17294
17295 /* For Ada types, make sure that the gnat-specific data is always
17296 initialized (if not already set). There are a few types where
17297 we should not be doing so, because the type-specific area is
17298 already used to hold some other piece of info (eg: TYPE_CODE_FLT
17299 where the type-specific area is used to store the floatformat).
17300 But this is not a problem, because the gnat-specific information
17301 is actually not needed for these types. */
17302 if (need_gnat_info (cu)
17303 && TYPE_CODE (type) != TYPE_CODE_FUNC
17304 && TYPE_CODE (type) != TYPE_CODE_FLT
17305 && !HAVE_GNAT_AUX_INFO (type))
17306 INIT_GNAT_SPECIFIC (type);
17307
17308 if (dwarf2_per_objfile->die_type_hash == NULL)
17309 {
17310 dwarf2_per_objfile->die_type_hash =
17311 htab_create_alloc_ex (127,
17312 per_cu_offset_and_type_hash,
17313 per_cu_offset_and_type_eq,
17314 NULL,
17315 &objfile->objfile_obstack,
17316 hashtab_obstack_allocate,
17317 dummy_obstack_deallocate);
17318 }
17319
17320 ofs.per_cu = cu->per_cu;
17321 ofs.offset = die->offset;
17322 ofs.type = type;
17323 slot = (struct dwarf2_per_cu_offset_and_type **)
17324 htab_find_slot (dwarf2_per_objfile->die_type_hash, &ofs, INSERT);
17325 if (*slot)
17326 complaint (&symfile_complaints,
17327 _("A problem internal to GDB: DIE 0x%x has type already set"),
17328 die->offset.sect_off);
17329 *slot = obstack_alloc (&objfile->objfile_obstack, sizeof (**slot));
17330 **slot = ofs;
17331 return type;
17332 }
17333
17334 /* Look up the type for the die at OFFSET in the appropriate type_hash
17335 table, or return NULL if the die does not have a saved type. */
17336
17337 static struct type *
17338 get_die_type_at_offset (sect_offset offset,
17339 struct dwarf2_per_cu_data *per_cu)
17340 {
17341 struct dwarf2_per_cu_offset_and_type *slot, ofs;
17342
17343 if (dwarf2_per_objfile->die_type_hash == NULL)
17344 return NULL;
17345
17346 ofs.per_cu = per_cu;
17347 ofs.offset = offset;
17348 slot = htab_find (dwarf2_per_objfile->die_type_hash, &ofs);
17349 if (slot)
17350 return slot->type;
17351 else
17352 return NULL;
17353 }
17354
17355 /* Look up the type for DIE in the appropriate type_hash table,
17356 or return NULL if DIE does not have a saved type. */
17357
17358 static struct type *
17359 get_die_type (struct die_info *die, struct dwarf2_cu *cu)
17360 {
17361 return get_die_type_at_offset (die->offset, cu->per_cu);
17362 }
17363
17364 /* Add a dependence relationship from CU to REF_PER_CU. */
17365
17366 static void
17367 dwarf2_add_dependence (struct dwarf2_cu *cu,
17368 struct dwarf2_per_cu_data *ref_per_cu)
17369 {
17370 void **slot;
17371
17372 if (cu->dependencies == NULL)
17373 cu->dependencies
17374 = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
17375 NULL, &cu->comp_unit_obstack,
17376 hashtab_obstack_allocate,
17377 dummy_obstack_deallocate);
17378
17379 slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
17380 if (*slot == NULL)
17381 *slot = ref_per_cu;
17382 }
17383
17384 /* Subroutine of dwarf2_mark to pass to htab_traverse.
17385 Set the mark field in every compilation unit in the
17386 cache that we must keep because we are keeping CU. */
17387
17388 static int
17389 dwarf2_mark_helper (void **slot, void *data)
17390 {
17391 struct dwarf2_per_cu_data *per_cu;
17392
17393 per_cu = (struct dwarf2_per_cu_data *) *slot;
17394
17395 /* cu->dependencies references may not yet have been ever read if QUIT aborts
17396 reading of the chain. As such dependencies remain valid it is not much
17397 useful to track and undo them during QUIT cleanups. */
17398 if (per_cu->cu == NULL)
17399 return 1;
17400
17401 if (per_cu->cu->mark)
17402 return 1;
17403 per_cu->cu->mark = 1;
17404
17405 if (per_cu->cu->dependencies != NULL)
17406 htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
17407
17408 return 1;
17409 }
17410
17411 /* Set the mark field in CU and in every other compilation unit in the
17412 cache that we must keep because we are keeping CU. */
17413
17414 static void
17415 dwarf2_mark (struct dwarf2_cu *cu)
17416 {
17417 if (cu->mark)
17418 return;
17419 cu->mark = 1;
17420 if (cu->dependencies != NULL)
17421 htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
17422 }
17423
17424 static void
17425 dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
17426 {
17427 while (per_cu)
17428 {
17429 per_cu->cu->mark = 0;
17430 per_cu = per_cu->cu->read_in_chain;
17431 }
17432 }
17433
17434 /* Trivial hash function for partial_die_info: the hash value of a DIE
17435 is its offset in .debug_info for this objfile. */
17436
17437 static hashval_t
17438 partial_die_hash (const void *item)
17439 {
17440 const struct partial_die_info *part_die = item;
17441
17442 return part_die->offset.sect_off;
17443 }
17444
17445 /* Trivial comparison function for partial_die_info structures: two DIEs
17446 are equal if they have the same offset. */
17447
17448 static int
17449 partial_die_eq (const void *item_lhs, const void *item_rhs)
17450 {
17451 const struct partial_die_info *part_die_lhs = item_lhs;
17452 const struct partial_die_info *part_die_rhs = item_rhs;
17453
17454 return part_die_lhs->offset.sect_off == part_die_rhs->offset.sect_off;
17455 }
17456
17457 static struct cmd_list_element *set_dwarf2_cmdlist;
17458 static struct cmd_list_element *show_dwarf2_cmdlist;
17459
17460 static void
17461 set_dwarf2_cmd (char *args, int from_tty)
17462 {
17463 help_list (set_dwarf2_cmdlist, "maintenance set dwarf2 ", -1, gdb_stdout);
17464 }
17465
17466 static void
17467 show_dwarf2_cmd (char *args, int from_tty)
17468 {
17469 cmd_show_list (show_dwarf2_cmdlist, from_tty, "");
17470 }
17471
17472 /* If section described by INFO was mmapped, munmap it now. */
17473
17474 static void
17475 munmap_section_buffer (struct dwarf2_section_info *info)
17476 {
17477 if (info->map_addr != NULL)
17478 {
17479 #ifdef HAVE_MMAP
17480 int res;
17481
17482 res = munmap (info->map_addr, info->map_len);
17483 gdb_assert (res == 0);
17484 #else
17485 /* Without HAVE_MMAP, we should never be here to begin with. */
17486 gdb_assert_not_reached ("no mmap support");
17487 #endif
17488 }
17489 }
17490
17491 /* munmap debug sections for OBJFILE, if necessary. */
17492
17493 static void
17494 dwarf2_per_objfile_free (struct objfile *objfile, void *d)
17495 {
17496 struct dwarf2_per_objfile *data = d;
17497 int ix;
17498 struct dwarf2_section_info *section;
17499
17500 /* This is sorted according to the order they're defined in to make it easier
17501 to keep in sync. */
17502 munmap_section_buffer (&data->info);
17503 munmap_section_buffer (&data->abbrev);
17504 munmap_section_buffer (&data->line);
17505 munmap_section_buffer (&data->loc);
17506 munmap_section_buffer (&data->macinfo);
17507 munmap_section_buffer (&data->macro);
17508 munmap_section_buffer (&data->str);
17509 munmap_section_buffer (&data->ranges);
17510 munmap_section_buffer (&data->addr);
17511 munmap_section_buffer (&data->frame);
17512 munmap_section_buffer (&data->eh_frame);
17513 munmap_section_buffer (&data->gdb_index);
17514
17515 for (ix = 0;
17516 VEC_iterate (dwarf2_section_info_def, data->types, ix, section);
17517 ++ix)
17518 munmap_section_buffer (section);
17519
17520 for (ix = 0; ix < dwarf2_per_objfile->n_comp_units; ++ix)
17521 VEC_free (dwarf2_per_cu_ptr,
17522 dwarf2_per_objfile->all_comp_units[ix]->imported_symtabs);
17523
17524 VEC_free (dwarf2_section_info_def, data->types);
17525
17526 if (data->dwo_files)
17527 free_dwo_files (data->dwo_files, objfile);
17528 }
17529
17530 \f
17531 /* The "save gdb-index" command. */
17532
17533 /* The contents of the hash table we create when building the string
17534 table. */
17535 struct strtab_entry
17536 {
17537 offset_type offset;
17538 const char *str;
17539 };
17540
17541 /* Hash function for a strtab_entry.
17542
17543 Function is used only during write_hash_table so no index format backward
17544 compatibility is needed. */
17545
17546 static hashval_t
17547 hash_strtab_entry (const void *e)
17548 {
17549 const struct strtab_entry *entry = e;
17550 return mapped_index_string_hash (INT_MAX, entry->str);
17551 }
17552
17553 /* Equality function for a strtab_entry. */
17554
17555 static int
17556 eq_strtab_entry (const void *a, const void *b)
17557 {
17558 const struct strtab_entry *ea = a;
17559 const struct strtab_entry *eb = b;
17560 return !strcmp (ea->str, eb->str);
17561 }
17562
17563 /* Create a strtab_entry hash table. */
17564
17565 static htab_t
17566 create_strtab (void)
17567 {
17568 return htab_create_alloc (100, hash_strtab_entry, eq_strtab_entry,
17569 xfree, xcalloc, xfree);
17570 }
17571
17572 /* Add a string to the constant pool. Return the string's offset in
17573 host order. */
17574
17575 static offset_type
17576 add_string (htab_t table, struct obstack *cpool, const char *str)
17577 {
17578 void **slot;
17579 struct strtab_entry entry;
17580 struct strtab_entry *result;
17581
17582 entry.str = str;
17583 slot = htab_find_slot (table, &entry, INSERT);
17584 if (*slot)
17585 result = *slot;
17586 else
17587 {
17588 result = XNEW (struct strtab_entry);
17589 result->offset = obstack_object_size (cpool);
17590 result->str = str;
17591 obstack_grow_str0 (cpool, str);
17592 *slot = result;
17593 }
17594 return result->offset;
17595 }
17596
17597 /* An entry in the symbol table. */
17598 struct symtab_index_entry
17599 {
17600 /* The name of the symbol. */
17601 const char *name;
17602 /* The offset of the name in the constant pool. */
17603 offset_type index_offset;
17604 /* A sorted vector of the indices of all the CUs that hold an object
17605 of this name. */
17606 VEC (offset_type) *cu_indices;
17607 };
17608
17609 /* The symbol table. This is a power-of-2-sized hash table. */
17610 struct mapped_symtab
17611 {
17612 offset_type n_elements;
17613 offset_type size;
17614 struct symtab_index_entry **data;
17615 };
17616
17617 /* Hash function for a symtab_index_entry. */
17618
17619 static hashval_t
17620 hash_symtab_entry (const void *e)
17621 {
17622 const struct symtab_index_entry *entry = e;
17623 return iterative_hash (VEC_address (offset_type, entry->cu_indices),
17624 sizeof (offset_type) * VEC_length (offset_type,
17625 entry->cu_indices),
17626 0);
17627 }
17628
17629 /* Equality function for a symtab_index_entry. */
17630
17631 static int
17632 eq_symtab_entry (const void *a, const void *b)
17633 {
17634 const struct symtab_index_entry *ea = a;
17635 const struct symtab_index_entry *eb = b;
17636 int len = VEC_length (offset_type, ea->cu_indices);
17637 if (len != VEC_length (offset_type, eb->cu_indices))
17638 return 0;
17639 return !memcmp (VEC_address (offset_type, ea->cu_indices),
17640 VEC_address (offset_type, eb->cu_indices),
17641 sizeof (offset_type) * len);
17642 }
17643
17644 /* Destroy a symtab_index_entry. */
17645
17646 static void
17647 delete_symtab_entry (void *p)
17648 {
17649 struct symtab_index_entry *entry = p;
17650 VEC_free (offset_type, entry->cu_indices);
17651 xfree (entry);
17652 }
17653
17654 /* Create a hash table holding symtab_index_entry objects. */
17655
17656 static htab_t
17657 create_symbol_hash_table (void)
17658 {
17659 return htab_create_alloc (100, hash_symtab_entry, eq_symtab_entry,
17660 delete_symtab_entry, xcalloc, xfree);
17661 }
17662
17663 /* Create a new mapped symtab object. */
17664
17665 static struct mapped_symtab *
17666 create_mapped_symtab (void)
17667 {
17668 struct mapped_symtab *symtab = XNEW (struct mapped_symtab);
17669 symtab->n_elements = 0;
17670 symtab->size = 1024;
17671 symtab->data = XCNEWVEC (struct symtab_index_entry *, symtab->size);
17672 return symtab;
17673 }
17674
17675 /* Destroy a mapped_symtab. */
17676
17677 static void
17678 cleanup_mapped_symtab (void *p)
17679 {
17680 struct mapped_symtab *symtab = p;
17681 /* The contents of the array are freed when the other hash table is
17682 destroyed. */
17683 xfree (symtab->data);
17684 xfree (symtab);
17685 }
17686
17687 /* Find a slot in SYMTAB for the symbol NAME. Returns a pointer to
17688 the slot.
17689
17690 Function is used only during write_hash_table so no index format backward
17691 compatibility is needed. */
17692
17693 static struct symtab_index_entry **
17694 find_slot (struct mapped_symtab *symtab, const char *name)
17695 {
17696 offset_type index, step, hash = mapped_index_string_hash (INT_MAX, name);
17697
17698 index = hash & (symtab->size - 1);
17699 step = ((hash * 17) & (symtab->size - 1)) | 1;
17700
17701 for (;;)
17702 {
17703 if (!symtab->data[index] || !strcmp (name, symtab->data[index]->name))
17704 return &symtab->data[index];
17705 index = (index + step) & (symtab->size - 1);
17706 }
17707 }
17708
17709 /* Expand SYMTAB's hash table. */
17710
17711 static void
17712 hash_expand (struct mapped_symtab *symtab)
17713 {
17714 offset_type old_size = symtab->size;
17715 offset_type i;
17716 struct symtab_index_entry **old_entries = symtab->data;
17717
17718 symtab->size *= 2;
17719 symtab->data = XCNEWVEC (struct symtab_index_entry *, symtab->size);
17720
17721 for (i = 0; i < old_size; ++i)
17722 {
17723 if (old_entries[i])
17724 {
17725 struct symtab_index_entry **slot = find_slot (symtab,
17726 old_entries[i]->name);
17727 *slot = old_entries[i];
17728 }
17729 }
17730
17731 xfree (old_entries);
17732 }
17733
17734 /* Add an entry to SYMTAB. NAME is the name of the symbol.
17735 CU_INDEX is the index of the CU in which the symbol appears.
17736 IS_STATIC is one if the symbol is static, otherwise zero (global). */
17737
17738 static void
17739 add_index_entry (struct mapped_symtab *symtab, const char *name,
17740 int is_static, gdb_index_symbol_kind kind,
17741 offset_type cu_index)
17742 {
17743 struct symtab_index_entry **slot;
17744 offset_type cu_index_and_attrs;
17745
17746 ++symtab->n_elements;
17747 if (4 * symtab->n_elements / 3 >= symtab->size)
17748 hash_expand (symtab);
17749
17750 slot = find_slot (symtab, name);
17751 if (!*slot)
17752 {
17753 *slot = XNEW (struct symtab_index_entry);
17754 (*slot)->name = name;
17755 /* index_offset is set later. */
17756 (*slot)->cu_indices = NULL;
17757 }
17758
17759 cu_index_and_attrs = 0;
17760 DW2_GDB_INDEX_CU_SET_VALUE (cu_index_and_attrs, cu_index);
17761 DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE (cu_index_and_attrs, is_static);
17762 DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE (cu_index_and_attrs, kind);
17763
17764 /* We don't want to record an index value twice as we want to avoid the
17765 duplication.
17766 We process all global symbols and then all static symbols
17767 (which would allow us to avoid the duplication by only having to check
17768 the last entry pushed), but a symbol could have multiple kinds in one CU.
17769 To keep things simple we don't worry about the duplication here and
17770 sort and uniqufy the list after we've processed all symbols. */
17771 VEC_safe_push (offset_type, (*slot)->cu_indices, cu_index_and_attrs);
17772 }
17773
17774 /* qsort helper routine for uniquify_cu_indices. */
17775
17776 static int
17777 offset_type_compare (const void *ap, const void *bp)
17778 {
17779 offset_type a = *(offset_type *) ap;
17780 offset_type b = *(offset_type *) bp;
17781
17782 return (a > b) - (b > a);
17783 }
17784
17785 /* Sort and remove duplicates of all symbols' cu_indices lists. */
17786
17787 static void
17788 uniquify_cu_indices (struct mapped_symtab *symtab)
17789 {
17790 int i;
17791
17792 for (i = 0; i < symtab->size; ++i)
17793 {
17794 struct symtab_index_entry *entry = symtab->data[i];
17795
17796 if (entry
17797 && entry->cu_indices != NULL)
17798 {
17799 unsigned int next_to_insert, next_to_check;
17800 offset_type last_value;
17801
17802 qsort (VEC_address (offset_type, entry->cu_indices),
17803 VEC_length (offset_type, entry->cu_indices),
17804 sizeof (offset_type), offset_type_compare);
17805
17806 last_value = VEC_index (offset_type, entry->cu_indices, 0);
17807 next_to_insert = 1;
17808 for (next_to_check = 1;
17809 next_to_check < VEC_length (offset_type, entry->cu_indices);
17810 ++next_to_check)
17811 {
17812 if (VEC_index (offset_type, entry->cu_indices, next_to_check)
17813 != last_value)
17814 {
17815 last_value = VEC_index (offset_type, entry->cu_indices,
17816 next_to_check);
17817 VEC_replace (offset_type, entry->cu_indices, next_to_insert,
17818 last_value);
17819 ++next_to_insert;
17820 }
17821 }
17822 VEC_truncate (offset_type, entry->cu_indices, next_to_insert);
17823 }
17824 }
17825 }
17826
17827 /* Add a vector of indices to the constant pool. */
17828
17829 static offset_type
17830 add_indices_to_cpool (htab_t symbol_hash_table, struct obstack *cpool,
17831 struct symtab_index_entry *entry)
17832 {
17833 void **slot;
17834
17835 slot = htab_find_slot (symbol_hash_table, entry, INSERT);
17836 if (!*slot)
17837 {
17838 offset_type len = VEC_length (offset_type, entry->cu_indices);
17839 offset_type val = MAYBE_SWAP (len);
17840 offset_type iter;
17841 int i;
17842
17843 *slot = entry;
17844 entry->index_offset = obstack_object_size (cpool);
17845
17846 obstack_grow (cpool, &val, sizeof (val));
17847 for (i = 0;
17848 VEC_iterate (offset_type, entry->cu_indices, i, iter);
17849 ++i)
17850 {
17851 val = MAYBE_SWAP (iter);
17852 obstack_grow (cpool, &val, sizeof (val));
17853 }
17854 }
17855 else
17856 {
17857 struct symtab_index_entry *old_entry = *slot;
17858 entry->index_offset = old_entry->index_offset;
17859 entry = old_entry;
17860 }
17861 return entry->index_offset;
17862 }
17863
17864 /* Write the mapped hash table SYMTAB to the obstack OUTPUT, with
17865 constant pool entries going into the obstack CPOOL. */
17866
17867 static void
17868 write_hash_table (struct mapped_symtab *symtab,
17869 struct obstack *output, struct obstack *cpool)
17870 {
17871 offset_type i;
17872 htab_t symbol_hash_table;
17873 htab_t str_table;
17874
17875 symbol_hash_table = create_symbol_hash_table ();
17876 str_table = create_strtab ();
17877
17878 /* We add all the index vectors to the constant pool first, to
17879 ensure alignment is ok. */
17880 for (i = 0; i < symtab->size; ++i)
17881 {
17882 if (symtab->data[i])
17883 add_indices_to_cpool (symbol_hash_table, cpool, symtab->data[i]);
17884 }
17885
17886 /* Now write out the hash table. */
17887 for (i = 0; i < symtab->size; ++i)
17888 {
17889 offset_type str_off, vec_off;
17890
17891 if (symtab->data[i])
17892 {
17893 str_off = add_string (str_table, cpool, symtab->data[i]->name);
17894 vec_off = symtab->data[i]->index_offset;
17895 }
17896 else
17897 {
17898 /* While 0 is a valid constant pool index, it is not valid
17899 to have 0 for both offsets. */
17900 str_off = 0;
17901 vec_off = 0;
17902 }
17903
17904 str_off = MAYBE_SWAP (str_off);
17905 vec_off = MAYBE_SWAP (vec_off);
17906
17907 obstack_grow (output, &str_off, sizeof (str_off));
17908 obstack_grow (output, &vec_off, sizeof (vec_off));
17909 }
17910
17911 htab_delete (str_table);
17912 htab_delete (symbol_hash_table);
17913 }
17914
17915 /* Struct to map psymtab to CU index in the index file. */
17916 struct psymtab_cu_index_map
17917 {
17918 struct partial_symtab *psymtab;
17919 unsigned int cu_index;
17920 };
17921
17922 static hashval_t
17923 hash_psymtab_cu_index (const void *item)
17924 {
17925 const struct psymtab_cu_index_map *map = item;
17926
17927 return htab_hash_pointer (map->psymtab);
17928 }
17929
17930 static int
17931 eq_psymtab_cu_index (const void *item_lhs, const void *item_rhs)
17932 {
17933 const struct psymtab_cu_index_map *lhs = item_lhs;
17934 const struct psymtab_cu_index_map *rhs = item_rhs;
17935
17936 return lhs->psymtab == rhs->psymtab;
17937 }
17938
17939 /* Helper struct for building the address table. */
17940 struct addrmap_index_data
17941 {
17942 struct objfile *objfile;
17943 struct obstack *addr_obstack;
17944 htab_t cu_index_htab;
17945
17946 /* Non-zero if the previous_* fields are valid.
17947 We can't write an entry until we see the next entry (since it is only then
17948 that we know the end of the entry). */
17949 int previous_valid;
17950 /* Index of the CU in the table of all CUs in the index file. */
17951 unsigned int previous_cu_index;
17952 /* Start address of the CU. */
17953 CORE_ADDR previous_cu_start;
17954 };
17955
17956 /* Write an address entry to OBSTACK. */
17957
17958 static void
17959 add_address_entry (struct objfile *objfile, struct obstack *obstack,
17960 CORE_ADDR start, CORE_ADDR end, unsigned int cu_index)
17961 {
17962 offset_type cu_index_to_write;
17963 char addr[8];
17964 CORE_ADDR baseaddr;
17965
17966 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
17967
17968 store_unsigned_integer (addr, 8, BFD_ENDIAN_LITTLE, start - baseaddr);
17969 obstack_grow (obstack, addr, 8);
17970 store_unsigned_integer (addr, 8, BFD_ENDIAN_LITTLE, end - baseaddr);
17971 obstack_grow (obstack, addr, 8);
17972 cu_index_to_write = MAYBE_SWAP (cu_index);
17973 obstack_grow (obstack, &cu_index_to_write, sizeof (offset_type));
17974 }
17975
17976 /* Worker function for traversing an addrmap to build the address table. */
17977
17978 static int
17979 add_address_entry_worker (void *datap, CORE_ADDR start_addr, void *obj)
17980 {
17981 struct addrmap_index_data *data = datap;
17982 struct partial_symtab *pst = obj;
17983
17984 if (data->previous_valid)
17985 add_address_entry (data->objfile, data->addr_obstack,
17986 data->previous_cu_start, start_addr,
17987 data->previous_cu_index);
17988
17989 data->previous_cu_start = start_addr;
17990 if (pst != NULL)
17991 {
17992 struct psymtab_cu_index_map find_map, *map;
17993 find_map.psymtab = pst;
17994 map = htab_find (data->cu_index_htab, &find_map);
17995 gdb_assert (map != NULL);
17996 data->previous_cu_index = map->cu_index;
17997 data->previous_valid = 1;
17998 }
17999 else
18000 data->previous_valid = 0;
18001
18002 return 0;
18003 }
18004
18005 /* Write OBJFILE's address map to OBSTACK.
18006 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
18007 in the index file. */
18008
18009 static void
18010 write_address_map (struct objfile *objfile, struct obstack *obstack,
18011 htab_t cu_index_htab)
18012 {
18013 struct addrmap_index_data addrmap_index_data;
18014
18015 /* When writing the address table, we have to cope with the fact that
18016 the addrmap iterator only provides the start of a region; we have to
18017 wait until the next invocation to get the start of the next region. */
18018
18019 addrmap_index_data.objfile = objfile;
18020 addrmap_index_data.addr_obstack = obstack;
18021 addrmap_index_data.cu_index_htab = cu_index_htab;
18022 addrmap_index_data.previous_valid = 0;
18023
18024 addrmap_foreach (objfile->psymtabs_addrmap, add_address_entry_worker,
18025 &addrmap_index_data);
18026
18027 /* It's highly unlikely the last entry (end address = 0xff...ff)
18028 is valid, but we should still handle it.
18029 The end address is recorded as the start of the next region, but that
18030 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
18031 anyway. */
18032 if (addrmap_index_data.previous_valid)
18033 add_address_entry (objfile, obstack,
18034 addrmap_index_data.previous_cu_start, (CORE_ADDR) -1,
18035 addrmap_index_data.previous_cu_index);
18036 }
18037
18038 /* Return the symbol kind of PSYM. */
18039
18040 static gdb_index_symbol_kind
18041 symbol_kind (struct partial_symbol *psym)
18042 {
18043 domain_enum domain = PSYMBOL_DOMAIN (psym);
18044 enum address_class aclass = PSYMBOL_CLASS (psym);
18045
18046 switch (domain)
18047 {
18048 case VAR_DOMAIN:
18049 switch (aclass)
18050 {
18051 case LOC_BLOCK:
18052 return GDB_INDEX_SYMBOL_KIND_FUNCTION;
18053 case LOC_TYPEDEF:
18054 return GDB_INDEX_SYMBOL_KIND_TYPE;
18055 case LOC_COMPUTED:
18056 case LOC_CONST_BYTES:
18057 case LOC_OPTIMIZED_OUT:
18058 case LOC_STATIC:
18059 return GDB_INDEX_SYMBOL_KIND_VARIABLE;
18060 case LOC_CONST:
18061 /* Note: It's currently impossible to recognize psyms as enum values
18062 short of reading the type info. For now punt. */
18063 return GDB_INDEX_SYMBOL_KIND_VARIABLE;
18064 default:
18065 /* There are other LOC_FOO values that one might want to classify
18066 as variables, but dwarf2read.c doesn't currently use them. */
18067 return GDB_INDEX_SYMBOL_KIND_OTHER;
18068 }
18069 case STRUCT_DOMAIN:
18070 return GDB_INDEX_SYMBOL_KIND_TYPE;
18071 default:
18072 return GDB_INDEX_SYMBOL_KIND_OTHER;
18073 }
18074 }
18075
18076 /* Add a list of partial symbols to SYMTAB. */
18077
18078 static void
18079 write_psymbols (struct mapped_symtab *symtab,
18080 htab_t psyms_seen,
18081 struct partial_symbol **psymp,
18082 int count,
18083 offset_type cu_index,
18084 int is_static)
18085 {
18086 for (; count-- > 0; ++psymp)
18087 {
18088 struct partial_symbol *psym = *psymp;
18089 void **slot;
18090
18091 if (SYMBOL_LANGUAGE (psym) == language_ada)
18092 error (_("Ada is not currently supported by the index"));
18093
18094 /* Only add a given psymbol once. */
18095 slot = htab_find_slot (psyms_seen, psym, INSERT);
18096 if (!*slot)
18097 {
18098 gdb_index_symbol_kind kind = symbol_kind (psym);
18099
18100 *slot = psym;
18101 add_index_entry (symtab, SYMBOL_SEARCH_NAME (psym),
18102 is_static, kind, cu_index);
18103 }
18104 }
18105 }
18106
18107 /* Write the contents of an ("unfinished") obstack to FILE. Throw an
18108 exception if there is an error. */
18109
18110 static void
18111 write_obstack (FILE *file, struct obstack *obstack)
18112 {
18113 if (fwrite (obstack_base (obstack), 1, obstack_object_size (obstack),
18114 file)
18115 != obstack_object_size (obstack))
18116 error (_("couldn't data write to file"));
18117 }
18118
18119 /* Unlink a file if the argument is not NULL. */
18120
18121 static void
18122 unlink_if_set (void *p)
18123 {
18124 char **filename = p;
18125 if (*filename)
18126 unlink (*filename);
18127 }
18128
18129 /* A helper struct used when iterating over debug_types. */
18130 struct signatured_type_index_data
18131 {
18132 struct objfile *objfile;
18133 struct mapped_symtab *symtab;
18134 struct obstack *types_list;
18135 htab_t psyms_seen;
18136 int cu_index;
18137 };
18138
18139 /* A helper function that writes a single signatured_type to an
18140 obstack. */
18141
18142 static int
18143 write_one_signatured_type (void **slot, void *d)
18144 {
18145 struct signatured_type_index_data *info = d;
18146 struct signatured_type *entry = (struct signatured_type *) *slot;
18147 struct dwarf2_per_cu_data *per_cu = &entry->per_cu;
18148 struct partial_symtab *psymtab = per_cu->v.psymtab;
18149 gdb_byte val[8];
18150
18151 write_psymbols (info->symtab,
18152 info->psyms_seen,
18153 info->objfile->global_psymbols.list
18154 + psymtab->globals_offset,
18155 psymtab->n_global_syms, info->cu_index,
18156 0);
18157 write_psymbols (info->symtab,
18158 info->psyms_seen,
18159 info->objfile->static_psymbols.list
18160 + psymtab->statics_offset,
18161 psymtab->n_static_syms, info->cu_index,
18162 1);
18163
18164 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE,
18165 entry->per_cu.offset.sect_off);
18166 obstack_grow (info->types_list, val, 8);
18167 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE,
18168 entry->type_offset_in_tu.cu_off);
18169 obstack_grow (info->types_list, val, 8);
18170 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, entry->signature);
18171 obstack_grow (info->types_list, val, 8);
18172
18173 ++info->cu_index;
18174
18175 return 1;
18176 }
18177
18178 /* Recurse into all "included" dependencies and write their symbols as
18179 if they appeared in this psymtab. */
18180
18181 static void
18182 recursively_write_psymbols (struct objfile *objfile,
18183 struct partial_symtab *psymtab,
18184 struct mapped_symtab *symtab,
18185 htab_t psyms_seen,
18186 offset_type cu_index)
18187 {
18188 int i;
18189
18190 for (i = 0; i < psymtab->number_of_dependencies; ++i)
18191 if (psymtab->dependencies[i]->user != NULL)
18192 recursively_write_psymbols (objfile, psymtab->dependencies[i],
18193 symtab, psyms_seen, cu_index);
18194
18195 write_psymbols (symtab,
18196 psyms_seen,
18197 objfile->global_psymbols.list + psymtab->globals_offset,
18198 psymtab->n_global_syms, cu_index,
18199 0);
18200 write_psymbols (symtab,
18201 psyms_seen,
18202 objfile->static_psymbols.list + psymtab->statics_offset,
18203 psymtab->n_static_syms, cu_index,
18204 1);
18205 }
18206
18207 /* Create an index file for OBJFILE in the directory DIR. */
18208
18209 static void
18210 write_psymtabs_to_index (struct objfile *objfile, const char *dir)
18211 {
18212 struct cleanup *cleanup;
18213 char *filename, *cleanup_filename;
18214 struct obstack contents, addr_obstack, constant_pool, symtab_obstack;
18215 struct obstack cu_list, types_cu_list;
18216 int i;
18217 FILE *out_file;
18218 struct mapped_symtab *symtab;
18219 offset_type val, size_of_contents, total_len;
18220 struct stat st;
18221 htab_t psyms_seen;
18222 htab_t cu_index_htab;
18223 struct psymtab_cu_index_map *psymtab_cu_index_map;
18224
18225 if (!objfile->psymtabs || !objfile->psymtabs_addrmap)
18226 return;
18227
18228 if (dwarf2_per_objfile->using_index)
18229 error (_("Cannot use an index to create the index"));
18230
18231 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) > 1)
18232 error (_("Cannot make an index when the file has multiple .debug_types sections"));
18233
18234 if (stat (objfile->name, &st) < 0)
18235 perror_with_name (objfile->name);
18236
18237 filename = concat (dir, SLASH_STRING, lbasename (objfile->name),
18238 INDEX_SUFFIX, (char *) NULL);
18239 cleanup = make_cleanup (xfree, filename);
18240
18241 out_file = fopen (filename, "wb");
18242 if (!out_file)
18243 error (_("Can't open `%s' for writing"), filename);
18244
18245 cleanup_filename = filename;
18246 make_cleanup (unlink_if_set, &cleanup_filename);
18247
18248 symtab = create_mapped_symtab ();
18249 make_cleanup (cleanup_mapped_symtab, symtab);
18250
18251 obstack_init (&addr_obstack);
18252 make_cleanup_obstack_free (&addr_obstack);
18253
18254 obstack_init (&cu_list);
18255 make_cleanup_obstack_free (&cu_list);
18256
18257 obstack_init (&types_cu_list);
18258 make_cleanup_obstack_free (&types_cu_list);
18259
18260 psyms_seen = htab_create_alloc (100, htab_hash_pointer, htab_eq_pointer,
18261 NULL, xcalloc, xfree);
18262 make_cleanup_htab_delete (psyms_seen);
18263
18264 /* While we're scanning CU's create a table that maps a psymtab pointer
18265 (which is what addrmap records) to its index (which is what is recorded
18266 in the index file). This will later be needed to write the address
18267 table. */
18268 cu_index_htab = htab_create_alloc (100,
18269 hash_psymtab_cu_index,
18270 eq_psymtab_cu_index,
18271 NULL, xcalloc, xfree);
18272 make_cleanup_htab_delete (cu_index_htab);
18273 psymtab_cu_index_map = (struct psymtab_cu_index_map *)
18274 xmalloc (sizeof (struct psymtab_cu_index_map)
18275 * dwarf2_per_objfile->n_comp_units);
18276 make_cleanup (xfree, psymtab_cu_index_map);
18277
18278 /* The CU list is already sorted, so we don't need to do additional
18279 work here. Also, the debug_types entries do not appear in
18280 all_comp_units, but only in their own hash table. */
18281 for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
18282 {
18283 struct dwarf2_per_cu_data *per_cu
18284 = dwarf2_per_objfile->all_comp_units[i];
18285 struct partial_symtab *psymtab = per_cu->v.psymtab;
18286 gdb_byte val[8];
18287 struct psymtab_cu_index_map *map;
18288 void **slot;
18289
18290 if (psymtab->user == NULL)
18291 recursively_write_psymbols (objfile, psymtab, symtab, psyms_seen, i);
18292
18293 map = &psymtab_cu_index_map[i];
18294 map->psymtab = psymtab;
18295 map->cu_index = i;
18296 slot = htab_find_slot (cu_index_htab, map, INSERT);
18297 gdb_assert (slot != NULL);
18298 gdb_assert (*slot == NULL);
18299 *slot = map;
18300
18301 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE,
18302 per_cu->offset.sect_off);
18303 obstack_grow (&cu_list, val, 8);
18304 store_unsigned_integer (val, 8, BFD_ENDIAN_LITTLE, per_cu->length);
18305 obstack_grow (&cu_list, val, 8);
18306 }
18307
18308 /* Dump the address map. */
18309 write_address_map (objfile, &addr_obstack, cu_index_htab);
18310
18311 /* Write out the .debug_type entries, if any. */
18312 if (dwarf2_per_objfile->signatured_types)
18313 {
18314 struct signatured_type_index_data sig_data;
18315
18316 sig_data.objfile = objfile;
18317 sig_data.symtab = symtab;
18318 sig_data.types_list = &types_cu_list;
18319 sig_data.psyms_seen = psyms_seen;
18320 sig_data.cu_index = dwarf2_per_objfile->n_comp_units;
18321 htab_traverse_noresize (dwarf2_per_objfile->signatured_types,
18322 write_one_signatured_type, &sig_data);
18323 }
18324
18325 /* Now that we've processed all symbols we can shrink their cu_indices
18326 lists. */
18327 uniquify_cu_indices (symtab);
18328
18329 obstack_init (&constant_pool);
18330 make_cleanup_obstack_free (&constant_pool);
18331 obstack_init (&symtab_obstack);
18332 make_cleanup_obstack_free (&symtab_obstack);
18333 write_hash_table (symtab, &symtab_obstack, &constant_pool);
18334
18335 obstack_init (&contents);
18336 make_cleanup_obstack_free (&contents);
18337 size_of_contents = 6 * sizeof (offset_type);
18338 total_len = size_of_contents;
18339
18340 /* The version number. */
18341 val = MAYBE_SWAP (7);
18342 obstack_grow (&contents, &val, sizeof (val));
18343
18344 /* The offset of the CU list from the start of the file. */
18345 val = MAYBE_SWAP (total_len);
18346 obstack_grow (&contents, &val, sizeof (val));
18347 total_len += obstack_object_size (&cu_list);
18348
18349 /* The offset of the types CU list from the start of the file. */
18350 val = MAYBE_SWAP (total_len);
18351 obstack_grow (&contents, &val, sizeof (val));
18352 total_len += obstack_object_size (&types_cu_list);
18353
18354 /* The offset of the address table from the start of the file. */
18355 val = MAYBE_SWAP (total_len);
18356 obstack_grow (&contents, &val, sizeof (val));
18357 total_len += obstack_object_size (&addr_obstack);
18358
18359 /* The offset of the symbol table from the start of the file. */
18360 val = MAYBE_SWAP (total_len);
18361 obstack_grow (&contents, &val, sizeof (val));
18362 total_len += obstack_object_size (&symtab_obstack);
18363
18364 /* The offset of the constant pool from the start of the file. */
18365 val = MAYBE_SWAP (total_len);
18366 obstack_grow (&contents, &val, sizeof (val));
18367 total_len += obstack_object_size (&constant_pool);
18368
18369 gdb_assert (obstack_object_size (&contents) == size_of_contents);
18370
18371 write_obstack (out_file, &contents);
18372 write_obstack (out_file, &cu_list);
18373 write_obstack (out_file, &types_cu_list);
18374 write_obstack (out_file, &addr_obstack);
18375 write_obstack (out_file, &symtab_obstack);
18376 write_obstack (out_file, &constant_pool);
18377
18378 fclose (out_file);
18379
18380 /* We want to keep the file, so we set cleanup_filename to NULL
18381 here. See unlink_if_set. */
18382 cleanup_filename = NULL;
18383
18384 do_cleanups (cleanup);
18385 }
18386
18387 /* Implementation of the `save gdb-index' command.
18388
18389 Note that the file format used by this command is documented in the
18390 GDB manual. Any changes here must be documented there. */
18391
18392 static void
18393 save_gdb_index_command (char *arg, int from_tty)
18394 {
18395 struct objfile *objfile;
18396
18397 if (!arg || !*arg)
18398 error (_("usage: save gdb-index DIRECTORY"));
18399
18400 ALL_OBJFILES (objfile)
18401 {
18402 struct stat st;
18403
18404 /* If the objfile does not correspond to an actual file, skip it. */
18405 if (stat (objfile->name, &st) < 0)
18406 continue;
18407
18408 dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
18409 if (dwarf2_per_objfile)
18410 {
18411 volatile struct gdb_exception except;
18412
18413 TRY_CATCH (except, RETURN_MASK_ERROR)
18414 {
18415 write_psymtabs_to_index (objfile, arg);
18416 }
18417 if (except.reason < 0)
18418 exception_fprintf (gdb_stderr, except,
18419 _("Error while writing index for `%s': "),
18420 objfile->name);
18421 }
18422 }
18423 }
18424
18425 \f
18426
18427 int dwarf2_always_disassemble;
18428
18429 static void
18430 show_dwarf2_always_disassemble (struct ui_file *file, int from_tty,
18431 struct cmd_list_element *c, const char *value)
18432 {
18433 fprintf_filtered (file,
18434 _("Whether to always disassemble "
18435 "DWARF expressions is %s.\n"),
18436 value);
18437 }
18438
18439 static void
18440 show_check_physname (struct ui_file *file, int from_tty,
18441 struct cmd_list_element *c, const char *value)
18442 {
18443 fprintf_filtered (file,
18444 _("Whether to check \"physname\" is %s.\n"),
18445 value);
18446 }
18447
18448 void _initialize_dwarf2_read (void);
18449
18450 void
18451 _initialize_dwarf2_read (void)
18452 {
18453 struct cmd_list_element *c;
18454
18455 dwarf2_objfile_data_key
18456 = register_objfile_data_with_cleanup (NULL, dwarf2_per_objfile_free);
18457
18458 add_prefix_cmd ("dwarf2", class_maintenance, set_dwarf2_cmd, _("\
18459 Set DWARF 2 specific variables.\n\
18460 Configure DWARF 2 variables such as the cache size"),
18461 &set_dwarf2_cmdlist, "maintenance set dwarf2 ",
18462 0/*allow-unknown*/, &maintenance_set_cmdlist);
18463
18464 add_prefix_cmd ("dwarf2", class_maintenance, show_dwarf2_cmd, _("\
18465 Show DWARF 2 specific variables\n\
18466 Show DWARF 2 variables such as the cache size"),
18467 &show_dwarf2_cmdlist, "maintenance show dwarf2 ",
18468 0/*allow-unknown*/, &maintenance_show_cmdlist);
18469
18470 add_setshow_zinteger_cmd ("max-cache-age", class_obscure,
18471 &dwarf2_max_cache_age, _("\
18472 Set the upper bound on the age of cached dwarf2 compilation units."), _("\
18473 Show the upper bound on the age of cached dwarf2 compilation units."), _("\
18474 A higher limit means that cached compilation units will be stored\n\
18475 in memory longer, and more total memory will be used. Zero disables\n\
18476 caching, which can slow down startup."),
18477 NULL,
18478 show_dwarf2_max_cache_age,
18479 &set_dwarf2_cmdlist,
18480 &show_dwarf2_cmdlist);
18481
18482 add_setshow_boolean_cmd ("always-disassemble", class_obscure,
18483 &dwarf2_always_disassemble, _("\
18484 Set whether `info address' always disassembles DWARF expressions."), _("\
18485 Show whether `info address' always disassembles DWARF expressions."), _("\
18486 When enabled, DWARF expressions are always printed in an assembly-like\n\
18487 syntax. When disabled, expressions will be printed in a more\n\
18488 conversational style, when possible."),
18489 NULL,
18490 show_dwarf2_always_disassemble,
18491 &set_dwarf2_cmdlist,
18492 &show_dwarf2_cmdlist);
18493
18494 add_setshow_boolean_cmd ("dwarf2-read", no_class, &dwarf2_read_debug, _("\
18495 Set debugging of the dwarf2 reader."), _("\
18496 Show debugging of the dwarf2 reader."), _("\
18497 When enabled, debugging messages are printed during dwarf2 reading\n\
18498 and symtab expansion."),
18499 NULL,
18500 NULL,
18501 &setdebuglist, &showdebuglist);
18502
18503 add_setshow_zinteger_cmd ("dwarf2-die", no_class, &dwarf2_die_debug, _("\
18504 Set debugging of the dwarf2 DIE reader."), _("\
18505 Show debugging of the dwarf2 DIE reader."), _("\
18506 When enabled (non-zero), DIEs are dumped after they are read in.\n\
18507 The value is the maximum depth to print."),
18508 NULL,
18509 NULL,
18510 &setdebuglist, &showdebuglist);
18511
18512 add_setshow_boolean_cmd ("check-physname", no_class, &check_physname, _("\
18513 Set cross-checking of \"physname\" code against demangler."), _("\
18514 Show cross-checking of \"physname\" code against demangler."), _("\
18515 When enabled, GDB's internal \"physname\" code is checked against\n\
18516 the demangler."),
18517 NULL, show_check_physname,
18518 &setdebuglist, &showdebuglist);
18519
18520 c = add_cmd ("gdb-index", class_files, save_gdb_index_command,
18521 _("\
18522 Save a gdb-index file.\n\
18523 Usage: save gdb-index DIRECTORY"),
18524 &save_cmdlist);
18525 set_cmd_completer (c, filename_completer);
18526 }