]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gdb/hpread.c
Copyright updates for 2007.
[thirdparty/binutils-gdb.git] / gdb / hpread.c
CommitLineData
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
45struct 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
97struct 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
118static void
119lbrac_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
125static void
126lbrac_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
145void hpread_symfile_init (struct objfile *);
146
147void do_pxdb (bfd *);
c906108c 148
a14ed312 149void hpread_build_psymtabs (struct objfile *, int);
c906108c 150
a14ed312 151void hpread_symfile_finish (struct objfile *);
c906108c 152
f5479e9c
EZ
153static void set_namestring (union dnttentry *sym, char **namep,
154 struct objfile *objfile);
155
8af51c36
EZ
156static union dnttentry *hpread_get_gntt (int, struct objfile *);
157
2f4150cc
AC
158static union dnttentry *hpread_get_lntt (int index, struct objfile *objfile);
159
160
8af51c36
EZ
161static unsigned long hpread_get_textlow (int, int, struct objfile *, int);
162
c906108c 163static 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
167static 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
171static unsigned long hpread_get_scope_start (sltpointer, struct objfile *);
172
173static unsigned long hpread_get_line (sltpointer, struct objfile *);
174
175static CORE_ADDR hpread_get_location (sltpointer, struct objfile *);
176
f5479e9c 177static int hpread_has_name (enum dntt_entry_type kind);
504d5c7e 178
8af51c36
EZ
179static void hpread_psymtab_to_symtab_1 (struct partial_symtab *);
180
f5479e9c 181static void hpread_psymtab_to_symtab (struct partial_symtab *);
8af51c36 182
c906108c 183static struct symtab *hpread_expand_symtab
a14ed312
KB
184 (struct objfile *, int, int, CORE_ADDR, int,
185 struct section_offsets *, char *);
c906108c 186
8af51c36 187static int hpread_type_translate (dnttpointer);
c906108c 188
8af51c36
EZ
189static struct type **hpread_lookup_type (dnttpointer, struct objfile *);
190
191static struct type *hpread_alloc_type (dnttpointer, struct objfile *);
192
193static struct type *hpread_read_enum_type
194 (dnttpointer, union dnttentry *, struct objfile *);
c906108c
SS
195
196static struct type *hpread_read_function_type
8af51c36
EZ
197 (dnttpointer, union dnttentry *, struct objfile *, int);
198
199static struct type *hpread_read_doc_function_type
200 (dnttpointer, union dnttentry *, struct objfile *, int);
201
202static struct type *hpread_read_struct_type
a14ed312 203 (dnttpointer, union dnttentry *, struct objfile *);
c906108c 204
8af51c36 205static struct type *hpread_get_nth_template_arg (struct objfile *, int);
c906108c 206
8af51c36
EZ
207static struct type *hpread_read_templ_arg_type
208 (dnttpointer, union dnttentry *, struct objfile *, char *);
c906108c 209
8af51c36
EZ
210static struct type *hpread_read_set_type
211 (dnttpointer, union dnttentry *, struct objfile *);
c906108c 212
8af51c36
EZ
213static struct type *hpread_read_array_type
214 (dnttpointer, union dnttentry *dn_bufp, struct objfile *objfile);
c906108c 215
8af51c36
EZ
216static struct type *hpread_read_subrange_type
217 (dnttpointer, union dnttentry *, struct objfile *);
c5aa993b 218
8af51c36 219static struct type *hpread_type_lookup (dnttpointer, struct objfile *);
c906108c 220
8af51c36
EZ
221static sltpointer hpread_record_lines
222 (struct subfile *, sltpointer, sltpointer, struct objfile *, CORE_ADDR);
c906108c 223
8af51c36
EZ
224static 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 228static int hpread_get_scope_depth (union dnttentry *, struct objfile *, int);
c906108c 229
8af51c36
EZ
230static void fix_static_member_physnames
231 (struct type *, char *, struct objfile *);
c906108c 232
8af51c36
EZ
233static void fixup_class_method_type
234 (struct type *, struct type *, struct objfile *);
c906108c 235
8af51c36 236static void hpread_adjust_bitoffsets (struct type *, int);
c906108c 237
7c46b9fb
RC
238static int hpread_adjust_stack_address (CORE_ADDR func_addr);
239
8af51c36
EZ
240static 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 */
246static 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 */
250static 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 263static int
8af51c36
EZ
264file_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. */
274static enum language
275trans_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
290static 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
297static void
298set_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 323static int
8af51c36 324hpread_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 356static int
8af51c36
EZ
357hpread_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
488void
489do_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
567typedef struct
c906108c 568{
8af51c36
EZ
569 int start;
570 int end;
c906108c 571}
8af51c36 572pst_syms_struct;
c906108c 573
8af51c36 574static pst_syms_struct *pst_syms_array = 0;
c906108c 575
504d5c7e
JB
576static int pst_syms_count = 0;
577static int pst_syms_size = 0;
c906108c 578
8af51c36 579/* used by the TELL_OBJFILE macro */
504d5c7e 580static int told_objfile = 0;
8af51c36
EZ
581
582/* Set up psymtab symbol index stuff */
583static void
584init_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 */
592static void
593clear_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 */
602static void
603record_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 */
624static int
625find_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 */
649static int
650find_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 */
668static int
669find_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 */
687static int
688find_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
717static int
8af51c36
EZ
718scan_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 841static int
8af51c36
EZ
842hpread_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 1546static int
8af51c36 1547hpread_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. */
1664void
1665hpread_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
1761void
1762hpread_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
2284void
2285hpread_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 2298static union dnttentry *
8af51c36
EZ
2299hpread_get_lntt (int index, struct objfile *objfile)
2300{
2301 return (union dnttentry *)
2302 &(LNTT (objfile)[(index * sizeof (struct dntt_type_block))]);
2303}
2304
2305static union dnttentry *
2306hpread_get_gntt (int index, struct objfile *objfile)
2307{
2308 return (union dnttentry *)
2309 &(GNTT (objfile)[(index * sizeof (struct dntt_type_block))]);
2310}
2311
f5479e9c 2312static union sltentry *
8af51c36
EZ
2313hpread_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
2323static unsigned long
2324hpread_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
2381static struct partial_symtab *
2382hpread_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
2411static struct partial_symtab *
2412hpread_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
2530static unsigned long
2531hpread_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
2541static unsigned long
2542hpread_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
2552static CORE_ADDR
2553hpread_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 2591static int
8af51c36
EZ
2592hpread_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
2665static void
2666hpread_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 2723static void
8af51c36
EZ
2724hpread_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
2780static struct symtab *
2781hpread_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
2887static int
2888hpread_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
2978static struct type **
2979hpread_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
3063static struct type *
3064hpread_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
3085static struct type *
3086hpread_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
3179static struct type *
3180hpread_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. */
3348finish:
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 3362static struct type *
8af51c36
EZ
3363hpread_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. */
3528finish:
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 */
3550static 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
3558static struct type *
3559hpread_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
4390static void
4391fix_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
4421static void
4422fixup_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
4447finish:
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 */
4465static struct type *
4466hpread_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
4476static struct type *
4477hpread_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
4497static struct type *
fba45db2
KB
4498hpread_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
4519static struct type *
fba45db2
KB
4520hpread_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. */
4577static struct type *
fba45db2
KB
4578hpread_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 4638static struct type *
fba45db2 4639hpread_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
4994static sltpointer
fba45db2
KB
4995hpread_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 5024static char *
8af51c36
EZ
5025class_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
5084static void
fba45db2
KB
5085hpread_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 (&param_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
6206static int
6207hpread_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
6252static void
6253hpread_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. */
6279int
6280hpread_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
6304static dnttpointer
6305hpread_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}