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 #include "gdb_assert.h"
41 /* Private information attached to an objfile which we use to find
42 and internalize the HP C debug symbols within that objfile. */
44 struct hpread_symfile_info
46 /* The contents of each of the debug sections (there are 4 of them). */
52 /* We keep the size of the $VT$ section for range checking. */
55 /* Some routines still need to know the number of symbols in the
56 main debug sections ($LNTT$ and $GNTT$). */
57 unsigned int lntt_symcount
;
58 unsigned int gntt_symcount
;
60 /* To keep track of all the types we've processed. */
61 struct type
**dntt_type_vector
;
62 int dntt_type_vector_length
;
64 /* Keeps track of the beginning of a range of source lines. */
67 /* Some state variables we'll need. */
70 /* Keep track of the current function's address. We may need to look
71 up something based on this address. */
72 unsigned int current_function_value
;
75 /* Accessor macros to get at the fields. */
76 #define HPUX_SYMFILE_INFO(o) \
77 ((struct hpread_symfile_info *)((o)->sym_private))
78 #define GNTT(o) (HPUX_SYMFILE_INFO(o)->gntt)
79 #define LNTT(o) (HPUX_SYMFILE_INFO(o)->lntt)
80 #define SLT(o) (HPUX_SYMFILE_INFO(o)->slt)
81 #define VT(o) (HPUX_SYMFILE_INFO(o)->vt)
82 #define VT_SIZE(o) (HPUX_SYMFILE_INFO(o)->vt_size)
83 #define LNTT_SYMCOUNT(o) (HPUX_SYMFILE_INFO(o)->lntt_symcount)
84 #define GNTT_SYMCOUNT(o) (HPUX_SYMFILE_INFO(o)->gntt_symcount)
85 #define DNTT_TYPE_VECTOR(o) (HPUX_SYMFILE_INFO(o)->dntt_type_vector)
86 #define DNTT_TYPE_VECTOR_LENGTH(o) \
87 (HPUX_SYMFILE_INFO(o)->dntt_type_vector_length)
88 #define SL_INDEX(o) (HPUX_SYMFILE_INFO(o)->sl_index)
89 #define WITHIN_FUNCTION(o) (HPUX_SYMFILE_INFO(o)->within_function)
90 #define CURRENT_FUNCTION_VALUE(o) (HPUX_SYMFILE_INFO(o)->current_function_value)
93 /* We put a pointer to this structure in the read_symtab_private field
98 /* The offset within the file symbol table of first local symbol for
103 /* Length (in bytes) of the section of the symbol table devoted to
104 this file's symbols (actually, the section bracketed may contain
105 more than just this file's symbols). If ldsymlen is 0, the only
106 reason for this thing's existence is the dependency list.
107 Nothing else will happen when it is read in. */
112 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
113 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
114 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
116 /* Complaints about the symbols we have encountered. */
118 lbrac_unmatched_complaint (int arg1
)
120 complaint (&symfile_complaints
, "unmatched N_LBRAC before symtab pos %d",
125 lbrac_mismatch_complaint (int arg1
)
127 complaint (&symfile_complaints
,
128 "N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", arg1
);
131 /* To generate dumping code, uncomment this define. The dumping
132 itself is controlled by routine-local statics called "dumping". */
133 /* #define DUMPING 1 */
135 /* To use the quick look-up tables, uncomment this define. */
136 #define QUICK_LOOK_UP 1
138 /* To call PXDB to process un-processed files, uncomment this define. */
141 /* Forward procedure declarations */
143 /* Used in somread.c. */
144 void hpread_symfile_init (struct objfile
*);
146 void do_pxdb (bfd
*);
148 void hpread_build_psymtabs (struct objfile
*, int);
150 void hpread_symfile_finish (struct objfile
*);
152 static void set_namestring (union dnttentry
*sym
, char **namep
,
153 struct objfile
*objfile
);
155 static union dnttentry
*hpread_get_gntt (int, struct objfile
*);
157 static union dnttentry
*hpread_get_lntt (int index
, struct objfile
*objfile
);
160 static unsigned long hpread_get_textlow (int, int, struct objfile
*, int);
162 static struct partial_symtab
*hpread_start_psymtab
163 (struct objfile
*, char *, CORE_ADDR
, int,
164 struct partial_symbol
**, struct partial_symbol
**);
166 static struct partial_symtab
*hpread_end_psymtab
167 (struct partial_symtab
*, char **, int, int, CORE_ADDR
,
168 struct partial_symtab
**, int);
170 static unsigned long hpread_get_scope_start (sltpointer
, struct objfile
*);
172 static unsigned long hpread_get_line (sltpointer
, struct objfile
*);
174 static CORE_ADDR
hpread_get_location (sltpointer
, struct objfile
*);
176 static int hpread_has_name (enum dntt_entry_type kind
);
178 static void hpread_psymtab_to_symtab_1 (struct partial_symtab
*);
180 static void hpread_psymtab_to_symtab (struct partial_symtab
*);
182 static struct symtab
*hpread_expand_symtab
183 (struct objfile
*, int, int, CORE_ADDR
, int,
184 struct section_offsets
*, char *);
186 static int hpread_type_translate (dnttpointer
);
188 static struct type
**hpread_lookup_type (dnttpointer
, struct objfile
*);
190 static struct type
*hpread_alloc_type (dnttpointer
, struct objfile
*);
192 static struct type
*hpread_read_enum_type
193 (dnttpointer
, union dnttentry
*, struct objfile
*);
195 static struct type
*hpread_read_function_type
196 (dnttpointer
, union dnttentry
*, struct objfile
*, int);
198 static struct type
*hpread_read_doc_function_type
199 (dnttpointer
, union dnttentry
*, struct objfile
*, int);
201 static struct type
*hpread_read_struct_type
202 (dnttpointer
, union dnttentry
*, struct objfile
*);
204 static struct type
*hpread_get_nth_template_arg (struct objfile
*, int);
206 static struct type
*hpread_read_templ_arg_type
207 (dnttpointer
, union dnttentry
*, struct objfile
*, char *);
209 static struct type
*hpread_read_set_type
210 (dnttpointer
, union dnttentry
*, struct objfile
*);
212 static struct type
*hpread_read_array_type
213 (dnttpointer
, union dnttentry
*dn_bufp
, struct objfile
*objfile
);
215 static struct type
*hpread_read_subrange_type
216 (dnttpointer
, union dnttentry
*, struct objfile
*);
218 static struct type
*hpread_type_lookup (dnttpointer
, struct objfile
*);
220 static sltpointer hpread_record_lines
221 (struct subfile
*, sltpointer
, sltpointer
, struct objfile
*, CORE_ADDR
);
223 static void hpread_process_one_debug_symbol
224 (union dnttentry
*, char *, struct section_offsets
*,
225 struct objfile
*, CORE_ADDR
, int, char *, int, int *);
227 static int hpread_get_scope_depth (union dnttentry
*, struct objfile
*, int);
229 static void fix_static_member_physnames
230 (struct type
*, char *, struct objfile
*);
232 static void fixup_class_method_type
233 (struct type
*, struct type
*, struct objfile
*);
235 static void hpread_adjust_bitoffsets (struct type
*, int);
237 static dnttpointer hpread_get_next_skip_over_anon_unions
238 (int, dnttpointer
, union dnttentry
**, struct objfile
*);
241 /* Global to indicate presence of HP-compiled objects,
242 in particular, SOM executable file with SOM debug info
243 Defined in symtab.c, used in hppa-tdep.c. */
244 extern int hp_som_som_object_present
;
246 /* Static used to indicate a class type that requires a
247 fix-up of one of its method types */
248 static struct type
*fixup_class
= NULL
;
250 /* Static used to indicate the method type that is to be
251 used to fix-up the type for fixup_class */
252 static struct type
*fixup_method
= NULL
;
256 /* NOTE use of system files! May not be portable. */
258 #define PXDB_SVR4 "/opt/langtools/bin/pxdb"
259 #define PXDB_BSD "/usr/bin/pxdb"
262 #include "gdb_string.h"
264 /* check for the existence of a file, given its full pathname */
266 file_exists (char *filename
)
269 return (access (filename
, F_OK
) == 0);
274 /* Translate from the "hp_language" enumeration in hp-symtab.h
275 used in the debug info to gdb's generic enumeration in defs.h. */
277 trans_lang (enum hp_language in_lang
)
279 if (in_lang
== HP_LANGUAGE_C
)
282 else if (in_lang
== HP_LANGUAGE_CPLUSPLUS
)
283 return language_cplus
;
285 else if (in_lang
== HP_LANGUAGE_FORTRAN
)
286 return language_fortran
;
289 return language_unknown
;
292 static char main_string
[] = "main";
295 /* Given the native debug symbol SYM, set NAMEP to the name associated
296 with the debug symbol. Note we may be called with a debug symbol which
297 has no associated name, in that case we return an empty string. */
300 set_namestring (union dnttentry
*sym
, char **namep
, struct objfile
*objfile
)
302 /* Note that we "know" that the name for any symbol is always in the same
303 place. Hence we don't have to conditionalize on the symbol type. */
304 if (! hpread_has_name (sym
->dblock
.kind
))
306 else if ((unsigned) sym
->dsfile
.name
>= VT_SIZE (objfile
))
308 complaint (&symfile_complaints
, "bad string table offset in symbol %d",
313 *namep
= sym
->dsfile
.name
+ VT (objfile
);
316 /* Call PXDB to process our file.
318 Approach copied from DDE's "dbgk_run_pxdb". Note: we
319 don't check for BSD location of pxdb, nor for existence
322 NOTE: uses system function and string functions directly.
324 Return value: 1 if ok, 0 if not */
326 hpread_call_pxdb (const char *file_name
)
332 if (file_exists (PXDB_SVR4
))
334 p
= xmalloc (strlen (PXDB_SVR4
) + strlen (file_name
) + 2);
335 strcpy (p
, PXDB_SVR4
);
337 strcat (p
, file_name
);
339 warning ("File not processed by pxdb--about to process now.\n");
342 retval
= (status
== 0);
346 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
);
351 } /* hpread_call_pxdb */
354 /* Return 1 if the file turns out to need pre-processing
355 by PXDB, and we have thus called PXDB to do this processing
356 and the file therefore needs to be re-loaded. Otherwise
359 hpread_pxdb_needed (bfd
*sym_bfd
)
361 asection
*pinfo_section
, *debug_section
, *header_section
;
362 unsigned int do_pxdb
;
364 bfd_size_type header_section_size
;
369 header_section
= bfd_get_section_by_name (sym_bfd
, "$HEADER$");
372 return 0; /* No header at all, can't recover... */
375 debug_section
= bfd_get_section_by_name (sym_bfd
, "$DEBUG$");
376 pinfo_section
= bfd_get_section_by_name (sym_bfd
, "$PINFO$");
378 if (pinfo_section
&& !debug_section
)
380 /* Debug info with DOC, has different header format.
381 this only happens if the file was pxdbed and compiled optimized
382 otherwise the PINFO section is not there. */
383 header_section_size
= bfd_section_size (objfile
->obfd
, header_section
);
385 if (header_section_size
== (bfd_size_type
) sizeof (DOC_info_PXDB_header
))
387 buf
= alloca (sizeof (DOC_info_PXDB_header
));
389 if (!bfd_get_section_contents (sym_bfd
,
392 header_section_size
))
393 error ("bfd_get_section_contents\n");
395 tmp
= bfd_get_32 (sym_bfd
, (bfd_byte
*) (buf
+ sizeof (int) * 4));
396 pxdbed
= (tmp
>> 31) & 0x1;
399 error ("file debug header info invalid\n");
404 error ("invalid $HEADER$ size in executable \n");
410 /* this can be three different cases:
411 1. pxdbed and not doc
412 - DEBUG and HEADER sections are there
413 - header is PXDB_header type
414 - pxdbed flag is set to 1
416 2. not pxdbed and doc
417 - DEBUG and HEADER sections are there
418 - header is DOC_info_header type
419 - pxdbed flag is set to 0
421 3. not pxdbed and not doc
422 - DEBUG and HEADER sections are there
423 - header is XDB_header type
424 - pxdbed flag is set to 0
426 NOTE: the pxdbed flag is meaningful also in the not
427 already pxdb processed version of the header,
428 because in case on non-already processed by pxdb files
429 that same bit in the header would be always zero.
430 Why? Because the bit is the leftmost bit of a word
431 which contains a 'length' which is always a positive value
432 so that bit is never set to 1 (otherwise it would be negative)
434 Given the above, we have two choices : either we ignore the
435 size of the header itself and just look at the pxdbed field,
436 or we check the size and then we (for safety and paranoia related
437 issues) check the bit.
438 The first solution is used by DDE, the second by PXDB itself.
439 I am using the second one here, because I already wrote it,
440 and it is the end of a long day.
441 Also, using the first approach would still involve size issues
442 because we need to read in the contents of the header section, and
443 give the correct amount of stuff we want to read to the
444 get_bfd_section_contents function. */
446 /* decide which case depending on the size of the header section.
447 The size is as defined in hp-symtab.h */
449 header_section_size
= bfd_section_size (objfile
->obfd
, header_section
);
451 if (header_section_size
== (bfd_size_type
) sizeof (PXDB_header
)) /* pxdb and not doc */
454 buf
= alloca (sizeof (PXDB_header
));
455 if (!bfd_get_section_contents (sym_bfd
,
458 header_section_size
))
459 error ("bfd_get_section_contents\n");
461 tmp
= bfd_get_32 (sym_bfd
, (bfd_byte
*) (buf
+ sizeof (int) * 3));
462 pxdbed
= (tmp
>> 31) & 0x1;
467 error ("file debug header invalid\n");
469 else /*not pxdbed and doc OR not pxdbed and non doc */
481 } /* hpread_pxdb_needed */
485 /* Check whether the file needs to be preprocessed by pxdb.
489 do_pxdb (bfd
*sym_bfd
)
491 /* The following code is HP-specific. The "right" way of
492 doing this is unknown, but we bet would involve a target-
493 specific pre-file-load check using a generic mechanism. */
495 /* This code will not be executed if the file is not in SOM
496 format (i.e. if compiled with gcc) */
497 if (hpread_pxdb_needed (sym_bfd
))
499 /*This file has not been pre-processed. Preprocess now */
501 if (hpread_call_pxdb (sym_bfd
->filename
))
503 /* The call above has changed the on-disk file,
504 we can close the file anyway, because the
505 symbols will be reread in when the target is run */
515 /* Code to handle quick lookup-tables follows. */
518 /* Some useful macros */
519 #define VALID_FILE(i) ((i) < pxdb_header_p->fd_entries)
520 #define VALID_MODULE(i) ((i) < pxdb_header_p->md_entries)
521 #define VALID_PROC(i) ((i) < pxdb_header_p->pd_entries)
522 #define VALID_CLASS(i) ((i) < pxdb_header_p->cd_entries)
524 #define FILE_START(i) (qFD[i].adrStart)
525 #define MODULE_START(i) (qMD[i].adrStart)
526 #define PROC_START(i) (qPD[i].adrStart)
528 #define FILE_END(i) (qFD[i].adrEnd)
529 #define MODULE_END(i) (qMD[i].adrEnd)
530 #define PROC_END(i) (qPD[i].adrEnd)
532 #define FILE_ISYM(i) (qFD[i].isym)
533 #define MODULE_ISYM(i) (qMD[i].isym)
534 #define PROC_ISYM(i) (qPD[i].isym)
536 #define VALID_CURR_FILE (curr_fd < pxdb_header_p->fd_entries)
537 #define VALID_CURR_MODULE (curr_md < pxdb_header_p->md_entries)
538 #define VALID_CURR_PROC (curr_pd < pxdb_header_p->pd_entries)
539 #define VALID_CURR_CLASS (curr_cd < pxdb_header_p->cd_entries)
541 #define CURR_FILE_START (qFD[curr_fd].adrStart)
542 #define CURR_MODULE_START (qMD[curr_md].adrStart)
543 #define CURR_PROC_START (qPD[curr_pd].adrStart)
545 #define CURR_FILE_END (qFD[curr_fd].adrEnd)
546 #define CURR_MODULE_END (qMD[curr_md].adrEnd)
547 #define CURR_PROC_END (qPD[curr_pd].adrEnd)
549 #define CURR_FILE_ISYM (qFD[curr_fd].isym)
550 #define CURR_MODULE_ISYM (qMD[curr_md].isym)
551 #define CURR_PROC_ISYM (qPD[curr_pd].isym)
553 #define TELL_OBJFILE \
555 if( !told_objfile ) { \
557 warning ("\nIn object file \"%s\":\n", \
564 /* Keeping track of the start/end symbol table (LNTT) indices of
565 psymtabs created so far */
574 static pst_syms_struct
*pst_syms_array
= 0;
576 static int pst_syms_count
= 0;
577 static int pst_syms_size
= 0;
579 /* used by the TELL_OBJFILE macro */
580 static int told_objfile
= 0;
582 /* Set up psymtab symbol index stuff */
588 pst_syms_array
= (pst_syms_struct
*) xmalloc (20 * sizeof (pst_syms_struct
));
591 /* Clean up psymtab symbol index stuff */
593 clear_pst_syms (void)
597 xfree (pst_syms_array
);
601 /* Add information about latest psymtab to symbol index table */
603 record_pst_syms (int start_sym
, int end_sym
)
605 if (++pst_syms_count
> pst_syms_size
)
607 pst_syms_array
= (pst_syms_struct
*) xrealloc (pst_syms_array
,
608 2 * pst_syms_size
* sizeof (pst_syms_struct
));
611 pst_syms_array
[pst_syms_count
- 1].start
= start_sym
;
612 pst_syms_array
[pst_syms_count
- 1].end
= end_sym
;
615 /* Find a suitable symbol table index which can serve as the upper
616 bound of a psymtab that starts at INDEX
618 This scans backwards in the psymtab symbol index table to find a
619 "hole" in which the given index can fit. This is a heuristic!!
620 We don't search the entire table to check for multiple holes,
621 we don't care about overlaps, etc.
623 Return 0 => not found */
625 find_next_pst_start (int index
)
629 for (i
= pst_syms_count
- 1; i
>= 0; i
--)
630 if (pst_syms_array
[i
].end
<= index
)
631 return (i
== pst_syms_count
- 1) ? 0 : pst_syms_array
[i
+ 1].start
- 1;
633 if (pst_syms_array
[0].start
> index
)
634 return pst_syms_array
[0].start
- 1;
641 /* Utility functions to find the ending symbol index for a psymtab */
643 /* Find the next file entry that begins beyond INDEX, and return
644 its starting symbol index - 1.
645 QFD is the file table, CURR_FD is the file entry from where to start,
646 PXDB_HEADER_P as in hpread_quick_traverse (to allow macros to work).
648 Return 0 => not found */
650 find_next_file_isym (int index
, quick_file_entry
*qFD
, int curr_fd
,
651 PXDB_header_ptr pxdb_header_p
)
653 while (VALID_CURR_FILE
)
655 if (CURR_FILE_ISYM
>= index
)
656 return CURR_FILE_ISYM
- 1;
662 /* Find the next procedure entry that begins beyond INDEX, and return
663 its starting symbol index - 1.
664 QPD is the procedure table, CURR_PD is the proc entry from where to start,
665 PXDB_HEADER_P as in hpread_quick_traverse (to allow macros to work).
667 Return 0 => not found */
669 find_next_proc_isym (int index
, quick_procedure_entry
*qPD
, int curr_pd
,
670 PXDB_header_ptr pxdb_header_p
)
672 while (VALID_CURR_PROC
)
674 if (CURR_PROC_ISYM
>= index
)
675 return CURR_PROC_ISYM
- 1;
681 /* Find the next module entry that begins beyond INDEX, and return
682 its starting symbol index - 1.
683 QMD is the module table, CURR_MD is the modue entry from where to start,
684 PXDB_HEADER_P as in hpread_quick_traverse (to allow macros to work).
686 Return 0 => not found */
688 find_next_module_isym (int index
, quick_module_entry
*qMD
, int curr_md
,
689 PXDB_header_ptr pxdb_header_p
)
691 while (VALID_CURR_MODULE
)
693 if (CURR_MODULE_ISYM
>= index
)
694 return CURR_MODULE_ISYM
- 1;
700 /* Scan and record partial symbols for all functions starting from index
701 pointed to by CURR_PD_P, and between code addresses START_ADR and END_ADR.
702 Other parameters are explained in comments below. */
704 /* This used to be inline in hpread_quick_traverse, but now that we do
705 essentially the same thing for two different cases (modules and
706 module-less files), it's better organized in a separate routine,
707 although it does take lots of arguments. pai/1997-10-08
709 CURR_PD_P is the pointer to the current proc index. QPD is the
710 procedure quick lookup table. MAX_PROCS is the number of entries
711 in the proc. table. START_ADR is the beginning of the code range
712 for the current psymtab. end_adr is the end of the code range for
713 the current psymtab. PST is the current psymtab. VT_bits is
714 a pointer to the strings table of SOM debug space. OBJFILE is
715 the current object file. */
718 scan_procs (int *curr_pd_p
, quick_procedure_entry
*qPD
, int max_procs
,
719 CORE_ADDR start_adr
, CORE_ADDR end_adr
, struct partial_symtab
*pst
,
720 char *vt_bits
, struct objfile
*objfile
)
722 union dnttentry
*dn_bufp
;
723 int symbol_count
= 0; /* Total number of symbols in this psymtab */
724 int curr_pd
= *curr_pd_p
; /* Convenience variable -- avoid dereferencing pointer all the time */
727 /* Turn this on for lots of debugging information in this routine */
728 static int dumping
= 0;
734 printf ("Scan_procs called, addresses %x to %x, proc %x\n", start_adr
, end_adr
, curr_pd
);
738 while ((CURR_PROC_START
<= end_adr
) && (curr_pd
< max_procs
))
741 char *rtn_name
; /* mangled name */
742 char *rtn_dem_name
; /* qualified demangled name */
746 if ((trans_lang ((enum hp_language
) qPD
[curr_pd
].language
) == language_cplus
) &&
747 vt_bits
[(long) qPD
[curr_pd
].sbAlias
]) /* not a null string */
749 /* Get mangled name for the procedure, and demangle it */
750 rtn_name
= &vt_bits
[(long) qPD
[curr_pd
].sbAlias
];
751 rtn_dem_name
= cplus_demangle (rtn_name
, DMGL_ANSI
| DMGL_PARAMS
);
755 rtn_name
= &vt_bits
[(long) qPD
[curr_pd
].sbProc
];
759 /* Hack to get around HP C/C++ compilers' insistence on providing
760 "_MAIN_" as an alternate name for "main" */
761 if ((strcmp (rtn_name
, "_MAIN_") == 0) &&
762 (strcmp (&vt_bits
[(long) qPD
[curr_pd
].sbProc
], "main") == 0))
763 rtn_dem_name
= rtn_name
= main_string
;
768 printf ("..add %s (demangled %s), index %x to this psymtab\n", rtn_name
, rtn_dem_name
, curr_pd
);
772 /* Check for module-spanning routines. */
773 if (CURR_PROC_END
> end_adr
)
776 warning ("Procedure \"%s\" [0x%x] spans file or module boundaries.", rtn_name
, curr_pd
);
779 /* Add this routine symbol to the list in the objfile.
780 Unfortunately we have to go to the LNTT to determine the
781 correct list to put it on. An alternative (which the
782 code used to do) would be to not check and always throw
783 it on the "static" list. But if we go that route, then
784 symbol_lookup() needs to be tweaked a bit to account
785 for the fact that the function might not be found on
786 the correct list in the psymtab. - RT */
787 dn_bufp
= hpread_get_lntt (qPD
[curr_pd
].isym
, objfile
);
788 if (dn_bufp
->dfunc
.global
)
789 add_psymbol_with_dem_name_to_list (rtn_name
,
792 strlen (rtn_dem_name
),
794 LOC_BLOCK
, /* "I am a routine" */
795 &objfile
->global_psymbols
,
796 (qPD
[curr_pd
].adrStart
+ /* Starting address of rtn */
797 ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
))),
799 trans_lang ((enum hp_language
) qPD
[curr_pd
].language
),
802 add_psymbol_with_dem_name_to_list (rtn_name
,
805 strlen (rtn_dem_name
),
807 LOC_BLOCK
, /* "I am a routine" */
808 &objfile
->static_psymbols
,
809 (qPD
[curr_pd
].adrStart
+ /* Starting address of rtn */
810 ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
))),
812 trans_lang ((enum hp_language
) qPD
[curr_pd
].language
),
816 *curr_pd_p
= ++curr_pd
; /* bump up count & reflect in caller */
817 } /* loop over procedures */
822 if (symbol_count
== 0)
823 printf ("Scan_procs: no symbols found!\n");
831 /* Traverse the quick look-up tables, building a set of psymtabs.
833 This constructs a psymtab for modules and files in the quick lookup
836 Mostly, modules correspond to compilation units, so we try to
837 create psymtabs that correspond to modules; however, in some cases
838 a file can result in a compiled object which does not have a module
839 entry for it, so in such cases we create a psymtab for the file. */
842 hpread_quick_traverse (struct objfile
*objfile
, char *gntt_bits
,
843 char *vt_bits
, PXDB_header_ptr pxdb_header_p
)
845 struct partial_symtab
*pst
;
849 quick_procedure_entry
*qPD
;
850 quick_file_entry
*qFD
;
851 quick_module_entry
*qMD
;
852 quick_class_entry
*qCD
;
856 CORE_ADDR start_adr
; /* current psymtab's starting code addr */
857 CORE_ADDR end_adr
; /* current psymtab's ending code addr */
858 CORE_ADDR next_mod_adr
; /* next module's starting code addr */
859 int curr_pd
; /* current procedure */
860 int curr_fd
; /* current file */
861 int curr_md
; /* current module */
862 int start_sym
; /* current psymtab's starting symbol index */
863 int end_sym
; /* current psymtab's ending symbol index */
864 int max_LNTT_sym_index
;
866 B_TYPE
*class_entered
;
868 struct partial_symbol
**global_syms
; /* We'll be filling in the "global" */
869 struct partial_symbol
**static_syms
; /* and "static" tables in the objfile
870 as we go, so we need a pair of
874 /* Turn this on for lots of debugging information in this routine.
875 You get a blow-by-blow account of quick lookup table reading */
876 static int dumping
= 0;
879 pst
= (struct partial_symtab
*) 0;
881 /* Clear out some globals */
885 /* Demangling style -- if EDG style already set, don't change it,
886 as HP style causes some problems with the KAI EDG compiler */
887 if (current_demangling_style
!= edg_demangling
)
889 /* Otherwise, ensure that we are using HP style demangling */
890 set_demangling_style (HP_DEMANGLING_STYLE_STRING
);
893 /* First we need to find the starting points of the quick
894 look-up tables in the GNTT. */
898 qPD
= (quick_procedure_entry_ptr
) addr
;
899 addr
+= pxdb_header_p
->pd_entries
* sizeof (quick_procedure_entry
);
904 printf ("\n Printing routines as we see them\n");
905 for (i
= 0; VALID_PROC (i
); i
++)
907 idx
= (long) qPD
[i
].sbProc
;
908 printf ("%s %x..%x\n", &vt_bits
[idx
],
909 (int) PROC_START (i
),
915 qFD
= (quick_file_entry_ptr
) addr
;
916 addr
+= pxdb_header_p
->fd_entries
* sizeof (quick_file_entry
);
921 printf ("\n Printing files as we see them\n");
922 for (i
= 0; VALID_FILE (i
); i
++)
924 idx
= (long) qFD
[i
].sbFile
;
925 printf ("%s %x..%x\n", &vt_bits
[idx
],
926 (int) FILE_START (i
),
932 qMD
= (quick_module_entry_ptr
) addr
;
933 addr
+= pxdb_header_p
->md_entries
* sizeof (quick_module_entry
);
938 printf ("\n Printing modules as we see them\n");
939 for (i
= 0; i
< pxdb_header_p
->md_entries
; i
++)
941 idx
= (long) qMD
[i
].sbMod
;
942 printf ("%s\n", &vt_bits
[idx
]);
947 qCD
= (quick_class_entry_ptr
) addr
;
948 addr
+= pxdb_header_p
->cd_entries
* sizeof (quick_class_entry
);
953 printf ("\n Printing classes as we see them\n");
954 for (i
= 0; VALID_CLASS (i
); i
++)
956 idx
= (long) qCD
[i
].sbClass
;
957 printf ("%s\n", &vt_bits
[idx
]);
960 printf ("\n Done with dump, on to build!\n");
964 /* We need this index only while hp-symtab-read.c expects
965 a byte offset to the end of the LNTT entries for a given
966 psymtab. Thus the need for it should go away someday.
968 When it goes away, then we won't have any need to load the
969 LNTT from the objfile at psymtab-time, and start-up will be
970 faster. To make that work, we'll need some way to create
971 a null pst for the "globals" pseudo-module. */
972 max_LNTT_sym_index
= LNTT_SYMCOUNT (objfile
);
974 /* Scan the module descriptors and make a psymtab for each.
976 We know the MDs, FDs and the PDs are in order by starting
977 address. We use that fact to traverse all three arrays in
978 parallel, knowing when the next PD is in a new file
979 and we need to create a new psymtab. */
980 curr_pd
= 0; /* Current procedure entry */
981 curr_fd
= 0; /* Current file entry */
982 curr_md
= 0; /* Current module entry */
984 start_adr
= 0; /* Current psymtab code range */
987 start_sym
= 0; /* Current psymtab symbol range */
990 syms_in_pst
= 0; /* Symbol count for psymtab */
992 /* Psts actually just have pointers into the objfile's
993 symbol table, not their own symbol tables. */
994 global_syms
= objfile
->global_psymbols
.list
;
995 static_syms
= objfile
->static_psymbols
.list
;
998 /* First skip over pseudo-entries with address 0. These represent inlined
999 routines and abstract (uninstantiated) template routines.
1000 FIXME: These should be read in and available -- even if we can't set
1001 breakpoints, etc., there's some information that can be presented
1002 to the user. pai/1997-10-08 */
1004 while (VALID_CURR_PROC
&& (CURR_PROC_START
== 0))
1007 /* Loop over files, modules, and procedures in code address order. Each
1008 time we enter an iteration of this loop, curr_pd points to the first
1009 unprocessed procedure, curr_fd points to the first unprocessed file, and
1010 curr_md to the first unprocessed module. Each iteration of this loop
1011 updates these as required -- any or all of them may be bumpd up
1012 each time around. When we exit this loop, we are done with all files
1013 and modules in the tables -- there may still be some procedures, however.
1015 Note: This code used to loop only over module entries, under the assumption
1016 that files can occur via inclusions and are thus unreliable, while a
1017 compiled object always corresponds to a module. With CTTI in the HP aCC
1018 compiler, it turns out that compiled objects may have only files and no
1019 modules; so we have to loop over files and modules, creating psymtabs for
1020 either as appropriate. Unfortunately there are some problems (notably:
1021 1. the lack of "SRC_FILE_END" entries in the LNTT, 2. the lack of pointers
1022 to the ending symbol indices of a module or a file) which make it quite hard
1023 to do this correctly. Currently it uses a bunch of heuristics to start and
1024 end psymtabs; they seem to work well with most objects generated by aCC, but
1025 who knows when that will change... */
1027 while (VALID_CURR_FILE
|| VALID_CURR_MODULE
)
1030 char *mod_name_string
= NULL
;
1031 char *full_name_string
;
1033 /* First check for modules like "version.c", which have no code
1034 in them but still have qMD entries. They also have no qFD or
1035 qPD entries. Their start address is -1 and their end address
1037 if (VALID_CURR_MODULE
&& (CURR_MODULE_START
== -1) && (CURR_MODULE_END
== 0))
1040 mod_name_string
= &vt_bits
[(long) qMD
[curr_md
].sbMod
];
1044 printf ("Module with data only %s\n", mod_name_string
);
1047 /* We'll skip the rest (it makes error-checking easier), and
1048 just make an empty pst. Right now empty psts are not put
1049 in the pst chain, so all this is for naught, but later it
1052 pst
= hpread_start_psymtab (objfile
,
1054 CURR_MODULE_START
, /* Low text address: bogus! */
1055 (CURR_MODULE_ISYM
* sizeof (struct dntt_type_block
)),
1060 pst
= hpread_end_psymtab (pst
,
1061 NULL
, /* psymtab_include_list */
1062 0, /* includes_used */
1063 end_sym
* sizeof (struct dntt_type_block
),
1064 /* byte index in LNTT of end
1065 = capping symbol offset
1066 = LDSYMOFF of nextfile */
1068 NULL
, /* dependency_list */
1069 0); /* dependencies_used */
1071 global_syms
= objfile
->global_psymbols
.next
;
1072 static_syms
= objfile
->static_psymbols
.next
;
1076 else if (VALID_CURR_MODULE
&&
1077 ((CURR_MODULE_START
== 0) || (CURR_MODULE_START
== -1) ||
1078 (CURR_MODULE_END
== 0) || (CURR_MODULE_END
== -1)))
1081 warning ("Module \"%s\" [0x%s] has non-standard addresses. It starts at 0x%s, ends at 0x%s, and will be skipped.",
1082 mod_name_string
, paddr_nz (curr_md
), paddr_nz (start_adr
), paddr_nz (end_adr
));
1083 /* On to next module */
1088 /* First check if we are looking at a file with code in it
1089 that does not overlap the current module's code range */
1091 if (VALID_CURR_FILE
? (VALID_CURR_MODULE
? (CURR_FILE_END
< CURR_MODULE_START
) : 1) : 0)
1094 /* Looking at file not corresponding to any module,
1095 create a psymtab for it */
1096 full_name_string
= &vt_bits
[(long) qFD
[curr_fd
].sbFile
];
1097 start_adr
= CURR_FILE_START
;
1098 end_adr
= CURR_FILE_END
;
1099 start_sym
= CURR_FILE_ISYM
;
1101 /* Check if there are any procedures not handled until now, that
1102 begin before the start address of this file, and if so, adjust
1103 this module's start address to include them. This handles routines that
1104 are in between file or module ranges for some reason (probably
1105 indicates a compiler bug */
1107 if (CURR_PROC_START
< start_adr
)
1110 warning ("Found procedure \"%s\" [0x%x] that is not in any file or module.",
1111 &vt_bits
[(long) qPD
[curr_pd
].sbProc
], curr_pd
);
1112 start_adr
= CURR_PROC_START
;
1113 if (CURR_PROC_ISYM
< start_sym
)
1114 start_sym
= CURR_PROC_ISYM
;
1117 /* Sometimes (compiler bug -- COBOL) the module end address is higher
1118 than the start address of the next module, so check for that and
1119 adjust accordingly */
1121 if (VALID_FILE (curr_fd
+ 1) && (FILE_START (curr_fd
+ 1) <= end_adr
))
1124 warning ("File \"%s\" [0x%x] has ending address after starting address of next file; adjusting ending address down.",
1125 full_name_string
, curr_fd
);
1126 end_adr
= FILE_START (curr_fd
+ 1) - 1; /* Is -4 (or -8 for 64-bit) better? */
1128 if (VALID_MODULE (curr_md
) && (CURR_MODULE_START
<= end_adr
))
1131 warning ("File \"%s\" [0x%x] has ending address after starting address of next module; adjusting ending address down.",
1132 full_name_string
, curr_fd
);
1133 end_adr
= CURR_MODULE_START
- 1; /* Is -4 (or -8 for 64-bit) better? */
1140 printf ("Make new psymtab for file %s (%x to %x).\n",
1141 full_name_string
, start_adr
, end_adr
);
1144 /* Create the basic psymtab, connecting it in the list
1145 for this objfile and pointing its symbol entries
1146 to the current end of the symbol areas in the objfile.
1148 The "ldsymoff" parameter is the byte offset in the LNTT
1149 of the first symbol in this file. Some day we should
1150 turn this into an index (fix in hp-symtab-read.c as well).
1151 And it's not even the right byte offset, as we're using
1152 the size of a union! FIXME! */
1153 pst
= hpread_start_psymtab (objfile
,
1155 start_adr
, /* Low text address */
1156 (start_sym
* sizeof (struct dntt_type_block
)),
1161 /* Set up to only enter each class referenced in this module once. */
1162 class_entered
= xmalloc (B_BYTES (pxdb_header_p
->cd_entries
));
1163 B_CLRALL (class_entered
, pxdb_header_p
->cd_entries
);
1165 /* Scan the procedure descriptors for procedures in the current
1166 file, based on the starting addresses. */
1168 syms_in_pst
= scan_procs (&curr_pd
, qPD
, pxdb_header_p
->pd_entries
,
1169 start_adr
, end_adr
, pst
, vt_bits
, objfile
);
1171 /* Get ending symbol offset */
1174 /* First check for starting index before previous psymtab */
1175 if (pst_syms_count
&& start_sym
< pst_syms_array
[pst_syms_count
- 1].end
)
1177 end_sym
= find_next_pst_start (start_sym
);
1179 /* Look for next start index of a file or module, or procedure */
1182 int next_file_isym
= find_next_file_isym (start_sym
, qFD
, curr_fd
+ 1, pxdb_header_p
);
1183 int next_module_isym
= find_next_module_isym (start_sym
, qMD
, curr_md
, pxdb_header_p
);
1184 int next_proc_isym
= find_next_proc_isym (start_sym
, qPD
, curr_pd
, pxdb_header_p
);
1186 if (next_file_isym
&& next_module_isym
)
1188 /* pick lower of next file or module start index */
1189 end_sym
= min (next_file_isym
, next_module_isym
);
1193 /* one of them is zero, pick the other */
1194 end_sym
= max (next_file_isym
, next_module_isym
);
1197 /* As a precaution, check next procedure index too */
1199 end_sym
= next_proc_isym
;
1201 end_sym
= min (end_sym
, next_proc_isym
);
1204 /* Couldn't find procedure, file, or module, use globals as default */
1206 end_sym
= pxdb_header_p
->globals
;
1211 printf ("File psymtab indices: %x to %x\n", start_sym
, end_sym
);
1215 pst
= hpread_end_psymtab (pst
,
1216 NULL
, /* psymtab_include_list */
1217 0, /* includes_used */
1218 end_sym
* sizeof (struct dntt_type_block
),
1219 /* byte index in LNTT of end
1220 = capping symbol offset
1221 = LDSYMOFF of nextfile */
1222 end_adr
, /* text high */
1223 NULL
, /* dependency_list */
1224 0); /* dependencies_used */
1226 record_pst_syms (start_sym
, end_sym
);
1229 warning ("No symbols in psymtab for file \"%s\" [0x%x].", full_name_string
, curr_fd
);
1234 printf ("Made new psymtab for file %s (%x to %x), sym %x to %x.\n",
1235 full_name_string
, start_adr
, end_adr
, CURR_FILE_ISYM
, end_sym
);
1238 /* Prepare for the next psymtab. */
1239 global_syms
= objfile
->global_psymbols
.next
;
1240 static_syms
= objfile
->static_psymbols
.next
;
1241 xfree (class_entered
);
1244 } /* Psymtab for file */
1247 /* We have a module for which we create a psymtab */
1249 mod_name_string
= &vt_bits
[(long) qMD
[curr_md
].sbMod
];
1251 /* We will include the code ranges of any files that happen to
1252 overlap with this module */
1254 /* So, first pick the lower of the file's and module's start addresses */
1255 start_adr
= CURR_MODULE_START
;
1256 if (VALID_CURR_FILE
)
1258 if (CURR_FILE_START
< CURR_MODULE_START
)
1261 warning ("File \"%s\" [0x%x] crosses beginning of module \"%s\".",
1262 &vt_bits
[(long) qFD
[curr_fd
].sbFile
],
1263 curr_fd
, mod_name_string
);
1265 start_adr
= CURR_FILE_START
;
1269 /* Also pick the lower of the file's and the module's start symbol indices */
1270 start_sym
= CURR_MODULE_ISYM
;
1271 if (VALID_CURR_FILE
&& (CURR_FILE_ISYM
< CURR_MODULE_ISYM
))
1272 start_sym
= CURR_FILE_ISYM
;
1274 /* For the end address, we scan through the files till we find one
1275 that overlaps the current module but ends beyond it; if no such file exists we
1276 simply use the module's start address.
1277 (Note, if file entries themselves overlap
1278 we take the longest overlapping extension beyond the end of the module...)
1279 We assume that modules never overlap. */
1281 end_adr
= CURR_MODULE_END
;
1283 if (VALID_CURR_FILE
)
1285 while (VALID_CURR_FILE
&& (CURR_FILE_START
< end_adr
))
1290 printf ("Maybe skipping file %s which overlaps with module %s\n",
1291 &vt_bits
[(long) qFD
[curr_fd
].sbFile
], mod_name_string
);
1293 if (CURR_FILE_END
> end_adr
)
1296 warning ("File \"%s\" [0x%x] crosses end of module \"%s\".",
1297 &vt_bits
[(long) qFD
[curr_fd
].sbFile
],
1298 curr_fd
, mod_name_string
);
1299 end_adr
= CURR_FILE_END
;
1303 curr_fd
--; /* back up after going too far */
1306 /* Sometimes (compiler bug -- COBOL) the module end address is higher
1307 than the start address of the next module, so check for that and
1308 adjust accordingly */
1310 if (VALID_MODULE (curr_md
+ 1) && (MODULE_START (curr_md
+ 1) <= end_adr
))
1313 warning ("Module \"%s\" [0x%x] has ending address after starting address of next module; adjusting ending address down.",
1314 mod_name_string
, curr_md
);
1315 end_adr
= MODULE_START (curr_md
+ 1) - 1; /* Is -4 (or -8 for 64-bit) better? */
1317 if (VALID_FILE (curr_fd
+ 1) && (FILE_START (curr_fd
+ 1) <= end_adr
))
1320 warning ("Module \"%s\" [0x%x] has ending address after starting address of next file; adjusting ending address down.",
1321 mod_name_string
, curr_md
);
1322 end_adr
= FILE_START (curr_fd
+ 1) - 1; /* Is -4 (or -8 for 64-bit) better? */
1325 /* Use one file to get the full name for the module. This
1326 situation can arise if there is executable code in a #include
1327 file. Each file with code in it gets a qFD. Files which don't
1328 contribute code don't get a qFD, even if they include files
1333 #include "rtn.h" return x;
1336 There will a qFD for "rtn.h",and a qMD for "body.c",
1337 but no qMD for "rtn.h" or qFD for "body.c"!
1339 We pick the name of the last file to overlap with this
1340 module. C convention is to put include files first. In a
1341 perfect world, we could check names and use the file whose full
1342 path name ends with the module name. */
1344 if (VALID_CURR_FILE
)
1345 full_name_string
= &vt_bits
[(long) qFD
[curr_fd
].sbFile
];
1347 full_name_string
= mod_name_string
;
1349 /* Check if there are any procedures not handled until now, that
1350 begin before the start address we have now, and if so, adjust
1351 this psymtab's start address to include them. This handles routines that
1352 are in between file or module ranges for some reason (probably
1353 indicates a compiler bug */
1355 if (CURR_PROC_START
< start_adr
)
1358 warning ("Found procedure \"%s\" [0x%x] that is not in any file or module.",
1359 &vt_bits
[(long) qPD
[curr_pd
].sbProc
], curr_pd
);
1360 start_adr
= CURR_PROC_START
;
1361 if (CURR_PROC_ISYM
< start_sym
)
1362 start_sym
= CURR_PROC_ISYM
;
1368 printf ("Make new psymtab for module %s (%x to %x), using file %s\n",
1369 mod_name_string
, start_adr
, end_adr
, full_name_string
);
1372 /* Create the basic psymtab, connecting it in the list
1373 for this objfile and pointing its symbol entries
1374 to the current end of the symbol areas in the objfile.
1376 The "ldsymoff" parameter is the byte offset in the LNTT
1377 of the first symbol in this file. Some day we should
1378 turn this into an index (fix in hp-symtab-read.c as well).
1379 And it's not even the right byte offset, as we're using
1380 the size of a union! FIXME! */
1381 pst
= hpread_start_psymtab (objfile
,
1383 start_adr
, /* Low text address */
1384 (start_sym
* sizeof (struct dntt_type_block
)),
1389 /* Set up to only enter each class referenced in this module once. */
1390 class_entered
= xmalloc (B_BYTES (pxdb_header_p
->cd_entries
));
1391 B_CLRALL (class_entered
, pxdb_header_p
->cd_entries
);
1393 /* Scan the procedure descriptors for procedures in the current
1394 module, based on the starting addresses. */
1396 syms_in_pst
= scan_procs (&curr_pd
, qPD
, pxdb_header_p
->pd_entries
,
1397 start_adr
, end_adr
, pst
, vt_bits
, objfile
);
1399 /* Get ending symbol offset */
1402 /* First check for starting index before previous psymtab */
1403 if (pst_syms_count
&& start_sym
< pst_syms_array
[pst_syms_count
- 1].end
)
1405 end_sym
= find_next_pst_start (start_sym
);
1407 /* Look for next start index of a file or module, or procedure */
1410 int next_file_isym
= find_next_file_isym (start_sym
, qFD
, curr_fd
+ 1, pxdb_header_p
);
1411 int next_module_isym
= find_next_module_isym (start_sym
, qMD
, curr_md
+ 1, pxdb_header_p
);
1412 int next_proc_isym
= find_next_proc_isym (start_sym
, qPD
, curr_pd
, pxdb_header_p
);
1414 if (next_file_isym
&& next_module_isym
)
1416 /* pick lower of next file or module start index */
1417 end_sym
= min (next_file_isym
, next_module_isym
);
1421 /* one of them is zero, pick the other */
1422 end_sym
= max (next_file_isym
, next_module_isym
);
1425 /* As a precaution, check next procedure index too */
1427 end_sym
= next_proc_isym
;
1429 end_sym
= min (end_sym
, next_proc_isym
);
1432 /* Couldn't find procedure, file, or module, use globals as default */
1434 end_sym
= pxdb_header_p
->globals
;
1439 printf ("Module psymtab indices: %x to %x\n", start_sym
, end_sym
);
1443 pst
= hpread_end_psymtab (pst
,
1444 NULL
, /* psymtab_include_list */
1445 0, /* includes_used */
1446 end_sym
* sizeof (struct dntt_type_block
),
1447 /* byte index in LNTT of end
1448 = capping symbol offset
1449 = LDSYMOFF of nextfile */
1450 end_adr
, /* text high */
1451 NULL
, /* dependency_list */
1452 0); /* dependencies_used */
1454 record_pst_syms (start_sym
, end_sym
);
1457 warning ("No symbols in psymtab for module \"%s\" [0x%x].", mod_name_string
, curr_md
);
1462 printf ("Made new psymtab for module %s (%x to %x), sym %x to %x.\n",
1463 mod_name_string
, start_adr
, end_adr
, CURR_MODULE_ISYM
, end_sym
);
1467 /* Prepare for the next psymtab. */
1468 global_syms
= objfile
->global_psymbols
.next
;
1469 static_syms
= objfile
->static_psymbols
.next
;
1470 xfree (class_entered
);
1474 } /* psymtab for module */
1475 } /* psymtab for non-bogus file or module */
1476 } /* End of while loop over all files & modules */
1478 /* There may be some routines after all files and modules -- these will get
1479 inserted in a separate new module of their own */
1480 if (VALID_CURR_PROC
)
1482 start_adr
= CURR_PROC_START
;
1483 end_adr
= qPD
[pxdb_header_p
->pd_entries
- 1].adrEnd
;
1485 warning ("Found functions beyond end of all files and modules [0x%x].", curr_pd
);
1489 printf ("Orphan functions at end, PD %d and beyond (%x to %x)\n",
1490 curr_pd
, start_adr
, end_adr
);
1493 pst
= hpread_start_psymtab (objfile
,
1495 start_adr
, /* Low text address */
1496 (CURR_PROC_ISYM
* sizeof (struct dntt_type_block
)),
1501 scan_procs (&curr_pd
, qPD
, pxdb_header_p
->pd_entries
,
1502 start_adr
, end_adr
, pst
, vt_bits
, objfile
);
1504 pst
= hpread_end_psymtab (pst
,
1505 NULL
, /* psymtab_include_list */
1506 0, /* includes_used */
1507 pxdb_header_p
->globals
* sizeof (struct dntt_type_block
),
1508 /* byte index in LNTT of end
1509 = capping symbol offset
1510 = LDSYMOFF of nextfile */
1511 end_adr
, /* text high */
1512 NULL
, /* dependency_list */
1513 0); /* dependencies_used */
1518 /* Now build psts for non-module things (in the tail of
1519 the LNTT, after the last END MODULE entry).
1521 If null psts were kept on the chain, this would be
1522 a solution. FIXME */
1523 pst
= hpread_start_psymtab (objfile
,
1526 (pxdb_header_p
->globals
1527 * sizeof (struct dntt_type_block
)),
1528 objfile
->global_psymbols
.next
,
1529 objfile
->static_psymbols
.next
);
1530 hpread_end_psymtab (pst
,
1532 (max_LNTT_sym_index
* sizeof (struct dntt_type_block
)),
1541 } /* End of hpread_quick_traverse. */
1544 /* Get appropriate header, based on pxdb type.
1545 Return value: 1 if ok, 0 if not */
1547 hpread_get_header (struct objfile
*objfile
, PXDB_header_ptr pxdb_header_p
)
1549 asection
*pinfo_section
, *debug_section
, *header_section
;
1552 /* Turn on for debugging information */
1553 static int dumping
= 0;
1556 header_section
= bfd_get_section_by_name (objfile
->obfd
, "$HEADER$");
1557 if (!header_section
)
1559 /* We don't have either PINFO or DEBUG sections. But
1560 stuff like "libc.sl" has no debug info. There's no
1561 need to warn the user of this, as it may be ok. The
1562 caller will figure it out and issue any needed
1566 printf ("==No debug info at all for %s.\n", objfile
->name
);
1572 /* We would like either a $DEBUG$ or $PINFO$ section.
1573 Once we know which, we can understand the header
1574 data (which we have defined to suit the more common
1576 debug_section
= bfd_get_section_by_name (objfile
->obfd
, "$DEBUG$");
1577 pinfo_section
= bfd_get_section_by_name (objfile
->obfd
, "$PINFO$");
1580 /* The expected case: normal pxdb header. */
1581 bfd_get_section_contents (objfile
->obfd
, header_section
,
1582 pxdb_header_p
, 0, sizeof (PXDB_header
));
1584 if (!pxdb_header_p
->pxdbed
)
1586 /* This shouldn't happen if we check in "symfile.c". */
1588 } /* DEBUG section */
1591 else if (pinfo_section
)
1593 /* The DOC case; we need to translate this into a
1595 DOC_info_PXDB_header doc_header
;
1600 printf ("==OOps, PINFO, let's try to handle this, %s.\n", objfile
->name
);
1604 bfd_get_section_contents (objfile
->obfd
,
1607 sizeof (DOC_info_PXDB_header
));
1609 if (!doc_header
.pxdbed
)
1611 /* This shouldn't happen if we check in "symfile.c". */
1612 warning ("File \"%s\" not processed by pxdb!", objfile
->name
);
1616 /* Copy relevent fields to standard header passed in. */
1617 pxdb_header_p
->pd_entries
= doc_header
.pd_entries
;
1618 pxdb_header_p
->fd_entries
= doc_header
.fd_entries
;
1619 pxdb_header_p
->md_entries
= doc_header
.md_entries
;
1620 pxdb_header_p
->pxdbed
= doc_header
.pxdbed
;
1621 pxdb_header_p
->bighdr
= doc_header
.bighdr
;
1622 pxdb_header_p
->sa_header
= doc_header
.sa_header
;
1623 pxdb_header_p
->inlined
= doc_header
.inlined
;
1624 pxdb_header_p
->globals
= doc_header
.globals
;
1625 pxdb_header_p
->time
= doc_header
.time
;
1626 pxdb_header_p
->pg_entries
= doc_header
.pg_entries
;
1627 pxdb_header_p
->functions
= doc_header
.functions
;
1628 pxdb_header_p
->files
= doc_header
.files
;
1629 pxdb_header_p
->cd_entries
= doc_header
.cd_entries
;
1630 pxdb_header_p
->aa_entries
= doc_header
.aa_entries
;
1631 pxdb_header_p
->oi_entries
= doc_header
.oi_entries
;
1632 pxdb_header_p
->version
= doc_header
.version
;
1633 } /* PINFO section */
1639 printf ("==No debug info at all for %s.\n", objfile
->name
);
1647 } /* End of hpread_get_header */
1648 #endif /* QUICK_LOOK_UP */
1651 /* Initialization for reading native HP C debug symbols from OBJFILE.
1653 Its only purpose in life is to set up the symbol reader's private
1654 per-objfile data structures, and read in the raw contents of the debug
1655 sections (attaching pointers to the debug info into the private data
1658 Since BFD doesn't know how to read debug symbols in a format-independent
1659 way (and may never do so...), we have to do it ourselves. Note we may
1660 be called on a file without native HP C debugging symbols.
1662 FIXME, there should be a cleaner peephole into the BFD environment
1665 hpread_symfile_init (struct objfile
*objfile
)
1667 asection
*vt_section
, *slt_section
, *lntt_section
, *gntt_section
;
1669 /* Allocate struct to keep track of the symfile */
1670 objfile
->sym_private
=
1671 xmmalloc (objfile
->md
, sizeof (struct hpread_symfile_info
));
1672 memset (objfile
->sym_private
, 0, sizeof (struct hpread_symfile_info
));
1674 /* We haven't read in any types yet. */
1675 DNTT_TYPE_VECTOR (objfile
) = 0;
1677 /* Read in data from the $GNTT$ subspace. */
1678 gntt_section
= bfd_get_section_by_name (objfile
->obfd
, "$GNTT$");
1683 = obstack_alloc (&objfile
->symbol_obstack
,
1684 bfd_section_size (objfile
->obfd
, gntt_section
));
1686 bfd_get_section_contents (objfile
->obfd
, gntt_section
, GNTT (objfile
),
1687 0, bfd_section_size (objfile
->obfd
, gntt_section
));
1689 GNTT_SYMCOUNT (objfile
)
1690 = bfd_section_size (objfile
->obfd
, gntt_section
)
1691 / sizeof (struct dntt_type_block
);
1693 /* Read in data from the $LNTT$ subspace. Also keep track of the number
1696 FIXME: this could be moved into the psymtab-to-symtab expansion
1697 code, and save startup time. At the moment this data is
1698 still used, though. We'd need a way to tell hp-symtab-read.c
1699 whether or not to load the LNTT. */
1700 lntt_section
= bfd_get_section_by_name (objfile
->obfd
, "$LNTT$");
1705 = obstack_alloc (&objfile
->symbol_obstack
,
1706 bfd_section_size (objfile
->obfd
, lntt_section
));
1708 bfd_get_section_contents (objfile
->obfd
, lntt_section
, LNTT (objfile
),
1709 0, bfd_section_size (objfile
->obfd
, lntt_section
));
1711 LNTT_SYMCOUNT (objfile
)
1712 = bfd_section_size (objfile
->obfd
, lntt_section
)
1713 / sizeof (struct dntt_type_block
);
1715 /* Read in data from the $SLT$ subspace. $SLT$ contains information
1716 on source line numbers. */
1717 slt_section
= bfd_get_section_by_name (objfile
->obfd
, "$SLT$");
1722 obstack_alloc (&objfile
->symbol_obstack
,
1723 bfd_section_size (objfile
->obfd
, slt_section
));
1725 bfd_get_section_contents (objfile
->obfd
, slt_section
, SLT (objfile
),
1726 0, bfd_section_size (objfile
->obfd
, slt_section
));
1728 /* Read in data from the $VT$ subspace. $VT$ contains things like
1729 names and constants. Keep track of the number of symbols in the VT. */
1730 vt_section
= bfd_get_section_by_name (objfile
->obfd
, "$VT$");
1734 VT_SIZE (objfile
) = bfd_section_size (objfile
->obfd
, vt_section
);
1737 (char *) obstack_alloc (&objfile
->symbol_obstack
,
1740 bfd_get_section_contents (objfile
->obfd
, vt_section
, VT (objfile
),
1741 0, VT_SIZE (objfile
));
1744 /* Scan and build partial symbols for a symbol file.
1746 The minimal symbol table (either SOM or HP a.out) has already been
1747 read in; all we need to do is setup partial symbols based on the
1748 native debugging information.
1750 Note that the minimal table is produced by the linker, and has
1751 only global routines in it; the psymtab is based on compiler-
1752 generated debug information and has non-global
1753 routines in it as well as files and class information.
1755 We assume hpread_symfile_init has been called to initialize the
1756 symbol reader's private data structures.
1758 MAINLINE is true if we are reading the main symbol table (as
1759 opposed to a shared lib or dynamically loaded file). */
1762 hpread_build_psymtabs (struct objfile
*objfile
, int mainline
)
1766 /* Turn this on to get debugging output. */
1767 static int dumping
= 0;
1771 int past_first_source_file
= 0;
1772 struct cleanup
*old_chain
;
1774 int hp_symnum
, symcount
, i
;
1777 union dnttentry
*dn_bufp
;
1783 /* Current partial symtab */
1784 struct partial_symtab
*pst
;
1786 /* List of current psymtab's include files */
1787 char **psymtab_include_list
;
1788 int includes_allocated
;
1791 /* Index within current psymtab dependency list */
1792 struct partial_symtab
**dependency_list
;
1793 int dependencies_used
, dependencies_allocated
;
1795 /* Just in case the stabs reader left turds lying around. */
1796 free_pending_blocks ();
1797 make_cleanup (really_free_pendings
, 0);
1799 pst
= (struct partial_symtab
*) 0;
1801 /* We shouldn't use alloca, instead use malloc/free. Doing so avoids
1802 a number of problems with cross compilation and creating useless holes
1803 in the stack when we have to allocate new entries. FIXME. */
1805 includes_allocated
= 30;
1807 psymtab_include_list
= (char **) alloca (includes_allocated
*
1810 dependencies_allocated
= 30;
1811 dependencies_used
= 0;
1813 (struct partial_symtab
**) alloca (dependencies_allocated
*
1814 sizeof (struct partial_symtab
*));
1816 old_chain
= make_cleanup_free_objfile (objfile
);
1818 last_source_file
= 0;
1820 #ifdef QUICK_LOOK_UP
1822 /* Begin code for new-style loading of quick look-up tables. */
1824 /* elz: this checks whether the file has beeen processed by pxdb.
1825 If not we would like to try to read the psymbols in
1826 anyway, but it turns out to be not so easy. So this could
1827 actually be commented out, but I leave it in, just in case
1828 we decide to add support for non-pxdb-ed stuff in the future. */
1829 PXDB_header pxdb_header
;
1830 int found_modules_in_program
;
1832 if (hpread_get_header (objfile
, &pxdb_header
))
1834 /* Build a minimal table. No types, no global variables,
1835 no include files.... */
1838 printf ("\nNew method for %s\n", objfile
->name
);
1841 /* elz: quick_traverse returns true if it found
1842 some modules in the main source file, other
1844 In C and C++, all the files have MODULES entries
1845 in the LNTT, and the quick table traverse is all
1846 based on finding these MODULES entries. Without
1847 those it cannot work.
1848 It happens that F77 programs don't have MODULES
1849 so the quick traverse gets confused. F90 programs
1850 have modules, and the quick method still works.
1851 So, if modules (other than those in end.c) are
1852 not found we give up on the quick table stuff,
1853 and fall back on the slower method */
1854 found_modules_in_program
= hpread_quick_traverse (objfile
,
1859 discard_cleanups (old_chain
);
1861 /* Set up to scan the global section of the LNTT.
1863 This field is not always correct: if there are
1864 no globals, it will point to the last record in
1865 the regular LNTT, which is usually an END MODULE.
1867 Since it might happen that there could be a file
1868 with just one global record, there's no way to
1869 tell other than by looking at the record, so that's
1871 if (found_modules_in_program
)
1872 scan_start
= pxdb_header
.globals
;
1878 printf ("\nGoing on to old method for %s\n", objfile
->name
);
1882 #endif /* QUICK_LOOK_UP */
1884 /* Make two passes, one over the GNTT symbols, the other for the
1887 JB comment: above isn't true--they only make one pass, over
1889 for (i
= 0; i
< 1; i
++)
1891 int within_function
= 0;
1894 symcount
= GNTT_SYMCOUNT (objfile
);
1896 symcount
= LNTT_SYMCOUNT (objfile
);
1899 for (hp_symnum
= scan_start
; hp_symnum
< symcount
; hp_symnum
++)
1903 dn_bufp
= hpread_get_gntt (hp_symnum
, objfile
);
1905 dn_bufp
= hpread_get_lntt (hp_symnum
, objfile
);
1907 if (dn_bufp
->dblock
.extension
)
1910 /* Only handle things which are necessary for minimal symbols.
1911 everything else is ignored. */
1912 switch (dn_bufp
->dblock
.kind
)
1914 case DNTT_TYPE_SRCFILE
:
1916 #ifdef QUICK_LOOK_UP
1917 if (scan_start
== hp_symnum
1918 && symcount
== hp_symnum
+ 1)
1920 /* If there are NO globals in an executable,
1921 PXDB's index to the globals will point to
1922 the last record in the file, which
1923 could be this record. (this happened for F77 libraries)
1924 ignore it and be done! */
1927 #endif /* QUICK_LOOK_UP */
1929 /* A source file of some kind. Note this may simply
1930 be an included file. */
1931 set_namestring (dn_bufp
, &namestring
, objfile
);
1933 /* Check if this is the source file we are already working
1935 if (pst
&& !strcmp (namestring
, pst
->filename
))
1938 /* Check if this is an include file, if so check if we have
1939 already seen it. Add it to the include list */
1940 p
= strrchr (namestring
, '.');
1941 if (!strcmp (p
, ".h"))
1946 for (j
= 0; j
< includes_used
; j
++)
1947 if (!strcmp (namestring
, psymtab_include_list
[j
]))
1955 /* Add it to the list of includes seen so far and
1956 allocate more include space if necessary. */
1957 psymtab_include_list
[includes_used
++] = namestring
;
1958 if (includes_used
>= includes_allocated
)
1960 char **orig
= psymtab_include_list
;
1962 psymtab_include_list
= (char **)
1963 alloca ((includes_allocated
*= 2) *
1965 memcpy (psymtab_include_list
, orig
,
1966 includes_used
* sizeof (char *));
1975 pst
->filename
= (char *)
1976 obstack_alloc (&pst
->objfile
->psymbol_obstack
,
1977 strlen (namestring
) + 1);
1978 strcpy (pst
->filename
, namestring
);
1985 /* This is a bonafide new source file.
1986 End the current partial symtab and start a new one. */
1988 if (pst
&& past_first_source_file
)
1990 hpread_end_psymtab (pst
, psymtab_include_list
,
1993 * sizeof (struct dntt_type_block
)),
1995 dependency_list
, dependencies_used
);
1996 pst
= (struct partial_symtab
*) 0;
1998 dependencies_used
= 0;
2001 past_first_source_file
= 1;
2003 valu
= hpread_get_textlow (i
, hp_symnum
, objfile
, symcount
);
2004 valu
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2005 pst
= hpread_start_psymtab (objfile
,
2008 * sizeof (struct dntt_type_block
)),
2009 objfile
->global_psymbols
.next
,
2010 objfile
->static_psymbols
.next
);
2016 case DNTT_TYPE_MODULE
:
2017 /* A source file. It's still unclear to me what the
2018 real difference between a DNTT_TYPE_SRCFILE and DNTT_TYPE_MODULE
2019 is supposed to be. */
2021 /* First end the previous psymtab */
2024 hpread_end_psymtab (pst
, psymtab_include_list
, includes_used
,
2026 * sizeof (struct dntt_type_block
)),
2028 dependency_list
, dependencies_used
);
2029 pst
= (struct partial_symtab
*) 0;
2031 dependencies_used
= 0;
2035 /* Now begin a new module and a new psymtab for it */
2036 set_namestring (dn_bufp
, &namestring
, objfile
);
2037 valu
= hpread_get_textlow (i
, hp_symnum
, objfile
, symcount
);
2038 valu
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2041 pst
= hpread_start_psymtab (objfile
,
2044 * sizeof (struct dntt_type_block
)),
2045 objfile
->global_psymbols
.next
,
2046 objfile
->static_psymbols
.next
);
2052 case DNTT_TYPE_FUNCTION
:
2053 case DNTT_TYPE_ENTRY
:
2054 /* The beginning of a function. DNTT_TYPE_ENTRY may also denote
2055 a secondary entry point. */
2056 valu
= dn_bufp
->dfunc
.hiaddr
+ ANOFFSET (objfile
->section_offsets
,
2057 SECT_OFF_TEXT (objfile
));
2058 if (valu
> texthigh
)
2060 valu
= dn_bufp
->dfunc
.lowaddr
+
2061 ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2062 set_namestring (dn_bufp
, &namestring
, objfile
);
2063 if (dn_bufp
->dfunc
.global
)
2064 add_psymbol_to_list (namestring
, strlen (namestring
),
2065 VAR_DOMAIN
, LOC_BLOCK
,
2066 &objfile
->global_psymbols
, valu
,
2067 0, language_unknown
, objfile
);
2069 add_psymbol_to_list (namestring
, strlen (namestring
),
2070 VAR_DOMAIN
, LOC_BLOCK
,
2071 &objfile
->static_psymbols
, valu
,
2072 0, language_unknown
, objfile
);
2073 within_function
= 1;
2076 case DNTT_TYPE_DOC_FUNCTION
:
2077 valu
= dn_bufp
->ddocfunc
.hiaddr
+ ANOFFSET (objfile
->section_offsets
,
2078 SECT_OFF_TEXT (objfile
));
2079 if (valu
> texthigh
)
2081 valu
= dn_bufp
->ddocfunc
.lowaddr
+
2082 ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2083 set_namestring (dn_bufp
, &namestring
, objfile
);
2084 if (dn_bufp
->ddocfunc
.global
)
2085 add_psymbol_to_list (namestring
, strlen (namestring
),
2086 VAR_DOMAIN
, LOC_BLOCK
,
2087 &objfile
->global_psymbols
, valu
,
2088 0, language_unknown
, objfile
);
2090 add_psymbol_to_list (namestring
, strlen (namestring
),
2091 VAR_DOMAIN
, LOC_BLOCK
,
2092 &objfile
->static_psymbols
, valu
,
2093 0, language_unknown
, objfile
);
2094 within_function
= 1;
2097 case DNTT_TYPE_BEGIN
:
2099 /* We don't check MODULE end here, because there can be
2100 symbols beyond the module end which properly belong to the
2101 current psymtab -- so we wait till the next MODULE start */
2104 #ifdef QUICK_LOOK_UP
2105 if (scan_start
== hp_symnum
2106 && symcount
== hp_symnum
+ 1)
2108 /* If there are NO globals in an executable,
2109 PXDB's index to the globals will point to
2110 the last record in the file, which is
2111 probably an END MODULE, i.e. this record.
2112 ignore it and be done! */
2115 #endif /* QUICK_LOOK_UP */
2117 /* Scope block begin/end. We only care about function
2118 and file blocks right now. */
2120 if ((dn_bufp
->dend
.endkind
== DNTT_TYPE_FUNCTION
) ||
2121 (dn_bufp
->dend
.endkind
== DNTT_TYPE_DOC_FUNCTION
))
2122 within_function
= 0;
2125 case DNTT_TYPE_SVAR
:
2126 case DNTT_TYPE_DVAR
:
2127 case DNTT_TYPE_TYPEDEF
:
2128 case DNTT_TYPE_TAGDEF
:
2130 /* Variables, typedefs an the like. */
2131 enum address_class storage
;
2134 /* Don't add locals to the partial symbol table. */
2136 && (dn_bufp
->dblock
.kind
== DNTT_TYPE_SVAR
2137 || dn_bufp
->dblock
.kind
== DNTT_TYPE_DVAR
))
2140 /* TAGDEFs go into the structure domain. */
2141 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_TAGDEF
)
2142 domain
= STRUCT_DOMAIN
;
2144 domain
= VAR_DOMAIN
;
2146 /* What kind of "storage" does this use? */
2147 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_SVAR
)
2148 storage
= LOC_STATIC
;
2149 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_DVAR
2150 && dn_bufp
->ddvar
.regvar
)
2151 storage
= LOC_REGISTER
;
2152 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_DVAR
)
2153 storage
= LOC_LOCAL
;
2155 storage
= LOC_UNDEF
;
2157 set_namestring (dn_bufp
, &namestring
, objfile
);
2160 pst
= hpread_start_psymtab (objfile
,
2163 * sizeof (struct dntt_type_block
)),
2164 objfile
->global_psymbols
.next
,
2165 objfile
->static_psymbols
.next
);
2168 /* Compute address of the data symbol */
2169 valu
= dn_bufp
->dsvar
.location
;
2170 /* Relocate in case it's in a shared library */
2171 if (storage
== LOC_STATIC
)
2172 valu
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2174 /* Luckily, dvar, svar, typedef, and tagdef all
2175 have their "global" bit in the same place, so it works
2176 (though it's bad programming practice) to reference
2177 "dsvar.global" even though we may be looking at
2178 any of the above four types. */
2179 if (dn_bufp
->dsvar
.global
)
2181 add_psymbol_to_list (namestring
, strlen (namestring
),
2183 &objfile
->global_psymbols
,
2185 0, language_unknown
, objfile
);
2189 add_psymbol_to_list (namestring
, strlen (namestring
),
2191 &objfile
->static_psymbols
,
2193 0, language_unknown
, objfile
);
2196 /* For TAGDEF's, the above code added the tagname to the
2197 struct domain. This will cause tag "t" to be found
2198 on a reference of the form "(struct t) x". But for
2199 C++ classes, "t" will also be a typename, which we
2200 want to find on a reference of the form "ptype t".
2201 Therefore, we also add "t" to the var domain.
2202 Do the same for enum's due to the way aCC generates
2203 debug info for these (see more extended comment
2204 in hp-symtab-read.c).
2205 We do the same for templates, so that "ptype t"
2206 where "t" is a template also works. */
2207 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_TAGDEF
&&
2208 dn_bufp
->dtype
.type
.dnttp
.index
< LNTT_SYMCOUNT (objfile
))
2210 int global
= dn_bufp
->dtag
.global
;
2211 /* Look ahead to see if it's a C++ class */
2212 dn_bufp
= hpread_get_lntt (dn_bufp
->dtype
.type
.dnttp
.index
, objfile
);
2213 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_CLASS
||
2214 dn_bufp
->dblock
.kind
== DNTT_TYPE_ENUM
||
2215 dn_bufp
->dblock
.kind
== DNTT_TYPE_TEMPLATE
)
2219 add_psymbol_to_list (namestring
, strlen (namestring
),
2220 VAR_DOMAIN
, storage
,
2221 &objfile
->global_psymbols
,
2222 dn_bufp
->dsvar
.location
,
2223 0, language_unknown
, objfile
);
2227 add_psymbol_to_list (namestring
, strlen (namestring
),
2228 VAR_DOMAIN
, storage
,
2229 &objfile
->static_psymbols
,
2230 dn_bufp
->dsvar
.location
,
2231 0, language_unknown
, objfile
);
2238 case DNTT_TYPE_MEMENUM
:
2239 case DNTT_TYPE_CONST
:
2240 /* Constants and members of enumerated types. */
2241 set_namestring (dn_bufp
, &namestring
, objfile
);
2244 pst
= hpread_start_psymtab (objfile
,
2247 * sizeof (struct dntt_type_block
)),
2248 objfile
->global_psymbols
.next
,
2249 objfile
->static_psymbols
.next
);
2251 if (dn_bufp
->dconst
.global
)
2252 add_psymbol_to_list (namestring
, strlen (namestring
),
2253 VAR_DOMAIN
, LOC_CONST
,
2254 &objfile
->global_psymbols
, 0,
2255 0, language_unknown
, objfile
);
2257 add_psymbol_to_list (namestring
, strlen (namestring
),
2258 VAR_DOMAIN
, LOC_CONST
,
2259 &objfile
->static_psymbols
, 0,
2260 0, language_unknown
, objfile
);
2268 /* End any pending partial symbol table. */
2271 hpread_end_psymtab (pst
, psymtab_include_list
, includes_used
,
2272 hp_symnum
* sizeof (struct dntt_type_block
),
2273 0, dependency_list
, dependencies_used
);
2276 discard_cleanups (old_chain
);
2279 /* Perform any local cleanups required when we are done with a particular
2280 objfile. I.E, we are in the process of discarding all symbol information
2281 for an objfile, freeing up all memory held for it, and unlinking the
2282 objfile struct from the global list of known objfiles. */
2285 hpread_symfile_finish (struct objfile
*objfile
)
2287 if (objfile
->sym_private
!= NULL
)
2289 xmfree (objfile
->md
, objfile
->sym_private
);
2294 /* The remaining functions are all for internal use only. */
2296 /* Various small functions to get entries in the debug symbol sections. */
2298 static union dnttentry
*
2299 hpread_get_lntt (int index
, struct objfile
*objfile
)
2301 return (union dnttentry
*)
2302 &(LNTT (objfile
)[(index
* sizeof (struct dntt_type_block
))]);
2305 static union dnttentry
*
2306 hpread_get_gntt (int index
, struct objfile
*objfile
)
2308 return (union dnttentry
*)
2309 &(GNTT (objfile
)[(index
* sizeof (struct dntt_type_block
))]);
2312 static union sltentry
*
2313 hpread_get_slt (int index
, struct objfile
*objfile
)
2315 return (union sltentry
*) &(SLT (objfile
)[index
* sizeof (union sltentry
)]);
2318 /* Get the low address associated with some symbol (typically the start
2319 of a particular source file or module). Since that information is not
2320 stored as part of the DNTT_TYPE_MODULE or DNTT_TYPE_SRCFILE symbol we
2321 must infer it from the existence of DNTT_TYPE_FUNCTION symbols. */
2323 static unsigned long
2324 hpread_get_textlow (int global
, int index
, struct objfile
*objfile
,
2327 union dnttentry
*dn_bufp
= NULL
;
2328 struct minimal_symbol
*msymbol
;
2330 /* Look for a DNTT_TYPE_FUNCTION symbol. */
2331 if (index
< symcount
) /* symcount is the number of symbols in */
2332 { /* the dbinfo, LNTT table */
2336 dn_bufp
= hpread_get_gntt (index
++, objfile
);
2338 dn_bufp
= hpread_get_lntt (index
++, objfile
);
2340 while (dn_bufp
->dblock
.kind
!= DNTT_TYPE_FUNCTION
2341 && dn_bufp
->dblock
.kind
!= DNTT_TYPE_DOC_FUNCTION
2342 && dn_bufp
->dblock
.kind
!= DNTT_TYPE_END
2343 && index
< symcount
);
2346 /* NOTE: cagney/2003-03-29: If !(index < symcount), dn_bufp is left
2347 undefined and that means that the test below is using a garbage
2348 pointer from the stack. */
2349 gdb_assert (dn_bufp
!= NULL
);
2351 /* Avoid going past a DNTT_TYPE_END when looking for a DNTT_TYPE_FUNCTION. This
2352 might happen when a sourcefile has no functions. */
2353 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_END
)
2356 /* Avoid going past the end of the LNTT file */
2357 if (index
== symcount
)
2360 /* The minimal symbols are typically more accurate for some reason. */
2361 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_FUNCTION
)
2362 msymbol
= lookup_minimal_symbol (dn_bufp
->dfunc
.name
+ VT (objfile
), NULL
,
2364 else /* must be a DNTT_TYPE_DOC_FUNCTION */
2365 msymbol
= lookup_minimal_symbol (dn_bufp
->ddocfunc
.name
+ VT (objfile
), NULL
,
2369 return SYMBOL_VALUE_ADDRESS (msymbol
);
2371 return dn_bufp
->dfunc
.lowaddr
;
2374 /* Allocate and partially fill a partial symtab. It will be
2375 completely filled at the end of the symbol list.
2377 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
2378 is the address relative to which its symbols are (incremental) or 0
2381 static struct partial_symtab
*
2382 hpread_start_psymtab (struct objfile
*objfile
, char *filename
,
2383 CORE_ADDR textlow
, int ldsymoff
,
2384 struct partial_symbol
**global_syms
,
2385 struct partial_symbol
**static_syms
)
2387 int offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2388 extern void hpread_psymtab_to_symtab ();
2389 struct partial_symtab
*result
=
2390 start_psymtab_common (objfile
, objfile
->section_offsets
,
2391 filename
, textlow
, global_syms
, static_syms
);
2393 result
->textlow
+= offset
;
2394 result
->read_symtab_private
= (char *)
2395 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct symloc
));
2396 LDSYMOFF (result
) = ldsymoff
;
2397 result
->read_symtab
= hpread_psymtab_to_symtab
;
2403 /* Close off the current usage of PST.
2404 Returns PST or NULL if the partial symtab was empty and thrown away.
2406 capping_symbol_offset --Byte index in LNTT or GNTT of the
2407 last symbol processed during the build
2408 of the previous pst.
2410 FIXME: List variables and peculiarities of same. */
2412 static struct partial_symtab
*
2413 hpread_end_psymtab (struct partial_symtab
*pst
, char **include_list
,
2414 int num_includes
, int capping_symbol_offset
,
2415 CORE_ADDR capping_text
,
2416 struct partial_symtab
**dependency_list
,
2417 int number_dependencies
)
2420 struct objfile
*objfile
= pst
->objfile
;
2421 int offset
= ANOFFSET (pst
->section_offsets
, SECT_OFF_TEXT (objfile
));
2424 /* Turn on to see what kind of a psymtab we've built. */
2425 static int dumping
= 0;
2428 if (capping_symbol_offset
!= -1)
2429 LDSYMLEN (pst
) = capping_symbol_offset
- LDSYMOFF (pst
);
2432 pst
->texthigh
= capping_text
+ offset
;
2434 pst
->n_global_syms
=
2435 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
2436 pst
->n_static_syms
=
2437 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
2442 printf ("\nPst %s, LDSYMOFF %x (%x), LDSYMLEN %x (%x), globals %d, statics %d\n",
2445 LDSYMOFF (pst
) / sizeof (struct dntt_type_block
),
2447 LDSYMLEN (pst
) / sizeof (struct dntt_type_block
),
2448 pst
->n_global_syms
, pst
->n_static_syms
);
2452 pst
->number_of_dependencies
= number_dependencies
;
2453 if (number_dependencies
)
2455 pst
->dependencies
= (struct partial_symtab
**)
2456 obstack_alloc (&objfile
->psymbol_obstack
,
2457 number_dependencies
* sizeof (struct partial_symtab
*));
2458 memcpy (pst
->dependencies
, dependency_list
,
2459 number_dependencies
* sizeof (struct partial_symtab
*));
2462 pst
->dependencies
= 0;
2464 for (i
= 0; i
< num_includes
; i
++)
2466 struct partial_symtab
*subpst
=
2467 allocate_psymtab (include_list
[i
], objfile
);
2469 subpst
->section_offsets
= pst
->section_offsets
;
2470 subpst
->read_symtab_private
=
2471 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
2472 sizeof (struct symloc
));
2476 subpst
->texthigh
= 0;
2478 /* We could save slight bits of space by only making one of these,
2479 shared by the entire set of include files. FIXME-someday. */
2480 subpst
->dependencies
= (struct partial_symtab
**)
2481 obstack_alloc (&objfile
->psymbol_obstack
,
2482 sizeof (struct partial_symtab
*));
2483 subpst
->dependencies
[0] = pst
;
2484 subpst
->number_of_dependencies
= 1;
2486 subpst
->globals_offset
=
2487 subpst
->n_global_syms
=
2488 subpst
->statics_offset
=
2489 subpst
->n_static_syms
= 0;
2493 subpst
->read_symtab
= pst
->read_symtab
;
2496 sort_pst_symbols (pst
);
2498 /* If there is already a psymtab or symtab for a file of this name, remove it.
2499 (If there is a symtab, more drastic things also happen.)
2500 This happens in VxWorks. */
2501 free_named_symtabs (pst
->filename
);
2503 if (num_includes
== 0
2504 && number_dependencies
== 0
2505 && pst
->n_global_syms
== 0
2506 && pst
->n_static_syms
== 0)
2508 /* Throw away this psymtab, it's empty. We can't deallocate it, since
2509 it is on the obstack, but we can forget to chain it on the list.
2510 Empty psymtabs happen as a result of header files which don't have
2511 any symbols in them. There can be a lot of them. But this check
2512 is wrong, in that a psymtab with N_SLINE entries but nothing else
2513 is not empty, but we don't realize that. Fixing that without slowing
2514 things down might be tricky.
2515 It's also wrong if we're using the quick look-up tables, as
2516 we can get empty psymtabs from modules with no routines in
2519 discard_psymtab (pst
);
2521 /* Indicate that psymtab was thrown away. */
2522 pst
= (struct partial_symtab
*) NULL
;
2529 /* Get the nesting depth for the source line identified by INDEX. */
2531 static unsigned long
2532 hpread_get_scope_start (sltpointer index
, struct objfile
*objfile
)
2534 union sltentry
*sl_bufp
;
2536 sl_bufp
= hpread_get_slt (index
, objfile
);
2537 return sl_bufp
->sspec
.backptr
.dnttp
.index
;
2540 /* Get the source line number the the line identified by INDEX. */
2542 static unsigned long
2543 hpread_get_line (sltpointer index
, struct objfile
*objfile
)
2545 union sltentry
*sl_bufp
;
2547 sl_bufp
= hpread_get_slt (index
, objfile
);
2548 return sl_bufp
->snorm
.line
;
2551 /* Find the code address associated with a given sltpointer */
2554 hpread_get_location (sltpointer index
, struct objfile
*objfile
)
2556 union sltentry
*sl_bufp
;
2559 /* code location of special sltentrys is determined from context */
2560 sl_bufp
= hpread_get_slt (index
, objfile
);
2562 if (sl_bufp
->snorm
.sltdesc
== SLT_END
)
2564 /* find previous normal sltentry and get address */
2565 for (i
= 0; ((sl_bufp
->snorm
.sltdesc
!= SLT_NORMAL
) &&
2566 (sl_bufp
->snorm
.sltdesc
!= SLT_NORMAL_OFFSET
) &&
2567 (sl_bufp
->snorm
.sltdesc
!= SLT_EXIT
)); i
++)
2568 sl_bufp
= hpread_get_slt (index
- i
, objfile
);
2569 if (sl_bufp
->snorm
.sltdesc
== SLT_NORMAL_OFFSET
)
2570 return sl_bufp
->snormoff
.address
;
2572 return sl_bufp
->snorm
.address
;
2575 /* find next normal sltentry and get address */
2576 for (i
= 0; ((sl_bufp
->snorm
.sltdesc
!= SLT_NORMAL
) &&
2577 (sl_bufp
->snorm
.sltdesc
!= SLT_NORMAL_OFFSET
) &&
2578 (sl_bufp
->snorm
.sltdesc
!= SLT_EXIT
)); i
++)
2579 sl_bufp
= hpread_get_slt (index
+ i
, objfile
);
2580 if (sl_bufp
->snorm
.sltdesc
== SLT_NORMAL_OFFSET
)
2581 return sl_bufp
->snormoff
.address
;
2583 return sl_bufp
->snorm
.address
;
2587 /* Return 1 if an HP debug symbol of type KIND has a name associated with
2588 * it, else return 0. (This function is not currently used, but I'll
2589 * leave it here in case it proves useful later on. - RT).
2593 hpread_has_name (enum dntt_entry_type kind
)
2597 case DNTT_TYPE_SRCFILE
:
2598 case DNTT_TYPE_MODULE
:
2599 case DNTT_TYPE_FUNCTION
:
2600 case DNTT_TYPE_DOC_FUNCTION
:
2601 case DNTT_TYPE_ENTRY
:
2602 case DNTT_TYPE_IMPORT
:
2603 case DNTT_TYPE_LABEL
:
2604 case DNTT_TYPE_FPARAM
:
2605 case DNTT_TYPE_SVAR
:
2606 case DNTT_TYPE_DVAR
:
2607 case DNTT_TYPE_CONST
:
2608 case DNTT_TYPE_TYPEDEF
:
2609 case DNTT_TYPE_TAGDEF
:
2610 case DNTT_TYPE_MEMENUM
:
2611 case DNTT_TYPE_FIELD
:
2613 case DNTT_TYPE_BLOCKDATA
:
2614 case DNTT_TYPE_MEMFUNC
:
2615 case DNTT_TYPE_DOC_MEMFUNC
:
2618 case DNTT_TYPE_BEGIN
:
2620 case DNTT_TYPE_POINTER
:
2621 case DNTT_TYPE_ENUM
:
2623 case DNTT_TYPE_ARRAY
:
2624 case DNTT_TYPE_STRUCT
:
2625 case DNTT_TYPE_UNION
:
2626 case DNTT_TYPE_VARIANT
:
2627 case DNTT_TYPE_FILE
:
2628 case DNTT_TYPE_FUNCTYPE
:
2629 case DNTT_TYPE_SUBRANGE
:
2630 case DNTT_TYPE_WITH
:
2631 case DNTT_TYPE_COMMON
:
2632 case DNTT_TYPE_COBSTRUCT
:
2633 case DNTT_TYPE_XREF
:
2634 case DNTT_TYPE_MACRO
:
2635 case DNTT_TYPE_CLASS_SCOPE
:
2636 case DNTT_TYPE_REFERENCE
:
2637 case DNTT_TYPE_PTRMEM
:
2638 case DNTT_TYPE_PTRMEMFUNC
:
2639 case DNTT_TYPE_CLASS
:
2640 case DNTT_TYPE_GENFIELD
:
2641 case DNTT_TYPE_VFUNC
:
2642 case DNTT_TYPE_MEMACCESS
:
2643 case DNTT_TYPE_INHERITANCE
:
2644 case DNTT_TYPE_FRIEND_CLASS
:
2645 case DNTT_TYPE_FRIEND_FUNC
:
2646 case DNTT_TYPE_MODIFIER
:
2647 case DNTT_TYPE_OBJECT_ID
:
2648 case DNTT_TYPE_TEMPLATE
:
2649 case DNTT_TYPE_TEMPLATE_ARG
:
2650 case DNTT_TYPE_FUNC_TEMPLATE
:
2651 case DNTT_TYPE_LINK
:
2652 /* DNTT_TYPE_DYN_ARRAY_DESC ? */
2653 /* DNTT_TYPE_DESC_SUBRANGE ? */
2654 /* DNTT_TYPE_BEGIN_EXT ? */
2655 /* DNTT_TYPE_INLN ? */
2656 /* DNTT_TYPE_INLN_LIST ? */
2657 /* DNTT_TYPE_ALIAS ? */
2663 /* Do the dirty work of reading in the full symbol from a partial symbol
2667 hpread_psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2669 struct cleanup
*old_chain
;
2672 /* Get out quick if passed junk. */
2676 /* Complain if we've already read in this symbol table. */
2679 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in."
2680 " Shouldn't happen.\n",
2685 /* Read in all partial symtabs on which this one is dependent */
2686 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2687 if (!pst
->dependencies
[i
]->readin
)
2689 /* Inform about additional files that need to be read in. */
2692 fputs_filtered (" ", gdb_stdout
);
2694 fputs_filtered ("and ", gdb_stdout
);
2696 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2697 wrap_here (""); /* Flush output */
2698 gdb_flush (gdb_stdout
);
2700 hpread_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
2703 /* If it's real... */
2706 /* Init stuff necessary for reading in symbols */
2708 old_chain
= make_cleanup (really_free_pendings
, 0);
2711 hpread_expand_symtab (pst
->objfile
, LDSYMOFF (pst
), LDSYMLEN (pst
),
2712 pst
->textlow
, pst
->texthigh
- pst
->textlow
,
2713 pst
->section_offsets
, pst
->filename
);
2714 sort_symtab_syms (pst
->symtab
);
2716 do_cleanups (old_chain
);
2722 /* Read in all of the symbols for a given psymtab for real.
2723 Be verbose about it if the user wants that. */
2726 hpread_psymtab_to_symtab (struct partial_symtab
*pst
)
2728 /* Get out quick if given junk. */
2735 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in."
2736 " Shouldn't happen.\n",
2741 /* elz: setting the flag to indicate that the code of the target
2742 was compiled using an HP compiler (aCC, cc)
2743 the processing_acc_compilation variable is declared in the
2744 file buildsym.h, the HP_COMPILED_TARGET is defined to be equal
2745 to 3 in the file tm_hppa.h */
2747 processing_gcc_compilation
= 0;
2749 if (LDSYMLEN (pst
) || pst
->number_of_dependencies
)
2751 /* Print the message now, before reading the string table,
2752 to avoid disconcerting pauses. */
2755 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
2756 gdb_flush (gdb_stdout
);
2759 hpread_psymtab_to_symtab_1 (pst
);
2761 /* Match with global symbols. This only needs to be done once,
2762 after all of the symtabs and dependencies have been read in. */
2763 scan_file_globals (pst
->objfile
);
2765 /* Finish up the debug error message. */
2767 printf_filtered ("done.\n");
2771 /* Read in a defined section of a specific object file's symbols.
2773 DESC is the file descriptor for the file, positioned at the
2774 beginning of the symtab
2775 SYM_OFFSET is the offset within the file of
2776 the beginning of the symbols we want to read
2777 SYM_SIZE is the size of the symbol info to read in.
2778 TEXT_OFFSET is the beginning of the text segment we are reading symbols for
2779 TEXT_SIZE is the size of the text segment read in.
2780 SECTION_OFFSETS are the relocation offsets which get added to each symbol. */
2782 static struct symtab
*
2783 hpread_expand_symtab (struct objfile
*objfile
, int sym_offset
, int sym_size
,
2784 CORE_ADDR text_offset
, int text_size
,
2785 struct section_offsets
*section_offsets
, char *filename
)
2788 union dnttentry
*dn_bufp
;
2789 unsigned max_symnum
;
2790 int at_module_boundary
= 0;
2791 /* 1 => at end, -1 => at beginning */
2793 int sym_index
= sym_offset
/ sizeof (struct dntt_type_block
);
2795 current_objfile
= objfile
;
2798 last_source_file
= 0;
2800 /* Demangling style -- if EDG style already set, don't change it,
2801 as HP style causes some problems with the KAI EDG compiler */
2802 if (current_demangling_style
!= edg_demangling
)
2804 /* Otherwise, ensure that we are using HP style demangling */
2805 set_demangling_style (HP_DEMANGLING_STYLE_STRING
);
2808 dn_bufp
= hpread_get_lntt (sym_index
, objfile
);
2809 if (!((dn_bufp
->dblock
.kind
== (unsigned char) DNTT_TYPE_SRCFILE
) ||
2810 (dn_bufp
->dblock
.kind
== (unsigned char) DNTT_TYPE_MODULE
)))
2812 start_symtab ("globals", NULL
, 0);
2813 record_debugformat ("HP");
2816 /* The psymtab builder (hp-psymtab-read.c) is the one that
2817 * determined the "sym_size" argument (i.e. how many DNTT symbols
2818 * are in this symtab), which we use to compute "max_symnum"
2819 * (point in DNTT to which we read).
2821 * Perhaps this should be changed so that
2822 * process_one_debug_symbol() "knows" when
2823 * to stop reading (based on reading from the MODULE to the matching
2824 * END), and take out this reliance on a #-syms being passed in...
2825 * (I'm worried about the reliability of this number). But I'll
2826 * leave it as-is, for now. - RT
2828 * The change above has been made. I've left the "for" loop control
2829 * in to prepare for backing this out again. -JB
2831 max_symnum
= sym_size
/ sizeof (struct dntt_type_block
);
2832 /* No reason to multiply on pst side and divide on sym side... FIXME */
2834 /* Read in and process each debug symbol within the specified range.
2837 symnum
< max_symnum
;
2840 QUIT
; /* Allow this to be interruptable */
2841 dn_bufp
= hpread_get_lntt (sym_index
+ symnum
, objfile
);
2843 if (dn_bufp
->dblock
.extension
)
2846 /* Yow! We call set_namestring on things without names! */
2847 set_namestring (dn_bufp
, &namestring
, objfile
);
2849 hpread_process_one_debug_symbol (dn_bufp
, namestring
, section_offsets
,
2850 objfile
, text_offset
, text_size
,
2851 filename
, symnum
+ sym_index
,
2855 /* OLD COMMENTS: This routine is only called for psts. All psts
2856 * correspond to MODULES. If we ever do lazy-reading of globals
2857 * from the LNTT, then there will be a pst which ends when the
2858 * LNTT ends, and not at an END MODULE entry. Then we'll have
2859 * to re-visit this break.
2861 if( at_end_of_module )
2866 /* We no longer break out of the loop when we reach the end of a
2867 module. The reason is that with CTTI, the compiler can generate
2868 function symbols (for template function instantiations) which are not
2869 in any module; typically they show up beyond a module's end, and
2870 before the next module's start. We include them in the current
2871 module. However, we still don't trust the MAX_SYMNUM value from
2872 the psymtab, so we break out if we enter a new module. */
2874 if (at_module_boundary
== -1)
2878 current_objfile
= NULL
;
2879 hp_som_som_object_present
= 1; /* Indicate we've processed an HP SOM SOM file */
2881 return end_symtab (text_offset
+ text_size
, objfile
, SECT_OFF_TEXT (objfile
));
2887 /* Convert basic types from HP debug format into GDB internal format. */
2890 hpread_type_translate (dnttpointer typep
)
2892 if (!typep
.dntti
.immediate
)
2894 error ("error in hpread_type_translate\n.");
2898 switch (typep
.dntti
.type
)
2900 case HP_TYPE_BOOLEAN
:
2901 case HP_TYPE_BOOLEAN_S300_COMPAT
:
2902 case HP_TYPE_BOOLEAN_VAX_COMPAT
:
2904 case HP_TYPE_CHAR
: /* C signed char, C++ plain char */
2906 case HP_TYPE_WIDE_CHAR
:
2909 if (typep
.dntti
.bitlength
<= 8)
2910 return FT_SIGNED_CHAR
; /* C++ signed char */
2911 if (typep
.dntti
.bitlength
<= 16)
2913 if (typep
.dntti
.bitlength
<= 32)
2915 return FT_LONG_LONG
;
2917 if (typep
.dntti
.bitlength
<= 8)
2918 return FT_SIGNED_CHAR
; /* C++ signed char. */
2920 case HP_TYPE_UNSIGNED_LONG
:
2921 if (typep
.dntti
.bitlength
<= 8)
2922 return FT_UNSIGNED_CHAR
; /* C/C++ unsigned char */
2923 if (typep
.dntti
.bitlength
<= 16)
2924 return FT_UNSIGNED_SHORT
;
2925 if (typep
.dntti
.bitlength
<= 32)
2926 return FT_UNSIGNED_LONG
;
2927 return FT_UNSIGNED_LONG_LONG
;
2928 case HP_TYPE_UNSIGNED_INT
:
2929 if (typep
.dntti
.bitlength
<= 8)
2930 return FT_UNSIGNED_CHAR
;
2931 if (typep
.dntti
.bitlength
<= 16)
2932 return FT_UNSIGNED_SHORT
;
2933 if (typep
.dntti
.bitlength
<= 32)
2934 return FT_UNSIGNED_INTEGER
;
2935 return FT_UNSIGNED_LONG_LONG
;
2937 case HP_TYPE_REAL_3000
:
2938 case HP_TYPE_DOUBLE
:
2939 if (typep
.dntti
.bitlength
== 64)
2940 return FT_DBL_PREC_FLOAT
;
2941 if (typep
.dntti
.bitlength
== 128)
2942 return FT_EXT_PREC_FLOAT
;
2944 case HP_TYPE_COMPLEX
:
2945 case HP_TYPE_COMPLEXS3000
:
2946 if (typep
.dntti
.bitlength
== 128)
2947 return FT_DBL_PREC_COMPLEX
;
2948 if (typep
.dntti
.bitlength
== 192)
2949 return FT_EXT_PREC_COMPLEX
;
2953 case HP_TYPE_STRING200
:
2954 case HP_TYPE_LONGSTRING200
:
2955 case HP_TYPE_FTN_STRING_SPEC
:
2956 case HP_TYPE_MOD_STRING_SPEC
:
2957 case HP_TYPE_MOD_STRING_3000
:
2958 case HP_TYPE_FTN_STRING_S300_COMPAT
:
2959 case HP_TYPE_FTN_STRING_VAX_COMPAT
:
2961 case HP_TYPE_TEMPLATE_ARG
:
2962 return FT_TEMPLATE_ARG
;
2964 case HP_TYPE_FLABEL
:
2965 case HP_TYPE_PACKED_DECIMAL
:
2966 case HP_TYPE_ANYPOINTER
:
2967 case HP_TYPE_GLOBAL_ANYPOINTER
:
2968 case HP_TYPE_LOCAL_ANYPOINTER
:
2970 warning ("hpread_type_translate: unhandled type code.\n");
2975 /* Given a position in the DNTT, return a pointer to the
2976 * already-built "struct type" (if any), for the type defined
2980 static struct type
**
2981 hpread_lookup_type (dnttpointer hp_type
, struct objfile
*objfile
)
2984 int index
= hp_type
.dnttp
.index
;
2985 int size_changed
= 0;
2987 /* The immediate flag indicates this doesn't actually point to
2990 if (hp_type
.dntti
.immediate
)
2993 /* For each objfile, we maintain a "type vector".
2994 * This an array of "struct type *"'s with one pointer per DNTT index.
2995 * Given a DNTT index, we look in this array to see if we have
2996 * already processed this DNTT and if it is a type definition.
2997 * If so, then we can locate a pointer to the already-built
2998 * "struct type", and not build it again.
3000 * The need for this arises because our DNTT-walking code wanders
3001 * around. In particular, it will encounter the same type multiple
3002 * times (once for each object of that type). We don't want to
3003 * built multiple "struct type"'s for the same thing.
3005 * Having said this, I should point out that this type-vector is
3006 * an expensive way to keep track of this. If most DNTT entries are
3007 * 3 words, the type-vector will be 1/3 the size of the DNTT itself.
3008 * Alternative solutions:
3009 * - Keep a compressed or hashed table. Less memory, but more expensive
3010 * to search and update.
3011 * - (Suggested by JB): Overwrite the DNTT entry itself
3012 * with the info. Create a new type code "ALREADY_BUILT", and modify
3013 * the DNTT to have that type code and point to the already-built entry.
3017 if (index
< LNTT_SYMCOUNT (objfile
))
3019 if (index
>= DNTT_TYPE_VECTOR_LENGTH (objfile
))
3021 old_len
= DNTT_TYPE_VECTOR_LENGTH (objfile
);
3023 /* See if we need to allocate a type-vector. */
3026 DNTT_TYPE_VECTOR_LENGTH (objfile
) = LNTT_SYMCOUNT (objfile
) + GNTT_SYMCOUNT (objfile
);
3027 DNTT_TYPE_VECTOR (objfile
) = (struct type
**)
3028 xmmalloc (objfile
->md
, DNTT_TYPE_VECTOR_LENGTH (objfile
) * sizeof (struct type
*));
3029 memset (&DNTT_TYPE_VECTOR (objfile
)[old_len
], 0,
3030 (DNTT_TYPE_VECTOR_LENGTH (objfile
) - old_len
) *
3031 sizeof (struct type
*));
3034 /* See if we need to resize type-vector. With my change to
3035 * initially allocate a correct-size type-vector, this code
3036 * should no longer trigger.
3038 while (index
>= DNTT_TYPE_VECTOR_LENGTH (objfile
))
3040 DNTT_TYPE_VECTOR_LENGTH (objfile
) *= 2;
3045 DNTT_TYPE_VECTOR (objfile
) = (struct type
**)
3046 xmrealloc (objfile
->md
,
3047 (char *) DNTT_TYPE_VECTOR (objfile
),
3048 (DNTT_TYPE_VECTOR_LENGTH (objfile
) * sizeof (struct type
*)));
3050 memset (&DNTT_TYPE_VECTOR (objfile
)[old_len
], 0,
3051 (DNTT_TYPE_VECTOR_LENGTH (objfile
) - old_len
) *
3052 sizeof (struct type
*));
3056 return &DNTT_TYPE_VECTOR (objfile
)[index
];
3062 /* Possibly allocate a GDB internal type so we can internalize HP_TYPE.
3063 Note we'll just return the address of a GDB internal type if we already
3064 have it lying around. */
3066 static struct type
*
3067 hpread_alloc_type (dnttpointer hp_type
, struct objfile
*objfile
)
3069 struct type
**type_addr
;
3071 type_addr
= hpread_lookup_type (hp_type
, objfile
);
3072 if (*type_addr
== 0)
3074 *type_addr
= alloc_type (objfile
);
3076 /* A hack - if we really are a C++ class symbol, then this default
3077 * will get overriden later on.
3079 TYPE_CPLUS_SPECIFIC (*type_addr
)
3080 = (struct cplus_struct_type
*) &cplus_struct_default
;
3086 /* Read a native enumerated type and return it in GDB internal form. */
3088 static struct type
*
3089 hpread_read_enum_type (dnttpointer hp_type
, union dnttentry
*dn_bufp
,
3090 struct objfile
*objfile
)
3093 struct pending
**symlist
, *osyms
, *syms
;
3094 struct pending
*local_list
= NULL
;
3095 int o_nsyms
, nsyms
= 0;
3097 union dnttentry
*memp
;
3102 /* Allocate a GDB type. If we've already read in this enum type,
3103 * it'll return the already built GDB type, so stop here.
3104 * (Note: I added this check, to conform with what's done for
3105 * struct, union, class.
3106 * I assume this is OK. - RT)
3108 type
= hpread_alloc_type (hp_type
, objfile
);
3109 if (TYPE_CODE (type
) == TYPE_CODE_ENUM
)
3112 /* HP C supports "sized enums", where a specifier such as "short" or
3113 "char" can be used to get enums of different sizes. So don't assume
3114 an enum is always 4 bytes long. pai/1997-08-21 */
3115 TYPE_LENGTH (type
) = dn_bufp
->denum
.bitlength
/ 8;
3117 symlist
= &file_symbols
;
3119 o_nsyms
= osyms
? osyms
->nsyms
: 0;
3121 /* Get a name for each member and add it to our list of members.
3122 * The list of "mem" SOM records we are walking should all be
3123 * SOM type DNTT_TYPE_MEMENUM (not checked).
3125 mem
= dn_bufp
->denum
.firstmem
;
3126 while (mem
.word
&& mem
.word
!= DNTTNIL
)
3128 memp
= hpread_get_lntt (mem
.dnttp
.index
, objfile
);
3130 name
= VT (objfile
) + memp
->dmember
.name
;
3131 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
3132 sizeof (struct symbol
));
3133 memset (sym
, 0, sizeof (struct symbol
));
3134 DEPRECATED_SYMBOL_NAME (sym
) = obsavestring (name
, strlen (name
),
3135 &objfile
->symbol_obstack
);
3136 SYMBOL_CLASS (sym
) = LOC_CONST
;
3137 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
3138 SYMBOL_VALUE (sym
) = memp
->dmember
.value
;
3139 add_symbol_to_list (sym
, symlist
);
3141 mem
= memp
->dmember
.nextmem
;
3144 /* Now that we know more about the enum, fill in more info. */
3145 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
3146 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
3147 TYPE_NFIELDS (type
) = nsyms
;
3148 TYPE_FIELDS (type
) = (struct field
*)
3149 obstack_alloc (&objfile
->type_obstack
, sizeof (struct field
) * nsyms
);
3151 /* Find the symbols for the members and put them into the type.
3152 The symbols can be found in the symlist that we put them on
3153 to cause them to be defined. osyms contains the old value
3154 of that symlist; everything up to there was defined by us.
3156 Note that we preserve the order of the enum constants, so
3157 that in something like "enum {FOO, LAST_THING=FOO}" we print
3158 FOO, not LAST_THING. */
3159 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
3164 for (; j
< syms
->nsyms
; j
++, n
++)
3166 struct symbol
*xsym
= syms
->symbol
[j
];
3167 SYMBOL_TYPE (xsym
) = type
;
3168 TYPE_FIELD_NAME (type
, n
) = DEPRECATED_SYMBOL_NAME (xsym
);
3169 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (xsym
);
3170 TYPE_FIELD_BITSIZE (type
, n
) = 0;
3171 TYPE_FIELD_STATIC_KIND (type
, n
) = 0;
3180 /* Read and internalize a native function debug symbol. */
3182 static struct type
*
3183 hpread_read_function_type (dnttpointer hp_type
, union dnttentry
*dn_bufp
,
3184 struct objfile
*objfile
, int newblock
)
3186 struct type
*type
, *type1
;
3187 struct pending
*syms
;
3188 struct pending
*local_list
= NULL
;
3191 union dnttentry
*paramp
;
3195 int record_args
= 1;
3197 /* See if we've already read in this type. */
3198 type
= hpread_alloc_type (hp_type
, objfile
);
3199 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
3201 record_args
= 0; /* already read in, don't modify type */
3205 /* Nope, so read it in and store it away. */
3206 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_FUNCTION
||
3207 dn_bufp
->dblock
.kind
== DNTT_TYPE_MEMFUNC
)
3208 type1
= lookup_function_type (hpread_type_lookup (dn_bufp
->dfunc
.retval
,
3210 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_FUNCTYPE
)
3211 type1
= lookup_function_type (hpread_type_lookup (dn_bufp
->dfunctype
.retval
,
3213 else /* expect DNTT_TYPE_FUNC_TEMPLATE */
3214 type1
= lookup_function_type (hpread_type_lookup (dn_bufp
->dfunc_template
.retval
,
3216 replace_type (type
, type1
);
3218 /* Mark it -- in the middle of processing */
3219 TYPE_FLAGS (type
) |= TYPE_FLAG_INCOMPLETE
;
3222 /* Now examine each parameter noting its type, location, and a
3223 wealth of other information. */
3224 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_FUNCTION
||
3225 dn_bufp
->dblock
.kind
== DNTT_TYPE_MEMFUNC
)
3226 param
= dn_bufp
->dfunc
.firstparam
;
3227 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_FUNCTYPE
)
3228 param
= dn_bufp
->dfunctype
.firstparam
;
3229 else /* expect DNTT_TYPE_FUNC_TEMPLATE */
3230 param
= dn_bufp
->dfunc_template
.firstparam
;
3231 while (param
.word
&& param
.word
!= DNTTNIL
)
3233 paramp
= hpread_get_lntt (param
.dnttp
.index
, objfile
);
3235 param
= paramp
->dfparam
.nextparam
;
3238 name
= VT (objfile
) + paramp
->dfparam
.name
;
3239 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
3240 sizeof (struct symbol
));
3241 (void) memset (sym
, 0, sizeof (struct symbol
));
3242 DEPRECATED_SYMBOL_NAME (sym
) = obsavestring (name
, strlen (name
),
3243 &objfile
->symbol_obstack
);
3245 /* Figure out where it lives. */
3246 if (paramp
->dfparam
.regparam
)
3247 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
3248 else if (paramp
->dfparam
.indirect
)
3249 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
3251 SYMBOL_CLASS (sym
) = LOC_ARG
;
3252 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
3253 if (paramp
->dfparam
.copyparam
)
3255 SYMBOL_VALUE (sym
) = paramp
->dfparam
.location
;
3256 #ifdef HPREAD_ADJUST_STACK_ADDRESS
3258 += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile
));
3260 /* This is likely a pass-by-invisible reference parameter,
3261 Hack on the symbol class to make GDB happy. */
3262 /* ??rehrauer: This appears to be broken w/r/t to passing
3263 C values of type float and struct. Perhaps this ought
3264 to be highighted as a special case, but for now, just
3265 allowing these to be LOC_ARGs seems to work fine.
3268 SYMBOL_CLASS (sym
) = LOC_REGPARM_ADDR
;
3272 SYMBOL_VALUE (sym
) = paramp
->dfparam
.location
;
3275 SYMBOL_TYPE (sym
) = hpread_type_lookup (paramp
->dfparam
.type
, objfile
);
3276 /* Add it to the symbol list. */
3277 /* Note 1 (RT) At the moment, add_symbol_to_list() is also being
3278 * called on FPARAM symbols from the process_one_debug_symbol()
3279 * level... so parameters are getting added twice! (this shows
3280 * up in the symbol dump you get from "maint print symbols ...").
3281 * Note 2 (RT) I took out the processing of FPARAM from the
3282 * process_one_debug_symbol() level, so at the moment parameters are only
3283 * being processed here. This seems to have no ill effect.
3285 /* Note 3 (pai/1997-08-11) I removed the add_symbol_to_list() which put
3286 each fparam on the local_symbols list from here. Now we use the
3287 local_list to which fparams are added below, and set the param_symbols
3288 global to point to that at the end of this routine. */
3289 /* elz: I added this new list of symbols which is local to the function.
3290 this list is the one which is actually used to build the type for the
3291 function rather than the gloabal list pointed to by symlist.
3292 Using a global list to keep track of the parameters is wrong, because
3293 this function is called recursively if one parameter happend to be
3294 a function itself with more parameters in it. Adding parameters to the
3295 same global symbol list would not work!
3296 Actually it did work in case of cc compiled programs where you do
3297 not check the parameter lists of the arguments. */
3298 add_symbol_to_list (sym
, &local_list
);
3302 /* If type was read in earlier, don't bother with modifying
3307 /* Note how many parameters we found. */
3308 TYPE_NFIELDS (type
) = nsyms
;
3309 TYPE_FIELDS (type
) = (struct field
*)
3310 obstack_alloc (&objfile
->type_obstack
,
3311 sizeof (struct field
) * nsyms
);
3313 /* Find the symbols for the parameters and
3314 use them to fill parameter-type information into the function-type.
3315 The parameter symbols can be found in the local_list that we just put them on. */
3316 /* Note that we preserve the order of the parameters, so
3317 that in something like "enum {FOO, LAST_THING=FOO}" we print
3318 FOO, not LAST_THING. */
3320 /* get the parameters types from the local list not the global list
3321 so that the type can be correctly constructed for functions which
3322 have function as parameters */
3323 for (syms
= local_list
, n
= 0; syms
; syms
= syms
->next
)
3326 for (j
= 0; j
< syms
->nsyms
; j
++, n
++)
3328 struct symbol
*xsym
= syms
->symbol
[j
];
3329 TYPE_FIELD_NAME (type
, n
) = DEPRECATED_SYMBOL_NAME (xsym
);
3330 TYPE_FIELD_TYPE (type
, n
) = SYMBOL_TYPE (xsym
);
3331 TYPE_FIELD_ARTIFICIAL (type
, n
) = 0;
3332 TYPE_FIELD_BITSIZE (type
, n
) = 0;
3333 TYPE_FIELD_STATIC_KIND (type
, n
) = 0;
3336 /* Mark it as having been processed */
3337 TYPE_FLAGS (type
) &= ~(TYPE_FLAG_INCOMPLETE
);
3339 /* Check whether we need to fix-up a class type with this function's type */
3340 if (fixup_class
&& (fixup_method
== type
))
3342 fixup_class_method_type (fixup_class
, fixup_method
, objfile
);
3344 fixup_method
= NULL
;
3347 /* Set the param list of this level of the context stack
3348 to our local list. Do this only if this function was
3349 called for creating a new block, and not if it was called
3350 simply to get the function type. This prevents recursive
3351 invocations from trashing param_symbols. */
3354 param_symbols
= local_list
;
3360 /* Read and internalize a native DOC function debug symbol. */
3361 /* This is almost identical to hpread_read_function_type(), except
3362 * for references to dn_bufp->ddocfunc instead of db_bufp->dfunc.
3363 * Since debug information for DOC functions is more likely to be
3364 * volatile, please leave it this way.
3366 static struct type
*
3367 hpread_read_doc_function_type (dnttpointer hp_type
, union dnttentry
*dn_bufp
,
3368 struct objfile
*objfile
, int newblock
)
3370 struct pending
*syms
;
3371 struct pending
*local_list
= NULL
;
3375 union dnttentry
*paramp
;
3379 int record_args
= 1;
3381 /* See if we've already read in this type. */
3382 type
= hpread_alloc_type (hp_type
, objfile
);
3383 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
3385 record_args
= 0; /* already read in, don't modify type */
3389 struct type
*type1
= NULL
;
3390 /* Nope, so read it in and store it away. */
3391 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_DOC_FUNCTION
||
3392 dn_bufp
->dblock
.kind
== DNTT_TYPE_DOC_MEMFUNC
)
3393 type1
= lookup_function_type (hpread_type_lookup (dn_bufp
->ddocfunc
.retval
,
3395 /* NOTE: cagney/2003-03-29: Oh, no not again. TYPE1 is
3396 potentially left undefined here. Assert it isn't and hope
3397 the assert never fails ... */
3398 gdb_assert (type1
!= NULL
);
3400 replace_type (type
, type1
);
3402 /* Mark it -- in the middle of processing */
3403 TYPE_FLAGS (type
) |= TYPE_FLAG_INCOMPLETE
;
3406 /* Now examine each parameter noting its type, location, and a
3407 wealth of other information. */
3408 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_DOC_FUNCTION
||
3409 dn_bufp
->dblock
.kind
== DNTT_TYPE_DOC_MEMFUNC
)
3410 param
= dn_bufp
->ddocfunc
.firstparam
;
3411 while (param
.word
&& param
.word
!= DNTTNIL
)
3413 paramp
= hpread_get_lntt (param
.dnttp
.index
, objfile
);
3415 param
= paramp
->dfparam
.nextparam
;
3418 name
= VT (objfile
) + paramp
->dfparam
.name
;
3419 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
3420 sizeof (struct symbol
));
3421 (void) memset (sym
, 0, sizeof (struct symbol
));
3422 DEPRECATED_SYMBOL_NAME (sym
) = name
;
3424 /* Figure out where it lives. */
3425 if (paramp
->dfparam
.regparam
)
3426 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
3427 else if (paramp
->dfparam
.indirect
)
3428 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
3430 SYMBOL_CLASS (sym
) = LOC_ARG
;
3431 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
3432 if (paramp
->dfparam
.copyparam
)
3434 SYMBOL_VALUE (sym
) = paramp
->dfparam
.location
;
3435 #ifdef HPREAD_ADJUST_STACK_ADDRESS
3437 += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile
));
3439 /* This is likely a pass-by-invisible reference parameter,
3440 Hack on the symbol class to make GDB happy. */
3441 /* ??rehrauer: This appears to be broken w/r/t to passing
3442 C values of type float and struct. Perhaps this ought
3443 to be highighted as a special case, but for now, just
3444 allowing these to be LOC_ARGs seems to work fine.
3447 SYMBOL_CLASS (sym
) = LOC_REGPARM_ADDR
;
3451 SYMBOL_VALUE (sym
) = paramp
->dfparam
.location
;
3454 SYMBOL_TYPE (sym
) = hpread_type_lookup (paramp
->dfparam
.type
, objfile
);
3455 /* Add it to the symbol list. */
3456 /* Note 1 (RT) At the moment, add_symbol_to_list() is also being
3457 * called on FPARAM symbols from the process_one_debug_symbol()
3458 * level... so parameters are getting added twice! (this shows
3459 * up in the symbol dump you get from "maint print symbols ...").
3460 * Note 2 (RT) I took out the processing of FPARAM from the
3461 * process_one_debug_symbol() level, so at the moment parameters are only
3462 * being processed here. This seems to have no ill effect.
3464 /* Note 3 (pai/1997-08-11) I removed the add_symbol_to_list() which put
3465 each fparam on the local_symbols list from here. Now we use the
3466 local_list to which fparams are added below, and set the param_symbols
3467 global to point to that at the end of this routine. */
3469 /* elz: I added this new list of symbols which is local to the function.
3470 this list is the one which is actually used to build the type for the
3471 function rather than the gloabal list pointed to by symlist.
3472 Using a global list to keep track of the parameters is wrong, because
3473 this function is called recursively if one parameter happend to be
3474 a function itself with more parameters in it. Adding parameters to the
3475 same global symbol list would not work!
3476 Actually it did work in case of cc compiled programs where you do not check the
3477 parameter lists of the arguments. */
3478 add_symbol_to_list (sym
, &local_list
);
3481 /* If type was read in earlier, don't bother with modifying
3486 /* Note how many parameters we found. */
3487 TYPE_NFIELDS (type
) = nsyms
;
3488 TYPE_FIELDS (type
) = (struct field
*)
3489 obstack_alloc (&objfile
->type_obstack
,
3490 sizeof (struct field
) * nsyms
);
3492 /* Find the symbols for the parameters and
3493 use them to fill parameter-type information into the function-type.
3494 The parameter symbols can be found in the local_list that we just put them on. */
3495 /* Note that we preserve the order of the parameters, so
3496 that in something like "enum {FOO, LAST_THING=FOO}" we print
3497 FOO, not LAST_THING. */
3499 /* get the parameters types from the local list not the global list
3500 so that the type can be correctly constructed for functions which
3501 have function as parameters
3503 for (syms
= local_list
, n
= 0; syms
; syms
= syms
->next
)
3506 for (j
= 0; j
< syms
->nsyms
; j
++, n
++)
3508 struct symbol
*xsym
= syms
->symbol
[j
];
3509 TYPE_FIELD_NAME (type
, n
) = DEPRECATED_SYMBOL_NAME (xsym
);
3510 TYPE_FIELD_TYPE (type
, n
) = SYMBOL_TYPE (xsym
);
3511 TYPE_FIELD_ARTIFICIAL (type
, n
) = 0;
3512 TYPE_FIELD_BITSIZE (type
, n
) = 0;
3513 TYPE_FIELD_STATIC_KIND (type
, n
) = 0;
3517 /* Mark it as having been processed */
3518 TYPE_FLAGS (type
) &= ~(TYPE_FLAG_INCOMPLETE
);
3520 /* Check whether we need to fix-up a class type with this function's type */
3521 if (fixup_class
&& (fixup_method
== type
))
3523 fixup_class_method_type (fixup_class
, fixup_method
, objfile
);
3525 fixup_method
= NULL
;
3528 /* Set the param list of this level of the context stack
3529 to our local list. Do this only if this function was
3530 called for creating a new block, and not if it was called
3531 simply to get the function type. This prevents recursive
3532 invocations from trashing param_symbols. */
3535 param_symbols
= local_list
;
3542 /* A file-level variable which keeps track of the current-template
3543 * being processed. Set in hpread_read_struct_type() while processing
3544 * a template type. Referred to in hpread_get_nth_templ_arg().
3545 * Yes, this is a kludge, but it arises from the kludge that already
3546 * exists in symtab.h, namely the fact that they encode
3547 * "template argument n" with fundamental type FT_TEMPLATE_ARG and
3548 * bitlength n. This means that deep in processing fundamental types
3549 * I need to ask the question "what template am I in the middle of?".
3550 * The alternative to stuffing a global would be to pass an argument
3551 * down the chain of calls just for this purpose.
3553 * There may be problems handling nested templates... tough.
3555 static struct type
*current_template
= NULL
;
3557 /* Read in and internalize a structure definition.
3558 * This same routine is called for struct, union, and class types.
3559 * Also called for templates, since they build a very similar
3560 * type entry as for class types.
3563 static struct type
*
3564 hpread_read_struct_type (dnttpointer hp_type
, union dnttentry
*dn_bufp
,
3565 struct objfile
*objfile
)
3567 /* The data members get linked together into a list of struct nextfield's */
3570 struct nextfield
*next
;
3572 unsigned char attributes
; /* store visibility and virtuality info */
3573 #define ATTR_VIRTUAL 1
3574 #define ATTR_PRIVATE 2
3575 #define ATTR_PROTECT 3
3579 /* The methods get linked together into a list of struct next_fn_field's */
3580 struct next_fn_field
3582 struct next_fn_field
*next
;
3583 struct fn_fieldlist field
;
3584 struct fn_field fn_field
;
3588 /* The template args get linked together into a list of struct next_template's */
3589 struct next_template
3591 struct next_template
*next
;
3592 struct template_arg arg
;
3595 /* The template instantiations get linked together into a list of these... */
3596 struct next_instantiation
3598 struct next_instantiation
*next
;
3603 struct type
*baseclass
;
3604 struct type
*memtype
;
3605 struct nextfield
*list
= 0, *tmp_list
= 0;
3606 struct next_fn_field
*fn_list
= 0;
3607 struct next_fn_field
*fn_p
;
3608 struct next_template
*t_new
, *t_list
= 0;
3609 struct nextfield
*new;
3610 struct next_fn_field
*fn_new
;
3611 struct next_instantiation
*i_new
, *i_list
= 0;
3612 int n
, nfields
= 0, n_fn_fields
= 0, n_fn_fields_total
= 0;
3613 int n_base_classes
= 0, n_templ_args
= 0;
3614 int ninstantiations
= 0;
3615 dnttpointer field
, fn_field
, parent
;
3616 union dnttentry
*fieldp
, *fn_fieldp
, *parentp
;
3618 int static_member
= 0;
3619 int const_member
= 0;
3620 int volatile_member
= 0;
3621 unsigned long vtbl_offset
;
3622 int need_bitvectors
= 0;
3623 char *method_name
= NULL
;
3624 char *method_alias
= NULL
;
3627 /* Is it something we've already dealt with? */
3628 type
= hpread_alloc_type (hp_type
, objfile
);
3629 if ((TYPE_CODE (type
) == TYPE_CODE_STRUCT
) ||
3630 (TYPE_CODE (type
) == TYPE_CODE_UNION
) ||
3631 (TYPE_CODE (type
) == TYPE_CODE_CLASS
) ||
3632 (TYPE_CODE (type
) == TYPE_CODE_TEMPLATE
))
3635 /* Get the basic type correct. */
3636 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_STRUCT
)
3638 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
3639 TYPE_LENGTH (type
) = dn_bufp
->dstruct
.bitlength
/ 8;
3641 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_UNION
)
3643 TYPE_CODE (type
) = TYPE_CODE_UNION
;
3644 TYPE_LENGTH (type
) = dn_bufp
->dunion
.bitlength
/ 8;
3646 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_CLASS
)
3648 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
3649 TYPE_LENGTH (type
) = dn_bufp
->dclass
.bitlength
/ 8;
3651 /* Overrides the TYPE_CPLUS_SPECIFIC(type) with allocated memory
3652 * rather than &cplus_struct_default.
3654 allocate_cplus_struct_type (type
);
3656 /* Fill in declared-type.
3657 * (The C++ compiler will emit TYPE_CODE_CLASS
3658 * for all 3 of "class", "struct"
3659 * "union", and we have to look at the "class_decl" field if we
3660 * want to know how it was really declared)
3662 /* (0==class, 1==union, 2==struct) */
3663 TYPE_DECLARED_TYPE (type
) = dn_bufp
->dclass
.class_decl
;
3665 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_TEMPLATE
)
3667 /* Get the basic type correct. */
3668 TYPE_CODE (type
) = TYPE_CODE_TEMPLATE
;
3669 allocate_cplus_struct_type (type
);
3670 TYPE_DECLARED_TYPE (type
) = DECLARED_TYPE_TEMPLATE
;
3676 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
3678 /* For classes, read the parent list.
3679 * Question (RT): Do we need to do this for templates also?
3681 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_CLASS
)
3684 /* First read the parent-list (classes from which we derive fields) */
3685 parent
= dn_bufp
->dclass
.parentlist
;
3686 while (parent
.word
&& parent
.word
!= DNTTNIL
)
3688 parentp
= hpread_get_lntt (parent
.dnttp
.index
, objfile
);
3690 /* "parentp" should point to a DNTT_TYPE_INHERITANCE record */
3692 /* Get space to record the next field/data-member. */
3693 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
3697 FIELD_BITSIZE (list
->field
) = 0;
3698 FIELD_STATIC_KIND (list
->field
) = 0;
3700 /* The "classname" field is actually a DNTT pointer to the base class */
3701 baseclass
= hpread_type_lookup (parentp
->dinheritance
.classname
,
3703 FIELD_TYPE (list
->field
) = baseclass
;
3705 list
->field
.name
= type_name_no_tag (FIELD_TYPE (list
->field
));
3707 list
->attributes
= 0;
3709 /* Check for virtuality of base, and set the
3710 * offset of the base subobject within the object.
3711 * (Offset set to -1 for virtual bases (for now).)
3713 if (parentp
->dinheritance
.Virtual
)
3715 B_SET (&(list
->attributes
), ATTR_VIRTUAL
);
3716 parentp
->dinheritance
.offset
= -1;
3719 FIELD_BITPOS (list
->field
) = parentp
->dinheritance
.offset
;
3721 /* Check visibility */
3722 switch (parentp
->dinheritance
.visibility
)
3725 B_SET (&(list
->attributes
), ATTR_PROTECT
);
3728 B_SET (&(list
->attributes
), ATTR_PRIVATE
);
3735 parent
= parentp
->dinheritance
.next
;
3739 /* For templates, read the template argument list.
3740 * This must be done before processing the member list, because
3741 * the member list may refer back to this. E.g.:
3742 * template <class T1, class T2> class q2 {
3747 * We need to read the argument list "T1", "T2" first.
3749 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_TEMPLATE
)
3751 /* Kludge alert: This stuffs a global "current_template" which
3752 * is referred to by hpread_get_nth_templ_arg(). The global
3753 * is cleared at the end of this routine.
3755 current_template
= type
;
3757 /* Read in the argument list */
3758 field
= dn_bufp
->dtemplate
.arglist
;
3759 while (field
.word
&& field
.word
!= DNTTNIL
)
3761 /* Get this template argument */
3762 fieldp
= hpread_get_lntt (field
.dnttp
.index
, objfile
);
3763 if (fieldp
->dblock
.kind
!= DNTT_TYPE_TEMPLATE_ARG
)
3765 warning ("Invalid debug info: Template argument entry is of wrong kind");
3768 /* Bump the count */
3770 /* Allocate and fill in a struct next_template */
3771 t_new
= (struct next_template
*) alloca (sizeof (struct next_template
));
3772 t_new
->next
= t_list
;
3774 t_list
->arg
.name
= VT (objfile
) + fieldp
->dtempl_arg
.name
;
3775 t_list
->arg
.type
= hpread_read_templ_arg_type (field
, fieldp
,
3776 objfile
, t_list
->arg
.name
);
3777 /* Walk to the next template argument */
3778 field
= fieldp
->dtempl_arg
.nextarg
;
3782 TYPE_NTEMPLATE_ARGS (type
) = n_templ_args
;
3784 if (n_templ_args
> 0)
3785 TYPE_TEMPLATE_ARGS (type
) = (struct template_arg
*)
3786 obstack_alloc (&objfile
->type_obstack
, sizeof (struct template_arg
) * n_templ_args
);
3787 for (n
= n_templ_args
; t_list
; t_list
= t_list
->next
)
3790 TYPE_TEMPLATE_ARG (type
, n
) = t_list
->arg
;
3793 /* Next read in and internalize all the fields/members. */
3794 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_STRUCT
)
3795 field
= dn_bufp
->dstruct
.firstfield
;
3796 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_UNION
)
3797 field
= dn_bufp
->dunion
.firstfield
;
3798 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_CLASS
)
3799 field
= dn_bufp
->dclass
.memberlist
;
3800 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_TEMPLATE
)
3801 field
= dn_bufp
->dtemplate
.memberlist
;
3803 field
.word
= DNTTNIL
;
3805 while (field
.word
&& field
.word
!= DNTTNIL
)
3807 fieldp
= hpread_get_lntt (field
.dnttp
.index
, objfile
);
3809 /* At this point "fieldp" may point to either a DNTT_TYPE_FIELD
3810 * or a DNTT_TYPE_GENFIELD record.
3815 volatile_member
= 0;
3817 if (fieldp
->dblock
.kind
== DNTT_TYPE_GENFIELD
)
3820 /* The type will be GENFIELD if the field is a method or
3821 * a static member (or some other cases -- see below)
3824 /* Follow a link to get to the record for the field. */
3825 fn_field
= fieldp
->dgenfield
.field
;
3826 fn_fieldp
= hpread_get_lntt (fn_field
.dnttp
.index
, objfile
);
3828 /* Virtual funcs are indicated by a VFUNC which points to the
3831 if (fn_fieldp
->dblock
.kind
== DNTT_TYPE_VFUNC
)
3833 vtbl_offset
= fn_fieldp
->dvfunc
.vtbl_offset
;
3834 fn_field
= fn_fieldp
->dvfunc
.funcptr
;
3835 fn_fieldp
= hpread_get_lntt (fn_field
.dnttp
.index
, objfile
);
3838 /* A function's entry may be preceded by a modifier which
3839 * labels it static/constant/volatile.
3841 if (fn_fieldp
->dblock
.kind
== DNTT_TYPE_MODIFIER
)
3843 static_member
= fn_fieldp
->dmodifier
.m_static
;
3844 const_member
= fn_fieldp
->dmodifier
.m_const
;
3845 volatile_member
= fn_fieldp
->dmodifier
.m_volatile
;
3846 fn_field
= fn_fieldp
->dmodifier
.type
;
3847 fn_fieldp
= hpread_get_lntt (fn_field
.dnttp
.index
, objfile
);
3850 /* Check whether we have a method */
3851 if ((fn_fieldp
->dblock
.kind
== DNTT_TYPE_MEMFUNC
) ||
3852 (fn_fieldp
->dblock
.kind
== DNTT_TYPE_FUNCTION
) ||
3853 (fn_fieldp
->dblock
.kind
== DNTT_TYPE_DOC_MEMFUNC
) ||
3854 (fn_fieldp
->dblock
.kind
== DNTT_TYPE_DOC_FUNCTION
))
3860 /* Look up function type of method */
3861 memtype
= hpread_type_lookup (fn_field
, objfile
);
3863 /* Methods can be seen before classes in the SOM records.
3864 If we are processing this class because it's a parameter of a
3865 method, at this point the method's type is actually incomplete;
3866 we'll have to fix it up later; mark the class for this. */
3868 if (TYPE_INCOMPLETE (memtype
))
3870 TYPE_FLAGS (type
) |= TYPE_FLAG_INCOMPLETE
;
3872 warning ("Two classes to fix up for method?? Type information may be incorrect for some classes.");
3874 warning ("Two methods to be fixed up at once?? Type information may be incorrect for some classes.");
3875 fixup_class
= type
; /* remember this class has to be fixed up */
3876 fixup_method
= memtype
; /* remember the method type to be used in fixup */
3879 /* HP aCC generates operator names without the "operator" keyword, and
3880 generates null strings as names for operators that are
3881 user-defined type conversions to basic types (e.g. operator int ()).
3882 So try to reconstruct name as best as possible. */
3884 method_name
= (char *) (VT (objfile
) + fn_fieldp
->dfunc
.name
);
3885 method_alias
= (char *) (VT (objfile
) + fn_fieldp
->dfunc
.alias
);
3887 if (!method_name
|| /* no name */
3888 !*method_name
|| /* or null name */
3889 cplus_mangle_opname (method_name
, DMGL_ANSI
)) /* or name is an operator like "<" */
3891 char *tmp_name
= cplus_demangle (method_alias
, DMGL_ANSI
);
3892 char *op_string
= strstr (tmp_name
, "operator");
3893 method_name
= xmalloc (strlen (op_string
) + 1); /* don't overwrite VT! */
3894 strcpy (method_name
, op_string
);
3897 /* First check if a method of the same name has already been seen. */
3901 if (STREQ (fn_p
->field
.name
, method_name
))
3906 /* If no such method was found, allocate a new entry in the list */
3909 /* Get space to record this member function */
3910 /* Note: alloca used; this will disappear on routine exit */
3911 fn_new
= (struct next_fn_field
*) alloca (sizeof (struct next_fn_field
));
3912 fn_new
->next
= fn_list
;
3915 /* Fill in the fields of the struct nextfield */
3917 /* Record the (unmangled) method name */
3918 fn_list
->field
.name
= method_name
;
3919 /* Initial space for overloaded methods */
3920 /* Note: xmalloc is used; this will persist after this routine exits */
3921 fn_list
->field
.fn_fields
= (struct fn_field
*) xmalloc (5 * (sizeof (struct fn_field
)));
3922 fn_list
->field
.length
= 1; /* Init # of overloaded instances */
3923 fn_list
->num_fn_fields
= 5; /* # of entries for which space allocated */
3925 ix
= 0; /* array index for fn_field */
3926 /* Bump the total count of the distinctly named methods */
3930 /* Another overloaded instance of an already seen method name */
3932 if (++(fn_p
->field
.length
) > fn_p
->num_fn_fields
)
3934 /* Increase space allocated for overloaded instances */
3935 fn_p
->field
.fn_fields
3936 = (struct fn_field
*) xrealloc (fn_p
->field
.fn_fields
,
3937 (fn_p
->num_fn_fields
+ 5) * sizeof (struct fn_field
));
3938 fn_p
->num_fn_fields
+= 5;
3940 ix
= fn_p
->field
.length
- 1; /* array index for fn_field */
3943 /* "physname" is intended to be the name of this overloaded instance. */
3944 if ((fn_fieldp
->dfunc
.language
== HP_LANGUAGE_CPLUSPLUS
) &&
3946 *method_alias
) /* not a null string */
3947 fn_p
->field
.fn_fields
[ix
].physname
= method_alias
;
3949 fn_p
->field
.fn_fields
[ix
].physname
= method_name
;
3950 /* What's expected here is the function type */
3951 /* But mark it as NULL if the method was incompletely processed
3952 We'll fix this up later when the method is fully processed */
3953 if (TYPE_INCOMPLETE (memtype
))
3954 fn_p
->field
.fn_fields
[ix
].type
= NULL
;
3956 fn_p
->field
.fn_fields
[ix
].type
= memtype
;
3958 /* For virtual functions, fill in the voffset field with the
3959 * virtual table offset. (This is just copied over from the
3960 * SOM record; not sure if it is what GDB expects here...).
3961 * But if the function is a static method, set it to 1.
3963 * Note that we have to add 1 because 1 indicates a static
3964 * method, and 0 indicates a non-static, non-virtual method */
3967 fn_p
->field
.fn_fields
[ix
].voffset
= VOFFSET_STATIC
;
3969 fn_p
->field
.fn_fields
[ix
].voffset
= vtbl_offset
? vtbl_offset
+ 1 : 0;
3971 /* Also fill in the fcontext field with the current
3972 * class. (The latter isn't quite right: should be the baseclass
3973 * that defines the virtual function... Note we do have
3974 * a variable "baseclass" that we could stuff into the fcontext
3975 * field, but "baseclass" isn't necessarily right either,
3976 * since the virtual function could have been defined more
3977 * than one level up).
3980 if (vtbl_offset
!= 0)
3981 fn_p
->field
.fn_fields
[ix
].fcontext
= type
;
3983 fn_p
->field
.fn_fields
[ix
].fcontext
= NULL
;
3985 /* Other random fields pertaining to this method */
3986 fn_p
->field
.fn_fields
[ix
].is_const
= const_member
;
3987 fn_p
->field
.fn_fields
[ix
].is_volatile
= volatile_member
; /* ?? */
3988 switch (fieldp
->dgenfield
.visibility
)
3991 fn_p
->field
.fn_fields
[ix
].is_protected
= 1;
3992 fn_p
->field
.fn_fields
[ix
].is_private
= 0;
3995 fn_p
->field
.fn_fields
[ix
].is_protected
= 0;
3996 fn_p
->field
.fn_fields
[ix
].is_private
= 1;
3998 default: /* public */
3999 fn_p
->field
.fn_fields
[ix
].is_protected
= 0;
4000 fn_p
->field
.fn_fields
[ix
].is_private
= 0;
4002 fn_p
->field
.fn_fields
[ix
].is_stub
= 0;
4004 /* HP aCC emits both MEMFUNC and FUNCTION entries for a method;
4005 if the class points to the FUNCTION, there is usually separate
4006 code for the method; but if we have a MEMFUNC, the method has
4007 been inlined (and there is usually no FUNCTION entry)
4008 FIXME Not sure if this test is accurate. pai/1997-08-22 */
4009 if ((fn_fieldp
->dblock
.kind
== DNTT_TYPE_MEMFUNC
) ||
4010 (fn_fieldp
->dblock
.kind
== DNTT_TYPE_DOC_MEMFUNC
))
4011 fn_p
->field
.fn_fields
[ix
].is_inlined
= 1;
4013 fn_p
->field
.fn_fields
[ix
].is_inlined
= 0;
4015 fn_p
->field
.fn_fields
[ix
].dummy
= 0;
4017 /* Bump the total count of the member functions */
4018 n_fn_fields_total
++;
4021 else if (fn_fieldp
->dblock
.kind
== DNTT_TYPE_SVAR
)
4023 /* This case is for static data members of classes */
4025 /* pai:: FIXME -- check that "staticmem" bit is set */
4027 /* Get space to record this static member */
4028 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
4032 list
->field
.name
= VT (objfile
) + fn_fieldp
->dsvar
.name
;
4033 SET_FIELD_PHYSNAME (list
->field
, 0); /* initialize to empty */
4034 memtype
= hpread_type_lookup (fn_fieldp
->dsvar
.type
, objfile
);
4036 FIELD_TYPE (list
->field
) = memtype
;
4037 list
->attributes
= 0;
4038 switch (fieldp
->dgenfield
.visibility
)
4041 B_SET (&(list
->attributes
), ATTR_PROTECT
);
4044 B_SET (&(list
->attributes
), ATTR_PRIVATE
);
4050 else if (fn_fieldp
->dblock
.kind
== DNTT_TYPE_FIELD
)
4052 /* FIELDs follow GENFIELDs for fields of anonymous unions.
4053 Code below is replicated from the case for FIELDs further
4054 below, except that fieldp is replaced by fn_fieldp */
4055 if (!fn_fieldp
->dfield
.a_union
)
4056 warning ("Debug info inconsistent: FIELD of anonymous union doesn't have a_union bit set");
4057 /* Get space to record the next field/data-member. */
4058 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
4062 list
->field
.name
= VT (objfile
) + fn_fieldp
->dfield
.name
;
4063 FIELD_BITPOS (list
->field
) = fn_fieldp
->dfield
.bitoffset
;
4064 if (fn_fieldp
->dfield
.bitlength
% 8)
4065 list
->field
.bitsize
= fn_fieldp
->dfield
.bitlength
;
4067 list
->field
.bitsize
= 0;
4069 memtype
= hpread_type_lookup (fn_fieldp
->dfield
.type
, objfile
);
4070 list
->field
.type
= memtype
;
4071 list
->attributes
= 0;
4072 switch (fn_fieldp
->dfield
.visibility
)
4075 B_SET (&(list
->attributes
), ATTR_PROTECT
);
4078 B_SET (&(list
->attributes
), ATTR_PRIVATE
);
4083 else if (fn_fieldp
->dblock
.kind
== DNTT_TYPE_SVAR
)
4085 /* Field of anonymous union; union is not inside a class */
4086 if (!fn_fieldp
->dsvar
.a_union
)
4087 warning ("Debug info inconsistent: SVAR field in anonymous union doesn't have a_union bit set");
4088 /* Get space to record the next field/data-member. */
4089 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
4093 list
->field
.name
= VT (objfile
) + fn_fieldp
->dsvar
.name
;
4094 FIELD_BITPOS (list
->field
) = 0; /* FIXME is this always true? */
4095 FIELD_BITSIZE (list
->field
) = 0; /* use length from type */
4096 FIELD_STATIC_KIND (list
->field
) = 0;
4097 memtype
= hpread_type_lookup (fn_fieldp
->dsvar
.type
, objfile
);
4098 list
->field
.type
= memtype
;
4099 list
->attributes
= 0;
4100 /* No info to set visibility -- always public */
4103 else if (fn_fieldp
->dblock
.kind
== DNTT_TYPE_DVAR
)
4105 /* Field of anonymous union; union is not inside a class */
4106 if (!fn_fieldp
->ddvar
.a_union
)
4107 warning ("Debug info inconsistent: DVAR field in anonymous union doesn't have a_union bit set");
4108 /* Get space to record the next field/data-member. */
4109 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
4113 list
->field
.name
= VT (objfile
) + fn_fieldp
->ddvar
.name
;
4114 FIELD_BITPOS (list
->field
) = 0; /* FIXME is this always true? */
4115 FIELD_BITSIZE (list
->field
) = 0; /* use length from type */
4116 FIELD_STATIC_KIND (list
->field
) = 0;
4117 memtype
= hpread_type_lookup (fn_fieldp
->ddvar
.type
, objfile
);
4118 list
->field
.type
= memtype
;
4119 list
->attributes
= 0;
4120 /* No info to set visibility -- always public */
4124 { /* Not a method, nor a static data member, nor an anon union field */
4126 /* This case is for miscellaneous type entries (local enums,
4127 local function templates, etc.) that can be present
4130 /* Enums -- will be handled by other code that takes care
4131 of DNTT_TYPE_ENUM; here we see only DNTT_TYPE_MEMENUM so
4132 it's not clear we could have handled them here at all. */
4133 /* FUNC_TEMPLATE: is handled by other code (?). */
4134 /* MEMACCESS: modified access for inherited member. Not
4135 sure what to do with this, ignoriing it at present. */
4137 /* What other entries can appear following a GENFIELD which
4138 we do not handle above? (MODIFIER, VFUNC handled above.) */
4140 if ((fn_fieldp
->dblock
.kind
!= DNTT_TYPE_MEMACCESS
) &&
4141 (fn_fieldp
->dblock
.kind
!= DNTT_TYPE_MEMENUM
) &&
4142 (fn_fieldp
->dblock
.kind
!= DNTT_TYPE_FUNC_TEMPLATE
))
4143 warning ("Internal error: Unexpected debug record kind %d found following DNTT_GENFIELD",
4144 fn_fieldp
->dblock
.kind
);
4146 /* walk to the next FIELD or GENFIELD */
4147 field
= fieldp
->dgenfield
.nextfield
;
4150 else if (fieldp
->dblock
.kind
== DNTT_TYPE_FIELD
)
4153 /* Ordinary structure/union/class field */
4154 struct type
*anon_union_type
;
4156 /* Get space to record the next field/data-member. */
4157 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
4161 list
->field
.name
= VT (objfile
) + fieldp
->dfield
.name
;
4164 /* A FIELD by itself (without a GENFIELD) can also be a static member */
4165 FIELD_STATIC_KIND (list
->field
) = 0;
4166 if (fieldp
->dfield
.staticmem
)
4168 FIELD_BITPOS (list
->field
) = -1;
4169 FIELD_BITSIZE (list
->field
) = 0;
4172 /* Non-static data member */
4174 FIELD_BITPOS (list
->field
) = fieldp
->dfield
.bitoffset
;
4175 if (fieldp
->dfield
.bitlength
% 8)
4176 FIELD_BITSIZE (list
->field
) = fieldp
->dfield
.bitlength
;
4178 FIELD_BITSIZE (list
->field
) = 0;
4181 memtype
= hpread_type_lookup (fieldp
->dfield
.type
, objfile
);
4182 FIELD_TYPE (list
->field
) = memtype
;
4183 list
->attributes
= 0;
4184 switch (fieldp
->dfield
.visibility
)
4187 B_SET (&(list
->attributes
), ATTR_PROTECT
);
4190 B_SET (&(list
->attributes
), ATTR_PRIVATE
);
4196 /* Note 1: First, we have to check if the current field is an anonymous
4197 union. If it is, then *its* fields are threaded along in the
4198 nextfield chain. :-( This was supposed to help debuggers, but is
4199 really just a nuisance since we deal with anonymous unions anyway by
4200 checking that the name is null. So anyway, we skip over the fields
4201 of the anonymous union. pai/1997-08-22 */
4202 /* Note 2: In addition, the bitoffsets for the fields of the anon union
4203 are relative to the enclosing struct, *NOT* relative to the anon
4204 union! This is an even bigger nuisance -- we have to go in and munge
4205 the anon union's type information appropriately. pai/1997-08-22 */
4207 /* Both tasks noted above are done by a separate function. This takes us
4208 to the next FIELD or GENFIELD, skipping anon unions, and recursively
4209 processing intermediate types. */
4210 field
= hpread_get_next_skip_over_anon_unions (1, field
, &fieldp
, objfile
);
4215 /* neither field nor genfield ?? is this possible?? */
4216 /* pai:: FIXME walk to the next -- how? */
4217 warning ("Internal error: unexpected DNTT kind %d encountered as field of struct",
4218 fieldp
->dblock
.kind
);
4219 warning ("Skipping remaining fields of struct");
4220 break; /* get out of loop of fields */
4224 /* If it's a template, read in the instantiation list */
4225 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_TEMPLATE
)
4227 ninstantiations
= 0;
4228 field
= dn_bufp
->dtemplate
.expansions
;
4229 while (field
.word
&& field
.word
!= DNTTNIL
)
4231 fieldp
= hpread_get_lntt (field
.dnttp
.index
, objfile
);
4233 /* The expansions or nextexp should point to a tagdef */
4234 if (fieldp
->dblock
.kind
!= DNTT_TYPE_TAGDEF
)
4237 i_new
= (struct next_instantiation
*) alloca (sizeof (struct next_instantiation
));
4238 i_new
->next
= i_list
;
4240 i_list
->t
= hpread_type_lookup (field
, objfile
);
4243 /* And the "type" field of that should point to a class */
4244 field
= fieldp
->dtag
.type
;
4245 fieldp
= hpread_get_lntt (field
.dnttp
.index
, objfile
);
4246 if (fieldp
->dblock
.kind
!= DNTT_TYPE_CLASS
)
4249 /* Get the next expansion */
4250 field
= fieldp
->dclass
.nextexp
;
4253 TYPE_NINSTANTIATIONS (type
) = ninstantiations
;
4254 if (ninstantiations
> 0)
4255 TYPE_INSTANTIATIONS (type
) = (struct type
**)
4256 obstack_alloc (&objfile
->type_obstack
, sizeof (struct type
*) * ninstantiations
);
4257 for (n
= ninstantiations
; i_list
; i_list
= i_list
->next
)
4260 TYPE_INSTANTIATION (type
, n
) = i_list
->t
;
4264 /* Copy the field-list to GDB's symbol table */
4265 TYPE_NFIELDS (type
) = nfields
;
4266 TYPE_N_BASECLASSES (type
) = n_base_classes
;
4267 TYPE_FIELDS (type
) = (struct field
*)
4268 obstack_alloc (&objfile
->type_obstack
, sizeof (struct field
) * nfields
);
4269 /* Copy the saved-up fields into the field vector. */
4270 for (n
= nfields
, tmp_list
= list
; tmp_list
; tmp_list
= tmp_list
->next
)
4273 TYPE_FIELD (type
, n
) = tmp_list
->field
;
4276 /* Copy the "function-field-list" (i.e., the list of member
4277 * functions in the class) to GDB's symbol table
4279 TYPE_NFN_FIELDS (type
) = n_fn_fields
;
4280 TYPE_NFN_FIELDS_TOTAL (type
) = n_fn_fields_total
;
4281 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
4282 obstack_alloc (&objfile
->type_obstack
, sizeof (struct fn_fieldlist
) * n_fn_fields
);
4283 for (n
= n_fn_fields
; fn_list
; fn_list
= fn_list
->next
)
4286 TYPE_FN_FIELDLIST (type
, n
) = fn_list
->field
;
4289 /* pai:: FIXME -- perhaps each bitvector should be created individually */
4290 for (n
= nfields
, tmp_list
= list
; tmp_list
; tmp_list
= tmp_list
->next
)
4293 if (tmp_list
->attributes
)
4295 need_bitvectors
= 1;
4300 if (need_bitvectors
)
4302 /* pai:: this step probably redundant */
4303 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
4305 TYPE_FIELD_VIRTUAL_BITS (type
) =
4306 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
4307 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), nfields
);
4309 TYPE_FIELD_PRIVATE_BITS (type
) =
4310 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
4311 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
4313 TYPE_FIELD_PROTECTED_BITS (type
) =
4314 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
4315 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
4317 /* this field vector isn't actually used with HP aCC */
4318 TYPE_FIELD_IGNORE_BITS (type
) =
4319 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
4320 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
4322 while (nfields
-- > 0)
4324 if (B_TST (&(list
->attributes
), ATTR_VIRTUAL
))
4325 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
4326 if (B_TST (&(list
->attributes
), ATTR_PRIVATE
))
4327 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
4328 if (B_TST (&(list
->attributes
), ATTR_PROTECT
))
4329 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
4336 TYPE_FIELD_VIRTUAL_BITS (type
) = NULL
;
4337 TYPE_FIELD_PROTECTED_BITS (type
) = NULL
;
4338 TYPE_FIELD_PRIVATE_BITS (type
) = NULL
;
4341 if (has_vtable (type
))
4343 /* Allocate space for class runtime information */
4344 TYPE_RUNTIME_PTR (type
) = (struct runtime_info
*) xmalloc (sizeof (struct runtime_info
));
4345 /* Set flag for vtable */
4346 TYPE_VTABLE (type
) = 1;
4347 /* The first non-virtual base class with a vtable. */
4348 TYPE_PRIMARY_BASE (type
) = primary_base_class (type
);
4349 /* The virtual base list. */
4350 TYPE_VIRTUAL_BASE_LIST (type
) = virtual_base_list (type
);
4353 TYPE_RUNTIME_PTR (type
) = NULL
;
4355 /* If this is a local type (C++ - declared inside a function), record file name & line # */
4356 if (hpread_get_scope_depth (dn_bufp
, objfile
, 1 /* no need for real depth */ ))
4358 TYPE_LOCALTYPE_PTR (type
) = (struct local_type_info
*) xmalloc (sizeof (struct local_type_info
));
4359 TYPE_LOCALTYPE_FILE (type
) = (char *) xmalloc (strlen (current_subfile
->name
) + 1);
4360 strcpy (TYPE_LOCALTYPE_FILE (type
), current_subfile
->name
);
4361 if (current_subfile
->line_vector
&& (current_subfile
->line_vector
->nitems
> 0))
4362 TYPE_LOCALTYPE_LINE (type
) = current_subfile
->line_vector
->item
[current_subfile
->line_vector
->nitems
- 1].line
;
4364 TYPE_LOCALTYPE_LINE (type
) = 0;
4367 TYPE_LOCALTYPE_PTR (type
) = NULL
;
4369 /* Clear the global saying what template we are in the middle of processing */
4370 current_template
= NULL
;
4375 /* Adjust the physnames for each static member of a struct
4376 or class type to be something like "A::x"; then various
4377 other pieces of code that do a lookup_symbol on the phyname
4379 TYPE is a pointer to the struct/class type
4380 NAME is a char * (string) which is the class/struct name
4384 fix_static_member_physnames (struct type
*type
, char *class_name
,
4385 struct objfile
*objfile
)
4389 /* We fix the member names only for classes or structs */
4390 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
)
4393 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
4394 if (TYPE_FIELD_STATIC (type
, i
))
4396 if (TYPE_FIELD_STATIC_PHYSNAME (type
, i
))
4397 return; /* physnames are already set */
4399 SET_FIELD_PHYSNAME (TYPE_FIELDS (type
)[i
],
4400 obstack_alloc (&objfile
->type_obstack
,
4401 strlen (class_name
) + strlen (TYPE_FIELD_NAME (type
, i
)) + 3));
4402 strcpy (TYPE_FIELD_STATIC_PHYSNAME (type
, i
), class_name
);
4403 strcat (TYPE_FIELD_STATIC_PHYSNAME (type
, i
), "::");
4404 strcat (TYPE_FIELD_STATIC_PHYSNAME (type
, i
), TYPE_FIELD_NAME (type
, i
));
4408 /* Fix-up the type structure for a CLASS so that the type entry
4409 * for a method (previously marked with a null type in hpread_read_struct_type()
4410 * is set correctly to METHOD.
4411 * OBJFILE is as for other such functions.
4415 fixup_class_method_type (struct type
*class, struct type
*method
,
4416 struct objfile
*objfile
)
4420 if (!class || !method
|| !objfile
)
4423 /* Only for types that have methods */
4424 if ((TYPE_CODE (class) != TYPE_CODE_CLASS
) &&
4425 (TYPE_CODE (class) != TYPE_CODE_UNION
))
4428 /* Loop over all methods and find the one marked with a NULL type */
4429 for (i
= 0; i
< TYPE_NFN_FIELDS (class); i
++)
4430 for (j
= 0; j
< TYPE_FN_FIELDLIST_LENGTH (class, i
); j
++)
4431 if (TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i
), j
) == NULL
)
4433 /* Set the method type */
4434 TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i
), j
) = method
;
4436 /* Break out of both loops -- only one method to fix up in a class */
4441 TYPE_FLAGS (class) &= ~TYPE_FLAG_INCOMPLETE
;
4445 /* If we're in the middle of processing a template, get a pointer
4446 * to the Nth template argument.
4447 * An example may make this clearer:
4448 * template <class T1, class T2> class q2 {
4453 * The type for "a" will be "first template arg" and
4454 * the type for "b" will be "second template arg".
4455 * We need to look these up in order to fill in "a" and "b"'s type.
4456 * This is called from hpread_type_lookup().
4458 static struct type
*
4459 hpread_get_nth_template_arg (struct objfile
*objfile
, int n
)
4461 if (current_template
!= NULL
)
4462 return TYPE_TEMPLATE_ARG (current_template
, n
).type
;
4464 return lookup_fundamental_type (objfile
, FT_TEMPLATE_ARG
);
4467 /* Read in and internalize a TEMPL_ARG (template arg) symbol. */
4469 static struct type
*
4470 hpread_read_templ_arg_type (dnttpointer hp_type
, union dnttentry
*dn_bufp
,
4471 struct objfile
*objfile
, char *name
)
4475 /* See if it's something we've already deal with. */
4476 type
= hpread_alloc_type (hp_type
, objfile
);
4477 if (TYPE_CODE (type
) == TYPE_CODE_TEMPLATE_ARG
)
4480 /* Nope. Fill in the appropriate fields. */
4481 TYPE_CODE (type
) = TYPE_CODE_TEMPLATE_ARG
;
4482 TYPE_LENGTH (type
) = 0;
4483 TYPE_NFIELDS (type
) = 0;
4484 TYPE_NAME (type
) = name
;
4488 /* Read in and internalize a set debug symbol. */
4490 static struct type
*
4491 hpread_read_set_type (dnttpointer hp_type
, union dnttentry
*dn_bufp
,
4492 struct objfile
*objfile
)
4496 /* See if it's something we've already deal with. */
4497 type
= hpread_alloc_type (hp_type
, objfile
);
4498 if (TYPE_CODE (type
) == TYPE_CODE_SET
)
4501 /* Nope. Fill in the appropriate fields. */
4502 TYPE_CODE (type
) = TYPE_CODE_SET
;
4503 TYPE_LENGTH (type
) = dn_bufp
->dset
.bitlength
/ 8;
4504 TYPE_NFIELDS (type
) = 0;
4505 TYPE_TARGET_TYPE (type
) = hpread_type_lookup (dn_bufp
->dset
.subtype
,
4510 /* Read in and internalize an array debug symbol. */
4512 static struct type
*
4513 hpread_read_array_type (dnttpointer hp_type
, union dnttentry
*dn_bufp
,
4514 struct objfile
*objfile
)
4518 /* Allocate an array type symbol.
4519 * Why no check for already-read here, like in the other
4520 * hpread_read_xxx_type routines? Because it kept us
4521 * from properly determining the size of the array!
4523 type
= hpread_alloc_type (hp_type
, objfile
);
4525 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
4527 /* Although the hp-symtab.h does not *require* this to be the case,
4528 * GDB is assuming that "arrayisbytes" and "elemisbytes" be consistent.
4529 * I.e., express both array-length and element-length in bits,
4530 * or express both array-length and element-length in bytes.
4532 if (!((dn_bufp
->darray
.arrayisbytes
&& dn_bufp
->darray
.elemisbytes
) ||
4533 (!dn_bufp
->darray
.arrayisbytes
&& !dn_bufp
->darray
.elemisbytes
)))
4535 warning ("error in hpread_array_type.\n");
4538 else if (dn_bufp
->darray
.arraylength
== 0x7fffffff)
4540 /* The HP debug format represents char foo[]; as an array with
4541 * length 0x7fffffff. Internally GDB wants to represent this
4542 * as an array of length zero.
4544 TYPE_LENGTH (type
) = 0;
4546 else if (dn_bufp
->darray
.arrayisbytes
)
4547 TYPE_LENGTH (type
) = dn_bufp
->darray
.arraylength
;
4548 else /* arraylength is in bits */
4549 TYPE_LENGTH (type
) = dn_bufp
->darray
.arraylength
/ 8;
4551 TYPE_TARGET_TYPE (type
) = hpread_type_lookup (dn_bufp
->darray
.elemtype
,
4554 /* The one "field" is used to store the subscript type */
4555 /* Since C and C++ multi-dimensional arrays are simply represented
4556 * as: array of array of ..., we only need one subscript-type
4557 * per array. This subscript type is typically a subrange of integer.
4558 * If this gets extended to support languages like Pascal, then
4559 * we need to fix this to represent multi-dimensional arrays properly.
4561 TYPE_NFIELDS (type
) = 1;
4562 TYPE_FIELDS (type
) = (struct field
*)
4563 obstack_alloc (&objfile
->type_obstack
, sizeof (struct field
));
4564 TYPE_FIELD_TYPE (type
, 0) = hpread_type_lookup (dn_bufp
->darray
.indextype
,
4569 /* Read in and internalize a subrange debug symbol. */
4570 static struct type
*
4571 hpread_read_subrange_type (dnttpointer hp_type
, union dnttentry
*dn_bufp
,
4572 struct objfile
*objfile
)
4576 /* Is it something we've already dealt with. */
4577 type
= hpread_alloc_type (hp_type
, objfile
);
4578 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
4581 /* Nope, internalize it. */
4582 TYPE_CODE (type
) = TYPE_CODE_RANGE
;
4583 TYPE_LENGTH (type
) = dn_bufp
->dsubr
.bitlength
/ 8;
4584 TYPE_NFIELDS (type
) = 2;
4586 = (struct field
*) obstack_alloc (&objfile
->type_obstack
,
4587 2 * sizeof (struct field
));
4589 if (dn_bufp
->dsubr
.dyn_low
)
4590 TYPE_FIELD_BITPOS (type
, 0) = 0;
4592 TYPE_FIELD_BITPOS (type
, 0) = dn_bufp
->dsubr
.lowbound
;
4594 if (dn_bufp
->dsubr
.dyn_high
)
4595 TYPE_FIELD_BITPOS (type
, 1) = -1;
4597 TYPE_FIELD_BITPOS (type
, 1) = dn_bufp
->dsubr
.highbound
;
4598 TYPE_TARGET_TYPE (type
) = hpread_type_lookup (dn_bufp
->dsubr
.subtype
,
4603 /* struct type * hpread_type_lookup(hp_type, objfile)
4605 * hp_type: A pointer into the DNTT specifying what type we
4606 * are about to "look up"., or else [for fundamental types
4607 * like int, float, ...] an "immediate" structure describing
4610 * Return value: A pointer to a "struct type" (representation of a
4611 * type in GDB's internal symbol table - see gdbtypes.h)
4612 * Routine description:
4613 * There are a variety of places when scanning the DNTT when we
4614 * need to interpret a "type" field. The simplest and most basic
4615 * example is when we're processing the symbol table record
4616 * for a data symbol (a SVAR or DVAR record). That has
4617 * a "type" field specifying the type of the data symbol. That
4618 * "type" field is either an "immediate" type specification (for the
4619 * fundamental types) or a DNTT pointer (for more complicated types).
4620 * For the more complicated types, we may or may not have already
4621 * processed the pointed-to type. (Multiple data symbols can of course
4622 * share the same type).
4623 * The job of hpread_type_lookup() is to process this "type" field.
4624 * Most of the real work is done in subroutines. Here we interpret
4625 * the immediate flag. If not immediate, chase the DNTT pointer to
4626 * find our way to the SOM record describing the type, switch on
4627 * the SOM kind, and then call an appropriate subroutine depending
4628 * on what kind of type we are constructing. (e.g., an array type,
4629 * a struct/class type, etc).
4631 static struct type
*
4632 hpread_type_lookup (dnttpointer hp_type
, struct objfile
*objfile
)
4634 union dnttentry
*dn_bufp
;
4635 struct type
*tmp_type
;
4637 /* First see if it's a simple builtin type. */
4638 if (hp_type
.dntti
.immediate
)
4640 /* If this is a template argument, the argument number is
4641 * encoded in the bitlength. All other cases, just return
4642 * GDB's representation of this fundamental type.
4644 if (hp_type
.dntti
.type
== HP_TYPE_TEMPLATE_ARG
)
4645 return hpread_get_nth_template_arg (objfile
, hp_type
.dntti
.bitlength
);
4647 return lookup_fundamental_type (objfile
,
4648 hpread_type_translate (hp_type
));
4651 /* Not a builtin type. We'll have to read it in. */
4652 if (hp_type
.dnttp
.index
< LNTT_SYMCOUNT (objfile
))
4653 dn_bufp
= hpread_get_lntt (hp_type
.dnttp
.index
, objfile
);
4655 /* This is a fancy way of returning NULL */
4656 return lookup_fundamental_type (objfile
, FT_VOID
);
4658 switch (dn_bufp
->dblock
.kind
)
4660 case DNTT_TYPE_SRCFILE
:
4661 case DNTT_TYPE_MODULE
:
4662 case DNTT_TYPE_ENTRY
:
4663 case DNTT_TYPE_BEGIN
:
4665 case DNTT_TYPE_IMPORT
:
4666 case DNTT_TYPE_LABEL
:
4667 case DNTT_TYPE_FPARAM
:
4668 case DNTT_TYPE_SVAR
:
4669 case DNTT_TYPE_DVAR
:
4670 case DNTT_TYPE_CONST
:
4671 case DNTT_TYPE_MEMENUM
:
4672 case DNTT_TYPE_VARIANT
:
4673 case DNTT_TYPE_FILE
:
4674 case DNTT_TYPE_WITH
:
4675 case DNTT_TYPE_COMMON
:
4676 case DNTT_TYPE_COBSTRUCT
:
4677 case DNTT_TYPE_XREF
:
4679 case DNTT_TYPE_MACRO
:
4680 case DNTT_TYPE_BLOCKDATA
:
4681 case DNTT_TYPE_CLASS_SCOPE
:
4682 case DNTT_TYPE_MEMACCESS
:
4683 case DNTT_TYPE_INHERITANCE
:
4684 case DNTT_TYPE_OBJECT_ID
:
4685 case DNTT_TYPE_FRIEND_CLASS
:
4686 case DNTT_TYPE_FRIEND_FUNC
:
4687 /* These are not types - something went wrong. */
4688 /* This is a fancy way of returning NULL */
4689 return lookup_fundamental_type (objfile
, FT_VOID
);
4691 case DNTT_TYPE_FUNCTION
:
4692 /* We wind up here when dealing with class member functions
4693 * (called from hpread_read_struct_type(), i.e. when processing
4694 * the class definition itself).
4696 return hpread_read_function_type (hp_type
, dn_bufp
, objfile
, 0);
4698 case DNTT_TYPE_DOC_FUNCTION
:
4699 return hpread_read_doc_function_type (hp_type
, dn_bufp
, objfile
, 0);
4701 case DNTT_TYPE_TYPEDEF
:
4703 /* A typedef - chase it down by making a recursive call */
4704 struct type
*structtype
= hpread_type_lookup (dn_bufp
->dtype
.type
,
4707 /* The following came from the base hpread.c that we inherited.
4708 * It is WRONG so I have commented it out. - RT
4712 suffix = VT (objfile) + dn_bufp->dtype.name;
4713 TYPE_NAME (structtype) = suffix;
4715 * ... further explanation ....
4717 * What we have here is a typedef pointing to a typedef.
4722 * What we desire to build is (these are pictures
4723 * of "struct type"'s):
4725 * +---------+ +----------+ +------------+
4726 * | typedef | | typedef | | fund. type |
4727 * | type| -> | type| -> | |
4728 * | "fum" | | "foo" | | "int" |
4729 * +---------+ +----------+ +------------+
4731 * What this commented-out code is doing is smashing the
4732 * name of pointed-to-type to be the same as the pointed-from
4733 * type. So we wind up with something like:
4735 * +---------+ +----------+ +------------+
4736 * | typedef | | typedef | | fund. type |
4737 * | type| -> | type| -> | |
4738 * | "fum" | | "fum" | | "fum" |
4739 * +---------+ +----------+ +------------+
4746 case DNTT_TYPE_TAGDEF
:
4748 /* Just a little different from above. We have to tack on
4749 * an identifier of some kind (struct, union, enum, class, etc).
4751 struct type
*structtype
= hpread_type_lookup (dn_bufp
->dtype
.type
,
4753 char *prefix
, *suffix
;
4754 suffix
= VT (objfile
) + dn_bufp
->dtype
.name
;
4756 /* Lookup the next type in the list. It should be a structure,
4757 * union, class, enum, or template type.
4758 * We will need to attach that to our name.
4760 if (dn_bufp
->dtype
.type
.dnttp
.index
< LNTT_SYMCOUNT (objfile
))
4761 dn_bufp
= hpread_get_lntt (dn_bufp
->dtype
.type
.dnttp
.index
, objfile
);
4764 complaint (&symfile_complaints
, "error in hpread_type_lookup().");
4768 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_STRUCT
)
4772 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_UNION
)
4776 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_CLASS
)
4778 /* Further field for CLASS saying how it was really declared */
4779 /* 0==class, 1==union, 2==struct */
4780 if (dn_bufp
->dclass
.class_decl
== 0)
4782 else if (dn_bufp
->dclass
.class_decl
== 1)
4784 else if (dn_bufp
->dclass
.class_decl
== 2)
4789 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_ENUM
)
4793 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_TEMPLATE
)
4795 prefix
= "template ";
4802 /* Build the correct name. */
4803 TYPE_NAME (structtype
)
4804 = (char *) obstack_alloc (&objfile
->type_obstack
,
4805 strlen (prefix
) + strlen (suffix
) + 1);
4806 TYPE_NAME (structtype
) = strcpy (TYPE_NAME (structtype
), prefix
);
4807 TYPE_NAME (structtype
) = strcat (TYPE_NAME (structtype
), suffix
);
4808 TYPE_TAG_NAME (structtype
) = suffix
;
4810 /* For classes/structs, we have to set the static member "physnames"
4811 to point to strings like "Class::Member" */
4812 if (TYPE_CODE (structtype
) == TYPE_CODE_STRUCT
)
4813 fix_static_member_physnames (structtype
, suffix
, objfile
);
4818 case DNTT_TYPE_POINTER
:
4819 /* Pointer type - call a routine in gdbtypes.c that constructs
4820 * the appropriate GDB type.
4822 return make_pointer_type (
4823 hpread_type_lookup (dn_bufp
->dptr
.pointsto
,
4827 case DNTT_TYPE_REFERENCE
:
4828 /* C++ reference type - call a routine in gdbtypes.c that constructs
4829 * the appropriate GDB type.
4831 return make_reference_type (
4832 hpread_type_lookup (dn_bufp
->dreference
.pointsto
,
4836 case DNTT_TYPE_ENUM
:
4837 return hpread_read_enum_type (hp_type
, dn_bufp
, objfile
);
4839 return hpread_read_set_type (hp_type
, dn_bufp
, objfile
);
4840 case DNTT_TYPE_SUBRANGE
:
4841 return hpread_read_subrange_type (hp_type
, dn_bufp
, objfile
);
4842 case DNTT_TYPE_ARRAY
:
4843 return hpread_read_array_type (hp_type
, dn_bufp
, objfile
);
4844 case DNTT_TYPE_STRUCT
:
4845 case DNTT_TYPE_UNION
:
4846 return hpread_read_struct_type (hp_type
, dn_bufp
, objfile
);
4847 case DNTT_TYPE_FIELD
:
4848 return hpread_type_lookup (dn_bufp
->dfield
.type
, objfile
);
4850 case DNTT_TYPE_FUNCTYPE
:
4851 /* Here we want to read the function SOMs and return a
4852 * type for it. We get here, for instance, when processing
4853 * pointer-to-function type.
4855 return hpread_read_function_type (hp_type
, dn_bufp
, objfile
, 0);
4857 case DNTT_TYPE_PTRMEM
:
4858 /* Declares a C++ pointer-to-data-member type.
4859 * The "pointsto" field defines the class,
4860 * while the "memtype" field defines the pointed-to-type.
4863 struct type
*ptrmemtype
;
4864 struct type
*class_type
;
4865 struct type
*memtype
;
4866 memtype
= hpread_type_lookup (dn_bufp
->dptrmem
.memtype
,
4868 class_type
= hpread_type_lookup (dn_bufp
->dptrmem
.pointsto
,
4870 ptrmemtype
= alloc_type (objfile
);
4871 smash_to_member_type (ptrmemtype
, class_type
, memtype
);
4872 return make_pointer_type (ptrmemtype
, NULL
);
4876 case DNTT_TYPE_PTRMEMFUNC
:
4877 /* Defines a C++ pointer-to-function-member type.
4878 * The "pointsto" field defines the class,
4879 * while the "memtype" field defines the pointed-to-type.
4882 struct type
*ptrmemtype
;
4883 struct type
*class_type
;
4884 struct type
*functype
;
4885 struct type
*retvaltype
;
4888 class_type
= hpread_type_lookup (dn_bufp
->dptrmem
.pointsto
,
4890 functype
= hpread_type_lookup (dn_bufp
->dptrmem
.memtype
,
4892 retvaltype
= TYPE_TARGET_TYPE (functype
);
4893 nargs
= TYPE_NFIELDS (functype
);
4894 ptrmemtype
= alloc_type (objfile
);
4896 smash_to_method_type (ptrmemtype
, class_type
, retvaltype
,
4897 TYPE_FIELDS (functype
),
4898 TYPE_NFIELDS (functype
),
4900 return make_pointer_type (ptrmemtype
, NULL
);
4904 case DNTT_TYPE_CLASS
:
4905 return hpread_read_struct_type (hp_type
, dn_bufp
, objfile
);
4907 case DNTT_TYPE_GENFIELD
:
4908 /* Chase pointer from GENFIELD to FIELD, and make recursive
4911 return hpread_type_lookup (dn_bufp
->dgenfield
.field
, objfile
);
4913 case DNTT_TYPE_VFUNC
:
4914 /* C++ virtual function.
4915 * We get here in the course of processing a class type which
4916 * contains virtual functions. Just go through another level
4917 * of indirection to get to the pointed-to function SOM.
4919 return hpread_type_lookup (dn_bufp
->dvfunc
.funcptr
, objfile
);
4921 case DNTT_TYPE_MODIFIER
:
4922 /* Check the modifiers and then just make a recursive call on
4923 * the "type" pointed to by the modifier DNTT.
4925 * pai:: FIXME -- do we ever want to handle "m_duplicate" and
4926 * "m_void" modifiers? Is static_flag really needed here?
4927 * (m_static used for methods of classes, elsewhere).
4929 tmp_type
= make_cv_type (dn_bufp
->dmodifier
.m_const
,
4930 dn_bufp
->dmodifier
.m_volatile
,
4931 hpread_type_lookup (dn_bufp
->dmodifier
.type
, objfile
),
4936 case DNTT_TYPE_MEMFUNC
:
4937 /* Member function. Treat like a function.
4938 * I think we get here in the course of processing a
4939 * pointer-to-member-function type...
4941 return hpread_read_function_type (hp_type
, dn_bufp
, objfile
, 0);
4943 case DNTT_TYPE_DOC_MEMFUNC
:
4944 return hpread_read_doc_function_type (hp_type
, dn_bufp
, objfile
, 0);
4946 case DNTT_TYPE_TEMPLATE
:
4947 /* Template - sort of the header for a template definition,
4948 * which like a class, points to a member list and also points
4949 * to a TEMPLATE_ARG list of type-arguments.
4951 return hpread_read_struct_type (hp_type
, dn_bufp
, objfile
);
4953 case DNTT_TYPE_TEMPLATE_ARG
:
4956 /* The TEMPLATE record points to an argument list of
4957 * TEMPLATE_ARG records, each of which describes one
4958 * of the type-arguments.
4960 name
= VT (objfile
) + dn_bufp
->dtempl_arg
.name
;
4961 return hpread_read_templ_arg_type (hp_type
, dn_bufp
, objfile
, name
);
4964 case DNTT_TYPE_FUNC_TEMPLATE
:
4965 /* We wind up here when processing a TEMPLATE type,
4966 * if the template has member function(s).
4967 * Treat it like a FUNCTION.
4969 return hpread_read_function_type (hp_type
, dn_bufp
, objfile
, 0);
4971 case DNTT_TYPE_LINK
:
4972 /* The LINK record is used to link up templates with instantiations.
4973 * There is no type associated with the LINK record per se.
4975 return lookup_fundamental_type (objfile
, FT_VOID
);
4977 /* Also not yet handled... */
4978 /* case DNTT_TYPE_DYN_ARRAY_DESC: */
4979 /* case DNTT_TYPE_DESC_SUBRANGE: */
4980 /* case DNTT_TYPE_BEGIN_EXT: */
4981 /* case DNTT_TYPE_INLN: */
4982 /* case DNTT_TYPE_INLN_LIST: */
4983 /* case DNTT_TYPE_ALIAS: */
4985 /* A fancy way of returning NULL */
4986 return lookup_fundamental_type (objfile
, FT_VOID
);
4991 hpread_record_lines (struct subfile
*subfile
, sltpointer s_idx
,
4992 sltpointer e_idx
, struct objfile
*objfile
,
4995 union sltentry
*sl_bufp
;
4997 while (s_idx
<= e_idx
)
4999 sl_bufp
= hpread_get_slt (s_idx
, objfile
);
5000 /* Only record "normal" entries in the SLT. */
5001 if (sl_bufp
->snorm
.sltdesc
== SLT_NORMAL
5002 || sl_bufp
->snorm
.sltdesc
== SLT_EXIT
)
5003 record_line (subfile
, sl_bufp
->snorm
.line
,
5004 sl_bufp
->snorm
.address
+ offset
);
5005 else if (sl_bufp
->snorm
.sltdesc
== SLT_NORMAL_OFFSET
)
5006 record_line (subfile
, sl_bufp
->snormoff
.line
,
5007 sl_bufp
->snormoff
.address
+ offset
);
5013 /* Given a function "f" which is a member of a class, find
5014 * the classname that it is a member of. Used to construct
5015 * the name (e.g., "c::f") which GDB will put in the
5016 * "demangled name" field of the function's symbol.
5017 * Called from hpread_process_one_debug_symbol()
5018 * If "f" is not a member function, return NULL.
5021 class_of (struct type
*functype
)
5023 struct type
*first_param_type
;
5024 char *first_param_name
;
5025 struct type
*pointed_to_type
;
5028 /* Check that the function has a first argument "this",
5029 * and that "this" is a pointer to a class. If not,
5030 * functype is not a member function, so return NULL.
5032 if (TYPE_NFIELDS (functype
) == 0)
5034 first_param_name
= TYPE_FIELD_NAME (functype
, 0);
5035 if (first_param_name
== NULL
)
5036 return NULL
; /* paranoia */
5037 if (strcmp (first_param_name
, "this"))
5039 first_param_type
= TYPE_FIELD_TYPE (functype
, 0);
5040 if (first_param_type
== NULL
)
5041 return NULL
; /* paranoia */
5042 if (TYPE_CODE (first_param_type
) != TYPE_CODE_PTR
)
5045 /* Get the thing that "this" points to, check that
5046 * it's a class, and get its class name.
5048 pointed_to_type
= TYPE_TARGET_TYPE (first_param_type
);
5049 if (pointed_to_type
== NULL
)
5050 return NULL
; /* paranoia */
5051 if (TYPE_CODE (pointed_to_type
) != TYPE_CODE_CLASS
)
5053 class_name
= TYPE_NAME (pointed_to_type
);
5054 if (class_name
== NULL
)
5055 return NULL
; /* paranoia */
5057 /* The class name may be of the form "class c", in which case
5058 * we want to strip off the leading "class ".
5060 if (strncmp (class_name
, "class ", 6) == 0)
5066 /* Internalize one native debug symbol.
5067 * Called in a loop from hpread_expand_symtab().
5076 * index: Index of this symbol
5077 * at_module_boundary_p Pointer to boolean flag to control caller's loop.
5081 hpread_process_one_debug_symbol (union dnttentry
*dn_bufp
, char *name
,
5082 struct section_offsets
*section_offsets
,
5083 struct objfile
*objfile
, CORE_ADDR text_offset
,
5084 int text_size
, char *filename
, int index
,
5085 int *at_module_boundary_p
)
5090 int offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT (objfile
));
5091 int data_offset
= ANOFFSET (section_offsets
, SECT_OFF_DATA (objfile
));
5092 union dnttentry
*dn_temp
;
5093 dnttpointer hp_type
;
5095 struct context_stack
*new;
5096 char *class_scope_name
;
5098 /* Allocate one GDB debug symbol and fill in some default values. */
5099 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
5100 sizeof (struct symbol
));
5101 memset (sym
, 0, sizeof (struct symbol
));
5102 DEPRECATED_SYMBOL_NAME (sym
) = obsavestring (name
, strlen (name
), &objfile
->symbol_obstack
);
5103 SYMBOL_LANGUAGE (sym
) = language_auto
;
5104 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
5105 SYMBOL_LINE (sym
) = 0;
5106 SYMBOL_VALUE (sym
) = 0;
5107 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5109 /* Just a trick in case the SOM debug symbol is a type definition.
5110 * There are routines that are set up to build a GDB type symbol, given
5111 * a SOM dnttpointer. So we set up a dummy SOM dnttpointer "hp_type".
5112 * This allows us to call those same routines.
5114 hp_type
.dnttp
.extension
= 1;
5115 hp_type
.dnttp
.immediate
= 0;
5116 hp_type
.dnttp
.global
= 0;
5117 hp_type
.dnttp
.index
= index
;
5119 /* This "type" is the type of SOM record.
5120 * Switch on SOM type.
5122 type
= dn_bufp
->dblock
.kind
;
5125 case DNTT_TYPE_SRCFILE
:
5126 /* This type of symbol indicates from which source file or
5127 * include file any following data comes. It may indicate:
5129 * o The start of an entirely new source file (and thus
5132 * o The start of a different source file due to #include
5134 * o The end of an include file and the return to the original
5135 * file. Thus if "foo.c" includes "bar.h", we see first
5136 * a SRCFILE for foo.c, then one for bar.h, and then one for
5139 * If it indicates the start of a new module then we must
5140 * finish the symbol table of the previous module
5141 * (if any) and start accumulating a new symbol table.
5145 if (!last_source_file
)
5148 * A note on "last_source_file": this is a char* pointing
5149 * to the actual file name. "start_symtab" sets it,
5150 * "end_symtab" clears it.
5152 * So if "last_source_file" is NULL, then either this is
5153 * the first record we are looking at, or a previous call
5154 * to "end_symtab()" was made to close out the previous
5155 * module. Since we're now quitting the scan loop when we
5156 * see a MODULE END record, we should never get here, except
5157 * in the case that we're not using the quick look-up tables
5158 * and have to use the old system as a fall-back.
5160 start_symtab (name
, NULL
, valu
);
5161 record_debugformat ("HP");
5162 SL_INDEX (objfile
) = dn_bufp
->dsfile
.address
;
5167 /* Either a new include file, or a SRCFILE record
5168 * saying we are back in the main source (or out of
5169 * a nested include file) again.
5171 SL_INDEX (objfile
) = hpread_record_lines (current_subfile
,
5173 dn_bufp
->dsfile
.address
,
5177 /* A note on "start_subfile". This routine will check
5178 * the name we pass it and look for an existing subfile
5179 * of that name. There's thus only one sub-file for the
5180 * actual source (e.g. for "foo.c" in foo.c), despite the
5181 * fact that we'll see lots of SRCFILE entries for foo.c
5184 start_subfile (name
, NULL
);
5187 case DNTT_TYPE_MODULE
:
5189 * We no longer ignore DNTT_TYPE_MODULE symbols. The module
5190 * represents the meaningful semantic structure of a compilation
5191 * unit. We expect to start the psymtab-to-symtab expansion
5192 * looking at a MODULE entry, and to end it at the corresponding
5195 *--Begin outdated comments
5197 * This record signifies the start of a new source module
5198 * In C/C++ there is no explicit "module" construct in the language,
5199 * but each compilation unit is implicitly a module and they
5200 * do emit the DNTT_TYPE_MODULE records.
5201 * The end of the module is marked by a matching DNTT_TYPE_END record.
5203 * The reason GDB gets away with ignoring the DNTT_TYPE_MODULE record
5204 * is it notices the DNTT_TYPE_END record for the previous
5205 * module (see comments under DNTT_TYPE_END case), and then treats
5206 * the next DNTT_TYPE_SRCFILE record as if it were the module-start record.
5207 * (i.e., it makes a start_symtab() call).
5208 * This scheme seems a little convoluted, but I'll leave it
5209 * alone on the principle "if it ain't broke don't fix
5212 *-- End outdated comments
5216 if (!last_source_file
)
5218 /* Start of a new module. We know this because "last_source_file"
5219 * is NULL, which can only happen the first time or if we just
5220 * made a call to end_symtab() to close out the previous module.
5222 start_symtab (name
, NULL
, valu
);
5223 SL_INDEX (objfile
) = dn_bufp
->dmodule
.address
;
5227 /* This really shouldn't happen if we're using the quick
5228 * look-up tables, as it would mean we'd scanned past an
5229 * END MODULE entry. But if we're not using the tables,
5230 * we started the module on the SRCFILE entry, so it's ok.
5231 * For now, accept this.
5233 /* warning( "Error expanding psymtab, missed module end, found entry for %s",
5236 *at_module_boundary_p
= -1;
5239 start_subfile (name
, NULL
);
5242 case DNTT_TYPE_FUNCTION
:
5243 case DNTT_TYPE_ENTRY
:
5244 /* A function or secondary entry point. */
5245 valu
= dn_bufp
->dfunc
.lowaddr
+ offset
;
5247 /* Record lines up to this point. */
5248 SL_INDEX (objfile
) = hpread_record_lines (current_subfile
,
5250 dn_bufp
->dfunc
.address
,
5253 WITHIN_FUNCTION (objfile
) = 1;
5254 CURRENT_FUNCTION_VALUE (objfile
) = valu
;
5256 /* Stack must be empty now. */
5257 if (context_stack_depth
!= 0)
5258 lbrac_unmatched_complaint (symnum
);
5259 new = push_context (0, valu
);
5261 /* Built a type for the function. This includes processing
5262 * the symbol records for the function parameters.
5264 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
5265 SYMBOL_TYPE (sym
) = hpread_read_function_type (hp_type
, dn_bufp
, objfile
, 1);
5267 /* All functions in C++ have prototypes. For C we don't have enough
5268 information in the debug info. */
5269 if (SYMBOL_LANGUAGE (sym
) == language_cplus
)
5270 TYPE_FLAGS (SYMBOL_TYPE (sym
)) |= TYPE_FLAG_PROTOTYPED
;
5272 /* The "DEPRECATED_SYMBOL_NAME" field is expected to be the mangled name
5273 * (if any), which we get from the "alias" field of the SOM record
5276 if ((dn_bufp
->dfunc
.language
== HP_LANGUAGE_CPLUSPLUS
) &&
5277 dn_bufp
->dfunc
.alias
&& /* has an alias */
5278 *(char *) (VT (objfile
) + dn_bufp
->dfunc
.alias
)) /* not a null string */
5279 DEPRECATED_SYMBOL_NAME (sym
) = VT (objfile
) + dn_bufp
->dfunc
.alias
;
5281 DEPRECATED_SYMBOL_NAME (sym
) = VT (objfile
) + dn_bufp
->dfunc
.name
;
5283 /* Special hack to get around HP compilers' insistence on
5284 * reporting "main" as "_MAIN_" for C/C++ */
5285 if ((strcmp (DEPRECATED_SYMBOL_NAME (sym
), "_MAIN_") == 0) &&
5286 (strcmp (VT (objfile
) + dn_bufp
->dfunc
.name
, "main") == 0))
5287 DEPRECATED_SYMBOL_NAME (sym
) = VT (objfile
) + dn_bufp
->dfunc
.name
;
5289 /* The SYMBOL_CPLUS_DEMANGLED_NAME field is expected to
5290 * be the demangled name.
5292 if (dn_bufp
->dfunc
.language
== HP_LANGUAGE_CPLUSPLUS
)
5294 /* SYMBOL_INIT_DEMANGLED_NAME is a macro which winds up
5295 * calling the demangler in libiberty (cplus_demangle()) to
5296 * do the job. This generally does the job, even though
5297 * it's intended for the GNU compiler and not the aCC compiler
5298 * Note that SYMBOL_INIT_DEMANGLED_NAME calls the
5299 * demangler with arguments DMGL_PARAMS | DMGL_ANSI.
5300 * Generally, we don't want params when we display
5301 * a demangled name, but when I took out the DMGL_PARAMS,
5302 * some things broke, so I'm leaving it in here, and
5303 * working around the issue in stack.c. - RT
5305 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
5306 if ((DEPRECATED_SYMBOL_NAME (sym
) == VT (objfile
) + dn_bufp
->dfunc
.alias
) &&
5307 (!SYMBOL_CPLUS_DEMANGLED_NAME (sym
)))
5310 /* Well, the symbol name is mangled, but the
5311 * demangler in libiberty failed so the demangled
5312 * field is still NULL. Try to
5313 * do the job ourselves based on the "name" field
5314 * in the SOM record. A complication here is that
5315 * the name field contains only the function name
5316 * (like "f"), whereas we want the class qualification
5317 * (as in "c::f"). Try to reconstruct that.
5322 basename
= VT (objfile
) + dn_bufp
->dfunc
.name
;
5323 classname
= class_of (SYMBOL_TYPE (sym
));
5326 dem_name
= xmalloc (strlen (basename
) + strlen (classname
) + 3);
5327 strcpy (dem_name
, classname
);
5328 strcat (dem_name
, "::");
5329 strcat (dem_name
, basename
);
5330 SYMBOL_CPLUS_DEMANGLED_NAME (sym
) = dem_name
;
5331 SYMBOL_LANGUAGE (sym
) = language_cplus
;
5336 /* Add the function symbol to the list of symbols in this blockvector */
5337 if (dn_bufp
->dfunc
.global
)
5338 add_symbol_to_list (sym
, &global_symbols
);
5340 add_symbol_to_list (sym
, &file_symbols
);
5343 /* Search forward to the next BEGIN and also read
5344 * in the line info up to that point.
5345 * Not sure why this is needed.
5346 * In HP FORTRAN this code is harmful since there
5347 * may not be a BEGIN after the FUNCTION.
5348 * So I made it C/C++ specific. - RT
5350 if (dn_bufp
->dfunc
.language
== HP_LANGUAGE_C
||
5351 dn_bufp
->dfunc
.language
== HP_LANGUAGE_CPLUSPLUS
)
5353 while (dn_bufp
->dblock
.kind
!= DNTT_TYPE_BEGIN
)
5355 dn_bufp
= hpread_get_lntt (++index
, objfile
);
5356 if (dn_bufp
->dblock
.extension
)
5359 SL_INDEX (objfile
) = hpread_record_lines (current_subfile
,
5361 dn_bufp
->dbegin
.address
,
5363 SYMBOL_LINE (sym
) = hpread_get_line (dn_bufp
->dbegin
.address
, objfile
);
5365 record_line (current_subfile
, SYMBOL_LINE (sym
), valu
);
5368 case DNTT_TYPE_DOC_FUNCTION
:
5369 valu
= dn_bufp
->ddocfunc
.lowaddr
+ offset
;
5371 /* Record lines up to this point. */
5372 SL_INDEX (objfile
) = hpread_record_lines (current_subfile
,
5374 dn_bufp
->ddocfunc
.address
,
5377 WITHIN_FUNCTION (objfile
) = 1;
5378 CURRENT_FUNCTION_VALUE (objfile
) = valu
;
5379 /* Stack must be empty now. */
5380 if (context_stack_depth
!= 0)
5381 lbrac_unmatched_complaint (symnum
);
5382 new = push_context (0, valu
);
5384 /* Built a type for the function. This includes processing
5385 * the symbol records for the function parameters.
5387 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
5388 SYMBOL_TYPE (sym
) = hpread_read_doc_function_type (hp_type
, dn_bufp
, objfile
, 1);
5390 /* The "DEPRECATED_SYMBOL_NAME" field is expected to be the mangled name
5391 * (if any), which we get from the "alias" field of the SOM record
5394 if ((dn_bufp
->ddocfunc
.language
== HP_LANGUAGE_CPLUSPLUS
) &&
5395 dn_bufp
->ddocfunc
.alias
&& /* has an alias */
5396 *(char *) (VT (objfile
) + dn_bufp
->ddocfunc
.alias
)) /* not a null string */
5397 DEPRECATED_SYMBOL_NAME (sym
) = VT (objfile
) + dn_bufp
->ddocfunc
.alias
;
5399 DEPRECATED_SYMBOL_NAME (sym
) = VT (objfile
) + dn_bufp
->ddocfunc
.name
;
5401 /* Special hack to get around HP compilers' insistence on
5402 * reporting "main" as "_MAIN_" for C/C++ */
5403 if ((strcmp (DEPRECATED_SYMBOL_NAME (sym
), "_MAIN_") == 0) &&
5404 (strcmp (VT (objfile
) + dn_bufp
->ddocfunc
.name
, "main") == 0))
5405 DEPRECATED_SYMBOL_NAME (sym
) = VT (objfile
) + dn_bufp
->ddocfunc
.name
;
5407 if (dn_bufp
->ddocfunc
.language
== HP_LANGUAGE_CPLUSPLUS
)
5410 /* SYMBOL_INIT_DEMANGLED_NAME is a macro which winds up
5411 * calling the demangler in libiberty (cplus_demangle()) to
5412 * do the job. This generally does the job, even though
5413 * it's intended for the GNU compiler and not the aCC compiler
5414 * Note that SYMBOL_INIT_DEMANGLED_NAME calls the
5415 * demangler with arguments DMGL_PARAMS | DMGL_ANSI.
5416 * Generally, we don't want params when we display
5417 * a demangled name, but when I took out the DMGL_PARAMS,
5418 * some things broke, so I'm leaving it in here, and
5419 * working around the issue in stack.c. - RT
5421 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
5423 if ((DEPRECATED_SYMBOL_NAME (sym
) == VT (objfile
) + dn_bufp
->ddocfunc
.alias
) &&
5424 (!SYMBOL_CPLUS_DEMANGLED_NAME (sym
)))
5427 /* Well, the symbol name is mangled, but the
5428 * demangler in libiberty failed so the demangled
5429 * field is still NULL. Try to
5430 * do the job ourselves based on the "name" field
5431 * in the SOM record. A complication here is that
5432 * the name field contains only the function name
5433 * (like "f"), whereas we want the class qualification
5434 * (as in "c::f"). Try to reconstruct that.
5439 basename
= VT (objfile
) + dn_bufp
->ddocfunc
.name
;
5440 classname
= class_of (SYMBOL_TYPE (sym
));
5443 dem_name
= xmalloc (strlen (basename
) + strlen (classname
) + 3);
5444 strcpy (dem_name
, classname
);
5445 strcat (dem_name
, "::");
5446 strcat (dem_name
, basename
);
5447 SYMBOL_CPLUS_DEMANGLED_NAME (sym
) = dem_name
;
5448 SYMBOL_LANGUAGE (sym
) = language_cplus
;
5453 /* Add the function symbol to the list of symbols in this blockvector */
5454 if (dn_bufp
->ddocfunc
.global
)
5455 add_symbol_to_list (sym
, &global_symbols
);
5457 add_symbol_to_list (sym
, &file_symbols
);
5460 /* Search forward to the next BEGIN and also read
5461 * in the line info up to that point.
5462 * Not sure why this is needed.
5463 * In HP FORTRAN this code is harmful since there
5464 * may not be a BEGIN after the FUNCTION.
5465 * So I made it C/C++ specific. - RT
5467 if (dn_bufp
->ddocfunc
.language
== HP_LANGUAGE_C
||
5468 dn_bufp
->ddocfunc
.language
== HP_LANGUAGE_CPLUSPLUS
)
5470 while (dn_bufp
->dblock
.kind
!= DNTT_TYPE_BEGIN
)
5472 dn_bufp
= hpread_get_lntt (++index
, objfile
);
5473 if (dn_bufp
->dblock
.extension
)
5476 SL_INDEX (objfile
) = hpread_record_lines (current_subfile
,
5478 dn_bufp
->dbegin
.address
,
5480 SYMBOL_LINE (sym
) = hpread_get_line (dn_bufp
->dbegin
.address
, objfile
);
5482 record_line (current_subfile
, SYMBOL_LINE (sym
), valu
);
5485 case DNTT_TYPE_BEGIN
:
5486 /* Begin a new scope. */
5487 if (context_stack_depth
== 1 /* this means we're at function level */ &&
5488 context_stack
[0].name
!= NULL
/* this means it's a function */ &&
5489 context_stack
[0].depth
== 0 /* this means it's the first BEGIN
5490 we've seen after the FUNCTION */
5493 /* This is the first BEGIN after a FUNCTION.
5494 * We ignore this one, since HP compilers always insert
5495 * at least one BEGIN, i.e. it's:
5501 * (possibly nested BEGIN ... END's if there are inner { } blocks)
5505 * By ignoring this first BEGIN, the local symbols get treated
5506 * as belonging to the function scope, and "print func::local_sym"
5507 * works (which is what we want).
5510 /* All we do here is increase the depth count associated with
5511 * the FUNCTION entry in the context stack. This ensures that
5512 * the next BEGIN we see (if any), representing a real nested { }
5513 * block, will get processed.
5516 context_stack
[0].depth
++;
5522 /* Record lines up to this SLT pointer. */
5523 SL_INDEX (objfile
) = hpread_record_lines (current_subfile
,
5525 dn_bufp
->dbegin
.address
,
5527 /* Calculate start address of new scope */
5528 valu
= hpread_get_location (dn_bufp
->dbegin
.address
, objfile
);
5529 valu
+= offset
; /* Relocate for dynamic loading */
5530 /* We use the scope start DNTT index as nesting depth identifier! */
5531 desc
= hpread_get_scope_start (dn_bufp
->dbegin
.address
, objfile
);
5532 new = push_context (desc
, valu
);
5539 /* Valid end kinds are:
5548 SL_INDEX (objfile
) = hpread_record_lines (current_subfile
,
5550 dn_bufp
->dend
.address
,
5552 switch (dn_bufp
->dend
.endkind
)
5554 case DNTT_TYPE_MODULE
:
5555 /* Ending a module ends the symbol table for that module.
5556 * Calling end_symtab() has the side effect of clearing the
5557 * last_source_file pointer, which in turn signals
5558 * process_one_debug_symbol() to treat the next DNTT_TYPE_SRCFILE
5559 * record as a module-begin.
5561 valu
= text_offset
+ text_size
+ offset
;
5563 /* Tell our caller that we're done with expanding the
5564 * debug information for a module.
5566 *at_module_boundary_p
= 1;
5568 /* Don't do this, as our caller will do it!
5570 * (void) end_symtab (valu, objfile, 0);
5574 case DNTT_TYPE_FUNCTION
:
5575 /* Ending a function, well, ends the function's scope. */
5576 dn_temp
= hpread_get_lntt (dn_bufp
->dend
.beginscope
.dnttp
.index
,
5578 valu
= dn_temp
->dfunc
.hiaddr
+ offset
;
5579 /* Insert func params into local list */
5580 merge_symbol_lists (¶m_symbols
, &local_symbols
);
5581 new = pop_context ();
5582 /* Make a block for the local symbols within. */
5583 finish_block (new->name
, &local_symbols
, new->old_blocks
,
5584 new->start_addr
, valu
, objfile
);
5585 WITHIN_FUNCTION (objfile
) = 0; /* This may have to change for Pascal */
5586 local_symbols
= new->locals
;
5587 param_symbols
= new->params
;
5590 case DNTT_TYPE_BEGIN
:
5591 if (context_stack_depth
== 1 &&
5592 context_stack
[0].name
!= NULL
&&
5593 context_stack
[0].depth
== 1)
5595 /* This is the END corresponding to the
5596 * BEGIN which we ignored - see DNTT_TYPE_BEGIN case above.
5598 context_stack
[0].depth
--;
5602 /* Ending a local scope. */
5603 valu
= hpread_get_location (dn_bufp
->dend
.address
, objfile
);
5604 /* Why in the hell is this needed? */
5605 valu
+= offset
+ 9; /* Relocate for dynamic loading */
5606 new = pop_context ();
5607 desc
= dn_bufp
->dend
.beginscope
.dnttp
.index
;
5608 if (desc
!= new->depth
)
5609 lbrac_mismatch_complaint (symnum
);
5611 /* Make a block for the local symbols within. */
5612 finish_block (new->name
, &local_symbols
, new->old_blocks
,
5613 new->start_addr
, valu
, objfile
);
5614 local_symbols
= new->locals
;
5615 param_symbols
= new->params
;
5619 case DNTT_TYPE_WITH
:
5620 /* Since we ignore the DNTT_TYPE_WITH that starts the scope,
5621 * we can ignore the DNTT_TYPE_END that ends it.
5625 case DNTT_TYPE_COMMON
:
5626 /* End a FORTRAN common block. We don't currently handle these */
5627 complaint (&symfile_complaints
,
5628 "unhandled symbol in hp-symtab-read.c: DNTT_TYPE_COMMON/DNTT_TYPE_END.\n");
5631 case DNTT_TYPE_CLASS_SCOPE
:
5633 /* pai: FIXME Not handling nested classes for now -- must
5634 * maintain a stack */
5635 class_scope_name
= NULL
;
5638 /* End a class scope */
5639 valu
= hpread_get_location (dn_bufp
->dend
.address
, objfile
);
5640 /* Why in the hell is this needed? */
5641 valu
+= offset
+ 9; /* Relocate for dynamic loading */
5642 new = pop_context ();
5643 desc
= dn_bufp
->dend
.beginscope
.dnttp
.index
;
5644 if (desc
!= new->depth
)
5645 lbrac_mismatch_complaint ((char *) symnum
);
5646 /* Make a block for the local symbols within. */
5647 finish_block (new->name
, &local_symbols
, new->old_blocks
,
5648 new->start_addr
, valu
, objfile
);
5649 local_symbols
= new->locals
;
5650 param_symbols
= new->params
;
5655 complaint (&symfile_complaints
,
5656 "internal error in hp-symtab-read.c: Unexpected DNTT_TYPE_END kind.");
5661 /* DNTT_TYPE_IMPORT is not handled */
5663 case DNTT_TYPE_LABEL
:
5664 SYMBOL_DOMAIN (sym
) = LABEL_DOMAIN
;
5667 case DNTT_TYPE_FPARAM
:
5668 /* Function parameters. */
5669 /* Note 1: This code was present in the 4.16 sources, and then
5670 removed, because fparams are handled in
5671 hpread_read_function_type(). However, while fparam symbols
5672 are indeed handled twice, this code here cannot be removed
5673 because then they don't get added to the local symbol list of
5674 the function's code block, which leads to a failure to look
5675 up locals, "this"-relative member names, etc. So I've put
5676 this code back in. pai/1997-07-21 */
5677 /* Note 2: To fix a defect, we stopped adding FPARAMS to local_symbols
5678 in hpread_read_function_type(), so FPARAMS had to be handled
5679 here. I changed the location to be the appropriate argument
5680 kinds rather than LOC_LOCAL. pai/1997-08-08 */
5681 /* Note 3: Well, the fix in Note 2 above broke argument printing
5682 in traceback frames, and further it makes assumptions about the
5683 order of the FPARAM entries from HP compilers (cc and aCC in particular
5684 generate them in reverse orders -- fixing one breaks for the other).
5685 So I've added code in hpread_read_function_type() to add fparams
5686 to a param_symbols list for the current context level. These are
5687 then merged into local_symbols when a function end is reached.
5690 break; /* do nothing; handled in hpread_read_function_type() */
5692 #if 0 /* Old code */
5693 if (dn_bufp
->dfparam
.regparam
)
5694 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
5695 else if (dn_bufp
->dfparam
.indirect
)
5696 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
5698 SYMBOL_CLASS (sym
) = LOC_ARG
;
5699 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
5700 if (dn_bufp
->dfparam
.copyparam
)
5702 SYMBOL_VALUE (sym
) = dn_bufp
->dfparam
.location
;
5703 #ifdef HPREAD_ADJUST_STACK_ADDRESS
5705 += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile
));
5709 SYMBOL_VALUE (sym
) = dn_bufp
->dfparam
.location
;
5710 SYMBOL_TYPE (sym
) = hpread_type_lookup (dn_bufp
->dfparam
.type
, objfile
);
5711 add_symbol_to_list (sym
, &fparam_symbols
);
5715 case DNTT_TYPE_SVAR
:
5716 /* Static variables. */
5717 SYMBOL_CLASS (sym
) = LOC_STATIC
;
5719 /* Note: There is a case that arises with globals in shared
5720 * libraries where we need to set the address to LOC_INDIRECT.
5721 * This case is if you have a global "g" in one library, and
5722 * it is referenced "extern <type> g;" in another library.
5723 * If we're processing the symbols for the referencing library,
5724 * we'll see a global "g", but in this case the address given
5725 * in the symbol table contains a pointer to the real "g".
5726 * We use the storage class LOC_INDIRECT to indicate this. RT
5728 if (is_in_import_list (DEPRECATED_SYMBOL_NAME (sym
), objfile
))
5729 SYMBOL_CLASS (sym
) = LOC_INDIRECT
;
5731 SYMBOL_VALUE_ADDRESS (sym
) = dn_bufp
->dsvar
.location
+ data_offset
;
5732 SYMBOL_TYPE (sym
) = hpread_type_lookup (dn_bufp
->dsvar
.type
, objfile
);
5734 if (dn_bufp
->dsvar
.global
)
5735 add_symbol_to_list (sym
, &global_symbols
);
5737 else if (WITHIN_FUNCTION (objfile
))
5738 add_symbol_to_list (sym
, &local_symbols
);
5741 add_symbol_to_list (sym
, &file_symbols
);
5743 if (dn_bufp
->dsvar
.thread_specific
)
5745 /* Thread-local variable.
5747 SYMBOL_CLASS (sym
) = LOC_HP_THREAD_LOCAL_STATIC
;
5748 SYMBOL_BASEREG (sym
) = CR27_REGNUM
;
5750 if (objfile
->flags
& OBJF_SHARED
)
5753 * This variable is not only thread local but
5754 * in a shared library.
5756 * Alas, the shared lib structures are private
5757 * to "somsolib.c". But C lets us point to one.
5761 if (objfile
->obj_private
== NULL
)
5762 error ("Internal error in reading shared library information.");
5764 so
= ((obj_private_data_t
*) (objfile
->obj_private
))->so_info
;
5766 error ("Internal error in reading shared library information.");
5768 /* Thread-locals in shared libraries do NOT have the
5769 * standard offset ("data_offset"), so we re-calculate
5770 * where to look for this variable, using a call-back
5771 * to interpret the private shared-library data.
5773 SYMBOL_VALUE_ADDRESS (sym
) = dn_bufp
->dsvar
.location
+
5774 so_lib_thread_start_addr (so
);
5779 case DNTT_TYPE_DVAR
:
5780 /* Dynamic variables. */
5781 if (dn_bufp
->ddvar
.regvar
)
5782 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
5784 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
5786 SYMBOL_VALUE (sym
) = dn_bufp
->ddvar
.location
;
5787 #ifdef HPREAD_ADJUST_STACK_ADDRESS
5789 += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile
));
5791 SYMBOL_TYPE (sym
) = hpread_type_lookup (dn_bufp
->ddvar
.type
, objfile
);
5792 if (dn_bufp
->ddvar
.global
)
5793 add_symbol_to_list (sym
, &global_symbols
);
5794 else if (WITHIN_FUNCTION (objfile
))
5795 add_symbol_to_list (sym
, &local_symbols
);
5797 add_symbol_to_list (sym
, &file_symbols
);
5800 case DNTT_TYPE_CONST
:
5801 /* A constant (pascal?). */
5802 SYMBOL_CLASS (sym
) = LOC_CONST
;
5803 SYMBOL_VALUE (sym
) = dn_bufp
->dconst
.location
;
5804 SYMBOL_TYPE (sym
) = hpread_type_lookup (dn_bufp
->dconst
.type
, objfile
);
5805 if (dn_bufp
->dconst
.global
)
5806 add_symbol_to_list (sym
, &global_symbols
);
5807 else if (WITHIN_FUNCTION (objfile
))
5808 add_symbol_to_list (sym
, &local_symbols
);
5810 add_symbol_to_list (sym
, &file_symbols
);
5813 case DNTT_TYPE_TYPEDEF
:
5814 /* A typedef. We do want to process these, since a name is
5815 * added to the domain for the typedef'ed name.
5817 SYMBOL_DOMAIN (sym
) = VAR_DOMAIN
;
5818 SYMBOL_TYPE (sym
) = hpread_type_lookup (dn_bufp
->dtype
.type
, objfile
);
5819 if (dn_bufp
->dtype
.global
)
5820 add_symbol_to_list (sym
, &global_symbols
);
5821 else if (WITHIN_FUNCTION (objfile
))
5822 add_symbol_to_list (sym
, &local_symbols
);
5824 add_symbol_to_list (sym
, &file_symbols
);
5827 case DNTT_TYPE_TAGDEF
:
5829 int global
= dn_bufp
->dtag
.global
;
5830 /* Structure, union, enum, template, or class tag definition */
5831 /* We do want to process these, since a name is
5832 * added to the domain for the tag name (and if C++ class,
5833 * for the typename also).
5835 SYMBOL_DOMAIN (sym
) = STRUCT_DOMAIN
;
5837 /* The tag contains in its "type" field a pointer to the
5838 * DNTT_TYPE_STRUCT, DNTT_TYPE_UNION, DNTT_TYPE_ENUM,
5839 * DNTT_TYPE_CLASS or DNTT_TYPE_TEMPLATE
5840 * record that actually defines the type.
5842 SYMBOL_TYPE (sym
) = hpread_type_lookup (dn_bufp
->dtype
.type
, objfile
);
5843 TYPE_NAME (sym
->type
) = DEPRECATED_SYMBOL_NAME (sym
);
5844 TYPE_TAG_NAME (sym
->type
) = DEPRECATED_SYMBOL_NAME (sym
);
5845 if (dn_bufp
->dtag
.global
)
5846 add_symbol_to_list (sym
, &global_symbols
);
5847 else if (WITHIN_FUNCTION (objfile
))
5848 add_symbol_to_list (sym
, &local_symbols
);
5850 add_symbol_to_list (sym
, &file_symbols
);
5852 /* If this is a C++ class, then we additionally
5853 * need to define a typedef for the
5854 * class type. E.g., so that the name "c" becomes visible as
5855 * a type name when the user says "class c { ... }".
5856 * In order to figure this out, we need to chase down the "type"
5857 * field to get to the DNTT_TYPE_CLASS record.
5859 * We also add the typename for ENUM. Though this isn't
5860 * strictly correct, it is necessary because of the debug info
5861 * generated by the aCC compiler, in which we cannot
5862 * distinguish between:
5865 * typedef enum { ... } e;
5866 * I.e., the compiler emits the same debug info for the above
5867 * two cases, in both cases "e" appearing as a tagdef.
5868 * Therefore go ahead and generate the typename so that
5869 * "ptype e" will work in the above cases.
5871 * We also add the typename for TEMPLATE, so as to allow "ptype t"
5872 * when "t" is a template name.
5874 if (dn_bufp
->dtype
.type
.dnttp
.index
< LNTT_SYMCOUNT (objfile
))
5875 dn_bufp
= hpread_get_lntt (dn_bufp
->dtag
.type
.dnttp
.index
, objfile
);
5878 complaint (&symfile_complaints
, "error processing class tagdef");
5881 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_CLASS
||
5882 dn_bufp
->dblock
.kind
== DNTT_TYPE_ENUM
||
5883 dn_bufp
->dblock
.kind
== DNTT_TYPE_TEMPLATE
)
5885 struct symbol
*newsym
;
5887 newsym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
5888 sizeof (struct symbol
));
5889 memset (newsym
, 0, sizeof (struct symbol
));
5890 DEPRECATED_SYMBOL_NAME (newsym
) = name
;
5891 SYMBOL_LANGUAGE (newsym
) = language_auto
;
5892 SYMBOL_DOMAIN (newsym
) = VAR_DOMAIN
;
5893 SYMBOL_LINE (newsym
) = 0;
5894 SYMBOL_VALUE (newsym
) = 0;
5895 SYMBOL_CLASS (newsym
) = LOC_TYPEDEF
;
5896 SYMBOL_TYPE (newsym
) = sym
->type
;
5898 add_symbol_to_list (newsym
, &global_symbols
);
5899 else if (WITHIN_FUNCTION (objfile
))
5900 add_symbol_to_list (newsym
, &local_symbols
);
5902 add_symbol_to_list (newsym
, &file_symbols
);
5907 case DNTT_TYPE_POINTER
:
5908 /* Declares a pointer type. Should not be necessary to do anything
5909 * with the type at this level; these are processed
5910 * at the hpread_type_lookup() level.
5914 case DNTT_TYPE_ENUM
:
5915 /* Declares an enum type. Should not be necessary to do anything
5916 * with the type at this level; these are processed
5917 * at the hpread_type_lookup() level.
5921 case DNTT_TYPE_MEMENUM
:
5922 /* Member of enum */
5923 /* Ignored at this level, but hpread_read_enum_type() will take
5924 * care of walking the list of enumeration members.
5929 /* Declares a set type. Should not be necessary to do anything
5930 * with the type at this level; these are processed
5931 * at the hpread_type_lookup() level.
5935 case DNTT_TYPE_SUBRANGE
:
5936 /* Declares a subrange type. Should not be necessary to do anything
5937 * with the type at this level; these are processed
5938 * at the hpread_type_lookup() level.
5942 case DNTT_TYPE_ARRAY
:
5943 /* Declares an array type. Should not be necessary to do anything
5944 * with the type at this level; these are processed
5945 * at the hpread_type_lookup() level.
5949 case DNTT_TYPE_STRUCT
:
5950 case DNTT_TYPE_UNION
:
5951 /* Declares an struct/union type.
5952 * Should not be necessary to do anything
5953 * with the type at this level; these are processed
5954 * at the hpread_type_lookup() level.
5958 case DNTT_TYPE_FIELD
:
5959 /* Structure/union/class field */
5960 /* Ignored at this level, but hpread_read_struct_type() will take
5961 * care of walking the list of structure/union/class members.
5965 /* DNTT_TYPE_VARIANT is not handled by GDB */
5967 /* DNTT_TYPE_FILE is not handled by GDB */
5969 case DNTT_TYPE_FUNCTYPE
:
5971 /* Ignored at this level, handled within hpread_type_lookup() */
5974 case DNTT_TYPE_WITH
:
5975 /* This is emitted within methods to indicate "with <class>"
5976 * scoping rules (i.e., indicate that the class data members
5977 * are directly visible).
5978 * However, since GDB already infers this by looking at the
5979 * "this" argument, interpreting the DNTT_TYPE_WITH
5980 * symbol record is unnecessary.
5984 case DNTT_TYPE_COMMON
:
5985 /* FORTRAN common. Not yet handled. */
5986 complaint (&symfile_complaints
,
5987 "unhandled symbol in hp-symtab-read.c: DNTT_TYPE_COMMON.");
5990 /* DNTT_TYPE_COBSTRUCT is not handled by GDB. */
5991 /* DNTT_TYPE_XREF is not handled by GDB. */
5992 /* DNTT_TYPE_SA is not handled by GDB. */
5993 /* DNTT_TYPE_MACRO is not handled by GDB */
5995 case DNTT_TYPE_BLOCKDATA
:
5996 /* Not sure what this is - part of FORTRAN support maybe?
5997 * Anyway, not yet handled.
5999 complaint (&symfile_complaints
,
6000 "unhandled symbol in hp-symtab-read.c: DNTT_TYPE_BLOCKDATA.");
6003 case DNTT_TYPE_CLASS_SCOPE
:
6007 /* The compiler brackets member functions with a CLASS_SCOPE/END
6008 * pair of records, presumably to put them in a different scope
6009 * from the module scope where they are normally defined.
6010 * E.g., in the situation:
6012 * void c::f() { ...}
6013 * The member function "c::f" will be bracketed by a CLASS_SCOPE/END.
6014 * This causes "break f" at the module level to pick the
6015 * the file-level function f(), not the member function
6016 * (which needs to be referenced via "break c::f").
6018 * Here we record the class name to generate the demangled names of
6019 * member functions later.
6021 * FIXME Not being used now for anything -- cplus_demangle seems
6022 * enough for getting the class-qualified names of functions. We
6023 * may need this for handling nested classes and types. */
6025 /* pai: FIXME Not handling nested classes for now -- need to
6026 * maintain a stack */
6028 dn_temp
= hpread_get_lntt (dn_bufp
->dclass_scope
.type
.dnttp
.index
, objfile
);
6029 if (dn_temp
->dblock
.kind
== DNTT_TYPE_TAGDEF
)
6030 class_scope_name
= VT (objfile
) + dn_temp
->dtag
.name
;
6032 class_scope_name
= NULL
;
6036 /* Begin a new scope. */
6037 SL_INDEX (objfile
) = hpread_record_lines (current_subfile
,
6039 dn_bufp
->dclass_scope
.address
,
6041 valu
= hpread_get_location (dn_bufp
->dclass_scope
.address
, objfile
);
6042 valu
+= offset
; /* Relocate for dynamic loading */
6043 desc
= hpread_get_scope_start (dn_bufp
->dclass_scope
.address
, objfile
);
6044 /* We use the scope start DNTT index as the nesting depth identifier! */
6045 new = push_context (desc
, valu
);
6049 case DNTT_TYPE_REFERENCE
:
6050 /* Declares a C++ reference type. 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_PTRMEM
:
6057 /* Declares a C++ pointer-to-data-member type. This does not
6058 * need to be handled at this level; being a type description it
6059 * is instead handled at the hpread_type_lookup() level.
6063 case DNTT_TYPE_PTRMEMFUNC
:
6064 /* Declares a C++ pointer-to-function-member type. This does not
6065 * need to be handled at this level; being a type description it
6066 * is instead handled at the hpread_type_lookup() level.
6070 case DNTT_TYPE_CLASS
:
6071 /* Declares a class type.
6072 * Should not be necessary to do anything
6073 * with the type at this level; these are processed
6074 * at the hpread_type_lookup() level.
6078 case DNTT_TYPE_GENFIELD
:
6079 /* I believe this is used for class member functions */
6080 /* Ignored at this level, but hpread_read_struct_type() will take
6081 * care of walking the list of class members.
6085 case DNTT_TYPE_VFUNC
:
6086 /* Virtual function */
6087 /* This does not have to be handled at this level; handled in
6088 * the course of processing class symbols.
6092 case DNTT_TYPE_MEMACCESS
:
6093 /* DDE ignores this symbol table record.
6094 * It has something to do with "modified access" to class members.
6095 * I'll assume we can safely ignore it too.
6099 case DNTT_TYPE_INHERITANCE
:
6100 /* These don't have to be handled here, since they are handled
6101 * within hpread_read_struct_type() in the process of constructing
6106 case DNTT_TYPE_FRIEND_CLASS
:
6107 case DNTT_TYPE_FRIEND_FUNC
:
6108 /* These can safely be ignored, as GDB doesn't need this
6109 * info. DDE only uses it in "describe". We may later want
6110 * to extend GDB's "ptype" to give this info, but for now
6111 * it seems safe enough to ignore it.
6115 case DNTT_TYPE_MODIFIER
:
6116 /* Intended to supply "modified access" to a type */
6117 /* From the way DDE handles this, it looks like it always
6118 * modifies a type. Therefore it is safe to ignore it at this
6119 * level, and handle it in hpread_type_lookup().
6123 case DNTT_TYPE_OBJECT_ID
:
6124 /* Just ignore this - that's all DDE does */
6127 case DNTT_TYPE_MEMFUNC
:
6128 /* Member function */
6129 /* This does not have to be handled at this level; handled in
6130 * the course of processing class symbols.
6134 case DNTT_TYPE_DOC_MEMFUNC
:
6135 /* Member function */
6136 /* This does not have to be handled at this level; handled in
6137 * the course of processing class symbols.
6141 case DNTT_TYPE_TEMPLATE
:
6142 /* Template - sort of the header for a template definition,
6143 * which like a class, points to a member list and also points
6144 * to a TEMPLATE_ARG list of type-arguments.
6145 * We do not need to process TEMPLATE records at this level though.
6149 case DNTT_TYPE_TEMPLATE_ARG
:
6150 /* The TEMPLATE record points to an argument list of
6151 * TEMPLATE_ARG records, each of which describes one
6152 * of the type-arguments.
6153 * We do not need to process TEMPLATE_ARG records at this level though.
6157 case DNTT_TYPE_FUNC_TEMPLATE
:
6158 /* This will get emitted for member functions of templates.
6159 * But we don't need to process this record at this level though,
6160 * we will process it in the course of processing a TEMPLATE
6165 case DNTT_TYPE_LINK
:
6166 /* The LINK record is used to link up templates with instantiations. */
6167 /* It is not clear why this is needed, and furthermore aCC does
6168 * not appear to generate this, so I think we can safely ignore it. - RT
6172 /* DNTT_TYPE_DYN_ARRAY_DESC is not handled by GDB */
6173 /* DNTT_TYPE_DESC_SUBRANGE is not handled by GDB */
6174 /* DNTT_TYPE_BEGIN_EXT is not handled by GDB */
6175 /* DNTT_TYPE_INLN is not handled by GDB */
6176 /* DNTT_TYPE_INLN_LIST is not handled by GDB */
6177 /* DNTT_TYPE_ALIAS is not handled by GDB */
6184 /* Get nesting depth for a DNTT entry.
6185 * DN_BUFP points to a DNTT entry.
6186 * OBJFILE is the object file.
6187 * REPORT_NESTED is a flag; if 0, real nesting depth is
6188 * reported, if it is 1, the function simply returns a
6189 * non-zero value if the nesting depth is anything > 0.
6191 * Return value is an integer. 0 => not a local type / name
6192 * positive return => type or name is local to some
6193 * block or function.
6197 /* elz: ATTENTION: FIXME: NOTE: WARNING!!!!
6198 this function now returns 0 right away. It was taking too much time
6199 at start up. Now, though, the local types are not handled correctly.
6204 hpread_get_scope_depth (union dnttentry
*dn_bufp
, struct objfile
*objfile
,
6208 register union dnttentry
*dn_tmp
;
6209 register short depth
= 0;
6210 /****************************/
6212 /****************************/
6214 index
= (((char *) dn_bufp
) - LNTT (objfile
)) / (sizeof (struct dntt_type_block
));
6216 while (--index
>= 0)
6218 dn_tmp
= hpread_get_lntt (index
, objfile
);
6219 switch (dn_tmp
->dblock
.kind
)
6221 case DNTT_TYPE_MODULE
:
6224 /* index is signed int; dnttp.index is 29-bit unsigned int! */
6225 index
= (int) dn_tmp
->dend
.beginscope
.dnttp
.index
;
6227 case DNTT_TYPE_BEGIN
:
6228 case DNTT_TYPE_FUNCTION
:
6229 case DNTT_TYPE_DOC_FUNCTION
:
6230 case DNTT_TYPE_WITH
:
6231 case DNTT_TYPE_COMMON
:
6232 case DNTT_TYPE_CLASS_SCOPE
:
6244 /* Adjust the bitoffsets for all fields of an anonymous union of
6245 type TYPE by negative BITS. This handles HP aCC's hideous habit
6246 of giving members of anonymous unions bit offsets relative to the
6247 enclosing structure instead of relative to the union itself. */
6250 hpread_adjust_bitoffsets (struct type
*type
, int bits
)
6254 /* This is done only for unions; caller had better check that
6255 it is an anonymous one. */
6256 if (TYPE_CODE (type
) != TYPE_CODE_UNION
)
6259 /* Adjust each field; since this is a union, there are no base
6260 classes. Also no static membes. Also, no need for recursion as
6261 the members of this union if themeselves structs or unions, have
6262 the correct bitoffsets; if an anonymous union is a member of this
6263 anonymous union, the code in hpread_read_struct_type() will
6266 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
6267 TYPE_FIELD_BITPOS (type
, i
) -= bits
;
6270 /* Because of quirks in HP compilers' treatment of anonymous unions inside
6271 classes, we have to chase through a chain of threaded FIELD entries.
6272 If we encounter an anonymous union in the chain, we must recursively skip over
6275 This function does a "next" in the chain of FIELD entries, but transparently
6276 skips over anonymous unions' fields (recursively).
6278 Inputs are the number of times to do "next" at the top level, the dnttpointer
6279 (FIELD) and entry pointer (FIELDP) for the dntt record corresponding to it,
6280 and the ubiquitous objfile parameter. (Note: FIELDP is a **.) Return value
6281 is a dnttpointer for the new field after all the skipped ones */
6284 hpread_get_next_skip_over_anon_unions (int skip_fields
, dnttpointer field
,
6285 union dnttentry
**fieldp
,
6286 struct objfile
*objfile
)
6288 struct type
*anon_type
;
6293 for (i
= 0; i
< skip_fields
; i
++)
6295 /* Get type of item we're looking at now; recursively processes the types
6296 of these intermediate items we skip over, so they aren't lost. */
6297 anon_type
= hpread_type_lookup ((*fieldp
)->dfield
.type
, objfile
);
6298 anon_type
= CHECK_TYPEDEF (anon_type
);
6299 bitoffset
= (*fieldp
)->dfield
.bitoffset
;
6300 name
= VT (objfile
) + (*fieldp
)->dfield
.name
;
6301 /* First skip over one item to avoid stack death on recursion */
6302 field
= (*fieldp
)->dfield
.nextfield
;
6303 *fieldp
= hpread_get_lntt (field
.dnttp
.index
, objfile
);
6304 /* Do we have another anonymous union? If so, adjust the bitoffsets
6305 of its members and skip over its members. */
6306 if ((TYPE_CODE (anon_type
) == TYPE_CODE_UNION
) &&
6307 (!name
|| STREQ (name
, "")))
6309 hpread_adjust_bitoffsets (anon_type
, bitoffset
);
6310 field
= hpread_get_next_skip_over_anon_unions (TYPE_NFIELDS (anon_type
), field
, fieldp
, objfile
);