1 /* Read hp debug symbols and convert to internal format, for GDB.
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.
22 Written by the Center for Software Science at the University of Utah
23 and by Cygnus Support. */
27 #include "gdb_string.h"
28 #include "hp-symtab.h"
34 #include "complaints.h"
35 #include "gdb-stabs.h"
39 /* Private information attached to an objfile which we use to find
40 and internalize the HP C debug symbols within that objfile. */
42 struct hpread_symfile_info
44 /* The contents of each of the debug sections (there are 4 of them). */
50 /* We keep the size of the $VT$ section for range checking. */
53 /* Some routines still need to know the number of symbols in the
54 main debug sections ($LNTT$ and $GNTT$). */
55 unsigned int lntt_symcount;
56 unsigned int gntt_symcount;
58 /* To keep track of all the types we've processed. */
59 struct type **dntt_type_vector;
60 int dntt_type_vector_length;
62 /* Keeps track of the beginning of a range of source lines. */
65 /* Some state variables we'll need. */
68 /* Keep track of the current function's address. We may need to look
69 up something based on this address. */
70 unsigned int current_function_value;
73 /* Accessor macros to get at the fields. */
74 #define HPUX_SYMFILE_INFO(o) \
75 ((struct hpread_symfile_info *)((o)->sym_private))
76 #define GNTT(o) (HPUX_SYMFILE_INFO(o)->gntt)
77 #define LNTT(o) (HPUX_SYMFILE_INFO(o)->lntt)
78 #define SLT(o) (HPUX_SYMFILE_INFO(o)->slt)
79 #define VT(o) (HPUX_SYMFILE_INFO(o)->vt)
80 #define VT_SIZE(o) (HPUX_SYMFILE_INFO(o)->vt_size)
81 #define LNTT_SYMCOUNT(o) (HPUX_SYMFILE_INFO(o)->lntt_symcount)
82 #define GNTT_SYMCOUNT(o) (HPUX_SYMFILE_INFO(o)->gntt_symcount)
83 #define DNTT_TYPE_VECTOR(o) (HPUX_SYMFILE_INFO(o)->dntt_type_vector)
84 #define DNTT_TYPE_VECTOR_LENGTH(o) \
85 (HPUX_SYMFILE_INFO(o)->dntt_type_vector_length)
86 #define SL_INDEX(o) (HPUX_SYMFILE_INFO(o)->sl_index)
87 #define WITHIN_FUNCTION(o) (HPUX_SYMFILE_INFO(o)->within_function)
88 #define CURRENT_FUNCTION_VALUE(o) (HPUX_SYMFILE_INFO(o)->current_function_value)
90 /* Given the native debug symbol SYM, set NAMEP to the name associated
91 with the debug symbol. Note we may be called with a debug symbol which
92 has no associated name, in that case we return an empty string.
94 Also note we "know" that the name for any symbol is always in the
95 same place. Hence we don't have to conditionalize on the symbol type. */
96 #define SET_NAMESTRING(SYM, NAMEP, OBJFILE) \
97 if (! hpread_has_name ((SYM)->dblock.kind)) \
99 else if (((unsigned)(SYM)->dsfile.name) >= VT_SIZE (OBJFILE)) \
101 complaint (&symfile_complaints, "bad string table offset in symbol %d", \
106 *NAMEP = (SYM)->dsfile.name + VT (OBJFILE)
108 /* We put a pointer to this structure in the read_symtab_private field
113 /* The offset within the file symbol table of first local symbol for
118 /* Length (in bytes) of the section of the symbol table devoted to
119 this file's symbols (actually, the section bracketed may contain
120 more than just this file's symbols). If ldsymlen is 0, the only
121 reason for this thing's existence is the dependency list.
122 Nothing else will happen when it is read in. */
127 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
128 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
129 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
131 /* Complaints about the symbols we have encountered. */
133 lbrac_unmatched_complaint (int arg1)
135 complaint (&symfile_complaints, "unmatched N_LBRAC before symtab pos %d",
140 lbrac_mismatch_complaint (int arg1)
142 complaint (&symfile_complaints,
143 "N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", arg1);
146 /* To generate dumping code, uncomment this define. The dumping
147 itself is controlled by routine-local statics called "dumping". */
148 /* #define DUMPING 1 */
150 /* To use the quick look-up tables, uncomment this define. */
151 #define QUICK_LOOK_UP 1
153 /* To call PXDB to process un-processed files, uncomment this define. */
156 /* Forward procedure declarations */
158 void hpread_symfile_init (struct objfile *);
160 void do_pxdb (bfd *);
162 void hpread_build_psymtabs (struct objfile *, int);
164 void hpread_symfile_finish (struct objfile *);
166 static union dnttentry *hpread_get_gntt (int, struct objfile *);
168 static union dnttentry *hpread_get_lntt (int index, struct objfile *objfile);
171 static unsigned long hpread_get_textlow (int, int, struct objfile *, int);
173 static struct partial_symtab *hpread_start_psymtab
174 (struct objfile *, char *, CORE_ADDR, int,
175 struct partial_symbol **, struct partial_symbol **);
177 static struct partial_symtab *hpread_end_psymtab
178 (struct partial_symtab *, char **, int, int, CORE_ADDR,
179 struct partial_symtab **, int);
181 static unsigned long hpread_get_scope_start (sltpointer, struct objfile *);
183 static unsigned long hpread_get_line (sltpointer, struct objfile *);
185 static CORE_ADDR hpread_get_location (sltpointer, struct objfile *);
187 int hpread_has_name (enum dntt_entry_type kind);
189 static void hpread_psymtab_to_symtab_1 (struct partial_symtab *);
191 void hpread_psymtab_to_symtab (struct partial_symtab *);
193 static struct symtab *hpread_expand_symtab
194 (struct objfile *, int, int, CORE_ADDR, int,
195 struct section_offsets *, char *);
197 static int hpread_type_translate (dnttpointer);
199 static struct type **hpread_lookup_type (dnttpointer, struct objfile *);
201 static struct type *hpread_alloc_type (dnttpointer, struct objfile *);
203 static struct type *hpread_read_enum_type
204 (dnttpointer, union dnttentry *, struct objfile *);
206 static struct type *hpread_read_function_type
207 (dnttpointer, union dnttentry *, struct objfile *, int);
209 static struct type *hpread_read_doc_function_type
210 (dnttpointer, union dnttentry *, struct objfile *, int);
212 static struct type *hpread_read_struct_type
213 (dnttpointer, union dnttentry *, struct objfile *);
215 static struct type *hpread_get_nth_template_arg (struct objfile *, int);
217 static struct type *hpread_read_templ_arg_type
218 (dnttpointer, union dnttentry *, struct objfile *, char *);
220 static struct type *hpread_read_set_type
221 (dnttpointer, union dnttentry *, struct objfile *);
223 static struct type *hpread_read_array_type
224 (dnttpointer, union dnttentry *dn_bufp, struct objfile *objfile);
226 static struct type *hpread_read_subrange_type
227 (dnttpointer, union dnttentry *, struct objfile *);
229 static struct type *hpread_type_lookup (dnttpointer, struct objfile *);
231 static sltpointer hpread_record_lines
232 (struct subfile *, sltpointer, sltpointer, struct objfile *, CORE_ADDR);
234 static void hpread_process_one_debug_symbol
235 (union dnttentry *, char *, struct section_offsets *,
236 struct objfile *, CORE_ADDR, int, char *, int, int *);
238 static int hpread_get_scope_depth (union dnttentry *, struct objfile *, int);
240 static void fix_static_member_physnames
241 (struct type *, char *, struct objfile *);
243 static void fixup_class_method_type
244 (struct type *, struct type *, struct objfile *);
246 static void hpread_adjust_bitoffsets (struct type *, int);
248 static dnttpointer hpread_get_next_skip_over_anon_unions
249 (int, dnttpointer, union dnttentry **, struct objfile *);
252 /* Global to indicate presence of HP-compiled objects,
253 in particular, SOM executable file with SOM debug info
254 Defined in symtab.c, used in hppa-tdep.c. */
255 extern int hp_som_som_object_present;
257 /* Static used to indicate a class type that requires a
258 fix-up of one of its method types */
259 static struct type *fixup_class = NULL;
261 /* Static used to indicate the method type that is to be
262 used to fix-up the type for fixup_class */
263 static struct type *fixup_method = NULL;
267 /* NOTE use of system files! May not be portable. */
269 #define PXDB_SVR4 "/opt/langtools/bin/pxdb"
270 #define PXDB_BSD "/usr/bin/pxdb"
273 #include "gdb_string.h"
275 /* check for the existence of a file, given its full pathname */
277 file_exists (char *filename)
280 return (access (filename, F_OK) == 0);
285 /* Translate from the "hp_language" enumeration in hp-symtab.h
286 used in the debug info to gdb's generic enumeration in defs.h. */
288 trans_lang (enum hp_language in_lang)
290 if (in_lang == HP_LANGUAGE_C)
293 else if (in_lang == HP_LANGUAGE_CPLUSPLUS)
294 return language_cplus;
296 else if (in_lang == HP_LANGUAGE_FORTRAN)
297 return language_fortran;
300 return language_unknown;
303 static char main_string[] = "main";
305 /* Call PXDB to process our file.
307 Approach copied from DDE's "dbgk_run_pxdb". Note: we
308 don't check for BSD location of pxdb, nor for existence
311 NOTE: uses system function and string functions directly.
313 Return value: 1 if ok, 0 if not */
315 hpread_call_pxdb (const char *file_name)
321 if (file_exists (PXDB_SVR4))
323 p = xmalloc (strlen (PXDB_SVR4) + strlen (file_name) + 2);
324 strcpy (p, PXDB_SVR4);
326 strcat (p, file_name);
328 warning ("File not processed by pxdb--about to process now.\n");
331 retval = (status == 0);
335 warning ("pxdb not found at standard location: /opt/langtools/bin\ngdb will not be able to debug %s.\nPlease install pxdb at the above location and then restart gdb.\nYou can also run pxdb on %s with the command\n\"pxdb %s\" and then restart gdb.", file_name, file_name, file_name);
340 } /* hpread_call_pxdb */
343 /* Return 1 if the file turns out to need pre-processing
344 by PXDB, and we have thus called PXDB to do this processing
345 and the file therefore needs to be re-loaded. Otherwise
348 hpread_pxdb_needed (bfd *sym_bfd)
350 asection *pinfo_section, *debug_section, *header_section;
351 unsigned int do_pxdb;
353 bfd_size_type header_section_size;
358 header_section = bfd_get_section_by_name (sym_bfd, "$HEADER$");
361 return 0; /* No header at all, can't recover... */
364 debug_section = bfd_get_section_by_name (sym_bfd, "$DEBUG$");
365 pinfo_section = bfd_get_section_by_name (sym_bfd, "$PINFO$");
367 if (pinfo_section && !debug_section)
369 /* Debug info with DOC, has different header format.
370 this only happens if the file was pxdbed and compiled optimized
371 otherwise the PINFO section is not there. */
372 header_section_size = bfd_section_size (objfile->obfd, header_section);
374 if (header_section_size == (bfd_size_type) sizeof (DOC_info_PXDB_header))
376 buf = alloca (sizeof (DOC_info_PXDB_header));
378 if (!bfd_get_section_contents (sym_bfd,
381 header_section_size))
382 error ("bfd_get_section_contents\n");
384 tmp = bfd_get_32 (sym_bfd, (bfd_byte *) (buf + sizeof (int) * 4));
385 pxdbed = (tmp >> 31) & 0x1;
388 error ("file debug header info invalid\n");
393 error ("invalid $HEADER$ size in executable \n");
399 /* this can be three different cases:
400 1. pxdbed and not doc
401 - DEBUG and HEADER sections are there
402 - header is PXDB_header type
403 - pxdbed flag is set to 1
405 2. not pxdbed and doc
406 - DEBUG and HEADER sections are there
407 - header is DOC_info_header type
408 - pxdbed flag is set to 0
410 3. not pxdbed and not doc
411 - DEBUG and HEADER sections are there
412 - header is XDB_header type
413 - pxdbed flag is set to 0
415 NOTE: the pxdbed flag is meaningful also in the not
416 already pxdb processed version of the header,
417 because in case on non-already processed by pxdb files
418 that same bit in the header would be always zero.
419 Why? Because the bit is the leftmost bit of a word
420 which contains a 'length' which is always a positive value
421 so that bit is never set to 1 (otherwise it would be negative)
423 Given the above, we have two choices : either we ignore the
424 size of the header itself and just look at the pxdbed field,
425 or we check the size and then we (for safety and paranoia related
426 issues) check the bit.
427 The first solution is used by DDE, the second by PXDB itself.
428 I am using the second one here, because I already wrote it,
429 and it is the end of a long day.
430 Also, using the first approach would still involve size issues
431 because we need to read in the contents of the header section, and
432 give the correct amount of stuff we want to read to the
433 get_bfd_section_contents function. */
435 /* decide which case depending on the size of the header section.
436 The size is as defined in hp-symtab.h */
438 header_section_size = bfd_section_size (objfile->obfd, header_section);
440 if (header_section_size == (bfd_size_type) sizeof (PXDB_header)) /* pxdb and not doc */
443 buf = alloca (sizeof (PXDB_header));
444 if (!bfd_get_section_contents (sym_bfd,
447 header_section_size))
448 error ("bfd_get_section_contents\n");
450 tmp = bfd_get_32 (sym_bfd, (bfd_byte *) (buf + sizeof (int) * 3));
451 pxdbed = (tmp >> 31) & 0x1;
456 error ("file debug header invalid\n");
458 else /*not pxdbed and doc OR not pxdbed and non doc */
470 } /* hpread_pxdb_needed */
474 /* Check whether the file needs to be preprocessed by pxdb.
478 do_pxdb (bfd *sym_bfd)
480 /* The following code is HP-specific. The "right" way of
481 doing this is unknown, but we bet would involve a target-
482 specific pre-file-load check using a generic mechanism. */
484 /* This code will not be executed if the file is not in SOM
485 format (i.e. if compiled with gcc) */
486 if (hpread_pxdb_needed (sym_bfd))
488 /*This file has not been pre-processed. Preprocess now */
490 if (hpread_call_pxdb (sym_bfd->filename))
492 /* The call above has changed the on-disk file,
493 we can close the file anyway, because the
494 symbols will be reread in when the target is run */
504 /* Code to handle quick lookup-tables follows. */
507 /* Some useful macros */
508 #define VALID_FILE(i) ((i) < pxdb_header_p->fd_entries)
509 #define VALID_MODULE(i) ((i) < pxdb_header_p->md_entries)
510 #define VALID_PROC(i) ((i) < pxdb_header_p->pd_entries)
511 #define VALID_CLASS(i) ((i) < pxdb_header_p->cd_entries)
513 #define FILE_START(i) (qFD[i].adrStart)
514 #define MODULE_START(i) (qMD[i].adrStart)
515 #define PROC_START(i) (qPD[i].adrStart)
517 #define FILE_END(i) (qFD[i].adrEnd)
518 #define MODULE_END(i) (qMD[i].adrEnd)
519 #define PROC_END(i) (qPD[i].adrEnd)
521 #define FILE_ISYM(i) (qFD[i].isym)
522 #define MODULE_ISYM(i) (qMD[i].isym)
523 #define PROC_ISYM(i) (qPD[i].isym)
525 #define VALID_CURR_FILE (curr_fd < pxdb_header_p->fd_entries)
526 #define VALID_CURR_MODULE (curr_md < pxdb_header_p->md_entries)
527 #define VALID_CURR_PROC (curr_pd < pxdb_header_p->pd_entries)
528 #define VALID_CURR_CLASS (curr_cd < pxdb_header_p->cd_entries)
530 #define CURR_FILE_START (qFD[curr_fd].adrStart)
531 #define CURR_MODULE_START (qMD[curr_md].adrStart)
532 #define CURR_PROC_START (qPD[curr_pd].adrStart)
534 #define CURR_FILE_END (qFD[curr_fd].adrEnd)
535 #define CURR_MODULE_END (qMD[curr_md].adrEnd)
536 #define CURR_PROC_END (qPD[curr_pd].adrEnd)
538 #define CURR_FILE_ISYM (qFD[curr_fd].isym)
539 #define CURR_MODULE_ISYM (qMD[curr_md].isym)
540 #define CURR_PROC_ISYM (qPD[curr_pd].isym)
542 #define TELL_OBJFILE \
544 if( !told_objfile ) { \
546 warning ("\nIn object file \"%s\":\n", \
553 /* Keeping track of the start/end symbol table (LNTT) indices of
554 psymtabs created so far */
563 static pst_syms_struct *pst_syms_array = 0;
565 static int pst_syms_count = 0;
566 static int pst_syms_size = 0;
568 /* used by the TELL_OBJFILE macro */
569 static int told_objfile = 0;
571 /* Set up psymtab symbol index stuff */
577 pst_syms_array = (pst_syms_struct *) xmalloc (20 * sizeof (pst_syms_struct));
580 /* Clean up psymtab symbol index stuff */
582 clear_pst_syms (void)
586 xfree (pst_syms_array);
590 /* Add information about latest psymtab to symbol index table */
592 record_pst_syms (int start_sym, int end_sym)
594 if (++pst_syms_count > pst_syms_size)
596 pst_syms_array = (pst_syms_struct *) xrealloc (pst_syms_array,
597 2 * pst_syms_size * sizeof (pst_syms_struct));
600 pst_syms_array[pst_syms_count - 1].start = start_sym;
601 pst_syms_array[pst_syms_count - 1].end = end_sym;
604 /* Find a suitable symbol table index which can serve as the upper
605 bound of a psymtab that starts at INDEX
607 This scans backwards in the psymtab symbol index table to find a
608 "hole" in which the given index can fit. This is a heuristic!!
609 We don't search the entire table to check for multiple holes,
610 we don't care about overlaps, etc.
612 Return 0 => not found */
614 find_next_pst_start (int index)
618 for (i = pst_syms_count - 1; i >= 0; i--)
619 if (pst_syms_array[i].end <= index)
620 return (i == pst_syms_count - 1) ? 0 : pst_syms_array[i + 1].start - 1;
622 if (pst_syms_array[0].start > index)
623 return pst_syms_array[0].start - 1;
630 /* Utility functions to find the ending symbol index for a psymtab */
632 /* Find the next file entry that begins beyond INDEX, and return
633 its starting symbol index - 1.
634 QFD is the file table, CURR_FD is the file entry from where to start,
635 PXDB_HEADER_P as in hpread_quick_traverse (to allow macros to work).
637 Return 0 => not found */
639 find_next_file_isym (int index, quick_file_entry *qFD, int curr_fd,
640 PXDB_header_ptr pxdb_header_p)
642 while (VALID_CURR_FILE)
644 if (CURR_FILE_ISYM >= index)
645 return CURR_FILE_ISYM - 1;
651 /* Find the next procedure entry that begins beyond INDEX, and return
652 its starting symbol index - 1.
653 QPD is the procedure table, CURR_PD is the proc entry from where to start,
654 PXDB_HEADER_P as in hpread_quick_traverse (to allow macros to work).
656 Return 0 => not found */
658 find_next_proc_isym (int index, quick_procedure_entry *qPD, int curr_pd,
659 PXDB_header_ptr pxdb_header_p)
661 while (VALID_CURR_PROC)
663 if (CURR_PROC_ISYM >= index)
664 return CURR_PROC_ISYM - 1;
670 /* Find the next module entry that begins beyond INDEX, and return
671 its starting symbol index - 1.
672 QMD is the module table, CURR_MD is the modue entry from where to start,
673 PXDB_HEADER_P as in hpread_quick_traverse (to allow macros to work).
675 Return 0 => not found */
677 find_next_module_isym (int index, quick_module_entry *qMD, int curr_md,
678 PXDB_header_ptr pxdb_header_p)
680 while (VALID_CURR_MODULE)
682 if (CURR_MODULE_ISYM >= index)
683 return CURR_MODULE_ISYM - 1;
689 /* Scan and record partial symbols for all functions starting from index
690 pointed to by CURR_PD_P, and between code addresses START_ADR and END_ADR.
691 Other parameters are explained in comments below. */
693 /* This used to be inline in hpread_quick_traverse, but now that we do
694 essentially the same thing for two different cases (modules and
695 module-less files), it's better organized in a separate routine,
696 although it does take lots of arguments. pai/1997-10-08
698 CURR_PD_P is the pointer to the current proc index. QPD is the
699 procedure quick lookup table. MAX_PROCS is the number of entries
700 in the proc. table. START_ADR is the beginning of the code range
701 for the current psymtab. end_adr is the end of the code range for
702 the current psymtab. PST is the current psymtab. VT_bits is
703 a pointer to the strings table of SOM debug space. OBJFILE is
704 the current object file. */
707 scan_procs (int *curr_pd_p, quick_procedure_entry *qPD, int max_procs,
708 CORE_ADDR start_adr, CORE_ADDR end_adr, struct partial_symtab *pst,
709 char *vt_bits, struct objfile *objfile)
711 union dnttentry *dn_bufp;
712 int symbol_count = 0; /* Total number of symbols in this psymtab */
713 int curr_pd = *curr_pd_p; /* Convenience variable -- avoid dereferencing pointer all the time */
716 /* Turn this on for lots of debugging information in this routine */
717 static int dumping = 0;
723 printf ("Scan_procs called, addresses %x to %x, proc %x\n", start_adr, end_adr, curr_pd);
727 while ((CURR_PROC_START <= end_adr) && (curr_pd < max_procs))
730 char *rtn_name; /* mangled name */
731 char *rtn_dem_name; /* qualified demangled name */
735 if ((trans_lang ((enum hp_language) qPD[curr_pd].language) == language_cplus) &&
736 vt_bits[(long) qPD[curr_pd].sbAlias]) /* not a null string */
738 /* Get mangled name for the procedure, and demangle it */
739 rtn_name = &vt_bits[(long) qPD[curr_pd].sbAlias];
740 rtn_dem_name = cplus_demangle (rtn_name, DMGL_ANSI | DMGL_PARAMS);
744 rtn_name = &vt_bits[(long) qPD[curr_pd].sbProc];
748 /* Hack to get around HP C/C++ compilers' insistence on providing
749 "_MAIN_" as an alternate name for "main" */
750 if ((strcmp (rtn_name, "_MAIN_") == 0) &&
751 (strcmp (&vt_bits[(long) qPD[curr_pd].sbProc], "main") == 0))
752 rtn_dem_name = rtn_name = main_string;
757 printf ("..add %s (demangled %s), index %x to this psymtab\n", rtn_name, rtn_dem_name, curr_pd);
761 /* Check for module-spanning routines. */
762 if (CURR_PROC_END > end_adr)
765 warning ("Procedure \"%s\" [0x%x] spans file or module boundaries.", rtn_name, curr_pd);
768 /* Add this routine symbol to the list in the objfile.
769 Unfortunately we have to go to the LNTT to determine the
770 correct list to put it on. An alternative (which the
771 code used to do) would be to not check and always throw
772 it on the "static" list. But if we go that route, then
773 symbol_lookup() needs to be tweaked a bit to account
774 for the fact that the function might not be found on
775 the correct list in the psymtab. - RT */
776 dn_bufp = hpread_get_lntt (qPD[curr_pd].isym, objfile);
777 if (dn_bufp->dfunc.global)
778 add_psymbol_with_dem_name_to_list (rtn_name,
781 strlen (rtn_dem_name),
783 LOC_BLOCK, /* "I am a routine" */
784 &objfile->global_psymbols,
785 (qPD[curr_pd].adrStart + /* Starting address of rtn */
786 ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile))),
788 trans_lang ((enum hp_language) qPD[curr_pd].language),
791 add_psymbol_with_dem_name_to_list (rtn_name,
794 strlen (rtn_dem_name),
796 LOC_BLOCK, /* "I am a routine" */
797 &objfile->static_psymbols,
798 (qPD[curr_pd].adrStart + /* Starting address of rtn */
799 ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile))),
801 trans_lang ((enum hp_language) qPD[curr_pd].language),
805 *curr_pd_p = ++curr_pd; /* bump up count & reflect in caller */
806 } /* loop over procedures */
811 if (symbol_count == 0)
812 printf ("Scan_procs: no symbols found!\n");
820 /* Traverse the quick look-up tables, building a set of psymtabs.
822 This constructs a psymtab for modules and files in the quick lookup
825 Mostly, modules correspond to compilation units, so we try to
826 create psymtabs that correspond to modules; however, in some cases
827 a file can result in a compiled object which does not have a module
828 entry for it, so in such cases we create a psymtab for the file. */
831 hpread_quick_traverse (struct objfile *objfile, char *gntt_bits,
832 char *vt_bits, PXDB_header_ptr pxdb_header_p)
834 struct partial_symtab *pst;
838 quick_procedure_entry *qPD;
839 quick_file_entry *qFD;
840 quick_module_entry *qMD;
841 quick_class_entry *qCD;
845 CORE_ADDR start_adr; /* current psymtab's starting code addr */
846 CORE_ADDR end_adr; /* current psymtab's ending code addr */
847 CORE_ADDR next_mod_adr; /* next module's starting code addr */
848 int curr_pd; /* current procedure */
849 int curr_fd; /* current file */
850 int curr_md; /* current module */
851 int start_sym; /* current psymtab's starting symbol index */
852 int end_sym; /* current psymtab's ending symbol index */
853 int max_LNTT_sym_index;
855 B_TYPE *class_entered;
857 struct partial_symbol **global_syms; /* We'll be filling in the "global" */
858 struct partial_symbol **static_syms; /* and "static" tables in the objfile
859 as we go, so we need a pair of
863 /* Turn this on for lots of debugging information in this routine.
864 You get a blow-by-blow account of quick lookup table reading */
865 static int dumping = 0;
868 pst = (struct partial_symtab *) 0;
870 /* Clear out some globals */
874 /* Demangling style -- if EDG style already set, don't change it,
875 as HP style causes some problems with the KAI EDG compiler */
876 if (current_demangling_style != edg_demangling)
878 /* Otherwise, ensure that we are using HP style demangling */
879 set_demangling_style (HP_DEMANGLING_STYLE_STRING);
882 /* First we need to find the starting points of the quick
883 look-up tables in the GNTT. */
887 qPD = (quick_procedure_entry_ptr) addr;
888 addr += pxdb_header_p->pd_entries * sizeof (quick_procedure_entry);
893 printf ("\n Printing routines as we see them\n");
894 for (i = 0; VALID_PROC (i); i++)
896 idx = (long) qPD[i].sbProc;
897 printf ("%s %x..%x\n", &vt_bits[idx],
898 (int) PROC_START (i),
904 qFD = (quick_file_entry_ptr) addr;
905 addr += pxdb_header_p->fd_entries * sizeof (quick_file_entry);
910 printf ("\n Printing files as we see them\n");
911 for (i = 0; VALID_FILE (i); i++)
913 idx = (long) qFD[i].sbFile;
914 printf ("%s %x..%x\n", &vt_bits[idx],
915 (int) FILE_START (i),
921 qMD = (quick_module_entry_ptr) addr;
922 addr += pxdb_header_p->md_entries * sizeof (quick_module_entry);
927 printf ("\n Printing modules as we see them\n");
928 for (i = 0; i < pxdb_header_p->md_entries; i++)
930 idx = (long) qMD[i].sbMod;
931 printf ("%s\n", &vt_bits[idx]);
936 qCD = (quick_class_entry_ptr) addr;
937 addr += pxdb_header_p->cd_entries * sizeof (quick_class_entry);
942 printf ("\n Printing classes as we see them\n");
943 for (i = 0; VALID_CLASS (i); i++)
945 idx = (long) qCD[i].sbClass;
946 printf ("%s\n", &vt_bits[idx]);
949 printf ("\n Done with dump, on to build!\n");
953 /* We need this index only while hp-symtab-read.c expects
954 a byte offset to the end of the LNTT entries for a given
955 psymtab. Thus the need for it should go away someday.
957 When it goes away, then we won't have any need to load the
958 LNTT from the objfile at psymtab-time, and start-up will be
959 faster. To make that work, we'll need some way to create
960 a null pst for the "globals" pseudo-module. */
961 max_LNTT_sym_index = LNTT_SYMCOUNT (objfile);
963 /* Scan the module descriptors and make a psymtab for each.
965 We know the MDs, FDs and the PDs are in order by starting
966 address. We use that fact to traverse all three arrays in
967 parallel, knowing when the next PD is in a new file
968 and we need to create a new psymtab. */
969 curr_pd = 0; /* Current procedure entry */
970 curr_fd = 0; /* Current file entry */
971 curr_md = 0; /* Current module entry */
973 start_adr = 0; /* Current psymtab code range */
976 start_sym = 0; /* Current psymtab symbol range */
979 syms_in_pst = 0; /* Symbol count for psymtab */
981 /* Psts actually just have pointers into the objfile's
982 symbol table, not their own symbol tables. */
983 global_syms = objfile->global_psymbols.list;
984 static_syms = objfile->static_psymbols.list;
987 /* First skip over pseudo-entries with address 0. These represent inlined
988 routines and abstract (uninstantiated) template routines.
989 FIXME: These should be read in and available -- even if we can't set
990 breakpoints, etc., there's some information that can be presented
991 to the user. pai/1997-10-08 */
993 while (VALID_CURR_PROC && (CURR_PROC_START == 0))
996 /* Loop over files, modules, and procedures in code address order. Each
997 time we enter an iteration of this loop, curr_pd points to the first
998 unprocessed procedure, curr_fd points to the first unprocessed file, and
999 curr_md to the first unprocessed module. Each iteration of this loop
1000 updates these as required -- any or all of them may be bumpd up
1001 each time around. When we exit this loop, we are done with all files
1002 and modules in the tables -- there may still be some procedures, however.
1004 Note: This code used to loop only over module entries, under the assumption
1005 that files can occur via inclusions and are thus unreliable, while a
1006 compiled object always corresponds to a module. With CTTI in the HP aCC
1007 compiler, it turns out that compiled objects may have only files and no
1008 modules; so we have to loop over files and modules, creating psymtabs for
1009 either as appropriate. Unfortunately there are some problems (notably:
1010 1. the lack of "SRC_FILE_END" entries in the LNTT, 2. the lack of pointers
1011 to the ending symbol indices of a module or a file) which make it quite hard
1012 to do this correctly. Currently it uses a bunch of heuristics to start and
1013 end psymtabs; they seem to work well with most objects generated by aCC, but
1014 who knows when that will change... */
1016 while (VALID_CURR_FILE || VALID_CURR_MODULE)
1019 char *mod_name_string;
1020 char *full_name_string;
1022 /* First check for modules like "version.c", which have no code
1023 in them but still have qMD entries. They also have no qFD or
1024 qPD entries. Their start address is -1 and their end address
1026 if (VALID_CURR_MODULE && (CURR_MODULE_START == -1) && (CURR_MODULE_END == 0))
1029 mod_name_string = &vt_bits[(long) qMD[curr_md].sbMod];
1033 printf ("Module with data only %s\n", mod_name_string);
1036 /* We'll skip the rest (it makes error-checking easier), and
1037 just make an empty pst. Right now empty psts are not put
1038 in the pst chain, so all this is for naught, but later it
1041 pst = hpread_start_psymtab (objfile,
1043 CURR_MODULE_START, /* Low text address: bogus! */
1044 (CURR_MODULE_ISYM * sizeof (struct dntt_type_block)),
1049 pst = hpread_end_psymtab (pst,
1050 NULL, /* psymtab_include_list */
1051 0, /* includes_used */
1052 end_sym * sizeof (struct dntt_type_block),
1053 /* byte index in LNTT of end
1054 = capping symbol offset
1055 = LDSYMOFF of nextfile */
1057 NULL, /* dependency_list */
1058 0); /* dependencies_used */
1060 global_syms = objfile->global_psymbols.next;
1061 static_syms = objfile->static_psymbols.next;
1065 else if (VALID_CURR_MODULE &&
1066 ((CURR_MODULE_START == 0) || (CURR_MODULE_START == -1) ||
1067 (CURR_MODULE_END == 0) || (CURR_MODULE_END == -1)))
1070 warning ("Module \"%s\" [0x%s] has non-standard addresses. It starts at 0x%s, ends at 0x%s, and will be skipped.",
1071 mod_name_string, paddr_nz (curr_md), paddr_nz (start_adr), paddr_nz (end_adr));
1072 /* On to next module */
1077 /* First check if we are looking at a file with code in it
1078 that does not overlap the current module's code range */
1080 if (VALID_CURR_FILE ? (VALID_CURR_MODULE ? (CURR_FILE_END < CURR_MODULE_START) : 1) : 0)
1083 /* Looking at file not corresponding to any module,
1084 create a psymtab for it */
1085 full_name_string = &vt_bits[(long) qFD[curr_fd].sbFile];
1086 start_adr = CURR_FILE_START;
1087 end_adr = CURR_FILE_END;
1088 start_sym = CURR_FILE_ISYM;
1090 /* Check if there are any procedures not handled until now, that
1091 begin before the start address of this file, and if so, adjust
1092 this module's start address to include them. This handles routines that
1093 are in between file or module ranges for some reason (probably
1094 indicates a compiler bug */
1096 if (CURR_PROC_START < start_adr)
1099 warning ("Found procedure \"%s\" [0x%x] that is not in any file or module.",
1100 &vt_bits[(long) qPD[curr_pd].sbProc], curr_pd);
1101 start_adr = CURR_PROC_START;
1102 if (CURR_PROC_ISYM < start_sym)
1103 start_sym = CURR_PROC_ISYM;
1106 /* Sometimes (compiler bug -- COBOL) the module end address is higher
1107 than the start address of the next module, so check for that and
1108 adjust accordingly */
1110 if (VALID_FILE (curr_fd + 1) && (FILE_START (curr_fd + 1) <= end_adr))
1113 warning ("File \"%s\" [0x%x] has ending address after starting address of next file; adjusting ending address down.",
1114 full_name_string, curr_fd);
1115 end_adr = FILE_START (curr_fd + 1) - 1; /* Is -4 (or -8 for 64-bit) better? */
1117 if (VALID_MODULE (curr_md) && (CURR_MODULE_START <= end_adr))
1120 warning ("File \"%s\" [0x%x] has ending address after starting address of next module; adjusting ending address down.",
1121 full_name_string, curr_fd);
1122 end_adr = CURR_MODULE_START - 1; /* Is -4 (or -8 for 64-bit) better? */
1129 printf ("Make new psymtab for file %s (%x to %x).\n",
1130 full_name_string, start_adr, end_adr);
1133 /* Create the basic psymtab, connecting it in the list
1134 for this objfile and pointing its symbol entries
1135 to the current end of the symbol areas in the objfile.
1137 The "ldsymoff" parameter is the byte offset in the LNTT
1138 of the first symbol in this file. Some day we should
1139 turn this into an index (fix in hp-symtab-read.c as well).
1140 And it's not even the right byte offset, as we're using
1141 the size of a union! FIXME! */
1142 pst = hpread_start_psymtab (objfile,
1144 start_adr, /* Low text address */
1145 (start_sym * sizeof (struct dntt_type_block)),
1150 /* Set up to only enter each class referenced in this module once. */
1151 class_entered = xmalloc (B_BYTES (pxdb_header_p->cd_entries));
1152 B_CLRALL (class_entered, pxdb_header_p->cd_entries);
1154 /* Scan the procedure descriptors for procedures in the current
1155 file, based on the starting addresses. */
1157 syms_in_pst = scan_procs (&curr_pd, qPD, pxdb_header_p->pd_entries,
1158 start_adr, end_adr, pst, vt_bits, objfile);
1160 /* Get ending symbol offset */
1163 /* First check for starting index before previous psymtab */
1164 if (pst_syms_count && start_sym < pst_syms_array[pst_syms_count - 1].end)
1166 end_sym = find_next_pst_start (start_sym);
1168 /* Look for next start index of a file or module, or procedure */
1171 int next_file_isym = find_next_file_isym (start_sym, qFD, curr_fd + 1, pxdb_header_p);
1172 int next_module_isym = find_next_module_isym (start_sym, qMD, curr_md, pxdb_header_p);
1173 int next_proc_isym = find_next_proc_isym (start_sym, qPD, curr_pd, pxdb_header_p);
1175 if (next_file_isym && next_module_isym)
1177 /* pick lower of next file or module start index */
1178 end_sym = min (next_file_isym, next_module_isym);
1182 /* one of them is zero, pick the other */
1183 end_sym = max (next_file_isym, next_module_isym);
1186 /* As a precaution, check next procedure index too */
1188 end_sym = next_proc_isym;
1190 end_sym = min (end_sym, next_proc_isym);
1193 /* Couldn't find procedure, file, or module, use globals as default */
1195 end_sym = pxdb_header_p->globals;
1200 printf ("File psymtab indices: %x to %x\n", start_sym, end_sym);
1204 pst = hpread_end_psymtab (pst,
1205 NULL, /* psymtab_include_list */
1206 0, /* includes_used */
1207 end_sym * sizeof (struct dntt_type_block),
1208 /* byte index in LNTT of end
1209 = capping symbol offset
1210 = LDSYMOFF of nextfile */
1211 end_adr, /* text high */
1212 NULL, /* dependency_list */
1213 0); /* dependencies_used */
1215 record_pst_syms (start_sym, end_sym);
1218 warning ("No symbols in psymtab for file \"%s\" [0x%x].", full_name_string, curr_fd);
1223 printf ("Made new psymtab for file %s (%x to %x), sym %x to %x.\n",
1224 full_name_string, start_adr, end_adr, CURR_FILE_ISYM, end_sym);
1227 /* Prepare for the next psymtab. */
1228 global_syms = objfile->global_psymbols.next;
1229 static_syms = objfile->static_psymbols.next;
1230 xfree (class_entered);
1233 } /* Psymtab for file */
1236 /* We have a module for which we create a psymtab */
1238 mod_name_string = &vt_bits[(long) qMD[curr_md].sbMod];
1240 /* We will include the code ranges of any files that happen to
1241 overlap with this module */
1243 /* So, first pick the lower of the file's and module's start addresses */
1244 start_adr = CURR_MODULE_START;
1245 if (VALID_CURR_FILE)
1247 if (CURR_FILE_START < CURR_MODULE_START)
1250 warning ("File \"%s\" [0x%x] crosses beginning of module \"%s\".",
1251 &vt_bits[(long) qFD[curr_fd].sbFile],
1252 curr_fd, mod_name_string);
1254 start_adr = CURR_FILE_START;
1258 /* Also pick the lower of the file's and the module's start symbol indices */
1259 start_sym = CURR_MODULE_ISYM;
1260 if (VALID_CURR_FILE && (CURR_FILE_ISYM < CURR_MODULE_ISYM))
1261 start_sym = CURR_FILE_ISYM;
1263 /* For the end address, we scan through the files till we find one
1264 that overlaps the current module but ends beyond it; if no such file exists we
1265 simply use the module's start address.
1266 (Note, if file entries themselves overlap
1267 we take the longest overlapping extension beyond the end of the module...)
1268 We assume that modules never overlap. */
1270 end_adr = CURR_MODULE_END;
1272 if (VALID_CURR_FILE)
1274 while (VALID_CURR_FILE && (CURR_FILE_START < end_adr))
1279 printf ("Maybe skipping file %s which overlaps with module %s\n",
1280 &vt_bits[(long) qFD[curr_fd].sbFile], mod_name_string);
1282 if (CURR_FILE_END > end_adr)
1285 warning ("File \"%s\" [0x%x] crosses end of module \"%s\".",
1286 &vt_bits[(long) qFD[curr_fd].sbFile],
1287 curr_fd, mod_name_string);
1288 end_adr = CURR_FILE_END;
1292 curr_fd--; /* back up after going too far */
1295 /* Sometimes (compiler bug -- COBOL) the module end address is higher
1296 than the start address of the next module, so check for that and
1297 adjust accordingly */
1299 if (VALID_MODULE (curr_md + 1) && (MODULE_START (curr_md + 1) <= end_adr))
1302 warning ("Module \"%s\" [0x%x] has ending address after starting address of next module; adjusting ending address down.",
1303 mod_name_string, curr_md);
1304 end_adr = MODULE_START (curr_md + 1) - 1; /* Is -4 (or -8 for 64-bit) better? */
1306 if (VALID_FILE (curr_fd + 1) && (FILE_START (curr_fd + 1) <= end_adr))
1309 warning ("Module \"%s\" [0x%x] has ending address after starting address of next file; adjusting ending address down.",
1310 mod_name_string, curr_md);
1311 end_adr = FILE_START (curr_fd + 1) - 1; /* Is -4 (or -8 for 64-bit) better? */
1314 /* Use one file to get the full name for the module. This
1315 situation can arise if there is executable code in a #include
1316 file. Each file with code in it gets a qFD. Files which don't
1317 contribute code don't get a qFD, even if they include files
1322 #include "rtn.h" return x;
1325 There will a qFD for "rtn.h",and a qMD for "body.c",
1326 but no qMD for "rtn.h" or qFD for "body.c"!
1328 We pick the name of the last file to overlap with this
1329 module. C convention is to put include files first. In a
1330 perfect world, we could check names and use the file whose full
1331 path name ends with the module name. */
1333 if (VALID_CURR_FILE)
1334 full_name_string = &vt_bits[(long) qFD[curr_fd].sbFile];
1336 full_name_string = mod_name_string;
1338 /* Check if there are any procedures not handled until now, that
1339 begin before the start address we have now, and if so, adjust
1340 this psymtab's start address to include them. This handles routines that
1341 are in between file or module ranges for some reason (probably
1342 indicates a compiler bug */
1344 if (CURR_PROC_START < start_adr)
1347 warning ("Found procedure \"%s\" [0x%x] that is not in any file or module.",
1348 &vt_bits[(long) qPD[curr_pd].sbProc], curr_pd);
1349 start_adr = CURR_PROC_START;
1350 if (CURR_PROC_ISYM < start_sym)
1351 start_sym = CURR_PROC_ISYM;
1357 printf ("Make new psymtab for module %s (%x to %x), using file %s\n",
1358 mod_name_string, start_adr, end_adr, full_name_string);
1361 /* Create the basic psymtab, connecting it in the list
1362 for this objfile and pointing its symbol entries
1363 to the current end of the symbol areas in the objfile.
1365 The "ldsymoff" parameter is the byte offset in the LNTT
1366 of the first symbol in this file. Some day we should
1367 turn this into an index (fix in hp-symtab-read.c as well).
1368 And it's not even the right byte offset, as we're using
1369 the size of a union! FIXME! */
1370 pst = hpread_start_psymtab (objfile,
1372 start_adr, /* Low text address */
1373 (start_sym * sizeof (struct dntt_type_block)),
1378 /* Set up to only enter each class referenced in this module once. */
1379 class_entered = xmalloc (B_BYTES (pxdb_header_p->cd_entries));
1380 B_CLRALL (class_entered, pxdb_header_p->cd_entries);
1382 /* Scan the procedure descriptors for procedures in the current
1383 module, based on the starting addresses. */
1385 syms_in_pst = scan_procs (&curr_pd, qPD, pxdb_header_p->pd_entries,
1386 start_adr, end_adr, pst, vt_bits, objfile);
1388 /* Get ending symbol offset */
1391 /* First check for starting index before previous psymtab */
1392 if (pst_syms_count && start_sym < pst_syms_array[pst_syms_count - 1].end)
1394 end_sym = find_next_pst_start (start_sym);
1396 /* Look for next start index of a file or module, or procedure */
1399 int next_file_isym = find_next_file_isym (start_sym, qFD, curr_fd + 1, pxdb_header_p);
1400 int next_module_isym = find_next_module_isym (start_sym, qMD, curr_md + 1, pxdb_header_p);
1401 int next_proc_isym = find_next_proc_isym (start_sym, qPD, curr_pd, pxdb_header_p);
1403 if (next_file_isym && next_module_isym)
1405 /* pick lower of next file or module start index */
1406 end_sym = min (next_file_isym, next_module_isym);
1410 /* one of them is zero, pick the other */
1411 end_sym = max (next_file_isym, next_module_isym);
1414 /* As a precaution, check next procedure index too */
1416 end_sym = next_proc_isym;
1418 end_sym = min (end_sym, next_proc_isym);
1421 /* Couldn't find procedure, file, or module, use globals as default */
1423 end_sym = pxdb_header_p->globals;
1428 printf ("Module psymtab indices: %x to %x\n", start_sym, end_sym);
1432 pst = hpread_end_psymtab (pst,
1433 NULL, /* psymtab_include_list */
1434 0, /* includes_used */
1435 end_sym * sizeof (struct dntt_type_block),
1436 /* byte index in LNTT of end
1437 = capping symbol offset
1438 = LDSYMOFF of nextfile */
1439 end_adr, /* text high */
1440 NULL, /* dependency_list */
1441 0); /* dependencies_used */
1443 record_pst_syms (start_sym, end_sym);
1446 warning ("No symbols in psymtab for module \"%s\" [0x%x].", mod_name_string, curr_md);
1451 printf ("Made new psymtab for module %s (%x to %x), sym %x to %x.\n",
1452 mod_name_string, start_adr, end_adr, CURR_MODULE_ISYM, end_sym);
1456 /* Prepare for the next psymtab. */
1457 global_syms = objfile->global_psymbols.next;
1458 static_syms = objfile->static_psymbols.next;
1459 xfree (class_entered);
1463 } /* psymtab for module */
1464 } /* psymtab for non-bogus file or module */
1465 } /* End of while loop over all files & modules */
1467 /* There may be some routines after all files and modules -- these will get
1468 inserted in a separate new module of their own */
1469 if (VALID_CURR_PROC)
1471 start_adr = CURR_PROC_START;
1472 end_adr = qPD[pxdb_header_p->pd_entries - 1].adrEnd;
1474 warning ("Found functions beyond end of all files and modules [0x%x].", curr_pd);
1478 printf ("Orphan functions at end, PD %d and beyond (%x to %x)\n",
1479 curr_pd, start_adr, end_adr);
1482 pst = hpread_start_psymtab (objfile,
1484 start_adr, /* Low text address */
1485 (CURR_PROC_ISYM * sizeof (struct dntt_type_block)),
1490 scan_procs (&curr_pd, qPD, pxdb_header_p->pd_entries,
1491 start_adr, end_adr, pst, vt_bits, objfile);
1493 pst = hpread_end_psymtab (pst,
1494 NULL, /* psymtab_include_list */
1495 0, /* includes_used */
1496 pxdb_header_p->globals * sizeof (struct dntt_type_block),
1497 /* byte index in LNTT of end
1498 = capping symbol offset
1499 = LDSYMOFF of nextfile */
1500 end_adr, /* text high */
1501 NULL, /* dependency_list */
1502 0); /* dependencies_used */
1507 /* Now build psts for non-module things (in the tail of
1508 the LNTT, after the last END MODULE entry).
1510 If null psts were kept on the chain, this would be
1511 a solution. FIXME */
1512 pst = hpread_start_psymtab (objfile,
1515 (pxdb_header_p->globals
1516 * sizeof (struct dntt_type_block)),
1517 objfile->global_psymbols.next,
1518 objfile->static_psymbols.next);
1519 hpread_end_psymtab (pst,
1521 (max_LNTT_sym_index * sizeof (struct dntt_type_block)),
1530 } /* End of hpread_quick_traverse. */
1533 /* Get appropriate header, based on pxdb type.
1534 Return value: 1 if ok, 0 if not */
1536 hpread_get_header (struct objfile *objfile, PXDB_header_ptr pxdb_header_p)
1538 asection *pinfo_section, *debug_section, *header_section;
1541 /* Turn on for debugging information */
1542 static int dumping = 0;
1545 header_section = bfd_get_section_by_name (objfile->obfd, "$HEADER$");
1546 if (!header_section)
1548 /* We don't have either PINFO or DEBUG sections. But
1549 stuff like "libc.sl" has no debug info. There's no
1550 need to warn the user of this, as it may be ok. The
1551 caller will figure it out and issue any needed
1555 printf ("==No debug info at all for %s.\n", objfile->name);
1561 /* We would like either a $DEBUG$ or $PINFO$ section.
1562 Once we know which, we can understand the header
1563 data (which we have defined to suit the more common
1565 debug_section = bfd_get_section_by_name (objfile->obfd, "$DEBUG$");
1566 pinfo_section = bfd_get_section_by_name (objfile->obfd, "$PINFO$");
1569 /* The expected case: normal pxdb header. */
1570 bfd_get_section_contents (objfile->obfd, header_section,
1571 pxdb_header_p, 0, sizeof (PXDB_header));
1573 if (!pxdb_header_p->pxdbed)
1575 /* This shouldn't happen if we check in "symfile.c". */
1577 } /* DEBUG section */
1580 else if (pinfo_section)
1582 /* The DOC case; we need to translate this into a
1584 DOC_info_PXDB_header doc_header;
1589 printf ("==OOps, PINFO, let's try to handle this, %s.\n", objfile->name);
1593 bfd_get_section_contents (objfile->obfd,
1596 sizeof (DOC_info_PXDB_header));
1598 if (!doc_header.pxdbed)
1600 /* This shouldn't happen if we check in "symfile.c". */
1601 warning ("File \"%s\" not processed by pxdb!", objfile->name);
1605 /* Copy relevent fields to standard header passed in. */
1606 pxdb_header_p->pd_entries = doc_header.pd_entries;
1607 pxdb_header_p->fd_entries = doc_header.fd_entries;
1608 pxdb_header_p->md_entries = doc_header.md_entries;
1609 pxdb_header_p->pxdbed = doc_header.pxdbed;
1610 pxdb_header_p->bighdr = doc_header.bighdr;
1611 pxdb_header_p->sa_header = doc_header.sa_header;
1612 pxdb_header_p->inlined = doc_header.inlined;
1613 pxdb_header_p->globals = doc_header.globals;
1614 pxdb_header_p->time = doc_header.time;
1615 pxdb_header_p->pg_entries = doc_header.pg_entries;
1616 pxdb_header_p->functions = doc_header.functions;
1617 pxdb_header_p->files = doc_header.files;
1618 pxdb_header_p->cd_entries = doc_header.cd_entries;
1619 pxdb_header_p->aa_entries = doc_header.aa_entries;
1620 pxdb_header_p->oi_entries = doc_header.oi_entries;
1621 pxdb_header_p->version = doc_header.version;
1622 } /* PINFO section */
1628 printf ("==No debug info at all for %s.\n", objfile->name);
1636 } /* End of hpread_get_header */
1637 #endif /* QUICK_LOOK_UP */
1640 /* Initialization for reading native HP C debug symbols from OBJFILE.
1642 Its only purpose in life is to set up the symbol reader's private
1643 per-objfile data structures, and read in the raw contents of the debug
1644 sections (attaching pointers to the debug info into the private data
1647 Since BFD doesn't know how to read debug symbols in a format-independent
1648 way (and may never do so...), we have to do it ourselves. Note we may
1649 be called on a file without native HP C debugging symbols.
1651 FIXME, there should be a cleaner peephole into the BFD environment
1654 hpread_symfile_init (struct objfile *objfile)
1656 asection *vt_section, *slt_section, *lntt_section, *gntt_section;
1658 /* Allocate struct to keep track of the symfile */
1659 objfile->sym_private = (PTR)
1660 xmmalloc (objfile->md, sizeof (struct hpread_symfile_info));
1661 memset (objfile->sym_private, 0, sizeof (struct hpread_symfile_info));
1663 /* We haven't read in any types yet. */
1664 DNTT_TYPE_VECTOR (objfile) = 0;
1666 /* Read in data from the $GNTT$ subspace. */
1667 gntt_section = bfd_get_section_by_name (objfile->obfd, "$GNTT$");
1672 = obstack_alloc (&objfile->symbol_obstack,
1673 bfd_section_size (objfile->obfd, gntt_section));
1675 bfd_get_section_contents (objfile->obfd, gntt_section, GNTT (objfile),
1676 0, bfd_section_size (objfile->obfd, gntt_section));
1678 GNTT_SYMCOUNT (objfile)
1679 = bfd_section_size (objfile->obfd, gntt_section)
1680 / sizeof (struct dntt_type_block);
1682 /* Read in data from the $LNTT$ subspace. Also keep track of the number
1685 FIXME: this could be moved into the psymtab-to-symtab expansion
1686 code, and save startup time. At the moment this data is
1687 still used, though. We'd need a way to tell hp-symtab-read.c
1688 whether or not to load the LNTT. */
1689 lntt_section = bfd_get_section_by_name (objfile->obfd, "$LNTT$");
1694 = obstack_alloc (&objfile->symbol_obstack,
1695 bfd_section_size (objfile->obfd, lntt_section));
1697 bfd_get_section_contents (objfile->obfd, lntt_section, LNTT (objfile),
1698 0, bfd_section_size (objfile->obfd, lntt_section));
1700 LNTT_SYMCOUNT (objfile)
1701 = bfd_section_size (objfile->obfd, lntt_section)
1702 / sizeof (struct dntt_type_block);
1704 /* Read in data from the $SLT$ subspace. $SLT$ contains information
1705 on source line numbers. */
1706 slt_section = bfd_get_section_by_name (objfile->obfd, "$SLT$");
1711 obstack_alloc (&objfile->symbol_obstack,
1712 bfd_section_size (objfile->obfd, slt_section));
1714 bfd_get_section_contents (objfile->obfd, slt_section, SLT (objfile),
1715 0, bfd_section_size (objfile->obfd, slt_section));
1717 /* Read in data from the $VT$ subspace. $VT$ contains things like
1718 names and constants. Keep track of the number of symbols in the VT. */
1719 vt_section = bfd_get_section_by_name (objfile->obfd, "$VT$");
1723 VT_SIZE (objfile) = bfd_section_size (objfile->obfd, vt_section);
1726 (char *) obstack_alloc (&objfile->symbol_obstack,
1729 bfd_get_section_contents (objfile->obfd, vt_section, VT (objfile),
1730 0, VT_SIZE (objfile));
1733 /* Scan and build partial symbols for a symbol file.
1735 The minimal symbol table (either SOM or HP a.out) has already been
1736 read in; all we need to do is setup partial symbols based on the
1737 native debugging information.
1739 Note that the minimal table is produced by the linker, and has
1740 only global routines in it; the psymtab is based on compiler-
1741 generated debug information and has non-global
1742 routines in it as well as files and class information.
1744 We assume hpread_symfile_init has been called to initialize the
1745 symbol reader's private data structures.
1747 MAINLINE is true if we are reading the main symbol table (as
1748 opposed to a shared lib or dynamically loaded file). */
1751 hpread_build_psymtabs (struct objfile *objfile, int mainline)
1755 /* Turn this on to get debugging output. */
1756 static int dumping = 0;
1760 int past_first_source_file = 0;
1761 struct cleanup *old_chain;
1763 int hp_symnum, symcount, i;
1766 union dnttentry *dn_bufp;
1772 /* Current partial symtab */
1773 struct partial_symtab *pst;
1775 /* List of current psymtab's include files */
1776 char **psymtab_include_list;
1777 int includes_allocated;
1780 /* Index within current psymtab dependency list */
1781 struct partial_symtab **dependency_list;
1782 int dependencies_used, dependencies_allocated;
1784 /* Just in case the stabs reader left turds lying around. */
1785 free_pending_blocks ();
1786 make_cleanup (really_free_pendings, 0);
1788 pst = (struct partial_symtab *) 0;
1790 /* We shouldn't use alloca, instead use malloc/free. Doing so avoids
1791 a number of problems with cross compilation and creating useless holes
1792 in the stack when we have to allocate new entries. FIXME. */
1794 includes_allocated = 30;
1796 psymtab_include_list = (char **) alloca (includes_allocated *
1799 dependencies_allocated = 30;
1800 dependencies_used = 0;
1802 (struct partial_symtab **) alloca (dependencies_allocated *
1803 sizeof (struct partial_symtab *));
1805 old_chain = make_cleanup_free_objfile (objfile);
1807 last_source_file = 0;
1809 #ifdef QUICK_LOOK_UP
1811 /* Begin code for new-style loading of quick look-up tables. */
1813 /* elz: this checks whether the file has beeen processed by pxdb.
1814 If not we would like to try to read the psymbols in
1815 anyway, but it turns out to be not so easy. So this could
1816 actually be commented out, but I leave it in, just in case
1817 we decide to add support for non-pxdb-ed stuff in the future. */
1818 PXDB_header pxdb_header;
1819 int found_modules_in_program;
1821 if (hpread_get_header (objfile, &pxdb_header))
1823 /* Build a minimal table. No types, no global variables,
1824 no include files.... */
1827 printf ("\nNew method for %s\n", objfile->name);
1830 /* elz: quick_traverse returns true if it found
1831 some modules in the main source file, other
1833 In C and C++, all the files have MODULES entries
1834 in the LNTT, and the quick table traverse is all
1835 based on finding these MODULES entries. Without
1836 those it cannot work.
1837 It happens that F77 programs don't have MODULES
1838 so the quick traverse gets confused. F90 programs
1839 have modules, and the quick method still works.
1840 So, if modules (other than those in end.c) are
1841 not found we give up on the quick table stuff,
1842 and fall back on the slower method */
1843 found_modules_in_program = hpread_quick_traverse (objfile,
1848 discard_cleanups (old_chain);
1850 /* Set up to scan the global section of the LNTT.
1852 This field is not always correct: if there are
1853 no globals, it will point to the last record in
1854 the regular LNTT, which is usually an END MODULE.
1856 Since it might happen that there could be a file
1857 with just one global record, there's no way to
1858 tell other than by looking at the record, so that's
1860 if (found_modules_in_program)
1861 scan_start = pxdb_header.globals;
1867 printf ("\nGoing on to old method for %s\n", objfile->name);
1871 #endif /* QUICK_LOOK_UP */
1873 /* Make two passes, one over the GNTT symbols, the other for the
1876 JB comment: above isn't true--they only make one pass, over
1878 for (i = 0; i < 1; i++)
1880 int within_function = 0;
1883 symcount = GNTT_SYMCOUNT (objfile);
1885 symcount = LNTT_SYMCOUNT (objfile);
1888 for (hp_symnum = scan_start; hp_symnum < symcount; hp_symnum++)
1892 dn_bufp = hpread_get_gntt (hp_symnum, objfile);
1894 dn_bufp = hpread_get_lntt (hp_symnum, objfile);
1896 if (dn_bufp->dblock.extension)
1899 /* Only handle things which are necessary for minimal symbols.
1900 everything else is ignored. */
1901 switch (dn_bufp->dblock.kind)
1903 case DNTT_TYPE_SRCFILE:
1905 #ifdef QUICK_LOOK_UP
1906 if (scan_start == hp_symnum
1907 && symcount == hp_symnum + 1)
1909 /* If there are NO globals in an executable,
1910 PXDB's index to the globals will point to
1911 the last record in the file, which
1912 could be this record. (this happened for F77 libraries)
1913 ignore it and be done! */
1916 #endif /* QUICK_LOOK_UP */
1918 /* A source file of some kind. Note this may simply
1919 be an included file. */
1920 SET_NAMESTRING (dn_bufp, &namestring, objfile);
1922 /* Check if this is the source file we are already working
1924 if (pst && !strcmp (namestring, pst->filename))
1927 /* Check if this is an include file, if so check if we have
1928 already seen it. Add it to the include list */
1929 p = strrchr (namestring, '.');
1930 if (!strcmp (p, ".h"))
1935 for (j = 0; j < includes_used; j++)
1936 if (!strcmp (namestring, psymtab_include_list[j]))
1944 /* Add it to the list of includes seen so far and
1945 allocate more include space if necessary. */
1946 psymtab_include_list[includes_used++] = namestring;
1947 if (includes_used >= includes_allocated)
1949 char **orig = psymtab_include_list;
1951 psymtab_include_list = (char **)
1952 alloca ((includes_allocated *= 2) *
1954 memcpy ((PTR) psymtab_include_list, (PTR) orig,
1955 includes_used * sizeof (char *));
1964 pst->filename = (char *)
1965 obstack_alloc (&pst->objfile->psymbol_obstack,
1966 strlen (namestring) + 1);
1967 strcpy (pst->filename, namestring);
1974 /* This is a bonafide new source file.
1975 End the current partial symtab and start a new one. */
1977 if (pst && past_first_source_file)
1979 hpread_end_psymtab (pst, psymtab_include_list,
1982 * sizeof (struct dntt_type_block)),
1984 dependency_list, dependencies_used);
1985 pst = (struct partial_symtab *) 0;
1987 dependencies_used = 0;
1990 past_first_source_file = 1;
1992 valu = hpread_get_textlow (i, hp_symnum, objfile, symcount);
1993 valu += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1994 pst = hpread_start_psymtab (objfile,
1997 * sizeof (struct dntt_type_block)),
1998 objfile->global_psymbols.next,
1999 objfile->static_psymbols.next);
2005 case DNTT_TYPE_MODULE:
2006 /* A source file. It's still unclear to me what the
2007 real difference between a DNTT_TYPE_SRCFILE and DNTT_TYPE_MODULE
2008 is supposed to be. */
2010 /* First end the previous psymtab */
2013 hpread_end_psymtab (pst, psymtab_include_list, includes_used,
2015 * sizeof (struct dntt_type_block)),
2017 dependency_list, dependencies_used);
2018 pst = (struct partial_symtab *) 0;
2020 dependencies_used = 0;
2024 /* Now begin a new module and a new psymtab for it */
2025 SET_NAMESTRING (dn_bufp, &namestring, objfile);
2026 valu = hpread_get_textlow (i, hp_symnum, objfile, symcount);
2027 valu += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2030 pst = hpread_start_psymtab (objfile,
2033 * sizeof (struct dntt_type_block)),
2034 objfile->global_psymbols.next,
2035 objfile->static_psymbols.next);
2041 case DNTT_TYPE_FUNCTION:
2042 case DNTT_TYPE_ENTRY:
2043 /* The beginning of a function. DNTT_TYPE_ENTRY may also denote
2044 a secondary entry point. */
2045 valu = dn_bufp->dfunc.hiaddr + ANOFFSET (objfile->section_offsets,
2046 SECT_OFF_TEXT (objfile));
2047 if (valu > texthigh)
2049 valu = dn_bufp->dfunc.lowaddr +
2050 ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2051 SET_NAMESTRING (dn_bufp, &namestring, objfile);
2052 if (dn_bufp->dfunc.global)
2053 add_psymbol_to_list (namestring, strlen (namestring),
2054 VAR_NAMESPACE, LOC_BLOCK,
2055 &objfile->global_psymbols, valu,
2056 0, language_unknown, objfile);
2058 add_psymbol_to_list (namestring, strlen (namestring),
2059 VAR_NAMESPACE, LOC_BLOCK,
2060 &objfile->static_psymbols, valu,
2061 0, language_unknown, objfile);
2062 within_function = 1;
2065 case DNTT_TYPE_DOC_FUNCTION:
2066 valu = dn_bufp->ddocfunc.hiaddr + ANOFFSET (objfile->section_offsets,
2067 SECT_OFF_TEXT (objfile));
2068 if (valu > texthigh)
2070 valu = dn_bufp->ddocfunc.lowaddr +
2071 ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2072 SET_NAMESTRING (dn_bufp, &namestring, objfile);
2073 if (dn_bufp->ddocfunc.global)
2074 add_psymbol_to_list (namestring, strlen (namestring),
2075 VAR_NAMESPACE, LOC_BLOCK,
2076 &objfile->global_psymbols, valu,
2077 0, language_unknown, objfile);
2079 add_psymbol_to_list (namestring, strlen (namestring),
2080 VAR_NAMESPACE, LOC_BLOCK,
2081 &objfile->static_psymbols, valu,
2082 0, language_unknown, objfile);
2083 within_function = 1;
2086 case DNTT_TYPE_BEGIN:
2088 /* We don't check MODULE end here, because there can be
2089 symbols beyond the module end which properly belong to the
2090 current psymtab -- so we wait till the next MODULE start */
2093 #ifdef QUICK_LOOK_UP
2094 if (scan_start == hp_symnum
2095 && symcount == hp_symnum + 1)
2097 /* If there are NO globals in an executable,
2098 PXDB's index to the globals will point to
2099 the last record in the file, which is
2100 probably an END MODULE, i.e. this record.
2101 ignore it and be done! */
2104 #endif /* QUICK_LOOK_UP */
2106 /* Scope block begin/end. We only care about function
2107 and file blocks right now. */
2109 if ((dn_bufp->dend.endkind == DNTT_TYPE_FUNCTION) ||
2110 (dn_bufp->dend.endkind == DNTT_TYPE_DOC_FUNCTION))
2111 within_function = 0;
2114 case DNTT_TYPE_SVAR:
2115 case DNTT_TYPE_DVAR:
2116 case DNTT_TYPE_TYPEDEF:
2117 case DNTT_TYPE_TAGDEF:
2119 /* Variables, typedefs an the like. */
2120 enum address_class storage;
2121 namespace_enum namespace;
2123 /* Don't add locals to the partial symbol table. */
2125 && (dn_bufp->dblock.kind == DNTT_TYPE_SVAR
2126 || dn_bufp->dblock.kind == DNTT_TYPE_DVAR))
2129 /* TAGDEFs go into the structure namespace. */
2130 if (dn_bufp->dblock.kind == DNTT_TYPE_TAGDEF)
2131 namespace = STRUCT_NAMESPACE;
2133 namespace = VAR_NAMESPACE;
2135 /* What kind of "storage" does this use? */
2136 if (dn_bufp->dblock.kind == DNTT_TYPE_SVAR)
2137 storage = LOC_STATIC;
2138 else if (dn_bufp->dblock.kind == DNTT_TYPE_DVAR
2139 && dn_bufp->ddvar.regvar)
2140 storage = LOC_REGISTER;
2141 else if (dn_bufp->dblock.kind == DNTT_TYPE_DVAR)
2142 storage = LOC_LOCAL;
2144 storage = LOC_UNDEF;
2146 SET_NAMESTRING (dn_bufp, &namestring, objfile);
2149 pst = hpread_start_psymtab (objfile,
2152 * sizeof (struct dntt_type_block)),
2153 objfile->global_psymbols.next,
2154 objfile->static_psymbols.next);
2157 /* Compute address of the data symbol */
2158 valu = dn_bufp->dsvar.location;
2159 /* Relocate in case it's in a shared library */
2160 if (storage == LOC_STATIC)
2161 valu += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
2163 /* Luckily, dvar, svar, typedef, and tagdef all
2164 have their "global" bit in the same place, so it works
2165 (though it's bad programming practice) to reference
2166 "dsvar.global" even though we may be looking at
2167 any of the above four types. */
2168 if (dn_bufp->dsvar.global)
2170 add_psymbol_to_list (namestring, strlen (namestring),
2172 &objfile->global_psymbols,
2174 0, language_unknown, objfile);
2178 add_psymbol_to_list (namestring, strlen (namestring),
2180 &objfile->static_psymbols,
2182 0, language_unknown, objfile);
2185 /* For TAGDEF's, the above code added the tagname to the
2186 struct namespace. This will cause tag "t" to be found
2187 on a reference of the form "(struct t) x". But for
2188 C++ classes, "t" will also be a typename, which we
2189 want to find on a reference of the form "ptype t".
2190 Therefore, we also add "t" to the var namespace.
2191 Do the same for enum's due to the way aCC generates
2192 debug info for these (see more extended comment
2193 in hp-symtab-read.c).
2194 We do the same for templates, so that "ptype t"
2195 where "t" is a template also works. */
2196 if (dn_bufp->dblock.kind == DNTT_TYPE_TAGDEF &&
2197 dn_bufp->dtype.type.dnttp.index < LNTT_SYMCOUNT (objfile))
2199 int global = dn_bufp->dtag.global;
2200 /* Look ahead to see if it's a C++ class */
2201 dn_bufp = hpread_get_lntt (dn_bufp->dtype.type.dnttp.index, objfile);
2202 if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS ||
2203 dn_bufp->dblock.kind == DNTT_TYPE_ENUM ||
2204 dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
2208 add_psymbol_to_list (namestring, strlen (namestring),
2209 VAR_NAMESPACE, storage,
2210 &objfile->global_psymbols,
2211 dn_bufp->dsvar.location,
2212 0, language_unknown, objfile);
2216 add_psymbol_to_list (namestring, strlen (namestring),
2217 VAR_NAMESPACE, storage,
2218 &objfile->static_psymbols,
2219 dn_bufp->dsvar.location,
2220 0, language_unknown, objfile);
2227 case DNTT_TYPE_MEMENUM:
2228 case DNTT_TYPE_CONST:
2229 /* Constants and members of enumerated types. */
2230 SET_NAMESTRING (dn_bufp, &namestring, objfile);
2233 pst = hpread_start_psymtab (objfile,
2236 * sizeof (struct dntt_type_block)),
2237 objfile->global_psymbols.next,
2238 objfile->static_psymbols.next);
2240 if (dn_bufp->dconst.global)
2241 add_psymbol_to_list (namestring, strlen (namestring),
2242 VAR_NAMESPACE, LOC_CONST,
2243 &objfile->global_psymbols, 0,
2244 0, language_unknown, objfile);
2246 add_psymbol_to_list (namestring, strlen (namestring),
2247 VAR_NAMESPACE, LOC_CONST,
2248 &objfile->static_psymbols, 0,
2249 0, language_unknown, objfile);
2257 /* End any pending partial symbol table. */
2260 hpread_end_psymtab (pst, psymtab_include_list, includes_used,
2261 hp_symnum * sizeof (struct dntt_type_block),
2262 0, dependency_list, dependencies_used);
2265 discard_cleanups (old_chain);
2268 /* Perform any local cleanups required when we are done with a particular
2269 objfile. I.E, we are in the process of discarding all symbol information
2270 for an objfile, freeing up all memory held for it, and unlinking the
2271 objfile struct from the global list of known objfiles. */
2274 hpread_symfile_finish (struct objfile *objfile)
2276 if (objfile->sym_private != NULL)
2278 xmfree (objfile->md, objfile->sym_private);
2283 /* The remaining functions are all for internal use only. */
2285 /* Various small functions to get entries in the debug symbol sections. */
2288 hpread_get_lntt (int index, struct objfile *objfile)
2290 return (union dnttentry *)
2291 &(LNTT (objfile)[(index * sizeof (struct dntt_type_block))]);
2294 static union dnttentry *
2295 hpread_get_gntt (int index, struct objfile *objfile)
2297 return (union dnttentry *)
2298 &(GNTT (objfile)[(index * sizeof (struct dntt_type_block))]);
2302 hpread_get_slt (int index, struct objfile *objfile)
2304 return (union sltentry *) &(SLT (objfile)[index * sizeof (union sltentry)]);
2307 /* Get the low address associated with some symbol (typically the start
2308 of a particular source file or module). Since that information is not
2309 stored as part of the DNTT_TYPE_MODULE or DNTT_TYPE_SRCFILE symbol we
2310 must infer it from the existence of DNTT_TYPE_FUNCTION symbols. */
2312 static unsigned long
2313 hpread_get_textlow (int global, int index, struct objfile *objfile,
2316 union dnttentry *dn_bufp;
2317 struct minimal_symbol *msymbol;
2319 /* Look for a DNTT_TYPE_FUNCTION symbol. */
2320 if (index < symcount) /* symcount is the number of symbols in */
2321 { /* the dbinfo, LNTT table */
2325 dn_bufp = hpread_get_gntt (index++, objfile);
2327 dn_bufp = hpread_get_lntt (index++, objfile);
2329 while (dn_bufp->dblock.kind != DNTT_TYPE_FUNCTION
2330 && dn_bufp->dblock.kind != DNTT_TYPE_DOC_FUNCTION
2331 && dn_bufp->dblock.kind != DNTT_TYPE_END
2332 && index < symcount);
2335 /* Avoid going past a DNTT_TYPE_END when looking for a DNTT_TYPE_FUNCTION. This
2336 might happen when a sourcefile has no functions. */
2337 if (dn_bufp->dblock.kind == DNTT_TYPE_END)
2340 /* Avoid going past the end of the LNTT file */
2341 if (index == symcount)
2344 /* The minimal symbols are typically more accurate for some reason. */
2345 if (dn_bufp->dblock.kind == DNTT_TYPE_FUNCTION)
2346 msymbol = lookup_minimal_symbol (dn_bufp->dfunc.name + VT (objfile), NULL,
2348 else /* must be a DNTT_TYPE_DOC_FUNCTION */
2349 msymbol = lookup_minimal_symbol (dn_bufp->ddocfunc.name + VT (objfile), NULL,
2353 return SYMBOL_VALUE_ADDRESS (msymbol);
2355 return dn_bufp->dfunc.lowaddr;
2358 /* Allocate and partially fill a partial symtab. It will be
2359 completely filled at the end of the symbol list.
2361 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
2362 is the address relative to which its symbols are (incremental) or 0
2365 static struct partial_symtab *
2366 hpread_start_psymtab (struct objfile *objfile, char *filename,
2367 CORE_ADDR textlow, int ldsymoff,
2368 struct partial_symbol **global_syms,
2369 struct partial_symbol **static_syms)
2371 int offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
2372 extern void hpread_psymtab_to_symtab ();
2373 struct partial_symtab *result =
2374 start_psymtab_common (objfile, objfile->section_offsets,
2375 filename, textlow, global_syms, static_syms);
2377 result->textlow += offset;
2378 result->read_symtab_private = (char *)
2379 obstack_alloc (&objfile->psymbol_obstack, sizeof (struct symloc));
2380 LDSYMOFF (result) = ldsymoff;
2381 result->read_symtab = hpread_psymtab_to_symtab;
2387 /* Close off the current usage of PST.
2388 Returns PST or NULL if the partial symtab was empty and thrown away.
2390 capping_symbol_offset --Byte index in LNTT or GNTT of the
2391 last symbol processed during the build
2392 of the previous pst.
2394 FIXME: List variables and peculiarities of same. */
2396 static struct partial_symtab *
2397 hpread_end_psymtab (struct partial_symtab *pst, char **include_list,
2398 int num_includes, int capping_symbol_offset,
2399 CORE_ADDR capping_text,
2400 struct partial_symtab **dependency_list,
2401 int number_dependencies)
2404 struct objfile *objfile = pst->objfile;
2405 int offset = ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (objfile));
2408 /* Turn on to see what kind of a psymtab we've built. */
2409 static int dumping = 0;
2412 if (capping_symbol_offset != -1)
2413 LDSYMLEN (pst) = capping_symbol_offset - LDSYMOFF (pst);
2416 pst->texthigh = capping_text + offset;
2418 pst->n_global_syms =
2419 objfile->global_psymbols.next - (objfile->global_psymbols.list + pst->globals_offset);
2420 pst->n_static_syms =
2421 objfile->static_psymbols.next - (objfile->static_psymbols.list + pst->statics_offset);
2426 printf ("\nPst %s, LDSYMOFF %x (%x), LDSYMLEN %x (%x), globals %d, statics %d\n",
2429 LDSYMOFF (pst) / sizeof (struct dntt_type_block),
2431 LDSYMLEN (pst) / sizeof (struct dntt_type_block),
2432 pst->n_global_syms, pst->n_static_syms);
2436 pst->number_of_dependencies = number_dependencies;
2437 if (number_dependencies)
2439 pst->dependencies = (struct partial_symtab **)
2440 obstack_alloc (&objfile->psymbol_obstack,
2441 number_dependencies * sizeof (struct partial_symtab *));
2442 memcpy (pst->dependencies, dependency_list,
2443 number_dependencies * sizeof (struct partial_symtab *));
2446 pst->dependencies = 0;
2448 for (i = 0; i < num_includes; i++)
2450 struct partial_symtab *subpst =
2451 allocate_psymtab (include_list[i], objfile);
2453 subpst->section_offsets = pst->section_offsets;
2454 subpst->read_symtab_private =
2455 (char *) obstack_alloc (&objfile->psymbol_obstack,
2456 sizeof (struct symloc));
2460 subpst->texthigh = 0;
2462 /* We could save slight bits of space by only making one of these,
2463 shared by the entire set of include files. FIXME-someday. */
2464 subpst->dependencies = (struct partial_symtab **)
2465 obstack_alloc (&objfile->psymbol_obstack,
2466 sizeof (struct partial_symtab *));
2467 subpst->dependencies[0] = pst;
2468 subpst->number_of_dependencies = 1;
2470 subpst->globals_offset =
2471 subpst->n_global_syms =
2472 subpst->statics_offset =
2473 subpst->n_static_syms = 0;
2477 subpst->read_symtab = pst->read_symtab;
2480 sort_pst_symbols (pst);
2482 /* If there is already a psymtab or symtab for a file of this name, remove it.
2483 (If there is a symtab, more drastic things also happen.)
2484 This happens in VxWorks. */
2485 free_named_symtabs (pst->filename);
2487 if (num_includes == 0
2488 && number_dependencies == 0
2489 && pst->n_global_syms == 0
2490 && pst->n_static_syms == 0)
2492 /* Throw away this psymtab, it's empty. We can't deallocate it, since
2493 it is on the obstack, but we can forget to chain it on the list.
2494 Empty psymtabs happen as a result of header files which don't have
2495 any symbols in them. There can be a lot of them. But this check
2496 is wrong, in that a psymtab with N_SLINE entries but nothing else
2497 is not empty, but we don't realize that. Fixing that without slowing
2498 things down might be tricky.
2499 It's also wrong if we're using the quick look-up tables, as
2500 we can get empty psymtabs from modules with no routines in
2503 discard_psymtab (pst);
2505 /* Indicate that psymtab was thrown away. */
2506 pst = (struct partial_symtab *) NULL;
2513 /* Get the nesting depth for the source line identified by INDEX. */
2515 static unsigned long
2516 hpread_get_scope_start (sltpointer index, struct objfile *objfile)
2518 union sltentry *sl_bufp;
2520 sl_bufp = hpread_get_slt (index, objfile);
2521 return sl_bufp->sspec.backptr.dnttp.index;
2524 /* Get the source line number the the line identified by INDEX. */
2526 static unsigned long
2527 hpread_get_line (sltpointer index, struct objfile *objfile)
2529 union sltentry *sl_bufp;
2531 sl_bufp = hpread_get_slt (index, objfile);
2532 return sl_bufp->snorm.line;
2535 /* Find the code address associated with a given sltpointer */
2538 hpread_get_location (sltpointer index, struct objfile *objfile)
2540 union sltentry *sl_bufp;
2543 /* code location of special sltentrys is determined from context */
2544 sl_bufp = hpread_get_slt (index, objfile);
2546 if (sl_bufp->snorm.sltdesc == SLT_END)
2548 /* find previous normal sltentry and get address */
2549 for (i = 0; ((sl_bufp->snorm.sltdesc != SLT_NORMAL) &&
2550 (sl_bufp->snorm.sltdesc != SLT_NORMAL_OFFSET) &&
2551 (sl_bufp->snorm.sltdesc != SLT_EXIT)); i++)
2552 sl_bufp = hpread_get_slt (index - i, objfile);
2553 if (sl_bufp->snorm.sltdesc == SLT_NORMAL_OFFSET)
2554 return sl_bufp->snormoff.address;
2556 return sl_bufp->snorm.address;
2559 /* find next normal sltentry and get address */
2560 for (i = 0; ((sl_bufp->snorm.sltdesc != SLT_NORMAL) &&
2561 (sl_bufp->snorm.sltdesc != SLT_NORMAL_OFFSET) &&
2562 (sl_bufp->snorm.sltdesc != SLT_EXIT)); i++)
2563 sl_bufp = hpread_get_slt (index + i, objfile);
2564 if (sl_bufp->snorm.sltdesc == SLT_NORMAL_OFFSET)
2565 return sl_bufp->snormoff.address;
2567 return sl_bufp->snorm.address;
2571 /* Return 1 if an HP debug symbol of type KIND has a name associated with
2572 * it, else return 0. (This function is not currently used, but I'll
2573 * leave it here in case it proves useful later on. - RT).
2577 hpread_has_name (enum dntt_entry_type kind)
2581 case DNTT_TYPE_SRCFILE:
2582 case DNTT_TYPE_MODULE:
2583 case DNTT_TYPE_FUNCTION:
2584 case DNTT_TYPE_DOC_FUNCTION:
2585 case DNTT_TYPE_ENTRY:
2586 case DNTT_TYPE_IMPORT:
2587 case DNTT_TYPE_LABEL:
2588 case DNTT_TYPE_FPARAM:
2589 case DNTT_TYPE_SVAR:
2590 case DNTT_TYPE_DVAR:
2591 case DNTT_TYPE_CONST:
2592 case DNTT_TYPE_TYPEDEF:
2593 case DNTT_TYPE_TAGDEF:
2594 case DNTT_TYPE_MEMENUM:
2595 case DNTT_TYPE_FIELD:
2597 case DNTT_TYPE_BLOCKDATA:
2598 case DNTT_TYPE_MEMFUNC:
2599 case DNTT_TYPE_DOC_MEMFUNC:
2602 case DNTT_TYPE_BEGIN:
2604 case DNTT_TYPE_POINTER:
2605 case DNTT_TYPE_ENUM:
2607 case DNTT_TYPE_ARRAY:
2608 case DNTT_TYPE_STRUCT:
2609 case DNTT_TYPE_UNION:
2610 case DNTT_TYPE_VARIANT:
2611 case DNTT_TYPE_FILE:
2612 case DNTT_TYPE_FUNCTYPE:
2613 case DNTT_TYPE_SUBRANGE:
2614 case DNTT_TYPE_WITH:
2615 case DNTT_TYPE_COMMON:
2616 case DNTT_TYPE_COBSTRUCT:
2617 case DNTT_TYPE_XREF:
2618 case DNTT_TYPE_MACRO:
2619 case DNTT_TYPE_CLASS_SCOPE:
2620 case DNTT_TYPE_REFERENCE:
2621 case DNTT_TYPE_PTRMEM:
2622 case DNTT_TYPE_PTRMEMFUNC:
2623 case DNTT_TYPE_CLASS:
2624 case DNTT_TYPE_GENFIELD:
2625 case DNTT_TYPE_VFUNC:
2626 case DNTT_TYPE_MEMACCESS:
2627 case DNTT_TYPE_INHERITANCE:
2628 case DNTT_TYPE_FRIEND_CLASS:
2629 case DNTT_TYPE_FRIEND_FUNC:
2630 case DNTT_TYPE_MODIFIER:
2631 case DNTT_TYPE_OBJECT_ID:
2632 case DNTT_TYPE_TEMPLATE:
2633 case DNTT_TYPE_TEMPLATE_ARG:
2634 case DNTT_TYPE_FUNC_TEMPLATE:
2635 case DNTT_TYPE_LINK:
2636 /* DNTT_TYPE_DYN_ARRAY_DESC ? */
2637 /* DNTT_TYPE_DESC_SUBRANGE ? */
2638 /* DNTT_TYPE_BEGIN_EXT ? */
2639 /* DNTT_TYPE_INLN ? */
2640 /* DNTT_TYPE_INLN_LIST ? */
2641 /* DNTT_TYPE_ALIAS ? */
2647 /* Do the dirty work of reading in the full symbol from a partial symbol
2651 hpread_psymtab_to_symtab_1 (struct partial_symtab *pst)
2653 struct cleanup *old_chain;
2656 /* Get out quick if passed junk. */
2660 /* Complain if we've already read in this symbol table. */
2663 fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in."
2664 " Shouldn't happen.\n",
2669 /* Read in all partial symtabs on which this one is dependent */
2670 for (i = 0; i < pst->number_of_dependencies; i++)
2671 if (!pst->dependencies[i]->readin)
2673 /* Inform about additional files that need to be read in. */
2676 fputs_filtered (" ", gdb_stdout);
2678 fputs_filtered ("and ", gdb_stdout);
2680 printf_filtered ("%s...", pst->dependencies[i]->filename);
2681 wrap_here (""); /* Flush output */
2682 gdb_flush (gdb_stdout);
2684 hpread_psymtab_to_symtab_1 (pst->dependencies[i]);
2687 /* If it's real... */
2690 /* Init stuff necessary for reading in symbols */
2692 old_chain = make_cleanup (really_free_pendings, 0);
2695 hpread_expand_symtab (pst->objfile, LDSYMOFF (pst), LDSYMLEN (pst),
2696 pst->textlow, pst->texthigh - pst->textlow,
2697 pst->section_offsets, pst->filename);
2698 sort_symtab_syms (pst->symtab);
2700 do_cleanups (old_chain);
2706 /* Read in all of the symbols for a given psymtab for real.
2707 Be verbose about it if the user wants that. */
2710 hpread_psymtab_to_symtab (struct partial_symtab *pst)
2712 /* Get out quick if given junk. */
2719 fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in."
2720 " Shouldn't happen.\n",
2725 /* elz: setting the flag to indicate that the code of the target
2726 was compiled using an HP compiler (aCC, cc)
2727 the processing_acc_compilation variable is declared in the
2728 file buildsym.h, the HP_COMPILED_TARGET is defined to be equal
2729 to 3 in the file tm_hppa.h */
2731 processing_gcc_compilation = 0;
2733 if (LDSYMLEN (pst) || pst->number_of_dependencies)
2735 /* Print the message now, before reading the string table,
2736 to avoid disconcerting pauses. */
2739 printf_filtered ("Reading in symbols for %s...", pst->filename);
2740 gdb_flush (gdb_stdout);
2743 hpread_psymtab_to_symtab_1 (pst);
2745 /* Match with global symbols. This only needs to be done once,
2746 after all of the symtabs and dependencies have been read in. */
2747 scan_file_globals (pst->objfile);
2749 /* Finish up the debug error message. */
2751 printf_filtered ("done.\n");
2755 /* Read in a defined section of a specific object file's symbols.
2757 DESC is the file descriptor for the file, positioned at the
2758 beginning of the symtab
2759 SYM_OFFSET is the offset within the file of
2760 the beginning of the symbols we want to read
2761 SYM_SIZE is the size of the symbol info to read in.
2762 TEXT_OFFSET is the beginning of the text segment we are reading symbols for
2763 TEXT_SIZE is the size of the text segment read in.
2764 SECTION_OFFSETS are the relocation offsets which get added to each symbol. */
2766 static struct symtab *
2767 hpread_expand_symtab (struct objfile *objfile, int sym_offset, int sym_size,
2768 CORE_ADDR text_offset, int text_size,
2769 struct section_offsets *section_offsets, char *filename)
2772 union dnttentry *dn_bufp;
2773 unsigned max_symnum;
2774 int at_module_boundary = 0;
2775 /* 1 => at end, -1 => at beginning */
2777 int sym_index = sym_offset / sizeof (struct dntt_type_block);
2779 current_objfile = objfile;
2782 last_source_file = 0;
2784 /* Demangling style -- if EDG style already set, don't change it,
2785 as HP style causes some problems with the KAI EDG compiler */
2786 if (current_demangling_style != edg_demangling)
2788 /* Otherwise, ensure that we are using HP style demangling */
2789 set_demangling_style (HP_DEMANGLING_STYLE_STRING);
2792 dn_bufp = hpread_get_lntt (sym_index, objfile);
2793 if (!((dn_bufp->dblock.kind == (unsigned char) DNTT_TYPE_SRCFILE) ||
2794 (dn_bufp->dblock.kind == (unsigned char) DNTT_TYPE_MODULE)))
2796 start_symtab ("globals", NULL, 0);
2797 record_debugformat ("HP");
2800 /* The psymtab builder (hp-psymtab-read.c) is the one that
2801 * determined the "sym_size" argument (i.e. how many DNTT symbols
2802 * are in this symtab), which we use to compute "max_symnum"
2803 * (point in DNTT to which we read).
2805 * Perhaps this should be changed so that
2806 * process_one_debug_symbol() "knows" when
2807 * to stop reading (based on reading from the MODULE to the matching
2808 * END), and take out this reliance on a #-syms being passed in...
2809 * (I'm worried about the reliability of this number). But I'll
2810 * leave it as-is, for now. - RT
2812 * The change above has been made. I've left the "for" loop control
2813 * in to prepare for backing this out again. -JB
2815 max_symnum = sym_size / sizeof (struct dntt_type_block);
2816 /* No reason to multiply on pst side and divide on sym side... FIXME */
2818 /* Read in and process each debug symbol within the specified range.
2821 symnum < max_symnum;
2824 QUIT; /* Allow this to be interruptable */
2825 dn_bufp = hpread_get_lntt (sym_index + symnum, objfile);
2827 if (dn_bufp->dblock.extension)
2830 /* Yow! We call SET_NAMESTRING on things without names! */
2831 SET_NAMESTRING (dn_bufp, &namestring, objfile);
2833 hpread_process_one_debug_symbol (dn_bufp, namestring, section_offsets,
2834 objfile, text_offset, text_size,
2835 filename, symnum + sym_index,
2839 /* OLD COMMENTS: This routine is only called for psts. All psts
2840 * correspond to MODULES. If we ever do lazy-reading of globals
2841 * from the LNTT, then there will be a pst which ends when the
2842 * LNTT ends, and not at an END MODULE entry. Then we'll have
2843 * to re-visit this break.
2845 if( at_end_of_module )
2850 /* We no longer break out of the loop when we reach the end of a
2851 module. The reason is that with CTTI, the compiler can generate
2852 function symbols (for template function instantiations) which are not
2853 in any module; typically they show up beyond a module's end, and
2854 before the next module's start. We include them in the current
2855 module. However, we still don't trust the MAX_SYMNUM value from
2856 the psymtab, so we break out if we enter a new module. */
2858 if (at_module_boundary == -1)
2862 current_objfile = NULL;
2863 hp_som_som_object_present = 1; /* Indicate we've processed an HP SOM SOM file */
2865 return end_symtab (text_offset + text_size, objfile, SECT_OFF_TEXT (objfile));
2871 /* Convert basic types from HP debug format into GDB internal format. */
2874 hpread_type_translate (dnttpointer typep)
2876 if (!typep.dntti.immediate)
2878 error ("error in hpread_type_translate\n.");
2882 switch (typep.dntti.type)
2884 case HP_TYPE_BOOLEAN:
2885 case HP_TYPE_BOOLEAN_S300_COMPAT:
2886 case HP_TYPE_BOOLEAN_VAX_COMPAT:
2888 case HP_TYPE_CHAR: /* C signed char, C++ plain char */
2890 case HP_TYPE_WIDE_CHAR:
2893 if (typep.dntti.bitlength <= 8)
2894 return FT_SIGNED_CHAR; /* C++ signed char */
2895 if (typep.dntti.bitlength <= 16)
2897 if (typep.dntti.bitlength <= 32)
2899 return FT_LONG_LONG;
2901 if (typep.dntti.bitlength <= 8)
2902 return FT_SIGNED_CHAR; /* C++ signed char. */
2904 case HP_TYPE_UNSIGNED_LONG:
2905 if (typep.dntti.bitlength <= 8)
2906 return FT_UNSIGNED_CHAR; /* C/C++ unsigned char */
2907 if (typep.dntti.bitlength <= 16)
2908 return FT_UNSIGNED_SHORT;
2909 if (typep.dntti.bitlength <= 32)
2910 return FT_UNSIGNED_LONG;
2911 return FT_UNSIGNED_LONG_LONG;
2912 case HP_TYPE_UNSIGNED_INT:
2913 if (typep.dntti.bitlength <= 8)
2914 return FT_UNSIGNED_CHAR;
2915 if (typep.dntti.bitlength <= 16)
2916 return FT_UNSIGNED_SHORT;
2917 if (typep.dntti.bitlength <= 32)
2918 return FT_UNSIGNED_INTEGER;
2919 return FT_UNSIGNED_LONG_LONG;
2921 case HP_TYPE_REAL_3000:
2922 case HP_TYPE_DOUBLE:
2923 if (typep.dntti.bitlength == 64)
2924 return FT_DBL_PREC_FLOAT;
2925 if (typep.dntti.bitlength == 128)
2926 return FT_EXT_PREC_FLOAT;
2928 case HP_TYPE_COMPLEX:
2929 case HP_TYPE_COMPLEXS3000:
2930 if (typep.dntti.bitlength == 128)
2931 return FT_DBL_PREC_COMPLEX;
2932 if (typep.dntti.bitlength == 192)
2933 return FT_EXT_PREC_COMPLEX;
2937 case HP_TYPE_STRING200:
2938 case HP_TYPE_LONGSTRING200:
2939 case HP_TYPE_FTN_STRING_SPEC:
2940 case HP_TYPE_MOD_STRING_SPEC:
2941 case HP_TYPE_MOD_STRING_3000:
2942 case HP_TYPE_FTN_STRING_S300_COMPAT:
2943 case HP_TYPE_FTN_STRING_VAX_COMPAT:
2945 case HP_TYPE_TEMPLATE_ARG:
2946 return FT_TEMPLATE_ARG;
2948 case HP_TYPE_FLABEL:
2949 case HP_TYPE_PACKED_DECIMAL:
2950 case HP_TYPE_ANYPOINTER:
2951 case HP_TYPE_GLOBAL_ANYPOINTER:
2952 case HP_TYPE_LOCAL_ANYPOINTER:
2954 warning ("hpread_type_translate: unhandled type code.\n");
2959 /* Given a position in the DNTT, return a pointer to the
2960 * already-built "struct type" (if any), for the type defined
2964 static struct type **
2965 hpread_lookup_type (dnttpointer hp_type, struct objfile *objfile)
2968 int index = hp_type.dnttp.index;
2969 int size_changed = 0;
2971 /* The immediate flag indicates this doesn't actually point to
2974 if (hp_type.dntti.immediate)
2977 /* For each objfile, we maintain a "type vector".
2978 * This an array of "struct type *"'s with one pointer per DNTT index.
2979 * Given a DNTT index, we look in this array to see if we have
2980 * already processed this DNTT and if it is a type definition.
2981 * If so, then we can locate a pointer to the already-built
2982 * "struct type", and not build it again.
2984 * The need for this arises because our DNTT-walking code wanders
2985 * around. In particular, it will encounter the same type multiple
2986 * times (once for each object of that type). We don't want to
2987 * built multiple "struct type"'s for the same thing.
2989 * Having said this, I should point out that this type-vector is
2990 * an expensive way to keep track of this. If most DNTT entries are
2991 * 3 words, the type-vector will be 1/3 the size of the DNTT itself.
2992 * Alternative solutions:
2993 * - Keep a compressed or hashed table. Less memory, but more expensive
2994 * to search and update.
2995 * - (Suggested by JB): Overwrite the DNTT entry itself
2996 * with the info. Create a new type code "ALREADY_BUILT", and modify
2997 * the DNTT to have that type code and point to the already-built entry.
3001 if (index < LNTT_SYMCOUNT (objfile))
3003 if (index >= DNTT_TYPE_VECTOR_LENGTH (objfile))
3005 old_len = DNTT_TYPE_VECTOR_LENGTH (objfile);
3007 /* See if we need to allocate a type-vector. */
3010 DNTT_TYPE_VECTOR_LENGTH (objfile) = LNTT_SYMCOUNT (objfile) + GNTT_SYMCOUNT (objfile);
3011 DNTT_TYPE_VECTOR (objfile) = (struct type **)
3012 xmmalloc (objfile->md, DNTT_TYPE_VECTOR_LENGTH (objfile) * sizeof (struct type *));
3013 memset (&DNTT_TYPE_VECTOR (objfile)[old_len], 0,
3014 (DNTT_TYPE_VECTOR_LENGTH (objfile) - old_len) *
3015 sizeof (struct type *));
3018 /* See if we need to resize type-vector. With my change to
3019 * initially allocate a correct-size type-vector, this code
3020 * should no longer trigger.
3022 while (index >= DNTT_TYPE_VECTOR_LENGTH (objfile))
3024 DNTT_TYPE_VECTOR_LENGTH (objfile) *= 2;
3029 DNTT_TYPE_VECTOR (objfile) = (struct type **)
3030 xmrealloc (objfile->md,
3031 (char *) DNTT_TYPE_VECTOR (objfile),
3032 (DNTT_TYPE_VECTOR_LENGTH (objfile) * sizeof (struct type *)));
3034 memset (&DNTT_TYPE_VECTOR (objfile)[old_len], 0,
3035 (DNTT_TYPE_VECTOR_LENGTH (objfile) - old_len) *
3036 sizeof (struct type *));
3040 return &DNTT_TYPE_VECTOR (objfile)[index];
3046 /* Possibly allocate a GDB internal type so we can internalize HP_TYPE.
3047 Note we'll just return the address of a GDB internal type if we already
3048 have it lying around. */
3050 static struct type *
3051 hpread_alloc_type (dnttpointer hp_type, struct objfile *objfile)
3053 struct type **type_addr;
3055 type_addr = hpread_lookup_type (hp_type, objfile);
3056 if (*type_addr == 0)
3058 *type_addr = alloc_type (objfile);
3060 /* A hack - if we really are a C++ class symbol, then this default
3061 * will get overriden later on.
3063 TYPE_CPLUS_SPECIFIC (*type_addr)
3064 = (struct cplus_struct_type *) &cplus_struct_default;
3070 /* Read a native enumerated type and return it in GDB internal form. */
3072 static struct type *
3073 hpread_read_enum_type (dnttpointer hp_type, union dnttentry *dn_bufp,
3074 struct objfile *objfile)
3077 struct pending **symlist, *osyms, *syms;
3078 struct pending *local_list = NULL;
3079 int o_nsyms, nsyms = 0;
3081 union dnttentry *memp;
3086 /* Allocate a GDB type. If we've already read in this enum type,
3087 * it'll return the already built GDB type, so stop here.
3088 * (Note: I added this check, to conform with what's done for
3089 * struct, union, class.
3090 * I assume this is OK. - RT)
3092 type = hpread_alloc_type (hp_type, objfile);
3093 if (TYPE_CODE (type) == TYPE_CODE_ENUM)
3096 /* HP C supports "sized enums", where a specifier such as "short" or
3097 "char" can be used to get enums of different sizes. So don't assume
3098 an enum is always 4 bytes long. pai/1997-08-21 */
3099 TYPE_LENGTH (type) = dn_bufp->denum.bitlength / 8;
3101 symlist = &file_symbols;
3103 o_nsyms = osyms ? osyms->nsyms : 0;
3105 /* Get a name for each member and add it to our list of members.
3106 * The list of "mem" SOM records we are walking should all be
3107 * SOM type DNTT_TYPE_MEMENUM (not checked).
3109 mem = dn_bufp->denum.firstmem;
3110 while (mem.word && mem.word != DNTTNIL)
3112 memp = hpread_get_lntt (mem.dnttp.index, objfile);
3114 name = VT (objfile) + memp->dmember.name;
3115 sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
3116 sizeof (struct symbol));
3117 memset (sym, 0, sizeof (struct symbol));
3118 SYMBOL_NAME (sym) = obsavestring (name, strlen (name),
3119 &objfile->symbol_obstack);
3120 SYMBOL_CLASS (sym) = LOC_CONST;
3121 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
3122 SYMBOL_VALUE (sym) = memp->dmember.value;
3123 add_symbol_to_list (sym, symlist);
3125 mem = memp->dmember.nextmem;
3128 /* Now that we know more about the enum, fill in more info. */
3129 TYPE_CODE (type) = TYPE_CODE_ENUM;
3130 TYPE_FLAGS (type) &= ~TYPE_FLAG_STUB;
3131 TYPE_NFIELDS (type) = nsyms;
3132 TYPE_FIELDS (type) = (struct field *)
3133 obstack_alloc (&objfile->type_obstack, sizeof (struct field) * nsyms);
3135 /* Find the symbols for the members and put them into the type.
3136 The symbols can be found in the symlist that we put them on
3137 to cause them to be defined. osyms contains the old value
3138 of that symlist; everything up to there was defined by us.
3140 Note that we preserve the order of the enum constants, so
3141 that in something like "enum {FOO, LAST_THING=FOO}" we print
3142 FOO, not LAST_THING. */
3143 for (syms = *symlist, n = 0; syms; syms = syms->next)
3148 for (; j < syms->nsyms; j++, n++)
3150 struct symbol *xsym = syms->symbol[j];
3151 SYMBOL_TYPE (xsym) = type;
3152 TYPE_FIELD_NAME (type, n) = SYMBOL_NAME (xsym);
3153 TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym);
3154 TYPE_FIELD_BITSIZE (type, n) = 0;
3155 TYPE_FIELD_STATIC_KIND (type, n) = 0;
3164 /* Read and internalize a native function debug symbol. */
3166 static struct type *
3167 hpread_read_function_type (dnttpointer hp_type, union dnttentry *dn_bufp,
3168 struct objfile *objfile, int newblock)
3170 struct type *type, *type1;
3171 struct pending *syms;
3172 struct pending *local_list = NULL;
3175 union dnttentry *paramp;
3179 int record_args = 1;
3181 /* See if we've already read in this type. */
3182 type = hpread_alloc_type (hp_type, objfile);
3183 if (TYPE_CODE (type) == TYPE_CODE_FUNC)
3185 record_args = 0; /* already read in, don't modify type */
3189 /* Nope, so read it in and store it away. */
3190 if (dn_bufp->dblock.kind == DNTT_TYPE_FUNCTION ||
3191 dn_bufp->dblock.kind == DNTT_TYPE_MEMFUNC)
3192 type1 = lookup_function_type (hpread_type_lookup (dn_bufp->dfunc.retval,
3194 else if (dn_bufp->dblock.kind == DNTT_TYPE_FUNCTYPE)
3195 type1 = lookup_function_type (hpread_type_lookup (dn_bufp->dfunctype.retval,
3197 else /* expect DNTT_TYPE_FUNC_TEMPLATE */
3198 type1 = lookup_function_type (hpread_type_lookup (dn_bufp->dfunc_template.retval,
3200 replace_type (type, type1);
3202 /* Mark it -- in the middle of processing */
3203 TYPE_FLAGS (type) |= TYPE_FLAG_INCOMPLETE;
3206 /* Now examine each parameter noting its type, location, and a
3207 wealth of other information. */
3208 if (dn_bufp->dblock.kind == DNTT_TYPE_FUNCTION ||
3209 dn_bufp->dblock.kind == DNTT_TYPE_MEMFUNC)
3210 param = dn_bufp->dfunc.firstparam;
3211 else if (dn_bufp->dblock.kind == DNTT_TYPE_FUNCTYPE)
3212 param = dn_bufp->dfunctype.firstparam;
3213 else /* expect DNTT_TYPE_FUNC_TEMPLATE */
3214 param = dn_bufp->dfunc_template.firstparam;
3215 while (param.word && param.word != DNTTNIL)
3217 paramp = hpread_get_lntt (param.dnttp.index, objfile);
3219 param = paramp->dfparam.nextparam;
3222 name = VT (objfile) + paramp->dfparam.name;
3223 sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
3224 sizeof (struct symbol));
3225 (void) memset (sym, 0, sizeof (struct symbol));
3226 SYMBOL_NAME (sym) = obsavestring (name, strlen (name),
3227 &objfile->symbol_obstack);
3229 /* Figure out where it lives. */
3230 if (paramp->dfparam.regparam)
3231 SYMBOL_CLASS (sym) = LOC_REGPARM;
3232 else if (paramp->dfparam.indirect)
3233 SYMBOL_CLASS (sym) = LOC_REF_ARG;
3235 SYMBOL_CLASS (sym) = LOC_ARG;
3236 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
3237 if (paramp->dfparam.copyparam)
3239 SYMBOL_VALUE (sym) = paramp->dfparam.location;
3240 #ifdef HPREAD_ADJUST_STACK_ADDRESS
3242 += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile));
3244 /* This is likely a pass-by-invisible reference parameter,
3245 Hack on the symbol class to make GDB happy. */
3246 /* ??rehrauer: This appears to be broken w/r/t to passing
3247 C values of type float and struct. Perhaps this ought
3248 to be highighted as a special case, but for now, just
3249 allowing these to be LOC_ARGs seems to work fine.
3252 SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR;
3256 SYMBOL_VALUE (sym) = paramp->dfparam.location;
3259 SYMBOL_TYPE (sym) = hpread_type_lookup (paramp->dfparam.type, objfile);
3260 /* Add it to the symbol list. */
3261 /* Note 1 (RT) At the moment, add_symbol_to_list() is also being
3262 * called on FPARAM symbols from the process_one_debug_symbol()
3263 * level... so parameters are getting added twice! (this shows
3264 * up in the symbol dump you get from "maint print symbols ...").
3265 * Note 2 (RT) I took out the processing of FPARAM from the
3266 * process_one_debug_symbol() level, so at the moment parameters are only
3267 * being processed here. This seems to have no ill effect.
3269 /* Note 3 (pai/1997-08-11) I removed the add_symbol_to_list() which put
3270 each fparam on the local_symbols list from here. Now we use the
3271 local_list to which fparams are added below, and set the param_symbols
3272 global to point to that at the end of this routine. */
3273 /* elz: I added this new list of symbols which is local to the function.
3274 this list is the one which is actually used to build the type for the
3275 function rather than the gloabal list pointed to by symlist.
3276 Using a global list to keep track of the parameters is wrong, because
3277 this function is called recursively if one parameter happend to be
3278 a function itself with more parameters in it. Adding parameters to the
3279 same global symbol list would not work!
3280 Actually it did work in case of cc compiled programs where you do
3281 not check the parameter lists of the arguments. */
3282 add_symbol_to_list (sym, &local_list);
3286 /* If type was read in earlier, don't bother with modifying
3291 /* Note how many parameters we found. */
3292 TYPE_NFIELDS (type) = nsyms;
3293 TYPE_FIELDS (type) = (struct field *)
3294 obstack_alloc (&objfile->type_obstack,
3295 sizeof (struct field) * nsyms);
3297 /* Find the symbols for the parameters and
3298 use them to fill parameter-type information into the function-type.
3299 The parameter symbols can be found in the local_list that we just put them on. */
3300 /* Note that we preserve the order of the parameters, so
3301 that in something like "enum {FOO, LAST_THING=FOO}" we print
3302 FOO, not LAST_THING. */
3304 /* get the parameters types from the local list not the global list
3305 so that the type can be correctly constructed for functions which
3306 have function as parameters */
3307 for (syms = local_list, n = 0; syms; syms = syms->next)
3310 for (j = 0; j < syms->nsyms; j++, n++)
3312 struct symbol *xsym = syms->symbol[j];
3313 TYPE_FIELD_NAME (type, n) = SYMBOL_NAME (xsym);
3314 TYPE_FIELD_TYPE (type, n) = SYMBOL_TYPE (xsym);
3315 TYPE_FIELD_ARTIFICIAL (type, n) = 0;
3316 TYPE_FIELD_BITSIZE (type, n) = 0;
3317 TYPE_FIELD_STATIC_KIND (type, n) = 0;
3320 /* Mark it as having been processed */
3321 TYPE_FLAGS (type) &= ~(TYPE_FLAG_INCOMPLETE);
3323 /* Check whether we need to fix-up a class type with this function's type */
3324 if (fixup_class && (fixup_method == type))
3326 fixup_class_method_type (fixup_class, fixup_method, objfile);
3328 fixup_method = NULL;
3331 /* Set the param list of this level of the context stack
3332 to our local list. Do this only if this function was
3333 called for creating a new block, and not if it was called
3334 simply to get the function type. This prevents recursive
3335 invocations from trashing param_symbols. */
3338 param_symbols = local_list;
3344 /* Read and internalize a native DOC function debug symbol. */
3345 /* This is almost identical to hpread_read_function_type(), except
3346 * for references to dn_bufp->ddocfunc instead of db_bufp->dfunc.
3347 * Since debug information for DOC functions is more likely to be
3348 * volatile, please leave it this way.
3350 static struct type *
3351 hpread_read_doc_function_type (dnttpointer hp_type, union dnttentry *dn_bufp,
3352 struct objfile *objfile, int newblock)
3354 struct type *type, *type1;
3355 struct pending *syms;
3356 struct pending *local_list = NULL;
3359 union dnttentry *paramp;
3363 int record_args = 1;
3365 /* See if we've already read in this type. */
3366 type = hpread_alloc_type (hp_type, objfile);
3367 if (TYPE_CODE (type) == TYPE_CODE_FUNC)
3369 record_args = 0; /* already read in, don't modify type */
3373 /* Nope, so read it in and store it away. */
3374 if (dn_bufp->dblock.kind == DNTT_TYPE_DOC_FUNCTION ||
3375 dn_bufp->dblock.kind == DNTT_TYPE_DOC_MEMFUNC)
3376 type1 = lookup_function_type (hpread_type_lookup (dn_bufp->ddocfunc.retval,
3378 replace_type (type, type1);
3380 /* Mark it -- in the middle of processing */
3381 TYPE_FLAGS (type) |= TYPE_FLAG_INCOMPLETE;
3384 /* Now examine each parameter noting its type, location, and a
3385 wealth of other information. */
3386 if (dn_bufp->dblock.kind == DNTT_TYPE_DOC_FUNCTION ||
3387 dn_bufp->dblock.kind == DNTT_TYPE_DOC_MEMFUNC)
3388 param = dn_bufp->ddocfunc.firstparam;
3389 while (param.word && param.word != DNTTNIL)
3391 paramp = hpread_get_lntt (param.dnttp.index, objfile);
3393 param = paramp->dfparam.nextparam;
3396 name = VT (objfile) + paramp->dfparam.name;
3397 sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
3398 sizeof (struct symbol));
3399 (void) memset (sym, 0, sizeof (struct symbol));
3400 SYMBOL_NAME (sym) = name;
3402 /* Figure out where it lives. */
3403 if (paramp->dfparam.regparam)
3404 SYMBOL_CLASS (sym) = LOC_REGPARM;
3405 else if (paramp->dfparam.indirect)
3406 SYMBOL_CLASS (sym) = LOC_REF_ARG;
3408 SYMBOL_CLASS (sym) = LOC_ARG;
3409 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
3410 if (paramp->dfparam.copyparam)
3412 SYMBOL_VALUE (sym) = paramp->dfparam.location;
3413 #ifdef HPREAD_ADJUST_STACK_ADDRESS
3415 += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile));
3417 /* This is likely a pass-by-invisible reference parameter,
3418 Hack on the symbol class to make GDB happy. */
3419 /* ??rehrauer: This appears to be broken w/r/t to passing
3420 C values of type float and struct. Perhaps this ought
3421 to be highighted as a special case, but for now, just
3422 allowing these to be LOC_ARGs seems to work fine.
3425 SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR;
3429 SYMBOL_VALUE (sym) = paramp->dfparam.location;
3432 SYMBOL_TYPE (sym) = hpread_type_lookup (paramp->dfparam.type, objfile);
3433 /* Add it to the symbol list. */
3434 /* Note 1 (RT) At the moment, add_symbol_to_list() is also being
3435 * called on FPARAM symbols from the process_one_debug_symbol()
3436 * level... so parameters are getting added twice! (this shows
3437 * up in the symbol dump you get from "maint print symbols ...").
3438 * Note 2 (RT) I took out the processing of FPARAM from the
3439 * process_one_debug_symbol() level, so at the moment parameters are only
3440 * being processed here. This seems to have no ill effect.
3442 /* Note 3 (pai/1997-08-11) I removed the add_symbol_to_list() which put
3443 each fparam on the local_symbols list from here. Now we use the
3444 local_list to which fparams are added below, and set the param_symbols
3445 global to point to that at the end of this routine. */
3447 /* elz: I added this new list of symbols which is local to the function.
3448 this list is the one which is actually used to build the type for the
3449 function rather than the gloabal list pointed to by symlist.
3450 Using a global list to keep track of the parameters is wrong, because
3451 this function is called recursively if one parameter happend to be
3452 a function itself with more parameters in it. Adding parameters to the
3453 same global symbol list would not work!
3454 Actually it did work in case of cc compiled programs where you do not check the
3455 parameter lists of the arguments. */
3456 add_symbol_to_list (sym, &local_list);
3459 /* If type was read in earlier, don't bother with modifying
3464 /* Note how many parameters we found. */
3465 TYPE_NFIELDS (type) = nsyms;
3466 TYPE_FIELDS (type) = (struct field *)
3467 obstack_alloc (&objfile->type_obstack,
3468 sizeof (struct field) * nsyms);
3470 /* Find the symbols for the parameters and
3471 use them to fill parameter-type information into the function-type.
3472 The parameter symbols can be found in the local_list that we just put them on. */
3473 /* Note that we preserve the order of the parameters, so
3474 that in something like "enum {FOO, LAST_THING=FOO}" we print
3475 FOO, not LAST_THING. */
3477 /* get the parameters types from the local list not the global list
3478 so that the type can be correctly constructed for functions which
3479 have function as parameters
3481 for (syms = local_list, n = 0; syms; syms = syms->next)
3484 for (j = 0; j < syms->nsyms; j++, n++)
3486 struct symbol *xsym = syms->symbol[j];
3487 TYPE_FIELD_NAME (type, n) = SYMBOL_NAME (xsym);
3488 TYPE_FIELD_TYPE (type, n) = SYMBOL_TYPE (xsym);
3489 TYPE_FIELD_ARTIFICIAL (type, n) = 0;
3490 TYPE_FIELD_BITSIZE (type, n) = 0;
3491 TYPE_FIELD_STATIC_KIND (type, n) = 0;
3495 /* Mark it as having been processed */
3496 TYPE_FLAGS (type) &= ~(TYPE_FLAG_INCOMPLETE);
3498 /* Check whether we need to fix-up a class type with this function's type */
3499 if (fixup_class && (fixup_method == type))
3501 fixup_class_method_type (fixup_class, fixup_method, objfile);
3503 fixup_method = NULL;
3506 /* Set the param list of this level of the context stack
3507 to our local list. Do this only if this function was
3508 called for creating a new block, and not if it was called
3509 simply to get the function type. This prevents recursive
3510 invocations from trashing param_symbols. */
3513 param_symbols = local_list;
3520 /* A file-level variable which keeps track of the current-template
3521 * being processed. Set in hpread_read_struct_type() while processing
3522 * a template type. Referred to in hpread_get_nth_templ_arg().
3523 * Yes, this is a kludge, but it arises from the kludge that already
3524 * exists in symtab.h, namely the fact that they encode
3525 * "template argument n" with fundamental type FT_TEMPLATE_ARG and
3526 * bitlength n. This means that deep in processing fundamental types
3527 * I need to ask the question "what template am I in the middle of?".
3528 * The alternative to stuffing a global would be to pass an argument
3529 * down the chain of calls just for this purpose.
3531 * There may be problems handling nested templates... tough.
3533 static struct type *current_template = NULL;
3535 /* Read in and internalize a structure definition.
3536 * This same routine is called for struct, union, and class types.
3537 * Also called for templates, since they build a very similar
3538 * type entry as for class types.
3541 static struct type *
3542 hpread_read_struct_type (dnttpointer hp_type, union dnttentry *dn_bufp,
3543 struct objfile *objfile)
3545 /* The data members get linked together into a list of struct nextfield's */
3548 struct nextfield *next;
3550 unsigned char attributes; /* store visibility and virtuality info */
3551 #define ATTR_VIRTUAL 1
3552 #define ATTR_PRIVATE 2
3553 #define ATTR_PROTECT 3
3557 /* The methods get linked together into a list of struct next_fn_field's */
3558 struct next_fn_field
3560 struct next_fn_field *next;
3561 struct fn_fieldlist field;
3562 struct fn_field fn_field;
3566 /* The template args get linked together into a list of struct next_template's */
3567 struct next_template
3569 struct next_template *next;
3570 struct template_arg arg;
3573 /* The template instantiations get linked together into a list of these... */
3574 struct next_instantiation
3576 struct next_instantiation *next;
3581 struct type *baseclass;
3582 struct type *memtype;
3583 struct nextfield *list = 0, *tmp_list = 0;
3584 struct next_fn_field *fn_list = 0;
3585 struct next_fn_field *fn_p;
3586 struct next_template *t_new, *t_list = 0;
3587 struct nextfield *new;
3588 struct next_fn_field *fn_new;
3589 struct next_instantiation *i_new, *i_list = 0;
3590 int n, nfields = 0, n_fn_fields = 0, n_fn_fields_total = 0;
3591 int n_base_classes = 0, n_templ_args = 0;
3592 int ninstantiations = 0;
3593 dnttpointer field, fn_field, parent;
3594 union dnttentry *fieldp, *fn_fieldp, *parentp;
3596 int static_member = 0;
3597 int const_member = 0;
3598 int volatile_member = 0;
3599 unsigned long vtbl_offset;
3600 int need_bitvectors = 0;
3601 char *method_name = NULL;
3602 char *method_alias = NULL;
3605 /* Is it something we've already dealt with? */
3606 type = hpread_alloc_type (hp_type, objfile);
3607 if ((TYPE_CODE (type) == TYPE_CODE_STRUCT) ||
3608 (TYPE_CODE (type) == TYPE_CODE_UNION) ||
3609 (TYPE_CODE (type) == TYPE_CODE_CLASS) ||
3610 (TYPE_CODE (type) == TYPE_CODE_TEMPLATE))
3613 /* Get the basic type correct. */
3614 if (dn_bufp->dblock.kind == DNTT_TYPE_STRUCT)
3616 TYPE_CODE (type) = TYPE_CODE_STRUCT;
3617 TYPE_LENGTH (type) = dn_bufp->dstruct.bitlength / 8;
3619 else if (dn_bufp->dblock.kind == DNTT_TYPE_UNION)
3621 TYPE_CODE (type) = TYPE_CODE_UNION;
3622 TYPE_LENGTH (type) = dn_bufp->dunion.bitlength / 8;
3624 else if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS)
3626 TYPE_CODE (type) = TYPE_CODE_CLASS;
3627 TYPE_LENGTH (type) = dn_bufp->dclass.bitlength / 8;
3629 /* Overrides the TYPE_CPLUS_SPECIFIC(type) with allocated memory
3630 * rather than &cplus_struct_default.
3632 allocate_cplus_struct_type (type);
3634 /* Fill in declared-type.
3635 * (The C++ compiler will emit TYPE_CODE_CLASS
3636 * for all 3 of "class", "struct"
3637 * "union", and we have to look at the "class_decl" field if we
3638 * want to know how it was really declared)
3640 /* (0==class, 1==union, 2==struct) */
3641 TYPE_DECLARED_TYPE (type) = dn_bufp->dclass.class_decl;
3643 else if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
3645 /* Get the basic type correct. */
3646 TYPE_CODE (type) = TYPE_CODE_TEMPLATE;
3647 allocate_cplus_struct_type (type);
3648 TYPE_DECLARED_TYPE (type) = DECLARED_TYPE_TEMPLATE;
3654 TYPE_FLAGS (type) &= ~TYPE_FLAG_STUB;
3656 /* For classes, read the parent list.
3657 * Question (RT): Do we need to do this for templates also?
3659 if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS)
3662 /* First read the parent-list (classes from which we derive fields) */
3663 parent = dn_bufp->dclass.parentlist;
3664 while (parent.word && parent.word != DNTTNIL)
3666 parentp = hpread_get_lntt (parent.dnttp.index, objfile);
3668 /* "parentp" should point to a DNTT_TYPE_INHERITANCE record */
3670 /* Get space to record the next field/data-member. */
3671 new = (struct nextfield *) alloca (sizeof (struct nextfield));
3675 FIELD_BITSIZE (list->field) = 0;
3676 FIELD_STATIC_KIND (list->field) = 0;
3678 /* The "classname" field is actually a DNTT pointer to the base class */
3679 baseclass = hpread_type_lookup (parentp->dinheritance.classname,
3681 FIELD_TYPE (list->field) = baseclass;
3683 list->field.name = type_name_no_tag (FIELD_TYPE (list->field));
3685 list->attributes = 0;
3687 /* Check for virtuality of base, and set the
3688 * offset of the base subobject within the object.
3689 * (Offset set to -1 for virtual bases (for now).)
3691 if (parentp->dinheritance.Virtual)
3693 B_SET (&(list->attributes), ATTR_VIRTUAL);
3694 parentp->dinheritance.offset = -1;
3697 FIELD_BITPOS (list->field) = parentp->dinheritance.offset;
3699 /* Check visibility */
3700 switch (parentp->dinheritance.visibility)
3703 B_SET (&(list->attributes), ATTR_PROTECT);
3706 B_SET (&(list->attributes), ATTR_PRIVATE);
3713 parent = parentp->dinheritance.next;
3717 /* For templates, read the template argument list.
3718 * This must be done before processing the member list, because
3719 * the member list may refer back to this. E.g.:
3720 * template <class T1, class T2> class q2 {
3725 * We need to read the argument list "T1", "T2" first.
3727 if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
3729 /* Kludge alert: This stuffs a global "current_template" which
3730 * is referred to by hpread_get_nth_templ_arg(). The global
3731 * is cleared at the end of this routine.
3733 current_template = type;
3735 /* Read in the argument list */
3736 field = dn_bufp->dtemplate.arglist;
3737 while (field.word && field.word != DNTTNIL)
3739 /* Get this template argument */
3740 fieldp = hpread_get_lntt (field.dnttp.index, objfile);
3741 if (fieldp->dblock.kind != DNTT_TYPE_TEMPLATE_ARG)
3743 warning ("Invalid debug info: Template argument entry is of wrong kind");
3746 /* Bump the count */
3748 /* Allocate and fill in a struct next_template */
3749 t_new = (struct next_template *) alloca (sizeof (struct next_template));
3750 t_new->next = t_list;
3752 t_list->arg.name = VT (objfile) + fieldp->dtempl_arg.name;
3753 t_list->arg.type = hpread_read_templ_arg_type (field, fieldp,
3754 objfile, t_list->arg.name);
3755 /* Walk to the next template argument */
3756 field = fieldp->dtempl_arg.nextarg;
3760 TYPE_NTEMPLATE_ARGS (type) = n_templ_args;
3762 if (n_templ_args > 0)
3763 TYPE_TEMPLATE_ARGS (type) = (struct template_arg *)
3764 obstack_alloc (&objfile->type_obstack, sizeof (struct template_arg) * n_templ_args);
3765 for (n = n_templ_args; t_list; t_list = t_list->next)
3768 TYPE_TEMPLATE_ARG (type, n) = t_list->arg;
3771 /* Next read in and internalize all the fields/members. */
3772 if (dn_bufp->dblock.kind == DNTT_TYPE_STRUCT)
3773 field = dn_bufp->dstruct.firstfield;
3774 else if (dn_bufp->dblock.kind == DNTT_TYPE_UNION)
3775 field = dn_bufp->dunion.firstfield;
3776 else if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS)
3777 field = dn_bufp->dclass.memberlist;
3778 else if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
3779 field = dn_bufp->dtemplate.memberlist;
3781 field.word = DNTTNIL;
3783 while (field.word && field.word != DNTTNIL)
3785 fieldp = hpread_get_lntt (field.dnttp.index, objfile);
3787 /* At this point "fieldp" may point to either a DNTT_TYPE_FIELD
3788 * or a DNTT_TYPE_GENFIELD record.
3793 volatile_member = 0;
3795 if (fieldp->dblock.kind == DNTT_TYPE_GENFIELD)
3798 /* The type will be GENFIELD if the field is a method or
3799 * a static member (or some other cases -- see below)
3802 /* Follow a link to get to the record for the field. */
3803 fn_field = fieldp->dgenfield.field;
3804 fn_fieldp = hpread_get_lntt (fn_field.dnttp.index, objfile);
3806 /* Virtual funcs are indicated by a VFUNC which points to the
3809 if (fn_fieldp->dblock.kind == DNTT_TYPE_VFUNC)
3811 vtbl_offset = fn_fieldp->dvfunc.vtbl_offset;
3812 fn_field = fn_fieldp->dvfunc.funcptr;
3813 fn_fieldp = hpread_get_lntt (fn_field.dnttp.index, objfile);
3816 /* A function's entry may be preceded by a modifier which
3817 * labels it static/constant/volatile.
3819 if (fn_fieldp->dblock.kind == DNTT_TYPE_MODIFIER)
3821 static_member = fn_fieldp->dmodifier.m_static;
3822 const_member = fn_fieldp->dmodifier.m_const;
3823 volatile_member = fn_fieldp->dmodifier.m_volatile;
3824 fn_field = fn_fieldp->dmodifier.type;
3825 fn_fieldp = hpread_get_lntt (fn_field.dnttp.index, objfile);
3828 /* Check whether we have a method */
3829 if ((fn_fieldp->dblock.kind == DNTT_TYPE_MEMFUNC) ||
3830 (fn_fieldp->dblock.kind == DNTT_TYPE_FUNCTION) ||
3831 (fn_fieldp->dblock.kind == DNTT_TYPE_DOC_MEMFUNC) ||
3832 (fn_fieldp->dblock.kind == DNTT_TYPE_DOC_FUNCTION))
3838 /* Look up function type of method */
3839 memtype = hpread_type_lookup (fn_field, objfile);
3841 /* Methods can be seen before classes in the SOM records.
3842 If we are processing this class because it's a parameter of a
3843 method, at this point the method's type is actually incomplete;
3844 we'll have to fix it up later; mark the class for this. */
3846 if (TYPE_INCOMPLETE (memtype))
3848 TYPE_FLAGS (type) |= TYPE_FLAG_INCOMPLETE;
3850 warning ("Two classes to fix up for method?? Type information may be incorrect for some classes.");
3852 warning ("Two methods to be fixed up at once?? Type information may be incorrect for some classes.");
3853 fixup_class = type; /* remember this class has to be fixed up */
3854 fixup_method = memtype; /* remember the method type to be used in fixup */
3857 /* HP aCC generates operator names without the "operator" keyword, and
3858 generates null strings as names for operators that are
3859 user-defined type conversions to basic types (e.g. operator int ()).
3860 So try to reconstruct name as best as possible. */
3862 method_name = (char *) (VT (objfile) + fn_fieldp->dfunc.name);
3863 method_alias = (char *) (VT (objfile) + fn_fieldp->dfunc.alias);
3865 if (!method_name || /* no name */
3866 !*method_name || /* or null name */
3867 cplus_mangle_opname (method_name, DMGL_ANSI)) /* or name is an operator like "<" */
3869 char *tmp_name = cplus_demangle (method_alias, DMGL_ANSI);
3870 char *op_string = strstr (tmp_name, "operator");
3871 method_name = xmalloc (strlen (op_string) + 1); /* don't overwrite VT! */
3872 strcpy (method_name, op_string);
3875 /* First check if a method of the same name has already been seen. */
3879 if (STREQ (fn_p->field.name, method_name))
3884 /* If no such method was found, allocate a new entry in the list */
3887 /* Get space to record this member function */
3888 /* Note: alloca used; this will disappear on routine exit */
3889 fn_new = (struct next_fn_field *) alloca (sizeof (struct next_fn_field));
3890 fn_new->next = fn_list;
3893 /* Fill in the fields of the struct nextfield */
3895 /* Record the (unmangled) method name */
3896 fn_list->field.name = method_name;
3897 /* Initial space for overloaded methods */
3898 /* Note: xmalloc is used; this will persist after this routine exits */
3899 fn_list->field.fn_fields = (struct fn_field *) xmalloc (5 * (sizeof (struct fn_field)));
3900 fn_list->field.length = 1; /* Init # of overloaded instances */
3901 fn_list->num_fn_fields = 5; /* # of entries for which space allocated */
3903 ix = 0; /* array index for fn_field */
3904 /* Bump the total count of the distinctly named methods */
3908 /* Another overloaded instance of an already seen method name */
3910 if (++(fn_p->field.length) > fn_p->num_fn_fields)
3912 /* Increase space allocated for overloaded instances */
3913 fn_p->field.fn_fields
3914 = (struct fn_field *) xrealloc (fn_p->field.fn_fields,
3915 (fn_p->num_fn_fields + 5) * sizeof (struct fn_field));
3916 fn_p->num_fn_fields += 5;
3918 ix = fn_p->field.length - 1; /* array index for fn_field */
3921 /* "physname" is intended to be the name of this overloaded instance. */
3922 if ((fn_fieldp->dfunc.language == HP_LANGUAGE_CPLUSPLUS) &&
3924 *method_alias) /* not a null string */
3925 fn_p->field.fn_fields[ix].physname = method_alias;
3927 fn_p->field.fn_fields[ix].physname = method_name;
3928 /* What's expected here is the function type */
3929 /* But mark it as NULL if the method was incompletely processed
3930 We'll fix this up later when the method is fully processed */
3931 if (TYPE_INCOMPLETE (memtype))
3932 fn_p->field.fn_fields[ix].type = NULL;
3934 fn_p->field.fn_fields[ix].type = memtype;
3936 /* For virtual functions, fill in the voffset field with the
3937 * virtual table offset. (This is just copied over from the
3938 * SOM record; not sure if it is what GDB expects here...).
3939 * But if the function is a static method, set it to 1.
3941 * Note that we have to add 1 because 1 indicates a static
3942 * method, and 0 indicates a non-static, non-virtual method */
3945 fn_p->field.fn_fields[ix].voffset = VOFFSET_STATIC;
3947 fn_p->field.fn_fields[ix].voffset = vtbl_offset ? vtbl_offset + 1 : 0;
3949 /* Also fill in the fcontext field with the current
3950 * class. (The latter isn't quite right: should be the baseclass
3951 * that defines the virtual function... Note we do have
3952 * a variable "baseclass" that we could stuff into the fcontext
3953 * field, but "baseclass" isn't necessarily right either,
3954 * since the virtual function could have been defined more
3955 * than one level up).
3958 if (vtbl_offset != 0)
3959 fn_p->field.fn_fields[ix].fcontext = type;
3961 fn_p->field.fn_fields[ix].fcontext = NULL;
3963 /* Other random fields pertaining to this method */
3964 fn_p->field.fn_fields[ix].is_const = const_member;
3965 fn_p->field.fn_fields[ix].is_volatile = volatile_member; /* ?? */
3966 switch (fieldp->dgenfield.visibility)
3969 fn_p->field.fn_fields[ix].is_protected = 1;
3970 fn_p->field.fn_fields[ix].is_private = 0;
3973 fn_p->field.fn_fields[ix].is_protected = 0;
3974 fn_p->field.fn_fields[ix].is_private = 1;
3976 default: /* public */
3977 fn_p->field.fn_fields[ix].is_protected = 0;
3978 fn_p->field.fn_fields[ix].is_private = 0;
3980 fn_p->field.fn_fields[ix].is_stub = 0;
3982 /* HP aCC emits both MEMFUNC and FUNCTION entries for a method;
3983 if the class points to the FUNCTION, there is usually separate
3984 code for the method; but if we have a MEMFUNC, the method has
3985 been inlined (and there is usually no FUNCTION entry)
3986 FIXME Not sure if this test is accurate. pai/1997-08-22 */
3987 if ((fn_fieldp->dblock.kind == DNTT_TYPE_MEMFUNC) ||
3988 (fn_fieldp->dblock.kind == DNTT_TYPE_DOC_MEMFUNC))
3989 fn_p->field.fn_fields[ix].is_inlined = 1;
3991 fn_p->field.fn_fields[ix].is_inlined = 0;
3993 fn_p->field.fn_fields[ix].dummy = 0;
3995 /* Bump the total count of the member functions */
3996 n_fn_fields_total++;
3999 else if (fn_fieldp->dblock.kind == DNTT_TYPE_SVAR)
4001 /* This case is for static data members of classes */
4003 /* pai:: FIXME -- check that "staticmem" bit is set */
4005 /* Get space to record this static member */
4006 new = (struct nextfield *) alloca (sizeof (struct nextfield));
4010 list->field.name = VT (objfile) + fn_fieldp->dsvar.name;
4011 SET_FIELD_PHYSNAME (list->field, 0); /* initialize to empty */
4012 memtype = hpread_type_lookup (fn_fieldp->dsvar.type, objfile);
4014 FIELD_TYPE (list->field) = memtype;
4015 list->attributes = 0;
4016 switch (fieldp->dgenfield.visibility)
4019 B_SET (&(list->attributes), ATTR_PROTECT);
4022 B_SET (&(list->attributes), ATTR_PRIVATE);
4028 else if (fn_fieldp->dblock.kind == DNTT_TYPE_FIELD)
4030 /* FIELDs follow GENFIELDs for fields of anonymous unions.
4031 Code below is replicated from the case for FIELDs further
4032 below, except that fieldp is replaced by fn_fieldp */
4033 if (!fn_fieldp->dfield.a_union)
4034 warning ("Debug info inconsistent: FIELD of anonymous union doesn't have a_union bit set");
4035 /* Get space to record the next field/data-member. */
4036 new = (struct nextfield *) alloca (sizeof (struct nextfield));
4040 list->field.name = VT (objfile) + fn_fieldp->dfield.name;
4041 FIELD_BITPOS (list->field) = fn_fieldp->dfield.bitoffset;
4042 if (fn_fieldp->dfield.bitlength % 8)
4043 list->field.bitsize = fn_fieldp->dfield.bitlength;
4045 list->field.bitsize = 0;
4047 memtype = hpread_type_lookup (fn_fieldp->dfield.type, objfile);
4048 list->field.type = memtype;
4049 list->attributes = 0;
4050 switch (fn_fieldp->dfield.visibility)
4053 B_SET (&(list->attributes), ATTR_PROTECT);
4056 B_SET (&(list->attributes), ATTR_PRIVATE);
4061 else if (fn_fieldp->dblock.kind == DNTT_TYPE_SVAR)
4063 /* Field of anonymous union; union is not inside a class */
4064 if (!fn_fieldp->dsvar.a_union)
4065 warning ("Debug info inconsistent: SVAR field in anonymous union doesn't have a_union bit set");
4066 /* Get space to record the next field/data-member. */
4067 new = (struct nextfield *) alloca (sizeof (struct nextfield));
4071 list->field.name = VT (objfile) + fn_fieldp->dsvar.name;
4072 FIELD_BITPOS (list->field) = 0; /* FIXME is this always true? */
4073 FIELD_BITSIZE (list->field) = 0; /* use length from type */
4074 FIELD_STATIC_KIND (list->field) = 0;
4075 memtype = hpread_type_lookup (fn_fieldp->dsvar.type, objfile);
4076 list->field.type = memtype;
4077 list->attributes = 0;
4078 /* No info to set visibility -- always public */
4081 else if (fn_fieldp->dblock.kind == DNTT_TYPE_DVAR)
4083 /* Field of anonymous union; union is not inside a class */
4084 if (!fn_fieldp->ddvar.a_union)
4085 warning ("Debug info inconsistent: DVAR field in anonymous union doesn't have a_union bit set");
4086 /* Get space to record the next field/data-member. */
4087 new = (struct nextfield *) alloca (sizeof (struct nextfield));
4091 list->field.name = VT (objfile) + fn_fieldp->ddvar.name;
4092 FIELD_BITPOS (list->field) = 0; /* FIXME is this always true? */
4093 FIELD_BITSIZE (list->field) = 0; /* use length from type */
4094 FIELD_STATIC_KIND (list->field) = 0;
4095 memtype = hpread_type_lookup (fn_fieldp->ddvar.type, objfile);
4096 list->field.type = memtype;
4097 list->attributes = 0;
4098 /* No info to set visibility -- always public */
4102 { /* Not a method, nor a static data member, nor an anon union field */
4104 /* This case is for miscellaneous type entries (local enums,
4105 local function templates, etc.) that can be present
4108 /* Enums -- will be handled by other code that takes care
4109 of DNTT_TYPE_ENUM; here we see only DNTT_TYPE_MEMENUM so
4110 it's not clear we could have handled them here at all. */
4111 /* FUNC_TEMPLATE: is handled by other code (?). */
4112 /* MEMACCESS: modified access for inherited member. Not
4113 sure what to do with this, ignoriing it at present. */
4115 /* What other entries can appear following a GENFIELD which
4116 we do not handle above? (MODIFIER, VFUNC handled above.) */
4118 if ((fn_fieldp->dblock.kind != DNTT_TYPE_MEMACCESS) &&
4119 (fn_fieldp->dblock.kind != DNTT_TYPE_MEMENUM) &&
4120 (fn_fieldp->dblock.kind != DNTT_TYPE_FUNC_TEMPLATE))
4121 warning ("Internal error: Unexpected debug record kind %d found following DNTT_GENFIELD",
4122 fn_fieldp->dblock.kind);
4124 /* walk to the next FIELD or GENFIELD */
4125 field = fieldp->dgenfield.nextfield;
4128 else if (fieldp->dblock.kind == DNTT_TYPE_FIELD)
4131 /* Ordinary structure/union/class field */
4132 struct type *anon_union_type;
4134 /* Get space to record the next field/data-member. */
4135 new = (struct nextfield *) alloca (sizeof (struct nextfield));
4139 list->field.name = VT (objfile) + fieldp->dfield.name;
4142 /* A FIELD by itself (without a GENFIELD) can also be a static member */
4143 FIELD_STATIC_KIND (list->field) = 0;
4144 if (fieldp->dfield.staticmem)
4146 FIELD_BITPOS (list->field) = -1;
4147 FIELD_BITSIZE (list->field) = 0;
4150 /* Non-static data member */
4152 FIELD_BITPOS (list->field) = fieldp->dfield.bitoffset;
4153 if (fieldp->dfield.bitlength % 8)
4154 FIELD_BITSIZE (list->field) = fieldp->dfield.bitlength;
4156 FIELD_BITSIZE (list->field) = 0;
4159 memtype = hpread_type_lookup (fieldp->dfield.type, objfile);
4160 FIELD_TYPE (list->field) = memtype;
4161 list->attributes = 0;
4162 switch (fieldp->dfield.visibility)
4165 B_SET (&(list->attributes), ATTR_PROTECT);
4168 B_SET (&(list->attributes), ATTR_PRIVATE);
4174 /* Note 1: First, we have to check if the current field is an anonymous
4175 union. If it is, then *its* fields are threaded along in the
4176 nextfield chain. :-( This was supposed to help debuggers, but is
4177 really just a nuisance since we deal with anonymous unions anyway by
4178 checking that the name is null. So anyway, we skip over the fields
4179 of the anonymous union. pai/1997-08-22 */
4180 /* Note 2: In addition, the bitoffsets for the fields of the anon union
4181 are relative to the enclosing struct, *NOT* relative to the anon
4182 union! This is an even bigger nuisance -- we have to go in and munge
4183 the anon union's type information appropriately. pai/1997-08-22 */
4185 /* Both tasks noted above are done by a separate function. This takes us
4186 to the next FIELD or GENFIELD, skipping anon unions, and recursively
4187 processing intermediate types. */
4188 field = hpread_get_next_skip_over_anon_unions (1, field, &fieldp, objfile);
4193 /* neither field nor genfield ?? is this possible?? */
4194 /* pai:: FIXME walk to the next -- how? */
4195 warning ("Internal error: unexpected DNTT kind %d encountered as field of struct",
4196 fieldp->dblock.kind);
4197 warning ("Skipping remaining fields of struct");
4198 break; /* get out of loop of fields */
4202 /* If it's a template, read in the instantiation list */
4203 if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
4205 ninstantiations = 0;
4206 field = dn_bufp->dtemplate.expansions;
4207 while (field.word && field.word != DNTTNIL)
4209 fieldp = hpread_get_lntt (field.dnttp.index, objfile);
4211 /* The expansions or nextexp should point to a tagdef */
4212 if (fieldp->dblock.kind != DNTT_TYPE_TAGDEF)
4215 i_new = (struct next_instantiation *) alloca (sizeof (struct next_instantiation));
4216 i_new->next = i_list;
4218 i_list->t = hpread_type_lookup (field, objfile);
4221 /* And the "type" field of that should point to a class */
4222 field = fieldp->dtag.type;
4223 fieldp = hpread_get_lntt (field.dnttp.index, objfile);
4224 if (fieldp->dblock.kind != DNTT_TYPE_CLASS)
4227 /* Get the next expansion */
4228 field = fieldp->dclass.nextexp;
4231 TYPE_NINSTANTIATIONS (type) = ninstantiations;
4232 if (ninstantiations > 0)
4233 TYPE_INSTANTIATIONS (type) = (struct type **)
4234 obstack_alloc (&objfile->type_obstack, sizeof (struct type *) * ninstantiations);
4235 for (n = ninstantiations; i_list; i_list = i_list->next)
4238 TYPE_INSTANTIATION (type, n) = i_list->t;
4242 /* Copy the field-list to GDB's symbol table */
4243 TYPE_NFIELDS (type) = nfields;
4244 TYPE_N_BASECLASSES (type) = n_base_classes;
4245 TYPE_FIELDS (type) = (struct field *)
4246 obstack_alloc (&objfile->type_obstack, sizeof (struct field) * nfields);
4247 /* Copy the saved-up fields into the field vector. */
4248 for (n = nfields, tmp_list = list; tmp_list; tmp_list = tmp_list->next)
4251 TYPE_FIELD (type, n) = tmp_list->field;
4254 /* Copy the "function-field-list" (i.e., the list of member
4255 * functions in the class) to GDB's symbol table
4257 TYPE_NFN_FIELDS (type) = n_fn_fields;
4258 TYPE_NFN_FIELDS_TOTAL (type) = n_fn_fields_total;
4259 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *)
4260 obstack_alloc (&objfile->type_obstack, sizeof (struct fn_fieldlist) * n_fn_fields);
4261 for (n = n_fn_fields; fn_list; fn_list = fn_list->next)
4264 TYPE_FN_FIELDLIST (type, n) = fn_list->field;
4267 /* pai:: FIXME -- perhaps each bitvector should be created individually */
4268 for (n = nfields, tmp_list = list; tmp_list; tmp_list = tmp_list->next)
4271 if (tmp_list->attributes)
4273 need_bitvectors = 1;
4278 if (need_bitvectors)
4280 /* pai:: this step probably redundant */
4281 ALLOCATE_CPLUS_STRUCT_TYPE (type);
4283 TYPE_FIELD_VIRTUAL_BITS (type) =
4284 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
4285 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), nfields);
4287 TYPE_FIELD_PRIVATE_BITS (type) =
4288 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
4289 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
4291 TYPE_FIELD_PROTECTED_BITS (type) =
4292 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
4293 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
4295 /* this field vector isn't actually used with HP aCC */
4296 TYPE_FIELD_IGNORE_BITS (type) =
4297 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields));
4298 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields);
4300 while (nfields-- > 0)
4302 if (B_TST (&(list->attributes), ATTR_VIRTUAL))
4303 SET_TYPE_FIELD_VIRTUAL (type, nfields);
4304 if (B_TST (&(list->attributes), ATTR_PRIVATE))
4305 SET_TYPE_FIELD_PRIVATE (type, nfields);
4306 if (B_TST (&(list->attributes), ATTR_PROTECT))
4307 SET_TYPE_FIELD_PROTECTED (type, nfields);
4314 TYPE_FIELD_VIRTUAL_BITS (type) = NULL;
4315 TYPE_FIELD_PROTECTED_BITS (type) = NULL;
4316 TYPE_FIELD_PRIVATE_BITS (type) = NULL;
4319 if (has_vtable (type))
4321 /* Allocate space for class runtime information */
4322 TYPE_RUNTIME_PTR (type) = (struct runtime_info *) xmalloc (sizeof (struct runtime_info));
4323 /* Set flag for vtable */
4324 TYPE_VTABLE (type) = 1;
4325 /* The first non-virtual base class with a vtable. */
4326 TYPE_PRIMARY_BASE (type) = primary_base_class (type);
4327 /* The virtual base list. */
4328 TYPE_VIRTUAL_BASE_LIST (type) = virtual_base_list (type);
4331 TYPE_RUNTIME_PTR (type) = NULL;
4333 /* If this is a local type (C++ - declared inside a function), record file name & line # */
4334 if (hpread_get_scope_depth (dn_bufp, objfile, 1 /* no need for real depth */ ))
4336 TYPE_LOCALTYPE_PTR (type) = (struct local_type_info *) xmalloc (sizeof (struct local_type_info));
4337 TYPE_LOCALTYPE_FILE (type) = (char *) xmalloc (strlen (current_subfile->name) + 1);
4338 strcpy (TYPE_LOCALTYPE_FILE (type), current_subfile->name);
4339 if (current_subfile->line_vector && (current_subfile->line_vector->nitems > 0))
4340 TYPE_LOCALTYPE_LINE (type) = current_subfile->line_vector->item[current_subfile->line_vector->nitems - 1].line;
4342 TYPE_LOCALTYPE_LINE (type) = 0;
4345 TYPE_LOCALTYPE_PTR (type) = NULL;
4347 /* Clear the global saying what template we are in the middle of processing */
4348 current_template = NULL;
4353 /* Adjust the physnames for each static member of a struct
4354 or class type to be something like "A::x"; then various
4355 other pieces of code that do a lookup_symbol on the phyname
4357 TYPE is a pointer to the struct/class type
4358 NAME is a char * (string) which is the class/struct name
4362 fix_static_member_physnames (struct type *type, char *class_name,
4363 struct objfile *objfile)
4367 /* We fix the member names only for classes or structs */
4368 if (TYPE_CODE (type) != TYPE_CODE_STRUCT)
4371 for (i = 0; i < TYPE_NFIELDS (type); i++)
4372 if (TYPE_FIELD_STATIC (type, i))
4374 if (TYPE_FIELD_STATIC_PHYSNAME (type, i))
4375 return; /* physnames are already set */
4377 SET_FIELD_PHYSNAME (TYPE_FIELDS (type)[i],
4378 obstack_alloc (&objfile->type_obstack,
4379 strlen (class_name) + strlen (TYPE_FIELD_NAME (type, i)) + 3));
4380 strcpy (TYPE_FIELD_STATIC_PHYSNAME (type, i), class_name);
4381 strcat (TYPE_FIELD_STATIC_PHYSNAME (type, i), "::");
4382 strcat (TYPE_FIELD_STATIC_PHYSNAME (type, i), TYPE_FIELD_NAME (type, i));
4386 /* Fix-up the type structure for a CLASS so that the type entry
4387 * for a method (previously marked with a null type in hpread_read_struct_type()
4388 * is set correctly to METHOD.
4389 * OBJFILE is as for other such functions.
4393 fixup_class_method_type (struct type *class, struct type *method,
4394 struct objfile *objfile)
4398 if (!class || !method || !objfile)
4401 /* Only for types that have methods */
4402 if ((TYPE_CODE (class) != TYPE_CODE_CLASS) &&
4403 (TYPE_CODE (class) != TYPE_CODE_UNION))
4406 /* Loop over all methods and find the one marked with a NULL type */
4407 for (i = 0; i < TYPE_NFN_FIELDS (class); i++)
4408 for (j = 0; j < TYPE_FN_FIELDLIST_LENGTH (class, i); j++)
4409 if (TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i), j) == NULL)
4411 /* Set the method type */
4412 TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i), j) = method;
4414 /* Break out of both loops -- only one method to fix up in a class */
4419 TYPE_FLAGS (class) &= ~TYPE_FLAG_INCOMPLETE;
4423 /* If we're in the middle of processing a template, get a pointer
4424 * to the Nth template argument.
4425 * An example may make this clearer:
4426 * template <class T1, class T2> class q2 {
4431 * The type for "a" will be "first template arg" and
4432 * the type for "b" will be "second template arg".
4433 * We need to look these up in order to fill in "a" and "b"'s type.
4434 * This is called from hpread_type_lookup().
4436 static struct type *
4437 hpread_get_nth_template_arg (struct objfile *objfile, int n)
4439 if (current_template != NULL)
4440 return TYPE_TEMPLATE_ARG (current_template, n).type;
4442 return lookup_fundamental_type (objfile, FT_TEMPLATE_ARG);
4445 /* Read in and internalize a TEMPL_ARG (template arg) symbol. */
4447 static struct type *
4448 hpread_read_templ_arg_type (dnttpointer hp_type, union dnttentry *dn_bufp,
4449 struct objfile *objfile, char *name)
4453 /* See if it's something we've already deal with. */
4454 type = hpread_alloc_type (hp_type, objfile);
4455 if (TYPE_CODE (type) == TYPE_CODE_TEMPLATE_ARG)
4458 /* Nope. Fill in the appropriate fields. */
4459 TYPE_CODE (type) = TYPE_CODE_TEMPLATE_ARG;
4460 TYPE_LENGTH (type) = 0;
4461 TYPE_NFIELDS (type) = 0;
4462 TYPE_NAME (type) = name;
4466 /* Read in and internalize a set debug symbol. */
4468 static struct type *
4469 hpread_read_set_type (dnttpointer hp_type, union dnttentry *dn_bufp,
4470 struct objfile *objfile)
4474 /* See if it's something we've already deal with. */
4475 type = hpread_alloc_type (hp_type, objfile);
4476 if (TYPE_CODE (type) == TYPE_CODE_SET)
4479 /* Nope. Fill in the appropriate fields. */
4480 TYPE_CODE (type) = TYPE_CODE_SET;
4481 TYPE_LENGTH (type) = dn_bufp->dset.bitlength / 8;
4482 TYPE_NFIELDS (type) = 0;
4483 TYPE_TARGET_TYPE (type) = hpread_type_lookup (dn_bufp->dset.subtype,
4488 /* Read in and internalize an array debug symbol. */
4490 static struct type *
4491 hpread_read_array_type (dnttpointer hp_type, union dnttentry *dn_bufp,
4492 struct objfile *objfile)
4496 /* Allocate an array type symbol.
4497 * Why no check for already-read here, like in the other
4498 * hpread_read_xxx_type routines? Because it kept us
4499 * from properly determining the size of the array!
4501 type = hpread_alloc_type (hp_type, objfile);
4503 TYPE_CODE (type) = TYPE_CODE_ARRAY;
4505 /* Although the hp-symtab.h does not *require* this to be the case,
4506 * GDB is assuming that "arrayisbytes" and "elemisbytes" be consistent.
4507 * I.e., express both array-length and element-length in bits,
4508 * or express both array-length and element-length in bytes.
4510 if (!((dn_bufp->darray.arrayisbytes && dn_bufp->darray.elemisbytes) ||
4511 (!dn_bufp->darray.arrayisbytes && !dn_bufp->darray.elemisbytes)))
4513 warning ("error in hpread_array_type.\n");
4516 else if (dn_bufp->darray.arraylength == 0x7fffffff)
4518 /* The HP debug format represents char foo[]; as an array with
4519 * length 0x7fffffff. Internally GDB wants to represent this
4520 * as an array of length zero.
4522 TYPE_LENGTH (type) = 0;
4524 else if (dn_bufp->darray.arrayisbytes)
4525 TYPE_LENGTH (type) = dn_bufp->darray.arraylength;
4526 else /* arraylength is in bits */
4527 TYPE_LENGTH (type) = dn_bufp->darray.arraylength / 8;
4529 TYPE_TARGET_TYPE (type) = hpread_type_lookup (dn_bufp->darray.elemtype,
4532 /* The one "field" is used to store the subscript type */
4533 /* Since C and C++ multi-dimensional arrays are simply represented
4534 * as: array of array of ..., we only need one subscript-type
4535 * per array. This subscript type is typically a subrange of integer.
4536 * If this gets extended to support languages like Pascal, then
4537 * we need to fix this to represent multi-dimensional arrays properly.
4539 TYPE_NFIELDS (type) = 1;
4540 TYPE_FIELDS (type) = (struct field *)
4541 obstack_alloc (&objfile->type_obstack, sizeof (struct field));
4542 TYPE_FIELD_TYPE (type, 0) = hpread_type_lookup (dn_bufp->darray.indextype,
4547 /* Read in and internalize a subrange debug symbol. */
4548 static struct type *
4549 hpread_read_subrange_type (dnttpointer hp_type, union dnttentry *dn_bufp,
4550 struct objfile *objfile)
4554 /* Is it something we've already dealt with. */
4555 type = hpread_alloc_type (hp_type, objfile);
4556 if (TYPE_CODE (type) == TYPE_CODE_RANGE)
4559 /* Nope, internalize it. */
4560 TYPE_CODE (type) = TYPE_CODE_RANGE;
4561 TYPE_LENGTH (type) = dn_bufp->dsubr.bitlength / 8;
4562 TYPE_NFIELDS (type) = 2;
4564 = (struct field *) obstack_alloc (&objfile->type_obstack,
4565 2 * sizeof (struct field));
4567 if (dn_bufp->dsubr.dyn_low)
4568 TYPE_FIELD_BITPOS (type, 0) = 0;
4570 TYPE_FIELD_BITPOS (type, 0) = dn_bufp->dsubr.lowbound;
4572 if (dn_bufp->dsubr.dyn_high)
4573 TYPE_FIELD_BITPOS (type, 1) = -1;
4575 TYPE_FIELD_BITPOS (type, 1) = dn_bufp->dsubr.highbound;
4576 TYPE_TARGET_TYPE (type) = hpread_type_lookup (dn_bufp->dsubr.subtype,
4581 /* struct type * hpread_type_lookup(hp_type, objfile)
4583 * hp_type: A pointer into the DNTT specifying what type we
4584 * are about to "look up"., or else [for fundamental types
4585 * like int, float, ...] an "immediate" structure describing
4588 * Return value: A pointer to a "struct type" (representation of a
4589 * type in GDB's internal symbol table - see gdbtypes.h)
4590 * Routine description:
4591 * There are a variety of places when scanning the DNTT when we
4592 * need to interpret a "type" field. The simplest and most basic
4593 * example is when we're processing the symbol table record
4594 * for a data symbol (a SVAR or DVAR record). That has
4595 * a "type" field specifying the type of the data symbol. That
4596 * "type" field is either an "immediate" type specification (for the
4597 * fundamental types) or a DNTT pointer (for more complicated types).
4598 * For the more complicated types, we may or may not have already
4599 * processed the pointed-to type. (Multiple data symbols can of course
4600 * share the same type).
4601 * The job of hpread_type_lookup() is to process this "type" field.
4602 * Most of the real work is done in subroutines. Here we interpret
4603 * the immediate flag. If not immediate, chase the DNTT pointer to
4604 * find our way to the SOM record describing the type, switch on
4605 * the SOM kind, and then call an appropriate subroutine depending
4606 * on what kind of type we are constructing. (e.g., an array type,
4607 * a struct/class type, etc).
4609 static struct type *
4610 hpread_type_lookup (dnttpointer hp_type, struct objfile *objfile)
4612 union dnttentry *dn_bufp;
4613 struct type *tmp_type;
4615 /* First see if it's a simple builtin type. */
4616 if (hp_type.dntti.immediate)
4618 /* If this is a template argument, the argument number is
4619 * encoded in the bitlength. All other cases, just return
4620 * GDB's representation of this fundamental type.
4622 if (hp_type.dntti.type == HP_TYPE_TEMPLATE_ARG)
4623 return hpread_get_nth_template_arg (objfile, hp_type.dntti.bitlength);
4625 return lookup_fundamental_type (objfile,
4626 hpread_type_translate (hp_type));
4629 /* Not a builtin type. We'll have to read it in. */
4630 if (hp_type.dnttp.index < LNTT_SYMCOUNT (objfile))
4631 dn_bufp = hpread_get_lntt (hp_type.dnttp.index, objfile);
4633 /* This is a fancy way of returning NULL */
4634 return lookup_fundamental_type (objfile, FT_VOID);
4636 switch (dn_bufp->dblock.kind)
4638 case DNTT_TYPE_SRCFILE:
4639 case DNTT_TYPE_MODULE:
4640 case DNTT_TYPE_ENTRY:
4641 case DNTT_TYPE_BEGIN:
4643 case DNTT_TYPE_IMPORT:
4644 case DNTT_TYPE_LABEL:
4645 case DNTT_TYPE_FPARAM:
4646 case DNTT_TYPE_SVAR:
4647 case DNTT_TYPE_DVAR:
4648 case DNTT_TYPE_CONST:
4649 case DNTT_TYPE_MEMENUM:
4650 case DNTT_TYPE_VARIANT:
4651 case DNTT_TYPE_FILE:
4652 case DNTT_TYPE_WITH:
4653 case DNTT_TYPE_COMMON:
4654 case DNTT_TYPE_COBSTRUCT:
4655 case DNTT_TYPE_XREF:
4657 case DNTT_TYPE_MACRO:
4658 case DNTT_TYPE_BLOCKDATA:
4659 case DNTT_TYPE_CLASS_SCOPE:
4660 case DNTT_TYPE_MEMACCESS:
4661 case DNTT_TYPE_INHERITANCE:
4662 case DNTT_TYPE_OBJECT_ID:
4663 case DNTT_TYPE_FRIEND_CLASS:
4664 case DNTT_TYPE_FRIEND_FUNC:
4665 /* These are not types - something went wrong. */
4666 /* This is a fancy way of returning NULL */
4667 return lookup_fundamental_type (objfile, FT_VOID);
4669 case DNTT_TYPE_FUNCTION:
4670 /* We wind up here when dealing with class member functions
4671 * (called from hpread_read_struct_type(), i.e. when processing
4672 * the class definition itself).
4674 return hpread_read_function_type (hp_type, dn_bufp, objfile, 0);
4676 case DNTT_TYPE_DOC_FUNCTION:
4677 return hpread_read_doc_function_type (hp_type, dn_bufp, objfile, 0);
4679 case DNTT_TYPE_TYPEDEF:
4681 /* A typedef - chase it down by making a recursive call */
4682 struct type *structtype = hpread_type_lookup (dn_bufp->dtype.type,
4685 /* The following came from the base hpread.c that we inherited.
4686 * It is WRONG so I have commented it out. - RT
4690 suffix = VT (objfile) + dn_bufp->dtype.name;
4691 TYPE_NAME (structtype) = suffix;
4693 * ... further explanation ....
4695 * What we have here is a typedef pointing to a typedef.
4700 * What we desire to build is (these are pictures
4701 * of "struct type"'s):
4703 * +---------+ +----------+ +------------+
4704 * | typedef | | typedef | | fund. type |
4705 * | type| -> | type| -> | |
4706 * | "fum" | | "foo" | | "int" |
4707 * +---------+ +----------+ +------------+
4709 * What this commented-out code is doing is smashing the
4710 * name of pointed-to-type to be the same as the pointed-from
4711 * type. So we wind up with something like:
4713 * +---------+ +----------+ +------------+
4714 * | typedef | | typedef | | fund. type |
4715 * | type| -> | type| -> | |
4716 * | "fum" | | "fum" | | "fum" |
4717 * +---------+ +----------+ +------------+
4724 case DNTT_TYPE_TAGDEF:
4726 /* Just a little different from above. We have to tack on
4727 * an identifier of some kind (struct, union, enum, class, etc).
4729 struct type *structtype = hpread_type_lookup (dn_bufp->dtype.type,
4731 char *prefix, *suffix;
4732 suffix = VT (objfile) + dn_bufp->dtype.name;
4734 /* Lookup the next type in the list. It should be a structure,
4735 * union, class, enum, or template type.
4736 * We will need to attach that to our name.
4738 if (dn_bufp->dtype.type.dnttp.index < LNTT_SYMCOUNT (objfile))
4739 dn_bufp = hpread_get_lntt (dn_bufp->dtype.type.dnttp.index, objfile);
4742 complaint (&symfile_complaints, "error in hpread_type_lookup().");
4746 if (dn_bufp->dblock.kind == DNTT_TYPE_STRUCT)
4750 else if (dn_bufp->dblock.kind == DNTT_TYPE_UNION)
4754 else if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS)
4756 /* Further field for CLASS saying how it was really declared */
4757 /* 0==class, 1==union, 2==struct */
4758 if (dn_bufp->dclass.class_decl == 0)
4760 else if (dn_bufp->dclass.class_decl == 1)
4762 else if (dn_bufp->dclass.class_decl == 2)
4767 else if (dn_bufp->dblock.kind == DNTT_TYPE_ENUM)
4771 else if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
4773 prefix = "template ";
4780 /* Build the correct name. */
4781 TYPE_NAME (structtype)
4782 = (char *) obstack_alloc (&objfile->type_obstack,
4783 strlen (prefix) + strlen (suffix) + 1);
4784 TYPE_NAME (structtype) = strcpy (TYPE_NAME (structtype), prefix);
4785 TYPE_NAME (structtype) = strcat (TYPE_NAME (structtype), suffix);
4786 TYPE_TAG_NAME (structtype) = suffix;
4788 /* For classes/structs, we have to set the static member "physnames"
4789 to point to strings like "Class::Member" */
4790 if (TYPE_CODE (structtype) == TYPE_CODE_STRUCT)
4791 fix_static_member_physnames (structtype, suffix, objfile);
4796 case DNTT_TYPE_POINTER:
4797 /* Pointer type - call a routine in gdbtypes.c that constructs
4798 * the appropriate GDB type.
4800 return make_pointer_type (
4801 hpread_type_lookup (dn_bufp->dptr.pointsto,
4805 case DNTT_TYPE_REFERENCE:
4806 /* C++ reference type - call a routine in gdbtypes.c that constructs
4807 * the appropriate GDB type.
4809 return make_reference_type (
4810 hpread_type_lookup (dn_bufp->dreference.pointsto,
4814 case DNTT_TYPE_ENUM:
4815 return hpread_read_enum_type (hp_type, dn_bufp, objfile);
4817 return hpread_read_set_type (hp_type, dn_bufp, objfile);
4818 case DNTT_TYPE_SUBRANGE:
4819 return hpread_read_subrange_type (hp_type, dn_bufp, objfile);
4820 case DNTT_TYPE_ARRAY:
4821 return hpread_read_array_type (hp_type, dn_bufp, objfile);
4822 case DNTT_TYPE_STRUCT:
4823 case DNTT_TYPE_UNION:
4824 return hpread_read_struct_type (hp_type, dn_bufp, objfile);
4825 case DNTT_TYPE_FIELD:
4826 return hpread_type_lookup (dn_bufp->dfield.type, objfile);
4828 case DNTT_TYPE_FUNCTYPE:
4829 /* Here we want to read the function SOMs and return a
4830 * type for it. We get here, for instance, when processing
4831 * pointer-to-function type.
4833 return hpread_read_function_type (hp_type, dn_bufp, objfile, 0);
4835 case DNTT_TYPE_PTRMEM:
4836 /* Declares a C++ pointer-to-data-member type.
4837 * The "pointsto" field defines the class,
4838 * while the "memtype" field defines the pointed-to-type.
4841 struct type *ptrmemtype;
4842 struct type *class_type;
4843 struct type *memtype;
4844 memtype = hpread_type_lookup (dn_bufp->dptrmem.memtype,
4846 class_type = hpread_type_lookup (dn_bufp->dptrmem.pointsto,
4848 ptrmemtype = alloc_type (objfile);
4849 smash_to_member_type (ptrmemtype, class_type, memtype);
4850 return make_pointer_type (ptrmemtype, NULL);
4854 case DNTT_TYPE_PTRMEMFUNC:
4855 /* Defines a C++ pointer-to-function-member type.
4856 * The "pointsto" field defines the class,
4857 * while the "memtype" field defines the pointed-to-type.
4860 struct type *ptrmemtype;
4861 struct type *class_type;
4862 struct type *functype;
4863 struct type *retvaltype;
4866 class_type = hpread_type_lookup (dn_bufp->dptrmem.pointsto,
4868 functype = hpread_type_lookup (dn_bufp->dptrmem.memtype,
4870 retvaltype = TYPE_TARGET_TYPE (functype);
4871 nargs = TYPE_NFIELDS (functype);
4872 ptrmemtype = alloc_type (objfile);
4874 smash_to_method_type (ptrmemtype, class_type, retvaltype,
4875 TYPE_FIELDS (functype),
4876 TYPE_NFIELDS (functype),
4878 return make_pointer_type (ptrmemtype, NULL);
4882 case DNTT_TYPE_CLASS:
4883 return hpread_read_struct_type (hp_type, dn_bufp, objfile);
4885 case DNTT_TYPE_GENFIELD:
4886 /* Chase pointer from GENFIELD to FIELD, and make recursive
4889 return hpread_type_lookup (dn_bufp->dgenfield.field, objfile);
4891 case DNTT_TYPE_VFUNC:
4892 /* C++ virtual function.
4893 * We get here in the course of processing a class type which
4894 * contains virtual functions. Just go through another level
4895 * of indirection to get to the pointed-to function SOM.
4897 return hpread_type_lookup (dn_bufp->dvfunc.funcptr, objfile);
4899 case DNTT_TYPE_MODIFIER:
4900 /* Check the modifiers and then just make a recursive call on
4901 * the "type" pointed to by the modifier DNTT.
4903 * pai:: FIXME -- do we ever want to handle "m_duplicate" and
4904 * "m_void" modifiers? Is static_flag really needed here?
4905 * (m_static used for methods of classes, elsewhere).
4907 tmp_type = make_cv_type (dn_bufp->dmodifier.m_const,
4908 dn_bufp->dmodifier.m_volatile,
4909 hpread_type_lookup (dn_bufp->dmodifier.type, objfile),
4914 case DNTT_TYPE_MEMFUNC:
4915 /* Member function. Treat like a function.
4916 * I think we get here in the course of processing a
4917 * pointer-to-member-function type...
4919 return hpread_read_function_type (hp_type, dn_bufp, objfile, 0);
4921 case DNTT_TYPE_DOC_MEMFUNC:
4922 return hpread_read_doc_function_type (hp_type, dn_bufp, objfile, 0);
4924 case DNTT_TYPE_TEMPLATE:
4925 /* Template - sort of the header for a template definition,
4926 * which like a class, points to a member list and also points
4927 * to a TEMPLATE_ARG list of type-arguments.
4929 return hpread_read_struct_type (hp_type, dn_bufp, objfile);
4931 case DNTT_TYPE_TEMPLATE_ARG:
4934 /* The TEMPLATE record points to an argument list of
4935 * TEMPLATE_ARG records, each of which describes one
4936 * of the type-arguments.
4938 name = VT (objfile) + dn_bufp->dtempl_arg.name;
4939 return hpread_read_templ_arg_type (hp_type, dn_bufp, objfile, name);
4942 case DNTT_TYPE_FUNC_TEMPLATE:
4943 /* We wind up here when processing a TEMPLATE type,
4944 * if the template has member function(s).
4945 * Treat it like a FUNCTION.
4947 return hpread_read_function_type (hp_type, dn_bufp, objfile, 0);
4949 case DNTT_TYPE_LINK:
4950 /* The LINK record is used to link up templates with instantiations.
4951 * There is no type associated with the LINK record per se.
4953 return lookup_fundamental_type (objfile, FT_VOID);
4955 /* Also not yet handled... */
4956 /* case DNTT_TYPE_DYN_ARRAY_DESC: */
4957 /* case DNTT_TYPE_DESC_SUBRANGE: */
4958 /* case DNTT_TYPE_BEGIN_EXT: */
4959 /* case DNTT_TYPE_INLN: */
4960 /* case DNTT_TYPE_INLN_LIST: */
4961 /* case DNTT_TYPE_ALIAS: */
4963 /* A fancy way of returning NULL */
4964 return lookup_fundamental_type (objfile, FT_VOID);
4969 hpread_record_lines (struct subfile *subfile, sltpointer s_idx,
4970 sltpointer e_idx, struct objfile *objfile,
4973 union sltentry *sl_bufp;
4975 while (s_idx <= e_idx)
4977 sl_bufp = hpread_get_slt (s_idx, objfile);
4978 /* Only record "normal" entries in the SLT. */
4979 if (sl_bufp->snorm.sltdesc == SLT_NORMAL
4980 || sl_bufp->snorm.sltdesc == SLT_EXIT)
4981 record_line (subfile, sl_bufp->snorm.line,
4982 sl_bufp->snorm.address + offset);
4983 else if (sl_bufp->snorm.sltdesc == SLT_NORMAL_OFFSET)
4984 record_line (subfile, sl_bufp->snormoff.line,
4985 sl_bufp->snormoff.address + offset);
4991 /* Given a function "f" which is a member of a class, find
4992 * the classname that it is a member of. Used to construct
4993 * the name (e.g., "c::f") which GDB will put in the
4994 * "demangled name" field of the function's symbol.
4995 * Called from hpread_process_one_debug_symbol()
4996 * If "f" is not a member function, return NULL.
4999 class_of (struct type *functype)
5001 struct type *first_param_type;
5002 char *first_param_name;
5003 struct type *pointed_to_type;
5006 /* Check that the function has a first argument "this",
5007 * and that "this" is a pointer to a class. If not,
5008 * functype is not a member function, so return NULL.
5010 if (TYPE_NFIELDS (functype) == 0)
5012 first_param_name = TYPE_FIELD_NAME (functype, 0);
5013 if (first_param_name == NULL)
5014 return NULL; /* paranoia */
5015 if (strcmp (first_param_name, "this"))
5017 first_param_type = TYPE_FIELD_TYPE (functype, 0);
5018 if (first_param_type == NULL)
5019 return NULL; /* paranoia */
5020 if (TYPE_CODE (first_param_type) != TYPE_CODE_PTR)
5023 /* Get the thing that "this" points to, check that
5024 * it's a class, and get its class name.
5026 pointed_to_type = TYPE_TARGET_TYPE (first_param_type);
5027 if (pointed_to_type == NULL)
5028 return NULL; /* paranoia */
5029 if (TYPE_CODE (pointed_to_type) != TYPE_CODE_CLASS)
5031 class_name = TYPE_NAME (pointed_to_type);
5032 if (class_name == NULL)
5033 return NULL; /* paranoia */
5035 /* The class name may be of the form "class c", in which case
5036 * we want to strip off the leading "class ".
5038 if (strncmp (class_name, "class ", 6) == 0)
5044 /* Internalize one native debug symbol.
5045 * Called in a loop from hpread_expand_symtab().
5054 * index: Index of this symbol
5055 * at_module_boundary_p Pointer to boolean flag to control caller's loop.
5059 hpread_process_one_debug_symbol (union dnttentry *dn_bufp, char *name,
5060 struct section_offsets *section_offsets,
5061 struct objfile *objfile, CORE_ADDR text_offset,
5062 int text_size, char *filename, int index,
5063 int *at_module_boundary_p)
5068 int offset = ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
5069 int data_offset = ANOFFSET (section_offsets, SECT_OFF_DATA (objfile));
5070 union dnttentry *dn_temp;
5071 dnttpointer hp_type;
5073 struct context_stack *new;
5074 char *class_scope_name;
5076 /* Allocate one GDB debug symbol and fill in some default values. */
5077 sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
5078 sizeof (struct symbol));
5079 memset (sym, 0, sizeof (struct symbol));
5080 SYMBOL_NAME (sym) = obsavestring (name, strlen (name), &objfile->symbol_obstack);
5081 SYMBOL_LANGUAGE (sym) = language_auto;
5082 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
5083 SYMBOL_LINE (sym) = 0;
5084 SYMBOL_VALUE (sym) = 0;
5085 SYMBOL_CLASS (sym) = LOC_TYPEDEF;
5087 /* Just a trick in case the SOM debug symbol is a type definition.
5088 * There are routines that are set up to build a GDB type symbol, given
5089 * a SOM dnttpointer. So we set up a dummy SOM dnttpointer "hp_type".
5090 * This allows us to call those same routines.
5092 hp_type.dnttp.extension = 1;
5093 hp_type.dnttp.immediate = 0;
5094 hp_type.dnttp.global = 0;
5095 hp_type.dnttp.index = index;
5097 /* This "type" is the type of SOM record.
5098 * Switch on SOM type.
5100 type = dn_bufp->dblock.kind;
5103 case DNTT_TYPE_SRCFILE:
5104 /* This type of symbol indicates from which source file or
5105 * include file any following data comes. It may indicate:
5107 * o The start of an entirely new source file (and thus
5110 * o The start of a different source file due to #include
5112 * o The end of an include file and the return to the original
5113 * file. Thus if "foo.c" includes "bar.h", we see first
5114 * a SRCFILE for foo.c, then one for bar.h, and then one for
5117 * If it indicates the start of a new module then we must
5118 * finish the symbol table of the previous module
5119 * (if any) and start accumulating a new symbol table.
5123 if (!last_source_file)
5126 * A note on "last_source_file": this is a char* pointing
5127 * to the actual file name. "start_symtab" sets it,
5128 * "end_symtab" clears it.
5130 * So if "last_source_file" is NULL, then either this is
5131 * the first record we are looking at, or a previous call
5132 * to "end_symtab()" was made to close out the previous
5133 * module. Since we're now quitting the scan loop when we
5134 * see a MODULE END record, we should never get here, except
5135 * in the case that we're not using the quick look-up tables
5136 * and have to use the old system as a fall-back.
5138 start_symtab (name, NULL, valu);
5139 record_debugformat ("HP");
5140 SL_INDEX (objfile) = dn_bufp->dsfile.address;
5145 /* Either a new include file, or a SRCFILE record
5146 * saying we are back in the main source (or out of
5147 * a nested include file) again.
5149 SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5151 dn_bufp->dsfile.address,
5155 /* A note on "start_subfile". This routine will check
5156 * the name we pass it and look for an existing subfile
5157 * of that name. There's thus only one sub-file for the
5158 * actual source (e.g. for "foo.c" in foo.c), despite the
5159 * fact that we'll see lots of SRCFILE entries for foo.c
5162 start_subfile (name, NULL);
5165 case DNTT_TYPE_MODULE:
5167 * We no longer ignore DNTT_TYPE_MODULE symbols. The module
5168 * represents the meaningful semantic structure of a compilation
5169 * unit. We expect to start the psymtab-to-symtab expansion
5170 * looking at a MODULE entry, and to end it at the corresponding
5173 *--Begin outdated comments
5175 * This record signifies the start of a new source module
5176 * In C/C++ there is no explicit "module" construct in the language,
5177 * but each compilation unit is implicitly a module and they
5178 * do emit the DNTT_TYPE_MODULE records.
5179 * The end of the module is marked by a matching DNTT_TYPE_END record.
5181 * The reason GDB gets away with ignoring the DNTT_TYPE_MODULE record
5182 * is it notices the DNTT_TYPE_END record for the previous
5183 * module (see comments under DNTT_TYPE_END case), and then treats
5184 * the next DNTT_TYPE_SRCFILE record as if it were the module-start record.
5185 * (i.e., it makes a start_symtab() call).
5186 * This scheme seems a little convoluted, but I'll leave it
5187 * alone on the principle "if it ain't broke don't fix
5190 *-- End outdated comments
5194 if (!last_source_file)
5196 /* Start of a new module. We know this because "last_source_file"
5197 * is NULL, which can only happen the first time or if we just
5198 * made a call to end_symtab() to close out the previous module.
5200 start_symtab (name, NULL, valu);
5201 SL_INDEX (objfile) = dn_bufp->dmodule.address;
5205 /* This really shouldn't happen if we're using the quick
5206 * look-up tables, as it would mean we'd scanned past an
5207 * END MODULE entry. But if we're not using the tables,
5208 * we started the module on the SRCFILE entry, so it's ok.
5209 * For now, accept this.
5211 /* warning( "Error expanding psymtab, missed module end, found entry for %s",
5214 *at_module_boundary_p = -1;
5217 start_subfile (name, NULL);
5220 case DNTT_TYPE_FUNCTION:
5221 case DNTT_TYPE_ENTRY:
5222 /* A function or secondary entry point. */
5223 valu = dn_bufp->dfunc.lowaddr + offset;
5225 /* Record lines up to this point. */
5226 SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5228 dn_bufp->dfunc.address,
5231 WITHIN_FUNCTION (objfile) = 1;
5232 CURRENT_FUNCTION_VALUE (objfile) = valu;
5234 /* Stack must be empty now. */
5235 if (context_stack_depth != 0)
5236 lbrac_unmatched_complaint ((char *) symnum);
5237 new = push_context (0, valu);
5239 /* Built a type for the function. This includes processing
5240 * the symbol records for the function parameters.
5242 SYMBOL_CLASS (sym) = LOC_BLOCK;
5243 SYMBOL_TYPE (sym) = hpread_read_function_type (hp_type, dn_bufp, objfile, 1);
5245 /* All functions in C++ have prototypes. For C we don't have enough
5246 information in the debug info. */
5247 if (SYMBOL_LANGUAGE (s) == language_cplus)
5248 TYPE_FLAGS (SYMBOL_TYPE (s)) |= TYPE_FLAG_PROTOTYPED;
5250 /* The "SYMBOL_NAME" field is expected to be the mangled name
5251 * (if any), which we get from the "alias" field of the SOM record
5254 if ((dn_bufp->dfunc.language == HP_LANGUAGE_CPLUSPLUS) &&
5255 dn_bufp->dfunc.alias && /* has an alias */
5256 *(char *) (VT (objfile) + dn_bufp->dfunc.alias)) /* not a null string */
5257 SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->dfunc.alias;
5259 SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->dfunc.name;
5261 /* Special hack to get around HP compilers' insistence on
5262 * reporting "main" as "_MAIN_" for C/C++ */
5263 if ((strcmp (SYMBOL_NAME (sym), "_MAIN_") == 0) &&
5264 (strcmp (VT (objfile) + dn_bufp->dfunc.name, "main") == 0))
5265 SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->dfunc.name;
5267 /* The SYMBOL_CPLUS_DEMANGLED_NAME field is expected to
5268 * be the demangled name.
5270 if (dn_bufp->dfunc.language == HP_LANGUAGE_CPLUSPLUS)
5272 /* SYMBOL_INIT_DEMANGLED_NAME is a macro which winds up
5273 * calling the demangler in libiberty (cplus_demangle()) to
5274 * do the job. This generally does the job, even though
5275 * it's intended for the GNU compiler and not the aCC compiler
5276 * Note that SYMBOL_INIT_DEMANGLED_NAME calls the
5277 * demangler with arguments DMGL_PARAMS | DMGL_ANSI.
5278 * Generally, we don't want params when we display
5279 * a demangled name, but when I took out the DMGL_PARAMS,
5280 * some things broke, so I'm leaving it in here, and
5281 * working around the issue in stack.c. - RT
5283 SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->symbol_obstack);
5284 if ((SYMBOL_NAME (sym) == VT (objfile) + dn_bufp->dfunc.alias) &&
5285 (!SYMBOL_CPLUS_DEMANGLED_NAME (sym)))
5288 /* Well, the symbol name is mangled, but the
5289 * demangler in libiberty failed so the demangled
5290 * field is still NULL. Try to
5291 * do the job ourselves based on the "name" field
5292 * in the SOM record. A complication here is that
5293 * the name field contains only the function name
5294 * (like "f"), whereas we want the class qualification
5295 * (as in "c::f"). Try to reconstruct that.
5300 basename = VT (objfile) + dn_bufp->dfunc.name;
5301 classname = class_of (SYMBOL_TYPE (sym));
5304 dem_name = xmalloc (strlen (basename) + strlen (classname) + 3);
5305 strcpy (dem_name, classname);
5306 strcat (dem_name, "::");
5307 strcat (dem_name, basename);
5308 SYMBOL_CPLUS_DEMANGLED_NAME (sym) = dem_name;
5309 SYMBOL_LANGUAGE (sym) = language_cplus;
5314 /* Add the function symbol to the list of symbols in this blockvector */
5315 if (dn_bufp->dfunc.global)
5316 add_symbol_to_list (sym, &global_symbols);
5318 add_symbol_to_list (sym, &file_symbols);
5321 /* Search forward to the next BEGIN and also read
5322 * in the line info up to that point.
5323 * Not sure why this is needed.
5324 * In HP FORTRAN this code is harmful since there
5325 * may not be a BEGIN after the FUNCTION.
5326 * So I made it C/C++ specific. - RT
5328 if (dn_bufp->dfunc.language == HP_LANGUAGE_C ||
5329 dn_bufp->dfunc.language == HP_LANGUAGE_CPLUSPLUS)
5331 while (dn_bufp->dblock.kind != DNTT_TYPE_BEGIN)
5333 dn_bufp = hpread_get_lntt (++index, objfile);
5334 if (dn_bufp->dblock.extension)
5337 SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5339 dn_bufp->dbegin.address,
5341 SYMBOL_LINE (sym) = hpread_get_line (dn_bufp->dbegin.address, objfile);
5343 record_line (current_subfile, SYMBOL_LINE (sym), valu);
5346 case DNTT_TYPE_DOC_FUNCTION:
5347 valu = dn_bufp->ddocfunc.lowaddr + offset;
5349 /* Record lines up to this point. */
5350 SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5352 dn_bufp->ddocfunc.address,
5355 WITHIN_FUNCTION (objfile) = 1;
5356 CURRENT_FUNCTION_VALUE (objfile) = valu;
5357 /* Stack must be empty now. */
5358 if (context_stack_depth != 0)
5359 lbrac_unmatched_complaint ((char *) symnum);
5360 new = push_context (0, valu);
5362 /* Built a type for the function. This includes processing
5363 * the symbol records for the function parameters.
5365 SYMBOL_CLASS (sym) = LOC_BLOCK;
5366 SYMBOL_TYPE (sym) = hpread_read_doc_function_type (hp_type, dn_bufp, objfile, 1);
5368 /* The "SYMBOL_NAME" field is expected to be the mangled name
5369 * (if any), which we get from the "alias" field of the SOM record
5372 if ((dn_bufp->ddocfunc.language == HP_LANGUAGE_CPLUSPLUS) &&
5373 dn_bufp->ddocfunc.alias && /* has an alias */
5374 *(char *) (VT (objfile) + dn_bufp->ddocfunc.alias)) /* not a null string */
5375 SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->ddocfunc.alias;
5377 SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->ddocfunc.name;
5379 /* Special hack to get around HP compilers' insistence on
5380 * reporting "main" as "_MAIN_" for C/C++ */
5381 if ((strcmp (SYMBOL_NAME (sym), "_MAIN_") == 0) &&
5382 (strcmp (VT (objfile) + dn_bufp->ddocfunc.name, "main") == 0))
5383 SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->ddocfunc.name;
5385 if (dn_bufp->ddocfunc.language == HP_LANGUAGE_CPLUSPLUS)
5388 /* SYMBOL_INIT_DEMANGLED_NAME is a macro which winds up
5389 * calling the demangler in libiberty (cplus_demangle()) to
5390 * do the job. This generally does the job, even though
5391 * it's intended for the GNU compiler and not the aCC compiler
5392 * Note that SYMBOL_INIT_DEMANGLED_NAME calls the
5393 * demangler with arguments DMGL_PARAMS | DMGL_ANSI.
5394 * Generally, we don't want params when we display
5395 * a demangled name, but when I took out the DMGL_PARAMS,
5396 * some things broke, so I'm leaving it in here, and
5397 * working around the issue in stack.c. - RT
5399 SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->symbol_obstack);
5401 if ((SYMBOL_NAME (sym) == VT (objfile) + dn_bufp->ddocfunc.alias) &&
5402 (!SYMBOL_CPLUS_DEMANGLED_NAME (sym)))
5405 /* Well, the symbol name is mangled, but the
5406 * demangler in libiberty failed so the demangled
5407 * field is still NULL. Try to
5408 * do the job ourselves based on the "name" field
5409 * in the SOM record. A complication here is that
5410 * the name field contains only the function name
5411 * (like "f"), whereas we want the class qualification
5412 * (as in "c::f"). Try to reconstruct that.
5417 basename = VT (objfile) + dn_bufp->ddocfunc.name;
5418 classname = class_of (SYMBOL_TYPE (sym));
5421 dem_name = xmalloc (strlen (basename) + strlen (classname) + 3);
5422 strcpy (dem_name, classname);
5423 strcat (dem_name, "::");
5424 strcat (dem_name, basename);
5425 SYMBOL_CPLUS_DEMANGLED_NAME (sym) = dem_name;
5426 SYMBOL_LANGUAGE (sym) = language_cplus;
5431 /* Add the function symbol to the list of symbols in this blockvector */
5432 if (dn_bufp->ddocfunc.global)
5433 add_symbol_to_list (sym, &global_symbols);
5435 add_symbol_to_list (sym, &file_symbols);
5438 /* Search forward to the next BEGIN and also read
5439 * in the line info up to that point.
5440 * Not sure why this is needed.
5441 * In HP FORTRAN this code is harmful since there
5442 * may not be a BEGIN after the FUNCTION.
5443 * So I made it C/C++ specific. - RT
5445 if (dn_bufp->ddocfunc.language == HP_LANGUAGE_C ||
5446 dn_bufp->ddocfunc.language == HP_LANGUAGE_CPLUSPLUS)
5448 while (dn_bufp->dblock.kind != DNTT_TYPE_BEGIN)
5450 dn_bufp = hpread_get_lntt (++index, objfile);
5451 if (dn_bufp->dblock.extension)
5454 SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5456 dn_bufp->dbegin.address,
5458 SYMBOL_LINE (sym) = hpread_get_line (dn_bufp->dbegin.address, objfile);
5460 record_line (current_subfile, SYMBOL_LINE (sym), valu);
5463 case DNTT_TYPE_BEGIN:
5464 /* Begin a new scope. */
5465 if (context_stack_depth == 1 /* this means we're at function level */ &&
5466 context_stack[0].name != NULL /* this means it's a function */ &&
5467 context_stack[0].depth == 0 /* this means it's the first BEGIN
5468 we've seen after the FUNCTION */
5471 /* This is the first BEGIN after a FUNCTION.
5472 * We ignore this one, since HP compilers always insert
5473 * at least one BEGIN, i.e. it's:
5479 * (possibly nested BEGIN ... END's if there are inner { } blocks)
5483 * By ignoring this first BEGIN, the local symbols get treated
5484 * as belonging to the function scope, and "print func::local_sym"
5485 * works (which is what we want).
5488 /* All we do here is increase the depth count associated with
5489 * the FUNCTION entry in the context stack. This ensures that
5490 * the next BEGIN we see (if any), representing a real nested { }
5491 * block, will get processed.
5494 context_stack[0].depth++;
5500 /* Record lines up to this SLT pointer. */
5501 SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5503 dn_bufp->dbegin.address,
5505 /* Calculate start address of new scope */
5506 valu = hpread_get_location (dn_bufp->dbegin.address, objfile);
5507 valu += offset; /* Relocate for dynamic loading */
5508 /* We use the scope start DNTT index as nesting depth identifier! */
5509 desc = hpread_get_scope_start (dn_bufp->dbegin.address, objfile);
5510 new = push_context (desc, valu);
5517 /* Valid end kinds are:
5526 SL_INDEX (objfile) = hpread_record_lines (current_subfile,
5528 dn_bufp->dend.address,
5530 switch (dn_bufp->dend.endkind)
5532 case DNTT_TYPE_MODULE:
5533 /* Ending a module ends the symbol table for that module.
5534 * Calling end_symtab() has the side effect of clearing the
5535 * last_source_file pointer, which in turn signals
5536 * process_one_debug_symbol() to treat the next DNTT_TYPE_SRCFILE
5537 * record as a module-begin.
5539 valu = text_offset + text_size + offset;
5541 /* Tell our caller that we're done with expanding the
5542 * debug information for a module.
5544 *at_module_boundary_p = 1;
5546 /* Don't do this, as our caller will do it!
5548 * (void) end_symtab (valu, objfile, 0);
5552 case DNTT_TYPE_FUNCTION:
5553 /* Ending a function, well, ends the function's scope. */
5554 dn_temp = hpread_get_lntt (dn_bufp->dend.beginscope.dnttp.index,
5556 valu = dn_temp->dfunc.hiaddr + offset;
5557 /* Insert func params into local list */
5558 merge_symbol_lists (¶m_symbols, &local_symbols);
5559 new = pop_context ();
5560 /* Make a block for the local symbols within. */
5561 finish_block (new->name, &local_symbols, new->old_blocks,
5562 new->start_addr, valu, objfile);
5563 WITHIN_FUNCTION (objfile) = 0; /* This may have to change for Pascal */
5564 local_symbols = new->locals;
5565 param_symbols = new->params;
5568 case DNTT_TYPE_BEGIN:
5569 if (context_stack_depth == 1 &&
5570 context_stack[0].name != NULL &&
5571 context_stack[0].depth == 1)
5573 /* This is the END corresponding to the
5574 * BEGIN which we ignored - see DNTT_TYPE_BEGIN case above.
5576 context_stack[0].depth--;
5580 /* Ending a local scope. */
5581 valu = hpread_get_location (dn_bufp->dend.address, objfile);
5582 /* Why in the hell is this needed? */
5583 valu += offset + 9; /* Relocate for dynamic loading */
5584 new = pop_context ();
5585 desc = dn_bufp->dend.beginscope.dnttp.index;
5586 if (desc != new->depth)
5587 lbrac_mismatch_complaint ((char *) symnum);
5589 /* Make a block for the local symbols within. */
5590 finish_block (new->name, &local_symbols, new->old_blocks,
5591 new->start_addr, valu, objfile);
5592 local_symbols = new->locals;
5593 param_symbols = new->params;
5597 case DNTT_TYPE_WITH:
5598 /* Since we ignore the DNTT_TYPE_WITH that starts the scope,
5599 * we can ignore the DNTT_TYPE_END that ends it.
5603 case DNTT_TYPE_COMMON:
5604 /* End a FORTRAN common block. We don't currently handle these */
5605 complaint (&symfile_complaints,
5606 "unhandled symbol in hp-symtab-read.c: DNTT_TYPE_COMMON/DNTT_TYPE_END.\n");
5609 case DNTT_TYPE_CLASS_SCOPE:
5611 /* pai: FIXME Not handling nested classes for now -- must
5612 * maintain a stack */
5613 class_scope_name = NULL;
5616 /* End a class scope */
5617 valu = hpread_get_location (dn_bufp->dend.address, objfile);
5618 /* Why in the hell is this needed? */
5619 valu += offset + 9; /* Relocate for dynamic loading */
5620 new = pop_context ();
5621 desc = dn_bufp->dend.beginscope.dnttp.index;
5622 if (desc != new->depth)
5623 lbrac_mismatch_complaint ((char *) symnum);
5624 /* Make a block for the local symbols within. */
5625 finish_block (new->name, &local_symbols, new->old_blocks,
5626 new->start_addr, valu, objfile);
5627 local_symbols = new->locals;
5628 param_symbols = new->params;
5633 complaint (&symfile_complaints,
5634 "internal error in hp-symtab-read.c: Unexpected DNTT_TYPE_END kind.");
5639 /* DNTT_TYPE_IMPORT is not handled */
5641 case DNTT_TYPE_LABEL:
5642 SYMBOL_NAMESPACE (sym) = LABEL_NAMESPACE;
5645 case DNTT_TYPE_FPARAM:
5646 /* Function parameters. */
5647 /* Note 1: This code was present in the 4.16 sources, and then
5648 removed, because fparams are handled in
5649 hpread_read_function_type(). However, while fparam symbols
5650 are indeed handled twice, this code here cannot be removed
5651 because then they don't get added to the local symbol list of
5652 the function's code block, which leads to a failure to look
5653 up locals, "this"-relative member names, etc. So I've put
5654 this code back in. pai/1997-07-21 */
5655 /* Note 2: To fix a defect, we stopped adding FPARAMS to local_symbols
5656 in hpread_read_function_type(), so FPARAMS had to be handled
5657 here. I changed the location to be the appropriate argument
5658 kinds rather than LOC_LOCAL. pai/1997-08-08 */
5659 /* Note 3: Well, the fix in Note 2 above broke argument printing
5660 in traceback frames, and further it makes assumptions about the
5661 order of the FPARAM entries from HP compilers (cc and aCC in particular
5662 generate them in reverse orders -- fixing one breaks for the other).
5663 So I've added code in hpread_read_function_type() to add fparams
5664 to a param_symbols list for the current context level. These are
5665 then merged into local_symbols when a function end is reached.
5668 break; /* do nothing; handled in hpread_read_function_type() */
5670 #if 0 /* Old code */
5671 if (dn_bufp->dfparam.regparam)
5672 SYMBOL_CLASS (sym) = LOC_REGISTER;
5673 else if (dn_bufp->dfparam.indirect)
5674 SYMBOL_CLASS (sym) = LOC_REF_ARG;
5676 SYMBOL_CLASS (sym) = LOC_ARG;
5677 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
5678 if (dn_bufp->dfparam.copyparam)
5680 SYMBOL_VALUE (sym) = dn_bufp->dfparam.location;
5681 #ifdef HPREAD_ADJUST_STACK_ADDRESS
5683 += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile));
5687 SYMBOL_VALUE (sym) = dn_bufp->dfparam.location;
5688 SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dfparam.type, objfile);
5689 add_symbol_to_list (sym, &fparam_symbols);
5693 case DNTT_TYPE_SVAR:
5694 /* Static variables. */
5695 SYMBOL_CLASS (sym) = LOC_STATIC;
5697 /* Note: There is a case that arises with globals in shared
5698 * libraries where we need to set the address to LOC_INDIRECT.
5699 * This case is if you have a global "g" in one library, and
5700 * it is referenced "extern <type> g;" in another library.
5701 * If we're processing the symbols for the referencing library,
5702 * we'll see a global "g", but in this case the address given
5703 * in the symbol table contains a pointer to the real "g".
5704 * We use the storage class LOC_INDIRECT to indicate this. RT
5706 if (is_in_import_list (SYMBOL_NAME (sym), objfile))
5707 SYMBOL_CLASS (sym) = LOC_INDIRECT;
5709 SYMBOL_VALUE_ADDRESS (sym) = dn_bufp->dsvar.location + data_offset;
5710 SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dsvar.type, objfile);
5712 if (dn_bufp->dsvar.global)
5713 add_symbol_to_list (sym, &global_symbols);
5715 else if (WITHIN_FUNCTION (objfile))
5716 add_symbol_to_list (sym, &local_symbols);
5719 add_symbol_to_list (sym, &file_symbols);
5721 if (dn_bufp->dsvar.thread_specific)
5723 /* Thread-local variable.
5725 SYMBOL_CLASS (sym) = LOC_HP_THREAD_LOCAL_STATIC;
5726 SYMBOL_BASEREG (sym) = CR27_REGNUM;
5728 if (objfile->flags & OBJF_SHARED)
5731 * This variable is not only thread local but
5732 * in a shared library.
5734 * Alas, the shared lib structures are private
5735 * to "somsolib.c". But C lets us point to one.
5739 if (objfile->obj_private == NULL)
5740 error ("Internal error in reading shared library information.");
5742 so = ((obj_private_data_t *) (objfile->obj_private))->so_info;
5744 error ("Internal error in reading shared library information.");
5746 /* Thread-locals in shared libraries do NOT have the
5747 * standard offset ("data_offset"), so we re-calculate
5748 * where to look for this variable, using a call-back
5749 * to interpret the private shared-library data.
5751 SYMBOL_VALUE_ADDRESS (sym) = dn_bufp->dsvar.location +
5752 so_lib_thread_start_addr (so);
5757 case DNTT_TYPE_DVAR:
5758 /* Dynamic variables. */
5759 if (dn_bufp->ddvar.regvar)
5760 SYMBOL_CLASS (sym) = LOC_REGISTER;
5762 SYMBOL_CLASS (sym) = LOC_LOCAL;
5764 SYMBOL_VALUE (sym) = dn_bufp->ddvar.location;
5765 #ifdef HPREAD_ADJUST_STACK_ADDRESS
5767 += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile));
5769 SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->ddvar.type, objfile);
5770 if (dn_bufp->ddvar.global)
5771 add_symbol_to_list (sym, &global_symbols);
5772 else if (WITHIN_FUNCTION (objfile))
5773 add_symbol_to_list (sym, &local_symbols);
5775 add_symbol_to_list (sym, &file_symbols);
5778 case DNTT_TYPE_CONST:
5779 /* A constant (pascal?). */
5780 SYMBOL_CLASS (sym) = LOC_CONST;
5781 SYMBOL_VALUE (sym) = dn_bufp->dconst.location;
5782 SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dconst.type, objfile);
5783 if (dn_bufp->dconst.global)
5784 add_symbol_to_list (sym, &global_symbols);
5785 else if (WITHIN_FUNCTION (objfile))
5786 add_symbol_to_list (sym, &local_symbols);
5788 add_symbol_to_list (sym, &file_symbols);
5791 case DNTT_TYPE_TYPEDEF:
5792 /* A typedef. We do want to process these, since a name is
5793 * added to the namespace for the typedef'ed name.
5795 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
5796 SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dtype.type, objfile);
5797 if (dn_bufp->dtype.global)
5798 add_symbol_to_list (sym, &global_symbols);
5799 else if (WITHIN_FUNCTION (objfile))
5800 add_symbol_to_list (sym, &local_symbols);
5802 add_symbol_to_list (sym, &file_symbols);
5805 case DNTT_TYPE_TAGDEF:
5807 int global = dn_bufp->dtag.global;
5808 /* Structure, union, enum, template, or class tag definition */
5809 /* We do want to process these, since a name is
5810 * added to the namespace for the tag name (and if C++ class,
5811 * for the typename also).
5813 SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
5815 /* The tag contains in its "type" field a pointer to the
5816 * DNTT_TYPE_STRUCT, DNTT_TYPE_UNION, DNTT_TYPE_ENUM,
5817 * DNTT_TYPE_CLASS or DNTT_TYPE_TEMPLATE
5818 * record that actually defines the type.
5820 SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dtype.type, objfile);
5821 TYPE_NAME (sym->type) = SYMBOL_NAME (sym);
5822 TYPE_TAG_NAME (sym->type) = SYMBOL_NAME (sym);
5823 if (dn_bufp->dtag.global)
5824 add_symbol_to_list (sym, &global_symbols);
5825 else if (WITHIN_FUNCTION (objfile))
5826 add_symbol_to_list (sym, &local_symbols);
5828 add_symbol_to_list (sym, &file_symbols);
5830 /* If this is a C++ class, then we additionally
5831 * need to define a typedef for the
5832 * class type. E.g., so that the name "c" becomes visible as
5833 * a type name when the user says "class c { ... }".
5834 * In order to figure this out, we need to chase down the "type"
5835 * field to get to the DNTT_TYPE_CLASS record.
5837 * We also add the typename for ENUM. Though this isn't
5838 * strictly correct, it is necessary because of the debug info
5839 * generated by the aCC compiler, in which we cannot
5840 * distinguish between:
5843 * typedef enum { ... } e;
5844 * I.e., the compiler emits the same debug info for the above
5845 * two cases, in both cases "e" appearing as a tagdef.
5846 * Therefore go ahead and generate the typename so that
5847 * "ptype e" will work in the above cases.
5849 * We also add the typename for TEMPLATE, so as to allow "ptype t"
5850 * when "t" is a template name.
5852 if (dn_bufp->dtype.type.dnttp.index < LNTT_SYMCOUNT (objfile))
5853 dn_bufp = hpread_get_lntt (dn_bufp->dtag.type.dnttp.index, objfile);
5856 complaint (&symfile_complaints, "error processing class tagdef");
5859 if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS ||
5860 dn_bufp->dblock.kind == DNTT_TYPE_ENUM ||
5861 dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE)
5863 struct symbol *newsym;
5865 newsym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
5866 sizeof (struct symbol));
5867 memset (newsym, 0, sizeof (struct symbol));
5868 SYMBOL_NAME (newsym) = name;
5869 SYMBOL_LANGUAGE (newsym) = language_auto;
5870 SYMBOL_NAMESPACE (newsym) = VAR_NAMESPACE;
5871 SYMBOL_LINE (newsym) = 0;
5872 SYMBOL_VALUE (newsym) = 0;
5873 SYMBOL_CLASS (newsym) = LOC_TYPEDEF;
5874 SYMBOL_TYPE (newsym) = sym->type;
5876 add_symbol_to_list (newsym, &global_symbols);
5877 else if (WITHIN_FUNCTION (objfile))
5878 add_symbol_to_list (newsym, &local_symbols);
5880 add_symbol_to_list (newsym, &file_symbols);
5885 case DNTT_TYPE_POINTER:
5886 /* Declares a pointer type. Should not be necessary to do anything
5887 * with the type at this level; these are processed
5888 * at the hpread_type_lookup() level.
5892 case DNTT_TYPE_ENUM:
5893 /* Declares an enum type. Should not be necessary to do anything
5894 * with the type at this level; these are processed
5895 * at the hpread_type_lookup() level.
5899 case DNTT_TYPE_MEMENUM:
5900 /* Member of enum */
5901 /* Ignored at this level, but hpread_read_enum_type() will take
5902 * care of walking the list of enumeration members.
5907 /* Declares a set type. Should not be necessary to do anything
5908 * with the type at this level; these are processed
5909 * at the hpread_type_lookup() level.
5913 case DNTT_TYPE_SUBRANGE:
5914 /* Declares a subrange type. Should not be necessary to do anything
5915 * with the type at this level; these are processed
5916 * at the hpread_type_lookup() level.
5920 case DNTT_TYPE_ARRAY:
5921 /* Declares an array type. Should not be necessary to do anything
5922 * with the type at this level; these are processed
5923 * at the hpread_type_lookup() level.
5927 case DNTT_TYPE_STRUCT:
5928 case DNTT_TYPE_UNION:
5929 /* Declares an struct/union type.
5930 * Should not be necessary to do anything
5931 * with the type at this level; these are processed
5932 * at the hpread_type_lookup() level.
5936 case DNTT_TYPE_FIELD:
5937 /* Structure/union/class field */
5938 /* Ignored at this level, but hpread_read_struct_type() will take
5939 * care of walking the list of structure/union/class members.
5943 /* DNTT_TYPE_VARIANT is not handled by GDB */
5945 /* DNTT_TYPE_FILE is not handled by GDB */
5947 case DNTT_TYPE_FUNCTYPE:
5949 /* Ignored at this level, handled within hpread_type_lookup() */
5952 case DNTT_TYPE_WITH:
5953 /* This is emitted within methods to indicate "with <class>"
5954 * scoping rules (i.e., indicate that the class data members
5955 * are directly visible).
5956 * However, since GDB already infers this by looking at the
5957 * "this" argument, interpreting the DNTT_TYPE_WITH
5958 * symbol record is unnecessary.
5962 case DNTT_TYPE_COMMON:
5963 /* FORTRAN common. Not yet handled. */
5964 complaint (&symfile_complaints,
5965 "unhandled symbol in hp-symtab-read.c: DNTT_TYPE_COMMON.");
5968 /* DNTT_TYPE_COBSTRUCT is not handled by GDB. */
5969 /* DNTT_TYPE_XREF is not handled by GDB. */
5970 /* DNTT_TYPE_SA is not handled by GDB. */
5971 /* DNTT_TYPE_MACRO is not handled by GDB */
5973 case DNTT_TYPE_BLOCKDATA:
5974 /* Not sure what this is - part of FORTRAN support maybe?
5975 * Anyway, not yet handled.
5977 complaint (&symfile_complaints,
5978 "unhandled symbol in hp-symtab-read.c: DNTT_TYPE_BLOCKDATA.");
5981 case DNTT_TYPE_CLASS_SCOPE:
5985 /* The compiler brackets member functions with a CLASS_SCOPE/END
5986 * pair of records, presumably to put them in a different scope
5987 * from the module scope where they are normally defined.
5988 * E.g., in the situation:
5990 * void c::f() { ...}
5991 * The member function "c::f" will be bracketed by a CLASS_SCOPE/END.
5992 * This causes "break f" at the module level to pick the
5993 * the file-level function f(), not the member function
5994 * (which needs to be referenced via "break c::f").
5996 * Here we record the class name to generate the demangled names of
5997 * member functions later.
5999 * FIXME Not being used now for anything -- cplus_demangle seems
6000 * enough for getting the class-qualified names of functions. We
6001 * may need this for handling nested classes and types. */
6003 /* pai: FIXME Not handling nested classes for now -- need to
6004 * maintain a stack */
6006 dn_temp = hpread_get_lntt (dn_bufp->dclass_scope.type.dnttp.index, objfile);
6007 if (dn_temp->dblock.kind == DNTT_TYPE_TAGDEF)
6008 class_scope_name = VT (objfile) + dn_temp->dtag.name;
6010 class_scope_name = NULL;
6014 /* Begin a new scope. */
6015 SL_INDEX (objfile) = hpread_record_lines (current_subfile,
6017 dn_bufp->dclass_scope.address,
6019 valu = hpread_get_location (dn_bufp->dclass_scope.address, objfile);
6020 valu += offset; /* Relocate for dynamic loading */
6021 desc = hpread_get_scope_start (dn_bufp->dclass_scope.address, objfile);
6022 /* We use the scope start DNTT index as the nesting depth identifier! */
6023 new = push_context (desc, valu);
6027 case DNTT_TYPE_REFERENCE:
6028 /* Declares a C++ reference type. Should not be necessary to do anything
6029 * with the type at this level; these are processed
6030 * at the hpread_type_lookup() level.
6034 case DNTT_TYPE_PTRMEM:
6035 /* Declares a C++ pointer-to-data-member type. This does not
6036 * need to be handled at this level; being a type description it
6037 * is instead handled at the hpread_type_lookup() level.
6041 case DNTT_TYPE_PTRMEMFUNC:
6042 /* Declares a C++ pointer-to-function-member type. This does not
6043 * need to be handled at this level; being a type description it
6044 * is instead handled at the hpread_type_lookup() level.
6048 case DNTT_TYPE_CLASS:
6049 /* Declares a class type.
6050 * Should not be necessary to do anything
6051 * with the type at this level; these are processed
6052 * at the hpread_type_lookup() level.
6056 case DNTT_TYPE_GENFIELD:
6057 /* I believe this is used for class member functions */
6058 /* Ignored at this level, but hpread_read_struct_type() will take
6059 * care of walking the list of class members.
6063 case DNTT_TYPE_VFUNC:
6064 /* Virtual function */
6065 /* This does not have to be handled at this level; handled in
6066 * the course of processing class symbols.
6070 case DNTT_TYPE_MEMACCESS:
6071 /* DDE ignores this symbol table record.
6072 * It has something to do with "modified access" to class members.
6073 * I'll assume we can safely ignore it too.
6077 case DNTT_TYPE_INHERITANCE:
6078 /* These don't have to be handled here, since they are handled
6079 * within hpread_read_struct_type() in the process of constructing
6084 case DNTT_TYPE_FRIEND_CLASS:
6085 case DNTT_TYPE_FRIEND_FUNC:
6086 /* These can safely be ignored, as GDB doesn't need this
6087 * info. DDE only uses it in "describe". We may later want
6088 * to extend GDB's "ptype" to give this info, but for now
6089 * it seems safe enough to ignore it.
6093 case DNTT_TYPE_MODIFIER:
6094 /* Intended to supply "modified access" to a type */
6095 /* From the way DDE handles this, it looks like it always
6096 * modifies a type. Therefore it is safe to ignore it at this
6097 * level, and handle it in hpread_type_lookup().
6101 case DNTT_TYPE_OBJECT_ID:
6102 /* Just ignore this - that's all DDE does */
6105 case DNTT_TYPE_MEMFUNC:
6106 /* Member function */
6107 /* This does not have to be handled at this level; handled in
6108 * the course of processing class symbols.
6112 case DNTT_TYPE_DOC_MEMFUNC:
6113 /* Member function */
6114 /* This does not have to be handled at this level; handled in
6115 * the course of processing class symbols.
6119 case DNTT_TYPE_TEMPLATE:
6120 /* Template - sort of the header for a template definition,
6121 * which like a class, points to a member list and also points
6122 * to a TEMPLATE_ARG list of type-arguments.
6123 * We do not need to process TEMPLATE records at this level though.
6127 case DNTT_TYPE_TEMPLATE_ARG:
6128 /* The TEMPLATE record points to an argument list of
6129 * TEMPLATE_ARG records, each of which describes one
6130 * of the type-arguments.
6131 * We do not need to process TEMPLATE_ARG records at this level though.
6135 case DNTT_TYPE_FUNC_TEMPLATE:
6136 /* This will get emitted for member functions of templates.
6137 * But we don't need to process this record at this level though,
6138 * we will process it in the course of processing a TEMPLATE
6143 case DNTT_TYPE_LINK:
6144 /* The LINK record is used to link up templates with instantiations. */
6145 /* It is not clear why this is needed, and furthermore aCC does
6146 * not appear to generate this, so I think we can safely ignore it. - RT
6150 /* DNTT_TYPE_DYN_ARRAY_DESC is not handled by GDB */
6151 /* DNTT_TYPE_DESC_SUBRANGE is not handled by GDB */
6152 /* DNTT_TYPE_BEGIN_EXT is not handled by GDB */
6153 /* DNTT_TYPE_INLN is not handled by GDB */
6154 /* DNTT_TYPE_INLN_LIST is not handled by GDB */
6155 /* DNTT_TYPE_ALIAS is not handled by GDB */
6162 /* Get nesting depth for a DNTT entry.
6163 * DN_BUFP points to a DNTT entry.
6164 * OBJFILE is the object file.
6165 * REPORT_NESTED is a flag; if 0, real nesting depth is
6166 * reported, if it is 1, the function simply returns a
6167 * non-zero value if the nesting depth is anything > 0.
6169 * Return value is an integer. 0 => not a local type / name
6170 * positive return => type or name is local to some
6171 * block or function.
6175 /* elz: ATTENTION: FIXME: NOTE: WARNING!!!!
6176 this function now returns 0 right away. It was taking too much time
6177 at start up. Now, though, the local types are not handled correctly.
6182 hpread_get_scope_depth (union dnttentry *dn_bufp, struct objfile *objfile,
6186 register union dnttentry *dn_tmp;
6187 register short depth = 0;
6188 /****************************/
6190 /****************************/
6192 index = (((char *) dn_bufp) - LNTT (objfile)) / (sizeof (struct dntt_type_block));
6194 while (--index >= 0)
6196 dn_tmp = hpread_get_lntt (index, objfile);
6197 switch (dn_tmp->dblock.kind)
6199 case DNTT_TYPE_MODULE:
6202 /* index is signed int; dnttp.index is 29-bit unsigned int! */
6203 index = (int) dn_tmp->dend.beginscope.dnttp.index;
6205 case DNTT_TYPE_BEGIN:
6206 case DNTT_TYPE_FUNCTION:
6207 case DNTT_TYPE_DOC_FUNCTION:
6208 case DNTT_TYPE_WITH:
6209 case DNTT_TYPE_COMMON:
6210 case DNTT_TYPE_CLASS_SCOPE:
6222 /* Adjust the bitoffsets for all fields of an anonymous union of
6223 type TYPE by negative BITS. This handles HP aCC's hideous habit
6224 of giving members of anonymous unions bit offsets relative to the
6225 enclosing structure instead of relative to the union itself. */
6228 hpread_adjust_bitoffsets (struct type *type, int bits)
6232 /* This is done only for unions; caller had better check that
6233 it is an anonymous one. */
6234 if (TYPE_CODE (type) != TYPE_CODE_UNION)
6237 /* Adjust each field; since this is a union, there are no base
6238 classes. Also no static membes. Also, no need for recursion as
6239 the members of this union if themeselves structs or unions, have
6240 the correct bitoffsets; if an anonymous union is a member of this
6241 anonymous union, the code in hpread_read_struct_type() will
6244 for (i = 0; i < TYPE_NFIELDS (type); i++)
6245 TYPE_FIELD_BITPOS (type, i) -= bits;
6248 /* Because of quirks in HP compilers' treatment of anonymous unions inside
6249 classes, we have to chase through a chain of threaded FIELD entries.
6250 If we encounter an anonymous union in the chain, we must recursively skip over
6253 This function does a "next" in the chain of FIELD entries, but transparently
6254 skips over anonymous unions' fields (recursively).
6256 Inputs are the number of times to do "next" at the top level, the dnttpointer
6257 (FIELD) and entry pointer (FIELDP) for the dntt record corresponding to it,
6258 and the ubiquitous objfile parameter. (Note: FIELDP is a **.) Return value
6259 is a dnttpointer for the new field after all the skipped ones */
6262 hpread_get_next_skip_over_anon_unions (int skip_fields, dnttpointer field,
6263 union dnttentry **fieldp,
6264 struct objfile *objfile)
6266 struct type *anon_type;
6271 for (i = 0; i < skip_fields; i++)
6273 /* Get type of item we're looking at now; recursively processes the types
6274 of these intermediate items we skip over, so they aren't lost. */
6275 anon_type = hpread_type_lookup ((*fieldp)->dfield.type, objfile);
6276 anon_type = CHECK_TYPEDEF (anon_type);
6277 bitoffset = (*fieldp)->dfield.bitoffset;
6278 name = VT (objfile) + (*fieldp)->dfield.name;
6279 /* First skip over one item to avoid stack death on recursion */
6280 field = (*fieldp)->dfield.nextfield;
6281 *fieldp = hpread_get_lntt (field.dnttp.index, objfile);
6282 /* Do we have another anonymous union? If so, adjust the bitoffsets
6283 of its members and skip over its members. */
6284 if ((TYPE_CODE (anon_type) == TYPE_CODE_UNION) &&
6285 (!name || STREQ (name, "")))
6287 hpread_adjust_bitoffsets (anon_type, bitoffset);
6288 field = hpread_get_next_skip_over_anon_unions (TYPE_NFIELDS (anon_type), field, fieldp, objfile);