]>
Commit | Line | Data |
---|---|---|
c906108c | 1 | /* Read hp debug symbols and convert to internal format, for GDB. |
6aba47ca DJ |
2 | Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, |
3 | 2003, 2004, 2006, 2007 Free Software Foundation, Inc. | |
c906108c SS |
4 | |
5 | This file is part of GDB. | |
6 | ||
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. | |
11 | ||
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. | |
16 | ||
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 | |
197e01b6 EZ |
19 | Foundation, Inc., 51 Franklin Street, Fifth Floor, |
20 | Boston, MA 02110-1301, USA. | |
c906108c SS |
21 | |
22 | Written by the Center for Software Science at the University of Utah | |
23 | and by Cygnus Support. */ | |
24 | ||
25 | #include "defs.h" | |
26 | #include "bfd.h" | |
27 | #include "gdb_string.h" | |
28 | #include "hp-symtab.h" | |
29 | #include "syms.h" | |
30 | #include "symtab.h" | |
31 | #include "symfile.h" | |
32 | #include "objfiles.h" | |
33 | #include "buildsym.h" | |
34 | #include "complaints.h" | |
35 | #include "gdb-stabs.h" | |
36 | #include "gdbtypes.h" | |
37 | #include "demangle.h" | |
acf86d54 | 38 | #include "solib-som.h" |
65e82032 | 39 | #include "gdb_assert.h" |
7c46b9fb | 40 | #include "hppa-tdep.h" |
c906108c SS |
41 | |
42 | /* Private information attached to an objfile which we use to find | |
43 | and internalize the HP C debug symbols within that objfile. */ | |
44 | ||
45 | struct hpread_symfile_info | |
c5aa993b JM |
46 | { |
47 | /* The contents of each of the debug sections (there are 4 of them). */ | |
48 | char *gntt; | |
49 | char *lntt; | |
50 | char *slt; | |
51 | char *vt; | |
c906108c | 52 | |
c5aa993b JM |
53 | /* We keep the size of the $VT$ section for range checking. */ |
54 | unsigned int vt_size; | |
c906108c | 55 | |
c5aa993b JM |
56 | /* Some routines still need to know the number of symbols in the |
57 | main debug sections ($LNTT$ and $GNTT$). */ | |
58 | unsigned int lntt_symcount; | |
59 | unsigned int gntt_symcount; | |
c906108c | 60 | |
c5aa993b | 61 | /* To keep track of all the types we've processed. */ |
9a6f53fe EZ |
62 | struct type **dntt_type_vector; |
63 | int dntt_type_vector_length; | |
c906108c | 64 | |
c5aa993b JM |
65 | /* Keeps track of the beginning of a range of source lines. */ |
66 | sltpointer sl_index; | |
c906108c | 67 | |
c5aa993b JM |
68 | /* Some state variables we'll need. */ |
69 | int within_function; | |
c906108c | 70 | |
c5aa993b JM |
71 | /* Keep track of the current function's address. We may need to look |
72 | up something based on this address. */ | |
73 | unsigned int current_function_value; | |
74 | }; | |
c906108c SS |
75 | |
76 | /* Accessor macros to get at the fields. */ | |
77 | #define HPUX_SYMFILE_INFO(o) \ | |
0a6ddd08 | 78 | ((struct hpread_symfile_info *)((o)->deprecated_sym_private)) |
c906108c SS |
79 | #define GNTT(o) (HPUX_SYMFILE_INFO(o)->gntt) |
80 | #define LNTT(o) (HPUX_SYMFILE_INFO(o)->lntt) | |
81 | #define SLT(o) (HPUX_SYMFILE_INFO(o)->slt) | |
82 | #define VT(o) (HPUX_SYMFILE_INFO(o)->vt) | |
83 | #define VT_SIZE(o) (HPUX_SYMFILE_INFO(o)->vt_size) | |
84 | #define LNTT_SYMCOUNT(o) (HPUX_SYMFILE_INFO(o)->lntt_symcount) | |
85 | #define GNTT_SYMCOUNT(o) (HPUX_SYMFILE_INFO(o)->gntt_symcount) | |
9a6f53fe EZ |
86 | #define DNTT_TYPE_VECTOR(o) (HPUX_SYMFILE_INFO(o)->dntt_type_vector) |
87 | #define DNTT_TYPE_VECTOR_LENGTH(o) \ | |
88 | (HPUX_SYMFILE_INFO(o)->dntt_type_vector_length) | |
c906108c SS |
89 | #define SL_INDEX(o) (HPUX_SYMFILE_INFO(o)->sl_index) |
90 | #define WITHIN_FUNCTION(o) (HPUX_SYMFILE_INFO(o)->within_function) | |
91 | #define CURRENT_FUNCTION_VALUE(o) (HPUX_SYMFILE_INFO(o)->current_function_value) | |
92 | ||
c906108c SS |
93 | \f |
94 | /* We put a pointer to this structure in the read_symtab_private field | |
95 | of the psymtab. */ | |
96 | ||
97 | struct symloc | |
c5aa993b JM |
98 | { |
99 | /* The offset within the file symbol table of first local symbol for | |
100 | this file. */ | |
c906108c | 101 | |
c5aa993b | 102 | int ldsymoff; |
c906108c | 103 | |
c5aa993b JM |
104 | /* Length (in bytes) of the section of the symbol table devoted to |
105 | this file's symbols (actually, the section bracketed may contain | |
106 | more than just this file's symbols). If ldsymlen is 0, the only | |
107 | reason for this thing's existence is the dependency list. | |
108 | Nothing else will happen when it is read in. */ | |
c906108c | 109 | |
c5aa993b JM |
110 | int ldsymlen; |
111 | }; | |
c906108c SS |
112 | |
113 | #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff) | |
114 | #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen) | |
115 | #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private)) | |
116 | \f | |
c906108c | 117 | /* Complaints about the symbols we have encountered. */ |
23136709 KB |
118 | static void |
119 | lbrac_unmatched_complaint (int arg1) | |
8af51c36 | 120 | { |
e2e0b3e5 | 121 | complaint (&symfile_complaints, _("unmatched N_LBRAC before symtab pos %d"), |
23136709 KB |
122 | arg1); |
123 | } | |
8af51c36 | 124 | |
23136709 KB |
125 | static void |
126 | lbrac_mismatch_complaint (int arg1) | |
8af51c36 | 127 | { |
23136709 | 128 | complaint (&symfile_complaints, |
e2e0b3e5 | 129 | _("N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d"), arg1); |
23136709 | 130 | } |
8af51c36 EZ |
131 | |
132 | /* To generate dumping code, uncomment this define. The dumping | |
133 | itself is controlled by routine-local statics called "dumping". */ | |
134 | /* #define DUMPING 1 */ | |
135 | ||
136 | /* To use the quick look-up tables, uncomment this define. */ | |
137 | #define QUICK_LOOK_UP 1 | |
138 | ||
139 | /* To call PXDB to process un-processed files, uncomment this define. */ | |
140 | #define USE_PXDB 1 | |
141 | ||
142 | /* Forward procedure declarations */ | |
143 | ||
f5479e9c | 144 | /* Used in somread.c. */ |
8af51c36 EZ |
145 | void hpread_symfile_init (struct objfile *); |
146 | ||
147 | void do_pxdb (bfd *); | |
c906108c | 148 | |
a14ed312 | 149 | void hpread_build_psymtabs (struct objfile *, int); |
c906108c | 150 | |
a14ed312 | 151 | void hpread_symfile_finish (struct objfile *); |
c906108c | 152 | |
f5479e9c EZ |
153 | static void set_namestring (union dnttentry *sym, char **namep, |
154 | struct objfile *objfile); | |
155 | ||
8af51c36 EZ |
156 | static union dnttentry *hpread_get_gntt (int, struct objfile *); |
157 | ||
2f4150cc AC |
158 | static union dnttentry *hpread_get_lntt (int index, struct objfile *objfile); |
159 | ||
160 | ||
8af51c36 EZ |
161 | static unsigned long hpread_get_textlow (int, int, struct objfile *, int); |
162 | ||
c906108c | 163 | static struct partial_symtab *hpread_start_psymtab |
a14ed312 KB |
164 | (struct objfile *, char *, CORE_ADDR, int, |
165 | struct partial_symbol **, struct partial_symbol **); | |
c906108c SS |
166 | |
167 | static struct partial_symtab *hpread_end_psymtab | |
a14ed312 KB |
168 | (struct partial_symtab *, char **, int, int, CORE_ADDR, |
169 | struct partial_symtab **, int); | |
c906108c | 170 | |
8af51c36 EZ |
171 | static unsigned long hpread_get_scope_start (sltpointer, struct objfile *); |
172 | ||
173 | static unsigned long hpread_get_line (sltpointer, struct objfile *); | |
174 | ||
175 | static CORE_ADDR hpread_get_location (sltpointer, struct objfile *); | |
176 | ||
f5479e9c | 177 | static int hpread_has_name (enum dntt_entry_type kind); |
504d5c7e | 178 | |
8af51c36 EZ |
179 | static void hpread_psymtab_to_symtab_1 (struct partial_symtab *); |
180 | ||
f5479e9c | 181 | static void hpread_psymtab_to_symtab (struct partial_symtab *); |
8af51c36 | 182 | |
c906108c | 183 | static struct symtab *hpread_expand_symtab |
a14ed312 KB |
184 | (struct objfile *, int, int, CORE_ADDR, int, |
185 | struct section_offsets *, char *); | |
c906108c | 186 | |
8af51c36 | 187 | static int hpread_type_translate (dnttpointer); |
c906108c | 188 | |
8af51c36 EZ |
189 | static struct type **hpread_lookup_type (dnttpointer, struct objfile *); |
190 | ||
191 | static struct type *hpread_alloc_type (dnttpointer, struct objfile *); | |
192 | ||
193 | static struct type *hpread_read_enum_type | |
194 | (dnttpointer, union dnttentry *, struct objfile *); | |
c906108c SS |
195 | |
196 | static struct type *hpread_read_function_type | |
8af51c36 EZ |
197 | (dnttpointer, union dnttentry *, struct objfile *, int); |
198 | ||
199 | static struct type *hpread_read_doc_function_type | |
200 | (dnttpointer, union dnttentry *, struct objfile *, int); | |
201 | ||
202 | static struct type *hpread_read_struct_type | |
a14ed312 | 203 | (dnttpointer, union dnttentry *, struct objfile *); |
c906108c | 204 | |
8af51c36 | 205 | static struct type *hpread_get_nth_template_arg (struct objfile *, int); |
c906108c | 206 | |
8af51c36 EZ |
207 | static struct type *hpread_read_templ_arg_type |
208 | (dnttpointer, union dnttentry *, struct objfile *, char *); | |
c906108c | 209 | |
8af51c36 EZ |
210 | static struct type *hpread_read_set_type |
211 | (dnttpointer, union dnttentry *, struct objfile *); | |
c906108c | 212 | |
8af51c36 EZ |
213 | static struct type *hpread_read_array_type |
214 | (dnttpointer, union dnttentry *dn_bufp, struct objfile *objfile); | |
c906108c | 215 | |
8af51c36 EZ |
216 | static struct type *hpread_read_subrange_type |
217 | (dnttpointer, union dnttentry *, struct objfile *); | |
c5aa993b | 218 | |
8af51c36 | 219 | static struct type *hpread_type_lookup (dnttpointer, struct objfile *); |
c906108c | 220 | |
8af51c36 EZ |
221 | static sltpointer hpread_record_lines |
222 | (struct subfile *, sltpointer, sltpointer, struct objfile *, CORE_ADDR); | |
c906108c | 223 | |
8af51c36 EZ |
224 | static void hpread_process_one_debug_symbol |
225 | (union dnttentry *, char *, struct section_offsets *, | |
226 | struct objfile *, CORE_ADDR, int, char *, int, int *); | |
c906108c | 227 | |
8af51c36 | 228 | static int hpread_get_scope_depth (union dnttentry *, struct objfile *, int); |
c906108c | 229 | |
8af51c36 EZ |
230 | static void fix_static_member_physnames |
231 | (struct type *, char *, struct objfile *); | |
c906108c | 232 | |
8af51c36 EZ |
233 | static void fixup_class_method_type |
234 | (struct type *, struct type *, struct objfile *); | |
c906108c | 235 | |
8af51c36 | 236 | static void hpread_adjust_bitoffsets (struct type *, int); |
c906108c | 237 | |
7c46b9fb RC |
238 | static int hpread_adjust_stack_address (CORE_ADDR func_addr); |
239 | ||
8af51c36 EZ |
240 | static dnttpointer hpread_get_next_skip_over_anon_unions |
241 | (int, dnttpointer, union dnttentry **, struct objfile *); | |
c906108c | 242 | |
8af51c36 | 243 | \f |
8af51c36 EZ |
244 | /* Static used to indicate a class type that requires a |
245 | fix-up of one of its method types */ | |
246 | static struct type *fixup_class = NULL; | |
c906108c | 247 | |
8af51c36 EZ |
248 | /* Static used to indicate the method type that is to be |
249 | used to fix-up the type for fixup_class */ | |
250 | static struct type *fixup_method = NULL; | |
c906108c | 251 | |
8af51c36 | 252 | #ifdef USE_PXDB |
c906108c | 253 | |
8af51c36 | 254 | /* NOTE use of system files! May not be portable. */ |
c906108c | 255 | |
8af51c36 EZ |
256 | #define PXDB_SVR4 "/opt/langtools/bin/pxdb" |
257 | #define PXDB_BSD "/usr/bin/pxdb" | |
c906108c | 258 | |
8af51c36 EZ |
259 | #include <stdlib.h> |
260 | #include "gdb_string.h" | |
c906108c | 261 | |
8af51c36 | 262 | /* check for the existence of a file, given its full pathname */ |
f5479e9c | 263 | static int |
8af51c36 EZ |
264 | file_exists (char *filename) |
265 | { | |
266 | if (filename) | |
267 | return (access (filename, F_OK) == 0); | |
268 | return 0; | |
269 | } | |
c906108c | 270 | |
c906108c | 271 | |
8af51c36 EZ |
272 | /* Translate from the "hp_language" enumeration in hp-symtab.h |
273 | used in the debug info to gdb's generic enumeration in defs.h. */ | |
274 | static enum language | |
275 | trans_lang (enum hp_language in_lang) | |
276 | { | |
277 | if (in_lang == HP_LANGUAGE_C) | |
278 | return language_c; | |
c906108c | 279 | |
8af51c36 EZ |
280 | else if (in_lang == HP_LANGUAGE_CPLUSPLUS) |
281 | return language_cplus; | |
c906108c | 282 | |
8af51c36 EZ |
283 | else if (in_lang == HP_LANGUAGE_FORTRAN) |
284 | return language_fortran; | |
c906108c | 285 | |
8af51c36 EZ |
286 | else |
287 | return language_unknown; | |
c906108c SS |
288 | } |
289 | ||
8af51c36 EZ |
290 | static char main_string[] = "main"; |
291 | \f | |
68b8d23e JB |
292 | |
293 | /* Given the native debug symbol SYM, set NAMEP to the name associated | |
294 | with the debug symbol. Note we may be called with a debug symbol which | |
295 | has no associated name, in that case we return an empty string. */ | |
296 | ||
297 | static void | |
298 | set_namestring (union dnttentry *sym, char **namep, struct objfile *objfile) | |
299 | { | |
300 | /* Note that we "know" that the name for any symbol is always in the same | |
301 | place. Hence we don't have to conditionalize on the symbol type. */ | |
302 | if (! hpread_has_name (sym->dblock.kind)) | |
303 | *namep = ""; | |
304 | else if ((unsigned) sym->dsfile.name >= VT_SIZE (objfile)) | |
305 | { | |
e2e0b3e5 | 306 | complaint (&symfile_complaints, _("bad string table offset in symbol %d"), |
68b8d23e JB |
307 | symnum); |
308 | *namep = ""; | |
309 | } | |
310 | else | |
311 | *namep = sym->dsfile.name + VT (objfile); | |
312 | } | |
313 | ||
8af51c36 | 314 | /* Call PXDB to process our file. |
c906108c | 315 | |
8af51c36 EZ |
316 | Approach copied from DDE's "dbgk_run_pxdb". Note: we |
317 | don't check for BSD location of pxdb, nor for existence | |
318 | of pxdb itself, etc. | |
c906108c | 319 | |
8af51c36 | 320 | NOTE: uses system function and string functions directly. |
c906108c | 321 | |
8af51c36 | 322 | Return value: 1 if ok, 0 if not */ |
f5479e9c | 323 | static int |
8af51c36 | 324 | hpread_call_pxdb (const char *file_name) |
c906108c | 325 | { |
8af51c36 EZ |
326 | char *p; |
327 | int status; | |
328 | int retval; | |
c906108c | 329 | |
8af51c36 EZ |
330 | if (file_exists (PXDB_SVR4)) |
331 | { | |
332 | p = xmalloc (strlen (PXDB_SVR4) + strlen (file_name) + 2); | |
333 | strcpy (p, PXDB_SVR4); | |
334 | strcat (p, " "); | |
335 | strcat (p, file_name); | |
c906108c | 336 | |
8a3fe4f8 | 337 | warning (_("File not processed by pxdb--about to process now.")); |
8af51c36 | 338 | status = system (p); |
c906108c | 339 | |
8af51c36 EZ |
340 | retval = (status == 0); |
341 | } | |
342 | else | |
343 | { | |
8a3fe4f8 | 344 | 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); |
c906108c | 345 | |
8af51c36 EZ |
346 | retval = 0; |
347 | } | |
348 | return retval; | |
349 | } /* hpread_call_pxdb */ | |
350 | \f | |
c906108c | 351 | |
8af51c36 EZ |
352 | /* Return 1 if the file turns out to need pre-processing |
353 | by PXDB, and we have thus called PXDB to do this processing | |
354 | and the file therefore needs to be re-loaded. Otherwise | |
355 | return 0. */ | |
f5479e9c | 356 | static int |
8af51c36 EZ |
357 | hpread_pxdb_needed (bfd *sym_bfd) |
358 | { | |
359 | asection *pinfo_section, *debug_section, *header_section; | |
360 | unsigned int do_pxdb; | |
361 | char *buf; | |
362 | bfd_size_type header_section_size; | |
c906108c | 363 | |
8af51c36 EZ |
364 | unsigned long tmp; |
365 | unsigned int pxdbed; | |
c906108c | 366 | |
8af51c36 EZ |
367 | header_section = bfd_get_section_by_name (sym_bfd, "$HEADER$"); |
368 | if (!header_section) | |
369 | { | |
370 | return 0; /* No header at all, can't recover... */ | |
371 | } | |
c906108c | 372 | |
8af51c36 EZ |
373 | debug_section = bfd_get_section_by_name (sym_bfd, "$DEBUG$"); |
374 | pinfo_section = bfd_get_section_by_name (sym_bfd, "$PINFO$"); | |
c906108c | 375 | |
8af51c36 EZ |
376 | if (pinfo_section && !debug_section) |
377 | { | |
378 | /* Debug info with DOC, has different header format. | |
379 | this only happens if the file was pxdbed and compiled optimized | |
380 | otherwise the PINFO section is not there. */ | |
381 | header_section_size = bfd_section_size (objfile->obfd, header_section); | |
c906108c | 382 | |
8af51c36 EZ |
383 | if (header_section_size == (bfd_size_type) sizeof (DOC_info_PXDB_header)) |
384 | { | |
385 | buf = alloca (sizeof (DOC_info_PXDB_header)); | |
d4687fa0 | 386 | memset (buf, 0, sizeof (DOC_info_PXDB_header)); |
c906108c | 387 | |
8af51c36 EZ |
388 | if (!bfd_get_section_contents (sym_bfd, |
389 | header_section, | |
390 | buf, 0, | |
391 | header_section_size)) | |
8a3fe4f8 | 392 | error (_("bfd_get_section_contents.")); |
c906108c | 393 | |
8af51c36 EZ |
394 | tmp = bfd_get_32 (sym_bfd, (bfd_byte *) (buf + sizeof (int) * 4)); |
395 | pxdbed = (tmp >> 31) & 0x1; | |
c906108c | 396 | |
8af51c36 | 397 | if (!pxdbed) |
8a3fe4f8 | 398 | error (_("file debug header info invalid.")); |
8af51c36 EZ |
399 | do_pxdb = 0; |
400 | } | |
c906108c | 401 | |
c906108c | 402 | else |
8a3fe4f8 | 403 | error (_("invalid $HEADER$ size in executable.")); |
8af51c36 EZ |
404 | } |
405 | ||
406 | else | |
407 | { | |
c906108c | 408 | |
8af51c36 EZ |
409 | /* this can be three different cases: |
410 | 1. pxdbed and not doc | |
411 | - DEBUG and HEADER sections are there | |
412 | - header is PXDB_header type | |
413 | - pxdbed flag is set to 1 | |
414 | ||
415 | 2. not pxdbed and doc | |
416 | - DEBUG and HEADER sections are there | |
417 | - header is DOC_info_header type | |
418 | - pxdbed flag is set to 0 | |
419 | ||
420 | 3. not pxdbed and not doc | |
421 | - DEBUG and HEADER sections are there | |
422 | - header is XDB_header type | |
423 | - pxdbed flag is set to 0 | |
424 | ||
425 | NOTE: the pxdbed flag is meaningful also in the not | |
426 | already pxdb processed version of the header, | |
427 | because in case on non-already processed by pxdb files | |
428 | that same bit in the header would be always zero. | |
429 | Why? Because the bit is the leftmost bit of a word | |
430 | which contains a 'length' which is always a positive value | |
431 | so that bit is never set to 1 (otherwise it would be negative) | |
432 | ||
433 | Given the above, we have two choices : either we ignore the | |
434 | size of the header itself and just look at the pxdbed field, | |
435 | or we check the size and then we (for safety and paranoia related | |
436 | issues) check the bit. | |
437 | The first solution is used by DDE, the second by PXDB itself. | |
438 | I am using the second one here, because I already wrote it, | |
439 | and it is the end of a long day. | |
440 | Also, using the first approach would still involve size issues | |
441 | because we need to read in the contents of the header section, and | |
442 | give the correct amount of stuff we want to read to the | |
443 | get_bfd_section_contents function. */ | |
444 | ||
445 | /* decide which case depending on the size of the header section. | |
446 | The size is as defined in hp-symtab.h */ | |
447 | ||
448 | header_section_size = bfd_section_size (objfile->obfd, header_section); | |
449 | ||
450 | if (header_section_size == (bfd_size_type) sizeof (PXDB_header)) /* pxdb and not doc */ | |
c906108c | 451 | { |
8af51c36 EZ |
452 | |
453 | buf = alloca (sizeof (PXDB_header)); | |
d4687fa0 | 454 | memset (buf, 0, sizeof (PXDB_header)); |
8af51c36 EZ |
455 | if (!bfd_get_section_contents (sym_bfd, |
456 | header_section, | |
457 | buf, 0, | |
458 | header_section_size)) | |
8a3fe4f8 | 459 | error (_("bfd_get_section_contents.")); |
8af51c36 EZ |
460 | |
461 | tmp = bfd_get_32 (sym_bfd, (bfd_byte *) (buf + sizeof (int) * 3)); | |
462 | pxdbed = (tmp >> 31) & 0x1; | |
463 | ||
464 | if (pxdbed) | |
465 | do_pxdb = 0; | |
c906108c | 466 | else |
8a3fe4f8 | 467 | error (_("file debug header invalid.")); |
8af51c36 EZ |
468 | } |
469 | else /*not pxdbed and doc OR not pxdbed and non doc */ | |
470 | do_pxdb = 1; | |
471 | } | |
c906108c | 472 | |
8af51c36 EZ |
473 | if (do_pxdb) |
474 | { | |
475 | return 1; | |
476 | } | |
477 | else | |
478 | { | |
479 | return 0; | |
480 | } | |
481 | } /* hpread_pxdb_needed */ | |
c906108c | 482 | |
8af51c36 | 483 | #endif |
c906108c | 484 | |
8af51c36 EZ |
485 | /* Check whether the file needs to be preprocessed by pxdb. |
486 | If so, call pxdb. */ | |
c906108c | 487 | |
8af51c36 EZ |
488 | void |
489 | do_pxdb (bfd *sym_bfd) | |
490 | { | |
491 | /* The following code is HP-specific. The "right" way of | |
492 | doing this is unknown, but we bet would involve a target- | |
493 | specific pre-file-load check using a generic mechanism. */ | |
c906108c | 494 | |
8af51c36 EZ |
495 | /* This code will not be executed if the file is not in SOM |
496 | format (i.e. if compiled with gcc) */ | |
497 | if (hpread_pxdb_needed (sym_bfd)) | |
498 | { | |
499 | /*This file has not been pre-processed. Preprocess now */ | |
c906108c | 500 | |
8af51c36 EZ |
501 | if (hpread_call_pxdb (sym_bfd->filename)) |
502 | { | |
503 | /* The call above has changed the on-disk file, | |
504 | we can close the file anyway, because the | |
505 | symbols will be reread in when the target is run */ | |
506 | bfd_close (sym_bfd); | |
507 | } | |
508 | } | |
509 | } | |
510 | \f | |
c906108c | 511 | |
c906108c | 512 | |
8af51c36 | 513 | #ifdef QUICK_LOOK_UP |
c906108c | 514 | |
8af51c36 | 515 | /* Code to handle quick lookup-tables follows. */ |
c906108c | 516 | |
c906108c | 517 | |
8af51c36 EZ |
518 | /* Some useful macros */ |
519 | #define VALID_FILE(i) ((i) < pxdb_header_p->fd_entries) | |
520 | #define VALID_MODULE(i) ((i) < pxdb_header_p->md_entries) | |
521 | #define VALID_PROC(i) ((i) < pxdb_header_p->pd_entries) | |
522 | #define VALID_CLASS(i) ((i) < pxdb_header_p->cd_entries) | |
c906108c | 523 | |
8af51c36 EZ |
524 | #define FILE_START(i) (qFD[i].adrStart) |
525 | #define MODULE_START(i) (qMD[i].adrStart) | |
526 | #define PROC_START(i) (qPD[i].adrStart) | |
c906108c | 527 | |
8af51c36 EZ |
528 | #define FILE_END(i) (qFD[i].adrEnd) |
529 | #define MODULE_END(i) (qMD[i].adrEnd) | |
530 | #define PROC_END(i) (qPD[i].adrEnd) | |
c906108c | 531 | |
8af51c36 EZ |
532 | #define FILE_ISYM(i) (qFD[i].isym) |
533 | #define MODULE_ISYM(i) (qMD[i].isym) | |
534 | #define PROC_ISYM(i) (qPD[i].isym) | |
c906108c | 535 | |
8af51c36 EZ |
536 | #define VALID_CURR_FILE (curr_fd < pxdb_header_p->fd_entries) |
537 | #define VALID_CURR_MODULE (curr_md < pxdb_header_p->md_entries) | |
538 | #define VALID_CURR_PROC (curr_pd < pxdb_header_p->pd_entries) | |
539 | #define VALID_CURR_CLASS (curr_cd < pxdb_header_p->cd_entries) | |
c906108c | 540 | |
8af51c36 EZ |
541 | #define CURR_FILE_START (qFD[curr_fd].adrStart) |
542 | #define CURR_MODULE_START (qMD[curr_md].adrStart) | |
543 | #define CURR_PROC_START (qPD[curr_pd].adrStart) | |
c906108c | 544 | |
8af51c36 EZ |
545 | #define CURR_FILE_END (qFD[curr_fd].adrEnd) |
546 | #define CURR_MODULE_END (qMD[curr_md].adrEnd) | |
547 | #define CURR_PROC_END (qPD[curr_pd].adrEnd) | |
c906108c | 548 | |
8af51c36 EZ |
549 | #define CURR_FILE_ISYM (qFD[curr_fd].isym) |
550 | #define CURR_MODULE_ISYM (qMD[curr_md].isym) | |
551 | #define CURR_PROC_ISYM (qPD[curr_pd].isym) | |
c906108c | 552 | |
8af51c36 EZ |
553 | #define TELL_OBJFILE \ |
554 | do { \ | |
555 | if( !told_objfile ) { \ | |
556 | told_objfile = 1; \ | |
8a3fe4f8 | 557 | warning (_("\nIn object file \"%s\":"), \ |
8af51c36 EZ |
558 | objfile->name); \ |
559 | } \ | |
560 | } while (0) | |
561 | \f | |
c906108c | 562 | |
c906108c | 563 | |
8af51c36 EZ |
564 | /* Keeping track of the start/end symbol table (LNTT) indices of |
565 | psymtabs created so far */ | |
566 | ||
567 | typedef struct | |
c906108c | 568 | { |
8af51c36 EZ |
569 | int start; |
570 | int end; | |
c906108c | 571 | } |
8af51c36 | 572 | pst_syms_struct; |
c906108c | 573 | |
8af51c36 | 574 | static pst_syms_struct *pst_syms_array = 0; |
c906108c | 575 | |
504d5c7e JB |
576 | static int pst_syms_count = 0; |
577 | static int pst_syms_size = 0; | |
c906108c | 578 | |
8af51c36 | 579 | /* used by the TELL_OBJFILE macro */ |
504d5c7e | 580 | static int told_objfile = 0; |
8af51c36 EZ |
581 | |
582 | /* Set up psymtab symbol index stuff */ | |
583 | static void | |
584 | init_pst_syms (void) | |
c906108c | 585 | { |
8af51c36 EZ |
586 | pst_syms_count = 0; |
587 | pst_syms_size = 20; | |
588 | pst_syms_array = (pst_syms_struct *) xmalloc (20 * sizeof (pst_syms_struct)); | |
c906108c SS |
589 | } |
590 | ||
8af51c36 EZ |
591 | /* Clean up psymtab symbol index stuff */ |
592 | static void | |
593 | clear_pst_syms (void) | |
c906108c | 594 | { |
8af51c36 EZ |
595 | pst_syms_count = 0; |
596 | pst_syms_size = 0; | |
597 | xfree (pst_syms_array); | |
598 | pst_syms_array = 0; | |
c906108c SS |
599 | } |
600 | ||
8af51c36 EZ |
601 | /* Add information about latest psymtab to symbol index table */ |
602 | static void | |
603 | record_pst_syms (int start_sym, int end_sym) | |
c906108c | 604 | { |
8af51c36 EZ |
605 | if (++pst_syms_count > pst_syms_size) |
606 | { | |
607 | pst_syms_array = (pst_syms_struct *) xrealloc (pst_syms_array, | |
608 | 2 * pst_syms_size * sizeof (pst_syms_struct)); | |
609 | pst_syms_size *= 2; | |
610 | } | |
611 | pst_syms_array[pst_syms_count - 1].start = start_sym; | |
612 | pst_syms_array[pst_syms_count - 1].end = end_sym; | |
c906108c SS |
613 | } |
614 | ||
8af51c36 EZ |
615 | /* Find a suitable symbol table index which can serve as the upper |
616 | bound of a psymtab that starts at INDEX | |
c906108c | 617 | |
8af51c36 EZ |
618 | This scans backwards in the psymtab symbol index table to find a |
619 | "hole" in which the given index can fit. This is a heuristic!! | |
620 | We don't search the entire table to check for multiple holes, | |
621 | we don't care about overlaps, etc. | |
622 | ||
623 | Return 0 => not found */ | |
624 | static int | |
625 | find_next_pst_start (int index) | |
c906108c | 626 | { |
8af51c36 | 627 | int i; |
c906108c | 628 | |
8af51c36 EZ |
629 | for (i = pst_syms_count - 1; i >= 0; i--) |
630 | if (pst_syms_array[i].end <= index) | |
631 | return (i == pst_syms_count - 1) ? 0 : pst_syms_array[i + 1].start - 1; | |
c906108c | 632 | |
8af51c36 EZ |
633 | if (pst_syms_array[0].start > index) |
634 | return pst_syms_array[0].start - 1; | |
c906108c | 635 | |
8af51c36 | 636 | return 0; |
c906108c | 637 | } |
8af51c36 | 638 | \f |
c906108c | 639 | |
c906108c | 640 | |
8af51c36 | 641 | /* Utility functions to find the ending symbol index for a psymtab */ |
c906108c | 642 | |
8af51c36 EZ |
643 | /* Find the next file entry that begins beyond INDEX, and return |
644 | its starting symbol index - 1. | |
645 | QFD is the file table, CURR_FD is the file entry from where to start, | |
646 | PXDB_HEADER_P as in hpread_quick_traverse (to allow macros to work). | |
647 | ||
648 | Return 0 => not found */ | |
649 | static int | |
650 | find_next_file_isym (int index, quick_file_entry *qFD, int curr_fd, | |
651 | PXDB_header_ptr pxdb_header_p) | |
652 | { | |
653 | while (VALID_CURR_FILE) | |
654 | { | |
655 | if (CURR_FILE_ISYM >= index) | |
656 | return CURR_FILE_ISYM - 1; | |
657 | curr_fd++; | |
658 | } | |
659 | return 0; | |
c906108c SS |
660 | } |
661 | ||
8af51c36 EZ |
662 | /* Find the next procedure entry that begins beyond INDEX, and return |
663 | its starting symbol index - 1. | |
664 | QPD is the procedure table, CURR_PD is the proc entry from where to start, | |
665 | PXDB_HEADER_P as in hpread_quick_traverse (to allow macros to work). | |
c906108c | 666 | |
8af51c36 EZ |
667 | Return 0 => not found */ |
668 | static int | |
669 | find_next_proc_isym (int index, quick_procedure_entry *qPD, int curr_pd, | |
670 | PXDB_header_ptr pxdb_header_p) | |
c906108c | 671 | { |
8af51c36 EZ |
672 | while (VALID_CURR_PROC) |
673 | { | |
674 | if (CURR_PROC_ISYM >= index) | |
675 | return CURR_PROC_ISYM - 1; | |
676 | curr_pd++; | |
677 | } | |
678 | return 0; | |
c906108c SS |
679 | } |
680 | ||
8af51c36 EZ |
681 | /* Find the next module entry that begins beyond INDEX, and return |
682 | its starting symbol index - 1. | |
683 | QMD is the module table, CURR_MD is the modue entry from where to start, | |
684 | PXDB_HEADER_P as in hpread_quick_traverse (to allow macros to work). | |
c906108c | 685 | |
8af51c36 EZ |
686 | Return 0 => not found */ |
687 | static int | |
688 | find_next_module_isym (int index, quick_module_entry *qMD, int curr_md, | |
689 | PXDB_header_ptr pxdb_header_p) | |
690 | { | |
691 | while (VALID_CURR_MODULE) | |
c906108c | 692 | { |
8af51c36 EZ |
693 | if (CURR_MODULE_ISYM >= index) |
694 | return CURR_MODULE_ISYM - 1; | |
695 | curr_md++; | |
c906108c | 696 | } |
8af51c36 | 697 | return 0; |
c906108c | 698 | } |
c906108c | 699 | |
8af51c36 EZ |
700 | /* Scan and record partial symbols for all functions starting from index |
701 | pointed to by CURR_PD_P, and between code addresses START_ADR and END_ADR. | |
702 | Other parameters are explained in comments below. */ | |
703 | ||
704 | /* This used to be inline in hpread_quick_traverse, but now that we do | |
705 | essentially the same thing for two different cases (modules and | |
706 | module-less files), it's better organized in a separate routine, | |
707 | although it does take lots of arguments. pai/1997-10-08 | |
708 | ||
709 | CURR_PD_P is the pointer to the current proc index. QPD is the | |
710 | procedure quick lookup table. MAX_PROCS is the number of entries | |
711 | in the proc. table. START_ADR is the beginning of the code range | |
712 | for the current psymtab. end_adr is the end of the code range for | |
713 | the current psymtab. PST is the current psymtab. VT_bits is | |
714 | a pointer to the strings table of SOM debug space. OBJFILE is | |
715 | the current object file. */ | |
c906108c SS |
716 | |
717 | static int | |
8af51c36 EZ |
718 | scan_procs (int *curr_pd_p, quick_procedure_entry *qPD, int max_procs, |
719 | CORE_ADDR start_adr, CORE_ADDR end_adr, struct partial_symtab *pst, | |
720 | char *vt_bits, struct objfile *objfile) | |
c906108c | 721 | { |
8af51c36 EZ |
722 | union dnttentry *dn_bufp; |
723 | int symbol_count = 0; /* Total number of symbols in this psymtab */ | |
724 | int curr_pd = *curr_pd_p; /* Convenience variable -- avoid dereferencing pointer all the time */ | |
c906108c | 725 | |
8af51c36 EZ |
726 | #ifdef DUMPING |
727 | /* Turn this on for lots of debugging information in this routine */ | |
728 | static int dumping = 0; | |
729 | #endif | |
730 | ||
731 | #ifdef DUMPING | |
732 | if (dumping) | |
733 | { | |
734 | printf ("Scan_procs called, addresses %x to %x, proc %x\n", start_adr, end_adr, curr_pd); | |
c906108c | 735 | } |
8af51c36 | 736 | #endif |
c906108c | 737 | |
8af51c36 EZ |
738 | while ((CURR_PROC_START <= end_adr) && (curr_pd < max_procs)) |
739 | { | |
c906108c | 740 | |
8af51c36 EZ |
741 | char *rtn_name; /* mangled name */ |
742 | char *rtn_dem_name; /* qualified demangled name */ | |
743 | char *class_name; | |
744 | int class; | |
c906108c | 745 | |
8af51c36 EZ |
746 | if ((trans_lang ((enum hp_language) qPD[curr_pd].language) == language_cplus) && |
747 | vt_bits[(long) qPD[curr_pd].sbAlias]) /* not a null string */ | |
748 | { | |
749 | /* Get mangled name for the procedure, and demangle it */ | |
750 | rtn_name = &vt_bits[(long) qPD[curr_pd].sbAlias]; | |
751 | rtn_dem_name = cplus_demangle (rtn_name, DMGL_ANSI | DMGL_PARAMS); | |
752 | } | |
753 | else | |
754 | { | |
755 | rtn_name = &vt_bits[(long) qPD[curr_pd].sbProc]; | |
756 | rtn_dem_name = NULL; | |
757 | } | |
c906108c | 758 | |
8af51c36 EZ |
759 | /* Hack to get around HP C/C++ compilers' insistence on providing |
760 | "_MAIN_" as an alternate name for "main" */ | |
761 | if ((strcmp (rtn_name, "_MAIN_") == 0) && | |
762 | (strcmp (&vt_bits[(long) qPD[curr_pd].sbProc], "main") == 0)) | |
763 | rtn_dem_name = rtn_name = main_string; | |
c906108c | 764 | |
8af51c36 EZ |
765 | #ifdef DUMPING |
766 | if (dumping) | |
767 | { | |
768 | printf ("..add %s (demangled %s), index %x to this psymtab\n", rtn_name, rtn_dem_name, curr_pd); | |
769 | } | |
770 | #endif | |
771 | ||
772 | /* Check for module-spanning routines. */ | |
773 | if (CURR_PROC_END > end_adr) | |
774 | { | |
775 | TELL_OBJFILE; | |
8a3fe4f8 | 776 | warning (_("Procedure \"%s\" [0x%x] spans file or module boundaries."), rtn_name, curr_pd); |
8af51c36 EZ |
777 | } |
778 | ||
779 | /* Add this routine symbol to the list in the objfile. | |
780 | Unfortunately we have to go to the LNTT to determine the | |
781 | correct list to put it on. An alternative (which the | |
782 | code used to do) would be to not check and always throw | |
783 | it on the "static" list. But if we go that route, then | |
784 | symbol_lookup() needs to be tweaked a bit to account | |
785 | for the fact that the function might not be found on | |
786 | the correct list in the psymtab. - RT */ | |
787 | dn_bufp = hpread_get_lntt (qPD[curr_pd].isym, objfile); | |
788 | if (dn_bufp->dfunc.global) | |
789 | add_psymbol_with_dem_name_to_list (rtn_name, | |
790 | strlen (rtn_name), | |
791 | rtn_dem_name, | |
792 | strlen (rtn_dem_name), | |
176620f1 | 793 | VAR_DOMAIN, |
8af51c36 EZ |
794 | LOC_BLOCK, /* "I am a routine" */ |
795 | &objfile->global_psymbols, | |
796 | (qPD[curr_pd].adrStart + /* Starting address of rtn */ | |
797 | ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile))), | |
798 | 0, /* core addr?? */ | |
799 | trans_lang ((enum hp_language) qPD[curr_pd].language), | |
800 | objfile); | |
801 | else | |
802 | add_psymbol_with_dem_name_to_list (rtn_name, | |
803 | strlen (rtn_name), | |
804 | rtn_dem_name, | |
805 | strlen (rtn_dem_name), | |
176620f1 | 806 | VAR_DOMAIN, |
8af51c36 EZ |
807 | LOC_BLOCK, /* "I am a routine" */ |
808 | &objfile->static_psymbols, | |
809 | (qPD[curr_pd].adrStart + /* Starting address of rtn */ | |
810 | ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile))), | |
811 | 0, /* core addr?? */ | |
812 | trans_lang ((enum hp_language) qPD[curr_pd].language), | |
813 | objfile); | |
814 | ||
815 | symbol_count++; | |
816 | *curr_pd_p = ++curr_pd; /* bump up count & reflect in caller */ | |
817 | } /* loop over procedures */ | |
818 | ||
819 | #ifdef DUMPING | |
820 | if (dumping) | |
821 | { | |
822 | if (symbol_count == 0) | |
823 | printf ("Scan_procs: no symbols found!\n"); | |
824 | } | |
825 | #endif | |
826 | ||
827 | return symbol_count; | |
c906108c | 828 | } |
c906108c | 829 | |
c906108c | 830 | |
8af51c36 | 831 | /* Traverse the quick look-up tables, building a set of psymtabs. |
c906108c | 832 | |
8af51c36 EZ |
833 | This constructs a psymtab for modules and files in the quick lookup |
834 | tables. | |
c906108c | 835 | |
8af51c36 EZ |
836 | Mostly, modules correspond to compilation units, so we try to |
837 | create psymtabs that correspond to modules; however, in some cases | |
838 | a file can result in a compiled object which does not have a module | |
839 | entry for it, so in such cases we create a psymtab for the file. */ | |
c906108c | 840 | |
f5479e9c | 841 | static int |
8af51c36 EZ |
842 | hpread_quick_traverse (struct objfile *objfile, char *gntt_bits, |
843 | char *vt_bits, PXDB_header_ptr pxdb_header_p) | |
844 | { | |
845 | struct partial_symtab *pst; | |
c906108c | 846 | |
8af51c36 | 847 | char *addr; |
c906108c | 848 | |
8af51c36 EZ |
849 | quick_procedure_entry *qPD; |
850 | quick_file_entry *qFD; | |
851 | quick_module_entry *qMD; | |
852 | quick_class_entry *qCD; | |
c906108c | 853 | |
8af51c36 EZ |
854 | int idx; |
855 | int i; | |
856 | CORE_ADDR start_adr; /* current psymtab's starting code addr */ | |
857 | CORE_ADDR end_adr; /* current psymtab's ending code addr */ | |
858 | CORE_ADDR next_mod_adr; /* next module's starting code addr */ | |
859 | int curr_pd; /* current procedure */ | |
860 | int curr_fd; /* current file */ | |
861 | int curr_md; /* current module */ | |
862 | int start_sym; /* current psymtab's starting symbol index */ | |
863 | int end_sym; /* current psymtab's ending symbol index */ | |
864 | int max_LNTT_sym_index; | |
865 | int syms_in_pst; | |
866 | B_TYPE *class_entered; | |
867 | ||
868 | struct partial_symbol **global_syms; /* We'll be filling in the "global" */ | |
869 | struct partial_symbol **static_syms; /* and "static" tables in the objfile | |
870 | as we go, so we need a pair of | |
871 | current pointers. */ | |
872 | ||
873 | #ifdef DUMPING | |
874 | /* Turn this on for lots of debugging information in this routine. | |
875 | You get a blow-by-blow account of quick lookup table reading */ | |
876 | static int dumping = 0; | |
877 | #endif | |
c906108c | 878 | |
8af51c36 | 879 | pst = (struct partial_symtab *) 0; |
c906108c | 880 | |
8af51c36 EZ |
881 | /* Clear out some globals */ |
882 | init_pst_syms (); | |
883 | told_objfile = 0; | |
c906108c | 884 | |
8af51c36 EZ |
885 | /* Demangling style -- if EDG style already set, don't change it, |
886 | as HP style causes some problems with the KAI EDG compiler */ | |
887 | if (current_demangling_style != edg_demangling) | |
888 | { | |
889 | /* Otherwise, ensure that we are using HP style demangling */ | |
890 | set_demangling_style (HP_DEMANGLING_STYLE_STRING); | |
c906108c SS |
891 | } |
892 | ||
8af51c36 EZ |
893 | /* First we need to find the starting points of the quick |
894 | look-up tables in the GNTT. */ | |
c906108c | 895 | |
8af51c36 | 896 | addr = gntt_bits; |
c906108c | 897 | |
8af51c36 EZ |
898 | qPD = (quick_procedure_entry_ptr) addr; |
899 | addr += pxdb_header_p->pd_entries * sizeof (quick_procedure_entry); | |
900 | ||
901 | #ifdef DUMPING | |
902 | if (dumping) | |
c906108c | 903 | { |
8af51c36 EZ |
904 | printf ("\n Printing routines as we see them\n"); |
905 | for (i = 0; VALID_PROC (i); i++) | |
906 | { | |
907 | idx = (long) qPD[i].sbProc; | |
908 | printf ("%s %x..%x\n", &vt_bits[idx], | |
909 | (int) PROC_START (i), | |
910 | (int) PROC_END (i)); | |
911 | } | |
912 | } | |
913 | #endif | |
c906108c | 914 | |
8af51c36 EZ |
915 | qFD = (quick_file_entry_ptr) addr; |
916 | addr += pxdb_header_p->fd_entries * sizeof (quick_file_entry); | |
c906108c | 917 | |
8af51c36 EZ |
918 | #ifdef DUMPING |
919 | if (dumping) | |
920 | { | |
921 | printf ("\n Printing files as we see them\n"); | |
922 | for (i = 0; VALID_FILE (i); i++) | |
923 | { | |
924 | idx = (long) qFD[i].sbFile; | |
925 | printf ("%s %x..%x\n", &vt_bits[idx], | |
926 | (int) FILE_START (i), | |
927 | (int) FILE_END (i)); | |
928 | } | |
c906108c | 929 | } |
8af51c36 | 930 | #endif |
c906108c | 931 | |
8af51c36 EZ |
932 | qMD = (quick_module_entry_ptr) addr; |
933 | addr += pxdb_header_p->md_entries * sizeof (quick_module_entry); | |
c906108c | 934 | |
8af51c36 EZ |
935 | #ifdef DUMPING |
936 | if (dumping) | |
c906108c | 937 | { |
8af51c36 EZ |
938 | printf ("\n Printing modules as we see them\n"); |
939 | for (i = 0; i < pxdb_header_p->md_entries; i++) | |
940 | { | |
941 | idx = (long) qMD[i].sbMod; | |
942 | printf ("%s\n", &vt_bits[idx]); | |
943 | } | |
c906108c | 944 | } |
8af51c36 | 945 | #endif |
c906108c | 946 | |
8af51c36 EZ |
947 | qCD = (quick_class_entry_ptr) addr; |
948 | addr += pxdb_header_p->cd_entries * sizeof (quick_class_entry); | |
c906108c | 949 | |
8af51c36 EZ |
950 | #ifdef DUMPING |
951 | if (dumping) | |
c906108c | 952 | { |
8af51c36 EZ |
953 | printf ("\n Printing classes as we see them\n"); |
954 | for (i = 0; VALID_CLASS (i); i++) | |
955 | { | |
956 | idx = (long) qCD[i].sbClass; | |
957 | printf ("%s\n", &vt_bits[idx]); | |
958 | } | |
c906108c | 959 | |
8af51c36 | 960 | printf ("\n Done with dump, on to build!\n"); |
c906108c | 961 | } |
8af51c36 | 962 | #endif |
c906108c | 963 | |
8af51c36 EZ |
964 | /* We need this index only while hp-symtab-read.c expects |
965 | a byte offset to the end of the LNTT entries for a given | |
966 | psymtab. Thus the need for it should go away someday. | |
967 | ||
968 | When it goes away, then we won't have any need to load the | |
969 | LNTT from the objfile at psymtab-time, and start-up will be | |
970 | faster. To make that work, we'll need some way to create | |
971 | a null pst for the "globals" pseudo-module. */ | |
972 | max_LNTT_sym_index = LNTT_SYMCOUNT (objfile); | |
973 | ||
974 | /* Scan the module descriptors and make a psymtab for each. | |
975 | ||
976 | We know the MDs, FDs and the PDs are in order by starting | |
977 | address. We use that fact to traverse all three arrays in | |
978 | parallel, knowing when the next PD is in a new file | |
979 | and we need to create a new psymtab. */ | |
980 | curr_pd = 0; /* Current procedure entry */ | |
981 | curr_fd = 0; /* Current file entry */ | |
982 | curr_md = 0; /* Current module entry */ | |
983 | ||
984 | start_adr = 0; /* Current psymtab code range */ | |
985 | end_adr = 0; | |
986 | ||
987 | start_sym = 0; /* Current psymtab symbol range */ | |
988 | end_sym = 0; | |
989 | ||
990 | syms_in_pst = 0; /* Symbol count for psymtab */ | |
991 | ||
992 | /* Psts actually just have pointers into the objfile's | |
993 | symbol table, not their own symbol tables. */ | |
994 | global_syms = objfile->global_psymbols.list; | |
995 | static_syms = objfile->static_psymbols.list; | |
996 | ||
997 | ||
998 | /* First skip over pseudo-entries with address 0. These represent inlined | |
999 | routines and abstract (uninstantiated) template routines. | |
1000 | FIXME: These should be read in and available -- even if we can't set | |
1001 | breakpoints, etc., there's some information that can be presented | |
1002 | to the user. pai/1997-10-08 */ | |
1003 | ||
1004 | while (VALID_CURR_PROC && (CURR_PROC_START == 0)) | |
1005 | curr_pd++; | |
1006 | ||
1007 | /* Loop over files, modules, and procedures in code address order. Each | |
1008 | time we enter an iteration of this loop, curr_pd points to the first | |
1009 | unprocessed procedure, curr_fd points to the first unprocessed file, and | |
1010 | curr_md to the first unprocessed module. Each iteration of this loop | |
1011 | updates these as required -- any or all of them may be bumpd up | |
1012 | each time around. When we exit this loop, we are done with all files | |
1013 | and modules in the tables -- there may still be some procedures, however. | |
1014 | ||
1015 | Note: This code used to loop only over module entries, under the assumption | |
1016 | that files can occur via inclusions and are thus unreliable, while a | |
1017 | compiled object always corresponds to a module. With CTTI in the HP aCC | |
1018 | compiler, it turns out that compiled objects may have only files and no | |
1019 | modules; so we have to loop over files and modules, creating psymtabs for | |
1020 | either as appropriate. Unfortunately there are some problems (notably: | |
1021 | 1. the lack of "SRC_FILE_END" entries in the LNTT, 2. the lack of pointers | |
1022 | to the ending symbol indices of a module or a file) which make it quite hard | |
1023 | to do this correctly. Currently it uses a bunch of heuristics to start and | |
1024 | end psymtabs; they seem to work well with most objects generated by aCC, but | |
1025 | who knows when that will change... */ | |
1026 | ||
1027 | while (VALID_CURR_FILE || VALID_CURR_MODULE) | |
1028 | { | |
c906108c | 1029 | |
65e82032 | 1030 | char *mod_name_string = NULL; |
8af51c36 | 1031 | char *full_name_string; |
c906108c | 1032 | |
8af51c36 EZ |
1033 | /* First check for modules like "version.c", which have no code |
1034 | in them but still have qMD entries. They also have no qFD or | |
1035 | qPD entries. Their start address is -1 and their end address | |
1036 | is 0. */ | |
1037 | if (VALID_CURR_MODULE && (CURR_MODULE_START == -1) && (CURR_MODULE_END == 0)) | |
1038 | { | |
c906108c | 1039 | |
8af51c36 | 1040 | mod_name_string = &vt_bits[(long) qMD[curr_md].sbMod]; |
c906108c | 1041 | |
8af51c36 EZ |
1042 | #ifdef DUMPING |
1043 | if (dumping) | |
1044 | printf ("Module with data only %s\n", mod_name_string); | |
1045 | #endif | |
1046 | ||
1047 | /* We'll skip the rest (it makes error-checking easier), and | |
1048 | just make an empty pst. Right now empty psts are not put | |
1049 | in the pst chain, so all this is for naught, but later it | |
1050 | might help. */ | |
1051 | ||
1052 | pst = hpread_start_psymtab (objfile, | |
1053 | mod_name_string, | |
1054 | CURR_MODULE_START, /* Low text address: bogus! */ | |
1055 | (CURR_MODULE_ISYM * sizeof (struct dntt_type_block)), | |
1056 | /* ldsymoff */ | |
1057 | global_syms, | |
1058 | static_syms); | |
1059 | ||
1060 | pst = hpread_end_psymtab (pst, | |
1061 | NULL, /* psymtab_include_list */ | |
1062 | 0, /* includes_used */ | |
1063 | end_sym * sizeof (struct dntt_type_block), | |
1064 | /* byte index in LNTT of end | |
1065 | = capping symbol offset | |
1066 | = LDSYMOFF of nextfile */ | |
1067 | 0, /* text high */ | |
1068 | NULL, /* dependency_list */ | |
1069 | 0); /* dependencies_used */ | |
1070 | ||
1071 | global_syms = objfile->global_psymbols.next; | |
1072 | static_syms = objfile->static_psymbols.next; | |
1073 | ||
1074 | curr_md++; | |
1075 | } | |
1076 | else if (VALID_CURR_MODULE && | |
1077 | ((CURR_MODULE_START == 0) || (CURR_MODULE_START == -1) || | |
1078 | (CURR_MODULE_END == 0) || (CURR_MODULE_END == -1))) | |
c906108c | 1079 | { |
8af51c36 | 1080 | TELL_OBJFILE; |
8a3fe4f8 | 1081 | warning (_("Module \"%s\" [0x%s] has non-standard addresses. It starts at 0x%s, ends at 0x%s, and will be skipped."), |
8af51c36 EZ |
1082 | mod_name_string, paddr_nz (curr_md), paddr_nz (start_adr), paddr_nz (end_adr)); |
1083 | /* On to next module */ | |
1084 | curr_md++; | |
c906108c | 1085 | } |
8af51c36 EZ |
1086 | else |
1087 | { | |
1088 | /* First check if we are looking at a file with code in it | |
1089 | that does not overlap the current module's code range */ | |
c906108c | 1090 | |
8af51c36 EZ |
1091 | if (VALID_CURR_FILE ? (VALID_CURR_MODULE ? (CURR_FILE_END < CURR_MODULE_START) : 1) : 0) |
1092 | { | |
c906108c | 1093 | |
8af51c36 EZ |
1094 | /* Looking at file not corresponding to any module, |
1095 | create a psymtab for it */ | |
1096 | full_name_string = &vt_bits[(long) qFD[curr_fd].sbFile]; | |
1097 | start_adr = CURR_FILE_START; | |
1098 | end_adr = CURR_FILE_END; | |
1099 | start_sym = CURR_FILE_ISYM; | |
c906108c | 1100 | |
8af51c36 EZ |
1101 | /* Check if there are any procedures not handled until now, that |
1102 | begin before the start address of this file, and if so, adjust | |
1103 | this module's start address to include them. This handles routines that | |
1104 | are in between file or module ranges for some reason (probably | |
1105 | indicates a compiler bug */ | |
c906108c | 1106 | |
8af51c36 EZ |
1107 | if (CURR_PROC_START < start_adr) |
1108 | { | |
1109 | TELL_OBJFILE; | |
8a3fe4f8 | 1110 | warning (_("Found procedure \"%s\" [0x%x] that is not in any file or module."), |
8af51c36 EZ |
1111 | &vt_bits[(long) qPD[curr_pd].sbProc], curr_pd); |
1112 | start_adr = CURR_PROC_START; | |
1113 | if (CURR_PROC_ISYM < start_sym) | |
1114 | start_sym = CURR_PROC_ISYM; | |
1115 | } | |
c906108c | 1116 | |
8af51c36 EZ |
1117 | /* Sometimes (compiler bug -- COBOL) the module end address is higher |
1118 | than the start address of the next module, so check for that and | |
1119 | adjust accordingly */ | |
c906108c | 1120 | |
8af51c36 EZ |
1121 | if (VALID_FILE (curr_fd + 1) && (FILE_START (curr_fd + 1) <= end_adr)) |
1122 | { | |
1123 | TELL_OBJFILE; | |
8a3fe4f8 | 1124 | warning (_("File \"%s\" [0x%x] has ending address after starting address of next file; adjusting ending address down."), |
8af51c36 EZ |
1125 | full_name_string, curr_fd); |
1126 | end_adr = FILE_START (curr_fd + 1) - 1; /* Is -4 (or -8 for 64-bit) better? */ | |
1127 | } | |
1128 | if (VALID_MODULE (curr_md) && (CURR_MODULE_START <= end_adr)) | |
1129 | { | |
1130 | TELL_OBJFILE; | |
8a3fe4f8 | 1131 | warning (_("File \"%s\" [0x%x] has ending address after starting address of next module; adjusting ending address down."), |
8af51c36 EZ |
1132 | full_name_string, curr_fd); |
1133 | end_adr = CURR_MODULE_START - 1; /* Is -4 (or -8 for 64-bit) better? */ | |
1134 | } | |
c906108c | 1135 | |
c906108c | 1136 | |
8af51c36 EZ |
1137 | #ifdef DUMPING |
1138 | if (dumping) | |
1139 | { | |
1140 | printf ("Make new psymtab for file %s (%x to %x).\n", | |
1141 | full_name_string, start_adr, end_adr); | |
1142 | } | |
1143 | #endif | |
1144 | /* Create the basic psymtab, connecting it in the list | |
1145 | for this objfile and pointing its symbol entries | |
1146 | to the current end of the symbol areas in the objfile. | |
1147 | ||
1148 | The "ldsymoff" parameter is the byte offset in the LNTT | |
1149 | of the first symbol in this file. Some day we should | |
1150 | turn this into an index (fix in hp-symtab-read.c as well). | |
1151 | And it's not even the right byte offset, as we're using | |
1152 | the size of a union! FIXME! */ | |
1153 | pst = hpread_start_psymtab (objfile, | |
1154 | full_name_string, | |
1155 | start_adr, /* Low text address */ | |
1156 | (start_sym * sizeof (struct dntt_type_block)), | |
1157 | /* ldsymoff */ | |
1158 | global_syms, | |
1159 | static_syms); | |
1160 | ||
1161 | /* Set up to only enter each class referenced in this module once. */ | |
1162 | class_entered = xmalloc (B_BYTES (pxdb_header_p->cd_entries)); | |
1163 | B_CLRALL (class_entered, pxdb_header_p->cd_entries); | |
1164 | ||
1165 | /* Scan the procedure descriptors for procedures in the current | |
1166 | file, based on the starting addresses. */ | |
1167 | ||
1168 | syms_in_pst = scan_procs (&curr_pd, qPD, pxdb_header_p->pd_entries, | |
1169 | start_adr, end_adr, pst, vt_bits, objfile); | |
1170 | ||
1171 | /* Get ending symbol offset */ | |
1172 | ||
1173 | end_sym = 0; | |
1174 | /* First check for starting index before previous psymtab */ | |
1175 | if (pst_syms_count && start_sym < pst_syms_array[pst_syms_count - 1].end) | |
1176 | { | |
1177 | end_sym = find_next_pst_start (start_sym); | |
1178 | } | |
1179 | /* Look for next start index of a file or module, or procedure */ | |
1180 | if (!end_sym) | |
1181 | { | |
1182 | int next_file_isym = find_next_file_isym (start_sym, qFD, curr_fd + 1, pxdb_header_p); | |
1183 | int next_module_isym = find_next_module_isym (start_sym, qMD, curr_md, pxdb_header_p); | |
1184 | int next_proc_isym = find_next_proc_isym (start_sym, qPD, curr_pd, pxdb_header_p); | |
1185 | ||
1186 | if (next_file_isym && next_module_isym) | |
1187 | { | |
1188 | /* pick lower of next file or module start index */ | |
1189 | end_sym = min (next_file_isym, next_module_isym); | |
1190 | } | |
1191 | else | |
1192 | { | |
1193 | /* one of them is zero, pick the other */ | |
1194 | end_sym = max (next_file_isym, next_module_isym); | |
1195 | } | |
1196 | ||
1197 | /* As a precaution, check next procedure index too */ | |
1198 | if (!end_sym) | |
1199 | end_sym = next_proc_isym; | |
1200 | else | |
1201 | end_sym = min (end_sym, next_proc_isym); | |
1202 | } | |
c906108c | 1203 | |
8af51c36 EZ |
1204 | /* Couldn't find procedure, file, or module, use globals as default */ |
1205 | if (!end_sym) | |
1206 | end_sym = pxdb_header_p->globals; | |
c906108c | 1207 | |
8af51c36 EZ |
1208 | #ifdef DUMPING |
1209 | if (dumping) | |
1210 | { | |
1211 | printf ("File psymtab indices: %x to %x\n", start_sym, end_sym); | |
1212 | } | |
1213 | #endif | |
c906108c | 1214 | |
8af51c36 EZ |
1215 | pst = hpread_end_psymtab (pst, |
1216 | NULL, /* psymtab_include_list */ | |
1217 | 0, /* includes_used */ | |
1218 | end_sym * sizeof (struct dntt_type_block), | |
1219 | /* byte index in LNTT of end | |
1220 | = capping symbol offset | |
1221 | = LDSYMOFF of nextfile */ | |
1222 | end_adr, /* text high */ | |
1223 | NULL, /* dependency_list */ | |
1224 | 0); /* dependencies_used */ | |
c906108c | 1225 | |
8af51c36 | 1226 | record_pst_syms (start_sym, end_sym); |
c906108c | 1227 | |
8af51c36 | 1228 | if (NULL == pst) |
8a3fe4f8 | 1229 | warning (_("No symbols in psymtab for file \"%s\" [0x%x]."), full_name_string, curr_fd); |
c906108c | 1230 | |
8af51c36 EZ |
1231 | #ifdef DUMPING |
1232 | if (dumping) | |
1233 | { | |
1234 | printf ("Made new psymtab for file %s (%x to %x), sym %x to %x.\n", | |
1235 | full_name_string, start_adr, end_adr, CURR_FILE_ISYM, end_sym); | |
1236 | } | |
1237 | #endif | |
1238 | /* Prepare for the next psymtab. */ | |
1239 | global_syms = objfile->global_psymbols.next; | |
1240 | static_syms = objfile->static_psymbols.next; | |
1241 | xfree (class_entered); | |
c906108c | 1242 | |
8af51c36 EZ |
1243 | curr_fd++; |
1244 | } /* Psymtab for file */ | |
1245 | else | |
1246 | { | |
1247 | /* We have a module for which we create a psymtab */ | |
c906108c | 1248 | |
8af51c36 | 1249 | mod_name_string = &vt_bits[(long) qMD[curr_md].sbMod]; |
c906108c | 1250 | |
8af51c36 EZ |
1251 | /* We will include the code ranges of any files that happen to |
1252 | overlap with this module */ | |
c906108c | 1253 | |
8af51c36 EZ |
1254 | /* So, first pick the lower of the file's and module's start addresses */ |
1255 | start_adr = CURR_MODULE_START; | |
1256 | if (VALID_CURR_FILE) | |
1257 | { | |
1258 | if (CURR_FILE_START < CURR_MODULE_START) | |
1259 | { | |
1260 | TELL_OBJFILE; | |
8a3fe4f8 | 1261 | warning (_("File \"%s\" [0x%x] crosses beginning of module \"%s\"."), |
8af51c36 EZ |
1262 | &vt_bits[(long) qFD[curr_fd].sbFile], |
1263 | curr_fd, mod_name_string); | |
1264 | ||
1265 | start_adr = CURR_FILE_START; | |
1266 | } | |
1267 | } | |
c906108c | 1268 | |
8af51c36 EZ |
1269 | /* Also pick the lower of the file's and the module's start symbol indices */ |
1270 | start_sym = CURR_MODULE_ISYM; | |
1271 | if (VALID_CURR_FILE && (CURR_FILE_ISYM < CURR_MODULE_ISYM)) | |
1272 | start_sym = CURR_FILE_ISYM; | |
c906108c | 1273 | |
8af51c36 EZ |
1274 | /* For the end address, we scan through the files till we find one |
1275 | that overlaps the current module but ends beyond it; if no such file exists we | |
1276 | simply use the module's start address. | |
1277 | (Note, if file entries themselves overlap | |
1278 | we take the longest overlapping extension beyond the end of the module...) | |
1279 | We assume that modules never overlap. */ | |
c906108c | 1280 | |
8af51c36 | 1281 | end_adr = CURR_MODULE_END; |
c906108c | 1282 | |
8af51c36 EZ |
1283 | if (VALID_CURR_FILE) |
1284 | { | |
1285 | while (VALID_CURR_FILE && (CURR_FILE_START < end_adr)) | |
1286 | { | |
c906108c | 1287 | |
8af51c36 EZ |
1288 | #ifdef DUMPING |
1289 | if (dumping) | |
1290 | printf ("Maybe skipping file %s which overlaps with module %s\n", | |
1291 | &vt_bits[(long) qFD[curr_fd].sbFile], mod_name_string); | |
1292 | #endif | |
1293 | if (CURR_FILE_END > end_adr) | |
1294 | { | |
1295 | TELL_OBJFILE; | |
8a3fe4f8 | 1296 | warning (_("File \"%s\" [0x%x] crosses end of module \"%s\"."), |
8af51c36 EZ |
1297 | &vt_bits[(long) qFD[curr_fd].sbFile], |
1298 | curr_fd, mod_name_string); | |
1299 | end_adr = CURR_FILE_END; | |
1300 | } | |
1301 | curr_fd++; | |
1302 | } | |
1303 | curr_fd--; /* back up after going too far */ | |
1304 | } | |
1305 | ||
1306 | /* Sometimes (compiler bug -- COBOL) the module end address is higher | |
1307 | than the start address of the next module, so check for that and | |
1308 | adjust accordingly */ | |
1309 | ||
1310 | if (VALID_MODULE (curr_md + 1) && (MODULE_START (curr_md + 1) <= end_adr)) | |
1311 | { | |
1312 | TELL_OBJFILE; | |
8a3fe4f8 | 1313 | warning (_("Module \"%s\" [0x%x] has ending address after starting address of next module; adjusting ending address down."), |
8af51c36 EZ |
1314 | mod_name_string, curr_md); |
1315 | end_adr = MODULE_START (curr_md + 1) - 1; /* Is -4 (or -8 for 64-bit) better? */ | |
1316 | } | |
1317 | if (VALID_FILE (curr_fd + 1) && (FILE_START (curr_fd + 1) <= end_adr)) | |
1318 | { | |
1319 | TELL_OBJFILE; | |
8a3fe4f8 | 1320 | warning (_("Module \"%s\" [0x%x] has ending address after starting address of next file; adjusting ending address down."), |
8af51c36 EZ |
1321 | mod_name_string, curr_md); |
1322 | end_adr = FILE_START (curr_fd + 1) - 1; /* Is -4 (or -8 for 64-bit) better? */ | |
1323 | } | |
1324 | ||
1325 | /* Use one file to get the full name for the module. This | |
1326 | situation can arise if there is executable code in a #include | |
1327 | file. Each file with code in it gets a qFD. Files which don't | |
1328 | contribute code don't get a qFD, even if they include files | |
1329 | which do, e.g.: | |
1330 | ||
1331 | body.c: rtn.h: | |
1332 | int x; int main() { | |
1333 | #include "rtn.h" return x; | |
1334 | } | |
1335 | ||
1336 | There will a qFD for "rtn.h",and a qMD for "body.c", | |
1337 | but no qMD for "rtn.h" or qFD for "body.c"! | |
1338 | ||
1339 | We pick the name of the last file to overlap with this | |
1340 | module. C convention is to put include files first. In a | |
1341 | perfect world, we could check names and use the file whose full | |
1342 | path name ends with the module name. */ | |
1343 | ||
1344 | if (VALID_CURR_FILE) | |
1345 | full_name_string = &vt_bits[(long) qFD[curr_fd].sbFile]; | |
1346 | else | |
1347 | full_name_string = mod_name_string; | |
1348 | ||
1349 | /* Check if there are any procedures not handled until now, that | |
1350 | begin before the start address we have now, and if so, adjust | |
1351 | this psymtab's start address to include them. This handles routines that | |
1352 | are in between file or module ranges for some reason (probably | |
1353 | indicates a compiler bug */ | |
1354 | ||
1355 | if (CURR_PROC_START < start_adr) | |
1356 | { | |
1357 | TELL_OBJFILE; | |
8a3fe4f8 | 1358 | warning (_("Found procedure \"%s\" [0x%x] that is not in any file or module."), |
8af51c36 EZ |
1359 | &vt_bits[(long) qPD[curr_pd].sbProc], curr_pd); |
1360 | start_adr = CURR_PROC_START; | |
1361 | if (CURR_PROC_ISYM < start_sym) | |
1362 | start_sym = CURR_PROC_ISYM; | |
1363 | } | |
1364 | ||
1365 | #ifdef DUMPING | |
1366 | if (dumping) | |
1367 | { | |
1368 | printf ("Make new psymtab for module %s (%x to %x), using file %s\n", | |
1369 | mod_name_string, start_adr, end_adr, full_name_string); | |
1370 | } | |
1371 | #endif | |
1372 | /* Create the basic psymtab, connecting it in the list | |
1373 | for this objfile and pointing its symbol entries | |
1374 | to the current end of the symbol areas in the objfile. | |
1375 | ||
1376 | The "ldsymoff" parameter is the byte offset in the LNTT | |
1377 | of the first symbol in this file. Some day we should | |
1378 | turn this into an index (fix in hp-symtab-read.c as well). | |
1379 | And it's not even the right byte offset, as we're using | |
1380 | the size of a union! FIXME! */ | |
1381 | pst = hpread_start_psymtab (objfile, | |
1382 | full_name_string, | |
1383 | start_adr, /* Low text address */ | |
1384 | (start_sym * sizeof (struct dntt_type_block)), | |
1385 | /* ldsymoff */ | |
1386 | global_syms, | |
1387 | static_syms); | |
1388 | ||
1389 | /* Set up to only enter each class referenced in this module once. */ | |
1390 | class_entered = xmalloc (B_BYTES (pxdb_header_p->cd_entries)); | |
1391 | B_CLRALL (class_entered, pxdb_header_p->cd_entries); | |
1392 | ||
1393 | /* Scan the procedure descriptors for procedures in the current | |
1394 | module, based on the starting addresses. */ | |
1395 | ||
1396 | syms_in_pst = scan_procs (&curr_pd, qPD, pxdb_header_p->pd_entries, | |
1397 | start_adr, end_adr, pst, vt_bits, objfile); | |
1398 | ||
1399 | /* Get ending symbol offset */ | |
1400 | ||
1401 | end_sym = 0; | |
1402 | /* First check for starting index before previous psymtab */ | |
1403 | if (pst_syms_count && start_sym < pst_syms_array[pst_syms_count - 1].end) | |
1404 | { | |
1405 | end_sym = find_next_pst_start (start_sym); | |
1406 | } | |
1407 | /* Look for next start index of a file or module, or procedure */ | |
1408 | if (!end_sym) | |
1409 | { | |
1410 | int next_file_isym = find_next_file_isym (start_sym, qFD, curr_fd + 1, pxdb_header_p); | |
1411 | int next_module_isym = find_next_module_isym (start_sym, qMD, curr_md + 1, pxdb_header_p); | |
1412 | int next_proc_isym = find_next_proc_isym (start_sym, qPD, curr_pd, pxdb_header_p); | |
1413 | ||
1414 | if (next_file_isym && next_module_isym) | |
1415 | { | |
1416 | /* pick lower of next file or module start index */ | |
1417 | end_sym = min (next_file_isym, next_module_isym); | |
1418 | } | |
1419 | else | |
1420 | { | |
1421 | /* one of them is zero, pick the other */ | |
1422 | end_sym = max (next_file_isym, next_module_isym); | |
1423 | } | |
1424 | ||
1425 | /* As a precaution, check next procedure index too */ | |
1426 | if (!end_sym) | |
1427 | end_sym = next_proc_isym; | |
1428 | else | |
1429 | end_sym = min (end_sym, next_proc_isym); | |
1430 | } | |
1431 | ||
1432 | /* Couldn't find procedure, file, or module, use globals as default */ | |
1433 | if (!end_sym) | |
1434 | end_sym = pxdb_header_p->globals; | |
1435 | ||
1436 | #ifdef DUMPING | |
1437 | if (dumping) | |
1438 | { | |
1439 | printf ("Module psymtab indices: %x to %x\n", start_sym, end_sym); | |
1440 | } | |
1441 | #endif | |
1442 | ||
1443 | pst = hpread_end_psymtab (pst, | |
1444 | NULL, /* psymtab_include_list */ | |
1445 | 0, /* includes_used */ | |
1446 | end_sym * sizeof (struct dntt_type_block), | |
1447 | /* byte index in LNTT of end | |
1448 | = capping symbol offset | |
1449 | = LDSYMOFF of nextfile */ | |
1450 | end_adr, /* text high */ | |
1451 | NULL, /* dependency_list */ | |
1452 | 0); /* dependencies_used */ | |
1453 | ||
1454 | record_pst_syms (start_sym, end_sym); | |
1455 | ||
1456 | if (NULL == pst) | |
8a3fe4f8 | 1457 | warning (_("No symbols in psymtab for module \"%s\" [0x%x]."), mod_name_string, curr_md); |
8af51c36 EZ |
1458 | |
1459 | #ifdef DUMPING | |
1460 | if (dumping) | |
1461 | { | |
1462 | printf ("Made new psymtab for module %s (%x to %x), sym %x to %x.\n", | |
1463 | mod_name_string, start_adr, end_adr, CURR_MODULE_ISYM, end_sym); | |
1464 | } | |
1465 | #endif | |
1466 | ||
1467 | /* Prepare for the next psymtab. */ | |
1468 | global_syms = objfile->global_psymbols.next; | |
1469 | static_syms = objfile->static_psymbols.next; | |
1470 | xfree (class_entered); | |
1471 | ||
1472 | curr_md++; | |
1473 | curr_fd++; | |
1474 | } /* psymtab for module */ | |
1475 | } /* psymtab for non-bogus file or module */ | |
1476 | } /* End of while loop over all files & modules */ | |
1477 | ||
1478 | /* There may be some routines after all files and modules -- these will get | |
1479 | inserted in a separate new module of their own */ | |
1480 | if (VALID_CURR_PROC) | |
c906108c | 1481 | { |
8af51c36 EZ |
1482 | start_adr = CURR_PROC_START; |
1483 | end_adr = qPD[pxdb_header_p->pd_entries - 1].adrEnd; | |
1484 | TELL_OBJFILE; | |
8a3fe4f8 | 1485 | warning (_("Found functions beyond end of all files and modules [0x%x]."), curr_pd); |
8af51c36 EZ |
1486 | #ifdef DUMPING |
1487 | if (dumping) | |
c906108c | 1488 | { |
8af51c36 EZ |
1489 | printf ("Orphan functions at end, PD %d and beyond (%x to %x)\n", |
1490 | curr_pd, start_adr, end_adr); | |
c906108c | 1491 | } |
8af51c36 EZ |
1492 | #endif |
1493 | pst = hpread_start_psymtab (objfile, | |
1494 | "orphans", | |
1495 | start_adr, /* Low text address */ | |
1496 | (CURR_PROC_ISYM * sizeof (struct dntt_type_block)), | |
1497 | /* ldsymoff */ | |
1498 | global_syms, | |
1499 | static_syms); | |
1500 | ||
1501 | scan_procs (&curr_pd, qPD, pxdb_header_p->pd_entries, | |
1502 | start_adr, end_adr, pst, vt_bits, objfile); | |
1503 | ||
1504 | pst = hpread_end_psymtab (pst, | |
1505 | NULL, /* psymtab_include_list */ | |
1506 | 0, /* includes_used */ | |
1507 | pxdb_header_p->globals * sizeof (struct dntt_type_block), | |
1508 | /* byte index in LNTT of end | |
1509 | = capping symbol offset | |
1510 | = LDSYMOFF of nextfile */ | |
1511 | end_adr, /* text high */ | |
1512 | NULL, /* dependency_list */ | |
1513 | 0); /* dependencies_used */ | |
c906108c | 1514 | } |
c906108c | 1515 | |
c906108c | 1516 | |
8af51c36 EZ |
1517 | #ifdef NEVER_NEVER |
1518 | /* Now build psts for non-module things (in the tail of | |
1519 | the LNTT, after the last END MODULE entry). | |
1520 | ||
1521 | If null psts were kept on the chain, this would be | |
1522 | a solution. FIXME */ | |
1523 | pst = hpread_start_psymtab (objfile, | |
1524 | "globals", | |
1525 | 0, | |
1526 | (pxdb_header_p->globals | |
1527 | * sizeof (struct dntt_type_block)), | |
1528 | objfile->global_psymbols.next, | |
1529 | objfile->static_psymbols.next); | |
1530 | hpread_end_psymtab (pst, | |
1531 | NULL, 0, | |
1532 | (max_LNTT_sym_index * sizeof (struct dntt_type_block)), | |
1533 | 0, | |
1534 | NULL, 0); | |
1535 | #endif | |
c906108c | 1536 | |
8af51c36 | 1537 | clear_pst_syms (); |
c906108c | 1538 | |
8af51c36 | 1539 | return 1; |
c906108c | 1540 | |
8af51c36 EZ |
1541 | } /* End of hpread_quick_traverse. */ |
1542 | \f | |
c906108c | 1543 | |
8af51c36 EZ |
1544 | /* Get appropriate header, based on pxdb type. |
1545 | Return value: 1 if ok, 0 if not */ | |
f5479e9c | 1546 | static int |
8af51c36 | 1547 | hpread_get_header (struct objfile *objfile, PXDB_header_ptr pxdb_header_p) |
c906108c | 1548 | { |
8af51c36 | 1549 | asection *pinfo_section, *debug_section, *header_section; |
c906108c | 1550 | |
8af51c36 EZ |
1551 | #ifdef DUMPING |
1552 | /* Turn on for debugging information */ | |
1553 | static int dumping = 0; | |
1554 | #endif | |
c906108c | 1555 | |
8af51c36 EZ |
1556 | header_section = bfd_get_section_by_name (objfile->obfd, "$HEADER$"); |
1557 | if (!header_section) | |
1558 | { | |
1559 | /* We don't have either PINFO or DEBUG sections. But | |
1560 | stuff like "libc.sl" has no debug info. There's no | |
1561 | need to warn the user of this, as it may be ok. The | |
1562 | caller will figure it out and issue any needed | |
1563 | messages. */ | |
1564 | #ifdef DUMPING | |
1565 | if (dumping) | |
1566 | printf ("==No debug info at all for %s.\n", objfile->name); | |
1567 | #endif | |
1568 | ||
1569 | return 0; | |
1570 | } | |
1571 | ||
1572 | /* We would like either a $DEBUG$ or $PINFO$ section. | |
1573 | Once we know which, we can understand the header | |
1574 | data (which we have defined to suit the more common | |
1575 | $DEBUG$ case). */ | |
1576 | debug_section = bfd_get_section_by_name (objfile->obfd, "$DEBUG$"); | |
1577 | pinfo_section = bfd_get_section_by_name (objfile->obfd, "$PINFO$"); | |
1578 | if (debug_section) | |
1579 | { | |
1580 | /* The expected case: normal pxdb header. */ | |
1581 | bfd_get_section_contents (objfile->obfd, header_section, | |
1582 | pxdb_header_p, 0, sizeof (PXDB_header)); | |
1583 | ||
1584 | if (!pxdb_header_p->pxdbed) | |
1585 | { | |
1586 | /* This shouldn't happen if we check in "symfile.c". */ | |
1587 | return 0; | |
1588 | } /* DEBUG section */ | |
1589 | } | |
1590 | ||
1591 | else if (pinfo_section) | |
1592 | { | |
1593 | /* The DOC case; we need to translate this into a | |
1594 | regular header. */ | |
1595 | DOC_info_PXDB_header doc_header; | |
1596 | ||
1597 | #ifdef DUMPING | |
1598 | if (dumping) | |
1599 | { | |
1600 | printf ("==OOps, PINFO, let's try to handle this, %s.\n", objfile->name); | |
1601 | } | |
1602 | #endif | |
1603 | ||
1604 | bfd_get_section_contents (objfile->obfd, | |
1605 | header_section, | |
1606 | &doc_header, 0, | |
1607 | sizeof (DOC_info_PXDB_header)); | |
1608 | ||
1609 | if (!doc_header.pxdbed) | |
1610 | { | |
1611 | /* This shouldn't happen if we check in "symfile.c". */ | |
8a3fe4f8 | 1612 | warning (_("File \"%s\" not processed by pxdb!"), objfile->name); |
8af51c36 EZ |
1613 | return 0; |
1614 | } | |
1615 | ||
1616 | /* Copy relevent fields to standard header passed in. */ | |
1617 | pxdb_header_p->pd_entries = doc_header.pd_entries; | |
1618 | pxdb_header_p->fd_entries = doc_header.fd_entries; | |
1619 | pxdb_header_p->md_entries = doc_header.md_entries; | |
1620 | pxdb_header_p->pxdbed = doc_header.pxdbed; | |
1621 | pxdb_header_p->bighdr = doc_header.bighdr; | |
1622 | pxdb_header_p->sa_header = doc_header.sa_header; | |
1623 | pxdb_header_p->inlined = doc_header.inlined; | |
1624 | pxdb_header_p->globals = doc_header.globals; | |
1625 | pxdb_header_p->time = doc_header.time; | |
1626 | pxdb_header_p->pg_entries = doc_header.pg_entries; | |
1627 | pxdb_header_p->functions = doc_header.functions; | |
1628 | pxdb_header_p->files = doc_header.files; | |
1629 | pxdb_header_p->cd_entries = doc_header.cd_entries; | |
1630 | pxdb_header_p->aa_entries = doc_header.aa_entries; | |
1631 | pxdb_header_p->oi_entries = doc_header.oi_entries; | |
1632 | pxdb_header_p->version = doc_header.version; | |
1633 | } /* PINFO section */ | |
1634 | ||
1635 | else | |
1636 | { | |
1637 | #ifdef DUMPING | |
1638 | if (dumping) | |
1639 | printf ("==No debug info at all for %s.\n", objfile->name); | |
1640 | #endif | |
1641 | ||
1642 | return 0; | |
1643 | ||
1644 | } | |
1645 | ||
1646 | return 1; | |
1647 | } /* End of hpread_get_header */ | |
1648 | #endif /* QUICK_LOOK_UP */ | |
1649 | \f | |
1650 | ||
1651 | /* Initialization for reading native HP C debug symbols from OBJFILE. | |
1652 | ||
1653 | Its only purpose in life is to set up the symbol reader's private | |
1654 | per-objfile data structures, and read in the raw contents of the debug | |
1655 | sections (attaching pointers to the debug info into the private data | |
1656 | structures). | |
1657 | ||
1658 | Since BFD doesn't know how to read debug symbols in a format-independent | |
1659 | way (and may never do so...), we have to do it ourselves. Note we may | |
1660 | be called on a file without native HP C debugging symbols. | |
1661 | ||
1662 | FIXME, there should be a cleaner peephole into the BFD environment | |
1663 | here. */ | |
1664 | void | |
1665 | hpread_symfile_init (struct objfile *objfile) | |
1666 | { | |
1667 | asection *vt_section, *slt_section, *lntt_section, *gntt_section; | |
1668 | ||
1669 | /* Allocate struct to keep track of the symfile */ | |
0a6ddd08 | 1670 | objfile->deprecated_sym_private = |
7936743b | 1671 | xmalloc (sizeof (struct hpread_symfile_info)); |
0a6ddd08 | 1672 | memset (objfile->deprecated_sym_private, 0, sizeof (struct hpread_symfile_info)); |
8af51c36 EZ |
1673 | |
1674 | /* We haven't read in any types yet. */ | |
9a6f53fe | 1675 | DNTT_TYPE_VECTOR (objfile) = 0; |
8af51c36 EZ |
1676 | |
1677 | /* Read in data from the $GNTT$ subspace. */ | |
1678 | gntt_section = bfd_get_section_by_name (objfile->obfd, "$GNTT$"); | |
1679 | if (!gntt_section) | |
1680 | return; | |
1681 | ||
1682 | GNTT (objfile) | |
4a146b47 | 1683 | = obstack_alloc (&objfile->objfile_obstack, |
8af51c36 EZ |
1684 | bfd_section_size (objfile->obfd, gntt_section)); |
1685 | ||
1686 | bfd_get_section_contents (objfile->obfd, gntt_section, GNTT (objfile), | |
1687 | 0, bfd_section_size (objfile->obfd, gntt_section)); | |
1688 | ||
1689 | GNTT_SYMCOUNT (objfile) | |
1690 | = bfd_section_size (objfile->obfd, gntt_section) | |
1691 | / sizeof (struct dntt_type_block); | |
1692 | ||
1693 | /* Read in data from the $LNTT$ subspace. Also keep track of the number | |
1694 | of LNTT symbols. | |
1695 | ||
1696 | FIXME: this could be moved into the psymtab-to-symtab expansion | |
1697 | code, and save startup time. At the moment this data is | |
1698 | still used, though. We'd need a way to tell hp-symtab-read.c | |
1699 | whether or not to load the LNTT. */ | |
1700 | lntt_section = bfd_get_section_by_name (objfile->obfd, "$LNTT$"); | |
1701 | if (!lntt_section) | |
1702 | return; | |
1703 | ||
1704 | LNTT (objfile) | |
4a146b47 | 1705 | = obstack_alloc (&objfile->objfile_obstack, |
8af51c36 EZ |
1706 | bfd_section_size (objfile->obfd, lntt_section)); |
1707 | ||
1708 | bfd_get_section_contents (objfile->obfd, lntt_section, LNTT (objfile), | |
1709 | 0, bfd_section_size (objfile->obfd, lntt_section)); | |
1710 | ||
1711 | LNTT_SYMCOUNT (objfile) | |
1712 | = bfd_section_size (objfile->obfd, lntt_section) | |
1713 | / sizeof (struct dntt_type_block); | |
1714 | ||
1715 | /* Read in data from the $SLT$ subspace. $SLT$ contains information | |
1716 | on source line numbers. */ | |
1717 | slt_section = bfd_get_section_by_name (objfile->obfd, "$SLT$"); | |
1718 | if (!slt_section) | |
1719 | return; | |
1720 | ||
1721 | SLT (objfile) = | |
4a146b47 | 1722 | obstack_alloc (&objfile->objfile_obstack, |
8af51c36 EZ |
1723 | bfd_section_size (objfile->obfd, slt_section)); |
1724 | ||
1725 | bfd_get_section_contents (objfile->obfd, slt_section, SLT (objfile), | |
1726 | 0, bfd_section_size (objfile->obfd, slt_section)); | |
1727 | ||
1728 | /* Read in data from the $VT$ subspace. $VT$ contains things like | |
1729 | names and constants. Keep track of the number of symbols in the VT. */ | |
1730 | vt_section = bfd_get_section_by_name (objfile->obfd, "$VT$"); | |
1731 | if (!vt_section) | |
1732 | return; | |
1733 | ||
1734 | VT_SIZE (objfile) = bfd_section_size (objfile->obfd, vt_section); | |
1735 | ||
1736 | VT (objfile) = | |
4a146b47 | 1737 | (char *) obstack_alloc (&objfile->objfile_obstack, |
8af51c36 EZ |
1738 | VT_SIZE (objfile)); |
1739 | ||
1740 | bfd_get_section_contents (objfile->obfd, vt_section, VT (objfile), | |
1741 | 0, VT_SIZE (objfile)); | |
1742 | } | |
1743 | ||
1744 | /* Scan and build partial symbols for a symbol file. | |
1745 | ||
1746 | The minimal symbol table (either SOM or HP a.out) has already been | |
1747 | read in; all we need to do is setup partial symbols based on the | |
1748 | native debugging information. | |
1749 | ||
1750 | Note that the minimal table is produced by the linker, and has | |
1751 | only global routines in it; the psymtab is based on compiler- | |
1752 | generated debug information and has non-global | |
1753 | routines in it as well as files and class information. | |
1754 | ||
1755 | We assume hpread_symfile_init has been called to initialize the | |
1756 | symbol reader's private data structures. | |
1757 | ||
1758 | MAINLINE is true if we are reading the main symbol table (as | |
1759 | opposed to a shared lib or dynamically loaded file). */ | |
1760 | ||
1761 | void | |
1762 | hpread_build_psymtabs (struct objfile *objfile, int mainline) | |
1763 | { | |
1764 | ||
1765 | #ifdef DUMPING | |
1766 | /* Turn this on to get debugging output. */ | |
1767 | static int dumping = 0; | |
1768 | #endif | |
1769 | ||
1770 | char *namestring; | |
1771 | int past_first_source_file = 0; | |
1772 | struct cleanup *old_chain; | |
1773 | ||
1774 | int hp_symnum, symcount, i; | |
1775 | int scan_start = 0; | |
1776 | ||
1777 | union dnttentry *dn_bufp; | |
1778 | unsigned long valu; | |
1779 | char *p; | |
1780 | int texthigh = 0; | |
1781 | int have_name = 0; | |
1782 | ||
1783 | /* Current partial symtab */ | |
1784 | struct partial_symtab *pst; | |
1785 | ||
1786 | /* List of current psymtab's include files */ | |
1787 | char **psymtab_include_list; | |
1788 | int includes_allocated; | |
1789 | int includes_used; | |
1790 | ||
1791 | /* Index within current psymtab dependency list */ | |
1792 | struct partial_symtab **dependency_list; | |
1793 | int dependencies_used, dependencies_allocated; | |
1794 | ||
1795 | /* Just in case the stabs reader left turds lying around. */ | |
1796 | free_pending_blocks (); | |
1797 | make_cleanup (really_free_pendings, 0); | |
1798 | ||
1799 | pst = (struct partial_symtab *) 0; | |
1800 | ||
1801 | /* We shouldn't use alloca, instead use malloc/free. Doing so avoids | |
1802 | a number of problems with cross compilation and creating useless holes | |
1803 | in the stack when we have to allocate new entries. FIXME. */ | |
1804 | ||
1805 | includes_allocated = 30; | |
1806 | includes_used = 0; | |
1807 | psymtab_include_list = (char **) alloca (includes_allocated * | |
1808 | sizeof (char *)); | |
1809 | ||
1810 | dependencies_allocated = 30; | |
1811 | dependencies_used = 0; | |
1812 | dependency_list = | |
1813 | (struct partial_symtab **) alloca (dependencies_allocated * | |
1814 | sizeof (struct partial_symtab *)); | |
1815 | ||
1816 | old_chain = make_cleanup_free_objfile (objfile); | |
1817 | ||
1818 | last_source_file = 0; | |
1819 | ||
1820 | #ifdef QUICK_LOOK_UP | |
1821 | { | |
1822 | /* Begin code for new-style loading of quick look-up tables. */ | |
1823 | ||
1824 | /* elz: this checks whether the file has beeen processed by pxdb. | |
1825 | If not we would like to try to read the psymbols in | |
1826 | anyway, but it turns out to be not so easy. So this could | |
1827 | actually be commented out, but I leave it in, just in case | |
1828 | we decide to add support for non-pxdb-ed stuff in the future. */ | |
1829 | PXDB_header pxdb_header; | |
1830 | int found_modules_in_program; | |
1831 | ||
1832 | if (hpread_get_header (objfile, &pxdb_header)) | |
1833 | { | |
1834 | /* Build a minimal table. No types, no global variables, | |
1835 | no include files.... */ | |
1836 | #ifdef DUMPING | |
1837 | if (dumping) | |
1838 | printf ("\nNew method for %s\n", objfile->name); | |
1839 | #endif | |
1840 | ||
1841 | /* elz: quick_traverse returns true if it found | |
1842 | some modules in the main source file, other | |
1843 | than those in end.c | |
1844 | In C and C++, all the files have MODULES entries | |
1845 | in the LNTT, and the quick table traverse is all | |
1846 | based on finding these MODULES entries. Without | |
1847 | those it cannot work. | |
1848 | It happens that F77 programs don't have MODULES | |
1849 | so the quick traverse gets confused. F90 programs | |
1850 | have modules, and the quick method still works. | |
1851 | So, if modules (other than those in end.c) are | |
1852 | not found we give up on the quick table stuff, | |
1853 | and fall back on the slower method */ | |
1854 | found_modules_in_program = hpread_quick_traverse (objfile, | |
1855 | GNTT (objfile), | |
1856 | VT (objfile), | |
1857 | &pxdb_header); | |
1858 | ||
1859 | discard_cleanups (old_chain); | |
1860 | ||
1861 | /* Set up to scan the global section of the LNTT. | |
1862 | ||
1863 | This field is not always correct: if there are | |
1864 | no globals, it will point to the last record in | |
1865 | the regular LNTT, which is usually an END MODULE. | |
1866 | ||
1867 | Since it might happen that there could be a file | |
1868 | with just one global record, there's no way to | |
1869 | tell other than by looking at the record, so that's | |
1870 | done below. */ | |
1871 | if (found_modules_in_program) | |
1872 | scan_start = pxdb_header.globals; | |
1873 | } | |
1874 | #ifdef DUMPING | |
1875 | else | |
1876 | { | |
1877 | if (dumping) | |
1878 | printf ("\nGoing on to old method for %s\n", objfile->name); | |
1879 | } | |
1880 | #endif | |
1881 | } | |
1882 | #endif /* QUICK_LOOK_UP */ | |
1883 | ||
1884 | /* Make two passes, one over the GNTT symbols, the other for the | |
1885 | LNTT symbols. | |
1886 | ||
1887 | JB comment: above isn't true--they only make one pass, over | |
1888 | the LNTT. */ | |
1889 | for (i = 0; i < 1; i++) | |
1890 | { | |
1891 | int within_function = 0; | |
1892 | ||
1893 | if (i) | |
1894 | symcount = GNTT_SYMCOUNT (objfile); | |
1895 | else | |
1896 | symcount = LNTT_SYMCOUNT (objfile); | |
1897 | ||
1898 | ||
1899 | for (hp_symnum = scan_start; hp_symnum < symcount; hp_symnum++) | |
1900 | { | |
1901 | QUIT; | |
1902 | if (i) | |
1903 | dn_bufp = hpread_get_gntt (hp_symnum, objfile); | |
1904 | else | |
1905 | dn_bufp = hpread_get_lntt (hp_symnum, objfile); | |
1906 | ||
1907 | if (dn_bufp->dblock.extension) | |
1908 | continue; | |
1909 | ||
1910 | /* Only handle things which are necessary for minimal symbols. | |
1911 | everything else is ignored. */ | |
1912 | switch (dn_bufp->dblock.kind) | |
1913 | { | |
1914 | case DNTT_TYPE_SRCFILE: | |
1915 | { | |
1916 | #ifdef QUICK_LOOK_UP | |
1917 | if (scan_start == hp_symnum | |
1918 | && symcount == hp_symnum + 1) | |
1919 | { | |
1920 | /* If there are NO globals in an executable, | |
1921 | PXDB's index to the globals will point to | |
1922 | the last record in the file, which | |
1923 | could be this record. (this happened for F77 libraries) | |
1924 | ignore it and be done! */ | |
1925 | continue; | |
1926 | } | |
1927 | #endif /* QUICK_LOOK_UP */ | |
1928 | ||
1929 | /* A source file of some kind. Note this may simply | |
1930 | be an included file. */ | |
68b8d23e | 1931 | set_namestring (dn_bufp, &namestring, objfile); |
8af51c36 EZ |
1932 | |
1933 | /* Check if this is the source file we are already working | |
1934 | with. */ | |
1935 | if (pst && !strcmp (namestring, pst->filename)) | |
1936 | continue; | |
1937 | ||
1938 | /* Check if this is an include file, if so check if we have | |
1939 | already seen it. Add it to the include list */ | |
1940 | p = strrchr (namestring, '.'); | |
1941 | if (!strcmp (p, ".h")) | |
1942 | { | |
1943 | int j, found; | |
1944 | ||
1945 | found = 0; | |
1946 | for (j = 0; j < includes_used; j++) | |
1947 | if (!strcmp (namestring, psymtab_include_list[j])) | |
1948 | { | |
1949 | found = 1; | |
1950 | break; | |
1951 | } | |
1952 | if (found) | |
1953 | continue; | |
1954 | ||
1955 | /* Add it to the list of includes seen so far and | |
1956 | allocate more include space if necessary. */ | |
1957 | psymtab_include_list[includes_used++] = namestring; | |
1958 | if (includes_used >= includes_allocated) | |
1959 | { | |
1960 | char **orig = psymtab_include_list; | |
1961 | ||
1962 | psymtab_include_list = (char **) | |
1963 | alloca ((includes_allocated *= 2) * | |
1964 | sizeof (char *)); | |
4efb68b1 | 1965 | memcpy (psymtab_include_list, orig, |
8af51c36 EZ |
1966 | includes_used * sizeof (char *)); |
1967 | } | |
1968 | continue; | |
1969 | } | |
1970 | ||
1971 | if (pst) | |
1972 | { | |
1973 | if (!have_name) | |
1974 | { | |
1975 | pst->filename = (char *) | |
8b92e4d5 | 1976 | obstack_alloc (&pst->objfile->objfile_obstack, |
8af51c36 EZ |
1977 | strlen (namestring) + 1); |
1978 | strcpy (pst->filename, namestring); | |
1979 | have_name = 1; | |
1980 | continue; | |
1981 | } | |
1982 | continue; | |
1983 | } | |
1984 | ||
1985 | /* This is a bonafide new source file. | |
1986 | End the current partial symtab and start a new one. */ | |
1987 | ||
1988 | if (pst && past_first_source_file) | |
1989 | { | |
1990 | hpread_end_psymtab (pst, psymtab_include_list, | |
1991 | includes_used, | |
1992 | (hp_symnum | |
1993 | * sizeof (struct dntt_type_block)), | |
1994 | texthigh, | |
1995 | dependency_list, dependencies_used); | |
1996 | pst = (struct partial_symtab *) 0; | |
1997 | includes_used = 0; | |
1998 | dependencies_used = 0; | |
1999 | } | |
2000 | else | |
2001 | past_first_source_file = 1; | |
2002 | ||
2003 | valu = hpread_get_textlow (i, hp_symnum, objfile, symcount); | |
2004 | valu += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); | |
2005 | pst = hpread_start_psymtab (objfile, | |
2006 | namestring, valu, | |
2007 | (hp_symnum | |
2008 | * sizeof (struct dntt_type_block)), | |
2009 | objfile->global_psymbols.next, | |
2010 | objfile->static_psymbols.next); | |
2011 | texthigh = valu; | |
2012 | have_name = 1; | |
2013 | continue; | |
2014 | } | |
2015 | ||
2016 | case DNTT_TYPE_MODULE: | |
2017 | /* A source file. It's still unclear to me what the | |
2018 | real difference between a DNTT_TYPE_SRCFILE and DNTT_TYPE_MODULE | |
2019 | is supposed to be. */ | |
2020 | ||
2021 | /* First end the previous psymtab */ | |
2022 | if (pst) | |
2023 | { | |
2024 | hpread_end_psymtab (pst, psymtab_include_list, includes_used, | |
2025 | ((hp_symnum - 1) | |
2026 | * sizeof (struct dntt_type_block)), | |
2027 | texthigh, | |
2028 | dependency_list, dependencies_used); | |
2029 | pst = (struct partial_symtab *) 0; | |
2030 | includes_used = 0; | |
2031 | dependencies_used = 0; | |
2032 | have_name = 0; | |
2033 | } | |
2034 | ||
2035 | /* Now begin a new module and a new psymtab for it */ | |
68b8d23e | 2036 | set_namestring (dn_bufp, &namestring, objfile); |
8af51c36 EZ |
2037 | valu = hpread_get_textlow (i, hp_symnum, objfile, symcount); |
2038 | valu += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); | |
2039 | if (!pst) | |
2040 | { | |
2041 | pst = hpread_start_psymtab (objfile, | |
2042 | namestring, valu, | |
2043 | (hp_symnum | |
2044 | * sizeof (struct dntt_type_block)), | |
2045 | objfile->global_psymbols.next, | |
2046 | objfile->static_psymbols.next); | |
2047 | texthigh = valu; | |
2048 | have_name = 0; | |
2049 | } | |
2050 | continue; | |
2051 | ||
2052 | case DNTT_TYPE_FUNCTION: | |
2053 | case DNTT_TYPE_ENTRY: | |
2054 | /* The beginning of a function. DNTT_TYPE_ENTRY may also denote | |
2055 | a secondary entry point. */ | |
2056 | valu = dn_bufp->dfunc.hiaddr + ANOFFSET (objfile->section_offsets, | |
2057 | SECT_OFF_TEXT (objfile)); | |
2058 | if (valu > texthigh) | |
2059 | texthigh = valu; | |
2060 | valu = dn_bufp->dfunc.lowaddr + | |
2061 | ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); | |
68b8d23e | 2062 | set_namestring (dn_bufp, &namestring, objfile); |
8af51c36 EZ |
2063 | if (dn_bufp->dfunc.global) |
2064 | add_psymbol_to_list (namestring, strlen (namestring), | |
176620f1 | 2065 | VAR_DOMAIN, LOC_BLOCK, |
8af51c36 EZ |
2066 | &objfile->global_psymbols, valu, |
2067 | 0, language_unknown, objfile); | |
2068 | else | |
2069 | add_psymbol_to_list (namestring, strlen (namestring), | |
176620f1 | 2070 | VAR_DOMAIN, LOC_BLOCK, |
8af51c36 EZ |
2071 | &objfile->static_psymbols, valu, |
2072 | 0, language_unknown, objfile); | |
2073 | within_function = 1; | |
2074 | continue; | |
2075 | ||
2076 | case DNTT_TYPE_DOC_FUNCTION: | |
2077 | valu = dn_bufp->ddocfunc.hiaddr + ANOFFSET (objfile->section_offsets, | |
2078 | SECT_OFF_TEXT (objfile)); | |
2079 | if (valu > texthigh) | |
2080 | texthigh = valu; | |
2081 | valu = dn_bufp->ddocfunc.lowaddr + | |
2082 | ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); | |
68b8d23e | 2083 | set_namestring (dn_bufp, &namestring, objfile); |
8af51c36 EZ |
2084 | if (dn_bufp->ddocfunc.global) |
2085 | add_psymbol_to_list (namestring, strlen (namestring), | |
176620f1 | 2086 | VAR_DOMAIN, LOC_BLOCK, |
8af51c36 EZ |
2087 | &objfile->global_psymbols, valu, |
2088 | 0, language_unknown, objfile); | |
2089 | else | |
2090 | add_psymbol_to_list (namestring, strlen (namestring), | |
176620f1 | 2091 | VAR_DOMAIN, LOC_BLOCK, |
8af51c36 EZ |
2092 | &objfile->static_psymbols, valu, |
2093 | 0, language_unknown, objfile); | |
2094 | within_function = 1; | |
2095 | continue; | |
2096 | ||
2097 | case DNTT_TYPE_BEGIN: | |
2098 | case DNTT_TYPE_END: | |
2099 | /* We don't check MODULE end here, because there can be | |
2100 | symbols beyond the module end which properly belong to the | |
2101 | current psymtab -- so we wait till the next MODULE start */ | |
2102 | ||
2103 | ||
2104 | #ifdef QUICK_LOOK_UP | |
2105 | if (scan_start == hp_symnum | |
2106 | && symcount == hp_symnum + 1) | |
2107 | { | |
2108 | /* If there are NO globals in an executable, | |
2109 | PXDB's index to the globals will point to | |
2110 | the last record in the file, which is | |
2111 | probably an END MODULE, i.e. this record. | |
2112 | ignore it and be done! */ | |
2113 | continue; | |
2114 | } | |
2115 | #endif /* QUICK_LOOK_UP */ | |
2116 | ||
2117 | /* Scope block begin/end. We only care about function | |
2118 | and file blocks right now. */ | |
2119 | ||
2120 | if ((dn_bufp->dend.endkind == DNTT_TYPE_FUNCTION) || | |
2121 | (dn_bufp->dend.endkind == DNTT_TYPE_DOC_FUNCTION)) | |
2122 | within_function = 0; | |
2123 | continue; | |
2124 | ||
2125 | case DNTT_TYPE_SVAR: | |
2126 | case DNTT_TYPE_DVAR: | |
2127 | case DNTT_TYPE_TYPEDEF: | |
2128 | case DNTT_TYPE_TAGDEF: | |
2129 | { | |
2130 | /* Variables, typedefs an the like. */ | |
2131 | enum address_class storage; | |
176620f1 | 2132 | domain_enum domain; |
8af51c36 EZ |
2133 | |
2134 | /* Don't add locals to the partial symbol table. */ | |
2135 | if (within_function | |
2136 | && (dn_bufp->dblock.kind == DNTT_TYPE_SVAR | |
2137 | || dn_bufp->dblock.kind == DNTT_TYPE_DVAR)) | |
2138 | continue; | |
2139 | ||
176620f1 | 2140 | /* TAGDEFs go into the structure domain. */ |
8af51c36 | 2141 | if (dn_bufp->dblock.kind == DNTT_TYPE_TAGDEF) |
176620f1 | 2142 | domain = STRUCT_DOMAIN; |
8af51c36 | 2143 | else |
176620f1 | 2144 | domain = VAR_DOMAIN; |
8af51c36 EZ |
2145 | |
2146 | /* What kind of "storage" does this use? */ | |
2147 | if (dn_bufp->dblock.kind == DNTT_TYPE_SVAR) | |
2148 | storage = LOC_STATIC; | |
2149 | else if (dn_bufp->dblock.kind == DNTT_TYPE_DVAR | |
2150 | && dn_bufp->ddvar.regvar) | |
2151 | storage = LOC_REGISTER; | |
2152 | else if (dn_bufp->dblock.kind == DNTT_TYPE_DVAR) | |
2153 | storage = LOC_LOCAL; | |
2154 | else | |
2155 | storage = LOC_UNDEF; | |
2156 | ||
68b8d23e | 2157 | set_namestring (dn_bufp, &namestring, objfile); |
8af51c36 EZ |
2158 | if (!pst) |
2159 | { | |
2160 | pst = hpread_start_psymtab (objfile, | |
2161 | "globals", 0, | |
2162 | (hp_symnum | |
2163 | * sizeof (struct dntt_type_block)), | |
2164 | objfile->global_psymbols.next, | |
2165 | objfile->static_psymbols.next); | |
2166 | } | |
2167 | ||
2168 | /* Compute address of the data symbol */ | |
2169 | valu = dn_bufp->dsvar.location; | |
2170 | /* Relocate in case it's in a shared library */ | |
2171 | if (storage == LOC_STATIC) | |
2172 | valu += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); | |
2173 | ||
2174 | /* Luckily, dvar, svar, typedef, and tagdef all | |
2175 | have their "global" bit in the same place, so it works | |
2176 | (though it's bad programming practice) to reference | |
2177 | "dsvar.global" even though we may be looking at | |
2178 | any of the above four types. */ | |
2179 | if (dn_bufp->dsvar.global) | |
2180 | { | |
2181 | add_psymbol_to_list (namestring, strlen (namestring), | |
176620f1 | 2182 | domain, storage, |
8af51c36 EZ |
2183 | &objfile->global_psymbols, |
2184 | valu, | |
2185 | 0, language_unknown, objfile); | |
2186 | } | |
2187 | else | |
2188 | { | |
2189 | add_psymbol_to_list (namestring, strlen (namestring), | |
176620f1 | 2190 | domain, storage, |
8af51c36 EZ |
2191 | &objfile->static_psymbols, |
2192 | valu, | |
2193 | 0, language_unknown, objfile); | |
2194 | } | |
2195 | ||
2196 | /* For TAGDEF's, the above code added the tagname to the | |
176620f1 | 2197 | struct domain. This will cause tag "t" to be found |
8af51c36 EZ |
2198 | on a reference of the form "(struct t) x". But for |
2199 | C++ classes, "t" will also be a typename, which we | |
2200 | want to find on a reference of the form "ptype t". | |
176620f1 | 2201 | Therefore, we also add "t" to the var domain. |
8af51c36 EZ |
2202 | Do the same for enum's due to the way aCC generates |
2203 | debug info for these (see more extended comment | |
2204 | in hp-symtab-read.c). | |
2205 | We do the same for templates, so that "ptype t" | |
2206 | where "t" is a template also works. */ | |
2207 | if (dn_bufp->dblock.kind == DNTT_TYPE_TAGDEF && | |
2208 | dn_bufp->dtype.type.dnttp.index < LNTT_SYMCOUNT (objfile)) | |
2209 | { | |
2210 | int global = dn_bufp->dtag.global; | |
2211 | /* Look ahead to see if it's a C++ class */ | |
2212 | dn_bufp = hpread_get_lntt (dn_bufp->dtype.type.dnttp.index, objfile); | |
2213 | if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS || | |
2214 | dn_bufp->dblock.kind == DNTT_TYPE_ENUM || | |
2215 | dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE) | |
2216 | { | |
2217 | if (global) | |
2218 | { | |
2219 | add_psymbol_to_list (namestring, strlen (namestring), | |
176620f1 | 2220 | VAR_DOMAIN, storage, |
8af51c36 EZ |
2221 | &objfile->global_psymbols, |
2222 | dn_bufp->dsvar.location, | |
2223 | 0, language_unknown, objfile); | |
2224 | } | |
2225 | else | |
2226 | { | |
2227 | add_psymbol_to_list (namestring, strlen (namestring), | |
176620f1 | 2228 | VAR_DOMAIN, storage, |
8af51c36 EZ |
2229 | &objfile->static_psymbols, |
2230 | dn_bufp->dsvar.location, | |
2231 | 0, language_unknown, objfile); | |
2232 | } | |
2233 | } | |
2234 | } | |
2235 | } | |
2236 | continue; | |
2237 | ||
2238 | case DNTT_TYPE_MEMENUM: | |
2239 | case DNTT_TYPE_CONST: | |
2240 | /* Constants and members of enumerated types. */ | |
68b8d23e | 2241 | set_namestring (dn_bufp, &namestring, objfile); |
8af51c36 EZ |
2242 | if (!pst) |
2243 | { | |
2244 | pst = hpread_start_psymtab (objfile, | |
2245 | "globals", 0, | |
2246 | (hp_symnum | |
2247 | * sizeof (struct dntt_type_block)), | |
2248 | objfile->global_psymbols.next, | |
2249 | objfile->static_psymbols.next); | |
2250 | } | |
2251 | if (dn_bufp->dconst.global) | |
2252 | add_psymbol_to_list (namestring, strlen (namestring), | |
176620f1 | 2253 | VAR_DOMAIN, LOC_CONST, |
8af51c36 EZ |
2254 | &objfile->global_psymbols, 0, |
2255 | 0, language_unknown, objfile); | |
2256 | else | |
2257 | add_psymbol_to_list (namestring, strlen (namestring), | |
176620f1 | 2258 | VAR_DOMAIN, LOC_CONST, |
8af51c36 EZ |
2259 | &objfile->static_psymbols, 0, |
2260 | 0, language_unknown, objfile); | |
2261 | continue; | |
2262 | default: | |
2263 | continue; | |
2264 | } | |
2265 | } | |
2266 | } | |
2267 | ||
2268 | /* End any pending partial symbol table. */ | |
2269 | if (pst) | |
2270 | { | |
2271 | hpread_end_psymtab (pst, psymtab_include_list, includes_used, | |
2272 | hp_symnum * sizeof (struct dntt_type_block), | |
2273 | 0, dependency_list, dependencies_used); | |
2274 | } | |
2275 | ||
2276 | discard_cleanups (old_chain); | |
2277 | } | |
2278 | ||
2279 | /* Perform any local cleanups required when we are done with a particular | |
2280 | objfile. I.E, we are in the process of discarding all symbol information | |
2281 | for an objfile, freeing up all memory held for it, and unlinking the | |
2282 | objfile struct from the global list of known objfiles. */ | |
2283 | ||
2284 | void | |
2285 | hpread_symfile_finish (struct objfile *objfile) | |
2286 | { | |
0a6ddd08 | 2287 | if (objfile->deprecated_sym_private != NULL) |
8af51c36 | 2288 | { |
0a6ddd08 | 2289 | xfree (objfile->deprecated_sym_private); |
8af51c36 EZ |
2290 | } |
2291 | } | |
2292 | \f | |
2293 | ||
2294 | /* The remaining functions are all for internal use only. */ | |
2295 | ||
2296 | /* Various small functions to get entries in the debug symbol sections. */ | |
2297 | ||
f5479e9c | 2298 | static union dnttentry * |
8af51c36 EZ |
2299 | hpread_get_lntt (int index, struct objfile *objfile) |
2300 | { | |
2301 | return (union dnttentry *) | |
2302 | &(LNTT (objfile)[(index * sizeof (struct dntt_type_block))]); | |
2303 | } | |
2304 | ||
2305 | static union dnttentry * | |
2306 | hpread_get_gntt (int index, struct objfile *objfile) | |
2307 | { | |
2308 | return (union dnttentry *) | |
2309 | &(GNTT (objfile)[(index * sizeof (struct dntt_type_block))]); | |
2310 | } | |
2311 | ||
f5479e9c | 2312 | static union sltentry * |
8af51c36 EZ |
2313 | hpread_get_slt (int index, struct objfile *objfile) |
2314 | { | |
2315 | return (union sltentry *) &(SLT (objfile)[index * sizeof (union sltentry)]); | |
2316 | } | |
2317 | ||
2318 | /* Get the low address associated with some symbol (typically the start | |
2319 | of a particular source file or module). Since that information is not | |
2320 | stored as part of the DNTT_TYPE_MODULE or DNTT_TYPE_SRCFILE symbol we | |
2321 | must infer it from the existence of DNTT_TYPE_FUNCTION symbols. */ | |
2322 | ||
2323 | static unsigned long | |
2324 | hpread_get_textlow (int global, int index, struct objfile *objfile, | |
2325 | int symcount) | |
2326 | { | |
65e82032 | 2327 | union dnttentry *dn_bufp = NULL; |
8af51c36 EZ |
2328 | struct minimal_symbol *msymbol; |
2329 | ||
2330 | /* Look for a DNTT_TYPE_FUNCTION symbol. */ | |
2331 | if (index < symcount) /* symcount is the number of symbols in */ | |
2332 | { /* the dbinfo, LNTT table */ | |
2333 | do | |
2334 | { | |
2335 | if (global) | |
2336 | dn_bufp = hpread_get_gntt (index++, objfile); | |
2337 | else | |
2338 | dn_bufp = hpread_get_lntt (index++, objfile); | |
2339 | } | |
2340 | while (dn_bufp->dblock.kind != DNTT_TYPE_FUNCTION | |
2341 | && dn_bufp->dblock.kind != DNTT_TYPE_DOC_FUNCTION | |
2342 | && dn_bufp->dblock.kind != DNTT_TYPE_END | |
2343 | && index < symcount); | |
2344 | } | |
2345 | ||
65e82032 AC |
2346 | /* NOTE: cagney/2003-03-29: If !(index < symcount), dn_bufp is left |
2347 | undefined and that means that the test below is using a garbage | |
2348 | pointer from the stack. */ | |
2349 | gdb_assert (dn_bufp != NULL); | |
2350 | ||
8af51c36 EZ |
2351 | /* Avoid going past a DNTT_TYPE_END when looking for a DNTT_TYPE_FUNCTION. This |
2352 | might happen when a sourcefile has no functions. */ | |
2353 | if (dn_bufp->dblock.kind == DNTT_TYPE_END) | |
2354 | return 0; | |
2355 | ||
2356 | /* Avoid going past the end of the LNTT file */ | |
2357 | if (index == symcount) | |
2358 | return 0; | |
2359 | ||
2360 | /* The minimal symbols are typically more accurate for some reason. */ | |
2361 | if (dn_bufp->dblock.kind == DNTT_TYPE_FUNCTION) | |
2362 | msymbol = lookup_minimal_symbol (dn_bufp->dfunc.name + VT (objfile), NULL, | |
2363 | objfile); | |
2364 | else /* must be a DNTT_TYPE_DOC_FUNCTION */ | |
2365 | msymbol = lookup_minimal_symbol (dn_bufp->ddocfunc.name + VT (objfile), NULL, | |
2366 | objfile); | |
2367 | ||
2368 | if (msymbol) | |
2369 | return SYMBOL_VALUE_ADDRESS (msymbol); | |
2370 | else | |
2371 | return dn_bufp->dfunc.lowaddr; | |
2372 | } | |
2373 | ||
2374 | /* Allocate and partially fill a partial symtab. It will be | |
2375 | completely filled at the end of the symbol list. | |
2376 | ||
2377 | SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR | |
2378 | is the address relative to which its symbols are (incremental) or 0 | |
2379 | (normal). */ | |
2380 | ||
2381 | static struct partial_symtab * | |
2382 | hpread_start_psymtab (struct objfile *objfile, char *filename, | |
2383 | CORE_ADDR textlow, int ldsymoff, | |
2384 | struct partial_symbol **global_syms, | |
2385 | struct partial_symbol **static_syms) | |
2386 | { | |
2387 | int offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); | |
8af51c36 EZ |
2388 | struct partial_symtab *result = |
2389 | start_psymtab_common (objfile, objfile->section_offsets, | |
2390 | filename, textlow, global_syms, static_syms); | |
2391 | ||
2392 | result->textlow += offset; | |
2393 | result->read_symtab_private = (char *) | |
8b92e4d5 | 2394 | obstack_alloc (&objfile->objfile_obstack, sizeof (struct symloc)); |
8af51c36 EZ |
2395 | LDSYMOFF (result) = ldsymoff; |
2396 | result->read_symtab = hpread_psymtab_to_symtab; | |
2397 | ||
2398 | return result; | |
2399 | } | |
2400 | \f | |
2401 | ||
2402 | /* Close off the current usage of PST. | |
2403 | Returns PST or NULL if the partial symtab was empty and thrown away. | |
2404 | ||
2405 | capping_symbol_offset --Byte index in LNTT or GNTT of the | |
2406 | last symbol processed during the build | |
2407 | of the previous pst. | |
2408 | ||
2409 | FIXME: List variables and peculiarities of same. */ | |
2410 | ||
2411 | static struct partial_symtab * | |
2412 | hpread_end_psymtab (struct partial_symtab *pst, char **include_list, | |
2413 | int num_includes, int capping_symbol_offset, | |
2414 | CORE_ADDR capping_text, | |
2415 | struct partial_symtab **dependency_list, | |
2416 | int number_dependencies) | |
2417 | { | |
2418 | int i; | |
2419 | struct objfile *objfile = pst->objfile; | |
2420 | int offset = ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (objfile)); | |
2421 | ||
2422 | #ifdef DUMPING | |
2423 | /* Turn on to see what kind of a psymtab we've built. */ | |
2424 | static int dumping = 0; | |
2425 | #endif | |
2426 | ||
2427 | if (capping_symbol_offset != -1) | |
2428 | LDSYMLEN (pst) = capping_symbol_offset - LDSYMOFF (pst); | |
2429 | else | |
2430 | LDSYMLEN (pst) = 0; | |
2431 | pst->texthigh = capping_text + offset; | |
2432 | ||
2433 | pst->n_global_syms = | |
2434 | objfile->global_psymbols.next - (objfile->global_psymbols.list + pst->globals_offset); | |
2435 | pst->n_static_syms = | |
2436 | objfile->static_psymbols.next - (objfile->static_psymbols.list + pst->statics_offset); | |
2437 | ||
2438 | #ifdef DUMPING | |
2439 | if (dumping) | |
2440 | { | |
2441 | printf ("\nPst %s, LDSYMOFF %x (%x), LDSYMLEN %x (%x), globals %d, statics %d\n", | |
2442 | pst->filename, | |
2443 | LDSYMOFF (pst), | |
2444 | LDSYMOFF (pst) / sizeof (struct dntt_type_block), | |
2445 | LDSYMLEN (pst), | |
2446 | LDSYMLEN (pst) / sizeof (struct dntt_type_block), | |
2447 | pst->n_global_syms, pst->n_static_syms); | |
2448 | } | |
2449 | #endif | |
2450 | ||
2451 | pst->number_of_dependencies = number_dependencies; | |
2452 | if (number_dependencies) | |
2453 | { | |
2454 | pst->dependencies = (struct partial_symtab **) | |
8b92e4d5 | 2455 | obstack_alloc (&objfile->objfile_obstack, |
8af51c36 EZ |
2456 | number_dependencies * sizeof (struct partial_symtab *)); |
2457 | memcpy (pst->dependencies, dependency_list, | |
2458 | number_dependencies * sizeof (struct partial_symtab *)); | |
2459 | } | |
2460 | else | |
2461 | pst->dependencies = 0; | |
2462 | ||
2463 | for (i = 0; i < num_includes; i++) | |
2464 | { | |
2465 | struct partial_symtab *subpst = | |
2466 | allocate_psymtab (include_list[i], objfile); | |
2467 | ||
2468 | subpst->section_offsets = pst->section_offsets; | |
2469 | subpst->read_symtab_private = | |
8b92e4d5 | 2470 | (char *) obstack_alloc (&objfile->objfile_obstack, |
8af51c36 EZ |
2471 | sizeof (struct symloc)); |
2472 | LDSYMOFF (subpst) = | |
2473 | LDSYMLEN (subpst) = | |
2474 | subpst->textlow = | |
2475 | subpst->texthigh = 0; | |
2476 | ||
2477 | /* We could save slight bits of space by only making one of these, | |
2478 | shared by the entire set of include files. FIXME-someday. */ | |
2479 | subpst->dependencies = (struct partial_symtab **) | |
8b92e4d5 | 2480 | obstack_alloc (&objfile->objfile_obstack, |
8af51c36 EZ |
2481 | sizeof (struct partial_symtab *)); |
2482 | subpst->dependencies[0] = pst; | |
2483 | subpst->number_of_dependencies = 1; | |
2484 | ||
2485 | subpst->globals_offset = | |
2486 | subpst->n_global_syms = | |
2487 | subpst->statics_offset = | |
2488 | subpst->n_static_syms = 0; | |
2489 | ||
2490 | subpst->readin = 0; | |
2491 | subpst->symtab = 0; | |
2492 | subpst->read_symtab = pst->read_symtab; | |
2493 | } | |
2494 | ||
2495 | sort_pst_symbols (pst); | |
2496 | ||
2497 | /* If there is already a psymtab or symtab for a file of this name, remove it. | |
2498 | (If there is a symtab, more drastic things also happen.) | |
2499 | This happens in VxWorks. */ | |
2500 | free_named_symtabs (pst->filename); | |
2501 | ||
2502 | if (num_includes == 0 | |
2503 | && number_dependencies == 0 | |
2504 | && pst->n_global_syms == 0 | |
2505 | && pst->n_static_syms == 0) | |
2506 | { | |
2507 | /* Throw away this psymtab, it's empty. We can't deallocate it, since | |
2508 | it is on the obstack, but we can forget to chain it on the list. | |
2509 | Empty psymtabs happen as a result of header files which don't have | |
2510 | any symbols in them. There can be a lot of them. But this check | |
2511 | is wrong, in that a psymtab with N_SLINE entries but nothing else | |
2512 | is not empty, but we don't realize that. Fixing that without slowing | |
2513 | things down might be tricky. | |
2514 | It's also wrong if we're using the quick look-up tables, as | |
2515 | we can get empty psymtabs from modules with no routines in | |
2516 | them. */ | |
2517 | ||
2518 | discard_psymtab (pst); | |
2519 | ||
2520 | /* Indicate that psymtab was thrown away. */ | |
2521 | pst = (struct partial_symtab *) NULL; | |
2522 | ||
2523 | } | |
2524 | return pst; | |
2525 | } | |
2526 | ||
2527 | \f | |
2528 | /* Get the nesting depth for the source line identified by INDEX. */ | |
2529 | ||
2530 | static unsigned long | |
2531 | hpread_get_scope_start (sltpointer index, struct objfile *objfile) | |
2532 | { | |
2533 | union sltentry *sl_bufp; | |
2534 | ||
2535 | sl_bufp = hpread_get_slt (index, objfile); | |
2536 | return sl_bufp->sspec.backptr.dnttp.index; | |
2537 | } | |
2538 | ||
2539 | /* Get the source line number the the line identified by INDEX. */ | |
2540 | ||
2541 | static unsigned long | |
2542 | hpread_get_line (sltpointer index, struct objfile *objfile) | |
2543 | { | |
2544 | union sltentry *sl_bufp; | |
2545 | ||
2546 | sl_bufp = hpread_get_slt (index, objfile); | |
2547 | return sl_bufp->snorm.line; | |
2548 | } | |
2549 | ||
2550 | /* Find the code address associated with a given sltpointer */ | |
2551 | ||
2552 | static CORE_ADDR | |
2553 | hpread_get_location (sltpointer index, struct objfile *objfile) | |
2554 | { | |
2555 | union sltentry *sl_bufp; | |
2556 | int i; | |
2557 | ||
2558 | /* code location of special sltentrys is determined from context */ | |
2559 | sl_bufp = hpread_get_slt (index, objfile); | |
2560 | ||
2561 | if (sl_bufp->snorm.sltdesc == SLT_END) | |
2562 | { | |
2563 | /* find previous normal sltentry and get address */ | |
2564 | for (i = 0; ((sl_bufp->snorm.sltdesc != SLT_NORMAL) && | |
2565 | (sl_bufp->snorm.sltdesc != SLT_NORMAL_OFFSET) && | |
2566 | (sl_bufp->snorm.sltdesc != SLT_EXIT)); i++) | |
2567 | sl_bufp = hpread_get_slt (index - i, objfile); | |
2568 | if (sl_bufp->snorm.sltdesc == SLT_NORMAL_OFFSET) | |
2569 | return sl_bufp->snormoff.address; | |
2570 | else | |
2571 | return sl_bufp->snorm.address; | |
2572 | } | |
2573 | ||
2574 | /* find next normal sltentry and get address */ | |
2575 | for (i = 0; ((sl_bufp->snorm.sltdesc != SLT_NORMAL) && | |
2576 | (sl_bufp->snorm.sltdesc != SLT_NORMAL_OFFSET) && | |
2577 | (sl_bufp->snorm.sltdesc != SLT_EXIT)); i++) | |
2578 | sl_bufp = hpread_get_slt (index + i, objfile); | |
2579 | if (sl_bufp->snorm.sltdesc == SLT_NORMAL_OFFSET) | |
2580 | return sl_bufp->snormoff.address; | |
2581 | else | |
2582 | return sl_bufp->snorm.address; | |
2583 | } | |
2584 | \f | |
2585 | ||
2586 | /* Return 1 if an HP debug symbol of type KIND has a name associated with | |
2587 | * it, else return 0. (This function is not currently used, but I'll | |
2588 | * leave it here in case it proves useful later on. - RT). | |
2589 | */ | |
2590 | ||
f5479e9c | 2591 | static int |
8af51c36 EZ |
2592 | hpread_has_name (enum dntt_entry_type kind) |
2593 | { | |
2594 | switch (kind) | |
2595 | { | |
2596 | case DNTT_TYPE_SRCFILE: | |
2597 | case DNTT_TYPE_MODULE: | |
2598 | case DNTT_TYPE_FUNCTION: | |
2599 | case DNTT_TYPE_DOC_FUNCTION: | |
2600 | case DNTT_TYPE_ENTRY: | |
2601 | case DNTT_TYPE_IMPORT: | |
2602 | case DNTT_TYPE_LABEL: | |
2603 | case DNTT_TYPE_FPARAM: | |
2604 | case DNTT_TYPE_SVAR: | |
2605 | case DNTT_TYPE_DVAR: | |
2606 | case DNTT_TYPE_CONST: | |
2607 | case DNTT_TYPE_TYPEDEF: | |
2608 | case DNTT_TYPE_TAGDEF: | |
2609 | case DNTT_TYPE_MEMENUM: | |
2610 | case DNTT_TYPE_FIELD: | |
2611 | case DNTT_TYPE_SA: | |
2612 | case DNTT_TYPE_BLOCKDATA: | |
2613 | case DNTT_TYPE_MEMFUNC: | |
2614 | case DNTT_TYPE_DOC_MEMFUNC: | |
2615 | return 1; | |
2616 | ||
2617 | case DNTT_TYPE_BEGIN: | |
2618 | case DNTT_TYPE_END: | |
2619 | case DNTT_TYPE_POINTER: | |
2620 | case DNTT_TYPE_ENUM: | |
2621 | case DNTT_TYPE_SET: | |
2622 | case DNTT_TYPE_ARRAY: | |
2623 | case DNTT_TYPE_STRUCT: | |
2624 | case DNTT_TYPE_UNION: | |
2625 | case DNTT_TYPE_VARIANT: | |
2626 | case DNTT_TYPE_FILE: | |
2627 | case DNTT_TYPE_FUNCTYPE: | |
2628 | case DNTT_TYPE_SUBRANGE: | |
2629 | case DNTT_TYPE_WITH: | |
2630 | case DNTT_TYPE_COMMON: | |
2631 | case DNTT_TYPE_COBSTRUCT: | |
2632 | case DNTT_TYPE_XREF: | |
2633 | case DNTT_TYPE_MACRO: | |
2634 | case DNTT_TYPE_CLASS_SCOPE: | |
2635 | case DNTT_TYPE_REFERENCE: | |
2636 | case DNTT_TYPE_PTRMEM: | |
2637 | case DNTT_TYPE_PTRMEMFUNC: | |
2638 | case DNTT_TYPE_CLASS: | |
2639 | case DNTT_TYPE_GENFIELD: | |
2640 | case DNTT_TYPE_VFUNC: | |
2641 | case DNTT_TYPE_MEMACCESS: | |
2642 | case DNTT_TYPE_INHERITANCE: | |
2643 | case DNTT_TYPE_FRIEND_CLASS: | |
2644 | case DNTT_TYPE_FRIEND_FUNC: | |
2645 | case DNTT_TYPE_MODIFIER: | |
2646 | case DNTT_TYPE_OBJECT_ID: | |
2647 | case DNTT_TYPE_TEMPLATE: | |
2648 | case DNTT_TYPE_TEMPLATE_ARG: | |
2649 | case DNTT_TYPE_FUNC_TEMPLATE: | |
2650 | case DNTT_TYPE_LINK: | |
2651 | /* DNTT_TYPE_DYN_ARRAY_DESC ? */ | |
2652 | /* DNTT_TYPE_DESC_SUBRANGE ? */ | |
2653 | /* DNTT_TYPE_BEGIN_EXT ? */ | |
2654 | /* DNTT_TYPE_INLN ? */ | |
2655 | /* DNTT_TYPE_INLN_LIST ? */ | |
2656 | /* DNTT_TYPE_ALIAS ? */ | |
2657 | default: | |
2658 | return 0; | |
2659 | } | |
2660 | } | |
2661 | ||
2662 | /* Do the dirty work of reading in the full symbol from a partial symbol | |
2663 | table. */ | |
2664 | ||
2665 | static void | |
2666 | hpread_psymtab_to_symtab_1 (struct partial_symtab *pst) | |
2667 | { | |
2668 | struct cleanup *old_chain; | |
2669 | int i; | |
2670 | ||
2671 | /* Get out quick if passed junk. */ | |
2672 | if (!pst) | |
2673 | return; | |
2674 | ||
2675 | /* Complain if we've already read in this symbol table. */ | |
2676 | if (pst->readin) | |
2677 | { | |
2b9848d8 PM |
2678 | fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in." |
2679 | " Shouldn't happen.\n", | |
2680 | pst->filename); | |
8af51c36 EZ |
2681 | return; |
2682 | } | |
2683 | ||
2684 | /* Read in all partial symtabs on which this one is dependent */ | |
2685 | for (i = 0; i < pst->number_of_dependencies; i++) | |
2686 | if (!pst->dependencies[i]->readin) | |
2687 | { | |
2688 | /* Inform about additional files that need to be read in. */ | |
2689 | if (info_verbose) | |
2690 | { | |
2691 | fputs_filtered (" ", gdb_stdout); | |
2692 | wrap_here (""); | |
2693 | fputs_filtered ("and ", gdb_stdout); | |
2694 | wrap_here (""); | |
2695 | printf_filtered ("%s...", pst->dependencies[i]->filename); | |
2696 | wrap_here (""); /* Flush output */ | |
2697 | gdb_flush (gdb_stdout); | |
2698 | } | |
2699 | hpread_psymtab_to_symtab_1 (pst->dependencies[i]); | |
2700 | } | |
2701 | ||
2702 | /* If it's real... */ | |
2703 | if (LDSYMLEN (pst)) | |
2704 | { | |
2705 | /* Init stuff necessary for reading in symbols */ | |
2706 | buildsym_init (); | |
2707 | old_chain = make_cleanup (really_free_pendings, 0); | |
2708 | ||
2709 | pst->symtab = | |
2710 | hpread_expand_symtab (pst->objfile, LDSYMOFF (pst), LDSYMLEN (pst), | |
2711 | pst->textlow, pst->texthigh - pst->textlow, | |
2712 | pst->section_offsets, pst->filename); | |
8af51c36 EZ |
2713 | |
2714 | do_cleanups (old_chain); | |
2715 | } | |
2716 | ||
2717 | pst->readin = 1; | |
2718 | } | |
2719 | ||
2720 | /* Read in all of the symbols for a given psymtab for real. | |
2721 | Be verbose about it if the user wants that. */ | |
2722 | ||
f5479e9c | 2723 | static void |
8af51c36 EZ |
2724 | hpread_psymtab_to_symtab (struct partial_symtab *pst) |
2725 | { | |
2726 | /* Get out quick if given junk. */ | |
2727 | if (!pst) | |
2728 | return; | |
2729 | ||
2730 | /* Sanity check. */ | |
2731 | if (pst->readin) | |
2732 | { | |
2b9848d8 PM |
2733 | fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in." |
2734 | " Shouldn't happen.\n", | |
2735 | pst->filename); | |
8af51c36 EZ |
2736 | return; |
2737 | } | |
2738 | ||
2739 | /* elz: setting the flag to indicate that the code of the target | |
2740 | was compiled using an HP compiler (aCC, cc) | |
2741 | the processing_acc_compilation variable is declared in the | |
2742 | file buildsym.h, the HP_COMPILED_TARGET is defined to be equal | |
2743 | to 3 in the file tm_hppa.h */ | |
2744 | ||
2745 | processing_gcc_compilation = 0; | |
2746 | ||
2747 | if (LDSYMLEN (pst) || pst->number_of_dependencies) | |
2748 | { | |
2749 | /* Print the message now, before reading the string table, | |
2750 | to avoid disconcerting pauses. */ | |
2751 | if (info_verbose) | |
2752 | { | |
2753 | printf_filtered ("Reading in symbols for %s...", pst->filename); | |
2754 | gdb_flush (gdb_stdout); | |
2755 | } | |
2756 | ||
2757 | hpread_psymtab_to_symtab_1 (pst); | |
2758 | ||
2759 | /* Match with global symbols. This only needs to be done once, | |
2760 | after all of the symtabs and dependencies have been read in. */ | |
2761 | scan_file_globals (pst->objfile); | |
2762 | ||
2763 | /* Finish up the debug error message. */ | |
2764 | if (info_verbose) | |
2765 | printf_filtered ("done.\n"); | |
2766 | } | |
2767 | } | |
2768 | ||
2769 | /* Read in a defined section of a specific object file's symbols. | |
2770 | ||
2771 | DESC is the file descriptor for the file, positioned at the | |
2772 | beginning of the symtab | |
2773 | SYM_OFFSET is the offset within the file of | |
2774 | the beginning of the symbols we want to read | |
2775 | SYM_SIZE is the size of the symbol info to read in. | |
2776 | TEXT_OFFSET is the beginning of the text segment we are reading symbols for | |
2777 | TEXT_SIZE is the size of the text segment read in. | |
2778 | SECTION_OFFSETS are the relocation offsets which get added to each symbol. */ | |
2779 | ||
2780 | static struct symtab * | |
2781 | hpread_expand_symtab (struct objfile *objfile, int sym_offset, int sym_size, | |
2782 | CORE_ADDR text_offset, int text_size, | |
2783 | struct section_offsets *section_offsets, char *filename) | |
2784 | { | |
2785 | char *namestring; | |
2786 | union dnttentry *dn_bufp; | |
2787 | unsigned max_symnum; | |
2788 | int at_module_boundary = 0; | |
2789 | /* 1 => at end, -1 => at beginning */ | |
2790 | ||
2791 | int sym_index = sym_offset / sizeof (struct dntt_type_block); | |
2792 | ||
2793 | current_objfile = objfile; | |
2794 | subfile_stack = 0; | |
2795 | ||
2796 | last_source_file = 0; | |
2797 | ||
2798 | /* Demangling style -- if EDG style already set, don't change it, | |
2799 | as HP style causes some problems with the KAI EDG compiler */ | |
2800 | if (current_demangling_style != edg_demangling) | |
2801 | { | |
2802 | /* Otherwise, ensure that we are using HP style demangling */ | |
2803 | set_demangling_style (HP_DEMANGLING_STYLE_STRING); | |
2804 | } | |
2805 | ||
2806 | dn_bufp = hpread_get_lntt (sym_index, objfile); | |
2807 | if (!((dn_bufp->dblock.kind == (unsigned char) DNTT_TYPE_SRCFILE) || | |
2808 | (dn_bufp->dblock.kind == (unsigned char) DNTT_TYPE_MODULE))) | |
2809 | { | |
2810 | start_symtab ("globals", NULL, 0); | |
2811 | record_debugformat ("HP"); | |
2812 | } | |
2813 | ||
2814 | /* The psymtab builder (hp-psymtab-read.c) is the one that | |
2815 | * determined the "sym_size" argument (i.e. how many DNTT symbols | |
2816 | * are in this symtab), which we use to compute "max_symnum" | |
2817 | * (point in DNTT to which we read). | |
2818 | * | |
2819 | * Perhaps this should be changed so that | |
2820 | * process_one_debug_symbol() "knows" when | |
2821 | * to stop reading (based on reading from the MODULE to the matching | |
2822 | * END), and take out this reliance on a #-syms being passed in... | |
2823 | * (I'm worried about the reliability of this number). But I'll | |
2824 | * leave it as-is, for now. - RT | |
2825 | * | |
2826 | * The change above has been made. I've left the "for" loop control | |
2827 | * in to prepare for backing this out again. -JB | |
2828 | */ | |
2829 | max_symnum = sym_size / sizeof (struct dntt_type_block); | |
2830 | /* No reason to multiply on pst side and divide on sym side... FIXME */ | |
2831 | ||
2832 | /* Read in and process each debug symbol within the specified range. | |
2833 | */ | |
2834 | for (symnum = 0; | |
2835 | symnum < max_symnum; | |
2836 | symnum++) | |
2837 | { | |
2838 | QUIT; /* Allow this to be interruptable */ | |
2839 | dn_bufp = hpread_get_lntt (sym_index + symnum, objfile); | |
2840 | ||
2841 | if (dn_bufp->dblock.extension) | |
2842 | continue; | |
2843 | ||
68b8d23e JB |
2844 | /* Yow! We call set_namestring on things without names! */ |
2845 | set_namestring (dn_bufp, &namestring, objfile); | |
8af51c36 EZ |
2846 | |
2847 | hpread_process_one_debug_symbol (dn_bufp, namestring, section_offsets, | |
2848 | objfile, text_offset, text_size, | |
2849 | filename, symnum + sym_index, | |
2850 | &at_module_boundary | |
2851 | ); | |
2852 | ||
2853 | /* OLD COMMENTS: This routine is only called for psts. All psts | |
2854 | * correspond to MODULES. If we ever do lazy-reading of globals | |
2855 | * from the LNTT, then there will be a pst which ends when the | |
2856 | * LNTT ends, and not at an END MODULE entry. Then we'll have | |
2857 | * to re-visit this break. | |
2858 | ||
2859 | if( at_end_of_module ) | |
2860 | break; | |
2861 | ||
2862 | */ | |
2863 | ||
2864 | /* We no longer break out of the loop when we reach the end of a | |
2865 | module. The reason is that with CTTI, the compiler can generate | |
2866 | function symbols (for template function instantiations) which are not | |
2867 | in any module; typically they show up beyond a module's end, and | |
2868 | before the next module's start. We include them in the current | |
2869 | module. However, we still don't trust the MAX_SYMNUM value from | |
2870 | the psymtab, so we break out if we enter a new module. */ | |
2871 | ||
2872 | if (at_module_boundary == -1) | |
2873 | break; | |
2874 | } | |
2875 | ||
2876 | current_objfile = NULL; | |
f83f82bc | 2877 | deprecated_hp_som_som_object_present = 1; /* Indicate we've processed an HP SOM SOM file */ |
8af51c36 EZ |
2878 | |
2879 | return end_symtab (text_offset + text_size, objfile, SECT_OFF_TEXT (objfile)); | |
2880 | } | |
2881 | \f | |
2882 | ||
2883 | ||
2884 | ||
2885 | /* Convert basic types from HP debug format into GDB internal format. */ | |
2886 | ||
2887 | static int | |
2888 | hpread_type_translate (dnttpointer typep) | |
2889 | { | |
2890 | if (!typep.dntti.immediate) | |
2891 | { | |
8a3fe4f8 | 2892 | error (_("error in hpread_type_translate\n.")); |
8af51c36 EZ |
2893 | return FT_VOID; |
2894 | } | |
2895 | ||
2896 | switch (typep.dntti.type) | |
2897 | { | |
2898 | case HP_TYPE_BOOLEAN: | |
2899 | case HP_TYPE_BOOLEAN_S300_COMPAT: | |
2900 | case HP_TYPE_BOOLEAN_VAX_COMPAT: | |
2901 | return FT_BOOLEAN; | |
2902 | case HP_TYPE_CHAR: /* C signed char, C++ plain char */ | |
2903 | ||
2904 | case HP_TYPE_WIDE_CHAR: | |
2905 | return FT_CHAR; | |
2906 | case HP_TYPE_INT: | |
2907 | if (typep.dntti.bitlength <= 8) | |
2908 | return FT_SIGNED_CHAR; /* C++ signed char */ | |
2909 | if (typep.dntti.bitlength <= 16) | |
2910 | return FT_SHORT; | |
2911 | if (typep.dntti.bitlength <= 32) | |
2912 | return FT_INTEGER; | |
2913 | return FT_LONG_LONG; | |
2914 | case HP_TYPE_LONG: | |
2915 | if (typep.dntti.bitlength <= 8) | |
2916 | return FT_SIGNED_CHAR; /* C++ signed char. */ | |
2917 | return FT_LONG; | |
2918 | case HP_TYPE_UNSIGNED_LONG: | |
2919 | if (typep.dntti.bitlength <= 8) | |
2920 | return FT_UNSIGNED_CHAR; /* C/C++ unsigned char */ | |
2921 | if (typep.dntti.bitlength <= 16) | |
2922 | return FT_UNSIGNED_SHORT; | |
2923 | if (typep.dntti.bitlength <= 32) | |
2924 | return FT_UNSIGNED_LONG; | |
2925 | return FT_UNSIGNED_LONG_LONG; | |
2926 | case HP_TYPE_UNSIGNED_INT: | |
2927 | if (typep.dntti.bitlength <= 8) | |
2928 | return FT_UNSIGNED_CHAR; | |
2929 | if (typep.dntti.bitlength <= 16) | |
2930 | return FT_UNSIGNED_SHORT; | |
2931 | if (typep.dntti.bitlength <= 32) | |
2932 | return FT_UNSIGNED_INTEGER; | |
2933 | return FT_UNSIGNED_LONG_LONG; | |
2934 | case HP_TYPE_REAL: | |
2935 | case HP_TYPE_REAL_3000: | |
2936 | case HP_TYPE_DOUBLE: | |
2937 | if (typep.dntti.bitlength == 64) | |
2938 | return FT_DBL_PREC_FLOAT; | |
2939 | if (typep.dntti.bitlength == 128) | |
2940 | return FT_EXT_PREC_FLOAT; | |
2941 | return FT_FLOAT; | |
2942 | case HP_TYPE_COMPLEX: | |
2943 | case HP_TYPE_COMPLEXS3000: | |
2944 | if (typep.dntti.bitlength == 128) | |
2945 | return FT_DBL_PREC_COMPLEX; | |
2946 | if (typep.dntti.bitlength == 192) | |
2947 | return FT_EXT_PREC_COMPLEX; | |
2948 | return FT_COMPLEX; | |
2949 | case HP_TYPE_VOID: | |
2950 | return FT_VOID; | |
2951 | case HP_TYPE_STRING200: | |
2952 | case HP_TYPE_LONGSTRING200: | |
2953 | case HP_TYPE_FTN_STRING_SPEC: | |
2954 | case HP_TYPE_MOD_STRING_SPEC: | |
2955 | case HP_TYPE_MOD_STRING_3000: | |
2956 | case HP_TYPE_FTN_STRING_S300_COMPAT: | |
2957 | case HP_TYPE_FTN_STRING_VAX_COMPAT: | |
2958 | return FT_STRING; | |
2959 | case HP_TYPE_TEMPLATE_ARG: | |
2960 | return FT_TEMPLATE_ARG; | |
2961 | case HP_TYPE_TEXT: | |
2962 | case HP_TYPE_FLABEL: | |
2963 | case HP_TYPE_PACKED_DECIMAL: | |
2964 | case HP_TYPE_ANYPOINTER: | |
2965 | case HP_TYPE_GLOBAL_ANYPOINTER: | |
2966 | case HP_TYPE_LOCAL_ANYPOINTER: | |
2967 | default: | |
8a3fe4f8 | 2968 | warning (_("hpread_type_translate: unhandled type code.")); |
8af51c36 EZ |
2969 | return FT_VOID; |
2970 | } | |
2971 | } | |
2972 | ||
2973 | /* Given a position in the DNTT, return a pointer to the | |
2974 | * already-built "struct type" (if any), for the type defined | |
2975 | * at that position. | |
2976 | */ | |
2977 | ||
2978 | static struct type ** | |
2979 | hpread_lookup_type (dnttpointer hp_type, struct objfile *objfile) | |
2980 | { | |
2981 | unsigned old_len; | |
2982 | int index = hp_type.dnttp.index; | |
2983 | int size_changed = 0; | |
2984 | ||
2985 | /* The immediate flag indicates this doesn't actually point to | |
2986 | * a type DNTT. | |
2987 | */ | |
2988 | if (hp_type.dntti.immediate) | |
2989 | return NULL; | |
2990 | ||
2991 | /* For each objfile, we maintain a "type vector". | |
2992 | * This an array of "struct type *"'s with one pointer per DNTT index. | |
2993 | * Given a DNTT index, we look in this array to see if we have | |
2994 | * already processed this DNTT and if it is a type definition. | |
2995 | * If so, then we can locate a pointer to the already-built | |
2996 | * "struct type", and not build it again. | |
2997 | * | |
2998 | * The need for this arises because our DNTT-walking code wanders | |
2999 | * around. In particular, it will encounter the same type multiple | |
3000 | * times (once for each object of that type). We don't want to | |
3001 | * built multiple "struct type"'s for the same thing. | |
3002 | * | |
3003 | * Having said this, I should point out that this type-vector is | |
3004 | * an expensive way to keep track of this. If most DNTT entries are | |
3005 | * 3 words, the type-vector will be 1/3 the size of the DNTT itself. | |
3006 | * Alternative solutions: | |
3007 | * - Keep a compressed or hashed table. Less memory, but more expensive | |
3008 | * to search and update. | |
3009 | * - (Suggested by JB): Overwrite the DNTT entry itself | |
3010 | * with the info. Create a new type code "ALREADY_BUILT", and modify | |
3011 | * the DNTT to have that type code and point to the already-built entry. | |
3012 | * -RT | |
3013 | */ | |
3014 | ||
3015 | if (index < LNTT_SYMCOUNT (objfile)) | |
3016 | { | |
9a6f53fe | 3017 | if (index >= DNTT_TYPE_VECTOR_LENGTH (objfile)) |
8af51c36 | 3018 | { |
9a6f53fe | 3019 | old_len = DNTT_TYPE_VECTOR_LENGTH (objfile); |
8af51c36 EZ |
3020 | |
3021 | /* See if we need to allocate a type-vector. */ | |
3022 | if (old_len == 0) | |
3023 | { | |
9a6f53fe EZ |
3024 | DNTT_TYPE_VECTOR_LENGTH (objfile) = LNTT_SYMCOUNT (objfile) + GNTT_SYMCOUNT (objfile); |
3025 | DNTT_TYPE_VECTOR (objfile) = (struct type **) | |
7936743b | 3026 | xmalloc (DNTT_TYPE_VECTOR_LENGTH (objfile) * sizeof (struct type *)); |
9a6f53fe EZ |
3027 | memset (&DNTT_TYPE_VECTOR (objfile)[old_len], 0, |
3028 | (DNTT_TYPE_VECTOR_LENGTH (objfile) - old_len) * | |
8af51c36 EZ |
3029 | sizeof (struct type *)); |
3030 | } | |
3031 | ||
3032 | /* See if we need to resize type-vector. With my change to | |
3033 | * initially allocate a correct-size type-vector, this code | |
3034 | * should no longer trigger. | |
3035 | */ | |
9a6f53fe | 3036 | while (index >= DNTT_TYPE_VECTOR_LENGTH (objfile)) |
8af51c36 | 3037 | { |
9a6f53fe | 3038 | DNTT_TYPE_VECTOR_LENGTH (objfile) *= 2; |
8af51c36 EZ |
3039 | size_changed = 1; |
3040 | } | |
3041 | if (size_changed) | |
3042 | { | |
9a6f53fe | 3043 | DNTT_TYPE_VECTOR (objfile) = (struct type **) |
0efffb96 | 3044 | xrealloc ((char *) DNTT_TYPE_VECTOR (objfile), |
9a6f53fe | 3045 | (DNTT_TYPE_VECTOR_LENGTH (objfile) * sizeof (struct type *))); |
8af51c36 | 3046 | |
9a6f53fe EZ |
3047 | memset (&DNTT_TYPE_VECTOR (objfile)[old_len], 0, |
3048 | (DNTT_TYPE_VECTOR_LENGTH (objfile) - old_len) * | |
8af51c36 EZ |
3049 | sizeof (struct type *)); |
3050 | } | |
3051 | ||
3052 | } | |
9a6f53fe | 3053 | return &DNTT_TYPE_VECTOR (objfile)[index]; |
8af51c36 EZ |
3054 | } |
3055 | else | |
3056 | return NULL; | |
3057 | } | |
3058 | ||
3059 | /* Possibly allocate a GDB internal type so we can internalize HP_TYPE. | |
3060 | Note we'll just return the address of a GDB internal type if we already | |
3061 | have it lying around. */ | |
3062 | ||
3063 | static struct type * | |
3064 | hpread_alloc_type (dnttpointer hp_type, struct objfile *objfile) | |
3065 | { | |
3066 | struct type **type_addr; | |
3067 | ||
3068 | type_addr = hpread_lookup_type (hp_type, objfile); | |
3069 | if (*type_addr == 0) | |
3070 | { | |
3071 | *type_addr = alloc_type (objfile); | |
3072 | ||
3073 | /* A hack - if we really are a C++ class symbol, then this default | |
3074 | * will get overriden later on. | |
3075 | */ | |
3076 | TYPE_CPLUS_SPECIFIC (*type_addr) | |
3077 | = (struct cplus_struct_type *) &cplus_struct_default; | |
3078 | } | |
3079 | ||
3080 | return *type_addr; | |
3081 | } | |
3082 | ||
3083 | /* Read a native enumerated type and return it in GDB internal form. */ | |
3084 | ||
3085 | static struct type * | |
3086 | hpread_read_enum_type (dnttpointer hp_type, union dnttentry *dn_bufp, | |
3087 | struct objfile *objfile) | |
3088 | { | |
3089 | struct type *type; | |
3090 | struct pending **symlist, *osyms, *syms; | |
3091 | struct pending *local_list = NULL; | |
3092 | int o_nsyms, nsyms = 0; | |
3093 | dnttpointer mem; | |
3094 | union dnttentry *memp; | |
3095 | char *name; | |
3096 | long n; | |
3097 | struct symbol *sym; | |
3098 | ||
3099 | /* Allocate a GDB type. If we've already read in this enum type, | |
3100 | * it'll return the already built GDB type, so stop here. | |
3101 | * (Note: I added this check, to conform with what's done for | |
3102 | * struct, union, class. | |
3103 | * I assume this is OK. - RT) | |
3104 | */ | |
3105 | type = hpread_alloc_type (hp_type, objfile); | |
3106 | if (TYPE_CODE (type) == TYPE_CODE_ENUM) | |
3107 | return type; | |
3108 | ||
3109 | /* HP C supports "sized enums", where a specifier such as "short" or | |
3110 | "char" can be used to get enums of different sizes. So don't assume | |
3111 | an enum is always 4 bytes long. pai/1997-08-21 */ | |
3112 | TYPE_LENGTH (type) = dn_bufp->denum.bitlength / 8; | |
3113 | ||
3114 | symlist = &file_symbols; | |
3115 | osyms = *symlist; | |
c906108c SS |
3116 | o_nsyms = osyms ? osyms->nsyms : 0; |
3117 | ||
8af51c36 EZ |
3118 | /* Get a name for each member and add it to our list of members. |
3119 | * The list of "mem" SOM records we are walking should all be | |
3120 | * SOM type DNTT_TYPE_MEMENUM (not checked). | |
3121 | */ | |
c906108c | 3122 | mem = dn_bufp->denum.firstmem; |
8af51c36 | 3123 | while (mem.word && mem.word != DNTTNIL) |
c906108c SS |
3124 | { |
3125 | memp = hpread_get_lntt (mem.dnttp.index, objfile); | |
3126 | ||
3127 | name = VT (objfile) + memp->dmember.name; | |
4a146b47 | 3128 | sym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack, |
c906108c SS |
3129 | sizeof (struct symbol)); |
3130 | memset (sym, 0, sizeof (struct symbol)); | |
22abf04a | 3131 | DEPRECATED_SYMBOL_NAME (sym) = obsavestring (name, strlen (name), |
4a146b47 | 3132 | &objfile->objfile_obstack); |
c906108c | 3133 | SYMBOL_CLASS (sym) = LOC_CONST; |
176620f1 | 3134 | SYMBOL_DOMAIN (sym) = VAR_DOMAIN; |
c906108c SS |
3135 | SYMBOL_VALUE (sym) = memp->dmember.value; |
3136 | add_symbol_to_list (sym, symlist); | |
3137 | nsyms++; | |
3138 | mem = memp->dmember.nextmem; | |
3139 | } | |
3140 | ||
3141 | /* Now that we know more about the enum, fill in more info. */ | |
3142 | TYPE_CODE (type) = TYPE_CODE_ENUM; | |
3143 | TYPE_FLAGS (type) &= ~TYPE_FLAG_STUB; | |
3144 | TYPE_NFIELDS (type) = nsyms; | |
3145 | TYPE_FIELDS (type) = (struct field *) | |
b99607ea | 3146 | obstack_alloc (&objfile->objfile_obstack, sizeof (struct field) * nsyms); |
c906108c SS |
3147 | |
3148 | /* Find the symbols for the members and put them into the type. | |
3149 | The symbols can be found in the symlist that we put them on | |
3150 | to cause them to be defined. osyms contains the old value | |
3151 | of that symlist; everything up to there was defined by us. | |
3152 | ||
3153 | Note that we preserve the order of the enum constants, so | |
3154 | that in something like "enum {FOO, LAST_THING=FOO}" we print | |
3155 | FOO, not LAST_THING. */ | |
3156 | for (syms = *symlist, n = 0; syms; syms = syms->next) | |
3157 | { | |
3158 | int j = 0; | |
3159 | if (syms == osyms) | |
3160 | j = o_nsyms; | |
3161 | for (; j < syms->nsyms; j++, n++) | |
3162 | { | |
3163 | struct symbol *xsym = syms->symbol[j]; | |
3164 | SYMBOL_TYPE (xsym) = type; | |
22abf04a | 3165 | TYPE_FIELD_NAME (type, n) = DEPRECATED_SYMBOL_NAME (xsym); |
c906108c SS |
3166 | TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym); |
3167 | TYPE_FIELD_BITSIZE (type, n) = 0; | |
01ad7f36 | 3168 | TYPE_FIELD_STATIC_KIND (type, n) = 0; |
c906108c | 3169 | } |
8af51c36 EZ |
3170 | if (syms == osyms) |
3171 | break; | |
3172 | } | |
3173 | ||
3174 | return type; | |
3175 | } | |
3176 | ||
3177 | /* Read and internalize a native function debug symbol. */ | |
3178 | ||
3179 | static struct type * | |
3180 | hpread_read_function_type (dnttpointer hp_type, union dnttentry *dn_bufp, | |
3181 | struct objfile *objfile, int newblock) | |
3182 | { | |
3183 | struct type *type, *type1; | |
3184 | struct pending *syms; | |
3185 | struct pending *local_list = NULL; | |
3186 | int nsyms = 0; | |
3187 | dnttpointer param; | |
3188 | union dnttentry *paramp; | |
3189 | char *name; | |
3190 | long n; | |
3191 | struct symbol *sym; | |
3192 | int record_args = 1; | |
3193 | ||
3194 | /* See if we've already read in this type. */ | |
3195 | type = hpread_alloc_type (hp_type, objfile); | |
3196 | if (TYPE_CODE (type) == TYPE_CODE_FUNC) | |
3197 | { | |
3198 | record_args = 0; /* already read in, don't modify type */ | |
3199 | } | |
3200 | else | |
3201 | { | |
3202 | /* Nope, so read it in and store it away. */ | |
3203 | if (dn_bufp->dblock.kind == DNTT_TYPE_FUNCTION || | |
3204 | dn_bufp->dblock.kind == DNTT_TYPE_MEMFUNC) | |
3205 | type1 = lookup_function_type (hpread_type_lookup (dn_bufp->dfunc.retval, | |
3206 | objfile)); | |
3207 | else if (dn_bufp->dblock.kind == DNTT_TYPE_FUNCTYPE) | |
3208 | type1 = lookup_function_type (hpread_type_lookup (dn_bufp->dfunctype.retval, | |
3209 | objfile)); | |
3210 | else /* expect DNTT_TYPE_FUNC_TEMPLATE */ | |
3211 | type1 = lookup_function_type (hpread_type_lookup (dn_bufp->dfunc_template.retval, | |
3212 | objfile)); | |
0004e5a2 | 3213 | replace_type (type, type1); |
8af51c36 EZ |
3214 | |
3215 | /* Mark it -- in the middle of processing */ | |
3216 | TYPE_FLAGS (type) |= TYPE_FLAG_INCOMPLETE; | |
3217 | } | |
3218 | ||
3219 | /* Now examine each parameter noting its type, location, and a | |
3220 | wealth of other information. */ | |
3221 | if (dn_bufp->dblock.kind == DNTT_TYPE_FUNCTION || | |
3222 | dn_bufp->dblock.kind == DNTT_TYPE_MEMFUNC) | |
3223 | param = dn_bufp->dfunc.firstparam; | |
3224 | else if (dn_bufp->dblock.kind == DNTT_TYPE_FUNCTYPE) | |
3225 | param = dn_bufp->dfunctype.firstparam; | |
3226 | else /* expect DNTT_TYPE_FUNC_TEMPLATE */ | |
3227 | param = dn_bufp->dfunc_template.firstparam; | |
3228 | while (param.word && param.word != DNTTNIL) | |
3229 | { | |
3230 | paramp = hpread_get_lntt (param.dnttp.index, objfile); | |
3231 | nsyms++; | |
3232 | param = paramp->dfparam.nextparam; | |
3233 | ||
3234 | /* Get the name. */ | |
3235 | name = VT (objfile) + paramp->dfparam.name; | |
4a146b47 | 3236 | sym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack, |
8af51c36 EZ |
3237 | sizeof (struct symbol)); |
3238 | (void) memset (sym, 0, sizeof (struct symbol)); | |
22abf04a | 3239 | DEPRECATED_SYMBOL_NAME (sym) = obsavestring (name, strlen (name), |
4a146b47 | 3240 | &objfile->objfile_obstack); |
8af51c36 EZ |
3241 | |
3242 | /* Figure out where it lives. */ | |
3243 | if (paramp->dfparam.regparam) | |
3244 | SYMBOL_CLASS (sym) = LOC_REGPARM; | |
3245 | else if (paramp->dfparam.indirect) | |
3246 | SYMBOL_CLASS (sym) = LOC_REF_ARG; | |
3247 | else | |
3248 | SYMBOL_CLASS (sym) = LOC_ARG; | |
176620f1 | 3249 | SYMBOL_DOMAIN (sym) = VAR_DOMAIN; |
8af51c36 EZ |
3250 | if (paramp->dfparam.copyparam) |
3251 | { | |
3252 | SYMBOL_VALUE (sym) = paramp->dfparam.location; | |
8af51c36 | 3253 | SYMBOL_VALUE (sym) |
7c46b9fb RC |
3254 | += hpread_adjust_stack_address (CURRENT_FUNCTION_VALUE (objfile)); |
3255 | ||
8af51c36 EZ |
3256 | /* This is likely a pass-by-invisible reference parameter, |
3257 | Hack on the symbol class to make GDB happy. */ | |
3258 | /* ??rehrauer: This appears to be broken w/r/t to passing | |
3259 | C values of type float and struct. Perhaps this ought | |
3260 | to be highighted as a special case, but for now, just | |
3261 | allowing these to be LOC_ARGs seems to work fine. | |
3262 | */ | |
3263 | #if 0 | |
3264 | SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR; | |
3265 | #endif | |
3266 | } | |
3267 | else | |
3268 | SYMBOL_VALUE (sym) = paramp->dfparam.location; | |
3269 | ||
3270 | /* Get its type. */ | |
3271 | SYMBOL_TYPE (sym) = hpread_type_lookup (paramp->dfparam.type, objfile); | |
3272 | /* Add it to the symbol list. */ | |
3273 | /* Note 1 (RT) At the moment, add_symbol_to_list() is also being | |
3274 | * called on FPARAM symbols from the process_one_debug_symbol() | |
3275 | * level... so parameters are getting added twice! (this shows | |
3276 | * up in the symbol dump you get from "maint print symbols ..."). | |
3277 | * Note 2 (RT) I took out the processing of FPARAM from the | |
3278 | * process_one_debug_symbol() level, so at the moment parameters are only | |
3279 | * being processed here. This seems to have no ill effect. | |
3280 | */ | |
3281 | /* Note 3 (pai/1997-08-11) I removed the add_symbol_to_list() which put | |
3282 | each fparam on the local_symbols list from here. Now we use the | |
3283 | local_list to which fparams are added below, and set the param_symbols | |
3284 | global to point to that at the end of this routine. */ | |
3285 | /* elz: I added this new list of symbols which is local to the function. | |
3286 | this list is the one which is actually used to build the type for the | |
3287 | function rather than the gloabal list pointed to by symlist. | |
3288 | Using a global list to keep track of the parameters is wrong, because | |
3289 | this function is called recursively if one parameter happend to be | |
3290 | a function itself with more parameters in it. Adding parameters to the | |
3291 | same global symbol list would not work! | |
3292 | Actually it did work in case of cc compiled programs where you do | |
3293 | not check the parameter lists of the arguments. */ | |
3294 | add_symbol_to_list (sym, &local_list); | |
3295 | ||
3296 | } | |
3297 | ||
3298 | /* If type was read in earlier, don't bother with modifying | |
3299 | the type struct */ | |
3300 | if (!record_args) | |
3301 | goto finish; | |
3302 | ||
3303 | /* Note how many parameters we found. */ | |
3304 | TYPE_NFIELDS (type) = nsyms; | |
3305 | TYPE_FIELDS (type) = (struct field *) | |
b99607ea | 3306 | obstack_alloc (&objfile->objfile_obstack, |
8af51c36 EZ |
3307 | sizeof (struct field) * nsyms); |
3308 | ||
3309 | /* Find the symbols for the parameters and | |
3310 | use them to fill parameter-type information into the function-type. | |
3311 | The parameter symbols can be found in the local_list that we just put them on. */ | |
3312 | /* Note that we preserve the order of the parameters, so | |
3313 | that in something like "enum {FOO, LAST_THING=FOO}" we print | |
3314 | FOO, not LAST_THING. */ | |
3315 | ||
3316 | /* get the parameters types from the local list not the global list | |
3317 | so that the type can be correctly constructed for functions which | |
3318 | have function as parameters */ | |
3319 | for (syms = local_list, n = 0; syms; syms = syms->next) | |
3320 | { | |
3321 | int j = 0; | |
3322 | for (j = 0; j < syms->nsyms; j++, n++) | |
3323 | { | |
3324 | struct symbol *xsym = syms->symbol[j]; | |
22abf04a | 3325 | TYPE_FIELD_NAME (type, n) = DEPRECATED_SYMBOL_NAME (xsym); |
8af51c36 EZ |
3326 | TYPE_FIELD_TYPE (type, n) = SYMBOL_TYPE (xsym); |
3327 | TYPE_FIELD_ARTIFICIAL (type, n) = 0; | |
3328 | TYPE_FIELD_BITSIZE (type, n) = 0; | |
01ad7f36 | 3329 | TYPE_FIELD_STATIC_KIND (type, n) = 0; |
8af51c36 EZ |
3330 | } |
3331 | } | |
3332 | /* Mark it as having been processed */ | |
3333 | TYPE_FLAGS (type) &= ~(TYPE_FLAG_INCOMPLETE); | |
3334 | ||
3335 | /* Check whether we need to fix-up a class type with this function's type */ | |
3336 | if (fixup_class && (fixup_method == type)) | |
3337 | { | |
3338 | fixup_class_method_type (fixup_class, fixup_method, objfile); | |
3339 | fixup_class = NULL; | |
3340 | fixup_method = NULL; | |
c906108c SS |
3341 | } |
3342 | ||
8af51c36 EZ |
3343 | /* Set the param list of this level of the context stack |
3344 | to our local list. Do this only if this function was | |
3345 | called for creating a new block, and not if it was called | |
3346 | simply to get the function type. This prevents recursive | |
3347 | invocations from trashing param_symbols. */ | |
3348 | finish: | |
3349 | if (newblock) | |
3350 | param_symbols = local_list; | |
3351 | ||
c906108c SS |
3352 | return type; |
3353 | } | |
3354 | ||
c906108c | 3355 | |
8af51c36 EZ |
3356 | /* Read and internalize a native DOC function debug symbol. */ |
3357 | /* This is almost identical to hpread_read_function_type(), except | |
3358 | * for references to dn_bufp->ddocfunc instead of db_bufp->dfunc. | |
3359 | * Since debug information for DOC functions is more likely to be | |
3360 | * volatile, please leave it this way. | |
3361 | */ | |
c906108c | 3362 | static struct type * |
8af51c36 EZ |
3363 | hpread_read_doc_function_type (dnttpointer hp_type, union dnttentry *dn_bufp, |
3364 | struct objfile *objfile, int newblock) | |
c906108c | 3365 | { |
8af51c36 EZ |
3366 | struct pending *syms; |
3367 | struct pending *local_list = NULL; | |
3368 | int nsyms = 0; | |
65e82032 | 3369 | struct type *type; |
c906108c SS |
3370 | dnttpointer param; |
3371 | union dnttentry *paramp; | |
3372 | char *name; | |
3373 | long n; | |
3374 | struct symbol *sym; | |
8af51c36 | 3375 | int record_args = 1; |
c906108c SS |
3376 | |
3377 | /* See if we've already read in this type. */ | |
3378 | type = hpread_alloc_type (hp_type, objfile); | |
3379 | if (TYPE_CODE (type) == TYPE_CODE_FUNC) | |
8af51c36 EZ |
3380 | { |
3381 | record_args = 0; /* already read in, don't modify type */ | |
3382 | } | |
3383 | else | |
3384 | { | |
65e82032 | 3385 | struct type *type1 = NULL; |
8af51c36 EZ |
3386 | /* Nope, so read it in and store it away. */ |
3387 | if (dn_bufp->dblock.kind == DNTT_TYPE_DOC_FUNCTION || | |
3388 | dn_bufp->dblock.kind == DNTT_TYPE_DOC_MEMFUNC) | |
3389 | type1 = lookup_function_type (hpread_type_lookup (dn_bufp->ddocfunc.retval, | |
3390 | objfile)); | |
65e82032 AC |
3391 | /* NOTE: cagney/2003-03-29: Oh, no not again. TYPE1 is |
3392 | potentially left undefined here. Assert it isn't and hope | |
3393 | the assert never fails ... */ | |
3394 | gdb_assert (type1 != NULL); | |
3395 | ||
0004e5a2 | 3396 | replace_type (type, type1); |
8af51c36 EZ |
3397 | |
3398 | /* Mark it -- in the middle of processing */ | |
3399 | TYPE_FLAGS (type) |= TYPE_FLAG_INCOMPLETE; | |
3400 | } | |
c906108c SS |
3401 | |
3402 | /* Now examine each parameter noting its type, location, and a | |
3403 | wealth of other information. */ | |
8af51c36 EZ |
3404 | if (dn_bufp->dblock.kind == DNTT_TYPE_DOC_FUNCTION || |
3405 | dn_bufp->dblock.kind == DNTT_TYPE_DOC_MEMFUNC) | |
3406 | param = dn_bufp->ddocfunc.firstparam; | |
c906108c SS |
3407 | while (param.word && param.word != DNTTNIL) |
3408 | { | |
3409 | paramp = hpread_get_lntt (param.dnttp.index, objfile); | |
3410 | nsyms++; | |
3411 | param = paramp->dfparam.nextparam; | |
3412 | ||
3413 | /* Get the name. */ | |
3414 | name = VT (objfile) + paramp->dfparam.name; | |
4a146b47 | 3415 | sym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack, |
c906108c SS |
3416 | sizeof (struct symbol)); |
3417 | (void) memset (sym, 0, sizeof (struct symbol)); | |
22abf04a | 3418 | DEPRECATED_SYMBOL_NAME (sym) = name; |
8af51c36 EZ |
3419 | |
3420 | /* Figure out where it lives. */ | |
3421 | if (paramp->dfparam.regparam) | |
3422 | SYMBOL_CLASS (sym) = LOC_REGPARM; | |
3423 | else if (paramp->dfparam.indirect) | |
3424 | SYMBOL_CLASS (sym) = LOC_REF_ARG; | |
3425 | else | |
3426 | SYMBOL_CLASS (sym) = LOC_ARG; | |
176620f1 | 3427 | SYMBOL_DOMAIN (sym) = VAR_DOMAIN; |
8af51c36 EZ |
3428 | if (paramp->dfparam.copyparam) |
3429 | { | |
3430 | SYMBOL_VALUE (sym) = paramp->dfparam.location; | |
8af51c36 | 3431 | SYMBOL_VALUE (sym) |
7c46b9fb RC |
3432 | += hpread_adjust_stack_address(CURRENT_FUNCTION_VALUE (objfile)); |
3433 | ||
8af51c36 EZ |
3434 | /* This is likely a pass-by-invisible reference parameter, |
3435 | Hack on the symbol class to make GDB happy. */ | |
3436 | /* ??rehrauer: This appears to be broken w/r/t to passing | |
3437 | C values of type float and struct. Perhaps this ought | |
3438 | to be highighted as a special case, but for now, just | |
3439 | allowing these to be LOC_ARGs seems to work fine. | |
3440 | */ | |
3441 | #if 0 | |
3442 | SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR; | |
3443 | #endif | |
3444 | } | |
3445 | else | |
3446 | SYMBOL_VALUE (sym) = paramp->dfparam.location; | |
3447 | ||
3448 | /* Get its type. */ | |
3449 | SYMBOL_TYPE (sym) = hpread_type_lookup (paramp->dfparam.type, objfile); | |
3450 | /* Add it to the symbol list. */ | |
3451 | /* Note 1 (RT) At the moment, add_symbol_to_list() is also being | |
3452 | * called on FPARAM symbols from the process_one_debug_symbol() | |
3453 | * level... so parameters are getting added twice! (this shows | |
3454 | * up in the symbol dump you get from "maint print symbols ..."). | |
3455 | * Note 2 (RT) I took out the processing of FPARAM from the | |
3456 | * process_one_debug_symbol() level, so at the moment parameters are only | |
3457 | * being processed here. This seems to have no ill effect. | |
3458 | */ | |
3459 | /* Note 3 (pai/1997-08-11) I removed the add_symbol_to_list() which put | |
3460 | each fparam on the local_symbols list from here. Now we use the | |
3461 | local_list to which fparams are added below, and set the param_symbols | |
3462 | global to point to that at the end of this routine. */ | |
3463 | ||
3464 | /* elz: I added this new list of symbols which is local to the function. | |
3465 | this list is the one which is actually used to build the type for the | |
3466 | function rather than the gloabal list pointed to by symlist. | |
3467 | Using a global list to keep track of the parameters is wrong, because | |
3468 | this function is called recursively if one parameter happend to be | |
3469 | a function itself with more parameters in it. Adding parameters to the | |
3470 | same global symbol list would not work! | |
3471 | Actually it did work in case of cc compiled programs where you do not check the | |
3472 | parameter lists of the arguments. */ | |
3473 | add_symbol_to_list (sym, &local_list); | |
3474 | } | |
3475 | ||
3476 | /* If type was read in earlier, don't bother with modifying | |
3477 | the type struct */ | |
3478 | if (!record_args) | |
3479 | goto finish; | |
3480 | ||
3481 | /* Note how many parameters we found. */ | |
3482 | TYPE_NFIELDS (type) = nsyms; | |
3483 | TYPE_FIELDS (type) = (struct field *) | |
b99607ea | 3484 | obstack_alloc (&objfile->objfile_obstack, |
8af51c36 EZ |
3485 | sizeof (struct field) * nsyms); |
3486 | ||
3487 | /* Find the symbols for the parameters and | |
3488 | use them to fill parameter-type information into the function-type. | |
3489 | The parameter symbols can be found in the local_list that we just put them on. */ | |
3490 | /* Note that we preserve the order of the parameters, so | |
3491 | that in something like "enum {FOO, LAST_THING=FOO}" we print | |
3492 | FOO, not LAST_THING. */ | |
3493 | ||
3494 | /* get the parameters types from the local list not the global list | |
3495 | so that the type can be correctly constructed for functions which | |
3496 | have function as parameters | |
3497 | */ | |
3498 | for (syms = local_list, n = 0; syms; syms = syms->next) | |
3499 | { | |
3500 | int j = 0; | |
3501 | for (j = 0; j < syms->nsyms; j++, n++) | |
3502 | { | |
3503 | struct symbol *xsym = syms->symbol[j]; | |
22abf04a | 3504 | TYPE_FIELD_NAME (type, n) = DEPRECATED_SYMBOL_NAME (xsym); |
8af51c36 EZ |
3505 | TYPE_FIELD_TYPE (type, n) = SYMBOL_TYPE (xsym); |
3506 | TYPE_FIELD_ARTIFICIAL (type, n) = 0; | |
3507 | TYPE_FIELD_BITSIZE (type, n) = 0; | |
01ad7f36 | 3508 | TYPE_FIELD_STATIC_KIND (type, n) = 0; |
8af51c36 EZ |
3509 | } |
3510 | } | |
3511 | ||
3512 | /* Mark it as having been processed */ | |
3513 | TYPE_FLAGS (type) &= ~(TYPE_FLAG_INCOMPLETE); | |
3514 | ||
3515 | /* Check whether we need to fix-up a class type with this function's type */ | |
3516 | if (fixup_class && (fixup_method == type)) | |
3517 | { | |
3518 | fixup_class_method_type (fixup_class, fixup_method, objfile); | |
3519 | fixup_class = NULL; | |
3520 | fixup_method = NULL; | |
3521 | } | |
3522 | ||
3523 | /* Set the param list of this level of the context stack | |
3524 | to our local list. Do this only if this function was | |
3525 | called for creating a new block, and not if it was called | |
3526 | simply to get the function type. This prevents recursive | |
3527 | invocations from trashing param_symbols. */ | |
3528 | finish: | |
3529 | if (newblock) | |
3530 | param_symbols = local_list; | |
3531 | ||
3532 | return type; | |
3533 | } | |
3534 | ||
3535 | ||
3536 | ||
3537 | /* A file-level variable which keeps track of the current-template | |
3538 | * being processed. Set in hpread_read_struct_type() while processing | |
3539 | * a template type. Referred to in hpread_get_nth_templ_arg(). | |
3540 | * Yes, this is a kludge, but it arises from the kludge that already | |
3541 | * exists in symtab.h, namely the fact that they encode | |
3542 | * "template argument n" with fundamental type FT_TEMPLATE_ARG and | |
3543 | * bitlength n. This means that deep in processing fundamental types | |
3544 | * I need to ask the question "what template am I in the middle of?". | |
3545 | * The alternative to stuffing a global would be to pass an argument | |
3546 | * down the chain of calls just for this purpose. | |
3547 | * | |
3548 | * There may be problems handling nested templates... tough. | |
3549 | */ | |
3550 | static struct type *current_template = NULL; | |
3551 | ||
3552 | /* Read in and internalize a structure definition. | |
3553 | * This same routine is called for struct, union, and class types. | |
3554 | * Also called for templates, since they build a very similar | |
3555 | * type entry as for class types. | |
3556 | */ | |
3557 | ||
3558 | static struct type * | |
3559 | hpread_read_struct_type (dnttpointer hp_type, union dnttentry *dn_bufp, | |
3560 | struct objfile *objfile) | |
3561 | { | |
3562 | /* The data members get linked together into a list of struct nextfield's */ | |
3563 | struct nextfield | |
3564 | { | |
3565 | struct nextfield *next; | |
3566 | struct field field; | |
3567 | unsigned char attributes; /* store visibility and virtuality info */ | |
3568 | #define ATTR_VIRTUAL 1 | |
3569 | #define ATTR_PRIVATE 2 | |
3570 | #define ATTR_PROTECT 3 | |
3571 | }; | |
3572 | ||
3573 | ||
3574 | /* The methods get linked together into a list of struct next_fn_field's */ | |
3575 | struct next_fn_field | |
3576 | { | |
3577 | struct next_fn_field *next; | |
3578 | struct fn_fieldlist field; | |
3579 | struct fn_field fn_field; | |
3580 | int num_fn_fields; | |
3581 | }; | |
3582 | ||
3583 | /* The template args get linked together into a list of struct next_template's */ | |
3584 | struct next_template | |
3585 | { | |
3586 | struct next_template *next; | |
3587 | struct template_arg arg; | |
3588 | }; | |
3589 | ||
3590 | /* The template instantiations get linked together into a list of these... */ | |
3591 | struct next_instantiation | |
3592 | { | |
3593 | struct next_instantiation *next; | |
3594 | struct type *t; | |
3595 | }; | |
3596 | ||
3597 | struct type *type; | |
3598 | struct type *baseclass; | |
3599 | struct type *memtype; | |
3600 | struct nextfield *list = 0, *tmp_list = 0; | |
3601 | struct next_fn_field *fn_list = 0; | |
3602 | struct next_fn_field *fn_p; | |
3603 | struct next_template *t_new, *t_list = 0; | |
3604 | struct nextfield *new; | |
3605 | struct next_fn_field *fn_new; | |
3606 | struct next_instantiation *i_new, *i_list = 0; | |
3607 | int n, nfields = 0, n_fn_fields = 0, n_fn_fields_total = 0; | |
3608 | int n_base_classes = 0, n_templ_args = 0; | |
3609 | int ninstantiations = 0; | |
3610 | dnttpointer field, fn_field, parent; | |
3611 | union dnttentry *fieldp, *fn_fieldp, *parentp; | |
3612 | int i; | |
3613 | int static_member = 0; | |
3614 | int const_member = 0; | |
3615 | int volatile_member = 0; | |
3616 | unsigned long vtbl_offset; | |
3617 | int need_bitvectors = 0; | |
3618 | char *method_name = NULL; | |
3619 | char *method_alias = NULL; | |
3620 | ||
3621 | ||
3622 | /* Is it something we've already dealt with? */ | |
3623 | type = hpread_alloc_type (hp_type, objfile); | |
3624 | if ((TYPE_CODE (type) == TYPE_CODE_STRUCT) || | |
3625 | (TYPE_CODE (type) == TYPE_CODE_UNION) || | |
3626 | (TYPE_CODE (type) == TYPE_CODE_CLASS) || | |
3627 | (TYPE_CODE (type) == TYPE_CODE_TEMPLATE)) | |
3628 | return type; | |
3629 | ||
3630 | /* Get the basic type correct. */ | |
3631 | if (dn_bufp->dblock.kind == DNTT_TYPE_STRUCT) | |
3632 | { | |
3633 | TYPE_CODE (type) = TYPE_CODE_STRUCT; | |
3634 | TYPE_LENGTH (type) = dn_bufp->dstruct.bitlength / 8; | |
3635 | } | |
3636 | else if (dn_bufp->dblock.kind == DNTT_TYPE_UNION) | |
3637 | { | |
3638 | TYPE_CODE (type) = TYPE_CODE_UNION; | |
3639 | TYPE_LENGTH (type) = dn_bufp->dunion.bitlength / 8; | |
3640 | } | |
3641 | else if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS) | |
3642 | { | |
3643 | TYPE_CODE (type) = TYPE_CODE_CLASS; | |
3644 | TYPE_LENGTH (type) = dn_bufp->dclass.bitlength / 8; | |
3645 | ||
3646 | /* Overrides the TYPE_CPLUS_SPECIFIC(type) with allocated memory | |
3647 | * rather than &cplus_struct_default. | |
3648 | */ | |
3649 | allocate_cplus_struct_type (type); | |
3650 | ||
3651 | /* Fill in declared-type. | |
3652 | * (The C++ compiler will emit TYPE_CODE_CLASS | |
3653 | * for all 3 of "class", "struct" | |
3654 | * "union", and we have to look at the "class_decl" field if we | |
3655 | * want to know how it was really declared) | |
3656 | */ | |
3657 | /* (0==class, 1==union, 2==struct) */ | |
3658 | TYPE_DECLARED_TYPE (type) = dn_bufp->dclass.class_decl; | |
3659 | } | |
3660 | else if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE) | |
3661 | { | |
3662 | /* Get the basic type correct. */ | |
3663 | TYPE_CODE (type) = TYPE_CODE_TEMPLATE; | |
3664 | allocate_cplus_struct_type (type); | |
3665 | TYPE_DECLARED_TYPE (type) = DECLARED_TYPE_TEMPLATE; | |
3666 | } | |
3667 | else | |
3668 | return type; | |
3669 | ||
3670 | ||
3671 | TYPE_FLAGS (type) &= ~TYPE_FLAG_STUB; | |
3672 | ||
3673 | /* For classes, read the parent list. | |
3674 | * Question (RT): Do we need to do this for templates also? | |
3675 | */ | |
3676 | if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS) | |
3677 | { | |
3678 | ||
3679 | /* First read the parent-list (classes from which we derive fields) */ | |
3680 | parent = dn_bufp->dclass.parentlist; | |
3681 | while (parent.word && parent.word != DNTTNIL) | |
3682 | { | |
3683 | parentp = hpread_get_lntt (parent.dnttp.index, objfile); | |
3684 | ||
3685 | /* "parentp" should point to a DNTT_TYPE_INHERITANCE record */ | |
3686 | ||
3687 | /* Get space to record the next field/data-member. */ | |
3688 | new = (struct nextfield *) alloca (sizeof (struct nextfield)); | |
d4687fa0 | 3689 | memset (new, 0, sizeof (struct nextfield)); |
8af51c36 EZ |
3690 | new->next = list; |
3691 | list = new; | |
3692 | ||
3693 | FIELD_BITSIZE (list->field) = 0; | |
01ad7f36 | 3694 | FIELD_STATIC_KIND (list->field) = 0; |
8af51c36 EZ |
3695 | |
3696 | /* The "classname" field is actually a DNTT pointer to the base class */ | |
3697 | baseclass = hpread_type_lookup (parentp->dinheritance.classname, | |
3698 | objfile); | |
3699 | FIELD_TYPE (list->field) = baseclass; | |
3700 | ||
3701 | list->field.name = type_name_no_tag (FIELD_TYPE (list->field)); | |
3702 | ||
3703 | list->attributes = 0; | |
3704 | ||
3705 | /* Check for virtuality of base, and set the | |
3706 | * offset of the base subobject within the object. | |
3707 | * (Offset set to -1 for virtual bases (for now).) | |
3708 | */ | |
3709 | if (parentp->dinheritance.Virtual) | |
3710 | { | |
3711 | B_SET (&(list->attributes), ATTR_VIRTUAL); | |
3712 | parentp->dinheritance.offset = -1; | |
3713 | } | |
3714 | else | |
3715 | FIELD_BITPOS (list->field) = parentp->dinheritance.offset; | |
3716 | ||
3717 | /* Check visibility */ | |
3718 | switch (parentp->dinheritance.visibility) | |
3719 | { | |
3720 | case 1: | |
3721 | B_SET (&(list->attributes), ATTR_PROTECT); | |
3722 | break; | |
3723 | case 2: | |
3724 | B_SET (&(list->attributes), ATTR_PRIVATE); | |
3725 | break; | |
3726 | } | |
3727 | ||
3728 | n_base_classes++; | |
3729 | nfields++; | |
3730 | ||
3731 | parent = parentp->dinheritance.next; | |
3732 | } | |
3733 | } | |
3734 | ||
3735 | /* For templates, read the template argument list. | |
3736 | * This must be done before processing the member list, because | |
3737 | * the member list may refer back to this. E.g.: | |
3738 | * template <class T1, class T2> class q2 { | |
3739 | * public: | |
3740 | * T1 a; | |
3741 | * T2 b; | |
3742 | * }; | |
3743 | * We need to read the argument list "T1", "T2" first. | |
3744 | */ | |
3745 | if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE) | |
3746 | { | |
3747 | /* Kludge alert: This stuffs a global "current_template" which | |
3748 | * is referred to by hpread_get_nth_templ_arg(). The global | |
3749 | * is cleared at the end of this routine. | |
3750 | */ | |
3751 | current_template = type; | |
3752 | ||
3753 | /* Read in the argument list */ | |
3754 | field = dn_bufp->dtemplate.arglist; | |
3755 | while (field.word && field.word != DNTTNIL) | |
3756 | { | |
3757 | /* Get this template argument */ | |
3758 | fieldp = hpread_get_lntt (field.dnttp.index, objfile); | |
3759 | if (fieldp->dblock.kind != DNTT_TYPE_TEMPLATE_ARG) | |
3760 | { | |
8a3fe4f8 | 3761 | warning (_("Invalid debug info: Template argument entry is of wrong kind")); |
8af51c36 EZ |
3762 | break; |
3763 | } | |
3764 | /* Bump the count */ | |
3765 | n_templ_args++; | |
3766 | /* Allocate and fill in a struct next_template */ | |
3767 | t_new = (struct next_template *) alloca (sizeof (struct next_template)); | |
d4687fa0 | 3768 | memset (t_new, 0, sizeof (struct next_template)); |
8af51c36 EZ |
3769 | t_new->next = t_list; |
3770 | t_list = t_new; | |
3771 | t_list->arg.name = VT (objfile) + fieldp->dtempl_arg.name; | |
3772 | t_list->arg.type = hpread_read_templ_arg_type (field, fieldp, | |
3773 | objfile, t_list->arg.name); | |
3774 | /* Walk to the next template argument */ | |
3775 | field = fieldp->dtempl_arg.nextarg; | |
3776 | } | |
3777 | } | |
3778 | ||
3779 | TYPE_NTEMPLATE_ARGS (type) = n_templ_args; | |
3780 | ||
3781 | if (n_templ_args > 0) | |
3782 | TYPE_TEMPLATE_ARGS (type) = (struct template_arg *) | |
b99607ea | 3783 | obstack_alloc (&objfile->objfile_obstack, sizeof (struct template_arg) * n_templ_args); |
8af51c36 EZ |
3784 | for (n = n_templ_args; t_list; t_list = t_list->next) |
3785 | { | |
3786 | n -= 1; | |
3787 | TYPE_TEMPLATE_ARG (type, n) = t_list->arg; | |
3788 | } | |
3789 | ||
3790 | /* Next read in and internalize all the fields/members. */ | |
3791 | if (dn_bufp->dblock.kind == DNTT_TYPE_STRUCT) | |
3792 | field = dn_bufp->dstruct.firstfield; | |
3793 | else if (dn_bufp->dblock.kind == DNTT_TYPE_UNION) | |
3794 | field = dn_bufp->dunion.firstfield; | |
3795 | else if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS) | |
3796 | field = dn_bufp->dclass.memberlist; | |
3797 | else if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE) | |
3798 | field = dn_bufp->dtemplate.memberlist; | |
3799 | else | |
3800 | field.word = DNTTNIL; | |
3801 | ||
3802 | while (field.word && field.word != DNTTNIL) | |
3803 | { | |
3804 | fieldp = hpread_get_lntt (field.dnttp.index, objfile); | |
3805 | ||
3806 | /* At this point "fieldp" may point to either a DNTT_TYPE_FIELD | |
3807 | * or a DNTT_TYPE_GENFIELD record. | |
3808 | */ | |
3809 | vtbl_offset = 0; | |
3810 | static_member = 0; | |
3811 | const_member = 0; | |
3812 | volatile_member = 0; | |
3813 | ||
3814 | if (fieldp->dblock.kind == DNTT_TYPE_GENFIELD) | |
3815 | { | |
3816 | ||
3817 | /* The type will be GENFIELD if the field is a method or | |
3818 | * a static member (or some other cases -- see below) | |
3819 | */ | |
3820 | ||
3821 | /* Follow a link to get to the record for the field. */ | |
3822 | fn_field = fieldp->dgenfield.field; | |
3823 | fn_fieldp = hpread_get_lntt (fn_field.dnttp.index, objfile); | |
3824 | ||
3825 | /* Virtual funcs are indicated by a VFUNC which points to the | |
3826 | * real entry | |
3827 | */ | |
3828 | if (fn_fieldp->dblock.kind == DNTT_TYPE_VFUNC) | |
3829 | { | |
3830 | vtbl_offset = fn_fieldp->dvfunc.vtbl_offset; | |
3831 | fn_field = fn_fieldp->dvfunc.funcptr; | |
3832 | fn_fieldp = hpread_get_lntt (fn_field.dnttp.index, objfile); | |
3833 | } | |
3834 | ||
3835 | /* A function's entry may be preceded by a modifier which | |
3836 | * labels it static/constant/volatile. | |
3837 | */ | |
3838 | if (fn_fieldp->dblock.kind == DNTT_TYPE_MODIFIER) | |
3839 | { | |
3840 | static_member = fn_fieldp->dmodifier.m_static; | |
3841 | const_member = fn_fieldp->dmodifier.m_const; | |
3842 | volatile_member = fn_fieldp->dmodifier.m_volatile; | |
3843 | fn_field = fn_fieldp->dmodifier.type; | |
3844 | fn_fieldp = hpread_get_lntt (fn_field.dnttp.index, objfile); | |
3845 | } | |
3846 | ||
3847 | /* Check whether we have a method */ | |
3848 | if ((fn_fieldp->dblock.kind == DNTT_TYPE_MEMFUNC) || | |
3849 | (fn_fieldp->dblock.kind == DNTT_TYPE_FUNCTION) || | |
3850 | (fn_fieldp->dblock.kind == DNTT_TYPE_DOC_MEMFUNC) || | |
3851 | (fn_fieldp->dblock.kind == DNTT_TYPE_DOC_FUNCTION)) | |
3852 | { | |
3853 | /* Method found */ | |
3854 | ||
3855 | short ix = 0; | |
3856 | ||
3857 | /* Look up function type of method */ | |
3858 | memtype = hpread_type_lookup (fn_field, objfile); | |
3859 | ||
3860 | /* Methods can be seen before classes in the SOM records. | |
3861 | If we are processing this class because it's a parameter of a | |
3862 | method, at this point the method's type is actually incomplete; | |
3863 | we'll have to fix it up later; mark the class for this. */ | |
3864 | ||
3865 | if (TYPE_INCOMPLETE (memtype)) | |
3866 | { | |
3867 | TYPE_FLAGS (type) |= TYPE_FLAG_INCOMPLETE; | |
3868 | if (fixup_class) | |
8a3fe4f8 | 3869 | warning (_("Two classes to fix up for method?? Type information may be incorrect for some classes.")); |
8af51c36 | 3870 | if (fixup_method) |
8a3fe4f8 | 3871 | warning (_("Two methods to be fixed up at once?? Type information may be incorrect for some classes.")); |
8af51c36 EZ |
3872 | fixup_class = type; /* remember this class has to be fixed up */ |
3873 | fixup_method = memtype; /* remember the method type to be used in fixup */ | |
3874 | } | |
3875 | ||
3876 | /* HP aCC generates operator names without the "operator" keyword, and | |
3877 | generates null strings as names for operators that are | |
3878 | user-defined type conversions to basic types (e.g. operator int ()). | |
3879 | So try to reconstruct name as best as possible. */ | |
3880 | ||
3881 | method_name = (char *) (VT (objfile) + fn_fieldp->dfunc.name); | |
3882 | method_alias = (char *) (VT (objfile) + fn_fieldp->dfunc.alias); | |
3883 | ||
3884 | if (!method_name || /* no name */ | |
3885 | !*method_name || /* or null name */ | |
3886 | cplus_mangle_opname (method_name, DMGL_ANSI)) /* or name is an operator like "<" */ | |
3887 | { | |
3888 | char *tmp_name = cplus_demangle (method_alias, DMGL_ANSI); | |
3889 | char *op_string = strstr (tmp_name, "operator"); | |
3890 | method_name = xmalloc (strlen (op_string) + 1); /* don't overwrite VT! */ | |
3891 | strcpy (method_name, op_string); | |
3892 | } | |
3893 | ||
3894 | /* First check if a method of the same name has already been seen. */ | |
3895 | fn_p = fn_list; | |
3896 | while (fn_p) | |
3897 | { | |
cb137aa5 | 3898 | if (DEPRECATED_STREQ (fn_p->field.name, method_name)) |
8af51c36 EZ |
3899 | break; |
3900 | fn_p = fn_p->next; | |
3901 | } | |
3902 | ||
3903 | /* If no such method was found, allocate a new entry in the list */ | |
3904 | if (!fn_p) | |
3905 | { | |
3906 | /* Get space to record this member function */ | |
3907 | /* Note: alloca used; this will disappear on routine exit */ | |
3908 | fn_new = (struct next_fn_field *) alloca (sizeof (struct next_fn_field)); | |
d4687fa0 | 3909 | memset (fn_new, 0, sizeof (struct next_fn_field)); |
8af51c36 EZ |
3910 | fn_new->next = fn_list; |
3911 | fn_list = fn_new; | |
3912 | ||
3913 | /* Fill in the fields of the struct nextfield */ | |
3914 | ||
3915 | /* Record the (unmangled) method name */ | |
3916 | fn_list->field.name = method_name; | |
3917 | /* Initial space for overloaded methods */ | |
3918 | /* Note: xmalloc is used; this will persist after this routine exits */ | |
3919 | fn_list->field.fn_fields = (struct fn_field *) xmalloc (5 * (sizeof (struct fn_field))); | |
3920 | fn_list->field.length = 1; /* Init # of overloaded instances */ | |
3921 | fn_list->num_fn_fields = 5; /* # of entries for which space allocated */ | |
3922 | fn_p = fn_list; | |
3923 | ix = 0; /* array index for fn_field */ | |
3924 | /* Bump the total count of the distinctly named methods */ | |
3925 | n_fn_fields++; | |
3926 | } | |
3927 | else | |
3928 | /* Another overloaded instance of an already seen method name */ | |
3929 | { | |
3930 | if (++(fn_p->field.length) > fn_p->num_fn_fields) | |
3931 | { | |
3932 | /* Increase space allocated for overloaded instances */ | |
3933 | fn_p->field.fn_fields | |
3934 | = (struct fn_field *) xrealloc (fn_p->field.fn_fields, | |
3935 | (fn_p->num_fn_fields + 5) * sizeof (struct fn_field)); | |
3936 | fn_p->num_fn_fields += 5; | |
3937 | } | |
3938 | ix = fn_p->field.length - 1; /* array index for fn_field */ | |
3939 | } | |
3940 | ||
3941 | /* "physname" is intended to be the name of this overloaded instance. */ | |
3942 | if ((fn_fieldp->dfunc.language == HP_LANGUAGE_CPLUSPLUS) && | |
3943 | method_alias && | |
3944 | *method_alias) /* not a null string */ | |
3945 | fn_p->field.fn_fields[ix].physname = method_alias; | |
3946 | else | |
3947 | fn_p->field.fn_fields[ix].physname = method_name; | |
3948 | /* What's expected here is the function type */ | |
3949 | /* But mark it as NULL if the method was incompletely processed | |
3950 | We'll fix this up later when the method is fully processed */ | |
3951 | if (TYPE_INCOMPLETE (memtype)) | |
ad2f7632 | 3952 | fn_p->field.fn_fields[ix].type = NULL; |
8af51c36 | 3953 | else |
ad2f7632 | 3954 | fn_p->field.fn_fields[ix].type = memtype; |
42725910 | 3955 | |
8af51c36 EZ |
3956 | /* For virtual functions, fill in the voffset field with the |
3957 | * virtual table offset. (This is just copied over from the | |
3958 | * SOM record; not sure if it is what GDB expects here...). | |
3959 | * But if the function is a static method, set it to 1. | |
3960 | * | |
3961 | * Note that we have to add 1 because 1 indicates a static | |
3962 | * method, and 0 indicates a non-static, non-virtual method */ | |
3963 | ||
3964 | if (static_member) | |
3965 | fn_p->field.fn_fields[ix].voffset = VOFFSET_STATIC; | |
3966 | else | |
3967 | fn_p->field.fn_fields[ix].voffset = vtbl_offset ? vtbl_offset + 1 : 0; | |
3968 | ||
3969 | /* Also fill in the fcontext field with the current | |
3970 | * class. (The latter isn't quite right: should be the baseclass | |
3971 | * that defines the virtual function... Note we do have | |
3972 | * a variable "baseclass" that we could stuff into the fcontext | |
3973 | * field, but "baseclass" isn't necessarily right either, | |
3974 | * since the virtual function could have been defined more | |
3975 | * than one level up). | |
3976 | */ | |
3977 | ||
3978 | if (vtbl_offset != 0) | |
3979 | fn_p->field.fn_fields[ix].fcontext = type; | |
3980 | else | |
3981 | fn_p->field.fn_fields[ix].fcontext = NULL; | |
3982 | ||
3983 | /* Other random fields pertaining to this method */ | |
3984 | fn_p->field.fn_fields[ix].is_const = const_member; | |
3985 | fn_p->field.fn_fields[ix].is_volatile = volatile_member; /* ?? */ | |
3986 | switch (fieldp->dgenfield.visibility) | |
3987 | { | |
3988 | case 1: | |
3989 | fn_p->field.fn_fields[ix].is_protected = 1; | |
3990 | fn_p->field.fn_fields[ix].is_private = 0; | |
3991 | break; | |
3992 | case 2: | |
3993 | fn_p->field.fn_fields[ix].is_protected = 0; | |
3994 | fn_p->field.fn_fields[ix].is_private = 1; | |
3995 | break; | |
3996 | default: /* public */ | |
3997 | fn_p->field.fn_fields[ix].is_protected = 0; | |
3998 | fn_p->field.fn_fields[ix].is_private = 0; | |
3999 | } | |
4000 | fn_p->field.fn_fields[ix].is_stub = 0; | |
4001 | ||
4002 | /* HP aCC emits both MEMFUNC and FUNCTION entries for a method; | |
4003 | if the class points to the FUNCTION, there is usually separate | |
4004 | code for the method; but if we have a MEMFUNC, the method has | |
4005 | been inlined (and there is usually no FUNCTION entry) | |
4006 | FIXME Not sure if this test is accurate. pai/1997-08-22 */ | |
4007 | if ((fn_fieldp->dblock.kind == DNTT_TYPE_MEMFUNC) || | |
4008 | (fn_fieldp->dblock.kind == DNTT_TYPE_DOC_MEMFUNC)) | |
4009 | fn_p->field.fn_fields[ix].is_inlined = 1; | |
4010 | else | |
4011 | fn_p->field.fn_fields[ix].is_inlined = 0; | |
4012 | ||
4013 | fn_p->field.fn_fields[ix].dummy = 0; | |
4014 | ||
4015 | /* Bump the total count of the member functions */ | |
4016 | n_fn_fields_total++; | |
4017 | ||
4018 | } | |
4019 | else if (fn_fieldp->dblock.kind == DNTT_TYPE_SVAR) | |
4020 | { | |
4021 | /* This case is for static data members of classes */ | |
4022 | ||
4023 | /* pai:: FIXME -- check that "staticmem" bit is set */ | |
4024 | ||
4025 | /* Get space to record this static member */ | |
4026 | new = (struct nextfield *) alloca (sizeof (struct nextfield)); | |
d4687fa0 | 4027 | memset (new, 0, sizeof (struct nextfield)); |
8af51c36 EZ |
4028 | new->next = list; |
4029 | list = new; | |
4030 | ||
4031 | list->field.name = VT (objfile) + fn_fieldp->dsvar.name; | |
8af51c36 EZ |
4032 | SET_FIELD_PHYSNAME (list->field, 0); /* initialize to empty */ |
4033 | memtype = hpread_type_lookup (fn_fieldp->dsvar.type, objfile); | |
4034 | ||
4035 | FIELD_TYPE (list->field) = memtype; | |
4036 | list->attributes = 0; | |
4037 | switch (fieldp->dgenfield.visibility) | |
4038 | { | |
4039 | case 1: | |
4040 | B_SET (&(list->attributes), ATTR_PROTECT); | |
4041 | break; | |
4042 | case 2: | |
4043 | B_SET (&(list->attributes), ATTR_PRIVATE); | |
4044 | break; | |
4045 | } | |
4046 | nfields++; | |
4047 | } | |
4048 | ||
4049 | else if (fn_fieldp->dblock.kind == DNTT_TYPE_FIELD) | |
4050 | { | |
4051 | /* FIELDs follow GENFIELDs for fields of anonymous unions. | |
4052 | Code below is replicated from the case for FIELDs further | |
4053 | below, except that fieldp is replaced by fn_fieldp */ | |
4054 | if (!fn_fieldp->dfield.a_union) | |
8a3fe4f8 | 4055 | warning (_("Debug info inconsistent: FIELD of anonymous union doesn't have a_union bit set")); |
8af51c36 EZ |
4056 | /* Get space to record the next field/data-member. */ |
4057 | new = (struct nextfield *) alloca (sizeof (struct nextfield)); | |
d4687fa0 | 4058 | memset (new, 0, sizeof (struct nextfield)); |
8af51c36 EZ |
4059 | new->next = list; |
4060 | list = new; | |
4061 | ||
4062 | list->field.name = VT (objfile) + fn_fieldp->dfield.name; | |
4063 | FIELD_BITPOS (list->field) = fn_fieldp->dfield.bitoffset; | |
4064 | if (fn_fieldp->dfield.bitlength % 8) | |
4065 | list->field.bitsize = fn_fieldp->dfield.bitlength; | |
4066 | else | |
4067 | list->field.bitsize = 0; | |
4068 | ||
4069 | memtype = hpread_type_lookup (fn_fieldp->dfield.type, objfile); | |
4070 | list->field.type = memtype; | |
4071 | list->attributes = 0; | |
4072 | switch (fn_fieldp->dfield.visibility) | |
4073 | { | |
4074 | case 1: | |
4075 | B_SET (&(list->attributes), ATTR_PROTECT); | |
4076 | break; | |
4077 | case 2: | |
4078 | B_SET (&(list->attributes), ATTR_PRIVATE); | |
4079 | break; | |
4080 | } | |
4081 | nfields++; | |
4082 | } | |
4083 | else if (fn_fieldp->dblock.kind == DNTT_TYPE_SVAR) | |
4084 | { | |
4085 | /* Field of anonymous union; union is not inside a class */ | |
4086 | if (!fn_fieldp->dsvar.a_union) | |
8a3fe4f8 | 4087 | warning (_("Debug info inconsistent: SVAR field in anonymous union doesn't have a_union bit set")); |
8af51c36 EZ |
4088 | /* Get space to record the next field/data-member. */ |
4089 | new = (struct nextfield *) alloca (sizeof (struct nextfield)); | |
d4687fa0 | 4090 | memset (new, 0, sizeof (struct nextfield)); |
8af51c36 EZ |
4091 | new->next = list; |
4092 | list = new; | |
4093 | ||
4094 | list->field.name = VT (objfile) + fn_fieldp->dsvar.name; | |
4095 | FIELD_BITPOS (list->field) = 0; /* FIXME is this always true? */ | |
4096 | FIELD_BITSIZE (list->field) = 0; /* use length from type */ | |
01ad7f36 | 4097 | FIELD_STATIC_KIND (list->field) = 0; |
8af51c36 EZ |
4098 | memtype = hpread_type_lookup (fn_fieldp->dsvar.type, objfile); |
4099 | list->field.type = memtype; | |
4100 | list->attributes = 0; | |
4101 | /* No info to set visibility -- always public */ | |
4102 | nfields++; | |
4103 | } | |
4104 | else if (fn_fieldp->dblock.kind == DNTT_TYPE_DVAR) | |
4105 | { | |
4106 | /* Field of anonymous union; union is not inside a class */ | |
4107 | if (!fn_fieldp->ddvar.a_union) | |
8a3fe4f8 | 4108 | warning (_("Debug info inconsistent: DVAR field in anonymous union doesn't have a_union bit set")); |
8af51c36 EZ |
4109 | /* Get space to record the next field/data-member. */ |
4110 | new = (struct nextfield *) alloca (sizeof (struct nextfield)); | |
d4687fa0 | 4111 | memset (new, 0, sizeof (struct nextfield)); |
8af51c36 EZ |
4112 | new->next = list; |
4113 | list = new; | |
4114 | ||
4115 | list->field.name = VT (objfile) + fn_fieldp->ddvar.name; | |
4116 | FIELD_BITPOS (list->field) = 0; /* FIXME is this always true? */ | |
4117 | FIELD_BITSIZE (list->field) = 0; /* use length from type */ | |
01ad7f36 | 4118 | FIELD_STATIC_KIND (list->field) = 0; |
8af51c36 EZ |
4119 | memtype = hpread_type_lookup (fn_fieldp->ddvar.type, objfile); |
4120 | list->field.type = memtype; | |
4121 | list->attributes = 0; | |
4122 | /* No info to set visibility -- always public */ | |
4123 | nfields++; | |
4124 | } | |
4125 | else | |
4126 | { /* Not a method, nor a static data member, nor an anon union field */ | |
4127 | ||
4128 | /* This case is for miscellaneous type entries (local enums, | |
4129 | local function templates, etc.) that can be present | |
4130 | inside a class. */ | |
4131 | ||
4132 | /* Enums -- will be handled by other code that takes care | |
4133 | of DNTT_TYPE_ENUM; here we see only DNTT_TYPE_MEMENUM so | |
4134 | it's not clear we could have handled them here at all. */ | |
4135 | /* FUNC_TEMPLATE: is handled by other code (?). */ | |
4136 | /* MEMACCESS: modified access for inherited member. Not | |
4137 | sure what to do with this, ignoriing it at present. */ | |
4138 | ||
4139 | /* What other entries can appear following a GENFIELD which | |
4140 | we do not handle above? (MODIFIER, VFUNC handled above.) */ | |
4141 | ||
4142 | if ((fn_fieldp->dblock.kind != DNTT_TYPE_MEMACCESS) && | |
4143 | (fn_fieldp->dblock.kind != DNTT_TYPE_MEMENUM) && | |
4144 | (fn_fieldp->dblock.kind != DNTT_TYPE_FUNC_TEMPLATE)) | |
8a3fe4f8 | 4145 | warning (_("Internal error: Unexpected debug record kind %d found following DNTT_GENFIELD"), |
8af51c36 EZ |
4146 | fn_fieldp->dblock.kind); |
4147 | } | |
4148 | /* walk to the next FIELD or GENFIELD */ | |
4149 | field = fieldp->dgenfield.nextfield; | |
4150 | ||
4151 | } | |
4152 | else if (fieldp->dblock.kind == DNTT_TYPE_FIELD) | |
4153 | { | |
4154 | ||
4155 | /* Ordinary structure/union/class field */ | |
4156 | struct type *anon_union_type; | |
4157 | ||
4158 | /* Get space to record the next field/data-member. */ | |
4159 | new = (struct nextfield *) alloca (sizeof (struct nextfield)); | |
d4687fa0 | 4160 | memset (new, 0, sizeof (struct nextfield)); |
8af51c36 EZ |
4161 | new->next = list; |
4162 | list = new; | |
4163 | ||
4164 | list->field.name = VT (objfile) + fieldp->dfield.name; | |
4165 | ||
4166 | ||
9f9057da MC |
4167 | /* A FIELD by itself (without a GENFIELD) can also be a static |
4168 | member. Mark it as static with a physname of NULL. | |
4169 | fix_static_member_physnames will assign the physname later. */ | |
8af51c36 EZ |
4170 | if (fieldp->dfield.staticmem) |
4171 | { | |
9f9057da MC |
4172 | SET_FIELD_PHYSNAME (list->field, NULL); |
4173 | FIELD_BITPOS (list->field) = 0; | |
8af51c36 EZ |
4174 | FIELD_BITSIZE (list->field) = 0; |
4175 | } | |
4176 | else | |
4177 | /* Non-static data member */ | |
4178 | { | |
9f9057da | 4179 | FIELD_STATIC_KIND (list->field) = 0; |
8af51c36 EZ |
4180 | FIELD_BITPOS (list->field) = fieldp->dfield.bitoffset; |
4181 | if (fieldp->dfield.bitlength % 8) | |
4182 | FIELD_BITSIZE (list->field) = fieldp->dfield.bitlength; | |
4183 | else | |
4184 | FIELD_BITSIZE (list->field) = 0; | |
4185 | } | |
4186 | ||
4187 | memtype = hpread_type_lookup (fieldp->dfield.type, objfile); | |
4188 | FIELD_TYPE (list->field) = memtype; | |
4189 | list->attributes = 0; | |
4190 | switch (fieldp->dfield.visibility) | |
4191 | { | |
4192 | case 1: | |
4193 | B_SET (&(list->attributes), ATTR_PROTECT); | |
4194 | break; | |
4195 | case 2: | |
4196 | B_SET (&(list->attributes), ATTR_PRIVATE); | |
4197 | break; | |
4198 | } | |
4199 | nfields++; | |
4200 | ||
4201 | ||
4202 | /* Note 1: First, we have to check if the current field is an anonymous | |
4203 | union. If it is, then *its* fields are threaded along in the | |
4204 | nextfield chain. :-( This was supposed to help debuggers, but is | |
4205 | really just a nuisance since we deal with anonymous unions anyway by | |
4206 | checking that the name is null. So anyway, we skip over the fields | |
4207 | of the anonymous union. pai/1997-08-22 */ | |
4208 | /* Note 2: In addition, the bitoffsets for the fields of the anon union | |
4209 | are relative to the enclosing struct, *NOT* relative to the anon | |
4210 | union! This is an even bigger nuisance -- we have to go in and munge | |
4211 | the anon union's type information appropriately. pai/1997-08-22 */ | |
c906108c | 4212 | |
8af51c36 EZ |
4213 | /* Both tasks noted above are done by a separate function. This takes us |
4214 | to the next FIELD or GENFIELD, skipping anon unions, and recursively | |
4215 | processing intermediate types. */ | |
4216 | field = hpread_get_next_skip_over_anon_unions (1, field, &fieldp, objfile); | |
4217 | ||
4218 | } | |
c906108c | 4219 | else |
c906108c | 4220 | { |
8af51c36 EZ |
4221 | /* neither field nor genfield ?? is this possible?? */ |
4222 | /* pai:: FIXME walk to the next -- how? */ | |
8a3fe4f8 | 4223 | warning (_("Internal error: unexpected DNTT kind %d encountered as field of struct"), |
8af51c36 | 4224 | fieldp->dblock.kind); |
8a3fe4f8 | 4225 | warning (_("Skipping remaining fields of struct")); |
8af51c36 | 4226 | break; /* get out of loop of fields */ |
c906108c | 4227 | } |
8af51c36 | 4228 | } |
c906108c | 4229 | |
8af51c36 EZ |
4230 | /* If it's a template, read in the instantiation list */ |
4231 | if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE) | |
4232 | { | |
4233 | ninstantiations = 0; | |
4234 | field = dn_bufp->dtemplate.expansions; | |
4235 | while (field.word && field.word != DNTTNIL) | |
4236 | { | |
4237 | fieldp = hpread_get_lntt (field.dnttp.index, objfile); | |
4238 | ||
4239 | /* The expansions or nextexp should point to a tagdef */ | |
4240 | if (fieldp->dblock.kind != DNTT_TYPE_TAGDEF) | |
4241 | break; | |
4242 | ||
4243 | i_new = (struct next_instantiation *) alloca (sizeof (struct next_instantiation)); | |
d4687fa0 | 4244 | memset (i_new, 0, sizeof (struct next_instantiation)); |
8af51c36 EZ |
4245 | i_new->next = i_list; |
4246 | i_list = i_new; | |
4247 | i_list->t = hpread_type_lookup (field, objfile); | |
4248 | ninstantiations++; | |
4249 | ||
4250 | /* And the "type" field of that should point to a class */ | |
4251 | field = fieldp->dtag.type; | |
4252 | fieldp = hpread_get_lntt (field.dnttp.index, objfile); | |
4253 | if (fieldp->dblock.kind != DNTT_TYPE_CLASS) | |
4254 | break; | |
4255 | ||
4256 | /* Get the next expansion */ | |
4257 | field = fieldp->dclass.nextexp; | |
4258 | } | |
4259 | } | |
4260 | TYPE_NINSTANTIATIONS (type) = ninstantiations; | |
4261 | if (ninstantiations > 0) | |
4262 | TYPE_INSTANTIATIONS (type) = (struct type **) | |
b99607ea | 4263 | obstack_alloc (&objfile->objfile_obstack, sizeof (struct type *) * ninstantiations); |
8af51c36 EZ |
4264 | for (n = ninstantiations; i_list; i_list = i_list->next) |
4265 | { | |
4266 | n -= 1; | |
4267 | TYPE_INSTANTIATION (type, n) = i_list->t; | |
c906108c SS |
4268 | } |
4269 | ||
8af51c36 EZ |
4270 | |
4271 | /* Copy the field-list to GDB's symbol table */ | |
4272 | TYPE_NFIELDS (type) = nfields; | |
4273 | TYPE_N_BASECLASSES (type) = n_base_classes; | |
c906108c | 4274 | TYPE_FIELDS (type) = (struct field *) |
b99607ea | 4275 | obstack_alloc (&objfile->objfile_obstack, sizeof (struct field) * nfields); |
8af51c36 EZ |
4276 | /* Copy the saved-up fields into the field vector. */ |
4277 | for (n = nfields, tmp_list = list; tmp_list; tmp_list = tmp_list->next) | |
4278 | { | |
4279 | n -= 1; | |
4280 | TYPE_FIELD (type, n) = tmp_list->field; | |
4281 | } | |
c906108c | 4282 | |
8af51c36 EZ |
4283 | /* Copy the "function-field-list" (i.e., the list of member |
4284 | * functions in the class) to GDB's symbol table | |
4285 | */ | |
4286 | TYPE_NFN_FIELDS (type) = n_fn_fields; | |
4287 | TYPE_NFN_FIELDS_TOTAL (type) = n_fn_fields_total; | |
4288 | TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *) | |
b99607ea | 4289 | obstack_alloc (&objfile->objfile_obstack, sizeof (struct fn_fieldlist) * n_fn_fields); |
8af51c36 | 4290 | for (n = n_fn_fields; fn_list; fn_list = fn_list->next) |
c906108c | 4291 | { |
8af51c36 EZ |
4292 | n -= 1; |
4293 | TYPE_FN_FIELDLIST (type, n) = fn_list->field; | |
4294 | } | |
4295 | ||
4296 | /* pai:: FIXME -- perhaps each bitvector should be created individually */ | |
4297 | for (n = nfields, tmp_list = list; tmp_list; tmp_list = tmp_list->next) | |
4298 | { | |
4299 | n -= 1; | |
4300 | if (tmp_list->attributes) | |
c906108c | 4301 | { |
8af51c36 EZ |
4302 | need_bitvectors = 1; |
4303 | break; | |
c906108c | 4304 | } |
c906108c | 4305 | } |
c906108c | 4306 | |
8af51c36 | 4307 | if (need_bitvectors) |
c906108c | 4308 | { |
8af51c36 EZ |
4309 | /* pai:: this step probably redundant */ |
4310 | ALLOCATE_CPLUS_STRUCT_TYPE (type); | |
c906108c | 4311 | |
8af51c36 EZ |
4312 | TYPE_FIELD_VIRTUAL_BITS (type) = |
4313 | (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields)); | |
4314 | B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), nfields); | |
c906108c | 4315 | |
8af51c36 EZ |
4316 | TYPE_FIELD_PRIVATE_BITS (type) = |
4317 | (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields)); | |
4318 | B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields); | |
c906108c | 4319 | |
8af51c36 EZ |
4320 | TYPE_FIELD_PROTECTED_BITS (type) = |
4321 | (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields)); | |
4322 | B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields); | |
4323 | ||
4324 | /* this field vector isn't actually used with HP aCC */ | |
4325 | TYPE_FIELD_IGNORE_BITS (type) = | |
4326 | (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields)); | |
4327 | B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields); | |
4328 | ||
4329 | while (nfields-- > 0) | |
4330 | { | |
4331 | if (B_TST (&(list->attributes), ATTR_VIRTUAL)) | |
4332 | SET_TYPE_FIELD_VIRTUAL (type, nfields); | |
4333 | if (B_TST (&(list->attributes), ATTR_PRIVATE)) | |
4334 | SET_TYPE_FIELD_PRIVATE (type, nfields); | |
4335 | if (B_TST (&(list->attributes), ATTR_PROTECT)) | |
4336 | SET_TYPE_FIELD_PROTECTED (type, nfields); | |
4337 | ||
4338 | list = list->next; | |
4339 | } | |
4340 | } | |
4341 | else | |
c906108c | 4342 | { |
8af51c36 EZ |
4343 | TYPE_FIELD_VIRTUAL_BITS (type) = NULL; |
4344 | TYPE_FIELD_PROTECTED_BITS (type) = NULL; | |
4345 | TYPE_FIELD_PRIVATE_BITS (type) = NULL; | |
c906108c | 4346 | } |
8af51c36 EZ |
4347 | |
4348 | if (has_vtable (type)) | |
c906108c | 4349 | { |
8af51c36 EZ |
4350 | /* Allocate space for class runtime information */ |
4351 | TYPE_RUNTIME_PTR (type) = (struct runtime_info *) xmalloc (sizeof (struct runtime_info)); | |
4352 | /* Set flag for vtable */ | |
4353 | TYPE_VTABLE (type) = 1; | |
4354 | /* The first non-virtual base class with a vtable. */ | |
4355 | TYPE_PRIMARY_BASE (type) = primary_base_class (type); | |
4356 | /* The virtual base list. */ | |
4357 | TYPE_VIRTUAL_BASE_LIST (type) = virtual_base_list (type); | |
c906108c SS |
4358 | } |
4359 | else | |
8af51c36 | 4360 | TYPE_RUNTIME_PTR (type) = NULL; |
c906108c | 4361 | |
8af51c36 EZ |
4362 | /* If this is a local type (C++ - declared inside a function), record file name & line # */ |
4363 | if (hpread_get_scope_depth (dn_bufp, objfile, 1 /* no need for real depth */ )) | |
4364 | { | |
4365 | TYPE_LOCALTYPE_PTR (type) = (struct local_type_info *) xmalloc (sizeof (struct local_type_info)); | |
4366 | TYPE_LOCALTYPE_FILE (type) = (char *) xmalloc (strlen (current_subfile->name) + 1); | |
4367 | strcpy (TYPE_LOCALTYPE_FILE (type), current_subfile->name); | |
4368 | if (current_subfile->line_vector && (current_subfile->line_vector->nitems > 0)) | |
4369 | TYPE_LOCALTYPE_LINE (type) = current_subfile->line_vector->item[current_subfile->line_vector->nitems - 1].line; | |
4370 | else | |
4371 | TYPE_LOCALTYPE_LINE (type) = 0; | |
4372 | } | |
4373 | else | |
4374 | TYPE_LOCALTYPE_PTR (type) = NULL; | |
c906108c | 4375 | |
8af51c36 EZ |
4376 | /* Clear the global saying what template we are in the middle of processing */ |
4377 | current_template = NULL; | |
c906108c | 4378 | |
8af51c36 EZ |
4379 | return type; |
4380 | } | |
c906108c | 4381 | |
8af51c36 EZ |
4382 | /* Adjust the physnames for each static member of a struct |
4383 | or class type to be something like "A::x"; then various | |
4384 | other pieces of code that do a lookup_symbol on the phyname | |
4385 | work correctly. | |
4386 | TYPE is a pointer to the struct/class type | |
4387 | NAME is a char * (string) which is the class/struct name | |
4388 | Void return */ | |
c906108c | 4389 | |
8af51c36 EZ |
4390 | static void |
4391 | fix_static_member_physnames (struct type *type, char *class_name, | |
4392 | struct objfile *objfile) | |
4393 | { | |
4394 | int i; | |
c906108c | 4395 | |
8af51c36 EZ |
4396 | /* We fix the member names only for classes or structs */ |
4397 | if (TYPE_CODE (type) != TYPE_CODE_STRUCT) | |
4398 | return; | |
4399 | ||
4400 | for (i = 0; i < TYPE_NFIELDS (type); i++) | |
4401 | if (TYPE_FIELD_STATIC (type, i)) | |
4402 | { | |
4403 | if (TYPE_FIELD_STATIC_PHYSNAME (type, i)) | |
4404 | return; /* physnames are already set */ | |
4405 | ||
0004e5a2 | 4406 | SET_FIELD_PHYSNAME (TYPE_FIELDS (type)[i], |
b99607ea | 4407 | obstack_alloc (&objfile->objfile_obstack, |
8af51c36 EZ |
4408 | strlen (class_name) + strlen (TYPE_FIELD_NAME (type, i)) + 3)); |
4409 | strcpy (TYPE_FIELD_STATIC_PHYSNAME (type, i), class_name); | |
4410 | strcat (TYPE_FIELD_STATIC_PHYSNAME (type, i), "::"); | |
4411 | strcat (TYPE_FIELD_STATIC_PHYSNAME (type, i), TYPE_FIELD_NAME (type, i)); | |
4412 | } | |
4413 | } | |
4414 | ||
4415 | /* Fix-up the type structure for a CLASS so that the type entry | |
4416 | * for a method (previously marked with a null type in hpread_read_struct_type() | |
4417 | * is set correctly to METHOD. | |
4418 | * OBJFILE is as for other such functions. | |
4419 | * Void return. */ | |
4420 | ||
4421 | static void | |
4422 | fixup_class_method_type (struct type *class, struct type *method, | |
4423 | struct objfile *objfile) | |
4424 | { | |
4425 | int i, j, k; | |
4426 | ||
4427 | if (!class || !method || !objfile) | |
4428 | return; | |
4429 | ||
4430 | /* Only for types that have methods */ | |
4431 | if ((TYPE_CODE (class) != TYPE_CODE_CLASS) && | |
4432 | (TYPE_CODE (class) != TYPE_CODE_UNION)) | |
4433 | return; | |
4434 | ||
4435 | /* Loop over all methods and find the one marked with a NULL type */ | |
4436 | for (i = 0; i < TYPE_NFN_FIELDS (class); i++) | |
4437 | for (j = 0; j < TYPE_FN_FIELDLIST_LENGTH (class, i); j++) | |
4438 | if (TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i), j) == NULL) | |
4439 | { | |
4440 | /* Set the method type */ | |
4441 | TYPE_FN_FIELD_TYPE (TYPE_FN_FIELDLIST1 (class, i), j) = method; | |
8af51c36 | 4442 | |
8af51c36 EZ |
4443 | /* Break out of both loops -- only one method to fix up in a class */ |
4444 | goto finish; | |
4445 | } | |
4446 | ||
4447 | finish: | |
4448 | TYPE_FLAGS (class) &= ~TYPE_FLAG_INCOMPLETE; | |
4449 | } | |
4450 | ||
4451 | ||
4452 | /* If we're in the middle of processing a template, get a pointer | |
4453 | * to the Nth template argument. | |
4454 | * An example may make this clearer: | |
4455 | * template <class T1, class T2> class q2 { | |
4456 | * public: | |
4457 | * T1 a; | |
4458 | * T2 b; | |
4459 | * }; | |
4460 | * The type for "a" will be "first template arg" and | |
4461 | * the type for "b" will be "second template arg". | |
4462 | * We need to look these up in order to fill in "a" and "b"'s type. | |
4463 | * This is called from hpread_type_lookup(). | |
4464 | */ | |
4465 | static struct type * | |
4466 | hpread_get_nth_template_arg (struct objfile *objfile, int n) | |
4467 | { | |
4468 | if (current_template != NULL) | |
4469 | return TYPE_TEMPLATE_ARG (current_template, n).type; | |
4470 | else | |
4471 | return lookup_fundamental_type (objfile, FT_TEMPLATE_ARG); | |
4472 | } | |
4473 | ||
4474 | /* Read in and internalize a TEMPL_ARG (template arg) symbol. */ | |
4475 | ||
4476 | static struct type * | |
4477 | hpread_read_templ_arg_type (dnttpointer hp_type, union dnttentry *dn_bufp, | |
4478 | struct objfile *objfile, char *name) | |
4479 | { | |
4480 | struct type *type; | |
4481 | ||
4482 | /* See if it's something we've already deal with. */ | |
4483 | type = hpread_alloc_type (hp_type, objfile); | |
4484 | if (TYPE_CODE (type) == TYPE_CODE_TEMPLATE_ARG) | |
4485 | return type; | |
4486 | ||
4487 | /* Nope. Fill in the appropriate fields. */ | |
4488 | TYPE_CODE (type) = TYPE_CODE_TEMPLATE_ARG; | |
4489 | TYPE_LENGTH (type) = 0; | |
4490 | TYPE_NFIELDS (type) = 0; | |
4491 | TYPE_NAME (type) = name; | |
c906108c SS |
4492 | return type; |
4493 | } | |
4494 | ||
4495 | /* Read in and internalize a set debug symbol. */ | |
4496 | ||
4497 | static struct type * | |
fba45db2 KB |
4498 | hpread_read_set_type (dnttpointer hp_type, union dnttentry *dn_bufp, |
4499 | struct objfile *objfile) | |
c906108c SS |
4500 | { |
4501 | struct type *type; | |
4502 | ||
4503 | /* See if it's something we've already deal with. */ | |
4504 | type = hpread_alloc_type (hp_type, objfile); | |
4505 | if (TYPE_CODE (type) == TYPE_CODE_SET) | |
4506 | return type; | |
4507 | ||
4508 | /* Nope. Fill in the appropriate fields. */ | |
4509 | TYPE_CODE (type) = TYPE_CODE_SET; | |
4510 | TYPE_LENGTH (type) = dn_bufp->dset.bitlength / 8; | |
4511 | TYPE_NFIELDS (type) = 0; | |
4512 | TYPE_TARGET_TYPE (type) = hpread_type_lookup (dn_bufp->dset.subtype, | |
4513 | objfile); | |
4514 | return type; | |
4515 | } | |
4516 | ||
4517 | /* Read in and internalize an array debug symbol. */ | |
4518 | ||
4519 | static struct type * | |
fba45db2 KB |
4520 | hpread_read_array_type (dnttpointer hp_type, union dnttentry *dn_bufp, |
4521 | struct objfile *objfile) | |
c906108c SS |
4522 | { |
4523 | struct type *type; | |
c906108c | 4524 | |
8af51c36 EZ |
4525 | /* Allocate an array type symbol. |
4526 | * Why no check for already-read here, like in the other | |
4527 | * hpread_read_xxx_type routines? Because it kept us | |
4528 | * from properly determining the size of the array! | |
4529 | */ | |
c906108c SS |
4530 | type = hpread_alloc_type (hp_type, objfile); |
4531 | ||
4532 | TYPE_CODE (type) = TYPE_CODE_ARRAY; | |
4533 | ||
8af51c36 EZ |
4534 | /* Although the hp-symtab.h does not *require* this to be the case, |
4535 | * GDB is assuming that "arrayisbytes" and "elemisbytes" be consistent. | |
4536 | * I.e., express both array-length and element-length in bits, | |
4537 | * or express both array-length and element-length in bytes. | |
4538 | */ | |
4539 | if (!((dn_bufp->darray.arrayisbytes && dn_bufp->darray.elemisbytes) || | |
4540 | (!dn_bufp->darray.arrayisbytes && !dn_bufp->darray.elemisbytes))) | |
4541 | { | |
8a3fe4f8 | 4542 | warning (_("error in hpread_array_type.")); |
8af51c36 EZ |
4543 | return NULL; |
4544 | } | |
c906108c SS |
4545 | else if (dn_bufp->darray.arraylength == 0x7fffffff) |
4546 | { | |
4547 | /* The HP debug format represents char foo[]; as an array with | |
8af51c36 EZ |
4548 | * length 0x7fffffff. Internally GDB wants to represent this |
4549 | * as an array of length zero. | |
4550 | */ | |
c5aa993b | 4551 | TYPE_LENGTH (type) = 0; |
c906108c | 4552 | } |
8af51c36 EZ |
4553 | else if (dn_bufp->darray.arrayisbytes) |
4554 | TYPE_LENGTH (type) = dn_bufp->darray.arraylength; | |
4555 | else /* arraylength is in bits */ | |
c906108c SS |
4556 | TYPE_LENGTH (type) = dn_bufp->darray.arraylength / 8; |
4557 | ||
c906108c SS |
4558 | TYPE_TARGET_TYPE (type) = hpread_type_lookup (dn_bufp->darray.elemtype, |
4559 | objfile); | |
8af51c36 EZ |
4560 | |
4561 | /* The one "field" is used to store the subscript type */ | |
4562 | /* Since C and C++ multi-dimensional arrays are simply represented | |
4563 | * as: array of array of ..., we only need one subscript-type | |
4564 | * per array. This subscript type is typically a subrange of integer. | |
4565 | * If this gets extended to support languages like Pascal, then | |
4566 | * we need to fix this to represent multi-dimensional arrays properly. | |
4567 | */ | |
4568 | TYPE_NFIELDS (type) = 1; | |
c906108c | 4569 | TYPE_FIELDS (type) = (struct field *) |
b99607ea | 4570 | obstack_alloc (&objfile->objfile_obstack, sizeof (struct field)); |
c906108c SS |
4571 | TYPE_FIELD_TYPE (type, 0) = hpread_type_lookup (dn_bufp->darray.indextype, |
4572 | objfile); | |
4573 | return type; | |
4574 | } | |
4575 | ||
4576 | /* Read in and internalize a subrange debug symbol. */ | |
4577 | static struct type * | |
fba45db2 KB |
4578 | hpread_read_subrange_type (dnttpointer hp_type, union dnttentry *dn_bufp, |
4579 | struct objfile *objfile) | |
c906108c SS |
4580 | { |
4581 | struct type *type; | |
4582 | ||
4583 | /* Is it something we've already dealt with. */ | |
4584 | type = hpread_alloc_type (hp_type, objfile); | |
4585 | if (TYPE_CODE (type) == TYPE_CODE_RANGE) | |
4586 | return type; | |
4587 | ||
4588 | /* Nope, internalize it. */ | |
4589 | TYPE_CODE (type) = TYPE_CODE_RANGE; | |
4590 | TYPE_LENGTH (type) = dn_bufp->dsubr.bitlength / 8; | |
4591 | TYPE_NFIELDS (type) = 2; | |
4592 | TYPE_FIELDS (type) | |
b99607ea | 4593 | = (struct field *) obstack_alloc (&objfile->objfile_obstack, |
c906108c SS |
4594 | 2 * sizeof (struct field)); |
4595 | ||
4596 | if (dn_bufp->dsubr.dyn_low) | |
4597 | TYPE_FIELD_BITPOS (type, 0) = 0; | |
4598 | else | |
4599 | TYPE_FIELD_BITPOS (type, 0) = dn_bufp->dsubr.lowbound; | |
4600 | ||
4601 | if (dn_bufp->dsubr.dyn_high) | |
4602 | TYPE_FIELD_BITPOS (type, 1) = -1; | |
4603 | else | |
4604 | TYPE_FIELD_BITPOS (type, 1) = dn_bufp->dsubr.highbound; | |
4605 | TYPE_TARGET_TYPE (type) = hpread_type_lookup (dn_bufp->dsubr.subtype, | |
4606 | objfile); | |
4607 | return type; | |
4608 | } | |
4609 | ||
8af51c36 EZ |
4610 | /* struct type * hpread_type_lookup(hp_type, objfile) |
4611 | * Arguments: | |
4612 | * hp_type: A pointer into the DNTT specifying what type we | |
4613 | * are about to "look up"., or else [for fundamental types | |
4614 | * like int, float, ...] an "immediate" structure describing | |
4615 | * the type. | |
4616 | * objfile: ? | |
4617 | * Return value: A pointer to a "struct type" (representation of a | |
4618 | * type in GDB's internal symbol table - see gdbtypes.h) | |
4619 | * Routine description: | |
4620 | * There are a variety of places when scanning the DNTT when we | |
4621 | * need to interpret a "type" field. The simplest and most basic | |
4622 | * example is when we're processing the symbol table record | |
4623 | * for a data symbol (a SVAR or DVAR record). That has | |
4624 | * a "type" field specifying the type of the data symbol. That | |
4625 | * "type" field is either an "immediate" type specification (for the | |
4626 | * fundamental types) or a DNTT pointer (for more complicated types). | |
4627 | * For the more complicated types, we may or may not have already | |
4628 | * processed the pointed-to type. (Multiple data symbols can of course | |
4629 | * share the same type). | |
4630 | * The job of hpread_type_lookup() is to process this "type" field. | |
4631 | * Most of the real work is done in subroutines. Here we interpret | |
4632 | * the immediate flag. If not immediate, chase the DNTT pointer to | |
4633 | * find our way to the SOM record describing the type, switch on | |
4634 | * the SOM kind, and then call an appropriate subroutine depending | |
4635 | * on what kind of type we are constructing. (e.g., an array type, | |
4636 | * a struct/class type, etc). | |
4637 | */ | |
c906108c | 4638 | static struct type * |
fba45db2 | 4639 | hpread_type_lookup (dnttpointer hp_type, struct objfile *objfile) |
c906108c SS |
4640 | { |
4641 | union dnttentry *dn_bufp; | |
8af51c36 | 4642 | struct type *tmp_type; |
c906108c SS |
4643 | |
4644 | /* First see if it's a simple builtin type. */ | |
4645 | if (hp_type.dntti.immediate) | |
8af51c36 EZ |
4646 | { |
4647 | /* If this is a template argument, the argument number is | |
4648 | * encoded in the bitlength. All other cases, just return | |
4649 | * GDB's representation of this fundamental type. | |
4650 | */ | |
4651 | if (hp_type.dntti.type == HP_TYPE_TEMPLATE_ARG) | |
4652 | return hpread_get_nth_template_arg (objfile, hp_type.dntti.bitlength); | |
4653 | else | |
4654 | return lookup_fundamental_type (objfile, | |
4655 | hpread_type_translate (hp_type)); | |
4656 | } | |
c906108c SS |
4657 | |
4658 | /* Not a builtin type. We'll have to read it in. */ | |
4659 | if (hp_type.dnttp.index < LNTT_SYMCOUNT (objfile)) | |
4660 | dn_bufp = hpread_get_lntt (hp_type.dnttp.index, objfile); | |
4661 | else | |
8af51c36 | 4662 | /* This is a fancy way of returning NULL */ |
c906108c SS |
4663 | return lookup_fundamental_type (objfile, FT_VOID); |
4664 | ||
4665 | switch (dn_bufp->dblock.kind) | |
4666 | { | |
4667 | case DNTT_TYPE_SRCFILE: | |
4668 | case DNTT_TYPE_MODULE: | |
c906108c SS |
4669 | case DNTT_TYPE_ENTRY: |
4670 | case DNTT_TYPE_BEGIN: | |
4671 | case DNTT_TYPE_END: | |
4672 | case DNTT_TYPE_IMPORT: | |
4673 | case DNTT_TYPE_LABEL: | |
c906108c SS |
4674 | case DNTT_TYPE_FPARAM: |
4675 | case DNTT_TYPE_SVAR: | |
4676 | case DNTT_TYPE_DVAR: | |
4677 | case DNTT_TYPE_CONST: | |
8af51c36 EZ |
4678 | case DNTT_TYPE_MEMENUM: |
4679 | case DNTT_TYPE_VARIANT: | |
4680 | case DNTT_TYPE_FILE: | |
4681 | case DNTT_TYPE_WITH: | |
4682 | case DNTT_TYPE_COMMON: | |
4683 | case DNTT_TYPE_COBSTRUCT: | |
4684 | case DNTT_TYPE_XREF: | |
4685 | case DNTT_TYPE_SA: | |
4686 | case DNTT_TYPE_MACRO: | |
4687 | case DNTT_TYPE_BLOCKDATA: | |
4688 | case DNTT_TYPE_CLASS_SCOPE: | |
4689 | case DNTT_TYPE_MEMACCESS: | |
4690 | case DNTT_TYPE_INHERITANCE: | |
4691 | case DNTT_TYPE_OBJECT_ID: | |
4692 | case DNTT_TYPE_FRIEND_CLASS: | |
4693 | case DNTT_TYPE_FRIEND_FUNC: | |
4694 | /* These are not types - something went wrong. */ | |
4695 | /* This is a fancy way of returning NULL */ | |
c906108c SS |
4696 | return lookup_fundamental_type (objfile, FT_VOID); |
4697 | ||
8af51c36 EZ |
4698 | case DNTT_TYPE_FUNCTION: |
4699 | /* We wind up here when dealing with class member functions | |
4700 | * (called from hpread_read_struct_type(), i.e. when processing | |
4701 | * the class definition itself). | |
4702 | */ | |
4703 | return hpread_read_function_type (hp_type, dn_bufp, objfile, 0); | |
4704 | ||
4705 | case DNTT_TYPE_DOC_FUNCTION: | |
4706 | return hpread_read_doc_function_type (hp_type, dn_bufp, objfile, 0); | |
4707 | ||
c906108c SS |
4708 | case DNTT_TYPE_TYPEDEF: |
4709 | { | |
8af51c36 | 4710 | /* A typedef - chase it down by making a recursive call */ |
c906108c SS |
4711 | struct type *structtype = hpread_type_lookup (dn_bufp->dtype.type, |
4712 | objfile); | |
c906108c | 4713 | |
8af51c36 EZ |
4714 | /* The following came from the base hpread.c that we inherited. |
4715 | * It is WRONG so I have commented it out. - RT | |
4716 | *... | |
4717 | ||
4718 | char *suffix; | |
4719 | suffix = VT (objfile) + dn_bufp->dtype.name; | |
4720 | TYPE_NAME (structtype) = suffix; | |
4721 | ||
4722 | * ... further explanation .... | |
4723 | * | |
4724 | * What we have here is a typedef pointing to a typedef. | |
4725 | * E.g., | |
4726 | * typedef int foo; | |
4727 | * typedef foo fum; | |
4728 | * | |
4729 | * What we desire to build is (these are pictures | |
4730 | * of "struct type"'s): | |
4731 | * | |
4732 | * +---------+ +----------+ +------------+ | |
4733 | * | typedef | | typedef | | fund. type | | |
4734 | * | type| -> | type| -> | | | |
4735 | * | "fum" | | "foo" | | "int" | | |
4736 | * +---------+ +----------+ +------------+ | |
4737 | * | |
4738 | * What this commented-out code is doing is smashing the | |
4739 | * name of pointed-to-type to be the same as the pointed-from | |
4740 | * type. So we wind up with something like: | |
4741 | * | |
4742 | * +---------+ +----------+ +------------+ | |
4743 | * | typedef | | typedef | | fund. type | | |
4744 | * | type| -> | type| -> | | | |
4745 | * | "fum" | | "fum" | | "fum" | | |
4746 | * +---------+ +----------+ +------------+ | |
4747 | * | |
4748 | */ | |
4749 | ||
c906108c SS |
4750 | return structtype; |
4751 | } | |
4752 | ||
4753 | case DNTT_TYPE_TAGDEF: | |
4754 | { | |
4755 | /* Just a little different from above. We have to tack on | |
8af51c36 EZ |
4756 | * an identifier of some kind (struct, union, enum, class, etc). |
4757 | */ | |
c906108c SS |
4758 | struct type *structtype = hpread_type_lookup (dn_bufp->dtype.type, |
4759 | objfile); | |
4760 | char *prefix, *suffix; | |
4761 | suffix = VT (objfile) + dn_bufp->dtype.name; | |
4762 | ||
4763 | /* Lookup the next type in the list. It should be a structure, | |
8af51c36 EZ |
4764 | * union, class, enum, or template type. |
4765 | * We will need to attach that to our name. | |
4766 | */ | |
c906108c SS |
4767 | if (dn_bufp->dtype.type.dnttp.index < LNTT_SYMCOUNT (objfile)) |
4768 | dn_bufp = hpread_get_lntt (dn_bufp->dtype.type.dnttp.index, objfile); | |
4769 | else | |
8af51c36 | 4770 | { |
e2e0b3e5 | 4771 | complaint (&symfile_complaints, _("error in hpread_type_lookup().")); |
8af51c36 EZ |
4772 | return NULL; |
4773 | } | |
c906108c SS |
4774 | |
4775 | if (dn_bufp->dblock.kind == DNTT_TYPE_STRUCT) | |
8af51c36 EZ |
4776 | { |
4777 | prefix = "struct "; | |
4778 | } | |
c906108c | 4779 | else if (dn_bufp->dblock.kind == DNTT_TYPE_UNION) |
8af51c36 EZ |
4780 | { |
4781 | prefix = "union "; | |
4782 | } | |
4783 | else if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS) | |
4784 | { | |
4785 | /* Further field for CLASS saying how it was really declared */ | |
4786 | /* 0==class, 1==union, 2==struct */ | |
4787 | if (dn_bufp->dclass.class_decl == 0) | |
4788 | prefix = "class "; | |
4789 | else if (dn_bufp->dclass.class_decl == 1) | |
4790 | prefix = "union "; | |
4791 | else if (dn_bufp->dclass.class_decl == 2) | |
4792 | prefix = "struct "; | |
4793 | else | |
4794 | prefix = ""; | |
4795 | } | |
4796 | else if (dn_bufp->dblock.kind == DNTT_TYPE_ENUM) | |
4797 | { | |
4798 | prefix = "enum "; | |
4799 | } | |
4800 | else if (dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE) | |
4801 | { | |
4802 | prefix = "template "; | |
4803 | } | |
c906108c | 4804 | else |
8af51c36 EZ |
4805 | { |
4806 | prefix = ""; | |
4807 | } | |
c906108c SS |
4808 | |
4809 | /* Build the correct name. */ | |
0004e5a2 | 4810 | TYPE_NAME (structtype) |
b99607ea | 4811 | = (char *) obstack_alloc (&objfile->objfile_obstack, |
c906108c SS |
4812 | strlen (prefix) + strlen (suffix) + 1); |
4813 | TYPE_NAME (structtype) = strcpy (TYPE_NAME (structtype), prefix); | |
4814 | TYPE_NAME (structtype) = strcat (TYPE_NAME (structtype), suffix); | |
4815 | TYPE_TAG_NAME (structtype) = suffix; | |
4816 | ||
8af51c36 EZ |
4817 | /* For classes/structs, we have to set the static member "physnames" |
4818 | to point to strings like "Class::Member" */ | |
4819 | if (TYPE_CODE (structtype) == TYPE_CODE_STRUCT) | |
4820 | fix_static_member_physnames (structtype, suffix, objfile); | |
c906108c SS |
4821 | |
4822 | return structtype; | |
4823 | } | |
8af51c36 | 4824 | |
c906108c | 4825 | case DNTT_TYPE_POINTER: |
8af51c36 EZ |
4826 | /* Pointer type - call a routine in gdbtypes.c that constructs |
4827 | * the appropriate GDB type. | |
4828 | */ | |
4829 | return make_pointer_type ( | |
4830 | hpread_type_lookup (dn_bufp->dptr.pointsto, | |
4831 | objfile), | |
4832 | NULL); | |
4833 | ||
4834 | case DNTT_TYPE_REFERENCE: | |
4835 | /* C++ reference type - call a routine in gdbtypes.c that constructs | |
4836 | * the appropriate GDB type. | |
4837 | */ | |
4838 | return make_reference_type ( | |
4839 | hpread_type_lookup (dn_bufp->dreference.pointsto, | |
4840 | objfile), | |
4841 | NULL); | |
4842 | ||
c906108c SS |
4843 | case DNTT_TYPE_ENUM: |
4844 | return hpread_read_enum_type (hp_type, dn_bufp, objfile); | |
c906108c SS |
4845 | case DNTT_TYPE_SET: |
4846 | return hpread_read_set_type (hp_type, dn_bufp, objfile); | |
4847 | case DNTT_TYPE_SUBRANGE: | |
4848 | return hpread_read_subrange_type (hp_type, dn_bufp, objfile); | |
4849 | case DNTT_TYPE_ARRAY: | |
4850 | return hpread_read_array_type (hp_type, dn_bufp, objfile); | |
4851 | case DNTT_TYPE_STRUCT: | |
4852 | case DNTT_TYPE_UNION: | |
4853 | return hpread_read_struct_type (hp_type, dn_bufp, objfile); | |
4854 | case DNTT_TYPE_FIELD: | |
4855 | return hpread_type_lookup (dn_bufp->dfield.type, objfile); | |
8af51c36 | 4856 | |
c906108c | 4857 | case DNTT_TYPE_FUNCTYPE: |
8af51c36 EZ |
4858 | /* Here we want to read the function SOMs and return a |
4859 | * type for it. We get here, for instance, when processing | |
4860 | * pointer-to-function type. | |
4861 | */ | |
4862 | return hpread_read_function_type (hp_type, dn_bufp, objfile, 0); | |
4863 | ||
4864 | case DNTT_TYPE_PTRMEM: | |
4865 | /* Declares a C++ pointer-to-data-member type. | |
4866 | * The "pointsto" field defines the class, | |
4867 | * while the "memtype" field defines the pointed-to-type. | |
4868 | */ | |
4869 | { | |
4870 | struct type *ptrmemtype; | |
4871 | struct type *class_type; | |
4872 | struct type *memtype; | |
53103997 JB |
4873 | |
4874 | memtype = hpread_type_lookup (dn_bufp->dptrmem.memtype, objfile); | |
4875 | class_type = hpread_type_lookup (dn_bufp->dptrmem.pointsto, objfile); | |
0d5de010 | 4876 | return lookup_memberptr_type (memtype, class_type); |
8af51c36 EZ |
4877 | } |
4878 | break; | |
4879 | ||
4880 | case DNTT_TYPE_PTRMEMFUNC: | |
4881 | /* Defines a C++ pointer-to-function-member type. | |
4882 | * The "pointsto" field defines the class, | |
4883 | * while the "memtype" field defines the pointed-to-type. | |
4884 | */ | |
4885 | { | |
4886 | struct type *ptrmemtype; | |
4887 | struct type *class_type; | |
4888 | struct type *functype; | |
4889 | struct type *retvaltype; | |
4890 | int nargs; | |
4891 | int i; | |
8af51c36 EZ |
4892 | class_type = hpread_type_lookup (dn_bufp->dptrmem.pointsto, |
4893 | objfile); | |
4894 | functype = hpread_type_lookup (dn_bufp->dptrmem.memtype, | |
4895 | objfile); | |
4896 | retvaltype = TYPE_TARGET_TYPE (functype); | |
4897 | nargs = TYPE_NFIELDS (functype); | |
8af51c36 | 4898 | ptrmemtype = alloc_type (objfile); |
ad2f7632 DJ |
4899 | |
4900 | smash_to_method_type (ptrmemtype, class_type, retvaltype, | |
4901 | TYPE_FIELDS (functype), | |
4902 | TYPE_NFIELDS (functype), | |
4903 | 0); | |
0d5de010 | 4904 | return lookup_methodptr_type (ptrmemtype); |
8af51c36 EZ |
4905 | } |
4906 | break; | |
4907 | ||
4908 | case DNTT_TYPE_CLASS: | |
4909 | return hpread_read_struct_type (hp_type, dn_bufp, objfile); | |
4910 | ||
4911 | case DNTT_TYPE_GENFIELD: | |
4912 | /* Chase pointer from GENFIELD to FIELD, and make recursive | |
4913 | * call on that. | |
4914 | */ | |
4915 | return hpread_type_lookup (dn_bufp->dgenfield.field, objfile); | |
4916 | ||
4917 | case DNTT_TYPE_VFUNC: | |
4918 | /* C++ virtual function. | |
4919 | * We get here in the course of processing a class type which | |
4920 | * contains virtual functions. Just go through another level | |
4921 | * of indirection to get to the pointed-to function SOM. | |
4922 | */ | |
4923 | return hpread_type_lookup (dn_bufp->dvfunc.funcptr, objfile); | |
4924 | ||
4925 | case DNTT_TYPE_MODIFIER: | |
4926 | /* Check the modifiers and then just make a recursive call on | |
4927 | * the "type" pointed to by the modifier DNTT. | |
4928 | * | |
4929 | * pai:: FIXME -- do we ever want to handle "m_duplicate" and | |
4930 | * "m_void" modifiers? Is static_flag really needed here? | |
4931 | * (m_static used for methods of classes, elsewhere). | |
4932 | */ | |
4933 | tmp_type = make_cv_type (dn_bufp->dmodifier.m_const, | |
4934 | dn_bufp->dmodifier.m_volatile, | |
4935 | hpread_type_lookup (dn_bufp->dmodifier.type, objfile), | |
4936 | 0); | |
4937 | return tmp_type; | |
4938 | ||
4939 | ||
4940 | case DNTT_TYPE_MEMFUNC: | |
4941 | /* Member function. Treat like a function. | |
4942 | * I think we get here in the course of processing a | |
4943 | * pointer-to-member-function type... | |
4944 | */ | |
4945 | return hpread_read_function_type (hp_type, dn_bufp, objfile, 0); | |
4946 | ||
4947 | case DNTT_TYPE_DOC_MEMFUNC: | |
4948 | return hpread_read_doc_function_type (hp_type, dn_bufp, objfile, 0); | |
4949 | ||
4950 | case DNTT_TYPE_TEMPLATE: | |
4951 | /* Template - sort of the header for a template definition, | |
4952 | * which like a class, points to a member list and also points | |
4953 | * to a TEMPLATE_ARG list of type-arguments. | |
4954 | */ | |
4955 | return hpread_read_struct_type (hp_type, dn_bufp, objfile); | |
4956 | ||
4957 | case DNTT_TYPE_TEMPLATE_ARG: | |
4958 | { | |
4959 | char *name; | |
4960 | /* The TEMPLATE record points to an argument list of | |
4961 | * TEMPLATE_ARG records, each of which describes one | |
4962 | * of the type-arguments. | |
4963 | */ | |
4964 | name = VT (objfile) + dn_bufp->dtempl_arg.name; | |
4965 | return hpread_read_templ_arg_type (hp_type, dn_bufp, objfile, name); | |
4966 | } | |
4967 | ||
4968 | case DNTT_TYPE_FUNC_TEMPLATE: | |
4969 | /* We wind up here when processing a TEMPLATE type, | |
4970 | * if the template has member function(s). | |
4971 | * Treat it like a FUNCTION. | |
4972 | */ | |
4973 | return hpread_read_function_type (hp_type, dn_bufp, objfile, 0); | |
4974 | ||
4975 | case DNTT_TYPE_LINK: | |
4976 | /* The LINK record is used to link up templates with instantiations. | |
4977 | * There is no type associated with the LINK record per se. | |
4978 | */ | |
4979 | return lookup_fundamental_type (objfile, FT_VOID); | |
4980 | ||
4981 | /* Also not yet handled... */ | |
4982 | /* case DNTT_TYPE_DYN_ARRAY_DESC: */ | |
4983 | /* case DNTT_TYPE_DESC_SUBRANGE: */ | |
4984 | /* case DNTT_TYPE_BEGIN_EXT: */ | |
4985 | /* case DNTT_TYPE_INLN: */ | |
4986 | /* case DNTT_TYPE_INLN_LIST: */ | |
4987 | /* case DNTT_TYPE_ALIAS: */ | |
c906108c | 4988 | default: |
8af51c36 | 4989 | /* A fancy way of returning NULL */ |
c906108c SS |
4990 | return lookup_fundamental_type (objfile, FT_VOID); |
4991 | } | |
4992 | } | |
4993 | ||
4994 | static sltpointer | |
fba45db2 KB |
4995 | hpread_record_lines (struct subfile *subfile, sltpointer s_idx, |
4996 | sltpointer e_idx, struct objfile *objfile, | |
4997 | CORE_ADDR offset) | |
c906108c SS |
4998 | { |
4999 | union sltentry *sl_bufp; | |
5000 | ||
5001 | while (s_idx <= e_idx) | |
5002 | { | |
5003 | sl_bufp = hpread_get_slt (s_idx, objfile); | |
5004 | /* Only record "normal" entries in the SLT. */ | |
5005 | if (sl_bufp->snorm.sltdesc == SLT_NORMAL | |
5006 | || sl_bufp->snorm.sltdesc == SLT_EXIT) | |
5007 | record_line (subfile, sl_bufp->snorm.line, | |
5008 | sl_bufp->snorm.address + offset); | |
8af51c36 EZ |
5009 | else if (sl_bufp->snorm.sltdesc == SLT_NORMAL_OFFSET) |
5010 | record_line (subfile, sl_bufp->snormoff.line, | |
5011 | sl_bufp->snormoff.address + offset); | |
c906108c SS |
5012 | s_idx++; |
5013 | } | |
5014 | return e_idx; | |
5015 | } | |
5016 | ||
8af51c36 EZ |
5017 | /* Given a function "f" which is a member of a class, find |
5018 | * the classname that it is a member of. Used to construct | |
5019 | * the name (e.g., "c::f") which GDB will put in the | |
5020 | * "demangled name" field of the function's symbol. | |
5021 | * Called from hpread_process_one_debug_symbol() | |
5022 | * If "f" is not a member function, return NULL. | |
5023 | */ | |
f5479e9c | 5024 | static char * |
8af51c36 EZ |
5025 | class_of (struct type *functype) |
5026 | { | |
5027 | struct type *first_param_type; | |
5028 | char *first_param_name; | |
5029 | struct type *pointed_to_type; | |
5030 | char *class_name; | |
5031 | ||
5032 | /* Check that the function has a first argument "this", | |
5033 | * and that "this" is a pointer to a class. If not, | |
5034 | * functype is not a member function, so return NULL. | |
5035 | */ | |
5036 | if (TYPE_NFIELDS (functype) == 0) | |
5037 | return NULL; | |
5038 | first_param_name = TYPE_FIELD_NAME (functype, 0); | |
5039 | if (first_param_name == NULL) | |
5040 | return NULL; /* paranoia */ | |
5041 | if (strcmp (first_param_name, "this")) | |
5042 | return NULL; | |
5043 | first_param_type = TYPE_FIELD_TYPE (functype, 0); | |
5044 | if (first_param_type == NULL) | |
5045 | return NULL; /* paranoia */ | |
5046 | if (TYPE_CODE (first_param_type) != TYPE_CODE_PTR) | |
5047 | return NULL; | |
5048 | ||
5049 | /* Get the thing that "this" points to, check that | |
5050 | * it's a class, and get its class name. | |
5051 | */ | |
5052 | pointed_to_type = TYPE_TARGET_TYPE (first_param_type); | |
5053 | if (pointed_to_type == NULL) | |
5054 | return NULL; /* paranoia */ | |
5055 | if (TYPE_CODE (pointed_to_type) != TYPE_CODE_CLASS) | |
5056 | return NULL; | |
5057 | class_name = TYPE_NAME (pointed_to_type); | |
5058 | if (class_name == NULL) | |
5059 | return NULL; /* paranoia */ | |
5060 | ||
5061 | /* The class name may be of the form "class c", in which case | |
5062 | * we want to strip off the leading "class ". | |
5063 | */ | |
5064 | if (strncmp (class_name, "class ", 6) == 0) | |
5065 | class_name += 6; | |
5066 | ||
5067 | return class_name; | |
5068 | } | |
5069 | ||
5070 | /* Internalize one native debug symbol. | |
5071 | * Called in a loop from hpread_expand_symtab(). | |
5072 | * Arguments: | |
5073 | * dn_bufp: | |
5074 | * name: | |
5075 | * section_offsets: | |
5076 | * objfile: | |
5077 | * text_offset: | |
5078 | * text_size: | |
5079 | * filename: | |
5080 | * index: Index of this symbol | |
5081 | * at_module_boundary_p Pointer to boolean flag to control caller's loop. | |
5082 | */ | |
c906108c SS |
5083 | |
5084 | static void | |
fba45db2 KB |
5085 | hpread_process_one_debug_symbol (union dnttentry *dn_bufp, char *name, |
5086 | struct section_offsets *section_offsets, | |
5087 | struct objfile *objfile, CORE_ADDR text_offset, | |
8af51c36 EZ |
5088 | int text_size, char *filename, int index, |
5089 | int *at_module_boundary_p) | |
c906108c SS |
5090 | { |
5091 | unsigned long desc; | |
5092 | int type; | |
5093 | CORE_ADDR valu; | |
b8fbeb18 | 5094 | int offset = ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile)); |
8af51c36 | 5095 | int data_offset = ANOFFSET (section_offsets, SECT_OFF_DATA (objfile)); |
c906108c SS |
5096 | union dnttentry *dn_temp; |
5097 | dnttpointer hp_type; | |
5098 | struct symbol *sym; | |
5099 | struct context_stack *new; | |
8af51c36 | 5100 | char *class_scope_name; |
c906108c | 5101 | |
8af51c36 | 5102 | /* Allocate one GDB debug symbol and fill in some default values. */ |
4a146b47 | 5103 | sym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack, |
c906108c SS |
5104 | sizeof (struct symbol)); |
5105 | memset (sym, 0, sizeof (struct symbol)); | |
4a146b47 | 5106 | DEPRECATED_SYMBOL_NAME (sym) = obsavestring (name, strlen (name), &objfile->objfile_obstack); |
c906108c | 5107 | SYMBOL_LANGUAGE (sym) = language_auto; |
176620f1 | 5108 | SYMBOL_DOMAIN (sym) = VAR_DOMAIN; |
c906108c SS |
5109 | SYMBOL_LINE (sym) = 0; |
5110 | SYMBOL_VALUE (sym) = 0; | |
5111 | SYMBOL_CLASS (sym) = LOC_TYPEDEF; | |
5112 | ||
8af51c36 EZ |
5113 | /* Just a trick in case the SOM debug symbol is a type definition. |
5114 | * There are routines that are set up to build a GDB type symbol, given | |
5115 | * a SOM dnttpointer. So we set up a dummy SOM dnttpointer "hp_type". | |
5116 | * This allows us to call those same routines. | |
5117 | */ | |
c906108c SS |
5118 | hp_type.dnttp.extension = 1; |
5119 | hp_type.dnttp.immediate = 0; | |
5120 | hp_type.dnttp.global = 0; | |
5121 | hp_type.dnttp.index = index; | |
5122 | ||
8af51c36 EZ |
5123 | /* This "type" is the type of SOM record. |
5124 | * Switch on SOM type. | |
5125 | */ | |
c906108c | 5126 | type = dn_bufp->dblock.kind; |
c906108c SS |
5127 | switch (type) |
5128 | { | |
5129 | case DNTT_TYPE_SRCFILE: | |
8af51c36 EZ |
5130 | /* This type of symbol indicates from which source file or |
5131 | * include file any following data comes. It may indicate: | |
5132 | * | |
5133 | * o The start of an entirely new source file (and thus | |
5134 | * a new module) | |
5135 | * | |
5136 | * o The start of a different source file due to #include | |
5137 | * | |
5138 | * o The end of an include file and the return to the original | |
5139 | * file. Thus if "foo.c" includes "bar.h", we see first | |
5140 | * a SRCFILE for foo.c, then one for bar.h, and then one for | |
5141 | * foo.c again. | |
5142 | * | |
5143 | * If it indicates the start of a new module then we must | |
5144 | * finish the symbol table of the previous module | |
5145 | * (if any) and start accumulating a new symbol table. | |
5146 | */ | |
c906108c SS |
5147 | |
5148 | valu = text_offset; | |
5149 | if (!last_source_file) | |
5150 | { | |
8af51c36 EZ |
5151 | /* |
5152 | * A note on "last_source_file": this is a char* pointing | |
5153 | * to the actual file name. "start_symtab" sets it, | |
5154 | * "end_symtab" clears it. | |
5155 | * | |
5156 | * So if "last_source_file" is NULL, then either this is | |
5157 | * the first record we are looking at, or a previous call | |
5158 | * to "end_symtab()" was made to close out the previous | |
5159 | * module. Since we're now quitting the scan loop when we | |
5160 | * see a MODULE END record, we should never get here, except | |
5161 | * in the case that we're not using the quick look-up tables | |
5162 | * and have to use the old system as a fall-back. | |
5163 | */ | |
c906108c SS |
5164 | start_symtab (name, NULL, valu); |
5165 | record_debugformat ("HP"); | |
5166 | SL_INDEX (objfile) = dn_bufp->dsfile.address; | |
5167 | } | |
8af51c36 EZ |
5168 | |
5169 | else | |
5170 | { | |
5171 | /* Either a new include file, or a SRCFILE record | |
5172 | * saying we are back in the main source (or out of | |
5173 | * a nested include file) again. | |
5174 | */ | |
5175 | SL_INDEX (objfile) = hpread_record_lines (current_subfile, | |
5176 | SL_INDEX (objfile), | |
5177 | dn_bufp->dsfile.address, | |
5178 | objfile, offset); | |
5179 | } | |
5180 | ||
5181 | /* A note on "start_subfile". This routine will check | |
5182 | * the name we pass it and look for an existing subfile | |
5183 | * of that name. There's thus only one sub-file for the | |
5184 | * actual source (e.g. for "foo.c" in foo.c), despite the | |
5185 | * fact that we'll see lots of SRCFILE entries for foo.c | |
5186 | * inside foo.c. | |
5187 | */ | |
5188 | start_subfile (name, NULL); | |
5189 | break; | |
5190 | ||
5191 | case DNTT_TYPE_MODULE: | |
5192 | /* | |
5193 | * We no longer ignore DNTT_TYPE_MODULE symbols. The module | |
5194 | * represents the meaningful semantic structure of a compilation | |
5195 | * unit. We expect to start the psymtab-to-symtab expansion | |
5196 | * looking at a MODULE entry, and to end it at the corresponding | |
5197 | * END MODULE entry. | |
5198 | * | |
5199 | *--Begin outdated comments | |
5200 | * | |
5201 | * This record signifies the start of a new source module | |
5202 | * In C/C++ there is no explicit "module" construct in the language, | |
5203 | * but each compilation unit is implicitly a module and they | |
5204 | * do emit the DNTT_TYPE_MODULE records. | |
5205 | * The end of the module is marked by a matching DNTT_TYPE_END record. | |
5206 | * | |
5207 | * The reason GDB gets away with ignoring the DNTT_TYPE_MODULE record | |
5208 | * is it notices the DNTT_TYPE_END record for the previous | |
5209 | * module (see comments under DNTT_TYPE_END case), and then treats | |
5210 | * the next DNTT_TYPE_SRCFILE record as if it were the module-start record. | |
5211 | * (i.e., it makes a start_symtab() call). | |
5212 | * This scheme seems a little convoluted, but I'll leave it | |
5213 | * alone on the principle "if it ain't broke don't fix | |
5214 | * it". (RT). | |
5215 | * | |
5216 | *-- End outdated comments | |
5217 | */ | |
5218 | ||
5219 | valu = text_offset; | |
5220 | if (!last_source_file) | |
5221 | { | |
5222 | /* Start of a new module. We know this because "last_source_file" | |
5223 | * is NULL, which can only happen the first time or if we just | |
5224 | * made a call to end_symtab() to close out the previous module. | |
5225 | */ | |
5226 | start_symtab (name, NULL, valu); | |
5227 | SL_INDEX (objfile) = dn_bufp->dmodule.address; | |
5228 | } | |
c906108c SS |
5229 | else |
5230 | { | |
8af51c36 EZ |
5231 | /* This really shouldn't happen if we're using the quick |
5232 | * look-up tables, as it would mean we'd scanned past an | |
5233 | * END MODULE entry. But if we're not using the tables, | |
5234 | * we started the module on the SRCFILE entry, so it's ok. | |
5235 | * For now, accept this. | |
5236 | */ | |
5237 | /* warning( "Error expanding psymtab, missed module end, found entry for %s", | |
5238 | * name ); | |
5239 | */ | |
5240 | *at_module_boundary_p = -1; | |
c906108c | 5241 | } |
c5aa993b | 5242 | |
8af51c36 | 5243 | start_subfile (name, NULL); |
c906108c SS |
5244 | break; |
5245 | ||
5246 | case DNTT_TYPE_FUNCTION: | |
5247 | case DNTT_TYPE_ENTRY: | |
5248 | /* A function or secondary entry point. */ | |
5249 | valu = dn_bufp->dfunc.lowaddr + offset; | |
8af51c36 EZ |
5250 | |
5251 | /* Record lines up to this point. */ | |
c906108c SS |
5252 | SL_INDEX (objfile) = hpread_record_lines (current_subfile, |
5253 | SL_INDEX (objfile), | |
5254 | dn_bufp->dfunc.address, | |
5255 | objfile, offset); | |
c5aa993b | 5256 | |
c906108c SS |
5257 | WITHIN_FUNCTION (objfile) = 1; |
5258 | CURRENT_FUNCTION_VALUE (objfile) = valu; | |
5259 | ||
5260 | /* Stack must be empty now. */ | |
5261 | if (context_stack_depth != 0) | |
1fb309ea | 5262 | lbrac_unmatched_complaint (symnum); |
c906108c SS |
5263 | new = push_context (0, valu); |
5264 | ||
8af51c36 EZ |
5265 | /* Built a type for the function. This includes processing |
5266 | * the symbol records for the function parameters. | |
5267 | */ | |
c906108c | 5268 | SYMBOL_CLASS (sym) = LOC_BLOCK; |
8af51c36 EZ |
5269 | SYMBOL_TYPE (sym) = hpread_read_function_type (hp_type, dn_bufp, objfile, 1); |
5270 | ||
1e698235 DJ |
5271 | /* All functions in C++ have prototypes. For C we don't have enough |
5272 | information in the debug info. */ | |
3269bcfa JB |
5273 | if (SYMBOL_LANGUAGE (sym) == language_cplus) |
5274 | TYPE_FLAGS (SYMBOL_TYPE (sym)) |= TYPE_FLAG_PROTOTYPED; | |
1e698235 | 5275 | |
22abf04a | 5276 | /* The "DEPRECATED_SYMBOL_NAME" field is expected to be the mangled name |
8af51c36 EZ |
5277 | * (if any), which we get from the "alias" field of the SOM record |
5278 | * if that exists. | |
5279 | */ | |
5280 | if ((dn_bufp->dfunc.language == HP_LANGUAGE_CPLUSPLUS) && | |
5281 | dn_bufp->dfunc.alias && /* has an alias */ | |
5282 | *(char *) (VT (objfile) + dn_bufp->dfunc.alias)) /* not a null string */ | |
22abf04a | 5283 | DEPRECATED_SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->dfunc.alias; |
8af51c36 | 5284 | else |
22abf04a | 5285 | DEPRECATED_SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->dfunc.name; |
8af51c36 EZ |
5286 | |
5287 | /* Special hack to get around HP compilers' insistence on | |
5288 | * reporting "main" as "_MAIN_" for C/C++ */ | |
22abf04a | 5289 | if ((strcmp (DEPRECATED_SYMBOL_NAME (sym), "_MAIN_") == 0) && |
8af51c36 | 5290 | (strcmp (VT (objfile) + dn_bufp->dfunc.name, "main") == 0)) |
22abf04a | 5291 | DEPRECATED_SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->dfunc.name; |
8af51c36 EZ |
5292 | |
5293 | /* The SYMBOL_CPLUS_DEMANGLED_NAME field is expected to | |
5294 | * be the demangled name. | |
5295 | */ | |
5296 | if (dn_bufp->dfunc.language == HP_LANGUAGE_CPLUSPLUS) | |
5297 | { | |
5298 | /* SYMBOL_INIT_DEMANGLED_NAME is a macro which winds up | |
5299 | * calling the demangler in libiberty (cplus_demangle()) to | |
5300 | * do the job. This generally does the job, even though | |
5301 | * it's intended for the GNU compiler and not the aCC compiler | |
5302 | * Note that SYMBOL_INIT_DEMANGLED_NAME calls the | |
5303 | * demangler with arguments DMGL_PARAMS | DMGL_ANSI. | |
5304 | * Generally, we don't want params when we display | |
5305 | * a demangled name, but when I took out the DMGL_PARAMS, | |
5306 | * some things broke, so I'm leaving it in here, and | |
5307 | * working around the issue in stack.c. - RT | |
5308 | */ | |
4a146b47 | 5309 | SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->objfile_obstack); |
22abf04a | 5310 | if ((DEPRECATED_SYMBOL_NAME (sym) == VT (objfile) + dn_bufp->dfunc.alias) && |
8af51c36 EZ |
5311 | (!SYMBOL_CPLUS_DEMANGLED_NAME (sym))) |
5312 | { | |
5313 | ||
5314 | /* Well, the symbol name is mangled, but the | |
5315 | * demangler in libiberty failed so the demangled | |
5316 | * field is still NULL. Try to | |
5317 | * do the job ourselves based on the "name" field | |
5318 | * in the SOM record. A complication here is that | |
5319 | * the name field contains only the function name | |
5320 | * (like "f"), whereas we want the class qualification | |
5321 | * (as in "c::f"). Try to reconstruct that. | |
5322 | */ | |
5323 | char *basename; | |
5324 | char *classname; | |
5325 | char *dem_name; | |
5326 | basename = VT (objfile) + dn_bufp->dfunc.name; | |
5327 | classname = class_of (SYMBOL_TYPE (sym)); | |
5328 | if (classname) | |
5329 | { | |
5330 | dem_name = xmalloc (strlen (basename) + strlen (classname) + 3); | |
5331 | strcpy (dem_name, classname); | |
5332 | strcat (dem_name, "::"); | |
5333 | strcat (dem_name, basename); | |
5334 | SYMBOL_CPLUS_DEMANGLED_NAME (sym) = dem_name; | |
5335 | SYMBOL_LANGUAGE (sym) = language_cplus; | |
5336 | } | |
5337 | } | |
5338 | } | |
5339 | ||
5340 | /* Add the function symbol to the list of symbols in this blockvector */ | |
c906108c SS |
5341 | if (dn_bufp->dfunc.global) |
5342 | add_symbol_to_list (sym, &global_symbols); | |
5343 | else | |
5344 | add_symbol_to_list (sym, &file_symbols); | |
5345 | new->name = sym; | |
5346 | ||
8af51c36 EZ |
5347 | /* Search forward to the next BEGIN and also read |
5348 | * in the line info up to that point. | |
5349 | * Not sure why this is needed. | |
5350 | * In HP FORTRAN this code is harmful since there | |
5351 | * may not be a BEGIN after the FUNCTION. | |
5352 | * So I made it C/C++ specific. - RT | |
5353 | */ | |
5354 | if (dn_bufp->dfunc.language == HP_LANGUAGE_C || | |
5355 | dn_bufp->dfunc.language == HP_LANGUAGE_CPLUSPLUS) | |
c906108c | 5356 | { |
8af51c36 EZ |
5357 | while (dn_bufp->dblock.kind != DNTT_TYPE_BEGIN) |
5358 | { | |
5359 | dn_bufp = hpread_get_lntt (++index, objfile); | |
5360 | if (dn_bufp->dblock.extension) | |
5361 | continue; | |
5362 | } | |
5363 | SL_INDEX (objfile) = hpread_record_lines (current_subfile, | |
5364 | SL_INDEX (objfile), | |
5365 | dn_bufp->dbegin.address, | |
5366 | objfile, offset); | |
5367 | SYMBOL_LINE (sym) = hpread_get_line (dn_bufp->dbegin.address, objfile); | |
c906108c | 5368 | } |
8af51c36 EZ |
5369 | record_line (current_subfile, SYMBOL_LINE (sym), valu); |
5370 | break; | |
5371 | ||
5372 | case DNTT_TYPE_DOC_FUNCTION: | |
5373 | valu = dn_bufp->ddocfunc.lowaddr + offset; | |
5374 | ||
5375 | /* Record lines up to this point. */ | |
c906108c SS |
5376 | SL_INDEX (objfile) = hpread_record_lines (current_subfile, |
5377 | SL_INDEX (objfile), | |
8af51c36 | 5378 | dn_bufp->ddocfunc.address, |
c906108c | 5379 | objfile, offset); |
8af51c36 EZ |
5380 | |
5381 | WITHIN_FUNCTION (objfile) = 1; | |
5382 | CURRENT_FUNCTION_VALUE (objfile) = valu; | |
5383 | /* Stack must be empty now. */ | |
5384 | if (context_stack_depth != 0) | |
1fb309ea | 5385 | lbrac_unmatched_complaint (symnum); |
8af51c36 EZ |
5386 | new = push_context (0, valu); |
5387 | ||
5388 | /* Built a type for the function. This includes processing | |
5389 | * the symbol records for the function parameters. | |
5390 | */ | |
5391 | SYMBOL_CLASS (sym) = LOC_BLOCK; | |
5392 | SYMBOL_TYPE (sym) = hpread_read_doc_function_type (hp_type, dn_bufp, objfile, 1); | |
5393 | ||
22abf04a | 5394 | /* The "DEPRECATED_SYMBOL_NAME" field is expected to be the mangled name |
8af51c36 EZ |
5395 | * (if any), which we get from the "alias" field of the SOM record |
5396 | * if that exists. | |
5397 | */ | |
5398 | if ((dn_bufp->ddocfunc.language == HP_LANGUAGE_CPLUSPLUS) && | |
5399 | dn_bufp->ddocfunc.alias && /* has an alias */ | |
5400 | *(char *) (VT (objfile) + dn_bufp->ddocfunc.alias)) /* not a null string */ | |
22abf04a | 5401 | DEPRECATED_SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->ddocfunc.alias; |
8af51c36 | 5402 | else |
22abf04a | 5403 | DEPRECATED_SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->ddocfunc.name; |
8af51c36 EZ |
5404 | |
5405 | /* Special hack to get around HP compilers' insistence on | |
5406 | * reporting "main" as "_MAIN_" for C/C++ */ | |
22abf04a | 5407 | if ((strcmp (DEPRECATED_SYMBOL_NAME (sym), "_MAIN_") == 0) && |
8af51c36 | 5408 | (strcmp (VT (objfile) + dn_bufp->ddocfunc.name, "main") == 0)) |
22abf04a | 5409 | DEPRECATED_SYMBOL_NAME (sym) = VT (objfile) + dn_bufp->ddocfunc.name; |
8af51c36 EZ |
5410 | |
5411 | if (dn_bufp->ddocfunc.language == HP_LANGUAGE_CPLUSPLUS) | |
5412 | { | |
5413 | ||
5414 | /* SYMBOL_INIT_DEMANGLED_NAME is a macro which winds up | |
5415 | * calling the demangler in libiberty (cplus_demangle()) to | |
5416 | * do the job. This generally does the job, even though | |
5417 | * it's intended for the GNU compiler and not the aCC compiler | |
5418 | * Note that SYMBOL_INIT_DEMANGLED_NAME calls the | |
5419 | * demangler with arguments DMGL_PARAMS | DMGL_ANSI. | |
5420 | * Generally, we don't want params when we display | |
5421 | * a demangled name, but when I took out the DMGL_PARAMS, | |
5422 | * some things broke, so I'm leaving it in here, and | |
5423 | * working around the issue in stack.c. - RT | |
5424 | */ | |
4a146b47 | 5425 | SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->objfile_obstack); |
8af51c36 | 5426 | |
22abf04a | 5427 | if ((DEPRECATED_SYMBOL_NAME (sym) == VT (objfile) + dn_bufp->ddocfunc.alias) && |
8af51c36 EZ |
5428 | (!SYMBOL_CPLUS_DEMANGLED_NAME (sym))) |
5429 | { | |
5430 | ||
5431 | /* Well, the symbol name is mangled, but the | |
5432 | * demangler in libiberty failed so the demangled | |
5433 | * field is still NULL. Try to | |
5434 | * do the job ourselves based on the "name" field | |
5435 | * in the SOM record. A complication here is that | |
5436 | * the name field contains only the function name | |
5437 | * (like "f"), whereas we want the class qualification | |
5438 | * (as in "c::f"). Try to reconstruct that. | |
5439 | */ | |
5440 | char *basename; | |
5441 | char *classname; | |
5442 | char *dem_name; | |
5443 | basename = VT (objfile) + dn_bufp->ddocfunc.name; | |
5444 | classname = class_of (SYMBOL_TYPE (sym)); | |
5445 | if (classname) | |
5446 | { | |
5447 | dem_name = xmalloc (strlen (basename) + strlen (classname) + 3); | |
5448 | strcpy (dem_name, classname); | |
5449 | strcat (dem_name, "::"); | |
5450 | strcat (dem_name, basename); | |
5451 | SYMBOL_CPLUS_DEMANGLED_NAME (sym) = dem_name; | |
5452 | SYMBOL_LANGUAGE (sym) = language_cplus; | |
5453 | } | |
5454 | } | |
5455 | } | |
5456 | ||
5457 | /* Add the function symbol to the list of symbols in this blockvector */ | |
5458 | if (dn_bufp->ddocfunc.global) | |
5459 | add_symbol_to_list (sym, &global_symbols); | |
5460 | else | |
5461 | add_symbol_to_list (sym, &file_symbols); | |
5462 | new->name = sym; | |
5463 | ||
5464 | /* Search forward to the next BEGIN and also read | |
5465 | * in the line info up to that point. | |
5466 | * Not sure why this is needed. | |
5467 | * In HP FORTRAN this code is harmful since there | |
5468 | * may not be a BEGIN after the FUNCTION. | |
5469 | * So I made it C/C++ specific. - RT | |
5470 | */ | |
5471 | if (dn_bufp->ddocfunc.language == HP_LANGUAGE_C || | |
5472 | dn_bufp->ddocfunc.language == HP_LANGUAGE_CPLUSPLUS) | |
5473 | { | |
5474 | while (dn_bufp->dblock.kind != DNTT_TYPE_BEGIN) | |
5475 | { | |
5476 | dn_bufp = hpread_get_lntt (++index, objfile); | |
5477 | if (dn_bufp->dblock.extension) | |
5478 | continue; | |
5479 | } | |
5480 | SL_INDEX (objfile) = hpread_record_lines (current_subfile, | |
5481 | SL_INDEX (objfile), | |
5482 | dn_bufp->dbegin.address, | |
5483 | objfile, offset); | |
5484 | SYMBOL_LINE (sym) = hpread_get_line (dn_bufp->dbegin.address, objfile); | |
5485 | } | |
c906108c SS |
5486 | record_line (current_subfile, SYMBOL_LINE (sym), valu); |
5487 | break; | |
5488 | ||
5489 | case DNTT_TYPE_BEGIN: | |
8af51c36 EZ |
5490 | /* Begin a new scope. */ |
5491 | if (context_stack_depth == 1 /* this means we're at function level */ && | |
5492 | context_stack[0].name != NULL /* this means it's a function */ && | |
5493 | context_stack[0].depth == 0 /* this means it's the first BEGIN | |
5494 | we've seen after the FUNCTION */ | |
5495 | ) | |
5496 | { | |
5497 | /* This is the first BEGIN after a FUNCTION. | |
5498 | * We ignore this one, since HP compilers always insert | |
5499 | * at least one BEGIN, i.e. it's: | |
5500 | * | |
5501 | * FUNCTION | |
5502 | * argument symbols | |
5503 | * BEGIN | |
5504 | * local symbols | |
5505 | * (possibly nested BEGIN ... END's if there are inner { } blocks) | |
5506 | * END | |
5507 | * END | |
5508 | * | |
5509 | * By ignoring this first BEGIN, the local symbols get treated | |
5510 | * as belonging to the function scope, and "print func::local_sym" | |
5511 | * works (which is what we want). | |
5512 | */ | |
5513 | ||
5514 | /* All we do here is increase the depth count associated with | |
5515 | * the FUNCTION entry in the context stack. This ensures that | |
5516 | * the next BEGIN we see (if any), representing a real nested { } | |
5517 | * block, will get processed. | |
5518 | */ | |
5519 | ||
5520 | context_stack[0].depth++; | |
5521 | ||
5522 | } | |
5523 | else | |
5524 | { | |
5525 | ||
5526 | /* Record lines up to this SLT pointer. */ | |
5527 | SL_INDEX (objfile) = hpread_record_lines (current_subfile, | |
5528 | SL_INDEX (objfile), | |
5529 | dn_bufp->dbegin.address, | |
5530 | objfile, offset); | |
5531 | /* Calculate start address of new scope */ | |
5532 | valu = hpread_get_location (dn_bufp->dbegin.address, objfile); | |
5533 | valu += offset; /* Relocate for dynamic loading */ | |
5534 | /* We use the scope start DNTT index as nesting depth identifier! */ | |
5535 | desc = hpread_get_scope_start (dn_bufp->dbegin.address, objfile); | |
5536 | new = push_context (desc, valu); | |
5537 | } | |
c906108c SS |
5538 | break; |
5539 | ||
5540 | case DNTT_TYPE_END: | |
5541 | /* End a scope. */ | |
8af51c36 EZ |
5542 | |
5543 | /* Valid end kinds are: | |
5544 | * MODULE | |
5545 | * FUNCTION | |
5546 | * WITH | |
5547 | * COMMON | |
5548 | * BEGIN | |
5549 | * CLASS_SCOPE | |
5550 | */ | |
5551 | ||
c906108c SS |
5552 | SL_INDEX (objfile) = hpread_record_lines (current_subfile, |
5553 | SL_INDEX (objfile), | |
8af51c36 | 5554 | dn_bufp->dend.address, |
c906108c SS |
5555 | objfile, offset); |
5556 | switch (dn_bufp->dend.endkind) | |
5557 | { | |
5558 | case DNTT_TYPE_MODULE: | |
8af51c36 EZ |
5559 | /* Ending a module ends the symbol table for that module. |
5560 | * Calling end_symtab() has the side effect of clearing the | |
5561 | * last_source_file pointer, which in turn signals | |
5562 | * process_one_debug_symbol() to treat the next DNTT_TYPE_SRCFILE | |
5563 | * record as a module-begin. | |
5564 | */ | |
c906108c | 5565 | valu = text_offset + text_size + offset; |
8af51c36 EZ |
5566 | |
5567 | /* Tell our caller that we're done with expanding the | |
5568 | * debug information for a module. | |
5569 | */ | |
5570 | *at_module_boundary_p = 1; | |
5571 | ||
5572 | /* Don't do this, as our caller will do it! | |
5573 | ||
5574 | * (void) end_symtab (valu, objfile, 0); | |
5575 | */ | |
c906108c SS |
5576 | break; |
5577 | ||
5578 | case DNTT_TYPE_FUNCTION: | |
5579 | /* Ending a function, well, ends the function's scope. */ | |
5580 | dn_temp = hpread_get_lntt (dn_bufp->dend.beginscope.dnttp.index, | |
5581 | objfile); | |
5582 | valu = dn_temp->dfunc.hiaddr + offset; | |
8af51c36 EZ |
5583 | /* Insert func params into local list */ |
5584 | merge_symbol_lists (¶m_symbols, &local_symbols); | |
c906108c SS |
5585 | new = pop_context (); |
5586 | /* Make a block for the local symbols within. */ | |
5587 | finish_block (new->name, &local_symbols, new->old_blocks, | |
5588 | new->start_addr, valu, objfile); | |
8af51c36 EZ |
5589 | WITHIN_FUNCTION (objfile) = 0; /* This may have to change for Pascal */ |
5590 | local_symbols = new->locals; | |
5591 | param_symbols = new->params; | |
c906108c | 5592 | break; |
8af51c36 | 5593 | |
c906108c | 5594 | case DNTT_TYPE_BEGIN: |
8af51c36 EZ |
5595 | if (context_stack_depth == 1 && |
5596 | context_stack[0].name != NULL && | |
5597 | context_stack[0].depth == 1) | |
5598 | { | |
5599 | /* This is the END corresponding to the | |
5600 | * BEGIN which we ignored - see DNTT_TYPE_BEGIN case above. | |
5601 | */ | |
5602 | context_stack[0].depth--; | |
5603 | } | |
5604 | else | |
5605 | { | |
5606 | /* Ending a local scope. */ | |
5607 | valu = hpread_get_location (dn_bufp->dend.address, objfile); | |
5608 | /* Why in the hell is this needed? */ | |
5609 | valu += offset + 9; /* Relocate for dynamic loading */ | |
5610 | new = pop_context (); | |
5611 | desc = dn_bufp->dend.beginscope.dnttp.index; | |
5612 | if (desc != new->depth) | |
1fb309ea | 5613 | lbrac_mismatch_complaint (symnum); |
8af51c36 EZ |
5614 | |
5615 | /* Make a block for the local symbols within. */ | |
5616 | finish_block (new->name, &local_symbols, new->old_blocks, | |
5617 | new->start_addr, valu, objfile); | |
5618 | local_symbols = new->locals; | |
5619 | param_symbols = new->params; | |
5620 | } | |
5621 | break; | |
5622 | ||
5623 | case DNTT_TYPE_WITH: | |
5624 | /* Since we ignore the DNTT_TYPE_WITH that starts the scope, | |
5625 | * we can ignore the DNTT_TYPE_END that ends it. | |
5626 | */ | |
5627 | break; | |
5628 | ||
5629 | case DNTT_TYPE_COMMON: | |
5630 | /* End a FORTRAN common block. We don't currently handle these */ | |
23136709 | 5631 | complaint (&symfile_complaints, |
e2e0b3e5 | 5632 | _("unhandled symbol in hp-symtab-read.c: DNTT_TYPE_COMMON/DNTT_TYPE_END.\n")); |
8af51c36 EZ |
5633 | break; |
5634 | ||
5635 | case DNTT_TYPE_CLASS_SCOPE: | |
5636 | ||
5637 | /* pai: FIXME Not handling nested classes for now -- must | |
5638 | * maintain a stack */ | |
5639 | class_scope_name = NULL; | |
5640 | ||
5641 | #if 0 | |
5642 | /* End a class scope */ | |
c906108c SS |
5643 | valu = hpread_get_location (dn_bufp->dend.address, objfile); |
5644 | /* Why in the hell is this needed? */ | |
5645 | valu += offset + 9; /* Relocate for dynamic loading */ | |
5646 | new = pop_context (); | |
5647 | desc = dn_bufp->dend.beginscope.dnttp.index; | |
5648 | if (desc != new->depth) | |
23136709 | 5649 | lbrac_mismatch_complaint ((char *) symnum); |
c906108c SS |
5650 | /* Make a block for the local symbols within. */ |
5651 | finish_block (new->name, &local_symbols, new->old_blocks, | |
5652 | new->start_addr, valu, objfile); | |
5653 | local_symbols = new->locals; | |
8af51c36 EZ |
5654 | param_symbols = new->params; |
5655 | #endif | |
5656 | break; | |
5657 | ||
5658 | default: | |
23136709 | 5659 | complaint (&symfile_complaints, |
e2e0b3e5 | 5660 | _("internal error in hp-symtab-read.c: Unexpected DNTT_TYPE_END kind.")); |
c906108c SS |
5661 | break; |
5662 | } | |
5663 | break; | |
8af51c36 EZ |
5664 | |
5665 | /* DNTT_TYPE_IMPORT is not handled */ | |
5666 | ||
c906108c | 5667 | case DNTT_TYPE_LABEL: |
176620f1 | 5668 | SYMBOL_DOMAIN (sym) = LABEL_DOMAIN; |
c906108c | 5669 | break; |
8af51c36 | 5670 | |
c906108c SS |
5671 | case DNTT_TYPE_FPARAM: |
5672 | /* Function parameters. */ | |
8af51c36 EZ |
5673 | /* Note 1: This code was present in the 4.16 sources, and then |
5674 | removed, because fparams are handled in | |
5675 | hpread_read_function_type(). However, while fparam symbols | |
5676 | are indeed handled twice, this code here cannot be removed | |
5677 | because then they don't get added to the local symbol list of | |
5678 | the function's code block, which leads to a failure to look | |
5679 | up locals, "this"-relative member names, etc. So I've put | |
5680 | this code back in. pai/1997-07-21 */ | |
5681 | /* Note 2: To fix a defect, we stopped adding FPARAMS to local_symbols | |
5682 | in hpread_read_function_type(), so FPARAMS had to be handled | |
5683 | here. I changed the location to be the appropriate argument | |
5684 | kinds rather than LOC_LOCAL. pai/1997-08-08 */ | |
5685 | /* Note 3: Well, the fix in Note 2 above broke argument printing | |
5686 | in traceback frames, and further it makes assumptions about the | |
5687 | order of the FPARAM entries from HP compilers (cc and aCC in particular | |
5688 | generate them in reverse orders -- fixing one breaks for the other). | |
5689 | So I've added code in hpread_read_function_type() to add fparams | |
5690 | to a param_symbols list for the current context level. These are | |
5691 | then merged into local_symbols when a function end is reached. | |
5692 | pai/1997-08-11 */ | |
5693 | ||
5694 | break; /* do nothing; handled in hpread_read_function_type() */ | |
5695 | ||
5696 | #if 0 /* Old code */ | |
c906108c SS |
5697 | if (dn_bufp->dfparam.regparam) |
5698 | SYMBOL_CLASS (sym) = LOC_REGISTER; | |
8af51c36 EZ |
5699 | else if (dn_bufp->dfparam.indirect) |
5700 | SYMBOL_CLASS (sym) = LOC_REF_ARG; | |
c906108c | 5701 | else |
8af51c36 | 5702 | SYMBOL_CLASS (sym) = LOC_ARG; |
176620f1 | 5703 | SYMBOL_DOMAIN (sym) = VAR_DOMAIN; |
c906108c SS |
5704 | if (dn_bufp->dfparam.copyparam) |
5705 | { | |
5706 | SYMBOL_VALUE (sym) = dn_bufp->dfparam.location; | |
c906108c | 5707 | SYMBOL_VALUE (sym) |
7c46b9fb | 5708 | += hpread_adjust_stack_address (CURRENT_FUNCTION_VALUE (objfile)); |
c906108c SS |
5709 | } |
5710 | else | |
5711 | SYMBOL_VALUE (sym) = dn_bufp->dfparam.location; | |
5712 | SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dfparam.type, objfile); | |
8af51c36 | 5713 | add_symbol_to_list (sym, &fparam_symbols); |
c906108c | 5714 | break; |
8af51c36 EZ |
5715 | #endif |
5716 | ||
c906108c SS |
5717 | case DNTT_TYPE_SVAR: |
5718 | /* Static variables. */ | |
5719 | SYMBOL_CLASS (sym) = LOC_STATIC; | |
8af51c36 EZ |
5720 | |
5721 | /* Note: There is a case that arises with globals in shared | |
5722 | * libraries where we need to set the address to LOC_INDIRECT. | |
5723 | * This case is if you have a global "g" in one library, and | |
5724 | * it is referenced "extern <type> g;" in another library. | |
5725 | * If we're processing the symbols for the referencing library, | |
5726 | * we'll see a global "g", but in this case the address given | |
5727 | * in the symbol table contains a pointer to the real "g". | |
5728 | * We use the storage class LOC_INDIRECT to indicate this. RT | |
5729 | */ | |
22abf04a | 5730 | if (is_in_import_list (DEPRECATED_SYMBOL_NAME (sym), objfile)) |
8af51c36 EZ |
5731 | SYMBOL_CLASS (sym) = LOC_INDIRECT; |
5732 | ||
5733 | SYMBOL_VALUE_ADDRESS (sym) = dn_bufp->dsvar.location + data_offset; | |
c906108c | 5734 | SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dsvar.type, objfile); |
8af51c36 | 5735 | |
c906108c SS |
5736 | if (dn_bufp->dsvar.global) |
5737 | add_symbol_to_list (sym, &global_symbols); | |
8af51c36 | 5738 | |
c906108c SS |
5739 | else if (WITHIN_FUNCTION (objfile)) |
5740 | add_symbol_to_list (sym, &local_symbols); | |
8af51c36 | 5741 | |
c906108c SS |
5742 | else |
5743 | add_symbol_to_list (sym, &file_symbols); | |
8af51c36 EZ |
5744 | |
5745 | if (dn_bufp->dsvar.thread_specific) | |
5746 | { | |
5747 | /* Thread-local variable. | |
5748 | */ | |
407caf07 | 5749 | SYMBOL_CLASS (sym) = LOC_HP_THREAD_LOCAL_STATIC; |
34f75cc1 | 5750 | SYMBOL_BASEREG (sym) = HPPA_CR27_REGNUM; |
8af51c36 EZ |
5751 | |
5752 | if (objfile->flags & OBJF_SHARED) | |
5753 | { | |
5754 | /* | |
5755 | * This variable is not only thread local but | |
5756 | * in a shared library. | |
5757 | * | |
5758 | * Alas, the shared lib structures are private | |
5759 | * to "somsolib.c". But C lets us point to one. | |
5760 | */ | |
5761 | struct so_list *so; | |
7c46b9fb | 5762 | struct hppa_objfile_private *priv; |
8af51c36 | 5763 | |
7c46b9fb RC |
5764 | priv = (struct hppa_objfile_private *) |
5765 | objfile_data (objfile, hppa_objfile_priv_data); | |
5766 | if (priv == NULL) | |
8a3fe4f8 | 5767 | error (_("Internal error in reading shared library information.")); |
8af51c36 | 5768 | |
7c46b9fb | 5769 | so = ((struct hppa_objfile_private *) priv)->so_info; |
8af51c36 | 5770 | if (so == NULL) |
8a3fe4f8 | 5771 | error (_("Internal error in reading shared library information.")); |
8af51c36 EZ |
5772 | |
5773 | /* Thread-locals in shared libraries do NOT have the | |
5774 | * standard offset ("data_offset"), so we re-calculate | |
5775 | * where to look for this variable, using a call-back | |
5776 | * to interpret the private shared-library data. | |
5777 | */ | |
acf86d54 RC |
5778 | SYMBOL_VALUE_ADDRESS (sym) = dn_bufp->dsvar.location + |
5779 | gdbarch_tdep (current_gdbarch)->solib_thread_start_addr (so); | |
8af51c36 EZ |
5780 | } |
5781 | } | |
c906108c | 5782 | break; |
8af51c36 | 5783 | |
c906108c SS |
5784 | case DNTT_TYPE_DVAR: |
5785 | /* Dynamic variables. */ | |
5786 | if (dn_bufp->ddvar.regvar) | |
5787 | SYMBOL_CLASS (sym) = LOC_REGISTER; | |
5788 | else | |
5789 | SYMBOL_CLASS (sym) = LOC_LOCAL; | |
8af51c36 | 5790 | |
c906108c | 5791 | SYMBOL_VALUE (sym) = dn_bufp->ddvar.location; |
c906108c | 5792 | SYMBOL_VALUE (sym) |
7c46b9fb | 5793 | += hpread_adjust_stack_address (CURRENT_FUNCTION_VALUE (objfile)); |
c906108c SS |
5794 | SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->ddvar.type, objfile); |
5795 | if (dn_bufp->ddvar.global) | |
5796 | add_symbol_to_list (sym, &global_symbols); | |
5797 | else if (WITHIN_FUNCTION (objfile)) | |
5798 | add_symbol_to_list (sym, &local_symbols); | |
5799 | else | |
5800 | add_symbol_to_list (sym, &file_symbols); | |
5801 | break; | |
8af51c36 | 5802 | |
c906108c SS |
5803 | case DNTT_TYPE_CONST: |
5804 | /* A constant (pascal?). */ | |
5805 | SYMBOL_CLASS (sym) = LOC_CONST; | |
5806 | SYMBOL_VALUE (sym) = dn_bufp->dconst.location; | |
5807 | SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dconst.type, objfile); | |
5808 | if (dn_bufp->dconst.global) | |
5809 | add_symbol_to_list (sym, &global_symbols); | |
5810 | else if (WITHIN_FUNCTION (objfile)) | |
5811 | add_symbol_to_list (sym, &local_symbols); | |
5812 | else | |
5813 | add_symbol_to_list (sym, &file_symbols); | |
5814 | break; | |
8af51c36 | 5815 | |
c906108c | 5816 | case DNTT_TYPE_TYPEDEF: |
8af51c36 | 5817 | /* A typedef. We do want to process these, since a name is |
176620f1 | 5818 | * added to the domain for the typedef'ed name. |
8af51c36 | 5819 | */ |
176620f1 | 5820 | SYMBOL_DOMAIN (sym) = VAR_DOMAIN; |
c906108c SS |
5821 | SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dtype.type, objfile); |
5822 | if (dn_bufp->dtype.global) | |
5823 | add_symbol_to_list (sym, &global_symbols); | |
5824 | else if (WITHIN_FUNCTION (objfile)) | |
5825 | add_symbol_to_list (sym, &local_symbols); | |
5826 | else | |
5827 | add_symbol_to_list (sym, &file_symbols); | |
5828 | break; | |
8af51c36 | 5829 | |
c906108c | 5830 | case DNTT_TYPE_TAGDEF: |
8af51c36 EZ |
5831 | { |
5832 | int global = dn_bufp->dtag.global; | |
5833 | /* Structure, union, enum, template, or class tag definition */ | |
5834 | /* We do want to process these, since a name is | |
176620f1 | 5835 | * added to the domain for the tag name (and if C++ class, |
8af51c36 EZ |
5836 | * for the typename also). |
5837 | */ | |
176620f1 | 5838 | SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN; |
8af51c36 EZ |
5839 | |
5840 | /* The tag contains in its "type" field a pointer to the | |
5841 | * DNTT_TYPE_STRUCT, DNTT_TYPE_UNION, DNTT_TYPE_ENUM, | |
5842 | * DNTT_TYPE_CLASS or DNTT_TYPE_TEMPLATE | |
5843 | * record that actually defines the type. | |
5844 | */ | |
5845 | SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dtype.type, objfile); | |
22abf04a DC |
5846 | TYPE_NAME (sym->type) = DEPRECATED_SYMBOL_NAME (sym); |
5847 | TYPE_TAG_NAME (sym->type) = DEPRECATED_SYMBOL_NAME (sym); | |
8af51c36 EZ |
5848 | if (dn_bufp->dtag.global) |
5849 | add_symbol_to_list (sym, &global_symbols); | |
5850 | else if (WITHIN_FUNCTION (objfile)) | |
5851 | add_symbol_to_list (sym, &local_symbols); | |
5852 | else | |
5853 | add_symbol_to_list (sym, &file_symbols); | |
5854 | ||
5855 | /* If this is a C++ class, then we additionally | |
5856 | * need to define a typedef for the | |
5857 | * class type. E.g., so that the name "c" becomes visible as | |
5858 | * a type name when the user says "class c { ... }". | |
5859 | * In order to figure this out, we need to chase down the "type" | |
5860 | * field to get to the DNTT_TYPE_CLASS record. | |
5861 | * | |
5862 | * We also add the typename for ENUM. Though this isn't | |
5863 | * strictly correct, it is necessary because of the debug info | |
5864 | * generated by the aCC compiler, in which we cannot | |
5865 | * distinguish between: | |
5866 | * enum e { ... }; | |
5867 | * and | |
5868 | * typedef enum { ... } e; | |
5869 | * I.e., the compiler emits the same debug info for the above | |
5870 | * two cases, in both cases "e" appearing as a tagdef. | |
5871 | * Therefore go ahead and generate the typename so that | |
5872 | * "ptype e" will work in the above cases. | |
5873 | * | |
5874 | * We also add the typename for TEMPLATE, so as to allow "ptype t" | |
5875 | * when "t" is a template name. | |
5876 | */ | |
5877 | if (dn_bufp->dtype.type.dnttp.index < LNTT_SYMCOUNT (objfile)) | |
5878 | dn_bufp = hpread_get_lntt (dn_bufp->dtag.type.dnttp.index, objfile); | |
5879 | else | |
5880 | { | |
e2e0b3e5 | 5881 | complaint (&symfile_complaints, _("error processing class tagdef")); |
8af51c36 EZ |
5882 | return; |
5883 | } | |
5884 | if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS || | |
5885 | dn_bufp->dblock.kind == DNTT_TYPE_ENUM || | |
5886 | dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE) | |
5887 | { | |
5888 | struct symbol *newsym; | |
5889 | ||
4a146b47 | 5890 | newsym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack, |
8af51c36 EZ |
5891 | sizeof (struct symbol)); |
5892 | memset (newsym, 0, sizeof (struct symbol)); | |
22abf04a | 5893 | DEPRECATED_SYMBOL_NAME (newsym) = name; |
8af51c36 | 5894 | SYMBOL_LANGUAGE (newsym) = language_auto; |
176620f1 | 5895 | SYMBOL_DOMAIN (newsym) = VAR_DOMAIN; |
8af51c36 EZ |
5896 | SYMBOL_LINE (newsym) = 0; |
5897 | SYMBOL_VALUE (newsym) = 0; | |
5898 | SYMBOL_CLASS (newsym) = LOC_TYPEDEF; | |
5899 | SYMBOL_TYPE (newsym) = sym->type; | |
5900 | if (global) | |
5901 | add_symbol_to_list (newsym, &global_symbols); | |
5902 | else if (WITHIN_FUNCTION (objfile)) | |
5903 | add_symbol_to_list (newsym, &local_symbols); | |
5904 | else | |
5905 | add_symbol_to_list (newsym, &file_symbols); | |
5906 | } | |
5907 | } | |
c906108c | 5908 | break; |
8af51c36 | 5909 | |
c906108c | 5910 | case DNTT_TYPE_POINTER: |
8af51c36 EZ |
5911 | /* Declares a pointer type. Should not be necessary to do anything |
5912 | * with the type at this level; these are processed | |
5913 | * at the hpread_type_lookup() level. | |
5914 | */ | |
c906108c | 5915 | break; |
8af51c36 | 5916 | |
c906108c | 5917 | case DNTT_TYPE_ENUM: |
8af51c36 EZ |
5918 | /* Declares an enum type. Should not be necessary to do anything |
5919 | * with the type at this level; these are processed | |
5920 | * at the hpread_type_lookup() level. | |
5921 | */ | |
c906108c | 5922 | break; |
8af51c36 | 5923 | |
c906108c | 5924 | case DNTT_TYPE_MEMENUM: |
8af51c36 EZ |
5925 | /* Member of enum */ |
5926 | /* Ignored at this level, but hpread_read_enum_type() will take | |
5927 | * care of walking the list of enumeration members. | |
5928 | */ | |
c906108c | 5929 | break; |
8af51c36 | 5930 | |
c906108c | 5931 | case DNTT_TYPE_SET: |
8af51c36 EZ |
5932 | /* Declares a set type. Should not be necessary to do anything |
5933 | * with the type at this level; these are processed | |
5934 | * at the hpread_type_lookup() level. | |
5935 | */ | |
c906108c | 5936 | break; |
8af51c36 | 5937 | |
c906108c | 5938 | case DNTT_TYPE_SUBRANGE: |
8af51c36 EZ |
5939 | /* Declares a subrange type. Should not be necessary to do anything |
5940 | * with the type at this level; these are processed | |
5941 | * at the hpread_type_lookup() level. | |
5942 | */ | |
c906108c | 5943 | break; |
8af51c36 | 5944 | |
c906108c | 5945 | case DNTT_TYPE_ARRAY: |
8af51c36 EZ |
5946 | /* Declares an array type. Should not be necessary to do anything |
5947 | * with the type at this level; these are processed | |
5948 | * at the hpread_type_lookup() level. | |
5949 | */ | |
c906108c | 5950 | break; |
8af51c36 | 5951 | |
c906108c SS |
5952 | case DNTT_TYPE_STRUCT: |
5953 | case DNTT_TYPE_UNION: | |
8af51c36 EZ |
5954 | /* Declares an struct/union type. |
5955 | * Should not be necessary to do anything | |
5956 | * with the type at this level; these are processed | |
5957 | * at the hpread_type_lookup() level. | |
5958 | */ | |
5959 | break; | |
5960 | ||
5961 | case DNTT_TYPE_FIELD: | |
5962 | /* Structure/union/class field */ | |
5963 | /* Ignored at this level, but hpread_read_struct_type() will take | |
5964 | * care of walking the list of structure/union/class members. | |
5965 | */ | |
5966 | break; | |
5967 | ||
5968 | /* DNTT_TYPE_VARIANT is not handled by GDB */ | |
5969 | ||
5970 | /* DNTT_TYPE_FILE is not handled by GDB */ | |
5971 | ||
5972 | case DNTT_TYPE_FUNCTYPE: | |
5973 | /* Function type */ | |
5974 | /* Ignored at this level, handled within hpread_type_lookup() */ | |
5975 | break; | |
5976 | ||
5977 | case DNTT_TYPE_WITH: | |
5978 | /* This is emitted within methods to indicate "with <class>" | |
5979 | * scoping rules (i.e., indicate that the class data members | |
5980 | * are directly visible). | |
5981 | * However, since GDB already infers this by looking at the | |
5982 | * "this" argument, interpreting the DNTT_TYPE_WITH | |
5983 | * symbol record is unnecessary. | |
5984 | */ | |
5985 | break; | |
5986 | ||
5987 | case DNTT_TYPE_COMMON: | |
5988 | /* FORTRAN common. Not yet handled. */ | |
23136709 | 5989 | complaint (&symfile_complaints, |
e2e0b3e5 | 5990 | _("unhandled symbol in hp-symtab-read.c: DNTT_TYPE_COMMON.")); |
8af51c36 EZ |
5991 | break; |
5992 | ||
5993 | /* DNTT_TYPE_COBSTRUCT is not handled by GDB. */ | |
5994 | /* DNTT_TYPE_XREF is not handled by GDB. */ | |
5995 | /* DNTT_TYPE_SA is not handled by GDB. */ | |
5996 | /* DNTT_TYPE_MACRO is not handled by GDB */ | |
5997 | ||
5998 | case DNTT_TYPE_BLOCKDATA: | |
5999 | /* Not sure what this is - part of FORTRAN support maybe? | |
6000 | * Anyway, not yet handled. | |
6001 | */ | |
23136709 | 6002 | complaint (&symfile_complaints, |
e2e0b3e5 | 6003 | _("unhandled symbol in hp-symtab-read.c: DNTT_TYPE_BLOCKDATA.")); |
8af51c36 EZ |
6004 | break; |
6005 | ||
6006 | case DNTT_TYPE_CLASS_SCOPE: | |
6007 | ||
6008 | ||
6009 | ||
6010 | /* The compiler brackets member functions with a CLASS_SCOPE/END | |
6011 | * pair of records, presumably to put them in a different scope | |
6012 | * from the module scope where they are normally defined. | |
6013 | * E.g., in the situation: | |
6014 | * void f() { ... } | |
6015 | * void c::f() { ...} | |
6016 | * The member function "c::f" will be bracketed by a CLASS_SCOPE/END. | |
6017 | * This causes "break f" at the module level to pick the | |
6018 | * the file-level function f(), not the member function | |
6019 | * (which needs to be referenced via "break c::f"). | |
6020 | * | |
6021 | * Here we record the class name to generate the demangled names of | |
6022 | * member functions later. | |
6023 | * | |
6024 | * FIXME Not being used now for anything -- cplus_demangle seems | |
6025 | * enough for getting the class-qualified names of functions. We | |
6026 | * may need this for handling nested classes and types. */ | |
6027 | ||
6028 | /* pai: FIXME Not handling nested classes for now -- need to | |
6029 | * maintain a stack */ | |
6030 | ||
6031 | dn_temp = hpread_get_lntt (dn_bufp->dclass_scope.type.dnttp.index, objfile); | |
6032 | if (dn_temp->dblock.kind == DNTT_TYPE_TAGDEF) | |
6033 | class_scope_name = VT (objfile) + dn_temp->dtag.name; | |
6034 | else | |
6035 | class_scope_name = NULL; | |
6036 | ||
6037 | #if 0 | |
6038 | ||
6039 | /* Begin a new scope. */ | |
6040 | SL_INDEX (objfile) = hpread_record_lines (current_subfile, | |
6041 | SL_INDEX (objfile), | |
6042 | dn_bufp->dclass_scope.address, | |
6043 | objfile, offset); | |
6044 | valu = hpread_get_location (dn_bufp->dclass_scope.address, objfile); | |
6045 | valu += offset; /* Relocate for dynamic loading */ | |
6046 | desc = hpread_get_scope_start (dn_bufp->dclass_scope.address, objfile); | |
6047 | /* We use the scope start DNTT index as the nesting depth identifier! */ | |
6048 | new = push_context (desc, valu); | |
6049 | #endif | |
6050 | break; | |
6051 | ||
6052 | case DNTT_TYPE_REFERENCE: | |
6053 | /* Declares a C++ reference type. Should not be necessary to do anything | |
6054 | * with the type at this level; these are processed | |
6055 | * at the hpread_type_lookup() level. | |
6056 | */ | |
6057 | break; | |
6058 | ||
6059 | case DNTT_TYPE_PTRMEM: | |
6060 | /* Declares a C++ pointer-to-data-member type. This does not | |
6061 | * need to be handled at this level; being a type description it | |
6062 | * is instead handled at the hpread_type_lookup() level. | |
6063 | */ | |
6064 | break; | |
6065 | ||
6066 | case DNTT_TYPE_PTRMEMFUNC: | |
6067 | /* Declares a C++ pointer-to-function-member type. This does not | |
6068 | * need to be handled at this level; being a type description it | |
6069 | * is instead handled at the hpread_type_lookup() level. | |
6070 | */ | |
6071 | break; | |
6072 | ||
6073 | case DNTT_TYPE_CLASS: | |
6074 | /* Declares a class type. | |
6075 | * Should not be necessary to do anything | |
6076 | * with the type at this level; these are processed | |
6077 | * at the hpread_type_lookup() level. | |
6078 | */ | |
6079 | break; | |
6080 | ||
6081 | case DNTT_TYPE_GENFIELD: | |
6082 | /* I believe this is used for class member functions */ | |
6083 | /* Ignored at this level, but hpread_read_struct_type() will take | |
6084 | * care of walking the list of class members. | |
6085 | */ | |
6086 | break; | |
6087 | ||
6088 | case DNTT_TYPE_VFUNC: | |
6089 | /* Virtual function */ | |
6090 | /* This does not have to be handled at this level; handled in | |
6091 | * the course of processing class symbols. | |
6092 | */ | |
6093 | break; | |
6094 | ||
6095 | case DNTT_TYPE_MEMACCESS: | |
6096 | /* DDE ignores this symbol table record. | |
6097 | * It has something to do with "modified access" to class members. | |
6098 | * I'll assume we can safely ignore it too. | |
6099 | */ | |
6100 | break; | |
6101 | ||
6102 | case DNTT_TYPE_INHERITANCE: | |
6103 | /* These don't have to be handled here, since they are handled | |
6104 | * within hpread_read_struct_type() in the process of constructing | |
6105 | * a class type. | |
6106 | */ | |
6107 | break; | |
6108 | ||
6109 | case DNTT_TYPE_FRIEND_CLASS: | |
6110 | case DNTT_TYPE_FRIEND_FUNC: | |
6111 | /* These can safely be ignored, as GDB doesn't need this | |
6112 | * info. DDE only uses it in "describe". We may later want | |
6113 | * to extend GDB's "ptype" to give this info, but for now | |
6114 | * it seems safe enough to ignore it. | |
6115 | */ | |
6116 | break; | |
6117 | ||
6118 | case DNTT_TYPE_MODIFIER: | |
6119 | /* Intended to supply "modified access" to a type */ | |
6120 | /* From the way DDE handles this, it looks like it always | |
6121 | * modifies a type. Therefore it is safe to ignore it at this | |
6122 | * level, and handle it in hpread_type_lookup(). | |
6123 | */ | |
6124 | break; | |
6125 | ||
6126 | case DNTT_TYPE_OBJECT_ID: | |
6127 | /* Just ignore this - that's all DDE does */ | |
6128 | break; | |
6129 | ||
6130 | case DNTT_TYPE_MEMFUNC: | |
6131 | /* Member function */ | |
6132 | /* This does not have to be handled at this level; handled in | |
6133 | * the course of processing class symbols. | |
6134 | */ | |
6135 | break; | |
6136 | ||
6137 | case DNTT_TYPE_DOC_MEMFUNC: | |
6138 | /* Member function */ | |
6139 | /* This does not have to be handled at this level; handled in | |
6140 | * the course of processing class symbols. | |
6141 | */ | |
6142 | break; | |
6143 | ||
6144 | case DNTT_TYPE_TEMPLATE: | |
6145 | /* Template - sort of the header for a template definition, | |
6146 | * which like a class, points to a member list and also points | |
6147 | * to a TEMPLATE_ARG list of type-arguments. | |
6148 | * We do not need to process TEMPLATE records at this level though. | |
6149 | */ | |
6150 | break; | |
6151 | ||
6152 | case DNTT_TYPE_TEMPLATE_ARG: | |
6153 | /* The TEMPLATE record points to an argument list of | |
6154 | * TEMPLATE_ARG records, each of which describes one | |
6155 | * of the type-arguments. | |
6156 | * We do not need to process TEMPLATE_ARG records at this level though. | |
6157 | */ | |
6158 | break; | |
6159 | ||
6160 | case DNTT_TYPE_FUNC_TEMPLATE: | |
6161 | /* This will get emitted for member functions of templates. | |
6162 | * But we don't need to process this record at this level though, | |
6163 | * we will process it in the course of processing a TEMPLATE | |
6164 | * record. | |
6165 | */ | |
6166 | break; | |
6167 | ||
6168 | case DNTT_TYPE_LINK: | |
6169 | /* The LINK record is used to link up templates with instantiations. */ | |
6170 | /* It is not clear why this is needed, and furthermore aCC does | |
6171 | * not appear to generate this, so I think we can safely ignore it. - RT | |
6172 | */ | |
c906108c | 6173 | break; |
8af51c36 EZ |
6174 | |
6175 | /* DNTT_TYPE_DYN_ARRAY_DESC is not handled by GDB */ | |
6176 | /* DNTT_TYPE_DESC_SUBRANGE is not handled by GDB */ | |
6177 | /* DNTT_TYPE_BEGIN_EXT is not handled by GDB */ | |
6178 | /* DNTT_TYPE_INLN is not handled by GDB */ | |
6179 | /* DNTT_TYPE_INLN_LIST is not handled by GDB */ | |
6180 | /* DNTT_TYPE_ALIAS is not handled by GDB */ | |
6181 | ||
c906108c SS |
6182 | default: |
6183 | break; | |
6184 | } | |
6185 | } | |
8af51c36 EZ |
6186 | |
6187 | /* Get nesting depth for a DNTT entry. | |
6188 | * DN_BUFP points to a DNTT entry. | |
6189 | * OBJFILE is the object file. | |
6190 | * REPORT_NESTED is a flag; if 0, real nesting depth is | |
6191 | * reported, if it is 1, the function simply returns a | |
6192 | * non-zero value if the nesting depth is anything > 0. | |
6193 | * | |
6194 | * Return value is an integer. 0 => not a local type / name | |
6195 | * positive return => type or name is local to some | |
6196 | * block or function. | |
6197 | */ | |
6198 | ||
6199 | ||
6200 | /* elz: ATTENTION: FIXME: NOTE: WARNING!!!! | |
6201 | this function now returns 0 right away. It was taking too much time | |
6202 | at start up. Now, though, the local types are not handled correctly. | |
6203 | */ | |
6204 | ||
6205 | ||
6206 | static int | |
6207 | hpread_get_scope_depth (union dnttentry *dn_bufp, struct objfile *objfile, | |
6208 | int report_nested) | |
6209 | { | |
52f0bd74 AC |
6210 | int index; |
6211 | union dnttentry *dn_tmp; | |
6212 | short depth = 0; | |
8af51c36 EZ |
6213 | /****************************/ |
6214 | return 0; | |
6215 | /****************************/ | |
6216 | ||
6217 | index = (((char *) dn_bufp) - LNTT (objfile)) / (sizeof (struct dntt_type_block)); | |
6218 | ||
6219 | while (--index >= 0) | |
6220 | { | |
6221 | dn_tmp = hpread_get_lntt (index, objfile); | |
6222 | switch (dn_tmp->dblock.kind) | |
6223 | { | |
6224 | case DNTT_TYPE_MODULE: | |
6225 | return depth; | |
6226 | case DNTT_TYPE_END: | |
6227 | /* index is signed int; dnttp.index is 29-bit unsigned int! */ | |
6228 | index = (int) dn_tmp->dend.beginscope.dnttp.index; | |
6229 | break; | |
6230 | case DNTT_TYPE_BEGIN: | |
6231 | case DNTT_TYPE_FUNCTION: | |
6232 | case DNTT_TYPE_DOC_FUNCTION: | |
6233 | case DNTT_TYPE_WITH: | |
6234 | case DNTT_TYPE_COMMON: | |
6235 | case DNTT_TYPE_CLASS_SCOPE: | |
6236 | depth++; | |
6237 | if (report_nested) | |
6238 | return 1; | |
6239 | break; | |
6240 | default: | |
6241 | break; | |
6242 | } | |
6243 | } | |
6244 | return depth; | |
6245 | } | |
6246 | ||
6247 | /* Adjust the bitoffsets for all fields of an anonymous union of | |
6248 | type TYPE by negative BITS. This handles HP aCC's hideous habit | |
6249 | of giving members of anonymous unions bit offsets relative to the | |
6250 | enclosing structure instead of relative to the union itself. */ | |
6251 | ||
6252 | static void | |
6253 | hpread_adjust_bitoffsets (struct type *type, int bits) | |
6254 | { | |
52f0bd74 | 6255 | int i; |
8af51c36 EZ |
6256 | |
6257 | /* This is done only for unions; caller had better check that | |
6258 | it is an anonymous one. */ | |
6259 | if (TYPE_CODE (type) != TYPE_CODE_UNION) | |
6260 | return; | |
6261 | ||
6262 | /* Adjust each field; since this is a union, there are no base | |
6263 | classes. Also no static membes. Also, no need for recursion as | |
6264 | the members of this union if themeselves structs or unions, have | |
6265 | the correct bitoffsets; if an anonymous union is a member of this | |
6266 | anonymous union, the code in hpread_read_struct_type() will | |
6267 | adjust for that. */ | |
6268 | ||
6269 | for (i = 0; i < TYPE_NFIELDS (type); i++) | |
6270 | TYPE_FIELD_BITPOS (type, i) -= bits; | |
6271 | } | |
6272 | ||
7c46b9fb RC |
6273 | /* Return the adjustment necessary to make for addresses on the stack |
6274 | as presented by hpread.c. | |
6275 | ||
6276 | This is necessary because of the stack direction on the PA and the | |
6277 | bizarre way in which someone (?) decided they wanted to handle | |
6278 | frame pointerless code in GDB. */ | |
6279 | int | |
6280 | hpread_adjust_stack_address (CORE_ADDR func_addr) | |
6281 | { | |
6282 | struct unwind_table_entry *u; | |
6283 | ||
6284 | u = find_unwind_entry (func_addr); | |
6285 | if (!u) | |
6286 | return 0; | |
6287 | else | |
6288 | return u->Total_frame_size << 3; | |
6289 | } | |
6290 | ||
8af51c36 EZ |
6291 | /* Because of quirks in HP compilers' treatment of anonymous unions inside |
6292 | classes, we have to chase through a chain of threaded FIELD entries. | |
6293 | If we encounter an anonymous union in the chain, we must recursively skip over | |
6294 | that too. | |
6295 | ||
6296 | This function does a "next" in the chain of FIELD entries, but transparently | |
6297 | skips over anonymous unions' fields (recursively). | |
6298 | ||
6299 | Inputs are the number of times to do "next" at the top level, the dnttpointer | |
6300 | (FIELD) and entry pointer (FIELDP) for the dntt record corresponding to it, | |
6301 | and the ubiquitous objfile parameter. (Note: FIELDP is a **.) Return value | |
6302 | is a dnttpointer for the new field after all the skipped ones */ | |
6303 | ||
6304 | static dnttpointer | |
6305 | hpread_get_next_skip_over_anon_unions (int skip_fields, dnttpointer field, | |
6306 | union dnttentry **fieldp, | |
6307 | struct objfile *objfile) | |
6308 | { | |
6309 | struct type *anon_type; | |
52f0bd74 | 6310 | int i; |
8af51c36 EZ |
6311 | int bitoffset; |
6312 | char *name; | |
6313 | ||
6314 | for (i = 0; i < skip_fields; i++) | |
6315 | { | |
6316 | /* Get type of item we're looking at now; recursively processes the types | |
6317 | of these intermediate items we skip over, so they aren't lost. */ | |
6318 | anon_type = hpread_type_lookup ((*fieldp)->dfield.type, objfile); | |
6319 | anon_type = CHECK_TYPEDEF (anon_type); | |
6320 | bitoffset = (*fieldp)->dfield.bitoffset; | |
6321 | name = VT (objfile) + (*fieldp)->dfield.name; | |
6322 | /* First skip over one item to avoid stack death on recursion */ | |
6323 | field = (*fieldp)->dfield.nextfield; | |
6324 | *fieldp = hpread_get_lntt (field.dnttp.index, objfile); | |
6325 | /* Do we have another anonymous union? If so, adjust the bitoffsets | |
6326 | of its members and skip over its members. */ | |
6327 | if ((TYPE_CODE (anon_type) == TYPE_CODE_UNION) && | |
cb137aa5 | 6328 | (!name || DEPRECATED_STREQ (name, ""))) |
8af51c36 EZ |
6329 | { |
6330 | hpread_adjust_bitoffsets (anon_type, bitoffset); | |
6331 | field = hpread_get_next_skip_over_anon_unions (TYPE_NFIELDS (anon_type), field, fieldp, objfile); | |
6332 | } | |
6333 | } | |
6334 | return field; | |
6335 | } |