]> Git Repo - binutils.git/blame - gdb/dwarf2read.c
projects / binutils.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
gdbserver/configure does not exist
[binutils.git] / gdb / dwarf2read.c
CommitLineData
fcf05549
SS		 1/* DWARF 2 debugging format support for GDB.
2 Copyright 1994, 1995, 1996 Free Software Foundation, Inc.
3
4 Adapted by Gary Funck ([email protected]), Intrepid Technology,
5 Inc. with support from Florida State University (under contract
6 with the Ada Joint Program Office), and Silicon Graphics, Inc.
7 Initial contribution by Brent Benson, Harris Computer Systems, Inc.,
8 based on Fred Fish's (Cygnus Support) implementation of DWARF 1
9 support in dwarfread.c
10
11This file is part of GDB.
12
13This program is free software; you can redistribute it and/or modify
14it under the terms of the GNU General Public License as published by
15the Free Software Foundation; either version 2 of the License, or (at
16your option) any later version.
17
18This program is distributed in the hope that it will be useful, but
19WITHOUT ANY WARRANTY; without even the implied warranty of
20MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21General Public License for more details.
22
23You should have received a copy of the GNU General Public License
24along with this program; if not, write to the Free Software
25Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26
27#include "defs.h"
28#include "bfd.h"
29#include "symtab.h"
30#include "gdbtypes.h"
31#include "symfile.h"
32#include "objfiles.h"
33#include "elf/dwarf2.h"
34#include "buildsym.h"
35#include "demangle.h"
36#include "expression.h"
37#include "language.h"
38
39#include <fcntl.h>
8501c742 40#include "gdb_string.h"
fcf05549
SS		 41#include <sys/types.h>
42
fcf05549
SS		 43/* .debug_info header for a compilation unit
44 Because of alignment constraints, this structure has padding and cannot
45 be mapped directly onto the beginning of the .debug_info section. */
46typedef struct comp_unit_header
47 {
48 unsigned int length; /* length of the .debug_info
49 contribution */
50 unsigned short version; /* version number -- 2 for DWARF
51 version 2 */
52 unsigned int abbrev_offset; /* offset into .debug_abbrev section */
53 unsigned char addr_size; /* byte size of an address -- 4 */
54 }
55_COMP_UNIT_HEADER;
56#define _ACTUAL_COMP_UNIT_HEADER_SIZE 11
57
58/* .debug_pubnames header
59 Because of alignment constraints, this structure has padding and cannot
60 be mapped directly onto the beginning of the .debug_info section. */
61typedef struct pubnames_header
62 {
63 unsigned int length; /* length of the .debug_pubnames
64 contribution */
65 unsigned char version; /* version number -- 2 for DWARF
66 version 2 */
67 unsigned int info_offset; /* offset into .debug_info section */
68 unsigned int info_size; /* byte size of .debug_info section
69 portion */
70 }
71_PUBNAMES_HEADER;
72#define _ACTUAL_PUBNAMES_HEADER_SIZE 13
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. */
77typedef struct aranges_header
78 {
79 unsigned int length; /* byte len of the .debug_aranges
80 contribution */
81 unsigned short version; /* version number -- 2 for DWARF
82 version 2 */
83 unsigned int info_offset; /* offset into .debug_info section */
84 unsigned char addr_size; /* byte size of an address */
85 unsigned char seg_size; /* byte size of segment descriptor */
86 }
87_ARANGES_HEADER;
88#define _ACTUAL_ARANGES_HEADER_SIZE 12
89
90/* .debug_line statement program prologue
91 Because of alignment constraints, this structure has padding and cannot
92 be mapped directly onto the beginning of the .debug_info section. */
93typedef struct statement_prologue
94 {
95 unsigned int total_length; /* byte length of the statement
96 information */
97 unsigned short version; /* version number -- 2 for DWARF
98 version 2 */
99 unsigned int prologue_length; /* # bytes between prologue &
100 stmt program */
101 unsigned char minimum_instruction_length; /* byte size of
102 smallest instr */
103 unsigned char default_is_stmt; /* initial value of is_stmt
104 register */
105 char line_base;
106 unsigned char line_range;
107 unsigned char opcode_base; /* number assigned to first special
108 opcode */
109 unsigned char *standard_opcode_lengths;
110 }
111_STATEMENT_PROLOGUE;
112
113/* offsets and sizes of debugging sections */
114
115static file_ptr dwarf_info_offset;
116static file_ptr dwarf_abbrev_offset;
117static file_ptr dwarf_line_offset;
118static file_ptr dwarf_pubnames_offset;
119static file_ptr dwarf_aranges_offset;
120static file_ptr dwarf_loc_offset;
121static file_ptr dwarf_macinfo_offset;
122static file_ptr dwarf_str_offset;
123
124static unsigned int dwarf_info_size;
125static unsigned int dwarf_abbrev_size;
126static unsigned int dwarf_line_size;
127static unsigned int dwarf_pubnames_size;
128static unsigned int dwarf_aranges_size;
129static unsigned int dwarf_loc_size;
130static unsigned int dwarf_macinfo_size;
131static unsigned int dwarf_str_size;
132
133/* names of the debugging sections */
134
135#define INFO_SECTION ".debug_info"
136#define ABBREV_SECTION ".debug_abbrev"
137#define LINE_SECTION ".debug_line"
138#define PUBNAMES_SECTION ".debug_pubnames"
139#define ARANGES_SECTION ".debug_aranges"
140#define LOC_SECTION ".debug_loc"
141#define MACINFO_SECTION ".debug_macinfo"
142#define STR_SECTION ".debug_str"
143
144/* Get at parts of an attribute structure */
145
146#define DW_STRING(attr) ((attr)->u.str)
147#define DW_UNSND(attr) ((attr)->u.unsnd)
148#define DW_BLOCK(attr) ((attr)->u.blk)
149#define DW_SND(attr) ((attr)->u.snd)
150#define DW_ADDR(attr) ((attr)->u.addr)
151
152/* local data types */
153
154/* The data in a compilation unit header looks like this. */
155struct comp_unit_head
156 {
157 int length;
158 short version;
159 int abbrev_offset;
160 unsigned char addr_size;
161 };
162
163/* The data in the .debug_line statement prologue looks like this. */
164struct line_head
165 {
166 unsigned int total_length;
167 unsigned short version;
168 unsigned int prologue_length;
169 unsigned char minimum_instruction_length;
170 unsigned char default_is_stmt;
171 char line_base;
172 unsigned char line_range;
173 unsigned char opcode_base;
174 unsigned char *standard_opcode_lengths;
175 };
176
177/* When we construct a partial symbol table entry we only
178 need this much information. */
179struct partial_die_info
180 {
181 unsigned short tag;
182 unsigned char has_children;
183 unsigned char is_external;
184 unsigned int offset;
185 unsigned int abbrev;
186 char *name;
187 CORE_ADDR lowpc;
188 CORE_ADDR highpc;
189 struct dwarf_block *locdesc;
190 unsigned int language;
191 int value;
192 };
193
194/* This data structure holds the information of an abbrev. */
195struct abbrev_info
196 {
197 unsigned int number; /* number identifying abbrev */
198 unsigned int tag; /* dwarf tag */
199 int has_children; /* boolean */
200 unsigned int num_attrs; /* number of attributes */
201 struct attr_abbrev *attrs; /* an array of attribute descriptions */
202 struct abbrev_info *next; /* next in chain */
203 };
204
205struct attr_abbrev
206 {
207 unsigned int name;
208 unsigned int form;
209 };
210
211/* This data structure holds a complete die structure. */
212struct die_info
213 {
214 unsigned short tag; /* Tag indicating type of die */
215 unsigned short has_children; /* Does the die have children */
216 unsigned int abbrev; /* Abbrev number */
217 unsigned int offset; /* Offset in .debug_info section */
218 unsigned int num_attrs; /* Number of attributes */
219 struct attribute *attrs; /* An array of attributes */
220 struct die_info *next_ref; /* Next die in ref hash table */
221 struct die_info *next; /* Next die in linked list */
222 struct type *type; /* Cached type information */
223 };
224
225/* Attributes have a name and a value */
226struct attribute
227 {
228 unsigned short name;
229 unsigned short form;
230 union
231 {
232 char *str;
233 struct dwarf_block *blk;
234 unsigned int unsnd;
235 int snd;
236 CORE_ADDR addr;
237 }
238 u;
239 };
240
241/* Blocks are a bunch of untyped bytes. */
242struct dwarf_block
243 {
244 unsigned int size;
245 char *data;
246 };
247
248/* We only hold one compilation unit's abbrevs in
249 memory at any one time. */
250#ifndef ABBREV_HASH_SIZE
251#define ABBREV_HASH_SIZE 121
252#endif
253#ifndef ATTR_ALLOC_CHUNK
254#define ATTR_ALLOC_CHUNK 4
255#endif
256
257/* FIXME: do away with this */
258
259#ifndef DWARF2_MAX_STRING_SIZE
260#define DWARF2_MAX_STRING_SIZE 1024
261#endif
262
263static struct abbrev_info *dwarf2_abbrevs[ABBREV_HASH_SIZE];
264
265/* A hash table of die offsets for following references. */
266#ifndef REF_HASH_SIZE
267#define REF_HASH_SIZE 1021
268#endif
269
270static struct die_info *die_ref_table[REF_HASH_SIZE];
271
272/* Allocate fields for structs, unions and enums in this size. */
273#ifndef DW_FIELD_ALLOC_CHUNK
274#define DW_FIELD_ALLOC_CHUNK 4
275#endif
276
277/* The language we are debugging. */
278static enum language cu_language;
279static const struct language_defn *cu_language_defn;
280
281/* Actually data from the sections. */
282static char *dwarf_info_buffer;
283static char *dwarf_abbrev_buffer;
284static char *dwarf_line_buffer;
285
286/* A zeroed version of several structures for initialization purposes. */
287static struct partial_die_info zeroed_partial_die;
288static struct die_info zeroed_die;
289
290/* The generic symbol table building routines have separate lists for
291 file scope symbols and all all other scopes (local scopes). So
292 we need to select the right one to pass to add_symbol_to_list().
293 We do it by keeping a pointer to the correct list in list_in_scope.
294
295 FIXME: The original dwarf code just treated the file scope as the first
296 local scope, and all other local scopes as nested local scopes, and worked
297 fine. Check to see if we really need to distinguish these
298 in buildsym.c. */
299static struct pending **list_in_scope = &file_symbols;
300static int isreg; /* Kludge to identify register
301 variables */
302static int offreg; /* Kludge to identify basereg
303 references */
304
305/* This value is added to each symbol value. FIXME: Generalize to
306 the section_offsets structure used by dbxread (once this is done,
307 pass the appropriate section number to end_symtab). */
308static CORE_ADDR baseaddr; /* Add to each symbol value */
309
310/* Maintain an array of referenced fundamental types for the current
311 compilation unit being read. For DWARF version 1, we have to construct
312 the fundamental types on the fly, since no information about the
313 fundamental types is supplied. Each such fundamental type is created by
314 calling a language dependent routine to create the type, and then a
315 pointer to that type is then placed in the array at the index specified
316 by it's FT_<TYPENAME> value. The array has a fixed size set by the
317 FT_NUM_MEMBERS compile time constant, which is the number of predefined
318 fundamental types gdb knows how to construct. */
319static struct type *ftypes[FT_NUM_MEMBERS]; /* Fundamental types */
320
321/* FIXME - set from bfd function */
322static int bits_per_byte = 8;
323
324/* Keep track of whether we have given a warning about not
325 handling DW_TAG_const_type dies. */
326static int tag_const_warning_given = 0;
327
328/* Keep track of whether we have given a warning about not
329 handling DW_TAG_volatile_type dies. */
330static int tag_volatile_warning_given = 0;
331
332/* Keep track of constant array bound warning. */
333static int array_bound_warning_given = 0;
334
335/* Remember the addr_size read from the dwarf.
336 If a target expects to link compilation units with differing address
337 sizes, gdb needs to be sure that the appropriate size is here for
338 whatever scope is currently getting read. */
339static int address_size;
340
341/* Externals references. */
342extern int info_verbose; /* From main.c; nonzero => verbose */
343
344/* local function prototypes */
345
346static void dwarf2_locate_sections PARAMS ((bfd *, asection *, PTR));
347
348static void dwarf2_build_psymtabs_easy PARAMS ((struct objfile *,
349 struct section_offsets *,
350 int));
351static void dwarf2_build_psymtabs_hard PARAMS ((struct objfile *,
352 struct section_offsets *,
353 int));
354
355static char *scan_partial_symbols PARAMS ((char *, struct objfile *,
356 CORE_ADDR *, CORE_ADDR *));
357
358static void add_partial_symbol PARAMS ((struct partial_die_info *,
359 struct objfile *));
360
361static void dwarf2_psymtab_to_symtab PARAMS ((struct partial_symtab *));
362
363static void psymtab_to_symtab_1 PARAMS ((struct partial_symtab *));
364
365static void add_die_to_symtab PARAMS ((struct die_info *, struct objfile *));
366
367static char *dwarf2_read_section PARAMS ((bfd *, file_ptr, unsigned int));
368
369static void dwarf2_read_abbrevs PARAMS ((bfd *, unsigned int));
370
371static void dwarf2_empty_abbrev_table PARAMS ((void));
372
373static struct abbrev_info *dwarf2_lookup_abbrev PARAMS ((unsigned int));
374
375static char *read_partial_die PARAMS ((struct partial_die_info *,
376 bfd *, char *, int *));
377
378static char *read_full_die PARAMS ((struct die_info **, bfd *, char *));
379
380static unsigned int read_1_byte PARAMS ((bfd *, char *));
381
382static unsigned int read_2_bytes PARAMS ((bfd *, char *));
383
384static unsigned int read_4_bytes PARAMS ((bfd *, char *));
385
386static unsigned int read_8_bytes PARAMS ((bfd *, char *));
387
388static CORE_ADDR read_address PARAMS ((bfd *, char *));
389
390static char *read_n_bytes PARAMS ((bfd *, char *, unsigned int));
391
392static char *read_string PARAMS ((bfd *, char *, unsigned int *));
393
394static unsigned int read_unsigned_leb128 PARAMS ((bfd *, char *,
395 unsigned int *));
396
397static int read_signed_leb128 PARAMS ((bfd *, char *, unsigned int *));
398
399static void set_cu_language PARAMS ((unsigned int));
400
401static void record_minimal_symbol PARAMS ((char *, CORE_ADDR,
402 enum minimal_symbol_type,
403 struct objfile *));
404
405static int convert_locdesc PARAMS ((struct dwarf_block *));
406
407static struct attribute *dwarf_attr PARAMS ((struct die_info *,
408 unsigned int));
409
410static void dwarf_decode_lines PARAMS ((unsigned int, bfd *));
411
412static struct symbol *new_symbol PARAMS ((struct die_info * die, struct objfile * objfile));
413
414static struct type *die_type PARAMS ((struct die_info * die, struct objfile * objfile));
415
416static struct type *type_at_offset PARAMS ((unsigned int offset, struct objfile * objfile));
417
418static struct type *tag_type_to_type PARAMS ((struct die_info * die, struct objfile * objfile));
419
420static void read_type_die PARAMS ((struct die_info * die, struct objfile * objfile));
421
422static void read_typedef PARAMS ((struct die_info * die, struct objfile * objfile));
423
424static void read_base_type PARAMS ((struct die_info * die, struct objfile * objfile));
425
426static void read_file_scope PARAMS ((struct die_info * die, struct objfile * objfile));
427
428static void read_func_scope PARAMS ((struct die_info * die, struct objfile * objfile));
429
430static void read_lexical_block_scope PARAMS ((struct die_info * die,
431 struct objfile * objfile));
432
433static void read_structure_scope PARAMS ((struct die_info * die, struct objfile * objfile));
434
435static void read_common_block PARAMS ((struct die_info * die, struct objfile * objfile));
436
437static void read_enumeration PARAMS ((struct die_info * die, struct objfile * objfile));
438
439static struct type * dwarf_base_type PARAMS ((int encoding, int size));
440
441static CORE_ADDR decode_locdesc PARAMS ((struct dwarf_block *,
442 struct objfile *));
443
444static char *create_name PARAMS ((char *, struct obstack *));
445
446static void dwarf_read_array_type PARAMS ((struct die_info * die,
447 struct objfile * objfile));
448
449static void read_tag_pointer_type PARAMS ((struct die_info * die,
450 struct objfile * objfile));
451
452static void read_tag_const_type PARAMS ((struct die_info * die,
453 struct objfile * objfile));
454
455static void read_tag_volatile_type PARAMS ((struct die_info * die,
456 struct objfile * objfile));
457
458static void read_tag_string_type PARAMS ((struct die_info * die,
459 struct objfile * objfile));
460
461static void read_subroutine_type PARAMS ((struct die_info * die,
462 struct objfile * objfile));
463
464struct die_info *read_comp_unit PARAMS ((char *info_ptr, bfd * abfd));
465
466static void free_die_list PARAMS ((struct die_info * dies));
467
468static void process_die PARAMS ((struct die_info *, struct objfile *));
469
470static char *dwarf_tag_name PARAMS ((unsigned tag));
471
472static char *dwarf_attr_name PARAMS ((unsigned attr));
473
474static char *dwarf_form_name PARAMS ((unsigned form));
475
476static char *dwarf_stack_op_name PARAMS ((unsigned op));
477
478static char *dwarf_bool_name PARAMS ((unsigned bool));
479
480static char *dwarf_bool_name PARAMS ((unsigned tag));
481
482static char *dwarf_type_encoding_name PARAMS ((unsigned enc));
483
484static char *dwarf_cfi_name PARAMS ((unsigned cfi_opc));
485
486struct die_info *copy_die PARAMS ((struct die_info *old_die));
487
488struct die_info *sibling_die PARAMS ((struct die_info *die));
489
490void dump_die PARAMS ((struct die_info *die));
491
492void dump_die_list PARAMS ((struct die_info *dies));
493
494void store_in_ref_table PARAMS ((unsigned int, struct die_info *));
495
496struct die_info *follow_die_ref PARAMS ((unsigned int offset));
497
498static struct type *dwarf2_fundamental_type PARAMS ((struct objfile *, int));
499
500/* memory allocation interface */
501
502static struct type *dwarf_alloc_type PARAMS ((struct objfile *));
503
504static struct abbrev_info *dwarf_alloc_abbrev PARAMS ((void));
505
506static struct dwarf_block *dwarf_alloc_block PARAMS ((void));
507
508static struct die_info *dwarf_alloc_die PARAMS ((void));
509
510/* Try to locate the sections we need for DWARF 2 debugging
511 information and return true if we have enough to do something. */
512
513int
514dwarf2_has_info (abfd)
515 bfd *abfd;
516{
517 dwarf_info_offset = dwarf_abbrev_offset = dwarf_line_offset = 0;
518 bfd_map_over_sections (abfd, dwarf2_locate_sections, NULL);
519 if (dwarf_info_offset && dwarf_abbrev_offset && dwarf_line_offset)
520 {
521 return 1;
522 }
523 else
524 {
525 return 0;
526 }
527}
528
529/* This function is mapped across the sections and remembers the
530 offset and size of each of the debugging sections we are interested
531 in. */
532
533static void
534dwarf2_locate_sections (ignore_abfd, sectp, ignore_ptr)
535 bfd *ignore_abfd;
536 asection *sectp;
537 PTR ignore_ptr;
538{
539 if (STREQ (sectp->name, INFO_SECTION))
540 {
541 dwarf_info_offset = sectp->filepos;
542 dwarf_info_size = bfd_get_section_size_before_reloc (sectp);
543 }
544 else if (STREQ (sectp->name, ABBREV_SECTION))
545 {
546 dwarf_abbrev_offset = sectp->filepos;
547 dwarf_abbrev_size = bfd_get_section_size_before_reloc (sectp);
548 }
549 else if (STREQ (sectp->name, LINE_SECTION))
550 {
551 dwarf_line_offset = sectp->filepos;
552 dwarf_line_size = bfd_get_section_size_before_reloc (sectp);
553 }
554 else if (STREQ (sectp->name, PUBNAMES_SECTION))
555 {
556 dwarf_pubnames_offset = sectp->filepos;
557 dwarf_pubnames_size = bfd_get_section_size_before_reloc (sectp);
558 }
559 else if (STREQ (sectp->name, ARANGES_SECTION))
560 {
561 dwarf_aranges_offset = sectp->filepos;
562 dwarf_aranges_size = bfd_get_section_size_before_reloc (sectp);
563 }
564 else if (STREQ (sectp->name, LOC_SECTION))
565 {
566 dwarf_loc_offset = sectp->filepos;
567 dwarf_loc_size = bfd_get_section_size_before_reloc (sectp);
568 }
569 else if (STREQ (sectp->name, MACINFO_SECTION))
570 {
571 dwarf_macinfo_offset = sectp->filepos;
572 dwarf_macinfo_size = bfd_get_section_size_before_reloc (sectp);
573 }
574 else if (STREQ (sectp->name, STR_SECTION))
575 {
576 dwarf_str_offset = sectp->filepos;
577 dwarf_str_size = bfd_get_section_size_before_reloc (sectp);
578 }
579}
580
581/* Build a partial symbol table. */
582
583void
584dwarf2_build_psymtabs (objfile, section_offsets, mainline)
585 struct objfile *objfile;
586 struct section_offsets *section_offsets;
587 int mainline;
588{
589 bfd *abfd = objfile->obfd;
590
591 /* We definitely need the .debug_info, .debug_abbrev, and .debug_line
592 sections */
593
594 dwarf_info_buffer = dwarf2_read_section (abfd,
595 dwarf_info_offset,
596 dwarf_info_size);
597 dwarf_abbrev_buffer = dwarf2_read_section (abfd,
598 dwarf_abbrev_offset,
599 dwarf_abbrev_size);
600 dwarf_line_buffer = dwarf2_read_section (abfd,
601 dwarf_line_offset,
602 dwarf_line_size);
603
604 if (mainline || objfile->global_psymbols.size == 0 ||
605 objfile->static_psymbols.size == 0)
606 {
607 init_psymbol_list (objfile, 1024);
608 }
609
610#if 0
611 if (dwarf_aranges_offset && dwarf_pubnames_offset)
612 {
613 /* Things are significanlty easier if we have .debug_aranges and
614 .debug_pubnames sections */
615
616 dwarf2_build_psymtabs_easy (objfile, section_offsets, mainline);
617 }
618 else
619#endif
620 /* only test this case for now */
621 {
622 /* In this case we have to work a bit harder */
623 dwarf2_build_psymtabs_hard (objfile, section_offsets, mainline);
624 }
625}
626
627/* Build the partial symbol table from the information in the
628 .debug_pubnames and .debug_aranges sections. */
629
630static void
631dwarf2_build_psymtabs_easy (objfile, section_offsets, mainline)
632 struct objfile *objfile;
633 struct section_offsets *section_offsets;
634 int mainline;
635{
636 bfd *abfd = objfile->obfd;
637 char *aranges_buffer, *pubnames_buffer;
638 char *aranges_ptr, *pubnames_ptr;
639 unsigned int entry_length, version, info_offset, info_size;
640
641 pubnames_buffer = dwarf2_read_section (abfd,
642 dwarf_pubnames_offset,
643 dwarf_pubnames_size);
644 pubnames_ptr = pubnames_buffer;
645 while ((pubnames_ptr - pubnames_buffer) < dwarf_pubnames_size)
646 {
647 entry_length = read_4_bytes (abfd, pubnames_ptr);
648 pubnames_ptr += 4;
649 version = read_1_byte (abfd, pubnames_ptr);
650 pubnames_ptr += 1;
651 info_offset = read_4_bytes (abfd, pubnames_ptr);
652 pubnames_ptr += 4;
653 info_size = read_4_bytes (abfd, pubnames_ptr);
654 pubnames_ptr += 4;
655 }
656
657 aranges_buffer = dwarf2_read_section (abfd,
658 dwarf_aranges_offset,
659 dwarf_aranges_size);
660
661}
662
663/* Build the partial symbol table by doing a quick pass through the
664 .debug_info and .debug_abbrev sections. */
665
666static void
667dwarf2_build_psymtabs_hard (objfile, section_offsets, mainline)
668 struct objfile *objfile;
669 struct section_offsets *section_offsets;
670 int mainline;
671{
672 /* Instead of reading this into a big buffer, we should probably use
673 mmap() on architectures that support it. (FIXME) */
674 bfd *abfd = objfile->obfd;
675 char *info_ptr, *abbrev_ptr;
676 char *beg_of_comp_unit, *comp_unit_die_offset;
677 struct comp_unit_head cu_header;
678 struct partial_die_info comp_unit_die;
679 struct partial_symtab *pst;
680 struct cleanup *back_to;
681 int comp_unit_has_pc_info;
682 int has_pc_info;
683 CORE_ADDR lowpc, highpc;
684
685 comp_unit_die = zeroed_partial_die;
686 info_ptr = dwarf_info_buffer;
687 abbrev_ptr = dwarf_abbrev_buffer;
688
689 while ((info_ptr - dwarf_info_buffer)
690 + ((info_ptr - dwarf_info_buffer) % 4) < dwarf_info_size)
691 {
692 beg_of_comp_unit = info_ptr;
693 cu_header.length = read_4_bytes (abfd, info_ptr);
694 info_ptr += 4;
695 cu_header.version = read_2_bytes (abfd, info_ptr);
696 info_ptr += 2;
697 cu_header.abbrev_offset = read_4_bytes (abfd, info_ptr);
698 info_ptr += 4;
699 cu_header.addr_size = read_1_byte (abfd, info_ptr);
700 info_ptr += 1;
701 address_size = cu_header.addr_size;
702
703 if (cu_header.version != 2)
704 {
705 error ("Dwarf Error: wrong version in compilation unit header.");
706 return;
707 }
708
709 /* Read the abbrevs for this compilation unit into a table */
710 dwarf2_read_abbrevs (abfd, cu_header.abbrev_offset);
711 back_to = make_cleanup (dwarf2_empty_abbrev_table, NULL);
712
713 /* Read the compilation unit die */
714 info_ptr = read_partial_die (&comp_unit_die, abfd,
715 info_ptr, &comp_unit_has_pc_info);
716
717 /* Set the language we're debugging */
718 set_cu_language (comp_unit_die.language);
719
720 /* Allocate a new partial symbol table structure */
721 pst = start_psymtab_common (objfile, section_offsets,
722 comp_unit_die.name,
723 comp_unit_die.lowpc,
724 objfile->global_psymbols.next,
725 objfile->static_psymbols.next);
726
727 /* Store offset in the .debug_info section of the comp_unit_die. */
728 pst->read_symtab_private = (char *)
729 (beg_of_comp_unit - dwarf_info_buffer);
730
731 /* Store the function that reads in the rest of the symbol table */
732 pst->read_symtab = dwarf2_psymtab_to_symtab;
733
734 /* Read the rest of the partial symbols from this comp unit */
735 info_ptr = scan_partial_symbols (info_ptr, objfile, &lowpc, &highpc);
736
737 /* If the compilation unit didn't have an explicit address range,
738 then use the information extracted from its child dies. */
739 if (!comp_unit_has_pc_info)
740 {
741 comp_unit_die.lowpc = lowpc;
742 comp_unit_die.highpc = highpc;
743 }
744 pst->textlow = comp_unit_die.lowpc;
745 pst->texthigh = comp_unit_die.highpc;
746
747 pst->n_global_syms = objfile->global_psymbols.next -
748 (objfile->global_psymbols.list + pst->globals_offset);
749 pst->n_static_syms = objfile->static_psymbols.next -
750 (objfile->static_psymbols.list + pst->statics_offset);
751 sort_pst_symbols (pst);
752
753 /* If there is already a psymtab or symtab for a file of this
754 name, remove it. (If there is a symtab, more drastic things
755 also happen.) This happens in VxWorks. */
756 free_named_symtabs (pst->filename);
757
758 info_ptr = beg_of_comp_unit + cu_header.length + 4;
759 }
760 do_cleanups (back_to);
761}
762
763/* Read in all interesting dies to the end of the compilation unit. */
764
765static char *
766scan_partial_symbols (info_ptr, objfile, lowpc, highpc)
767 char *info_ptr;
768 struct objfile *objfile;
769 CORE_ADDR *lowpc;
770 CORE_ADDR *highpc;
771{
772 /* FIXME: This should free the attributes of the partial die structure
773 when it is done with them (is there a more efficient way
774 to do this). */
775 bfd *abfd = objfile->obfd;
776 struct partial_die_info pdi;
777 int nesting_level = 1; /* we've already read in comp_unit_die */
778 int has_pc_info;
779
780 pdi = zeroed_partial_die;
781 *lowpc = ((CORE_ADDR) -1);
782 *highpc = ((CORE_ADDR) 0);
783 do
784 {
785 info_ptr = read_partial_die (&pdi, abfd, info_ptr, &has_pc_info);
786 switch (pdi.tag)
787 {
788 case DW_TAG_subprogram:
789 case DW_TAG_variable:
790 case DW_TAG_typedef:
791 case DW_TAG_class_type:
792 case DW_TAG_structure_type:
793 case DW_TAG_union_type:
794 if (pdi.is_external || nesting_level == 1)
795 {
796 if (pdi.name)
797 {
798 add_partial_symbol (&pdi, objfile);
799 }
800 }
801 if (has_pc_info)
802 {
803 if (pdi.lowpc < *lowpc)
804 {
805 *lowpc = pdi.lowpc;
806 }
807 if (pdi.highpc > *lowpc)
808 {
809 *highpc = pdi.highpc;
810 }
811 }
812 }
813 if (pdi.has_children)
814 {
815 nesting_level++;
816 }
817 if (pdi.tag == 0)
818 {
819 nesting_level--;
820 }
821 }
822 while (nesting_level);
823 return info_ptr;
824}
825
826static void
827add_partial_symbol (pdi, objfile)
828 struct partial_die_info *pdi;
829 struct objfile *objfile;
830{
831 switch (pdi->tag)
832 {
833 case DW_TAG_subprogram:
834 if (pdi->is_external)
835 {
836 record_minimal_symbol (pdi->name, pdi->lowpc,
837 mst_text, objfile);
838 add_psymbol_to_list (pdi->name, strlen (pdi->name),
839 VAR_NAMESPACE, LOC_BLOCK,
840 &objfile->global_psymbols,
841 0, pdi->lowpc, cu_language, objfile);
842 }
843 else
844 {
845 add_psymbol_to_list (pdi->name, strlen (pdi->name),
846 VAR_NAMESPACE, LOC_BLOCK,
847 &objfile->static_psymbols,
848 0, pdi->lowpc, cu_language, objfile);
849 }
850 break;
851 case DW_TAG_variable:
852 if (pdi->is_external)
853 {
854 record_minimal_symbol (pdi->name, convert_locdesc (pdi->locdesc),
855 mst_data, objfile);
856 add_psymbol_to_list (pdi->name, strlen (pdi->name),
857 VAR_NAMESPACE, LOC_STATIC,
858 &objfile->global_psymbols,
859 0, 0, cu_language, objfile);
860 }
861 else
862 {
863 add_psymbol_to_list (pdi->name, strlen (pdi->name),
864 VAR_NAMESPACE, LOC_STATIC,
865 &objfile->static_psymbols,
866 0, 0, cu_language, objfile);
867 }
868 break;
869 case DW_TAG_typedef:
870 add_psymbol_to_list (pdi->name, strlen (pdi->name),
871 VAR_NAMESPACE, LOC_TYPEDEF,
872 &objfile->static_psymbols,
873 0, 0, cu_language, objfile);
874 break;
875 case DW_TAG_class_type:
876 case DW_TAG_structure_type:
877 case DW_TAG_union_type:
878 case DW_TAG_enumeration_type:
879 add_psymbol_to_list (pdi->name, strlen (pdi->name),
880 STRUCT_NAMESPACE, LOC_TYPEDEF,
881 &objfile->static_psymbols,
882 0, 0, cu_language, objfile);
883 if (cu_language == language_cplus)
884 {
885 /* For C++, these implicitly act as typedefs as well. */
886 add_psymbol_to_list (pdi->name, strlen (pdi->name),
887 VAR_NAMESPACE, LOC_TYPEDEF,
888 &objfile->static_psymbols,
889 0, 0, cu_language, objfile);
890 }
891 break;
892 }
893}
894
895/* Expand this partial symbol table into a full symbol table. */
896
897static void
898dwarf2_psymtab_to_symtab (pst)
899 struct partial_symtab *pst;
900{
901 /* FIXME: This is barely more than a stub. */
902 if (pst != NULL)
903 {
904 if (pst->readin)
905 {
906 warning ("bug: psymtab for %s is already read in.", pst->filename);
907 }
908 else
909 {
910 psymtab_to_symtab_1 (pst);
911 }
912 }
913}
914
915static void
916psymtab_to_symtab_1 (pst)
917 struct partial_symtab *pst;
918{
919 struct objfile *objfile = pst->objfile;
920 bfd *abfd = objfile->obfd;
921 struct comp_unit_head cu_header;
922 struct die_info *dies;
923 struct attribute *attr;
924 unsigned long offset;
925 unsigned long int nesting_level;
926 CORE_ADDR highpc;
927 struct attribute *high_pc_attr;
928 struct die_info *child_die;
929 char *info_ptr;
930 struct context_stack *context;
931 struct symtab *symtab;
932 struct cleanup *abbrev_cleanup, *die_cleanup;
933
934 /* Get the offset of this compilation units debug info */
935 offset = (unsigned long) pst->read_symtab_private;
936 info_ptr = dwarf_info_buffer + offset;
937
938 /* read in the comp_unit header */
939 cu_header.length = read_4_bytes (abfd, info_ptr);
940 info_ptr += 4;
941 cu_header.version = read_2_bytes (abfd, info_ptr);
942 info_ptr += 2;
943 cu_header.abbrev_offset = read_4_bytes (abfd, info_ptr);
944 info_ptr += 4;
945 cu_header.addr_size = read_1_byte (abfd, info_ptr);
946 info_ptr += 1;
947
948 /* Read the abbrevs for this compilation unit */
949 dwarf2_read_abbrevs (abfd, cu_header.abbrev_offset);
950 abbrev_cleanup = make_cleanup (dwarf2_empty_abbrev_table, NULL);
951
952 dies = read_comp_unit (info_ptr, abfd);
953
954 die_cleanup = make_cleanup (free_die_list, dies);
955
956 /* Do line number decoding in read_file_scope () */
957 process_die (dies, objfile);
958
959 attr = dwarf_attr (dies, DW_AT_high_pc);
960 if (attr)
961 {
962 highpc = DW_ADDR (attr);
963 }
964 else
965 {
966 /* Some compilers don't define a DW_AT_high_pc attribute for
967 the compilation unit. If the DW_AT_high_pc is missing,
968 synthesize it, by scanning the DIE's below the compilation unit. */
969 highpc = 0;
970 if (dies->has_children)
971 {
972 child_die = dies->next;
973 while (child_die && child_die->tag)
974 {
975 if (child_die->tag == DW_TAG_subprogram)
976 {
977 high_pc_attr = dwarf_attr (child_die, DW_AT_high_pc);
978 if (high_pc_attr)
979 {
980 highpc = max (highpc, DW_ADDR (high_pc_attr));
981 }
982 }
983 child_die = sibling_die (child_die);
984 }
985 }
986 }
987
988 symtab = end_symtab (highpc, objfile, 0);
989 if (symtab != NULL)
990 {
991 symtab->language = cu_language;
992 }
993 pst->symtab = symtab;
994 pst->readin = 1;
995 if (info_verbose)
996 {
997 printf_filtered ("Sorting symbol table...");
998 wrap_here ("");
999 fflush (stdout);
1000 }
1001 sort_symtab_syms (pst->symtab);
1002 do_cleanups (abbrev_cleanup);
1003}
1004
1005/* Process a die and its children. */
1006
1007static void
1008process_die (die, objfile)
1009 struct die_info *die;
1010 struct objfile *objfile;
1011{
1012 switch (die->tag)
1013 {
1014 case DW_TAG_padding:
1015 break;
1016 case DW_TAG_compile_unit:
1017 read_file_scope (die, objfile);
1018 break;
1019 case DW_TAG_subprogram:
1020 if (dwarf_attr (die, DW_AT_low_pc))
1021 {
1022 read_func_scope (die, objfile);
1023 }
1024 break;
1025 case DW_TAG_lexical_block:
1026 read_lexical_block_scope (die, objfile);
1027 break;
1028 case DW_TAG_class_type:
1029 case DW_TAG_structure_type:
1030 case DW_TAG_union_type:
1031 read_structure_scope (die, objfile);
1032 break;
1033 case DW_TAG_enumeration_type:
1034 read_enumeration (die, objfile);
1035 break;
1036 case DW_TAG_subroutine_type:
1037 read_subroutine_type (die, objfile);
1038 break;
1039 case DW_TAG_array_type:
1040 dwarf_read_array_type (die, objfile);
1041 break;
1042 case DW_TAG_pointer_type:
1043 read_tag_pointer_type (die, objfile);
1044 break;
1045 case DW_TAG_string_type:
1046 read_tag_string_type (die, objfile);
1047 break;
1048 case DW_TAG_base_type:
1049 read_base_type (die, objfile);
1050 break;
1051 case DW_TAG_common_block:
1052 read_common_block (die, objfile);
1053 break;
1054 case DW_TAG_common_inclusion:
1055 break;
1056 default:
1057 new_symbol (die, objfile);
1058 break;
1059 }
1060}
1061
1062static void
1063read_file_scope (die, objfile)
1064 struct die_info *die;
1065 struct objfile *objfile;
1066{
1067 unsigned int line_offset = 0;
1068 CORE_ADDR lowpc = ((CORE_ADDR) -1);
1069 CORE_ADDR highpc = ((CORE_ADDR) 0);
1070 struct attribute *attr, *low_pc_attr, *high_pc_attr;
1071 char *name = NULL;
1072 char *comp_dir = NULL;
1073 struct die_info *child_die;
1074 bfd *abfd = objfile->obfd;
1075
1076 low_pc_attr = dwarf_attr (die, DW_AT_low_pc);
1077 if (low_pc_attr)
1078 {
1079 lowpc = DW_ADDR (low_pc_attr);
1080 }
1081 high_pc_attr = dwarf_attr (die, DW_AT_high_pc);
1082 if (high_pc_attr)
1083 {
1084 highpc = DW_ADDR (high_pc_attr);
1085 }
1086 if (!low_pc_attr || !high_pc_attr)
1087 {
1088 if (die->has_children)
1089 {
1090 child_die = die->next;
1091 while (child_die && child_die->tag)
1092 {
1093 if (child_die->tag == DW_TAG_subprogram)
1094 {
1095 low_pc_attr = dwarf_attr (child_die, DW_AT_low_pc);
1096 if (low_pc_attr)
1097 {
1098 lowpc = min (lowpc, DW_ADDR (low_pc_attr));
1099 }
1100 high_pc_attr = dwarf_attr (child_die, DW_AT_high_pc);
1101 if (high_pc_attr)
1102 {
1103 highpc = max (highpc, DW_ADDR (high_pc_attr));
1104 }
1105 }
1106 child_die = sibling_die (child_die);
1107 }
1108 }
1109 }
1110
1111 attr = dwarf_attr (die, DW_AT_name);
1112 if (attr)
1113 {
1114 name = DW_STRING (attr);
1115 }
1116 attr = dwarf_attr (die, DW_AT_comp_dir);
1117 if (attr)
1118 {
1119 comp_dir = DW_STRING (attr);
1120 }
1121
1122 if (objfile->ei.entry_point >= lowpc &&
1123 objfile->ei.entry_point < highpc)
1124 {
1125 objfile->ei.entry_file_lowpc = lowpc;
1126 objfile->ei.entry_file_highpc = highpc;
1127 }
1128
1129 attr = dwarf_attr (die, DW_AT_language);
1130 if (attr)
1131 {
1132 set_cu_language (DW_UNSND (attr));
1133 }
1134
1135#if 0
1136 /* FIXME:Do something here. */
1137 if (dip->at_producer != NULL)
1138 {
1139 handle_producer (dip->at_producer);
1140 }
1141#endif
1142
1143 start_symtab (name, comp_dir, lowpc);
1144
1145 /* Decode line number information. */
1146 attr = dwarf_attr (die, DW_AT_stmt_list);
1147 if (!attr)
1148 {
1149 error (
1150 "Dwarf Error: No line number information for compilation unit: %s.",
1151 name);
1152 }
1153 line_offset = DW_UNSND (attr);
1154 dwarf_decode_lines (line_offset, abfd);
1155
1156 /* Process all dies in compilation unit. */
1157 if (die->has_children)
1158 {
1159 child_die = die->next;
1160 while (child_die && child_die->tag)
1161 {
1162 process_die (child_die, objfile);
1163 child_die = sibling_die (child_die);
1164 }
1165 }
1166}
1167
1168static void
1169read_func_scope (die, objfile)
1170 struct die_info *die;
1171 struct objfile *objfile;
1172{
1173 register struct context_stack *new;
1174 CORE_ADDR lowpc = 0;
1175 CORE_ADDR highpc = 0;
1176 struct die_info *child_die;
1177 struct attribute *attr;
1178 struct minimal_symbol *min_sym;
1179 char *name = NULL;
1180
1181 attr = dwarf_attr (die, DW_AT_name);
1182 if (attr)
1183 {
1184 name = DW_STRING (attr);
1185 }
1186
1187 attr = dwarf_attr (die, DW_AT_low_pc);
1188 if (attr)
1189 {
1190 lowpc = DW_ADDR (attr);
1191 }
1192
1193 attr = dwarf_attr (die, DW_AT_high_pc);
1194 if (attr)
1195 {
1196 highpc = DW_ADDR (attr);
1197 }
1198
1199 if (objfile->ei.entry_point >= lowpc &&
1200 objfile->ei.entry_point < highpc)
1201 {
1202 objfile->ei.entry_func_lowpc = lowpc;
1203 objfile->ei.entry_func_highpc = highpc;
1204 }
1205
1206 if (STREQ (name, "main")) /* FIXME: hardwired name */
1207 {
1208 objfile->ei.main_func_lowpc = lowpc;
1209 objfile->ei.main_func_highpc = highpc;
1210 }
1211 new = push_context (0, lowpc);
1212 new->name = new_symbol (die, objfile);
1213 list_in_scope = &local_symbols;
1214
1215 if (die->has_children)
1216 {
1217 child_die = die->next;
1218 while (child_die && child_die->tag)
1219 {
1220 process_die (child_die, objfile);
1221 child_die = sibling_die (child_die);
1222 }
1223 }
1224
1225 new = pop_context ();
1226 /* Make a block for the local symbols within. */
1227 finish_block (new->name, &local_symbols, new->old_blocks,
1228 lowpc, highpc, objfile);
1229 list_in_scope = &file_symbols;
1230}
1231
1232/* Process all the DIES contained within a lexical block scope. Start
1233 a new scope, process the dies, and then close the scope. */
1234
1235static void
1236read_lexical_block_scope (die, objfile)
1237 struct die_info *die;
1238 struct objfile *objfile;
1239{
1240 register struct context_stack *new;
1241 CORE_ADDR lowpc = 0, highpc = 0;
1242 struct attribute *attr;
1243 struct die_info *child_die;
1244
1245 attr = dwarf_attr (die, DW_AT_low_pc);
1246 if (attr)
1247 {
1248 lowpc = DW_ADDR (attr);
1249 }
1250 attr = dwarf_attr (die, DW_AT_high_pc);
1251 if (attr)
1252 {
1253 highpc = DW_ADDR (attr);
1254 }
1255
1256 push_context (0, lowpc);
1257 if (die->has_children)
1258 {
1259 child_die = die->next;
1260 while (child_die && child_die->tag)
1261 {
1262 process_die (child_die, objfile);
1263 child_die = sibling_die (child_die);
1264 }
1265 }
1266 new = pop_context ();
1267
1268 if (local_symbols != NULL)
1269 {
1270 finish_block (0, &local_symbols, new->old_blocks, new->start_addr,
1271 highpc, objfile);
1272 }
1273 local_symbols = new->locals;
1274}
1275
1276/* Called when we find the DIE that starts a structure or union scope
1277 (definition) to process all dies that define the members of the
1278 structure or union.
1279
1280 NOTE: we need to call struct_type regardless of whether or not the
1281 DIE has an at_name attribute, since it might be an anonymous
1282 structure or union. This gets the type entered into our set of
1283 user defined types.
1284
1285 However, if the structure is incomplete (an opaque struct/union)
1286 then suppress creating a symbol table entry for it since gdb only
1287 wants to find the one with the complete definition. Note that if
1288 it is complete, we just call new_symbol, which does it's own
1289 checking about whether the struct/union is anonymous or not (and
1290 suppresses creating a symbol table entry itself). */
1291
1292static void
1293read_structure_scope (die, objfile)
1294 struct die_info *die;
1295 struct objfile *objfile;
1296{
1297 struct type *type, *member_type;
1298 struct field *fields;
1299 struct die_info *child_die;
1300 struct attribute *attr;
1301 struct symbol *sym;
1302 int num_fields;
1303
1304 type = dwarf_alloc_type (objfile);
1305
1306 INIT_CPLUS_SPECIFIC (type);
1307 attr = dwarf_attr (die, DW_AT_name);
1308
1309 if (die->tag == DW_TAG_structure_type)
1310 {
1311 TYPE_CODE (type) = TYPE_CODE_STRUCT;
1312 if (attr)
1313 {
1314 TYPE_NAME (type) = obconcat (&objfile->type_obstack,
1315 "struct", " ", DW_STRING (attr));
1316 }
1317 }
1318 else
1319 {
1320 /* die->tag == DW_TAG_union_type */
1321 TYPE_CODE (type) = TYPE_CODE_UNION;
1322 if (attr)
1323 {
1324 TYPE_NAME (type) = obconcat (&objfile->type_obstack,
1325 "union", " ", DW_STRING (attr));
1326 }
1327 }
1328
1329 attr = dwarf_attr (die, DW_AT_byte_size);
1330 if (attr)
1331 {
1332 TYPE_LENGTH (type) = DW_UNSND (attr);
1333 }
1334 else
1335 {
1336 TYPE_LENGTH (type) = 0;
1337 }
1338
1339 /* We need to add the type field to the die immediately so we don't
1340 infinitely recurse when dealing with pointers to the structure
1341 type within the structure itself. */
1342 die->type = type;
1343
1344 num_fields = 0;
1345 fields = NULL;
1346 if (die->has_children)
1347 {
1348 child_die = die->next;
1349 while (child_die && child_die->tag)
1350 {
1351 if (child_die->tag != DW_TAG_member)
1352 {
1353 process_die (child_die, objfile);
1354 }
1355 else
1356 {
1357 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
1358 {
1359 fields = (struct field *)
1360 xrealloc (fields,
1361 (num_fields + DW_FIELD_ALLOC_CHUNK)
1362 * sizeof (struct field));
1363 }
1364
1365 /* Get bit offset of field */
1366 attr = dwarf_attr (child_die, DW_AT_bit_offset);
1367 if (attr)
1368 {
1369 fields[num_fields].bitpos = DW_UNSND (attr);
1370 }
1371 else
1372 {
1373 fields[num_fields].bitpos = 0;
1374 }
1375 attr = dwarf_attr (child_die, DW_AT_data_member_location);
1376 if (attr)
1377 {
1378 fields[num_fields].bitpos +=
1379 decode_locdesc (DW_BLOCK (attr), objfile) * bits_per_byte;
1380 }
1381
1382 /* Get bit size of field (zero if none). */
1383 attr = dwarf_attr (child_die, DW_AT_bit_size);
1384 if (attr)
1385 {
1386 fields[num_fields].bitsize = DW_UNSND (attr);
1387 }
1388 else
1389 {
1390 fields[num_fields].bitsize = 0;
1391 }
1392
1393 /* Get type of member. */
1394 member_type = die_type (child_die, objfile);
1395 fields[num_fields].type = member_type;
1396
1397 /* Get name of member. */
1398 attr = dwarf_attr (child_die, DW_AT_name);
1399 if (attr)
1400 {
1401 fields[num_fields].name = obsavestring (DW_STRING (attr),
1402 strlen (DW_STRING (attr)),
1403 &objfile->type_obstack);
1404#if 0
1405 fields[num_fields].name = strdup (DW_STRING (attr));
1406#endif
1407 }
1408 num_fields++;
1409 }
1410 child_die = sibling_die (child_die);
1411 }
1412 type->nfields = num_fields;
1413 type->fields = fields;
1414 }
1415 else
1416 {
1417 /* No children, must be stub. */
1418 TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
1419 }
1420
1421 die->type = type;
1422 sym = new_symbol (die, objfile);
1423 if (sym != NULL)
1424 {
1425 SYMBOL_TYPE (sym) = type;
1426 }
1427}
1428
1429/* Given a pointer to a die which begins an enumeration, process all
1430 the dies that define the members of the enumeration.
1431
1432 This will be much nicer in draft 6 of the DWARF spec when our
1433 members will be dies instead squished into the DW_AT_element_list
1434 attribute.
1435
1436 NOTE: We reverse the order of the element list. */
1437
1438static void
1439read_enumeration (die, objfile)
1440 struct die_info *die;
1441 struct objfile *objfile;
1442{
1443 struct die_info *child_die;
1444 struct type *type;
1445 struct field *fields;
1446 struct attribute *attr;
1447 struct symbol *sym;
1448 struct dwarf_block *blk;
1449 int num_fields;
1450 unsigned int size, bytes_read, i;
1451
1452 type = dwarf_alloc_type (objfile);
1453
1454 TYPE_CODE (type) = TYPE_CODE_ENUM;
1455 attr = dwarf_attr (die, DW_AT_name);
1456 if (attr)
1457 {
1458 TYPE_NAME (type) = obconcat (&objfile->type_obstack,
1459 "enum ", " ", DW_STRING (attr));
1460 }
1461
1462 attr = dwarf_attr (die, DW_AT_byte_size);
1463 if (attr)
1464 {
1465 TYPE_LENGTH (type) = DW_UNSND (attr);
1466 }
1467 else
1468 {
1469 TYPE_LENGTH (type) = 0;
1470 }
1471
1472 num_fields = 0;
1473 fields = NULL;
1474 if (die->has_children)
1475 {
1476 child_die = die->next;
1477 while (child_die && child_die->tag)
1478 {
1479 if (child_die->tag != DW_TAG_enumerator)
1480 {
1481 process_die (child_die, objfile);
1482 }
1483 else
1484 {
1485 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0)
1486 {
1487 fields = (struct field *)
1488 xrealloc (fields,
1489 (num_fields + DW_FIELD_ALLOC_CHUNK)
1490 * sizeof (struct field));
1491 }
1492
1493 /* Handcraft a new symbol for this enum member. */
1494 sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
1495 sizeof (struct symbol));
1496 memset (sym, 0, sizeof (struct symbol));
1497
1498 fields[num_fields].type = NULL;
1499 fields[num_fields].bitsize = 0;
1500 attr = dwarf_attr (child_die, DW_AT_name);
1501 if (attr)
1502 {
1503 fields[num_fields].name = strdup (DW_STRING (attr));
1504 SYMBOL_NAME (sym) = strdup (fields[num_fields].name);
1505 }
1506 attr = dwarf_attr (child_die, DW_AT_const_value);
1507 if (attr)
1508 {
1509 fields[num_fields].bitpos = DW_UNSND (attr);
1510 SYMBOL_VALUE (sym) = DW_UNSND (attr);
1511 }
1512
1513#if 0
1514 SYMBOL_NAME (sym) = create_name (elist->str,
1515 &objfile->symbol_obstack);
1516#endif
1517 SYMBOL_INIT_LANGUAGE_SPECIFIC (sym, cu_language);
1518 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1519 SYMBOL_CLASS (sym) = LOC_CONST;
1520 SYMBOL_TYPE (sym) = type;
1521 add_symbol_to_list (sym, list_in_scope);
1522
1523 num_fields++;
1524 }
1525
1526 child_die = sibling_die (child_die);
1527 }
1528 type->fields = fields;
1529 type->nfields = num_fields;
1530 }
1531 die->type = type;
1532 sym = new_symbol (die, objfile);
1533 if (sym != NULL)
1534 {
1535 SYMBOL_TYPE (sym) = type;
1536 }
1537}
1538
1539/* Extract all information from a DW_TAG_array_type DIE and put it in
1540 the DIE's type field. For now, this only handles one dimensional
1541 arrays. */
1542
1543static void
1544dwarf_read_array_type (die, objfile)
1545 struct die_info *die;
1546 struct objfile *objfile;
1547{
1548 struct die_info *child_die;
1549 struct type *type, *element_type, *range_type, *index_type;
1550 struct attribute *attr;
1551 struct dwarf_block *blk;
1552 unsigned int size, i, type_form, bytes_read;
1553 unsigned int index_spec, lo_spec, hi_spec, type_ref;
1554 unsigned int low, high;
1555
1556 /* Return if we've already decoded this type. */
1557 if (die->type)
1558 {
1559 return;
1560 }
1561
1562 element_type = die_type (die, objfile);
1563
1564 low = 0;
1565 high = 1;
1566 if (cu_language == DW_LANG_Fortran77 || cu_language == DW_LANG_Fortran90)
1567 {
1568 /* FORTRAN implies a lower bound of 1, if not given. */
1569 low = 1;
1570 }
1571
1572 child_die = die->next;
1573 while (child_die && child_die->tag)
1574 {
1575 if (child_die->tag == DW_TAG_subrange_type)
1576 {
1577 index_type = die_type (child_die, objfile);
1578 attr = dwarf_attr (child_die, DW_AT_lower_bound);
1579 if (attr)
1580 {
1581 if (attr->form == DW_FORM_sdata)
1582 {
1583 low = DW_SND (attr);
1584 }
1585 else if (attr->form == DW_FORM_udata
1586 || attr->form == DW_FORM_data1
1587 || attr->form == DW_FORM_data2
1588 || attr->form == DW_FORM_data4)
1589 {
1590 low = DW_UNSND (attr);
1591 }
1592 else
1593 {
1594 if (!array_bound_warning_given)
1595 {
1596 warning ("Non-constant array bounds ignored.");
1597 array_bound_warning_given = 1;
1598 }
1599#ifdef FORTRAN_HACK
1600 type = dwarf_alloc_type (objfile);
1601 TYPE_TARGET_TYPE (type) = element_type;
1602 TYPE_OBJFILE (type) = objfile;
1603 TYPE_LENGTH (type) = 4;
1604 TYPE_CODE (type) = TYPE_CODE_PTR;
1605 TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
1606 TYPE_POINTER_TYPE (element_type) = type;
1607 goto done;
1608#else
1609 low = 0;
1610#endif
1611 }
1612 }
1613 attr = dwarf_attr (child_die, DW_AT_upper_bound);
1614 if (attr)
1615 {
1616 if (attr->form == DW_FORM_sdata)
1617 {
1618 high = DW_SND (attr);
1619 }
1620 else if (attr->form == DW_FORM_udata
1621 || attr->form == DW_FORM_data1
1622 || attr->form == DW_FORM_data2
1623 || attr->form == DW_FORM_data4)
1624 {
1625 high = DW_UNSND (attr);
1626 }
1627 else
1628 {
1629 if (!array_bound_warning_given)
1630 {
1631 warning ("Non-constant array bounds ignored.");
1632 array_bound_warning_given = 1;
1633 }
1634#ifdef FORTRAN_HACK
1635 type = dwarf_alloc_type (objfile);
1636 TYPE_TARGET_TYPE (type) = element_type;
1637 TYPE_OBJFILE (type) = objfile;
1638 TYPE_LENGTH (type) = 4;
1639 TYPE_CODE (type) = TYPE_CODE_PTR;
1640 TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
1641 TYPE_POINTER_TYPE (element_type) = type;
1642 goto done;
1643#else
1644 high = 1;
1645#endif
1646 }
1647 }
1648 }
1649 range_type = create_range_type (NULL, index_type, low, high);
1650 type = create_array_type (NULL, element_type, range_type);
1651 element_type = type;
1652 child_die = sibling_die (child_die);
1653 }
1654done:
1655 /* Install the type in the die. */
1656 die->type = type;
1657}
1658
1659/* First cut: install each common block member as a global variable. */
1660
1661static void
1662read_common_block (die, objfile)
1663 struct die_info *die;
1664 struct objfile *objfile;
1665{
1666 struct die_info *child_die;
1667 struct attribute *attr;
1668 struct symbol *sym;
1669 CORE_ADDR base;
1670
1671 attr = dwarf_attr (die, DW_AT_location);
1672 if (attr)
1673 {
1674 base = decode_locdesc (DW_BLOCK (attr), objfile);
1675 }
1676 if (die->has_children)
1677 {
1678 child_die = die->next;
1679 while (child_die && child_die->tag)
1680 {
1681 sym = new_symbol (child_die, objfile);
1682 attr = dwarf_attr (child_die, DW_AT_data_member_location);
1683 if (attr)
1684 {
1685 SYMBOL_VALUE_ADDRESS (sym) =
1686 base + decode_locdesc (DW_BLOCK (attr), objfile);
1687 add_symbol_to_list (sym, &global_symbols);
1688 }
1689 child_die = sibling_die (child_die);
1690 }
1691 }
1692}
1693
1694/* Extract all information from a DW_TAG_pointer_type DIE and add to
1695 the user defined type vector. */
1696
1697static void
1698read_tag_pointer_type (die, objfile)
1699 struct die_info *die;
1700 struct objfile *objfile;
1701{
1702 struct type *type, *pointed_to_type;
1703 struct attribute *attr;
1704
1705 if (die->type)
1706 {
1707 return;
1708 }
1709
1710 pointed_to_type = die_type (die, objfile);
1711
1712 type = dwarf_alloc_type (objfile);
1713 TYPE_TARGET_TYPE (type) = pointed_to_type;
1714 TYPE_OBJFILE (type) = objfile;
1715 attr = dwarf_attr (die, DW_AT_byte_size);
1716 if (attr)
1717 {
1718 TYPE_LENGTH (type) = DW_UNSND (attr);
1719 }
1720 else
1721 {
1722 TYPE_LENGTH (type) = address_size;
1723 }
1724 TYPE_CODE (type) = TYPE_CODE_PTR;
1725 TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
1726
1727 TYPE_POINTER_TYPE (pointed_to_type) = type;
1728 die->type = type;
1729}
1730
1731static void
1732read_tag_const_type (die, objfile)
1733 struct die_info *die;
1734 struct objfile *objfile;
1735{
1736 if (die->type)
1737 {
1738 return;
1739 }
1740
1741 if (!tag_const_warning_given)
1742 {
1743 warning ("gdb ignores `const' qualifiers.");
1744 tag_const_warning_given = 1;
1745 }
1746
1747 die->type = die_type (die, objfile);
1748}
1749
1750static void
1751read_tag_volatile_type (die, objfile)
1752 struct die_info *die;
1753 struct objfile *objfile;
1754{
1755 if (die->type)
1756 {
1757 return;
1758 }
1759
1760 if (!tag_volatile_warning_given)
1761 {
1762 warning ("gdb ignores `volatile' qualifiers.");
1763 tag_volatile_warning_given = 1;
1764 }
1765
1766 die->type = die_type (die, objfile);
1767}
1768
1769/* Extract all information from a DW_TAG_string_type DIE and add to
1770 the user defined type vector. It isn't really a user defined type,
1771 but it behaves like one, with other DIE's using an AT_user_def_type
1772 attribute to reference it. */
1773
1774static void
1775read_tag_string_type (die, objfile)
1776 struct die_info *die;
1777 struct objfile *objfile;
1778{
1779 struct type *type, *range_type, *index_type, *char_type;
1780 struct attribute *attr;
1781 unsigned int length;
1782
1783 if (die->type)
1784 {
1785 return;
1786 }
1787
1788 attr = dwarf_attr (die, DW_AT_string_length);
1789 if (attr)
1790 {
1791 length = DW_UNSND (attr);
1792 }
1793 else
1794 {
1795 length = 1;
1796 }
1797 index_type = dwarf2_fundamental_type (objfile, FT_INTEGER);
1798 range_type = create_range_type (NULL, index_type, 1, length);
1799 char_type = dwarf2_fundamental_type (objfile, FT_CHAR);
1800 type = create_string_type (char_type, range_type);
1801 die->type = type;
1802}
1803
1804/* Handle DIES due to C code like:
1805
1806 struct foo
1807 {
1808 int (*funcp)(int a, long l);
1809 int b;
1810 };
1811
1812 ('funcp' generates a DW_TAG_subroutine_type DIE)
1813
1814 NOTE: parameter DIES are currently ignored. See if gdb has a way to
1815 include this info in it's type system, and decode them if so. Is
1816 this what the type structure's "arg_types" field is for? (FIXME) */
1817
1818static void
1819read_subroutine_type (die, objfile)
1820 struct die_info *die;
1821 struct objfile *objfile;
1822{
1823 struct type *type; /* Type that this function returns */
1824 struct type *ftype; /* Function that returns above type */
1825
1826 /* Decode the type that this subroutine returns */
1827 if (die->type)
1828 {
1829 return;
1830 }
1831 type = die_type (die, objfile);
1832 ftype = lookup_function_type (type);
1833
1834 TYPE_TARGET_TYPE (ftype) = type;
1835 TYPE_LENGTH (ftype) = 1;
1836 TYPE_CODE (ftype) = TYPE_CODE_FUNC;
1837 TYPE_OBJFILE (ftype) = objfile;
1838
1839 die->type = type;
1840}
1841
1842static void
1843read_typedef (die, objfile)
1844 struct die_info *die;
1845 struct objfile *objfile;
1846{
1847 struct type *type;
1848
1849 if (!die->type)
1850 {
1851 type = die_type (die, objfile);
1852 die->type = type;
1853 }
1854}
1855
1856/* Find a representation of a given base type and install
1857 it in the TYPE field of the die. */
1858
1859static void
1860read_base_type (die, objfile)
1861 struct die_info *die;
1862 struct objfile *objfile;
1863{
1864 struct type *type;
1865 struct attribute *attr;
1866 int encoding = 0, size = 0;
1867
1868 /* If we've already decoded this die, this is a no-op. */
1869 if (die->type)
1870 {
1871 return;
1872 }
1873
1874 attr = dwarf_attr (die, DW_AT_encoding);
1875 if (attr)
1876 {
1877 encoding = DW_UNSND (attr);
1878 }
1879 attr = dwarf_attr (die, DW_AT_byte_size);
1880 if (attr)
1881 {
1882 size = DW_UNSND (attr);
1883 }
1884 type = dwarf_base_type (encoding, size);
1885 die->type = type;
1886}
1887
1888/* Read a whole compilation unit into a linked list of dies. */
1889
1890struct die_info *
1891read_comp_unit (info_ptr, abfd)
1892 char *info_ptr;
1893 bfd *abfd;
1894{
1895 struct die_info *first_die, *last_die, *die;
1896 char *cur_ptr;
1897 int nesting_level;
1898
1899 cur_ptr = info_ptr;
1900 nesting_level = 0;
1901 first_die = last_die = NULL;
1902 do
1903 {
1904 cur_ptr = read_full_die (&die, abfd, cur_ptr);
1905 if (die->has_children)
1906 {
1907 nesting_level++;
1908 }
1909 if (die->tag == 0)
1910 {
1911 nesting_level--;
1912 }
1913
1914 die->next = NULL;
1915
1916 /* Enter die in reference hash table */
1917 store_in_ref_table (die->offset, die);
1918
1919 if (!first_die)
1920 {
1921 first_die = last_die = die;
1922 }
1923 else
1924 {
1925 last_die->next = die;
1926 last_die = die;
1927 }
1928 }
1929 while (nesting_level > 0);
1930 return first_die;
1931}
1932
1933/* Free a linked list of dies. */
1934
1935static void
1936free_die_list (dies)
1937 struct die_info *dies;
1938{
1939 struct die_info *die, *next;
1940
1941 die = dies;
1942 while (die)
1943 {
1944 next = die->next;
1945 free (die->attrs);
1946 free (die);
1947 die = next;
1948 }
1949}
1950
1951/* Read the contents of the section at OFFSET and of size SIZE in the
1952 object file specified by ABFD into a buffer of bytes and return it. */
1953
1954static char *
1955dwarf2_read_section (abfd, offset, size)
1956 bfd * abfd;
1957 file_ptr offset;
1958 unsigned int size;
1959{
1960 char *buf;
1961
1962 buf = xmalloc (size);
1963 if ((bfd_seek (abfd, offset, SEEK_SET) != 0) ||
1964 (bfd_read (buf, size, 1, abfd) != size))
1965 {
1966 free (buf);
1967 buf = NULL;
1968 error ("Dwarf Error: Can't read DWARF data from '%s'",
1969 bfd_get_filename (abfd));
1970 }
1971 return buf;
1972}
1973
1974/* In DWARF version 2, the description of the debugging information is
1975 stored in a separate .debug_abbrev section. Before we read any
1976 dies from a section we read in all abbreviations and install them
1977 in a hash table. */
1978
1979static void
1980dwarf2_read_abbrevs (abfd, offset)
1981 bfd * abfd;
1982 unsigned int offset;
1983{
1984 char *abbrev_ptr;
1985 struct abbrev_info *cur_abbrev;
1986 unsigned int abbrev_number, bytes_read, abbrev_name;
1987 unsigned int abbrev_form, hash_number;
1988
1989 /* empty the table */
1990 dwarf2_empty_abbrev_table ();
1991
1992 abbrev_ptr = dwarf_abbrev_buffer + offset;
1993 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
1994 abbrev_ptr += bytes_read;
1995
1996 /* loop until we reach an abbrev number of 0 */
1997 while (abbrev_number)
1998 {
1999 cur_abbrev = dwarf_alloc_abbrev ();
2000
2001 /* read in abbrev header */
2002 cur_abbrev->number = abbrev_number;
2003 cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
2004 abbrev_ptr += bytes_read;
2005 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
2006 abbrev_ptr += 1;
2007
2008 /* now read in declarations */
2009 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
2010 abbrev_ptr += bytes_read;
2011 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
2012 abbrev_ptr += bytes_read;
2013 while (abbrev_name)
2014 {
2015 if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
2016 {
2017 cur_abbrev->attrs = xrealloc (cur_abbrev->attrs,
2018 (cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK)
2019 * sizeof (struct attr_abbrev));
2020 }
2021 cur_abbrev->attrs[cur_abbrev->num_attrs].name = abbrev_name;
2022 cur_abbrev->attrs[cur_abbrev->num_attrs++].form = abbrev_form;
2023 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
2024 abbrev_ptr += bytes_read;
2025 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
2026 abbrev_ptr += bytes_read;
2027 }
2028
2029 hash_number = abbrev_number % ABBREV_HASH_SIZE;
2030 cur_abbrev->next = dwarf2_abbrevs[hash_number];
2031 dwarf2_abbrevs[hash_number] = cur_abbrev;
2032
2033 /* get next abbrev */
2034 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
2035 abbrev_ptr += bytes_read;
2036 }
2037}
2038
2039/* Empty the abbrev table for a new compilation unit. */
2040
2041static void
2042dwarf2_empty_abbrev_table ()
2043{
2044 int i;
2045 struct abbrev_info *abbrev, *next;
2046
2047 for (i = 0; i < ABBREV_HASH_SIZE; ++i)
2048 {
2049 next = NULL;
2050 abbrev = dwarf2_abbrevs[i];
2051 while (abbrev)
2052 {
2053 next = abbrev->next;
2054 free (abbrev->attrs);
2055 free (abbrev);
2056 abbrev = next;
2057 }
2058 dwarf2_abbrevs[i] = NULL;
2059 }
2060}
2061
2062/* Lookup an abbrev_info structure in the abbrev hash table. */
2063
2064static struct abbrev_info *
2065dwarf2_lookup_abbrev (number)
2066 unsigned int number;
2067{
2068 unsigned int hash_number;
2069 struct abbrev_info *abbrev;
2070
2071 hash_number = number % ABBREV_HASH_SIZE;
2072 abbrev = dwarf2_abbrevs[hash_number];
2073
2074 while (abbrev)
2075 {
2076 if (abbrev->number == number)
2077 return abbrev;
2078 else
2079 abbrev = abbrev->next;
2080 }
2081 return NULL;
2082}
2083
2084/* Read a minimal amount of information into the minimal die structure. */
2085
2086static char *
2087read_partial_die (part_die, abfd, info_ptr, has_pc_info)
2088 struct partial_die_info *part_die;
2089 bfd * abfd;
2090 char *info_ptr;
2091 int *has_pc_info;
2092{
2093 unsigned int abbrev_number, bytes_read, i;
2094 struct abbrev_info *abbrev;
2095 char ebuf[256];
2096 int has_low_pc_attr = 0;
2097 int has_high_pc_attr = 0;
2098
2099 *has_pc_info = 0;
2100 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2101 info_ptr += bytes_read;
2102 if (!abbrev_number)
2103 {
2104 part_die->tag = 0;
2105 part_die->has_children = 0;
2106 part_die->abbrev = abbrev_number;
2107 return info_ptr;
2108 }
2109
2110 abbrev = dwarf2_lookup_abbrev (abbrev_number);
2111 if (!abbrev)
2112 {
2113 error ("Dwarf Error: Could not find abbrev number %d.", abbrev_number);
2114 }
2115 part_die->offset = info_ptr - dwarf_info_buffer;
2116 part_die->tag = abbrev->tag;
2117 part_die->has_children = abbrev->has_children;
2118 part_die->is_external = 0;
2119 part_die->abbrev = abbrev_number;
2120
2121 {
2122 char *str = "";
2123 struct dwarf_block *blk = 0;
2124 CORE_ADDR addr = ((CORE_ADDR) -1);
2125 unsigned int unsnd = ((unsigned int) -1);
2126 int snd = -1;
2127
2128 for (i = 0; i < abbrev->num_attrs; ++i)
2129 {
2130 /* read the correct type of data */
2131 switch (abbrev->attrs[i].form)
2132 {
2133 case DW_FORM_addr:
2134 addr = read_address (abfd, info_ptr);
2135 info_ptr += address_size;
2136 break;
2137 case DW_FORM_ref_addr:
2138 addr = read_address (abfd, info_ptr);
2139 info_ptr += address_size;
2140 break;
2141 case DW_FORM_block2:
2142 blk = dwarf_alloc_block ();
2143 blk->size = read_2_bytes (abfd, info_ptr);
2144 info_ptr += 2;
2145 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
2146 info_ptr += blk->size;
2147 break;
2148 case DW_FORM_block4:
2149 blk = dwarf_alloc_block ();
2150 blk->size = read_4_bytes (abfd, info_ptr);
2151 info_ptr += 2;
2152 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
2153 info_ptr += blk->size;
2154 break;
2155 case DW_FORM_data2:
2156 unsnd = read_2_bytes (abfd, info_ptr);
2157 info_ptr += 2;
2158 break;
2159 case DW_FORM_data4:
2160 unsnd = read_4_bytes (abfd, info_ptr);
2161 info_ptr += 4;
2162 break;
2163 case DW_FORM_data8:
2164 unsnd = read_8_bytes (abfd, info_ptr);
2165 info_ptr += 8;
2166 break;
2167 case DW_FORM_string:
2168 str = read_string (abfd, info_ptr, &bytes_read);
2169 info_ptr += bytes_read;
2170 break;
2171 case DW_FORM_block:
2172 blk = dwarf_alloc_block ();
2173 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2174 info_ptr += bytes_read;
2175 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
2176 info_ptr += blk->size;
2177 break;
2178 case DW_FORM_block1:
2179 blk = dwarf_alloc_block ();
2180 blk->size = read_1_byte (abfd, info_ptr);
2181 info_ptr += 1;
2182 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
2183 info_ptr += blk->size;
2184 break;
2185 case DW_FORM_data1:
2186 unsnd = read_1_byte (abfd, info_ptr);
2187 info_ptr += 1;
2188 break;
2189 case DW_FORM_ref1:
2190 unsnd = read_1_byte (abfd, info_ptr);
2191 info_ptr += 1;
2192 break;
2193 case DW_FORM_ref2:
2194 unsnd = read_2_bytes (abfd, info_ptr);
2195 info_ptr += 2;
2196 break;
2197 case DW_FORM_ref4:
2198 unsnd = read_4_bytes (abfd, info_ptr);
2199 info_ptr += 4;
2200 break;
2201 case DW_FORM_ref_udata:
2202 unsnd = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2203 info_ptr += bytes_read;
2204 break;
2205 case DW_FORM_flag:
2206 unsnd = read_1_byte (abfd, info_ptr);
2207 info_ptr += 1;
2208 break;
2209 case DW_FORM_sdata:
2210 snd = read_signed_leb128 (abfd, info_ptr, &bytes_read);
2211 info_ptr += bytes_read;
2212 break;
2213 case DW_FORM_udata:
2214 unsnd = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2215 info_ptr += bytes_read;
2216 break;
2217 case DW_FORM_indirect:
2218 default:
2219 sprintf (ebuf,
2220 "Dwarf Error: Cannot handle %s in DWARF reader.",
2221 dwarf_form_name (abbrev->attrs[i].form));
2222 error (ebuf);
2223 }
2224
2225 /* store the data if it is of an attribute we want to keep in a
2226 partial symbol table */
2227 switch (abbrev->attrs[i].name)
2228 {
2229 case DW_AT_name:
2230 part_die->name = str;
2231 break;
2232 case DW_AT_low_pc:
2233 has_low_pc_attr = 1;
2234 part_die->lowpc = addr;
2235 break;
2236 case DW_AT_high_pc:
2237 has_high_pc_attr = 1;
2238 part_die->highpc = addr;
2239 break;
2240 case DW_AT_location:
2241 part_die->locdesc = blk;
2242 break;
2243 case DW_AT_language:
2244 part_die->language = unsnd;
2245 break;
2246 case DW_AT_external:
2247 part_die->is_external = unsnd;
2248 }
2249 }
2250 }
2251 *has_pc_info = has_low_pc_attr && has_high_pc_attr;
2252 return info_ptr;
2253}
2254
2255/* Read the die from the .debug_info section buffer. And set diep to
2256 point to a newly allocated die with its information. */
2257
2258static char *
2259read_full_die (diep, abfd, info_ptr)
2260 struct die_info **diep;
2261 bfd *abfd;
2262 char *info_ptr;
2263{
2264 unsigned int abbrev_number, bytes_read, i, offset;
2265 struct abbrev_info *abbrev;
2266 struct die_info *die;
2267 char ebuf[256];
2268
2269 offset = info_ptr - dwarf_info_buffer;
2270 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2271 info_ptr += bytes_read;
2272 if (!abbrev_number)
2273 {
2274 die = dwarf_alloc_die ();
2275 die->tag = 0;
2276 die->abbrev = abbrev_number;
2277 die->type = NULL;
2278 *diep = die;
2279 return info_ptr;
2280 }
2281
2282 abbrev = dwarf2_lookup_abbrev (abbrev_number);
2283 if (!abbrev)
2284 {
2285 error ("Dwarf Error: could not find abbrev number %d.", abbrev_number);
2286 }
2287 die = dwarf_alloc_die ();
2288 die->offset = offset;
2289 die->tag = abbrev->tag;
2290 die->has_children = abbrev->has_children;
2291 die->abbrev = abbrev_number;
2292 die->type = NULL;
2293
2294 die->num_attrs = abbrev->num_attrs;
2295 die->attrs = xmalloc (die->num_attrs * sizeof (struct attribute));
2296
2297 {
2298 char *str;
2299 struct dwarf_block *blk;
2300 unsigned long addr;
2301 unsigned int unsnd;
2302 int snd;
2303
2304 for (i = 0; i < abbrev->num_attrs; ++i)
2305 {
2306 /* read the correct type of data */
2307
2308 die->attrs[i].name = abbrev->attrs[i].name;
2309 die->attrs[i].form = abbrev->attrs[i].form;
2310
2311 switch (abbrev->attrs[i].form)
2312 {
2313 case DW_FORM_addr:
2314 case DW_FORM_ref_addr:
2315 die->attrs[i].u.addr = read_address (abfd, info_ptr);
2316 info_ptr += address_size;
2317 break;
2318 case DW_FORM_block2:
2319 blk = dwarf_alloc_block ();
2320 blk->size = read_2_bytes (abfd, info_ptr);
2321 info_ptr += 2;
2322 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
2323 info_ptr += blk->size;
2324 die->attrs[i].u.blk = blk;
2325 break;
2326 case DW_FORM_block4:
2327 blk = dwarf_alloc_block ();
2328 blk->size = read_4_bytes (abfd, info_ptr);
2329 info_ptr += 2;
2330 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
2331 info_ptr += blk->size;
2332 die->attrs[i].u.blk = blk;
2333 break;
2334 case DW_FORM_data2:
2335 die->attrs[i].u.unsnd = read_2_bytes (abfd, info_ptr);
2336 info_ptr += 2;
2337 break;
2338 case DW_FORM_data4:
2339 die->attrs[i].u.unsnd = read_4_bytes (abfd, info_ptr);
2340 info_ptr += 4;
2341 break;
2342 case DW_FORM_data8:
2343 die->attrs[i].u.unsnd = read_8_bytes (abfd, info_ptr);
2344 info_ptr += 8;
2345 break;
2346 case DW_FORM_string:
2347 die->attrs[i].u.str = read_string (abfd, info_ptr, &bytes_read);
2348 info_ptr += bytes_read;
2349 break;
2350 case DW_FORM_block:
2351 blk = dwarf_alloc_block ();
2352 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
2353 info_ptr += bytes_read;
2354 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
2355 info_ptr += blk->size;
2356 die->attrs[i].u.blk = blk;
2357 break;
2358 case DW_FORM_block1:
2359 blk = dwarf_alloc_block ();
2360 blk->size = read_1_byte (abfd, info_ptr);
2361 info_ptr += 1;
2362 blk->data = read_n_bytes (abfd, info_ptr, blk->size);
2363 info_ptr += blk->size;
2364 die->attrs[i].u.blk = blk;
2365 break;
2366 case DW_FORM_data1:
2367 die->attrs[i].u.unsnd = read_1_byte (abfd, info_ptr);
2368 info_ptr += 1;
2369 break;
2370 case DW_FORM_ref1:
2371 die->attrs[i].u.unsnd = read_1_byte (abfd, info_ptr);
2372 info_ptr += 1;
2373 break;
2374 case DW_FORM_ref2:
2375 die->attrs[i].u.unsnd = read_2_bytes (abfd, info_ptr);
2376 info_ptr += 2;
2377 break;
2378 case DW_FORM_ref4:
2379 die->attrs[i].u.unsnd = read_4_bytes (abfd, info_ptr);
2380 info_ptr += 4;
2381 break;
2382 case DW_FORM_ref_udata:
2383 die->attrs[i].u.unsnd = read_unsigned_leb128 (abfd,
2384 info_ptr,
2385 &bytes_read);
2386 info_ptr += bytes_read;
2387 break;
2388 case DW_FORM_flag:
2389 die->attrs[i].u.unsnd = read_1_byte (abfd, info_ptr);
2390 info_ptr += 1;
2391 break;
2392 case DW_FORM_sdata:
2393 die->attrs[i].u.snd = read_signed_leb128 (abfd,
2394 info_ptr,
2395 &bytes_read);
2396 info_ptr += bytes_read;
2397 break;
2398 case DW_FORM_udata:
2399 die->attrs[i].u.unsnd = read_unsigned_leb128 (abfd,
2400 info_ptr,
2401 &bytes_read);
2402 info_ptr += bytes_read;
2403 break;
2404 case DW_FORM_indirect:
2405 default:
2406 sprintf (ebuf,
2407 "Dwarf Error: Cannot handle %s in DWARF reader.",
2408 dwarf_form_name (abbrev->attrs[i].form));
2409 error (ebuf);
2410 }
2411
2412 }
2413 }
2414 *diep = die;
2415 return info_ptr;
2416}
2417
2418/* read dwarf information from a buffer */
2419
2420static unsigned int
2421read_1_byte (abfd, buf)
2422 bfd *abfd;
2423 char *buf;
2424{
2425 return bfd_get_8 (abfd, (bfd_byte *) buf);
2426}
2427
2428static unsigned int
2429read_2_bytes (abfd, buf)
2430 bfd *abfd;
2431 char *buf;
2432{
2433 return bfd_get_16 (abfd, (bfd_byte *) buf);
2434}
2435
2436static unsigned int
2437read_4_bytes (abfd, buf)
2438 bfd *abfd;
2439 char *buf;
2440{
2441 return bfd_get_32 (abfd, (bfd_byte *) buf);
2442}
2443
2444static unsigned int
2445read_8_bytes (abfd, buf)
2446 bfd *abfd;
2447 char *buf;
2448{
2449 return bfd_get_64 (abfd, (bfd_byte *) buf);
2450}
2451
2452static CORE_ADDR
2453read_address (abfd, buf)
2454 bfd *abfd;
2455 char *buf;
2456{
2457 CORE_ADDR retval = 0;
2458
2459 if (address_size == 4)
2460 {
2461 retval = bfd_get_32 (abfd, (bfd_byte *) buf);
2462 } else { /* *THE* alternative is 8, right? */
2463 retval = bfd_get_64 (abfd, (bfd_byte *) buf);
2464 }
2465 return retval;
2466}
2467
2468static char *
2469read_n_bytes (abfd, buf, size)
2470 bfd * abfd;
2471 char *buf;
2472 unsigned int size;
2473{
2474 char *ret;
2475 unsigned int i;
2476
2477 ret = xmalloc (size);
2478 for (i = 0; i < size; ++i)
2479 {
2480 ret[i] = bfd_get_8 (abfd, (bfd_byte *) buf);
2481 buf++;
2482 }
2483 return ret;
2484}
2485
2486/* FIXME : hardwired string size limit */
2487
2488static char *
2489read_string (abfd, buf, bytes_read_ptr)
2490 bfd *abfd;
2491 char *buf;
2492 unsigned int *bytes_read_ptr;
2493{
2494 char ret_buf[DWARF2_MAX_STRING_SIZE], *ret, byte;
2495 unsigned int i;
2496
2497 i = 0;
2498 do
2499 {
2500 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
2501 buf++;
2502 ret_buf[i++] = byte;
2503 }
2504 while (byte);
2505 if (i == 1)
2506 {
2507 *bytes_read_ptr = 1;
2508 return NULL;
2509 }
2510 ret = xmalloc (i);
2511 strncpy (ret, ret_buf, i);
2512 *bytes_read_ptr = i;
2513 return ret;
2514}
2515
2516static unsigned int
2517read_unsigned_leb128 (abfd, buf, bytes_read_ptr)
2518 bfd *abfd;
2519 char *buf;
2520 unsigned int *bytes_read_ptr;
2521{
2522 unsigned int result, num_read;
2523 int i, shift;
2524 unsigned char byte;
2525
2526 result = 0;
2527 shift = 0;
2528 num_read = 0;
2529 i = 0;
2530 while (1)
2531 {
2532 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
2533 buf++;
2534 num_read++;
2535 result |= ((byte & 127) << shift);
2536 if ((byte & 128) == 0)
2537 {
2538 break;
2539 }
2540 shift += 7;
2541 }
2542 *bytes_read_ptr = num_read;
2543 return result;
2544}
2545
2546static int
2547read_signed_leb128 (abfd, buf, bytes_read_ptr)
2548 bfd *abfd;
2549 char *buf;
2550 unsigned int *bytes_read_ptr;
2551{
2552 int result;
2553 int i, shift, size, num_read;
2554 unsigned char byte;
2555
2556 result = 0;
2557 shift = 0;
2558 size = 32;
2559 num_read = 0;
2560 i = 0;
2561 while (1)
2562 {
2563 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
2564 buf++;
2565 num_read++;
2566 result |= ((byte & 127) << shift);
2567 shift += 7;
2568 if ((byte & 128) == 0)
2569 {
2570 break;
2571 }
2572 }
2573 if ((shift < size) && (byte & 0x40))
2574 {
2575 result |= -(1 << shift);
2576 }
2577 *bytes_read_ptr = num_read;
2578 return result;
2579}
2580
2581static void
2582set_cu_language (lang)
2583 unsigned int lang;
2584{
2585 switch (lang)
2586 {
2587 case DW_LANG_C89:
2588 case DW_LANG_C:
2589 case DW_LANG_Fortran77:
2590 cu_language = language_c;
2591 break;
2592 case DW_LANG_C_plus_plus:
2593 cu_language = language_cplus;
2594 break;
2595 case DW_LANG_Ada83:
2596 case DW_LANG_Cobol74:
2597 case DW_LANG_Cobol85:
2598#if 0
2599 case DW_LANG_Fortran77: /* moved up top for now */
2600#endif
2601 case DW_LANG_Fortran90:
2602 case DW_LANG_Pascal83:
2603 case DW_LANG_Modula2:
2604 default:
2605 cu_language = language_unknown;
2606 break;
2607 }
2608 cu_language_defn = language_def (cu_language);
2609}
2610
2611static void
2612record_minimal_symbol (name, address, ms_type, objfile)
2613 char *name;
2614 CORE_ADDR address;
2615 enum minimal_symbol_type ms_type;
2616 struct objfile *objfile;
2617{
2618 name = obsavestring (name, strlen (name), &objfile->symbol_obstack);
2619 prim_record_minimal_symbol (name, address, ms_type, objfile);
2620}
2621
2622/* Converts a location description into gdb form. */
2623
2624static int
2625convert_locdesc (blk)
2626 struct dwarf_block *blk;
2627{
2628 /* FIXME : this is only a stub! */
2629 return 0;
2630}
2631
2632/* Return the named attribute or NULL if not there. */
2633
2634static struct attribute *
2635dwarf_attr (die, name)
2636 struct die_info *die;
2637 unsigned int name;
2638{
2639 unsigned int i;
2640
2641 for (i = 0; i < die->num_attrs; ++i)
2642 {
2643 if (die->attrs[i].name == name)
2644 {
2645 return &die->attrs[i];
2646 }
2647 }
2648 return NULL;
2649}
2650
2651/* Decode the line number information for the compilation unit whose
2652 line number info is at OFFSET in the .debug_line section. */
2653
2654struct filenames
2655{
2656 int num_files;
9422fadb 2657 struct fileinfo
fcf05549
SS		 2658 {
2659 char *name;
2660 unsigned int dir;
2661 unsigned int time;
2662 unsigned int size;
2663 }
2664 *files;
2665};
2666
2667struct directories
2668{
2669 int num_dirs;
2670 char **dirs;
2671};
2672
2673static void
2674dwarf_decode_lines (offset, abfd)
2675 unsigned int offset;
2676 bfd *abfd;
2677{
2678 char *line_ptr;
2679 struct line_head lh;
2680 struct cleanup *back_to;
2681 unsigned int i, bytes_read;
2682 char *cur_file, *cur_dir;
2683 unsigned char op_code, extended_op, adj_opcode;
2684
2685#define FILE_ALLOC_CHUNK 5
2686#define DIR_ALLOC_CHUNK 5
2687
2688 struct filenames files;
2689 struct directories dirs;
2690
2691 /* state machine registers */
2692 unsigned int address = 0;
2693 unsigned int file = 1;
2694 unsigned int line = 1;
2695 unsigned int column = 0;
2696 int is_stmt; /* initialized below */
2697 int basic_block = 0;
2698 int beg_of_comp_unit = 0; /* is this right? */
2699 int end_sequence = 0;
2700
2701 files.num_files = 0;
2702 files.files = NULL;
2703
2704 dirs.num_dirs = 0;
2705 dirs.dirs = NULL;
2706
2707 line_ptr = dwarf_line_buffer + offset;
2708
2709 /* read in the prologue */
2710 lh.total_length = read_4_bytes (abfd, line_ptr);
2711 line_ptr += 4;
2712 lh.version = read_2_bytes (abfd, line_ptr);
2713 line_ptr += 2;
2714 lh.prologue_length = read_4_bytes (abfd, line_ptr);
2715 line_ptr += 4;
2716 lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
2717 line_ptr += 1;
2718 lh.default_is_stmt = read_1_byte (abfd, line_ptr);
2719 is_stmt = lh.default_is_stmt;
2720 line_ptr += 1;
2721 lh.line_base = read_1_byte (abfd, line_ptr);
2722 line_ptr += 1;
2723 lh.line_range = read_1_byte (abfd, line_ptr);
2724 line_ptr += 1;
2725 lh.opcode_base = read_1_byte (abfd, line_ptr);
2726 line_ptr += 1;
2727 lh.standard_opcode_lengths = (unsigned char *)
2728 xmalloc (lh.opcode_base * sizeof (unsigned char));
2729 back_to = make_cleanup (free, lh.standard_opcode_lengths);
2730
2731 lh.standard_opcode_lengths[0] = 1;
2732 for (i = 1; i < lh.opcode_base; ++i)
2733 {
2734 lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
2735 line_ptr += 1;
2736 }
2737
2738 /* Read directory table */
2739 while (cur_dir = read_string (abfd, line_ptr, &bytes_read))
2740 {
2741 line_ptr += bytes_read;
2742 if ((dirs.num_dirs % DIR_ALLOC_CHUNK) == 0)
2743 {
2744 dirs.dirs = xrealloc (dirs.dirs,
2745 (dirs.num_dirs + DIR_ALLOC_CHUNK) * sizeof (char *));
2746 }
2747 dirs.dirs[dirs.num_dirs++] = cur_dir;
2748 }
2749 line_ptr += bytes_read;
2750
2751 /* Read file name table */
2752 while (cur_file = read_string (abfd, line_ptr, &bytes_read))
2753 {
2754 line_ptr += bytes_read;
2755 if ((files.num_files % FILE_ALLOC_CHUNK) == 0)
2756 {
2757 files.files = xrealloc (files.files,
9422fadb 2758 (files.num_files + FILE_ALLOC_CHUNK) * sizeof (struct fileinfo));
fcf05549
SS		 2759 }
2760 files.files[files.num_files].name = cur_file;
2761 files.files[files.num_files].dir = read_unsigned_leb128 (abfd,
2762 line_ptr, &bytes_read);
2763 line_ptr += bytes_read;
2764 files.files[files.num_files].time = read_unsigned_leb128 (abfd,
2765 line_ptr, &bytes_read);
2766 line_ptr += bytes_read;
2767 files.files[files.num_files].size = read_unsigned_leb128 (abfd,
2768 line_ptr, &bytes_read);
2769 line_ptr += bytes_read;
2770 files.num_files++;
2771 }
2772 line_ptr += bytes_read;
2773
2774 /* Decode the table. */
2775 if (lh.total_length - (lh.prologue_length + 4 + 2) >= 4)
2776 do
2777 {
2778 op_code = read_1_byte (abfd, line_ptr);
2779 line_ptr += 1;
2780 switch (op_code)
2781 {
2782 case DW_LNS_extended_op:
2783 line_ptr += 1; /* ignore length */
2784 extended_op = read_1_byte (abfd, line_ptr);
2785 line_ptr += 1;
2786 switch (extended_op)
2787 {
2788 case DW_LNE_end_sequence:
2789 end_sequence = 1;
2790 record_line (current_subfile, line, address);
2791 return; /* return! */
2792 break;
2793 case DW_LNE_set_address:
2794 address = read_address (abfd, line_ptr);
2795 line_ptr += address_size;
2796 break;
2797 case DW_LNE_define_file:
2798 cur_file = read_string (abfd, line_ptr, &bytes_read);
2799 line_ptr += bytes_read;
2800 if ((files.num_files % FILE_ALLOC_CHUNK) == 0)
2801 {
2802 files.files = xrealloc (files.files,
2803 (files.num_files + FILE_ALLOC_CHUNK)
9422fadb 2804 * sizeof (struct fileinfo));
fcf05549
SS		 2805 }
2806 files.files[files.num_files].name = cur_file;
2807 files.files[files.num_files].dir = read_unsigned_leb128 (
2808 abfd, line_ptr, &bytes_read);
2809 line_ptr += bytes_read;
2810 files.files[files.num_files].time = read_unsigned_leb128 (abfd,
2811 line_ptr, &bytes_read);
2812 line_ptr += bytes_read;
2813 files.files[files.num_files].size = read_unsigned_leb128 (abfd,
2814 line_ptr, &bytes_read);
2815 line_ptr += bytes_read;
2816 break;
2817 default:
2818 error ("Dwarf Error: Mangled .debug_line section.");
2819 return;
2820 }
2821 break;
2822 case DW_LNS_copy:
2823 record_line (current_subfile, line, address);
2824 basic_block = 0;
2825 break;
2826 case DW_LNS_advance_pc:
2827 address += lh.minimum_instruction_length
2828 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
2829 line_ptr += bytes_read;
2830 break;
2831 case DW_LNS_advance_line:
2832 line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
2833 line_ptr += bytes_read;
2834 break;
2835 case DW_LNS_set_file:
2836 /* The file table is 0 based and the references are 1
2837 based, thus the subtraction of `1' at the end of the
2838 next line */
2839 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read) - 1;
2840 start_subfile (files.files[file].name,
2841 (files.files[file].dir ?
2842 dirs.dirs[files.files[file].dir] : 0));
2843 line_ptr += bytes_read;
2844 break;
2845 case DW_LNS_set_column:
2846 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
2847 line_ptr += bytes_read;
2848 break;
2849 case DW_LNS_negate_stmt:
2850 is_stmt = (!is_stmt);
2851 break;
2852 case DW_LNS_set_basic_block:
2853 basic_block = 1;
2854 break;
2855 case DW_LNS_const_add_pc:
2856 address += (255 - lh.opcode_base) / lh.line_range;
2857 break;
2858 case DW_LNS_fixed_advance_pc:
2859 address += read_2_bytes (abfd, line_ptr);
2860 line_ptr += 2;
2861 break;
2862 default: /* special operand */
2863 adj_opcode = op_code - lh.opcode_base;
2864 address += (adj_opcode / lh.line_range)
2865 * lh.minimum_instruction_length;
2866 line += lh.line_base + (adj_opcode % lh.line_range);
2867 /* append row to matrix using current values */
2868 record_line (current_subfile, line, address);
2869 basic_block = 1;
2870 }
2871 }
2872 while (1);
2873 do_cleanups (back_to);
2874}
2875
2876/* Given a pointer to a DWARF information entry, figure out if we need
2877 to make a symbol table entry for it, and if so, create a new entry
2878 and return a pointer to it. */
2879
2880static struct symbol *
2881new_symbol (die, objfile)
2882 struct die_info *die;
2883 struct objfile *objfile;
2884{
2885 struct symbol *sym = NULL;
2886 struct attribute *attr = NULL;
2887 struct attribute *attr2 = NULL;
2888 CORE_ADDR addr;
2889
2890 attr = dwarf_attr (die, DW_AT_name);
2891 if (attr)
2892 {
2893#if 0
2894 sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
2895 sizeof (struct symbol));
2896#endif
2897 sym = (struct symbol *) xmalloc (sizeof (struct symbol));
2898 memset (sym, 0, sizeof (struct symbol));
2899#if 0
2900 SYMBOL_NAME (sym) = create_name (DW_STRING (attr),
2901 &objfile->symbol_obstack);
2902#endif
2903 SYMBOL_NAME (sym) = strdup (DW_STRING (attr));
2904 /* default assumptions */
2905 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
2906 SYMBOL_CLASS (sym) = LOC_STATIC;
2907 SYMBOL_TYPE (sym) = die_type (die, objfile);
2908
2909 /* If this symbol is from a C++ compilation, then attempt to
2910 cache the demangled form for future reference. This is a
2911 typical time versus space tradeoff, that was decided in favor
2912 of time because it sped up C++ symbol lookups by a factor of
2913 about 20. */
2914
2915 SYMBOL_LANGUAGE (sym) = cu_language;
2916 SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->symbol_obstack);
2917 switch (die->tag)
2918 {
2919 case DW_TAG_label:
2920 attr = dwarf_attr (die, DW_AT_low_pc);
2921 if (attr)
2922 {
2923 SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr);
2924 }
2925 SYMBOL_CLASS (sym) = LOC_LABEL;
2926 break;
2927 case DW_TAG_subprogram:
2928 attr = dwarf_attr (die, DW_AT_low_pc);
2929 if (attr)
2930 {
2931 SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr);
2932 }
2933 SYMBOL_TYPE (sym) = make_function_type (die_type (die, objfile),
2934 NULL);
2935 SYMBOL_CLASS (sym) = LOC_BLOCK;
2936 attr2 = dwarf_attr (die, DW_AT_external);
2937 if (attr2 && (DW_UNSND (attr2) != 0))
2938 {
2939 add_symbol_to_list (sym, &global_symbols);
2940 }
2941 else
2942 {
2943 add_symbol_to_list (sym, list_in_scope);
2944 }
2945 break;
2946 case DW_TAG_variable:
2947 attr = dwarf_attr (die, DW_AT_location);
2948 if (attr)
2949 {
2950 attr2 = dwarf_attr (die, DW_AT_external);
2951 if (attr2 && (DW_UNSND (attr2) != 0))
2952 {
2953 SYMBOL_VALUE_ADDRESS (sym) =
2954 decode_locdesc (DW_BLOCK (attr), objfile);
2955 add_symbol_to_list (sym, &global_symbols);
2956 SYMBOL_CLASS (sym) = LOC_STATIC;
2957 SYMBOL_VALUE_ADDRESS (sym) += baseaddr;
2958 }
2959 else
2960 {
2961 SYMBOL_VALUE (sym) = addr =
2962 decode_locdesc (DW_BLOCK (attr), objfile);
2963 add_symbol_to_list (sym, list_in_scope);
2964 if (isreg)
2965 {
2966 SYMBOL_CLASS (sym) = LOC_REGISTER;
2967 }
2968 else if (offreg)
2969 {
2970 SYMBOL_CLASS (sym) = LOC_LOCAL;
2971 }
2972 else
2973 {
2974 SYMBOL_CLASS (sym) = LOC_STATIC;
2975 SYMBOL_VALUE_ADDRESS (sym) = addr + baseaddr;
2976 }
2977 }
2978 }
2979 break;
2980 case DW_TAG_formal_parameter:
2981 attr = dwarf_attr (die, DW_AT_location);
2982 if (attr != NULL)
2983 {
2984 SYMBOL_VALUE (sym) = decode_locdesc (DW_BLOCK (attr), objfile);
2985 }
2986 add_symbol_to_list (sym, list_in_scope);
2987 if (isreg)
2988 {
2989 SYMBOL_CLASS (sym) = LOC_REGPARM;
2990 }
2991 else
2992 {
2993 SYMBOL_CLASS (sym) = LOC_ARG;
2994 }
2995 break;
2996 case DW_TAG_unspecified_parameters:
2997 /* From varargs functions; gdb doesn't seem to have any
2998 interest in this information, so just ignore it for now.
2999 (FIXME?) */
3000 break;
3001 case DW_TAG_class_type:
3002 case DW_TAG_structure_type:
3003 case DW_TAG_union_type:
3004 case DW_TAG_enumeration_type:
3005 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
3006 SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
3007 add_symbol_to_list (sym, list_in_scope);
3008 break;
3009 case DW_TAG_typedef:
3010 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
3011 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
3012 add_symbol_to_list (sym, list_in_scope);
3013 break;
3014 default:
3015 /* Not a tag we recognize. Hopefully we aren't processing
3016 trash data, but since we must specifically ignore things
3017 we don't recognize, there is nothing else we should do at
3018 this point. */
3019 break;
3020 }
3021 }
3022 return (sym);
3023}
3024
3025/* Return the type of the die in question using its DW_AT_type attribute. */
3026
3027static struct type *
3028die_type (die, objfile)
3029 struct die_info *die;
3030 struct objfile *objfile;
3031{
3032 struct type *type;
3033 struct attribute *attr, *type_attr;
3034 struct die_info *type_die;
3035 unsigned int size = 0, encoding = 0, ref;
3036
3037 type_attr = dwarf_attr (die, DW_AT_type);
3038 if (!type_attr)
3039 {
3040 type = dwarf_base_type (0, 0);
3041 return type;
3042 }
3043 else
3044 {
3045 ref = DW_UNSND (type_attr);
3046 type_die = follow_die_ref (ref);
3047 if (!type_die)
3048 {
3049 error ("Dwarf Error: Cannot find referent at offset %d.", ref);
3050 return NULL;
3051 }
3052 }
3053 type = tag_type_to_type (type_die, objfile);
3054 if (!type)
3055 {
3056 error ("Dwarf Error: Problem turning type die at offset into gdb type:");
3057 dump_die (type_die);
3058 }
3059 return type;
3060}
3061
3062static struct type *
3063type_at_offset (offset, objfile)
3064 unsigned int offset;
3065 struct objfile *objfile;
3066{
3067 struct die_info *die;
3068 struct type *type;
3069
3070 die = follow_die_ref (offset);
3071 if (!die)
3072 {
3073 error ("Dwarf Error: Cannot find type referent at offset %d.", offset);
3074 return NULL;
3075 }
3076 type = tag_type_to_type (die, objfile);
3077 return type;
3078}
3079
3080static struct type *
3081tag_type_to_type (die, objfile)
3082 struct die_info *die;
3083 struct objfile *objfile;
3084{
3085 if (die->type)
3086 {
3087 return die->type;
3088 }
3089 else
3090 {
3091 read_type_die (die, objfile);
3092 if (!die->type)
3093 {
3094 dump_die (die);
3095 error ("Dwarf Error: Cannot find type of die:");
3096 }
3097 return die->type;
3098 }
3099}
3100
3101static void
3102read_type_die (die, objfile)
3103 struct die_info *die;
3104 struct objfile *objfile;
3105{
3106 switch (die->tag)
3107 {
3108 case DW_TAG_class_type:
3109 case DW_TAG_structure_type:
3110 case DW_TAG_union_type:
3111 read_structure_scope (die, objfile);
3112 break;
3113 case DW_TAG_enumeration_type:
3114 read_enumeration (die, objfile);
3115 break;
3116 case DW_TAG_subroutine_type:
3117 read_subroutine_type (die, objfile);
3118 break;
3119 case DW_TAG_array_type:
3120 dwarf_read_array_type (die, objfile);
3121 break;
3122 case DW_TAG_pointer_type:
3123 read_tag_pointer_type (die, objfile);
3124 break;
3125 case DW_TAG_const_type:
3126 read_tag_const_type (die, objfile);
3127 break;
3128 case DW_TAG_volatile_type:
3129 read_tag_volatile_type (die, objfile);
3130 break;
3131 case DW_TAG_string_type:
3132 read_tag_string_type (die, objfile);
3133 break;
3134 case DW_TAG_typedef:
3135 read_typedef (die, objfile);
3136 break;
3137 case DW_TAG_base_type:
3138 read_base_type (die, objfile);
3139 break;
3140 case DW_TAG_padding:
3141 case DW_TAG_compile_unit:
3142 case DW_TAG_subprogram:
3143 case DW_TAG_lexical_block:
3144 default:
3145 break;
3146 }
3147}
3148
3149static struct type *
3150dwarf_base_type (encoding, size)
3151 int encoding;
3152 int size;
3153{
3154 /* FIXME - this should not produce a new (struct type *)
3155 every time. It should cache base types. */
3156 struct type *type;
3157 switch (encoding)
3158 {
3159 case DW_ATE_address:
3160 type = dwarf2_fundamental_type (current_objfile, FT_VOID);
3161 return type;
3162 case DW_ATE_boolean:
3163 type = dwarf2_fundamental_type (current_objfile, FT_BOOLEAN);
3164 return type;
3165 case DW_ATE_complex_float:
3166 if (size == 16)
3167 {
3168 type = dwarf2_fundamental_type (current_objfile, FT_DBL_PREC_COMPLEX);
3169 }
3170 else
3171 {
3172 type = dwarf2_fundamental_type (current_objfile, FT_COMPLEX);
3173 }
3174 return type;
3175 case DW_ATE_float:
3176 if (size == 8)
3177 {
3178 type = dwarf2_fundamental_type (current_objfile, FT_DBL_PREC_FLOAT);
3179 }
3180 else
3181 {
3182 type = dwarf2_fundamental_type (current_objfile, FT_FLOAT);
3183 }
3184 return type;
3185 case DW_ATE_signed:
3186 switch (size)
3187 {
3188 case 1:
3189 type = dwarf2_fundamental_type (current_objfile, FT_SIGNED_CHAR);
3190 break;
3191 case 2:
3192 type = dwarf2_fundamental_type (current_objfile, FT_SIGNED_SHORT);
3193 break;
3194 default:
3195 case 4:
3196 type = dwarf2_fundamental_type (current_objfile, FT_SIGNED_INTEGER);
3197 break;
3198 }
3199 return type;
3200 case DW_ATE_signed_char:
3201 type = dwarf2_fundamental_type (current_objfile, FT_SIGNED_CHAR);
3202 return type;
3203 case DW_ATE_unsigned:
3204 switch (size)
3205 {
3206 case 1:
3207 type = dwarf2_fundamental_type (current_objfile, FT_UNSIGNED_CHAR);
3208 break;
3209 case 2:
3210 type = dwarf2_fundamental_type (current_objfile, FT_SIGNED_SHORT);
3211 break;
3212 default:
3213 case 4:
3214 type = dwarf2_fundamental_type (current_objfile, FT_UNSIGNED_INTEGER);
3215 break;
3216 }
3217 return type;
3218 case DW_ATE_unsigned_char:
3219 type = dwarf2_fundamental_type (current_objfile, FT_UNSIGNED_CHAR);
3220 return type;
3221 default:
3222 type = dwarf2_fundamental_type (current_objfile, FT_SIGNED_INTEGER);
3223 return type;
3224 }
3225}
3226
3227/* Given a pointer to a string and a pointer to an obstack, allocates
3228 a fresh copy of the string on the specified obstack. */
3229
3230static char *
3231create_name (name, obstackp)
3232 char *name;
3233 struct obstack *obstackp;
3234{
3235 int length;
3236 char *newname;
3237
3238 length = strlen (name) + 1;
3239 newname = (char *) obstack_alloc (obstackp, length);
3240 strcpy (newname, name);
3241 return (newname);
3242}
3243
3244struct die_info *
3245copy_die (old_die)
3246 struct die_info *old_die;
3247{
3248 struct die_info *new_die;
3249 int i, num_attrs;
3250
3251 new_die = (struct die_info *) xmalloc (sizeof (struct die_info));
3252 memset (new_die, 0, sizeof (struct die_info));
3253
3254 new_die->tag = old_die->tag;
3255 new_die->has_children = old_die->has_children;
3256 new_die->abbrev = old_die->abbrev;
3257 new_die->offset = old_die->offset;
3258 new_die->type = NULL;
3259
3260 num_attrs = old_die->num_attrs;
3261 new_die->num_attrs = num_attrs;
3262 new_die->attrs = (struct attribute *)
3263 xmalloc (num_attrs * sizeof (struct attribute));
3264
3265 for (i = 0; i < old_die->num_attrs; ++i)
3266 {
3267 new_die->attrs[i].name = old_die->attrs[i].name;
3268 new_die->attrs[i].form = old_die->attrs[i].form;
3269 new_die->attrs[i].u.addr = old_die->attrs[i].u.addr;
3270 }
3271
3272 new_die->next = NULL;
3273 return new_die;
3274}
3275
3276/* Return sibling of die, NULL if no sibling. */
3277
3278struct die_info *
3279sibling_die (die)
3280 struct die_info *die;
3281{
3282 struct die_info *new;
3283 int nesting_level = 0;
3284
3285 if (!die->has_children)
3286 {
3287 if (die->next && (die->next->tag == 0))
3288 {
3289 return NULL;
3290 }
3291 else
3292 {
3293 return die->next;
3294 }
3295 }
3296 else
3297 {
3298 do
3299 {
3300 if (die->has_children)
3301 {
3302 nesting_level++;
3303 }
3304 if (die->tag == 0)
3305 {
3306 nesting_level--;
3307 }
3308 die = die->next;
3309 }
3310 while (nesting_level);
3311 if (die && (die->tag == 0))
3312 {
3313 return NULL;
3314 }
3315 else
3316 {
3317 return die;
3318 }
3319 }
3320}
3321
3322/* Convert a DIE tag into its string name. */
3323
3324static char *
3325dwarf_tag_name (tag)
3326 register unsigned tag;
3327{
3328 switch (tag)
3329 {
3330 case DW_TAG_padding:
3331 return "DW_TAG_padding";
3332 case DW_TAG_array_type:
3333 return "DW_TAG_array_type";
3334 case DW_TAG_class_type:
3335 return "DW_TAG_class_type";
3336 case DW_TAG_entry_point:
3337 return "DW_TAG_entry_point";
3338 case DW_TAG_enumeration_type:
3339 return "DW_TAG_enumeration_type";
3340 case DW_TAG_formal_parameter:
3341 return "DW_TAG_formal_parameter";
3342 case DW_TAG_imported_declaration:
3343 return "DW_TAG_imported_declaration";
3344 case DW_TAG_label:
3345 return "DW_TAG_label";
3346 case DW_TAG_lexical_block:
3347 return "DW_TAG_lexical_block";
3348 case DW_TAG_member:
3349 return "DW_TAG_member";
3350 case DW_TAG_pointer_type:
3351 return "DW_TAG_pointer_type";
3352 case DW_TAG_reference_type:
3353 return "DW_TAG_reference_type";
3354 case DW_TAG_compile_unit:
3355 return "DW_TAG_compile_unit";
3356 case DW_TAG_string_type:
3357 return "DW_TAG_string_type";
3358 case DW_TAG_structure_type:
3359 return "DW_TAG_structure_type";
3360 case DW_TAG_subroutine_type:
3361 return "DW_TAG_subroutine_type";
3362 case DW_TAG_typedef:
3363 return "DW_TAG_typedef";
3364 case DW_TAG_union_type:
3365 return "DW_TAG_union_type";
3366 case DW_TAG_unspecified_parameters:
3367 return "DW_TAG_unspecified_parameters";
3368 case DW_TAG_variant:
3369 return "DW_TAG_variant";
3370 case DW_TAG_common_block:
3371 return "DW_TAG_common_block";
3372 case DW_TAG_common_inclusion:
3373 return "DW_TAG_common_inclusion";
3374 case DW_TAG_inheritance:
3375 return "DW_TAG_inheritance";
3376 case DW_TAG_inlined_subroutine:
3377 return "DW_TAG_inlined_subroutine";
3378 case DW_TAG_module:
3379 return "DW_TAG_module";
3380 case DW_TAG_ptr_to_member_type:
3381 return "DW_TAG_ptr_to_member_type";
3382 case DW_TAG_set_type:
3383 return "DW_TAG_set_type";
3384 case DW_TAG_subrange_type:
3385 return "DW_TAG_subrange_type";
3386 case DW_TAG_with_stmt:
3387 return "DW_TAG_with_stmt";
3388 case DW_TAG_access_declaration:
3389 return "DW_TAG_access_declaration";
3390 case DW_TAG_base_type:
3391 return "DW_TAG_base_type";
3392 case DW_TAG_catch_block:
3393 return "DW_TAG_catch_block";
3394 case DW_TAG_const_type:
3395 return "DW_TAG_const_type";
3396 case DW_TAG_constant:
3397 return "DW_TAG_constant";
3398 case DW_TAG_enumerator:
3399 return "DW_TAG_enumerator";
3400 case DW_TAG_file_type:
3401 return "DW_TAG_file_type";
3402 case DW_TAG_friend:
3403 return "DW_TAG_friend";
3404 case DW_TAG_namelist:
3405 return "DW_TAG_namelist";
3406 case DW_TAG_namelist_item:
3407 return "DW_TAG_namelist_item";
3408 case DW_TAG_packed_type:
3409 return "DW_TAG_packed_type";
3410 case DW_TAG_subprogram:
3411 return "DW_TAG_subprogram";
3412 case DW_TAG_template_type_param:
3413 return "DW_TAG_template_type_param";
3414 case DW_TAG_template_value_param:
3415 return "DW_TAG_template_value_param";
3416 case DW_TAG_thrown_type:
3417 return "DW_TAG_thrown_type";
3418 case DW_TAG_try_block:
3419 return "DW_TAG_try_block";
3420 case DW_TAG_variant_part:
3421 return "DW_TAG_variant_part";
3422 case DW_TAG_variable:
3423 return "DW_TAG_variable";
3424 case DW_TAG_volatile_type:
3425 return "DW_TAG_volatile_type";
3426 case DW_TAG_MIPS_loop:
3427 return "DW_TAG_MIPS_loop";
3428 case DW_TAG_format_label:
3429 return "DW_TAG_format_label";
3430 case DW_TAG_function_template:
3431 return "DW_TAG_function_template";
3432 case DW_TAG_class_template:
3433 return "DW_TAG_class_template";
3434 default:
3435 return "DW_TAG_<unknown>";
3436 }
3437}
3438
3439/* Convert a DWARF attribute code into its string name. */
3440
3441static char *
3442dwarf_attr_name (attr)
3443 register unsigned attr;
3444{
3445 switch (attr)
3446 {
3447 case DW_AT_sibling:
3448 return "DW_AT_sibling";
3449 case DW_AT_location:
3450 return "DW_AT_location";
3451 case DW_AT_name:
3452 return "DW_AT_name";
3453 case DW_AT_ordering:
3454 return "DW_AT_ordering";
3455 case DW_AT_subscr_data:
3456 return "DW_AT_subscr_data";
3457 case DW_AT_byte_size:
3458 return "DW_AT_byte_size";
3459 case DW_AT_bit_offset:
3460 return "DW_AT_bit_offset";
3461 case DW_AT_bit_size:
3462 return "DW_AT_bit_size";
3463 case DW_AT_element_list:
3464 return "DW_AT_element_list";
3465 case DW_AT_stmt_list:
3466 return "DW_AT_stmt_list";
3467 case DW_AT_low_pc:
3468 return "DW_AT_low_pc";
3469 case DW_AT_high_pc:
3470 return "DW_AT_high_pc";
3471 case DW_AT_language:
3472 return "DW_AT_language";
3473 case DW_AT_member:
3474 return "DW_AT_member";
3475 case DW_AT_discr:
3476 return "DW_AT_discr";
3477 case DW_AT_discr_value:
3478 return "DW_AT_discr_value";
3479 case DW_AT_visibility:
3480 return "DW_AT_visibility";
3481 case DW_AT_import:
3482 return "DW_AT_import";
3483 case DW_AT_string_length:
3484 return "DW_AT_string_length";
3485 case DW_AT_common_reference:
3486 return "DW_AT_common_reference";
3487 case DW_AT_comp_dir:
3488 return "DW_AT_comp_dir";
3489 case DW_AT_const_value:
3490 return "DW_AT_const_value";
3491 case DW_AT_containing_type:
3492 return "DW_AT_containing_type";
3493 case DW_AT_default_value:
3494 return "DW_AT_default_value";
3495 case DW_AT_inline:
3496 return "DW_AT_inline";
3497 case DW_AT_is_optional:
3498 return "DW_AT_is_optional";
3499 case DW_AT_lower_bound:
3500 return "DW_AT_lower_bound";
3501 case DW_AT_producer:
3502 return "DW_AT_producer";
3503 case DW_AT_prototyped:
3504 return "DW_AT_prototyped";
3505 case DW_AT_return_addr:
3506 return "DW_AT_return_addr";
3507 case DW_AT_start_scope:
3508 return "DW_AT_start_scope";
3509 case DW_AT_stride_size:
3510 return "DW_AT_stride_size";
3511 case DW_AT_upper_bound:
3512 return "DW_AT_upper_bound";
3513 case DW_AT_abstract_origin:
3514 return "DW_AT_abstract_origin";
3515 case DW_AT_accessibility:
3516 return "DW_AT_accessibility";
3517 case DW_AT_address_class:
3518 return "DW_AT_address_class";
3519 case DW_AT_artificial:
3520 return "DW_AT_artificial";
3521 case DW_AT_base_types:
3522 return "DW_AT_base_types";
3523 case DW_AT_calling_convention:
3524 return "DW_AT_calling_convention";
3525 case DW_AT_count:
3526 return "DW_AT_count";
3527 case DW_AT_data_member_location:
3528 return "DW_AT_data_member_location";
3529 case DW_AT_decl_column:
3530 return "DW_AT_decl_column";
3531 case DW_AT_decl_file:
3532 return "DW_AT_decl_file";
3533 case DW_AT_decl_line:
3534 return "DW_AT_decl_line";
3535 case DW_AT_declaration:
3536 return "DW_AT_declaration";
3537 case DW_AT_discr_list:
3538 return "DW_AT_discr_list";
3539 case DW_AT_encoding:
3540 return "DW_AT_encoding";
3541 case DW_AT_external:
3542 return "DW_AT_external";
3543 case DW_AT_frame_base:
3544 return "DW_AT_frame_base";
3545 case DW_AT_friend:
3546 return "DW_AT_friend";
3547 case DW_AT_identifier_case:
3548 return "DW_AT_identifier_case";
3549 case DW_AT_macro_info:
3550 return "DW_AT_macro_info";
3551 case DW_AT_namelist_items:
3552 return "DW_AT_namelist_items";
3553 case DW_AT_priority:
3554 return "DW_AT_priority";
3555 case DW_AT_segment:
3556 return "DW_AT_segment";
3557 case DW_AT_specification:
3558 return "DW_AT_specification";
3559 case DW_AT_static_link:
3560 return "DW_AT_static_link";
3561 case DW_AT_type:
3562 return "DW_AT_type";
3563 case DW_AT_use_location:
3564 return "DW_AT_use_location";
3565 case DW_AT_variable_parameter:
3566 return "DW_AT_variable_parameter";
3567 case DW_AT_virtuality:
3568 return "DW_AT_virtuality";
3569 case DW_AT_vtable_elem_location:
3570 return "DW_AT_vtable_elem_location";
3571
3572#ifdef MIPS
3573 case DW_AT_MIPS_fde:
3574 return "DW_AT_MIPS_fde";
3575 case DW_AT_MIPS_loop_begin:
3576 return "DW_AT_MIPS_loop_begin";
3577 case DW_AT_MIPS_tail_loop_begin:
3578 return "DW_AT_MIPS_tail_loop_begin";
3579 case DW_AT_MIPS_epilog_begin:
3580 return "DW_AT_MIPS_epilog_begin";
3581 case DW_AT_MIPS_loop_unroll_factor:
3582 return "DW_AT_MIPS_loop_unroll_factor";
3583 case DW_AT_MIPS_software_pipeline_depth:
3584 return "DW_AT_MIPS_software_pipeline_depth";
3585 case DW_AT_MIPS_linkage_name:
3586 return "DW_AT_MIPS_linkage_name";
3587#endif
3588
3589 case DW_AT_sf_names:
3590 return "DW_AT_sf_names";
3591 case DW_AT_src_info:
3592 return "DW_AT_src_info";
3593 case DW_AT_mac_info:
3594 return "DW_AT_mac_info";
3595 case DW_AT_src_coords:
3596 return "DW_AT_src_coords";
3597 case DW_AT_body_begin:
3598 return "DW_AT_body_begin";
3599 case DW_AT_body_end:
3600 return "DW_AT_body_end";
3601 default:
3602 return "DW_AT_<unknown>";
3603 }
3604}
3605
3606/* Convert a DWARF value form code into its string name. */
3607
3608static char *
3609dwarf_form_name (form)
3610 register unsigned form;
3611{
3612 switch (form)
3613 {
3614 case DW_FORM_addr:
3615 return "DW_FORM_addr";
3616 case DW_FORM_block2:
3617 return "DW_FORM_block2";
3618 case DW_FORM_block4:
3619 return "DW_FORM_block4";
3620 case DW_FORM_data2:
3621 return "DW_FORM_data2";
3622 case DW_FORM_data4:
3623 return "DW_FORM_data4";
3624 case DW_FORM_data8:
3625 return "DW_FORM_data8";
3626 case DW_FORM_string:
3627 return "DW_FORM_string";
3628 case DW_FORM_block:
3629 return "DW_FORM_block";
3630 case DW_FORM_block1:
3631 return "DW_FORM_block1";
3632 case DW_FORM_data1:
3633 return "DW_FORM_data1";
3634 case DW_FORM_flag:
3635 return "DW_FORM_flag";
3636 case DW_FORM_sdata:
3637 return "DW_FORM_sdata";
3638 case DW_FORM_strp:
3639 return "DW_FORM_strp";
3640 case DW_FORM_udata:
3641 return "DW_FORM_udata";
3642 case DW_FORM_ref_addr:
3643 return "DW_FORM_ref_addr";
3644 case DW_FORM_ref1:
3645 return "DW_FORM_ref1";
3646 case DW_FORM_ref2:
3647 return "DW_FORM_ref2";
3648 case DW_FORM_ref4:
3649 return "DW_FORM_ref4";
3650 case DW_FORM_ref8:
3651 return "DW_FORM_ref8";
3652 case DW_FORM_ref_udata:
3653 return "DW_FORM_ref_udata";
3654 case DW_FORM_indirect:
3655 return "DW_FORM_indirect";
3656 default:
3657 return "DW_FORM_<unknown>";
3658 }
3659}
3660
3661/* Convert a DWARF stack opcode into its string name. */
3662
3663static char *
3664dwarf_stack_op_name (op)
3665 register unsigned op;
3666{
3667 switch (op)
3668 {
3669 case DW_OP_addr:
3670 return "DW_OP_addr";
3671 case DW_OP_deref:
3672 return "DW_OP_deref";
3673 case DW_OP_const1u:
3674 return "DW_OP_const1u";
3675 case DW_OP_const1s:
3676 return "DW_OP_const1s";
3677 case DW_OP_const2u:
3678 return "DW_OP_const2u";
3679 case DW_OP_const2s:
3680 return "DW_OP_const2s";
3681 case DW_OP_const4u:
3682 return "DW_OP_const4u";
3683 case DW_OP_const4s:
3684 return "DW_OP_const4s";
3685 case DW_OP_const8u:
3686 return "DW_OP_const8u";
3687 case DW_OP_const8s:
3688 return "DW_OP_const8s";
3689 case DW_OP_constu:
3690 return "DW_OP_constu";
3691 case DW_OP_consts:
3692 return "DW_OP_consts";
3693 case DW_OP_dup:
3694 return "DW_OP_dup";
3695 case DW_OP_drop:
3696 return "DW_OP_drop";
3697 case DW_OP_over:
3698 return "DW_OP_over";
3699 case DW_OP_pick:
3700 return "DW_OP_pick";
3701 case DW_OP_swap:
3702 return "DW_OP_swap";
3703 case DW_OP_rot:
3704 return "DW_OP_rot";
3705 case DW_OP_xderef:
3706 return "DW_OP_xderef";
3707 case DW_OP_abs:
3708 return "DW_OP_abs";
3709 case DW_OP_and:
3710 return "DW_OP_and";
3711 case DW_OP_div:
3712 return "DW_OP_div";
3713 case DW_OP_minus:
3714 return "DW_OP_minus";
3715 case DW_OP_mod:
3716 return "DW_OP_mod";
3717 case DW_OP_mul:
3718 return "DW_OP_mul";
3719 case DW_OP_neg:
3720 return "DW_OP_neg";
3721 case DW_OP_not:
3722 return "DW_OP_not";
3723 case DW_OP_or:
3724 return "DW_OP_or";
3725 case DW_OP_plus:
3726 return "DW_OP_plus";
3727 case DW_OP_plus_uconst:
3728 return "DW_OP_plus_uconst";
3729 case DW_OP_shl:
3730 return "DW_OP_shl";
3731 case DW_OP_shr:
3732 return "DW_OP_shr";
3733 case DW_OP_shra:
3734 return "DW_OP_shra";
3735 case DW_OP_xor:
3736 return "DW_OP_xor";
3737 case DW_OP_bra:
3738 return "DW_OP_bra";
3739 case DW_OP_eq:
3740 return "DW_OP_eq";
3741 case DW_OP_ge:
3742 return "DW_OP_ge";
3743 case DW_OP_gt:
3744 return "DW_OP_gt";
3745 case DW_OP_le:
3746 return "DW_OP_le";
3747 case DW_OP_lt:
3748 return "DW_OP_lt";
3749 case DW_OP_ne:
3750 return "DW_OP_ne";
3751 case DW_OP_skip:
3752 return "DW_OP_skip";
3753 case DW_OP_lit0:
3754 return "DW_OP_lit0";
3755 case DW_OP_lit1:
3756 return "DW_OP_lit1";
3757 case DW_OP_lit2:
3758 return "DW_OP_lit2";
3759 case DW_OP_lit3:
3760 return "DW_OP_lit3";
3761 case DW_OP_lit4:
3762 return "DW_OP_lit4";
3763 case DW_OP_lit5:
3764 return "DW_OP_lit5";
3765 case DW_OP_lit6:
3766 return "DW_OP_lit6";
3767 case DW_OP_lit7:
3768 return "DW_OP_lit7";
3769 case DW_OP_lit8:
3770 return "DW_OP_lit8";
3771 case DW_OP_lit9:
3772 return "DW_OP_lit9";
3773 case DW_OP_lit10:
3774 return "DW_OP_lit10";
3775 case DW_OP_lit11:
3776 return "DW_OP_lit11";
3777 case DW_OP_lit12:
3778 return "DW_OP_lit12";
3779 case DW_OP_lit13:
3780 return "DW_OP_lit13";
3781 case DW_OP_lit14:
3782 return "DW_OP_lit14";
3783 case DW_OP_lit15:
3784 return "DW_OP_lit15";
3785 case DW_OP_lit16:
3786 return "DW_OP_lit16";
3787 case DW_OP_lit17:
3788 return "DW_OP_lit17";
3789 case DW_OP_lit18:
3790 return "DW_OP_lit18";
3791 case DW_OP_lit19:
3792 return "DW_OP_lit19";
3793 case DW_OP_lit20:
3794 return "DW_OP_lit20";
3795 case DW_OP_lit21:
3796 return "DW_OP_lit21";
3797 case DW_OP_lit22:
3798 return "DW_OP_lit22";
3799 case DW_OP_lit23:
3800 return "DW_OP_lit23";
3801 case DW_OP_lit24:
3802 return "DW_OP_lit24";
3803 case DW_OP_lit25:
3804 return "DW_OP_lit25";
3805 case DW_OP_lit26:
3806 return "DW_OP_lit26";
3807 case DW_OP_lit27:
3808 return "DW_OP_lit27";
3809 case DW_OP_lit28:
3810 return "DW_OP_lit28";
3811 case DW_OP_lit29:
3812 return "DW_OP_lit29";
3813 case DW_OP_lit30:
3814 return "DW_OP_lit30";
3815 case DW_OP_lit31:
3816 return "DW_OP_lit31";
3817 case DW_OP_reg0:
3818 return "DW_OP_reg0";
3819 case DW_OP_reg1:
3820 return "DW_OP_reg1";
3821 case DW_OP_reg2:
3822 return "DW_OP_reg2";
3823 case DW_OP_reg3:
3824 return "DW_OP_reg3";
3825 case DW_OP_reg4:
3826 return "DW_OP_reg4";
3827 case DW_OP_reg5:
3828 return "DW_OP_reg5";
3829 case DW_OP_reg6:
3830 return "DW_OP_reg6";
3831 case DW_OP_reg7:
3832 return "DW_OP_reg7";
3833 case DW_OP_reg8:
3834 return "DW_OP_reg8";
3835 case DW_OP_reg9:
3836 return "DW_OP_reg9";
3837 case DW_OP_reg10:
3838 return "DW_OP_reg10";
3839 case DW_OP_reg11:
3840 return "DW_OP_reg11";
3841 case DW_OP_reg12:
3842 return "DW_OP_reg12";
3843 case DW_OP_reg13:
3844 return "DW_OP_reg13";
3845 case DW_OP_reg14:
3846 return "DW_OP_reg14";
3847 case DW_OP_reg15:
3848 return "DW_OP_reg15";
3849 case DW_OP_reg16:
3850 return "DW_OP_reg16";
3851 case DW_OP_reg17:
3852 return "DW_OP_reg17";
3853 case DW_OP_reg18:
3854 return "DW_OP_reg18";
3855 case DW_OP_reg19:
3856 return "DW_OP_reg19";
3857 case DW_OP_reg20:
3858 return "DW_OP_reg20";
3859 case DW_OP_reg21:
3860 return "DW_OP_reg21";
3861 case DW_OP_reg22:
3862 return "DW_OP_reg22";
3863 case DW_OP_reg23:
3864 return "DW_OP_reg23";
3865 case DW_OP_reg24:
3866 return "DW_OP_reg24";
3867 case DW_OP_reg25:
3868 return "DW_OP_reg25";
3869 case DW_OP_reg26:
3870 return "DW_OP_reg26";
3871 case DW_OP_reg27:
3872 return "DW_OP_reg27";
3873 case DW_OP_reg28:
3874 return "DW_OP_reg28";
3875 case DW_OP_reg29:
3876 return "DW_OP_reg29";
3877 case DW_OP_reg30:
3878 return "DW_OP_reg30";
3879 case DW_OP_reg31:
3880 return "DW_OP_reg31";
3881 case DW_OP_breg0:
3882 return "DW_OP_breg0";
3883 case DW_OP_breg1:
3884 return "DW_OP_breg1";
3885 case DW_OP_breg2:
3886 return "DW_OP_breg2";
3887 case DW_OP_breg3:
3888 return "DW_OP_breg3";
3889 case DW_OP_breg4:
3890 return "DW_OP_breg4";
3891 case DW_OP_breg5:
3892 return "DW_OP_breg5";
3893 case DW_OP_breg6:
3894 return "DW_OP_breg6";
3895 case DW_OP_breg7:
3896 return "DW_OP_breg7";
3897 case DW_OP_breg8:
3898 return "DW_OP_breg8";
3899 case DW_OP_breg9:
3900 return "DW_OP_breg9";
3901 case DW_OP_breg10:
3902 return "DW_OP_breg10";
3903 case DW_OP_breg11:
3904 return "DW_OP_breg11";
3905 case DW_OP_breg12:
3906 return "DW_OP_breg12";
3907 case DW_OP_breg13:
3908 return "DW_OP_breg13";
3909 case DW_OP_breg14:
3910 return "DW_OP_breg14";
3911 case DW_OP_breg15:
3912 return "DW_OP_breg15";
3913 case DW_OP_breg16:
3914 return "DW_OP_breg16";
3915 case DW_OP_breg17:
3916 return "DW_OP_breg17";
3917 case DW_OP_breg18:
3918 return "DW_OP_breg18";
3919 case DW_OP_breg19:
3920 return "DW_OP_breg19";
3921 case DW_OP_breg20:
3922 return "DW_OP_breg20";
3923 case DW_OP_breg21:
3924 return "DW_OP_breg21";
3925 case DW_OP_breg22:
3926 return "DW_OP_breg22";
3927 case DW_OP_breg23:
3928 return "DW_OP_breg23";
3929 case DW_OP_breg24:
3930 return "DW_OP_breg24";
3931 case DW_OP_breg25:
3932 return "DW_OP_breg25";
3933 case DW_OP_breg26:
3934 return "DW_OP_breg26";
3935 case DW_OP_breg27:
3936 return "DW_OP_breg27";
3937 case DW_OP_breg28:
3938 return "DW_OP_breg28";
3939 case DW_OP_breg29:
3940 return "DW_OP_breg29";
3941 case DW_OP_breg30:
3942 return "DW_OP_breg30";
3943 case DW_OP_breg31:
3944 return "DW_OP_breg31";
3945 case DW_OP_regx:
3946 return "DW_OP_regx";
3947 case DW_OP_fbreg:
3948 return "DW_OP_fbreg";
3949 case DW_OP_bregx:
3950 return "DW_OP_bregx";
3951 case DW_OP_piece:
3952 return "DW_OP_piece";
3953 case DW_OP_deref_size:
3954 return "DW_OP_deref_size";
3955 case DW_OP_xderef_size:
3956 return "DW_OP_xderef_size";
3957 case DW_OP_nop:
3958 return "DW_OP_nop";
3959 default:
3960 return "OP_<unknown>";
3961 }
3962}
3963
3964static char *
3965dwarf_bool_name (bool)
3966 unsigned bool;
3967{
3968 if (bool)
3969 return "TRUE";
3970 else
3971 return "FALSE";
3972}
3973
3974/* Convert a DWARF type code into its string name. */
3975
3976static char *
3977dwarf_type_encoding_name (enc)
3978 register unsigned enc;
3979{
3980 switch (enc)
3981 {
3982 case DW_ATE_address:
3983 return "DW_ATE_address";
3984 case DW_ATE_boolean:
3985 return "DW_ATE_boolean";
3986 case DW_ATE_complex_float:
3987 return "DW_ATE_complex_float";
3988 case DW_ATE_float:
3989 return "DW_ATE_float";
3990 case DW_ATE_signed:
3991 return "DW_ATE_signed";
3992 case DW_ATE_signed_char:
3993 return "DW_ATE_signed_char";
3994 case DW_ATE_unsigned:
3995 return "DW_ATE_unsigned";
3996 case DW_ATE_unsigned_char:
3997 return "DW_ATE_unsigned_char";
3998 default:
3999 return "DW_ATE_<unknown>";
4000 }
4001}
4002
4003/* Convert a DWARF call frame info operation to its string name. */
4004
4005static char *
4006dwarf_cfi_name (cfi_opc)
4007 register unsigned cfi_opc;
4008{
4009 switch (cfi_opc)
4010 {
4011 case DW_CFA_advance_loc:
4012 return "DW_CFA_advance_loc";
4013 case DW_CFA_offset:
4014 return "DW_CFA_offset";
4015 case DW_CFA_restore:
4016 return "DW_CFA_restore";
4017 case DW_CFA_nop:
4018 return "DW_CFA_nop";
4019 case DW_CFA_set_loc:
4020 return "DW_CFA_set_loc";
4021 case DW_CFA_advance_loc1:
4022 return "DW_CFA_advance_loc1";
4023 case DW_CFA_advance_loc2:
4024 return "DW_CFA_advance_loc2";
4025 case DW_CFA_advance_loc4:
4026 return "DW_CFA_advance_loc4";
4027 case DW_CFA_offset_extended:
4028 return "DW_CFA_offset_extended";
4029 case DW_CFA_restore_extended:
4030 return "DW_CFA_restore_extended";
4031 case DW_CFA_undefined:
4032 return "DW_CFA_undefined";
4033 case DW_CFA_same_value:
4034 return "DW_CFA_same_value";
4035 case DW_CFA_register:
4036 return "DW_CFA_register";
4037 case DW_CFA_remember_state:
4038 return "DW_CFA_remember_state";
4039 case DW_CFA_restore_state:
4040 return "DW_CFA_restore_state";
4041 case DW_CFA_def_cfa:
4042 return "DW_CFA_def_cfa";
4043 case DW_CFA_def_cfa_register:
4044 return "DW_CFA_def_cfa_register";
4045 case DW_CFA_def_cfa_offset:
4046 return "DW_CFA_def_cfa_offset";
4047 /* SGI/MIPS specific */
4048 case DW_CFA_MIPS_advance_loc8:
4049 return "DW_CFA_MIPS_advance_loc8";
4050 default:
4051 return "DW_CFA_<unknown>";
4052 }
4053}
4054
4055void
4056dump_die (die)
4057 struct die_info *die;
4058{
4059 int i;
4060
4061 fprintf (stderr, "Die: %s (abbrev = %d, offset = %d)\n",
4062 dwarf_tag_name (die->tag), die->abbrev, die->offset);
4063 fprintf (stderr, "\thas children: %s\n",
4064 dwarf_bool_name (die->has_children));
4065
4066 fprintf (stderr, "\tattributes:\n");
4067 for (i = 0; i < die->num_attrs; ++i)
4068 {
4069 fprintf (stderr, "\t\t%s (%s) ",
4070 dwarf_attr_name (die->attrs[i].name),
4071 dwarf_form_name (die->attrs[i].form));
4072 switch (die->attrs[i].form)
4073 {
4074 case DW_FORM_ref_addr:
4075 case DW_FORM_addr:
4076 fprintf (stderr, sizeof (CORE_ADDR) > sizeof (long) ?
4077 "address: 0x%LLx" : "address: 0x%x",
4078 die->attrs[i].u.addr);
4079 break;
4080 case DW_FORM_block2:
4081 case DW_FORM_block4:
4082 case DW_FORM_block:
4083 case DW_FORM_block1:
4084 fprintf (stderr, "block: size %d",
4085 die->attrs[i].u.blk->size);
4086 break;
4087 case DW_FORM_data1:
4088 case DW_FORM_data2:
4089 case DW_FORM_data4:
4090 case DW_FORM_ref1:
4091 case DW_FORM_ref2:
4092 case DW_FORM_ref4:
4093 case DW_FORM_udata:
4094 case DW_FORM_sdata:
4095 fprintf (stderr, "constant: %d", die->attrs[i].u.unsnd);
4096 break;
4097 case DW_FORM_string:
4098 fprintf (stderr, "string: \"%s\"", die->attrs[i].u.str);
4099 break;
4100 case DW_FORM_flag:
4101 if (die->attrs[i].u.unsnd)
4102 fprintf (stderr, "flag: TRUE");
4103 else
4104 fprintf (stderr, "flag: FALSE");
4105 break;
4106 case DW_FORM_strp: /* we do not support separate string
4107 section yet */
4108 case DW_FORM_indirect: /* we do not handle indirect yet */
4109 case DW_FORM_data8: /* we do not have 64 bit quantities */
4110 error ("Dwarf Error: Unsupported attribute form: %d.",
4111 die->attrs[i].form);
4112 }
4113 fprintf (stderr, "\n");
4114 }
4115}
4116
4117void
4118dump_die_list (die)
4119 struct die_info *die;
4120{
4121 while (die)
4122 {
4123 dump_die (die);
4124 die = die->next;
4125 }
4126}
4127
4128void
4129store_in_ref_table (offset, die)
4130 unsigned int offset;
4131 struct die_info *die;
4132{
4133 int h;
4134 struct die_info *old;
4135
4136 h = (offset % REF_HASH_SIZE);
4137 old = die_ref_table[h];
4138 die->next_ref = old;
4139 die_ref_table[h] = die;
4140}
4141
4142struct die_info *
4143follow_die_ref (offset)
4144 unsigned int offset;
4145{
4146 struct die_info *die;
4147 int h;
4148
4149 h = (offset % REF_HASH_SIZE);
4150 die = die_ref_table[h];
4151 while (die)
4152 {
4153 if (die->offset == offset)
4154 {
4155 return die;
4156 }
4157 die = die->next_ref;
4158 }
4159 return NULL;
4160}
4161
4162static struct type *
4163dwarf2_fundamental_type (objfile, typeid)
4164 struct objfile *objfile;
4165 int typeid;
4166{
4167 if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
4168 {
4169 error ("Dwarf Error: internal error - invalid fundamental type id %d.",
4170 typeid);
4171 }
4172
4173 /* Look for this particular type in the fundamental type vector. If
4174 one is not found, create and install one appropriate for the
4175 current language and the current target machine. */
4176
4177 if (ftypes[typeid] == NULL)
4178 {
4179 ftypes[typeid] = cu_language_defn->la_fund_type (objfile, typeid);
4180 }
4181
4182 return (ftypes[typeid]);
4183}
4184
4185/* Decode simple location descriptions.
4186 There are three cases:
4187 An address: return the address.
4188 An address relative to frame pointer: return the offset.
4189 A register: return register number and set isreg to true.
4190 A constant followed by plus: return the constant. */
4191
4192static CORE_ADDR
4193decode_locdesc (blk, objfile)
4194 struct dwarf_block *blk;
4195 struct objfile *objfile;
4196{
4197 int i, snd;
4198 int size = blk->size;
4199 char *data = blk->data;
4200 unsigned int bytes_read, unsnd;
4201 unsigned char op;
4202 union
4203 {
4204 CORE_ADDR addr;
4205 char bytes[sizeof (CORE_ADDR)];
4206 }
4207 u;
4208
4209 i = 0;
4210 isreg = 0;
4211 offreg = 0;
4212
4213 /* FIXME: handle more general forms of location descriptors. */
4214 while (i < size)
4215 {
4216 op = data[i++];
4217 switch (op)
4218 {
4219 case DW_OP_reg0:
4220 isreg = 1;
4221 return 0;
4222 case DW_OP_reg1:
4223 isreg = 1;
4224 return 1;
4225 case DW_OP_reg2:
4226 isreg = 1;
4227 return 2;
4228 case DW_OP_reg3:
4229 isreg = 1;
4230 return 3;
4231 case DW_OP_reg4:
4232 isreg = 1;
4233 return 4;
4234 case DW_OP_reg5:
4235 isreg = 1;
4236 return 5;
4237 case DW_OP_reg6:
4238 isreg = 1;
4239 return 6;
4240 case DW_OP_reg7:
4241 isreg = 1;
4242 return 7;
4243 case DW_OP_reg8:
4244 isreg = 1;
4245 return 8;
4246 case DW_OP_reg9:
4247 isreg = 1;
4248 return 9;
4249 case DW_OP_reg10:
4250 isreg = 1;
4251 return 10;
4252 case DW_OP_reg11:
4253 isreg = 1;
4254 return 11;
4255 case DW_OP_reg12:
4256 isreg = 1;
4257 return 12;
4258 case DW_OP_reg13:
4259 isreg = 1;
4260 return 13;
4261 case DW_OP_reg14:
4262 isreg = 1;
4263 return 14;
4264 case DW_OP_reg15:
4265 isreg = 1;
4266 return 15;
4267 case DW_OP_reg16:
4268 isreg = 1;
4269 return 16;
4270 case DW_OP_reg17:
4271 isreg = 1;
4272 return 17;
4273 case DW_OP_reg18:
4274 isreg = 1;
4275 return 18;
4276 case DW_OP_reg19:
4277 isreg = 1;
4278 return 19;
4279 case DW_OP_reg20:
4280 isreg = 1;
4281 return 20;
4282 case DW_OP_reg21:
4283 isreg = 1;
4284 return 21;
4285 case DW_OP_reg22:
4286 isreg = 1;
4287 return 22;
4288 case DW_OP_reg23:
4289 isreg = 1;
4290 return 23;
4291 case DW_OP_reg24:
4292 isreg = 1;
4293 return 24;
4294 case DW_OP_reg25:
4295 isreg = 1;
4296 return 25;
4297 case DW_OP_reg26:
4298 isreg = 1;
4299 return 26;
4300 case DW_OP_reg27:
4301 isreg = 1;
4302 return 27;
4303 case DW_OP_reg28:
4304 isreg = 1;
4305 return 28;
4306 case DW_OP_reg29:
4307 isreg = 1;
4308 return 29;
4309 case DW_OP_reg30:
4310 isreg = 1;
4311 return 30;
4312 case DW_OP_reg31:
4313 isreg = 1;
4314 return 31;
4315
4316 case DW_OP_regx:
4317 isreg = 1;
4318 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
4319 i += bytes_read;
4320#if defined(HARRIS_TARGET) && defined(_M88K)
4321 /* The Harris 88110 gdb ports have long kept their special reg
4322 numbers between their gp-regs and their x-regs. This is
4323 not how our dwarf is generated. Punt. */
4324 return unsnd + 6;
4325#else
4326 return unsnd;
4327#endif
4328
4329 case DW_OP_fbreg:
4330 case DW_OP_breg31:
4331 offreg = 1;
4332 snd = read_signed_leb128 (NULL, (data + i), &bytes_read);
4333 i += bytes_read;
4334 return snd;
4335
4336 case DW_OP_addr:
4337 isreg = 0;
4338 return read_address (objfile->obfd, &data[i]);
4339
4340 case DW_OP_constu:
4341 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read);
4342 i += bytes_read;
4343 break;
4344
4345 case DW_OP_plus:
4346 return unsnd;
4347
4348 }
4349 }
4350 return 0;
4351}
4352
4353/* memory allocation interface */
4354
4355static struct type *
4356dwarf_alloc_type (objfile)
4357 struct objfile *objfile;
4358{
4359 struct type *type;
4360
4361 type = (struct type *) xmalloc (sizeof (struct type));
4362 memset (type, 0, sizeof (struct type));
4363
4364#if 0
4365 type = alloc_type (objfile);
4366#endif
4367
4368 return (type);
4369}
4370
4371static struct abbrev_info *
4372dwarf_alloc_abbrev ()
4373{
4374 struct abbrev_info *abbrev;
4375
4376 abbrev = xmalloc (sizeof (struct abbrev_info));
4377 memset (abbrev, 0, sizeof (struct abbrev_info));
4378 return (abbrev);
4379}
4380
4381static struct dwarf_block *
4382dwarf_alloc_block ()
4383{
4384 struct dwarf_block *blk;
4385
4386 blk = (struct dwarf_block *) xmalloc (sizeof (struct dwarf_block));
4387 return (blk);
4388}
4389
4390static struct die_info *
4391dwarf_alloc_die ()
4392{
4393 struct die_info *die;
4394
4395 die = (struct die_info *) xmalloc (sizeof (struct die_info));
4396 memset (die, 0, sizeof (struct die_info));
4397 return (die);
4398}
Empty description
This page took 0.493009 seconds and 4 git commands to generate.