1 /* Read hp debug symbols and convert to internal format, for GDB.
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.
22 Written by the Center for Software Science at the University of Utah
23 and by Cygnus Support. */
27 #include "gdb_string.h"
28 #include "hp-symtab.h"
34 #include "complaints.h"
35 #include "gdb-stabs.h"
39 /* Private information attached to an objfile which we use to find
40 and internalize the HP C debug symbols within that objfile. */
42 struct hpread_symfile_info
44 /* The contents of each of the debug sections (there are 4 of them). */
50 /* We keep the size of the $VT$ section for range checking. */
53 /* Some routines still need to know the number of symbols in the
54 main debug sections ($LNTT$ and $GNTT$). */
55 unsigned int lntt_symcount
;
56 unsigned int gntt_symcount
;
58 /* To keep track of all the types we've processed. */
59 struct type
**dntt_type_vector
;
60 int dntt_type_vector_length
;
62 /* Keeps track of the beginning of a range of source lines. */
65 /* Some state variables we'll need. */
68 /* Keep track of the current function's address. We may need to look
69 up something based on this address. */
70 unsigned int current_function_value
;
73 /* Accessor macros to get at the fields. */
74 #define HPUX_SYMFILE_INFO(o) \
75 ((struct hpread_symfile_info *)((o)->sym_private))
76 #define GNTT(o) (HPUX_SYMFILE_INFO(o)->gntt)
77 #define LNTT(o) (HPUX_SYMFILE_INFO(o)->lntt)
78 #define SLT(o) (HPUX_SYMFILE_INFO(o)->slt)
79 #define VT(o) (HPUX_SYMFILE_INFO(o)->vt)
80 #define VT_SIZE(o) (HPUX_SYMFILE_INFO(o)->vt_size)
81 #define LNTT_SYMCOUNT(o) (HPUX_SYMFILE_INFO(o)->lntt_symcount)
82 #define GNTT_SYMCOUNT(o) (HPUX_SYMFILE_INFO(o)->gntt_symcount)
83 #define DNTT_TYPE_VECTOR(o) (HPUX_SYMFILE_INFO(o)->dntt_type_vector)
84 #define DNTT_TYPE_VECTOR_LENGTH(o) \
85 (HPUX_SYMFILE_INFO(o)->dntt_type_vector_length)
86 #define SL_INDEX(o) (HPUX_SYMFILE_INFO(o)->sl_index)
87 #define WITHIN_FUNCTION(o) (HPUX_SYMFILE_INFO(o)->within_function)
88 #define CURRENT_FUNCTION_VALUE(o) (HPUX_SYMFILE_INFO(o)->current_function_value)
90 /* Given the native debug symbol SYM, set NAMEP to the name associated
91 with the debug symbol. Note we may be called with a debug symbol which
92 has no associated name, in that case we return an empty string.
94 Also note we "know" that the name for any symbol is always in the
95 same place. Hence we don't have to conditionalize on the symbol type. */
96 #define SET_NAMESTRING(SYM, NAMEP, OBJFILE) \
97 if (! hpread_has_name ((SYM)->dblock.kind)) \
99 else if (((unsigned)(SYM)->dsfile.name) >= VT_SIZE (OBJFILE)) \
101 complain (&string_table_offset_complaint, (char *) symnum); \
105 *NAMEP = (SYM)->dsfile.name + VT (OBJFILE)
107 /* We put a pointer to this structure in the read_symtab_private field
112 /* The offset within the file symbol table of first local symbol for
117 /* Length (in bytes) of the section of the symbol table devoted to
118 this file's symbols (actually, the section bracketed may contain
119 more than just this file's symbols). If ldsymlen is 0, the only
120 reason for this thing's existence is the dependency list.
121 Nothing else will happen when it is read in. */
126 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
127 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
128 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
130 /* FIXME: Shouldn't this stuff be in a .h file somewhere? */
131 /* Complaints about the symbols we have encountered. */
132 extern struct complaint string_table_offset_complaint
;
133 extern struct complaint lbrac_unmatched_complaint
;
134 extern struct complaint lbrac_mismatch_complaint
;
136 static struct complaint hpread_unhandled_end_common_complaint
=
138 "unhandled symbol in hp-symtab-read.c: DNTT_TYPE_COMMON/DNTT_TYPE_END.\n", 0, 0
141 static struct complaint hpread_unhandled_type_complaint
=
143 "hpread_type_translate: unhandled type code.", 0, 0
146 static struct complaint hpread_struct_complaint
=
148 "hpread_read_struct_type: expected SVAR type...", 0, 0
151 static struct complaint hpread_array_complaint
=
153 "error in hpread_array_type.", 0, 0
156 static struct complaint hpread_type_lookup_complaint
=
158 "error in hpread_type_lookup().", 0, 0
162 static struct complaint hpread_unexpected_end_complaint
=
164 "internal error in hp-symtab-read.c: Unexpected DNTT_TYPE_END kind.", 0, 0
167 static struct complaint hpread_tagdef_complaint
=
169 "error processing class tagdef", 0, 0
172 static struct complaint hpread_unhandled_common_complaint
=
174 "unhandled symbol in hp-symtab-read.c: DNTT_TYPE_COMMON.", 0, 0
177 static struct complaint hpread_unhandled_blockdata_complaint
=
179 "unhandled symbol in hp-symtab-read.c: DNTT_TYPE_BLOCKDATA.", 0, 0
182 /* To generate dumping code, uncomment this define. The dumping
183 itself is controlled by routine-local statics called "dumping". */
184 /* #define DUMPING 1 */
186 /* To use the quick look-up tables, uncomment this define. */
187 #define QUICK_LOOK_UP 1
189 /* To call PXDB to process un-processed files, uncomment this define. */
192 /* Forward procedure declarations */
194 void hpread_symfile_init (struct objfile
*);
196 void do_pxdb (bfd
*);
198 void hpread_build_psymtabs (struct objfile
*, int);
200 void hpread_symfile_finish (struct objfile
*);
202 static union dnttentry
*hpread_get_gntt (int, struct objfile
*);
204 static union dnttentry
*hpread_get_lntt (int index
, struct objfile
*objfile
);
207 static unsigned long hpread_get_textlow (int, int, struct objfile
*, int);
209 static struct partial_symtab
*hpread_start_psymtab
210 (struct objfile
*, char *, CORE_ADDR
, int,
211 struct partial_symbol
**, struct partial_symbol
**);
213 static struct partial_symtab
*hpread_end_psymtab
214 (struct partial_symtab
*, char **, int, int, CORE_ADDR
,
215 struct partial_symtab
**, int);
217 static unsigned long hpread_get_scope_start (sltpointer
, struct objfile
*);
219 static unsigned long hpread_get_line (sltpointer
, struct objfile
*);
221 static CORE_ADDR
hpread_get_location (sltpointer
, struct objfile
*);
223 static void hpread_psymtab_to_symtab_1 (struct partial_symtab
*);
225 void hpread_psymtab_to_symtab (struct partial_symtab
*);
227 static struct symtab
*hpread_expand_symtab
228 (struct objfile
*, int, int, CORE_ADDR
, int,
229 struct section_offsets
*, char *);
231 static int hpread_type_translate (dnttpointer
);
233 static struct type
**hpread_lookup_type (dnttpointer
, struct objfile
*);
235 static struct type
*hpread_alloc_type (dnttpointer
, struct objfile
*);
237 static struct type
*hpread_read_enum_type
238 (dnttpointer
, union dnttentry
*, struct objfile
*);
240 static struct type
*hpread_read_function_type
241 (dnttpointer
, union dnttentry
*, struct objfile
*, int);
243 static struct type
*hpread_read_doc_function_type
244 (dnttpointer
, union dnttentry
*, struct objfile
*, int);
246 static struct type
*hpread_read_struct_type
247 (dnttpointer
, union dnttentry
*, struct objfile
*);
249 static struct type
*hpread_get_nth_template_arg (struct objfile
*, int);
251 static struct type
*hpread_read_templ_arg_type
252 (dnttpointer
, union dnttentry
*, struct objfile
*, char *);
254 static struct type
*hpread_read_set_type
255 (dnttpointer
, union dnttentry
*, struct objfile
*);
257 static struct type
*hpread_read_array_type
258 (dnttpointer
, union dnttentry
*dn_bufp
, struct objfile
*objfile
);
260 static struct type
*hpread_read_subrange_type
261 (dnttpointer
, union dnttentry
*, struct objfile
*);
263 static struct type
*hpread_type_lookup (dnttpointer
, struct objfile
*);
265 static sltpointer hpread_record_lines
266 (struct subfile
*, sltpointer
, sltpointer
, struct objfile
*, CORE_ADDR
);
268 static void hpread_process_one_debug_symbol
269 (union dnttentry
*, char *, struct section_offsets
*,
270 struct objfile
*, CORE_ADDR
, int, char *, int, int *);
272 static int hpread_get_scope_depth (union dnttentry
*, struct objfile
*, int);
274 static void fix_static_member_physnames
275 (struct type
*, char *, struct objfile
*);
277 static void fixup_class_method_type
278 (struct type
*, struct type
*, struct objfile
*);
280 static void hpread_adjust_bitoffsets (struct type
*, int);
282 static dnttpointer hpread_get_next_skip_over_anon_unions
283 (int, dnttpointer
, union dnttentry
**, struct objfile
*);
286 /* Global to indicate presence of HP-compiled objects,
287 in particular, SOM executable file with SOM debug info
288 Defined in symtab.c, used in hppa-tdep.c. */
289 extern int hp_som_som_object_present
;
291 /* Static used to indicate a class type that requires a
292 fix-up of one of its method types */
293 static struct type
*fixup_class
= NULL
;
295 /* Static used to indicate the method type that is to be
296 used to fix-up the type for fixup_class */
297 static struct type
*fixup_method
= NULL
;
301 /* NOTE use of system files! May not be portable. */
303 #define PXDB_SVR4 "/opt/langtools/bin/pxdb"
304 #define PXDB_BSD "/usr/bin/pxdb"
307 #include "gdb_string.h"
309 /* check for the existence of a file, given its full pathname */
311 file_exists (char *filename
)
314 return (access (filename
, F_OK
) == 0);
319 /* Translate from the "hp_language" enumeration in hp-symtab.h
320 used in the debug info to gdb's generic enumeration in defs.h. */
322 trans_lang (enum hp_language in_lang
)
324 if (in_lang
== HP_LANGUAGE_C
)
327 else if (in_lang
== HP_LANGUAGE_CPLUSPLUS
)
328 return language_cplus
;
330 else if (in_lang
== HP_LANGUAGE_FORTRAN
)
331 return language_fortran
;
334 return language_unknown
;
337 static char main_string
[] = "main";
339 /* Call PXDB to process our file.
341 Approach copied from DDE's "dbgk_run_pxdb". Note: we
342 don't check for BSD location of pxdb, nor for existence
345 NOTE: uses system function and string functions directly.
347 Return value: 1 if ok, 0 if not */
349 hpread_call_pxdb (const char *file_name
)
355 if (file_exists (PXDB_SVR4
))
357 p
= xmalloc (strlen (PXDB_SVR4
) + strlen (file_name
) + 2);
358 strcpy (p
, PXDB_SVR4
);
360 strcat (p
, file_name
);
362 warning ("File not processed by pxdb--about to process now.\n");
365 retval
= (status
== 0);
369 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
);
374 } /* hpread_call_pxdb */
377 /* Return 1 if the file turns out to need pre-processing
378 by PXDB, and we have thus called PXDB to do this processing
379 and the file therefore needs to be re-loaded. Otherwise
382 hpread_pxdb_needed (bfd
*sym_bfd
)
384 asection
*pinfo_section
, *debug_section
, *header_section
;
385 unsigned int do_pxdb
;
387 bfd_size_type header_section_size
;
392 header_section
= bfd_get_section_by_name (sym_bfd
, "$HEADER$");
395 return 0; /* No header at all, can't recover... */
398 debug_section
= bfd_get_section_by_name (sym_bfd
, "$DEBUG$");
399 pinfo_section
= bfd_get_section_by_name (sym_bfd
, "$PINFO$");
401 if (pinfo_section
&& !debug_section
)
403 /* Debug info with DOC, has different header format.
404 this only happens if the file was pxdbed and compiled optimized
405 otherwise the PINFO section is not there. */
406 header_section_size
= bfd_section_size (objfile
->obfd
, header_section
);
408 if (header_section_size
== (bfd_size_type
) sizeof (DOC_info_PXDB_header
))
410 buf
= alloca (sizeof (DOC_info_PXDB_header
));
412 if (!bfd_get_section_contents (sym_bfd
,
415 header_section_size
))
416 error ("bfd_get_section_contents\n");
418 tmp
= bfd_get_32 (sym_bfd
, (bfd_byte
*) (buf
+ sizeof (int) * 4));
419 pxdbed
= (tmp
>> 31) & 0x1;
422 error ("file debug header info invalid\n");
427 error ("invalid $HEADER$ size in executable \n");
433 /* this can be three different cases:
434 1. pxdbed and not doc
435 - DEBUG and HEADER sections are there
436 - header is PXDB_header type
437 - pxdbed flag is set to 1
439 2. not pxdbed and doc
440 - DEBUG and HEADER sections are there
441 - header is DOC_info_header type
442 - pxdbed flag is set to 0
444 3. not pxdbed and not doc
445 - DEBUG and HEADER sections are there
446 - header is XDB_header type
447 - pxdbed flag is set to 0
449 NOTE: the pxdbed flag is meaningful also in the not
450 already pxdb processed version of the header,
451 because in case on non-already processed by pxdb files
452 that same bit in the header would be always zero.
453 Why? Because the bit is the leftmost bit of a word
454 which contains a 'length' which is always a positive value
455 so that bit is never set to 1 (otherwise it would be negative)
457 Given the above, we have two choices : either we ignore the
458 size of the header itself and just look at the pxdbed field,
459 or we check the size and then we (for safety and paranoia related
460 issues) check the bit.
461 The first solution is used by DDE, the second by PXDB itself.
462 I am using the second one here, because I already wrote it,
463 and it is the end of a long day.
464 Also, using the first approach would still involve size issues
465 because we need to read in the contents of the header section, and
466 give the correct amount of stuff we want to read to the
467 get_bfd_section_contents function. */
469 /* decide which case depending on the size of the header section.
470 The size is as defined in hp-symtab.h */
472 header_section_size
= bfd_section_size (objfile
->obfd
, header_section
);
474 if (header_section_size
== (bfd_size_type
) sizeof (PXDB_header
)) /* pxdb and not doc */
477 buf
= alloca (sizeof (PXDB_header
));
478 if (!bfd_get_section_contents (sym_bfd
,
481 header_section_size
))
482 error ("bfd_get_section_contents\n");
484 tmp
= bfd_get_32 (sym_bfd
, (bfd_byte
*) (buf
+ sizeof (int) * 3));
485 pxdbed
= (tmp
>> 31) & 0x1;
490 error ("file debug header invalid\n");
492 else /*not pxdbed and doc OR not pxdbed and non doc */
504 } /* hpread_pxdb_needed */
508 /* Check whether the file needs to be preprocessed by pxdb.
512 do_pxdb (bfd
*sym_bfd
)
514 /* The following code is HP-specific. The "right" way of
515 doing this is unknown, but we bet would involve a target-
516 specific pre-file-load check using a generic mechanism. */
518 /* This code will not be executed if the file is not in SOM
519 format (i.e. if compiled with gcc) */
520 if (hpread_pxdb_needed (sym_bfd
))
522 /*This file has not been pre-processed. Preprocess now */
524 if (hpread_call_pxdb (sym_bfd
->filename
))
526 /* The call above has changed the on-disk file,
527 we can close the file anyway, because the
528 symbols will be reread in when the target is run */
538 /* Code to handle quick lookup-tables follows. */
541 /* Some useful macros */
542 #define VALID_FILE(i) ((i) < pxdb_header_p->fd_entries)
543 #define VALID_MODULE(i) ((i) < pxdb_header_p->md_entries)
544 #define VALID_PROC(i) ((i) < pxdb_header_p->pd_entries)
545 #define VALID_CLASS(i) ((i) < pxdb_header_p->cd_entries)
547 #define FILE_START(i) (qFD[i].adrStart)
548 #define MODULE_START(i) (qMD[i].adrStart)
549 #define PROC_START(i) (qPD[i].adrStart)
551 #define FILE_END(i) (qFD[i].adrEnd)
552 #define MODULE_END(i) (qMD[i].adrEnd)
553 #define PROC_END(i) (qPD[i].adrEnd)
555 #define FILE_ISYM(i) (qFD[i].isym)
556 #define MODULE_ISYM(i) (qMD[i].isym)
557 #define PROC_ISYM(i) (qPD[i].isym)
559 #define VALID_CURR_FILE (curr_fd < pxdb_header_p->fd_entries)
560 #define VALID_CURR_MODULE (curr_md < pxdb_header_p->md_entries)
561 #define VALID_CURR_PROC (curr_pd < pxdb_header_p->pd_entries)
562 #define VALID_CURR_CLASS (curr_cd < pxdb_header_p->cd_entries)
564 #define CURR_FILE_START (qFD[curr_fd].adrStart)
565 #define CURR_MODULE_START (qMD[curr_md].adrStart)
566 #define CURR_PROC_START (qPD[curr_pd].adrStart)
568 #define CURR_FILE_END (qFD[curr_fd].adrEnd)
569 #define CURR_MODULE_END (qMD[curr_md].adrEnd)
570 #define CURR_PROC_END (qPD[curr_pd].adrEnd)
572 #define CURR_FILE_ISYM (qFD[curr_fd].isym)
573 #define CURR_MODULE_ISYM (qMD[curr_md].isym)
574 #define CURR_PROC_ISYM (qPD[curr_pd].isym)
576 #define TELL_OBJFILE \
578 if( !told_objfile ) { \
580 warning ("\nIn object file \"%s\":\n", \
587 /* Keeping track of the start/end symbol table (LNTT) indices of
588 psymtabs created so far */
597 static pst_syms_struct
*pst_syms_array
= 0;
599 static pst_syms_count
= 0;
600 static pst_syms_size
= 0;
602 /* used by the TELL_OBJFILE macro */
603 static boolean told_objfile
= 0;
605 /* Set up psymtab symbol index stuff */
611 pst_syms_array
= (pst_syms_struct
*) xmalloc (20 * sizeof (pst_syms_struct
));
614 /* Clean up psymtab symbol index stuff */
616 clear_pst_syms (void)
620 xfree (pst_syms_array
);
624 /* Add information about latest psymtab to symbol index table */
626 record_pst_syms (int start_sym
, int end_sym
)
628 if (++pst_syms_count
> pst_syms_size
)
630 pst_syms_array
= (pst_syms_struct
*) xrealloc (pst_syms_array
,
631 2 * pst_syms_size
* sizeof (pst_syms_struct
));
634 pst_syms_array
[pst_syms_count
- 1].start
= start_sym
;
635 pst_syms_array
[pst_syms_count
- 1].end
= end_sym
;
638 /* Find a suitable symbol table index which can serve as the upper
639 bound of a psymtab that starts at INDEX
641 This scans backwards in the psymtab symbol index table to find a
642 "hole" in which the given index can fit. This is a heuristic!!
643 We don't search the entire table to check for multiple holes,
644 we don't care about overlaps, etc.
646 Return 0 => not found */
648 find_next_pst_start (int index
)
652 for (i
= pst_syms_count
- 1; i
>= 0; i
--)
653 if (pst_syms_array
[i
].end
<= index
)
654 return (i
== pst_syms_count
- 1) ? 0 : pst_syms_array
[i
+ 1].start
- 1;
656 if (pst_syms_array
[0].start
> index
)
657 return pst_syms_array
[0].start
- 1;
664 /* Utility functions to find the ending symbol index for a psymtab */
666 /* Find the next file entry that begins beyond INDEX, and return
667 its starting symbol index - 1.
668 QFD is the file table, CURR_FD is the file entry from where to start,
669 PXDB_HEADER_P as in hpread_quick_traverse (to allow macros to work).
671 Return 0 => not found */
673 find_next_file_isym (int index
, quick_file_entry
*qFD
, int curr_fd
,
674 PXDB_header_ptr pxdb_header_p
)
676 while (VALID_CURR_FILE
)
678 if (CURR_FILE_ISYM
>= index
)
679 return CURR_FILE_ISYM
- 1;
685 /* Find the next procedure entry that begins beyond INDEX, and return
686 its starting symbol index - 1.
687 QPD is the procedure table, CURR_PD is the proc entry from where to start,
688 PXDB_HEADER_P as in hpread_quick_traverse (to allow macros to work).
690 Return 0 => not found */
692 find_next_proc_isym (int index
, quick_procedure_entry
*qPD
, int curr_pd
,
693 PXDB_header_ptr pxdb_header_p
)
695 while (VALID_CURR_PROC
)
697 if (CURR_PROC_ISYM
>= index
)
698 return CURR_PROC_ISYM
- 1;
704 /* Find the next module entry that begins beyond INDEX, and return
705 its starting symbol index - 1.
706 QMD is the module table, CURR_MD is the modue entry from where to start,
707 PXDB_HEADER_P as in hpread_quick_traverse (to allow macros to work).
709 Return 0 => not found */
711 find_next_module_isym (int index
, quick_module_entry
*qMD
, int curr_md
,
712 PXDB_header_ptr pxdb_header_p
)
714 while (VALID_CURR_MODULE
)
716 if (CURR_MODULE_ISYM
>= index
)
717 return CURR_MODULE_ISYM
- 1;
723 /* Scan and record partial symbols for all functions starting from index
724 pointed to by CURR_PD_P, and between code addresses START_ADR and END_ADR.
725 Other parameters are explained in comments below. */
727 /* This used to be inline in hpread_quick_traverse, but now that we do
728 essentially the same thing for two different cases (modules and
729 module-less files), it's better organized in a separate routine,
730 although it does take lots of arguments. pai/1997-10-08
732 CURR_PD_P is the pointer to the current proc index. QPD is the
733 procedure quick lookup table. MAX_PROCS is the number of entries
734 in the proc. table. START_ADR is the beginning of the code range
735 for the current psymtab. end_adr is the end of the code range for
736 the current psymtab. PST is the current psymtab. VT_bits is
737 a pointer to the strings table of SOM debug space. OBJFILE is
738 the current object file. */
741 scan_procs (int *curr_pd_p
, quick_procedure_entry
*qPD
, int max_procs
,
742 CORE_ADDR start_adr
, CORE_ADDR end_adr
, struct partial_symtab
*pst
,
743 char *vt_bits
, struct objfile
*objfile
)
745 union dnttentry
*dn_bufp
;
746 int symbol_count
= 0; /* Total number of symbols in this psymtab */
747 int curr_pd
= *curr_pd_p
; /* Convenience variable -- avoid dereferencing pointer all the time */
750 /* Turn this on for lots of debugging information in this routine */
751 static int dumping
= 0;
757 printf ("Scan_procs called, addresses %x to %x, proc %x\n", start_adr
, end_adr
, curr_pd
);
761 while ((CURR_PROC_START
<= end_adr
) && (curr_pd
< max_procs
))
764 char *rtn_name
; /* mangled name */
765 char *rtn_dem_name
; /* qualified demangled name */
769 if ((trans_lang ((enum hp_language
) qPD
[curr_pd
].language
) == language_cplus
) &&
770 vt_bits
[(long) qPD
[curr_pd
].sbAlias
]) /* not a null string */
772 /* Get mangled name for the procedure, and demangle it */
773 rtn_name
= &vt_bits
[(long) qPD
[curr_pd
].sbAlias
];
774 rtn_dem_name
= cplus_demangle (rtn_name
, DMGL_ANSI
| DMGL_PARAMS
);
778 rtn_name
= &vt_bits
[(long) qPD
[curr_pd
].sbProc
];
782 /* Hack to get around HP C/C++ compilers' insistence on providing
783 "_MAIN_" as an alternate name for "main" */
784 if ((strcmp (rtn_name
, "_MAIN_") == 0) &&
785 (strcmp (&vt_bits
[(long) qPD
[curr_pd
].sbProc
], "main") == 0))
786 rtn_dem_name
= rtn_name
= main_string
;
791 printf ("..add %s (demangled %s), index %x to this psymtab\n", rtn_name
, rtn_dem_name
, curr_pd
);
795 /* Check for module-spanning routines. */
796 if (CURR_PROC_END
> end_adr
)
799 warning ("Procedure \"%s\" [0x%x] spans file or module boundaries.", rtn_name
, curr_pd
);
802 /* Add this routine symbol to the list in the objfile.
803 Unfortunately we have to go to the LNTT to determine the
804 correct list to put it on. An alternative (which the
805 code used to do) would be to not check and always throw
806 it on the "static" list. But if we go that route, then
807 symbol_lookup() needs to be tweaked a bit to account
808 for the fact that the function might not be found on
809 the correct list in the psymtab. - RT */
810 dn_bufp
= hpread_get_lntt (qPD
[curr_pd
].isym
, objfile
);
811 if (dn_bufp
->dfunc
.global
)
812 add_psymbol_with_dem_name_to_list (rtn_name
,
815 strlen (rtn_dem_name
),
817 LOC_BLOCK
, /* "I am a routine" */
818 &objfile
->global_psymbols
,
819 (qPD
[curr_pd
].adrStart
+ /* Starting address of rtn */
820 ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
))),
822 trans_lang ((enum hp_language
) qPD
[curr_pd
].language
),
825 add_psymbol_with_dem_name_to_list (rtn_name
,
828 strlen (rtn_dem_name
),
830 LOC_BLOCK
, /* "I am a routine" */
831 &objfile
->static_psymbols
,
832 (qPD
[curr_pd
].adrStart
+ /* Starting address of rtn */
833 ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
))),
835 trans_lang ((enum hp_language
) qPD
[curr_pd
].language
),
839 *curr_pd_p
= ++curr_pd
; /* bump up count & reflect in caller */
840 } /* loop over procedures */
845 if (symbol_count
== 0)
846 printf ("Scan_procs: no symbols found!\n");
854 /* Traverse the quick look-up tables, building a set of psymtabs.
856 This constructs a psymtab for modules and files in the quick lookup
859 Mostly, modules correspond to compilation units, so we try to
860 create psymtabs that correspond to modules; however, in some cases
861 a file can result in a compiled object which does not have a module
862 entry for it, so in such cases we create a psymtab for the file. */
865 hpread_quick_traverse (struct objfile
*objfile
, char *gntt_bits
,
866 char *vt_bits
, PXDB_header_ptr pxdb_header_p
)
868 struct partial_symtab
*pst
;
872 quick_procedure_entry
*qPD
;
873 quick_file_entry
*qFD
;
874 quick_module_entry
*qMD
;
875 quick_class_entry
*qCD
;
879 CORE_ADDR start_adr
; /* current psymtab's starting code addr */
880 CORE_ADDR end_adr
; /* current psymtab's ending code addr */
881 CORE_ADDR next_mod_adr
; /* next module's starting code addr */
882 int curr_pd
; /* current procedure */
883 int curr_fd
; /* current file */
884 int curr_md
; /* current module */
885 int start_sym
; /* current psymtab's starting symbol index */
886 int end_sym
; /* current psymtab's ending symbol index */
887 int max_LNTT_sym_index
;
889 B_TYPE
*class_entered
;
891 struct partial_symbol
**global_syms
; /* We'll be filling in the "global" */
892 struct partial_symbol
**static_syms
; /* and "static" tables in the objfile
893 as we go, so we need a pair of
897 /* Turn this on for lots of debugging information in this routine.
898 You get a blow-by-blow account of quick lookup table reading */
899 static int dumping
= 0;
902 pst
= (struct partial_symtab
*) 0;
904 /* Clear out some globals */
908 /* Demangling style -- if EDG style already set, don't change it,
909 as HP style causes some problems with the KAI EDG compiler */
910 if (current_demangling_style
!= edg_demangling
)
912 /* Otherwise, ensure that we are using HP style demangling */
913 set_demangling_style (HP_DEMANGLING_STYLE_STRING
);
916 /* First we need to find the starting points of the quick
917 look-up tables in the GNTT. */
921 qPD
= (quick_procedure_entry_ptr
) addr
;
922 addr
+= pxdb_header_p
->pd_entries
* sizeof (quick_procedure_entry
);
927 printf ("\n Printing routines as we see them\n");
928 for (i
= 0; VALID_PROC (i
); i
++)
930 idx
= (long) qPD
[i
].sbProc
;
931 printf ("%s %x..%x\n", &vt_bits
[idx
],
932 (int) PROC_START (i
),
938 qFD
= (quick_file_entry_ptr
) addr
;
939 addr
+= pxdb_header_p
->fd_entries
* sizeof (quick_file_entry
);
944 printf ("\n Printing files as we see them\n");
945 for (i
= 0; VALID_FILE (i
); i
++)
947 idx
= (long) qFD
[i
].sbFile
;
948 printf ("%s %x..%x\n", &vt_bits
[idx
],
949 (int) FILE_START (i
),
955 qMD
= (quick_module_entry_ptr
) addr
;
956 addr
+= pxdb_header_p
->md_entries
* sizeof (quick_module_entry
);
961 printf ("\n Printing modules as we see them\n");
962 for (i
= 0; i
< pxdb_header_p
->md_entries
; i
++)
964 idx
= (long) qMD
[i
].sbMod
;
965 printf ("%s\n", &vt_bits
[idx
]);
970 qCD
= (quick_class_entry_ptr
) addr
;
971 addr
+= pxdb_header_p
->cd_entries
* sizeof (quick_class_entry
);
976 printf ("\n Printing classes as we see them\n");
977 for (i
= 0; VALID_CLASS (i
); i
++)
979 idx
= (long) qCD
[i
].sbClass
;
980 printf ("%s\n", &vt_bits
[idx
]);
983 printf ("\n Done with dump, on to build!\n");
987 /* We need this index only while hp-symtab-read.c expects
988 a byte offset to the end of the LNTT entries for a given
989 psymtab. Thus the need for it should go away someday.
991 When it goes away, then we won't have any need to load the
992 LNTT from the objfile at psymtab-time, and start-up will be
993 faster. To make that work, we'll need some way to create
994 a null pst for the "globals" pseudo-module. */
995 max_LNTT_sym_index
= LNTT_SYMCOUNT (objfile
);
997 /* Scan the module descriptors and make a psymtab for each.
999 We know the MDs, FDs and the PDs are in order by starting
1000 address. We use that fact to traverse all three arrays in
1001 parallel, knowing when the next PD is in a new file
1002 and we need to create a new psymtab. */
1003 curr_pd
= 0; /* Current procedure entry */
1004 curr_fd
= 0; /* Current file entry */
1005 curr_md
= 0; /* Current module entry */
1007 start_adr
= 0; /* Current psymtab code range */
1010 start_sym
= 0; /* Current psymtab symbol range */
1013 syms_in_pst
= 0; /* Symbol count for psymtab */
1015 /* Psts actually just have pointers into the objfile's
1016 symbol table, not their own symbol tables. */
1017 global_syms
= objfile
->global_psymbols
.list
;
1018 static_syms
= objfile
->static_psymbols
.list
;
1021 /* First skip over pseudo-entries with address 0. These represent inlined
1022 routines and abstract (uninstantiated) template routines.
1023 FIXME: These should be read in and available -- even if we can't set
1024 breakpoints, etc., there's some information that can be presented
1025 to the user. pai/1997-10-08 */
1027 while (VALID_CURR_PROC
&& (CURR_PROC_START
== 0))
1030 /* Loop over files, modules, and procedures in code address order. Each
1031 time we enter an iteration of this loop, curr_pd points to the first
1032 unprocessed procedure, curr_fd points to the first unprocessed file, and
1033 curr_md to the first unprocessed module. Each iteration of this loop
1034 updates these as required -- any or all of them may be bumpd up
1035 each time around. When we exit this loop, we are done with all files
1036 and modules in the tables -- there may still be some procedures, however.
1038 Note: This code used to loop only over module entries, under the assumption
1039 that files can occur via inclusions and are thus unreliable, while a
1040 compiled object always corresponds to a module. With CTTI in the HP aCC
1041 compiler, it turns out that compiled objects may have only files and no
1042 modules; so we have to loop over files and modules, creating psymtabs for
1043 either as appropriate. Unfortunately there are some problems (notably:
1044 1. the lack of "SRC_FILE_END" entries in the LNTT, 2. the lack of pointers
1045 to the ending symbol indices of a module or a file) which make it quite hard
1046 to do this correctly. Currently it uses a bunch of heuristics to start and
1047 end psymtabs; they seem to work well with most objects generated by aCC, but
1048 who knows when that will change... */
1050 while (VALID_CURR_FILE
|| VALID_CURR_MODULE
)
1053 char *mod_name_string
;
1054 char *full_name_string
;
1056 /* First check for modules like "version.c", which have no code
1057 in them but still have qMD entries. They also have no qFD or
1058 qPD entries. Their start address is -1 and their end address
1060 if (VALID_CURR_MODULE
&& (CURR_MODULE_START
== -1) && (CURR_MODULE_END
== 0))
1063 mod_name_string
= &vt_bits
[(long) qMD
[curr_md
].sbMod
];
1067 printf ("Module with data only %s\n", mod_name_string
);
1070 /* We'll skip the rest (it makes error-checking easier), and
1071 just make an empty pst. Right now empty psts are not put
1072 in the pst chain, so all this is for naught, but later it
1075 pst
= hpread_start_psymtab (objfile
,
1077 CURR_MODULE_START
, /* Low text address: bogus! */
1078 (CURR_MODULE_ISYM
* sizeof (struct dntt_type_block
)),
1083 pst
= hpread_end_psymtab (pst
,
1084 NULL
, /* psymtab_include_list */
1085 0, /* includes_used */
1086 end_sym
* sizeof (struct dntt_type_block
),
1087 /* byte index in LNTT of end
1088 = capping symbol offset
1089 = LDSYMOFF of nextfile */
1091 NULL
, /* dependency_list */
1092 0); /* dependencies_used */
1094 global_syms
= objfile
->global_psymbols
.next
;
1095 static_syms
= objfile
->static_psymbols
.next
;
1099 else if (VALID_CURR_MODULE
&&
1100 ((CURR_MODULE_START
== 0) || (CURR_MODULE_START
== -1) ||
1101 (CURR_MODULE_END
== 0) || (CURR_MODULE_END
== -1)))
1104 warning ("Module \"%s\" [0x%s] has non-standard addresses. It starts at 0x%s, ends at 0x%s, and will be skipped.",
1105 mod_name_string
, paddr_nz (curr_md
), paddr_nz (start_adr
), paddr_nz (end_adr
));
1106 /* On to next module */
1111 /* First check if we are looking at a file with code in it
1112 that does not overlap the current module's code range */
1114 if (VALID_CURR_FILE
? (VALID_CURR_MODULE
? (CURR_FILE_END
< CURR_MODULE_START
) : 1) : 0)
1117 /* Looking at file not corresponding to any module,
1118 create a psymtab for it */
1119 full_name_string
= &vt_bits
[(long) qFD
[curr_fd
].sbFile
];
1120 start_adr
= CURR_FILE_START
;
1121 end_adr
= CURR_FILE_END
;
1122 start_sym
= CURR_FILE_ISYM
;
1124 /* Check if there are any procedures not handled until now, that
1125 begin before the start address of this file, and if so, adjust
1126 this module's start address to include them. This handles routines that
1127 are in between file or module ranges for some reason (probably
1128 indicates a compiler bug */
1130 if (CURR_PROC_START
< start_adr
)
1133 warning ("Found procedure \"%s\" [0x%x] that is not in any file or module.",
1134 &vt_bits
[(long) qPD
[curr_pd
].sbProc
], curr_pd
);
1135 start_adr
= CURR_PROC_START
;
1136 if (CURR_PROC_ISYM
< start_sym
)
1137 start_sym
= CURR_PROC_ISYM
;
1140 /* Sometimes (compiler bug -- COBOL) the module end address is higher
1141 than the start address of the next module, so check for that and
1142 adjust accordingly */
1144 if (VALID_FILE (curr_fd
+ 1) && (FILE_START (curr_fd
+ 1) <= end_adr
))
1147 warning ("File \"%s\" [0x%x] has ending address after starting address of next file; adjusting ending address down.",
1148 full_name_string
, curr_fd
);
1149 end_adr
= FILE_START (curr_fd
+ 1) - 1; /* Is -4 (or -8 for 64-bit) better? */
1151 if (VALID_MODULE (curr_md
) && (CURR_MODULE_START
<= end_adr
))
1154 warning ("File \"%s\" [0x%x] has ending address after starting address of next module; adjusting ending address down.",
1155 full_name_string
, curr_fd
);
1156 end_adr
= CURR_MODULE_START
- 1; /* Is -4 (or -8 for 64-bit) better? */
1163 printf ("Make new psymtab for file %s (%x to %x).\n",
1164 full_name_string
, start_adr
, end_adr
);
1167 /* Create the basic psymtab, connecting it in the list
1168 for this objfile and pointing its symbol entries
1169 to the current end of the symbol areas in the objfile.
1171 The "ldsymoff" parameter is the byte offset in the LNTT
1172 of the first symbol in this file. Some day we should
1173 turn this into an index (fix in hp-symtab-read.c as well).
1174 And it's not even the right byte offset, as we're using
1175 the size of a union! FIXME! */
1176 pst
= hpread_start_psymtab (objfile
,
1178 start_adr
, /* Low text address */
1179 (start_sym
* sizeof (struct dntt_type_block
)),
1184 /* Set up to only enter each class referenced in this module once. */
1185 class_entered
= xmalloc (B_BYTES (pxdb_header_p
->cd_entries
));
1186 B_CLRALL (class_entered
, pxdb_header_p
->cd_entries
);
1188 /* Scan the procedure descriptors for procedures in the current
1189 file, based on the starting addresses. */
1191 syms_in_pst
= scan_procs (&curr_pd
, qPD
, pxdb_header_p
->pd_entries
,
1192 start_adr
, end_adr
, pst
, vt_bits
, objfile
);
1194 /* Get ending symbol offset */
1197 /* First check for starting index before previous psymtab */
1198 if (pst_syms_count
&& start_sym
< pst_syms_array
[pst_syms_count
- 1].end
)
1200 end_sym
= find_next_pst_start (start_sym
);
1202 /* Look for next start index of a file or module, or procedure */
1205 int next_file_isym
= find_next_file_isym (start_sym
, qFD
, curr_fd
+ 1, pxdb_header_p
);
1206 int next_module_isym
= find_next_module_isym (start_sym
, qMD
, curr_md
, pxdb_header_p
);
1207 int next_proc_isym
= find_next_proc_isym (start_sym
, qPD
, curr_pd
, pxdb_header_p
);
1209 if (next_file_isym
&& next_module_isym
)
1211 /* pick lower of next file or module start index */
1212 end_sym
= min (next_file_isym
, next_module_isym
);
1216 /* one of them is zero, pick the other */
1217 end_sym
= max (next_file_isym
, next_module_isym
);
1220 /* As a precaution, check next procedure index too */
1222 end_sym
= next_proc_isym
;
1224 end_sym
= min (end_sym
, next_proc_isym
);
1227 /* Couldn't find procedure, file, or module, use globals as default */
1229 end_sym
= pxdb_header_p
->globals
;
1234 printf ("File psymtab indices: %x to %x\n", start_sym
, end_sym
);
1238 pst
= hpread_end_psymtab (pst
,
1239 NULL
, /* psymtab_include_list */
1240 0, /* includes_used */
1241 end_sym
* sizeof (struct dntt_type_block
),
1242 /* byte index in LNTT of end
1243 = capping symbol offset
1244 = LDSYMOFF of nextfile */
1245 end_adr
, /* text high */
1246 NULL
, /* dependency_list */
1247 0); /* dependencies_used */
1249 record_pst_syms (start_sym
, end_sym
);
1252 warning ("No symbols in psymtab for file \"%s\" [0x%x].", full_name_string
, curr_fd
);
1257 printf ("Made new psymtab for file %s (%x to %x), sym %x to %x.\n",
1258 full_name_string
, start_adr
, end_adr
, CURR_FILE_ISYM
, end_sym
);
1261 /* Prepare for the next psymtab. */
1262 global_syms
= objfile
->global_psymbols
.next
;
1263 static_syms
= objfile
->static_psymbols
.next
;
1264 xfree (class_entered
);
1267 } /* Psymtab for file */
1270 /* We have a module for which we create a psymtab */
1272 mod_name_string
= &vt_bits
[(long) qMD
[curr_md
].sbMod
];
1274 /* We will include the code ranges of any files that happen to
1275 overlap with this module */
1277 /* So, first pick the lower of the file's and module's start addresses */
1278 start_adr
= CURR_MODULE_START
;
1279 if (VALID_CURR_FILE
)
1281 if (CURR_FILE_START
< CURR_MODULE_START
)
1284 warning ("File \"%s\" [0x%x] crosses beginning of module \"%s\".",
1285 &vt_bits
[(long) qFD
[curr_fd
].sbFile
],
1286 curr_fd
, mod_name_string
);
1288 start_adr
= CURR_FILE_START
;
1292 /* Also pick the lower of the file's and the module's start symbol indices */
1293 start_sym
= CURR_MODULE_ISYM
;
1294 if (VALID_CURR_FILE
&& (CURR_FILE_ISYM
< CURR_MODULE_ISYM
))
1295 start_sym
= CURR_FILE_ISYM
;
1297 /* For the end address, we scan through the files till we find one
1298 that overlaps the current module but ends beyond it; if no such file exists we
1299 simply use the module's start address.
1300 (Note, if file entries themselves overlap
1301 we take the longest overlapping extension beyond the end of the module...)
1302 We assume that modules never overlap. */
1304 end_adr
= CURR_MODULE_END
;
1306 if (VALID_CURR_FILE
)
1308 while (VALID_CURR_FILE
&& (CURR_FILE_START
< end_adr
))
1313 printf ("Maybe skipping file %s which overlaps with module %s\n",
1314 &vt_bits
[(long) qFD
[curr_fd
].sbFile
], mod_name_string
);
1316 if (CURR_FILE_END
> end_adr
)
1319 warning ("File \"%s\" [0x%x] crosses end of module \"%s\".",
1320 &vt_bits
[(long) qFD
[curr_fd
].sbFile
],
1321 curr_fd
, mod_name_string
);
1322 end_adr
= CURR_FILE_END
;
1326 curr_fd
--; /* back up after going too far */
1329 /* Sometimes (compiler bug -- COBOL) the module end address is higher
1330 than the start address of the next module, so check for that and
1331 adjust accordingly */
1333 if (VALID_MODULE (curr_md
+ 1) && (MODULE_START (curr_md
+ 1) <= end_adr
))
1336 warning ("Module \"%s\" [0x%x] has ending address after starting address of next module; adjusting ending address down.",
1337 mod_name_string
, curr_md
);
1338 end_adr
= MODULE_START (curr_md
+ 1) - 1; /* Is -4 (or -8 for 64-bit) better? */
1340 if (VALID_FILE (curr_fd
+ 1) && (FILE_START (curr_fd
+ 1) <= end_adr
))
1343 warning ("Module \"%s\" [0x%x] has ending address after starting address of next file; adjusting ending address down.",
1344 mod_name_string
, curr_md
);
1345 end_adr
= FILE_START (curr_fd
+ 1) - 1; /* Is -4 (or -8 for 64-bit) better? */
1348 /* Use one file to get the full name for the module. This
1349 situation can arise if there is executable code in a #include
1350 file. Each file with code in it gets a qFD. Files which don't
1351 contribute code don't get a qFD, even if they include files
1356 #include "rtn.h" return x;
1359 There will a qFD for "rtn.h",and a qMD for "body.c",
1360 but no qMD for "rtn.h" or qFD for "body.c"!
1362 We pick the name of the last file to overlap with this
1363 module. C convention is to put include files first. In a
1364 perfect world, we could check names and use the file whose full
1365 path name ends with the module name. */
1367 if (VALID_CURR_FILE
)
1368 full_name_string
= &vt_bits
[(long) qFD
[curr_fd
].sbFile
];
1370 full_name_string
= mod_name_string
;
1372 /* Check if there are any procedures not handled until now, that
1373 begin before the start address we have now, and if so, adjust
1374 this psymtab's start address to include them. This handles routines that
1375 are in between file or module ranges for some reason (probably
1376 indicates a compiler bug */
1378 if (CURR_PROC_START
< start_adr
)
1381 warning ("Found procedure \"%s\" [0x%x] that is not in any file or module.",
1382 &vt_bits
[(long) qPD
[curr_pd
].sbProc
], curr_pd
);
1383 start_adr
= CURR_PROC_START
;
1384 if (CURR_PROC_ISYM
< start_sym
)
1385 start_sym
= CURR_PROC_ISYM
;
1391 printf ("Make new psymtab for module %s (%x to %x), using file %s\n",
1392 mod_name_string
, start_adr
, end_adr
, full_name_string
);
1395 /* Create the basic psymtab, connecting it in the list
1396 for this objfile and pointing its symbol entries
1397 to the current end of the symbol areas in the objfile.
1399 The "ldsymoff" parameter is the byte offset in the LNTT
1400 of the first symbol in this file. Some day we should
1401 turn this into an index (fix in hp-symtab-read.c as well).
1402 And it's not even the right byte offset, as we're using
1403 the size of a union! FIXME! */
1404 pst
= hpread_start_psymtab (objfile
,
1406 start_adr
, /* Low text address */
1407 (start_sym
* sizeof (struct dntt_type_block
)),
1412 /* Set up to only enter each class referenced in this module once. */
1413 class_entered
= xmalloc (B_BYTES (pxdb_header_p
->cd_entries
));
1414 B_CLRALL (class_entered
, pxdb_header_p
->cd_entries
);
1416 /* Scan the procedure descriptors for procedures in the current
1417 module, based on the starting addresses. */
1419 syms_in_pst
= scan_procs (&curr_pd
, qPD
, pxdb_header_p
->pd_entries
,
1420 start_adr
, end_adr
, pst
, vt_bits
, objfile
);
1422 /* Get ending symbol offset */
1425 /* First check for starting index before previous psymtab */
1426 if (pst_syms_count
&& start_sym
< pst_syms_array
[pst_syms_count
- 1].end
)
1428 end_sym
= find_next_pst_start (start_sym
);
1430 /* Look for next start index of a file or module, or procedure */
1433 int next_file_isym
= find_next_file_isym (start_sym
, qFD
, curr_fd
+ 1, pxdb_header_p
);
1434 int next_module_isym
= find_next_module_isym (start_sym
, qMD
, curr_md
+ 1, pxdb_header_p
);
1435 int next_proc_isym
= find_next_proc_isym (start_sym
, qPD
, curr_pd
, pxdb_header_p
);
1437 if (next_file_isym
&& next_module_isym
)
1439 /* pick lower of next file or module start index */
1440 end_sym
= min (next_file_isym
, next_module_isym
);
1444 /* one of them is zero, pick the other */
1445 end_sym
= max (next_file_isym
, next_module_isym
);
1448 /* As a precaution, check next procedure index too */
1450 end_sym
= next_proc_isym
;
1452 end_sym
= min (end_sym
, next_proc_isym
);
1455 /* Couldn't find procedure, file, or module, use globals as default */
1457 end_sym
= pxdb_header_p
->globals
;
1462 printf ("Module psymtab indices: %x to %x\n", start_sym
, end_sym
);
1466 pst
= hpread_end_psymtab (pst
,
1467 NULL
, /* psymtab_include_list */
1468 0, /* includes_used */
1469 end_sym
* sizeof (struct dntt_type_block
),
1470 /* byte index in LNTT of end
1471 = capping symbol offset
1472 = LDSYMOFF of nextfile */
1473 end_adr
, /* text high */
1474 NULL
, /* dependency_list */
1475 0); /* dependencies_used */
1477 record_pst_syms (start_sym
, end_sym
);
1480 warning ("No symbols in psymtab for module \"%s\" [0x%x].", mod_name_string
, curr_md
);
1485 printf ("Made new psymtab for module %s (%x to %x), sym %x to %x.\n",
1486 mod_name_string
, start_adr
, end_adr
, CURR_MODULE_ISYM
, end_sym
);
1490 /* Prepare for the next psymtab. */
1491 global_syms
= objfile
->global_psymbols
.next
;
1492 static_syms
= objfile
->static_psymbols
.next
;
1493 xfree (class_entered
);
1497 } /* psymtab for module */
1498 } /* psymtab for non-bogus file or module */
1499 } /* End of while loop over all files & modules */
1501 /* There may be some routines after all files and modules -- these will get
1502 inserted in a separate new module of their own */
1503 if (VALID_CURR_PROC
)
1505 start_adr
= CURR_PROC_START
;
1506 end_adr
= qPD
[pxdb_header_p
->pd_entries
- 1].adrEnd
;
1508 warning ("Found functions beyond end of all files and modules [0x%x].", curr_pd
);
1512 printf ("Orphan functions at end, PD %d and beyond (%x to %x)\n",
1513 curr_pd
, start_adr
, end_adr
);
1516 pst
= hpread_start_psymtab (objfile
,
1518 start_adr
, /* Low text address */
1519 (CURR_PROC_ISYM
* sizeof (struct dntt_type_block
)),
1524 scan_procs (&curr_pd
, qPD
, pxdb_header_p
->pd_entries
,
1525 start_adr
, end_adr
, pst
, vt_bits
, objfile
);
1527 pst
= hpread_end_psymtab (pst
,
1528 NULL
, /* psymtab_include_list */
1529 0, /* includes_used */
1530 pxdb_header_p
->globals
* sizeof (struct dntt_type_block
),
1531 /* byte index in LNTT of end
1532 = capping symbol offset
1533 = LDSYMOFF of nextfile */
1534 end_adr
, /* text high */
1535 NULL
, /* dependency_list */
1536 0); /* dependencies_used */
1541 /* Now build psts for non-module things (in the tail of
1542 the LNTT, after the last END MODULE entry).
1544 If null psts were kept on the chain, this would be
1545 a solution. FIXME */
1546 pst
= hpread_start_psymtab (objfile
,
1549 (pxdb_header_p
->globals
1550 * sizeof (struct dntt_type_block
)),
1551 objfile
->global_psymbols
.next
,
1552 objfile
->static_psymbols
.next
);
1553 hpread_end_psymtab (pst
,
1555 (max_LNTT_sym_index
* sizeof (struct dntt_type_block
)),
1564 } /* End of hpread_quick_traverse. */
1567 /* Get appropriate header, based on pxdb type.
1568 Return value: 1 if ok, 0 if not */
1570 hpread_get_header (struct objfile
*objfile
, PXDB_header_ptr pxdb_header_p
)
1572 asection
*pinfo_section
, *debug_section
, *header_section
;
1575 /* Turn on for debugging information */
1576 static int dumping
= 0;
1579 header_section
= bfd_get_section_by_name (objfile
->obfd
, "$HEADER$");
1580 if (!header_section
)
1582 /* We don't have either PINFO or DEBUG sections. But
1583 stuff like "libc.sl" has no debug info. There's no
1584 need to warn the user of this, as it may be ok. The
1585 caller will figure it out and issue any needed
1589 printf ("==No debug info at all for %s.\n", objfile
->name
);
1595 /* We would like either a $DEBUG$ or $PINFO$ section.
1596 Once we know which, we can understand the header
1597 data (which we have defined to suit the more common
1599 debug_section
= bfd_get_section_by_name (objfile
->obfd
, "$DEBUG$");
1600 pinfo_section
= bfd_get_section_by_name (objfile
->obfd
, "$PINFO$");
1603 /* The expected case: normal pxdb header. */
1604 bfd_get_section_contents (objfile
->obfd
, header_section
,
1605 pxdb_header_p
, 0, sizeof (PXDB_header
));
1607 if (!pxdb_header_p
->pxdbed
)
1609 /* This shouldn't happen if we check in "symfile.c". */
1611 } /* DEBUG section */
1614 else if (pinfo_section
)
1616 /* The DOC case; we need to translate this into a
1618 DOC_info_PXDB_header doc_header
;
1623 printf ("==OOps, PINFO, let's try to handle this, %s.\n", objfile
->name
);
1627 bfd_get_section_contents (objfile
->obfd
,
1630 sizeof (DOC_info_PXDB_header
));
1632 if (!doc_header
.pxdbed
)
1634 /* This shouldn't happen if we check in "symfile.c". */
1635 warning ("File \"%s\" not processed by pxdb!", objfile
->name
);
1639 /* Copy relevent fields to standard header passed in. */
1640 pxdb_header_p
->pd_entries
= doc_header
.pd_entries
;
1641 pxdb_header_p
->fd_entries
= doc_header
.fd_entries
;
1642 pxdb_header_p
->md_entries
= doc_header
.md_entries
;
1643 pxdb_header_p
->pxdbed
= doc_header
.pxdbed
;
1644 pxdb_header_p
->bighdr
= doc_header
.bighdr
;
1645 pxdb_header_p
->sa_header
= doc_header
.sa_header
;
1646 pxdb_header_p
->inlined
= doc_header
.inlined
;
1647 pxdb_header_p
->globals
= doc_header
.globals
;
1648 pxdb_header_p
->time
= doc_header
.time
;
1649 pxdb_header_p
->pg_entries
= doc_header
.pg_entries
;
1650 pxdb_header_p
->functions
= doc_header
.functions
;
1651 pxdb_header_p
->files
= doc_header
.files
;
1652 pxdb_header_p
->cd_entries
= doc_header
.cd_entries
;
1653 pxdb_header_p
->aa_entries
= doc_header
.aa_entries
;
1654 pxdb_header_p
->oi_entries
= doc_header
.oi_entries
;
1655 pxdb_header_p
->version
= doc_header
.version
;
1656 } /* PINFO section */
1662 printf ("==No debug info at all for %s.\n", objfile
->name
);
1670 } /* End of hpread_get_header */
1671 #endif /* QUICK_LOOK_UP */
1674 /* Initialization for reading native HP C debug symbols from OBJFILE.
1676 Its only purpose in life is to set up the symbol reader's private
1677 per-objfile data structures, and read in the raw contents of the debug
1678 sections (attaching pointers to the debug info into the private data
1681 Since BFD doesn't know how to read debug symbols in a format-independent
1682 way (and may never do so...), we have to do it ourselves. Note we may
1683 be called on a file without native HP C debugging symbols.
1685 FIXME, there should be a cleaner peephole into the BFD environment
1688 hpread_symfile_init (struct objfile
*objfile
)
1690 asection
*vt_section
, *slt_section
, *lntt_section
, *gntt_section
;
1692 /* Allocate struct to keep track of the symfile */
1693 objfile
->sym_private
= (PTR
)
1694 xmmalloc (objfile
->md
, sizeof (struct hpread_symfile_info
));
1695 memset (objfile
->sym_private
, 0, sizeof (struct hpread_symfile_info
));
1697 /* We haven't read in any types yet. */
1698 DNTT_TYPE_VECTOR (objfile
) = 0;
1700 /* Read in data from the $GNTT$ subspace. */
1701 gntt_section
= bfd_get_section_by_name (objfile
->obfd
, "$GNTT$");
1706 = obstack_alloc (&objfile
->symbol_obstack
,
1707 bfd_section_size (objfile
->obfd
, gntt_section
));
1709 bfd_get_section_contents (objfile
->obfd
, gntt_section
, GNTT (objfile
),
1710 0, bfd_section_size (objfile
->obfd
, gntt_section
));
1712 GNTT_SYMCOUNT (objfile
)
1713 = bfd_section_size (objfile
->obfd
, gntt_section
)
1714 / sizeof (struct dntt_type_block
);
1716 /* Read in data from the $LNTT$ subspace. Also keep track of the number
1719 FIXME: this could be moved into the psymtab-to-symtab expansion
1720 code, and save startup time. At the moment this data is
1721 still used, though. We'd need a way to tell hp-symtab-read.c
1722 whether or not to load the LNTT. */
1723 lntt_section
= bfd_get_section_by_name (objfile
->obfd
, "$LNTT$");
1728 = obstack_alloc (&objfile
->symbol_obstack
,
1729 bfd_section_size (objfile
->obfd
, lntt_section
));
1731 bfd_get_section_contents (objfile
->obfd
, lntt_section
, LNTT (objfile
),
1732 0, bfd_section_size (objfile
->obfd
, lntt_section
));
1734 LNTT_SYMCOUNT (objfile
)
1735 = bfd_section_size (objfile
->obfd
, lntt_section
)
1736 / sizeof (struct dntt_type_block
);
1738 /* Read in data from the $SLT$ subspace. $SLT$ contains information
1739 on source line numbers. */
1740 slt_section
= bfd_get_section_by_name (objfile
->obfd
, "$SLT$");
1745 obstack_alloc (&objfile
->symbol_obstack
,
1746 bfd_section_size (objfile
->obfd
, slt_section
));
1748 bfd_get_section_contents (objfile
->obfd
, slt_section
, SLT (objfile
),
1749 0, bfd_section_size (objfile
->obfd
, slt_section
));
1751 /* Read in data from the $VT$ subspace. $VT$ contains things like
1752 names and constants. Keep track of the number of symbols in the VT. */
1753 vt_section
= bfd_get_section_by_name (objfile
->obfd
, "$VT$");
1757 VT_SIZE (objfile
) = bfd_section_size (objfile
->obfd
, vt_section
);
1760 (char *) obstack_alloc (&objfile
->symbol_obstack
,
1763 bfd_get_section_contents (objfile
->obfd
, vt_section
, VT (objfile
),
1764 0, VT_SIZE (objfile
));
1767 /* Scan and build partial symbols for a symbol file.
1769 The minimal symbol table (either SOM or HP a.out) has already been
1770 read in; all we need to do is setup partial symbols based on the
1771 native debugging information.
1773 Note that the minimal table is produced by the linker, and has
1774 only global routines in it; the psymtab is based on compiler-
1775 generated debug information and has non-global
1776 routines in it as well as files and class information.
1778 We assume hpread_symfile_init has been called to initialize the
1779 symbol reader's private data structures.
1781 MAINLINE is true if we are reading the main symbol table (as
1782 opposed to a shared lib or dynamically loaded file). */
1785 hpread_build_psymtabs (struct objfile
*objfile
, int mainline
)
1789 /* Turn this on to get debugging output. */
1790 static int dumping
= 0;
1794 int past_first_source_file
= 0;
1795 struct cleanup
*old_chain
;
1797 int hp_symnum
, symcount
, i
;
1800 union dnttentry
*dn_bufp
;
1806 /* Current partial symtab */
1807 struct partial_symtab
*pst
;
1809 /* List of current psymtab's include files */
1810 char **psymtab_include_list
;
1811 int includes_allocated
;
1814 /* Index within current psymtab dependency list */
1815 struct partial_symtab
**dependency_list
;
1816 int dependencies_used
, dependencies_allocated
;
1818 /* Just in case the stabs reader left turds lying around. */
1819 free_pending_blocks ();
1820 make_cleanup (really_free_pendings
, 0);
1822 pst
= (struct partial_symtab
*) 0;
1824 /* We shouldn't use alloca, instead use malloc/free. Doing so avoids
1825 a number of problems with cross compilation and creating useless holes
1826 in the stack when we have to allocate new entries. FIXME. */
1828 includes_allocated
= 30;
1830 psymtab_include_list
= (char **) alloca (includes_allocated
*
1833 dependencies_allocated
= 30;
1834 dependencies_used
= 0;
1836 (struct partial_symtab
**) alloca (dependencies_allocated
*
1837 sizeof (struct partial_symtab
*));
1839 old_chain
= make_cleanup_free_objfile (objfile
);
1841 last_source_file
= 0;
1843 #ifdef QUICK_LOOK_UP
1845 /* Begin code for new-style loading of quick look-up tables. */
1847 /* elz: this checks whether the file has beeen processed by pxdb.
1848 If not we would like to try to read the psymbols in
1849 anyway, but it turns out to be not so easy. So this could
1850 actually be commented out, but I leave it in, just in case
1851 we decide to add support for non-pxdb-ed stuff in the future. */
1852 PXDB_header pxdb_header
;
1853 int found_modules_in_program
;
1855 if (hpread_get_header (objfile
, &pxdb_header
))
1857 /* Build a minimal table. No types, no global variables,
1858 no include files.... */
1861 printf ("\nNew method for %s\n", objfile
->name
);
1864 /* elz: quick_traverse returns true if it found
1865 some modules in the main source file, other
1867 In C and C++, all the files have MODULES entries
1868 in the LNTT, and the quick table traverse is all
1869 based on finding these MODULES entries. Without
1870 those it cannot work.
1871 It happens that F77 programs don't have MODULES
1872 so the quick traverse gets confused. F90 programs
1873 have modules, and the quick method still works.
1874 So, if modules (other than those in end.c) are
1875 not found we give up on the quick table stuff,
1876 and fall back on the slower method */
1877 found_modules_in_program
= hpread_quick_traverse (objfile
,
1882 discard_cleanups (old_chain
);
1884 /* Set up to scan the global section of the LNTT.
1886 This field is not always correct: if there are
1887 no globals, it will point to the last record in
1888 the regular LNTT, which is usually an END MODULE.
1890 Since it might happen that there could be a file
1891 with just one global record, there's no way to
1892 tell other than by looking at the record, so that's
1894 if (found_modules_in_program
)
1895 scan_start
= pxdb_header
.globals
;
1901 printf ("\nGoing on to old method for %s\n", objfile
->name
);
1905 #endif /* QUICK_LOOK_UP */
1907 /* Make two passes, one over the GNTT symbols, the other for the
1910 JB comment: above isn't true--they only make one pass, over
1912 for (i
= 0; i
< 1; i
++)
1914 int within_function
= 0;
1917 symcount
= GNTT_SYMCOUNT (objfile
);
1919 symcount
= LNTT_SYMCOUNT (objfile
);
1922 for (hp_symnum
= scan_start
; hp_symnum
< symcount
; hp_symnum
++)
1926 dn_bufp
= hpread_get_gntt (hp_symnum
, objfile
);
1928 dn_bufp
= hpread_get_lntt (hp_symnum
, objfile
);
1930 if (dn_bufp
->dblock
.extension
)
1933 /* Only handle things which are necessary for minimal symbols.
1934 everything else is ignored. */
1935 switch (dn_bufp
->dblock
.kind
)
1937 case DNTT_TYPE_SRCFILE
:
1939 #ifdef QUICK_LOOK_UP
1940 if (scan_start
== hp_symnum
1941 && symcount
== hp_symnum
+ 1)
1943 /* If there are NO globals in an executable,
1944 PXDB's index to the globals will point to
1945 the last record in the file, which
1946 could be this record. (this happened for F77 libraries)
1947 ignore it and be done! */
1950 #endif /* QUICK_LOOK_UP */
1952 /* A source file of some kind. Note this may simply
1953 be an included file. */
1954 SET_NAMESTRING (dn_bufp
, &namestring
, objfile
);
1956 /* Check if this is the source file we are already working
1958 if (pst
&& !strcmp (namestring
, pst
->filename
))
1961 /* Check if this is an include file, if so check if we have
1962 already seen it. Add it to the include list */
1963 p
= strrchr (namestring
, '.');
1964 if (!strcmp (p
, ".h"))
1969 for (j
= 0; j
< includes_used
; j
++)
1970 if (!strcmp (namestring
, psymtab_include_list
[j
]))
1978 /* Add it to the list of includes seen so far and
1979 allocate more include space if necessary. */
1980 psymtab_include_list
[includes_used
++] = namestring
;
1981 if (includes_used
>= includes_allocated
)
1983 char **orig
= psymtab_include_list
;
1985 psymtab_include_list
= (char **)
1986 alloca ((includes_allocated
*= 2) *
1988 memcpy ((PTR
) psymtab_include_list
, (PTR
) orig
,
1989 includes_used
* sizeof (char *));
1998 pst
->filename
= (char *)
1999 obstack_alloc (&pst
->objfile
->psymbol_obstack
,
2000 strlen (namestring
) + 1);
2001 strcpy (pst
->filename
, namestring
);
2008 /* This is a bonafide new source file.
2009 End the current partial symtab and start a new one. */
2011 if (pst
&& past_first_source_file
)
2013 hpread_end_psymtab (pst
, psymtab_include_list
,
2016 * sizeof (struct dntt_type_block
)),
2018 dependency_list
, dependencies_used
);
2019 pst
= (struct partial_symtab
*) 0;
2021 dependencies_used
= 0;
2024 past_first_source_file
= 1;
2026 valu
= hpread_get_textlow (i
, hp_symnum
, objfile
, symcount
);
2027 valu
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2028 pst
= hpread_start_psymtab (objfile
,
2031 * sizeof (struct dntt_type_block
)),
2032 objfile
->global_psymbols
.next
,
2033 objfile
->static_psymbols
.next
);
2039 case DNTT_TYPE_MODULE
:
2040 /* A source file. It's still unclear to me what the
2041 real difference between a DNTT_TYPE_SRCFILE and DNTT_TYPE_MODULE
2042 is supposed to be. */
2044 /* First end the previous psymtab */
2047 hpread_end_psymtab (pst
, psymtab_include_list
, includes_used
,
2049 * sizeof (struct dntt_type_block
)),
2051 dependency_list
, dependencies_used
);
2052 pst
= (struct partial_symtab
*) 0;
2054 dependencies_used
= 0;
2058 /* Now begin a new module and a new psymtab for it */
2059 SET_NAMESTRING (dn_bufp
, &namestring
, objfile
);
2060 valu
= hpread_get_textlow (i
, hp_symnum
, objfile
, symcount
);
2061 valu
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2064 pst
= hpread_start_psymtab (objfile
,
2067 * sizeof (struct dntt_type_block
)),
2068 objfile
->global_psymbols
.next
,
2069 objfile
->static_psymbols
.next
);
2075 case DNTT_TYPE_FUNCTION
:
2076 case DNTT_TYPE_ENTRY
:
2077 /* The beginning of a function. DNTT_TYPE_ENTRY may also denote
2078 a secondary entry point. */
2079 valu
= dn_bufp
->dfunc
.hiaddr
+ ANOFFSET (objfile
->section_offsets
,
2080 SECT_OFF_TEXT (objfile
));
2081 if (valu
> texthigh
)
2083 valu
= dn_bufp
->dfunc
.lowaddr
+
2084 ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2085 SET_NAMESTRING (dn_bufp
, &namestring
, objfile
);
2086 if (dn_bufp
->dfunc
.global
)
2087 add_psymbol_to_list (namestring
, strlen (namestring
),
2088 VAR_NAMESPACE
, LOC_BLOCK
,
2089 &objfile
->global_psymbols
, valu
,
2090 0, language_unknown
, objfile
);
2092 add_psymbol_to_list (namestring
, strlen (namestring
),
2093 VAR_NAMESPACE
, LOC_BLOCK
,
2094 &objfile
->static_psymbols
, valu
,
2095 0, language_unknown
, objfile
);
2096 within_function
= 1;
2099 case DNTT_TYPE_DOC_FUNCTION
:
2100 valu
= dn_bufp
->ddocfunc
.hiaddr
+ ANOFFSET (objfile
->section_offsets
,
2101 SECT_OFF_TEXT (objfile
));
2102 if (valu
> texthigh
)
2104 valu
= dn_bufp
->ddocfunc
.lowaddr
+
2105 ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2106 SET_NAMESTRING (dn_bufp
, &namestring
, objfile
);
2107 if (dn_bufp
->ddocfunc
.global
)
2108 add_psymbol_to_list (namestring
, strlen (namestring
),
2109 VAR_NAMESPACE
, LOC_BLOCK
,
2110 &objfile
->global_psymbols
, valu
,
2111 0, language_unknown
, objfile
);
2113 add_psymbol_to_list (namestring
, strlen (namestring
),
2114 VAR_NAMESPACE
, LOC_BLOCK
,
2115 &objfile
->static_psymbols
, valu
,
2116 0, language_unknown
, objfile
);
2117 within_function
= 1;
2120 case DNTT_TYPE_BEGIN
:
2122 /* We don't check MODULE end here, because there can be
2123 symbols beyond the module end which properly belong to the
2124 current psymtab -- so we wait till the next MODULE start */
2127 #ifdef QUICK_LOOK_UP
2128 if (scan_start
== hp_symnum
2129 && symcount
== hp_symnum
+ 1)
2131 /* If there are NO globals in an executable,
2132 PXDB's index to the globals will point to
2133 the last record in the file, which is
2134 probably an END MODULE, i.e. this record.
2135 ignore it and be done! */
2138 #endif /* QUICK_LOOK_UP */
2140 /* Scope block begin/end. We only care about function
2141 and file blocks right now. */
2143 if ((dn_bufp
->dend
.endkind
== DNTT_TYPE_FUNCTION
) ||
2144 (dn_bufp
->dend
.endkind
== DNTT_TYPE_DOC_FUNCTION
))
2145 within_function
= 0;
2148 case DNTT_TYPE_SVAR
:
2149 case DNTT_TYPE_DVAR
:
2150 case DNTT_TYPE_TYPEDEF
:
2151 case DNTT_TYPE_TAGDEF
:
2153 /* Variables, typedefs an the like. */
2154 enum address_class storage
;
2155 namespace_enum
namespace;
2157 /* Don't add locals to the partial symbol table. */
2159 && (dn_bufp
->dblock
.kind
== DNTT_TYPE_SVAR
2160 || dn_bufp
->dblock
.kind
== DNTT_TYPE_DVAR
))
2163 /* TAGDEFs go into the structure namespace. */
2164 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_TAGDEF
)
2165 namespace = STRUCT_NAMESPACE
;
2167 namespace = VAR_NAMESPACE
;
2169 /* What kind of "storage" does this use? */
2170 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_SVAR
)
2171 storage
= LOC_STATIC
;
2172 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_DVAR
2173 && dn_bufp
->ddvar
.regvar
)
2174 storage
= LOC_REGISTER
;
2175 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_DVAR
)
2176 storage
= LOC_LOCAL
;
2178 storage
= LOC_UNDEF
;
2180 SET_NAMESTRING (dn_bufp
, &namestring
, objfile
);
2183 pst
= hpread_start_psymtab (objfile
,
2186 * sizeof (struct dntt_type_block
)),
2187 objfile
->global_psymbols
.next
,
2188 objfile
->static_psymbols
.next
);
2191 /* Compute address of the data symbol */
2192 valu
= dn_bufp
->dsvar
.location
;
2193 /* Relocate in case it's in a shared library */
2194 if (storage
== LOC_STATIC
)
2195 valu
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
2197 /* Luckily, dvar, svar, typedef, and tagdef all
2198 have their "global" bit in the same place, so it works
2199 (though it's bad programming practice) to reference
2200 "dsvar.global" even though we may be looking at
2201 any of the above four types. */
2202 if (dn_bufp
->dsvar
.global
)
2204 add_psymbol_to_list (namestring
, strlen (namestring
),
2206 &objfile
->global_psymbols
,
2208 0, language_unknown
, objfile
);
2212 add_psymbol_to_list (namestring
, strlen (namestring
),
2214 &objfile
->static_psymbols
,
2216 0, language_unknown
, objfile
);
2219 /* For TAGDEF's, the above code added the tagname to the
2220 struct namespace. This will cause tag "t" to be found
2221 on a reference of the form "(struct t) x". But for
2222 C++ classes, "t" will also be a typename, which we
2223 want to find on a reference of the form "ptype t".
2224 Therefore, we also add "t" to the var namespace.
2225 Do the same for enum's due to the way aCC generates
2226 debug info for these (see more extended comment
2227 in hp-symtab-read.c).
2228 We do the same for templates, so that "ptype t"
2229 where "t" is a template also works. */
2230 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_TAGDEF
&&
2231 dn_bufp
->dtype
.type
.dnttp
.index
< LNTT_SYMCOUNT (objfile
))
2233 int global
= dn_bufp
->dtag
.global
;
2234 /* Look ahead to see if it's a C++ class */
2235 dn_bufp
= hpread_get_lntt (dn_bufp
->dtype
.type
.dnttp
.index
, objfile
);
2236 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_CLASS
||
2237 dn_bufp
->dblock
.kind
== DNTT_TYPE_ENUM
||
2238 dn_bufp
->dblock
.kind
== DNTT_TYPE_TEMPLATE
)
2242 add_psymbol_to_list (namestring
, strlen (namestring
),
2243 VAR_NAMESPACE
, storage
,
2244 &objfile
->global_psymbols
,
2245 dn_bufp
->dsvar
.location
,
2246 0, language_unknown
, objfile
);
2250 add_psymbol_to_list (namestring
, strlen (namestring
),
2251 VAR_NAMESPACE
, storage
,
2252 &objfile
->static_psymbols
,
2253 dn_bufp
->dsvar
.location
,
2254 0, language_unknown
, objfile
);
2261 case DNTT_TYPE_MEMENUM
:
2262 case DNTT_TYPE_CONST
:
2263 /* Constants and members of enumerated types. */
2264 SET_NAMESTRING (dn_bufp
, &namestring
, objfile
);
2267 pst
= hpread_start_psymtab (objfile
,
2270 * sizeof (struct dntt_type_block
)),
2271 objfile
->global_psymbols
.next
,
2272 objfile
->static_psymbols
.next
);
2274 if (dn_bufp
->dconst
.global
)
2275 add_psymbol_to_list (namestring
, strlen (namestring
),
2276 VAR_NAMESPACE
, LOC_CONST
,
2277 &objfile
->global_psymbols
, 0,
2278 0, language_unknown
, objfile
);
2280 add_psymbol_to_list (namestring
, strlen (namestring
),
2281 VAR_NAMESPACE
, LOC_CONST
,
2282 &objfile
->static_psymbols
, 0,
2283 0, language_unknown
, objfile
);
2291 /* End any pending partial symbol table. */
2294 hpread_end_psymtab (pst
, psymtab_include_list
, includes_used
,
2295 hp_symnum
* sizeof (struct dntt_type_block
),
2296 0, dependency_list
, dependencies_used
);
2299 discard_cleanups (old_chain
);
2302 /* Perform any local cleanups required when we are done with a particular
2303 objfile. I.E, we are in the process of discarding all symbol information
2304 for an objfile, freeing up all memory held for it, and unlinking the
2305 objfile struct from the global list of known objfiles. */
2308 hpread_symfile_finish (struct objfile
*objfile
)
2310 if (objfile
->sym_private
!= NULL
)
2312 xmfree (objfile
->md
, objfile
->sym_private
);
2317 /* The remaining functions are all for internal use only. */
2319 /* Various small functions to get entries in the debug symbol sections. */
2322 hpread_get_lntt (int index
, struct objfile
*objfile
)
2324 return (union dnttentry
*)
2325 &(LNTT (objfile
)[(index
* sizeof (struct dntt_type_block
))]);
2328 static union dnttentry
*
2329 hpread_get_gntt (int index
, struct objfile
*objfile
)
2331 return (union dnttentry
*)
2332 &(GNTT (objfile
)[(index
* sizeof (struct dntt_type_block
))]);
2336 hpread_get_slt (int index
, struct objfile
*objfile
)
2338 return (union sltentry
*) &(SLT (objfile
)[index
* sizeof (union sltentry
)]);
2341 /* Get the low address associated with some symbol (typically the start
2342 of a particular source file or module). Since that information is not
2343 stored as part of the DNTT_TYPE_MODULE or DNTT_TYPE_SRCFILE symbol we
2344 must infer it from the existence of DNTT_TYPE_FUNCTION symbols. */
2346 static unsigned long
2347 hpread_get_textlow (int global
, int index
, struct objfile
*objfile
,
2350 union dnttentry
*dn_bufp
;
2351 struct minimal_symbol
*msymbol
;
2353 /* Look for a DNTT_TYPE_FUNCTION symbol. */
2354 if (index
< symcount
) /* symcount is the number of symbols in */
2355 { /* the dbinfo, LNTT table */
2359 dn_bufp
= hpread_get_gntt (index
++, objfile
);
2361 dn_bufp
= hpread_get_lntt (index
++, objfile
);
2363 while (dn_bufp
->dblock
.kind
!= DNTT_TYPE_FUNCTION
2364 && dn_bufp
->dblock
.kind
!= DNTT_TYPE_DOC_FUNCTION
2365 && dn_bufp
->dblock
.kind
!= DNTT_TYPE_END
2366 && index
< symcount
);
2369 /* Avoid going past a DNTT_TYPE_END when looking for a DNTT_TYPE_FUNCTION. This
2370 might happen when a sourcefile has no functions. */
2371 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_END
)
2374 /* Avoid going past the end of the LNTT file */
2375 if (index
== symcount
)
2378 /* The minimal symbols are typically more accurate for some reason. */
2379 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_FUNCTION
)
2380 msymbol
= lookup_minimal_symbol (dn_bufp
->dfunc
.name
+ VT (objfile
), NULL
,
2382 else /* must be a DNTT_TYPE_DOC_FUNCTION */
2383 msymbol
= lookup_minimal_symbol (dn_bufp
->ddocfunc
.name
+ VT (objfile
), NULL
,
2387 return SYMBOL_VALUE_ADDRESS (msymbol
);
2389 return dn_bufp
->dfunc
.lowaddr
;
2392 /* Allocate and partially fill a partial symtab. It will be
2393 completely filled at the end of the symbol list.
2395 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
2396 is the address relative to which its symbols are (incremental) or 0
2399 static struct partial_symtab
*
2400 hpread_start_psymtab (struct objfile
*objfile
, char *filename
,
2401 CORE_ADDR textlow
, int ldsymoff
,
2402 struct partial_symbol
**global_syms
,
2403 struct partial_symbol
**static_syms
)
2405 int offset
= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
2406 extern void hpread_psymtab_to_symtab ();
2407 struct partial_symtab
*result
=
2408 start_psymtab_common (objfile
, objfile
->section_offsets
,
2409 filename
, textlow
, global_syms
, static_syms
);
2411 result
->textlow
+= offset
;
2412 result
->read_symtab_private
= (char *)
2413 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct symloc
));
2414 LDSYMOFF (result
) = ldsymoff
;
2415 result
->read_symtab
= hpread_psymtab_to_symtab
;
2421 /* Close off the current usage of PST.
2422 Returns PST or NULL if the partial symtab was empty and thrown away.
2424 capping_symbol_offset --Byte index in LNTT or GNTT of the
2425 last symbol processed during the build
2426 of the previous pst.
2428 FIXME: List variables and peculiarities of same. */
2430 static struct partial_symtab
*
2431 hpread_end_psymtab (struct partial_symtab
*pst
, char **include_list
,
2432 int num_includes
, int capping_symbol_offset
,
2433 CORE_ADDR capping_text
,
2434 struct partial_symtab
**dependency_list
,
2435 int number_dependencies
)
2438 struct objfile
*objfile
= pst
->objfile
;
2439 int offset
= ANOFFSET (pst
->section_offsets
, SECT_OFF_TEXT (objfile
));
2442 /* Turn on to see what kind of a psymtab we've built. */
2443 static int dumping
= 0;
2446 if (capping_symbol_offset
!= -1)
2447 LDSYMLEN (pst
) = capping_symbol_offset
- LDSYMOFF (pst
);
2450 pst
->texthigh
= capping_text
+ offset
;
2452 pst
->n_global_syms
=
2453 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
2454 pst
->n_static_syms
=
2455 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
2460 printf ("\nPst %s, LDSYMOFF %x (%x), LDSYMLEN %x (%x), globals %d, statics %d\n",
2463 LDSYMOFF (pst
) / sizeof (struct dntt_type_block
),
2465 LDSYMLEN (pst
) / sizeof (struct dntt_type_block
),
2466 pst
->n_global_syms
, pst
->n_static_syms
);
2470 pst
->number_of_dependencies
= number_dependencies
;
2471 if (number_dependencies
)
2473 pst
->dependencies
= (struct partial_symtab
**)
2474 obstack_alloc (&objfile
->psymbol_obstack
,
2475 number_dependencies
* sizeof (struct partial_symtab
*));
2476 memcpy (pst
->dependencies
, dependency_list
,
2477 number_dependencies
* sizeof (struct partial_symtab
*));
2480 pst
->dependencies
= 0;
2482 for (i
= 0; i
< num_includes
; i
++)
2484 struct partial_symtab
*subpst
=
2485 allocate_psymtab (include_list
[i
], objfile
);
2487 subpst
->section_offsets
= pst
->section_offsets
;
2488 subpst
->read_symtab_private
=
2489 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
2490 sizeof (struct symloc
));
2494 subpst
->texthigh
= 0;
2496 /* We could save slight bits of space by only making one of these,
2497 shared by the entire set of include files. FIXME-someday. */
2498 subpst
->dependencies
= (struct partial_symtab
**)
2499 obstack_alloc (&objfile
->psymbol_obstack
,
2500 sizeof (struct partial_symtab
*));
2501 subpst
->dependencies
[0] = pst
;
2502 subpst
->number_of_dependencies
= 1;
2504 subpst
->globals_offset
=
2505 subpst
->n_global_syms
=
2506 subpst
->statics_offset
=
2507 subpst
->n_static_syms
= 0;
2511 subpst
->read_symtab
= pst
->read_symtab
;
2514 sort_pst_symbols (pst
);
2516 /* If there is already a psymtab or symtab for a file of this name, remove it.
2517 (If there is a symtab, more drastic things also happen.)
2518 This happens in VxWorks. */
2519 free_named_symtabs (pst
->filename
);
2521 if (num_includes
== 0
2522 && number_dependencies
== 0
2523 && pst
->n_global_syms
== 0
2524 && pst
->n_static_syms
== 0)
2526 /* Throw away this psymtab, it's empty. We can't deallocate it, since
2527 it is on the obstack, but we can forget to chain it on the list.
2528 Empty psymtabs happen as a result of header files which don't have
2529 any symbols in them. There can be a lot of them. But this check
2530 is wrong, in that a psymtab with N_SLINE entries but nothing else
2531 is not empty, but we don't realize that. Fixing that without slowing
2532 things down might be tricky.
2533 It's also wrong if we're using the quick look-up tables, as
2534 we can get empty psymtabs from modules with no routines in
2537 discard_psymtab (pst
);
2539 /* Indicate that psymtab was thrown away. */
2540 pst
= (struct partial_symtab
*) NULL
;
2547 /* Get the nesting depth for the source line identified by INDEX. */
2549 static unsigned long
2550 hpread_get_scope_start (sltpointer index
, struct objfile
*objfile
)
2552 union sltentry
*sl_bufp
;
2554 sl_bufp
= hpread_get_slt (index
, objfile
);
2555 return sl_bufp
->sspec
.backptr
.dnttp
.index
;
2558 /* Get the source line number the the line identified by INDEX. */
2560 static unsigned long
2561 hpread_get_line (sltpointer index
, struct objfile
*objfile
)
2563 union sltentry
*sl_bufp
;
2565 sl_bufp
= hpread_get_slt (index
, objfile
);
2566 return sl_bufp
->snorm
.line
;
2569 /* Find the code address associated with a given sltpointer */
2572 hpread_get_location (sltpointer index
, struct objfile
*objfile
)
2574 union sltentry
*sl_bufp
;
2577 /* code location of special sltentrys is determined from context */
2578 sl_bufp
= hpread_get_slt (index
, objfile
);
2580 if (sl_bufp
->snorm
.sltdesc
== SLT_END
)
2582 /* find previous normal sltentry and get address */
2583 for (i
= 0; ((sl_bufp
->snorm
.sltdesc
!= SLT_NORMAL
) &&
2584 (sl_bufp
->snorm
.sltdesc
!= SLT_NORMAL_OFFSET
) &&
2585 (sl_bufp
->snorm
.sltdesc
!= SLT_EXIT
)); i
++)
2586 sl_bufp
= hpread_get_slt (index
- i
, objfile
);
2587 if (sl_bufp
->snorm
.sltdesc
== SLT_NORMAL_OFFSET
)
2588 return sl_bufp
->snormoff
.address
;
2590 return sl_bufp
->snorm
.address
;
2593 /* find next normal sltentry and get address */
2594 for (i
= 0; ((sl_bufp
->snorm
.sltdesc
!= SLT_NORMAL
) &&
2595 (sl_bufp
->snorm
.sltdesc
!= SLT_NORMAL_OFFSET
) &&
2596 (sl_bufp
->snorm
.sltdesc
!= SLT_EXIT
)); i
++)
2597 sl_bufp
= hpread_get_slt (index
+ i
, objfile
);
2598 if (sl_bufp
->snorm
.sltdesc
== SLT_NORMAL_OFFSET
)
2599 return sl_bufp
->snormoff
.address
;
2601 return sl_bufp
->snorm
.address
;
2605 /* Return 1 if an HP debug symbol of type KIND has a name associated with
2606 * it, else return 0. (This function is not currently used, but I'll
2607 * leave it here in case it proves useful later on. - RT).
2611 hpread_has_name (enum dntt_entry_type kind
)
2615 case DNTT_TYPE_SRCFILE
:
2616 case DNTT_TYPE_MODULE
:
2617 case DNTT_TYPE_FUNCTION
:
2618 case DNTT_TYPE_DOC_FUNCTION
:
2619 case DNTT_TYPE_ENTRY
:
2620 case DNTT_TYPE_IMPORT
:
2621 case DNTT_TYPE_LABEL
:
2622 case DNTT_TYPE_FPARAM
:
2623 case DNTT_TYPE_SVAR
:
2624 case DNTT_TYPE_DVAR
:
2625 case DNTT_TYPE_CONST
:
2626 case DNTT_TYPE_TYPEDEF
:
2627 case DNTT_TYPE_TAGDEF
:
2628 case DNTT_TYPE_MEMENUM
:
2629 case DNTT_TYPE_FIELD
:
2631 case DNTT_TYPE_BLOCKDATA
:
2632 case DNTT_TYPE_MEMFUNC
:
2633 case DNTT_TYPE_DOC_MEMFUNC
:
2636 case DNTT_TYPE_BEGIN
:
2638 case DNTT_TYPE_POINTER
:
2639 case DNTT_TYPE_ENUM
:
2641 case DNTT_TYPE_ARRAY
:
2642 case DNTT_TYPE_STRUCT
:
2643 case DNTT_TYPE_UNION
:
2644 case DNTT_TYPE_VARIANT
:
2645 case DNTT_TYPE_FILE
:
2646 case DNTT_TYPE_FUNCTYPE
:
2647 case DNTT_TYPE_SUBRANGE
:
2648 case DNTT_TYPE_WITH
:
2649 case DNTT_TYPE_COMMON
:
2650 case DNTT_TYPE_COBSTRUCT
:
2651 case DNTT_TYPE_XREF
:
2652 case DNTT_TYPE_MACRO
:
2653 case DNTT_TYPE_CLASS_SCOPE
:
2654 case DNTT_TYPE_REFERENCE
:
2655 case DNTT_TYPE_PTRMEM
:
2656 case DNTT_TYPE_PTRMEMFUNC
:
2657 case DNTT_TYPE_CLASS
:
2658 case DNTT_TYPE_GENFIELD
:
2659 case DNTT_TYPE_VFUNC
:
2660 case DNTT_TYPE_MEMACCESS
:
2661 case DNTT_TYPE_INHERITANCE
:
2662 case DNTT_TYPE_FRIEND_CLASS
:
2663 case DNTT_TYPE_FRIEND_FUNC
:
2664 case DNTT_TYPE_MODIFIER
:
2665 case DNTT_TYPE_OBJECT_ID
:
2666 case DNTT_TYPE_TEMPLATE
:
2667 case DNTT_TYPE_TEMPLATE_ARG
:
2668 case DNTT_TYPE_FUNC_TEMPLATE
:
2669 case DNTT_TYPE_LINK
:
2670 /* DNTT_TYPE_DYN_ARRAY_DESC ? */
2671 /* DNTT_TYPE_DESC_SUBRANGE ? */
2672 /* DNTT_TYPE_BEGIN_EXT ? */
2673 /* DNTT_TYPE_INLN ? */
2674 /* DNTT_TYPE_INLN_LIST ? */
2675 /* DNTT_TYPE_ALIAS ? */
2681 /* Do the dirty work of reading in the full symbol from a partial symbol
2685 hpread_psymtab_to_symtab_1 (struct partial_symtab
*pst
)
2687 struct cleanup
*old_chain
;
2690 /* Get out quick if passed junk. */
2694 /* Complain if we've already read in this symbol table. */
2697 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in."
2698 " Shouldn't happen.\n",
2703 /* Read in all partial symtabs on which this one is dependent */
2704 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
2705 if (!pst
->dependencies
[i
]->readin
)
2707 /* Inform about additional files that need to be read in. */
2710 fputs_filtered (" ", gdb_stdout
);
2712 fputs_filtered ("and ", gdb_stdout
);
2714 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
2715 wrap_here (""); /* Flush output */
2716 gdb_flush (gdb_stdout
);
2718 hpread_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
2721 /* If it's real... */
2724 /* Init stuff necessary for reading in symbols */
2726 old_chain
= make_cleanup (really_free_pendings
, 0);
2729 hpread_expand_symtab (pst
->objfile
, LDSYMOFF (pst
), LDSYMLEN (pst
),
2730 pst
->textlow
, pst
->texthigh
- pst
->textlow
,
2731 pst
->section_offsets
, pst
->filename
);
2732 sort_symtab_syms (pst
->symtab
);
2734 do_cleanups (old_chain
);
2740 /* Read in all of the symbols for a given psymtab for real.
2741 Be verbose about it if the user wants that. */
2744 hpread_psymtab_to_symtab (struct partial_symtab
*pst
)
2746 /* Get out quick if given junk. */
2753 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in."
2754 " Shouldn't happen.\n",
2759 /* elz: setting the flag to indicate that the code of the target
2760 was compiled using an HP compiler (aCC, cc)
2761 the processing_acc_compilation variable is declared in the
2762 file buildsym.h, the HP_COMPILED_TARGET is defined to be equal
2763 to 3 in the file tm_hppa.h */
2765 processing_gcc_compilation
= 0;
2767 if (LDSYMLEN (pst
) || pst
->number_of_dependencies
)
2769 /* Print the message now, before reading the string table,
2770 to avoid disconcerting pauses. */
2773 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
2774 gdb_flush (gdb_stdout
);
2777 hpread_psymtab_to_symtab_1 (pst
);
2779 /* Match with global symbols. This only needs to be done once,
2780 after all of the symtabs and dependencies have been read in. */
2781 scan_file_globals (pst
->objfile
);
2783 /* Finish up the debug error message. */
2785 printf_filtered ("done.\n");
2789 /* Read in a defined section of a specific object file's symbols.
2791 DESC is the file descriptor for the file, positioned at the
2792 beginning of the symtab
2793 SYM_OFFSET is the offset within the file of
2794 the beginning of the symbols we want to read
2795 SYM_SIZE is the size of the symbol info to read in.
2796 TEXT_OFFSET is the beginning of the text segment we are reading symbols for
2797 TEXT_SIZE is the size of the text segment read in.
2798 SECTION_OFFSETS are the relocation offsets which get added to each symbol. */
2800 static struct symtab
*
2801 hpread_expand_symtab (struct objfile
*objfile
, int sym_offset
, int sym_size
,
2802 CORE_ADDR text_offset
, int text_size
,
2803 struct section_offsets
*section_offsets
, char *filename
)
2806 union dnttentry
*dn_bufp
;
2807 unsigned max_symnum
;
2808 int at_module_boundary
= 0;
2809 /* 1 => at end, -1 => at beginning */
2811 int sym_index
= sym_offset
/ sizeof (struct dntt_type_block
);
2813 current_objfile
= objfile
;
2816 last_source_file
= 0;
2818 /* Demangling style -- if EDG style already set, don't change it,
2819 as HP style causes some problems with the KAI EDG compiler */
2820 if (current_demangling_style
!= edg_demangling
)
2822 /* Otherwise, ensure that we are using HP style demangling */
2823 set_demangling_style (HP_DEMANGLING_STYLE_STRING
);
2826 dn_bufp
= hpread_get_lntt (sym_index
, objfile
);
2827 if (!((dn_bufp
->dblock
.kind
== (unsigned char) DNTT_TYPE_SRCFILE
) ||
2828 (dn_bufp
->dblock
.kind
== (unsigned char) DNTT_TYPE_MODULE
)))
2830 start_symtab ("globals", NULL
, 0);
2831 record_debugformat ("HP");
2834 /* The psymtab builder (hp-psymtab-read.c) is the one that
2835 * determined the "sym_size" argument (i.e. how many DNTT symbols
2836 * are in this symtab), which we use to compute "max_symnum"
2837 * (point in DNTT to which we read).
2839 * Perhaps this should be changed so that
2840 * process_one_debug_symbol() "knows" when
2841 * to stop reading (based on reading from the MODULE to the matching
2842 * END), and take out this reliance on a #-syms being passed in...
2843 * (I'm worried about the reliability of this number). But I'll
2844 * leave it as-is, for now. - RT
2846 * The change above has been made. I've left the "for" loop control
2847 * in to prepare for backing this out again. -JB
2849 max_symnum
= sym_size
/ sizeof (struct dntt_type_block
);
2850 /* No reason to multiply on pst side and divide on sym side... FIXME */
2852 /* Read in and process each debug symbol within the specified range.
2855 symnum
< max_symnum
;
2858 QUIT
; /* Allow this to be interruptable */
2859 dn_bufp
= hpread_get_lntt (sym_index
+ symnum
, objfile
);
2861 if (dn_bufp
->dblock
.extension
)
2864 /* Yow! We call SET_NAMESTRING on things without names! */
2865 SET_NAMESTRING (dn_bufp
, &namestring
, objfile
);
2867 hpread_process_one_debug_symbol (dn_bufp
, namestring
, section_offsets
,
2868 objfile
, text_offset
, text_size
,
2869 filename
, symnum
+ sym_index
,
2873 /* OLD COMMENTS: This routine is only called for psts. All psts
2874 * correspond to MODULES. If we ever do lazy-reading of globals
2875 * from the LNTT, then there will be a pst which ends when the
2876 * LNTT ends, and not at an END MODULE entry. Then we'll have
2877 * to re-visit this break.
2879 if( at_end_of_module )
2884 /* We no longer break out of the loop when we reach the end of a
2885 module. The reason is that with CTTI, the compiler can generate
2886 function symbols (for template function instantiations) which are not
2887 in any module; typically they show up beyond a module's end, and
2888 before the next module's start. We include them in the current
2889 module. However, we still don't trust the MAX_SYMNUM value from
2890 the psymtab, so we break out if we enter a new module. */
2892 if (at_module_boundary
== -1)
2896 current_objfile
= NULL
;
2897 hp_som_som_object_present
= 1; /* Indicate we've processed an HP SOM SOM file */
2899 return end_symtab (text_offset
+ text_size
, objfile
, SECT_OFF_TEXT (objfile
));
2905 /* Convert basic types from HP debug format into GDB internal format. */
2908 hpread_type_translate (dnttpointer typep
)
2910 if (!typep
.dntti
.immediate
)
2912 error ("error in hpread_type_translate\n.");
2916 switch (typep
.dntti
.type
)
2918 case HP_TYPE_BOOLEAN
:
2919 case HP_TYPE_BOOLEAN_S300_COMPAT
:
2920 case HP_TYPE_BOOLEAN_VAX_COMPAT
:
2922 case HP_TYPE_CHAR
: /* C signed char, C++ plain char */
2924 case HP_TYPE_WIDE_CHAR
:
2927 if (typep
.dntti
.bitlength
<= 8)
2928 return FT_SIGNED_CHAR
; /* C++ signed char */
2929 if (typep
.dntti
.bitlength
<= 16)
2931 if (typep
.dntti
.bitlength
<= 32)
2933 return FT_LONG_LONG
;
2935 if (typep
.dntti
.bitlength
<= 8)
2936 return FT_SIGNED_CHAR
; /* C++ signed char. */
2938 case HP_TYPE_UNSIGNED_LONG
:
2939 if (typep
.dntti
.bitlength
<= 8)
2940 return FT_UNSIGNED_CHAR
; /* C/C++ unsigned char */
2941 if (typep
.dntti
.bitlength
<= 16)
2942 return FT_UNSIGNED_SHORT
;
2943 if (typep
.dntti
.bitlength
<= 32)
2944 return FT_UNSIGNED_LONG
;
2945 return FT_UNSIGNED_LONG_LONG
;
2946 case HP_TYPE_UNSIGNED_INT
:
2947 if (typep
.dntti
.bitlength
<= 8)
2948 return FT_UNSIGNED_CHAR
;
2949 if (typep
.dntti
.bitlength
<= 16)
2950 return FT_UNSIGNED_SHORT
;
2951 if (typep
.dntti
.bitlength
<= 32)
2952 return FT_UNSIGNED_INTEGER
;
2953 return FT_UNSIGNED_LONG_LONG
;
2955 case HP_TYPE_REAL_3000
:
2956 case HP_TYPE_DOUBLE
:
2957 if (typep
.dntti
.bitlength
== 64)
2958 return FT_DBL_PREC_FLOAT
;
2959 if (typep
.dntti
.bitlength
== 128)
2960 return FT_EXT_PREC_FLOAT
;
2962 case HP_TYPE_COMPLEX
:
2963 case HP_TYPE_COMPLEXS3000
:
2964 if (typep
.dntti
.bitlength
== 128)
2965 return FT_DBL_PREC_COMPLEX
;
2966 if (typep
.dntti
.bitlength
== 192)
2967 return FT_EXT_PREC_COMPLEX
;
2971 case HP_TYPE_STRING200
:
2972 case HP_TYPE_LONGSTRING200
:
2973 case HP_TYPE_FTN_STRING_SPEC
:
2974 case HP_TYPE_MOD_STRING_SPEC
:
2975 case HP_TYPE_MOD_STRING_3000
:
2976 case HP_TYPE_FTN_STRING_S300_COMPAT
:
2977 case HP_TYPE_FTN_STRING_VAX_COMPAT
:
2979 case HP_TYPE_TEMPLATE_ARG
:
2980 return FT_TEMPLATE_ARG
;
2982 case HP_TYPE_FLABEL
:
2983 case HP_TYPE_PACKED_DECIMAL
:
2984 case HP_TYPE_ANYPOINTER
:
2985 case HP_TYPE_GLOBAL_ANYPOINTER
:
2986 case HP_TYPE_LOCAL_ANYPOINTER
:
2988 warning ("hpread_type_translate: unhandled type code.\n");
2993 /* Given a position in the DNTT, return a pointer to the
2994 * already-built "struct type" (if any), for the type defined
2998 static struct type
**
2999 hpread_lookup_type (dnttpointer hp_type
, struct objfile
*objfile
)
3002 int index
= hp_type
.dnttp
.index
;
3003 int size_changed
= 0;
3005 /* The immediate flag indicates this doesn't actually point to
3008 if (hp_type
.dntti
.immediate
)
3011 /* For each objfile, we maintain a "type vector".
3012 * This an array of "struct type *"'s with one pointer per DNTT index.
3013 * Given a DNTT index, we look in this array to see if we have
3014 * already processed this DNTT and if it is a type definition.
3015 * If so, then we can locate a pointer to the already-built
3016 * "struct type", and not build it again.
3018 * The need for this arises because our DNTT-walking code wanders
3019 * around. In particular, it will encounter the same type multiple
3020 * times (once for each object of that type). We don't want to
3021 * built multiple "struct type"'s for the same thing.
3023 * Having said this, I should point out that this type-vector is
3024 * an expensive way to keep track of this. If most DNTT entries are
3025 * 3 words, the type-vector will be 1/3 the size of the DNTT itself.
3026 * Alternative solutions:
3027 * - Keep a compressed or hashed table. Less memory, but more expensive
3028 * to search and update.
3029 * - (Suggested by JB): Overwrite the DNTT entry itself
3030 * with the info. Create a new type code "ALREADY_BUILT", and modify
3031 * the DNTT to have that type code and point to the already-built entry.
3035 if (index
< LNTT_SYMCOUNT (objfile
))
3037 if (index
>= DNTT_TYPE_VECTOR_LENGTH (objfile
))
3039 old_len
= DNTT_TYPE_VECTOR_LENGTH (objfile
);
3041 /* See if we need to allocate a type-vector. */
3044 DNTT_TYPE_VECTOR_LENGTH (objfile
) = LNTT_SYMCOUNT (objfile
) + GNTT_SYMCOUNT (objfile
);
3045 DNTT_TYPE_VECTOR (objfile
) = (struct type
**)
3046 xmmalloc (objfile
->md
, DNTT_TYPE_VECTOR_LENGTH (objfile
) * sizeof (struct type
*));
3047 memset (&DNTT_TYPE_VECTOR (objfile
)[old_len
], 0,
3048 (DNTT_TYPE_VECTOR_LENGTH (objfile
) - old_len
) *
3049 sizeof (struct type
*));
3052 /* See if we need to resize type-vector. With my change to
3053 * initially allocate a correct-size type-vector, this code
3054 * should no longer trigger.
3056 while (index
>= DNTT_TYPE_VECTOR_LENGTH (objfile
))
3058 DNTT_TYPE_VECTOR_LENGTH (objfile
) *= 2;
3063 DNTT_TYPE_VECTOR (objfile
) = (struct type
**)
3064 xmrealloc (objfile
->md
,
3065 (char *) DNTT_TYPE_VECTOR (objfile
),
3066 (DNTT_TYPE_VECTOR_LENGTH (objfile
) * sizeof (struct type
*)));
3068 memset (&DNTT_TYPE_VECTOR (objfile
)[old_len
], 0,
3069 (DNTT_TYPE_VECTOR_LENGTH (objfile
) - old_len
) *
3070 sizeof (struct type
*));
3074 return &DNTT_TYPE_VECTOR (objfile
)[index
];
3080 /* Possibly allocate a GDB internal type so we can internalize HP_TYPE.
3081 Note we'll just return the address of a GDB internal type if we already
3082 have it lying around. */
3084 static struct type
*
3085 hpread_alloc_type (dnttpointer hp_type
, struct objfile
*objfile
)
3087 struct type
**type_addr
;
3089 type_addr
= hpread_lookup_type (hp_type
, objfile
);
3090 if (*type_addr
== 0)
3092 *type_addr
= alloc_type (objfile
);
3094 /* A hack - if we really are a C++ class symbol, then this default
3095 * will get overriden later on.
3097 TYPE_CPLUS_SPECIFIC (*type_addr
)
3098 = (struct cplus_struct_type
*) &cplus_struct_default
;
3104 /* Read a native enumerated type and return it in GDB internal form. */
3106 static struct type
*
3107 hpread_read_enum_type (dnttpointer hp_type
, union dnttentry
*dn_bufp
,
3108 struct objfile
*objfile
)
3111 struct pending
**symlist
, *osyms
, *syms
;
3112 struct pending
*local_list
= NULL
;
3113 int o_nsyms
, nsyms
= 0;
3115 union dnttentry
*memp
;
3120 /* Allocate a GDB type. If we've already read in this enum type,
3121 * it'll return the already built GDB type, so stop here.
3122 * (Note: I added this check, to conform with what's done for
3123 * struct, union, class.
3124 * I assume this is OK. - RT)
3126 type
= hpread_alloc_type (hp_type
, objfile
);
3127 if (TYPE_CODE (type
) == TYPE_CODE_ENUM
)
3130 /* HP C supports "sized enums", where a specifier such as "short" or
3131 "char" can be used to get enums of different sizes. So don't assume
3132 an enum is always 4 bytes long. pai/1997-08-21 */
3133 TYPE_LENGTH (type
) = dn_bufp
->denum
.bitlength
/ 8;
3135 symlist
= &file_symbols
;
3137 o_nsyms
= osyms
? osyms
->nsyms
: 0;
3139 /* Get a name for each member and add it to our list of members.
3140 * The list of "mem" SOM records we are walking should all be
3141 * SOM type DNTT_TYPE_MEMENUM (not checked).
3143 mem
= dn_bufp
->denum
.firstmem
;
3144 while (mem
.word
&& mem
.word
!= DNTTNIL
)
3146 memp
= hpread_get_lntt (mem
.dnttp
.index
, objfile
);
3148 name
= VT (objfile
) + memp
->dmember
.name
;
3149 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
3150 sizeof (struct symbol
));
3151 memset (sym
, 0, sizeof (struct symbol
));
3152 SYMBOL_NAME (sym
) = obsavestring (name
, strlen (name
),
3153 &objfile
->symbol_obstack
);
3154 SYMBOL_CLASS (sym
) = LOC_CONST
;
3155 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3156 SYMBOL_VALUE (sym
) = memp
->dmember
.value
;
3157 add_symbol_to_list (sym
, symlist
);
3159 mem
= memp
->dmember
.nextmem
;
3162 /* Now that we know more about the enum, fill in more info. */
3163 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
3164 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
3165 TYPE_NFIELDS (type
) = nsyms
;
3166 TYPE_FIELDS (type
) = (struct field
*)
3167 obstack_alloc (&objfile
->type_obstack
, sizeof (struct field
) * nsyms
);
3169 /* Find the symbols for the members and put them into the type.
3170 The symbols can be found in the symlist that we put them on
3171 to cause them to be defined. osyms contains the old value
3172 of that symlist; everything up to there was defined by us.
3174 Note that we preserve the order of the enum constants, so
3175 that in something like "enum {FOO, LAST_THING=FOO}" we print
3176 FOO, not LAST_THING. */
3177 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
3182 for (; j
< syms
->nsyms
; j
++, n
++)
3184 struct symbol
*xsym
= syms
->symbol
[j
];
3185 SYMBOL_TYPE (xsym
) = type
;
3186 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
3187 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (xsym
);
3188 TYPE_FIELD_BITSIZE (type
, n
) = 0;
3197 /* Read and internalize a native function debug symbol. */
3199 static struct type
*
3200 hpread_read_function_type (dnttpointer hp_type
, union dnttentry
*dn_bufp
,
3201 struct objfile
*objfile
, int newblock
)
3203 struct type
*type
, *type1
;
3204 struct pending
*syms
;
3205 struct pending
*local_list
= NULL
;
3208 union dnttentry
*paramp
;
3212 int record_args
= 1;
3214 /* See if we've already read in this type. */
3215 type
= hpread_alloc_type (hp_type
, objfile
);
3216 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
3218 record_args
= 0; /* already read in, don't modify type */
3222 /* Nope, so read it in and store it away. */
3223 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_FUNCTION
||
3224 dn_bufp
->dblock
.kind
== DNTT_TYPE_MEMFUNC
)
3225 type1
= lookup_function_type (hpread_type_lookup (dn_bufp
->dfunc
.retval
,
3227 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_FUNCTYPE
)
3228 type1
= lookup_function_type (hpread_type_lookup (dn_bufp
->dfunctype
.retval
,
3230 else /* expect DNTT_TYPE_FUNC_TEMPLATE */
3231 type1
= lookup_function_type (hpread_type_lookup (dn_bufp
->dfunc_template
.retval
,
3233 memcpy ((char *) type
, (char *) type1
, sizeof (struct type
));
3235 /* Mark it -- in the middle of processing */
3236 TYPE_FLAGS (type
) |= TYPE_FLAG_INCOMPLETE
;
3239 /* Now examine each parameter noting its type, location, and a
3240 wealth of other information. */
3241 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_FUNCTION
||
3242 dn_bufp
->dblock
.kind
== DNTT_TYPE_MEMFUNC
)
3243 param
= dn_bufp
->dfunc
.firstparam
;
3244 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_FUNCTYPE
)
3245 param
= dn_bufp
->dfunctype
.firstparam
;
3246 else /* expect DNTT_TYPE_FUNC_TEMPLATE */
3247 param
= dn_bufp
->dfunc_template
.firstparam
;
3248 while (param
.word
&& param
.word
!= DNTTNIL
)
3250 paramp
= hpread_get_lntt (param
.dnttp
.index
, objfile
);
3252 param
= paramp
->dfparam
.nextparam
;
3255 name
= VT (objfile
) + paramp
->dfparam
.name
;
3256 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
3257 sizeof (struct symbol
));
3258 (void) memset (sym
, 0, sizeof (struct symbol
));
3259 SYMBOL_NAME (sym
) = obsavestring (name
, strlen (name
),
3260 &objfile
->symbol_obstack
);
3262 /* Figure out where it lives. */
3263 if (paramp
->dfparam
.regparam
)
3264 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
3265 else if (paramp
->dfparam
.indirect
)
3266 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
3268 SYMBOL_CLASS (sym
) = LOC_ARG
;
3269 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3270 if (paramp
->dfparam
.copyparam
)
3272 SYMBOL_VALUE (sym
) = paramp
->dfparam
.location
;
3273 #ifdef HPREAD_ADJUST_STACK_ADDRESS
3275 += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile
));
3277 /* This is likely a pass-by-invisible reference parameter,
3278 Hack on the symbol class to make GDB happy. */
3279 /* ??rehrauer: This appears to be broken w/r/t to passing
3280 C values of type float and struct. Perhaps this ought
3281 to be highighted as a special case, but for now, just
3282 allowing these to be LOC_ARGs seems to work fine.
3285 SYMBOL_CLASS (sym
) = LOC_REGPARM_ADDR
;
3289 SYMBOL_VALUE (sym
) = paramp
->dfparam
.location
;
3292 SYMBOL_TYPE (sym
) = hpread_type_lookup (paramp
->dfparam
.type
, objfile
);
3293 /* Add it to the symbol list. */
3294 /* Note 1 (RT) At the moment, add_symbol_to_list() is also being
3295 * called on FPARAM symbols from the process_one_debug_symbol()
3296 * level... so parameters are getting added twice! (this shows
3297 * up in the symbol dump you get from "maint print symbols ...").
3298 * Note 2 (RT) I took out the processing of FPARAM from the
3299 * process_one_debug_symbol() level, so at the moment parameters are only
3300 * being processed here. This seems to have no ill effect.
3302 /* Note 3 (pai/1997-08-11) I removed the add_symbol_to_list() which put
3303 each fparam on the local_symbols list from here. Now we use the
3304 local_list to which fparams are added below, and set the param_symbols
3305 global to point to that at the end of this routine. */
3306 /* elz: I added this new list of symbols which is local to the function.
3307 this list is the one which is actually used to build the type for the
3308 function rather than the gloabal list pointed to by symlist.
3309 Using a global list to keep track of the parameters is wrong, because
3310 this function is called recursively if one parameter happend to be
3311 a function itself with more parameters in it. Adding parameters to the
3312 same global symbol list would not work!
3313 Actually it did work in case of cc compiled programs where you do
3314 not check the parameter lists of the arguments. */
3315 add_symbol_to_list (sym
, &local_list
);
3319 /* If type was read in earlier, don't bother with modifying
3324 /* Note how many parameters we found. */
3325 TYPE_NFIELDS (type
) = nsyms
;
3326 TYPE_FIELDS (type
) = (struct field
*)
3327 obstack_alloc (&objfile
->type_obstack
,
3328 sizeof (struct field
) * nsyms
);
3330 /* Find the symbols for the parameters and
3331 use them to fill parameter-type information into the function-type.
3332 The parameter symbols can be found in the local_list that we just put them on. */
3333 /* Note that we preserve the order of the parameters, so
3334 that in something like "enum {FOO, LAST_THING=FOO}" we print
3335 FOO, not LAST_THING. */
3337 /* get the parameters types from the local list not the global list
3338 so that the type can be correctly constructed for functions which
3339 have function as parameters */
3340 for (syms
= local_list
, n
= 0; syms
; syms
= syms
->next
)
3343 for (j
= 0; j
< syms
->nsyms
; j
++, n
++)
3345 struct symbol
*xsym
= syms
->symbol
[j
];
3346 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
3347 TYPE_FIELD_TYPE (type
, n
) = SYMBOL_TYPE (xsym
);
3348 TYPE_FIELD_ARTIFICIAL (type
, n
) = 0;
3349 TYPE_FIELD_BITSIZE (type
, n
) = 0;
3352 /* Mark it as having been processed */
3353 TYPE_FLAGS (type
) &= ~(TYPE_FLAG_INCOMPLETE
);
3355 /* Check whether we need to fix-up a class type with this function's type */
3356 if (fixup_class
&& (fixup_method
== type
))
3358 fixup_class_method_type (fixup_class
, fixup_method
, objfile
);
3360 fixup_method
= NULL
;
3363 /* Set the param list of this level of the context stack
3364 to our local list. Do this only if this function was
3365 called for creating a new block, and not if it was called
3366 simply to get the function type. This prevents recursive
3367 invocations from trashing param_symbols. */
3370 param_symbols
= local_list
;
3376 /* Read and internalize a native DOC function debug symbol. */
3377 /* This is almost identical to hpread_read_function_type(), except
3378 * for references to dn_bufp->ddocfunc instead of db_bufp->dfunc.
3379 * Since debug information for DOC functions is more likely to be
3380 * volatile, please leave it this way.
3382 static struct type
*
3383 hpread_read_doc_function_type (dnttpointer hp_type
, union dnttentry
*dn_bufp
,
3384 struct objfile
*objfile
, int newblock
)
3386 struct type
*type
, *type1
;
3387 struct pending
*syms
;
3388 struct pending
*local_list
= NULL
;
3391 union dnttentry
*paramp
;
3395 int record_args
= 1;
3397 /* See if we've already read in this type. */
3398 type
= hpread_alloc_type (hp_type
, objfile
);
3399 if (TYPE_CODE (type
) == TYPE_CODE_FUNC
)
3401 record_args
= 0; /* already read in, don't modify type */
3405 /* Nope, so read it in and store it away. */
3406 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_DOC_FUNCTION
||
3407 dn_bufp
->dblock
.kind
== DNTT_TYPE_DOC_MEMFUNC
)
3408 type1
= lookup_function_type (hpread_type_lookup (dn_bufp
->ddocfunc
.retval
,
3410 memcpy ((char *) type
, (char *) type1
, sizeof (struct type
));
3412 /* Mark it -- in the middle of processing */
3413 TYPE_FLAGS (type
) |= TYPE_FLAG_INCOMPLETE
;
3416 /* Now examine each parameter noting its type, location, and a
3417 wealth of other information. */
3418 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_DOC_FUNCTION
||
3419 dn_bufp
->dblock
.kind
== DNTT_TYPE_DOC_MEMFUNC
)
3420 param
= dn_bufp
->ddocfunc
.firstparam
;
3421 while (param
.word
&& param
.word
!= DNTTNIL
)
3423 paramp
= hpread_get_lntt (param
.dnttp
.index
, objfile
);
3425 param
= paramp
->dfparam
.nextparam
;
3428 name
= VT (objfile
) + paramp
->dfparam
.name
;
3429 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
3430 sizeof (struct symbol
));
3431 (void) memset (sym
, 0, sizeof (struct symbol
));
3432 SYMBOL_NAME (sym
) = name
;
3434 /* Figure out where it lives. */
3435 if (paramp
->dfparam
.regparam
)
3436 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
3437 else if (paramp
->dfparam
.indirect
)
3438 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
3440 SYMBOL_CLASS (sym
) = LOC_ARG
;
3441 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
3442 if (paramp
->dfparam
.copyparam
)
3444 SYMBOL_VALUE (sym
) = paramp
->dfparam
.location
;
3445 #ifdef HPREAD_ADJUST_STACK_ADDRESS
3447 += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile
));
3449 /* This is likely a pass-by-invisible reference parameter,
3450 Hack on the symbol class to make GDB happy. */
3451 /* ??rehrauer: This appears to be broken w/r/t to passing
3452 C values of type float and struct. Perhaps this ought
3453 to be highighted as a special case, but for now, just
3454 allowing these to be LOC_ARGs seems to work fine.
3457 SYMBOL_CLASS (sym
) = LOC_REGPARM_ADDR
;
3461 SYMBOL_VALUE (sym
) = paramp
->dfparam
.location
;
3464 SYMBOL_TYPE (sym
) = hpread_type_lookup (paramp
->dfparam
.type
, objfile
);
3465 /* Add it to the symbol list. */
3466 /* Note 1 (RT) At the moment, add_symbol_to_list() is also being
3467 * called on FPARAM symbols from the process_one_debug_symbol()
3468 * level... so parameters are getting added twice! (this shows
3469 * up in the symbol dump you get from "maint print symbols ...").
3470 * Note 2 (RT) I took out the processing of FPARAM from the
3471 * process_one_debug_symbol() level, so at the moment parameters are only
3472 * being processed here. This seems to have no ill effect.
3474 /* Note 3 (pai/1997-08-11) I removed the add_symbol_to_list() which put
3475 each fparam on the local_symbols list from here. Now we use the
3476 local_list to which fparams are added below, and set the param_symbols
3477 global to point to that at the end of this routine. */
3479 /* elz: I added this new list of symbols which is local to the function.
3480 this list is the one which is actually used to build the type for the
3481 function rather than the gloabal list pointed to by symlist.
3482 Using a global list to keep track of the parameters is wrong, because
3483 this function is called recursively if one parameter happend to be
3484 a function itself with more parameters in it. Adding parameters to the
3485 same global symbol list would not work!
3486 Actually it did work in case of cc compiled programs where you do not check the
3487 parameter lists of the arguments. */
3488 add_symbol_to_list (sym
, &local_list
);
3491 /* If type was read in earlier, don't bother with modifying
3496 /* Note how many parameters we found. */
3497 TYPE_NFIELDS (type
) = nsyms
;
3498 TYPE_FIELDS (type
) = (struct field
*)
3499 obstack_alloc (&objfile
->type_obstack
,
3500 sizeof (struct field
) * nsyms
);
3502 /* Find the symbols for the parameters and
3503 use them to fill parameter-type information into the function-type.
3504 The parameter symbols can be found in the local_list that we just put them on. */
3505 /* Note that we preserve the order of the parameters, so
3506 that in something like "enum {FOO, LAST_THING=FOO}" we print
3507 FOO, not LAST_THING. */
3509 /* get the parameters types from the local list not the global list
3510 so that the type can be correctly constructed for functions which
3511 have function as parameters
3513 for (syms
= local_list
, n
= 0; syms
; syms
= syms
->next
)
3516 for (j
= 0; j
< syms
->nsyms
; j
++, n
++)
3518 struct symbol
*xsym
= syms
->symbol
[j
];
3519 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
3520 TYPE_FIELD_TYPE (type
, n
) = SYMBOL_TYPE (xsym
);
3521 TYPE_FIELD_ARTIFICIAL (type
, n
) = 0;
3522 TYPE_FIELD_BITSIZE (type
, n
) = 0;
3526 /* Mark it as having been processed */
3527 TYPE_FLAGS (type
) &= ~(TYPE_FLAG_INCOMPLETE
);
3529 /* Check whether we need to fix-up a class type with this function's type */
3530 if (fixup_class
&& (fixup_method
== type
))
3532 fixup_class_method_type (fixup_class
, fixup_method
, objfile
);
3534 fixup_method
= NULL
;
3537 /* Set the param list of this level of the context stack
3538 to our local list. Do this only if this function was
3539 called for creating a new block, and not if it was called
3540 simply to get the function type. This prevents recursive
3541 invocations from trashing param_symbols. */
3544 param_symbols
= local_list
;
3551 /* A file-level variable which keeps track of the current-template
3552 * being processed. Set in hpread_read_struct_type() while processing
3553 * a template type. Referred to in hpread_get_nth_templ_arg().
3554 * Yes, this is a kludge, but it arises from the kludge that already
3555 * exists in symtab.h, namely the fact that they encode
3556 * "template argument n" with fundamental type FT_TEMPLATE_ARG and
3557 * bitlength n. This means that deep in processing fundamental types
3558 * I need to ask the question "what template am I in the middle of?".
3559 * The alternative to stuffing a global would be to pass an argument
3560 * down the chain of calls just for this purpose.
3562 * There may be problems handling nested templates... tough.
3564 static struct type
*current_template
= NULL
;
3566 /* Read in and internalize a structure definition.
3567 * This same routine is called for struct, union, and class types.
3568 * Also called for templates, since they build a very similar
3569 * type entry as for class types.
3572 static struct type
*
3573 hpread_read_struct_type (dnttpointer hp_type
, union dnttentry
*dn_bufp
,
3574 struct objfile
*objfile
)
3576 /* The data members get linked together into a list of struct nextfield's */
3579 struct nextfield
*next
;
3581 unsigned char attributes
; /* store visibility and virtuality info */
3582 #define ATTR_VIRTUAL 1
3583 #define ATTR_PRIVATE 2
3584 #define ATTR_PROTECT 3
3588 /* The methods get linked together into a list of struct next_fn_field's */
3589 struct next_fn_field
3591 struct next_fn_field
*next
;
3592 struct fn_fieldlist field
;
3593 struct fn_field fn_field
;
3597 /* The template args get linked together into a list of struct next_template's */
3598 struct next_template
3600 struct next_template
*next
;
3601 struct template_arg arg
;
3604 /* The template instantiations get linked together into a list of these... */
3605 struct next_instantiation
3607 struct next_instantiation
*next
;
3612 struct type
*baseclass
;
3613 struct type
*memtype
;
3614 struct nextfield
*list
= 0, *tmp_list
= 0;
3615 struct next_fn_field
*fn_list
= 0;
3616 struct next_fn_field
*fn_p
;
3617 struct next_template
*t_new
, *t_list
= 0;
3618 struct nextfield
*new;
3619 struct next_fn_field
*fn_new
;
3620 struct next_instantiation
*i_new
, *i_list
= 0;
3621 int n
, nfields
= 0, n_fn_fields
= 0, n_fn_fields_total
= 0;
3622 int n_base_classes
= 0, n_templ_args
= 0;
3623 int ninstantiations
= 0;
3624 dnttpointer field
, fn_field
, parent
;
3625 union dnttentry
*fieldp
, *fn_fieldp
, *parentp
;
3627 int static_member
= 0;
3628 int const_member
= 0;
3629 int volatile_member
= 0;
3630 unsigned long vtbl_offset
;
3631 int need_bitvectors
= 0;
3632 char *method_name
= NULL
;
3633 char *method_alias
= NULL
;
3636 /* Is it something we've already dealt with? */
3637 type
= hpread_alloc_type (hp_type
, objfile
);
3638 if ((TYPE_CODE (type
) == TYPE_CODE_STRUCT
) ||
3639 (TYPE_CODE (type
) == TYPE_CODE_UNION
) ||
3640 (TYPE_CODE (type
) == TYPE_CODE_CLASS
) ||
3641 (TYPE_CODE (type
) == TYPE_CODE_TEMPLATE
))
3644 /* Get the basic type correct. */
3645 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_STRUCT
)
3647 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
3648 TYPE_LENGTH (type
) = dn_bufp
->dstruct
.bitlength
/ 8;
3650 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_UNION
)
3652 TYPE_CODE (type
) = TYPE_CODE_UNION
;
3653 TYPE_LENGTH (type
) = dn_bufp
->dunion
.bitlength
/ 8;
3655 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_CLASS
)
3657 TYPE_CODE (type
) = TYPE_CODE_CLASS
;
3658 TYPE_LENGTH (type
) = dn_bufp
->dclass
.bitlength
/ 8;
3660 /* Overrides the TYPE_CPLUS_SPECIFIC(type) with allocated memory
3661 * rather than &cplus_struct_default.
3663 allocate_cplus_struct_type (type
);
3665 /* Fill in declared-type.
3666 * (The C++ compiler will emit TYPE_CODE_CLASS
3667 * for all 3 of "class", "struct"
3668 * "union", and we have to look at the "class_decl" field if we
3669 * want to know how it was really declared)
3671 /* (0==class, 1==union, 2==struct) */
3672 TYPE_DECLARED_TYPE (type
) = dn_bufp
->dclass
.class_decl
;
3674 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_TEMPLATE
)
3676 /* Get the basic type correct. */
3677 TYPE_CODE (type
) = TYPE_CODE_TEMPLATE
;
3678 allocate_cplus_struct_type (type
);
3679 TYPE_DECLARED_TYPE (type
) = DECLARED_TYPE_TEMPLATE
;
3685 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
3687 /* For classes, read the parent list.
3688 * Question (RT): Do we need to do this for templates also?
3690 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_CLASS
)
3693 /* First read the parent-list (classes from which we derive fields) */
3694 parent
= dn_bufp
->dclass
.parentlist
;
3695 while (parent
.word
&& parent
.word
!= DNTTNIL
)
3697 parentp
= hpread_get_lntt (parent
.dnttp
.index
, objfile
);
3699 /* "parentp" should point to a DNTT_TYPE_INHERITANCE record */
3701 /* Get space to record the next field/data-member. */
3702 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
3706 FIELD_BITSIZE (list
->field
) = 0;
3708 /* The "classname" field is actually a DNTT pointer to the base class */
3709 baseclass
= hpread_type_lookup (parentp
->dinheritance
.classname
,
3711 FIELD_TYPE (list
->field
) = baseclass
;
3713 list
->field
.name
= type_name_no_tag (FIELD_TYPE (list
->field
));
3715 list
->attributes
= 0;
3717 /* Check for virtuality of base, and set the
3718 * offset of the base subobject within the object.
3719 * (Offset set to -1 for virtual bases (for now).)
3721 if (parentp
->dinheritance
.Virtual
)
3723 B_SET (&(list
->attributes
), ATTR_VIRTUAL
);
3724 parentp
->dinheritance
.offset
= -1;
3727 FIELD_BITPOS (list
->field
) = parentp
->dinheritance
.offset
;
3729 /* Check visibility */
3730 switch (parentp
->dinheritance
.visibility
)
3733 B_SET (&(list
->attributes
), ATTR_PROTECT
);
3736 B_SET (&(list
->attributes
), ATTR_PRIVATE
);
3743 parent
= parentp
->dinheritance
.next
;
3747 /* For templates, read the template argument list.
3748 * This must be done before processing the member list, because
3749 * the member list may refer back to this. E.g.:
3750 * template <class T1, class T2> class q2 {
3755 * We need to read the argument list "T1", "T2" first.
3757 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_TEMPLATE
)
3759 /* Kludge alert: This stuffs a global "current_template" which
3760 * is referred to by hpread_get_nth_templ_arg(). The global
3761 * is cleared at the end of this routine.
3763 current_template
= type
;
3765 /* Read in the argument list */
3766 field
= dn_bufp
->dtemplate
.arglist
;
3767 while (field
.word
&& field
.word
!= DNTTNIL
)
3769 /* Get this template argument */
3770 fieldp
= hpread_get_lntt (field
.dnttp
.index
, objfile
);
3771 if (fieldp
->dblock
.kind
!= DNTT_TYPE_TEMPLATE_ARG
)
3773 warning ("Invalid debug info: Template argument entry is of wrong kind");
3776 /* Bump the count */
3778 /* Allocate and fill in a struct next_template */
3779 t_new
= (struct next_template
*) alloca (sizeof (struct next_template
));
3780 t_new
->next
= t_list
;
3782 t_list
->arg
.name
= VT (objfile
) + fieldp
->dtempl_arg
.name
;
3783 t_list
->arg
.type
= hpread_read_templ_arg_type (field
, fieldp
,
3784 objfile
, t_list
->arg
.name
);
3785 /* Walk to the next template argument */
3786 field
= fieldp
->dtempl_arg
.nextarg
;
3790 TYPE_NTEMPLATE_ARGS (type
) = n_templ_args
;
3792 if (n_templ_args
> 0)
3793 TYPE_TEMPLATE_ARGS (type
) = (struct template_arg
*)
3794 obstack_alloc (&objfile
->type_obstack
, sizeof (struct template_arg
) * n_templ_args
);
3795 for (n
= n_templ_args
; t_list
; t_list
= t_list
->next
)
3798 TYPE_TEMPLATE_ARG (type
, n
) = t_list
->arg
;
3801 /* Next read in and internalize all the fields/members. */
3802 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_STRUCT
)
3803 field
= dn_bufp
->dstruct
.firstfield
;
3804 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_UNION
)
3805 field
= dn_bufp
->dunion
.firstfield
;
3806 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_CLASS
)
3807 field
= dn_bufp
->dclass
.memberlist
;
3808 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_TEMPLATE
)
3809 field
= dn_bufp
->dtemplate
.memberlist
;
3811 field
.word
= DNTTNIL
;
3813 while (field
.word
&& field
.word
!= DNTTNIL
)
3815 fieldp
= hpread_get_lntt (field
.dnttp
.index
, objfile
);
3817 /* At this point "fieldp" may point to either a DNTT_TYPE_FIELD
3818 * or a DNTT_TYPE_GENFIELD record.
3823 volatile_member
= 0;
3825 if (fieldp
->dblock
.kind
== DNTT_TYPE_GENFIELD
)
3828 /* The type will be GENFIELD if the field is a method or
3829 * a static member (or some other cases -- see below)
3832 /* Follow a link to get to the record for the field. */
3833 fn_field
= fieldp
->dgenfield
.field
;
3834 fn_fieldp
= hpread_get_lntt (fn_field
.dnttp
.index
, objfile
);
3836 /* Virtual funcs are indicated by a VFUNC which points to the
3839 if (fn_fieldp
->dblock
.kind
== DNTT_TYPE_VFUNC
)
3841 vtbl_offset
= fn_fieldp
->dvfunc
.vtbl_offset
;
3842 fn_field
= fn_fieldp
->dvfunc
.funcptr
;
3843 fn_fieldp
= hpread_get_lntt (fn_field
.dnttp
.index
, objfile
);
3846 /* A function's entry may be preceded by a modifier which
3847 * labels it static/constant/volatile.
3849 if (fn_fieldp
->dblock
.kind
== DNTT_TYPE_MODIFIER
)
3851 static_member
= fn_fieldp
->dmodifier
.m_static
;
3852 const_member
= fn_fieldp
->dmodifier
.m_const
;
3853 volatile_member
= fn_fieldp
->dmodifier
.m_volatile
;
3854 fn_field
= fn_fieldp
->dmodifier
.type
;
3855 fn_fieldp
= hpread_get_lntt (fn_field
.dnttp
.index
, objfile
);
3858 /* Check whether we have a method */
3859 if ((fn_fieldp
->dblock
.kind
== DNTT_TYPE_MEMFUNC
) ||
3860 (fn_fieldp
->dblock
.kind
== DNTT_TYPE_FUNCTION
) ||
3861 (fn_fieldp
->dblock
.kind
== DNTT_TYPE_DOC_MEMFUNC
) ||
3862 (fn_fieldp
->dblock
.kind
== DNTT_TYPE_DOC_FUNCTION
))
3868 /* Look up function type of method */
3869 memtype
= hpread_type_lookup (fn_field
, objfile
);
3871 /* Methods can be seen before classes in the SOM records.
3872 If we are processing this class because it's a parameter of a
3873 method, at this point the method's type is actually incomplete;
3874 we'll have to fix it up later; mark the class for this. */
3876 if (TYPE_INCOMPLETE (memtype
))
3878 TYPE_FLAGS (type
) |= TYPE_FLAG_INCOMPLETE
;
3880 warning ("Two classes to fix up for method?? Type information may be incorrect for some classes.");
3882 warning ("Two methods to be fixed up at once?? Type information may be incorrect for some classes.");
3883 fixup_class
= type
; /* remember this class has to be fixed up */
3884 fixup_method
= memtype
; /* remember the method type to be used in fixup */
3887 /* HP aCC generates operator names without the "operator" keyword, and
3888 generates null strings as names for operators that are
3889 user-defined type conversions to basic types (e.g. operator int ()).
3890 So try to reconstruct name as best as possible. */
3892 method_name
= (char *) (VT (objfile
) + fn_fieldp
->dfunc
.name
);
3893 method_alias
= (char *) (VT (objfile
) + fn_fieldp
->dfunc
.alias
);
3895 if (!method_name
|| /* no name */
3896 !*method_name
|| /* or null name */
3897 cplus_mangle_opname (method_name
, DMGL_ANSI
)) /* or name is an operator like "<" */
3899 char *tmp_name
= cplus_demangle (method_alias
, DMGL_ANSI
);
3900 char *op_string
= strstr (tmp_name
, "operator");
3901 method_name
= xmalloc (strlen (op_string
) + 1); /* don't overwrite VT! */
3902 strcpy (method_name
, op_string
);
3905 /* First check if a method of the same name has already been seen. */
3909 if (STREQ (fn_p
->field
.name
, method_name
))
3914 /* If no such method was found, allocate a new entry in the list */
3917 /* Get space to record this member function */
3918 /* Note: alloca used; this will disappear on routine exit */
3919 fn_new
= (struct next_fn_field
*) alloca (sizeof (struct next_fn_field
));
3920 fn_new
->next
= fn_list
;
3923 /* Fill in the fields of the struct nextfield */
3925 /* Record the (unmangled) method name */
3926 fn_list
->field
.name
= method_name
;
3927 /* Initial space for overloaded methods */
3928 /* Note: xmalloc is used; this will persist after this routine exits */
3929 fn_list
->field
.fn_fields
= (struct fn_field
*) xmalloc (5 * (sizeof (struct fn_field
)));
3930 fn_list
->field
.length
= 1; /* Init # of overloaded instances */
3931 fn_list
->num_fn_fields
= 5; /* # of entries for which space allocated */
3933 ix
= 0; /* array index for fn_field */
3934 /* Bump the total count of the distinctly named methods */
3938 /* Another overloaded instance of an already seen method name */
3940 if (++(fn_p
->field
.length
) > fn_p
->num_fn_fields
)
3942 /* Increase space allocated for overloaded instances */
3943 fn_p
->field
.fn_fields
3944 = (struct fn_field
*) xrealloc (fn_p
->field
.fn_fields
,
3945 (fn_p
->num_fn_fields
+ 5) * sizeof (struct fn_field
));
3946 fn_p
->num_fn_fields
+= 5;
3948 ix
= fn_p
->field
.length
- 1; /* array index for fn_field */
3951 /* "physname" is intended to be the name of this overloaded instance. */
3952 if ((fn_fieldp
->dfunc
.language
== HP_LANGUAGE_CPLUSPLUS
) &&
3954 *method_alias
) /* not a null string */
3955 fn_p
->field
.fn_fields
[ix
].physname
= method_alias
;
3957 fn_p
->field
.fn_fields
[ix
].physname
= method_name
;
3958 /* What's expected here is the function type */
3959 /* But mark it as NULL if the method was incompletely processed
3960 We'll fix this up later when the method is fully processed */
3961 if (TYPE_INCOMPLETE (memtype
))
3963 fn_p
->field
.fn_fields
[ix
].type
= NULL
;
3964 fn_p
->field
.fn_fields
[ix
].args
= NULL
;
3968 fn_p
->field
.fn_fields
[ix
].type
= memtype
;
3970 /* The argument list */
3971 fn_p
->field
.fn_fields
[ix
].type
->type_specific
.arg_types
=
3972 (struct type
**) obstack_alloc (&objfile
->type_obstack
,
3973 sizeof (struct type
*) * (memtype
->nfields
+ 1));
3974 for (i
= 0; i
< memtype
->nfields
; i
++)
3975 fn_p
->field
.fn_fields
[ix
].type
->type_specific
.arg_types
[i
] = memtype
->fields
[i
].type
;
3976 /* void termination */
3977 fn_p
->field
.fn_fields
[ix
].type
->type_specific
.arg_types
[memtype
->nfields
] = builtin_type_void
;
3979 /* pai: It's not clear why this args field has to be set. Perhaps
3980 * it should be eliminated entirely. */
3981 fn_p
->field
.fn_fields
[ix
].args
=
3982 (struct type
**) obstack_alloc (&objfile
->type_obstack
,
3983 sizeof (struct type
*) * (memtype
->nfields
+ 1));
3984 for (i
= 0; i
< memtype
->nfields
; i
++)
3985 fn_p
->field
.fn_fields
[ix
].args
[i
] = memtype
->fields
[i
].type
;
3986 /* null-terminated, unlike arg_types above e */
3987 fn_p
->field
.fn_fields
[ix
].args
[memtype
->nfields
] = NULL
;
3989 /* For virtual functions, fill in the voffset field with the
3990 * virtual table offset. (This is just copied over from the
3991 * SOM record; not sure if it is what GDB expects here...).
3992 * But if the function is a static method, set it to 1.
3994 * Note that we have to add 1 because 1 indicates a static
3995 * method, and 0 indicates a non-static, non-virtual method */
3998 fn_p
->field
.fn_fields
[ix
].voffset
= VOFFSET_STATIC
;
4000 fn_p
->field
.fn_fields
[ix
].voffset
= vtbl_offset
? vtbl_offset
+ 1 : 0;
4002 /* Also fill in the fcontext field with the current
4003 * class. (The latter isn't quite right: should be the baseclass
4004 * that defines the virtual function... Note we do have
4005 * a variable "baseclass" that we could stuff into the fcontext
4006 * field, but "baseclass" isn't necessarily right either,
4007 * since the virtual function could have been defined more
4008 * than one level up).
4011 if (vtbl_offset
!= 0)
4012 fn_p
->field
.fn_fields
[ix
].fcontext
= type
;
4014 fn_p
->field
.fn_fields
[ix
].fcontext
= NULL
;
4016 /* Other random fields pertaining to this method */
4017 fn_p
->field
.fn_fields
[ix
].is_const
= const_member
;
4018 fn_p
->field
.fn_fields
[ix
].is_volatile
= volatile_member
; /* ?? */
4019 switch (fieldp
->dgenfield
.visibility
)
4022 fn_p
->field
.fn_fields
[ix
].is_protected
= 1;
4023 fn_p
->field
.fn_fields
[ix
].is_private
= 0;
4026 fn_p
->field
.fn_fields
[ix
].is_protected
= 0;
4027 fn_p
->field
.fn_fields
[ix
].is_private
= 1;
4029 default: /* public */
4030 fn_p
->field
.fn_fields
[ix
].is_protected
= 0;
4031 fn_p
->field
.fn_fields
[ix
].is_private
= 0;
4033 fn_p
->field
.fn_fields
[ix
].is_stub
= 0;
4035 /* HP aCC emits both MEMFUNC and FUNCTION entries for a method;
4036 if the class points to the FUNCTION, there is usually separate
4037 code for the method; but if we have a MEMFUNC, the method has
4038 been inlined (and there is usually no FUNCTION entry)
4039 FIXME Not sure if this test is accurate. pai/1997-08-22 */
4040 if ((fn_fieldp
->dblock
.kind
== DNTT_TYPE_MEMFUNC
) ||
4041 (fn_fieldp
->dblock
.kind
== DNTT_TYPE_DOC_MEMFUNC
))
4042 fn_p
->field
.fn_fields
[ix
].is_inlined
= 1;
4044 fn_p
->field
.fn_fields
[ix
].is_inlined
= 0;
4046 fn_p
->field
.fn_fields
[ix
].dummy
= 0;
4048 /* Bump the total count of the member functions */
4049 n_fn_fields_total
++;
4052 else if (fn_fieldp
->dblock
.kind
== DNTT_TYPE_SVAR
)
4054 /* This case is for static data members of classes */
4056 /* pai:: FIXME -- check that "staticmem" bit is set */
4058 /* Get space to record this static member */
4059 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
4063 list
->field
.name
= VT (objfile
) + fn_fieldp
->dsvar
.name
;
4064 FIELD_BITSIZE (list
->field
) = -1; /* indicates static member */
4065 SET_FIELD_PHYSNAME (list
->field
, 0); /* initialize to empty */
4066 memtype
= hpread_type_lookup (fn_fieldp
->dsvar
.type
, objfile
);
4068 FIELD_TYPE (list
->field
) = memtype
;
4069 list
->attributes
= 0;
4070 switch (fieldp
->dgenfield
.visibility
)
4073 B_SET (&(list
->attributes
), ATTR_PROTECT
);
4076 B_SET (&(list
->attributes
), ATTR_PRIVATE
);
4082 else if (fn_fieldp
->dblock
.kind
== DNTT_TYPE_FIELD
)
4084 /* FIELDs follow GENFIELDs for fields of anonymous unions.
4085 Code below is replicated from the case for FIELDs further
4086 below, except that fieldp is replaced by fn_fieldp */
4087 if (!fn_fieldp
->dfield
.a_union
)
4088 warning ("Debug info inconsistent: FIELD of anonymous union doesn't have a_union bit set");
4089 /* Get space to record the next field/data-member. */
4090 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
4094 list
->field
.name
= VT (objfile
) + fn_fieldp
->dfield
.name
;
4095 FIELD_BITPOS (list
->field
) = fn_fieldp
->dfield
.bitoffset
;
4096 if (fn_fieldp
->dfield
.bitlength
% 8)
4097 list
->field
.bitsize
= fn_fieldp
->dfield
.bitlength
;
4099 list
->field
.bitsize
= 0;
4101 memtype
= hpread_type_lookup (fn_fieldp
->dfield
.type
, objfile
);
4102 list
->field
.type
= memtype
;
4103 list
->attributes
= 0;
4104 switch (fn_fieldp
->dfield
.visibility
)
4107 B_SET (&(list
->attributes
), ATTR_PROTECT
);
4110 B_SET (&(list
->attributes
), ATTR_PRIVATE
);
4115 else if (fn_fieldp
->dblock
.kind
== DNTT_TYPE_SVAR
)
4117 /* Field of anonymous union; union is not inside a class */
4118 if (!fn_fieldp
->dsvar
.a_union
)
4119 warning ("Debug info inconsistent: SVAR field in anonymous union doesn't have a_union bit set");
4120 /* Get space to record the next field/data-member. */
4121 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
4125 list
->field
.name
= VT (objfile
) + fn_fieldp
->dsvar
.name
;
4126 FIELD_BITPOS (list
->field
) = 0; /* FIXME is this always true? */
4127 FIELD_BITSIZE (list
->field
) = 0; /* use length from type */
4128 memtype
= hpread_type_lookup (fn_fieldp
->dsvar
.type
, objfile
);
4129 list
->field
.type
= memtype
;
4130 list
->attributes
= 0;
4131 /* No info to set visibility -- always public */
4134 else if (fn_fieldp
->dblock
.kind
== DNTT_TYPE_DVAR
)
4136 /* Field of anonymous union; union is not inside a class */
4137 if (!fn_fieldp
->ddvar
.a_union
)
4138 warning ("Debug info inconsistent: DVAR field in anonymous union doesn't have a_union bit set");
4139 /* Get space to record the next field/data-member. */
4140 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
4144 list
->field
.name
= VT (objfile
) + fn_fieldp
->ddvar
.name
;
4145 FIELD_BITPOS (list
->field
) = 0; /* FIXME is this always true? */
4146 FIELD_BITSIZE (list
->field
) = 0; /* use length from type */
4147 memtype
= hpread_type_lookup (fn_fieldp
->ddvar
.type
, objfile
);
4148 list
->field
.type
= memtype
;
4149 list
->attributes
= 0;
4150 /* No info to set visibility -- always public */
4154 { /* Not a method, nor a static data member, nor an anon union field */
4156 /* This case is for miscellaneous type entries (local enums,
4157 local function templates, etc.) that can be present
4160 /* Enums -- will be handled by other code that takes care
4161 of DNTT_TYPE_ENUM; here we see only DNTT_TYPE_MEMENUM so
4162 it's not clear we could have handled them here at all. */
4163 /* FUNC_TEMPLATE: is handled by other code (?). */
4164 /* MEMACCESS: modified access for inherited member. Not
4165 sure what to do with this, ignoriing it at present. */
4167 /* What other entries can appear following a GENFIELD which
4168 we do not handle above? (MODIFIER, VFUNC handled above.) */
4170 if ((fn_fieldp
->dblock
.kind
!= DNTT_TYPE_MEMACCESS
) &&
4171 (fn_fieldp
->dblock
.kind
!= DNTT_TYPE_MEMENUM
) &&
4172 (fn_fieldp
->dblock
.kind
!= DNTT_TYPE_FUNC_TEMPLATE
))
4173 warning ("Internal error: Unexpected debug record kind %d found following DNTT_GENFIELD",
4174 fn_fieldp
->dblock
.kind
);
4176 /* walk to the next FIELD or GENFIELD */
4177 field
= fieldp
->dgenfield
.nextfield
;
4180 else if (fieldp
->dblock
.kind
== DNTT_TYPE_FIELD
)
4183 /* Ordinary structure/union/class field */
4184 struct type
*anon_union_type
;
4186 /* Get space to record the next field/data-member. */
4187 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
4191 list
->field
.name
= VT (objfile
) + fieldp
->dfield
.name
;
4194 /* A FIELD by itself (without a GENFIELD) can also be a static member */
4195 if (fieldp
->dfield
.staticmem
)
4197 FIELD_BITPOS (list
->field
) = -1;
4198 FIELD_BITSIZE (list
->field
) = 0;
4201 /* Non-static data member */
4203 FIELD_BITPOS (list
->field
) = fieldp
->dfield
.bitoffset
;
4204 if (fieldp
->dfield
.bitlength
% 8)
4205 FIELD_BITSIZE (list
->field
) = fieldp
->dfield
.bitlength
;
4207 FIELD_BITSIZE (list
->field
) = 0;
4210 memtype
= hpread_type_lookup (fieldp
->dfield
.type
, objfile
);
4211 FIELD_TYPE (list
->field
) = memtype
;
4212 list
->attributes
= 0;
4213 switch (fieldp
->dfield
.visibility
)
4216 B_SET (&(list
->attributes
), ATTR_PROTECT
);
4219 B_SET (&(list
->attributes
), ATTR_PRIVATE
);
4225 /* Note 1: First, we have to check if the current field is an anonymous
4226 union. If it is, then *its* fields are threaded along in the
4227 nextfield chain. :-( This was supposed to help debuggers, but is
4228 really just a nuisance since we deal with anonymous unions anyway by
4229 checking that the name is null. So anyway, we skip over the fields
4230 of the anonymous union. pai/1997-08-22 */
4231 /* Note 2: In addition, the bitoffsets for the fields of the anon union
4232 are relative to the enclosing struct, *NOT* relative to the anon
4233 union! This is an even bigger nuisance -- we have to go in and munge
4234 the anon union's type information appropriately. pai/1997-08-22 */
4236 /* Both tasks noted above are done by a separate function. This takes us
4237 to the next FIELD or GENFIELD, skipping anon unions, and recursively
4238 processing intermediate types. */
4239 field
= hpread_get_next_skip_over_anon_unions (1, field
, &fieldp
, objfile
);
4244 /* neither field nor genfield ?? is this possible?? */
4245 /* pai:: FIXME walk to the next -- how? */
4246 warning ("Internal error: unexpected DNTT kind %d encountered as field of struct",
4247 fieldp
->dblock
.kind
);
4248 warning ("Skipping remaining fields of struct");
4249 break; /* get out of loop of fields */
4253 /* If it's a template, read in the instantiation list */
4254 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_TEMPLATE
)
4256 ninstantiations
= 0;
4257 field
= dn_bufp
->dtemplate
.expansions
;
4258 while (field
.word
&& field
.word
!= DNTTNIL
)
4260 fieldp
= hpread_get_lntt (field
.dnttp
.index
, objfile
);
4262 /* The expansions or nextexp should point to a tagdef */
4263 if (fieldp
->dblock
.kind
!= DNTT_TYPE_TAGDEF
)
4266 i_new
= (struct next_instantiation
*) alloca (sizeof (struct next_instantiation
));
4267 i_new
->next
= i_list
;
4269 i_list
->t
= hpread_type_lookup (field
, objfile
);
4272 /* And the "type" field of that should point to a class */
4273 field
= fieldp
->dtag
.type
;
4274 fieldp
= hpread_get_lntt (field
.dnttp
.index
, objfile
);
4275 if (fieldp
->dblock
.kind
!= DNTT_TYPE_CLASS
)
4278 /* Get the next expansion */
4279 field
= fieldp
->dclass
.nextexp
;
4282 TYPE_NINSTANTIATIONS (type
) = ninstantiations
;
4283 if (ninstantiations
> 0)
4284 TYPE_INSTANTIATIONS (type
) = (struct type
**)
4285 obstack_alloc (&objfile
->type_obstack
, sizeof (struct type
*) * ninstantiations
);
4286 for (n
= ninstantiations
; i_list
; i_list
= i_list
->next
)
4289 TYPE_INSTANTIATION (type
, n
) = i_list
->t
;
4293 /* Copy the field-list to GDB's symbol table */
4294 TYPE_NFIELDS (type
) = nfields
;
4295 TYPE_N_BASECLASSES (type
) = n_base_classes
;
4296 TYPE_FIELDS (type
) = (struct field
*)
4297 obstack_alloc (&objfile
->type_obstack
, sizeof (struct field
) * nfields
);
4298 /* Copy the saved-up fields into the field vector. */
4299 for (n
= nfields
, tmp_list
= list
; tmp_list
; tmp_list
= tmp_list
->next
)
4302 TYPE_FIELD (type
, n
) = tmp_list
->field
;
4305 /* Copy the "function-field-list" (i.e., the list of member
4306 * functions in the class) to GDB's symbol table
4308 TYPE_NFN_FIELDS (type
) = n_fn_fields
;
4309 TYPE_NFN_FIELDS_TOTAL (type
) = n_fn_fields_total
;
4310 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
4311 obstack_alloc (&objfile
->type_obstack
, sizeof (struct fn_fieldlist
) * n_fn_fields
);
4312 for (n
= n_fn_fields
; fn_list
; fn_list
= fn_list
->next
)
4315 TYPE_FN_FIELDLIST (type
, n
) = fn_list
->field
;
4318 /* pai:: FIXME -- perhaps each bitvector should be created individually */
4319 for (n
= nfields
, tmp_list
= list
; tmp_list
; tmp_list
= tmp_list
->next
)
4322 if (tmp_list
->attributes
)
4324 need_bitvectors
= 1;
4329 if (need_bitvectors
)
4331 /* pai:: this step probably redundant */
4332 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
4334 TYPE_FIELD_VIRTUAL_BITS (type
) =
4335 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
4336 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), nfields
);
4338 TYPE_FIELD_PRIVATE_BITS (type
) =
4339 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
4340 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
4342 TYPE_FIELD_PROTECTED_BITS (type
) =
4343 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
4344 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
4346 /* this field vector isn't actually used with HP aCC */
4347 TYPE_FIELD_IGNORE_BITS (type
) =
4348 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
4349 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
4351 while (nfields
-- > 0)
4353 if (B_TST (&(list
->attributes
), ATTR_VIRTUAL
))
4354 SET_TYPE_FIELD_VIRTUAL (type
, nfields
);
4355 if (B_TST (&(list
->attributes
), ATTR_PRIVATE
))
4356 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
4357 if (B_TST (&(list
->attributes
), ATTR_PROTECT
))
4358 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
4365 TYPE_FIELD_VIRTUAL_BITS (type
) = NULL
;
4366 TYPE_FIELD_PROTECTED_BITS (type
) = NULL
;
4367 TYPE_FIELD_PRIVATE_BITS (type
) = NULL
;
4370 if (has_vtable (type
))
4372 /* Allocate space for class runtime information */
4373 TYPE_RUNTIME_PTR (type
) = (struct runtime_info
*) xmalloc (sizeof (struct runtime_info
));
4374 /* Set flag for vtable */
4375 TYPE_VTABLE (type
) = 1;
4376 /* The first non-virtual base class with a vtable. */
4377 TYPE_PRIMARY_BASE (type
) = primary_base_class (type
);
4378 /* The virtual base list. */
4379 TYPE_VIRTUAL_BASE_LIST (type
) = virtual_base_list (type
);
4382 TYPE_RUNTIME_PTR (type
) = NULL
;
4384 /* If this is a local type (C++ - declared inside a function), record file name & line # */
4385 if (hpread_get_scope_depth (dn_bufp
, objfile
, 1 /* no need for real depth */ ))
4387 TYPE_LOCALTYPE_PTR (type
) = (struct local_type_info
*) xmalloc (sizeof (struct local_type_info
));
4388 TYPE_LOCALTYPE_FILE (type
) = (char *) xmalloc (strlen (current_subfile
->name
) + 1);
4389 strcpy (TYPE_LOCALTYPE_FILE (type
), current_subfile
->name
);
4390 if (current_subfile
->line_vector
&& (current_subfile
->line_vector
->nitems
> 0))
4391 TYPE_LOCALTYPE_LINE (type
) = current_subfile
->line_vector
->item
[current_subfile
->line_vector
->nitems
- 1].line
;
4393 TYPE_LOCALTYPE_LINE (type
) = 0;
4396 TYPE_LOCALTYPE_PTR (type
) = NULL
;
4398 /* Clear the global saying what template we are in the middle of processing */
4399 current_template
= NULL
;
4401 /* Fix up any cv-qualified versions of this type. */
4402 finish_cv_type (type
);
4407 /* Adjust the physnames for each static member of a struct
4408 or class type to be something like "A::x"; then various
4409 other pieces of code that do a lookup_symbol on the phyname
4411 TYPE is a pointer to the struct/class type
4412 NAME is a char * (string) which is the class/struct name
4416 fix_static_member_physnames (struct type
*type
, char *class_name
,
4417 struct objfile
*objfile
)
4421 /* We fix the member names only for classes or structs */
4422 if (TYPE_CODE (type
) != TYPE_CODE_STRUCT
)
4425 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
4426 if (TYPE_FIELD_STATIC (type
, i
))
4428 if (TYPE_FIELD_STATIC_PHYSNAME (type
, i
))
4429 return; /* physnames are already set */
4431 SET_FIELD_PHYSNAME (type
->fields
[i
],
4432 obstack_alloc (&objfile
->type_obstack
,
4433 strlen (class_name
) + strlen (TYPE_FIELD_NAME (type
, i
)) + 3));
4434 strcpy (TYPE_FIELD_STATIC_PHYSNAME (type
, i
), class_name
);
4435 strcat (TYPE_FIELD_STATIC_PHYSNAME (type
, i
), "::");
4436 strcat (TYPE_FIELD_STATIC_PHYSNAME (type
, i
), TYPE_FIELD_NAME (type
, i
));
4440 /* Fix-up the type structure for a CLASS so that the type entry
4441 * for a method (previously marked with a null type in hpread_read_struct_type()
4442 * is set correctly to METHOD.
4443 * OBJFILE is as for other such functions.
4447 fixup_class_method_type (struct type
*class, struct type
*method
,
4448 struct objfile
*objfile
)
4452 if (!class || !method
|| !objfile
)
4455 /* Only for types that have methods */
4456 if ((TYPE_CODE (class) != TYPE_CODE_CLASS
) &&
4457 (TYPE_CODE (class) != TYPE_CODE_UNION
))
4460 /* Loop over all methods and find the one marked with a NULL type */
4461 for (i
= 0; i
< TYPE_NFN_FIELDS (class); i
++)
4462 for (j
= 0; j
< TYPE_FN_FIELDLIST_LENGTH (class, i
); j
++)
4463 if (TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i
), j
) == NULL
)
4465 /* Set the method type */
4466 TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i
), j
) = method
;
4467 /* The argument list */
4468 (TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i
), j
))->type_specific
.arg_types
4469 = (struct type
**) obstack_alloc (&objfile
->type_obstack
,
4470 sizeof (struct type
*) * (method
->nfields
+ 1));
4471 for (k
= 0; k
< method
->nfields
; k
++)
4472 (TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i
), j
))->type_specific
.arg_types
[k
] = method
->fields
[k
].type
;
4473 /* void termination */
4474 (TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i
), j
))->type_specific
.arg_types
[method
->nfields
] = builtin_type_void
;
4476 /* pai: It's not clear why this args field has to be set. Perhaps
4477 * it should be eliminated entirely. */
4478 (TYPE_FN_FIELD (TYPE_FN_FIELDLIST1 (class, i
), j
)).args
4479 = (struct type
**) obstack_alloc (&objfile
->type_obstack
,
4480 sizeof (struct type
*) * (method
->nfields
+ 1));
4481 for (k
= 0; k
< method
->nfields
; k
++)
4482 (TYPE_FN_FIELD (TYPE_FN_FIELDLIST1 (class, i
), j
)).args
[k
] = method
->fields
[k
].type
;
4483 /* null-terminated, unlike arg_types above */
4484 (TYPE_FN_FIELD (TYPE_FN_FIELDLIST1 (class, i
), j
)).args
[method
->nfields
] = NULL
;
4486 /* Break out of both loops -- only one method to fix up in a class */
4491 TYPE_FLAGS (class) &= ~TYPE_FLAG_INCOMPLETE
;
4495 /* If we're in the middle of processing a template, get a pointer
4496 * to the Nth template argument.
4497 * An example may make this clearer:
4498 * template <class T1, class T2> class q2 {
4503 * The type for "a" will be "first template arg" and
4504 * the type for "b" will be "second template arg".
4505 * We need to look these up in order to fill in "a" and "b"'s type.
4506 * This is called from hpread_type_lookup().
4508 static struct type
*
4509 hpread_get_nth_template_arg (struct objfile
*objfile
, int n
)
4511 if (current_template
!= NULL
)
4512 return TYPE_TEMPLATE_ARG (current_template
, n
).type
;
4514 return lookup_fundamental_type (objfile
, FT_TEMPLATE_ARG
);
4517 /* Read in and internalize a TEMPL_ARG (template arg) symbol. */
4519 static struct type
*
4520 hpread_read_templ_arg_type (dnttpointer hp_type
, union dnttentry
*dn_bufp
,
4521 struct objfile
*objfile
, char *name
)
4525 /* See if it's something we've already deal with. */
4526 type
= hpread_alloc_type (hp_type
, objfile
);
4527 if (TYPE_CODE (type
) == TYPE_CODE_TEMPLATE_ARG
)
4530 /* Nope. Fill in the appropriate fields. */
4531 TYPE_CODE (type
) = TYPE_CODE_TEMPLATE_ARG
;
4532 TYPE_LENGTH (type
) = 0;
4533 TYPE_NFIELDS (type
) = 0;
4534 TYPE_NAME (type
) = name
;
4538 /* Read in and internalize a set debug symbol. */
4540 static struct type
*
4541 hpread_read_set_type (dnttpointer hp_type
, union dnttentry
*dn_bufp
,
4542 struct objfile
*objfile
)
4546 /* See if it's something we've already deal with. */
4547 type
= hpread_alloc_type (hp_type
, objfile
);
4548 if (TYPE_CODE (type
) == TYPE_CODE_SET
)
4551 /* Nope. Fill in the appropriate fields. */
4552 TYPE_CODE (type
) = TYPE_CODE_SET
;
4553 TYPE_LENGTH (type
) = dn_bufp
->dset
.bitlength
/ 8;
4554 TYPE_NFIELDS (type
) = 0;
4555 TYPE_TARGET_TYPE (type
) = hpread_type_lookup (dn_bufp
->dset
.subtype
,
4560 /* Read in and internalize an array debug symbol. */
4562 static struct type
*
4563 hpread_read_array_type (dnttpointer hp_type
, union dnttentry
*dn_bufp
,
4564 struct objfile
*objfile
)
4568 /* Allocate an array type symbol.
4569 * Why no check for already-read here, like in the other
4570 * hpread_read_xxx_type routines? Because it kept us
4571 * from properly determining the size of the array!
4573 type
= hpread_alloc_type (hp_type
, objfile
);
4575 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
4577 /* Although the hp-symtab.h does not *require* this to be the case,
4578 * GDB is assuming that "arrayisbytes" and "elemisbytes" be consistent.
4579 * I.e., express both array-length and element-length in bits,
4580 * or express both array-length and element-length in bytes.
4582 if (!((dn_bufp
->darray
.arrayisbytes
&& dn_bufp
->darray
.elemisbytes
) ||
4583 (!dn_bufp
->darray
.arrayisbytes
&& !dn_bufp
->darray
.elemisbytes
)))
4585 warning ("error in hpread_array_type.\n");
4588 else if (dn_bufp
->darray
.arraylength
== 0x7fffffff)
4590 /* The HP debug format represents char foo[]; as an array with
4591 * length 0x7fffffff. Internally GDB wants to represent this
4592 * as an array of length zero.
4594 TYPE_LENGTH (type
) = 0;
4596 else if (dn_bufp
->darray
.arrayisbytes
)
4597 TYPE_LENGTH (type
) = dn_bufp
->darray
.arraylength
;
4598 else /* arraylength is in bits */
4599 TYPE_LENGTH (type
) = dn_bufp
->darray
.arraylength
/ 8;
4601 TYPE_TARGET_TYPE (type
) = hpread_type_lookup (dn_bufp
->darray
.elemtype
,
4604 /* The one "field" is used to store the subscript type */
4605 /* Since C and C++ multi-dimensional arrays are simply represented
4606 * as: array of array of ..., we only need one subscript-type
4607 * per array. This subscript type is typically a subrange of integer.
4608 * If this gets extended to support languages like Pascal, then
4609 * we need to fix this to represent multi-dimensional arrays properly.
4611 TYPE_NFIELDS (type
) = 1;
4612 TYPE_FIELDS (type
) = (struct field
*)
4613 obstack_alloc (&objfile
->type_obstack
, sizeof (struct field
));
4614 TYPE_FIELD_TYPE (type
, 0) = hpread_type_lookup (dn_bufp
->darray
.indextype
,
4619 /* Read in and internalize a subrange debug symbol. */
4620 static struct type
*
4621 hpread_read_subrange_type (dnttpointer hp_type
, union dnttentry
*dn_bufp
,
4622 struct objfile
*objfile
)
4626 /* Is it something we've already dealt with. */
4627 type
= hpread_alloc_type (hp_type
, objfile
);
4628 if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
4631 /* Nope, internalize it. */
4632 TYPE_CODE (type
) = TYPE_CODE_RANGE
;
4633 TYPE_LENGTH (type
) = dn_bufp
->dsubr
.bitlength
/ 8;
4634 TYPE_NFIELDS (type
) = 2;
4636 = (struct field
*) obstack_alloc (&objfile
->type_obstack
,
4637 2 * sizeof (struct field
));
4639 if (dn_bufp
->dsubr
.dyn_low
)
4640 TYPE_FIELD_BITPOS (type
, 0) = 0;
4642 TYPE_FIELD_BITPOS (type
, 0) = dn_bufp
->dsubr
.lowbound
;
4644 if (dn_bufp
->dsubr
.dyn_high
)
4645 TYPE_FIELD_BITPOS (type
, 1) = -1;
4647 TYPE_FIELD_BITPOS (type
, 1) = dn_bufp
->dsubr
.highbound
;
4648 TYPE_TARGET_TYPE (type
) = hpread_type_lookup (dn_bufp
->dsubr
.subtype
,
4653 /* struct type * hpread_type_lookup(hp_type, objfile)
4655 * hp_type: A pointer into the DNTT specifying what type we
4656 * are about to "look up"., or else [for fundamental types
4657 * like int, float, ...] an "immediate" structure describing
4660 * Return value: A pointer to a "struct type" (representation of a
4661 * type in GDB's internal symbol table - see gdbtypes.h)
4662 * Routine description:
4663 * There are a variety of places when scanning the DNTT when we
4664 * need to interpret a "type" field. The simplest and most basic
4665 * example is when we're processing the symbol table record
4666 * for a data symbol (a SVAR or DVAR record). That has
4667 * a "type" field specifying the type of the data symbol. That
4668 * "type" field is either an "immediate" type specification (for the
4669 * fundamental types) or a DNTT pointer (for more complicated types).
4670 * For the more complicated types, we may or may not have already
4671 * processed the pointed-to type. (Multiple data symbols can of course
4672 * share the same type).
4673 * The job of hpread_type_lookup() is to process this "type" field.
4674 * Most of the real work is done in subroutines. Here we interpret
4675 * the immediate flag. If not immediate, chase the DNTT pointer to
4676 * find our way to the SOM record describing the type, switch on
4677 * the SOM kind, and then call an appropriate subroutine depending
4678 * on what kind of type we are constructing. (e.g., an array type,
4679 * a struct/class type, etc).
4681 static struct type
*
4682 hpread_type_lookup (dnttpointer hp_type
, struct objfile
*objfile
)
4684 union dnttentry
*dn_bufp
;
4685 struct type
*tmp_type
;
4687 /* First see if it's a simple builtin type. */
4688 if (hp_type
.dntti
.immediate
)
4690 /* If this is a template argument, the argument number is
4691 * encoded in the bitlength. All other cases, just return
4692 * GDB's representation of this fundamental type.
4694 if (hp_type
.dntti
.type
== HP_TYPE_TEMPLATE_ARG
)
4695 return hpread_get_nth_template_arg (objfile
, hp_type
.dntti
.bitlength
);
4697 return lookup_fundamental_type (objfile
,
4698 hpread_type_translate (hp_type
));
4701 /* Not a builtin type. We'll have to read it in. */
4702 if (hp_type
.dnttp
.index
< LNTT_SYMCOUNT (objfile
))
4703 dn_bufp
= hpread_get_lntt (hp_type
.dnttp
.index
, objfile
);
4705 /* This is a fancy way of returning NULL */
4706 return lookup_fundamental_type (objfile
, FT_VOID
);
4708 switch (dn_bufp
->dblock
.kind
)
4710 case DNTT_TYPE_SRCFILE
:
4711 case DNTT_TYPE_MODULE
:
4712 case DNTT_TYPE_ENTRY
:
4713 case DNTT_TYPE_BEGIN
:
4715 case DNTT_TYPE_IMPORT
:
4716 case DNTT_TYPE_LABEL
:
4717 case DNTT_TYPE_FPARAM
:
4718 case DNTT_TYPE_SVAR
:
4719 case DNTT_TYPE_DVAR
:
4720 case DNTT_TYPE_CONST
:
4721 case DNTT_TYPE_MEMENUM
:
4722 case DNTT_TYPE_VARIANT
:
4723 case DNTT_TYPE_FILE
:
4724 case DNTT_TYPE_WITH
:
4725 case DNTT_TYPE_COMMON
:
4726 case DNTT_TYPE_COBSTRUCT
:
4727 case DNTT_TYPE_XREF
:
4729 case DNTT_TYPE_MACRO
:
4730 case DNTT_TYPE_BLOCKDATA
:
4731 case DNTT_TYPE_CLASS_SCOPE
:
4732 case DNTT_TYPE_MEMACCESS
:
4733 case DNTT_TYPE_INHERITANCE
:
4734 case DNTT_TYPE_OBJECT_ID
:
4735 case DNTT_TYPE_FRIEND_CLASS
:
4736 case DNTT_TYPE_FRIEND_FUNC
:
4737 /* These are not types - something went wrong. */
4738 /* This is a fancy way of returning NULL */
4739 return lookup_fundamental_type (objfile
, FT_VOID
);
4741 case DNTT_TYPE_FUNCTION
:
4742 /* We wind up here when dealing with class member functions
4743 * (called from hpread_read_struct_type(), i.e. when processing
4744 * the class definition itself).
4746 return hpread_read_function_type (hp_type
, dn_bufp
, objfile
, 0);
4748 case DNTT_TYPE_DOC_FUNCTION
:
4749 return hpread_read_doc_function_type (hp_type
, dn_bufp
, objfile
, 0);
4751 case DNTT_TYPE_TYPEDEF
:
4753 /* A typedef - chase it down by making a recursive call */
4754 struct type
*structtype
= hpread_type_lookup (dn_bufp
->dtype
.type
,
4757 /* The following came from the base hpread.c that we inherited.
4758 * It is WRONG so I have commented it out. - RT
4762 suffix = VT (objfile) + dn_bufp->dtype.name;
4763 TYPE_NAME (structtype) = suffix;
4765 * ... further explanation ....
4767 * What we have here is a typedef pointing to a typedef.
4772 * What we desire to build is (these are pictures
4773 * of "struct type"'s):
4775 * +---------+ +----------+ +------------+
4776 * | typedef | | typedef | | fund. type |
4777 * | type| -> | type| -> | |
4778 * | "fum" | | "foo" | | "int" |
4779 * +---------+ +----------+ +------------+
4781 * What this commented-out code is doing is smashing the
4782 * name of pointed-to-type to be the same as the pointed-from
4783 * type. So we wind up with something like:
4785 * +---------+ +----------+ +------------+
4786 * | typedef | | typedef | | fund. type |
4787 * | type| -> | type| -> | |
4788 * | "fum" | | "fum" | | "fum" |
4789 * +---------+ +----------+ +------------+
4796 case DNTT_TYPE_TAGDEF
:
4798 /* Just a little different from above. We have to tack on
4799 * an identifier of some kind (struct, union, enum, class, etc).
4801 struct type
*structtype
= hpread_type_lookup (dn_bufp
->dtype
.type
,
4803 char *prefix
, *suffix
;
4804 suffix
= VT (objfile
) + dn_bufp
->dtype
.name
;
4806 /* Lookup the next type in the list. It should be a structure,
4807 * union, class, enum, or template type.
4808 * We will need to attach that to our name.
4810 if (dn_bufp
->dtype
.type
.dnttp
.index
< LNTT_SYMCOUNT (objfile
))
4811 dn_bufp
= hpread_get_lntt (dn_bufp
->dtype
.type
.dnttp
.index
, objfile
);
4814 complain (&hpread_type_lookup_complaint
);
4818 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_STRUCT
)
4822 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_UNION
)
4826 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_CLASS
)
4828 /* Further field for CLASS saying how it was really declared */
4829 /* 0==class, 1==union, 2==struct */
4830 if (dn_bufp
->dclass
.class_decl
== 0)
4832 else if (dn_bufp
->dclass
.class_decl
== 1)
4834 else if (dn_bufp
->dclass
.class_decl
== 2)
4839 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_ENUM
)
4843 else if (dn_bufp
->dblock
.kind
== DNTT_TYPE_TEMPLATE
)
4845 prefix
= "template ";
4852 /* Build the correct name. */
4854 = (char *) obstack_alloc (&objfile
->type_obstack
,
4855 strlen (prefix
) + strlen (suffix
) + 1);
4856 TYPE_NAME (structtype
) = strcpy (TYPE_NAME (structtype
), prefix
);
4857 TYPE_NAME (structtype
) = strcat (TYPE_NAME (structtype
), suffix
);
4858 TYPE_TAG_NAME (structtype
) = suffix
;
4860 /* For classes/structs, we have to set the static member "physnames"
4861 to point to strings like "Class::Member" */
4862 if (TYPE_CODE (structtype
) == TYPE_CODE_STRUCT
)
4863 fix_static_member_physnames (structtype
, suffix
, objfile
);
4868 case DNTT_TYPE_POINTER
:
4869 /* Pointer type - call a routine in gdbtypes.c that constructs
4870 * the appropriate GDB type.
4872 return make_pointer_type (
4873 hpread_type_lookup (dn_bufp
->dptr
.pointsto
,
4877 case DNTT_TYPE_REFERENCE
:
4878 /* C++ reference type - call a routine in gdbtypes.c that constructs
4879 * the appropriate GDB type.
4881 return make_reference_type (
4882 hpread_type_lookup (dn_bufp
->dreference
.pointsto
,
4886 case DNTT_TYPE_ENUM
:
4887 return hpread_read_enum_type (hp_type
, dn_bufp
, objfile
);
4889 return hpread_read_set_type (hp_type
, dn_bufp
, objfile
);
4890 case DNTT_TYPE_SUBRANGE
:
4891 return hpread_read_subrange_type (hp_type
, dn_bufp
, objfile
);
4892 case DNTT_TYPE_ARRAY
:
4893 return hpread_read_array_type (hp_type
, dn_bufp
, objfile
);
4894 case DNTT_TYPE_STRUCT
:
4895 case DNTT_TYPE_UNION
:
4896 return hpread_read_struct_type (hp_type
, dn_bufp
, objfile
);
4897 case DNTT_TYPE_FIELD
:
4898 return hpread_type_lookup (dn_bufp
->dfield
.type
, objfile
);
4900 case DNTT_TYPE_FUNCTYPE
:
4901 /* Here we want to read the function SOMs and return a
4902 * type for it. We get here, for instance, when processing
4903 * pointer-to-function type.
4905 return hpread_read_function_type (hp_type
, dn_bufp
, objfile
, 0);
4907 case DNTT_TYPE_PTRMEM
:
4908 /* Declares a C++ pointer-to-data-member type.
4909 * The "pointsto" field defines the class,
4910 * while the "memtype" field defines the pointed-to-type.
4913 struct type
*ptrmemtype
;
4914 struct type
*class_type
;
4915 struct type
*memtype
;
4916 memtype
= hpread_type_lookup (dn_bufp
->dptrmem
.memtype
,
4918 class_type
= hpread_type_lookup (dn_bufp
->dptrmem
.pointsto
,
4920 ptrmemtype
= alloc_type (objfile
);
4921 smash_to_member_type (ptrmemtype
, class_type
, memtype
);
4922 return make_pointer_type (ptrmemtype
, NULL
);
4926 case DNTT_TYPE_PTRMEMFUNC
:
4927 /* Defines a C++ pointer-to-function-member type.
4928 * The "pointsto" field defines the class,
4929 * while the "memtype" field defines the pointed-to-type.
4932 struct type
*ptrmemtype
;
4933 struct type
*class_type
;
4934 struct type
*functype
;
4935 struct type
*retvaltype
;
4938 struct type
**args_type
;
4939 class_type
= hpread_type_lookup (dn_bufp
->dptrmem
.pointsto
,
4941 functype
= hpread_type_lookup (dn_bufp
->dptrmem
.memtype
,
4943 retvaltype
= TYPE_TARGET_TYPE (functype
);
4944 nargs
= TYPE_NFIELDS (functype
);
4945 args_type
= (struct type
**) xmalloc ((nargs
+ 1) * sizeof (struct type
*));
4946 for (i
= 0; i
< nargs
; i
++)
4948 args_type
[i
] = TYPE_FIELD_TYPE (functype
, i
);
4950 args_type
[nargs
] = NULL
;
4951 ptrmemtype
= alloc_type (objfile
);
4952 smash_to_method_type (ptrmemtype
, class_type
, retvaltype
, args_type
);
4953 return make_pointer_type (ptrmemtype
, NULL
);
4957 case DNTT_TYPE_CLASS
:
4958 return hpread_read_struct_type (hp_type
, dn_bufp
, objfile
);
4960 case DNTT_TYPE_GENFIELD
:
4961 /* Chase pointer from GENFIELD to FIELD, and make recursive
4964 return hpread_type_lookup (dn_bufp
->dgenfield
.field
, objfile
);
4966 case DNTT_TYPE_VFUNC
:
4967 /* C++ virtual function.
4968 * We get here in the course of processing a class type which
4969 * contains virtual functions. Just go through another level
4970 * of indirection to get to the pointed-to function SOM.
4972 return hpread_type_lookup (dn_bufp
->dvfunc
.funcptr
, objfile
);
4974 case DNTT_TYPE_MODIFIER
:
4975 /* Check the modifiers and then just make a recursive call on
4976 * the "type" pointed to by the modifier DNTT.
4978 * pai:: FIXME -- do we ever want to handle "m_duplicate" and
4979 * "m_void" modifiers? Is static_flag really needed here?
4980 * (m_static used for methods of classes, elsewhere).
4982 tmp_type
= make_cv_type (dn_bufp
->dmodifier
.m_const
,
4983 dn_bufp
->dmodifier
.m_volatile
,
4984 hpread_type_lookup (dn_bufp
->dmodifier
.type
, objfile
),
4989 case DNTT_TYPE_MEMFUNC
:
4990 /* Member function. Treat like a function.
4991 * I think we get here in the course of processing a
4992 * pointer-to-member-function type...
4994 return hpread_read_function_type (hp_type
, dn_bufp
, objfile
, 0);
4996 case DNTT_TYPE_DOC_MEMFUNC
:
4997 return hpread_read_doc_function_type (hp_type
, dn_bufp
, objfile
, 0);
4999 case DNTT_TYPE_TEMPLATE
:
5000 /* Template - sort of the header for a template definition,
5001 * which like a class, points to a member list and also points
5002 * to a TEMPLATE_ARG list of type-arguments.
5004 return hpread_read_struct_type (hp_type
, dn_bufp
, objfile
);
5006 case DNTT_TYPE_TEMPLATE_ARG
:
5009 /* The TEMPLATE record points to an argument list of
5010 * TEMPLATE_ARG records, each of which describes one
5011 * of the type-arguments.
5013 name
= VT (objfile
) + dn_bufp
->dtempl_arg
.name
;
5014 return hpread_read_templ_arg_type (hp_type
, dn_bufp
, objfile
, name
);
5017 case DNTT_TYPE_FUNC_TEMPLATE
:
5018 /* We wind up here when processing a TEMPLATE type,
5019 * if the template has member function(s).
5020 * Treat it like a FUNCTION.
5022 return hpread_read_function_type (hp_type
, dn_bufp
, objfile
, 0);
5024 case DNTT_TYPE_LINK
:
5025 /* The LINK record is used to link up templates with instantiations.
5026 * There is no type associated with the LINK record per se.
5028 return lookup_fundamental_type (objfile
, FT_VOID
);
5030 /* Also not yet handled... */
5031 /* case DNTT_TYPE_DYN_ARRAY_DESC: */
5032 /* case DNTT_TYPE_DESC_SUBRANGE: */
5033 /* case DNTT_TYPE_BEGIN_EXT: */
5034 /* case DNTT_TYPE_INLN: */
5035 /* case DNTT_TYPE_INLN_LIST: */
5036 /* case DNTT_TYPE_ALIAS: */
5038 /* A fancy way of returning NULL */
5039 return lookup_fundamental_type (objfile
, FT_VOID
);
5044 hpread_record_lines (struct subfile
*subfile
, sltpointer s_idx
,
5045 sltpointer e_idx
, struct objfile
*objfile
,
5048 union sltentry
*sl_bufp
;
5050 while (s_idx
<= e_idx
)
5052 sl_bufp
= hpread_get_slt (s_idx
, objfile
);
5053 /* Only record "normal" entries in the SLT. */
5054 if (sl_bufp
->snorm
.sltdesc
== SLT_NORMAL
5055 || sl_bufp
->snorm
.sltdesc
== SLT_EXIT
)
5056 record_line (subfile
, sl_bufp
->snorm
.line
,
5057 sl_bufp
->snorm
.address
+ offset
);
5058 else if (sl_bufp
->snorm
.sltdesc
== SLT_NORMAL_OFFSET
)
5059 record_line (subfile
, sl_bufp
->snormoff
.line
,
5060 sl_bufp
->snormoff
.address
+ offset
);
5066 /* Given a function "f" which is a member of a class, find
5067 * the classname that it is a member of. Used to construct
5068 * the name (e.g., "c::f") which GDB will put in the
5069 * "demangled name" field of the function's symbol.
5070 * Called from hpread_process_one_debug_symbol()
5071 * If "f" is not a member function, return NULL.
5074 class_of (struct type
*functype
)
5076 struct type
*first_param_type
;
5077 char *first_param_name
;
5078 struct type
*pointed_to_type
;
5081 /* Check that the function has a first argument "this",
5082 * and that "this" is a pointer to a class. If not,
5083 * functype is not a member function, so return NULL.
5085 if (TYPE_NFIELDS (functype
) == 0)
5087 first_param_name
= TYPE_FIELD_NAME (functype
, 0);
5088 if (first_param_name
== NULL
)
5089 return NULL
; /* paranoia */
5090 if (strcmp (first_param_name
, "this"))
5092 first_param_type
= TYPE_FIELD_TYPE (functype
, 0);
5093 if (first_param_type
== NULL
)
5094 return NULL
; /* paranoia */
5095 if (TYPE_CODE (first_param_type
) != TYPE_CODE_PTR
)
5098 /* Get the thing that "this" points to, check that
5099 * it's a class, and get its class name.
5101 pointed_to_type
= TYPE_TARGET_TYPE (first_param_type
);
5102 if (pointed_to_type
== NULL
)
5103 return NULL
; /* paranoia */
5104 if (TYPE_CODE (pointed_to_type
) != TYPE_CODE_CLASS
)
5106 class_name
= TYPE_NAME (pointed_to_type
);
5107 if (class_name
== NULL
)
5108 return NULL
; /* paranoia */
5110 /* The class name may be of the form "class c", in which case
5111 * we want to strip off the leading "class ".
5113 if (strncmp (class_name
, "class ", 6) == 0)
5119 /* Internalize one native debug symbol.
5120 * Called in a loop from hpread_expand_symtab().
5129 * index: Index of this symbol
5130 * at_module_boundary_p Pointer to boolean flag to control caller's loop.
5134 hpread_process_one_debug_symbol (union dnttentry
*dn_bufp
, char *name
,
5135 struct section_offsets
*section_offsets
,
5136 struct objfile
*objfile
, CORE_ADDR text_offset
,
5137 int text_size
, char *filename
, int index
,
5138 int *at_module_boundary_p
)
5143 int offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT (objfile
));
5144 int data_offset
= ANOFFSET (section_offsets
, SECT_OFF_DATA (objfile
));
5145 union dnttentry
*dn_temp
;
5146 dnttpointer hp_type
;
5148 struct context_stack
*new;
5149 char *class_scope_name
;
5151 /* Allocate one GDB debug symbol and fill in some default values. */
5152 sym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
5153 sizeof (struct symbol
));
5154 memset (sym
, 0, sizeof (struct symbol
));
5155 SYMBOL_NAME (sym
) = obsavestring (name
, strlen (name
), &objfile
->symbol_obstack
);
5156 SYMBOL_LANGUAGE (sym
) = language_auto
;
5157 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
5158 SYMBOL_LINE (sym
) = 0;
5159 SYMBOL_VALUE (sym
) = 0;
5160 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
5162 /* Just a trick in case the SOM debug symbol is a type definition.
5163 * There are routines that are set up to build a GDB type symbol, given
5164 * a SOM dnttpointer. So we set up a dummy SOM dnttpointer "hp_type".
5165 * This allows us to call those same routines.
5167 hp_type
.dnttp
.extension
= 1;
5168 hp_type
.dnttp
.immediate
= 0;
5169 hp_type
.dnttp
.global
= 0;
5170 hp_type
.dnttp
.index
= index
;
5172 /* This "type" is the type of SOM record.
5173 * Switch on SOM type.
5175 type
= dn_bufp
->dblock
.kind
;
5178 case DNTT_TYPE_SRCFILE
:
5179 /* This type of symbol indicates from which source file or
5180 * include file any following data comes. It may indicate:
5182 * o The start of an entirely new source file (and thus
5185 * o The start of a different source file due to #include
5187 * o The end of an include file and the return to the original
5188 * file. Thus if "foo.c" includes "bar.h", we see first
5189 * a SRCFILE for foo.c, then one for bar.h, and then one for
5192 * If it indicates the start of a new module then we must
5193 * finish the symbol table of the previous module
5194 * (if any) and start accumulating a new symbol table.
5198 if (!last_source_file
)
5201 * A note on "last_source_file": this is a char* pointing
5202 * to the actual file name. "start_symtab" sets it,
5203 * "end_symtab" clears it.
5205 * So if "last_source_file" is NULL, then either this is
5206 * the first record we are looking at, or a previous call
5207 * to "end_symtab()" was made to close out the previous
5208 * module. Since we're now quitting the scan loop when we
5209 * see a MODULE END record, we should never get here, except
5210 * in the case that we're not using the quick look-up tables
5211 * and have to use the old system as a fall-back.
5213 start_symtab (name
, NULL
, valu
);
5214 record_debugformat ("HP");
5215 SL_INDEX (objfile
) = dn_bufp
->dsfile
.address
;
5220 /* Either a new include file, or a SRCFILE record
5221 * saying we are back in the main source (or out of
5222 * a nested include file) again.
5224 SL_INDEX (objfile
) = hpread_record_lines (current_subfile
,
5226 dn_bufp
->dsfile
.address
,
5230 /* A note on "start_subfile". This routine will check
5231 * the name we pass it and look for an existing subfile
5232 * of that name. There's thus only one sub-file for the
5233 * actual source (e.g. for "foo.c" in foo.c), despite the
5234 * fact that we'll see lots of SRCFILE entries for foo.c
5237 start_subfile (name
, NULL
);
5240 case DNTT_TYPE_MODULE
:
5242 * We no longer ignore DNTT_TYPE_MODULE symbols. The module
5243 * represents the meaningful semantic structure of a compilation
5244 * unit. We expect to start the psymtab-to-symtab expansion
5245 * looking at a MODULE entry, and to end it at the corresponding
5248 *--Begin outdated comments
5250 * This record signifies the start of a new source module
5251 * In C/C++ there is no explicit "module" construct in the language,
5252 * but each compilation unit is implicitly a module and they
5253 * do emit the DNTT_TYPE_MODULE records.
5254 * The end of the module is marked by a matching DNTT_TYPE_END record.
5256 * The reason GDB gets away with ignoring the DNTT_TYPE_MODULE record
5257 * is it notices the DNTT_TYPE_END record for the previous
5258 * module (see comments under DNTT_TYPE_END case), and then treats
5259 * the next DNTT_TYPE_SRCFILE record as if it were the module-start record.
5260 * (i.e., it makes a start_symtab() call).
5261 * This scheme seems a little convoluted, but I'll leave it
5262 * alone on the principle "if it ain't broke don't fix
5265 *-- End outdated comments
5269 if (!last_source_file
)
5271 /* Start of a new module. We know this because "last_source_file"
5272 * is NULL, which can only happen the first time or if we just
5273 * made a call to end_symtab() to close out the previous module.
5275 start_symtab (name
, NULL
, valu
);
5276 SL_INDEX (objfile
) = dn_bufp
->dmodule
.address
;
5280 /* This really shouldn't happen if we're using the quick
5281 * look-up tables, as it would mean we'd scanned past an
5282 * END MODULE entry. But if we're not using the tables,
5283 * we started the module on the SRCFILE entry, so it's ok.
5284 * For now, accept this.
5286 /* warning( "Error expanding psymtab, missed module end, found entry for %s",
5289 *at_module_boundary_p
= -1;
5292 start_subfile (name
, NULL
);
5295 case DNTT_TYPE_FUNCTION
:
5296 case DNTT_TYPE_ENTRY
:
5297 /* A function or secondary entry point. */
5298 valu
= dn_bufp
->dfunc
.lowaddr
+ offset
;
5300 /* Record lines up to this point. */
5301 SL_INDEX (objfile
) = hpread_record_lines (current_subfile
,
5303 dn_bufp
->dfunc
.address
,
5306 WITHIN_FUNCTION (objfile
) = 1;
5307 CURRENT_FUNCTION_VALUE (objfile
) = valu
;
5309 /* Stack must be empty now. */
5310 if (context_stack_depth
!= 0)
5311 complain (&lbrac_unmatched_complaint
, (char *) symnum
);
5312 new = push_context (0, valu
);
5314 /* Built a type for the function. This includes processing
5315 * the symbol records for the function parameters.
5317 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
5318 SYMBOL_TYPE (sym
) = hpread_read_function_type (hp_type
, dn_bufp
, objfile
, 1);
5320 /* The "SYMBOL_NAME" field is expected to be the mangled name
5321 * (if any), which we get from the "alias" field of the SOM record
5324 if ((dn_bufp
->dfunc
.language
== HP_LANGUAGE_CPLUSPLUS
) &&
5325 dn_bufp
->dfunc
.alias
&& /* has an alias */
5326 *(char *) (VT (objfile
) + dn_bufp
->dfunc
.alias
)) /* not a null string */
5327 SYMBOL_NAME (sym
) = VT (objfile
) + dn_bufp
->dfunc
.alias
;
5329 SYMBOL_NAME (sym
) = VT (objfile
) + dn_bufp
->dfunc
.name
;
5331 /* Special hack to get around HP compilers' insistence on
5332 * reporting "main" as "_MAIN_" for C/C++ */
5333 if ((strcmp (SYMBOL_NAME (sym
), "_MAIN_") == 0) &&
5334 (strcmp (VT (objfile
) + dn_bufp
->dfunc
.name
, "main") == 0))
5335 SYMBOL_NAME (sym
) = VT (objfile
) + dn_bufp
->dfunc
.name
;
5337 /* The SYMBOL_CPLUS_DEMANGLED_NAME field is expected to
5338 * be the demangled name.
5340 if (dn_bufp
->dfunc
.language
== HP_LANGUAGE_CPLUSPLUS
)
5342 /* SYMBOL_INIT_DEMANGLED_NAME is a macro which winds up
5343 * calling the demangler in libiberty (cplus_demangle()) to
5344 * do the job. This generally does the job, even though
5345 * it's intended for the GNU compiler and not the aCC compiler
5346 * Note that SYMBOL_INIT_DEMANGLED_NAME calls the
5347 * demangler with arguments DMGL_PARAMS | DMGL_ANSI.
5348 * Generally, we don't want params when we display
5349 * a demangled name, but when I took out the DMGL_PARAMS,
5350 * some things broke, so I'm leaving it in here, and
5351 * working around the issue in stack.c. - RT
5353 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
5354 if ((SYMBOL_NAME (sym
) == VT (objfile
) + dn_bufp
->dfunc
.alias
) &&
5355 (!SYMBOL_CPLUS_DEMANGLED_NAME (sym
)))
5358 /* Well, the symbol name is mangled, but the
5359 * demangler in libiberty failed so the demangled
5360 * field is still NULL. Try to
5361 * do the job ourselves based on the "name" field
5362 * in the SOM record. A complication here is that
5363 * the name field contains only the function name
5364 * (like "f"), whereas we want the class qualification
5365 * (as in "c::f"). Try to reconstruct that.
5370 basename
= VT (objfile
) + dn_bufp
->dfunc
.name
;
5371 classname
= class_of (SYMBOL_TYPE (sym
));
5374 dem_name
= xmalloc (strlen (basename
) + strlen (classname
) + 3);
5375 strcpy (dem_name
, classname
);
5376 strcat (dem_name
, "::");
5377 strcat (dem_name
, basename
);
5378 SYMBOL_CPLUS_DEMANGLED_NAME (sym
) = dem_name
;
5379 SYMBOL_LANGUAGE (sym
) = language_cplus
;
5384 /* Add the function symbol to the list of symbols in this blockvector */
5385 if (dn_bufp
->dfunc
.global
)
5386 add_symbol_to_list (sym
, &global_symbols
);
5388 add_symbol_to_list (sym
, &file_symbols
);
5391 /* Search forward to the next BEGIN and also read
5392 * in the line info up to that point.
5393 * Not sure why this is needed.
5394 * In HP FORTRAN this code is harmful since there
5395 * may not be a BEGIN after the FUNCTION.
5396 * So I made it C/C++ specific. - RT
5398 if (dn_bufp
->dfunc
.language
== HP_LANGUAGE_C
||
5399 dn_bufp
->dfunc
.language
== HP_LANGUAGE_CPLUSPLUS
)
5401 while (dn_bufp
->dblock
.kind
!= DNTT_TYPE_BEGIN
)
5403 dn_bufp
= hpread_get_lntt (++index
, objfile
);
5404 if (dn_bufp
->dblock
.extension
)
5407 SL_INDEX (objfile
) = hpread_record_lines (current_subfile
,
5409 dn_bufp
->dbegin
.address
,
5411 SYMBOL_LINE (sym
) = hpread_get_line (dn_bufp
->dbegin
.address
, objfile
);
5413 record_line (current_subfile
, SYMBOL_LINE (sym
), valu
);
5416 case DNTT_TYPE_DOC_FUNCTION
:
5417 valu
= dn_bufp
->ddocfunc
.lowaddr
+ offset
;
5419 /* Record lines up to this point. */
5420 SL_INDEX (objfile
) = hpread_record_lines (current_subfile
,
5422 dn_bufp
->ddocfunc
.address
,
5425 WITHIN_FUNCTION (objfile
) = 1;
5426 CURRENT_FUNCTION_VALUE (objfile
) = valu
;
5427 /* Stack must be empty now. */
5428 if (context_stack_depth
!= 0)
5429 complain (&lbrac_unmatched_complaint
, (char *) symnum
);
5430 new = push_context (0, valu
);
5432 /* Built a type for the function. This includes processing
5433 * the symbol records for the function parameters.
5435 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
5436 SYMBOL_TYPE (sym
) = hpread_read_doc_function_type (hp_type
, dn_bufp
, objfile
, 1);
5438 /* The "SYMBOL_NAME" field is expected to be the mangled name
5439 * (if any), which we get from the "alias" field of the SOM record
5442 if ((dn_bufp
->ddocfunc
.language
== HP_LANGUAGE_CPLUSPLUS
) &&
5443 dn_bufp
->ddocfunc
.alias
&& /* has an alias */
5444 *(char *) (VT (objfile
) + dn_bufp
->ddocfunc
.alias
)) /* not a null string */
5445 SYMBOL_NAME (sym
) = VT (objfile
) + dn_bufp
->ddocfunc
.alias
;
5447 SYMBOL_NAME (sym
) = VT (objfile
) + dn_bufp
->ddocfunc
.name
;
5449 /* Special hack to get around HP compilers' insistence on
5450 * reporting "main" as "_MAIN_" for C/C++ */
5451 if ((strcmp (SYMBOL_NAME (sym
), "_MAIN_") == 0) &&
5452 (strcmp (VT (objfile
) + dn_bufp
->ddocfunc
.name
, "main") == 0))
5453 SYMBOL_NAME (sym
) = VT (objfile
) + dn_bufp
->ddocfunc
.name
;
5455 if (dn_bufp
->ddocfunc
.language
== HP_LANGUAGE_CPLUSPLUS
)
5458 /* SYMBOL_INIT_DEMANGLED_NAME is a macro which winds up
5459 * calling the demangler in libiberty (cplus_demangle()) to
5460 * do the job. This generally does the job, even though
5461 * it's intended for the GNU compiler and not the aCC compiler
5462 * Note that SYMBOL_INIT_DEMANGLED_NAME calls the
5463 * demangler with arguments DMGL_PARAMS | DMGL_ANSI.
5464 * Generally, we don't want params when we display
5465 * a demangled name, but when I took out the DMGL_PARAMS,
5466 * some things broke, so I'm leaving it in here, and
5467 * working around the issue in stack.c. - RT
5469 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
5471 if ((SYMBOL_NAME (sym
) == VT (objfile
) + dn_bufp
->ddocfunc
.alias
) &&
5472 (!SYMBOL_CPLUS_DEMANGLED_NAME (sym
)))
5475 /* Well, the symbol name is mangled, but the
5476 * demangler in libiberty failed so the demangled
5477 * field is still NULL. Try to
5478 * do the job ourselves based on the "name" field
5479 * in the SOM record. A complication here is that
5480 * the name field contains only the function name
5481 * (like "f"), whereas we want the class qualification
5482 * (as in "c::f"). Try to reconstruct that.
5487 basename
= VT (objfile
) + dn_bufp
->ddocfunc
.name
;
5488 classname
= class_of (SYMBOL_TYPE (sym
));
5491 dem_name
= xmalloc (strlen (basename
) + strlen (classname
) + 3);
5492 strcpy (dem_name
, classname
);
5493 strcat (dem_name
, "::");
5494 strcat (dem_name
, basename
);
5495 SYMBOL_CPLUS_DEMANGLED_NAME (sym
) = dem_name
;
5496 SYMBOL_LANGUAGE (sym
) = language_cplus
;
5501 /* Add the function symbol to the list of symbols in this blockvector */
5502 if (dn_bufp
->ddocfunc
.global
)
5503 add_symbol_to_list (sym
, &global_symbols
);
5505 add_symbol_to_list (sym
, &file_symbols
);
5508 /* Search forward to the next BEGIN and also read
5509 * in the line info up to that point.
5510 * Not sure why this is needed.
5511 * In HP FORTRAN this code is harmful since there
5512 * may not be a BEGIN after the FUNCTION.
5513 * So I made it C/C++ specific. - RT
5515 if (dn_bufp
->ddocfunc
.language
== HP_LANGUAGE_C
||
5516 dn_bufp
->ddocfunc
.language
== HP_LANGUAGE_CPLUSPLUS
)
5518 while (dn_bufp
->dblock
.kind
!= DNTT_TYPE_BEGIN
)
5520 dn_bufp
= hpread_get_lntt (++index
, objfile
);
5521 if (dn_bufp
->dblock
.extension
)
5524 SL_INDEX (objfile
) = hpread_record_lines (current_subfile
,
5526 dn_bufp
->dbegin
.address
,
5528 SYMBOL_LINE (sym
) = hpread_get_line (dn_bufp
->dbegin
.address
, objfile
);
5530 record_line (current_subfile
, SYMBOL_LINE (sym
), valu
);
5533 case DNTT_TYPE_BEGIN
:
5534 /* Begin a new scope. */
5535 if (context_stack_depth
== 1 /* this means we're at function level */ &&
5536 context_stack
[0].name
!= NULL
/* this means it's a function */ &&
5537 context_stack
[0].depth
== 0 /* this means it's the first BEGIN
5538 we've seen after the FUNCTION */
5541 /* This is the first BEGIN after a FUNCTION.
5542 * We ignore this one, since HP compilers always insert
5543 * at least one BEGIN, i.e. it's:
5549 * (possibly nested BEGIN ... END's if there are inner { } blocks)
5553 * By ignoring this first BEGIN, the local symbols get treated
5554 * as belonging to the function scope, and "print func::local_sym"
5555 * works (which is what we want).
5558 /* All we do here is increase the depth count associated with
5559 * the FUNCTION entry in the context stack. This ensures that
5560 * the next BEGIN we see (if any), representing a real nested { }
5561 * block, will get processed.
5564 context_stack
[0].depth
++;
5570 /* Record lines up to this SLT pointer. */
5571 SL_INDEX (objfile
) = hpread_record_lines (current_subfile
,
5573 dn_bufp
->dbegin
.address
,
5575 /* Calculate start address of new scope */
5576 valu
= hpread_get_location (dn_bufp
->dbegin
.address
, objfile
);
5577 valu
+= offset
; /* Relocate for dynamic loading */
5578 /* We use the scope start DNTT index as nesting depth identifier! */
5579 desc
= hpread_get_scope_start (dn_bufp
->dbegin
.address
, objfile
);
5580 new = push_context (desc
, valu
);
5587 /* Valid end kinds are:
5596 SL_INDEX (objfile
) = hpread_record_lines (current_subfile
,
5598 dn_bufp
->dend
.address
,
5600 switch (dn_bufp
->dend
.endkind
)
5602 case DNTT_TYPE_MODULE
:
5603 /* Ending a module ends the symbol table for that module.
5604 * Calling end_symtab() has the side effect of clearing the
5605 * last_source_file pointer, which in turn signals
5606 * process_one_debug_symbol() to treat the next DNTT_TYPE_SRCFILE
5607 * record as a module-begin.
5609 valu
= text_offset
+ text_size
+ offset
;
5611 /* Tell our caller that we're done with expanding the
5612 * debug information for a module.
5614 *at_module_boundary_p
= 1;
5616 /* Don't do this, as our caller will do it!
5618 * (void) end_symtab (valu, objfile, 0);
5622 case DNTT_TYPE_FUNCTION
:
5623 /* Ending a function, well, ends the function's scope. */
5624 dn_temp
= hpread_get_lntt (dn_bufp
->dend
.beginscope
.dnttp
.index
,
5626 valu
= dn_temp
->dfunc
.hiaddr
+ offset
;
5627 /* Insert func params into local list */
5628 merge_symbol_lists (¶m_symbols
, &local_symbols
);
5629 new = pop_context ();
5630 /* Make a block for the local symbols within. */
5631 finish_block (new->name
, &local_symbols
, new->old_blocks
,
5632 new->start_addr
, valu
, objfile
);
5633 WITHIN_FUNCTION (objfile
) = 0; /* This may have to change for Pascal */
5634 local_symbols
= new->locals
;
5635 param_symbols
= new->params
;
5638 case DNTT_TYPE_BEGIN
:
5639 if (context_stack_depth
== 1 &&
5640 context_stack
[0].name
!= NULL
&&
5641 context_stack
[0].depth
== 1)
5643 /* This is the END corresponding to the
5644 * BEGIN which we ignored - see DNTT_TYPE_BEGIN case above.
5646 context_stack
[0].depth
--;
5650 /* Ending a local scope. */
5651 valu
= hpread_get_location (dn_bufp
->dend
.address
, objfile
);
5652 /* Why in the hell is this needed? */
5653 valu
+= offset
+ 9; /* Relocate for dynamic loading */
5654 new = pop_context ();
5655 desc
= dn_bufp
->dend
.beginscope
.dnttp
.index
;
5656 if (desc
!= new->depth
)
5657 complain (&lbrac_mismatch_complaint
, (char *) symnum
);
5659 /* Make a block for the local symbols within. */
5660 finish_block (new->name
, &local_symbols
, new->old_blocks
,
5661 new->start_addr
, valu
, objfile
);
5662 local_symbols
= new->locals
;
5663 param_symbols
= new->params
;
5667 case DNTT_TYPE_WITH
:
5668 /* Since we ignore the DNTT_TYPE_WITH that starts the scope,
5669 * we can ignore the DNTT_TYPE_END that ends it.
5673 case DNTT_TYPE_COMMON
:
5674 /* End a FORTRAN common block. We don't currently handle these */
5675 complain (&hpread_unhandled_end_common_complaint
);
5678 case DNTT_TYPE_CLASS_SCOPE
:
5680 /* pai: FIXME Not handling nested classes for now -- must
5681 * maintain a stack */
5682 class_scope_name
= NULL
;
5685 /* End a class scope */
5686 valu
= hpread_get_location (dn_bufp
->dend
.address
, objfile
);
5687 /* Why in the hell is this needed? */
5688 valu
+= offset
+ 9; /* Relocate for dynamic loading */
5689 new = pop_context ();
5690 desc
= dn_bufp
->dend
.beginscope
.dnttp
.index
;
5691 if (desc
!= new->depth
)
5692 complain (&lbrac_mismatch_complaint
, (char *) symnum
);
5693 /* Make a block for the local symbols within. */
5694 finish_block (new->name
, &local_symbols
, new->old_blocks
,
5695 new->start_addr
, valu
, objfile
);
5696 local_symbols
= new->locals
;
5697 param_symbols
= new->params
;
5702 complain (&hpread_unexpected_end_complaint
);
5707 /* DNTT_TYPE_IMPORT is not handled */
5709 case DNTT_TYPE_LABEL
:
5710 SYMBOL_NAMESPACE (sym
) = LABEL_NAMESPACE
;
5713 case DNTT_TYPE_FPARAM
:
5714 /* Function parameters. */
5715 /* Note 1: This code was present in the 4.16 sources, and then
5716 removed, because fparams are handled in
5717 hpread_read_function_type(). However, while fparam symbols
5718 are indeed handled twice, this code here cannot be removed
5719 because then they don't get added to the local symbol list of
5720 the function's code block, which leads to a failure to look
5721 up locals, "this"-relative member names, etc. So I've put
5722 this code back in. pai/1997-07-21 */
5723 /* Note 2: To fix a defect, we stopped adding FPARAMS to local_symbols
5724 in hpread_read_function_type(), so FPARAMS had to be handled
5725 here. I changed the location to be the appropriate argument
5726 kinds rather than LOC_LOCAL. pai/1997-08-08 */
5727 /* Note 3: Well, the fix in Note 2 above broke argument printing
5728 in traceback frames, and further it makes assumptions about the
5729 order of the FPARAM entries from HP compilers (cc and aCC in particular
5730 generate them in reverse orders -- fixing one breaks for the other).
5731 So I've added code in hpread_read_function_type() to add fparams
5732 to a param_symbols list for the current context level. These are
5733 then merged into local_symbols when a function end is reached.
5736 break; /* do nothing; handled in hpread_read_function_type() */
5738 #if 0 /* Old code */
5739 if (dn_bufp
->dfparam
.regparam
)
5740 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
5741 else if (dn_bufp
->dfparam
.indirect
)
5742 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
5744 SYMBOL_CLASS (sym
) = LOC_ARG
;
5745 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
5746 if (dn_bufp
->dfparam
.copyparam
)
5748 SYMBOL_VALUE (sym
) = dn_bufp
->dfparam
.location
;
5749 #ifdef HPREAD_ADJUST_STACK_ADDRESS
5751 += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile
));
5755 SYMBOL_VALUE (sym
) = dn_bufp
->dfparam
.location
;
5756 SYMBOL_TYPE (sym
) = hpread_type_lookup (dn_bufp
->dfparam
.type
, objfile
);
5757 add_symbol_to_list (sym
, &fparam_symbols
);
5761 case DNTT_TYPE_SVAR
:
5762 /* Static variables. */
5763 SYMBOL_CLASS (sym
) = LOC_STATIC
;
5765 /* Note: There is a case that arises with globals in shared
5766 * libraries where we need to set the address to LOC_INDIRECT.
5767 * This case is if you have a global "g" in one library, and
5768 * it is referenced "extern <type> g;" in another library.
5769 * If we're processing the symbols for the referencing library,
5770 * we'll see a global "g", but in this case the address given
5771 * in the symbol table contains a pointer to the real "g".
5772 * We use the storage class LOC_INDIRECT to indicate this. RT
5774 if (is_in_import_list (SYMBOL_NAME (sym
), objfile
))
5775 SYMBOL_CLASS (sym
) = LOC_INDIRECT
;
5777 SYMBOL_VALUE_ADDRESS (sym
) = dn_bufp
->dsvar
.location
+ data_offset
;
5778 SYMBOL_TYPE (sym
) = hpread_type_lookup (dn_bufp
->dsvar
.type
, objfile
);
5780 if (dn_bufp
->dsvar
.global
)
5781 add_symbol_to_list (sym
, &global_symbols
);
5783 else if (WITHIN_FUNCTION (objfile
))
5784 add_symbol_to_list (sym
, &local_symbols
);
5787 add_symbol_to_list (sym
, &file_symbols
);
5789 if (dn_bufp
->dsvar
.thread_specific
)
5791 /* Thread-local variable.
5793 SYMBOL_CLASS (sym
) = LOC_THREAD_LOCAL_STATIC
;
5794 SYMBOL_BASEREG (sym
) = CR27_REGNUM
;
5796 if (objfile
->flags
& OBJF_SHARED
)
5799 * This variable is not only thread local but
5800 * in a shared library.
5802 * Alas, the shared lib structures are private
5803 * to "somsolib.c". But C lets us point to one.
5807 if (objfile
->obj_private
== NULL
)
5808 error ("Internal error in reading shared library information.");
5810 so
= ((obj_private_data_t
*) (objfile
->obj_private
))->so_info
;
5812 error ("Internal error in reading shared library information.");
5814 /* Thread-locals in shared libraries do NOT have the
5815 * standard offset ("data_offset"), so we re-calculate
5816 * where to look for this variable, using a call-back
5817 * to interpret the private shared-library data.
5819 SYMBOL_VALUE_ADDRESS (sym
) = dn_bufp
->dsvar
.location
+
5820 so_lib_thread_start_addr (so
);
5825 case DNTT_TYPE_DVAR
:
5826 /* Dynamic variables. */
5827 if (dn_bufp
->ddvar
.regvar
)
5828 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
5830 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
5832 SYMBOL_VALUE (sym
) = dn_bufp
->ddvar
.location
;
5833 #ifdef HPREAD_ADJUST_STACK_ADDRESS
5835 += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile
));
5837 SYMBOL_TYPE (sym
) = hpread_type_lookup (dn_bufp
->ddvar
.type
, objfile
);
5838 if (dn_bufp
->ddvar
.global
)
5839 add_symbol_to_list (sym
, &global_symbols
);
5840 else if (WITHIN_FUNCTION (objfile
))
5841 add_symbol_to_list (sym
, &local_symbols
);
5843 add_symbol_to_list (sym
, &file_symbols
);
5846 case DNTT_TYPE_CONST
:
5847 /* A constant (pascal?). */
5848 SYMBOL_CLASS (sym
) = LOC_CONST
;
5849 SYMBOL_VALUE (sym
) = dn_bufp
->dconst
.location
;
5850 SYMBOL_TYPE (sym
) = hpread_type_lookup (dn_bufp
->dconst
.type
, objfile
);
5851 if (dn_bufp
->dconst
.global
)
5852 add_symbol_to_list (sym
, &global_symbols
);
5853 else if (WITHIN_FUNCTION (objfile
))
5854 add_symbol_to_list (sym
, &local_symbols
);
5856 add_symbol_to_list (sym
, &file_symbols
);
5859 case DNTT_TYPE_TYPEDEF
:
5860 /* A typedef. We do want to process these, since a name is
5861 * added to the namespace for the typedef'ed name.
5863 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
5864 SYMBOL_TYPE (sym
) = hpread_type_lookup (dn_bufp
->dtype
.type
, objfile
);
5865 if (dn_bufp
->dtype
.global
)
5866 add_symbol_to_list (sym
, &global_symbols
);
5867 else if (WITHIN_FUNCTION (objfile
))
5868 add_symbol_to_list (sym
, &local_symbols
);
5870 add_symbol_to_list (sym
, &file_symbols
);
5873 case DNTT_TYPE_TAGDEF
:
5875 int global
= dn_bufp
->dtag
.global
;
5876 /* Structure, union, enum, template, or class tag definition */
5877 /* We do want to process these, since a name is
5878 * added to the namespace for the tag name (and if C++ class,
5879 * for the typename also).
5881 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
5883 /* The tag contains in its "type" field a pointer to the
5884 * DNTT_TYPE_STRUCT, DNTT_TYPE_UNION, DNTT_TYPE_ENUM,
5885 * DNTT_TYPE_CLASS or DNTT_TYPE_TEMPLATE
5886 * record that actually defines the type.
5888 SYMBOL_TYPE (sym
) = hpread_type_lookup (dn_bufp
->dtype
.type
, objfile
);
5889 TYPE_NAME (sym
->type
) = SYMBOL_NAME (sym
);
5890 TYPE_TAG_NAME (sym
->type
) = SYMBOL_NAME (sym
);
5891 if (dn_bufp
->dtag
.global
)
5892 add_symbol_to_list (sym
, &global_symbols
);
5893 else if (WITHIN_FUNCTION (objfile
))
5894 add_symbol_to_list (sym
, &local_symbols
);
5896 add_symbol_to_list (sym
, &file_symbols
);
5898 /* If this is a C++ class, then we additionally
5899 * need to define a typedef for the
5900 * class type. E.g., so that the name "c" becomes visible as
5901 * a type name when the user says "class c { ... }".
5902 * In order to figure this out, we need to chase down the "type"
5903 * field to get to the DNTT_TYPE_CLASS record.
5905 * We also add the typename for ENUM. Though this isn't
5906 * strictly correct, it is necessary because of the debug info
5907 * generated by the aCC compiler, in which we cannot
5908 * distinguish between:
5911 * typedef enum { ... } e;
5912 * I.e., the compiler emits the same debug info for the above
5913 * two cases, in both cases "e" appearing as a tagdef.
5914 * Therefore go ahead and generate the typename so that
5915 * "ptype e" will work in the above cases.
5917 * We also add the typename for TEMPLATE, so as to allow "ptype t"
5918 * when "t" is a template name.
5920 if (dn_bufp
->dtype
.type
.dnttp
.index
< LNTT_SYMCOUNT (objfile
))
5921 dn_bufp
= hpread_get_lntt (dn_bufp
->dtag
.type
.dnttp
.index
, objfile
);
5924 complain (&hpread_tagdef_complaint
);
5927 if (dn_bufp
->dblock
.kind
== DNTT_TYPE_CLASS
||
5928 dn_bufp
->dblock
.kind
== DNTT_TYPE_ENUM
||
5929 dn_bufp
->dblock
.kind
== DNTT_TYPE_TEMPLATE
)
5931 struct symbol
*newsym
;
5933 newsym
= (struct symbol
*) obstack_alloc (&objfile
->symbol_obstack
,
5934 sizeof (struct symbol
));
5935 memset (newsym
, 0, sizeof (struct symbol
));
5936 SYMBOL_NAME (newsym
) = name
;
5937 SYMBOL_LANGUAGE (newsym
) = language_auto
;
5938 SYMBOL_NAMESPACE (newsym
) = VAR_NAMESPACE
;
5939 SYMBOL_LINE (newsym
) = 0;
5940 SYMBOL_VALUE (newsym
) = 0;
5941 SYMBOL_CLASS (newsym
) = LOC_TYPEDEF
;
5942 SYMBOL_TYPE (newsym
) = sym
->type
;
5944 add_symbol_to_list (newsym
, &global_symbols
);
5945 else if (WITHIN_FUNCTION (objfile
))
5946 add_symbol_to_list (newsym
, &local_symbols
);
5948 add_symbol_to_list (newsym
, &file_symbols
);
5953 case DNTT_TYPE_POINTER
:
5954 /* Declares a pointer type. Should not be necessary to do anything
5955 * with the type at this level; these are processed
5956 * at the hpread_type_lookup() level.
5960 case DNTT_TYPE_ENUM
:
5961 /* Declares an enum type. Should not be necessary to do anything
5962 * with the type at this level; these are processed
5963 * at the hpread_type_lookup() level.
5967 case DNTT_TYPE_MEMENUM
:
5968 /* Member of enum */
5969 /* Ignored at this level, but hpread_read_enum_type() will take
5970 * care of walking the list of enumeration members.
5975 /* Declares a set type. Should not be necessary to do anything
5976 * with the type at this level; these are processed
5977 * at the hpread_type_lookup() level.
5981 case DNTT_TYPE_SUBRANGE
:
5982 /* Declares a subrange type. Should not be necessary to do anything
5983 * with the type at this level; these are processed
5984 * at the hpread_type_lookup() level.
5988 case DNTT_TYPE_ARRAY
:
5989 /* Declares an array type. Should not be necessary to do anything
5990 * with the type at this level; these are processed
5991 * at the hpread_type_lookup() level.
5995 case DNTT_TYPE_STRUCT
:
5996 case DNTT_TYPE_UNION
:
5997 /* Declares an struct/union type.
5998 * Should not be necessary to do anything
5999 * with the type at this level; these are processed
6000 * at the hpread_type_lookup() level.
6004 case DNTT_TYPE_FIELD
:
6005 /* Structure/union/class field */
6006 /* Ignored at this level, but hpread_read_struct_type() will take
6007 * care of walking the list of structure/union/class members.
6011 /* DNTT_TYPE_VARIANT is not handled by GDB */
6013 /* DNTT_TYPE_FILE is not handled by GDB */
6015 case DNTT_TYPE_FUNCTYPE
:
6017 /* Ignored at this level, handled within hpread_type_lookup() */
6020 case DNTT_TYPE_WITH
:
6021 /* This is emitted within methods to indicate "with <class>"
6022 * scoping rules (i.e., indicate that the class data members
6023 * are directly visible).
6024 * However, since GDB already infers this by looking at the
6025 * "this" argument, interpreting the DNTT_TYPE_WITH
6026 * symbol record is unnecessary.
6030 case DNTT_TYPE_COMMON
:
6031 /* FORTRAN common. Not yet handled. */
6032 complain (&hpread_unhandled_common_complaint
);
6035 /* DNTT_TYPE_COBSTRUCT is not handled by GDB. */
6036 /* DNTT_TYPE_XREF is not handled by GDB. */
6037 /* DNTT_TYPE_SA is not handled by GDB. */
6038 /* DNTT_TYPE_MACRO is not handled by GDB */
6040 case DNTT_TYPE_BLOCKDATA
:
6041 /* Not sure what this is - part of FORTRAN support maybe?
6042 * Anyway, not yet handled.
6044 complain (&hpread_unhandled_blockdata_complaint
);
6047 case DNTT_TYPE_CLASS_SCOPE
:
6051 /* The compiler brackets member functions with a CLASS_SCOPE/END
6052 * pair of records, presumably to put them in a different scope
6053 * from the module scope where they are normally defined.
6054 * E.g., in the situation:
6056 * void c::f() { ...}
6057 * The member function "c::f" will be bracketed by a CLASS_SCOPE/END.
6058 * This causes "break f" at the module level to pick the
6059 * the file-level function f(), not the member function
6060 * (which needs to be referenced via "break c::f").
6062 * Here we record the class name to generate the demangled names of
6063 * member functions later.
6065 * FIXME Not being used now for anything -- cplus_demangle seems
6066 * enough for getting the class-qualified names of functions. We
6067 * may need this for handling nested classes and types. */
6069 /* pai: FIXME Not handling nested classes for now -- need to
6070 * maintain a stack */
6072 dn_temp
= hpread_get_lntt (dn_bufp
->dclass_scope
.type
.dnttp
.index
, objfile
);
6073 if (dn_temp
->dblock
.kind
== DNTT_TYPE_TAGDEF
)
6074 class_scope_name
= VT (objfile
) + dn_temp
->dtag
.name
;
6076 class_scope_name
= NULL
;
6080 /* Begin a new scope. */
6081 SL_INDEX (objfile
) = hpread_record_lines (current_subfile
,
6083 dn_bufp
->dclass_scope
.address
,
6085 valu
= hpread_get_location (dn_bufp
->dclass_scope
.address
, objfile
);
6086 valu
+= offset
; /* Relocate for dynamic loading */
6087 desc
= hpread_get_scope_start (dn_bufp
->dclass_scope
.address
, objfile
);
6088 /* We use the scope start DNTT index as the nesting depth identifier! */
6089 new = push_context (desc
, valu
);
6093 case DNTT_TYPE_REFERENCE
:
6094 /* Declares a C++ reference type. Should not be necessary to do anything
6095 * with the type at this level; these are processed
6096 * at the hpread_type_lookup() level.
6100 case DNTT_TYPE_PTRMEM
:
6101 /* Declares a C++ pointer-to-data-member type. This does not
6102 * need to be handled at this level; being a type description it
6103 * is instead handled at the hpread_type_lookup() level.
6107 case DNTT_TYPE_PTRMEMFUNC
:
6108 /* Declares a C++ pointer-to-function-member type. This does not
6109 * need to be handled at this level; being a type description it
6110 * is instead handled at the hpread_type_lookup() level.
6114 case DNTT_TYPE_CLASS
:
6115 /* Declares a class type.
6116 * Should not be necessary to do anything
6117 * with the type at this level; these are processed
6118 * at the hpread_type_lookup() level.
6122 case DNTT_TYPE_GENFIELD
:
6123 /* I believe this is used for class member functions */
6124 /* Ignored at this level, but hpread_read_struct_type() will take
6125 * care of walking the list of class members.
6129 case DNTT_TYPE_VFUNC
:
6130 /* Virtual function */
6131 /* This does not have to be handled at this level; handled in
6132 * the course of processing class symbols.
6136 case DNTT_TYPE_MEMACCESS
:
6137 /* DDE ignores this symbol table record.
6138 * It has something to do with "modified access" to class members.
6139 * I'll assume we can safely ignore it too.
6143 case DNTT_TYPE_INHERITANCE
:
6144 /* These don't have to be handled here, since they are handled
6145 * within hpread_read_struct_type() in the process of constructing
6150 case DNTT_TYPE_FRIEND_CLASS
:
6151 case DNTT_TYPE_FRIEND_FUNC
:
6152 /* These can safely be ignored, as GDB doesn't need this
6153 * info. DDE only uses it in "describe". We may later want
6154 * to extend GDB's "ptype" to give this info, but for now
6155 * it seems safe enough to ignore it.
6159 case DNTT_TYPE_MODIFIER
:
6160 /* Intended to supply "modified access" to a type */
6161 /* From the way DDE handles this, it looks like it always
6162 * modifies a type. Therefore it is safe to ignore it at this
6163 * level, and handle it in hpread_type_lookup().
6167 case DNTT_TYPE_OBJECT_ID
:
6168 /* Just ignore this - that's all DDE does */
6171 case DNTT_TYPE_MEMFUNC
:
6172 /* Member function */
6173 /* This does not have to be handled at this level; handled in
6174 * the course of processing class symbols.
6178 case DNTT_TYPE_DOC_MEMFUNC
:
6179 /* Member function */
6180 /* This does not have to be handled at this level; handled in
6181 * the course of processing class symbols.
6185 case DNTT_TYPE_TEMPLATE
:
6186 /* Template - sort of the header for a template definition,
6187 * which like a class, points to a member list and also points
6188 * to a TEMPLATE_ARG list of type-arguments.
6189 * We do not need to process TEMPLATE records at this level though.
6193 case DNTT_TYPE_TEMPLATE_ARG
:
6194 /* The TEMPLATE record points to an argument list of
6195 * TEMPLATE_ARG records, each of which describes one
6196 * of the type-arguments.
6197 * We do not need to process TEMPLATE_ARG records at this level though.
6201 case DNTT_TYPE_FUNC_TEMPLATE
:
6202 /* This will get emitted for member functions of templates.
6203 * But we don't need to process this record at this level though,
6204 * we will process it in the course of processing a TEMPLATE
6209 case DNTT_TYPE_LINK
:
6210 /* The LINK record is used to link up templates with instantiations. */
6211 /* It is not clear why this is needed, and furthermore aCC does
6212 * not appear to generate this, so I think we can safely ignore it. - RT
6216 /* DNTT_TYPE_DYN_ARRAY_DESC is not handled by GDB */
6217 /* DNTT_TYPE_DESC_SUBRANGE is not handled by GDB */
6218 /* DNTT_TYPE_BEGIN_EXT is not handled by GDB */
6219 /* DNTT_TYPE_INLN is not handled by GDB */
6220 /* DNTT_TYPE_INLN_LIST is not handled by GDB */
6221 /* DNTT_TYPE_ALIAS is not handled by GDB */
6228 /* Get nesting depth for a DNTT entry.
6229 * DN_BUFP points to a DNTT entry.
6230 * OBJFILE is the object file.
6231 * REPORT_NESTED is a flag; if 0, real nesting depth is
6232 * reported, if it is 1, the function simply returns a
6233 * non-zero value if the nesting depth is anything > 0.
6235 * Return value is an integer. 0 => not a local type / name
6236 * positive return => type or name is local to some
6237 * block or function.
6241 /* elz: ATTENTION: FIXME: NOTE: WARNING!!!!
6242 this function now returns 0 right away. It was taking too much time
6243 at start up. Now, though, the local types are not handled correctly.
6248 hpread_get_scope_depth (union dnttentry
*dn_bufp
, struct objfile
*objfile
,
6252 register union dnttentry
*dn_tmp
;
6253 register short depth
= 0;
6254 /****************************/
6256 /****************************/
6258 index
= (((char *) dn_bufp
) - LNTT (objfile
)) / (sizeof (struct dntt_type_block
));
6260 while (--index
>= 0)
6262 dn_tmp
= hpread_get_lntt (index
, objfile
);
6263 switch (dn_tmp
->dblock
.kind
)
6265 case DNTT_TYPE_MODULE
:
6268 /* index is signed int; dnttp.index is 29-bit unsigned int! */
6269 index
= (int) dn_tmp
->dend
.beginscope
.dnttp
.index
;
6271 case DNTT_TYPE_BEGIN
:
6272 case DNTT_TYPE_FUNCTION
:
6273 case DNTT_TYPE_DOC_FUNCTION
:
6274 case DNTT_TYPE_WITH
:
6275 case DNTT_TYPE_COMMON
:
6276 case DNTT_TYPE_CLASS_SCOPE
:
6288 /* Adjust the bitoffsets for all fields of an anonymous union of
6289 type TYPE by negative BITS. This handles HP aCC's hideous habit
6290 of giving members of anonymous unions bit offsets relative to the
6291 enclosing structure instead of relative to the union itself. */
6294 hpread_adjust_bitoffsets (struct type
*type
, int bits
)
6298 /* This is done only for unions; caller had better check that
6299 it is an anonymous one. */
6300 if (TYPE_CODE (type
) != TYPE_CODE_UNION
)
6303 /* Adjust each field; since this is a union, there are no base
6304 classes. Also no static membes. Also, no need for recursion as
6305 the members of this union if themeselves structs or unions, have
6306 the correct bitoffsets; if an anonymous union is a member of this
6307 anonymous union, the code in hpread_read_struct_type() will
6310 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
6311 TYPE_FIELD_BITPOS (type
, i
) -= bits
;
6314 /* Because of quirks in HP compilers' treatment of anonymous unions inside
6315 classes, we have to chase through a chain of threaded FIELD entries.
6316 If we encounter an anonymous union in the chain, we must recursively skip over
6319 This function does a "next" in the chain of FIELD entries, but transparently
6320 skips over anonymous unions' fields (recursively).
6322 Inputs are the number of times to do "next" at the top level, the dnttpointer
6323 (FIELD) and entry pointer (FIELDP) for the dntt record corresponding to it,
6324 and the ubiquitous objfile parameter. (Note: FIELDP is a **.) Return value
6325 is a dnttpointer for the new field after all the skipped ones */
6328 hpread_get_next_skip_over_anon_unions (int skip_fields
, dnttpointer field
,
6329 union dnttentry
**fieldp
,
6330 struct objfile
*objfile
)
6332 struct type
*anon_type
;
6337 for (i
= 0; i
< skip_fields
; i
++)
6339 /* Get type of item we're looking at now; recursively processes the types
6340 of these intermediate items we skip over, so they aren't lost. */
6341 anon_type
= hpread_type_lookup ((*fieldp
)->dfield
.type
, objfile
);
6342 anon_type
= CHECK_TYPEDEF (anon_type
);
6343 bitoffset
= (*fieldp
)->dfield
.bitoffset
;
6344 name
= VT (objfile
) + (*fieldp
)->dfield
.name
;
6345 /* First skip over one item to avoid stack death on recursion */
6346 field
= (*fieldp
)->dfield
.nextfield
;
6347 *fieldp
= hpread_get_lntt (field
.dnttp
.index
, objfile
);
6348 /* Do we have another anonymous union? If so, adjust the bitoffsets
6349 of its members and skip over its members. */
6350 if ((TYPE_CODE (anon_type
) == TYPE_CODE_UNION
) &&
6351 (!name
|| STREQ (name
, "")))
6353 hpread_adjust_bitoffsets (anon_type
, bitoffset
);
6354 field
= hpread_get_next_skip_over_anon_unions (TYPE_NFIELDS (anon_type
), field
, fieldp
, objfile
);