Remove h8/300 and z8k since not ready yet.
[deliverable/binutils-gdb.git] / gdb / dwarfread.c
1 /* DWARF debugging format support for GDB.
2 Copyright (C) 1991, 1992 Free Software Foundation, Inc.
3 Written by Fred Fish at Cygnus Support. Portions based on dbxread.c,
4 mipsread.c, coffread.c, and dwarfread.c from a Data General SVR4 gdb port.
5
6 This file is part of GDB.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
21
22 /*
23
24 FIXME: Figure out how to get the frame pointer register number in the
25 execution environment of the target. Remove R_FP kludge
26
27 FIXME: Add generation of dependencies list to partial symtab code.
28
29 FIXME: Resolve minor differences between what information we put in the
30 partial symbol table and what dbxread puts in. For example, we don't yet
31 put enum constants there. And dbxread seems to invent a lot of typedefs
32 we never see. Use the new printpsym command to see the partial symbol table
33 contents.
34
35 FIXME: Figure out a better way to tell gdb about the name of the function
36 contain the user's entry point (I.E. main())
37
38 FIXME: See other FIXME's and "ifdef 0" scattered throughout the code for
39 other things to work on, if you get bored. :-)
40
41 */
42
43 #include "defs.h"
44 #include "bfd.h"
45 #include "symtab.h"
46 #include "gdbtypes.h"
47 #include "symfile.h"
48 #include "objfiles.h"
49 #include "libbfd.h" /* FIXME Secret Internal BFD stuff (bfd_read) */
50 #include "elf/dwarf.h"
51 #include "buildsym.h"
52 #include "demangle.h"
53 #include "expression.h" /* Needed for enum exp_opcode in language.h, sigh... */
54 #include "language.h"
55 #include "complaints.h"
56
57 #include <fcntl.h>
58 #include <string.h>
59 #include <sys/types.h>
60
61 #ifndef NO_SYS_FILE
62 #include <sys/file.h>
63 #endif
64
65 /* FIXME -- convert this to SEEK_SET a la POSIX, move to config files. */
66 #ifndef L_SET
67 #define L_SET 0
68 #endif
69
70 /* Some macros to provide DIE info for complaints. */
71
72 #define DIE_ID (curdie!=NULL ? curdie->die_ref : 0)
73 #define DIE_NAME (curdie!=NULL && curdie->at_name!=NULL) ? curdie->at_name : ""
74
75 /* Complaints that can be issued during DWARF debug info reading. */
76
77 struct complaint no_bfd_get_N =
78 {
79 "DIE @ 0x%x \"%s\", no bfd support for %d byte data object", 0, 0
80 };
81
82 struct complaint malformed_die =
83 {
84 "DIE @ 0x%x \"%s\", malformed DIE, bad length (%d bytes)", 0, 0
85 };
86
87 struct complaint bad_die_ref =
88 {
89 "DIE @ 0x%x \"%s\", reference to DIE (0x%x) outside compilation unit", 0, 0
90 };
91
92 struct complaint unknown_attribute_form =
93 {
94 "DIE @ 0x%x \"%s\", unknown attribute form (0x%x)", 0, 0
95 };
96
97 struct complaint unknown_attribute_length =
98 {
99 "DIE @ 0x%x \"%s\", unknown attribute length, skipped remaining attributes", 0, 0
100 };
101
102 struct complaint unexpected_fund_type =
103 {
104 "DIE @ 0x%x \"%s\", unexpected fundamental type 0x%x", 0, 0
105 };
106
107 struct complaint unknown_type_modifier =
108 {
109 "DIE @ 0x%x \"%s\", unknown type modifier %u", 0, 0
110 };
111
112 struct complaint volatile_ignored =
113 {
114 "DIE @ 0x%x \"%s\", type modifier 'volatile' ignored", 0, 0
115 };
116
117 struct complaint const_ignored =
118 {
119 "DIE @ 0x%x \"%s\", type modifier 'const' ignored", 0, 0
120 };
121
122 struct complaint botched_modified_type =
123 {
124 "DIE @ 0x%x \"%s\", botched modified type decoding (mtype 0x%x)", 0, 0
125 };
126
127 struct complaint op_deref2 =
128 {
129 "DIE @ 0x%x \"%s\", OP_DEREF2 address 0x%x not handled", 0, 0
130 };
131
132 struct complaint op_deref4 =
133 {
134 "DIE @ 0x%x \"%s\", OP_DEREF4 address 0x%x not handled", 0, 0
135 };
136
137 struct complaint basereg_not_handled =
138 {
139 "DIE @ 0x%x \"%s\", BASEREG %d not handled", 0, 0
140 };
141
142 struct complaint dup_user_type_allocation =
143 {
144 "DIE @ 0x%x \"%s\", internal error: duplicate user type allocation", 0, 0
145 };
146
147 struct complaint dup_user_type_definition =
148 {
149 "DIE @ 0x%x \"%s\", internal error: duplicate user type definition", 0, 0
150 };
151
152 struct complaint missing_tag =
153 {
154 "DIE @ 0x%x \"%s\", missing class, structure, or union tag", 0, 0
155 };
156
157 struct complaint bad_array_element_type =
158 {
159 "DIE @ 0x%x \"%s\", bad array element type attribute 0x%x", 0, 0
160 };
161
162 struct complaint subscript_data_items =
163 {
164 "DIE @ 0x%x \"%s\", can't decode subscript data items", 0, 0
165 };
166
167 struct complaint unhandled_array_subscript_format =
168 {
169 "DIE @ 0x%x \"%s\", array subscript format 0x%x not handled yet", 0, 0
170 };
171
172 struct complaint unknown_array_subscript_format =
173 {
174 "DIE @ 0x%x \"%s\", unknown array subscript format %x", 0, 0
175 };
176
177 struct complaint not_row_major =
178 {
179 "DIE @ 0x%x \"%s\", array not row major; not handled correctly", 0, 0
180 };
181
182 #ifndef R_FP /* FIXME */
183 #define R_FP 14 /* Kludge to get frame pointer register number */
184 #endif
185
186 typedef unsigned int DIE_REF; /* Reference to a DIE */
187
188 #ifndef GCC_PRODUCER
189 #define GCC_PRODUCER "GNU C "
190 #endif
191
192 #ifndef GPLUS_PRODUCER
193 #define GPLUS_PRODUCER "GNU C++ "
194 #endif
195
196 #ifndef LCC_PRODUCER
197 #define LCC_PRODUCER "NCR C/C++"
198 #endif
199
200 #ifndef CFRONT_PRODUCER
201 #define CFRONT_PRODUCER "CFRONT " /* A wild a** guess... */
202 #endif
203
204 /* start-sanitize-chill */
205 #ifndef CHILL_PRODUCER
206 #define CHILL_PRODUCER "GNU Chill "
207 #endif
208 /* end-sanitize-chill */
209
210 /* Flags to target_to_host() that tell whether or not the data object is
211 expected to be signed. Used, for example, when fetching a signed
212 integer in the target environment which is used as a signed integer
213 in the host environment, and the two environments have different sized
214 ints. In this case, *somebody* has to sign extend the smaller sized
215 int. */
216
217 #define GET_UNSIGNED 0 /* No sign extension required */
218 #define GET_SIGNED 1 /* Sign extension required */
219
220 /* Defines for things which are specified in the document "DWARF Debugging
221 Information Format" published by UNIX International, Programming Languages
222 SIG. These defines are based on revision 1.0.0, Jan 20, 1992. */
223
224 #define SIZEOF_DIE_LENGTH 4
225 #define SIZEOF_DIE_TAG 2
226 #define SIZEOF_ATTRIBUTE 2
227 #define SIZEOF_FORMAT_SPECIFIER 1
228 #define SIZEOF_FMT_FT 2
229 #define SIZEOF_LINETBL_LENGTH 4
230 #define SIZEOF_LINETBL_LINENO 4
231 #define SIZEOF_LINETBL_STMT 2
232 #define SIZEOF_LINETBL_DELTA 4
233 #define SIZEOF_LOC_ATOM_CODE 1
234
235 #define FORM_FROM_ATTR(attr) ((attr) & 0xF) /* Implicitly specified */
236
237 /* Macros that return the sizes of various types of data in the target
238 environment.
239
240 FIXME: Currently these are just compile time constants (as they are in
241 other parts of gdb as well). They need to be able to get the right size
242 either from the bfd or possibly from the DWARF info. It would be nice if
243 the DWARF producer inserted DIES that describe the fundamental types in
244 the target environment into the DWARF info, similar to the way dbx stabs
245 producers produce information about their fundamental types. */
246
247 #define TARGET_FT_POINTER_SIZE(objfile) (TARGET_PTR_BIT / TARGET_CHAR_BIT)
248 #define TARGET_FT_LONG_SIZE(objfile) (TARGET_LONG_BIT / TARGET_CHAR_BIT)
249
250 /* The Amiga SVR4 header file <dwarf.h> defines AT_element_list as a
251 FORM_BLOCK2, and this is the value emitted by the AT&T compiler.
252 However, the Issue 2 DWARF specification from AT&T defines it as
253 a FORM_BLOCK4, as does the latest specification from UI/PLSIG.
254 For backwards compatibility with the AT&T compiler produced executables
255 we define AT_short_element_list for this variant. */
256
257 #define AT_short_element_list (0x00f0|FORM_BLOCK2)
258
259 /* External variables referenced. */
260
261 extern int info_verbose; /* From main.c; nonzero => verbose */
262 extern char *warning_pre_print; /* From utils.c */
263
264 /* The DWARF debugging information consists of two major pieces,
265 one is a block of DWARF Information Entries (DIE's) and the other
266 is a line number table. The "struct dieinfo" structure contains
267 the information for a single DIE, the one currently being processed.
268
269 In order to make it easier to randomly access the attribute fields
270 of the current DIE, which are specifically unordered within the DIE,
271 each DIE is scanned and an instance of the "struct dieinfo"
272 structure is initialized.
273
274 Initialization is done in two levels. The first, done by basicdieinfo(),
275 just initializes those fields that are vital to deciding whether or not
276 to use this DIE, how to skip past it, etc. The second, done by the
277 function completedieinfo(), fills in the rest of the information.
278
279 Attributes which have block forms are not interpreted at the time
280 the DIE is scanned, instead we just save pointers to the start
281 of their value fields.
282
283 Some fields have a flag <name>_p that is set when the value of the
284 field is valid (I.E. we found a matching attribute in the DIE). Since
285 we may want to test for the presence of some attributes in the DIE,
286 such as AT_low_pc, without restricting the values of the field,
287 we need someway to note that we found such an attribute.
288
289 */
290
291 typedef char BLOCK;
292
293 struct dieinfo {
294 char * die; /* Pointer to the raw DIE data */
295 unsigned long die_length; /* Length of the raw DIE data */
296 DIE_REF die_ref; /* Offset of this DIE */
297 unsigned short die_tag; /* Tag for this DIE */
298 unsigned long at_padding;
299 unsigned long at_sibling;
300 BLOCK * at_location;
301 char * at_name;
302 unsigned short at_fund_type;
303 BLOCK * at_mod_fund_type;
304 unsigned long at_user_def_type;
305 BLOCK * at_mod_u_d_type;
306 unsigned short at_ordering;
307 BLOCK * at_subscr_data;
308 unsigned long at_byte_size;
309 unsigned short at_bit_offset;
310 unsigned long at_bit_size;
311 BLOCK * at_element_list;
312 unsigned long at_stmt_list;
313 unsigned long at_low_pc;
314 unsigned long at_high_pc;
315 unsigned long at_language;
316 unsigned long at_member;
317 unsigned long at_discr;
318 BLOCK * at_discr_value;
319 BLOCK * at_string_length;
320 char * at_comp_dir;
321 char * at_producer;
322 unsigned long at_start_scope;
323 unsigned long at_stride_size;
324 unsigned long at_src_info;
325 char * at_prototyped;
326 unsigned int has_at_low_pc:1;
327 unsigned int has_at_stmt_list:1;
328 unsigned int has_at_byte_size:1;
329 unsigned int short_element_list:1;
330 };
331
332 static int diecount; /* Approximate count of dies for compilation unit */
333 static struct dieinfo *curdie; /* For warnings and such */
334
335 static char *dbbase; /* Base pointer to dwarf info */
336 static int dbsize; /* Size of dwarf info in bytes */
337 static int dbroff; /* Relative offset from start of .debug section */
338 static char *lnbase; /* Base pointer to line section */
339 static int isreg; /* Kludge to identify register variables */
340 static int offreg; /* Kludge to identify basereg references */
341
342 /* This value is added to each symbol value. FIXME: Generalize to
343 the section_offsets structure used by dbxread. */
344 static CORE_ADDR baseaddr; /* Add to each symbol value */
345
346 /* The section offsets used in the current psymtab or symtab. FIXME,
347 only used to pass one value (baseaddr) at the moment. */
348 static struct section_offsets *base_section_offsets;
349
350 /* Each partial symbol table entry contains a pointer to private data for the
351 read_symtab() function to use when expanding a partial symbol table entry
352 to a full symbol table entry. For DWARF debugging info, this data is
353 contained in the following structure and macros are provided for easy
354 access to the members given a pointer to a partial symbol table entry.
355
356 dbfoff Always the absolute file offset to the start of the ".debug"
357 section for the file containing the DIE's being accessed.
358
359 dbroff Relative offset from the start of the ".debug" access to the
360 first DIE to be accessed. When building the partial symbol
361 table, this value will be zero since we are accessing the
362 entire ".debug" section. When expanding a partial symbol
363 table entry, this value will be the offset to the first
364 DIE for the compilation unit containing the symbol that
365 triggers the expansion.
366
367 dblength The size of the chunk of DIE's being examined, in bytes.
368
369 lnfoff The absolute file offset to the line table fragment. Ignored
370 when building partial symbol tables, but used when expanding
371 them, and contains the absolute file offset to the fragment
372 of the ".line" section containing the line numbers for the
373 current compilation unit.
374 */
375
376 struct dwfinfo {
377 file_ptr dbfoff; /* Absolute file offset to start of .debug section */
378 int dbroff; /* Relative offset from start of .debug section */
379 int dblength; /* Size of the chunk of DIE's being examined */
380 file_ptr lnfoff; /* Absolute file offset to line table fragment */
381 };
382
383 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
384 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff)
385 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength)
386 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff)
387
388 /* The generic symbol table building routines have separate lists for
389 file scope symbols and all all other scopes (local scopes). So
390 we need to select the right one to pass to add_symbol_to_list().
391 We do it by keeping a pointer to the correct list in list_in_scope.
392
393 FIXME: The original dwarf code just treated the file scope as the first
394 local scope, and all other local scopes as nested local scopes, and worked
395 fine. Check to see if we really need to distinguish these in buildsym.c */
396
397 struct pending **list_in_scope = &file_symbols;
398
399 /* DIES which have user defined types or modified user defined types refer to
400 other DIES for the type information. Thus we need to associate the offset
401 of a DIE for a user defined type with a pointer to the type information.
402
403 Originally this was done using a simple but expensive algorithm, with an
404 array of unsorted structures, each containing an offset/type-pointer pair.
405 This array was scanned linearly each time a lookup was done. The result
406 was that gdb was spending over half it's startup time munging through this
407 array of pointers looking for a structure that had the right offset member.
408
409 The second attempt used the same array of structures, but the array was
410 sorted using qsort each time a new offset/type was recorded, and a binary
411 search was used to find the type pointer for a given DIE offset. This was
412 even slower, due to the overhead of sorting the array each time a new
413 offset/type pair was entered.
414
415 The third attempt uses a fixed size array of type pointers, indexed by a
416 value derived from the DIE offset. Since the minimum DIE size is 4 bytes,
417 we can divide any DIE offset by 4 to obtain a unique index into this fixed
418 size array. Since each element is a 4 byte pointer, it takes exactly as
419 much memory to hold this array as to hold the DWARF info for a given
420 compilation unit. But it gets freed as soon as we are done with it.
421 This has worked well in practice, as a reasonable tradeoff between memory
422 consumption and speed, without having to resort to much more complicated
423 algorithms. */
424
425 static struct type **utypes; /* Pointer to array of user type pointers */
426 static int numutypes; /* Max number of user type pointers */
427
428 /* Maintain an array of referenced fundamental types for the current
429 compilation unit being read. For DWARF version 1, we have to construct
430 the fundamental types on the fly, since no information about the
431 fundamental types is supplied. Each such fundamental type is created by
432 calling a language dependent routine to create the type, and then a
433 pointer to that type is then placed in the array at the index specified
434 by it's FT_<TYPENAME> value. The array has a fixed size set by the
435 FT_NUM_MEMBERS compile time constant, which is the number of predefined
436 fundamental types gdb knows how to construct. */
437
438 static struct type *ftypes[FT_NUM_MEMBERS]; /* Fundamental types */
439
440 /* Record the language for the compilation unit which is currently being
441 processed. We know it once we have seen the TAG_compile_unit DIE,
442 and we need it while processing the DIE's for that compilation unit.
443 It is eventually saved in the symtab structure, but we don't finalize
444 the symtab struct until we have processed all the DIE's for the
445 compilation unit. We also need to get and save a pointer to the
446 language struct for this language, so we can call the language
447 dependent routines for doing things such as creating fundamental
448 types. */
449
450 static enum language cu_language;
451 static const struct language_defn *cu_language_defn;
452
453 /* Forward declarations of static functions so we don't have to worry
454 about ordering within this file. */
455
456 static int
457 attribute_size PARAMS ((unsigned int));
458
459 static unsigned long
460 target_to_host PARAMS ((char *, int, int, struct objfile *));
461
462 static void
463 add_enum_psymbol PARAMS ((struct dieinfo *, struct objfile *));
464
465 static void
466 handle_producer PARAMS ((char *));
467
468 static void
469 read_file_scope PARAMS ((struct dieinfo *, char *, char *, struct objfile *));
470
471 static void
472 read_func_scope PARAMS ((struct dieinfo *, char *, char *, struct objfile *));
473
474 static void
475 read_lexical_block_scope PARAMS ((struct dieinfo *, char *, char *,
476 struct objfile *));
477
478 static void
479 scan_partial_symbols PARAMS ((char *, char *, struct objfile *));
480
481 static void
482 scan_compilation_units PARAMS ((char *, char *, file_ptr,
483 file_ptr, struct objfile *));
484
485 static void
486 add_partial_symbol PARAMS ((struct dieinfo *, struct objfile *));
487
488 static void
489 init_psymbol_list PARAMS ((struct objfile *, int));
490
491 static void
492 basicdieinfo PARAMS ((struct dieinfo *, char *, struct objfile *));
493
494 static void
495 completedieinfo PARAMS ((struct dieinfo *, struct objfile *));
496
497 static void
498 dwarf_psymtab_to_symtab PARAMS ((struct partial_symtab *));
499
500 static void
501 psymtab_to_symtab_1 PARAMS ((struct partial_symtab *));
502
503 static struct symtab *
504 read_ofile_symtab PARAMS ((struct partial_symtab *));
505
506 static void
507 process_dies PARAMS ((char *, char *, struct objfile *));
508
509 static void
510 read_structure_scope PARAMS ((struct dieinfo *, char *, char *,
511 struct objfile *));
512
513 static struct type *
514 decode_array_element_type PARAMS ((char *));
515
516 static struct type *
517 decode_subscript_data_item PARAMS ((char *, char *));
518
519 static void
520 dwarf_read_array_type PARAMS ((struct dieinfo *));
521
522 static void
523 read_tag_pointer_type PARAMS ((struct dieinfo *dip));
524
525 static void
526 read_tag_string_type PARAMS ((struct dieinfo *dip));
527
528 static void
529 read_subroutine_type PARAMS ((struct dieinfo *, char *, char *));
530
531 static void
532 read_enumeration PARAMS ((struct dieinfo *, char *, char *, struct objfile *));
533
534 static struct type *
535 struct_type PARAMS ((struct dieinfo *, char *, char *, struct objfile *));
536
537 static struct type *
538 enum_type PARAMS ((struct dieinfo *, struct objfile *));
539
540 static void
541 decode_line_numbers PARAMS ((char *));
542
543 static struct type *
544 decode_die_type PARAMS ((struct dieinfo *));
545
546 static struct type *
547 decode_mod_fund_type PARAMS ((char *));
548
549 static struct type *
550 decode_mod_u_d_type PARAMS ((char *));
551
552 static struct type *
553 decode_modified_type PARAMS ((char *, unsigned int, int));
554
555 static struct type *
556 decode_fund_type PARAMS ((unsigned int));
557
558 static char *
559 create_name PARAMS ((char *, struct obstack *));
560
561 static struct type *
562 lookup_utype PARAMS ((DIE_REF));
563
564 static struct type *
565 alloc_utype PARAMS ((DIE_REF, struct type *));
566
567 static struct symbol *
568 new_symbol PARAMS ((struct dieinfo *, struct objfile *));
569
570 static void
571 synthesize_typedef PARAMS ((struct dieinfo *, struct objfile *,
572 struct type *));
573
574 static int
575 locval PARAMS ((char *));
576
577 static void
578 record_minimal_symbol PARAMS ((char *, CORE_ADDR, enum minimal_symbol_type,
579 struct objfile *));
580
581 static void
582 set_cu_language PARAMS ((struct dieinfo *));
583
584 static struct type *
585 dwarf_fundamental_type PARAMS ((struct objfile *, int));
586
587
588 /*
589
590 LOCAL FUNCTION
591
592 dwarf_fundamental_type -- lookup or create a fundamental type
593
594 SYNOPSIS
595
596 struct type *
597 dwarf_fundamental_type (struct objfile *objfile, int typeid)
598
599 DESCRIPTION
600
601 DWARF version 1 doesn't supply any fundamental type information,
602 so gdb has to construct such types. It has a fixed number of
603 fundamental types that it knows how to construct, which is the
604 union of all types that it knows how to construct for all languages
605 that it knows about. These are enumerated in gdbtypes.h.
606
607 As an example, assume we find a DIE that references a DWARF
608 fundamental type of FT_integer. We first look in the ftypes
609 array to see if we already have such a type, indexed by the
610 gdb internal value of FT_INTEGER. If so, we simply return a
611 pointer to that type. If not, then we ask an appropriate
612 language dependent routine to create a type FT_INTEGER, using
613 defaults reasonable for the current target machine, and install
614 that type in ftypes for future reference.
615
616 RETURNS
617
618 Pointer to a fundamental type.
619
620 */
621
622 static struct type *
623 dwarf_fundamental_type (objfile, typeid)
624 struct objfile *objfile;
625 int typeid;
626 {
627 if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
628 {
629 error ("internal error - invalid fundamental type id %d", typeid);
630 }
631
632 /* Look for this particular type in the fundamental type vector. If one is
633 not found, create and install one appropriate for the current language
634 and the current target machine. */
635
636 if (ftypes[typeid] == NULL)
637 {
638 ftypes[typeid] = cu_language_defn -> la_fund_type(objfile, typeid);
639 }
640
641 return (ftypes[typeid]);
642 }
643
644 /*
645
646 LOCAL FUNCTION
647
648 set_cu_language -- set local copy of language for compilation unit
649
650 SYNOPSIS
651
652 void
653 set_cu_language (struct dieinfo *dip)
654
655 DESCRIPTION
656
657 Decode the language attribute for a compilation unit DIE and
658 remember what the language was. We use this at various times
659 when processing DIE's for a given compilation unit.
660
661 RETURNS
662
663 No return value.
664
665 */
666
667 static void
668 set_cu_language (dip)
669 struct dieinfo *dip;
670 {
671 switch (dip -> at_language)
672 {
673 case LANG_C89:
674 case LANG_C:
675 cu_language = language_c;
676 break;
677 case LANG_C_PLUS_PLUS:
678 cu_language = language_cplus;
679 break;
680 /* start-sanitize-chill */
681 case LANG_CHILL:
682 cu_language = language_chill;
683 break;
684 /* end-sanitize-chill */
685 case LANG_MODULA2:
686 cu_language = language_m2;
687 break;
688 case LANG_ADA83:
689 case LANG_COBOL74:
690 case LANG_COBOL85:
691 case LANG_FORTRAN77:
692 case LANG_FORTRAN90:
693 case LANG_PASCAL83:
694 /* We don't know anything special about these yet. */
695 cu_language = language_unknown;
696 break;
697 default:
698 /* If no at_language, try to deduce one from the filename */
699 cu_language = deduce_language_from_filename (dip -> at_name);
700 break;
701 }
702 cu_language_defn = language_def (cu_language);
703 }
704
705 /*
706
707 GLOBAL FUNCTION
708
709 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info
710
711 SYNOPSIS
712
713 void dwarf_build_psymtabs (struct objfile *objfile,
714 struct section_offsets *section_offsets,
715 int mainline, file_ptr dbfoff, unsigned int dbfsize,
716 file_ptr lnoffset, unsigned int lnsize)
717
718 DESCRIPTION
719
720 This function is called upon to build partial symtabs from files
721 containing DIE's (Dwarf Information Entries) and DWARF line numbers.
722
723 It is passed a bfd* containing the DIES
724 and line number information, the corresponding filename for that
725 file, a base address for relocating the symbols, a flag indicating
726 whether or not this debugging information is from a "main symbol
727 table" rather than a shared library or dynamically linked file,
728 and file offset/size pairs for the DIE information and line number
729 information.
730
731 RETURNS
732
733 No return value.
734
735 */
736
737 void
738 dwarf_build_psymtabs (objfile, section_offsets, mainline, dbfoff, dbfsize,
739 lnoffset, lnsize)
740 struct objfile *objfile;
741 struct section_offsets *section_offsets;
742 int mainline;
743 file_ptr dbfoff;
744 unsigned int dbfsize;
745 file_ptr lnoffset;
746 unsigned int lnsize;
747 {
748 bfd *abfd = objfile->obfd;
749 struct cleanup *back_to;
750
751 current_objfile = objfile;
752 dbsize = dbfsize;
753 dbbase = xmalloc (dbsize);
754 dbroff = 0;
755 if ((bfd_seek (abfd, dbfoff, L_SET) != 0) ||
756 (bfd_read (dbbase, dbsize, 1, abfd) != dbsize))
757 {
758 free (dbbase);
759 error ("can't read DWARF data from '%s'", bfd_get_filename (abfd));
760 }
761 back_to = make_cleanup (free, dbbase);
762
763 /* If we are reinitializing, or if we have never loaded syms yet, init.
764 Since we have no idea how many DIES we are looking at, we just guess
765 some arbitrary value. */
766
767 if (mainline || objfile -> global_psymbols.size == 0 ||
768 objfile -> static_psymbols.size == 0)
769 {
770 init_psymbol_list (objfile, 1024);
771 }
772
773 /* Save the relocation factor where everybody can see it. */
774
775 base_section_offsets = section_offsets;
776 baseaddr = ANOFFSET (section_offsets, 0);
777
778 /* Follow the compilation unit sibling chain, building a partial symbol
779 table entry for each one. Save enough information about each compilation
780 unit to locate the full DWARF information later. */
781
782 scan_compilation_units (dbbase, dbbase + dbsize, dbfoff, lnoffset, objfile);
783
784 do_cleanups (back_to);
785 current_objfile = NULL;
786 }
787
788
789 /*
790
791 LOCAL FUNCTION
792
793 record_minimal_symbol -- add entry to gdb's minimal symbol table
794
795 SYNOPSIS
796
797 static void record_minimal_symbol (char *name, CORE_ADDR address,
798 enum minimal_symbol_type ms_type,
799 struct objfile *objfile)
800
801 DESCRIPTION
802
803 Given a pointer to the name of a symbol that should be added to the
804 minimal symbol table, and the address associated with that
805 symbol, records this information for later use in building the
806 minimal symbol table.
807
808 */
809
810 static void
811 record_minimal_symbol (name, address, ms_type, objfile)
812 char *name;
813 CORE_ADDR address;
814 enum minimal_symbol_type ms_type;
815 struct objfile *objfile;
816 {
817 name = obsavestring (name, strlen (name), &objfile -> symbol_obstack);
818 prim_record_minimal_symbol (name, address, ms_type);
819 }
820
821 /*
822
823 LOCAL FUNCTION
824
825 read_lexical_block_scope -- process all dies in a lexical block
826
827 SYNOPSIS
828
829 static void read_lexical_block_scope (struct dieinfo *dip,
830 char *thisdie, char *enddie)
831
832 DESCRIPTION
833
834 Process all the DIES contained within a lexical block scope.
835 Start a new scope, process the dies, and then close the scope.
836
837 */
838
839 static void
840 read_lexical_block_scope (dip, thisdie, enddie, objfile)
841 struct dieinfo *dip;
842 char *thisdie;
843 char *enddie;
844 struct objfile *objfile;
845 {
846 register struct context_stack *new;
847
848 push_context (0, dip -> at_low_pc);
849 process_dies (thisdie + dip -> die_length, enddie, objfile);
850 new = pop_context ();
851 if (local_symbols != NULL)
852 {
853 finish_block (0, &local_symbols, new -> old_blocks, new -> start_addr,
854 dip -> at_high_pc, objfile);
855 }
856 local_symbols = new -> locals;
857 }
858
859 /*
860
861 LOCAL FUNCTION
862
863 lookup_utype -- look up a user defined type from die reference
864
865 SYNOPSIS
866
867 static type *lookup_utype (DIE_REF die_ref)
868
869 DESCRIPTION
870
871 Given a DIE reference, lookup the user defined type associated with
872 that DIE, if it has been registered already. If not registered, then
873 return NULL. Alloc_utype() can be called to register an empty
874 type for this reference, which will be filled in later when the
875 actual referenced DIE is processed.
876 */
877
878 static struct type *
879 lookup_utype (die_ref)
880 DIE_REF die_ref;
881 {
882 struct type *type = NULL;
883 int utypeidx;
884
885 utypeidx = (die_ref - dbroff) / 4;
886 if ((utypeidx < 0) || (utypeidx >= numutypes))
887 {
888 complain (&bad_die_ref, DIE_ID, DIE_NAME);
889 }
890 else
891 {
892 type = *(utypes + utypeidx);
893 }
894 return (type);
895 }
896
897
898 /*
899
900 LOCAL FUNCTION
901
902 alloc_utype -- add a user defined type for die reference
903
904 SYNOPSIS
905
906 static type *alloc_utype (DIE_REF die_ref, struct type *utypep)
907
908 DESCRIPTION
909
910 Given a die reference DIE_REF, and a possible pointer to a user
911 defined type UTYPEP, register that this reference has a user
912 defined type and either use the specified type in UTYPEP or
913 make a new empty type that will be filled in later.
914
915 We should only be called after calling lookup_utype() to verify that
916 there is not currently a type registered for DIE_REF.
917 */
918
919 static struct type *
920 alloc_utype (die_ref, utypep)
921 DIE_REF die_ref;
922 struct type *utypep;
923 {
924 struct type **typep;
925 int utypeidx;
926
927 utypeidx = (die_ref - dbroff) / 4;
928 typep = utypes + utypeidx;
929 if ((utypeidx < 0) || (utypeidx >= numutypes))
930 {
931 utypep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
932 complain (&bad_die_ref, DIE_ID, DIE_NAME);
933 }
934 else if (*typep != NULL)
935 {
936 utypep = *typep;
937 complain (&dup_user_type_allocation, DIE_ID, DIE_NAME);
938 }
939 else
940 {
941 if (utypep == NULL)
942 {
943 utypep = alloc_type (current_objfile);
944 }
945 *typep = utypep;
946 }
947 return (utypep);
948 }
949
950 /*
951
952 LOCAL FUNCTION
953
954 decode_die_type -- return a type for a specified die
955
956 SYNOPSIS
957
958 static struct type *decode_die_type (struct dieinfo *dip)
959
960 DESCRIPTION
961
962 Given a pointer to a die information structure DIP, decode the
963 type of the die and return a pointer to the decoded type. All
964 dies without specific types default to type int.
965 */
966
967 static struct type *
968 decode_die_type (dip)
969 struct dieinfo *dip;
970 {
971 struct type *type = NULL;
972
973 if (dip -> at_fund_type != 0)
974 {
975 type = decode_fund_type (dip -> at_fund_type);
976 }
977 else if (dip -> at_mod_fund_type != NULL)
978 {
979 type = decode_mod_fund_type (dip -> at_mod_fund_type);
980 }
981 else if (dip -> at_user_def_type)
982 {
983 if ((type = lookup_utype (dip -> at_user_def_type)) == NULL)
984 {
985 type = alloc_utype (dip -> at_user_def_type, NULL);
986 }
987 }
988 else if (dip -> at_mod_u_d_type)
989 {
990 type = decode_mod_u_d_type (dip -> at_mod_u_d_type);
991 }
992 else
993 {
994 type = dwarf_fundamental_type (current_objfile, FT_INTEGER);
995 }
996 return (type);
997 }
998
999 /*
1000
1001 LOCAL FUNCTION
1002
1003 struct_type -- compute and return the type for a struct or union
1004
1005 SYNOPSIS
1006
1007 static struct type *struct_type (struct dieinfo *dip, char *thisdie,
1008 char *enddie, struct objfile *objfile)
1009
1010 DESCRIPTION
1011
1012 Given pointer to a die information structure for a die which
1013 defines a union or structure (and MUST define one or the other),
1014 and pointers to the raw die data that define the range of dies which
1015 define the members, compute and return the user defined type for the
1016 structure or union.
1017 */
1018
1019 static struct type *
1020 struct_type (dip, thisdie, enddie, objfile)
1021 struct dieinfo *dip;
1022 char *thisdie;
1023 char *enddie;
1024 struct objfile *objfile;
1025 {
1026 struct type *type;
1027 struct nextfield {
1028 struct nextfield *next;
1029 struct field field;
1030 };
1031 struct nextfield *list = NULL;
1032 struct nextfield *new;
1033 int nfields = 0;
1034 int n;
1035 char *tpart1;
1036 struct dieinfo mbr;
1037 char *nextdie;
1038 #if !BITS_BIG_ENDIAN
1039 int anonymous_size;
1040 #endif
1041
1042 if ((type = lookup_utype (dip -> die_ref)) == NULL)
1043 {
1044 /* No forward references created an empty type, so install one now */
1045 type = alloc_utype (dip -> die_ref, NULL);
1046 }
1047 INIT_CPLUS_SPECIFIC(type);
1048 switch (dip -> die_tag)
1049 {
1050 case TAG_class_type:
1051 TYPE_CODE (type) = TYPE_CODE_CLASS;
1052 tpart1 = "class";
1053 break;
1054 case TAG_structure_type:
1055 TYPE_CODE (type) = TYPE_CODE_STRUCT;
1056 tpart1 = "struct";
1057 break;
1058 case TAG_union_type:
1059 TYPE_CODE (type) = TYPE_CODE_UNION;
1060 tpart1 = "union";
1061 break;
1062 default:
1063 /* Should never happen */
1064 TYPE_CODE (type) = TYPE_CODE_UNDEF;
1065 tpart1 = "???";
1066 complain (&missing_tag, DIE_ID, DIE_NAME);
1067 break;
1068 }
1069 /* Some compilers try to be helpful by inventing "fake" names for
1070 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1071 Thanks, but no thanks... */
1072 if (dip -> at_name != NULL
1073 && *dip -> at_name != '~'
1074 && *dip -> at_name != '.')
1075 {
1076 TYPE_NAME (type) = obconcat (&objfile -> type_obstack,
1077 tpart1, " ", dip -> at_name);
1078 }
1079 /* Use whatever size is known. Zero is a valid size. We might however
1080 wish to check has_at_byte_size to make sure that some byte size was
1081 given explicitly, but DWARF doesn't specify that explicit sizes of
1082 zero have to present, so complaining about missing sizes should
1083 probably not be the default. */
1084 TYPE_LENGTH (type) = dip -> at_byte_size;
1085 thisdie += dip -> die_length;
1086 while (thisdie < enddie)
1087 {
1088 basicdieinfo (&mbr, thisdie, objfile);
1089 completedieinfo (&mbr, objfile);
1090 if (mbr.die_length <= SIZEOF_DIE_LENGTH)
1091 {
1092 break;
1093 }
1094 else if (mbr.at_sibling != 0)
1095 {
1096 nextdie = dbbase + mbr.at_sibling - dbroff;
1097 }
1098 else
1099 {
1100 nextdie = thisdie + mbr.die_length;
1101 }
1102 switch (mbr.die_tag)
1103 {
1104 case TAG_member:
1105 /* Get space to record the next field's data. */
1106 new = (struct nextfield *) alloca (sizeof (struct nextfield));
1107 new -> next = list;
1108 list = new;
1109 /* Save the data. */
1110 list -> field.name =
1111 obsavestring (mbr.at_name, strlen (mbr.at_name),
1112 &objfile -> type_obstack);
1113 list -> field.type = decode_die_type (&mbr);
1114 list -> field.bitpos = 8 * locval (mbr.at_location);
1115 /* Handle bit fields. */
1116 list -> field.bitsize = mbr.at_bit_size;
1117 #if BITS_BIG_ENDIAN
1118 /* For big endian bits, the at_bit_offset gives the additional
1119 bit offset from the MSB of the containing anonymous object to
1120 the MSB of the field. We don't have to do anything special
1121 since we don't need to know the size of the anonymous object. */
1122 list -> field.bitpos += mbr.at_bit_offset;
1123 #else
1124 /* For little endian bits, we need to have a non-zero at_bit_size,
1125 so that we know we are in fact dealing with a bitfield. Compute
1126 the bit offset to the MSB of the anonymous object, subtract off
1127 the number of bits from the MSB of the field to the MSB of the
1128 object, and then subtract off the number of bits of the field
1129 itself. The result is the bit offset of the LSB of the field. */
1130 if (mbr.at_bit_size > 0)
1131 {
1132 if (mbr.has_at_byte_size)
1133 {
1134 /* The size of the anonymous object containing the bit field
1135 is explicit, so use the indicated size (in bytes). */
1136 anonymous_size = mbr.at_byte_size;
1137 }
1138 else
1139 {
1140 /* The size of the anonymous object containing the bit field
1141 matches the size of an object of the bit field's type.
1142 DWARF allows at_byte_size to be left out in such cases,
1143 as a debug information size optimization. */
1144 anonymous_size = TYPE_LENGTH (list -> field.type);
1145 }
1146 list -> field.bitpos +=
1147 anonymous_size * 8 - mbr.at_bit_offset - mbr.at_bit_size;
1148 }
1149 #endif
1150 nfields++;
1151 break;
1152 default:
1153 process_dies (thisdie, nextdie, objfile);
1154 break;
1155 }
1156 thisdie = nextdie;
1157 }
1158 /* Now create the vector of fields, and record how big it is. We may
1159 not even have any fields, if this DIE was generated due to a reference
1160 to an anonymous structure or union. In this case, TYPE_FLAG_STUB is
1161 set, which clues gdb in to the fact that it needs to search elsewhere
1162 for the full structure definition. */
1163 if (nfields == 0)
1164 {
1165 TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
1166 }
1167 else
1168 {
1169 TYPE_NFIELDS (type) = nfields;
1170 TYPE_FIELDS (type) = (struct field *)
1171 TYPE_ALLOC (type, sizeof (struct field) * nfields);
1172 /* Copy the saved-up fields into the field vector. */
1173 for (n = nfields; list; list = list -> next)
1174 {
1175 TYPE_FIELD (type, --n) = list -> field;
1176 }
1177 }
1178 return (type);
1179 }
1180
1181 /*
1182
1183 LOCAL FUNCTION
1184
1185 read_structure_scope -- process all dies within struct or union
1186
1187 SYNOPSIS
1188
1189 static void read_structure_scope (struct dieinfo *dip,
1190 char *thisdie, char *enddie, struct objfile *objfile)
1191
1192 DESCRIPTION
1193
1194 Called when we find the DIE that starts a structure or union
1195 scope (definition) to process all dies that define the members
1196 of the structure or union. DIP is a pointer to the die info
1197 struct for the DIE that names the structure or union.
1198
1199 NOTES
1200
1201 Note that we need to call struct_type regardless of whether or not
1202 the DIE has an at_name attribute, since it might be an anonymous
1203 structure or union. This gets the type entered into our set of
1204 user defined types.
1205
1206 However, if the structure is incomplete (an opaque struct/union)
1207 then suppress creating a symbol table entry for it since gdb only
1208 wants to find the one with the complete definition. Note that if
1209 it is complete, we just call new_symbol, which does it's own
1210 checking about whether the struct/union is anonymous or not (and
1211 suppresses creating a symbol table entry itself).
1212
1213 */
1214
1215 static void
1216 read_structure_scope (dip, thisdie, enddie, objfile)
1217 struct dieinfo *dip;
1218 char *thisdie;
1219 char *enddie;
1220 struct objfile *objfile;
1221 {
1222 struct type *type;
1223 struct symbol *sym;
1224
1225 type = struct_type (dip, thisdie, enddie, objfile);
1226 if (!(TYPE_FLAGS (type) & TYPE_FLAG_STUB))
1227 {
1228 sym = new_symbol (dip, objfile);
1229 if (sym != NULL)
1230 {
1231 SYMBOL_TYPE (sym) = type;
1232 if (cu_language == language_cplus)
1233 {
1234 synthesize_typedef (dip, objfile, type);
1235 }
1236 }
1237 }
1238 }
1239
1240 /*
1241
1242 LOCAL FUNCTION
1243
1244 decode_array_element_type -- decode type of the array elements
1245
1246 SYNOPSIS
1247
1248 static struct type *decode_array_element_type (char *scan, char *end)
1249
1250 DESCRIPTION
1251
1252 As the last step in decoding the array subscript information for an
1253 array DIE, we need to decode the type of the array elements. We are
1254 passed a pointer to this last part of the subscript information and
1255 must return the appropriate type. If the type attribute is not
1256 recognized, just warn about the problem and return type int.
1257 */
1258
1259 static struct type *
1260 decode_array_element_type (scan)
1261 char *scan;
1262 {
1263 struct type *typep;
1264 DIE_REF die_ref;
1265 unsigned short attribute;
1266 unsigned short fundtype;
1267 int nbytes;
1268
1269 attribute = target_to_host (scan, SIZEOF_ATTRIBUTE, GET_UNSIGNED,
1270 current_objfile);
1271 scan += SIZEOF_ATTRIBUTE;
1272 if ((nbytes = attribute_size (attribute)) == -1)
1273 {
1274 complain (&bad_array_element_type, DIE_ID, DIE_NAME, attribute);
1275 typep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
1276 }
1277 else
1278 {
1279 switch (attribute)
1280 {
1281 case AT_fund_type:
1282 fundtype = target_to_host (scan, nbytes, GET_UNSIGNED,
1283 current_objfile);
1284 typep = decode_fund_type (fundtype);
1285 break;
1286 case AT_mod_fund_type:
1287 typep = decode_mod_fund_type (scan);
1288 break;
1289 case AT_user_def_type:
1290 die_ref = target_to_host (scan, nbytes, GET_UNSIGNED,
1291 current_objfile);
1292 if ((typep = lookup_utype (die_ref)) == NULL)
1293 {
1294 typep = alloc_utype (die_ref, NULL);
1295 }
1296 break;
1297 case AT_mod_u_d_type:
1298 typep = decode_mod_u_d_type (scan);
1299 break;
1300 default:
1301 complain (&bad_array_element_type, DIE_ID, DIE_NAME, attribute);
1302 typep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
1303 break;
1304 }
1305 }
1306 return (typep);
1307 }
1308
1309 /*
1310
1311 LOCAL FUNCTION
1312
1313 decode_subscript_data_item -- decode array subscript item
1314
1315 SYNOPSIS
1316
1317 static struct type *
1318 decode_subscript_data_item (char *scan, char *end)
1319
1320 DESCRIPTION
1321
1322 The array subscripts and the data type of the elements of an
1323 array are described by a list of data items, stored as a block
1324 of contiguous bytes. There is a data item describing each array
1325 dimension, and a final data item describing the element type.
1326 The data items are ordered the same as their appearance in the
1327 source (I.E. leftmost dimension first, next to leftmost second,
1328 etc).
1329
1330 The data items describing each array dimension consist of four
1331 parts: (1) a format specifier, (2) type type of the subscript
1332 index, (3) a description of the low bound of the array dimension,
1333 and (4) a description of the high bound of the array dimension.
1334
1335 The last data item is the description of the type of each of
1336 the array elements.
1337
1338 We are passed a pointer to the start of the block of bytes
1339 containing the remaining data items, and a pointer to the first
1340 byte past the data. This function recursively decodes the
1341 remaining data items and returns a type.
1342
1343 If we somehow fail to decode some data, we complain about it
1344 and return a type "array of int".
1345
1346 BUGS
1347 FIXME: This code only implements the forms currently used
1348 by the AT&T and GNU C compilers.
1349
1350 The end pointer is supplied for error checking, maybe we should
1351 use it for that...
1352 */
1353
1354 static struct type *
1355 decode_subscript_data_item (scan, end)
1356 char *scan;
1357 char *end;
1358 {
1359 struct type *typep = NULL; /* Array type we are building */
1360 struct type *nexttype; /* Type of each element (may be array) */
1361 struct type *indextype; /* Type of this index */
1362 struct type *rangetype;
1363 unsigned int format;
1364 unsigned short fundtype;
1365 unsigned long lowbound;
1366 unsigned long highbound;
1367 int nbytes;
1368
1369 format = target_to_host (scan, SIZEOF_FORMAT_SPECIFIER, GET_UNSIGNED,
1370 current_objfile);
1371 scan += SIZEOF_FORMAT_SPECIFIER;
1372 switch (format)
1373 {
1374 case FMT_ET:
1375 typep = decode_array_element_type (scan);
1376 break;
1377 case FMT_FT_C_C:
1378 fundtype = target_to_host (scan, SIZEOF_FMT_FT, GET_UNSIGNED,
1379 current_objfile);
1380 indextype = decode_fund_type (fundtype);
1381 scan += SIZEOF_FMT_FT;
1382 nbytes = TARGET_FT_LONG_SIZE (current_objfile);
1383 lowbound = target_to_host (scan, nbytes, GET_UNSIGNED, current_objfile);
1384 scan += nbytes;
1385 highbound = target_to_host (scan, nbytes, GET_UNSIGNED, current_objfile);
1386 scan += nbytes;
1387 nexttype = decode_subscript_data_item (scan, end);
1388 if (nexttype == NULL)
1389 {
1390 /* Munged subscript data or other problem, fake it. */
1391 complain (&subscript_data_items, DIE_ID, DIE_NAME);
1392 nexttype = dwarf_fundamental_type (current_objfile, FT_INTEGER);
1393 }
1394 rangetype = create_range_type ((struct type *) NULL, indextype,
1395 lowbound, highbound);
1396 typep = create_array_type ((struct type *) NULL, nexttype, rangetype);
1397 break;
1398 case FMT_FT_C_X:
1399 case FMT_FT_X_C:
1400 case FMT_FT_X_X:
1401 case FMT_UT_C_C:
1402 case FMT_UT_C_X:
1403 case FMT_UT_X_C:
1404 case FMT_UT_X_X:
1405 complain (&unhandled_array_subscript_format, DIE_ID, DIE_NAME, format);
1406 nexttype = dwarf_fundamental_type (current_objfile, FT_INTEGER);
1407 rangetype = create_range_type ((struct type *) NULL, nexttype, 0, 0);
1408 typep = create_array_type ((struct type *) NULL, nexttype, rangetype);
1409 break;
1410 default:
1411 complain (&unknown_array_subscript_format, DIE_ID, DIE_NAME, format);
1412 nexttype = dwarf_fundamental_type (current_objfile, FT_INTEGER);
1413 rangetype = create_range_type ((struct type *) NULL, nexttype, 0, 0);
1414 typep = create_array_type ((struct type *) NULL, nexttype, rangetype);
1415 break;
1416 }
1417 return (typep);
1418 }
1419
1420 /*
1421
1422 LOCAL FUNCTION
1423
1424 dwarf_read_array_type -- read TAG_array_type DIE
1425
1426 SYNOPSIS
1427
1428 static void dwarf_read_array_type (struct dieinfo *dip)
1429
1430 DESCRIPTION
1431
1432 Extract all information from a TAG_array_type DIE and add to
1433 the user defined type vector.
1434 */
1435
1436 static void
1437 dwarf_read_array_type (dip)
1438 struct dieinfo *dip;
1439 {
1440 struct type *type;
1441 struct type *utype;
1442 char *sub;
1443 char *subend;
1444 unsigned short blocksz;
1445 int nbytes;
1446
1447 if (dip -> at_ordering != ORD_row_major)
1448 {
1449 /* FIXME: Can gdb even handle column major arrays? */
1450 complain (&not_row_major, DIE_ID, DIE_NAME);
1451 }
1452 if ((sub = dip -> at_subscr_data) != NULL)
1453 {
1454 nbytes = attribute_size (AT_subscr_data);
1455 blocksz = target_to_host (sub, nbytes, GET_UNSIGNED, current_objfile);
1456 subend = sub + nbytes + blocksz;
1457 sub += nbytes;
1458 type = decode_subscript_data_item (sub, subend);
1459 if ((utype = lookup_utype (dip -> die_ref)) == NULL)
1460 {
1461 /* Install user defined type that has not been referenced yet. */
1462 alloc_utype (dip -> die_ref, type);
1463 }
1464 else if (TYPE_CODE (utype) == TYPE_CODE_UNDEF)
1465 {
1466 /* Ick! A forward ref has already generated a blank type in our
1467 slot, and this type probably already has things pointing to it
1468 (which is what caused it to be created in the first place).
1469 If it's just a place holder we can plop our fully defined type
1470 on top of it. We can't recover the space allocated for our
1471 new type since it might be on an obstack, but we could reuse
1472 it if we kept a list of them, but it might not be worth it
1473 (FIXME). */
1474 *utype = *type;
1475 }
1476 else
1477 {
1478 /* Double ick! Not only is a type already in our slot, but
1479 someone has decorated it. Complain and leave it alone. */
1480 complain (&dup_user_type_definition, DIE_ID, DIE_NAME);
1481 }
1482 }
1483 }
1484
1485 /*
1486
1487 LOCAL FUNCTION
1488
1489 read_tag_pointer_type -- read TAG_pointer_type DIE
1490
1491 SYNOPSIS
1492
1493 static void read_tag_pointer_type (struct dieinfo *dip)
1494
1495 DESCRIPTION
1496
1497 Extract all information from a TAG_pointer_type DIE and add to
1498 the user defined type vector.
1499 */
1500
1501 static void
1502 read_tag_pointer_type (dip)
1503 struct dieinfo *dip;
1504 {
1505 struct type *type;
1506 struct type *utype;
1507
1508 type = decode_die_type (dip);
1509 if ((utype = lookup_utype (dip -> die_ref)) == NULL)
1510 {
1511 utype = lookup_pointer_type (type);
1512 alloc_utype (dip -> die_ref, utype);
1513 }
1514 else
1515 {
1516 TYPE_TARGET_TYPE (utype) = type;
1517 TYPE_POINTER_TYPE (type) = utype;
1518
1519 /* We assume the machine has only one representation for pointers! */
1520 /* FIXME: This confuses host<->target data representations, and is a
1521 poor assumption besides. */
1522
1523 TYPE_LENGTH (utype) = sizeof (char *);
1524 TYPE_CODE (utype) = TYPE_CODE_PTR;
1525 }
1526 }
1527
1528 /*
1529
1530 LOCAL FUNCTION
1531
1532 read_tag_string_type -- read TAG_string_type DIE
1533
1534 SYNOPSIS
1535
1536 static void read_tag_string_type (struct dieinfo *dip)
1537
1538 DESCRIPTION
1539
1540 Extract all information from a TAG_string_type DIE and add to
1541 the user defined type vector. It isn't really a user defined
1542 type, but it behaves like one, with other DIE's using an
1543 AT_user_def_type attribute to reference it.
1544 */
1545
1546 static void
1547 read_tag_string_type (dip)
1548 struct dieinfo *dip;
1549 {
1550 struct type *utype;
1551 struct type *indextype;
1552 struct type *rangetype;
1553 unsigned long lowbound = 0;
1554 unsigned long highbound;
1555
1556 if ((utype = lookup_utype (dip -> die_ref)) != NULL)
1557 {
1558 /* Ack, someone has stuck a type in the slot we want. Complain
1559 about it. */
1560 complain (&dup_user_type_definition, DIE_ID, DIE_NAME);
1561 }
1562 else
1563 {
1564 if (dip -> has_at_byte_size)
1565 {
1566 /* A fixed bounds string */
1567 highbound = dip -> at_byte_size - 1;
1568 }
1569 else
1570 {
1571 /* A varying length string. Stub for now. (FIXME) */
1572 highbound = 1;
1573 }
1574 indextype = dwarf_fundamental_type (current_objfile, FT_INTEGER);
1575 rangetype = create_range_type ((struct type *) NULL, indextype,
1576 lowbound, highbound);
1577 utype = create_string_type ((struct type *) NULL, rangetype);
1578 alloc_utype (dip -> die_ref, utype);
1579 }
1580 }
1581
1582 /*
1583
1584 LOCAL FUNCTION
1585
1586 read_subroutine_type -- process TAG_subroutine_type dies
1587
1588 SYNOPSIS
1589
1590 static void read_subroutine_type (struct dieinfo *dip, char thisdie,
1591 char *enddie)
1592
1593 DESCRIPTION
1594
1595 Handle DIES due to C code like:
1596
1597 struct foo {
1598 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE)
1599 int b;
1600 };
1601
1602 NOTES
1603
1604 The parameter DIES are currently ignored. See if gdb has a way to
1605 include this info in it's type system, and decode them if so. Is
1606 this what the type structure's "arg_types" field is for? (FIXME)
1607 */
1608
1609 static void
1610 read_subroutine_type (dip, thisdie, enddie)
1611 struct dieinfo *dip;
1612 char *thisdie;
1613 char *enddie;
1614 {
1615 struct type *type; /* Type that this function returns */
1616 struct type *ftype; /* Function that returns above type */
1617
1618 /* Decode the type that this subroutine returns */
1619
1620 type = decode_die_type (dip);
1621
1622 /* Check to see if we already have a partially constructed user
1623 defined type for this DIE, from a forward reference. */
1624
1625 if ((ftype = lookup_utype (dip -> die_ref)) == NULL)
1626 {
1627 /* This is the first reference to one of these types. Make
1628 a new one and place it in the user defined types. */
1629 ftype = lookup_function_type (type);
1630 alloc_utype (dip -> die_ref, ftype);
1631 }
1632 else if (TYPE_CODE (ftype) == TYPE_CODE_UNDEF)
1633 {
1634 /* We have an existing partially constructed type, so bash it
1635 into the correct type. */
1636 TYPE_TARGET_TYPE (ftype) = type;
1637 TYPE_FUNCTION_TYPE (type) = ftype;
1638 TYPE_LENGTH (ftype) = 1;
1639 TYPE_CODE (ftype) = TYPE_CODE_FUNC;
1640 }
1641 else
1642 {
1643 complain (&dup_user_type_definition, DIE_ID, DIE_NAME);
1644 }
1645 }
1646
1647 /*
1648
1649 LOCAL FUNCTION
1650
1651 read_enumeration -- process dies which define an enumeration
1652
1653 SYNOPSIS
1654
1655 static void read_enumeration (struct dieinfo *dip, char *thisdie,
1656 char *enddie, struct objfile *objfile)
1657
1658 DESCRIPTION
1659
1660 Given a pointer to a die which begins an enumeration, process all
1661 the dies that define the members of the enumeration.
1662
1663 NOTES
1664
1665 Note that we need to call enum_type regardless of whether or not we
1666 have a symbol, since we might have an enum without a tag name (thus
1667 no symbol for the tagname).
1668 */
1669
1670 static void
1671 read_enumeration (dip, thisdie, enddie, objfile)
1672 struct dieinfo *dip;
1673 char *thisdie;
1674 char *enddie;
1675 struct objfile *objfile;
1676 {
1677 struct type *type;
1678 struct symbol *sym;
1679
1680 type = enum_type (dip, objfile);
1681 sym = new_symbol (dip, objfile);
1682 if (sym != NULL)
1683 {
1684 SYMBOL_TYPE (sym) = type;
1685 if (cu_language == language_cplus)
1686 {
1687 synthesize_typedef (dip, objfile, type);
1688 }
1689 }
1690 }
1691
1692 /*
1693
1694 LOCAL FUNCTION
1695
1696 enum_type -- decode and return a type for an enumeration
1697
1698 SYNOPSIS
1699
1700 static type *enum_type (struct dieinfo *dip, struct objfile *objfile)
1701
1702 DESCRIPTION
1703
1704 Given a pointer to a die information structure for the die which
1705 starts an enumeration, process all the dies that define the members
1706 of the enumeration and return a type pointer for the enumeration.
1707
1708 At the same time, for each member of the enumeration, create a
1709 symbol for it with namespace VAR_NAMESPACE and class LOC_CONST,
1710 and give it the type of the enumeration itself.
1711
1712 NOTES
1713
1714 Note that the DWARF specification explicitly mandates that enum
1715 constants occur in reverse order from the source program order,
1716 for "consistency" and because this ordering is easier for many
1717 compilers to generate. (Draft 6, sec 3.8.5, Enumeration type
1718 Entries). Because gdb wants to see the enum members in program
1719 source order, we have to ensure that the order gets reversed while
1720 we are processing them.
1721 */
1722
1723 static struct type *
1724 enum_type (dip, objfile)
1725 struct dieinfo *dip;
1726 struct objfile *objfile;
1727 {
1728 struct type *type;
1729 struct nextfield {
1730 struct nextfield *next;
1731 struct field field;
1732 };
1733 struct nextfield *list = NULL;
1734 struct nextfield *new;
1735 int nfields = 0;
1736 int n;
1737 char *scan;
1738 char *listend;
1739 unsigned short blocksz;
1740 struct symbol *sym;
1741 int nbytes;
1742
1743 if ((type = lookup_utype (dip -> die_ref)) == NULL)
1744 {
1745 /* No forward references created an empty type, so install one now */
1746 type = alloc_utype (dip -> die_ref, NULL);
1747 }
1748 TYPE_CODE (type) = TYPE_CODE_ENUM;
1749 /* Some compilers try to be helpful by inventing "fake" names for
1750 anonymous enums, structures, and unions, like "~0fake" or ".0fake".
1751 Thanks, but no thanks... */
1752 if (dip -> at_name != NULL
1753 && *dip -> at_name != '~'
1754 && *dip -> at_name != '.')
1755 {
1756 TYPE_NAME (type) = obconcat (&objfile -> type_obstack, "enum",
1757 " ", dip -> at_name);
1758 }
1759 if (dip -> at_byte_size != 0)
1760 {
1761 TYPE_LENGTH (type) = dip -> at_byte_size;
1762 }
1763 if ((scan = dip -> at_element_list) != NULL)
1764 {
1765 if (dip -> short_element_list)
1766 {
1767 nbytes = attribute_size (AT_short_element_list);
1768 }
1769 else
1770 {
1771 nbytes = attribute_size (AT_element_list);
1772 }
1773 blocksz = target_to_host (scan, nbytes, GET_UNSIGNED, objfile);
1774 listend = scan + nbytes + blocksz;
1775 scan += nbytes;
1776 while (scan < listend)
1777 {
1778 new = (struct nextfield *) alloca (sizeof (struct nextfield));
1779 new -> next = list;
1780 list = new;
1781 list -> field.type = NULL;
1782 list -> field.bitsize = 0;
1783 list -> field.bitpos =
1784 target_to_host (scan, TARGET_FT_LONG_SIZE (objfile), GET_SIGNED,
1785 objfile);
1786 scan += TARGET_FT_LONG_SIZE (objfile);
1787 list -> field.name = obsavestring (scan, strlen (scan),
1788 &objfile -> type_obstack);
1789 scan += strlen (scan) + 1;
1790 nfields++;
1791 /* Handcraft a new symbol for this enum member. */
1792 sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
1793 sizeof (struct symbol));
1794 memset (sym, 0, sizeof (struct symbol));
1795 SYMBOL_NAME (sym) = create_name (list -> field.name,
1796 &objfile->symbol_obstack);
1797 SYMBOL_INIT_LANGUAGE_SPECIFIC (sym, cu_language);
1798 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
1799 SYMBOL_CLASS (sym) = LOC_CONST;
1800 SYMBOL_TYPE (sym) = type;
1801 SYMBOL_VALUE (sym) = list -> field.bitpos;
1802 add_symbol_to_list (sym, list_in_scope);
1803 }
1804 /* Now create the vector of fields, and record how big it is. This is
1805 where we reverse the order, by pulling the members off the list in
1806 reverse order from how they were inserted. If we have no fields
1807 (this is apparently possible in C++) then skip building a field
1808 vector. */
1809 if (nfields > 0)
1810 {
1811 TYPE_NFIELDS (type) = nfields;
1812 TYPE_FIELDS (type) = (struct field *)
1813 obstack_alloc (&objfile->symbol_obstack, sizeof (struct field) * nfields);
1814 /* Copy the saved-up fields into the field vector. */
1815 for (n = 0; (n < nfields) && (list != NULL); list = list -> next)
1816 {
1817 TYPE_FIELD (type, n++) = list -> field;
1818 }
1819 }
1820 }
1821 return (type);
1822 }
1823
1824 /*
1825
1826 LOCAL FUNCTION
1827
1828 read_func_scope -- process all dies within a function scope
1829
1830 DESCRIPTION
1831
1832 Process all dies within a given function scope. We are passed
1833 a die information structure pointer DIP for the die which
1834 starts the function scope, and pointers into the raw die data
1835 that define the dies within the function scope.
1836
1837 For now, we ignore lexical block scopes within the function.
1838 The problem is that AT&T cc does not define a DWARF lexical
1839 block scope for the function itself, while gcc defines a
1840 lexical block scope for the function. We need to think about
1841 how to handle this difference, or if it is even a problem.
1842 (FIXME)
1843 */
1844
1845 static void
1846 read_func_scope (dip, thisdie, enddie, objfile)
1847 struct dieinfo *dip;
1848 char *thisdie;
1849 char *enddie;
1850 struct objfile *objfile;
1851 {
1852 register struct context_stack *new;
1853
1854 if (objfile -> ei.entry_point >= dip -> at_low_pc &&
1855 objfile -> ei.entry_point < dip -> at_high_pc)
1856 {
1857 objfile -> ei.entry_func_lowpc = dip -> at_low_pc;
1858 objfile -> ei.entry_func_highpc = dip -> at_high_pc;
1859 }
1860 if (STREQ (dip -> at_name, "main")) /* FIXME: hardwired name */
1861 {
1862 objfile -> ei.main_func_lowpc = dip -> at_low_pc;
1863 objfile -> ei.main_func_highpc = dip -> at_high_pc;
1864 }
1865 new = push_context (0, dip -> at_low_pc);
1866 new -> name = new_symbol (dip, objfile);
1867 list_in_scope = &local_symbols;
1868 process_dies (thisdie + dip -> die_length, enddie, objfile);
1869 new = pop_context ();
1870 /* Make a block for the local symbols within. */
1871 finish_block (new -> name, &local_symbols, new -> old_blocks,
1872 new -> start_addr, dip -> at_high_pc, objfile);
1873 list_in_scope = &file_symbols;
1874 }
1875
1876
1877 /*
1878
1879 LOCAL FUNCTION
1880
1881 handle_producer -- process the AT_producer attribute
1882
1883 DESCRIPTION
1884
1885 Perform any operations that depend on finding a particular
1886 AT_producer attribute.
1887
1888 */
1889
1890 static void
1891 handle_producer (producer)
1892 char *producer;
1893 {
1894
1895 /* If this compilation unit was compiled with g++ or gcc, then set the
1896 processing_gcc_compilation flag. */
1897
1898 processing_gcc_compilation =
1899 STREQN (producer, GPLUS_PRODUCER, strlen (GPLUS_PRODUCER))
1900 /* start-sanitize-chill */
1901 || STREQN (producer, CHILL_PRODUCER, strlen (CHILL_PRODUCER))
1902 /* end-sanitize-chill */
1903 || STREQN (producer, GCC_PRODUCER, strlen (GCC_PRODUCER));
1904
1905 /* Select a demangling style if we can identify the producer and if
1906 the current style is auto. We leave the current style alone if it
1907 is not auto. We also leave the demangling style alone if we find a
1908 gcc (cc1) producer, as opposed to a g++ (cc1plus) producer. */
1909
1910 #if 1 /* Works, but is experimental. -fnf */
1911 if (AUTO_DEMANGLING)
1912 {
1913 if (STREQN (producer, GPLUS_PRODUCER, strlen (GPLUS_PRODUCER)))
1914 {
1915 set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
1916 }
1917 else if (STREQN (producer, LCC_PRODUCER, strlen (LCC_PRODUCER)))
1918 {
1919 set_demangling_style (LUCID_DEMANGLING_STYLE_STRING);
1920 }
1921 else if (STREQN (producer, CFRONT_PRODUCER, strlen (CFRONT_PRODUCER)))
1922 {
1923 set_demangling_style (CFRONT_DEMANGLING_STYLE_STRING);
1924 }
1925 }
1926 #endif
1927 }
1928
1929
1930 /*
1931
1932 LOCAL FUNCTION
1933
1934 read_file_scope -- process all dies within a file scope
1935
1936 DESCRIPTION
1937
1938 Process all dies within a given file scope. We are passed a
1939 pointer to the die information structure for the die which
1940 starts the file scope, and pointers into the raw die data which
1941 mark the range of dies within the file scope.
1942
1943 When the partial symbol table is built, the file offset for the line
1944 number table for each compilation unit is saved in the partial symbol
1945 table entry for that compilation unit. As the symbols for each
1946 compilation unit are read, the line number table is read into memory
1947 and the variable lnbase is set to point to it. Thus all we have to
1948 do is use lnbase to access the line number table for the current
1949 compilation unit.
1950 */
1951
1952 static void
1953 read_file_scope (dip, thisdie, enddie, objfile)
1954 struct dieinfo *dip;
1955 char *thisdie;
1956 char *enddie;
1957 struct objfile *objfile;
1958 {
1959 struct cleanup *back_to;
1960 struct symtab *symtab;
1961
1962 if (objfile -> ei.entry_point >= dip -> at_low_pc &&
1963 objfile -> ei.entry_point < dip -> at_high_pc)
1964 {
1965 objfile -> ei.entry_file_lowpc = dip -> at_low_pc;
1966 objfile -> ei.entry_file_highpc = dip -> at_high_pc;
1967 }
1968 set_cu_language (dip);
1969 if (dip -> at_producer != NULL)
1970 {
1971 handle_producer (dip -> at_producer);
1972 }
1973 numutypes = (enddie - thisdie) / 4;
1974 utypes = (struct type **) xmalloc (numutypes * sizeof (struct type *));
1975 back_to = make_cleanup (free, utypes);
1976 memset (utypes, 0, numutypes * sizeof (struct type *));
1977 memset (ftypes, 0, FT_NUM_MEMBERS * sizeof (struct type *));
1978 start_symtab (dip -> at_name, dip -> at_comp_dir, dip -> at_low_pc);
1979 decode_line_numbers (lnbase);
1980 process_dies (thisdie + dip -> die_length, enddie, objfile);
1981 symtab = end_symtab (dip -> at_high_pc, 0, 0, objfile);
1982 if (symtab != NULL)
1983 {
1984 symtab -> language = cu_language;
1985 }
1986 do_cleanups (back_to);
1987 utypes = NULL;
1988 numutypes = 0;
1989 }
1990
1991 /*
1992
1993 LOCAL FUNCTION
1994
1995 process_dies -- process a range of DWARF Information Entries
1996
1997 SYNOPSIS
1998
1999 static void process_dies (char *thisdie, char *enddie,
2000 struct objfile *objfile)
2001
2002 DESCRIPTION
2003
2004 Process all DIE's in a specified range. May be (and almost
2005 certainly will be) called recursively.
2006 */
2007
2008 static void
2009 process_dies (thisdie, enddie, objfile)
2010 char *thisdie;
2011 char *enddie;
2012 struct objfile *objfile;
2013 {
2014 char *nextdie;
2015 struct dieinfo di;
2016
2017 while (thisdie < enddie)
2018 {
2019 basicdieinfo (&di, thisdie, objfile);
2020 if (di.die_length < SIZEOF_DIE_LENGTH)
2021 {
2022 break;
2023 }
2024 else if (di.die_tag == TAG_padding)
2025 {
2026 nextdie = thisdie + di.die_length;
2027 }
2028 else
2029 {
2030 completedieinfo (&di, objfile);
2031 if (di.at_sibling != 0)
2032 {
2033 nextdie = dbbase + di.at_sibling - dbroff;
2034 }
2035 else
2036 {
2037 nextdie = thisdie + di.die_length;
2038 }
2039 switch (di.die_tag)
2040 {
2041 case TAG_compile_unit:
2042 read_file_scope (&di, thisdie, nextdie, objfile);
2043 break;
2044 case TAG_global_subroutine:
2045 case TAG_subroutine:
2046 if (di.has_at_low_pc)
2047 {
2048 read_func_scope (&di, thisdie, nextdie, objfile);
2049 }
2050 break;
2051 case TAG_lexical_block:
2052 read_lexical_block_scope (&di, thisdie, nextdie, objfile);
2053 break;
2054 case TAG_class_type:
2055 case TAG_structure_type:
2056 case TAG_union_type:
2057 read_structure_scope (&di, thisdie, nextdie, objfile);
2058 break;
2059 case TAG_enumeration_type:
2060 read_enumeration (&di, thisdie, nextdie, objfile);
2061 break;
2062 case TAG_subroutine_type:
2063 read_subroutine_type (&di, thisdie, nextdie);
2064 break;
2065 case TAG_array_type:
2066 dwarf_read_array_type (&di);
2067 break;
2068 case TAG_pointer_type:
2069 read_tag_pointer_type (&di);
2070 break;
2071 case TAG_string_type:
2072 read_tag_string_type (&di);
2073 break;
2074 default:
2075 new_symbol (&di, objfile);
2076 break;
2077 }
2078 }
2079 thisdie = nextdie;
2080 }
2081 }
2082
2083 /*
2084
2085 LOCAL FUNCTION
2086
2087 decode_line_numbers -- decode a line number table fragment
2088
2089 SYNOPSIS
2090
2091 static void decode_line_numbers (char *tblscan, char *tblend,
2092 long length, long base, long line, long pc)
2093
2094 DESCRIPTION
2095
2096 Translate the DWARF line number information to gdb form.
2097
2098 The ".line" section contains one or more line number tables, one for
2099 each ".line" section from the objects that were linked.
2100
2101 The AT_stmt_list attribute for each TAG_source_file entry in the
2102 ".debug" section contains the offset into the ".line" section for the
2103 start of the table for that file.
2104
2105 The table itself has the following structure:
2106
2107 <table length><base address><source statement entry>
2108 4 bytes 4 bytes 10 bytes
2109
2110 The table length is the total size of the table, including the 4 bytes
2111 for the length information.
2112
2113 The base address is the address of the first instruction generated
2114 for the source file.
2115
2116 Each source statement entry has the following structure:
2117
2118 <line number><statement position><address delta>
2119 4 bytes 2 bytes 4 bytes
2120
2121 The line number is relative to the start of the file, starting with
2122 line 1.
2123
2124 The statement position either -1 (0xFFFF) or the number of characters
2125 from the beginning of the line to the beginning of the statement.
2126
2127 The address delta is the difference between the base address and
2128 the address of the first instruction for the statement.
2129
2130 Note that we must copy the bytes from the packed table to our local
2131 variables before attempting to use them, to avoid alignment problems
2132 on some machines, particularly RISC processors.
2133
2134 BUGS
2135
2136 Does gdb expect the line numbers to be sorted? They are now by
2137 chance/luck, but are not required to be. (FIXME)
2138
2139 The line with number 0 is unused, gdb apparently can discover the
2140 span of the last line some other way. How? (FIXME)
2141 */
2142
2143 static void
2144 decode_line_numbers (linetable)
2145 char *linetable;
2146 {
2147 char *tblscan;
2148 char *tblend;
2149 unsigned long length;
2150 unsigned long base;
2151 unsigned long line;
2152 unsigned long pc;
2153
2154 if (linetable != NULL)
2155 {
2156 tblscan = tblend = linetable;
2157 length = target_to_host (tblscan, SIZEOF_LINETBL_LENGTH, GET_UNSIGNED,
2158 current_objfile);
2159 tblscan += SIZEOF_LINETBL_LENGTH;
2160 tblend += length;
2161 base = target_to_host (tblscan, TARGET_FT_POINTER_SIZE (objfile),
2162 GET_UNSIGNED, current_objfile);
2163 tblscan += TARGET_FT_POINTER_SIZE (objfile);
2164 base += baseaddr;
2165 while (tblscan < tblend)
2166 {
2167 line = target_to_host (tblscan, SIZEOF_LINETBL_LINENO, GET_UNSIGNED,
2168 current_objfile);
2169 tblscan += SIZEOF_LINETBL_LINENO + SIZEOF_LINETBL_STMT;
2170 pc = target_to_host (tblscan, SIZEOF_LINETBL_DELTA, GET_UNSIGNED,
2171 current_objfile);
2172 tblscan += SIZEOF_LINETBL_DELTA;
2173 pc += base;
2174 if (line != 0)
2175 {
2176 record_line (current_subfile, line, pc);
2177 }
2178 }
2179 }
2180 }
2181
2182 /*
2183
2184 LOCAL FUNCTION
2185
2186 locval -- compute the value of a location attribute
2187
2188 SYNOPSIS
2189
2190 static int locval (char *loc)
2191
2192 DESCRIPTION
2193
2194 Given pointer to a string of bytes that define a location, compute
2195 the location and return the value.
2196
2197 When computing values involving the current value of the frame pointer,
2198 the value zero is used, which results in a value relative to the frame
2199 pointer, rather than the absolute value. This is what GDB wants
2200 anyway.
2201
2202 When the result is a register number, the global isreg flag is set,
2203 otherwise it is cleared. This is a kludge until we figure out a better
2204 way to handle the problem. Gdb's design does not mesh well with the
2205 DWARF notion of a location computing interpreter, which is a shame
2206 because the flexibility goes unused.
2207
2208 NOTES
2209
2210 Note that stack[0] is unused except as a default error return.
2211 Note that stack overflow is not yet handled.
2212 */
2213
2214 static int
2215 locval (loc)
2216 char *loc;
2217 {
2218 unsigned short nbytes;
2219 unsigned short locsize;
2220 auto long stack[64];
2221 int stacki;
2222 char *end;
2223 long regno;
2224 int loc_atom_code;
2225 int loc_value_size;
2226
2227 nbytes = attribute_size (AT_location);
2228 locsize = target_to_host (loc, nbytes, GET_UNSIGNED, current_objfile);
2229 loc += nbytes;
2230 end = loc + locsize;
2231 stacki = 0;
2232 stack[stacki] = 0;
2233 isreg = 0;
2234 offreg = 0;
2235 loc_value_size = TARGET_FT_LONG_SIZE (current_objfile);
2236 while (loc < end)
2237 {
2238 loc_atom_code = target_to_host (loc, SIZEOF_LOC_ATOM_CODE, GET_UNSIGNED,
2239 current_objfile);
2240 loc += SIZEOF_LOC_ATOM_CODE;
2241 switch (loc_atom_code)
2242 {
2243 case 0:
2244 /* error */
2245 loc = end;
2246 break;
2247 case OP_REG:
2248 /* push register (number) */
2249 stack[++stacki] = target_to_host (loc, loc_value_size,
2250 GET_UNSIGNED, current_objfile);
2251 loc += loc_value_size;
2252 isreg = 1;
2253 break;
2254 case OP_BASEREG:
2255 /* push value of register (number) */
2256 /* Actually, we compute the value as if register has 0 */
2257 offreg = 1;
2258 regno = target_to_host (loc, loc_value_size, GET_UNSIGNED,
2259 current_objfile);
2260 loc += loc_value_size;
2261 if (regno == R_FP)
2262 {
2263 stack[++stacki] = 0;
2264 }
2265 else
2266 {
2267 stack[++stacki] = 0;
2268
2269 complain (&basereg_not_handled, DIE_ID, DIE_NAME, regno);
2270 }
2271 break;
2272 case OP_ADDR:
2273 /* push address (relocated address) */
2274 stack[++stacki] = target_to_host (loc, loc_value_size,
2275 GET_UNSIGNED, current_objfile);
2276 loc += loc_value_size;
2277 break;
2278 case OP_CONST:
2279 /* push constant (number) FIXME: signed or unsigned! */
2280 stack[++stacki] = target_to_host (loc, loc_value_size,
2281 GET_SIGNED, current_objfile);
2282 loc += loc_value_size;
2283 break;
2284 case OP_DEREF2:
2285 /* pop, deref and push 2 bytes (as a long) */
2286 complain (&op_deref2, DIE_ID, DIE_NAME, stack[stacki]);
2287 break;
2288 case OP_DEREF4: /* pop, deref and push 4 bytes (as a long) */
2289 complain (&op_deref4, DIE_ID, DIE_NAME, stack[stacki]);
2290 break;
2291 case OP_ADD: /* pop top 2 items, add, push result */
2292 stack[stacki - 1] += stack[stacki];
2293 stacki--;
2294 break;
2295 }
2296 }
2297 return (stack[stacki]);
2298 }
2299
2300 /*
2301
2302 LOCAL FUNCTION
2303
2304 read_ofile_symtab -- build a full symtab entry from chunk of DIE's
2305
2306 SYNOPSIS
2307
2308 static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
2309
2310 DESCRIPTION
2311
2312 When expanding a partial symbol table entry to a full symbol table
2313 entry, this is the function that gets called to read in the symbols
2314 for the compilation unit.
2315
2316 Returns a pointer to the newly constructed symtab (which is now
2317 the new first one on the objfile's symtab list).
2318 */
2319
2320 static struct symtab *
2321 read_ofile_symtab (pst)
2322 struct partial_symtab *pst;
2323 {
2324 struct cleanup *back_to;
2325 unsigned long lnsize;
2326 file_ptr foffset;
2327 bfd *abfd;
2328 char lnsizedata[SIZEOF_LINETBL_LENGTH];
2329
2330 abfd = pst -> objfile -> obfd;
2331 current_objfile = pst -> objfile;
2332
2333 /* Allocate a buffer for the entire chunk of DIE's for this compilation
2334 unit, seek to the location in the file, and read in all the DIE's. */
2335
2336 diecount = 0;
2337 dbsize = DBLENGTH (pst);
2338 dbbase = xmalloc (dbsize);
2339 dbroff = DBROFF(pst);
2340 foffset = DBFOFF(pst) + dbroff;
2341 base_section_offsets = pst->section_offsets;
2342 baseaddr = ANOFFSET (pst->section_offsets, 0);
2343 if (bfd_seek (abfd, foffset, L_SET) ||
2344 (bfd_read (dbbase, dbsize, 1, abfd) != dbsize))
2345 {
2346 free (dbbase);
2347 error ("can't read DWARF data");
2348 }
2349 back_to = make_cleanup (free, dbbase);
2350
2351 /* If there is a line number table associated with this compilation unit
2352 then read the size of this fragment in bytes, from the fragment itself.
2353 Allocate a buffer for the fragment and read it in for future
2354 processing. */
2355
2356 lnbase = NULL;
2357 if (LNFOFF (pst))
2358 {
2359 if (bfd_seek (abfd, LNFOFF (pst), L_SET) ||
2360 (bfd_read ((PTR) lnsizedata, sizeof (lnsizedata), 1, abfd) !=
2361 sizeof (lnsizedata)))
2362 {
2363 error ("can't read DWARF line number table size");
2364 }
2365 lnsize = target_to_host (lnsizedata, SIZEOF_LINETBL_LENGTH,
2366 GET_UNSIGNED, pst -> objfile);
2367 lnbase = xmalloc (lnsize);
2368 if (bfd_seek (abfd, LNFOFF (pst), L_SET) ||
2369 (bfd_read (lnbase, lnsize, 1, abfd) != lnsize))
2370 {
2371 free (lnbase);
2372 error ("can't read DWARF line numbers");
2373 }
2374 make_cleanup (free, lnbase);
2375 }
2376
2377 process_dies (dbbase, dbbase + dbsize, pst -> objfile);
2378 do_cleanups (back_to);
2379 current_objfile = NULL;
2380 return (pst -> objfile -> symtabs);
2381 }
2382
2383 /*
2384
2385 LOCAL FUNCTION
2386
2387 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry
2388
2389 SYNOPSIS
2390
2391 static void psymtab_to_symtab_1 (struct partial_symtab *pst)
2392
2393 DESCRIPTION
2394
2395 Called once for each partial symbol table entry that needs to be
2396 expanded into a full symbol table entry.
2397
2398 */
2399
2400 static void
2401 psymtab_to_symtab_1 (pst)
2402 struct partial_symtab *pst;
2403 {
2404 int i;
2405 struct cleanup *old_chain;
2406
2407 if (pst != NULL)
2408 {
2409 if (pst->readin)
2410 {
2411 warning ("psymtab for %s already read in. Shouldn't happen.",
2412 pst -> filename);
2413 }
2414 else
2415 {
2416 /* Read in all partial symtabs on which this one is dependent */
2417 for (i = 0; i < pst -> number_of_dependencies; i++)
2418 {
2419 if (!pst -> dependencies[i] -> readin)
2420 {
2421 /* Inform about additional files that need to be read in. */
2422 if (info_verbose)
2423 {
2424 fputs_filtered (" ", stdout);
2425 wrap_here ("");
2426 fputs_filtered ("and ", stdout);
2427 wrap_here ("");
2428 printf_filtered ("%s...",
2429 pst -> dependencies[i] -> filename);
2430 wrap_here ("");
2431 fflush (stdout); /* Flush output */
2432 }
2433 psymtab_to_symtab_1 (pst -> dependencies[i]);
2434 }
2435 }
2436 if (DBLENGTH (pst)) /* Otherwise it's a dummy */
2437 {
2438 buildsym_init ();
2439 old_chain = make_cleanup (really_free_pendings, 0);
2440 pst -> symtab = read_ofile_symtab (pst);
2441 if (info_verbose)
2442 {
2443 printf_filtered ("%d DIE's, sorting...", diecount);
2444 wrap_here ("");
2445 fflush (stdout);
2446 }
2447 sort_symtab_syms (pst -> symtab);
2448 do_cleanups (old_chain);
2449 }
2450 pst -> readin = 1;
2451 }
2452 }
2453 }
2454
2455 /*
2456
2457 LOCAL FUNCTION
2458
2459 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one
2460
2461 SYNOPSIS
2462
2463 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst)
2464
2465 DESCRIPTION
2466
2467 This is the DWARF support entry point for building a full symbol
2468 table entry from a partial symbol table entry. We are passed a
2469 pointer to the partial symbol table entry that needs to be expanded.
2470
2471 */
2472
2473 static void
2474 dwarf_psymtab_to_symtab (pst)
2475 struct partial_symtab *pst;
2476 {
2477
2478 if (pst != NULL)
2479 {
2480 if (pst -> readin)
2481 {
2482 warning ("psymtab for %s already read in. Shouldn't happen.",
2483 pst -> filename);
2484 }
2485 else
2486 {
2487 if (DBLENGTH (pst) || pst -> number_of_dependencies)
2488 {
2489 /* Print the message now, before starting serious work, to avoid
2490 disconcerting pauses. */
2491 if (info_verbose)
2492 {
2493 printf_filtered ("Reading in symbols for %s...",
2494 pst -> filename);
2495 fflush (stdout);
2496 }
2497
2498 psymtab_to_symtab_1 (pst);
2499
2500 #if 0 /* FIXME: Check to see what dbxread is doing here and see if
2501 we need to do an equivalent or is this something peculiar to
2502 stabs/a.out format.
2503 Match with global symbols. This only needs to be done once,
2504 after all of the symtabs and dependencies have been read in.
2505 */
2506 scan_file_globals (pst -> objfile);
2507 #endif
2508
2509 /* Finish up the verbose info message. */
2510 if (info_verbose)
2511 {
2512 printf_filtered ("done.\n");
2513 fflush (stdout);
2514 }
2515 }
2516 }
2517 }
2518 }
2519
2520 /*
2521
2522 LOCAL FUNCTION
2523
2524 init_psymbol_list -- initialize storage for partial symbols
2525
2526 SYNOPSIS
2527
2528 static void init_psymbol_list (struct objfile *objfile, int total_symbols)
2529
2530 DESCRIPTION
2531
2532 Initializes storage for all of the partial symbols that will be
2533 created by dwarf_build_psymtabs and subsidiaries.
2534 */
2535
2536 static void
2537 init_psymbol_list (objfile, total_symbols)
2538 struct objfile *objfile;
2539 int total_symbols;
2540 {
2541 /* Free any previously allocated psymbol lists. */
2542
2543 if (objfile -> global_psymbols.list)
2544 {
2545 mfree (objfile -> md, (PTR)objfile -> global_psymbols.list);
2546 }
2547 if (objfile -> static_psymbols.list)
2548 {
2549 mfree (objfile -> md, (PTR)objfile -> static_psymbols.list);
2550 }
2551
2552 /* Current best guess is that there are approximately a twentieth
2553 of the total symbols (in a debugging file) are global or static
2554 oriented symbols */
2555
2556 objfile -> global_psymbols.size = total_symbols / 10;
2557 objfile -> static_psymbols.size = total_symbols / 10;
2558 objfile -> global_psymbols.next =
2559 objfile -> global_psymbols.list = (struct partial_symbol *)
2560 xmmalloc (objfile -> md, objfile -> global_psymbols.size
2561 * sizeof (struct partial_symbol));
2562 objfile -> static_psymbols.next =
2563 objfile -> static_psymbols.list = (struct partial_symbol *)
2564 xmmalloc (objfile -> md, objfile -> static_psymbols.size
2565 * sizeof (struct partial_symbol));
2566 }
2567
2568 /*
2569
2570 LOCAL FUNCTION
2571
2572 add_enum_psymbol -- add enumeration members to partial symbol table
2573
2574 DESCRIPTION
2575
2576 Given pointer to a DIE that is known to be for an enumeration,
2577 extract the symbolic names of the enumeration members and add
2578 partial symbols for them.
2579 */
2580
2581 static void
2582 add_enum_psymbol (dip, objfile)
2583 struct dieinfo *dip;
2584 struct objfile *objfile;
2585 {
2586 char *scan;
2587 char *listend;
2588 unsigned short blocksz;
2589 int nbytes;
2590
2591 if ((scan = dip -> at_element_list) != NULL)
2592 {
2593 if (dip -> short_element_list)
2594 {
2595 nbytes = attribute_size (AT_short_element_list);
2596 }
2597 else
2598 {
2599 nbytes = attribute_size (AT_element_list);
2600 }
2601 blocksz = target_to_host (scan, nbytes, GET_UNSIGNED, objfile);
2602 scan += nbytes;
2603 listend = scan + blocksz;
2604 while (scan < listend)
2605 {
2606 scan += TARGET_FT_LONG_SIZE (objfile);
2607 ADD_PSYMBOL_TO_LIST (scan, strlen (scan), VAR_NAMESPACE, LOC_CONST,
2608 objfile -> static_psymbols, 0, cu_language,
2609 objfile);
2610 scan += strlen (scan) + 1;
2611 }
2612 }
2613 }
2614
2615 /*
2616
2617 LOCAL FUNCTION
2618
2619 add_partial_symbol -- add symbol to partial symbol table
2620
2621 DESCRIPTION
2622
2623 Given a DIE, if it is one of the types that we want to
2624 add to a partial symbol table, finish filling in the die info
2625 and then add a partial symbol table entry for it.
2626
2627 NOTES
2628
2629 The caller must ensure that the DIE has a valid name attribute.
2630 */
2631
2632 static void
2633 add_partial_symbol (dip, objfile)
2634 struct dieinfo *dip;
2635 struct objfile *objfile;
2636 {
2637 switch (dip -> die_tag)
2638 {
2639 case TAG_global_subroutine:
2640 record_minimal_symbol (dip -> at_name, dip -> at_low_pc, mst_text,
2641 objfile);
2642 ADD_PSYMBOL_TO_LIST (dip -> at_name, strlen (dip -> at_name),
2643 VAR_NAMESPACE, LOC_BLOCK,
2644 objfile -> global_psymbols,
2645 dip -> at_low_pc, cu_language, objfile);
2646 break;
2647 case TAG_global_variable:
2648 record_minimal_symbol (dip -> at_name, locval (dip -> at_location),
2649 mst_data, objfile);
2650 ADD_PSYMBOL_TO_LIST (dip -> at_name, strlen (dip -> at_name),
2651 VAR_NAMESPACE, LOC_STATIC,
2652 objfile -> global_psymbols,
2653 0, cu_language, objfile);
2654 break;
2655 case TAG_subroutine:
2656 ADD_PSYMBOL_TO_LIST (dip -> at_name, strlen (dip -> at_name),
2657 VAR_NAMESPACE, LOC_BLOCK,
2658 objfile -> static_psymbols,
2659 dip -> at_low_pc, cu_language, objfile);
2660 break;
2661 case TAG_local_variable:
2662 ADD_PSYMBOL_TO_LIST (dip -> at_name, strlen (dip -> at_name),
2663 VAR_NAMESPACE, LOC_STATIC,
2664 objfile -> static_psymbols,
2665 0, cu_language, objfile);
2666 break;
2667 case TAG_typedef:
2668 ADD_PSYMBOL_TO_LIST (dip -> at_name, strlen (dip -> at_name),
2669 VAR_NAMESPACE, LOC_TYPEDEF,
2670 objfile -> static_psymbols,
2671 0, cu_language, objfile);
2672 break;
2673 case TAG_class_type:
2674 case TAG_structure_type:
2675 case TAG_union_type:
2676 case TAG_enumeration_type:
2677 ADD_PSYMBOL_TO_LIST (dip -> at_name, strlen (dip -> at_name),
2678 STRUCT_NAMESPACE, LOC_TYPEDEF,
2679 objfile -> static_psymbols,
2680 0, cu_language, objfile);
2681 if (cu_language == language_cplus)
2682 {
2683 /* For C++, these implicitly act as typedefs as well. */
2684 ADD_PSYMBOL_TO_LIST (dip -> at_name, strlen (dip -> at_name),
2685 VAR_NAMESPACE, LOC_TYPEDEF,
2686 objfile -> static_psymbols,
2687 0, cu_language, objfile);
2688 }
2689 break;
2690 }
2691 }
2692
2693 /*
2694
2695 LOCAL FUNCTION
2696
2697 scan_partial_symbols -- scan DIE's within a single compilation unit
2698
2699 DESCRIPTION
2700
2701 Process the DIE's within a single compilation unit, looking for
2702 interesting DIE's that contribute to the partial symbol table entry
2703 for this compilation unit.
2704
2705 NOTES
2706
2707 There are some DIE's that may appear both at file scope and within
2708 the scope of a function. We are only interested in the ones at file
2709 scope, and the only way to tell them apart is to keep track of the
2710 scope. For example, consider the test case:
2711
2712 static int i;
2713 main () { int j; }
2714
2715 for which the relevant DWARF segment has the structure:
2716
2717 0x51:
2718 0x23 global subrtn sibling 0x9b
2719 name main
2720 fund_type FT_integer
2721 low_pc 0x800004cc
2722 high_pc 0x800004d4
2723
2724 0x74:
2725 0x23 local var sibling 0x97
2726 name j
2727 fund_type FT_integer
2728 location OP_BASEREG 0xe
2729 OP_CONST 0xfffffffc
2730 OP_ADD
2731 0x97:
2732 0x4
2733
2734 0x9b:
2735 0x1d local var sibling 0xb8
2736 name i
2737 fund_type FT_integer
2738 location OP_ADDR 0x800025dc
2739
2740 0xb8:
2741 0x4
2742
2743 We want to include the symbol 'i' in the partial symbol table, but
2744 not the symbol 'j'. In essence, we want to skip all the dies within
2745 the scope of a TAG_global_subroutine DIE.
2746
2747 Don't attempt to add anonymous structures or unions since they have
2748 no name. Anonymous enumerations however are processed, because we
2749 want to extract their member names (the check for a tag name is
2750 done later).
2751
2752 Also, for variables and subroutines, check that this is the place
2753 where the actual definition occurs, rather than just a reference
2754 to an external.
2755 */
2756
2757 static void
2758 scan_partial_symbols (thisdie, enddie, objfile)
2759 char *thisdie;
2760 char *enddie;
2761 struct objfile *objfile;
2762 {
2763 char *nextdie;
2764 char *temp;
2765 struct dieinfo di;
2766
2767 while (thisdie < enddie)
2768 {
2769 basicdieinfo (&di, thisdie, objfile);
2770 if (di.die_length < SIZEOF_DIE_LENGTH)
2771 {
2772 break;
2773 }
2774 else
2775 {
2776 nextdie = thisdie + di.die_length;
2777 /* To avoid getting complete die information for every die, we
2778 only do it (below) for the cases we are interested in. */
2779 switch (di.die_tag)
2780 {
2781 case TAG_global_subroutine:
2782 case TAG_subroutine:
2783 completedieinfo (&di, objfile);
2784 if (di.at_name && (di.has_at_low_pc || di.at_location))
2785 {
2786 add_partial_symbol (&di, objfile);
2787 /* If there is a sibling attribute, adjust the nextdie
2788 pointer to skip the entire scope of the subroutine.
2789 Apply some sanity checking to make sure we don't
2790 overrun or underrun the range of remaining DIE's */
2791 if (di.at_sibling != 0)
2792 {
2793 temp = dbbase + di.at_sibling - dbroff;
2794 if ((temp < thisdie) || (temp >= enddie))
2795 {
2796 complain (&bad_die_ref, DIE_ID, DIE_NAME,
2797 di.at_sibling);
2798 }
2799 else
2800 {
2801 nextdie = temp;
2802 }
2803 }
2804 }
2805 break;
2806 case TAG_global_variable:
2807 case TAG_local_variable:
2808 completedieinfo (&di, objfile);
2809 if (di.at_name && (di.has_at_low_pc || di.at_location))
2810 {
2811 add_partial_symbol (&di, objfile);
2812 }
2813 break;
2814 case TAG_typedef:
2815 case TAG_class_type:
2816 case TAG_structure_type:
2817 case TAG_union_type:
2818 completedieinfo (&di, objfile);
2819 if (di.at_name)
2820 {
2821 add_partial_symbol (&di, objfile);
2822 }
2823 break;
2824 case TAG_enumeration_type:
2825 completedieinfo (&di, objfile);
2826 if (di.at_name)
2827 {
2828 add_partial_symbol (&di, objfile);
2829 }
2830 add_enum_psymbol (&di, objfile);
2831 break;
2832 }
2833 }
2834 thisdie = nextdie;
2835 }
2836 }
2837
2838 /*
2839
2840 LOCAL FUNCTION
2841
2842 scan_compilation_units -- build a psymtab entry for each compilation
2843
2844 DESCRIPTION
2845
2846 This is the top level dwarf parsing routine for building partial
2847 symbol tables.
2848
2849 It scans from the beginning of the DWARF table looking for the first
2850 TAG_compile_unit DIE, and then follows the sibling chain to locate
2851 each additional TAG_compile_unit DIE.
2852
2853 For each TAG_compile_unit DIE it creates a partial symtab structure,
2854 calls a subordinate routine to collect all the compilation unit's
2855 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the
2856 new partial symtab structure into the partial symbol table. It also
2857 records the appropriate information in the partial symbol table entry
2858 to allow the chunk of DIE's and line number table for this compilation
2859 unit to be located and re-read later, to generate a complete symbol
2860 table entry for the compilation unit.
2861
2862 Thus it effectively partitions up a chunk of DIE's for multiple
2863 compilation units into smaller DIE chunks and line number tables,
2864 and associates them with a partial symbol table entry.
2865
2866 NOTES
2867
2868 If any compilation unit has no line number table associated with
2869 it for some reason (a missing at_stmt_list attribute, rather than
2870 just one with a value of zero, which is valid) then we ensure that
2871 the recorded file offset is zero so that the routine which later
2872 reads line number table fragments knows that there is no fragment
2873 to read.
2874
2875 RETURNS
2876
2877 Returns no value.
2878
2879 */
2880
2881 static void
2882 scan_compilation_units (thisdie, enddie, dbfoff, lnoffset, objfile)
2883 char *thisdie;
2884 char *enddie;
2885 file_ptr dbfoff;
2886 file_ptr lnoffset;
2887 struct objfile *objfile;
2888 {
2889 char *nextdie;
2890 struct dieinfo di;
2891 struct partial_symtab *pst;
2892 int culength;
2893 int curoff;
2894 file_ptr curlnoffset;
2895
2896 while (thisdie < enddie)
2897 {
2898 basicdieinfo (&di, thisdie, objfile);
2899 if (di.die_length < SIZEOF_DIE_LENGTH)
2900 {
2901 break;
2902 }
2903 else if (di.die_tag != TAG_compile_unit)
2904 {
2905 nextdie = thisdie + di.die_length;
2906 }
2907 else
2908 {
2909 completedieinfo (&di, objfile);
2910 set_cu_language (&di);
2911 if (di.at_sibling != 0)
2912 {
2913 nextdie = dbbase + di.at_sibling - dbroff;
2914 }
2915 else
2916 {
2917 nextdie = thisdie + di.die_length;
2918 }
2919 curoff = thisdie - dbbase;
2920 culength = nextdie - thisdie;
2921 curlnoffset = di.has_at_stmt_list ? lnoffset + di.at_stmt_list : 0;
2922
2923 /* First allocate a new partial symbol table structure */
2924
2925 pst = start_psymtab_common (objfile, base_section_offsets,
2926 di.at_name, di.at_low_pc,
2927 objfile -> global_psymbols.next,
2928 objfile -> static_psymbols.next);
2929
2930 pst -> texthigh = di.at_high_pc;
2931 pst -> read_symtab_private = (char *)
2932 obstack_alloc (&objfile -> psymbol_obstack,
2933 sizeof (struct dwfinfo));
2934 DBFOFF (pst) = dbfoff;
2935 DBROFF (pst) = curoff;
2936 DBLENGTH (pst) = culength;
2937 LNFOFF (pst) = curlnoffset;
2938 pst -> read_symtab = dwarf_psymtab_to_symtab;
2939
2940 /* Now look for partial symbols */
2941
2942 scan_partial_symbols (thisdie + di.die_length, nextdie, objfile);
2943
2944 pst -> n_global_syms = objfile -> global_psymbols.next -
2945 (objfile -> global_psymbols.list + pst -> globals_offset);
2946 pst -> n_static_syms = objfile -> static_psymbols.next -
2947 (objfile -> static_psymbols.list + pst -> statics_offset);
2948 sort_pst_symbols (pst);
2949 /* If there is already a psymtab or symtab for a file of this name,
2950 remove it. (If there is a symtab, more drastic things also
2951 happen.) This happens in VxWorks. */
2952 free_named_symtabs (pst -> filename);
2953 }
2954 thisdie = nextdie;
2955 }
2956 }
2957
2958 /*
2959
2960 LOCAL FUNCTION
2961
2962 new_symbol -- make a symbol table entry for a new symbol
2963
2964 SYNOPSIS
2965
2966 static struct symbol *new_symbol (struct dieinfo *dip,
2967 struct objfile *objfile)
2968
2969 DESCRIPTION
2970
2971 Given a pointer to a DWARF information entry, figure out if we need
2972 to make a symbol table entry for it, and if so, create a new entry
2973 and return a pointer to it.
2974 */
2975
2976 static struct symbol *
2977 new_symbol (dip, objfile)
2978 struct dieinfo *dip;
2979 struct objfile *objfile;
2980 {
2981 struct symbol *sym = NULL;
2982
2983 if (dip -> at_name != NULL)
2984 {
2985 sym = (struct symbol *) obstack_alloc (&objfile -> symbol_obstack,
2986 sizeof (struct symbol));
2987 memset (sym, 0, sizeof (struct symbol));
2988 SYMBOL_NAME (sym) = create_name (dip -> at_name,
2989 &objfile->symbol_obstack);
2990 /* default assumptions */
2991 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
2992 SYMBOL_CLASS (sym) = LOC_STATIC;
2993 SYMBOL_TYPE (sym) = decode_die_type (dip);
2994
2995 /* If this symbol is from a C++ compilation, then attempt to cache the
2996 demangled form for future reference. This is a typical time versus
2997 space tradeoff, that was decided in favor of time because it sped up
2998 C++ symbol lookups by a factor of about 20. */
2999
3000 SYMBOL_LANGUAGE (sym) = cu_language;
3001 SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile -> symbol_obstack);
3002 switch (dip -> die_tag)
3003 {
3004 case TAG_label:
3005 SYMBOL_VALUE (sym) = dip -> at_low_pc;
3006 SYMBOL_CLASS (sym) = LOC_LABEL;
3007 break;
3008 case TAG_global_subroutine:
3009 case TAG_subroutine:
3010 SYMBOL_VALUE (sym) = dip -> at_low_pc;
3011 SYMBOL_TYPE (sym) = lookup_function_type (SYMBOL_TYPE (sym));
3012 SYMBOL_CLASS (sym) = LOC_BLOCK;
3013 if (dip -> die_tag == TAG_global_subroutine)
3014 {
3015 add_symbol_to_list (sym, &global_symbols);
3016 }
3017 else
3018 {
3019 add_symbol_to_list (sym, list_in_scope);
3020 }
3021 break;
3022 case TAG_global_variable:
3023 if (dip -> at_location != NULL)
3024 {
3025 SYMBOL_VALUE (sym) = locval (dip -> at_location);
3026 add_symbol_to_list (sym, &global_symbols);
3027 SYMBOL_CLASS (sym) = LOC_STATIC;
3028 SYMBOL_VALUE (sym) += baseaddr;
3029 }
3030 break;
3031 case TAG_local_variable:
3032 if (dip -> at_location != NULL)
3033 {
3034 SYMBOL_VALUE (sym) = locval (dip -> at_location);
3035 add_symbol_to_list (sym, list_in_scope);
3036 if (isreg)
3037 {
3038 SYMBOL_CLASS (sym) = LOC_REGISTER;
3039 }
3040 else if (offreg)
3041 {
3042 SYMBOL_CLASS (sym) = LOC_LOCAL;
3043 }
3044 else
3045 {
3046 SYMBOL_CLASS (sym) = LOC_STATIC;
3047 SYMBOL_VALUE (sym) += baseaddr;
3048 }
3049 }
3050 break;
3051 case TAG_formal_parameter:
3052 if (dip -> at_location != NULL)
3053 {
3054 SYMBOL_VALUE (sym) = locval (dip -> at_location);
3055 }
3056 add_symbol_to_list (sym, list_in_scope);
3057 if (isreg)
3058 {
3059 SYMBOL_CLASS (sym) = LOC_REGPARM;
3060 }
3061 else
3062 {
3063 SYMBOL_CLASS (sym) = LOC_ARG;
3064 }
3065 break;
3066 case TAG_unspecified_parameters:
3067 /* From varargs functions; gdb doesn't seem to have any interest in
3068 this information, so just ignore it for now. (FIXME?) */
3069 break;
3070 case TAG_class_type:
3071 case TAG_structure_type:
3072 case TAG_union_type:
3073 case TAG_enumeration_type:
3074 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
3075 SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
3076 add_symbol_to_list (sym, list_in_scope);
3077 break;
3078 case TAG_typedef:
3079 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
3080 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
3081 add_symbol_to_list (sym, list_in_scope);
3082 break;
3083 default:
3084 /* Not a tag we recognize. Hopefully we aren't processing trash
3085 data, but since we must specifically ignore things we don't
3086 recognize, there is nothing else we should do at this point. */
3087 break;
3088 }
3089 }
3090 return (sym);
3091 }
3092
3093 /*
3094
3095 LOCAL FUNCTION
3096
3097 synthesize_typedef -- make a symbol table entry for a "fake" typedef
3098
3099 SYNOPSIS
3100
3101 static void synthesize_typedef (struct dieinfo *dip,
3102 struct objfile *objfile,
3103 struct type *type);
3104
3105 DESCRIPTION
3106
3107 Given a pointer to a DWARF information entry, synthesize a typedef
3108 for the name in the DIE, using the specified type.
3109
3110 This is used for C++ class, structs, unions, and enumerations to
3111 set up the tag name as a type.
3112
3113 */
3114
3115 static void
3116 synthesize_typedef (dip, objfile, type)
3117 struct dieinfo *dip;
3118 struct objfile *objfile;
3119 struct type *type;
3120 {
3121 struct symbol *sym = NULL;
3122
3123 if (dip -> at_name != NULL)
3124 {
3125 sym = (struct symbol *)
3126 obstack_alloc (&objfile -> symbol_obstack, sizeof (struct symbol));
3127 memset (sym, 0, sizeof (struct symbol));
3128 SYMBOL_NAME (sym) = create_name (dip -> at_name,
3129 &objfile->symbol_obstack);
3130 SYMBOL_INIT_LANGUAGE_SPECIFIC (sym, cu_language);
3131 SYMBOL_TYPE (sym) = type;
3132 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
3133 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
3134 add_symbol_to_list (sym, list_in_scope);
3135 }
3136 }
3137
3138 /*
3139
3140 LOCAL FUNCTION
3141
3142 decode_mod_fund_type -- decode a modified fundamental type
3143
3144 SYNOPSIS
3145
3146 static struct type *decode_mod_fund_type (char *typedata)
3147
3148 DESCRIPTION
3149
3150 Decode a block of data containing a modified fundamental
3151 type specification. TYPEDATA is a pointer to the block,
3152 which starts with a length containing the size of the rest
3153 of the block. At the end of the block is a fundmental type
3154 code value that gives the fundamental type. Everything
3155 in between are type modifiers.
3156
3157 We simply compute the number of modifiers and call the general
3158 function decode_modified_type to do the actual work.
3159 */
3160
3161 static struct type *
3162 decode_mod_fund_type (typedata)
3163 char *typedata;
3164 {
3165 struct type *typep = NULL;
3166 unsigned short modcount;
3167 int nbytes;
3168
3169 /* Get the total size of the block, exclusive of the size itself */
3170
3171 nbytes = attribute_size (AT_mod_fund_type);
3172 modcount = target_to_host (typedata, nbytes, GET_UNSIGNED, current_objfile);
3173 typedata += nbytes;
3174
3175 /* Deduct the size of the fundamental type bytes at the end of the block. */
3176
3177 modcount -= attribute_size (AT_fund_type);
3178
3179 /* Now do the actual decoding */
3180
3181 typep = decode_modified_type (typedata, modcount, AT_mod_fund_type);
3182 return (typep);
3183 }
3184
3185 /*
3186
3187 LOCAL FUNCTION
3188
3189 decode_mod_u_d_type -- decode a modified user defined type
3190
3191 SYNOPSIS
3192
3193 static struct type *decode_mod_u_d_type (char *typedata)
3194
3195 DESCRIPTION
3196
3197 Decode a block of data containing a modified user defined
3198 type specification. TYPEDATA is a pointer to the block,
3199 which consists of a two byte length, containing the size
3200 of the rest of the block. At the end of the block is a
3201 four byte value that gives a reference to a user defined type.
3202 Everything in between are type modifiers.
3203
3204 We simply compute the number of modifiers and call the general
3205 function decode_modified_type to do the actual work.
3206 */
3207
3208 static struct type *
3209 decode_mod_u_d_type (typedata)
3210 char *typedata;
3211 {
3212 struct type *typep = NULL;
3213 unsigned short modcount;
3214 int nbytes;
3215
3216 /* Get the total size of the block, exclusive of the size itself */
3217
3218 nbytes = attribute_size (AT_mod_u_d_type);
3219 modcount = target_to_host (typedata, nbytes, GET_UNSIGNED, current_objfile);
3220 typedata += nbytes;
3221
3222 /* Deduct the size of the reference type bytes at the end of the block. */
3223
3224 modcount -= attribute_size (AT_user_def_type);
3225
3226 /* Now do the actual decoding */
3227
3228 typep = decode_modified_type (typedata, modcount, AT_mod_u_d_type);
3229 return (typep);
3230 }
3231
3232 /*
3233
3234 LOCAL FUNCTION
3235
3236 decode_modified_type -- decode modified user or fundamental type
3237
3238 SYNOPSIS
3239
3240 static struct type *decode_modified_type (char *modifiers,
3241 unsigned short modcount, int mtype)
3242
3243 DESCRIPTION
3244
3245 Decode a modified type, either a modified fundamental type or
3246 a modified user defined type. MODIFIERS is a pointer to the
3247 block of bytes that define MODCOUNT modifiers. Immediately
3248 following the last modifier is a short containing the fundamental
3249 type or a long containing the reference to the user defined
3250 type. Which one is determined by MTYPE, which is either
3251 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified
3252 type we are generating.
3253
3254 We call ourself recursively to generate each modified type,`
3255 until MODCOUNT reaches zero, at which point we have consumed
3256 all the modifiers and generate either the fundamental type or
3257 user defined type. When the recursion unwinds, each modifier
3258 is applied in turn to generate the full modified type.
3259
3260 NOTES
3261
3262 If we find a modifier that we don't recognize, and it is not one
3263 of those reserved for application specific use, then we issue a
3264 warning and simply ignore the modifier.
3265
3266 BUGS
3267
3268 We currently ignore MOD_const and MOD_volatile. (FIXME)
3269
3270 */
3271
3272 static struct type *
3273 decode_modified_type (modifiers, modcount, mtype)
3274 char *modifiers;
3275 unsigned int modcount;
3276 int mtype;
3277 {
3278 struct type *typep = NULL;
3279 unsigned short fundtype;
3280 DIE_REF die_ref;
3281 char modifier;
3282 int nbytes;
3283
3284 if (modcount == 0)
3285 {
3286 switch (mtype)
3287 {
3288 case AT_mod_fund_type:
3289 nbytes = attribute_size (AT_fund_type);
3290 fundtype = target_to_host (modifiers, nbytes, GET_UNSIGNED,
3291 current_objfile);
3292 typep = decode_fund_type (fundtype);
3293 break;
3294 case AT_mod_u_d_type:
3295 nbytes = attribute_size (AT_user_def_type);
3296 die_ref = target_to_host (modifiers, nbytes, GET_UNSIGNED,
3297 current_objfile);
3298 if ((typep = lookup_utype (die_ref)) == NULL)
3299 {
3300 typep = alloc_utype (die_ref, NULL);
3301 }
3302 break;
3303 default:
3304 complain (&botched_modified_type, DIE_ID, DIE_NAME, mtype);
3305 typep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
3306 break;
3307 }
3308 }
3309 else
3310 {
3311 modifier = *modifiers++;
3312 typep = decode_modified_type (modifiers, --modcount, mtype);
3313 switch (modifier)
3314 {
3315 case MOD_pointer_to:
3316 typep = lookup_pointer_type (typep);
3317 break;
3318 case MOD_reference_to:
3319 typep = lookup_reference_type (typep);
3320 break;
3321 case MOD_const:
3322 complain (&const_ignored, DIE_ID, DIE_NAME); /* FIXME */
3323 break;
3324 case MOD_volatile:
3325 complain (&volatile_ignored, DIE_ID, DIE_NAME); /* FIXME */
3326 break;
3327 default:
3328 if (!(MOD_lo_user <= (unsigned char) modifier
3329 && (unsigned char) modifier <= MOD_hi_user))
3330 {
3331 complain (&unknown_type_modifier, DIE_ID, DIE_NAME, modifier);
3332 }
3333 break;
3334 }
3335 }
3336 return (typep);
3337 }
3338
3339 /*
3340
3341 LOCAL FUNCTION
3342
3343 decode_fund_type -- translate basic DWARF type to gdb base type
3344
3345 DESCRIPTION
3346
3347 Given an integer that is one of the fundamental DWARF types,
3348 translate it to one of the basic internal gdb types and return
3349 a pointer to the appropriate gdb type (a "struct type *").
3350
3351 NOTES
3352
3353 For robustness, if we are asked to translate a fundamental
3354 type that we are unprepared to deal with, we return int so
3355 callers can always depend upon a valid type being returned,
3356 and so gdb may at least do something reasonable by default.
3357 If the type is not in the range of those types defined as
3358 application specific types, we also issue a warning.
3359 */
3360
3361 static struct type *
3362 decode_fund_type (fundtype)
3363 unsigned int fundtype;
3364 {
3365 struct type *typep = NULL;
3366
3367 switch (fundtype)
3368 {
3369
3370 case FT_void:
3371 typep = dwarf_fundamental_type (current_objfile, FT_VOID);
3372 break;
3373
3374 case FT_boolean: /* Was FT_set in AT&T version */
3375 typep = dwarf_fundamental_type (current_objfile, FT_BOOLEAN);
3376 break;
3377
3378 case FT_pointer: /* (void *) */
3379 typep = dwarf_fundamental_type (current_objfile, FT_VOID);
3380 typep = lookup_pointer_type (typep);
3381 break;
3382
3383 case FT_char:
3384 typep = dwarf_fundamental_type (current_objfile, FT_CHAR);
3385 break;
3386
3387 case FT_signed_char:
3388 typep = dwarf_fundamental_type (current_objfile, FT_SIGNED_CHAR);
3389 break;
3390
3391 case FT_unsigned_char:
3392 typep = dwarf_fundamental_type (current_objfile, FT_UNSIGNED_CHAR);
3393 break;
3394
3395 case FT_short:
3396 typep = dwarf_fundamental_type (current_objfile, FT_SHORT);
3397 break;
3398
3399 case FT_signed_short:
3400 typep = dwarf_fundamental_type (current_objfile, FT_SIGNED_SHORT);
3401 break;
3402
3403 case FT_unsigned_short:
3404 typep = dwarf_fundamental_type (current_objfile, FT_UNSIGNED_SHORT);
3405 break;
3406
3407 case FT_integer:
3408 typep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
3409 break;
3410
3411 case FT_signed_integer:
3412 typep = dwarf_fundamental_type (current_objfile, FT_SIGNED_INTEGER);
3413 break;
3414
3415 case FT_unsigned_integer:
3416 typep = dwarf_fundamental_type (current_objfile, FT_UNSIGNED_INTEGER);
3417 break;
3418
3419 case FT_long:
3420 typep = dwarf_fundamental_type (current_objfile, FT_LONG);
3421 break;
3422
3423 case FT_signed_long:
3424 typep = dwarf_fundamental_type (current_objfile, FT_SIGNED_LONG);
3425 break;
3426
3427 case FT_unsigned_long:
3428 typep = dwarf_fundamental_type (current_objfile, FT_UNSIGNED_LONG);
3429 break;
3430
3431 case FT_long_long:
3432 typep = dwarf_fundamental_type (current_objfile, FT_LONG_LONG);
3433 break;
3434
3435 case FT_signed_long_long:
3436 typep = dwarf_fundamental_type (current_objfile, FT_SIGNED_LONG_LONG);
3437 break;
3438
3439 case FT_unsigned_long_long:
3440 typep = dwarf_fundamental_type (current_objfile, FT_UNSIGNED_LONG_LONG);
3441 break;
3442
3443 case FT_float:
3444 typep = dwarf_fundamental_type (current_objfile, FT_FLOAT);
3445 break;
3446
3447 case FT_dbl_prec_float:
3448 typep = dwarf_fundamental_type (current_objfile, FT_DBL_PREC_FLOAT);
3449 break;
3450
3451 case FT_ext_prec_float:
3452 typep = dwarf_fundamental_type (current_objfile, FT_EXT_PREC_FLOAT);
3453 break;
3454
3455 case FT_complex:
3456 typep = dwarf_fundamental_type (current_objfile, FT_COMPLEX);
3457 break;
3458
3459 case FT_dbl_prec_complex:
3460 typep = dwarf_fundamental_type (current_objfile, FT_DBL_PREC_COMPLEX);
3461 break;
3462
3463 case FT_ext_prec_complex:
3464 typep = dwarf_fundamental_type (current_objfile, FT_EXT_PREC_COMPLEX);
3465 break;
3466
3467 }
3468
3469 if (typep == NULL)
3470 {
3471 typep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
3472 if (!(FT_lo_user <= fundtype && fundtype <= FT_hi_user))
3473 {
3474 complain (&unexpected_fund_type, DIE_ID, DIE_NAME, fundtype);
3475 }
3476 }
3477
3478 return (typep);
3479 }
3480
3481 /*
3482
3483 LOCAL FUNCTION
3484
3485 create_name -- allocate a fresh copy of a string on an obstack
3486
3487 DESCRIPTION
3488
3489 Given a pointer to a string and a pointer to an obstack, allocates
3490 a fresh copy of the string on the specified obstack.
3491
3492 */
3493
3494 static char *
3495 create_name (name, obstackp)
3496 char *name;
3497 struct obstack *obstackp;
3498 {
3499 int length;
3500 char *newname;
3501
3502 length = strlen (name) + 1;
3503 newname = (char *) obstack_alloc (obstackp, length);
3504 strcpy (newname, name);
3505 return (newname);
3506 }
3507
3508 /*
3509
3510 LOCAL FUNCTION
3511
3512 basicdieinfo -- extract the minimal die info from raw die data
3513
3514 SYNOPSIS
3515
3516 void basicdieinfo (char *diep, struct dieinfo *dip,
3517 struct objfile *objfile)
3518
3519 DESCRIPTION
3520
3521 Given a pointer to raw DIE data, and a pointer to an instance of a
3522 die info structure, this function extracts the basic information
3523 from the DIE data required to continue processing this DIE, along
3524 with some bookkeeping information about the DIE.
3525
3526 The information we absolutely must have includes the DIE tag,
3527 and the DIE length. If we need the sibling reference, then we
3528 will have to call completedieinfo() to process all the remaining
3529 DIE information.
3530
3531 Note that since there is no guarantee that the data is properly
3532 aligned in memory for the type of access required (indirection
3533 through anything other than a char pointer), and there is no
3534 guarantee that it is in the same byte order as the gdb host,
3535 we call a function which deals with both alignment and byte
3536 swapping issues. Possibly inefficient, but quite portable.
3537
3538 We also take care of some other basic things at this point, such
3539 as ensuring that the instance of the die info structure starts
3540 out completely zero'd and that curdie is initialized for use
3541 in error reporting if we have a problem with the current die.
3542
3543 NOTES
3544
3545 All DIE's must have at least a valid length, thus the minimum
3546 DIE size is SIZEOF_DIE_LENGTH. In order to have a valid tag, the
3547 DIE size must be at least SIZEOF_DIE_TAG larger, otherwise they
3548 are forced to be TAG_padding DIES.
3549
3550 Padding DIES must be at least SIZEOF_DIE_LENGTH in length, implying
3551 that if a padding DIE is used for alignment and the amount needed is
3552 less than SIZEOF_DIE_LENGTH, then the padding DIE has to be big
3553 enough to align to the next alignment boundry.
3554
3555 We do some basic sanity checking here, such as verifying that the
3556 length of the die would not cause it to overrun the recorded end of
3557 the buffer holding the DIE info. If we find a DIE that is either
3558 too small or too large, we force it's length to zero which should
3559 cause the caller to take appropriate action.
3560 */
3561
3562 static void
3563 basicdieinfo (dip, diep, objfile)
3564 struct dieinfo *dip;
3565 char *diep;
3566 struct objfile *objfile;
3567 {
3568 curdie = dip;
3569 memset (dip, 0, sizeof (struct dieinfo));
3570 dip -> die = diep;
3571 dip -> die_ref = dbroff + (diep - dbbase);
3572 dip -> die_length = target_to_host (diep, SIZEOF_DIE_LENGTH, GET_UNSIGNED,
3573 objfile);
3574 if ((dip -> die_length < SIZEOF_DIE_LENGTH) ||
3575 ((diep + dip -> die_length) > (dbbase + dbsize)))
3576 {
3577 complain (&malformed_die, DIE_ID, DIE_NAME, dip -> die_length);
3578 dip -> die_length = 0;
3579 }
3580 else if (dip -> die_length < (SIZEOF_DIE_LENGTH + SIZEOF_DIE_TAG))
3581 {
3582 dip -> die_tag = TAG_padding;
3583 }
3584 else
3585 {
3586 diep += SIZEOF_DIE_LENGTH;
3587 dip -> die_tag = target_to_host (diep, SIZEOF_DIE_TAG, GET_UNSIGNED,
3588 objfile);
3589 }
3590 }
3591
3592 /*
3593
3594 LOCAL FUNCTION
3595
3596 completedieinfo -- finish reading the information for a given DIE
3597
3598 SYNOPSIS
3599
3600 void completedieinfo (struct dieinfo *dip, struct objfile *objfile)
3601
3602 DESCRIPTION
3603
3604 Given a pointer to an already partially initialized die info structure,
3605 scan the raw DIE data and finish filling in the die info structure
3606 from the various attributes found.
3607
3608 Note that since there is no guarantee that the data is properly
3609 aligned in memory for the type of access required (indirection
3610 through anything other than a char pointer), and there is no
3611 guarantee that it is in the same byte order as the gdb host,
3612 we call a function which deals with both alignment and byte
3613 swapping issues. Possibly inefficient, but quite portable.
3614
3615 NOTES
3616
3617 Each time we are called, we increment the diecount variable, which
3618 keeps an approximate count of the number of dies processed for
3619 each compilation unit. This information is presented to the user
3620 if the info_verbose flag is set.
3621
3622 */
3623
3624 static void
3625 completedieinfo (dip, objfile)
3626 struct dieinfo *dip;
3627 struct objfile *objfile;
3628 {
3629 char *diep; /* Current pointer into raw DIE data */
3630 char *end; /* Terminate DIE scan here */
3631 unsigned short attr; /* Current attribute being scanned */
3632 unsigned short form; /* Form of the attribute */
3633 int nbytes; /* Size of next field to read */
3634
3635 diecount++;
3636 diep = dip -> die;
3637 end = diep + dip -> die_length;
3638 diep += SIZEOF_DIE_LENGTH + SIZEOF_DIE_TAG;
3639 while (diep < end)
3640 {
3641 attr = target_to_host (diep, SIZEOF_ATTRIBUTE, GET_UNSIGNED, objfile);
3642 diep += SIZEOF_ATTRIBUTE;
3643 if ((nbytes = attribute_size (attr)) == -1)
3644 {
3645 complain (&unknown_attribute_length, DIE_ID, DIE_NAME);
3646 diep = end;
3647 continue;
3648 }
3649 switch (attr)
3650 {
3651 case AT_fund_type:
3652 dip -> at_fund_type = target_to_host (diep, nbytes, GET_UNSIGNED,
3653 objfile);
3654 break;
3655 case AT_ordering:
3656 dip -> at_ordering = target_to_host (diep, nbytes, GET_UNSIGNED,
3657 objfile);
3658 break;
3659 case AT_bit_offset:
3660 dip -> at_bit_offset = target_to_host (diep, nbytes, GET_UNSIGNED,
3661 objfile);
3662 break;
3663 case AT_sibling:
3664 dip -> at_sibling = target_to_host (diep, nbytes, GET_UNSIGNED,
3665 objfile);
3666 break;
3667 case AT_stmt_list:
3668 dip -> at_stmt_list = target_to_host (diep, nbytes, GET_UNSIGNED,
3669 objfile);
3670 dip -> has_at_stmt_list = 1;
3671 break;
3672 case AT_low_pc:
3673 dip -> at_low_pc = target_to_host (diep, nbytes, GET_UNSIGNED,
3674 objfile);
3675 dip -> at_low_pc += baseaddr;
3676 dip -> has_at_low_pc = 1;
3677 break;
3678 case AT_high_pc:
3679 dip -> at_high_pc = target_to_host (diep, nbytes, GET_UNSIGNED,
3680 objfile);
3681 dip -> at_high_pc += baseaddr;
3682 break;
3683 case AT_language:
3684 dip -> at_language = target_to_host (diep, nbytes, GET_UNSIGNED,
3685 objfile);
3686 break;
3687 case AT_user_def_type:
3688 dip -> at_user_def_type = target_to_host (diep, nbytes,
3689 GET_UNSIGNED, objfile);
3690 break;
3691 case AT_byte_size:
3692 dip -> at_byte_size = target_to_host (diep, nbytes, GET_UNSIGNED,
3693 objfile);
3694 dip -> has_at_byte_size = 1;
3695 break;
3696 case AT_bit_size:
3697 dip -> at_bit_size = target_to_host (diep, nbytes, GET_UNSIGNED,
3698 objfile);
3699 break;
3700 case AT_member:
3701 dip -> at_member = target_to_host (diep, nbytes, GET_UNSIGNED,
3702 objfile);
3703 break;
3704 case AT_discr:
3705 dip -> at_discr = target_to_host (diep, nbytes, GET_UNSIGNED,
3706 objfile);
3707 break;
3708 case AT_location:
3709 dip -> at_location = diep;
3710 break;
3711 case AT_mod_fund_type:
3712 dip -> at_mod_fund_type = diep;
3713 break;
3714 case AT_subscr_data:
3715 dip -> at_subscr_data = diep;
3716 break;
3717 case AT_mod_u_d_type:
3718 dip -> at_mod_u_d_type = diep;
3719 break;
3720 case AT_element_list:
3721 dip -> at_element_list = diep;
3722 dip -> short_element_list = 0;
3723 break;
3724 case AT_short_element_list:
3725 dip -> at_element_list = diep;
3726 dip -> short_element_list = 1;
3727 break;
3728 case AT_discr_value:
3729 dip -> at_discr_value = diep;
3730 break;
3731 case AT_string_length:
3732 dip -> at_string_length = diep;
3733 break;
3734 case AT_name:
3735 dip -> at_name = diep;
3736 break;
3737 case AT_comp_dir:
3738 /* For now, ignore any "hostname:" portion, since gdb doesn't
3739 know how to deal with it. (FIXME). */
3740 dip -> at_comp_dir = strrchr (diep, ':');
3741 if (dip -> at_comp_dir != NULL)
3742 {
3743 dip -> at_comp_dir++;
3744 }
3745 else
3746 {
3747 dip -> at_comp_dir = diep;
3748 }
3749 break;
3750 case AT_producer:
3751 dip -> at_producer = diep;
3752 break;
3753 case AT_start_scope:
3754 dip -> at_start_scope = target_to_host (diep, nbytes, GET_UNSIGNED,
3755 objfile);
3756 break;
3757 case AT_stride_size:
3758 dip -> at_stride_size = target_to_host (diep, nbytes, GET_UNSIGNED,
3759 objfile);
3760 break;
3761 case AT_src_info:
3762 dip -> at_src_info = target_to_host (diep, nbytes, GET_UNSIGNED,
3763 objfile);
3764 break;
3765 case AT_prototyped:
3766 dip -> at_prototyped = diep;
3767 break;
3768 default:
3769 /* Found an attribute that we are unprepared to handle. However
3770 it is specifically one of the design goals of DWARF that
3771 consumers should ignore unknown attributes. As long as the
3772 form is one that we recognize (so we know how to skip it),
3773 we can just ignore the unknown attribute. */
3774 break;
3775 }
3776 form = FORM_FROM_ATTR (attr);
3777 switch (form)
3778 {
3779 case FORM_DATA2:
3780 diep += 2;
3781 break;
3782 case FORM_DATA4:
3783 case FORM_REF:
3784 diep += 4;
3785 break;
3786 case FORM_DATA8:
3787 diep += 8;
3788 break;
3789 case FORM_ADDR:
3790 diep += TARGET_FT_POINTER_SIZE (objfile);
3791 break;
3792 case FORM_BLOCK2:
3793 diep += 2 + target_to_host (diep, nbytes, GET_UNSIGNED, objfile);
3794 break;
3795 case FORM_BLOCK4:
3796 diep += 4 + target_to_host (diep, nbytes, GET_UNSIGNED, objfile);
3797 break;
3798 case FORM_STRING:
3799 diep += strlen (diep) + 1;
3800 break;
3801 default:
3802 complain (&unknown_attribute_form, DIE_ID, DIE_NAME, form);
3803 diep = end;
3804 break;
3805 }
3806 }
3807 }
3808
3809 /*
3810
3811 LOCAL FUNCTION
3812
3813 target_to_host -- swap in target data to host
3814
3815 SYNOPSIS
3816
3817 target_to_host (char *from, int nbytes, int signextend,
3818 struct objfile *objfile)
3819
3820 DESCRIPTION
3821
3822 Given pointer to data in target format in FROM, a byte count for
3823 the size of the data in NBYTES, a flag indicating whether or not
3824 the data is signed in SIGNEXTEND, and a pointer to the current
3825 objfile in OBJFILE, convert the data to host format and return
3826 the converted value.
3827
3828 NOTES
3829
3830 FIXME: If we read data that is known to be signed, and expect to
3831 use it as signed data, then we need to explicitly sign extend the
3832 result until the bfd library is able to do this for us.
3833
3834 */
3835
3836 static unsigned long
3837 target_to_host (from, nbytes, signextend, objfile)
3838 char *from;
3839 int nbytes;
3840 int signextend; /* FIXME: Unused */
3841 struct objfile *objfile;
3842 {
3843 unsigned long rtnval;
3844
3845 switch (nbytes)
3846 {
3847 case 8:
3848 rtnval = bfd_get_64 (objfile -> obfd, (bfd_byte *) from);
3849 break;
3850 case 4:
3851 rtnval = bfd_get_32 (objfile -> obfd, (bfd_byte *) from);
3852 break;
3853 case 2:
3854 rtnval = bfd_get_16 (objfile -> obfd, (bfd_byte *) from);
3855 break;
3856 case 1:
3857 rtnval = bfd_get_8 (objfile -> obfd, (bfd_byte *) from);
3858 break;
3859 default:
3860 complain (&no_bfd_get_N, DIE_ID, DIE_NAME, nbytes);
3861 rtnval = 0;
3862 break;
3863 }
3864 return (rtnval);
3865 }
3866
3867 /*
3868
3869 LOCAL FUNCTION
3870
3871 attribute_size -- compute size of data for a DWARF attribute
3872
3873 SYNOPSIS
3874
3875 static int attribute_size (unsigned int attr)
3876
3877 DESCRIPTION
3878
3879 Given a DWARF attribute in ATTR, compute the size of the first
3880 piece of data associated with this attribute and return that
3881 size.
3882
3883 Returns -1 for unrecognized attributes.
3884
3885 */
3886
3887 static int
3888 attribute_size (attr)
3889 unsigned int attr;
3890 {
3891 int nbytes; /* Size of next data for this attribute */
3892 unsigned short form; /* Form of the attribute */
3893
3894 form = FORM_FROM_ATTR (attr);
3895 switch (form)
3896 {
3897 case FORM_STRING: /* A variable length field is next */
3898 nbytes = 0;
3899 break;
3900 case FORM_DATA2: /* Next 2 byte field is the data itself */
3901 case FORM_BLOCK2: /* Next 2 byte field is a block length */
3902 nbytes = 2;
3903 break;
3904 case FORM_DATA4: /* Next 4 byte field is the data itself */
3905 case FORM_BLOCK4: /* Next 4 byte field is a block length */
3906 case FORM_REF: /* Next 4 byte field is a DIE offset */
3907 nbytes = 4;
3908 break;
3909 case FORM_DATA8: /* Next 8 byte field is the data itself */
3910 nbytes = 8;
3911 break;
3912 case FORM_ADDR: /* Next field size is target sizeof(void *) */
3913 nbytes = TARGET_FT_POINTER_SIZE (objfile);
3914 break;
3915 default:
3916 complain (&unknown_attribute_form, DIE_ID, DIE_NAME, form);
3917 nbytes = -1;
3918 break;
3919 }
3920 return (nbytes);
3921 }
This page took 0.108271 seconds and 4 git commands to generate.