2003-05-30 Andrew Cagney <cagney@redhat.com>
[deliverable/binutils-gdb.git] / gdb / dwarf2read.c
1 /* DWARF 2 debugging format support for GDB.
2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3 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 in dwarfread.c
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 2 of the License, or (at
17 your option) any later version.
18
19 This program is distributed in the hope that it will be useful, but
20 WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 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, write to the Free Software
26 Foundation, Inc., 59 Temple Place - Suite 330,
27 Boston, MA 02111-1307, USA. */
28
29 #include "defs.h"
30 #include "bfd.h"
31 #include "symtab.h"
32 #include "gdbtypes.h"
33 #include "symfile.h"
34 #include "objfiles.h"
35 #include "elf/dwarf2.h"
36 #include "buildsym.h"
37 #include "demangle.h"
38 #include "expression.h"
39 #include "filenames.h" /* for DOSish file names */
40 #include "macrotab.h"
41 #include "language.h"
42 #include "complaints.h"
43 #include "bcache.h"
44 #include "dwarf2expr.h"
45 #include "dwarf2loc.h"
46 #include "cp-support.h"
47
48 #include <fcntl.h>
49 #include "gdb_string.h"
50 #include "gdb_assert.h"
51 #include <sys/types.h>
52
53 #ifndef DWARF2_REG_TO_REGNUM
54 #define DWARF2_REG_TO_REGNUM(REG) (REG)
55 #endif
56
57 #if 0
58 /* .debug_info header for a compilation unit
59 Because of alignment constraints, this structure has padding and cannot
60 be mapped directly onto the beginning of the .debug_info section. */
61 typedef struct comp_unit_header
62 {
63 unsigned int length; /* length of the .debug_info
64 contribution */
65 unsigned short version; /* version number -- 2 for DWARF
66 version 2 */
67 unsigned int abbrev_offset; /* offset into .debug_abbrev section */
68 unsigned char addr_size; /* byte size of an address -- 4 */
69 }
70 _COMP_UNIT_HEADER;
71 #define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
72 #endif
73
74 /* .debug_pubnames header
75 Because of alignment constraints, this structure has padding and cannot
76 be mapped directly onto the beginning of the .debug_info section. */
77 typedef struct pubnames_header
78 {
79 unsigned int length; /* length of the .debug_pubnames
80 contribution */
81 unsigned char version; /* version number -- 2 for DWARF
82 version 2 */
83 unsigned int info_offset; /* offset into .debug_info section */
84 unsigned int info_size; /* byte size of .debug_info section
85 portion */
86 }
87 _PUBNAMES_HEADER;
88 #define _ACTUAL_PUBNAMES_HEADER_SIZE 13
89
90 /* .debug_pubnames header
91 Because of alignment constraints, this structure has padding and cannot
92 be mapped directly onto the beginning of the .debug_info section. */
93 typedef struct aranges_header
94 {
95 unsigned int length; /* byte len of the .debug_aranges
96 contribution */
97 unsigned short version; /* version number -- 2 for DWARF
98 version 2 */
99 unsigned int info_offset; /* offset into .debug_info section */
100 unsigned char addr_size; /* byte size of an address */
101 unsigned char seg_size; /* byte size of segment descriptor */
102 }
103 _ARANGES_HEADER;
104 #define _ACTUAL_ARANGES_HEADER_SIZE 12
105
106 /* .debug_line statement program prologue
107 Because of alignment constraints, this structure has padding and cannot
108 be mapped directly onto the beginning of the .debug_info section. */
109 typedef struct statement_prologue
110 {
111 unsigned int total_length; /* byte length of the statement
112 information */
113 unsigned short version; /* version number -- 2 for DWARF
114 version 2 */
115 unsigned int prologue_length; /* # bytes between prologue &
116 stmt program */
117 unsigned char minimum_instruction_length; /* byte size of
118 smallest instr */
119 unsigned char default_is_stmt; /* initial value of is_stmt
120 register */
121 char line_base;
122 unsigned char line_range;
123 unsigned char opcode_base; /* number assigned to first special
124 opcode */
125 unsigned char *standard_opcode_lengths;
126 }
127 _STATEMENT_PROLOGUE;
128
129 /* offsets and sizes of debugging sections */
130
131 static file_ptr dwarf_info_offset;
132 static file_ptr dwarf_abbrev_offset;
133 static file_ptr dwarf_line_offset;
134 static file_ptr dwarf_pubnames_offset;
135 static file_ptr dwarf_aranges_offset;
136 static file_ptr dwarf_loc_offset;
137 static file_ptr dwarf_macinfo_offset;
138 static file_ptr dwarf_str_offset;
139 static file_ptr dwarf_ranges_offset;
140 file_ptr dwarf_frame_offset;
141 file_ptr dwarf_eh_frame_offset;
142
143 static unsigned int dwarf_info_size;
144 static unsigned int dwarf_abbrev_size;
145 static unsigned int dwarf_line_size;
146 static unsigned int dwarf_pubnames_size;
147 static unsigned int dwarf_aranges_size;
148 static unsigned int dwarf_loc_size;
149 static unsigned int dwarf_macinfo_size;
150 static unsigned int dwarf_str_size;
151 static unsigned int dwarf_ranges_size;
152 unsigned int dwarf_frame_size;
153 unsigned int dwarf_eh_frame_size;
154
155 static asection *dwarf_info_section;
156 static asection *dwarf_abbrev_section;
157 static asection *dwarf_line_section;
158 static asection *dwarf_pubnames_section;
159 static asection *dwarf_aranges_section;
160 static asection *dwarf_loc_section;
161 static asection *dwarf_macinfo_section;
162 static asection *dwarf_str_section;
163 static asection *dwarf_ranges_section;
164 asection *dwarf_frame_section;
165 asection *dwarf_eh_frame_section;
166
167 /* names of the debugging sections */
168
169 #define INFO_SECTION ".debug_info"
170 #define ABBREV_SECTION ".debug_abbrev"
171 #define LINE_SECTION ".debug_line"
172 #define PUBNAMES_SECTION ".debug_pubnames"
173 #define ARANGES_SECTION ".debug_aranges"
174 #define LOC_SECTION ".debug_loc"
175 #define MACINFO_SECTION ".debug_macinfo"
176 #define STR_SECTION ".debug_str"
177 #define RANGES_SECTION ".debug_ranges"
178 #define FRAME_SECTION ".debug_frame"
179 #define EH_FRAME_SECTION ".eh_frame"
180
181 /* local data types */
182
183 /* We hold several abbreviation tables in memory at the same time. */
184 #ifndef ABBREV_HASH_SIZE
185 #define ABBREV_HASH_SIZE 121
186 #endif
187
188 /* The data in a compilation unit header, after target2host
189 translation, looks like this. */
190 struct comp_unit_head
191 {
192 unsigned long length;
193 short version;
194 unsigned int abbrev_offset;
195 unsigned char addr_size;
196 unsigned char signed_addr_p;
197 unsigned int offset_size; /* size of file offsets; either 4 or 8 */
198 unsigned int initial_length_size; /* size of the length field; either
199 4 or 12 */
200
201 /* Offset to the first byte of this compilation unit header in the
202 * .debug_info section, for resolving relative reference dies. */
203
204 unsigned int offset;
205
206 /* Pointer to this compilation unit header in the .debug_info
207 * section */
208
209 char *cu_head_ptr;
210
211 /* Pointer to the first die of this compilatio unit. This will
212 * be the first byte following the compilation unit header. */
213
214 char *first_die_ptr;
215
216 /* Pointer to the next compilation unit header in the program. */
217
218 struct comp_unit_head *next;
219
220 /* DWARF abbreviation table associated with this compilation unit */
221
222 struct abbrev_info *dwarf2_abbrevs[ABBREV_HASH_SIZE];
223
224 /* Base address of this compilation unit. */
225
226 CORE_ADDR base_address;
227
228 /* Non-zero if base_address has been set. */
229
230 int base_known;
231 };
232
233 /* The line number information for a compilation unit (found in the
234 .debug_line section) begins with a "statement program header",
235 which contains the following information. */
236 struct line_header
237 {
238 unsigned int total_length;
239 unsigned short version;
240 unsigned int header_length;
241 unsigned char minimum_instruction_length;
242 unsigned char default_is_stmt;
243 int line_base;
244 unsigned char line_range;
245 unsigned char opcode_base;
246
247 /* standard_opcode_lengths[i] is the number of operands for the
248 standard opcode whose value is i. This means that
249 standard_opcode_lengths[0] is unused, and the last meaningful
250 element is standard_opcode_lengths[opcode_base - 1]. */
251 unsigned char *standard_opcode_lengths;
252
253 /* The include_directories table. NOTE! These strings are not
254 allocated with xmalloc; instead, they are pointers into
255 debug_line_buffer. If you try to free them, `free' will get
256 indigestion. */
257 unsigned int num_include_dirs, include_dirs_size;
258 char **include_dirs;
259
260 /* The file_names table. NOTE! These strings are not allocated
261 with xmalloc; instead, they are pointers into debug_line_buffer.
262 Don't try to free them directly. */
263 unsigned int num_file_names, file_names_size;
264 struct file_entry
265 {
266 char *name;
267 unsigned int dir_index;
268 unsigned int mod_time;
269 unsigned int length;
270 } *file_names;
271
272 /* The start and end of the statement program following this
273 header. These point into dwarf_line_buffer. */
274 char *statement_program_start, *statement_program_end;
275 };
276
277 /* When we construct a partial symbol table entry we only
278 need this much information. */
279 struct partial_die_info
280 {
281 enum dwarf_tag tag;
282 unsigned char has_children;
283 unsigned char is_external;
284 unsigned char is_declaration;
285 unsigned char has_type;
286 unsigned int offset;
287 unsigned int abbrev;
288 char *name;
289 int has_pc_info;
290 CORE_ADDR lowpc;
291 CORE_ADDR highpc;
292 struct dwarf_block *locdesc;
293 unsigned int language;
294 char *sibling;
295 };
296
297 /* This data structure holds the information of an abbrev. */
298 struct abbrev_info
299 {
300 unsigned int number; /* number identifying abbrev */
301 enum dwarf_tag tag; /* dwarf tag */
302 int has_children; /* boolean */
303 unsigned int num_attrs; /* number of attributes */
304 struct attr_abbrev *attrs; /* an array of attribute descriptions */
305 struct abbrev_info *next; /* next in chain */
306 };
307
308 struct attr_abbrev
309 {
310 enum dwarf_attribute name;
311 enum dwarf_form form;
312 };
313
314 /* This data structure holds a complete die structure. */
315 struct die_info
316 {
317 enum dwarf_tag tag; /* Tag indicating type of die */
318 unsigned short has_children; /* Does the die have children */
319 unsigned int abbrev; /* Abbrev number */
320 unsigned int offset; /* Offset in .debug_info section */
321 unsigned int num_attrs; /* Number of attributes */
322 struct attribute *attrs; /* An array of attributes */
323 struct die_info *next_ref; /* Next die in ref hash table */
324 struct die_info *next; /* Next die in linked list */
325 struct type *type; /* Cached type information */
326 };
327
328 /* Attributes have a name and a value */
329 struct attribute
330 {
331 enum dwarf_attribute name;
332 enum dwarf_form form;
333 union
334 {
335 char *str;
336 struct dwarf_block *blk;
337 unsigned long unsnd;
338 long int snd;
339 CORE_ADDR addr;
340 }
341 u;
342 };
343
344 struct function_range
345 {
346 const char *name;
347 CORE_ADDR lowpc, highpc;
348 int seen_line;
349 struct function_range *next;
350 };
351
352 static struct function_range *cu_first_fn, *cu_last_fn, *cu_cached_fn;
353
354 /* Get at parts of an attribute structure */
355
356 #define DW_STRING(attr) ((attr)->u.str)
357 #define DW_UNSND(attr) ((attr)->u.unsnd)
358 #define DW_BLOCK(attr) ((attr)->u.blk)
359 #define DW_SND(attr) ((attr)->u.snd)
360 #define DW_ADDR(attr) ((attr)->u.addr)
361
362 /* Blocks are a bunch of untyped bytes. */
363 struct dwarf_block
364 {
365 unsigned int size;
366 char *data;
367 };
368
369 #ifndef ATTR_ALLOC_CHUNK
370 #define ATTR_ALLOC_CHUNK 4
371 #endif
372
373 /* A hash table of die offsets for following references. */
374 #ifndef REF_HASH_SIZE
375 #define REF_HASH_SIZE 1021
376 #endif
377
378 static struct die_info *die_ref_table[REF_HASH_SIZE];
379
380 /* Obstack for allocating temporary storage used during symbol reading. */
381 static struct obstack dwarf2_tmp_obstack;
382
383 /* Offset to the first byte of the current compilation unit header,
384 for resolving relative reference dies. */
385 static unsigned int cu_header_offset;
386
387 /* Allocate fields for structs, unions and enums in this size. */
388 #ifndef DW_FIELD_ALLOC_CHUNK
389 #define DW_FIELD_ALLOC_CHUNK 4
390 #endif
391
392 /* The language we are debugging. */
393 static enum language cu_language;
394 static const struct language_defn *cu_language_defn;
395
396 /* Actually data from the sections. */
397 static char *dwarf_info_buffer;
398 static char *dwarf_abbrev_buffer;
399 static char *dwarf_line_buffer;
400 static char *dwarf_str_buffer;
401 static char *dwarf_macinfo_buffer;
402 static char *dwarf_ranges_buffer;
403 static char *dwarf_loc_buffer;
404
405 /* A zeroed version of a partial die for initialization purposes. */
406 static struct partial_die_info zeroed_partial_die;
407
408 /* The generic symbol table building routines have separate lists for
409 file scope symbols and all all other scopes (local scopes). So
410 we need to select the right one to pass to add_symbol_to_list().
411 We do it by keeping a pointer to the correct list in list_in_scope.
412
413 FIXME: The original dwarf code just treated the file scope as the first
414 local scope, and all other local scopes as nested local scopes, and worked
415 fine. Check to see if we really need to distinguish these
416 in buildsym.c. */
417 static struct pending **list_in_scope = &file_symbols;
418
419 /* FIXME: decode_locdesc sets these variables to describe the location
420 to the caller. These ought to be a structure or something. If
421 none of the flags are set, the object lives at the address returned
422 by decode_locdesc. */
423
424 static int optimized_out; /* No ops in location in expression,
425 so object was optimized out. */
426 static int isreg; /* Object lives in register.
427 decode_locdesc's return value is
428 the register number. */
429 static int offreg; /* Object's address is the sum of the
430 register specified by basereg, plus
431 the offset returned. */
432 static int basereg; /* See `offreg'. */
433 static int isderef; /* Value described by flags above is
434 the address of a pointer to the object. */
435 static int islocal; /* Variable is at the returned offset
436 from the frame start, but there's
437 no identified frame pointer for
438 this function, so we can't say
439 which register it's relative to;
440 use LOC_LOCAL. */
441 static int is_thread_local; /* Variable is at a constant offset in the
442 thread-local storage block for the
443 current thread and the dynamic linker
444 module containing this expression.
445 decode_locdesc returns the offset from
446 that base. */
447
448 /* DW_AT_frame_base values for the current function.
449 frame_base_reg is -1 if DW_AT_frame_base is missing, otherwise it
450 contains the register number for the frame register.
451 frame_base_offset is the offset from the frame register to the
452 virtual stack frame. */
453 static int frame_base_reg;
454 static CORE_ADDR frame_base_offset;
455
456 /* This value is added to each symbol value. FIXME: Generalize to
457 the section_offsets structure used by dbxread (once this is done,
458 pass the appropriate section number to end_symtab). */
459 static CORE_ADDR baseaddr; /* Add to each symbol value */
460
461 /* We put a pointer to this structure in the read_symtab_private field
462 of the psymtab.
463 The complete dwarf information for an objfile is kept in the
464 psymbol_obstack, so that absolute die references can be handled.
465 Most of the information in this structure is related to an entire
466 object file and could be passed via the sym_private field of the objfile.
467 It is however conceivable that dwarf2 might not be the only type
468 of symbols read from an object file. */
469
470 struct dwarf2_pinfo
471 {
472 /* Pointer to start of dwarf info buffer for the objfile. */
473
474 char *dwarf_info_buffer;
475
476 /* Offset in dwarf_info_buffer for this compilation unit. */
477
478 unsigned long dwarf_info_offset;
479
480 /* Pointer to start of dwarf abbreviation buffer for the objfile. */
481
482 char *dwarf_abbrev_buffer;
483
484 /* Size of dwarf abbreviation section for the objfile. */
485
486 unsigned int dwarf_abbrev_size;
487
488 /* Pointer to start of dwarf line buffer for the objfile. */
489
490 char *dwarf_line_buffer;
491
492 /* Size of dwarf_line_buffer, in bytes. */
493
494 unsigned int dwarf_line_size;
495
496 /* Pointer to start of dwarf string buffer for the objfile. */
497
498 char *dwarf_str_buffer;
499
500 /* Size of dwarf string section for the objfile. */
501
502 unsigned int dwarf_str_size;
503
504 /* Pointer to start of dwarf macro buffer for the objfile. */
505
506 char *dwarf_macinfo_buffer;
507
508 /* Size of dwarf macinfo section for the objfile. */
509
510 unsigned int dwarf_macinfo_size;
511
512 /* Pointer to start of dwarf ranges buffer for the objfile. */
513
514 char *dwarf_ranges_buffer;
515
516 /* Size of dwarf ranges buffer for the objfile. */
517
518 unsigned int dwarf_ranges_size;
519
520 /* Pointer to start of dwarf locations buffer for the objfile. */
521
522 char *dwarf_loc_buffer;
523
524 /* Size of dwarf locations buffer for the objfile. */
525
526 unsigned int dwarf_loc_size;
527 };
528
529 #define PST_PRIVATE(p) ((struct dwarf2_pinfo *)(p)->read_symtab_private)
530 #define DWARF_INFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_info_buffer)
531 #define DWARF_INFO_OFFSET(p) (PST_PRIVATE(p)->dwarf_info_offset)
532 #define DWARF_ABBREV_BUFFER(p) (PST_PRIVATE(p)->dwarf_abbrev_buffer)
533 #define DWARF_ABBREV_SIZE(p) (PST_PRIVATE(p)->dwarf_abbrev_size)
534 #define DWARF_LINE_BUFFER(p) (PST_PRIVATE(p)->dwarf_line_buffer)
535 #define DWARF_LINE_SIZE(p) (PST_PRIVATE(p)->dwarf_line_size)
536 #define DWARF_STR_BUFFER(p) (PST_PRIVATE(p)->dwarf_str_buffer)
537 #define DWARF_STR_SIZE(p) (PST_PRIVATE(p)->dwarf_str_size)
538 #define DWARF_MACINFO_BUFFER(p) (PST_PRIVATE(p)->dwarf_macinfo_buffer)
539 #define DWARF_MACINFO_SIZE(p) (PST_PRIVATE(p)->dwarf_macinfo_size)
540 #define DWARF_RANGES_BUFFER(p) (PST_PRIVATE(p)->dwarf_ranges_buffer)
541 #define DWARF_RANGES_SIZE(p) (PST_PRIVATE(p)->dwarf_ranges_size)
542 #define DWARF_LOC_BUFFER(p) (PST_PRIVATE(p)->dwarf_loc_buffer)
543 #define DWARF_LOC_SIZE(p) (PST_PRIVATE(p)->dwarf_loc_size)
544
545 /* Maintain an array of referenced fundamental types for the current
546 compilation unit being read. For DWARF version 1, we have to construct
547 the fundamental types on the fly, since no information about the
548 fundamental types is supplied. Each such fundamental type is created by
549 calling a language dependent routine to create the type, and then a
550 pointer to that type is then placed in the array at the index specified
551 by it's FT_<TYPENAME> value. The array has a fixed size set by the
552 FT_NUM_MEMBERS compile time constant, which is the number of predefined
553 fundamental types gdb knows how to construct. */
554 static struct type *ftypes[FT_NUM_MEMBERS]; /* Fundamental types */
555
556 /* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
557 but this would require a corresponding change in unpack_field_as_long
558 and friends. */
559 static int bits_per_byte = 8;
560
561 /* The routines that read and process dies for a C struct or C++ class
562 pass lists of data member fields and lists of member function fields
563 in an instance of a field_info structure, as defined below. */
564 struct field_info
565 {
566 /* List of data member and baseclasses fields. */
567 struct nextfield
568 {
569 struct nextfield *next;
570 int accessibility;
571 int virtuality;
572 struct field field;
573 }
574 *fields;
575
576 /* Number of fields. */
577 int nfields;
578
579 /* Number of baseclasses. */
580 int nbaseclasses;
581
582 /* Set if the accesibility of one of the fields is not public. */
583 int non_public_fields;
584
585 /* Member function fields array, entries are allocated in the order they
586 are encountered in the object file. */
587 struct nextfnfield
588 {
589 struct nextfnfield *next;
590 struct fn_field fnfield;
591 }
592 *fnfields;
593
594 /* Member function fieldlist array, contains name of possibly overloaded
595 member function, number of overloaded member functions and a pointer
596 to the head of the member function field chain. */
597 struct fnfieldlist
598 {
599 char *name;
600 int length;
601 struct nextfnfield *head;
602 }
603 *fnfieldlists;
604
605 /* Number of entries in the fnfieldlists array. */
606 int nfnfields;
607 };
608
609 /* Various complaints about symbol reading that don't abort the process */
610
611 static void
612 dwarf2_non_const_array_bound_ignored_complaint (const char *arg1)
613 {
614 complaint (&symfile_complaints, "non-constant array bounds form '%s' ignored",
615 arg1);
616 }
617
618 static void
619 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
620 {
621 complaint (&symfile_complaints,
622 "statement list doesn't fit in .debug_line section");
623 }
624
625 static void
626 dwarf2_complex_location_expr_complaint (void)
627 {
628 complaint (&symfile_complaints, "location expression too complex");
629 }
630
631 static void
632 dwarf2_unsupported_at_frame_base_complaint (const char *arg1)
633 {
634 complaint (&symfile_complaints,
635 "unsupported DW_AT_frame_base for function '%s'", arg1);
636 }
637
638 static void
639 dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
640 int arg3)
641 {
642 complaint (&symfile_complaints,
643 "const value length mismatch for '%s', got %d, expected %d", arg1,
644 arg2, arg3);
645 }
646
647 static void
648 dwarf2_macros_too_long_complaint (void)
649 {
650 complaint (&symfile_complaints,
651 "macro info runs off end of `.debug_macinfo' section");
652 }
653
654 static void
655 dwarf2_macro_malformed_definition_complaint (const char *arg1)
656 {
657 complaint (&symfile_complaints,
658 "macro debug info contains a malformed macro definition:\n`%s'",
659 arg1);
660 }
661
662 static void
663 dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
664 {
665 complaint (&symfile_complaints,
666 "invalid attribute class or form for '%s' in '%s'", arg1, arg2);
667 }
668
669 /* local function prototypes */
670
671 static void dwarf2_locate_sections (bfd *, asection *, void *);
672
673 #if 0
674 static void dwarf2_build_psymtabs_easy (struct objfile *, int);
675 #endif
676
677 static void dwarf2_build_psymtabs_hard (struct objfile *, int);
678
679 static char *scan_partial_symbols (char *, struct objfile *,
680 CORE_ADDR *, CORE_ADDR *,
681 const struct comp_unit_head *);
682
683 static void add_partial_symbol (struct partial_die_info *, struct objfile *,
684 const struct comp_unit_head *);
685
686 static void dwarf2_psymtab_to_symtab (struct partial_symtab *);
687
688 static void psymtab_to_symtab_1 (struct partial_symtab *);
689
690 char *dwarf2_read_section (struct objfile *, file_ptr, unsigned int,
691 asection *);
692
693 static void dwarf2_read_abbrevs (bfd *abfd, struct comp_unit_head *cu_header);
694
695 static void dwarf2_empty_abbrev_table (void *);
696
697 static struct abbrev_info *dwarf2_lookup_abbrev (unsigned int,
698 const struct comp_unit_head *cu_header);
699
700 static char *read_partial_die (struct partial_die_info *,
701 bfd *, char *,
702 const struct comp_unit_head *);
703
704 static char *read_full_die (struct die_info **, bfd *, char *,
705 const struct comp_unit_head *);
706
707 static char *read_attribute (struct attribute *, struct attr_abbrev *,
708 bfd *, char *, const struct comp_unit_head *);
709
710 static char *read_attribute_value (struct attribute *, unsigned,
711 bfd *, char *, const struct comp_unit_head *);
712
713 static unsigned int read_1_byte (bfd *, char *);
714
715 static int read_1_signed_byte (bfd *, char *);
716
717 static unsigned int read_2_bytes (bfd *, char *);
718
719 static unsigned int read_4_bytes (bfd *, char *);
720
721 static unsigned long read_8_bytes (bfd *, char *);
722
723 static CORE_ADDR read_address (bfd *, char *ptr, const struct comp_unit_head *,
724 int *bytes_read);
725
726 static LONGEST read_initial_length (bfd *, char *,
727 struct comp_unit_head *, int *bytes_read);
728
729 static LONGEST read_offset (bfd *, char *, const struct comp_unit_head *,
730 int *bytes_read);
731
732 static char *read_n_bytes (bfd *, char *, unsigned int);
733
734 static char *read_string (bfd *, char *, unsigned int *);
735
736 static char *read_indirect_string (bfd *, char *, const struct comp_unit_head *,
737 unsigned int *);
738
739 static unsigned long read_unsigned_leb128 (bfd *, char *, unsigned int *);
740
741 static long read_signed_leb128 (bfd *, char *, unsigned int *);
742
743 static void set_cu_language (unsigned int);
744
745 static struct attribute *dwarf_attr (struct die_info *, unsigned int);
746
747 static int die_is_declaration (struct die_info *);
748
749 static void free_line_header (struct line_header *lh);
750
751 static struct line_header *(dwarf_decode_line_header
752 (unsigned int offset,
753 bfd *abfd,
754 const struct comp_unit_head *cu_header));
755
756 static void dwarf_decode_lines (struct line_header *, char *, bfd *,
757 const struct comp_unit_head *);
758
759 static void dwarf2_start_subfile (char *, char *);
760
761 static struct symbol *new_symbol (struct die_info *, struct type *,
762 struct objfile *, const struct comp_unit_head *);
763
764 static void dwarf2_const_value (struct attribute *, struct symbol *,
765 struct objfile *, const struct comp_unit_head *);
766
767 static void dwarf2_const_value_data (struct attribute *attr,
768 struct symbol *sym,
769 int bits);
770
771 static struct type *die_type (struct die_info *, struct objfile *,
772 const struct comp_unit_head *);
773
774 static struct type *die_containing_type (struct die_info *, struct objfile *,
775 const struct comp_unit_head *);
776
777 #if 0
778 static struct type *type_at_offset (unsigned int, struct objfile *);
779 #endif
780
781 static struct type *tag_type_to_type (struct die_info *, struct objfile *,
782 const struct comp_unit_head *);
783
784 static void read_type_die (struct die_info *, struct objfile *,
785 const struct comp_unit_head *);
786
787 static void read_typedef (struct die_info *, struct objfile *,
788 const struct comp_unit_head *);
789
790 static void read_base_type (struct die_info *, struct objfile *);
791
792 static void read_file_scope (struct die_info *, struct objfile *,
793 const struct comp_unit_head *);
794
795 static void read_func_scope (struct die_info *, struct objfile *,
796 const struct comp_unit_head *);
797
798 static void read_lexical_block_scope (struct die_info *, struct objfile *,
799 const struct comp_unit_head *);
800
801 static int dwarf2_get_pc_bounds (struct die_info *,
802 CORE_ADDR *, CORE_ADDR *, struct objfile *,
803 const struct comp_unit_head *);
804
805 static void dwarf2_add_field (struct field_info *, struct die_info *,
806 struct objfile *, const struct comp_unit_head *);
807
808 static void dwarf2_attach_fields_to_type (struct field_info *,
809 struct type *, struct objfile *);
810
811 static void dwarf2_add_member_fn (struct field_info *,
812 struct die_info *, struct type *,
813 struct objfile *objfile,
814 const struct comp_unit_head *);
815
816 static void dwarf2_attach_fn_fields_to_type (struct field_info *,
817 struct type *, struct objfile *);
818
819 static void read_structure_scope (struct die_info *, struct objfile *,
820 const struct comp_unit_head *);
821
822 static void read_common_block (struct die_info *, struct objfile *,
823 const struct comp_unit_head *);
824
825 static void read_namespace (struct die_info *die, struct objfile *objfile,
826 const struct comp_unit_head *cu_header);
827
828 static void read_enumeration (struct die_info *, struct objfile *,
829 const struct comp_unit_head *);
830
831 static struct type *dwarf_base_type (int, int, struct objfile *);
832
833 static CORE_ADDR decode_locdesc (struct dwarf_block *, struct objfile *,
834 const struct comp_unit_head *);
835
836 static void read_array_type (struct die_info *, struct objfile *,
837 const struct comp_unit_head *);
838
839 static void read_tag_pointer_type (struct die_info *, struct objfile *,
840 const struct comp_unit_head *);
841
842 static void read_tag_ptr_to_member_type (struct die_info *, struct objfile *,
843 const struct comp_unit_head *);
844
845 static void read_tag_reference_type (struct die_info *, struct objfile *,
846 const struct comp_unit_head *);
847
848 static void read_tag_const_type (struct die_info *, struct objfile *,
849 const struct comp_unit_head *);
850
851 static void read_tag_volatile_type (struct die_info *, struct objfile *,
852 const struct comp_unit_head *);
853
854 static void read_tag_string_type (struct die_info *, struct objfile *);
855
856 static void read_subroutine_type (struct die_info *, struct objfile *,
857 const struct comp_unit_head *);
858
859 static struct die_info *read_comp_unit (char *, bfd *,
860 const struct comp_unit_head *);
861
862 static void free_die_list (struct die_info *);
863
864 static struct cleanup *make_cleanup_free_die_list (struct die_info *);
865
866 static void process_die (struct die_info *, struct objfile *,
867 const struct comp_unit_head *);
868
869 static char *dwarf2_linkage_name (struct die_info *);
870
871 static char *dwarf2_name (struct die_info *die);
872
873 static struct die_info *dwarf2_extension (struct die_info *die);
874
875 static char *dwarf_tag_name (unsigned int);
876
877 static char *dwarf_attr_name (unsigned int);
878
879 static char *dwarf_form_name (unsigned int);
880
881 static char *dwarf_stack_op_name (unsigned int);
882
883 static char *dwarf_bool_name (unsigned int);
884
885 static char *dwarf_type_encoding_name (unsigned int);
886
887 #if 0
888 static char *dwarf_cfi_name (unsigned int);
889
890 struct die_info *copy_die (struct die_info *);
891 #endif
892
893 static struct die_info *sibling_die (struct die_info *);
894
895 static void dump_die (struct die_info *);
896
897 static void dump_die_list (struct die_info *);
898
899 static void store_in_ref_table (unsigned int, struct die_info *);
900
901 static void dwarf2_empty_hash_tables (void);
902
903 static unsigned int dwarf2_get_ref_die_offset (struct attribute *);
904
905 static struct die_info *follow_die_ref (unsigned int);
906
907 static struct type *dwarf2_fundamental_type (struct objfile *, int);
908
909 /* memory allocation interface */
910
911 static void dwarf2_free_tmp_obstack (void *);
912
913 static struct dwarf_block *dwarf_alloc_block (void);
914
915 static struct abbrev_info *dwarf_alloc_abbrev (void);
916
917 static struct die_info *dwarf_alloc_die (void);
918
919 static void initialize_cu_func_list (void);
920
921 static void add_to_cu_func_list (const char *, CORE_ADDR, CORE_ADDR);
922
923 static void dwarf_decode_macros (struct line_header *, unsigned int,
924 char *, bfd *, const struct comp_unit_head *,
925 struct objfile *);
926
927 static int attr_form_is_block (struct attribute *);
928
929 static void
930 dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
931 const struct comp_unit_head *,
932 struct objfile *objfile);
933
934 /* Try to locate the sections we need for DWARF 2 debugging
935 information and return true if we have enough to do something. */
936
937 int
938 dwarf2_has_info (bfd *abfd)
939 {
940 dwarf_info_offset = 0;
941 dwarf_abbrev_offset = 0;
942 dwarf_line_offset = 0;
943 dwarf_str_offset = 0;
944 dwarf_macinfo_offset = 0;
945 dwarf_frame_offset = 0;
946 dwarf_eh_frame_offset = 0;
947 dwarf_ranges_offset = 0;
948 dwarf_loc_offset = 0;
949
950 bfd_map_over_sections (abfd, dwarf2_locate_sections, NULL);
951 if (dwarf_info_offset && dwarf_abbrev_offset)
952 {
953 return 1;
954 }
955 else
956 {
957 return 0;
958 }
959 }
960
961 /* This function is mapped across the sections and remembers the
962 offset and size of each of the debugging sections we are interested
963 in. */
964
965 static void
966 dwarf2_locate_sections (bfd *ignore_abfd, asection *sectp, void *ignore_ptr)
967 {
968 if (STREQ (sectp->name, INFO_SECTION))
969 {
970 dwarf_info_offset = sectp->filepos;
971 dwarf_info_size = bfd_get_section_size_before_reloc (sectp);
972 dwarf_info_section = sectp;
973 }
974 else if (STREQ (sectp->name, ABBREV_SECTION))
975 {
976 dwarf_abbrev_offset = sectp->filepos;
977 dwarf_abbrev_size = bfd_get_section_size_before_reloc (sectp);
978 dwarf_abbrev_section = sectp;
979 }
980 else if (STREQ (sectp->name, LINE_SECTION))
981 {
982 dwarf_line_offset = sectp->filepos;
983 dwarf_line_size = bfd_get_section_size_before_reloc (sectp);
984 dwarf_line_section = sectp;
985 }
986 else if (STREQ (sectp->name, PUBNAMES_SECTION))
987 {
988 dwarf_pubnames_offset = sectp->filepos;
989 dwarf_pubnames_size = bfd_get_section_size_before_reloc (sectp);
990 dwarf_pubnames_section = sectp;
991 }
992 else if (STREQ (sectp->name, ARANGES_SECTION))
993 {
994 dwarf_aranges_offset = sectp->filepos;
995 dwarf_aranges_size = bfd_get_section_size_before_reloc (sectp);
996 dwarf_aranges_section = sectp;
997 }
998 else if (STREQ (sectp->name, LOC_SECTION))
999 {
1000 dwarf_loc_offset = sectp->filepos;
1001 dwarf_loc_size = bfd_get_section_size_before_reloc (sectp);
1002 dwarf_loc_section = sectp;
1003 }
1004 else if (STREQ (sectp->name, MACINFO_SECTION))
1005 {
1006 dwarf_macinfo_offset = sectp->filepos;
1007 dwarf_macinfo_size = bfd_get_section_size_before_reloc (sectp);
1008 dwarf_macinfo_section = sectp;
1009 }
1010 else if (STREQ (sectp->name, STR_SECTION))
1011 {
1012 dwarf_str_offset = sectp->filepos;
1013 dwarf_str_size = bfd_get_section_size_before_reloc (sectp);
1014 dwarf_str_section = sectp;
1015 }
1016 else if (STREQ (sectp->name, FRAME_SECTION))
1017 {
1018 dwarf_frame_offset = sectp->filepos;
1019 dwarf_frame_size = bfd_get_section_size_before_reloc (sectp);
1020 dwarf_frame_section = sectp;
1021 }
1022 else if (STREQ (sectp->name, EH_FRAME_SECTION))
1023 {
1024 dwarf_eh_frame_offset = sectp->filepos;
1025 dwarf_eh_frame_size = bfd_get_section_size_before_reloc (sectp);
1026 dwarf_eh_frame_section = sectp;
1027 }
1028 else if (STREQ (sectp->name, RANGES_SECTION))
1029 {
1030 dwarf_ranges_offset = sectp->filepos;
1031 dwarf_ranges_size = bfd_get_section_size_before_reloc (sectp);
1032 dwarf_ranges_section = sectp;
1033 }
1034 }
1035
1036 /* Build a partial symbol table. */
1037
1038 void
1039 dwarf2_build_psymtabs (struct objfile *objfile, int mainline)
1040 {
1041
1042 /* We definitely need the .debug_info and .debug_abbrev sections */
1043
1044 dwarf_info_buffer = dwarf2_read_section (objfile,
1045 dwarf_info_offset,
1046 dwarf_info_size,
1047 dwarf_info_section);
1048 dwarf_abbrev_buffer = dwarf2_read_section (objfile,
1049 dwarf_abbrev_offset,
1050 dwarf_abbrev_size,
1051 dwarf_abbrev_section);
1052
1053 if (dwarf_line_offset)
1054 dwarf_line_buffer = dwarf2_read_section (objfile,
1055 dwarf_line_offset,
1056 dwarf_line_size,
1057 dwarf_line_section);
1058 else
1059 dwarf_line_buffer = NULL;
1060
1061 if (dwarf_str_offset)
1062 dwarf_str_buffer = dwarf2_read_section (objfile,
1063 dwarf_str_offset,
1064 dwarf_str_size,
1065 dwarf_str_section);
1066 else
1067 dwarf_str_buffer = NULL;
1068
1069 if (dwarf_macinfo_offset)
1070 dwarf_macinfo_buffer = dwarf2_read_section (objfile,
1071 dwarf_macinfo_offset,
1072 dwarf_macinfo_size,
1073 dwarf_macinfo_section);
1074 else
1075 dwarf_macinfo_buffer = NULL;
1076
1077 if (dwarf_ranges_offset)
1078 dwarf_ranges_buffer = dwarf2_read_section (objfile,
1079 dwarf_ranges_offset,
1080 dwarf_ranges_size,
1081 dwarf_ranges_section);
1082 else
1083 dwarf_ranges_buffer = NULL;
1084
1085 if (dwarf_loc_offset)
1086 dwarf_loc_buffer = dwarf2_read_section (objfile,
1087 dwarf_loc_offset,
1088 dwarf_loc_size,
1089 dwarf_loc_section);
1090 else
1091 dwarf_loc_buffer = NULL;
1092
1093 if (mainline
1094 || (objfile->global_psymbols.size == 0
1095 && objfile->static_psymbols.size == 0))
1096 {
1097 init_psymbol_list (objfile, 1024);
1098 }
1099
1100 #if 0
1101 if (dwarf_aranges_offset && dwarf_pubnames_offset)
1102 {
1103 /* Things are significantly easier if we have .debug_aranges and
1104 .debug_pubnames sections */
1105
1106 dwarf2_build_psymtabs_easy (objfile, mainline);
1107 }
1108 else
1109 #endif
1110 /* only test this case for now */
1111 {
1112 /* In this case we have to work a bit harder */
1113 dwarf2_build_psymtabs_hard (objfile, mainline);
1114 }
1115 }
1116
1117 #if 0
1118 /* Build the partial symbol table from the information in the
1119 .debug_pubnames and .debug_aranges sections. */
1120
1121 static void
1122 dwarf2_build_psymtabs_easy (struct objfile *objfile, int mainline)
1123 {
1124 bfd *abfd = objfile->obfd;
1125 char *aranges_buffer, *pubnames_buffer;
1126 char *aranges_ptr, *pubnames_ptr;
1127 unsigned int entry_length, version, info_offset, info_size;
1128
1129 pubnames_buffer = dwarf2_read_section (objfile,
1130 dwarf_pubnames_offset,
1131 dwarf_pubnames_size,
1132 dwarf_pubnames_section);
1133 pubnames_ptr = pubnames_buffer;
1134 while ((pubnames_ptr - pubnames_buffer) < dwarf_pubnames_size)
1135 {
1136 struct comp_unit_head cu_header;
1137 int bytes_read;
1138
1139 entry_length = read_initial_length (abfd, pubnames_ptr, &cu_header,
1140 &bytes_read);
1141 pubnames_ptr += bytes_read;
1142 version = read_1_byte (abfd, pubnames_ptr);
1143 pubnames_ptr += 1;
1144 info_offset = read_4_bytes (abfd, pubnames_ptr);
1145 pubnames_ptr += 4;
1146 info_size = read_4_bytes (abfd, pubnames_ptr);
1147 pubnames_ptr += 4;
1148 }
1149
1150 aranges_buffer = dwarf2_read_section (objfile,
1151 dwarf_aranges_offset,
1152 dwarf_aranges_size,
1153 dwarf_aranges_section);
1154
1155 }
1156 #endif
1157
1158 /* Read in the comp unit header information from the debug_info at
1159 info_ptr. */
1160
1161 static char *
1162 read_comp_unit_head (struct comp_unit_head *cu_header,
1163 char *info_ptr, bfd *abfd)
1164 {
1165 int signed_addr;
1166 int bytes_read;
1167 cu_header->length = read_initial_length (abfd, info_ptr, cu_header,
1168 &bytes_read);
1169 info_ptr += bytes_read;
1170 cu_header->version = read_2_bytes (abfd, info_ptr);
1171 info_ptr += 2;
1172 cu_header->abbrev_offset = read_offset (abfd, info_ptr, cu_header,
1173 &bytes_read);
1174 info_ptr += bytes_read;
1175 cu_header->addr_size = read_1_byte (abfd, info_ptr);
1176 info_ptr += 1;
1177 signed_addr = bfd_get_sign_extend_vma (abfd);
1178 if (signed_addr < 0)
1179 internal_error (__FILE__, __LINE__,
1180 "read_comp_unit_head: dwarf from non elf file");
1181 cu_header->signed_addr_p = signed_addr;
1182 return info_ptr;
1183 }
1184
1185 /* Build the partial symbol table by doing a quick pass through the
1186 .debug_info and .debug_abbrev sections. */
1187
1188 static void
1189 dwarf2_build_psymtabs_hard (struct objfile *objfile, int mainline)
1190 {
1191 /* Instead of reading this into a big buffer, we should probably use
1192 mmap() on architectures that support it. (FIXME) */
1193 bfd *abfd = objfile->obfd;
1194 char *info_ptr, *abbrev_ptr;
1195 char *beg_of_comp_unit;
1196 struct partial_die_info comp_unit_die;
1197 struct partial_symtab *pst;
1198 struct cleanup *back_to;
1199 CORE_ADDR lowpc, highpc;
1200
1201 info_ptr = dwarf_info_buffer;
1202 abbrev_ptr = dwarf_abbrev_buffer;
1203
1204 /* We use dwarf2_tmp_obstack for objects that don't need to survive
1205 the partial symbol scan, like attribute values.
1206
1207 We could reduce our peak memory consumption during partial symbol
1208 table construction by freeing stuff from this obstack more often
1209 --- say, after processing each compilation unit, or each die ---
1210 but it turns out that this saves almost nothing. For an
1211 executable with 11Mb of Dwarf 2 data, I found about 64k allocated
1212 on dwarf2_tmp_obstack. Some investigation showed:
1213
1214 1) 69% of the attributes used forms DW_FORM_addr, DW_FORM_data*,
1215 DW_FORM_flag, DW_FORM_[su]data, and DW_FORM_ref*. These are
1216 all fixed-length values not requiring dynamic allocation.
1217
1218 2) 30% of the attributes used the form DW_FORM_string. For
1219 DW_FORM_string, read_attribute simply hands back a pointer to
1220 the null-terminated string in dwarf_info_buffer, so no dynamic
1221 allocation is needed there either.
1222
1223 3) The remaining 1% of the attributes all used DW_FORM_block1.
1224 75% of those were DW_AT_frame_base location lists for
1225 functions; the rest were DW_AT_location attributes, probably
1226 for the global variables.
1227
1228 Anyway, what this all means is that the memory the dwarf2
1229 reader uses as temporary space reading partial symbols is about
1230 0.5% as much as we use for dwarf_*_buffer. That's noise. */
1231
1232 obstack_init (&dwarf2_tmp_obstack);
1233 back_to = make_cleanup (dwarf2_free_tmp_obstack, NULL);
1234
1235 /* Since the objects we're extracting from dwarf_info_buffer vary in
1236 length, only the individual functions to extract them (like
1237 read_comp_unit_head and read_partial_die) can really know whether
1238 the buffer is large enough to hold another complete object.
1239
1240 At the moment, they don't actually check that. If
1241 dwarf_info_buffer holds just one extra byte after the last
1242 compilation unit's dies, then read_comp_unit_head will happily
1243 read off the end of the buffer. read_partial_die is similarly
1244 casual. Those functions should be fixed.
1245
1246 For this loop condition, simply checking whether there's any data
1247 left at all should be sufficient. */
1248 while (info_ptr < dwarf_info_buffer + dwarf_info_size)
1249 {
1250 struct comp_unit_head cu_header;
1251 beg_of_comp_unit = info_ptr;
1252 info_ptr = read_comp_unit_head (&cu_header, info_ptr, abfd);
1253
1254 if (cu_header.version != 2)
1255 {
1256 error ("Dwarf Error: wrong version in compilation unit header (is %d, should be %d) [in module %s]", cu_header.version, 2, bfd_get_filename (abfd));
1257 return;
1258 }
1259 if (cu_header.abbrev_offset >= dwarf_abbrev_size)
1260 {
1261 error ("Dwarf Error: bad offset (0x%lx) in compilation unit header (offset 0x%lx + 6) [in module %s]",
1262 (long) cu_header.abbrev_offset,
1263 (long) (beg_of_comp_unit - dwarf_info_buffer),
1264 bfd_get_filename (abfd));
1265 return;
1266 }
1267 if (beg_of_comp_unit + cu_header.length + cu_header.initial_length_size
1268 > dwarf_info_buffer + dwarf_info_size)
1269 {
1270 error ("Dwarf Error: bad length (0x%lx) in compilation unit header (offset 0x%lx + 0) [in module %s]",
1271 (long) cu_header.length,
1272 (long) (beg_of_comp_unit - dwarf_info_buffer),
1273 bfd_get_filename (abfd));
1274 return;
1275 }
1276 /* Complete the cu_header */
1277 cu_header.offset = beg_of_comp_unit - dwarf_info_buffer;
1278 cu_header.first_die_ptr = info_ptr;
1279 cu_header.cu_head_ptr = beg_of_comp_unit;
1280
1281 /* Read the abbrevs for this compilation unit into a table */
1282 dwarf2_read_abbrevs (abfd, &cu_header);
1283 make_cleanup (dwarf2_empty_abbrev_table, cu_header.dwarf2_abbrevs);
1284
1285 /* Read the compilation unit die */
1286 info_ptr = read_partial_die (&comp_unit_die, abfd, info_ptr,
1287 &cu_header);
1288
1289 /* Set the language we're debugging */
1290 set_cu_language (comp_unit_die.language);
1291
1292 /* Allocate a new partial symbol table structure */
1293 pst = start_psymtab_common (objfile, objfile->section_offsets,
1294 comp_unit_die.name ? comp_unit_die.name : "",
1295 comp_unit_die.lowpc,
1296 objfile->global_psymbols.next,
1297 objfile->static_psymbols.next);
1298
1299 pst->read_symtab_private = (char *)
1300 obstack_alloc (&objfile->psymbol_obstack, sizeof (struct dwarf2_pinfo));
1301 cu_header_offset = beg_of_comp_unit - dwarf_info_buffer;
1302 DWARF_INFO_BUFFER (pst) = dwarf_info_buffer;
1303 DWARF_INFO_OFFSET (pst) = beg_of_comp_unit - dwarf_info_buffer;
1304 DWARF_ABBREV_BUFFER (pst) = dwarf_abbrev_buffer;
1305 DWARF_ABBREV_SIZE (pst) = dwarf_abbrev_size;
1306 DWARF_LINE_BUFFER (pst) = dwarf_line_buffer;
1307 DWARF_LINE_SIZE (pst) = dwarf_line_size;
1308 DWARF_STR_BUFFER (pst) = dwarf_str_buffer;
1309 DWARF_STR_SIZE (pst) = dwarf_str_size;
1310 DWARF_MACINFO_BUFFER (pst) = dwarf_macinfo_buffer;
1311 DWARF_MACINFO_SIZE (pst) = dwarf_macinfo_size;
1312 DWARF_RANGES_BUFFER (pst) = dwarf_ranges_buffer;
1313 DWARF_RANGES_SIZE (pst) = dwarf_ranges_size;
1314 DWARF_LOC_BUFFER (pst) = dwarf_loc_buffer;
1315 DWARF_LOC_SIZE (pst) = dwarf_loc_size;
1316 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1317
1318 /* Store the function that reads in the rest of the symbol table */
1319 pst->read_symtab = dwarf2_psymtab_to_symtab;
1320
1321 /* Check if comp unit has_children.
1322 If so, read the rest of the partial symbols from this comp unit.
1323 If not, there's no more debug_info for this comp unit. */
1324 if (comp_unit_die.has_children)
1325 {
1326 info_ptr = scan_partial_symbols (info_ptr, objfile, &lowpc, &highpc,
1327 &cu_header);
1328
1329 /* If the compilation unit didn't have an explicit address range,
1330 then use the information extracted from its child dies. */
1331 if (! comp_unit_die.has_pc_info)
1332 {
1333 comp_unit_die.lowpc = lowpc;
1334 comp_unit_die.highpc = highpc;
1335 }
1336 }
1337 pst->textlow = comp_unit_die.lowpc + baseaddr;
1338 pst->texthigh = comp_unit_die.highpc + baseaddr;
1339
1340 pst->n_global_syms = objfile->global_psymbols.next -
1341 (objfile->global_psymbols.list + pst->globals_offset);
1342 pst->n_static_syms = objfile->static_psymbols.next -
1343 (objfile->static_psymbols.list + pst->statics_offset);
1344 sort_pst_symbols (pst);
1345
1346 /* If there is already a psymtab or symtab for a file of this
1347 name, remove it. (If there is a symtab, more drastic things
1348 also happen.) This happens in VxWorks. */
1349 free_named_symtabs (pst->filename);
1350
1351 info_ptr = beg_of_comp_unit + cu_header.length
1352 + cu_header.initial_length_size;
1353 }
1354 do_cleanups (back_to);
1355 }
1356
1357 /* Read in all interesting dies to the end of the compilation unit. */
1358
1359 static char *
1360 scan_partial_symbols (char *info_ptr, struct objfile *objfile,
1361 CORE_ADDR *lowpc, CORE_ADDR *highpc,
1362 const struct comp_unit_head *cu_header)
1363 {
1364 bfd *abfd = objfile->obfd;
1365 struct partial_die_info pdi;
1366
1367 /* This function is called after we've read in the comp_unit_die in
1368 order to read its children. We start the nesting level at 1 since
1369 we have pushed 1 level down in order to read the comp unit's children.
1370 The comp unit itself is at level 0, so we stop reading when we pop
1371 back to that level. */
1372
1373 int nesting_level = 1;
1374
1375 /* We only want to read in symbols corresponding to variables or
1376 other similar objects that are global or static. Normally, these
1377 are all children of the DW_TAG_compile_unit die, so are all at
1378 level 1. But C++ namespaces give ries to DW_TAG_namespace dies
1379 whose children are global objects. So we keep track of what
1380 level we currently think of as referring to file scope; this
1381 should always equal 1 plus the number of namespaces that we are
1382 currently nested within. */
1383
1384 int file_scope_level = 1;
1385
1386 *lowpc = ((CORE_ADDR) -1);
1387 *highpc = ((CORE_ADDR) 0);
1388
1389 while (nesting_level)
1390 {
1391 info_ptr = read_partial_die (&pdi, abfd, info_ptr, cu_header);
1392
1393 /* Anonymous namespaces have no name but are interesting. */
1394
1395 if (pdi.name != NULL || pdi.tag == DW_TAG_namespace)
1396 {
1397 switch (pdi.tag)
1398 {
1399 case DW_TAG_subprogram:
1400 if (pdi.has_pc_info)
1401 {
1402 if (pdi.lowpc < *lowpc)
1403 {
1404 *lowpc = pdi.lowpc;
1405 }
1406 if (pdi.highpc > *highpc)
1407 {
1408 *highpc = pdi.highpc;
1409 }
1410 if ((pdi.is_external || nesting_level == file_scope_level)
1411 && !pdi.is_declaration)
1412 {
1413 add_partial_symbol (&pdi, objfile, cu_header);
1414 }
1415 }
1416 break;
1417 case DW_TAG_variable:
1418 case DW_TAG_typedef:
1419 case DW_TAG_class_type:
1420 case DW_TAG_structure_type:
1421 case DW_TAG_union_type:
1422 case DW_TAG_enumeration_type:
1423 if ((pdi.is_external || nesting_level == file_scope_level)
1424 && !pdi.is_declaration)
1425 {
1426 add_partial_symbol (&pdi, objfile, cu_header);
1427 }
1428 break;
1429 case DW_TAG_enumerator:
1430 /* File scope enumerators are added to the partial
1431 symbol table. They're children of the enumeration
1432 type die, so they occur at a level one higher than we
1433 normally look for. */
1434 if (nesting_level == file_scope_level + 1)
1435 add_partial_symbol (&pdi, objfile, cu_header);
1436 break;
1437 case DW_TAG_base_type:
1438 /* File scope base type definitions are added to the partial
1439 symbol table. */
1440 if (nesting_level == file_scope_level)
1441 add_partial_symbol (&pdi, objfile, cu_header);
1442 break;
1443 case DW_TAG_namespace:
1444 /* FIXME: carlton/2002-10-16: we're not yet doing
1445 anything useful with this, but for now make sure that
1446 these tags at least don't cause us to miss any
1447 important symbols. */
1448 if (pdi.has_children)
1449 file_scope_level++;
1450 default:
1451 break;
1452 }
1453 }
1454
1455 /* If the die has a sibling, skip to the sibling. Do not skip
1456 enumeration types, we want to record their enumerators. Do
1457 not skip namespaces, we want to record symbols inside
1458 them. */
1459 if (pdi.sibling
1460 && pdi.tag != DW_TAG_enumeration_type
1461 && pdi.tag != DW_TAG_namespace)
1462 {
1463 info_ptr = pdi.sibling;
1464 }
1465 else if (pdi.has_children)
1466 {
1467 /* Die has children, but either the optional DW_AT_sibling
1468 attribute is missing or we want to look at them. */
1469 nesting_level++;
1470 }
1471
1472 if (pdi.tag == 0)
1473 {
1474 nesting_level--;
1475 /* If this is the end of a DW_TAG_namespace entry, then
1476 decrease the file_scope_level, too. */
1477 if (nesting_level < file_scope_level)
1478 {
1479 file_scope_level--;
1480 gdb_assert (nesting_level == file_scope_level);
1481 }
1482 }
1483 }
1484
1485 /* If we didn't find a lowpc, set it to highpc to avoid complaints
1486 from `maint check'. */
1487 if (*lowpc == ((CORE_ADDR) -1))
1488 *lowpc = *highpc;
1489 return info_ptr;
1490 }
1491
1492 static void
1493 add_partial_symbol (struct partial_die_info *pdi, struct objfile *objfile,
1494 const struct comp_unit_head *cu_header)
1495 {
1496 CORE_ADDR addr = 0;
1497
1498 switch (pdi->tag)
1499 {
1500 case DW_TAG_subprogram:
1501 if (pdi->is_external)
1502 {
1503 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1504 mst_text, objfile); */
1505 add_psymbol_to_list (pdi->name, strlen (pdi->name),
1506 VAR_DOMAIN, LOC_BLOCK,
1507 &objfile->global_psymbols,
1508 0, pdi->lowpc + baseaddr, cu_language, objfile);
1509 }
1510 else
1511 {
1512 /*prim_record_minimal_symbol (pdi->name, pdi->lowpc + baseaddr,
1513 mst_file_text, objfile); */
1514 add_psymbol_to_list (pdi->name, strlen (pdi->name),
1515 VAR_DOMAIN, LOC_BLOCK,
1516 &objfile->static_psymbols,
1517 0, pdi->lowpc + baseaddr, cu_language, objfile);
1518 }
1519 break;
1520 case DW_TAG_variable:
1521 if (pdi->is_external)
1522 {
1523 /* Global Variable.
1524 Don't enter into the minimal symbol tables as there is
1525 a minimal symbol table entry from the ELF symbols already.
1526 Enter into partial symbol table if it has a location
1527 descriptor or a type.
1528 If the location descriptor is missing, new_symbol will create
1529 a LOC_UNRESOLVED symbol, the address of the variable will then
1530 be determined from the minimal symbol table whenever the variable
1531 is referenced.
1532 The address for the partial symbol table entry is not
1533 used by GDB, but it comes in handy for debugging partial symbol
1534 table building. */
1535
1536 if (pdi->locdesc)
1537 addr = decode_locdesc (pdi->locdesc, objfile, cu_header);
1538 if (pdi->locdesc || pdi->has_type)
1539 add_psymbol_to_list (pdi->name, strlen (pdi->name),
1540 VAR_DOMAIN, LOC_STATIC,
1541 &objfile->global_psymbols,
1542 0, addr + baseaddr, cu_language, objfile);
1543 }
1544 else
1545 {
1546 /* Static Variable. Skip symbols without location descriptors. */
1547 if (pdi->locdesc == NULL)
1548 return;
1549 addr = decode_locdesc (pdi->locdesc, objfile, cu_header);
1550 /*prim_record_minimal_symbol (pdi->name, addr + baseaddr,
1551 mst_file_data, objfile); */
1552 add_psymbol_to_list (pdi->name, strlen (pdi->name),
1553 VAR_DOMAIN, LOC_STATIC,
1554 &objfile->static_psymbols,
1555 0, addr + baseaddr, cu_language, objfile);
1556 }
1557 break;
1558 case DW_TAG_typedef:
1559 case DW_TAG_base_type:
1560 add_psymbol_to_list (pdi->name, strlen (pdi->name),
1561 VAR_DOMAIN, LOC_TYPEDEF,
1562 &objfile->static_psymbols,
1563 0, (CORE_ADDR) 0, cu_language, objfile);
1564 break;
1565 case DW_TAG_class_type:
1566 case DW_TAG_structure_type:
1567 case DW_TAG_union_type:
1568 case DW_TAG_enumeration_type:
1569 /* Skip aggregate types without children, these are external
1570 references. */
1571 if (pdi->has_children == 0)
1572 return;
1573 add_psymbol_to_list (pdi->name, strlen (pdi->name),
1574 STRUCT_DOMAIN, LOC_TYPEDEF,
1575 &objfile->static_psymbols,
1576 0, (CORE_ADDR) 0, cu_language, objfile);
1577
1578 if (cu_language == language_cplus)
1579 {
1580 /* For C++, these implicitly act as typedefs as well. */
1581 add_psymbol_to_list (pdi->name, strlen (pdi->name),
1582 VAR_DOMAIN, LOC_TYPEDEF,
1583 &objfile->static_psymbols,
1584 0, (CORE_ADDR) 0, cu_language, objfile);
1585 }
1586 break;
1587 case DW_TAG_enumerator:
1588 add_psymbol_to_list (pdi->name, strlen (pdi->name),
1589 VAR_DOMAIN, LOC_CONST,
1590 &objfile->static_psymbols,
1591 0, (CORE_ADDR) 0, cu_language, objfile);
1592 break;
1593 default:
1594 break;
1595 }
1596 }
1597
1598 /* Expand this partial symbol table into a full symbol table. */
1599
1600 static void
1601 dwarf2_psymtab_to_symtab (struct partial_symtab *pst)
1602 {
1603 /* FIXME: This is barely more than a stub. */
1604 if (pst != NULL)
1605 {
1606 if (pst->readin)
1607 {
1608 warning ("bug: psymtab for %s is already read in.", pst->filename);
1609 }
1610 else
1611 {
1612 if (info_verbose)
1613 {
1614 printf_filtered ("Reading in symbols for %s...", pst->filename);
1615 gdb_flush (gdb_stdout);
1616 }
1617
1618 psymtab_to_symtab_1 (pst);
1619
1620 /* Finish up the debug error message. */
1621 if (info_verbose)
1622 printf_filtered ("done.\n");
1623 }
1624 }
1625 }
1626
1627 static void
1628 psymtab_to_symtab_1 (struct partial_symtab *pst)
1629 {
1630 struct objfile *objfile = pst->objfile;
1631 bfd *abfd = objfile->obfd;
1632 struct comp_unit_head cu_header;
1633 struct die_info *dies;
1634 unsigned long offset;
1635 CORE_ADDR lowpc, highpc;
1636 struct die_info *child_die;
1637 char *info_ptr;
1638 struct symtab *symtab;
1639 struct cleanup *back_to;
1640 struct attribute *attr;
1641
1642 /* Set local variables from the partial symbol table info. */
1643 offset = DWARF_INFO_OFFSET (pst);
1644 dwarf_info_buffer = DWARF_INFO_BUFFER (pst);
1645 dwarf_abbrev_buffer = DWARF_ABBREV_BUFFER (pst);
1646 dwarf_abbrev_size = DWARF_ABBREV_SIZE (pst);
1647 dwarf_line_buffer = DWARF_LINE_BUFFER (pst);
1648 dwarf_line_size = DWARF_LINE_SIZE (pst);
1649 dwarf_str_buffer = DWARF_STR_BUFFER (pst);
1650 dwarf_str_size = DWARF_STR_SIZE (pst);
1651 dwarf_macinfo_buffer = DWARF_MACINFO_BUFFER (pst);
1652 dwarf_macinfo_size = DWARF_MACINFO_SIZE (pst);
1653 dwarf_ranges_buffer = DWARF_RANGES_BUFFER (pst);
1654 dwarf_ranges_size = DWARF_RANGES_SIZE (pst);
1655 dwarf_loc_buffer = DWARF_LOC_BUFFER (pst);
1656 dwarf_loc_size = DWARF_LOC_SIZE (pst);
1657 baseaddr = ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (objfile));
1658 cu_header_offset = offset;
1659 info_ptr = dwarf_info_buffer + offset;
1660
1661 obstack_init (&dwarf2_tmp_obstack);
1662 back_to = make_cleanup (dwarf2_free_tmp_obstack, NULL);
1663
1664 buildsym_init ();
1665 make_cleanup (really_free_pendings, NULL);
1666
1667 /* read in the comp_unit header */
1668 info_ptr = read_comp_unit_head (&cu_header, info_ptr, abfd);
1669
1670 /* Read the abbrevs for this compilation unit */
1671 dwarf2_read_abbrevs (abfd, &cu_header);
1672 make_cleanup (dwarf2_empty_abbrev_table, cu_header.dwarf2_abbrevs);
1673
1674 dies = read_comp_unit (info_ptr, abfd, &cu_header);
1675
1676 make_cleanup_free_die_list (dies);
1677
1678 /* Find the base address of the compilation unit for range lists and
1679 location lists. It will normally be specified by DW_AT_low_pc.
1680 In DWARF-3 draft 4, the base address could be overridden by
1681 DW_AT_entry_pc. It's been removed, but GCC still uses this for
1682 compilation units with discontinuous ranges. */
1683
1684 cu_header.base_known = 0;
1685 cu_header.base_address = 0;
1686
1687 attr = dwarf_attr (dies, DW_AT_entry_pc);
1688 if (attr)
1689 {
1690 cu_header.base_address = DW_ADDR (attr);
1691 cu_header.base_known = 1;
1692 }
1693 else
1694 {
1695 attr = dwarf_attr (dies, DW_AT_low_pc);
1696 if (attr)
1697 {
1698 cu_header.base_address = DW_ADDR (attr);
1699 cu_header.base_known = 1;
1700 }
1701 }
1702
1703 /* Do line number decoding in read_file_scope () */
1704 process_die (dies, objfile, &cu_header);
1705
1706 if (!dwarf2_get_pc_bounds (dies, &lowpc, &highpc, objfile, &cu_header))
1707 {
1708 /* Some compilers don't define a DW_AT_high_pc attribute for
1709 the compilation unit. If the DW_AT_high_pc is missing,
1710 synthesize it, by scanning the DIE's below the compilation unit. */
1711 highpc = 0;
1712 if (dies->has_children)
1713 {
1714 child_die = dies->next;
1715 while (child_die && child_die->tag)
1716 {
1717 if (child_die->tag == DW_TAG_subprogram)
1718 {
1719 CORE_ADDR low, high;
1720
1721 if (dwarf2_get_pc_bounds (child_die, &low, &high,
1722 objfile, &cu_header))
1723 {
1724 highpc = max (highpc, high);
1725 }
1726 }
1727 child_die = sibling_die (child_die);
1728 }
1729 }
1730 }
1731 symtab = end_symtab (highpc + baseaddr, objfile, SECT_OFF_TEXT (objfile));
1732
1733 /* Set symtab language to language from DW_AT_language.
1734 If the compilation is from a C file generated by language preprocessors,
1735 do not set the language if it was already deduced by start_subfile. */
1736 if (symtab != NULL
1737 && !(cu_language == language_c && symtab->language != language_c))
1738 {
1739 symtab->language = cu_language;
1740 }
1741 pst->symtab = symtab;
1742 pst->readin = 1;
1743 sort_symtab_syms (pst->symtab);
1744
1745 do_cleanups (back_to);
1746 }
1747
1748 /* Process a die and its children. */
1749
1750 static void
1751 process_die (struct die_info *die, struct objfile *objfile,
1752 const struct comp_unit_head *cu_header)
1753 {
1754 switch (die->tag)
1755 {
1756 case DW_TAG_padding:
1757 break;
1758 case DW_TAG_compile_unit:
1759 read_file_scope (die, objfile, cu_header);
1760 break;
1761 case DW_TAG_subprogram:
1762 read_subroutine_type (die, objfile, cu_header);
1763 read_func_scope (die, objfile, cu_header);
1764 break;
1765 case DW_TAG_inlined_subroutine:
1766 /* FIXME: These are ignored for now.
1767 They could be used to set breakpoints on all inlined instances
1768 of a function and make GDB `next' properly over inlined functions. */
1769 break;
1770 case DW_TAG_lexical_block:
1771 case DW_TAG_try_block:
1772 case DW_TAG_catch_block:
1773 read_lexical_block_scope (die, objfile, cu_header);
1774 break;
1775 case DW_TAG_class_type:
1776 case DW_TAG_structure_type:
1777 case DW_TAG_union_type:
1778 read_structure_scope (die, objfile, cu_header);
1779 break;
1780 case DW_TAG_enumeration_type:
1781 read_enumeration (die, objfile, cu_header);
1782 break;
1783 case DW_TAG_subroutine_type:
1784 read_subroutine_type (die, objfile, cu_header);
1785 break;
1786 case DW_TAG_array_type:
1787 read_array_type (die, objfile, cu_header);
1788 break;
1789 case DW_TAG_pointer_type:
1790 read_tag_pointer_type (die, objfile, cu_header);
1791 break;
1792 case DW_TAG_ptr_to_member_type:
1793 read_tag_ptr_to_member_type (die, objfile, cu_header);
1794 break;
1795 case DW_TAG_reference_type:
1796 read_tag_reference_type (die, objfile, cu_header);
1797 break;
1798 case DW_TAG_string_type:
1799 read_tag_string_type (die, objfile);
1800 break;
1801 case DW_TAG_base_type:
1802 read_base_type (die, objfile);
1803 if (dwarf_attr (die, DW_AT_name))
1804 {
1805 /* Add a typedef symbol for the base type definition. */
1806 new_symbol (die, die->type, objfile, cu_header);
1807 }
1808 break;
1809 case DW_TAG_common_block:
1810 read_common_block (die, objfile, cu_header);
1811 break;
1812 case DW_TAG_common_inclusion:
1813 break;
1814 case DW_TAG_namespace:
1815 if (!processing_has_namespace_info)
1816 {
1817 processing_has_namespace_info = 1;
1818 processing_current_namespace = "";
1819 }
1820 read_namespace (die, objfile, cu_header);
1821 break;
1822 case DW_TAG_imported_declaration:
1823 case DW_TAG_imported_module:
1824 /* FIXME: carlton/2002-10-16: Eventually, we should use the
1825 information contained in these. DW_TAG_imported_declaration
1826 dies shouldn't have children; DW_TAG_imported_module dies
1827 shouldn't in the C++ case, but conceivably could in the
1828 Fortran case, so we'll have to replace this gdb_assert if
1829 Fortran compilers start generating that info. */
1830 if (!processing_has_namespace_info)
1831 {
1832 processing_has_namespace_info = 1;
1833 processing_current_namespace = "";
1834 }
1835 gdb_assert (!die->has_children);
1836 break;
1837 default:
1838 new_symbol (die, NULL, objfile, cu_header);
1839 break;
1840 }
1841 }
1842
1843 static void
1844 initialize_cu_func_list (void)
1845 {
1846 cu_first_fn = cu_last_fn = cu_cached_fn = NULL;
1847 }
1848
1849 static void
1850 read_file_scope (struct die_info *die, struct objfile *objfile,
1851 const struct comp_unit_head *cu_header)
1852 {
1853 struct cleanup *back_to = make_cleanup (null_cleanup, 0);
1854 CORE_ADDR lowpc = ((CORE_ADDR) -1);
1855 CORE_ADDR highpc = ((CORE_ADDR) 0);
1856 struct attribute *attr;
1857 char *name = "<unknown>";
1858 char *comp_dir = NULL;
1859 struct die_info *child_die;
1860 bfd *abfd = objfile->obfd;
1861 struct line_header *line_header = 0;
1862
1863 if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, objfile, cu_header))
1864 {
1865 if (die->has_children)
1866 {
1867 child_die = die->next;
1868 while (child_die && child_die->tag)
1869 {
1870 if (child_die->tag == DW_TAG_subprogram)
1871 {
1872 CORE_ADDR low, high;
1873
1874 if (dwarf2_get_pc_bounds (child_die, &low, &high,
1875 objfile, cu_header))
1876 {
1877 lowpc = min (lowpc, low);
1878 highpc = max (highpc, high);
1879 }
1880 }
1881 child_die = sibling_die (child_die);
1882 }
1883 }
1884 }
1885
1886 /* If we didn't find a lowpc, set it to highpc to avoid complaints
1887 from finish_block. */
1888 if (lowpc == ((CORE_ADDR) -1))
1889 lowpc = highpc;
1890 lowpc += baseaddr;
1891 highpc += baseaddr;
1892
1893 attr = dwarf_attr (die, DW_AT_name);
1894 if (attr)
1895 {
1896 name = DW_STRING (attr);
1897 }
1898 attr = dwarf_attr (die, DW_AT_comp_dir);
1899 if (attr)
1900 {
1901 comp_dir = DW_STRING (attr);
1902 if (comp_dir)
1903 {
1904 /* Irix 6.2 native cc prepends <machine>.: to the compilation
1905 directory, get rid of it. */
1906 char *cp = strchr (comp_dir, ':');
1907
1908 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
1909 comp_dir = cp + 1;
1910 }
1911 }
1912
1913 if (objfile->ei.entry_point >= lowpc &&
1914 objfile->ei.entry_point < highpc)
1915 {
1916 objfile->ei.entry_file_lowpc = lowpc;
1917 objfile->ei.entry_file_highpc = highpc;
1918 }
1919
1920 attr = dwarf_attr (die, DW_AT_language);
1921 if (attr)
1922 {
1923 set_cu_language (DW_UNSND (attr));
1924 }
1925
1926 /* We assume that we're processing GCC output. */
1927 processing_gcc_compilation = 2;
1928 #if 0
1929 /* FIXME:Do something here. */
1930 if (dip->at_producer != NULL)
1931 {
1932 handle_producer (dip->at_producer);
1933 }
1934 #endif
1935
1936 /* The compilation unit may be in a different language or objfile,
1937 zero out all remembered fundamental types. */
1938 memset (ftypes, 0, FT_NUM_MEMBERS * sizeof (struct type *));
1939
1940 start_symtab (name, comp_dir, lowpc);
1941 record_debugformat ("DWARF 2");
1942
1943 initialize_cu_func_list ();
1944
1945 /* Process all dies in compilation unit. */
1946 if (die->has_children)
1947 {
1948 child_die = die->next;
1949 while (child_die && child_die->tag)
1950 {
1951 process_die (child_die, objfile, cu_header);
1952 child_die = sibling_die (child_die);
1953 }
1954 }
1955
1956 /* Decode line number information if present. */
1957 attr = dwarf_attr (die, DW_AT_stmt_list);
1958 if (attr)
1959 {
1960 unsigned int line_offset = DW_UNSND (attr);
1961 line_header = dwarf_decode_line_header (line_offset,
1962 abfd, cu_header);
1963 if (line_header)
1964 {
1965 make_cleanup ((make_cleanup_ftype *) free_line_header,
1966 (void *) line_header);
1967 dwarf_decode_lines (line_header, comp_dir, abfd, cu_header);
1968 }
1969 }
1970
1971 /* Decode macro information, if present. Dwarf 2 macro information
1972 refers to information in the line number info statement program
1973 header, so we can only read it if we've read the header
1974 successfully. */
1975 attr = dwarf_attr (die, DW_AT_macro_info);
1976 if (attr && line_header)
1977 {
1978 unsigned int macro_offset = DW_UNSND (attr);
1979 dwarf_decode_macros (line_header, macro_offset,
1980 comp_dir, abfd, cu_header, objfile);
1981 }
1982 do_cleanups (back_to);
1983 }
1984
1985 static void
1986 add_to_cu_func_list (const char *name, CORE_ADDR lowpc, CORE_ADDR highpc)
1987 {
1988 struct function_range *thisfn;
1989
1990 thisfn = (struct function_range *)
1991 obstack_alloc (&dwarf2_tmp_obstack, sizeof (struct function_range));
1992 thisfn->name = name;
1993 thisfn->lowpc = lowpc;
1994 thisfn->highpc = highpc;
1995 thisfn->seen_line = 0;
1996 thisfn->next = NULL;
1997
1998 if (cu_last_fn == NULL)
1999 cu_first_fn = thisfn;
2000 else
2001 cu_last_fn->next = thisfn;
2002
2003 cu_last_fn = thisfn;
2004 }
2005
2006 static void
2007 read_func_scope (struct die_info *die, struct objfile *objfile,
2008 const struct comp_unit_head *cu_header)
2009 {
2010 register struct context_stack *new;
2011 CORE_ADDR lowpc;
2012 CORE_ADDR highpc;
2013 struct die_info *child_die;
2014 struct attribute *attr;
2015 char *name;
2016
2017 name = dwarf2_linkage_name (die);
2018
2019 /* Ignore functions with missing or empty names and functions with
2020 missing or invalid low and high pc attributes. */
2021 if (name == NULL || !dwarf2_get_pc_bounds (die, &lowpc, &highpc, objfile, cu_header))
2022 return;
2023
2024 lowpc += baseaddr;
2025 highpc += baseaddr;
2026
2027 /* Record the function range for dwarf_decode_lines. */
2028 add_to_cu_func_list (name, lowpc, highpc);
2029
2030 if (objfile->ei.entry_point >= lowpc &&
2031 objfile->ei.entry_point < highpc)
2032 {
2033 objfile->ei.entry_func_lowpc = lowpc;
2034 objfile->ei.entry_func_highpc = highpc;
2035 }
2036
2037 /* Decode DW_AT_frame_base location descriptor if present, keep result
2038 for DW_OP_fbreg operands in decode_locdesc. */
2039 frame_base_reg = -1;
2040 frame_base_offset = 0;
2041 attr = dwarf_attr (die, DW_AT_frame_base);
2042 if (attr)
2043 {
2044 CORE_ADDR addr;
2045
2046 /* Support the .debug_loc offsets */
2047 if (attr_form_is_block (attr))
2048 {
2049 addr = decode_locdesc (DW_BLOCK (attr), objfile, cu_header);
2050 }
2051 else if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
2052 {
2053 dwarf2_complex_location_expr_complaint ();
2054 addr = 0;
2055 }
2056 else
2057 {
2058 dwarf2_invalid_attrib_class_complaint ("DW_AT_frame_base", name);
2059 addr = 0;
2060 }
2061
2062 if (isderef)
2063 dwarf2_unsupported_at_frame_base_complaint (name);
2064 else if (isreg)
2065 frame_base_reg = addr;
2066 else if (offreg)
2067 {
2068 frame_base_reg = basereg;
2069 frame_base_offset = addr;
2070 }
2071 else
2072 dwarf2_unsupported_at_frame_base_complaint (name);
2073 }
2074
2075 new = push_context (0, lowpc);
2076 new->name = new_symbol (die, die->type, objfile, cu_header);
2077
2078 /* If there was a location expression for DW_AT_frame_base above,
2079 record it. We still need to decode it above because not all
2080 symbols use location expressions exclusively. */
2081 if (attr)
2082 dwarf2_symbol_mark_computed (attr, new->name, cu_header, objfile);
2083
2084 list_in_scope = &local_symbols;
2085
2086 if (die->has_children)
2087 {
2088 child_die = die->next;
2089 while (child_die && child_die->tag)
2090 {
2091 process_die (child_die, objfile, cu_header);
2092 child_die = sibling_die (child_die);
2093 }
2094 }
2095
2096 new = pop_context ();
2097 /* Make a block for the local symbols within. */
2098 finish_block (new->name, &local_symbols, new->old_blocks,
2099 lowpc, highpc, objfile);
2100
2101 /* In C++, we can have functions nested inside functions (e.g., when
2102 a function declares a class that has methods). This means that
2103 when we finish processing a function scope, we may need to go
2104 back to building a containing block's symbol lists. */
2105 local_symbols = new->locals;
2106 param_symbols = new->params;
2107
2108 /* If we've finished processing a top-level function, subsequent
2109 symbols go in the file symbol list. */
2110 if (outermost_context_p ())
2111 list_in_scope = &file_symbols;
2112 }
2113
2114 /* Process all the DIES contained within a lexical block scope. Start
2115 a new scope, process the dies, and then close the scope. */
2116
2117 static void
2118 read_lexical_block_scope (struct die_info *die, struct objfile *objfile,
2119 const struct comp_unit_head *cu_header)
2120 {
2121 register struct context_stack *new;
2122 CORE_ADDR lowpc, highpc;
2123 struct die_info *child_die;
2124
2125 /* Ignore blocks with missing or invalid low and high pc attributes. */
2126 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
2127 as multiple lexical blocks? Handling children in a sane way would
2128 be nasty. Might be easier to properly extend generic blocks to
2129 describe ranges. */
2130 if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, objfile, cu_header))
2131 return;
2132 lowpc += baseaddr;
2133 highpc += baseaddr;
2134
2135 push_context (0, lowpc);
2136 if (die->has_children)
2137 {
2138 child_die = die->next;
2139 while (child_die && child_die->tag)
2140 {
2141 process_die (child_die, objfile, cu_header);
2142 child_die = sibling_die (child_die);
2143 }
2144 }
2145 new = pop_context ();
2146
2147 if (local_symbols != NULL)
2148 {
2149 finish_block (0, &local_symbols, new->old_blocks, new->start_addr,
2150 highpc, objfile);
2151 }
2152 local_symbols = new->locals;
2153 }
2154
2155 /* Get low and high pc attributes from a die. Return 1 if the attributes
2156 are present and valid, otherwise, return 0. Return -1 if the range is
2157 discontinuous, i.e. derived from DW_AT_ranges information. */
2158 static int
2159 dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
2160 CORE_ADDR *highpc, struct objfile *objfile,
2161 const struct comp_unit_head *cu_header)
2162 {
2163 struct attribute *attr;
2164 bfd *obfd = objfile->obfd;
2165 CORE_ADDR low = 0;
2166 CORE_ADDR high = 0;
2167 int ret = 0;
2168
2169 attr = dwarf_attr (die, DW_AT_high_pc);
2170 if (attr)
2171 {
2172 high = DW_ADDR (attr);
2173 attr = dwarf_attr (die, DW_AT_low_pc);
2174 if (attr)
2175 low = DW_ADDR (attr);
2176 else
2177 /* Found high w/o low attribute. */
2178 return 0;
2179
2180 /* Found consecutive range of addresses. */
2181 ret = 1;
2182 }
2183 else
2184 {
2185 attr = dwarf_attr (die, DW_AT_ranges);
2186 if (attr != NULL)
2187 {
2188 unsigned int addr_size = cu_header->addr_size;
2189 CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));
2190 /* Value of the DW_AT_ranges attribute is the offset in the
2191 .debug_renges section. */
2192 unsigned int offset = DW_UNSND (attr);
2193 /* Base address selection entry. */
2194 CORE_ADDR base;
2195 int found_base;
2196 int dummy;
2197 unsigned int i;
2198 char *buffer;
2199 CORE_ADDR marker;
2200 int low_set;
2201
2202 found_base = cu_header->base_known;
2203 base = cu_header->base_address;
2204 buffer = dwarf_ranges_buffer + offset;
2205
2206 /* Read in the largest possible address. */
2207 marker = read_address (obfd, buffer, cu_header, &dummy);
2208 if ((marker & mask) == mask)
2209 {
2210 /* If we found the largest possible address, then
2211 read the base address. */
2212 base = read_address (obfd, buffer + addr_size,
2213 cu_header, &dummy);
2214 buffer += 2 * addr_size;
2215 offset += 2 * addr_size;
2216 found_base = 1;
2217 }
2218
2219 low_set = 0;
2220
2221 while (1)
2222 {
2223 CORE_ADDR range_beginning, range_end;
2224
2225 range_beginning = read_address (obfd, buffer,
2226 cu_header, &dummy);
2227 buffer += addr_size;
2228 range_end = read_address (obfd, buffer, cu_header, &dummy);
2229 buffer += addr_size;
2230 offset += 2 * addr_size;
2231
2232 /* An end of list marker is a pair of zero addresses. */
2233 if (range_beginning == 0 && range_end == 0)
2234 /* Found the end of list entry. */
2235 break;
2236
2237 /* Each base address selection entry is a pair of 2 values.
2238 The first is the largest possible address, the second is
2239 the base address. Check for a base address here. */
2240 if ((range_beginning & mask) == mask)
2241 {
2242 /* If we found the largest possible address, then
2243 read the base address. */
2244 base = read_address (obfd, buffer + addr_size,
2245 cu_header, &dummy);
2246 found_base = 1;
2247 continue;
2248 }
2249
2250 if (!found_base)
2251 {
2252 /* We have no valid base address for the ranges
2253 data. */
2254 complaint (&symfile_complaints,
2255 "Invalid .debug_ranges data (no base address)");
2256 return 0;
2257 }
2258
2259 range_beginning += base;
2260 range_end += base;
2261
2262 /* FIXME: This is recording everything as a low-high
2263 segment of consecutive addresses. We should have a
2264 data structure for discontiguous block ranges
2265 instead. */
2266 if (! low_set)
2267 {
2268 low = range_beginning;
2269 high = range_end;
2270 low_set = 1;
2271 }
2272 else
2273 {
2274 if (range_beginning < low)
2275 low = range_beginning;
2276 if (range_end > high)
2277 high = range_end;
2278 }
2279 }
2280
2281 if (! low_set)
2282 /* If the first entry is an end-of-list marker, the range
2283 describes an empty scope, i.e. no instructions. */
2284 return 0;
2285
2286 ret = -1;
2287 }
2288 }
2289
2290 if (high < low)
2291 return 0;
2292
2293 /* When using the GNU linker, .gnu.linkonce. sections are used to
2294 eliminate duplicate copies of functions and vtables and such.
2295 The linker will arbitrarily choose one and discard the others.
2296 The AT_*_pc values for such functions refer to local labels in
2297 these sections. If the section from that file was discarded, the
2298 labels are not in the output, so the relocs get a value of 0.
2299 If this is a discarded function, mark the pc bounds as invalid,
2300 so that GDB will ignore it. */
2301 if (low == 0 && (bfd_get_file_flags (obfd) & HAS_RELOC) == 0)
2302 return 0;
2303
2304 *lowpc = low;
2305 *highpc = high;
2306 return ret;
2307 }
2308
2309 /* Add an aggregate field to the field list. */
2310
2311 static void
2312 dwarf2_add_field (struct field_info *fip, struct die_info *die,
2313 struct objfile *objfile,
2314 const struct comp_unit_head *cu_header)
2315 {
2316 struct nextfield *new_field;
2317 struct attribute *attr;
2318 struct field *fp;
2319 char *fieldname = "";
2320
2321 /* Allocate a new field list entry and link it in. */
2322 new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield));
2323 make_cleanup (xfree, new_field);
2324 memset (new_field, 0, sizeof (struct nextfield));
2325 new_field->next = fip->fields;
2326 fip->fields = new_field;
2327 fip->nfields++;
2328
2329 /* Handle accessibility and virtuality of field.
2330 The default accessibility for members is public, the default
2331 accessibility for inheritance is private. */
2332 if (die->tag != DW_TAG_inheritance)
2333 new_field->accessibility = DW_ACCESS_public;
2334 else
2335 new_field->accessibility = DW_ACCESS_private;
2336 new_field->virtuality = DW_VIRTUALITY_none;
2337
2338 attr = dwarf_attr (die, DW_AT_accessibility);
2339 if (attr)
2340 new_field->accessibility = DW_UNSND (attr);
2341 if (new_field->accessibility != DW_ACCESS_public)
2342 fip->non_public_fields = 1;
2343 attr = dwarf_attr (die, DW_AT_virtuality);
2344 if (attr)
2345 new_field->virtuality = DW_UNSND (attr);
2346
2347 fp = &new_field->field;
2348
2349 if (die->tag == DW_TAG_member && ! die_is_declaration (die))
2350 {
2351 /* Data member other than a C++ static data member. */
2352
2353 /* Get type of field. */
2354 fp->type = die_type (die, objfile, cu_header);
2355
2356 FIELD_STATIC_KIND (*fp) = 0;
2357
2358 /* Get bit size of field (zero if none). */
2359 attr = dwarf_attr (die, DW_AT_bit_size);
2360 if (attr)
2361 {
2362 FIELD_BITSIZE (*fp) = DW_UNSND (attr);
2363 }
2364 else
2365 {
2366 FIELD_BITSIZE (*fp) = 0;
2367 }
2368
2369 /* Get bit offset of field. */
2370 attr = dwarf_attr (die, DW_AT_data_member_location);
2371 if (attr)
2372 {
2373 FIELD_BITPOS (*fp) =
2374 decode_locdesc (DW_BLOCK (attr), objfile, cu_header) * bits_per_byte;
2375 }
2376 else
2377 FIELD_BITPOS (*fp) = 0;
2378 attr = dwarf_attr (die, DW_AT_bit_offset);
2379 if (attr)
2380 {
2381 if (BITS_BIG_ENDIAN)
2382 {
2383 /* For big endian bits, the DW_AT_bit_offset gives the
2384 additional bit offset from the MSB of the containing
2385 anonymous object to the MSB of the field. We don't
2386 have to do anything special since we don't need to
2387 know the size of the anonymous object. */
2388 FIELD_BITPOS (*fp) += DW_UNSND (attr);
2389 }
2390 else
2391 {
2392 /* For little endian bits, compute the bit offset to the
2393 MSB of the anonymous object, subtract off the number of
2394 bits from the MSB of the field to the MSB of the
2395 object, and then subtract off the number of bits of
2396 the field itself. The result is the bit offset of
2397 the LSB of the field. */
2398 int anonymous_size;
2399 int bit_offset = DW_UNSND (attr);
2400
2401 attr = dwarf_attr (die, DW_AT_byte_size);
2402 if (attr)
2403 {
2404 /* The size of the anonymous object containing
2405 the bit field is explicit, so use the
2406 indicated size (in bytes). */
2407 anonymous_size = DW_UNSND (attr);
2408 }
2409 else
2410 {
2411 /* The size of the anonymous object containing
2412 the bit field must be inferred from the type
2413 attribute of the data member containing the
2414 bit field. */
2415 anonymous_size = TYPE_LENGTH (fp->type);
2416 }
2417 FIELD_BITPOS (*fp) += anonymous_size * bits_per_byte
2418 - bit_offset - FIELD_BITSIZE (*fp);
2419 }
2420 }
2421
2422 /* Get name of field. */
2423 attr = dwarf_attr (die, DW_AT_name);
2424 if (attr && DW_STRING (attr))
2425 fieldname = DW_STRING (attr);
2426 fp->name = obsavestring (fieldname, strlen (fieldname),
2427 &objfile->type_obstack);
2428
2429 /* Change accessibility for artificial fields (e.g. virtual table
2430 pointer or virtual base class pointer) to private. */
2431 if (dwarf_attr (die, DW_AT_artificial))
2432 {
2433 new_field->accessibility = DW_ACCESS_private;
2434 fip->non_public_fields = 1;
2435 }
2436 }
2437 else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable)
2438 {
2439 /* C++ static member. */
2440
2441 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that
2442 is a declaration, but all versions of G++ as of this writing
2443 (so through at least 3.2.1) incorrectly generate
2444 DW_TAG_variable tags. */
2445
2446 char *physname;
2447
2448 /* Get name of field. */
2449 attr = dwarf_attr (die, DW_AT_name);
2450 if (attr && DW_STRING (attr))
2451 fieldname = DW_STRING (attr);
2452 else
2453 return;
2454
2455 /* Get physical name. */
2456 physname = dwarf2_linkage_name (die);
2457
2458 SET_FIELD_PHYSNAME (*fp, obsavestring (physname, strlen (physname),
2459 &objfile->type_obstack));
2460 FIELD_TYPE (*fp) = die_type (die, objfile, cu_header);
2461 FIELD_NAME (*fp) = obsavestring (fieldname, strlen (fieldname),
2462 &objfile->type_obstack);
2463 }
2464 else if (die->tag == DW_TAG_inheritance)
2465 {
2466 /* C++ base class field. */
2467 attr = dwarf_attr (die, DW_AT_data_member_location);
2468 if (attr)
2469 FIELD_BITPOS (*fp) = (decode_locdesc (DW_BLOCK (attr), objfile, cu_header)
2470 * bits_per_byte);
2471 FIELD_BITSIZE (*fp) = 0;
2472 FIELD_STATIC_KIND (*fp) = 0;
2473 FIELD_TYPE (*fp) = die_type (die, objfile, cu_header);
2474 FIELD_NAME (*fp) = type_name_no_tag (fp->type);
2475 fip->nbaseclasses++;
2476 }
2477 }
2478
2479 /* Create the vector of fields, and attach it to the type. */
2480
2481 static void
2482 dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type,
2483 struct objfile *objfile)
2484 {
2485 int nfields = fip->nfields;
2486
2487 /* Record the field count, allocate space for the array of fields,
2488 and create blank accessibility bitfields if necessary. */
2489 TYPE_NFIELDS (type) = nfields;
2490 TYPE_FIELDS (type) = (struct field *)
2491 TYPE_ALLOC (type, sizeof (struct field) * nfields);
2492 memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
2493
2494 if (fip->non_public_fields)
2495 {
2496 ALLOCATE_CPLUS_STRUCT_TYPE (type);
2497
2498 TYPE_FIELD_PRIVATE_BITS (type) =
2499 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
2500 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
2501
2502 TYPE_FIELD_PROTECTED_BITS (type) =
2503 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
2504 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
2505
2506 TYPE_FIELD_IGNORE_BITS (type) =
2507 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
2508 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
2509 }
2510
2511 /* If the type has baseclasses, allocate and clear a bit vector for
2512 TYPE_FIELD_VIRTUAL_BITS. */
2513 if (fip->nbaseclasses)
2514 {
2515 int num_bytes = B_BYTES (fip->nbaseclasses);
2516 char *pointer;
2517
2518 ALLOCATE_CPLUS_STRUCT_TYPE (type);
2519 pointer = (char *) TYPE_ALLOC (type, num_bytes);
2520 TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *) pointer;
2521 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->nbaseclasses);
2522 TYPE_N_BASECLASSES (type) = fip->nbaseclasses;
2523 }
2524
2525 /* Copy the saved-up fields into the field vector. Start from the head
2526 of the list, adding to the tail of the field array, so that they end
2527 up in the same order in the array in which they were added to the list. */
2528 while (nfields-- > 0)
2529 {
2530 TYPE_FIELD (type, nfields) = fip->fields->field;
2531 switch (fip->fields->accessibility)
2532 {
2533 case DW_ACCESS_private:
2534 SET_TYPE_FIELD_PRIVATE (type, nfields);
2535 break;
2536
2537 case DW_ACCESS_protected:
2538 SET_TYPE_FIELD_PROTECTED (type, nfields);
2539 break;
2540
2541 case DW_ACCESS_public:
2542 break;
2543
2544 default:
2545 /* Unknown accessibility. Complain and treat it as public. */
2546 {
2547 complaint (&symfile_complaints, "unsupported accessibility %d",
2548 fip->fields->accessibility);
2549 }
2550 break;
2551 }
2552 if (nfields < fip->nbaseclasses)
2553 {
2554 switch (fip->fields->virtuality)
2555 {
2556 case DW_VIRTUALITY_virtual:
2557 case DW_VIRTUALITY_pure_virtual:
2558 SET_TYPE_FIELD_VIRTUAL (type, nfields);
2559 break;
2560 }
2561 }
2562 fip->fields = fip->fields->next;
2563 }
2564 }
2565
2566 /* Add a member function to the proper fieldlist. */
2567
2568 static void
2569 dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
2570 struct type *type, struct objfile *objfile,
2571 const struct comp_unit_head *cu_header)
2572 {
2573 struct attribute *attr;
2574 struct fnfieldlist *flp;
2575 int i;
2576 struct fn_field *fnp;
2577 char *fieldname;
2578 char *physname;
2579 struct nextfnfield *new_fnfield;
2580
2581 /* Get name of member function. */
2582 attr = dwarf_attr (die, DW_AT_name);
2583 if (attr && DW_STRING (attr))
2584 fieldname = DW_STRING (attr);
2585 else
2586 return;
2587
2588 /* Get the mangled name. */
2589 physname = dwarf2_linkage_name (die);
2590
2591 /* Look up member function name in fieldlist. */
2592 for (i = 0; i < fip->nfnfields; i++)
2593 {
2594 if (STREQ (fip->fnfieldlists[i].name, fieldname))
2595 break;
2596 }
2597
2598 /* Create new list element if necessary. */
2599 if (i < fip->nfnfields)
2600 flp = &fip->fnfieldlists[i];
2601 else
2602 {
2603 if ((fip->nfnfields % DW_FIELD_ALLOC_CHUNK) == 0)
2604 {
2605 fip->fnfieldlists = (struct fnfieldlist *)
2606 xrealloc (fip->fnfieldlists,
2607 (fip->nfnfields + DW_FIELD_ALLOC_CHUNK)
2608 * sizeof (struct fnfieldlist));
2609 if (fip->nfnfields == 0)
2610 make_cleanup (free_current_contents, &fip->fnfieldlists);
2611 }
2612 flp = &fip->fnfieldlists[fip->nfnfields];
2613 flp->name = fieldname;
2614 flp->length = 0;
2615 flp->head = NULL;
2616 fip->nfnfields++;
2617 }
2618
2619 /* Create a new member function field and chain it to the field list
2620 entry. */
2621 new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield));
2622 make_cleanup (xfree, new_fnfield);
2623 memset (new_fnfield, 0, sizeof (struct nextfnfield));
2624 new_fnfield->next = flp->head;
2625 flp->head = new_fnfield;
2626 flp->length++;
2627
2628 /* Fill in the member function field info. */
2629 fnp = &new_fnfield->fnfield;
2630 fnp->physname = obsavestring (physname, strlen (physname),
2631 &objfile->type_obstack);
2632 fnp->type = alloc_type (objfile);
2633 if (die->type && TYPE_CODE (die->type) == TYPE_CODE_FUNC)
2634 {
2635 struct type *return_type = TYPE_TARGET_TYPE (die->type);
2636 int nparams = TYPE_NFIELDS (die->type);
2637
2638 /* TYPE is the domain of this method, and DIE->TYPE is the type
2639 of the method itself (TYPE_CODE_METHOD). */
2640 smash_to_method_type (fnp->type, type,
2641 TYPE_TARGET_TYPE (die->type),
2642 TYPE_FIELDS (die->type),
2643 TYPE_NFIELDS (die->type),
2644 TYPE_VARARGS (die->type));
2645
2646 /* Handle static member functions.
2647 Dwarf2 has no clean way to discern C++ static and non-static
2648 member functions. G++ helps GDB by marking the first
2649 parameter for non-static member functions (which is the
2650 this pointer) as artificial. We obtain this information
2651 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */
2652 if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (die->type, 0) == 0)
2653 fnp->voffset = VOFFSET_STATIC;
2654 }
2655 else
2656 complaint (&symfile_complaints, "member function type missing for '%s'",
2657 physname);
2658
2659 /* Get fcontext from DW_AT_containing_type if present. */
2660 if (dwarf_attr (die, DW_AT_containing_type) != NULL)
2661 fnp->fcontext = die_containing_type (die, objfile, cu_header);
2662
2663 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const
2664 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
2665
2666 /* Get accessibility. */
2667 attr = dwarf_attr (die, DW_AT_accessibility);
2668 if (attr)
2669 {
2670 switch (DW_UNSND (attr))
2671 {
2672 case DW_ACCESS_private:
2673 fnp->is_private = 1;
2674 break;
2675 case DW_ACCESS_protected:
2676 fnp->is_protected = 1;
2677 break;
2678 }
2679 }
2680
2681 /* Check for artificial methods. */
2682 attr = dwarf_attr (die, DW_AT_artificial);
2683 if (attr && DW_UNSND (attr) != 0)
2684 fnp->is_artificial = 1;
2685
2686 /* Get index in virtual function table if it is a virtual member function. */
2687 attr = dwarf_attr (die, DW_AT_vtable_elem_location);
2688 if (attr)
2689 {
2690 /* Support the .debug_loc offsets */
2691 if (attr_form_is_block (attr))
2692 {
2693 fnp->voffset = decode_locdesc (DW_BLOCK (attr), objfile, cu_header) + 2;
2694 }
2695 else if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
2696 {
2697 dwarf2_complex_location_expr_complaint ();
2698 }
2699 else
2700 {
2701 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location",
2702 fieldname);
2703 }
2704 }
2705 }
2706
2707 /* Create the vector of member function fields, and attach it to the type. */
2708
2709 static void
2710 dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type,
2711 struct objfile *objfile)
2712 {
2713 struct fnfieldlist *flp;
2714 int total_length = 0;
2715 int i;
2716
2717 ALLOCATE_CPLUS_STRUCT_TYPE (type);
2718 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
2719 TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * fip->nfnfields);
2720
2721 for (i = 0, flp = fip->fnfieldlists; i < fip->nfnfields; i++, flp++)
2722 {
2723 struct nextfnfield *nfp = flp->head;
2724 struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i);
2725 int k;
2726
2727 TYPE_FN_FIELDLIST_NAME (type, i) = flp->name;
2728 TYPE_FN_FIELDLIST_LENGTH (type, i) = flp->length;
2729 fn_flp->fn_fields = (struct fn_field *)
2730 TYPE_ALLOC (type, sizeof (struct fn_field) * flp->length);
2731 for (k = flp->length; (k--, nfp); nfp = nfp->next)
2732 fn_flp->fn_fields[k] = nfp->fnfield;
2733
2734 total_length += flp->length;
2735 }
2736
2737 TYPE_NFN_FIELDS (type) = fip->nfnfields;
2738 TYPE_NFN_FIELDS_TOTAL (type) = total_length;
2739 }
2740
2741 /* Called when we find the DIE that starts a structure or union scope
2742 (definition) to process all dies that define the members of the
2743 structure or union.
2744
2745 NOTE: we need to call struct_type regardless of whether or not the
2746 DIE has an at_name attribute, since it might be an anonymous
2747 structure or union. This gets the type entered into our set of
2748 user defined types.
2749
2750 However, if the structure is incomplete (an opaque struct/union)
2751 then suppress creating a symbol table entry for it since gdb only
2752 wants to find the one with the complete definition. Note that if
2753 it is complete, we just call new_symbol, which does it's own
2754 checking about whether the struct/union is anonymous or not (and
2755 suppresses creating a symbol table entry itself). */
2756
2757 static void
2758 read_structure_scope (struct die_info *die, struct objfile *objfile,
2759 const struct comp_unit_head *cu_header)
2760 {
2761 struct type *type;
2762 struct attribute *attr;
2763
2764 type = alloc_type (objfile);
2765
2766 INIT_CPLUS_SPECIFIC (type);
2767 attr = dwarf_attr (die, DW_AT_name);
2768 if (attr && DW_STRING (attr))
2769 {
2770 TYPE_TAG_NAME (type) = obsavestring (DW_STRING (attr),
2771 strlen (DW_STRING (attr)),
2772 &objfile->type_obstack);
2773 }
2774
2775 if (die->tag == DW_TAG_structure_type)
2776 {
2777 TYPE_CODE (type) = TYPE_CODE_STRUCT;
2778 }
2779 else if (die->tag == DW_TAG_union_type)
2780 {
2781 TYPE_CODE (type) = TYPE_CODE_UNION;
2782 }
2783 else
2784 {
2785 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT
2786 in gdbtypes.h. */
2787 TYPE_CODE (type) = TYPE_CODE_CLASS;
2788 }
2789
2790 attr = dwarf_attr (die, DW_AT_byte_size);
2791 if (attr)
2792 {
2793 TYPE_LENGTH (type) = DW_UNSND (attr);
2794 }
2795 else
2796 {
2797 TYPE_LENGTH (type) = 0;
2798 }
2799
2800 /* We need to add the type field to the die immediately so we don't
2801 infinitely recurse when dealing with pointers to the structure
2802 type within the structure itself. */
2803 die->type = type;
2804
2805 if (die->has_children && ! die_is_declaration (die))
2806 {
2807 struct field_info fi;
2808 struct die_info *child_die;
2809 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
2810
2811 memset (&fi, 0, sizeof (struct field_info));
2812
2813 child_die = die->next;
2814
2815 while (child_die && child_die->tag)
2816 {
2817 if (child_die->tag == DW_TAG_member
2818 || child_die->tag == DW_TAG_variable)
2819 {
2820 /* NOTE: carlton/2002-11-05: A C++ static data member
2821 should be a DW_TAG_member that is a declaration, but
2822 all versions of G++ as of this writing (so through at
2823 least 3.2.1) incorrectly generate DW_TAG_variable
2824 tags for them instead. */
2825 dwarf2_add_field (&fi, child_die, objfile, cu_header);
2826 }
2827 else if (child_die->tag == DW_TAG_subprogram)
2828 {
2829 /* C++ member function. */
2830 process_die (child_die, objfile, cu_header);
2831 dwarf2_add_member_fn (&fi, child_die, type, objfile, cu_header);
2832 }
2833 else if (child_die->tag == DW_TAG_inheritance)
2834 {
2835 /* C++ base class field. */
2836 dwarf2_add_field (&fi, child_die, objfile, cu_header);
2837 }
2838 else
2839 {
2840 process_die (child_die, objfile, cu_header);
2841 }
2842 child_die = sibling_die (child_die);
2843 }
2844
2845 /* Attach fields and member functions to the type. */
2846 if (fi.nfields)
2847 dwarf2_attach_fields_to_type (&fi, type, objfile);
2848 if (fi.nfnfields)
2849 {
2850 dwarf2_attach_fn_fields_to_type (&fi, type, objfile);
2851
2852 /* Get the type which refers to the base class (possibly this
2853 class itself) which contains the vtable pointer for the current
2854 class from the DW_AT_containing_type attribute. */
2855
2856 if (dwarf_attr (die, DW_AT_containing_type) != NULL)
2857 {
2858 struct type *t = die_containing_type (die, objfile, cu_header);
2859
2860 TYPE_VPTR_BASETYPE (type) = t;
2861 if (type == t)
2862 {
2863 static const char vptr_name[] =
2864 {'_', 'v', 'p', 't', 'r', '\0'};
2865 int i;
2866
2867 /* Our own class provides vtbl ptr. */
2868 for (i = TYPE_NFIELDS (t) - 1;
2869 i >= TYPE_N_BASECLASSES (t);
2870 --i)
2871 {
2872 char *fieldname = TYPE_FIELD_NAME (t, i);
2873
2874 if (STREQN (fieldname, vptr_name, strlen (vptr_name) - 1)
2875 && is_cplus_marker (fieldname[strlen (vptr_name)]))
2876 {
2877 TYPE_VPTR_FIELDNO (type) = i;
2878 break;
2879 }
2880 }
2881
2882 /* Complain if virtual function table field not found. */
2883 if (i < TYPE_N_BASECLASSES (t))
2884 complaint (&symfile_complaints,
2885 "virtual function table pointer not found when defining class '%s'",
2886 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) :
2887 "");
2888 }
2889 else
2890 {
2891 TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
2892 }
2893 }
2894 }
2895
2896 new_symbol (die, type, objfile, cu_header);
2897
2898 do_cleanups (back_to);
2899 }
2900 else
2901 {
2902 /* No children, must be stub. */
2903 TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
2904 }
2905 }
2906
2907 /* Given a pointer to a die which begins an enumeration, process all
2908 the dies that define the members of the enumeration.
2909
2910 This will be much nicer in draft 6 of the DWARF spec when our
2911 members will be dies instead squished into the DW_AT_element_list
2912 attribute.
2913
2914 NOTE: We reverse the order of the element list. */
2915
2916 static void
2917 read_enumeration (struct die_info *die, struct objfile *objfile,
2918 const struct comp_unit_head *cu_header)
2919 {
2920 struct die_info *child_die;
2921 struct type *type;
2922 struct field *fields;
2923 struct attribute *attr;
2924 struct symbol *sym;
2925 int num_fields;
2926 int unsigned_enum = 1;
2927
2928 type = alloc_type (objfile);
2929
2930 TYPE_CODE (type) = TYPE_CODE_ENUM;
2931 attr = dwarf_attr (die, DW_AT_name);
2932 if (attr && DW_STRING (attr))
2933 {
2934 TYPE_TAG_NAME (type) = obsavestring (DW_STRING (attr),
2935 strlen (DW_STRING (attr)),
2936 &objfile->type_obstack);
2937 }
2938
2939 attr = dwarf_attr (die, DW_AT_byte_size);
2940 if (attr)
2941 {
2942 TYPE_LENGTH (type) = DW_UNSND (attr);
2943 }
2944 else
2945 {
2946 TYPE_LENGTH (type) = 0;
2947 }
2948
2949 num_fields = 0;
2950 fields = NULL;
2951 if (die->has_children)
2952 {
2953 child_die = die->next;
2954 while (child_die && child_die->tag)
2955 {
2956 if (child_die->tag != DW_TAG_enumerator)
2957 {
2958 process_die (child_die, objfile, cu_header);
2959 }
2960 else
2961 {
2962 attr = dwarf_attr (child_die, DW_AT_name);
2963 if (attr)
2964 {
2965 sym = new_symbol (child_die, type, objfile, cu_header);
2966 if (SYMBOL_VALUE (sym) < 0)
2967 unsigned_enum = 0;
2968
2969 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
2970 {
2971 fields = (struct field *)
2972 xrealloc (fields,
2973 (num_fields + DW_FIELD_ALLOC_CHUNK)
2974 * sizeof (struct field));
2975 }
2976
2977 FIELD_NAME (fields[num_fields]) = DEPRECATED_SYMBOL_NAME (sym);
2978 FIELD_TYPE (fields[num_fields]) = NULL;
2979 FIELD_BITPOS (fields[num_fields]) = SYMBOL_VALUE (sym);
2980 FIELD_BITSIZE (fields[num_fields]) = 0;
2981 FIELD_STATIC_KIND (fields[num_fields]) = 0;
2982
2983 num_fields++;
2984 }
2985 }
2986
2987 child_die = sibling_die (child_die);
2988 }
2989
2990 if (num_fields)
2991 {
2992 TYPE_NFIELDS (type) = num_fields;
2993 TYPE_FIELDS (type) = (struct field *)
2994 TYPE_ALLOC (type, sizeof (struct field) * num_fields);
2995 memcpy (TYPE_FIELDS (type), fields,
2996 sizeof (struct field) * num_fields);
2997 xfree (fields);
2998 }
2999 if (unsigned_enum)
3000 TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
3001 }
3002 die->type = type;
3003 new_symbol (die, type, objfile, cu_header);
3004 }
3005
3006 /* Extract all information from a DW_TAG_array_type DIE and put it in
3007 the DIE's type field. For now, this only handles one dimensional
3008 arrays. */
3009
3010 static void
3011 read_array_type (struct die_info *die, struct objfile *objfile,
3012 const struct comp_unit_head *cu_header)
3013 {
3014 struct die_info *child_die;
3015 struct type *type = NULL;
3016 struct type *element_type, *range_type, *index_type;
3017 struct type **range_types = NULL;
3018 struct attribute *attr;
3019 int ndim = 0;
3020 struct cleanup *back_to;
3021
3022 /* Return if we've already decoded this type. */
3023 if (die->type)
3024 {
3025 return;
3026 }
3027
3028 element_type = die_type (die, objfile, cu_header);
3029
3030 /* Irix 6.2 native cc creates array types without children for
3031 arrays with unspecified length. */
3032 if (die->has_children == 0)
3033 {
3034 index_type = dwarf2_fundamental_type (objfile, FT_INTEGER);
3035 range_type = create_range_type (NULL, index_type, 0, -1);
3036 die->type = create_array_type (NULL, element_type, range_type);
3037 return;
3038 }
3039
3040 back_to = make_cleanup (null_cleanup, NULL);
3041 child_die = die->next;
3042 while (child_die && child_die->tag)
3043 {
3044 if (child_die->tag == DW_TAG_subrange_type)
3045 {
3046 unsigned int low, high;
3047
3048 /* Default bounds to an array with unspecified length. */
3049 low = 0;
3050 high = -1;
3051 if (cu_language == language_fortran)
3052 {
3053 /* FORTRAN implies a lower bound of 1, if not given. */
3054 low = 1;
3055 }
3056
3057 index_type = die_type (child_die, objfile, cu_header);
3058 attr = dwarf_attr (child_die, DW_AT_lower_bound);
3059 if (attr)
3060 {
3061 if (attr->form == DW_FORM_sdata)
3062 {
3063 low = DW_SND (attr);
3064 }
3065 else if (attr->form == DW_FORM_udata
3066 || attr->form == DW_FORM_data1
3067 || attr->form == DW_FORM_data2
3068 || attr->form == DW_FORM_data4
3069 || attr->form == DW_FORM_data8)
3070 {
3071 low = DW_UNSND (attr);
3072 }
3073 else
3074 {
3075 dwarf2_non_const_array_bound_ignored_complaint
3076 (dwarf_form_name (attr->form));
3077 #ifdef FORTRAN_HACK
3078 die->type = lookup_pointer_type (element_type);
3079 return;
3080 #else
3081 low = 0;
3082 #endif
3083 }
3084 }
3085 attr = dwarf_attr (child_die, DW_AT_upper_bound);
3086 if (attr)
3087 {
3088 if (attr->form == DW_FORM_sdata)
3089 {
3090 high = DW_SND (attr);
3091 }
3092 else if (attr->form == DW_FORM_udata
3093 || attr->form == DW_FORM_data1
3094 || attr->form == DW_FORM_data2
3095 || attr->form == DW_FORM_data4
3096 || attr->form == DW_FORM_data8)
3097 {
3098 high = DW_UNSND (attr);
3099 }
3100 else if (attr->form == DW_FORM_block1)
3101 {
3102 /* GCC encodes arrays with unspecified or dynamic length
3103 with a DW_FORM_block1 attribute.
3104 FIXME: GDB does not yet know how to handle dynamic
3105 arrays properly, treat them as arrays with unspecified
3106 length for now. */
3107 high = -1;
3108 }
3109 else
3110 {
3111 dwarf2_non_const_array_bound_ignored_complaint
3112 (dwarf_form_name (attr->form));
3113 #ifdef FORTRAN_HACK
3114 die->type = lookup_pointer_type (element_type);
3115 return;
3116 #else
3117 high = 1;
3118 #endif
3119 }
3120 }
3121
3122 /* Create a range type and save it for array type creation. */
3123 if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0)
3124 {
3125 range_types = (struct type **)
3126 xrealloc (range_types, (ndim + DW_FIELD_ALLOC_CHUNK)
3127 * sizeof (struct type *));
3128 if (ndim == 0)
3129 make_cleanup (free_current_contents, &range_types);
3130 }
3131 range_types[ndim++] = create_range_type (NULL, index_type, low, high);
3132 }
3133 child_die = sibling_die (child_die);
3134 }
3135
3136 /* Dwarf2 dimensions are output from left to right, create the
3137 necessary array types in backwards order. */
3138 type = element_type;
3139 while (ndim-- > 0)
3140 type = create_array_type (NULL, type, range_types[ndim]);
3141
3142 /* Understand Dwarf2 support for vector types (like they occur on
3143 the PowerPC w/ AltiVec). Gcc just adds another attribute to the
3144 array type. This is not part of the Dwarf2/3 standard yet, but a
3145 custom vendor extension. The main difference between a regular
3146 array and the vector variant is that vectors are passed by value
3147 to functions. */
3148 attr = dwarf_attr (die, DW_AT_GNU_vector);
3149 if (attr)
3150 TYPE_FLAGS (type) |= TYPE_FLAG_VECTOR;
3151
3152 do_cleanups (back_to);
3153
3154 /* Install the type in the die. */
3155 die->type = type;
3156 }
3157
3158 /* First cut: install each common block member as a global variable. */
3159
3160 static void
3161 read_common_block (struct die_info *die, struct objfile *objfile,
3162 const struct comp_unit_head *cu_header)
3163 {
3164 struct die_info *child_die;
3165 struct attribute *attr;
3166 struct symbol *sym;
3167 CORE_ADDR base = (CORE_ADDR) 0;
3168
3169 attr = dwarf_attr (die, DW_AT_location);
3170 if (attr)
3171 {
3172 /* Support the .debug_loc offsets */
3173 if (attr_form_is_block (attr))
3174 {
3175 base = decode_locdesc (DW_BLOCK (attr), objfile, cu_header);
3176 }
3177 else if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
3178 {
3179 dwarf2_complex_location_expr_complaint ();
3180 }
3181 else
3182 {
3183 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
3184 "common block member");
3185 }
3186 }
3187 if (die->has_children)
3188 {
3189 child_die = die->next;
3190 while (child_die && child_die->tag)
3191 {
3192 sym = new_symbol (child_die, NULL, objfile, cu_header);
3193 attr = dwarf_attr (child_die, DW_AT_data_member_location);
3194 if (attr)
3195 {
3196 SYMBOL_VALUE_ADDRESS (sym) =
3197 base + decode_locdesc (DW_BLOCK (attr), objfile, cu_header);
3198 add_symbol_to_list (sym, &global_symbols);
3199 }
3200 child_die = sibling_die (child_die);
3201 }
3202 }
3203 }
3204
3205 /* Read a C++ namespace. */
3206
3207 static void
3208 read_namespace (struct die_info *die, struct objfile *objfile,
3209 const struct comp_unit_head *cu_header)
3210 {
3211 const char *previous_namespace = processing_current_namespace;
3212 const char *name = NULL;
3213 int is_anonymous;
3214 struct die_info *current_die;
3215
3216 /* Loop through the extensions until we find a name. */
3217
3218 for (current_die = die;
3219 current_die != NULL;
3220 current_die = dwarf2_extension (die))
3221 {
3222 name = dwarf2_name (current_die);
3223 if (name != NULL)
3224 break;
3225 }
3226
3227 /* Is it an anonymous namespace? */
3228
3229 is_anonymous = (name == NULL);
3230 if (is_anonymous)
3231 name = "(anonymous namespace)";
3232
3233 /* Now build the name of the current namespace. */
3234
3235 if (previous_namespace[0] == '\0')
3236 {
3237 processing_current_namespace = name;
3238 }
3239 else
3240 {
3241 /* We need temp_name around because processing_current_namespace
3242 is a const char *. */
3243 char *temp_name = alloca (strlen (previous_namespace)
3244 + 2 + strlen(name) + 1);
3245 strcpy (temp_name, previous_namespace);
3246 strcat (temp_name, "::");
3247 strcat (temp_name, name);
3248
3249 processing_current_namespace = temp_name;
3250 }
3251
3252 /* If it's an anonymous namespace that we're seeing for the first
3253 time, add a using directive. */
3254
3255 if (is_anonymous && dwarf_attr (die, DW_AT_extension) == NULL)
3256 cp_add_using_directive (processing_current_namespace,
3257 strlen (previous_namespace),
3258 strlen (processing_current_namespace));
3259
3260 if (die->has_children)
3261 {
3262 struct die_info *child_die = die->next;
3263
3264 while (child_die && child_die->tag)
3265 {
3266 process_die (child_die, objfile, cu_header);
3267 child_die = sibling_die (child_die);
3268 }
3269 }
3270
3271 processing_current_namespace = previous_namespace;
3272 }
3273
3274 /* Extract all information from a DW_TAG_pointer_type DIE and add to
3275 the user defined type vector. */
3276
3277 static void
3278 read_tag_pointer_type (struct die_info *die, struct objfile *objfile,
3279 const struct comp_unit_head *cu_header)
3280 {
3281 struct type *type;
3282 struct attribute *attr_byte_size;
3283 struct attribute *attr_address_class;
3284 int byte_size, addr_class;
3285
3286 if (die->type)
3287 {
3288 return;
3289 }
3290
3291 type = lookup_pointer_type (die_type (die, objfile, cu_header));
3292
3293 attr_byte_size = dwarf_attr (die, DW_AT_byte_size);
3294 if (attr_byte_size)
3295 byte_size = DW_UNSND (attr_byte_size);
3296 else
3297 byte_size = cu_header->addr_size;
3298
3299 attr_address_class = dwarf_attr (die, DW_AT_address_class);
3300 if (attr_address_class)
3301 addr_class = DW_UNSND (attr_address_class);
3302 else
3303 addr_class = DW_ADDR_none;
3304
3305 /* If the pointer size or address class is different than the
3306 default, create a type variant marked as such and set the
3307 length accordingly. */
3308 if (TYPE_LENGTH (type) != byte_size || addr_class != DW_ADDR_none)
3309 {
3310 if (ADDRESS_CLASS_TYPE_FLAGS_P ())
3311 {
3312 int type_flags;
3313
3314 type_flags = ADDRESS_CLASS_TYPE_FLAGS (byte_size, addr_class);
3315 gdb_assert ((type_flags & ~TYPE_FLAG_ADDRESS_CLASS_ALL) == 0);
3316 type = make_type_with_address_space (type, type_flags);
3317 }
3318 else if (TYPE_LENGTH (type) != byte_size)
3319 {
3320 complaint (&symfile_complaints, "invalid pointer size %d", byte_size);
3321 }
3322 else {
3323 /* Should we also complain about unhandled address classes? */
3324 }
3325 }
3326
3327 TYPE_LENGTH (type) = byte_size;
3328 die->type = type;
3329 }
3330
3331 /* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to
3332 the user defined type vector. */
3333
3334 static void
3335 read_tag_ptr_to_member_type (struct die_info *die, struct objfile *objfile,
3336 const struct comp_unit_head *cu_header)
3337 {
3338 struct type *type;
3339 struct type *to_type;
3340 struct type *domain;
3341
3342 if (die->type)
3343 {
3344 return;
3345 }
3346
3347 type = alloc_type (objfile);
3348 to_type = die_type (die, objfile, cu_header);
3349 domain = die_containing_type (die, objfile, cu_header);
3350 smash_to_member_type (type, domain, to_type);
3351
3352 die->type = type;
3353 }
3354
3355 /* Extract all information from a DW_TAG_reference_type DIE and add to
3356 the user defined type vector. */
3357
3358 static void
3359 read_tag_reference_type (struct die_info *die, struct objfile *objfile,
3360 const struct comp_unit_head *cu_header)
3361 {
3362 struct type *type;
3363 struct attribute *attr;
3364
3365 if (die->type)
3366 {
3367 return;
3368 }
3369
3370 type = lookup_reference_type (die_type (die, objfile, cu_header));
3371 attr = dwarf_attr (die, DW_AT_byte_size);
3372 if (attr)
3373 {
3374 TYPE_LENGTH (type) = DW_UNSND (attr);
3375 }
3376 else
3377 {
3378 TYPE_LENGTH (type) = cu_header->addr_size;
3379 }
3380 die->type = type;
3381 }
3382
3383 static void
3384 read_tag_const_type (struct die_info *die, struct objfile *objfile,
3385 const struct comp_unit_head *cu_header)
3386 {
3387 struct type *base_type;
3388
3389 if (die->type)
3390 {
3391 return;
3392 }
3393
3394 base_type = die_type (die, objfile, cu_header);
3395 die->type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
3396 }
3397
3398 static void
3399 read_tag_volatile_type (struct die_info *die, struct objfile *objfile,
3400 const struct comp_unit_head *cu_header)
3401 {
3402 struct type *base_type;
3403
3404 if (die->type)
3405 {
3406 return;
3407 }
3408
3409 base_type = die_type (die, objfile, cu_header);
3410 die->type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
3411 }
3412
3413 /* Extract all information from a DW_TAG_string_type DIE and add to
3414 the user defined type vector. It isn't really a user defined type,
3415 but it behaves like one, with other DIE's using an AT_user_def_type
3416 attribute to reference it. */
3417
3418 static void
3419 read_tag_string_type (struct die_info *die, struct objfile *objfile)
3420 {
3421 struct type *type, *range_type, *index_type, *char_type;
3422 struct attribute *attr;
3423 unsigned int length;
3424
3425 if (die->type)
3426 {
3427 return;
3428 }
3429
3430 attr = dwarf_attr (die, DW_AT_string_length);
3431 if (attr)
3432 {
3433 length = DW_UNSND (attr);
3434 }
3435 else
3436 {
3437 /* check for the DW_AT_byte_size attribute */
3438 attr = dwarf_attr (die, DW_AT_byte_size);
3439 if (attr)
3440 {
3441 length = DW_UNSND (attr);
3442 }
3443 else
3444 {
3445 length = 1;
3446 }
3447 }
3448 index_type = dwarf2_fundamental_type (objfile, FT_INTEGER);
3449 range_type = create_range_type (NULL, index_type, 1, length);
3450 if (cu_language == language_fortran)
3451 {
3452 /* Need to create a unique string type for bounds
3453 information */
3454 type = create_string_type (0, range_type);
3455 }
3456 else
3457 {
3458 char_type = dwarf2_fundamental_type (objfile, FT_CHAR);
3459 type = create_string_type (char_type, range_type);
3460 }
3461 die->type = type;
3462 }
3463
3464 /* Handle DIES due to C code like:
3465
3466 struct foo
3467 {
3468 int (*funcp)(int a, long l);
3469 int b;
3470 };
3471
3472 ('funcp' generates a DW_TAG_subroutine_type DIE)
3473 */
3474
3475 static void
3476 read_subroutine_type (struct die_info *die, struct objfile *objfile,
3477 const struct comp_unit_head *cu_header)
3478 {
3479 struct type *type; /* Type that this function returns */
3480 struct type *ftype; /* Function that returns above type */
3481 struct attribute *attr;
3482
3483 /* Decode the type that this subroutine returns */
3484 if (die->type)
3485 {
3486 return;
3487 }
3488 type = die_type (die, objfile, cu_header);
3489 ftype = lookup_function_type (type);
3490
3491 /* All functions in C++ have prototypes. */
3492 attr = dwarf_attr (die, DW_AT_prototyped);
3493 if ((attr && (DW_UNSND (attr) != 0))
3494 || cu_language == language_cplus)
3495 TYPE_FLAGS (ftype) |= TYPE_FLAG_PROTOTYPED;
3496
3497 if (die->has_children)
3498 {
3499 struct die_info *child_die;
3500 int nparams = 0;
3501 int iparams = 0;
3502
3503 /* Count the number of parameters.
3504 FIXME: GDB currently ignores vararg functions, but knows about
3505 vararg member functions. */
3506 child_die = die->next;
3507 while (child_die && child_die->tag)
3508 {
3509 if (child_die->tag == DW_TAG_formal_parameter)
3510 nparams++;
3511 else if (child_die->tag == DW_TAG_unspecified_parameters)
3512 TYPE_FLAGS (ftype) |= TYPE_FLAG_VARARGS;
3513 child_die = sibling_die (child_die);
3514 }
3515
3516 /* Allocate storage for parameters and fill them in. */
3517 TYPE_NFIELDS (ftype) = nparams;
3518 TYPE_FIELDS (ftype) = (struct field *)
3519 TYPE_ALLOC (ftype, nparams * sizeof (struct field));
3520
3521 child_die = die->next;
3522 while (child_die && child_die->tag)
3523 {
3524 if (child_die->tag == DW_TAG_formal_parameter)
3525 {
3526 /* Dwarf2 has no clean way to discern C++ static and non-static
3527 member functions. G++ helps GDB by marking the first
3528 parameter for non-static member functions (which is the
3529 this pointer) as artificial. We pass this information
3530 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
3531 attr = dwarf_attr (child_die, DW_AT_artificial);
3532 if (attr)
3533 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
3534 else
3535 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
3536 TYPE_FIELD_TYPE (ftype, iparams) = die_type (child_die, objfile,
3537 cu_header);
3538 iparams++;
3539 }
3540 child_die = sibling_die (child_die);
3541 }
3542 }
3543
3544 die->type = ftype;
3545 }
3546
3547 static void
3548 read_typedef (struct die_info *die, struct objfile *objfile,
3549 const struct comp_unit_head *cu_header)
3550 {
3551 struct attribute *attr;
3552 char *name = NULL;
3553
3554 if (!die->type)
3555 {
3556 attr = dwarf_attr (die, DW_AT_name);
3557 if (attr && DW_STRING (attr))
3558 {
3559 name = DW_STRING (attr);
3560 }
3561 die->type = init_type (TYPE_CODE_TYPEDEF, 0, TYPE_FLAG_TARGET_STUB, name, objfile);
3562 TYPE_TARGET_TYPE (die->type) = die_type (die, objfile, cu_header);
3563 }
3564 }
3565
3566 /* Find a representation of a given base type and install
3567 it in the TYPE field of the die. */
3568
3569 static void
3570 read_base_type (struct die_info *die, struct objfile *objfile)
3571 {
3572 struct type *type;
3573 struct attribute *attr;
3574 int encoding = 0, size = 0;
3575
3576 /* If we've already decoded this die, this is a no-op. */
3577 if (die->type)
3578 {
3579 return;
3580 }
3581
3582 attr = dwarf_attr (die, DW_AT_encoding);
3583 if (attr)
3584 {
3585 encoding = DW_UNSND (attr);
3586 }
3587 attr = dwarf_attr (die, DW_AT_byte_size);
3588 if (attr)
3589 {
3590 size = DW_UNSND (attr);
3591 }
3592 attr = dwarf_attr (die, DW_AT_name);
3593 if (attr && DW_STRING (attr))
3594 {
3595 enum type_code code = TYPE_CODE_INT;
3596 int type_flags = 0;
3597
3598 switch (encoding)
3599 {
3600 case DW_ATE_address:
3601 /* Turn DW_ATE_address into a void * pointer. */
3602 code = TYPE_CODE_PTR;
3603 type_flags |= TYPE_FLAG_UNSIGNED;
3604 break;
3605 case DW_ATE_boolean:
3606 code = TYPE_CODE_BOOL;
3607 type_flags |= TYPE_FLAG_UNSIGNED;
3608 break;
3609 case DW_ATE_complex_float:
3610 code = TYPE_CODE_COMPLEX;
3611 break;
3612 case DW_ATE_float:
3613 code = TYPE_CODE_FLT;
3614 break;
3615 case DW_ATE_signed:
3616 case DW_ATE_signed_char:
3617 break;
3618 case DW_ATE_unsigned:
3619 case DW_ATE_unsigned_char:
3620 type_flags |= TYPE_FLAG_UNSIGNED;
3621 break;
3622 default:
3623 complaint (&symfile_complaints, "unsupported DW_AT_encoding: '%s'",
3624 dwarf_type_encoding_name (encoding));
3625 break;
3626 }
3627 type = init_type (code, size, type_flags, DW_STRING (attr), objfile);
3628 if (encoding == DW_ATE_address)
3629 TYPE_TARGET_TYPE (type) = dwarf2_fundamental_type (objfile, FT_VOID);
3630 else if (encoding == DW_ATE_complex_float)
3631 {
3632 if (size == 32)
3633 TYPE_TARGET_TYPE (type)
3634 = dwarf2_fundamental_type (objfile, FT_EXT_PREC_FLOAT);
3635 else if (size == 16)
3636 TYPE_TARGET_TYPE (type)
3637 = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT);
3638 else if (size == 8)
3639 TYPE_TARGET_TYPE (type)
3640 = dwarf2_fundamental_type (objfile, FT_FLOAT);
3641 }
3642 }
3643 else
3644 {
3645 type = dwarf_base_type (encoding, size, objfile);
3646 }
3647 die->type = type;
3648 }
3649
3650 /* Read a whole compilation unit into a linked list of dies. */
3651
3652 static struct die_info *
3653 read_comp_unit (char *info_ptr, bfd *abfd,
3654 const struct comp_unit_head *cu_header)
3655 {
3656 struct die_info *first_die, *last_die, *die;
3657 char *cur_ptr;
3658 int nesting_level;
3659
3660 /* Reset die reference table; we are
3661 building new ones now. */
3662 dwarf2_empty_hash_tables ();
3663
3664 cur_ptr = info_ptr;
3665 nesting_level = 0;
3666 first_die = last_die = NULL;
3667 do
3668 {
3669 cur_ptr = read_full_die (&die, abfd, cur_ptr, cu_header);
3670 if (die->has_children)
3671 {
3672 nesting_level++;
3673 }
3674 if (die->tag == 0)
3675 {
3676 nesting_level--;
3677 }
3678
3679 die->next = NULL;
3680
3681 /* Enter die in reference hash table */
3682 store_in_ref_table (die->offset, die);
3683
3684 if (!first_die)
3685 {
3686 first_die = last_die = die;
3687 }
3688 else
3689 {
3690 last_die->next = die;
3691 last_die = die;
3692 }
3693 }
3694 while (nesting_level > 0);
3695 return first_die;
3696 }
3697
3698 /* Free a linked list of dies. */
3699
3700 static void
3701 free_die_list (struct die_info *dies)
3702 {
3703 struct die_info *die, *next;
3704
3705 die = dies;
3706 while (die)
3707 {
3708 next = die->next;
3709 xfree (die->attrs);
3710 xfree (die);
3711 die = next;
3712 }
3713 }
3714
3715 static void
3716 do_free_die_list_cleanup (void *dies)
3717 {
3718 free_die_list (dies);
3719 }
3720
3721 static struct cleanup *
3722 make_cleanup_free_die_list (struct die_info *dies)
3723 {
3724 return make_cleanup (do_free_die_list_cleanup, dies);
3725 }
3726
3727
3728 /* Read the contents of the section at OFFSET and of size SIZE from the
3729 object file specified by OBJFILE into the psymbol_obstack and return it. */
3730
3731 char *
3732 dwarf2_read_section (struct objfile *objfile, file_ptr offset,
3733 unsigned int size, asection *sectp)
3734 {
3735 bfd *abfd = objfile->obfd;
3736 char *buf, *retbuf;
3737
3738 if (size == 0)
3739 return NULL;
3740
3741 buf = (char *) obstack_alloc (&objfile->psymbol_obstack, size);
3742 retbuf
3743 = (char *) symfile_relocate_debug_section (abfd, sectp, (bfd_byte *) buf);
3744 if (retbuf != NULL)
3745 return retbuf;
3746
3747 if ((bfd_seek (abfd, offset, SEEK_SET) != 0) ||
3748 (bfd_bread (buf, size, abfd) != size))
3749 {
3750 buf = NULL;
3751 error ("Dwarf Error: Can't read DWARF data from '%s'",
3752 bfd_get_filename (abfd));
3753 }
3754 return buf;
3755 }
3756
3757 /* In DWARF version 2, the description of the debugging information is
3758 stored in a separate .debug_abbrev section. Before we read any
3759 dies from a section we read in all abbreviations and install them
3760 in a hash table. */
3761
3762 static void
3763 dwarf2_read_abbrevs (bfd *abfd, struct comp_unit_head *cu_header)
3764 {
3765 char *abbrev_ptr;
3766 struct abbrev_info *cur_abbrev;
3767 unsigned int abbrev_number, bytes_read, abbrev_name;
3768 unsigned int abbrev_form, hash_number;
3769
3770 /* Initialize dwarf2 abbrevs */
3771 memset (cu_header->dwarf2_abbrevs, 0,
3772 ABBREV_HASH_SIZE*sizeof (struct abbrev_info *));
3773
3774 abbrev_ptr = dwarf_abbrev_buffer + cu_header->abbrev_offset;
3775 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
3776 abbrev_ptr += bytes_read;
3777
3778 /* loop until we reach an abbrev number of 0 */
3779 while (abbrev_number)
3780 {
3781 cur_abbrev = dwarf_alloc_abbrev ();
3782
3783 /* read in abbrev header */
3784 cur_abbrev->number = abbrev_number;
3785 cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
3786 abbrev_ptr += bytes_read;
3787 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
3788 abbrev_ptr += 1;
3789
3790 /* now read in declarations */
3791 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
3792 abbrev_ptr += bytes_read;
3793 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
3794 abbrev_ptr += bytes_read;
3795 while (abbrev_name)
3796 {
3797 if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
3798 {
3799 cur_abbrev->attrs = (struct attr_abbrev *)
3800 xrealloc (cur_abbrev->attrs,
3801 (cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK)
3802 * sizeof (struct attr_abbrev));
3803 }
3804 cur_abbrev->attrs[cur_abbrev->num_attrs].name = abbrev_name;
3805 cur_abbrev->attrs[cur_abbrev->num_attrs++].form = abbrev_form;
3806 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
3807 abbrev_ptr += bytes_read;
3808 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
3809 abbrev_ptr += bytes_read;
3810 }
3811
3812 hash_number = abbrev_number % ABBREV_HASH_SIZE;
3813 cur_abbrev->next = cu_header->dwarf2_abbrevs[hash_number];
3814 cu_header->dwarf2_abbrevs[hash_number] = cur_abbrev;
3815
3816 /* Get next abbreviation.
3817 Under Irix6 the abbreviations for a compilation unit are not
3818 always properly terminated with an abbrev number of 0.
3819 Exit loop if we encounter an abbreviation which we have
3820 already read (which means we are about to read the abbreviations
3821 for the next compile unit) or if the end of the abbreviation
3822 table is reached. */
3823 if ((unsigned int) (abbrev_ptr - dwarf_abbrev_buffer)
3824 >= dwarf_abbrev_size)
3825 break;
3826 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
3827 abbrev_ptr += bytes_read;
3828 if (dwarf2_lookup_abbrev (abbrev_number, cu_header) != NULL)
3829 break;
3830 }
3831 }
3832
3833 /* Empty the abbrev table for a new compilation unit. */
3834
3835 /* ARGSUSED */
3836 static void
3837 dwarf2_empty_abbrev_table (void *ptr_to_abbrevs_table)
3838 {
3839 int i;
3840 struct abbrev_info *abbrev, *next;
3841 struct abbrev_info **abbrevs;
3842
3843 abbrevs = (struct abbrev_info **)ptr_to_abbrevs_table;
3844
3845 for (i = 0; i < ABBREV_HASH_SIZE; ++i)
3846 {
3847 next = NULL;
3848 abbrev = abbrevs[i];
3849 while (abbrev)
3850 {
3851 next = abbrev->next;
3852 xfree (abbrev->attrs);
3853 xfree (abbrev);
3854 abbrev = next;
3855 }
3856 abbrevs[i] = NULL;
3857 }
3858 }
3859
3860 /* Lookup an abbrev_info structure in the abbrev hash table. */
3861
3862 static struct abbrev_info *
3863 dwarf2_lookup_abbrev (unsigned int number, const struct comp_unit_head *cu_header)
3864 {
3865 unsigned int hash_number;
3866 struct abbrev_info *abbrev;
3867
3868 hash_number = number % ABBREV_HASH_SIZE;
3869 abbrev = cu_header->dwarf2_abbrevs[hash_number];
3870
3871 while (abbrev)
3872 {
3873 if (abbrev->number == number)
3874 return abbrev;
3875 else
3876 abbrev = abbrev->next;
3877 }
3878 return NULL;
3879 }
3880
3881 /* Read a minimal amount of information into the minimal die structure. */
3882
3883 static char *
3884 read_partial_die (struct partial_die_info *part_die, bfd *abfd,
3885 char *info_ptr, const struct comp_unit_head *cu_header)
3886 {
3887 unsigned int abbrev_number, bytes_read, i;
3888 struct abbrev_info *abbrev;
3889 struct attribute attr;
3890 struct attribute spec_attr;
3891 int found_spec_attr = 0;
3892 int has_low_pc_attr = 0;
3893 int has_high_pc_attr = 0;
3894
3895 *part_die = zeroed_partial_die;
3896 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
3897 info_ptr += bytes_read;
3898 if (!abbrev_number)
3899 return info_ptr;
3900
3901 abbrev = dwarf2_lookup_abbrev (abbrev_number, cu_header);
3902 if (!abbrev)
3903 {
3904 error ("Dwarf Error: Could not find abbrev number %d [in module %s]", abbrev_number,
3905 bfd_get_filename (abfd));
3906 }
3907 part_die->offset = info_ptr - dwarf_info_buffer;
3908 part_die->tag = abbrev->tag;
3909 part_die->has_children = abbrev->has_children;
3910 part_die->abbrev = abbrev_number;
3911
3912 for (i = 0; i < abbrev->num_attrs; ++i)
3913 {
3914 info_ptr = read_attribute (&attr, &abbrev->attrs[i], abfd,
3915 info_ptr, cu_header);
3916
3917 /* Store the data if it is of an attribute we want to keep in a
3918 partial symbol table. */
3919 switch (attr.name)
3920 {
3921 case DW_AT_name:
3922
3923 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
3924 if (part_die->name == NULL)
3925 part_die->name = DW_STRING (&attr);
3926 break;
3927 case DW_AT_MIPS_linkage_name:
3928 part_die->name = DW_STRING (&attr);
3929 break;
3930 case DW_AT_low_pc:
3931 has_low_pc_attr = 1;
3932 part_die->lowpc = DW_ADDR (&attr);
3933 break;
3934 case DW_AT_high_pc:
3935 has_high_pc_attr = 1;
3936 part_die->highpc = DW_ADDR (&attr);
3937 break;
3938 case DW_AT_location:
3939 /* Support the .debug_loc offsets */
3940 if (attr_form_is_block (&attr))
3941 {
3942 part_die->locdesc = DW_BLOCK (&attr);
3943 }
3944 else if (attr.form == DW_FORM_data4 || attr.form == DW_FORM_data8)
3945 {
3946 dwarf2_complex_location_expr_complaint ();
3947 }
3948 else
3949 {
3950 dwarf2_invalid_attrib_class_complaint ("DW_AT_location",
3951 "partial symbol information");
3952 }
3953 break;
3954 case DW_AT_language:
3955 part_die->language = DW_UNSND (&attr);
3956 break;
3957 case DW_AT_external:
3958 part_die->is_external = DW_UNSND (&attr);
3959 break;
3960 case DW_AT_declaration:
3961 part_die->is_declaration = DW_UNSND (&attr);
3962 break;
3963 case DW_AT_type:
3964 part_die->has_type = 1;
3965 break;
3966 case DW_AT_abstract_origin:
3967 case DW_AT_specification:
3968 found_spec_attr = 1;
3969 spec_attr = attr;
3970 break;
3971 case DW_AT_sibling:
3972 /* Ignore absolute siblings, they might point outside of
3973 the current compile unit. */
3974 if (attr.form == DW_FORM_ref_addr)
3975 complaint (&symfile_complaints, "ignoring absolute DW_AT_sibling");
3976 else
3977 part_die->sibling =
3978 dwarf_info_buffer + dwarf2_get_ref_die_offset (&attr);
3979 break;
3980 default:
3981 break;
3982 }
3983 }
3984
3985 /* If we found a reference attribute and the die has no name, try
3986 to find a name in the referred to die. */
3987
3988 if (found_spec_attr && part_die->name == NULL)
3989 {
3990 struct partial_die_info spec_die;
3991 char *spec_ptr;
3992 int dummy;
3993
3994 spec_ptr = dwarf_info_buffer + dwarf2_get_ref_die_offset (&spec_attr);
3995 read_partial_die (&spec_die, abfd, spec_ptr, cu_header);
3996 if (spec_die.name)
3997 {
3998 part_die->name = spec_die.name;
3999
4000 /* Copy DW_AT_external attribute if it is set. */
4001 if (spec_die.is_external)
4002 part_die->is_external = spec_die.is_external;
4003 }
4004 }
4005
4006 /* When using the GNU linker, .gnu.linkonce. sections are used to
4007 eliminate duplicate copies of functions and vtables and such.
4008 The linker will arbitrarily choose one and discard the others.
4009 The AT_*_pc values for such functions refer to local labels in
4010 these sections. If the section from that file was discarded, the
4011 labels are not in the output, so the relocs get a value of 0.
4012 If this is a discarded function, mark the pc bounds as invalid,
4013 so that GDB will ignore it. */
4014 if (has_low_pc_attr && has_high_pc_attr
4015 && part_die->lowpc < part_die->highpc
4016 && (part_die->lowpc != 0
4017 || (bfd_get_file_flags (abfd) & HAS_RELOC)))
4018 part_die->has_pc_info = 1;
4019 return info_ptr;
4020 }
4021
4022 /* Read the die from the .debug_info section buffer. And set diep to
4023 point to a newly allocated die with its information. */
4024
4025 static char *
4026 read_full_die (struct die_info **diep, bfd *abfd, char *info_ptr,
4027 const struct comp_unit_head *cu_header)
4028 {
4029 unsigned int abbrev_number, bytes_read, i, offset;
4030 struct abbrev_info *abbrev;
4031 struct die_info *die;
4032
4033 offset = info_ptr - dwarf_info_buffer;
4034 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
4035 info_ptr += bytes_read;
4036 if (!abbrev_number)
4037 {
4038 die = dwarf_alloc_die ();
4039 die->tag = 0;
4040 die->abbrev = abbrev_number;
4041 die->type = NULL;
4042 *diep = die;
4043 return info_ptr;
4044 }
4045
4046 abbrev = dwarf2_lookup_abbrev (abbrev_number, cu_header);
4047 if (!abbrev)
4048 {
4049 error ("Dwarf Error: could not find abbrev number %d [in module %s]", abbrev_number,
4050 bfd_get_filename (abfd));
4051 }
4052 die = dwarf_alloc_die ();
4053 die->offset = offset;
4054 die->tag = abbrev->tag;
4055 die->has_children = abbrev->has_children;
4056 die->abbrev = abbrev_number;
4057 die->type = NULL;
4058
4059 die->num_attrs = abbrev->num_attrs;
4060 die->attrs = (struct attribute *)
4061 xmalloc (die->num_attrs * sizeof (struct attribute));
4062
4063 for (i = 0; i < abbrev->num_attrs; ++i)
4064 {
4065 info_ptr = read_attribute (&die->attrs[i], &abbrev->attrs[i],
4066 abfd, info_ptr, cu_header);
4067 }
4068
4069 *diep = die;
4070 return info_ptr;
4071 }
4072
4073 /* Read an attribute value described by an attribute form. */
4074
4075 static char *
4076 read_attribute_value (struct attribute *attr, unsigned form,
4077 bfd *abfd, char *info_ptr,
4078 const struct comp_unit_head *cu_header)
4079 {
4080 unsigned int bytes_read;
4081 struct dwarf_block *blk;
4082
4083 attr->form = form;
4084 switch (form)
4085 {
4086 case DW_FORM_addr:
4087 case DW_FORM_ref_addr:
4088 DW_ADDR (attr) = read_address (abfd, info_ptr, cu_header, &bytes_read);
4089 info_ptr += bytes_read;
4090 break;
4091 case DW_FORM_block2:
4092 blk = dwarf_alloc_block ();
4093 blk->size = read_2_bytes (abfd, info_ptr);
4094 info_ptr += 2;
4095 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
4096 info_ptr += blk->size;
4097 DW_BLOCK (attr) = blk;
4098 break;
4099 case DW_FORM_block4:
4100 blk = dwarf_alloc_block ();
4101 blk->size = read_4_bytes (abfd, info_ptr);
4102 info_ptr += 4;
4103 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
4104 info_ptr += blk->size;
4105 DW_BLOCK (attr) = blk;
4106 break;
4107 case DW_FORM_data2:
4108 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
4109 info_ptr += 2;
4110 break;
4111 case DW_FORM_data4:
4112 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
4113 info_ptr += 4;
4114 break;
4115 case DW_FORM_data8:
4116 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
4117 info_ptr += 8;
4118 break;
4119 case DW_FORM_string:
4120 DW_STRING (attr) = read_string (abfd, info_ptr, &bytes_read);
4121 info_ptr += bytes_read;
4122 break;
4123 case DW_FORM_strp:
4124 DW_STRING (attr) = read_indirect_string (abfd, info_ptr, cu_header,
4125 &bytes_read);
4126 info_ptr += bytes_read;
4127 break;
4128 case DW_FORM_block:
4129 blk = dwarf_alloc_block ();
4130 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
4131 info_ptr += bytes_read;
4132 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
4133 info_ptr += blk->size;
4134 DW_BLOCK (attr) = blk;
4135 break;
4136 case DW_FORM_block1:
4137 blk = dwarf_alloc_block ();
4138 blk->size = read_1_byte (abfd, info_ptr);
4139 info_ptr += 1;
4140 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
4141 info_ptr += blk->size;
4142 DW_BLOCK (attr) = blk;
4143 break;
4144 case DW_FORM_data1:
4145 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
4146 info_ptr += 1;
4147 break;
4148 case DW_FORM_flag:
4149 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
4150 info_ptr += 1;
4151 break;
4152 case DW_FORM_sdata:
4153 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
4154 info_ptr += bytes_read;
4155 break;
4156 case DW_FORM_udata:
4157 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
4158 info_ptr += bytes_read;
4159 break;
4160 case DW_FORM_ref1:
4161 DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
4162 info_ptr += 1;
4163 break;
4164 case DW_FORM_ref2:
4165 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
4166 info_ptr += 2;
4167 break;
4168 case DW_FORM_ref4:
4169 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
4170 info_ptr += 4;
4171 break;
4172 case DW_FORM_ref8:
4173 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
4174 info_ptr += 8;
4175 break;
4176 case DW_FORM_ref_udata:
4177 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
4178 info_ptr += bytes_read;
4179 break;
4180 case DW_FORM_indirect:
4181 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
4182 info_ptr += bytes_read;
4183 info_ptr = read_attribute_value (attr, form, abfd, info_ptr, cu_header);
4184 break;
4185 default:
4186 error ("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]",
4187 dwarf_form_name (form),
4188 bfd_get_filename (abfd));
4189 }
4190 return info_ptr;
4191 }
4192
4193 /* Read an attribute described by an abbreviated attribute. */
4194
4195 static char *
4196 read_attribute (struct attribute *attr, struct attr_abbrev *abbrev,
4197 bfd *abfd, char *info_ptr,
4198 const struct comp_unit_head *cu_header)
4199 {
4200 attr->name = abbrev->name;
4201 return read_attribute_value (attr, abbrev->form, abfd, info_ptr, cu_header);
4202 }
4203
4204 /* read dwarf information from a buffer */
4205
4206 static unsigned int
4207 read_1_byte (bfd *abfd, char *buf)
4208 {
4209 return bfd_get_8 (abfd, (bfd_byte *) buf);
4210 }
4211
4212 static int
4213 read_1_signed_byte (bfd *abfd, char *buf)
4214 {
4215 return bfd_get_signed_8 (abfd, (bfd_byte *) buf);
4216 }
4217
4218 static unsigned int
4219 read_2_bytes (bfd *abfd, char *buf)
4220 {
4221 return bfd_get_16 (abfd, (bfd_byte *) buf);
4222 }
4223
4224 static int
4225 read_2_signed_bytes (bfd *abfd, char *buf)
4226 {
4227 return bfd_get_signed_16 (abfd, (bfd_byte *) buf);
4228 }
4229
4230 static unsigned int
4231 read_4_bytes (bfd *abfd, char *buf)
4232 {
4233 return bfd_get_32 (abfd, (bfd_byte *) buf);
4234 }
4235
4236 static int
4237 read_4_signed_bytes (bfd *abfd, char *buf)
4238 {
4239 return bfd_get_signed_32 (abfd, (bfd_byte *) buf);
4240 }
4241
4242 static unsigned long
4243 read_8_bytes (bfd *abfd, char *buf)
4244 {
4245 return bfd_get_64 (abfd, (bfd_byte *) buf);
4246 }
4247
4248 static CORE_ADDR
4249 read_address (bfd *abfd, char *buf, const struct comp_unit_head *cu_header,
4250 int *bytes_read)
4251 {
4252 CORE_ADDR retval = 0;
4253
4254 if (cu_header->signed_addr_p)
4255 {
4256 switch (cu_header->addr_size)
4257 {
4258 case 2:
4259 retval = bfd_get_signed_16 (abfd, (bfd_byte *) buf);
4260 break;
4261 case 4:
4262 retval = bfd_get_signed_32 (abfd, (bfd_byte *) buf);
4263 break;
4264 case 8:
4265 retval = bfd_get_signed_64 (abfd, (bfd_byte *) buf);
4266 break;
4267 default:
4268 internal_error (__FILE__, __LINE__,
4269 "read_address: bad switch, signed [in module %s]",
4270 bfd_get_filename (abfd));
4271 }
4272 }
4273 else
4274 {
4275 switch (cu_header->addr_size)
4276 {
4277 case 2:
4278 retval = bfd_get_16 (abfd, (bfd_byte *) buf);
4279 break;
4280 case 4:
4281 retval = bfd_get_32 (abfd, (bfd_byte *) buf);
4282 break;
4283 case 8:
4284 retval = bfd_get_64 (abfd, (bfd_byte *) buf);
4285 break;
4286 default:
4287 internal_error (__FILE__, __LINE__,
4288 "read_address: bad switch, unsigned [in module %s]",
4289 bfd_get_filename (abfd));
4290 }
4291 }
4292
4293 *bytes_read = cu_header->addr_size;
4294 return retval;
4295 }
4296
4297 /* Read the initial length from a section. The (draft) DWARF 3
4298 specification allows the initial length to take up either 4 bytes
4299 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8
4300 bytes describe the length and all offsets will be 8 bytes in length
4301 instead of 4.
4302
4303 An older, non-standard 64-bit format is also handled by this
4304 function. The older format in question stores the initial length
4305 as an 8-byte quantity without an escape value. Lengths greater
4306 than 2^32 aren't very common which means that the initial 4 bytes
4307 is almost always zero. Since a length value of zero doesn't make
4308 sense for the 32-bit format, this initial zero can be considered to
4309 be an escape value which indicates the presence of the older 64-bit
4310 format. As written, the code can't detect (old format) lengths
4311 greater than 4GB. If it becomes necessary to handle lengths somewhat
4312 larger than 4GB, we could allow other small values (such as the
4313 non-sensical values of 1, 2, and 3) to also be used as escape values
4314 indicating the presence of the old format.
4315
4316 The value returned via bytes_read should be used to increment
4317 the relevant pointer after calling read_initial_length().
4318
4319 As a side effect, this function sets the fields initial_length_size
4320 and offset_size in cu_header to the values appropriate for the
4321 length field. (The format of the initial length field determines
4322 the width of file offsets to be fetched later with fetch_offset().)
4323
4324 [ Note: read_initial_length() and read_offset() are based on the
4325 document entitled "DWARF Debugging Information Format", revision
4326 3, draft 8, dated November 19, 2001. This document was obtained
4327 from:
4328
4329 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf
4330
4331 This document is only a draft and is subject to change. (So beware.)
4332
4333 Details regarding the older, non-standard 64-bit format were
4334 determined empirically by examining 64-bit ELF files produced
4335 by the SGI toolchain on an IRIX 6.5 machine.
4336
4337 - Kevin, July 16, 2002
4338 ] */
4339
4340 static LONGEST
4341 read_initial_length (bfd *abfd, char *buf, struct comp_unit_head *cu_header,
4342 int *bytes_read)
4343 {
4344 LONGEST retval = 0;
4345
4346 retval = bfd_get_32 (abfd, (bfd_byte *) buf);
4347
4348 if (retval == 0xffffffff)
4349 {
4350 retval = bfd_get_64 (abfd, (bfd_byte *) buf + 4);
4351 *bytes_read = 12;
4352 if (cu_header != NULL)
4353 {
4354 cu_header->initial_length_size = 12;
4355 cu_header->offset_size = 8;
4356 }
4357 }
4358 else if (retval == 0)
4359 {
4360 /* Handle (non-standard) 64-bit DWARF2 formats such as that used
4361 by IRIX. */
4362 retval = bfd_get_64 (abfd, (bfd_byte *) buf);
4363 *bytes_read = 8;
4364 if (cu_header != NULL)
4365 {
4366 cu_header->initial_length_size = 8;
4367 cu_header->offset_size = 8;
4368 }
4369 }
4370 else
4371 {
4372 *bytes_read = 4;
4373 if (cu_header != NULL)
4374 {
4375 cu_header->initial_length_size = 4;
4376 cu_header->offset_size = 4;
4377 }
4378 }
4379
4380 return retval;
4381 }
4382
4383 /* Read an offset from the data stream. The size of the offset is
4384 given by cu_header->offset_size. */
4385
4386 static LONGEST
4387 read_offset (bfd *abfd, char *buf, const struct comp_unit_head *cu_header,
4388 int *bytes_read)
4389 {
4390 LONGEST retval = 0;
4391
4392 switch (cu_header->offset_size)
4393 {
4394 case 4:
4395 retval = bfd_get_32 (abfd, (bfd_byte *) buf);
4396 *bytes_read = 4;
4397 break;
4398 case 8:
4399 retval = bfd_get_64 (abfd, (bfd_byte *) buf);
4400 *bytes_read = 8;
4401 break;
4402 default:
4403 internal_error (__FILE__, __LINE__,
4404 "read_offset: bad switch [in module %s]",
4405 bfd_get_filename (abfd));
4406 }
4407
4408 return retval;
4409 }
4410
4411 static char *
4412 read_n_bytes (bfd *abfd, char *buf, unsigned int size)
4413 {
4414 /* If the size of a host char is 8 bits, we can return a pointer
4415 to the buffer, otherwise we have to copy the data to a buffer
4416 allocated on the temporary obstack. */
4417 gdb_assert (HOST_CHAR_BIT == 8);
4418 return buf;
4419 }
4420
4421 static char *
4422 read_string (bfd *abfd, char *buf, unsigned int *bytes_read_ptr)
4423 {
4424 /* If the size of a host char is 8 bits, we can return a pointer
4425 to the string, otherwise we have to copy the string to a buffer
4426 allocated on the temporary obstack. */
4427 gdb_assert (HOST_CHAR_BIT == 8);
4428 if (*buf == '\0')
4429 {
4430 *bytes_read_ptr = 1;
4431 return NULL;
4432 }
4433 *bytes_read_ptr = strlen (buf) + 1;
4434 return buf;
4435 }
4436
4437 static char *
4438 read_indirect_string (bfd *abfd, char *buf,
4439 const struct comp_unit_head *cu_header,
4440 unsigned int *bytes_read_ptr)
4441 {
4442 LONGEST str_offset = read_offset (abfd, buf, cu_header,
4443 (int *) bytes_read_ptr);
4444
4445 if (dwarf_str_buffer == NULL)
4446 {
4447 error ("DW_FORM_strp used without .debug_str section [in module %s]",
4448 bfd_get_filename (abfd));
4449 return NULL;
4450 }
4451 if (str_offset >= dwarf_str_size)
4452 {
4453 error ("DW_FORM_strp pointing outside of .debug_str section [in module %s]",
4454 bfd_get_filename (abfd));
4455 return NULL;
4456 }
4457 gdb_assert (HOST_CHAR_BIT == 8);
4458 if (dwarf_str_buffer[str_offset] == '\0')
4459 return NULL;
4460 return dwarf_str_buffer + str_offset;
4461 }
4462
4463 static unsigned long
4464 read_unsigned_leb128 (bfd *abfd, char *buf, unsigned int *bytes_read_ptr)
4465 {
4466 unsigned long result;
4467 unsigned int num_read;
4468 int i, shift;
4469 unsigned char byte;
4470
4471 result = 0;
4472 shift = 0;
4473 num_read = 0;
4474 i = 0;
4475 while (1)
4476 {
4477 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
4478 buf++;
4479 num_read++;
4480 result |= ((unsigned long)(byte & 127) << shift);
4481 if ((byte & 128) == 0)
4482 {
4483 break;
4484 }
4485 shift += 7;
4486 }
4487 *bytes_read_ptr = num_read;
4488 return result;
4489 }
4490
4491 static long
4492 read_signed_leb128 (bfd *abfd, char *buf, unsigned int *bytes_read_ptr)
4493 {
4494 long result;
4495 int i, shift, size, num_read;
4496 unsigned char byte;
4497
4498 result = 0;
4499 shift = 0;
4500 size = 32;
4501 num_read = 0;
4502 i = 0;
4503 while (1)
4504 {
4505 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
4506 buf++;
4507 num_read++;
4508 result |= ((long)(byte & 127) << shift);
4509 shift += 7;
4510 if ((byte & 128) == 0)
4511 {
4512 break;
4513 }
4514 }
4515 if ((shift < size) && (byte & 0x40))
4516 {
4517 result |= -(1 << shift);
4518 }
4519 *bytes_read_ptr = num_read;
4520 return result;
4521 }
4522
4523 static void
4524 set_cu_language (unsigned int lang)
4525 {
4526 switch (lang)
4527 {
4528 case DW_LANG_C89:
4529 case DW_LANG_C:
4530 cu_language = language_c;
4531 break;
4532 case DW_LANG_C_plus_plus:
4533 cu_language = language_cplus;
4534 break;
4535 case DW_LANG_Fortran77:
4536 case DW_LANG_Fortran90:
4537 case DW_LANG_Fortran95:
4538 cu_language = language_fortran;
4539 break;
4540 case DW_LANG_Mips_Assembler:
4541 cu_language = language_asm;
4542 break;
4543 case DW_LANG_Java:
4544 cu_language = language_java;
4545 break;
4546 case DW_LANG_Ada83:
4547 case DW_LANG_Ada95:
4548 case DW_LANG_Cobol74:
4549 case DW_LANG_Cobol85:
4550 case DW_LANG_Pascal83:
4551 case DW_LANG_Modula2:
4552 default:
4553 cu_language = language_minimal;
4554 break;
4555 }
4556 cu_language_defn = language_def (cu_language);
4557 }
4558
4559 /* Return the named attribute or NULL if not there. */
4560
4561 static struct attribute *
4562 dwarf_attr (struct die_info *die, unsigned int name)
4563 {
4564 unsigned int i;
4565 struct attribute *spec = NULL;
4566
4567 for (i = 0; i < die->num_attrs; ++i)
4568 {
4569 if (die->attrs[i].name == name)
4570 {
4571 return &die->attrs[i];
4572 }
4573 if (die->attrs[i].name == DW_AT_specification
4574 || die->attrs[i].name == DW_AT_abstract_origin)
4575 spec = &die->attrs[i];
4576 }
4577 if (spec)
4578 {
4579 struct die_info *ref_die =
4580 follow_die_ref (dwarf2_get_ref_die_offset (spec));
4581
4582 if (ref_die)
4583 return dwarf_attr (ref_die, name);
4584 }
4585
4586 return NULL;
4587 }
4588
4589 static int
4590 die_is_declaration (struct die_info *die)
4591 {
4592 return (dwarf_attr (die, DW_AT_declaration)
4593 && ! dwarf_attr (die, DW_AT_specification));
4594 }
4595
4596
4597 /* Free the line_header structure *LH, and any arrays and strings it
4598 refers to. */
4599 static void
4600 free_line_header (struct line_header *lh)
4601 {
4602 if (lh->standard_opcode_lengths)
4603 xfree (lh->standard_opcode_lengths);
4604
4605 /* Remember that all the lh->file_names[i].name pointers are
4606 pointers into debug_line_buffer, and don't need to be freed. */
4607 if (lh->file_names)
4608 xfree (lh->file_names);
4609
4610 /* Similarly for the include directory names. */
4611 if (lh->include_dirs)
4612 xfree (lh->include_dirs);
4613
4614 xfree (lh);
4615 }
4616
4617
4618 /* Add an entry to LH's include directory table. */
4619 static void
4620 add_include_dir (struct line_header *lh, char *include_dir)
4621 {
4622 /* Grow the array if necessary. */
4623 if (lh->include_dirs_size == 0)
4624 {
4625 lh->include_dirs_size = 1; /* for testing */
4626 lh->include_dirs = xmalloc (lh->include_dirs_size
4627 * sizeof (*lh->include_dirs));
4628 }
4629 else if (lh->num_include_dirs >= lh->include_dirs_size)
4630 {
4631 lh->include_dirs_size *= 2;
4632 lh->include_dirs = xrealloc (lh->include_dirs,
4633 (lh->include_dirs_size
4634 * sizeof (*lh->include_dirs)));
4635 }
4636
4637 lh->include_dirs[lh->num_include_dirs++] = include_dir;
4638 }
4639
4640
4641 /* Add an entry to LH's file name table. */
4642 static void
4643 add_file_name (struct line_header *lh,
4644 char *name,
4645 unsigned int dir_index,
4646 unsigned int mod_time,
4647 unsigned int length)
4648 {
4649 struct file_entry *fe;
4650
4651 /* Grow the array if necessary. */
4652 if (lh->file_names_size == 0)
4653 {
4654 lh->file_names_size = 1; /* for testing */
4655 lh->file_names = xmalloc (lh->file_names_size
4656 * sizeof (*lh->file_names));
4657 }
4658 else if (lh->num_file_names >= lh->file_names_size)
4659 {
4660 lh->file_names_size *= 2;
4661 lh->file_names = xrealloc (lh->file_names,
4662 (lh->file_names_size
4663 * sizeof (*lh->file_names)));
4664 }
4665
4666 fe = &lh->file_names[lh->num_file_names++];
4667 fe->name = name;
4668 fe->dir_index = dir_index;
4669 fe->mod_time = mod_time;
4670 fe->length = length;
4671 }
4672
4673
4674 /* Read the statement program header starting at OFFSET in
4675 dwarf_line_buffer, according to the endianness of ABFD. Return a
4676 pointer to a struct line_header, allocated using xmalloc.
4677
4678 NOTE: the strings in the include directory and file name tables of
4679 the returned object point into debug_line_buffer, and must not be
4680 freed. */
4681 static struct line_header *
4682 dwarf_decode_line_header (unsigned int offset, bfd *abfd,
4683 const struct comp_unit_head *cu_header)
4684 {
4685 struct cleanup *back_to;
4686 struct line_header *lh;
4687 char *line_ptr;
4688 int bytes_read;
4689 int i;
4690 char *cur_dir, *cur_file;
4691
4692 if (dwarf_line_buffer == NULL)
4693 {
4694 complaint (&symfile_complaints, "missing .debug_line section");
4695 return 0;
4696 }
4697
4698 /* Make sure that at least there's room for the total_length field. That
4699 could be 12 bytes long, but we're just going to fudge that. */
4700 if (offset + 4 >= dwarf_line_size)
4701 {
4702 dwarf2_statement_list_fits_in_line_number_section_complaint ();
4703 return 0;
4704 }
4705
4706 lh = xmalloc (sizeof (*lh));
4707 memset (lh, 0, sizeof (*lh));
4708 back_to = make_cleanup ((make_cleanup_ftype *) free_line_header,
4709 (void *) lh);
4710
4711 line_ptr = dwarf_line_buffer + offset;
4712
4713 /* read in the header */
4714 lh->total_length = read_initial_length (abfd, line_ptr, NULL, &bytes_read);
4715 line_ptr += bytes_read;
4716 if (line_ptr + lh->total_length > dwarf_line_buffer + dwarf_line_size)
4717 {
4718 dwarf2_statement_list_fits_in_line_number_section_complaint ();
4719 return 0;
4720 }
4721 lh->statement_program_end = line_ptr + lh->total_length;
4722 lh->version = read_2_bytes (abfd, line_ptr);
4723 line_ptr += 2;
4724 lh->header_length = read_offset (abfd, line_ptr, cu_header, &bytes_read);
4725 line_ptr += bytes_read;
4726 lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
4727 line_ptr += 1;
4728 lh->default_is_stmt = read_1_byte (abfd, line_ptr);
4729 line_ptr += 1;
4730 lh->line_base = read_1_signed_byte (abfd, line_ptr);
4731 line_ptr += 1;
4732 lh->line_range = read_1_byte (abfd, line_ptr);
4733 line_ptr += 1;
4734 lh->opcode_base = read_1_byte (abfd, line_ptr);
4735 line_ptr += 1;
4736 lh->standard_opcode_lengths
4737 = (unsigned char *) xmalloc (lh->opcode_base * sizeof (unsigned char));
4738
4739 lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
4740 for (i = 1; i < lh->opcode_base; ++i)
4741 {
4742 lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
4743 line_ptr += 1;
4744 }
4745
4746 /* Read directory table */
4747 while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
4748 {
4749 line_ptr += bytes_read;
4750 add_include_dir (lh, cur_dir);
4751 }
4752 line_ptr += bytes_read;
4753
4754 /* Read file name table */
4755 while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
4756 {
4757 unsigned int dir_index, mod_time, length;
4758
4759 line_ptr += bytes_read;
4760 dir_index = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
4761 line_ptr += bytes_read;
4762 mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
4763 line_ptr += bytes_read;
4764 length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
4765 line_ptr += bytes_read;
4766
4767 add_file_name (lh, cur_file, dir_index, mod_time, length);
4768 }
4769 line_ptr += bytes_read;
4770 lh->statement_program_start = line_ptr;
4771
4772 if (line_ptr > dwarf_line_buffer + dwarf_line_size)
4773 complaint (&symfile_complaints,
4774 "line number info header doesn't fit in `.debug_line' section");
4775
4776 discard_cleanups (back_to);
4777 return lh;
4778 }
4779
4780 /* This function exists to work around a bug in certain compilers
4781 (particularly GCC 2.95), in which the first line number marker of a
4782 function does not show up until after the prologue, right before
4783 the second line number marker. This function shifts ADDRESS down
4784 to the beginning of the function if necessary, and is called on
4785 addresses passed to record_line. */
4786
4787 static CORE_ADDR
4788 check_cu_functions (CORE_ADDR address)
4789 {
4790 struct function_range *fn;
4791
4792 /* Find the function_range containing address. */
4793 if (!cu_first_fn)
4794 return address;
4795
4796 if (!cu_cached_fn)
4797 cu_cached_fn = cu_first_fn;
4798
4799 fn = cu_cached_fn;
4800 while (fn)
4801 if (fn->lowpc <= address && fn->highpc > address)
4802 goto found;
4803 else
4804 fn = fn->next;
4805
4806 fn = cu_first_fn;
4807 while (fn && fn != cu_cached_fn)
4808 if (fn->lowpc <= address && fn->highpc > address)
4809 goto found;
4810 else
4811 fn = fn->next;
4812
4813 return address;
4814
4815 found:
4816 if (fn->seen_line)
4817 return address;
4818 if (address != fn->lowpc)
4819 complaint (&symfile_complaints,
4820 "misplaced first line number at 0x%lx for '%s'",
4821 (unsigned long) address, fn->name);
4822 fn->seen_line = 1;
4823 return fn->lowpc;
4824 }
4825
4826 /* Decode the line number information for the compilation unit whose
4827 line number info is at OFFSET in the .debug_line section.
4828 The compilation directory of the file is passed in COMP_DIR. */
4829
4830 static void
4831 dwarf_decode_lines (struct line_header *lh, char *comp_dir, bfd *abfd,
4832 const struct comp_unit_head *cu_header)
4833 {
4834 char *line_ptr;
4835 char *line_end;
4836 unsigned int i, bytes_read;
4837 char *cur_dir;
4838 unsigned char op_code, extended_op, adj_opcode;
4839
4840 line_ptr = lh->statement_program_start;
4841 line_end = lh->statement_program_end;
4842
4843 /* Read the statement sequences until there's nothing left. */
4844 while (line_ptr < line_end)
4845 {
4846 /* state machine registers */
4847 CORE_ADDR address = 0;
4848 unsigned int file = 1;
4849 unsigned int line = 1;
4850 unsigned int column = 0;
4851 int is_stmt = lh->default_is_stmt;
4852 int basic_block = 0;
4853 int end_sequence = 0;
4854
4855 /* Start a subfile for the current file of the state machine. */
4856 if (lh->num_file_names >= file)
4857 {
4858 /* lh->include_dirs and lh->file_names are 0-based, but the
4859 directory and file name numbers in the statement program
4860 are 1-based. */
4861 struct file_entry *fe = &lh->file_names[file - 1];
4862 char *dir;
4863 if (fe->dir_index)
4864 dir = lh->include_dirs[fe->dir_index - 1];
4865 else
4866 dir = comp_dir;
4867 dwarf2_start_subfile (fe->name, dir);
4868 }
4869
4870 /* Decode the table. */
4871 while (!end_sequence)
4872 {
4873 op_code = read_1_byte (abfd, line_ptr);
4874 line_ptr += 1;
4875
4876 if (op_code >= lh->opcode_base)
4877 { /* Special operand. */
4878 adj_opcode = op_code - lh->opcode_base;
4879 address += (adj_opcode / lh->line_range)
4880 * lh->minimum_instruction_length;
4881 line += lh->line_base + (adj_opcode % lh->line_range);
4882 /* append row to matrix using current values */
4883 record_line (current_subfile, line,
4884 check_cu_functions (address));
4885 basic_block = 1;
4886 }
4887 else switch (op_code)
4888 {
4889 case DW_LNS_extended_op:
4890 line_ptr += 1; /* ignore length */
4891 extended_op = read_1_byte (abfd, line_ptr);
4892 line_ptr += 1;
4893 switch (extended_op)
4894 {
4895 case DW_LNE_end_sequence:
4896 end_sequence = 1;
4897 record_line (current_subfile, 0, address);
4898 break;
4899 case DW_LNE_set_address:
4900 address = read_address (abfd, line_ptr, cu_header, &bytes_read);
4901 line_ptr += bytes_read;
4902 address += baseaddr;
4903 break;
4904 case DW_LNE_define_file:
4905 {
4906 char *cur_file;
4907 unsigned int dir_index, mod_time, length;
4908
4909 cur_file = read_string (abfd, line_ptr, &bytes_read);
4910 line_ptr += bytes_read;
4911 dir_index =
4912 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
4913 line_ptr += bytes_read;
4914 mod_time =
4915 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
4916 line_ptr += bytes_read;
4917 length =
4918 read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
4919 line_ptr += bytes_read;
4920 add_file_name (lh, cur_file, dir_index, mod_time, length);
4921 }
4922 break;
4923 default:
4924 complaint (&symfile_complaints,
4925 "mangled .debug_line section");
4926 return;
4927 }
4928 break;
4929 case DW_LNS_copy:
4930 record_line (current_subfile, line,
4931 check_cu_functions (address));
4932 basic_block = 0;
4933 break;
4934 case DW_LNS_advance_pc:
4935 address += lh->minimum_instruction_length
4936 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
4937 line_ptr += bytes_read;
4938 break;
4939 case DW_LNS_advance_line:
4940 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
4941 line_ptr += bytes_read;
4942 break;
4943 case DW_LNS_set_file:
4944 {
4945 /* lh->include_dirs and lh->file_names are 0-based,
4946 but the directory and file name numbers in the
4947 statement program are 1-based. */
4948 struct file_entry *fe;
4949 char *dir;
4950 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
4951 line_ptr += bytes_read;
4952 fe = &lh->file_names[file - 1];
4953 if (fe->dir_index)
4954 dir = lh->include_dirs[fe->dir_index - 1];
4955 else
4956 dir = comp_dir;
4957 dwarf2_start_subfile (fe->name, dir);
4958 }
4959 break;
4960 case DW_LNS_set_column:
4961 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
4962 line_ptr += bytes_read;
4963 break;
4964 case DW_LNS_negate_stmt:
4965 is_stmt = (!is_stmt);
4966 break;
4967 case DW_LNS_set_basic_block:
4968 basic_block = 1;
4969 break;
4970 /* Add to the address register of the state machine the
4971 address increment value corresponding to special opcode
4972 255. Ie, this value is scaled by the minimum instruction
4973 length since special opcode 255 would have scaled the
4974 the increment. */
4975 case DW_LNS_const_add_pc:
4976 address += (lh->minimum_instruction_length
4977 * ((255 - lh->opcode_base) / lh->line_range));
4978 break;
4979 case DW_LNS_fixed_advance_pc:
4980 address += read_2_bytes (abfd, line_ptr);
4981 line_ptr += 2;
4982 break;
4983 default:
4984 { /* Unknown standard opcode, ignore it. */
4985 int i;
4986 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++)
4987 {
4988 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
4989 line_ptr += bytes_read;
4990 }
4991 }
4992 }
4993 }
4994 }
4995 }
4996
4997 /* Start a subfile for DWARF. FILENAME is the name of the file and
4998 DIRNAME the name of the source directory which contains FILENAME
4999 or NULL if not known.
5000 This routine tries to keep line numbers from identical absolute and
5001 relative file names in a common subfile.
5002
5003 Using the `list' example from the GDB testsuite, which resides in
5004 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename
5005 of /srcdir/list0.c yields the following debugging information for list0.c:
5006
5007 DW_AT_name: /srcdir/list0.c
5008 DW_AT_comp_dir: /compdir
5009 files.files[0].name: list0.h
5010 files.files[0].dir: /srcdir
5011 files.files[1].name: list0.c
5012 files.files[1].dir: /srcdir
5013
5014 The line number information for list0.c has to end up in a single
5015 subfile, so that `break /srcdir/list0.c:1' works as expected. */
5016
5017 static void
5018 dwarf2_start_subfile (char *filename, char *dirname)
5019 {
5020 /* If the filename isn't absolute, try to match an existing subfile
5021 with the full pathname. */
5022
5023 if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL)
5024 {
5025 struct subfile *subfile;
5026 char *fullname = concat (dirname, "/", filename, NULL);
5027
5028 for (subfile = subfiles; subfile; subfile = subfile->next)
5029 {
5030 if (FILENAME_CMP (subfile->name, fullname) == 0)
5031 {
5032 current_subfile = subfile;
5033 xfree (fullname);
5034 return;
5035 }
5036 }
5037 xfree (fullname);
5038 }
5039 start_subfile (filename, dirname);
5040 }
5041
5042 static void
5043 var_decode_location (struct attribute *attr, struct symbol *sym,
5044 struct objfile *objfile,
5045 const struct comp_unit_head *cu_header)
5046 {
5047 /* NOTE drow/2003-01-30: There used to be a comment and some special
5048 code here to turn a symbol with DW_AT_external and a
5049 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was
5050 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux
5051 with some versions of binutils) where shared libraries could have
5052 relocations against symbols in their debug information - the
5053 minimal symbol would have the right address, but the debug info
5054 would not. It's no longer necessary, because we will explicitly
5055 apply relocations when we read in the debug information now. */
5056
5057 /* A DW_AT_location attribute with no contents indicates that a
5058 variable has been optimized away. */
5059 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0)
5060 {
5061 SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
5062 return;
5063 }
5064
5065 /* Handle one degenerate form of location expression specially, to
5066 preserve GDB's previous behavior when section offsets are
5067 specified. If this is just a DW_OP_addr then mark this symbol
5068 as LOC_STATIC. */
5069
5070 if (attr_form_is_block (attr)
5071 && DW_BLOCK (attr)->size == 1 + cu_header->addr_size
5072 && DW_BLOCK (attr)->data[0] == DW_OP_addr)
5073 {
5074 int dummy;
5075
5076 SYMBOL_VALUE_ADDRESS (sym) =
5077 read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu_header,
5078 &dummy);
5079 fixup_symbol_section (sym, objfile);
5080 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
5081 SYMBOL_SECTION (sym));
5082 SYMBOL_CLASS (sym) = LOC_STATIC;
5083 return;
5084 }
5085
5086 /* NOTE drow/2002-01-30: It might be worthwhile to have a static
5087 expression evaluator, and use LOC_COMPUTED only when necessary
5088 (i.e. when the value of a register or memory location is
5089 referenced, or a thread-local block, etc.). Then again, it might
5090 not be worthwhile. I'm assuming that it isn't unless performance
5091 or memory numbers show me otherwise. */
5092
5093 dwarf2_symbol_mark_computed (attr, sym, cu_header, objfile);
5094 SYMBOL_CLASS (sym) = LOC_COMPUTED;
5095 }
5096
5097 /* Given a pointer to a DWARF information entry, figure out if we need
5098 to make a symbol table entry for it, and if so, create a new entry
5099 and return a pointer to it.
5100 If TYPE is NULL, determine symbol type from the die, otherwise
5101 used the passed type. */
5102
5103 static struct symbol *
5104 new_symbol (struct die_info *die, struct type *type, struct objfile *objfile,
5105 const struct comp_unit_head *cu_header)
5106 {
5107 struct symbol *sym = NULL;
5108 char *name;
5109 struct attribute *attr = NULL;
5110 struct attribute *attr2 = NULL;
5111 CORE_ADDR addr = 0;
5112
5113 name = dwarf2_linkage_name (die);
5114 if (name)
5115 {
5116 sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
5117 sizeof (struct symbol));
5118 OBJSTAT (objfile, n_syms++);
5119 memset (sym, 0, sizeof (struct symbol));
5120
5121 /* Cache this symbol's name and the name's demangled form (if any). */
5122 SYMBOL_LANGUAGE (sym) = cu_language;
5123 SYMBOL_SET_NAMES (sym, name, strlen (name), objfile);
5124
5125 /* Default assumptions.
5126 Use the passed type or decode it from the die. */
5127 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
5128 SYMBOL_CLASS (sym) = LOC_STATIC;
5129 if (type != NULL)
5130 SYMBOL_TYPE (sym) = type;
5131 else
5132 SYMBOL_TYPE (sym) = die_type (die, objfile, cu_header);
5133 attr = dwarf_attr (die, DW_AT_decl_line);
5134 if (attr)
5135 {
5136 SYMBOL_LINE (sym) = DW_UNSND (attr);
5137 }
5138 switch (die->tag)
5139 {
5140 case DW_TAG_label:
5141 attr = dwarf_attr (die, DW_AT_low_pc);
5142 if (attr)
5143 {
5144 SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr) + baseaddr;
5145 }
5146 SYMBOL_CLASS (sym) = LOC_LABEL;
5147 break;
5148 case DW_TAG_subprogram:
5149 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
5150 finish_block. */
5151 SYMBOL_CLASS (sym) = LOC_BLOCK;
5152 attr2 = dwarf_attr (die, DW_AT_external);
5153 if (attr2 && (DW_UNSND (attr2) != 0))
5154 {
5155 add_symbol_to_list (sym, &global_symbols);
5156 }
5157 else
5158 {
5159 add_symbol_to_list (sym, list_in_scope);
5160 }
5161 break;
5162 case DW_TAG_variable:
5163 /* Compilation with minimal debug info may result in variables
5164 with missing type entries. Change the misleading `void' type
5165 to something sensible. */
5166 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
5167 SYMBOL_TYPE (sym) = init_type (TYPE_CODE_INT,
5168 TARGET_INT_BIT / HOST_CHAR_BIT, 0,
5169 "<variable, no debug info>",
5170 objfile);
5171 attr = dwarf_attr (die, DW_AT_const_value);
5172 if (attr)
5173 {
5174 dwarf2_const_value (attr, sym, objfile, cu_header);
5175 attr2 = dwarf_attr (die, DW_AT_external);
5176 if (attr2 && (DW_UNSND (attr2) != 0))
5177 add_symbol_to_list (sym, &global_symbols);
5178 else
5179 add_symbol_to_list (sym, list_in_scope);
5180 break;
5181 }
5182 attr = dwarf_attr (die, DW_AT_location);
5183 if (attr)
5184 {
5185 var_decode_location (attr, sym, objfile, cu_header);
5186 attr2 = dwarf_attr (die, DW_AT_external);
5187 if (attr2 && (DW_UNSND (attr2) != 0))
5188 add_symbol_to_list (sym, &global_symbols);
5189 else
5190 add_symbol_to_list (sym, list_in_scope);
5191 }
5192 else
5193 {
5194 /* We do not know the address of this symbol.
5195 If it is an external symbol and we have type information
5196 for it, enter the symbol as a LOC_UNRESOLVED symbol.
5197 The address of the variable will then be determined from
5198 the minimal symbol table whenever the variable is
5199 referenced. */
5200 attr2 = dwarf_attr (die, DW_AT_external);
5201 if (attr2 && (DW_UNSND (attr2) != 0)
5202 && dwarf_attr (die, DW_AT_type) != NULL)
5203 {
5204 SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
5205 add_symbol_to_list (sym, &global_symbols);
5206 }
5207 }
5208 break;
5209 case DW_TAG_formal_parameter:
5210 attr = dwarf_attr (die, DW_AT_location);
5211 if (attr)
5212 {
5213 SYMBOL_VALUE (sym) =
5214 decode_locdesc (DW_BLOCK (attr), objfile, cu_header);
5215 if (isreg)
5216 {
5217 SYMBOL_CLASS (sym) = LOC_REGPARM;
5218 SYMBOL_VALUE (sym) =
5219 DWARF2_REG_TO_REGNUM (SYMBOL_VALUE (sym));
5220 }
5221 else if (offreg)
5222 {
5223 if (isderef)
5224 {
5225 if (basereg != frame_base_reg)
5226 dwarf2_complex_location_expr_complaint ();
5227 SYMBOL_CLASS (sym) = LOC_REF_ARG;
5228 }
5229 else
5230 {
5231 SYMBOL_CLASS (sym) = LOC_BASEREG_ARG;
5232 SYMBOL_BASEREG (sym) = DWARF2_REG_TO_REGNUM (basereg);
5233 }
5234 }
5235 else
5236 {
5237 SYMBOL_CLASS (sym) = LOC_ARG;
5238 }
5239 }
5240 attr = dwarf_attr (die, DW_AT_const_value);
5241 if (attr)
5242 {
5243 dwarf2_const_value (attr, sym, objfile, cu_header);
5244 }
5245 add_symbol_to_list (sym, list_in_scope);
5246 break;
5247 case DW_TAG_unspecified_parameters:
5248 /* From varargs functions; gdb doesn't seem to have any
5249 interest in this information, so just ignore it for now.
5250 (FIXME?) */
5251 break;
5252 case DW_TAG_class_type:
5253 case DW_TAG_structure_type:
5254 case DW_TAG_union_type:
5255 case DW_TAG_enumeration_type:
5256 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
5257 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
5258 add_symbol_to_list (sym, list_in_scope);
5259
5260 /* The semantics of C++ state that "struct foo { ... }" also
5261 defines a typedef for "foo". Synthesize a typedef symbol so
5262 that "ptype foo" works as expected. */
5263 if (cu_language == language_cplus)
5264 {
5265 struct symbol *typedef_sym = (struct symbol *)
5266 obstack_alloc (&objfile->symbol_obstack,
5267 sizeof (struct symbol));
5268 *typedef_sym = *sym;
5269 SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN;
5270 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
5271 TYPE_NAME (SYMBOL_TYPE (sym)) =
5272 obsavestring (DEPRECATED_SYMBOL_NAME (sym),
5273 strlen (DEPRECATED_SYMBOL_NAME (sym)),
5274 &objfile->type_obstack);
5275 add_symbol_to_list (typedef_sym, list_in_scope);
5276 }
5277 break;
5278 case DW_TAG_typedef:
5279 case DW_TAG_base_type:
5280 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
5281 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
5282 add_symbol_to_list (sym, list_in_scope);
5283 break;
5284 case DW_TAG_enumerator:
5285 attr = dwarf_attr (die, DW_AT_const_value);
5286 if (attr)
5287 {
5288 dwarf2_const_value (attr, sym, objfile, cu_header);
5289 }
5290 add_symbol_to_list (sym, list_in_scope);
5291 break;
5292 default:
5293 /* Not a tag we recognize. Hopefully we aren't processing
5294 trash data, but since we must specifically ignore things
5295 we don't recognize, there is nothing else we should do at
5296 this point. */
5297 complaint (&symfile_complaints, "unsupported tag: '%s'",
5298 dwarf_tag_name (die->tag));
5299 break;
5300 }
5301 }
5302 return (sym);
5303 }
5304
5305 /* Copy constant value from an attribute to a symbol. */
5306
5307 static void
5308 dwarf2_const_value (struct attribute *attr, struct symbol *sym,
5309 struct objfile *objfile,
5310 const struct comp_unit_head *cu_header)
5311 {
5312 struct dwarf_block *blk;
5313
5314 switch (attr->form)
5315 {
5316 case DW_FORM_addr:
5317 if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != cu_header->addr_size)
5318 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym),
5319 cu_header->addr_size,
5320 TYPE_LENGTH (SYMBOL_TYPE
5321 (sym)));
5322 SYMBOL_VALUE_BYTES (sym) = (char *)
5323 obstack_alloc (&objfile->symbol_obstack, cu_header->addr_size);
5324 /* NOTE: cagney/2003-05-09: In-lined store_address call with
5325 it's body - store_unsigned_integer. */
5326 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym), cu_header->addr_size,
5327 DW_ADDR (attr));
5328 SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
5329 break;
5330 case DW_FORM_block1:
5331 case DW_FORM_block2:
5332 case DW_FORM_block4:
5333 case DW_FORM_block:
5334 blk = DW_BLOCK (attr);
5335 if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != blk->size)
5336 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym),
5337 blk->size,
5338 TYPE_LENGTH (SYMBOL_TYPE
5339 (sym)));
5340 SYMBOL_VALUE_BYTES (sym) = (char *)
5341 obstack_alloc (&objfile->symbol_obstack, blk->size);
5342 memcpy (SYMBOL_VALUE_BYTES (sym), blk->data, blk->size);
5343 SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
5344 break;
5345
5346 /* The DW_AT_const_value attributes are supposed to carry the
5347 symbol's value "represented as it would be on the target
5348 architecture." By the time we get here, it's already been
5349 converted to host endianness, so we just need to sign- or
5350 zero-extend it as appropriate. */
5351 case DW_FORM_data1:
5352 dwarf2_const_value_data (attr, sym, 8);
5353 break;
5354 case DW_FORM_data2:
5355 dwarf2_const_value_data (attr, sym, 16);
5356 break;
5357 case DW_FORM_data4:
5358 dwarf2_const_value_data (attr, sym, 32);
5359 break;
5360 case DW_FORM_data8:
5361 dwarf2_const_value_data (attr, sym, 64);
5362 break;
5363
5364 case DW_FORM_sdata:
5365 SYMBOL_VALUE (sym) = DW_SND (attr);
5366 SYMBOL_CLASS (sym) = LOC_CONST;
5367 break;
5368
5369 case DW_FORM_udata:
5370 SYMBOL_VALUE (sym) = DW_UNSND (attr);
5371 SYMBOL_CLASS (sym) = LOC_CONST;
5372 break;
5373
5374 default:
5375 complaint (&symfile_complaints,
5376 "unsupported const value attribute form: '%s'",
5377 dwarf_form_name (attr->form));
5378 SYMBOL_VALUE (sym) = 0;
5379 SYMBOL_CLASS (sym) = LOC_CONST;
5380 break;
5381 }
5382 }
5383
5384
5385 /* Given an attr with a DW_FORM_dataN value in host byte order, sign-
5386 or zero-extend it as appropriate for the symbol's type. */
5387 static void
5388 dwarf2_const_value_data (struct attribute *attr,
5389 struct symbol *sym,
5390 int bits)
5391 {
5392 LONGEST l = DW_UNSND (attr);
5393
5394 if (bits < sizeof (l) * 8)
5395 {
5396 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym)))
5397 l &= ((LONGEST) 1 << bits) - 1;
5398 else
5399 l = (l << (sizeof (l) * 8 - bits)) >> (sizeof (l) * 8 - bits);
5400 }
5401
5402 SYMBOL_VALUE (sym) = l;
5403 SYMBOL_CLASS (sym) = LOC_CONST;
5404 }
5405
5406
5407 /* Return the type of the die in question using its DW_AT_type attribute. */
5408
5409 static struct type *
5410 die_type (struct die_info *die, struct objfile *objfile,
5411 const struct comp_unit_head *cu_header)
5412 {
5413 struct type *type;
5414 struct attribute *type_attr;
5415 struct die_info *type_die;
5416 unsigned int ref;
5417
5418 type_attr = dwarf_attr (die, DW_AT_type);
5419 if (!type_attr)
5420 {
5421 /* A missing DW_AT_type represents a void type. */
5422 return dwarf2_fundamental_type (objfile, FT_VOID);
5423 }
5424 else
5425 {
5426 ref = dwarf2_get_ref_die_offset (type_attr);
5427 type_die = follow_die_ref (ref);
5428 if (!type_die)
5429 {
5430 error ("Dwarf Error: Cannot find referent at offset %d [in module %s]",
5431 ref, objfile->name);
5432 return NULL;
5433 }
5434 }
5435 type = tag_type_to_type (type_die, objfile, cu_header);
5436 if (!type)
5437 {
5438 dump_die (type_die);
5439 error ("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]",
5440 objfile->name);
5441 }
5442 return type;
5443 }
5444
5445 /* Return the containing type of the die in question using its
5446 DW_AT_containing_type attribute. */
5447
5448 static struct type *
5449 die_containing_type (struct die_info *die, struct objfile *objfile,
5450 const struct comp_unit_head *cu_header)
5451 {
5452 struct type *type = NULL;
5453 struct attribute *type_attr;
5454 struct die_info *type_die = NULL;
5455 unsigned int ref;
5456
5457 type_attr = dwarf_attr (die, DW_AT_containing_type);
5458 if (type_attr)
5459 {
5460 ref = dwarf2_get_ref_die_offset (type_attr);
5461 type_die = follow_die_ref (ref);
5462 if (!type_die)
5463 {
5464 error ("Dwarf Error: Cannot find referent at offset %d [in module %s]", ref,
5465 objfile->name);
5466 return NULL;
5467 }
5468 type = tag_type_to_type (type_die, objfile, cu_header);
5469 }
5470 if (!type)
5471 {
5472 if (type_die)
5473 dump_die (type_die);
5474 error ("Dwarf Error: Problem turning containing type into gdb type [in module %s]",
5475 objfile->name);
5476 }
5477 return type;
5478 }
5479
5480 #if 0
5481 static struct type *
5482 type_at_offset (unsigned int offset, struct objfile *objfile)
5483 {
5484 struct die_info *die;
5485 struct type *type;
5486
5487 die = follow_die_ref (offset);
5488 if (!die)
5489 {
5490 error ("Dwarf Error: Cannot find type referent at offset %d.", offset);
5491 return NULL;
5492 }
5493 type = tag_type_to_type (die, objfile);
5494 return type;
5495 }
5496 #endif
5497
5498 static struct type *
5499 tag_type_to_type (struct die_info *die, struct objfile *objfile,
5500 const struct comp_unit_head *cu_header)
5501 {
5502 if (die->type)
5503 {
5504 return die->type;
5505 }
5506 else
5507 {
5508 read_type_die (die, objfile, cu_header);
5509 if (!die->type)
5510 {
5511 dump_die (die);
5512 error ("Dwarf Error: Cannot find type of die [in module %s]",
5513 objfile->name);
5514 }
5515 return die->type;
5516 }
5517 }
5518
5519 static void
5520 read_type_die (struct die_info *die, struct objfile *objfile,
5521 const struct comp_unit_head *cu_header)
5522 {
5523 switch (die->tag)
5524 {
5525 case DW_TAG_class_type:
5526 case DW_TAG_structure_type:
5527 case DW_TAG_union_type:
5528 read_structure_scope (die, objfile, cu_header);
5529 break;
5530 case DW_TAG_enumeration_type:
5531 read_enumeration (die, objfile, cu_header);
5532 break;
5533 case DW_TAG_subprogram:
5534 case DW_TAG_subroutine_type:
5535 read_subroutine_type (die, objfile, cu_header);
5536 break;
5537 case DW_TAG_array_type:
5538 read_array_type (die, objfile, cu_header);
5539 break;
5540 case DW_TAG_pointer_type:
5541 read_tag_pointer_type (die, objfile, cu_header);
5542 break;
5543 case DW_TAG_ptr_to_member_type:
5544 read_tag_ptr_to_member_type (die, objfile, cu_header);
5545 break;
5546 case DW_TAG_reference_type:
5547 read_tag_reference_type (die, objfile, cu_header);
5548 break;
5549 case DW_TAG_const_type:
5550 read_tag_const_type (die, objfile, cu_header);
5551 break;
5552 case DW_TAG_volatile_type:
5553 read_tag_volatile_type (die, objfile, cu_header);
5554 break;
5555 case DW_TAG_string_type:
5556 read_tag_string_type (die, objfile);
5557 break;
5558 case DW_TAG_typedef:
5559 read_typedef (die, objfile, cu_header);
5560 break;
5561 case DW_TAG_base_type:
5562 read_base_type (die, objfile);
5563 break;
5564 default:
5565 complaint (&symfile_complaints, "unexepected tag in read_type_die: '%s'",
5566 dwarf_tag_name (die->tag));
5567 break;
5568 }
5569 }
5570
5571 static struct type *
5572 dwarf_base_type (int encoding, int size, struct objfile *objfile)
5573 {
5574 /* FIXME - this should not produce a new (struct type *)
5575 every time. It should cache base types. */
5576 struct type *type;
5577 switch (encoding)
5578 {
5579 case DW_ATE_address:
5580 type = dwarf2_fundamental_type (objfile, FT_VOID);
5581 return type;
5582 case DW_ATE_boolean:
5583 type = dwarf2_fundamental_type (objfile, FT_BOOLEAN);
5584 return type;
5585 case DW_ATE_complex_float:
5586 if (size == 16)
5587 {
5588 type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_COMPLEX);
5589 }
5590 else
5591 {
5592 type = dwarf2_fundamental_type (objfile, FT_COMPLEX);
5593 }
5594 return type;
5595 case DW_ATE_float:
5596 if (size == 8)
5597 {
5598 type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT);
5599 }
5600 else
5601 {
5602 type = dwarf2_fundamental_type (objfile, FT_FLOAT);
5603 }
5604 return type;
5605 case DW_ATE_signed:
5606 switch (size)
5607 {
5608 case 1:
5609 type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR);
5610 break;
5611 case 2:
5612 type = dwarf2_fundamental_type (objfile, FT_SIGNED_SHORT);
5613 break;
5614 default:
5615 case 4:
5616 type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER);
5617 break;
5618 }
5619 return type;
5620 case DW_ATE_signed_char:
5621 type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR);
5622 return type;
5623 case DW_ATE_unsigned:
5624 switch (size)
5625 {
5626 case 1:
5627 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR);
5628 break;
5629 case 2:
5630 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_SHORT);
5631 break;
5632 default:
5633 case 4:
5634 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_INTEGER);
5635 break;
5636 }
5637 return type;
5638 case DW_ATE_unsigned_char:
5639 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR);
5640 return type;
5641 default:
5642 type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER);
5643 return type;
5644 }
5645 }
5646
5647 #if 0
5648 struct die_info *
5649 copy_die (struct die_info *old_die)
5650 {
5651 struct die_info *new_die;
5652 int i, num_attrs;
5653
5654 new_die = (struct die_info *) xmalloc (sizeof (struct die_info));
5655 memset (new_die, 0, sizeof (struct die_info));
5656
5657 new_die->tag = old_die->tag;
5658 new_die->has_children = old_die->has_children;
5659 new_die->abbrev = old_die->abbrev;
5660 new_die->offset = old_die->offset;
5661 new_die->type = NULL;
5662
5663 num_attrs = old_die->num_attrs;
5664 new_die->num_attrs = num_attrs;
5665 new_die->attrs = (struct attribute *)
5666 xmalloc (num_attrs * sizeof (struct attribute));
5667
5668 for (i = 0; i < old_die->num_attrs; ++i)
5669 {
5670 new_die->attrs[i].name = old_die->attrs[i].name;
5671 new_die->attrs[i].form = old_die->attrs[i].form;
5672 new_die->attrs[i].u.addr = old_die->attrs[i].u.addr;
5673 }
5674
5675 new_die->next = NULL;
5676 return new_die;
5677 }
5678 #endif
5679
5680 /* Return sibling of die, NULL if no sibling. */
5681
5682 static struct die_info *
5683 sibling_die (struct die_info *die)
5684 {
5685 int nesting_level = 0;
5686
5687 if (!die->has_children)
5688 {
5689 if (die->next && (die->next->tag == 0))
5690 {
5691 return NULL;
5692 }
5693 else
5694 {
5695 return die->next;
5696 }
5697 }
5698 else
5699 {
5700 do
5701 {
5702 if (die->has_children)
5703 {
5704 nesting_level++;
5705 }
5706 if (die->tag == 0)
5707 {
5708 nesting_level--;
5709 }
5710 die = die->next;
5711 }
5712 while (nesting_level);
5713 if (die && (die->tag == 0))
5714 {
5715 return NULL;
5716 }
5717 else
5718 {
5719 return die;
5720 }
5721 }
5722 }
5723
5724 /* Get linkage name of a die, return NULL if not found. */
5725
5726 static char *
5727 dwarf2_linkage_name (struct die_info *die)
5728 {
5729 struct attribute *attr;
5730
5731 attr = dwarf_attr (die, DW_AT_MIPS_linkage_name);
5732 if (attr && DW_STRING (attr))
5733 return DW_STRING (attr);
5734 attr = dwarf_attr (die, DW_AT_name);
5735 if (attr && DW_STRING (attr))
5736 return DW_STRING (attr);
5737 return NULL;
5738 }
5739
5740 /* Get name of a die, return NULL if not found. */
5741
5742 static char *
5743 dwarf2_name (struct die_info *die)
5744 {
5745 struct attribute *attr;
5746
5747 attr = dwarf_attr (die, DW_AT_name);
5748 if (attr && DW_STRING (attr))
5749 return DW_STRING (attr);
5750 return NULL;
5751 }
5752
5753 /* Return the die that this die in an extension of, or NULL if there
5754 is none. */
5755
5756 static struct die_info *
5757 dwarf2_extension (struct die_info *die)
5758 {
5759 struct attribute *attr;
5760 struct die_info *extension_die;
5761 unsigned int ref;
5762
5763 attr = dwarf_attr (die, DW_AT_extension);
5764 if (attr == NULL)
5765 return NULL;
5766
5767 ref = dwarf2_get_ref_die_offset (attr);
5768 extension_die = follow_die_ref (ref);
5769 if (!extension_die)
5770 {
5771 error ("Dwarf Error: Cannot find referent at offset %d.", ref);
5772 }
5773
5774 return extension_die;
5775 }
5776
5777 /* Convert a DIE tag into its string name. */
5778
5779 static char *
5780 dwarf_tag_name (register unsigned tag)
5781 {
5782 switch (tag)
5783 {
5784 case DW_TAG_padding:
5785 return "DW_TAG_padding";
5786 case DW_TAG_array_type:
5787 return "DW_TAG_array_type";
5788 case DW_TAG_class_type:
5789 return "DW_TAG_class_type";
5790 case DW_TAG_entry_point:
5791 return "DW_TAG_entry_point";
5792 case DW_TAG_enumeration_type:
5793 return "DW_TAG_enumeration_type";
5794 case DW_TAG_formal_parameter:
5795 return "DW_TAG_formal_parameter";
5796 case DW_TAG_imported_declaration:
5797 return "DW_TAG_imported_declaration";
5798 case DW_TAG_label:
5799 return "DW_TAG_label";
5800 case DW_TAG_lexical_block:
5801 return "DW_TAG_lexical_block";
5802 case DW_TAG_member:
5803 return "DW_TAG_member";
5804 case DW_TAG_pointer_type:
5805 return "DW_TAG_pointer_type";
5806 case DW_TAG_reference_type:
5807 return "DW_TAG_reference_type";
5808 case DW_TAG_compile_unit:
5809 return "DW_TAG_compile_unit";
5810 case DW_TAG_string_type:
5811 return "DW_TAG_string_type";
5812 case DW_TAG_structure_type:
5813 return "DW_TAG_structure_type";
5814 case DW_TAG_subroutine_type:
5815 return "DW_TAG_subroutine_type";
5816 case DW_TAG_typedef:
5817 return "DW_TAG_typedef";
5818 case DW_TAG_union_type:
5819 return "DW_TAG_union_type";
5820 case DW_TAG_unspecified_parameters:
5821 return "DW_TAG_unspecified_parameters";
5822 case DW_TAG_variant:
5823 return "DW_TAG_variant";
5824 case DW_TAG_common_block:
5825 return "DW_TAG_common_block";
5826 case DW_TAG_common_inclusion:
5827 return "DW_TAG_common_inclusion";
5828 case DW_TAG_inheritance:
5829 return "DW_TAG_inheritance";
5830 case DW_TAG_inlined_subroutine:
5831 return "DW_TAG_inlined_subroutine";
5832 case DW_TAG_module:
5833 return "DW_TAG_module";
5834 case DW_TAG_ptr_to_member_type:
5835 return "DW_TAG_ptr_to_member_type";
5836 case DW_TAG_set_type:
5837 return "DW_TAG_set_type";
5838 case DW_TAG_subrange_type:
5839 return "DW_TAG_subrange_type";
5840 case DW_TAG_with_stmt:
5841 return "DW_TAG_with_stmt";
5842 case DW_TAG_access_declaration:
5843 return "DW_TAG_access_declaration";
5844 case DW_TAG_base_type:
5845 return "DW_TAG_base_type";
5846 case DW_TAG_catch_block:
5847 return "DW_TAG_catch_block";
5848 case DW_TAG_const_type:
5849 return "DW_TAG_const_type";
5850 case DW_TAG_constant:
5851 return "DW_TAG_constant";
5852 case DW_TAG_enumerator:
5853 return "DW_TAG_enumerator";
5854 case DW_TAG_file_type:
5855 return "DW_TAG_file_type";
5856 case DW_TAG_friend:
5857 return "DW_TAG_friend";
5858 case DW_TAG_namelist:
5859 return "DW_TAG_namelist";
5860 case DW_TAG_namelist_item:
5861 return "DW_TAG_namelist_item";
5862 case DW_TAG_packed_type:
5863 return "DW_TAG_packed_type";
5864 case DW_TAG_subprogram:
5865 return "DW_TAG_subprogram";
5866 case DW_TAG_template_type_param:
5867 return "DW_TAG_template_type_param";
5868 case DW_TAG_template_value_param:
5869 return "DW_TAG_template_value_param";
5870 case DW_TAG_thrown_type:
5871 return "DW_TAG_thrown_type";
5872 case DW_TAG_try_block:
5873 return "DW_TAG_try_block";
5874 case DW_TAG_variant_part:
5875 return "DW_TAG_variant_part";
5876 case DW_TAG_variable:
5877 return "DW_TAG_variable";
5878 case DW_TAG_volatile_type:
5879 return "DW_TAG_volatile_type";
5880 case DW_TAG_dwarf_procedure:
5881 return "DW_TAG_dwarf_procedure";
5882 case DW_TAG_restrict_type:
5883 return "DW_TAG_restrict_type";
5884 case DW_TAG_interface_type:
5885 return "DW_TAG_interface_type";
5886 case DW_TAG_namespace:
5887 return "DW_TAG_namespace";
5888 case DW_TAG_imported_module:
5889 return "DW_TAG_imported_module";
5890 case DW_TAG_unspecified_type:
5891 return "DW_TAG_unspecified_type";
5892 case DW_TAG_partial_unit:
5893 return "DW_TAG_partial_unit";
5894 case DW_TAG_imported_unit:
5895 return "DW_TAG_imported_unit";
5896 case DW_TAG_MIPS_loop:
5897 return "DW_TAG_MIPS_loop";
5898 case DW_TAG_format_label:
5899 return "DW_TAG_format_label";
5900 case DW_TAG_function_template:
5901 return "DW_TAG_function_template";
5902 case DW_TAG_class_template:
5903 return "DW_TAG_class_template";
5904 default:
5905 return "DW_TAG_<unknown>";
5906 }
5907 }
5908
5909 /* Convert a DWARF attribute code into its string name. */
5910
5911 static char *
5912 dwarf_attr_name (register unsigned attr)
5913 {
5914 switch (attr)
5915 {
5916 case DW_AT_sibling:
5917 return "DW_AT_sibling";
5918 case DW_AT_location:
5919 return "DW_AT_location";
5920 case DW_AT_name:
5921 return "DW_AT_name";
5922 case DW_AT_ordering:
5923 return "DW_AT_ordering";
5924 case DW_AT_subscr_data:
5925 return "DW_AT_subscr_data";
5926 case DW_AT_byte_size:
5927 return "DW_AT_byte_size";
5928 case DW_AT_bit_offset:
5929 return "DW_AT_bit_offset";
5930 case DW_AT_bit_size:
5931 return "DW_AT_bit_size";
5932 case DW_AT_element_list:
5933 return "DW_AT_element_list";
5934 case DW_AT_stmt_list:
5935 return "DW_AT_stmt_list";
5936 case DW_AT_low_pc:
5937 return "DW_AT_low_pc";
5938 case DW_AT_high_pc:
5939 return "DW_AT_high_pc";
5940 case DW_AT_language:
5941 return "DW_AT_language";
5942 case DW_AT_member:
5943 return "DW_AT_member";
5944 case DW_AT_discr:
5945 return "DW_AT_discr";
5946 case DW_AT_discr_value:
5947 return "DW_AT_discr_value";
5948 case DW_AT_visibility:
5949 return "DW_AT_visibility";
5950 case DW_AT_import:
5951 return "DW_AT_import";
5952 case DW_AT_string_length:
5953 return "DW_AT_string_length";
5954 case DW_AT_common_reference:
5955 return "DW_AT_common_reference";
5956 case DW_AT_comp_dir:
5957 return "DW_AT_comp_dir";
5958 case DW_AT_const_value:
5959 return "DW_AT_const_value";
5960 case DW_AT_containing_type:
5961 return "DW_AT_containing_type";
5962 case DW_AT_default_value:
5963 return "DW_AT_default_value";
5964 case DW_AT_inline:
5965 return "DW_AT_inline";
5966 case DW_AT_is_optional:
5967 return "DW_AT_is_optional";
5968 case DW_AT_lower_bound:
5969 return "DW_AT_lower_bound";
5970 case DW_AT_producer:
5971 return "DW_AT_producer";
5972 case DW_AT_prototyped:
5973 return "DW_AT_prototyped";
5974 case DW_AT_return_addr:
5975 return "DW_AT_return_addr";
5976 case DW_AT_start_scope:
5977 return "DW_AT_start_scope";
5978 case DW_AT_stride_size:
5979 return "DW_AT_stride_size";
5980 case DW_AT_upper_bound:
5981 return "DW_AT_upper_bound";
5982 case DW_AT_abstract_origin:
5983 return "DW_AT_abstract_origin";
5984 case DW_AT_accessibility:
5985 return "DW_AT_accessibility";
5986 case DW_AT_address_class:
5987 return "DW_AT_address_class";
5988 case DW_AT_artificial:
5989 return "DW_AT_artificial";
5990 case DW_AT_base_types:
5991 return "DW_AT_base_types";
5992 case DW_AT_calling_convention:
5993 return "DW_AT_calling_convention";
5994 case DW_AT_count:
5995 return "DW_AT_count";
5996 case DW_AT_data_member_location:
5997 return "DW_AT_data_member_location";
5998 case DW_AT_decl_column:
5999 return "DW_AT_decl_column";
6000 case DW_AT_decl_file:
6001 return "DW_AT_decl_file";
6002 case DW_AT_decl_line:
6003 return "DW_AT_decl_line";
6004 case DW_AT_declaration:
6005 return "DW_AT_declaration";
6006 case DW_AT_discr_list:
6007 return "DW_AT_discr_list";
6008 case DW_AT_encoding:
6009 return "DW_AT_encoding";
6010 case DW_AT_external:
6011 return "DW_AT_external";
6012 case DW_AT_frame_base:
6013 return "DW_AT_frame_base";
6014 case DW_AT_friend:
6015 return "DW_AT_friend";
6016 case DW_AT_identifier_case:
6017 return "DW_AT_identifier_case";
6018 case DW_AT_macro_info:
6019 return "DW_AT_macro_info";
6020 case DW_AT_namelist_items:
6021 return "DW_AT_namelist_items";
6022 case DW_AT_priority:
6023 return "DW_AT_priority";
6024 case DW_AT_segment:
6025 return "DW_AT_segment";
6026 case DW_AT_specification:
6027 return "DW_AT_specification";
6028 case DW_AT_static_link:
6029 return "DW_AT_static_link";
6030 case DW_AT_type:
6031 return "DW_AT_type";
6032 case DW_AT_use_location:
6033 return "DW_AT_use_location";
6034 case DW_AT_variable_parameter:
6035 return "DW_AT_variable_parameter";
6036 case DW_AT_virtuality:
6037 return "DW_AT_virtuality";
6038 case DW_AT_vtable_elem_location:
6039 return "DW_AT_vtable_elem_location";
6040 case DW_AT_allocated:
6041 return "DW_AT_allocated";
6042 case DW_AT_associated:
6043 return "DW_AT_associated";
6044 case DW_AT_data_location:
6045 return "DW_AT_data_location";
6046 case DW_AT_stride:
6047 return "DW_AT_stride";
6048 case DW_AT_entry_pc:
6049 return "DW_AT_entry_pc";
6050 case DW_AT_use_UTF8:
6051 return "DW_AT_use_UTF8";
6052 case DW_AT_extension:
6053 return "DW_AT_extension";
6054 case DW_AT_ranges:
6055 return "DW_AT_ranges";
6056 case DW_AT_trampoline:
6057 return "DW_AT_trampoline";
6058 case DW_AT_call_column:
6059 return "DW_AT_call_column";
6060 case DW_AT_call_file:
6061 return "DW_AT_call_file";
6062 case DW_AT_call_line:
6063 return "DW_AT_call_line";
6064 #ifdef MIPS
6065 case DW_AT_MIPS_fde:
6066 return "DW_AT_MIPS_fde";
6067 case DW_AT_MIPS_loop_begin:
6068 return "DW_AT_MIPS_loop_begin";
6069 case DW_AT_MIPS_tail_loop_begin:
6070 return "DW_AT_MIPS_tail_loop_begin";
6071 case DW_AT_MIPS_epilog_begin:
6072 return "DW_AT_MIPS_epilog_begin";
6073 case DW_AT_MIPS_loop_unroll_factor:
6074 return "DW_AT_MIPS_loop_unroll_factor";
6075 case DW_AT_MIPS_software_pipeline_depth:
6076 return "DW_AT_MIPS_software_pipeline_depth";
6077 case DW_AT_MIPS_linkage_name:
6078 return "DW_AT_MIPS_linkage_name";
6079 #endif
6080
6081 case DW_AT_sf_names:
6082 return "DW_AT_sf_names";
6083 case DW_AT_src_info:
6084 return "DW_AT_src_info";
6085 case DW_AT_mac_info:
6086 return "DW_AT_mac_info";
6087 case DW_AT_src_coords:
6088 return "DW_AT_src_coords";
6089 case DW_AT_body_begin:
6090 return "DW_AT_body_begin";
6091 case DW_AT_body_end:
6092 return "DW_AT_body_end";
6093 case DW_AT_GNU_vector:
6094 return "DW_AT_GNU_vector";
6095 default:
6096 return "DW_AT_<unknown>";
6097 }
6098 }
6099
6100 /* Convert a DWARF value form code into its string name. */
6101
6102 static char *
6103 dwarf_form_name (register unsigned form)
6104 {
6105 switch (form)
6106 {
6107 case DW_FORM_addr:
6108 return "DW_FORM_addr";
6109 case DW_FORM_block2:
6110 return "DW_FORM_block2";
6111 case DW_FORM_block4:
6112 return "DW_FORM_block4";
6113 case DW_FORM_data2:
6114 return "DW_FORM_data2";
6115 case DW_FORM_data4:
6116 return "DW_FORM_data4";
6117 case DW_FORM_data8:
6118 return "DW_FORM_data8";
6119 case DW_FORM_string:
6120 return "DW_FORM_string";
6121 case DW_FORM_block:
6122 return "DW_FORM_block";
6123 case DW_FORM_block1:
6124 return "DW_FORM_block1";
6125 case DW_FORM_data1:
6126 return "DW_FORM_data1";
6127 case DW_FORM_flag:
6128 return "DW_FORM_flag";
6129 case DW_FORM_sdata:
6130 return "DW_FORM_sdata";
6131 case DW_FORM_strp:
6132 return "DW_FORM_strp";
6133 case DW_FORM_udata:
6134 return "DW_FORM_udata";
6135 case DW_FORM_ref_addr:
6136 return "DW_FORM_ref_addr";
6137 case DW_FORM_ref1:
6138 return "DW_FORM_ref1";
6139 case DW_FORM_ref2:
6140 return "DW_FORM_ref2";
6141 case DW_FORM_ref4:
6142 return "DW_FORM_ref4";
6143 case DW_FORM_ref8:
6144 return "DW_FORM_ref8";
6145 case DW_FORM_ref_udata:
6146 return "DW_FORM_ref_udata";
6147 case DW_FORM_indirect:
6148 return "DW_FORM_indirect";
6149 default:
6150 return "DW_FORM_<unknown>";
6151 }
6152 }
6153
6154 /* Convert a DWARF stack opcode into its string name. */
6155
6156 static char *
6157 dwarf_stack_op_name (register unsigned op)
6158 {
6159 switch (op)
6160 {
6161 case DW_OP_addr:
6162 return "DW_OP_addr";
6163 case DW_OP_deref:
6164 return "DW_OP_deref";
6165 case DW_OP_const1u:
6166 return "DW_OP_const1u";
6167 case DW_OP_const1s:
6168 return "DW_OP_const1s";
6169 case DW_OP_const2u:
6170 return "DW_OP_const2u";
6171 case DW_OP_const2s:
6172 return "DW_OP_const2s";
6173 case DW_OP_const4u:
6174 return "DW_OP_const4u";
6175 case DW_OP_const4s:
6176 return "DW_OP_const4s";
6177 case DW_OP_const8u:
6178 return "DW_OP_const8u";
6179 case DW_OP_const8s:
6180 return "DW_OP_const8s";
6181 case DW_OP_constu:
6182 return "DW_OP_constu";
6183 case DW_OP_consts:
6184 return "DW_OP_consts";
6185 case DW_OP_dup:
6186 return "DW_OP_dup";
6187 case DW_OP_drop:
6188 return "DW_OP_drop";
6189 case DW_OP_over:
6190 return "DW_OP_over";
6191 case DW_OP_pick:
6192 return "DW_OP_pick";
6193 case DW_OP_swap:
6194 return "DW_OP_swap";
6195 case DW_OP_rot:
6196 return "DW_OP_rot";
6197 case DW_OP_xderef:
6198 return "DW_OP_xderef";
6199 case DW_OP_abs:
6200 return "DW_OP_abs";
6201 case DW_OP_and:
6202 return "DW_OP_and";
6203 case DW_OP_div:
6204 return "DW_OP_div";
6205 case DW_OP_minus:
6206 return "DW_OP_minus";
6207 case DW_OP_mod:
6208 return "DW_OP_mod";
6209 case DW_OP_mul:
6210 return "DW_OP_mul";
6211 case DW_OP_neg:
6212 return "DW_OP_neg";
6213 case DW_OP_not:
6214 return "DW_OP_not";
6215 case DW_OP_or:
6216 return "DW_OP_or";
6217 case DW_OP_plus:
6218 return "DW_OP_plus";
6219 case DW_OP_plus_uconst:
6220 return "DW_OP_plus_uconst";
6221 case DW_OP_shl:
6222 return "DW_OP_shl";
6223 case DW_OP_shr:
6224 return "DW_OP_shr";
6225 case DW_OP_shra:
6226 return "DW_OP_shra";
6227 case DW_OP_xor:
6228 return "DW_OP_xor";
6229 case DW_OP_bra:
6230 return "DW_OP_bra";
6231 case DW_OP_eq:
6232 return "DW_OP_eq";
6233 case DW_OP_ge:
6234 return "DW_OP_ge";
6235 case DW_OP_gt:
6236 return "DW_OP_gt";
6237 case DW_OP_le:
6238 return "DW_OP_le";
6239 case DW_OP_lt:
6240 return "DW_OP_lt";
6241 case DW_OP_ne:
6242 return "DW_OP_ne";
6243 case DW_OP_skip:
6244 return "DW_OP_skip";
6245 case DW_OP_lit0:
6246 return "DW_OP_lit0";
6247 case DW_OP_lit1:
6248 return "DW_OP_lit1";
6249 case DW_OP_lit2:
6250 return "DW_OP_lit2";
6251 case DW_OP_lit3:
6252 return "DW_OP_lit3";
6253 case DW_OP_lit4:
6254 return "DW_OP_lit4";
6255 case DW_OP_lit5:
6256 return "DW_OP_lit5";
6257 case DW_OP_lit6:
6258 return "DW_OP_lit6";
6259 case DW_OP_lit7:
6260 return "DW_OP_lit7";
6261 case DW_OP_lit8:
6262 return "DW_OP_lit8";
6263 case DW_OP_lit9:
6264 return "DW_OP_lit9";
6265 case DW_OP_lit10:
6266 return "DW_OP_lit10";
6267 case DW_OP_lit11:
6268 return "DW_OP_lit11";
6269 case DW_OP_lit12:
6270 return "DW_OP_lit12";
6271 case DW_OP_lit13:
6272 return "DW_OP_lit13";
6273 case DW_OP_lit14:
6274 return "DW_OP_lit14";
6275 case DW_OP_lit15:
6276 return "DW_OP_lit15";
6277 case DW_OP_lit16:
6278 return "DW_OP_lit16";
6279 case DW_OP_lit17:
6280 return "DW_OP_lit17";
6281 case DW_OP_lit18:
6282 return "DW_OP_lit18";
6283 case DW_OP_lit19:
6284 return "DW_OP_lit19";
6285 case DW_OP_lit20:
6286 return "DW_OP_lit20";
6287 case DW_OP_lit21:
6288 return "DW_OP_lit21";
6289 case DW_OP_lit22:
6290 return "DW_OP_lit22";
6291 case DW_OP_lit23:
6292 return "DW_OP_lit23";
6293 case DW_OP_lit24:
6294 return "DW_OP_lit24";
6295 case DW_OP_lit25:
6296 return "DW_OP_lit25";
6297 case DW_OP_lit26:
6298 return "DW_OP_lit26";
6299 case DW_OP_lit27:
6300 return "DW_OP_lit27";
6301 case DW_OP_lit28:
6302 return "DW_OP_lit28";
6303 case DW_OP_lit29:
6304 return "DW_OP_lit29";
6305 case DW_OP_lit30:
6306 return "DW_OP_lit30";
6307 case DW_OP_lit31:
6308 return "DW_OP_lit31";
6309 case DW_OP_reg0:
6310 return "DW_OP_reg0";
6311 case DW_OP_reg1:
6312 return "DW_OP_reg1";
6313 case DW_OP_reg2:
6314 return "DW_OP_reg2";
6315 case DW_OP_reg3:
6316 return "DW_OP_reg3";
6317 case DW_OP_reg4:
6318 return "DW_OP_reg4";
6319 case DW_OP_reg5:
6320 return "DW_OP_reg5";
6321 case DW_OP_reg6:
6322 return "DW_OP_reg6";
6323 case DW_OP_reg7:
6324 return "DW_OP_reg7";
6325 case DW_OP_reg8:
6326 return "DW_OP_reg8";
6327 case DW_OP_reg9:
6328 return "DW_OP_reg9";
6329 case DW_OP_reg10:
6330 return "DW_OP_reg10";
6331 case DW_OP_reg11:
6332 return "DW_OP_reg11";
6333 case DW_OP_reg12:
6334 return "DW_OP_reg12";
6335 case DW_OP_reg13:
6336 return "DW_OP_reg13";
6337 case DW_OP_reg14:
6338 return "DW_OP_reg14";
6339 case DW_OP_reg15:
6340 return "DW_OP_reg15";
6341 case DW_OP_reg16:
6342 return "DW_OP_reg16";
6343 case DW_OP_reg17:
6344 return "DW_OP_reg17";
6345 case DW_OP_reg18:
6346 return "DW_OP_reg18";
6347 case DW_OP_reg19:
6348 return "DW_OP_reg19";
6349 case DW_OP_reg20:
6350 return "DW_OP_reg20";
6351 case DW_OP_reg21:
6352 return "DW_OP_reg21";
6353 case DW_OP_reg22:
6354 return "DW_OP_reg22";
6355 case DW_OP_reg23:
6356 return "DW_OP_reg23";
6357 case DW_OP_reg24:
6358 return "DW_OP_reg24";
6359 case DW_OP_reg25:
6360 return "DW_OP_reg25";
6361 case DW_OP_reg26:
6362 return "DW_OP_reg26";
6363 case DW_OP_reg27:
6364 return "DW_OP_reg27";
6365 case DW_OP_reg28:
6366 return "DW_OP_reg28";
6367 case DW_OP_reg29:
6368 return "DW_OP_reg29";
6369 case DW_OP_reg30:
6370 return "DW_OP_reg30";
6371 case DW_OP_reg31:
6372 return "DW_OP_reg31";
6373 case DW_OP_breg0:
6374 return "DW_OP_breg0";
6375 case DW_OP_breg1:
6376 return "DW_OP_breg1";
6377 case DW_OP_breg2:
6378 return "DW_OP_breg2";
6379 case DW_OP_breg3:
6380 return "DW_OP_breg3";
6381 case DW_OP_breg4:
6382 return "DW_OP_breg4";
6383 case DW_OP_breg5:
6384 return "DW_OP_breg5";
6385 case DW_OP_breg6:
6386 return "DW_OP_breg6";
6387 case DW_OP_breg7:
6388 return "DW_OP_breg7";
6389 case DW_OP_breg8:
6390 return "DW_OP_breg8";
6391 case DW_OP_breg9:
6392 return "DW_OP_breg9";
6393 case DW_OP_breg10:
6394 return "DW_OP_breg10";
6395 case DW_OP_breg11:
6396 return "DW_OP_breg11";
6397 case DW_OP_breg12:
6398 return "DW_OP_breg12";
6399 case DW_OP_breg13:
6400 return "DW_OP_breg13";
6401 case DW_OP_breg14:
6402 return "DW_OP_breg14";
6403 case DW_OP_breg15:
6404 return "DW_OP_breg15";
6405 case DW_OP_breg16:
6406 return "DW_OP_breg16";
6407 case DW_OP_breg17:
6408 return "DW_OP_breg17";
6409 case DW_OP_breg18:
6410 return "DW_OP_breg18";
6411 case DW_OP_breg19:
6412 return "DW_OP_breg19";
6413 case DW_OP_breg20:
6414 return "DW_OP_breg20";
6415 case DW_OP_breg21:
6416 return "DW_OP_breg21";
6417 case DW_OP_breg22:
6418 return "DW_OP_breg22";
6419 case DW_OP_breg23:
6420 return "DW_OP_breg23";
6421 case DW_OP_breg24:
6422 return "DW_OP_breg24";
6423 case DW_OP_breg25:
6424 return "DW_OP_breg25";
6425 case DW_OP_breg26:
6426 return "DW_OP_breg26";
6427 case DW_OP_breg27:
6428 return "DW_OP_breg27";
6429 case DW_OP_breg28:
6430 return "DW_OP_breg28";
6431 case DW_OP_breg29:
6432 return "DW_OP_breg29";
6433 case DW_OP_breg30:
6434 return "DW_OP_breg30";
6435 case DW_OP_breg31:
6436 return "DW_OP_breg31";
6437 case DW_OP_regx:
6438 return "DW_OP_regx";
6439 case DW_OP_fbreg:
6440 return "DW_OP_fbreg";
6441 case DW_OP_bregx:
6442 return "DW_OP_bregx";
6443 case DW_OP_piece:
6444 return "DW_OP_piece";
6445 case DW_OP_deref_size:
6446 return "DW_OP_deref_size";
6447 case DW_OP_xderef_size:
6448 return "DW_OP_xderef_size";
6449 case DW_OP_nop:
6450 return "DW_OP_nop";
6451 /* DWARF 3 extensions. */
6452 case DW_OP_push_object_address:
6453 return "DW_OP_push_object_address";
6454 case DW_OP_call2:
6455 return "DW_OP_call2";
6456 case DW_OP_call4:
6457 return "DW_OP_call4";
6458 case DW_OP_call_ref:
6459 return "DW_OP_call_ref";
6460 /* GNU extensions. */
6461 case DW_OP_GNU_push_tls_address:
6462 return "DW_OP_GNU_push_tls_address";
6463 default:
6464 return "OP_<unknown>";
6465 }
6466 }
6467
6468 static char *
6469 dwarf_bool_name (unsigned mybool)
6470 {
6471 if (mybool)
6472 return "TRUE";
6473 else
6474 return "FALSE";
6475 }
6476
6477 /* Convert a DWARF type code into its string name. */
6478
6479 static char *
6480 dwarf_type_encoding_name (register unsigned enc)
6481 {
6482 switch (enc)
6483 {
6484 case DW_ATE_address:
6485 return "DW_ATE_address";
6486 case DW_ATE_boolean:
6487 return "DW_ATE_boolean";
6488 case DW_ATE_complex_float:
6489 return "DW_ATE_complex_float";
6490 case DW_ATE_float:
6491 return "DW_ATE_float";
6492 case DW_ATE_signed:
6493 return "DW_ATE_signed";
6494 case DW_ATE_signed_char:
6495 return "DW_ATE_signed_char";
6496 case DW_ATE_unsigned:
6497 return "DW_ATE_unsigned";
6498 case DW_ATE_unsigned_char:
6499 return "DW_ATE_unsigned_char";
6500 case DW_ATE_imaginary_float:
6501 return "DW_ATE_imaginary_float";
6502 default:
6503 return "DW_ATE_<unknown>";
6504 }
6505 }
6506
6507 /* Convert a DWARF call frame info operation to its string name. */
6508
6509 #if 0
6510 static char *
6511 dwarf_cfi_name (register unsigned cfi_opc)
6512 {
6513 switch (cfi_opc)
6514 {
6515 case DW_CFA_advance_loc:
6516 return "DW_CFA_advance_loc";
6517 case DW_CFA_offset:
6518 return "DW_CFA_offset";
6519 case DW_CFA_restore:
6520 return "DW_CFA_restore";
6521 case DW_CFA_nop:
6522 return "DW_CFA_nop";
6523 case DW_CFA_set_loc:
6524 return "DW_CFA_set_loc";
6525 case DW_CFA_advance_loc1:
6526 return "DW_CFA_advance_loc1";
6527 case DW_CFA_advance_loc2:
6528 return "DW_CFA_advance_loc2";
6529 case DW_CFA_advance_loc4:
6530 return "DW_CFA_advance_loc4";
6531 case DW_CFA_offset_extended:
6532 return "DW_CFA_offset_extended";
6533 case DW_CFA_restore_extended:
6534 return "DW_CFA_restore_extended";
6535 case DW_CFA_undefined:
6536 return "DW_CFA_undefined";
6537 case DW_CFA_same_value:
6538 return "DW_CFA_same_value";
6539 case DW_CFA_register:
6540 return "DW_CFA_register";
6541 case DW_CFA_remember_state:
6542 return "DW_CFA_remember_state";
6543 case DW_CFA_restore_state:
6544 return "DW_CFA_restore_state";
6545 case DW_CFA_def_cfa:
6546 return "DW_CFA_def_cfa";
6547 case DW_CFA_def_cfa_register:
6548 return "DW_CFA_def_cfa_register";
6549 case DW_CFA_def_cfa_offset:
6550 return "DW_CFA_def_cfa_offset";
6551
6552 /* DWARF 3 */
6553 case DW_CFA_def_cfa_expression:
6554 return "DW_CFA_def_cfa_expression";
6555 case DW_CFA_expression:
6556 return "DW_CFA_expression";
6557 case DW_CFA_offset_extended_sf:
6558 return "DW_CFA_offset_extended_sf";
6559 case DW_CFA_def_cfa_sf:
6560 return "DW_CFA_def_cfa_sf";
6561 case DW_CFA_def_cfa_offset_sf:
6562 return "DW_CFA_def_cfa_offset_sf";
6563
6564 /* SGI/MIPS specific */
6565 case DW_CFA_MIPS_advance_loc8:
6566 return "DW_CFA_MIPS_advance_loc8";
6567
6568 /* GNU extensions */
6569 case DW_CFA_GNU_window_save:
6570 return "DW_CFA_GNU_window_save";
6571 case DW_CFA_GNU_args_size:
6572 return "DW_CFA_GNU_args_size";
6573 case DW_CFA_GNU_negative_offset_extended:
6574 return "DW_CFA_GNU_negative_offset_extended";
6575
6576 default:
6577 return "DW_CFA_<unknown>";
6578 }
6579 }
6580 #endif
6581
6582 static void
6583 dump_die (struct die_info *die)
6584 {
6585 unsigned int i;
6586
6587 fprintf_unfiltered (gdb_stderr, "Die: %s (abbrev = %d, offset = %d)\n",
6588 dwarf_tag_name (die->tag), die->abbrev, die->offset);
6589 fprintf_unfiltered (gdb_stderr, "\thas children: %s\n",
6590 dwarf_bool_name (die->has_children));
6591
6592 fprintf_unfiltered (gdb_stderr, "\tattributes:\n");
6593 for (i = 0; i < die->num_attrs; ++i)
6594 {
6595 fprintf_unfiltered (gdb_stderr, "\t\t%s (%s) ",
6596 dwarf_attr_name (die->attrs[i].name),
6597 dwarf_form_name (die->attrs[i].form));
6598 switch (die->attrs[i].form)
6599 {
6600 case DW_FORM_ref_addr:
6601 case DW_FORM_addr:
6602 fprintf_unfiltered (gdb_stderr, "address: ");
6603 print_address_numeric (DW_ADDR (&die->attrs[i]), 1, gdb_stderr);
6604 break;
6605 case DW_FORM_block2:
6606 case DW_FORM_block4:
6607 case DW_FORM_block:
6608 case DW_FORM_block1:
6609 fprintf_unfiltered (gdb_stderr, "block: size %d", DW_BLOCK (&die->attrs[i])->size);
6610 break;
6611 case DW_FORM_data1:
6612 case DW_FORM_data2:
6613 case DW_FORM_data4:
6614 case DW_FORM_data8:
6615 case DW_FORM_ref1:
6616 case DW_FORM_ref2:
6617 case DW_FORM_ref4:
6618 case DW_FORM_udata:
6619 case DW_FORM_sdata:
6620 fprintf_unfiltered (gdb_stderr, "constant: %ld", DW_UNSND (&die->attrs[i]));
6621 break;
6622 case DW_FORM_string:
6623 case DW_FORM_strp:
6624 fprintf_unfiltered (gdb_stderr, "string: \"%s\"",
6625 DW_STRING (&die->attrs[i])
6626 ? DW_STRING (&die->attrs[i]) : "");
6627 break;
6628 case DW_FORM_flag:
6629 if (DW_UNSND (&die->attrs[i]))
6630 fprintf_unfiltered (gdb_stderr, "flag: TRUE");
6631 else
6632 fprintf_unfiltered (gdb_stderr, "flag: FALSE");
6633 break;
6634 case DW_FORM_indirect:
6635 /* the reader will have reduced the indirect form to
6636 the "base form" so this form should not occur */
6637 fprintf_unfiltered (gdb_stderr, "unexpected attribute form: DW_FORM_indirect");
6638 break;
6639 default:
6640 fprintf_unfiltered (gdb_stderr, "unsupported attribute form: %d.",
6641 die->attrs[i].form);
6642 }
6643 fprintf_unfiltered (gdb_stderr, "\n");
6644 }
6645 }
6646
6647 static void
6648 dump_die_list (struct die_info *die)
6649 {
6650 while (die)
6651 {
6652 dump_die (die);
6653 die = die->next;
6654 }
6655 }
6656
6657 static void
6658 store_in_ref_table (unsigned int offset, struct die_info *die)
6659 {
6660 int h;
6661 struct die_info *old;
6662
6663 h = (offset % REF_HASH_SIZE);
6664 old = die_ref_table[h];
6665 die->next_ref = old;
6666 die_ref_table[h] = die;
6667 }
6668
6669
6670 static void
6671 dwarf2_empty_hash_tables (void)
6672 {
6673 memset (die_ref_table, 0, sizeof (die_ref_table));
6674 }
6675
6676 static unsigned int
6677 dwarf2_get_ref_die_offset (struct attribute *attr)
6678 {
6679 unsigned int result = 0;
6680
6681 switch (attr->form)
6682 {
6683 case DW_FORM_ref_addr:
6684 result = DW_ADDR (attr);
6685 break;
6686 case DW_FORM_ref1:
6687 case DW_FORM_ref2:
6688 case DW_FORM_ref4:
6689 case DW_FORM_ref8:
6690 case DW_FORM_ref_udata:
6691 result = cu_header_offset + DW_UNSND (attr);
6692 break;
6693 default:
6694 complaint (&symfile_complaints,
6695 "unsupported die ref attribute form: '%s'",
6696 dwarf_form_name (attr->form));
6697 }
6698 return result;
6699 }
6700
6701 static struct die_info *
6702 follow_die_ref (unsigned int offset)
6703 {
6704 struct die_info *die;
6705 int h;
6706
6707 h = (offset % REF_HASH_SIZE);
6708 die = die_ref_table[h];
6709 while (die)
6710 {
6711 if (die->offset == offset)
6712 {
6713 return die;
6714 }
6715 die = die->next_ref;
6716 }
6717 return NULL;
6718 }
6719
6720 static struct type *
6721 dwarf2_fundamental_type (struct objfile *objfile, int typeid)
6722 {
6723 if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
6724 {
6725 error ("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]",
6726 typeid, objfile->name);
6727 }
6728
6729 /* Look for this particular type in the fundamental type vector. If
6730 one is not found, create and install one appropriate for the
6731 current language and the current target machine. */
6732
6733 if (ftypes[typeid] == NULL)
6734 {
6735 ftypes[typeid] = cu_language_defn->la_fund_type (objfile, typeid);
6736 }
6737
6738 return (ftypes[typeid]);
6739 }
6740
6741 /* Decode simple location descriptions.
6742 Given a pointer to a dwarf block that defines a location, compute
6743 the location and return the value.
6744
6745 FIXME: This is a kludge until we figure out a better
6746 way to handle the location descriptions.
6747 Gdb's design does not mesh well with the DWARF2 notion of a location
6748 computing interpreter, which is a shame because the flexibility goes unused.
6749 FIXME: Implement more operations as necessary.
6750
6751 A location description containing no operations indicates that the
6752 object is optimized out. The global optimized_out flag is set for
6753 those, the return value is meaningless.
6754
6755 When the result is a register number, the global isreg flag is set,
6756 otherwise it is cleared.
6757
6758 When the result is a base register offset, the global offreg flag is set
6759 and the register number is returned in basereg, otherwise it is cleared.
6760
6761 When the DW_OP_fbreg operation is encountered without a corresponding
6762 DW_AT_frame_base attribute, the global islocal flag is set.
6763 Hopefully the machine dependent code knows how to set up a virtual
6764 frame pointer for the local references.
6765
6766 Note that stack[0] is unused except as a default error return.
6767 Note that stack overflow is not yet handled. */
6768
6769 static CORE_ADDR
6770 decode_locdesc (struct dwarf_block *blk, struct objfile *objfile,
6771 const struct comp_unit_head *cu_header)
6772 {
6773 int i;
6774 int size = blk->size;
6775 char *data = blk->data;
6776 CORE_ADDR stack[64];
6777 int stacki;
6778 unsigned int bytes_read, unsnd;
6779 unsigned char op;
6780
6781 i = 0;
6782 stacki = 0;
6783 stack[stacki] = 0;
6784 isreg = 0;
6785 offreg = 0;
6786 isderef = 0;
6787 islocal = 0;
6788 is_thread_local = 0;
6789 optimized_out = 1;
6790
6791 while (i < size)
6792 {
6793 optimized_out = 0;
6794 op = data[i++];
6795 switch (op)
6796 {
6797 case DW_OP_lit0:
6798 case DW_OP_lit1:
6799 case DW_OP_lit2:
6800 case DW_OP_lit3:
6801 case DW_OP_lit4:
6802 case DW_OP_lit5:
6803 case DW_OP_lit6:
6804 case DW_OP_lit7:
6805 case DW_OP_lit8:
6806 case DW_OP_lit9:
6807 case DW_OP_lit10:
6808 case DW_OP_lit11:
6809 case DW_OP_lit12:
6810 case DW_OP_lit13:
6811 case DW_OP_lit14:
6812 case DW_OP_lit15:
6813 case DW_OP_lit16:
6814 case DW_OP_lit17:
6815 case DW_OP_lit18:
6816 case DW_OP_lit19:
6817 case DW_OP_lit20:
6818 case DW_OP_lit21:
6819 case DW_OP_lit22:
6820 case DW_OP_lit23:
6821 case DW_OP_lit24:
6822 case DW_OP_lit25:
6823 case DW_OP_lit26:
6824 case DW_OP_lit27:
6825 case DW_OP_lit28:
6826 case DW_OP_lit29:
6827 case DW_OP_lit30:
6828 case DW_OP_lit31:
6829 stack[++stacki] = op - DW_OP_lit0;
6830 break;
6831
6832 case DW_OP_reg0:
6833 case DW_OP_reg1:
6834 case DW_OP_reg2:
6835 case DW_OP_reg3:
6836 case DW_OP_reg4:
6837 case DW_OP_reg5:
6838 case DW_OP_reg6:
6839 case DW_OP_reg7:
6840 case DW_OP_reg8:
6841 case DW_OP_reg9:
6842 case DW_OP_reg10:
6843 case DW_OP_reg11:
6844 case DW_OP_reg12:
6845 case DW_OP_reg13:
6846 case DW_OP_reg14:
6847 case DW_OP_reg15:
6848 case DW_OP_reg16:
6849 case DW_OP_reg17:
6850 case DW_OP_reg18:
6851 case DW_OP_reg19:
6852 case DW_OP_reg20:
6853 case DW_OP_reg21:
6854 case DW_OP_reg22:
6855 case DW_OP_reg23:
6856 case DW_OP_reg24:
6857 case DW_OP_reg25:
6858 case DW_OP_reg26:
6859 case DW_OP_reg27:
6860 case DW_OP_reg28:
6861 case DW_OP_reg29:
6862 case DW_OP_reg30:
6863 case DW_OP_reg31:
6864 isreg = 1;
6865 stack[++stacki] = op - DW_OP_reg0;
6866 break;
6867
6868 case DW_OP_regx:
6869 isreg = 1;
6870 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
6871 i += bytes_read;
6872 stack[++stacki] = unsnd;
6873 break;
6874
6875 case DW_OP_breg0:
6876 case DW_OP_breg1:
6877 case DW_OP_breg2:
6878 case DW_OP_breg3:
6879 case DW_OP_breg4:
6880 case DW_OP_breg5:
6881 case DW_OP_breg6:
6882 case DW_OP_breg7:
6883 case DW_OP_breg8:
6884 case DW_OP_breg9:
6885 case DW_OP_breg10:
6886 case DW_OP_breg11:
6887 case DW_OP_breg12:
6888 case DW_OP_breg13:
6889 case DW_OP_breg14:
6890 case DW_OP_breg15:
6891 case DW_OP_breg16:
6892 case DW_OP_breg17:
6893 case DW_OP_breg18:
6894 case DW_OP_breg19:
6895 case DW_OP_breg20:
6896 case DW_OP_breg21:
6897 case DW_OP_breg22:
6898 case DW_OP_breg23:
6899 case DW_OP_breg24:
6900 case DW_OP_breg25:
6901 case DW_OP_breg26:
6902 case DW_OP_breg27:
6903 case DW_OP_breg28:
6904 case DW_OP_breg29:
6905 case DW_OP_breg30:
6906 case DW_OP_breg31:
6907 offreg = 1;
6908 basereg = op - DW_OP_breg0;
6909 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
6910 i += bytes_read;
6911 break;
6912
6913 case DW_OP_bregx:
6914 offreg = 1;
6915 basereg = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
6916 i += bytes_read;
6917 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
6918 i += bytes_read;
6919 break;
6920
6921 case DW_OP_fbreg:
6922 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
6923 i += bytes_read;
6924 if (frame_base_reg >= 0)
6925 {
6926 offreg = 1;
6927 basereg = frame_base_reg;
6928 stack[stacki] += frame_base_offset;
6929 }
6930 else
6931 {
6932 complaint (&symfile_complaints,
6933 "DW_AT_frame_base missing for DW_OP_fbreg");
6934 islocal = 1;
6935 }
6936 break;
6937
6938 case DW_OP_addr:
6939 stack[++stacki] = read_address (objfile->obfd, &data[i],
6940 cu_header, &bytes_read);
6941 i += bytes_read;
6942 break;
6943
6944 case DW_OP_const1u:
6945 stack[++stacki] = read_1_byte (objfile->obfd, &data[i]);
6946 i += 1;
6947 break;
6948
6949 case DW_OP_const1s:
6950 stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]);
6951 i += 1;
6952 break;
6953
6954 case DW_OP_const2u:
6955 stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]);
6956 i += 2;
6957 break;
6958
6959 case DW_OP_const2s:
6960 stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]);
6961 i += 2;
6962 break;
6963
6964 case DW_OP_const4u:
6965 stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]);
6966 i += 4;
6967 break;
6968
6969 case DW_OP_const4s:
6970 stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]);
6971 i += 4;
6972 break;
6973
6974 case DW_OP_constu:
6975 stack[++stacki] = read_unsigned_leb128 (NULL, (data + i),
6976 &bytes_read);
6977 i += bytes_read;
6978 break;
6979
6980 case DW_OP_consts:
6981 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read);
6982 i += bytes_read;
6983 break;
6984
6985 case DW_OP_dup:
6986 stack[stacki + 1] = stack[stacki];
6987 stacki++;
6988 break;
6989
6990 case DW_OP_plus:
6991 stack[stacki - 1] += stack[stacki];
6992 stacki--;
6993 break;
6994
6995 case DW_OP_plus_uconst:
6996 stack[stacki] += read_unsigned_leb128 (NULL, (data + i), &bytes_read);
6997 i += bytes_read;
6998 break;
6999
7000 case DW_OP_minus:
7001 stack[stacki - 1] -= stack[stacki];
7002 stacki--;
7003 break;
7004
7005 case DW_OP_deref:
7006 isderef = 1;
7007 /* If we're not the last op, then we definitely can't encode
7008 this using GDB's address_class enum. */
7009 if (i < size)
7010 dwarf2_complex_location_expr_complaint ();
7011 break;
7012
7013 case DW_OP_GNU_push_tls_address:
7014 is_thread_local = 1;
7015 /* The top of the stack has the offset from the beginning
7016 of the thread control block at which the variable is located. */
7017 /* Nothing should follow this operator, so the top of stack would
7018 be returned. */
7019 if (i < size)
7020 dwarf2_complex_location_expr_complaint ();
7021 break;
7022
7023 default:
7024 complaint (&symfile_complaints, "unsupported stack op: '%s'",
7025 dwarf_stack_op_name (op));
7026 return (stack[stacki]);
7027 }
7028 }
7029 return (stack[stacki]);
7030 }
7031
7032 /* memory allocation interface */
7033
7034 /* ARGSUSED */
7035 static void
7036 dwarf2_free_tmp_obstack (void *ignore)
7037 {
7038 obstack_free (&dwarf2_tmp_obstack, NULL);
7039 }
7040
7041 static struct dwarf_block *
7042 dwarf_alloc_block (void)
7043 {
7044 struct dwarf_block *blk;
7045
7046 blk = (struct dwarf_block *)
7047 obstack_alloc (&dwarf2_tmp_obstack, sizeof (struct dwarf_block));
7048 return (blk);
7049 }
7050
7051 static struct abbrev_info *
7052 dwarf_alloc_abbrev (void)
7053 {
7054 struct abbrev_info *abbrev;
7055
7056 abbrev = (struct abbrev_info *) xmalloc (sizeof (struct abbrev_info));
7057 memset (abbrev, 0, sizeof (struct abbrev_info));
7058 return (abbrev);
7059 }
7060
7061 static struct die_info *
7062 dwarf_alloc_die (void)
7063 {
7064 struct die_info *die;
7065
7066 die = (struct die_info *) xmalloc (sizeof (struct die_info));
7067 memset (die, 0, sizeof (struct die_info));
7068 return (die);
7069 }
7070
7071 \f
7072 /* Macro support. */
7073
7074
7075 /* Return the full name of file number I in *LH's file name table.
7076 Use COMP_DIR as the name of the current directory of the
7077 compilation. The result is allocated using xmalloc; the caller is
7078 responsible for freeing it. */
7079 static char *
7080 file_full_name (int file, struct line_header *lh, const char *comp_dir)
7081 {
7082 struct file_entry *fe = &lh->file_names[file - 1];
7083
7084 if (IS_ABSOLUTE_PATH (fe->name))
7085 return xstrdup (fe->name);
7086 else
7087 {
7088 const char *dir;
7089 int dir_len;
7090 char *full_name;
7091
7092 if (fe->dir_index)
7093 dir = lh->include_dirs[fe->dir_index - 1];
7094 else
7095 dir = comp_dir;
7096
7097 if (dir)
7098 {
7099 dir_len = strlen (dir);
7100 full_name = xmalloc (dir_len + 1 + strlen (fe->name) + 1);
7101 strcpy (full_name, dir);
7102 full_name[dir_len] = '/';
7103 strcpy (full_name + dir_len + 1, fe->name);
7104 return full_name;
7105 }
7106 else
7107 return xstrdup (fe->name);
7108 }
7109 }
7110
7111
7112 static struct macro_source_file *
7113 macro_start_file (int file, int line,
7114 struct macro_source_file *current_file,
7115 const char *comp_dir,
7116 struct line_header *lh, struct objfile *objfile)
7117 {
7118 /* The full name of this source file. */
7119 char *full_name = file_full_name (file, lh, comp_dir);
7120
7121 /* We don't create a macro table for this compilation unit
7122 at all until we actually get a filename. */
7123 if (! pending_macros)
7124 pending_macros = new_macro_table (&objfile->symbol_obstack,
7125 objfile->macro_cache);
7126
7127 if (! current_file)
7128 /* If we have no current file, then this must be the start_file
7129 directive for the compilation unit's main source file. */
7130 current_file = macro_set_main (pending_macros, full_name);
7131 else
7132 current_file = macro_include (current_file, line, full_name);
7133
7134 xfree (full_name);
7135
7136 return current_file;
7137 }
7138
7139
7140 /* Copy the LEN characters at BUF to a xmalloc'ed block of memory,
7141 followed by a null byte. */
7142 static char *
7143 copy_string (const char *buf, int len)
7144 {
7145 char *s = xmalloc (len + 1);
7146 memcpy (s, buf, len);
7147 s[len] = '\0';
7148
7149 return s;
7150 }
7151
7152
7153 static const char *
7154 consume_improper_spaces (const char *p, const char *body)
7155 {
7156 if (*p == ' ')
7157 {
7158 complaint (&symfile_complaints,
7159 "macro definition contains spaces in formal argument list:\n`%s'",
7160 body);
7161
7162 while (*p == ' ')
7163 p++;
7164 }
7165
7166 return p;
7167 }
7168
7169
7170 static void
7171 parse_macro_definition (struct macro_source_file *file, int line,
7172 const char *body)
7173 {
7174 const char *p;
7175
7176 /* The body string takes one of two forms. For object-like macro
7177 definitions, it should be:
7178
7179 <macro name> " " <definition>
7180
7181 For function-like macro definitions, it should be:
7182
7183 <macro name> "() " <definition>
7184 or
7185 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
7186
7187 Spaces may appear only where explicitly indicated, and in the
7188 <definition>.
7189
7190 The Dwarf 2 spec says that an object-like macro's name is always
7191 followed by a space, but versions of GCC around March 2002 omit
7192 the space when the macro's definition is the empty string.
7193
7194 The Dwarf 2 spec says that there should be no spaces between the
7195 formal arguments in a function-like macro's formal argument list,
7196 but versions of GCC around March 2002 include spaces after the
7197 commas. */
7198
7199
7200 /* Find the extent of the macro name. The macro name is terminated
7201 by either a space or null character (for an object-like macro) or
7202 an opening paren (for a function-like macro). */
7203 for (p = body; *p; p++)
7204 if (*p == ' ' || *p == '(')
7205 break;
7206
7207 if (*p == ' ' || *p == '\0')
7208 {
7209 /* It's an object-like macro. */
7210 int name_len = p - body;
7211 char *name = copy_string (body, name_len);
7212 const char *replacement;
7213
7214 if (*p == ' ')
7215 replacement = body + name_len + 1;
7216 else
7217 {
7218 dwarf2_macro_malformed_definition_complaint (body);
7219 replacement = body + name_len;
7220 }
7221
7222 macro_define_object (file, line, name, replacement);
7223
7224 xfree (name);
7225 }
7226 else if (*p == '(')
7227 {
7228 /* It's a function-like macro. */
7229 char *name = copy_string (body, p - body);
7230 int argc = 0;
7231 int argv_size = 1;
7232 char **argv = xmalloc (argv_size * sizeof (*argv));
7233
7234 p++;
7235
7236 p = consume_improper_spaces (p, body);
7237
7238 /* Parse the formal argument list. */
7239 while (*p && *p != ')')
7240 {
7241 /* Find the extent of the current argument name. */
7242 const char *arg_start = p;
7243
7244 while (*p && *p != ',' && *p != ')' && *p != ' ')
7245 p++;
7246
7247 if (! *p || p == arg_start)
7248 dwarf2_macro_malformed_definition_complaint (body);
7249 else
7250 {
7251 /* Make sure argv has room for the new argument. */
7252 if (argc >= argv_size)
7253 {
7254 argv_size *= 2;
7255 argv = xrealloc (argv, argv_size * sizeof (*argv));
7256 }
7257
7258 argv[argc++] = copy_string (arg_start, p - arg_start);
7259 }
7260
7261 p = consume_improper_spaces (p, body);
7262
7263 /* Consume the comma, if present. */
7264 if (*p == ',')
7265 {
7266 p++;
7267
7268 p = consume_improper_spaces (p, body);
7269 }
7270 }
7271
7272 if (*p == ')')
7273 {
7274 p++;
7275
7276 if (*p == ' ')
7277 /* Perfectly formed definition, no complaints. */
7278 macro_define_function (file, line, name,
7279 argc, (const char **) argv,
7280 p + 1);
7281 else if (*p == '\0')
7282 {
7283 /* Complain, but do define it. */
7284 dwarf2_macro_malformed_definition_complaint (body);
7285 macro_define_function (file, line, name,
7286 argc, (const char **) argv,
7287 p);
7288 }
7289 else
7290 /* Just complain. */
7291 dwarf2_macro_malformed_definition_complaint (body);
7292 }
7293 else
7294 /* Just complain. */
7295 dwarf2_macro_malformed_definition_complaint (body);
7296
7297 xfree (name);
7298 {
7299 int i;
7300
7301 for (i = 0; i < argc; i++)
7302 xfree (argv[i]);
7303 }
7304 xfree (argv);
7305 }
7306 else
7307 dwarf2_macro_malformed_definition_complaint (body);
7308 }
7309
7310
7311 static void
7312 dwarf_decode_macros (struct line_header *lh, unsigned int offset,
7313 char *comp_dir, bfd *abfd,
7314 const struct comp_unit_head *cu_header,
7315 struct objfile *objfile)
7316 {
7317 char *mac_ptr, *mac_end;
7318 struct macro_source_file *current_file = 0;
7319
7320 if (dwarf_macinfo_buffer == NULL)
7321 {
7322 complaint (&symfile_complaints, "missing .debug_macinfo section");
7323 return;
7324 }
7325
7326 mac_ptr = dwarf_macinfo_buffer + offset;
7327 mac_end = dwarf_macinfo_buffer + dwarf_macinfo_size;
7328
7329 for (;;)
7330 {
7331 enum dwarf_macinfo_record_type macinfo_type;
7332
7333 /* Do we at least have room for a macinfo type byte? */
7334 if (mac_ptr >= mac_end)
7335 {
7336 dwarf2_macros_too_long_complaint ();
7337 return;
7338 }
7339
7340 macinfo_type = read_1_byte (abfd, mac_ptr);
7341 mac_ptr++;
7342
7343 switch (macinfo_type)
7344 {
7345 /* A zero macinfo type indicates the end of the macro
7346 information. */
7347 case 0:
7348 return;
7349
7350 case DW_MACINFO_define:
7351 case DW_MACINFO_undef:
7352 {
7353 int bytes_read;
7354 int line;
7355 char *body;
7356
7357 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
7358 mac_ptr += bytes_read;
7359 body = read_string (abfd, mac_ptr, &bytes_read);
7360 mac_ptr += bytes_read;
7361
7362 if (! current_file)
7363 complaint (&symfile_complaints,
7364 "debug info gives macro %s outside of any file: %s",
7365 macinfo_type ==
7366 DW_MACINFO_define ? "definition" : macinfo_type ==
7367 DW_MACINFO_undef ? "undefinition" :
7368 "something-or-other", body);
7369 else
7370 {
7371 if (macinfo_type == DW_MACINFO_define)
7372 parse_macro_definition (current_file, line, body);
7373 else if (macinfo_type == DW_MACINFO_undef)
7374 macro_undef (current_file, line, body);
7375 }
7376 }
7377 break;
7378
7379 case DW_MACINFO_start_file:
7380 {
7381 int bytes_read;
7382 int line, file;
7383
7384 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
7385 mac_ptr += bytes_read;
7386 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
7387 mac_ptr += bytes_read;
7388
7389 current_file = macro_start_file (file, line,
7390 current_file, comp_dir,
7391 lh, objfile);
7392 }
7393 break;
7394
7395 case DW_MACINFO_end_file:
7396 if (! current_file)
7397 complaint (&symfile_complaints,
7398 "macro debug info has an unmatched `close_file' directive");
7399 else
7400 {
7401 current_file = current_file->included_by;
7402 if (! current_file)
7403 {
7404 enum dwarf_macinfo_record_type next_type;
7405
7406 /* GCC circa March 2002 doesn't produce the zero
7407 type byte marking the end of the compilation
7408 unit. Complain if it's not there, but exit no
7409 matter what. */
7410
7411 /* Do we at least have room for a macinfo type byte? */
7412 if (mac_ptr >= mac_end)
7413 {
7414 dwarf2_macros_too_long_complaint ();
7415 return;
7416 }
7417
7418 /* We don't increment mac_ptr here, so this is just
7419 a look-ahead. */
7420 next_type = read_1_byte (abfd, mac_ptr);
7421 if (next_type != 0)
7422 complaint (&symfile_complaints,
7423 "no terminating 0-type entry for macros in `.debug_macinfo' section");
7424
7425 return;
7426 }
7427 }
7428 break;
7429
7430 case DW_MACINFO_vendor_ext:
7431 {
7432 int bytes_read;
7433 int constant;
7434 char *string;
7435
7436 constant = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
7437 mac_ptr += bytes_read;
7438 string = read_string (abfd, mac_ptr, &bytes_read);
7439 mac_ptr += bytes_read;
7440
7441 /* We don't recognize any vendor extensions. */
7442 }
7443 break;
7444 }
7445 }
7446 }
7447
7448 /* Check if the attribute's form is a DW_FORM_block*
7449 if so return true else false. */
7450 static int
7451 attr_form_is_block (struct attribute *attr)
7452 {
7453 return (attr == NULL ? 0 :
7454 attr->form == DW_FORM_block1
7455 || attr->form == DW_FORM_block2
7456 || attr->form == DW_FORM_block4
7457 || attr->form == DW_FORM_block);
7458 }
7459
7460 static void
7461 dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
7462 const struct comp_unit_head *cu_header,
7463 struct objfile *objfile)
7464 {
7465 if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8)
7466 {
7467 struct dwarf2_loclist_baton *baton;
7468
7469 baton = obstack_alloc (&objfile->symbol_obstack,
7470 sizeof (struct dwarf2_loclist_baton));
7471 baton->objfile = objfile;
7472
7473 /* We don't know how long the location list is, but make sure we
7474 don't run off the edge of the section. */
7475 baton->size = dwarf_loc_size - DW_UNSND (attr);
7476 baton->data = dwarf_loc_buffer + DW_UNSND (attr);
7477 baton->base_address = cu_header->base_address;
7478 if (cu_header->base_known == 0)
7479 complaint (&symfile_complaints,
7480 "Location list used without specifying the CU base address.");
7481
7482 SYMBOL_LOCATION_FUNCS (sym) = &dwarf2_loclist_funcs;
7483 SYMBOL_LOCATION_BATON (sym) = baton;
7484 }
7485 else
7486 {
7487 struct dwarf2_locexpr_baton *baton;
7488
7489 baton = obstack_alloc (&objfile->symbol_obstack,
7490 sizeof (struct dwarf2_locexpr_baton));
7491 baton->objfile = objfile;
7492
7493 if (attr_form_is_block (attr))
7494 {
7495 /* Note that we're just copying the block's data pointer
7496 here, not the actual data. We're still pointing into the
7497 dwarf_info_buffer for SYM's objfile; right now we never
7498 release that buffer, but when we do clean up properly
7499 this may need to change. */
7500 baton->size = DW_BLOCK (attr)->size;
7501 baton->data = DW_BLOCK (attr)->data;
7502 }
7503 else
7504 {
7505 dwarf2_invalid_attrib_class_complaint ("location description",
7506 SYMBOL_NATURAL_NAME (sym));
7507 baton->size = 0;
7508 baton->data = NULL;
7509 }
7510
7511 SYMBOL_LOCATION_FUNCS (sym) = &dwarf2_locexpr_funcs;
7512 SYMBOL_LOCATION_BATON (sym) = baton;
7513 }
7514 }
This page took 0.273857 seconds and 4 git commands to generate.