1 /* Read hp debug symbols and convert to internal format, for GDB.
2 Copyright 1993, 1996 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20 Written by the Center for Software Science at the University of Utah
21 and by Cygnus Support. */
25 #include "gdb_string.h"
26 #include "hp-symtab.h"
32 #include "complaints.h"
33 #include "gdb-stabs.h"
37 /* Private information attached to an objfile which we use to find
38 and internalize the HP C debug symbols within that objfile. */
40 struct hpread_symfile_info
42 /* The contents of each of the debug sections (there are 4 of them). */
48 /* We keep the size of the $VT$ section for range checking. */
51 /* Some routines still need to know the number of symbols in the
52 main debug sections ($LNTT$ and $GNTT$). */
53 unsigned int lntt_symcount
;
54 unsigned int gntt_symcount
;
56 /* To keep track of all the types we've processed. */
57 struct type
**type_vector
;
58 int type_vector_length
;
60 /* Keeps track of the beginning of a range of source lines. */
63 /* Some state variables we'll need. */
66 /* Keep track of the current function's address. We may need to look
67 up something based on this address. */
68 unsigned int current_function_value
;
71 /* Accessor macros to get at the fields. */
72 #define HPUX_SYMFILE_INFO(o) \
73 ((struct hpread_symfile_info *)((o)->sym_private))
74 #define GNTT(o) (HPUX_SYMFILE_INFO(o)->gntt)
75 #define LNTT(o) (HPUX_SYMFILE_INFO(o)->lntt)
76 #define SLT(o) (HPUX_SYMFILE_INFO(o)->slt)
77 #define VT(o) (HPUX_SYMFILE_INFO(o)->vt)
78 #define VT_SIZE(o) (HPUX_SYMFILE_INFO(o)->vt_size)
79 #define LNTT_SYMCOUNT(o) (HPUX_SYMFILE_INFO(o)->lntt_symcount)
80 #define GNTT_SYMCOUNT(o) (HPUX_SYMFILE_INFO(o)->gntt_symcount)
81 #define TYPE_VECTOR(o) (HPUX_SYMFILE_INFO(o)->type_vector)
82 #define TYPE_VECTOR_LENGTH(o) (HPUX_SYMFILE_INFO(o)->type_vector_length)
83 #define SL_INDEX(o) (HPUX_SYMFILE_INFO(o)->sl_index)
84 #define WITHIN_FUNCTION(o) (HPUX_SYMFILE_INFO(o)->within_function)
85 #define CURRENT_FUNCTION_VALUE(o) (HPUX_SYMFILE_INFO(o)->current_function_value)
87 /* Given the native debug symbol SYM, set NAMEP to the name associated
88 with the debug symbol. Note we may be called with a debug symbol which
89 has no associated name, in that case we return an empty string.
91 Also note we "know" that the name for any symbol is always in the
92 same place. Hence we don't have to conditionalize on the symbol type. */
93 #define SET_NAMESTRING(SYM, NAMEP, OBJFILE) \
94 if (! hpread_has_name ((SYM)->dblock.kind)) \
96 else if (((unsigned)(SYM)->dsfile.name) >= VT_SIZE (OBJFILE)) \
98 complain (&string_table_offset_complaint, (char *) symnum); \
102 *NAMEP = (SYM)->dsfile.name + VT (OBJFILE)
104 /* We put a pointer to this structure in the read_symtab_private field
109 /* The offset within the file symbol table of first local symbol for
114 /* Length (in bytes) of the section of the symbol table devoted to
115 this file's symbols (actually, the section bracketed may contain
116 more than just this file's symbols). If ldsymlen is 0, the only
117 reason for this thing's existence is the dependency list.
118 Nothing else will happen when it is read in. */
123 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
124 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
125 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
127 /* FIXME: Shouldn't this stuff be in a .h file somewhere? */
128 /* Nonzero means give verbose info on gdb action. */
129 extern int info_verbose
;
131 /* Complaints about the symbols we have encountered. */
132 extern struct complaint string_table_offset_complaint
;
133 extern struct complaint lbrac_unmatched_complaint
;
134 extern struct complaint lbrac_mismatch_complaint
;
137 void hpread_symfile_init
PARAMS ((struct objfile
*));
140 hpread_read_array_type
PARAMS ((dnttpointer
, union dnttentry
*, struct objfile
*));
142 static struct type
*hpread_alloc_type
143 PARAMS ((dnttpointer
, struct objfile
*));
145 static struct type
**hpread_lookup_type
146 PARAMS ((dnttpointer
, struct objfile
*));
148 static struct type
*hpread_read_enum_type
149 PARAMS ((dnttpointer
, union dnttentry
*, struct objfile
*));
151 static struct type
*hpread_read_set_type
152 PARAMS ((dnttpointer
, union dnttentry
*, struct objfile
*));
154 static struct type
*hpread_read_subrange_type
155 PARAMS ((dnttpointer
, union dnttentry
*, struct objfile
*));
157 static struct type
*hpread_read_struct_type
158 PARAMS ((dnttpointer
, union dnttentry
*, struct objfile
*));
160 void hpread_build_psymtabs
161 PARAMS ((struct objfile
*, struct section_offsets
*, int));
163 void hpread_symfile_finish
PARAMS ((struct objfile
*));
165 static struct partial_symtab
*hpread_start_psymtab
166 PARAMS ((struct objfile
*, struct section_offsets
*, char *, CORE_ADDR
, int,
167 struct partial_symbol
**, struct partial_symbol
**));
169 static struct partial_symtab
*hpread_end_psymtab
170 PARAMS ((struct partial_symtab
*, char **, int, int, CORE_ADDR
,
171 struct partial_symtab
**, int));
173 static struct symtab
*hpread_expand_symtab
174 PARAMS ((struct objfile
*, int, int, CORE_ADDR
, int,
175 struct section_offsets
*, char *));
177 static void hpread_process_one_debug_symbol
178 PARAMS ((union dnttentry
*, char *, struct section_offsets
*,
179 struct objfile
*, CORE_ADDR
, int, char *, int));
181 static sltpointer hpread_record_lines
182 PARAMS ((struct subfile
*, sltpointer
, sltpointer
,
183 struct objfile
*, CORE_ADDR
));
185 static struct type
*hpread_read_function_type
186 PARAMS ((dnttpointer
, union dnttentry
*, struct objfile
*));
188 static struct type
* hpread_type_lookup
189 PARAMS ((dnttpointer
, struct objfile
*));
191 static unsigned long hpread_get_depth
192 PARAMS ((sltpointer
, struct objfile
*));
194 static unsigned long hpread_get_line
195 PARAMS ((sltpointer
, struct objfile
*));
197 static CORE_ADDR hpread_get_location
198 PARAMS ((sltpointer
, struct objfile
*));
200 static int hpread_type_translate
PARAMS ((dnttpointer
));
201 static unsigned long hpread_get_textlow
PARAMS ((int, int, struct objfile
*));
202 static union dnttentry
*hpread_get_gntt
PARAMS ((int, struct objfile
*));
203 static union dnttentry
*hpread_get_lntt
PARAMS ((int, struct objfile
*));
204 static union sltentry
*hpread_get_slt
PARAMS ((int, struct objfile
*));
205 static void hpread_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
206 static void hpread_psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
207 static int hpread_has_name
PARAMS ((enum dntt_entry_type
));
210 /* Initialization for reading native HP C debug symbols from OBJFILE.
212 It's only purpose in life is to set up the symbol reader's private
213 per-objfile data structures, and read in the raw contents of the debug
214 sections (attaching pointers to the debug info into the private data
217 Since BFD doesn't know how to read debug symbols in a format-independent
218 way (and may never do so...), we have to do it ourselves. Note we may
219 be called on a file without native HP C debugging symbols.
220 FIXME, there should be a cleaner peephole into the BFD environment here. */
223 hpread_symfile_init (objfile
)
224 struct objfile
*objfile
;
226 asection
*vt_section
, *slt_section
, *lntt_section
, *gntt_section
;
228 /* Allocate struct to keep track of the symfile */
229 objfile
->sym_private
= (PTR
)
230 xmmalloc (objfile
->md
, sizeof (struct hpread_symfile_info
));
231 memset (objfile
->sym_private
, 0, sizeof (struct hpread_symfile_info
));
233 /* We haven't read in any types yet. */
234 TYPE_VECTOR (objfile
) = 0;
236 /* Read in data from the $GNTT$ subspace. */
237 gntt_section
= bfd_get_section_by_name (objfile
->obfd
, "$GNTT$");
242 = obstack_alloc (&objfile
->symbol_obstack
,
243 bfd_section_size (objfile
->obfd
, gntt_section
));
245 bfd_get_section_contents (objfile
->obfd
, gntt_section
, GNTT (objfile
),
246 0, bfd_section_size (objfile
->obfd
, gntt_section
));
248 GNTT_SYMCOUNT (objfile
)
249 = bfd_section_size (objfile
->obfd
, gntt_section
)
250 / sizeof (struct dntt_type_block
);
252 /* Read in data from the $LNTT$ subspace. Also keep track of the number
254 lntt_section
= bfd_get_section_by_name (objfile
->obfd
, "$LNTT$");
259 = obstack_alloc (&objfile
->symbol_obstack
,
260 bfd_section_size (objfile
->obfd
, lntt_section
));
262 bfd_get_section_contents (objfile
->obfd
, lntt_section
, LNTT (objfile
),
263 0, bfd_section_size (objfile
->obfd
, lntt_section
));
265 LNTT_SYMCOUNT (objfile
)
266 = bfd_section_size (objfile
->obfd
, lntt_section
)
267 / sizeof (struct dntt_type_block
);
269 /* Read in data from the $SLT$ subspace. $SLT$ contains information
270 on source line numbers. */
271 slt_section
= bfd_get_section_by_name (objfile
->obfd
, "$SLT$");
276 obstack_alloc (&objfile
->symbol_obstack
,
277 bfd_section_size (objfile
->obfd
, slt_section
));
279 bfd_get_section_contents (objfile
->obfd
, slt_section
, SLT (objfile
),
280 0, bfd_section_size (objfile
->obfd
, slt_section
));
282 /* Read in data from the $VT$ subspace. $VT$ contains things like
283 names and constants. Keep track of the number of symbols in the VT. */
284 vt_section
= bfd_get_section_by_name (objfile
->obfd
, "$VT$");
288 VT_SIZE (objfile
) = bfd_section_size (objfile
->obfd
, vt_section
);
291 (char *) obstack_alloc (&objfile
->symbol_obstack
,
294 bfd_get_section_contents (objfile
->obfd
, vt_section
, VT (objfile
),
295 0, VT_SIZE (objfile
));
298 /* Scan and build partial symbols for a symbol file.
300 The minimal symbol table (either SOM or HP a.out) has already been
301 read in; all we need to do is setup partial symbols based on the
302 native debugging information.
304 We assume hpread_symfile_init has been called to initialize the
305 symbol reader's private data structures.
307 SECTION_OFFSETS contains offsets relative to which the symbols in the
308 various sections are (depending where the sections were actually loaded).
309 MAINLINE is true if we are reading the main symbol
310 table (as opposed to a shared lib or dynamically loaded file). */
313 hpread_build_psymtabs (objfile
, section_offsets
, mainline
)
314 struct objfile
*objfile
;
315 struct section_offsets
*section_offsets
;
319 int past_first_source_file
= 0;
320 struct cleanup
*old_chain
;
322 int hp_symnum
, symcount
, i
;
324 union dnttentry
*dn_bufp
;
330 /* Current partial symtab */
331 struct partial_symtab
*pst
;
333 /* List of current psymtab's include files */
334 char **psymtab_include_list
;
335 int includes_allocated
;
338 /* Index within current psymtab dependency list */
339 struct partial_symtab
**dependency_list
;
340 int dependencies_used
, dependencies_allocated
;
342 /* Just in case the stabs reader left turds lying around. */
343 free_pending_blocks ();
344 make_cleanup (really_free_pendings
, 0);
346 pst
= (struct partial_symtab
*) 0;
348 /* We shouldn't use alloca, instead use malloc/free. Doing so avoids
349 a number of problems with cross compilation and creating useless holes
350 in the stack when we have to allocate new entries. FIXME. */
352 includes_allocated
= 30;
354 psymtab_include_list
= (char **) alloca (includes_allocated
*
357 dependencies_allocated
= 30;
358 dependencies_used
= 0;
360 (struct partial_symtab
**) alloca (dependencies_allocated
*
361 sizeof (struct partial_symtab
*));
363 old_chain
= make_cleanup (free_objfile
, objfile
);
365 last_source_file
= 0;
367 /* Make two passes, one ofr the GNTT symbols, the other for the
369 for (i
= 0; i
< 1; i
++)
371 int within_function
= 0;
374 symcount
= GNTT_SYMCOUNT (objfile
);
376 symcount
= LNTT_SYMCOUNT (objfile
);
378 for (hp_symnum
= 0; hp_symnum
< symcount
; hp_symnum
++)
382 dn_bufp
= hpread_get_gntt (hp_symnum
, objfile
);
384 dn_bufp
= hpread_get_lntt (hp_symnum
, objfile
);
386 if (dn_bufp
->dblock
.extension
)
389 /* Only handle things which are necessary for minimal symbols.
390 everything else is ignored. */
391 switch (dn_bufp
->dblock
.kind
)
393 case DNTT_TYPE_SRCFILE
:
395 /* A source file of some kind. Note this may simply
396 be an included file. */
397 SET_NAMESTRING (dn_bufp
, &namestring
, objfile
);
399 /* Check if this is the source file we are already working
401 if (pst
&& !strcmp (namestring
, pst
->filename
))
404 /* Check if this is an include file, if so check if we have
405 already seen it. Add it to the include list */
406 p
= strrchr (namestring
, '.');
407 if (!strcmp (p
, ".h"))
412 for (j
= 0; j
< includes_used
; j
++)
413 if (!strcmp (namestring
, psymtab_include_list
[j
]))
421 /* Add it to the list of includes seen so far and
422 allocate more include space if necessary. */
423 psymtab_include_list
[includes_used
++] = namestring
;
424 if (includes_used
>= includes_allocated
)
426 char **orig
= psymtab_include_list
;
428 psymtab_include_list
= (char **)
429 alloca ((includes_allocated
*= 2) *
431 memcpy ((PTR
) psymtab_include_list
, (PTR
) orig
,
432 includes_used
* sizeof (char *));
442 pst
->filename
= (char *)
443 obstack_alloc (&pst
->objfile
->psymbol_obstack
,
444 strlen (namestring
) + 1);
445 strcpy (pst
->filename
, namestring
);
452 /* This is a bonafide new source file.
453 End the current partial symtab and start a new one. */
455 if (pst
&& past_first_source_file
)
457 hpread_end_psymtab (pst
, psymtab_include_list
,
460 * sizeof (struct dntt_type_block
)),
462 dependency_list
, dependencies_used
);
463 pst
= (struct partial_symtab
*) 0;
465 dependencies_used
= 0;
468 past_first_source_file
= 1;
470 valu
= hpread_get_textlow (i
, hp_symnum
, objfile
);
471 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
472 pst
= hpread_start_psymtab (objfile
, section_offsets
,
475 * sizeof (struct dntt_type_block
)),
476 objfile
->global_psymbols
.next
,
477 objfile
->static_psymbols
.next
);
483 case DNTT_TYPE_MODULE
:
484 /* A source file. It's still unclear to me what the
485 real difference between a DNTT_TYPE_SRCFILE and DNTT_TYPE_MODULE
486 is supposed to be. */
487 SET_NAMESTRING (dn_bufp
, &namestring
, objfile
);
488 valu
= hpread_get_textlow (i
, hp_symnum
, objfile
);
489 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
492 pst
= hpread_start_psymtab (objfile
, section_offsets
,
495 * sizeof (struct dntt_type_block
)),
496 objfile
->global_psymbols
.next
,
497 objfile
->static_psymbols
.next
);
502 case DNTT_TYPE_FUNCTION
:
503 case DNTT_TYPE_ENTRY
:
504 /* The beginning of a function. DNTT_TYPE_ENTRY may also denote
505 a secondary entry point. */
506 valu
= dn_bufp
->dfunc
.hiaddr
+ ANOFFSET (section_offsets
,
510 valu
= dn_bufp
->dfunc
.lowaddr
+
511 ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
512 SET_NAMESTRING (dn_bufp
, &namestring
, objfile
);
513 add_psymbol_to_list (namestring
, strlen (namestring
),
514 VAR_NAMESPACE
, LOC_BLOCK
,
515 &objfile
->static_psymbols
, valu
,
516 0, language_unknown
, objfile
);
519 case DNTT_TYPE_BEGIN
:
521 /* Scope block begin/end. We only care about function
522 and file blocks right now. */
523 if (dn_bufp
->dend
.endkind
== DNTT_TYPE_MODULE
)
525 hpread_end_psymtab (pst
, psymtab_include_list
, includes_used
,
527 * sizeof (struct dntt_type_block
)),
529 dependency_list
, dependencies_used
);
530 pst
= (struct partial_symtab
*) 0;
532 dependencies_used
= 0;
535 if (dn_bufp
->dend
.endkind
== DNTT_TYPE_FUNCTION
)
540 case DNTT_TYPE_TYPEDEF
:
541 case DNTT_TYPE_TAGDEF
:
543 /* Variables, typedefs an the like. */
544 enum address_class storage
;
545 namespace_enum
namespace;
547 /* Don't add locals to the partial symbol table. */
549 && (dn_bufp
->dblock
.kind
== DNTT_TYPE_SVAR
550 || dn_bufp
->dblock
.kind
== DNTT_TYPE_DVAR
))
553 /* TAGDEFs go into the structure namespace. */
554 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_TAGDEF
)
555 namespace = STRUCT_NAMESPACE
;
557 namespace = VAR_NAMESPACE
;
559 /* What kind of "storage" does this use? */
560 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_SVAR
)
561 storage
= LOC_STATIC
;
562 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_DVAR
563 && dn_bufp
->ddvar
.regvar
)
564 storage
= LOC_REGISTER
;
565 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_DVAR
)
570 SET_NAMESTRING (dn_bufp
, &namestring
, objfile
);
573 pst
= hpread_start_psymtab (objfile
, section_offsets
,
576 * sizeof (struct dntt_type_block
)),
577 objfile
->global_psymbols
.next
,
578 objfile
->static_psymbols
.next
);
580 if (dn_bufp
->dsvar
.global
)
582 add_psymbol_to_list (namestring
, strlen (namestring
),
584 &objfile
->global_psymbols
,
585 dn_bufp
->dsvar
.location
,
586 0, language_unknown
, objfile
);
590 add_psymbol_to_list (namestring
, strlen (namestring
),
592 &objfile
->static_psymbols
,
593 dn_bufp
->dsvar
.location
,
594 0, language_unknown
, objfile
);
598 case DNTT_TYPE_MEMENUM
:
599 case DNTT_TYPE_CONST
:
600 /* Constants and members of enumerated types. */
601 SET_NAMESTRING (dn_bufp
, &namestring
, objfile
);
604 pst
= hpread_start_psymtab (objfile
, section_offsets
,
607 * sizeof (struct dntt_type_block
)),
608 objfile
->global_psymbols
.next
,
609 objfile
->static_psymbols
.next
);
611 add_psymbol_to_list (namestring
, strlen (namestring
),
612 VAR_NAMESPACE
, LOC_CONST
,
613 &objfile
->static_psymbols
, 0,
614 0, language_unknown
, objfile
);
622 /* End any pending partial symbol table. */
625 hpread_end_psymtab (pst
, psymtab_include_list
, includes_used
,
626 hp_symnum
* sizeof (struct dntt_type_block
),
627 0, dependency_list
, dependencies_used
);
630 discard_cleanups (old_chain
);
633 /* Perform any local cleanups required when we are done with a particular
634 objfile. I.E, we are in the process of discarding all symbol information
635 for an objfile, freeing up all memory held for it, and unlinking the
636 objfile struct from the global list of known objfiles. */
639 hpread_symfile_finish (objfile
)
640 struct objfile
*objfile
;
642 if (objfile
->sym_private
!= NULL
)
644 mfree (objfile
->md
, objfile
->sym_private
);
649 /* The remaining functions are all for internal use only. */
651 /* Various small functions to get entries in the debug symbol sections. */
653 static union dnttentry
*
654 hpread_get_lntt (index
, objfile
)
656 struct objfile
*objfile
;
658 return (union dnttentry
*)
659 &(LNTT (objfile
)[(index
* sizeof (struct dntt_type_block
))]);
662 static union dnttentry
*
663 hpread_get_gntt (index
, objfile
)
665 struct objfile
*objfile
;
667 return (union dnttentry
*)
668 &(GNTT (objfile
)[(index
* sizeof (struct dntt_type_block
))]);
671 static union sltentry
*
672 hpread_get_slt (index
, objfile
)
674 struct objfile
*objfile
;
676 return (union sltentry
*)&(SLT (objfile
)[index
* sizeof (union sltentry
)]);
679 /* Get the low address associated with some symbol (typically the start
680 of a particular source file or module). Since that information is not
681 stored as part of the DNTT_TYPE_MODULE or DNTT_TYPE_SRCFILE symbol we must infer it from
682 the existance of DNTT_TYPE_FUNCTION symbols. */
685 hpread_get_textlow (global
, index
, objfile
)
688 struct objfile
*objfile
;
690 union dnttentry
*dn_bufp
;
691 struct minimal_symbol
*msymbol
;
693 /* Look for a DNTT_TYPE_FUNCTION symbol. */
697 dn_bufp
= hpread_get_gntt (index
++, objfile
);
699 dn_bufp
= hpread_get_lntt (index
++, objfile
);
700 } while (dn_bufp
->dblock
.kind
!= DNTT_TYPE_FUNCTION
701 && dn_bufp
->dblock
.kind
!= DNTT_TYPE_END
);
703 /* Avoid going past a DNTT_TYPE_END when looking for a DNTT_TYPE_FUNCTION. This
704 might happen when a sourcefile has no functions. */
705 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_END
)
708 /* The minimal symbols are typically more accurate for some reason. */
709 msymbol
= lookup_minimal_symbol (dn_bufp
->dfunc
.name
+ VT (objfile
), NULL
,
712 return SYMBOL_VALUE_ADDRESS (msymbol
);
714 return dn_bufp
->dfunc
.lowaddr
;
717 /* Get the nesting depth for the source line identified by INDEX. */
720 hpread_get_depth (index
, objfile
)
722 struct objfile
*objfile
;
724 union sltentry
*sl_bufp
;
726 sl_bufp
= hpread_get_slt (index
, objfile
);
727 return sl_bufp
->sspec
.backptr
.dnttp
.index
;
730 /* Get the source line number the the line identified by INDEX. */
733 hpread_get_line (index
, objfile
)
735 struct objfile
*objfile
;
737 union sltentry
*sl_bufp
;
739 sl_bufp
= hpread_get_slt (index
, objfile
);
740 return sl_bufp
->snorm
.line
;
744 hpread_get_location (index
, objfile
)
746 struct objfile
*objfile
;
748 union sltentry
*sl_bufp
;
751 /* code location of special sltentrys is determined from context */
752 sl_bufp
= hpread_get_slt (index
, objfile
);
754 if (sl_bufp
->snorm
.sltdesc
== SLT_END
)
756 /* find previous normal sltentry and get address */
757 for (i
= 0; ((sl_bufp
->snorm
.sltdesc
!= SLT_NORMAL
) &&
758 (sl_bufp
->snorm
.sltdesc
!= SLT_EXIT
)); i
++)
759 sl_bufp
= hpread_get_slt (index
- i
, objfile
);
760 return sl_bufp
->snorm
.address
;
763 /* find next normal sltentry and get address */
764 for (i
= 0; ((sl_bufp
->snorm
.sltdesc
!= SLT_NORMAL
) &&
765 (sl_bufp
->snorm
.sltdesc
!= SLT_EXIT
)); i
++)
766 sl_bufp
= hpread_get_slt (index
+ i
, objfile
);
767 return sl_bufp
->snorm
.address
;
771 /* Return 1 if an HP debug symbol of type KIND has a name associated with
772 it, else return 0. */
775 hpread_has_name (kind
)
776 enum dntt_entry_type kind
;
780 case DNTT_TYPE_SRCFILE
:
781 case DNTT_TYPE_MODULE
:
782 case DNTT_TYPE_FUNCTION
:
783 case DNTT_TYPE_ENTRY
:
784 case DNTT_TYPE_IMPORT
:
785 case DNTT_TYPE_LABEL
:
786 case DNTT_TYPE_FPARAM
:
789 case DNTT_TYPE_CONST
:
790 case DNTT_TYPE_TYPEDEF
:
791 case DNTT_TYPE_TAGDEF
:
792 case DNTT_TYPE_MEMENUM
:
793 case DNTT_TYPE_FIELD
:
797 case DNTT_TYPE_BEGIN
:
800 case DNTT_TYPE_COMMON
:
801 case DNTT_TYPE_POINTER
:
804 case DNTT_TYPE_SUBRANGE
:
805 case DNTT_TYPE_ARRAY
:
806 case DNTT_TYPE_STRUCT
:
807 case DNTT_TYPE_UNION
:
808 case DNTT_TYPE_VARIANT
:
810 case DNTT_TYPE_FUNCTYPE
:
811 case DNTT_TYPE_COBSTRUCT
:
813 case DNTT_TYPE_MACRO
:
819 /* Allocate and partially fill a partial symtab. It will be
820 completely filled at the end of the symbol list.
822 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
823 is the address relative to which its symbols are (incremental) or 0
826 static struct partial_symtab
*
827 hpread_start_psymtab (objfile
, section_offsets
,
828 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
829 struct objfile
*objfile
;
830 struct section_offsets
*section_offsets
;
834 struct partial_symbol
**global_syms
;
835 struct partial_symbol
**static_syms
;
837 struct partial_symtab
*result
=
838 start_psymtab_common (objfile
, section_offsets
,
839 filename
, textlow
, global_syms
, static_syms
);
841 result
->read_symtab_private
= (char *)
842 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct symloc
));
843 LDSYMOFF (result
) = ldsymoff
;
844 result
->read_symtab
= hpread_psymtab_to_symtab
;
850 /* Close off the current usage of PST.
851 Returns PST or NULL if the partial symtab was empty and thrown away.
853 FIXME: List variables and peculiarities of same. */
855 static struct partial_symtab
*
856 hpread_end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
857 capping_text
, dependency_list
, number_dependencies
)
858 struct partial_symtab
*pst
;
861 int capping_symbol_offset
;
862 CORE_ADDR capping_text
;
863 struct partial_symtab
**dependency_list
;
864 int number_dependencies
;
867 struct objfile
*objfile
= pst
-> objfile
;
869 if (capping_symbol_offset
!= -1)
870 LDSYMLEN(pst
) = capping_symbol_offset
- LDSYMOFF(pst
);
871 pst
->texthigh
= capping_text
;
874 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
876 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
878 pst
->number_of_dependencies
= number_dependencies
;
879 if (number_dependencies
)
881 pst
->dependencies
= (struct partial_symtab
**)
882 obstack_alloc (&objfile
->psymbol_obstack
,
883 number_dependencies
* sizeof (struct partial_symtab
*));
884 memcpy (pst
->dependencies
, dependency_list
,
885 number_dependencies
* sizeof (struct partial_symtab
*));
888 pst
->dependencies
= 0;
890 for (i
= 0; i
< num_includes
; i
++)
892 struct partial_symtab
*subpst
=
893 allocate_psymtab (include_list
[i
], objfile
);
895 subpst
->section_offsets
= pst
->section_offsets
;
896 subpst
->read_symtab_private
=
897 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
898 sizeof (struct symloc
));
902 subpst
->texthigh
= 0;
904 /* We could save slight bits of space by only making one of these,
905 shared by the entire set of include files. FIXME-someday. */
906 subpst
->dependencies
= (struct partial_symtab
**)
907 obstack_alloc (&objfile
->psymbol_obstack
,
908 sizeof (struct partial_symtab
*));
909 subpst
->dependencies
[0] = pst
;
910 subpst
->number_of_dependencies
= 1;
912 subpst
->globals_offset
=
913 subpst
->n_global_syms
=
914 subpst
->statics_offset
=
915 subpst
->n_static_syms
= 0;
919 subpst
->read_symtab
= pst
->read_symtab
;
922 sort_pst_symbols (pst
);
924 /* If there is already a psymtab or symtab for a file of this name, remove it.
925 (If there is a symtab, more drastic things also happen.)
926 This happens in VxWorks. */
927 free_named_symtabs (pst
->filename
);
929 if (num_includes
== 0
930 && number_dependencies
== 0
931 && pst
->n_global_syms
== 0
932 && pst
->n_static_syms
== 0)
934 /* Throw away this psymtab, it's empty. We can't deallocate it, since
935 it is on the obstack, but we can forget to chain it on the list. */
936 /* Empty psymtabs happen as a result of header files which don't have
937 any symbols in them. There can be a lot of them. But this check
938 is wrong, in that a psymtab with N_SLINE entries but nothing else
939 is not empty, but we don't realize that. Fixing that without slowing
940 things down might be tricky. */
941 struct partial_symtab
*prev_pst
;
943 /* First, snip it out of the psymtab chain */
945 if (pst
->objfile
->psymtabs
== pst
)
946 pst
->objfile
->psymtabs
= pst
->next
;
948 for (prev_pst
= pst
->objfile
->psymtabs
; prev_pst
; prev_pst
= pst
->next
)
949 if (prev_pst
->next
== pst
)
950 prev_pst
->next
= pst
->next
;
952 /* Next, put it on a free list for recycling */
954 pst
->next
= pst
->objfile
->free_psymtabs
;
955 pst
->objfile
->free_psymtabs
= pst
;
957 /* Indicate that psymtab was thrown away. */
958 pst
= (struct partial_symtab
*)NULL
;
963 /* Do the dirty work of reading in the full symbol from a partial symbol
967 hpread_psymtab_to_symtab_1 (pst
)
968 struct partial_symtab
*pst
;
970 struct cleanup
*old_chain
;
973 /* Get out quick if passed junk. */
977 /* Complain if we've already read in this symbol table. */
980 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
985 /* Read in all partial symtabs on which this one is dependent */
986 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
987 if (!pst
->dependencies
[i
]->readin
)
989 /* Inform about additional files that need to be read in. */
992 fputs_filtered (" ", stdout
);
994 fputs_filtered ("and ", stdout
);
996 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
997 wrap_here (""); /* Flush output */
1000 hpread_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1003 /* If it's real... */
1006 /* Init stuff necessary for reading in symbols */
1008 old_chain
= make_cleanup (really_free_pendings
, 0);
1011 hpread_expand_symtab (pst
->objfile
, LDSYMOFF (pst
), LDSYMLEN (pst
),
1012 pst
->textlow
, pst
->texthigh
- pst
->textlow
,
1013 pst
->section_offsets
, pst
->filename
);
1014 sort_symtab_syms (pst
->symtab
);
1016 do_cleanups (old_chain
);
1022 /* Read in all of the symbols for a given psymtab for real.
1023 Be verbose about it if the user wants that. */
1026 hpread_psymtab_to_symtab (pst
)
1027 struct partial_symtab
*pst
;
1029 /* Get out quick if given junk. */
1036 fprintf (stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1041 if (LDSYMLEN (pst
) || pst
->number_of_dependencies
)
1043 /* Print the message now, before reading the string table,
1044 to avoid disconcerting pauses. */
1047 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1051 hpread_psymtab_to_symtab_1 (pst
);
1053 /* Match with global symbols. This only needs to be done once,
1054 after all of the symtabs and dependencies have been read in. */
1055 scan_file_globals (pst
->objfile
);
1057 /* Finish up the debug error message. */
1059 printf_filtered ("done.\n");
1062 /* Read in a defined section of a specific object file's symbols.
1064 DESC is the file descriptor for the file, positioned at the
1065 beginning of the symtab
1066 SYM_OFFSET is the offset within the file of
1067 the beginning of the symbols we want to read
1068 SYM_SIZE is the size of the symbol info to read in.
1069 TEXT_OFFSET is the beginning of the text segment we are reading symbols for
1070 TEXT_SIZE is the size of the text segment read in.
1071 SECTION_OFFSETS are the relocation offsets which get added to each symbol. */
1073 static struct symtab
*
1074 hpread_expand_symtab (objfile
, sym_offset
, sym_size
, text_offset
, text_size
,
1075 section_offsets
, filename
)
1076 struct objfile
*objfile
;
1079 CORE_ADDR text_offset
;
1081 struct section_offsets
*section_offsets
;
1085 union dnttentry
*dn_bufp
;
1086 unsigned max_symnum
;
1088 int sym_index
= sym_offset
/ sizeof (struct dntt_type_block
);
1090 current_objfile
= objfile
;
1093 last_source_file
= 0;
1095 dn_bufp
= hpread_get_lntt (sym_index
, objfile
);
1096 if (!((dn_bufp
->dblock
.kind
== (unsigned char) DNTT_TYPE_SRCFILE
) ||
1097 (dn_bufp
->dblock
.kind
== (unsigned char) DNTT_TYPE_MODULE
)))
1099 start_symtab ("globals", NULL
, 0);
1100 record_debugformat ("HP");
1103 max_symnum
= sym_size
/ sizeof (struct dntt_type_block
);
1105 /* Read in and process each debug symbol within the specified range. */
1107 symnum
< max_symnum
;
1110 QUIT
; /* Allow this to be interruptable */
1111 dn_bufp
= hpread_get_lntt (sym_index
+ symnum
, objfile
);
1113 if (dn_bufp
->dblock
.extension
)
1116 /* Yow! We call SET_NAMESTRING on things without names! */
1117 SET_NAMESTRING (dn_bufp
, &namestring
, objfile
);
1119 hpread_process_one_debug_symbol (dn_bufp
, namestring
, section_offsets
,
1120 objfile
, text_offset
, text_size
,
1121 filename
, symnum
+ sym_index
);
1124 current_objfile
= NULL
;
1126 return end_symtab (text_offset
+ text_size
, objfile
, 0);
1130 /* Convert basic types from HP debug format into GDB internal format. */
1133 hpread_type_translate (typep
)
1136 if (!typep
.dntti
.immediate
)
1139 switch (typep
.dntti
.type
)
1141 case HP_TYPE_BOOLEAN
:
1142 case HP_TYPE_BOOLEAN_S300_COMPAT
:
1143 case HP_TYPE_BOOLEAN_VAX_COMPAT
:
1145 /* Ugh. No way to distinguish between signed and unsigned chars. */
1147 case HP_TYPE_WIDE_CHAR
:
1150 if (typep
.dntti
.bitlength
<= 8)
1152 if (typep
.dntti
.bitlength
<= 16)
1154 if (typep
.dntti
.bitlength
<= 32)
1156 return FT_LONG_LONG
;
1159 case HP_TYPE_UNSIGNED_LONG
:
1160 if (typep
.dntti
.bitlength
<= 8)
1161 return FT_UNSIGNED_CHAR
;
1162 if (typep
.dntti
.bitlength
<= 16)
1163 return FT_UNSIGNED_SHORT
;
1164 if (typep
.dntti
.bitlength
<= 32)
1165 return FT_UNSIGNED_LONG
;
1166 return FT_UNSIGNED_LONG_LONG
;
1167 case HP_TYPE_UNSIGNED_INT
:
1168 if (typep
.dntti
.bitlength
<= 8)
1169 return FT_UNSIGNED_CHAR
;
1170 if (typep
.dntti
.bitlength
<= 16)
1171 return FT_UNSIGNED_SHORT
;
1172 if (typep
.dntti
.bitlength
<= 32)
1173 return FT_UNSIGNED_INTEGER
;
1174 return FT_UNSIGNED_LONG_LONG
;
1176 case HP_TYPE_REAL_3000
:
1177 case HP_TYPE_DOUBLE
:
1178 if (typep
.dntti
.bitlength
== 64)
1179 return FT_DBL_PREC_FLOAT
;
1180 if (typep
.dntti
.bitlength
== 128)
1181 return FT_EXT_PREC_FLOAT
;
1183 case HP_TYPE_COMPLEX
:
1184 case HP_TYPE_COMPLEXS3000
:
1185 if (typep
.dntti
.bitlength
== 128)
1186 return FT_DBL_PREC_COMPLEX
;
1187 if (typep
.dntti
.bitlength
== 192)
1188 return FT_EXT_PREC_COMPLEX
;
1190 case HP_TYPE_STRING200
:
1191 case HP_TYPE_LONGSTRING200
:
1192 case HP_TYPE_FTN_STRING_SPEC
:
1193 case HP_TYPE_MOD_STRING_SPEC
:
1194 case HP_TYPE_MOD_STRING_3000
:
1195 case HP_TYPE_FTN_STRING_S300_COMPAT
:
1196 case HP_TYPE_FTN_STRING_VAX_COMPAT
:
1203 /* Return the type associated with the index found in HP_TYPE. */
1205 static struct type
**
1206 hpread_lookup_type (hp_type
, objfile
)
1207 dnttpointer hp_type
;
1208 struct objfile
*objfile
;
1211 int index
= hp_type
.dnttp
.index
;
1213 if (hp_type
.dntti
.immediate
)
1216 if (index
< LNTT_SYMCOUNT (objfile
))
1218 if (index
>= TYPE_VECTOR_LENGTH (objfile
))
1220 old_len
= TYPE_VECTOR_LENGTH (objfile
);
1223 TYPE_VECTOR_LENGTH (objfile
) = 100;
1224 TYPE_VECTOR (objfile
) = (struct type
**)
1225 xmmalloc (objfile
-> md
,
1226 TYPE_VECTOR_LENGTH (objfile
) * sizeof (struct type
*));
1228 while (index
>= TYPE_VECTOR_LENGTH (objfile
))
1229 TYPE_VECTOR_LENGTH (objfile
) *= 2;
1230 TYPE_VECTOR (objfile
) = (struct type
**)
1231 xmrealloc (objfile
-> md
,
1232 (char *) TYPE_VECTOR (objfile
),
1233 (TYPE_VECTOR_LENGTH (objfile
) * sizeof (struct type
*)));
1234 memset (&TYPE_VECTOR (objfile
)[old_len
], 0,
1235 (TYPE_VECTOR_LENGTH (objfile
) - old_len
) *
1236 sizeof (struct type
*));
1238 return &TYPE_VECTOR (objfile
)[index
];
1244 /* Possibly allocate a GDB internal type so we can internalize HP_TYPE.
1245 Note we'll just return the address of a GDB internal type if we already
1246 have it lying around. */
1248 static struct type
*
1249 hpread_alloc_type (hp_type
, objfile
)
1250 dnttpointer hp_type
;
1251 struct objfile
*objfile
;
1253 struct type
**type_addr
;
1255 type_addr
= hpread_lookup_type (hp_type
, objfile
);
1256 if (*type_addr
== 0)
1257 *type_addr
= alloc_type (objfile
);
1259 TYPE_CPLUS_SPECIFIC (*type_addr
)
1260 = (struct cplus_struct_type
*) &cplus_struct_default
;
1264 /* Read a native enumerated type and return it in GDB internal form. */
1266 static struct type
*
1267 hpread_read_enum_type (hp_type
, dn_bufp
, objfile
)
1268 dnttpointer hp_type
;
1269 union dnttentry
*dn_bufp
;
1270 struct objfile
*objfile
;
1273 struct pending
**symlist
, *osyms
, *syms
;
1274 int o_nsyms
, nsyms
= 0;
1276 union dnttentry
*memp
;
1281 type
= hpread_alloc_type (hp_type
, objfile
);
1282 TYPE_LENGTH (type
) = 4;
1284 symlist
= &file_symbols
;
1286 o_nsyms
= osyms
? osyms
->nsyms
: 0;
1288 /* Get a name for each member and add it to our list of members. */
1289 mem
= dn_bufp
->denum
.firstmem
;
1290 while (mem
.dnttp
.extension
&& mem
.word
!= DNTTNIL
)
1292 memp
= hpread_get_lntt (mem
.dnttp
.index
, objfile
);
1294 name
= VT (objfile
) + memp
->dmember
.name
;
1295 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1296 sizeof (struct symbol
));
1297 memset (sym
, 0, sizeof (struct symbol
));
1298 SYMBOL_NAME (sym
) = obsavestring (name
, strlen (name
),
1299 &objfile
->symbol_obstack
);
1300 SYMBOL_CLASS (sym
) = LOC_CONST
;
1301 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1302 SYMBOL_VALUE (sym
) = memp
->dmember
.value
;
1303 add_symbol_to_list (sym
, symlist
);
1305 mem
= memp
->dmember
.nextmem
;
1308 /* Now that we know more about the enum, fill in more info. */
1309 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
1310 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
1311 TYPE_NFIELDS (type
) = nsyms
;
1312 TYPE_FIELDS (type
) = (struct field
*)
1313 obstack_alloc (&objfile
->type_obstack
, sizeof (struct field
) * nsyms
);
1315 /* Find the symbols for the members and put them into the type.
1316 The symbols can be found in the symlist that we put them on
1317 to cause them to be defined. osyms contains the old value
1318 of that symlist; everything up to there was defined by us.
1320 Note that we preserve the order of the enum constants, so
1321 that in something like "enum {FOO, LAST_THING=FOO}" we print
1322 FOO, not LAST_THING. */
1323 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
1328 for (; j
< syms
->nsyms
; j
++, n
++)
1330 struct symbol
*xsym
= syms
->symbol
[j
];
1331 SYMBOL_TYPE (xsym
) = type
;
1332 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
1333 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (xsym
);
1334 TYPE_FIELD_BITSIZE (type
, n
) = 0;
1343 /* Read and internalize a native function debug symbol. */
1345 static struct type
*
1346 hpread_read_function_type (hp_type
, dn_bufp
, objfile
)
1347 dnttpointer hp_type
;
1348 union dnttentry
*dn_bufp
;
1349 struct objfile
*objfile
;
1351 struct type
*type
, *type1
;
1352 struct pending
**symlist
, *osyms
, *syms
;
1353 int o_nsyms
, nsyms
= 0;
1355 union dnttentry
*paramp
;
1360 param
= dn_bufp
->dfunc
.firstparam
;
1362 /* See if we've already read in this type. */
1363 type
= hpread_alloc_type (hp_type
, objfile
);
1364 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1367 /* Nope, so read it in and store it away. */
1368 type1
= lookup_function_type (hpread_type_lookup (dn_bufp
->dfunc
.retval
,
1370 memcpy ((char *) type
, (char *) type1
, sizeof (struct type
));
1372 symlist
= &local_symbols
;
1374 o_nsyms
= osyms
? osyms
->nsyms
: 0;
1376 /* Now examine each parameter noting its type, location, and a
1377 wealth of other information. */
1378 while (param
.word
&& param
.word
!= DNTTNIL
)
1380 paramp
= hpread_get_lntt (param
.dnttp
.index
, objfile
);
1382 param
= paramp
->dfparam
.nextparam
;
1385 name
= VT (objfile
) + paramp
->dfparam
.name
;
1386 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1387 sizeof (struct symbol
));
1388 (void) memset (sym
, 0, sizeof (struct symbol
));
1389 SYMBOL_NAME (sym
) = obsavestring (name
, strlen (name
),
1390 &objfile
->symbol_obstack
);
1392 /* Figure out where it lives. */
1393 if (paramp
->dfparam
.regparam
)
1394 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
1395 else if (paramp
->dfparam
.indirect
)
1396 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
1398 SYMBOL_CLASS (sym
) = LOC_ARG
;
1399 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1400 if (paramp
->dfparam
.copyparam
)
1402 SYMBOL_VALUE (sym
) = paramp
->dfparam
.location
;
1403 #ifdef HPREAD_ADJUST_STACK_ADDRESS
1405 += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile
));
1407 /* This is likely a pass-by-invisible reference parameter,
1408 Hack on the symbol class to make GDB happy. */
1409 SYMBOL_CLASS (sym
) = LOC_REGPARM_ADDR
;
1412 SYMBOL_VALUE (sym
) = paramp
->dfparam
.location
;
1415 SYMBOL_TYPE (sym
) = hpread_type_lookup (paramp
->dfparam
.type
, objfile
);
1417 /* Add it to the list. */
1418 add_symbol_to_list (sym
, symlist
);
1421 /* Note how many parameters we found. */
1422 TYPE_NFIELDS (type
) = nsyms
;
1423 TYPE_FIELDS (type
) = (struct field
*)
1424 obstack_alloc (&objfile
->type_obstack
,
1425 sizeof (struct field
) * nsyms
);
1427 /* Find the symbols for the values and put them into the type.
1428 The symbols can be found in the symlist that we put them on
1429 to cause them to be defined. osyms contains the old value
1430 of that symlist; everything up to there was defined by us. */
1431 /* Note that we preserve the order of the parameters, so
1432 that in something like "enum {FOO, LAST_THING=FOO}" we print
1433 FOO, not LAST_THING. */
1434 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
1439 for (; j
< syms
->nsyms
; j
++, n
++)
1441 struct symbol
*xsym
= syms
->symbol
[j
];
1442 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
1443 TYPE_FIELD_TYPE (type
, n
) = SYMBOL_TYPE (xsym
);
1444 TYPE_FIELD_BITPOS (type
, n
) = n
;
1445 TYPE_FIELD_BITSIZE (type
, n
) = 0;
1453 /* Read in and internalize a structure definition. */
1455 static struct type
*
1456 hpread_read_struct_type (hp_type
, dn_bufp
, objfile
)
1457 dnttpointer hp_type
;
1458 union dnttentry
*dn_bufp
;
1459 struct objfile
*objfile
;
1463 struct nextfield
*next
;
1468 struct nextfield
*list
= 0;
1469 struct nextfield
*new;
1472 union dnttentry
*fieldp
;
1474 /* Is it something we've already dealt with? */
1475 type
= hpread_alloc_type (hp_type
, objfile
);
1476 if ((TYPE_CODE (type
) == TYPE_CODE_STRUCT
) ||
1477 (TYPE_CODE (type
) == TYPE_CODE_UNION
))
1480 /* Get the basic type correct. */
1481 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_STRUCT
)
1483 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1484 TYPE_LENGTH (type
) = dn_bufp
->dstruct
.bitlength
/ 8;
1486 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_UNION
)
1488 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1489 TYPE_LENGTH (type
) = dn_bufp
->dunion
.bitlength
/ 8;
1495 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
1497 /* Read in and internalize all the fields. */
1498 field
= dn_bufp
->dstruct
.firstfield
;
1499 while (field
.word
!= DNTTNIL
&& field
.dnttp
.extension
)
1501 fieldp
= hpread_get_lntt (field
.dnttp
.index
, objfile
);
1503 /* Get space to record the next field's data. */
1504 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1508 list
->field
.name
= VT (objfile
) + fieldp
->dfield
.name
;
1509 list
->field
.bitpos
= fieldp
->dfield
.bitoffset
;
1510 if (fieldp
->dfield
.bitlength
% 8)
1511 list
->field
.bitsize
= fieldp
->dfield
.bitlength
;
1513 list
->field
.bitsize
= 0;
1515 field
= fieldp
->dfield
.nextfield
;
1516 list
->field
.type
= hpread_type_lookup (fieldp
->dfield
.type
, objfile
);
1519 TYPE_NFIELDS (type
) = nfields
;
1520 TYPE_FIELDS (type
) = (struct field
*)
1521 obstack_alloc (&objfile
->type_obstack
, sizeof (struct field
) * nfields
);
1523 /* Copy the saved-up fields into the field vector. */
1524 for (n
= nfields
; list
; list
= list
->next
)
1527 TYPE_FIELD (type
, n
) = list
->field
;
1532 /* Read in and internalize a set debug symbol. */
1534 static struct type
*
1535 hpread_read_set_type (hp_type
, dn_bufp
, objfile
)
1536 dnttpointer hp_type
;
1537 union dnttentry
*dn_bufp
;
1538 struct objfile
*objfile
;
1542 /* See if it's something we've already deal with. */
1543 type
= hpread_alloc_type (hp_type
, objfile
);
1544 if (TYPE_CODE (type
) == TYPE_CODE_SET
)
1547 /* Nope. Fill in the appropriate fields. */
1548 TYPE_CODE (type
) = TYPE_CODE_SET
;
1549 TYPE_LENGTH (type
) = dn_bufp
->dset
.bitlength
/ 8;
1550 TYPE_NFIELDS (type
) = 0;
1551 TYPE_TARGET_TYPE (type
) = hpread_type_lookup (dn_bufp
->dset
.subtype
,
1556 /* Read in and internalize an array debug symbol. */
1558 static struct type
*
1559 hpread_read_array_type (hp_type
, dn_bufp
, objfile
)
1560 dnttpointer hp_type
;
1561 union dnttentry
*dn_bufp
;
1562 struct objfile
*objfile
;
1565 union dnttentry save
;
1568 /* Why no check here? Because it kept us from properly determining
1569 the size of the array! */
1570 type
= hpread_alloc_type (hp_type
, objfile
);
1572 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
1574 /* values are not normalized. */
1575 if (!((dn_bufp
->darray
.arrayisbytes
&& dn_bufp
->darray
.elemisbytes
)
1576 || (!dn_bufp
->darray
.arrayisbytes
&& !dn_bufp
->darray
.elemisbytes
)))
1578 else if (dn_bufp
->darray
.arraylength
== 0x7fffffff)
1580 /* The HP debug format represents char foo[]; as an array with
1581 length 0x7fffffff. Internally GDB wants to represent this
1582 as an array of length zero. */
1583 TYPE_LENGTH (type
) = 0;
1586 TYPE_LENGTH (type
) = dn_bufp
->darray
.arraylength
/ 8;
1588 TYPE_NFIELDS (type
) = 1;
1589 TYPE_TARGET_TYPE (type
) = hpread_type_lookup (dn_bufp
->darray
.elemtype
,
1592 TYPE_FIELDS (type
) = (struct field
*)
1593 obstack_alloc (&objfile
->type_obstack
, sizeof (struct field
));
1594 TYPE_FIELD_TYPE (type
, 0) = hpread_type_lookup (dn_bufp
->darray
.indextype
,
1599 /* Read in and internalize a subrange debug symbol. */
1600 static struct type
*
1601 hpread_read_subrange_type (hp_type
, dn_bufp
, objfile
)
1602 dnttpointer hp_type
;
1603 union dnttentry
*dn_bufp
;
1604 struct objfile
*objfile
;
1608 /* Is it something we've already dealt with. */
1609 type
= hpread_alloc_type (hp_type
, objfile
);
1610 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
1613 /* Nope, internalize it. */
1614 TYPE_CODE (type
) = TYPE_CODE_RANGE
;
1615 TYPE_LENGTH (type
) = dn_bufp
->dsubr
.bitlength
/ 8;
1616 TYPE_NFIELDS (type
) = 2;
1618 = (struct field
*) obstack_alloc (&objfile
->type_obstack
,
1619 2 * sizeof (struct field
));
1621 if (dn_bufp
->dsubr
.dyn_low
)
1622 TYPE_FIELD_BITPOS (type
, 0) = 0;
1624 TYPE_FIELD_BITPOS (type
, 0) = dn_bufp
->dsubr
.lowbound
;
1626 if (dn_bufp
->dsubr
.dyn_high
)
1627 TYPE_FIELD_BITPOS (type
, 1) = -1;
1629 TYPE_FIELD_BITPOS (type
, 1) = dn_bufp
->dsubr
.highbound
;
1630 TYPE_TARGET_TYPE (type
) = hpread_type_lookup (dn_bufp
->dsubr
.subtype
,
1635 static struct type
*
1636 hpread_type_lookup (hp_type
, objfile
)
1637 dnttpointer hp_type
;
1638 struct objfile
*objfile
;
1640 union dnttentry
*dn_bufp
;
1642 /* First see if it's a simple builtin type. */
1643 if (hp_type
.dntti
.immediate
)
1644 return lookup_fundamental_type (objfile
, hpread_type_translate (hp_type
));
1646 /* Not a builtin type. We'll have to read it in. */
1647 if (hp_type
.dnttp
.index
< LNTT_SYMCOUNT (objfile
))
1648 dn_bufp
= hpread_get_lntt (hp_type
.dnttp
.index
, objfile
);
1650 return lookup_fundamental_type (objfile
, FT_VOID
);
1652 switch (dn_bufp
->dblock
.kind
)
1654 case DNTT_TYPE_SRCFILE
:
1655 case DNTT_TYPE_MODULE
:
1656 case DNTT_TYPE_FUNCTION
:
1657 case DNTT_TYPE_ENTRY
:
1658 case DNTT_TYPE_BEGIN
:
1660 case DNTT_TYPE_IMPORT
:
1661 case DNTT_TYPE_LABEL
:
1662 case DNTT_TYPE_WITH
:
1663 case DNTT_TYPE_COMMON
:
1664 case DNTT_TYPE_FPARAM
:
1665 case DNTT_TYPE_SVAR
:
1666 case DNTT_TYPE_DVAR
:
1667 case DNTT_TYPE_CONST
:
1668 /* Opps. Something went very wrong. */
1669 return lookup_fundamental_type (objfile
, FT_VOID
);
1671 case DNTT_TYPE_TYPEDEF
:
1673 struct type
*structtype
= hpread_type_lookup (dn_bufp
->dtype
.type
,
1676 suffix
= VT (objfile
) + dn_bufp
->dtype
.name
;
1678 TYPE_CPLUS_SPECIFIC (structtype
)
1679 = (struct cplus_struct_type
*) &cplus_struct_default
;
1680 TYPE_NAME (structtype
) = suffix
;
1684 case DNTT_TYPE_TAGDEF
:
1686 /* Just a little different from above. We have to tack on
1687 an identifier of some kind (struct, union, enum, etc). */
1688 struct type
*structtype
= hpread_type_lookup (dn_bufp
->dtype
.type
,
1690 char *prefix
, *suffix
;
1691 suffix
= VT (objfile
) + dn_bufp
->dtype
.name
;
1693 /* Lookup the next type in the list. It should be a structure,
1694 union, or enum type. We will need to attach that to our name. */
1695 if (dn_bufp
->dtype
.type
.dnttp
.index
< LNTT_SYMCOUNT (objfile
))
1696 dn_bufp
= hpread_get_lntt (dn_bufp
->dtype
.type
.dnttp
.index
, objfile
);
1700 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_STRUCT
)
1702 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_UNION
)
1707 /* Build the correct name. */
1709 = (char *) obstack_alloc (&objfile
->type_obstack
,
1710 strlen (prefix
) + strlen (suffix
) + 1);
1711 TYPE_NAME (structtype
) = strcpy (TYPE_NAME (structtype
), prefix
);
1712 TYPE_NAME (structtype
) = strcat (TYPE_NAME (structtype
), suffix
);
1713 TYPE_TAG_NAME (structtype
) = suffix
;
1715 TYPE_CPLUS_SPECIFIC (structtype
)
1716 = (struct cplus_struct_type
*) &cplus_struct_default
;
1720 case DNTT_TYPE_POINTER
:
1721 return lookup_pointer_type (hpread_type_lookup (dn_bufp
->dptr
.pointsto
,
1723 case DNTT_TYPE_ENUM
:
1724 return hpread_read_enum_type (hp_type
, dn_bufp
, objfile
);
1725 case DNTT_TYPE_MEMENUM
:
1726 return lookup_fundamental_type (objfile
, FT_VOID
);
1728 return hpread_read_set_type (hp_type
, dn_bufp
, objfile
);
1729 case DNTT_TYPE_SUBRANGE
:
1730 return hpread_read_subrange_type (hp_type
, dn_bufp
, objfile
);
1731 case DNTT_TYPE_ARRAY
:
1732 return hpread_read_array_type (hp_type
, dn_bufp
, objfile
);
1733 case DNTT_TYPE_STRUCT
:
1734 case DNTT_TYPE_UNION
:
1735 return hpread_read_struct_type (hp_type
, dn_bufp
, objfile
);
1736 case DNTT_TYPE_FIELD
:
1737 return hpread_type_lookup (dn_bufp
->dfield
.type
, objfile
);
1738 case DNTT_TYPE_VARIANT
:
1739 case DNTT_TYPE_FILE
:
1740 return lookup_fundamental_type (objfile
, FT_VOID
);
1741 case DNTT_TYPE_FUNCTYPE
:
1742 return lookup_function_type (hpread_type_lookup (dn_bufp
->dfunctype
.retval
,
1744 case DNTT_TYPE_COBSTRUCT
:
1745 case DNTT_TYPE_XREF
:
1747 case DNTT_TYPE_MACRO
:
1749 return lookup_fundamental_type (objfile
, FT_VOID
);
1754 hpread_record_lines (subfile
, s_idx
, e_idx
, objfile
, offset
)
1755 struct subfile
*subfile
;
1756 sltpointer s_idx
, e_idx
;
1757 struct objfile
*objfile
;
1760 union sltentry
*sl_bufp
;
1762 while (s_idx
<= e_idx
)
1764 sl_bufp
= hpread_get_slt (s_idx
, objfile
);
1765 /* Only record "normal" entries in the SLT. */
1766 if (sl_bufp
->snorm
.sltdesc
== SLT_NORMAL
1767 || sl_bufp
->snorm
.sltdesc
== SLT_EXIT
)
1768 record_line (subfile
, sl_bufp
->snorm
.line
,
1769 sl_bufp
->snorm
.address
+ offset
);
1775 /* Internalize one native debug symbol. */
1778 hpread_process_one_debug_symbol (dn_bufp
, name
, section_offsets
, objfile
,
1779 text_offset
, text_size
, filename
, index
)
1780 union dnttentry
*dn_bufp
;
1782 struct section_offsets
*section_offsets
;
1783 struct objfile
*objfile
;
1784 CORE_ADDR text_offset
;
1792 int offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1793 union dnttentry
*dn_temp
;
1794 dnttpointer hp_type
;
1796 struct context_stack
*new;
1798 /* Allocate one GDB debug symbol and fill in some default values. */
1799 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
1800 sizeof (struct symbol
));
1801 memset (sym
, 0, sizeof (struct symbol
));
1802 SYMBOL_NAME (sym
) = obsavestring (name
, strlen (name
), &objfile
->symbol_obstack
);
1803 SYMBOL_LANGUAGE (sym
) = language_auto
;
1804 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
1805 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1806 SYMBOL_LINE (sym
) = 0;
1807 SYMBOL_VALUE (sym
) = 0;
1808 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1810 hp_type
.dnttp
.extension
= 1;
1811 hp_type
.dnttp
.immediate
= 0;
1812 hp_type
.dnttp
.global
= 0;
1813 hp_type
.dnttp
.index
= index
;
1815 type
= dn_bufp
->dblock
.kind
;
1819 case DNTT_TYPE_SRCFILE
:
1820 /* This type of symbol indicates from which source file or include file
1821 the following data comes. If there are no modules it also may
1822 indicate the start of a new source file, in which case we must
1823 finish the symbol table of the previous source file
1824 (if any) and start accumulating a new symbol table. */
1827 if (!last_source_file
)
1829 start_symtab (name
, NULL
, valu
);
1830 record_debugformat ("HP");
1831 SL_INDEX (objfile
) = dn_bufp
->dsfile
.address
;
1835 SL_INDEX (objfile
) = hpread_record_lines (current_subfile
,
1837 dn_bufp
->dsfile
.address
,
1840 start_subfile (name
, NULL
);
1843 case DNTT_TYPE_MODULE
:
1844 /* No need to do anything with these DNTT_TYPE_MODULE symbols anymore. */
1847 case DNTT_TYPE_FUNCTION
:
1848 case DNTT_TYPE_ENTRY
:
1849 /* A function or secondary entry point. */
1850 valu
= dn_bufp
->dfunc
.lowaddr
+ offset
;
1851 SL_INDEX (objfile
) = hpread_record_lines (current_subfile
,
1853 dn_bufp
->dfunc
.address
,
1856 WITHIN_FUNCTION (objfile
) = 1;
1857 CURRENT_FUNCTION_VALUE (objfile
) = valu
;
1859 /* Stack must be empty now. */
1860 if (context_stack_depth
!= 0)
1861 complain (&lbrac_unmatched_complaint
, (char *) symnum
);
1862 new = push_context (0, valu
);
1864 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1865 SYMBOL_TYPE (sym
) = hpread_read_function_type (hp_type
, dn_bufp
, objfile
);
1866 if (dn_bufp
->dfunc
.global
)
1867 add_symbol_to_list (sym
, &global_symbols
);
1869 add_symbol_to_list (sym
, &file_symbols
);
1872 /* Search forward to the next scope beginning. */
1873 while (dn_bufp
->dblock
.kind
!= DNTT_TYPE_BEGIN
)
1875 dn_bufp
= hpread_get_lntt (++index
, objfile
);
1876 if (dn_bufp
->dblock
.extension
)
1879 SL_INDEX (objfile
) = hpread_record_lines (current_subfile
,
1881 dn_bufp
->dbegin
.address
,
1883 SYMBOL_LINE (sym
) = hpread_get_line (dn_bufp
->dbegin
.address
, objfile
);
1884 record_line (current_subfile
, SYMBOL_LINE (sym
), valu
);
1887 case DNTT_TYPE_BEGIN
:
1888 /* Begin a new scope. */
1889 SL_INDEX (objfile
) = hpread_record_lines (current_subfile
,
1891 dn_bufp
->dbegin
.address
,
1893 valu
= hpread_get_location (dn_bufp
->dbegin
.address
, objfile
);
1894 valu
+= offset
; /* Relocate for dynamic loading */
1895 desc
= hpread_get_depth (dn_bufp
->dbegin
.address
, objfile
);
1896 new = push_context (desc
, valu
);
1901 SL_INDEX (objfile
) = hpread_record_lines (current_subfile
,
1903 dn_bufp
->dend
.address
+ 1,
1905 switch (dn_bufp
->dend
.endkind
)
1907 case DNTT_TYPE_MODULE
:
1908 /* Ending a module ends the symbol table for that module. */
1909 valu
= text_offset
+ text_size
+ offset
;
1910 (void) end_symtab (valu
, objfile
, 0);
1913 case DNTT_TYPE_FUNCTION
:
1914 /* Ending a function, well, ends the function's scope. */
1915 dn_temp
= hpread_get_lntt (dn_bufp
->dend
.beginscope
.dnttp
.index
,
1917 valu
= dn_temp
->dfunc
.hiaddr
+ offset
;
1918 new = pop_context ();
1919 /* Make a block for the local symbols within. */
1920 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1921 new->start_addr
, valu
, objfile
);
1922 WITHIN_FUNCTION (objfile
) = 0;
1924 case DNTT_TYPE_BEGIN
:
1925 /* Just ending a local scope. */
1926 valu
= hpread_get_location (dn_bufp
->dend
.address
, objfile
);
1927 /* Why in the hell is this needed? */
1928 valu
+= offset
+ 9; /* Relocate for dynamic loading */
1929 new = pop_context ();
1930 desc
= dn_bufp
->dend
.beginscope
.dnttp
.index
;
1931 if (desc
!= new->depth
)
1932 complain (&lbrac_mismatch_complaint
, (char *) symnum
);
1933 /* Make a block for the local symbols within. */
1934 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1935 new->start_addr
, valu
, objfile
);
1936 local_symbols
= new->locals
;
1940 case DNTT_TYPE_LABEL
:
1941 SYMBOL_NAMESPACE (sym
) = LABEL_NAMESPACE
;
1943 case DNTT_TYPE_FPARAM
:
1944 /* Function parameters. */
1945 if (dn_bufp
->dfparam
.regparam
)
1946 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1948 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1949 if (dn_bufp
->dfparam
.copyparam
)
1951 SYMBOL_VALUE (sym
) = dn_bufp
->dfparam
.location
;
1952 #ifdef HPREAD_ADJUST_STACK_ADDRESS
1954 += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile
));
1958 SYMBOL_VALUE (sym
) = dn_bufp
->dfparam
.location
;
1959 SYMBOL_TYPE (sym
) = hpread_type_lookup (dn_bufp
->dfparam
.type
, objfile
);
1960 add_symbol_to_list (sym
, &local_symbols
);
1962 case DNTT_TYPE_SVAR
:
1963 /* Static variables. */
1964 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1965 SYMBOL_VALUE_ADDRESS (sym
) = dn_bufp
->dsvar
.location
;
1966 SYMBOL_TYPE (sym
) = hpread_type_lookup (dn_bufp
->dsvar
.type
, objfile
);
1967 if (dn_bufp
->dsvar
.global
)
1968 add_symbol_to_list (sym
, &global_symbols
);
1969 else if (WITHIN_FUNCTION (objfile
))
1970 add_symbol_to_list (sym
, &local_symbols
);
1972 add_symbol_to_list (sym
, &file_symbols
);
1974 case DNTT_TYPE_DVAR
:
1975 /* Dynamic variables. */
1976 if (dn_bufp
->ddvar
.regvar
)
1977 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1979 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1980 SYMBOL_VALUE (sym
) = dn_bufp
->ddvar
.location
;
1981 #ifdef HPREAD_ADJUST_STACK_ADDRESS
1983 += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile
));
1985 SYMBOL_TYPE (sym
) = hpread_type_lookup (dn_bufp
->ddvar
.type
, objfile
);
1986 if (dn_bufp
->ddvar
.global
)
1987 add_symbol_to_list (sym
, &global_symbols
);
1988 else if (WITHIN_FUNCTION (objfile
))
1989 add_symbol_to_list (sym
, &local_symbols
);
1991 add_symbol_to_list (sym
, &file_symbols
);
1993 case DNTT_TYPE_CONST
:
1994 /* A constant (pascal?). */
1995 SYMBOL_CLASS (sym
) = LOC_CONST
;
1996 SYMBOL_VALUE (sym
) = dn_bufp
->dconst
.location
;
1997 SYMBOL_TYPE (sym
) = hpread_type_lookup (dn_bufp
->dconst
.type
, objfile
);
1998 if (dn_bufp
->dconst
.global
)
1999 add_symbol_to_list (sym
, &global_symbols
);
2000 else if (WITHIN_FUNCTION (objfile
))
2001 add_symbol_to_list (sym
, &local_symbols
);
2003 add_symbol_to_list (sym
, &file_symbols
);
2005 case DNTT_TYPE_TYPEDEF
:
2006 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2007 SYMBOL_TYPE (sym
) = hpread_type_lookup (dn_bufp
->dtype
.type
, objfile
);
2008 if (dn_bufp
->dtype
.global
)
2009 add_symbol_to_list (sym
, &global_symbols
);
2010 else if (WITHIN_FUNCTION (objfile
))
2011 add_symbol_to_list (sym
, &local_symbols
);
2013 add_symbol_to_list (sym
, &file_symbols
);
2015 case DNTT_TYPE_TAGDEF
:
2016 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
2017 SYMBOL_TYPE (sym
) = hpread_type_lookup (dn_bufp
->dtype
.type
, objfile
);
2018 TYPE_NAME (sym
->type
) = SYMBOL_NAME (sym
);
2019 TYPE_TAG_NAME (sym
->type
) = SYMBOL_NAME (sym
);
2020 if (dn_bufp
->dtype
.global
)
2021 add_symbol_to_list (sym
, &global_symbols
);
2022 else if (WITHIN_FUNCTION (objfile
))
2023 add_symbol_to_list (sym
, &local_symbols
);
2025 add_symbol_to_list (sym
, &file_symbols
);
2027 case DNTT_TYPE_POINTER
:
2028 SYMBOL_TYPE (sym
) = lookup_pointer_type (hpread_type_lookup
2029 (dn_bufp
->dptr
.pointsto
,
2031 add_symbol_to_list (sym
, &file_symbols
);
2033 case DNTT_TYPE_ENUM
:
2034 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
2035 SYMBOL_TYPE (sym
) = hpread_read_enum_type (hp_type
, dn_bufp
, objfile
);
2036 add_symbol_to_list (sym
, &file_symbols
);
2038 case DNTT_TYPE_MEMENUM
:
2041 SYMBOL_TYPE (sym
) = hpread_read_set_type (hp_type
, dn_bufp
, objfile
);
2042 add_symbol_to_list (sym
, &file_symbols
);
2044 case DNTT_TYPE_SUBRANGE
:
2045 SYMBOL_TYPE (sym
) = hpread_read_subrange_type (hp_type
, dn_bufp
,
2047 add_symbol_to_list (sym
, &file_symbols
);
2049 case DNTT_TYPE_ARRAY
:
2050 SYMBOL_TYPE (sym
) = hpread_read_array_type (hp_type
, dn_bufp
, objfile
);
2051 add_symbol_to_list (sym
, &file_symbols
);
2053 case DNTT_TYPE_STRUCT
:
2054 case DNTT_TYPE_UNION
:
2055 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
2056 SYMBOL_TYPE (sym
) = hpread_read_struct_type (hp_type
, dn_bufp
, objfile
);
2057 add_symbol_to_list (sym
, &file_symbols
);