1 /* Read hp debug symbols and convert to internal format, for GDB. 2 Copyright 1993, 1996 Free Software Foundation, Inc. 3 4 This file is part of GDB. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 2 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 19 20 Written by the Center for Software Science at the University of Utah 21 and by Cygnus Support. */ 22 23 #include "defs.h" 24 #include "bfd.h" 25 #include "gdb_string.h" 26 #include "hp-symtab.h" 27 #include "syms.h" 28 #include "symtab.h" 29 #include "symfile.h" 30 #include "objfiles.h" 31 #include "buildsym.h" 32 #include "complaints.h" 33 #include "gdb-stabs.h" 34 #include "gdbtypes.h" 35 #include "demangle.h" 36 37 /* Private information attached to an objfile which we use to find 38 and internalize the HP C debug symbols within that objfile. */ 39 40 struct hpread_symfile_info 41 { 42 /* The contents of each of the debug sections (there are 4 of them). */ 43 char *gntt; 44 char *lntt; 45 char *slt; 46 char *vt; 47 48 /* We keep the size of the $VT$ section for range checking. */ 49 unsigned int vt_size; 50 51 /* Some routines still need to know the number of symbols in the 52 main debug sections ($LNTT$ and $GNTT$). */ 53 unsigned int lntt_symcount; 54 unsigned int gntt_symcount; 55 56 /* To keep track of all the types we've processed. */ 57 struct type **type_vector; 58 int type_vector_length; 59 60 /* Keeps track of the beginning of a range of source lines. */ 61 sltpointer sl_index; 62 63 /* Some state variables we'll need. */ 64 int within_function; 65 66 /* Keep track of the current function's address. We may need to look 67 up something based on this address. */ 68 unsigned int current_function_value; 69 }; 70 71 /* Accessor macros to get at the fields. */ 72 #define HPUX_SYMFILE_INFO(o) \ 73 ((struct hpread_symfile_info *)((o)->sym_private)) 74 #define GNTT(o) (HPUX_SYMFILE_INFO(o)->gntt) 75 #define LNTT(o) (HPUX_SYMFILE_INFO(o)->lntt) 76 #define SLT(o) (HPUX_SYMFILE_INFO(o)->slt) 77 #define VT(o) (HPUX_SYMFILE_INFO(o)->vt) 78 #define VT_SIZE(o) (HPUX_SYMFILE_INFO(o)->vt_size) 79 #define LNTT_SYMCOUNT(o) (HPUX_SYMFILE_INFO(o)->lntt_symcount) 80 #define GNTT_SYMCOUNT(o) (HPUX_SYMFILE_INFO(o)->gntt_symcount) 81 #define TYPE_VECTOR(o) (HPUX_SYMFILE_INFO(o)->type_vector) 82 #define TYPE_VECTOR_LENGTH(o) (HPUX_SYMFILE_INFO(o)->type_vector_length) 83 #define SL_INDEX(o) (HPUX_SYMFILE_INFO(o)->sl_index) 84 #define WITHIN_FUNCTION(o) (HPUX_SYMFILE_INFO(o)->within_function) 85 #define CURRENT_FUNCTION_VALUE(o) (HPUX_SYMFILE_INFO(o)->current_function_value) 86 87 /* Given the native debug symbol SYM, set NAMEP to the name associated 88 with the debug symbol. Note we may be called with a debug symbol which 89 has no associated name, in that case we return an empty string. 90 91 Also note we "know" that the name for any symbol is always in the 92 same place. Hence we don't have to conditionalize on the symbol type. */ 93 #define SET_NAMESTRING(SYM, NAMEP, OBJFILE) \ 94 if (! hpread_has_name ((SYM)->dblock.kind)) \ 95 *NAMEP = ""; \ 96 else if (((unsigned)(SYM)->dsfile.name) >= VT_SIZE (OBJFILE)) \ 97 { \ 98 complain (&string_table_offset_complaint, (char *) symnum); \ 99 *NAMEP = ""; \ 100 } \ 101 else \ 102 *NAMEP = (SYM)->dsfile.name + VT (OBJFILE) 103 104 /* We put a pointer to this structure in the read_symtab_private field 105 of the psymtab. */ 106 107 struct symloc 108 { 109 /* The offset within the file symbol table of first local symbol for 110 this file. */ 111 112 int ldsymoff; 113 114 /* Length (in bytes) of the section of the symbol table devoted to 115 this file's symbols (actually, the section bracketed may contain 116 more than just this file's symbols). If ldsymlen is 0, the only 117 reason for this thing's existence is the dependency list. 118 Nothing else will happen when it is read in. */ 119 120 int ldsymlen; 121 }; 122 123 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff) 124 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen) 125 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private)) 126 127 /* FIXME: Shouldn't this stuff be in a .h file somewhere? */ 128 /* Nonzero means give verbose info on gdb action. */ 129 extern int info_verbose; 130 131 /* Complaints about the symbols we have encountered. */ 132 extern struct complaint string_table_offset_complaint; 133 extern struct complaint lbrac_unmatched_complaint; 134 extern struct complaint lbrac_mismatch_complaint; 135 136 137 void hpread_symfile_init PARAMS ((struct objfile *)); 138 139 static struct type * 140 hpread_read_array_type PARAMS ((dnttpointer, union dnttentry *, struct objfile *)); 141 142 static struct type *hpread_alloc_type 143 PARAMS ((dnttpointer, struct objfile *)); 144 145 static struct type **hpread_lookup_type 146 PARAMS ((dnttpointer, struct objfile *)); 147 148 static struct type *hpread_read_enum_type 149 PARAMS ((dnttpointer, union dnttentry *, struct objfile *)); 150 151 static struct type *hpread_read_set_type 152 PARAMS ((dnttpointer, union dnttentry *, struct objfile *)); 153 154 static struct type *hpread_read_subrange_type 155 PARAMS ((dnttpointer, union dnttentry *, struct objfile *)); 156 157 static struct type *hpread_read_struct_type 158 PARAMS ((dnttpointer, union dnttentry *, struct objfile *)); 159 160 void hpread_build_psymtabs 161 PARAMS ((struct objfile *, struct section_offsets *, int)); 162 163 void hpread_symfile_finish PARAMS ((struct objfile *)); 164 165 static struct partial_symtab *hpread_start_psymtab 166 PARAMS ((struct objfile *, struct section_offsets *, char *, CORE_ADDR, int, 167 struct partial_symbol **, struct partial_symbol **)); 168 169 static struct partial_symtab *hpread_end_psymtab 170 PARAMS ((struct partial_symtab *, char **, int, int, CORE_ADDR, 171 struct partial_symtab **, int)); 172 173 static struct symtab *hpread_expand_symtab 174 PARAMS ((struct objfile *, int, int, CORE_ADDR, int, 175 struct section_offsets *, char *)); 176 177 static void hpread_process_one_debug_symbol 178 PARAMS ((union dnttentry *, char *, struct section_offsets *, 179 struct objfile *, CORE_ADDR, int, char *, int)); 180 181 static sltpointer hpread_record_lines 182 PARAMS ((struct subfile *, sltpointer, sltpointer, 183 struct objfile *, CORE_ADDR)); 184 185 static struct type *hpread_read_function_type 186 PARAMS ((dnttpointer, union dnttentry *, struct objfile *)); 187 188 static struct type * hpread_type_lookup 189 PARAMS ((dnttpointer, struct objfile *)); 190 191 static unsigned long hpread_get_depth 192 PARAMS ((sltpointer, struct objfile *)); 193 194 static unsigned long hpread_get_line 195 PARAMS ((sltpointer, struct objfile *)); 196 197 static CORE_ADDR hpread_get_location 198 PARAMS ((sltpointer, struct objfile *)); 199 200 static int hpread_type_translate PARAMS ((dnttpointer)); 201 static unsigned long hpread_get_textlow PARAMS ((int, int, struct objfile *)); 202 static union dnttentry *hpread_get_gntt PARAMS ((int, struct objfile *)); 203 static union dnttentry *hpread_get_lntt PARAMS ((int, struct objfile *)); 204 static union sltentry *hpread_get_slt PARAMS ((int, struct objfile *)); 205 static void hpread_psymtab_to_symtab PARAMS ((struct partial_symtab *)); 206 static void hpread_psymtab_to_symtab_1 PARAMS ((struct partial_symtab *)); 207 static int hpread_has_name PARAMS ((enum dntt_entry_type)); 208 209 210 /* Initialization for reading native HP C debug symbols from OBJFILE. 211 212 It's only purpose in life is to set up the symbol reader's private 213 per-objfile data structures, and read in the raw contents of the debug 214 sections (attaching pointers to the debug info into the private data 215 structures). 216 217 Since BFD doesn't know how to read debug symbols in a format-independent 218 way (and may never do so...), we have to do it ourselves. Note we may 219 be called on a file without native HP C debugging symbols. 220 FIXME, there should be a cleaner peephole into the BFD environment here. */ 221 222 void 223 hpread_symfile_init (objfile) 224 struct objfile *objfile; 225 { 226 asection *vt_section, *slt_section, *lntt_section, *gntt_section; 227 228 /* Allocate struct to keep track of the symfile */ 229 objfile->sym_private = (PTR) 230 xmmalloc (objfile->md, sizeof (struct hpread_symfile_info)); 231 memset (objfile->sym_private, 0, sizeof (struct hpread_symfile_info)); 232 233 /* We haven't read in any types yet. */ 234 TYPE_VECTOR (objfile) = 0; 235 236 /* Read in data from the $GNTT$ subspace. */ 237 gntt_section = bfd_get_section_by_name (objfile->obfd, "$GNTT$"); 238 if (!gntt_section) 239 return; 240 241 GNTT (objfile) 242 = obstack_alloc (&objfile->symbol_obstack, 243 bfd_section_size (objfile->obfd, gntt_section)); 244 245 bfd_get_section_contents (objfile->obfd, gntt_section, GNTT (objfile), 246 0, bfd_section_size (objfile->obfd, gntt_section)); 247 248 GNTT_SYMCOUNT (objfile) 249 = bfd_section_size (objfile->obfd, gntt_section) 250 / sizeof (struct dntt_type_block); 251 252 /* Read in data from the $LNTT$ subspace. Also keep track of the number 253 of LNTT symbols. */ 254 lntt_section = bfd_get_section_by_name (objfile->obfd, "$LNTT$"); 255 if (!lntt_section) 256 return; 257 258 LNTT (objfile) 259 = obstack_alloc (&objfile->symbol_obstack, 260 bfd_section_size (objfile->obfd, lntt_section)); 261 262 bfd_get_section_contents (objfile->obfd, lntt_section, LNTT (objfile), 263 0, bfd_section_size (objfile->obfd, lntt_section)); 264 265 LNTT_SYMCOUNT (objfile) 266 = bfd_section_size (objfile->obfd, lntt_section) 267 / sizeof (struct dntt_type_block); 268 269 /* Read in data from the $SLT$ subspace. $SLT$ contains information 270 on source line numbers. */ 271 slt_section = bfd_get_section_by_name (objfile->obfd, "$SLT$"); 272 if (!slt_section) 273 return; 274 275 SLT (objfile) = 276 obstack_alloc (&objfile->symbol_obstack, 277 bfd_section_size (objfile->obfd, slt_section)); 278 279 bfd_get_section_contents (objfile->obfd, slt_section, SLT (objfile), 280 0, bfd_section_size (objfile->obfd, slt_section)); 281 282 /* Read in data from the $VT$ subspace. $VT$ contains things like 283 names and constants. Keep track of the number of symbols in the VT. */ 284 vt_section = bfd_get_section_by_name (objfile->obfd, "$VT$"); 285 if (!vt_section) 286 return; 287 288 VT_SIZE (objfile) = bfd_section_size (objfile->obfd, vt_section); 289 290 VT (objfile) = 291 (char *) obstack_alloc (&objfile->symbol_obstack, 292 VT_SIZE (objfile)); 293 294 bfd_get_section_contents (objfile->obfd, vt_section, VT (objfile), 295 0, VT_SIZE (objfile)); 296 } 297 298 /* Scan and build partial symbols for a symbol file. 299 300 The minimal symbol table (either SOM or HP a.out) has already been 301 read in; all we need to do is setup partial symbols based on the 302 native debugging information. 303 304 We assume hpread_symfile_init has been called to initialize the 305 symbol reader's private data structures. 306 307 SECTION_OFFSETS contains offsets relative to which the symbols in the 308 various sections are (depending where the sections were actually loaded). 309 MAINLINE is true if we are reading the main symbol 310 table (as opposed to a shared lib or dynamically loaded file). */ 311 312 void 313 hpread_build_psymtabs (objfile, section_offsets, mainline) 314 struct objfile *objfile; 315 struct section_offsets *section_offsets; 316 int mainline; 317 { 318 char *namestring; 319 int past_first_source_file = 0; 320 struct cleanup *old_chain; 321 322 int hp_symnum, symcount, i; 323 324 union dnttentry *dn_bufp; 325 unsigned long valu; 326 char *p; 327 int texthigh = 0; 328 int have_name = 0; 329 330 /* Current partial symtab */ 331 struct partial_symtab *pst; 332 333 /* List of current psymtab's include files */ 334 char **psymtab_include_list; 335 int includes_allocated; 336 int includes_used; 337 338 /* Index within current psymtab dependency list */ 339 struct partial_symtab **dependency_list; 340 int dependencies_used, dependencies_allocated; 341 342 /* Just in case the stabs reader left turds lying around. */ 343 free_pending_blocks (); 344 make_cleanup (really_free_pendings, 0); 345 346 pst = (struct partial_symtab *) 0; 347 348 /* We shouldn't use alloca, instead use malloc/free. Doing so avoids 349 a number of problems with cross compilation and creating useless holes 350 in the stack when we have to allocate new entries. FIXME. */ 351 352 includes_allocated = 30; 353 includes_used = 0; 354 psymtab_include_list = (char **) alloca (includes_allocated * 355 sizeof (char *)); 356 357 dependencies_allocated = 30; 358 dependencies_used = 0; 359 dependency_list = 360 (struct partial_symtab **) alloca (dependencies_allocated * 361 sizeof (struct partial_symtab *)); 362 363 old_chain = make_cleanup (free_objfile, objfile); 364 365 last_source_file = 0; 366 367 /* Make two passes, one ofr the GNTT symbols, the other for the 368 LNTT symbols. */ 369 for (i = 0; i < 1; i++) 370 { 371 int within_function = 0; 372 373 if (i) 374 symcount = GNTT_SYMCOUNT (objfile); 375 else 376 symcount = LNTT_SYMCOUNT (objfile); 377 378 for (hp_symnum = 0; hp_symnum < symcount; hp_symnum++) 379 { 380 QUIT; 381 if (i) 382 dn_bufp = hpread_get_gntt (hp_symnum, objfile); 383 else 384 dn_bufp = hpread_get_lntt (hp_symnum, objfile); 385 386 if (dn_bufp->dblock.extension) 387 continue; 388 389 /* Only handle things which are necessary for minimal symbols. 390 everything else is ignored. */ 391 switch (dn_bufp->dblock.kind) 392 { 393 case DNTT_TYPE_SRCFILE: 394 { 395 /* A source file of some kind. Note this may simply 396 be an included file. */ 397 SET_NAMESTRING (dn_bufp, &namestring, objfile); 398 399 /* Check if this is the source file we are already working 400 with. */ 401 if (pst && !strcmp (namestring, pst->filename)) 402 continue; 403 404 /* Check if this is an include file, if so check if we have 405 already seen it. Add it to the include list */ 406 p = strrchr (namestring, '.'); 407 if (!strcmp (p, ".h")) 408 { 409 int j, found; 410 411 found = 0; 412 for (j = 0; j < includes_used; j++) 413 if (!strcmp (namestring, psymtab_include_list[j])) 414 { 415 found = 1; 416 break; 417 } 418 if (found) 419 continue; 420 421 /* Add it to the list of includes seen so far and 422 allocate more include space if necessary. */ 423 psymtab_include_list[includes_used++] = namestring; 424 if (includes_used >= includes_allocated) 425 { 426 char **orig = psymtab_include_list; 427 428 psymtab_include_list = (char **) 429 alloca ((includes_allocated *= 2) * 430 sizeof (char *)); 431 memcpy ((PTR) psymtab_include_list, (PTR) orig, 432 includes_used * sizeof (char *)); 433 } 434 continue; 435 } 436 437 438 if (pst) 439 { 440 if (!have_name) 441 { 442 pst->filename = (char *) 443 obstack_alloc (&pst->objfile->psymbol_obstack, 444 strlen (namestring) + 1); 445 strcpy (pst->filename, namestring); 446 have_name = 1; 447 continue; 448 } 449 continue; 450 } 451 452 /* This is a bonafide new source file. 453 End the current partial symtab and start a new one. */ 454 455 if (pst && past_first_source_file) 456 { 457 hpread_end_psymtab (pst, psymtab_include_list, 458 includes_used, 459 (hp_symnum 460 * sizeof (struct dntt_type_block)), 461 texthigh, 462 dependency_list, dependencies_used); 463 pst = (struct partial_symtab *) 0; 464 includes_used = 0; 465 dependencies_used = 0; 466 } 467 else 468 past_first_source_file = 1; 469 470 valu = hpread_get_textlow (i, hp_symnum, objfile); 471 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT); 472 pst = hpread_start_psymtab (objfile, section_offsets, 473 namestring, valu, 474 (hp_symnum 475 * sizeof (struct dntt_type_block)), 476 objfile->global_psymbols.next, 477 objfile->static_psymbols.next); 478 texthigh = valu; 479 have_name = 1; 480 continue; 481 } 482 483 case DNTT_TYPE_MODULE: 484 /* A source file. It's still unclear to me what the 485 real difference between a DNTT_TYPE_SRCFILE and DNTT_TYPE_MODULE 486 is supposed to be. */ 487 SET_NAMESTRING (dn_bufp, &namestring, objfile); 488 valu = hpread_get_textlow (i, hp_symnum, objfile); 489 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT); 490 if (!pst) 491 { 492 pst = hpread_start_psymtab (objfile, section_offsets, 493 namestring, valu, 494 (hp_symnum 495 * sizeof (struct dntt_type_block)), 496 objfile->global_psymbols.next, 497 objfile->static_psymbols.next); 498 texthigh = valu; 499 have_name = 0; 500 } 501 continue; 502 case DNTT_TYPE_FUNCTION: 503 case DNTT_TYPE_ENTRY: 504 /* The beginning of a function. DNTT_TYPE_ENTRY may also denote 505 a secondary entry point. */ 506 valu = dn_bufp->dfunc.hiaddr + ANOFFSET (section_offsets, 507 SECT_OFF_TEXT); 508 if (valu > texthigh) 509 texthigh = valu; 510 valu = dn_bufp->dfunc.lowaddr + 511 ANOFFSET (section_offsets, SECT_OFF_TEXT); 512 SET_NAMESTRING (dn_bufp, &namestring, objfile); 513 add_psymbol_to_list (namestring, strlen (namestring), 514 VAR_NAMESPACE, LOC_BLOCK, 515 &objfile->static_psymbols, valu, 516 0, language_unknown, objfile); 517 within_function = 1; 518 continue; 519 case DNTT_TYPE_BEGIN: 520 case DNTT_TYPE_END: 521 /* Scope block begin/end. We only care about function 522 and file blocks right now. */ 523 if (dn_bufp->dend.endkind == DNTT_TYPE_MODULE) 524 { 525 hpread_end_psymtab (pst, psymtab_include_list, includes_used, 526 (hp_symnum 527 * sizeof (struct dntt_type_block)), 528 texthigh, 529 dependency_list, dependencies_used); 530 pst = (struct partial_symtab *) 0; 531 includes_used = 0; 532 dependencies_used = 0; 533 have_name = 0; 534 } 535 if (dn_bufp->dend.endkind == DNTT_TYPE_FUNCTION) 536 within_function = 0; 537 continue; 538 case DNTT_TYPE_SVAR: 539 case DNTT_TYPE_DVAR: 540 case DNTT_TYPE_TYPEDEF: 541 case DNTT_TYPE_TAGDEF: 542 { 543 /* Variables, typedefs an the like. */ 544 enum address_class storage; 545 namespace_enum namespace; 546 547 /* Don't add locals to the partial symbol table. */ 548 if (within_function 549 && (dn_bufp->dblock.kind == DNTT_TYPE_SVAR 550 || dn_bufp->dblock.kind == DNTT_TYPE_DVAR)) 551 continue; 552 553 /* TAGDEFs go into the structure namespace. */ 554 if (dn_bufp->dblock.kind == DNTT_TYPE_TAGDEF) 555 namespace = STRUCT_NAMESPACE; 556 else 557 namespace = VAR_NAMESPACE; 558 559 /* What kind of "storage" does this use? */ 560 if (dn_bufp->dblock.kind == DNTT_TYPE_SVAR) 561 storage = LOC_STATIC; 562 else if (dn_bufp->dblock.kind == DNTT_TYPE_DVAR 563 && dn_bufp->ddvar.regvar) 564 storage = LOC_REGISTER; 565 else if (dn_bufp->dblock.kind == DNTT_TYPE_DVAR) 566 storage = LOC_LOCAL; 567 else 568 storage = LOC_UNDEF; 569 570 SET_NAMESTRING (dn_bufp, &namestring, objfile); 571 if (!pst) 572 { 573 pst = hpread_start_psymtab (objfile, section_offsets, 574 "globals", 0, 575 (hp_symnum 576 * sizeof (struct dntt_type_block)), 577 objfile->global_psymbols.next, 578 objfile->static_psymbols.next); 579 } 580 if (dn_bufp->dsvar.global) 581 { 582 add_psymbol_to_list (namestring, strlen (namestring), 583 namespace, storage, 584 &objfile->global_psymbols, 585 dn_bufp->dsvar.location, 586 0, language_unknown, objfile); 587 } 588 else 589 { 590 add_psymbol_to_list (namestring, strlen (namestring), 591 namespace, storage, 592 &objfile->static_psymbols, 593 dn_bufp->dsvar.location, 594 0, language_unknown, objfile); 595 } 596 continue; 597 } 598 case DNTT_TYPE_MEMENUM: 599 case DNTT_TYPE_CONST: 600 /* Constants and members of enumerated types. */ 601 SET_NAMESTRING (dn_bufp, &namestring, objfile); 602 if (!pst) 603 { 604 pst = hpread_start_psymtab (objfile, section_offsets, 605 "globals", 0, 606 (hp_symnum 607 * sizeof (struct dntt_type_block)), 608 objfile->global_psymbols.next, 609 objfile->static_psymbols.next); 610 } 611 add_psymbol_to_list (namestring, strlen (namestring), 612 VAR_NAMESPACE, LOC_CONST, 613 &objfile->static_psymbols, 0, 614 0, language_unknown, objfile); 615 continue; 616 default: 617 continue; 618 } 619 } 620 } 621 622 /* End any pending partial symbol table. */ 623 if (pst) 624 { 625 hpread_end_psymtab (pst, psymtab_include_list, includes_used, 626 hp_symnum * sizeof (struct dntt_type_block), 627 0, dependency_list, dependencies_used); 628 } 629 630 discard_cleanups (old_chain); 631 } 632 633 /* Perform any local cleanups required when we are done with a particular 634 objfile. I.E, we are in the process of discarding all symbol information 635 for an objfile, freeing up all memory held for it, and unlinking the 636 objfile struct from the global list of known objfiles. */ 637 638 void 639 hpread_symfile_finish (objfile) 640 struct objfile *objfile; 641 { 642 if (objfile->sym_private != NULL) 643 { 644 mfree (objfile->md, objfile->sym_private); 645 } 646 } 647 648 649 /* The remaining functions are all for internal use only. */ 650 651 /* Various small functions to get entries in the debug symbol sections. */ 652 653 static union dnttentry * 654 hpread_get_lntt (index, objfile) 655 int index; 656 struct objfile *objfile; 657 { 658 return (union dnttentry *) 659 &(LNTT (objfile)[(index * sizeof (struct dntt_type_block))]); 660 } 661 662 static union dnttentry * 663 hpread_get_gntt (index, objfile) 664 int index; 665 struct objfile *objfile; 666 { 667 return (union dnttentry *) 668 &(GNTT (objfile)[(index * sizeof (struct dntt_type_block))]); 669 } 670 671 static union sltentry * 672 hpread_get_slt (index, objfile) 673 int index; 674 struct objfile *objfile; 675 { 676 return (union sltentry *)&(SLT (objfile)[index * sizeof (union sltentry)]); 677 } 678 679 /* Get the low address associated with some symbol (typically the start 680 of a particular source file or module). Since that information is not 681 stored as part of the DNTT_TYPE_MODULE or DNTT_TYPE_SRCFILE symbol we must infer it from 682 the existance of DNTT_TYPE_FUNCTION symbols. */ 683 684 static unsigned long 685 hpread_get_textlow (global, index, objfile) 686 int global; 687 int index; 688 struct objfile *objfile; 689 { 690 union dnttentry *dn_bufp; 691 struct minimal_symbol *msymbol; 692 693 /* Look for a DNTT_TYPE_FUNCTION symbol. */ 694 do 695 { 696 if (global) 697 dn_bufp = hpread_get_gntt (index++, objfile); 698 else 699 dn_bufp = hpread_get_lntt (index++, objfile); 700 } while (dn_bufp->dblock.kind != DNTT_TYPE_FUNCTION 701 && dn_bufp->dblock.kind != DNTT_TYPE_END); 702 703 /* Avoid going past a DNTT_TYPE_END when looking for a DNTT_TYPE_FUNCTION. This 704 might happen when a sourcefile has no functions. */ 705 if (dn_bufp->dblock.kind == DNTT_TYPE_END) 706 return 0; 707 708 /* The minimal symbols are typically more accurate for some reason. */ 709 msymbol = lookup_minimal_symbol (dn_bufp->dfunc.name + VT (objfile), NULL, 710 objfile); 711 if (msymbol) 712 return SYMBOL_VALUE_ADDRESS (msymbol); 713 else 714 return dn_bufp->dfunc.lowaddr; 715 } 716 717 /* Get the nesting depth for the source line identified by INDEX. */ 718 719 static unsigned long 720 hpread_get_depth (index, objfile) 721 sltpointer index; 722 struct objfile *objfile; 723 { 724 union sltentry *sl_bufp; 725 726 sl_bufp = hpread_get_slt (index, objfile); 727 return sl_bufp->sspec.backptr.dnttp.index; 728 } 729 730 /* Get the source line number the the line identified by INDEX. */ 731 732 static unsigned long 733 hpread_get_line (index, objfile) 734 sltpointer index; 735 struct objfile *objfile; 736 { 737 union sltentry *sl_bufp; 738 739 sl_bufp = hpread_get_slt (index, objfile); 740 return sl_bufp->snorm.line; 741 } 742 743 static CORE_ADDR 744 hpread_get_location (index, objfile) 745 sltpointer index; 746 struct objfile *objfile; 747 { 748 union sltentry *sl_bufp; 749 int i; 750 751 /* code location of special sltentrys is determined from context */ 752 sl_bufp = hpread_get_slt (index, objfile); 753 754 if (sl_bufp->snorm.sltdesc == SLT_END) 755 { 756 /* find previous normal sltentry and get address */ 757 for (i = 0; ((sl_bufp->snorm.sltdesc != SLT_NORMAL) && 758 (sl_bufp->snorm.sltdesc != SLT_EXIT)); i++) 759 sl_bufp = hpread_get_slt (index - i, objfile); 760 return sl_bufp->snorm.address; 761 } 762 763 /* find next normal sltentry and get address */ 764 for (i = 0; ((sl_bufp->snorm.sltdesc != SLT_NORMAL) && 765 (sl_bufp->snorm.sltdesc != SLT_EXIT)); i++) 766 sl_bufp = hpread_get_slt (index + i, objfile); 767 return sl_bufp->snorm.address; 768 } 769 770 771 /* Return 1 if an HP debug symbol of type KIND has a name associated with 772 it, else return 0. */ 773 774 static int 775 hpread_has_name (kind) 776 enum dntt_entry_type kind; 777 { 778 switch (kind) 779 { 780 case DNTT_TYPE_SRCFILE: 781 case DNTT_TYPE_MODULE: 782 case DNTT_TYPE_FUNCTION: 783 case DNTT_TYPE_ENTRY: 784 case DNTT_TYPE_IMPORT: 785 case DNTT_TYPE_LABEL: 786 case DNTT_TYPE_FPARAM: 787 case DNTT_TYPE_SVAR: 788 case DNTT_TYPE_DVAR: 789 case DNTT_TYPE_CONST: 790 case DNTT_TYPE_TYPEDEF: 791 case DNTT_TYPE_TAGDEF: 792 case DNTT_TYPE_MEMENUM: 793 case DNTT_TYPE_FIELD: 794 case DNTT_TYPE_SA: 795 return 1; 796 797 case DNTT_TYPE_BEGIN: 798 case DNTT_TYPE_END: 799 case DNTT_TYPE_WITH: 800 case DNTT_TYPE_COMMON: 801 case DNTT_TYPE_POINTER: 802 case DNTT_TYPE_ENUM: 803 case DNTT_TYPE_SET: 804 case DNTT_TYPE_SUBRANGE: 805 case DNTT_TYPE_ARRAY: 806 case DNTT_TYPE_STRUCT: 807 case DNTT_TYPE_UNION: 808 case DNTT_TYPE_VARIANT: 809 case DNTT_TYPE_FILE: 810 case DNTT_TYPE_FUNCTYPE: 811 case DNTT_TYPE_COBSTRUCT: 812 case DNTT_TYPE_XREF: 813 case DNTT_TYPE_MACRO: 814 default: 815 return 0; 816 } 817 } 818 819 /* Allocate and partially fill a partial symtab. It will be 820 completely filled at the end of the symbol list. 821 822 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR 823 is the address relative to which its symbols are (incremental) or 0 824 (normal). */ 825 826 static struct partial_symtab * 827 hpread_start_psymtab (objfile, section_offsets, 828 filename, textlow, ldsymoff, global_syms, static_syms) 829 struct objfile *objfile; 830 struct section_offsets *section_offsets; 831 char *filename; 832 CORE_ADDR textlow; 833 int ldsymoff; 834 struct partial_symbol **global_syms; 835 struct partial_symbol **static_syms; 836 { 837 struct partial_symtab *result = 838 start_psymtab_common (objfile, section_offsets, 839 filename, textlow, global_syms, static_syms); 840 841 result->read_symtab_private = (char *) 842 obstack_alloc (&objfile->psymbol_obstack, sizeof (struct symloc)); 843 LDSYMOFF (result) = ldsymoff; 844 result->read_symtab = hpread_psymtab_to_symtab; 845 846 return result; 847 } 848 849 850 /* Close off the current usage of PST. 851 Returns PST or NULL if the partial symtab was empty and thrown away. 852 853 FIXME: List variables and peculiarities of same. */ 854 855 static struct partial_symtab * 856 hpread_end_psymtab (pst, include_list, num_includes, capping_symbol_offset, 857 capping_text, dependency_list, number_dependencies) 858 struct partial_symtab *pst; 859 char **include_list; 860 int num_includes; 861 int capping_symbol_offset; 862 CORE_ADDR capping_text; 863 struct partial_symtab **dependency_list; 864 int number_dependencies; 865 { 866 int i; 867 struct objfile *objfile = pst -> objfile; 868 869 if (capping_symbol_offset != -1) 870 LDSYMLEN(pst) = capping_symbol_offset - LDSYMOFF(pst); 871 pst->texthigh = capping_text; 872 873 pst->n_global_syms = 874 objfile->global_psymbols.next - (objfile->global_psymbols.list + pst->globals_offset); 875 pst->n_static_syms = 876 objfile->static_psymbols.next - (objfile->static_psymbols.list + pst->statics_offset); 877 878 pst->number_of_dependencies = number_dependencies; 879 if (number_dependencies) 880 { 881 pst->dependencies = (struct partial_symtab **) 882 obstack_alloc (&objfile->psymbol_obstack, 883 number_dependencies * sizeof (struct partial_symtab *)); 884 memcpy (pst->dependencies, dependency_list, 885 number_dependencies * sizeof (struct partial_symtab *)); 886 } 887 else 888 pst->dependencies = 0; 889 890 for (i = 0; i < num_includes; i++) 891 { 892 struct partial_symtab *subpst = 893 allocate_psymtab (include_list[i], objfile); 894 895 subpst->section_offsets = pst->section_offsets; 896 subpst->read_symtab_private = 897 (char *) obstack_alloc (&objfile->psymbol_obstack, 898 sizeof (struct symloc)); 899 LDSYMOFF(subpst) = 900 LDSYMLEN(subpst) = 901 subpst->textlow = 902 subpst->texthigh = 0; 903 904 /* We could save slight bits of space by only making one of these, 905 shared by the entire set of include files. FIXME-someday. */ 906 subpst->dependencies = (struct partial_symtab **) 907 obstack_alloc (&objfile->psymbol_obstack, 908 sizeof (struct partial_symtab *)); 909 subpst->dependencies[0] = pst; 910 subpst->number_of_dependencies = 1; 911 912 subpst->globals_offset = 913 subpst->n_global_syms = 914 subpst->statics_offset = 915 subpst->n_static_syms = 0; 916 917 subpst->readin = 0; 918 subpst->symtab = 0; 919 subpst->read_symtab = pst->read_symtab; 920 } 921 922 sort_pst_symbols (pst); 923 924 /* If there is already a psymtab or symtab for a file of this name, remove it. 925 (If there is a symtab, more drastic things also happen.) 926 This happens in VxWorks. */ 927 free_named_symtabs (pst->filename); 928 929 if (num_includes == 0 930 && number_dependencies == 0 931 && pst->n_global_syms == 0 932 && pst->n_static_syms == 0) 933 { 934 /* Throw away this psymtab, it's empty. We can't deallocate it, since 935 it is on the obstack, but we can forget to chain it on the list. */ 936 /* Empty psymtabs happen as a result of header files which don't have 937 any symbols in them. There can be a lot of them. But this check 938 is wrong, in that a psymtab with N_SLINE entries but nothing else 939 is not empty, but we don't realize that. Fixing that without slowing 940 things down might be tricky. */ 941 struct partial_symtab *prev_pst; 942 943 /* First, snip it out of the psymtab chain */ 944 945 if (pst->objfile->psymtabs == pst) 946 pst->objfile->psymtabs = pst->next; 947 else 948 for (prev_pst = pst->objfile->psymtabs; prev_pst; prev_pst = pst->next) 949 if (prev_pst->next == pst) 950 prev_pst->next = pst->next; 951 952 /* Next, put it on a free list for recycling */ 953 954 pst->next = pst->objfile->free_psymtabs; 955 pst->objfile->free_psymtabs = pst; 956 957 /* Indicate that psymtab was thrown away. */ 958 pst = (struct partial_symtab *)NULL; 959 } 960 return pst; 961 } 962 963 /* Do the dirty work of reading in the full symbol from a partial symbol 964 table. */ 965 966 static void 967 hpread_psymtab_to_symtab_1 (pst) 968 struct partial_symtab *pst; 969 { 970 struct cleanup *old_chain; 971 int i; 972 973 /* Get out quick if passed junk. */ 974 if (!pst) 975 return; 976 977 /* Complain if we've already read in this symbol table. */ 978 if (pst->readin) 979 { 980 fprintf (stderr, "Psymtab for %s already read in. Shouldn't happen.\n", 981 pst->filename); 982 return; 983 } 984 985 /* Read in all partial symtabs on which this one is dependent */ 986 for (i = 0; i < pst->number_of_dependencies; i++) 987 if (!pst->dependencies[i]->readin) 988 { 989 /* Inform about additional files that need to be read in. */ 990 if (info_verbose) 991 { 992 fputs_filtered (" ", stdout); 993 wrap_here (""); 994 fputs_filtered ("and ", stdout); 995 wrap_here (""); 996 printf_filtered ("%s...", pst->dependencies[i]->filename); 997 wrap_here (""); /* Flush output */ 998 fflush (stdout); 999 } 1000 hpread_psymtab_to_symtab_1 (pst->dependencies[i]); 1001 } 1002 1003 /* If it's real... */ 1004 if (LDSYMLEN (pst)) 1005 { 1006 /* Init stuff necessary for reading in symbols */ 1007 buildsym_init (); 1008 old_chain = make_cleanup (really_free_pendings, 0); 1009 1010 pst->symtab = 1011 hpread_expand_symtab (pst->objfile, LDSYMOFF (pst), LDSYMLEN (pst), 1012 pst->textlow, pst->texthigh - pst->textlow, 1013 pst->section_offsets, pst->filename); 1014 sort_symtab_syms (pst->symtab); 1015 1016 do_cleanups (old_chain); 1017 } 1018 1019 pst->readin = 1; 1020 } 1021 1022 /* Read in all of the symbols for a given psymtab for real. 1023 Be verbose about it if the user wants that. */ 1024 1025 static void 1026 hpread_psymtab_to_symtab (pst) 1027 struct partial_symtab *pst; 1028 { 1029 /* Get out quick if given junk. */ 1030 if (!pst) 1031 return; 1032 1033 /* Sanity check. */ 1034 if (pst->readin) 1035 { 1036 fprintf (stderr, "Psymtab for %s already read in. Shouldn't happen.\n", 1037 pst->filename); 1038 return; 1039 } 1040 1041 if (LDSYMLEN (pst) || pst->number_of_dependencies) 1042 { 1043 /* Print the message now, before reading the string table, 1044 to avoid disconcerting pauses. */ 1045 if (info_verbose) 1046 { 1047 printf_filtered ("Reading in symbols for %s...", pst->filename); 1048 fflush (stdout); 1049 } 1050 1051 hpread_psymtab_to_symtab_1 (pst); 1052 1053 /* Match with global symbols. This only needs to be done once, 1054 after all of the symtabs and dependencies have been read in. */ 1055 scan_file_globals (pst->objfile); 1056 1057 /* Finish up the debug error message. */ 1058 if (info_verbose) 1059 printf_filtered ("done.\n"); 1060 } 1061 } 1062 /* Read in a defined section of a specific object file's symbols. 1063 1064 DESC is the file descriptor for the file, positioned at the 1065 beginning of the symtab 1066 SYM_OFFSET is the offset within the file of 1067 the beginning of the symbols we want to read 1068 SYM_SIZE is the size of the symbol info to read in. 1069 TEXT_OFFSET is the beginning of the text segment we are reading symbols for 1070 TEXT_SIZE is the size of the text segment read in. 1071 SECTION_OFFSETS are the relocation offsets which get added to each symbol. */ 1072 1073 static struct symtab * 1074 hpread_expand_symtab (objfile, sym_offset, sym_size, text_offset, text_size, 1075 section_offsets, filename) 1076 struct objfile *objfile; 1077 int sym_offset; 1078 int sym_size; 1079 CORE_ADDR text_offset; 1080 int text_size; 1081 struct section_offsets *section_offsets; 1082 char *filename; 1083 { 1084 char *namestring; 1085 union dnttentry *dn_bufp; 1086 unsigned max_symnum; 1087 1088 int sym_index = sym_offset / sizeof (struct dntt_type_block); 1089 1090 current_objfile = objfile; 1091 subfile_stack = 0; 1092 1093 last_source_file = 0; 1094 1095 dn_bufp = hpread_get_lntt (sym_index, objfile); 1096 if (!((dn_bufp->dblock.kind == (unsigned char) DNTT_TYPE_SRCFILE) || 1097 (dn_bufp->dblock.kind == (unsigned char) DNTT_TYPE_MODULE))) 1098 start_symtab ("globals", NULL, 0); 1099 1100 max_symnum = sym_size / sizeof (struct dntt_type_block); 1101 1102 /* Read in and process each debug symbol within the specified range. */ 1103 for (symnum = 0; 1104 symnum < max_symnum; 1105 symnum++) 1106 { 1107 QUIT; /* Allow this to be interruptable */ 1108 dn_bufp = hpread_get_lntt (sym_index + symnum, objfile); 1109 1110 if (dn_bufp->dblock.extension) 1111 continue; 1112 1113 /* Yow! We call SET_NAMESTRING on things without names! */ 1114 SET_NAMESTRING (dn_bufp, &namestring, objfile); 1115 1116 hpread_process_one_debug_symbol (dn_bufp, namestring, section_offsets, 1117 objfile, text_offset, text_size, 1118 filename, symnum + sym_index); 1119 } 1120 1121 current_objfile = NULL; 1122 1123 return end_symtab (text_offset + text_size, objfile, 0); 1124 } 1125 1126 1127 /* Convert basic types from HP debug format into GDB internal format. */ 1128 1129 static int 1130 hpread_type_translate (typep) 1131 dnttpointer typep; 1132 { 1133 if (!typep.dntti.immediate) 1134 abort (); 1135 1136 switch (typep.dntti.type) 1137 { 1138 case HP_TYPE_BOOLEAN: 1139 case HP_TYPE_BOOLEAN_S300_COMPAT: 1140 case HP_TYPE_BOOLEAN_VAX_COMPAT: 1141 return FT_BOOLEAN; 1142 /* Ugh. No way to distinguish between signed and unsigned chars. */ 1143 case HP_TYPE_CHAR: 1144 case HP_TYPE_WIDE_CHAR: 1145 return FT_CHAR; 1146 case HP_TYPE_INT: 1147 if (typep.dntti.bitlength <= 8) 1148 return FT_CHAR; 1149 if (typep.dntti.bitlength <= 16) 1150 return FT_SHORT; 1151 if (typep.dntti.bitlength <= 32) 1152 return FT_INTEGER; 1153 return FT_LONG_LONG; 1154 case HP_TYPE_LONG: 1155 return FT_LONG; 1156 case HP_TYPE_UNSIGNED_LONG: 1157 if (typep.dntti.bitlength <= 8) 1158 return FT_UNSIGNED_CHAR; 1159 if (typep.dntti.bitlength <= 16) 1160 return FT_UNSIGNED_SHORT; 1161 if (typep.dntti.bitlength <= 32) 1162 return FT_UNSIGNED_LONG; 1163 return FT_UNSIGNED_LONG_LONG; 1164 case HP_TYPE_UNSIGNED_INT: 1165 if (typep.dntti.bitlength <= 8) 1166 return FT_UNSIGNED_CHAR; 1167 if (typep.dntti.bitlength <= 16) 1168 return FT_UNSIGNED_SHORT; 1169 if (typep.dntti.bitlength <= 32) 1170 return FT_UNSIGNED_INTEGER; 1171 return FT_UNSIGNED_LONG_LONG; 1172 case HP_TYPE_REAL: 1173 case HP_TYPE_REAL_3000: 1174 case HP_TYPE_DOUBLE: 1175 if (typep.dntti.bitlength == 64) 1176 return FT_DBL_PREC_FLOAT; 1177 if (typep.dntti.bitlength == 128) 1178 return FT_EXT_PREC_FLOAT; 1179 return FT_FLOAT; 1180 case HP_TYPE_COMPLEX: 1181 case HP_TYPE_COMPLEXS3000: 1182 if (typep.dntti.bitlength == 128) 1183 return FT_DBL_PREC_COMPLEX; 1184 if (typep.dntti.bitlength == 192) 1185 return FT_EXT_PREC_COMPLEX; 1186 return FT_COMPLEX; 1187 case HP_TYPE_STRING200: 1188 case HP_TYPE_LONGSTRING200: 1189 case HP_TYPE_FTN_STRING_SPEC: 1190 case HP_TYPE_MOD_STRING_SPEC: 1191 case HP_TYPE_MOD_STRING_3000: 1192 case HP_TYPE_FTN_STRING_S300_COMPAT: 1193 case HP_TYPE_FTN_STRING_VAX_COMPAT: 1194 return FT_STRING; 1195 default: 1196 abort (); 1197 } 1198 } 1199 1200 /* Return the type associated with the index found in HP_TYPE. */ 1201 1202 static struct type ** 1203 hpread_lookup_type (hp_type, objfile) 1204 dnttpointer hp_type; 1205 struct objfile *objfile; 1206 { 1207 unsigned old_len; 1208 int index = hp_type.dnttp.index; 1209 1210 if (hp_type.dntti.immediate) 1211 return NULL; 1212 1213 if (index < LNTT_SYMCOUNT (objfile)) 1214 { 1215 if (index >= TYPE_VECTOR_LENGTH (objfile)) 1216 { 1217 old_len = TYPE_VECTOR_LENGTH (objfile); 1218 if (old_len == 0) 1219 { 1220 TYPE_VECTOR_LENGTH (objfile) = 100; 1221 TYPE_VECTOR (objfile) = (struct type **) 1222 xmmalloc (objfile -> md, 1223 TYPE_VECTOR_LENGTH (objfile) * sizeof (struct type *)); 1224 } 1225 while (index >= TYPE_VECTOR_LENGTH (objfile)) 1226 TYPE_VECTOR_LENGTH (objfile) *= 2; 1227 TYPE_VECTOR (objfile) = (struct type **) 1228 xmrealloc (objfile -> md, 1229 (char *) TYPE_VECTOR (objfile), 1230 (TYPE_VECTOR_LENGTH (objfile) * sizeof (struct type *))); 1231 memset (&TYPE_VECTOR (objfile)[old_len], 0, 1232 (TYPE_VECTOR_LENGTH (objfile) - old_len) * 1233 sizeof (struct type *)); 1234 } 1235 return &TYPE_VECTOR (objfile)[index]; 1236 } 1237 else 1238 return NULL; 1239 } 1240 1241 /* Possibly allocate a GDB internal type so we can internalize HP_TYPE. 1242 Note we'll just return the address of a GDB internal type if we already 1243 have it lying around. */ 1244 1245 static struct type * 1246 hpread_alloc_type (hp_type, objfile) 1247 dnttpointer hp_type; 1248 struct objfile *objfile; 1249 { 1250 struct type **type_addr; 1251 1252 type_addr = hpread_lookup_type (hp_type, objfile); 1253 if (*type_addr == 0) 1254 *type_addr = alloc_type (objfile); 1255 1256 TYPE_CPLUS_SPECIFIC (*type_addr) 1257 = (struct cplus_struct_type *) &cplus_struct_default; 1258 return *type_addr; 1259 } 1260 1261 /* Read a native enumerated type and return it in GDB internal form. */ 1262 1263 static struct type * 1264 hpread_read_enum_type (hp_type, dn_bufp, objfile) 1265 dnttpointer hp_type; 1266 union dnttentry *dn_bufp; 1267 struct objfile *objfile; 1268 { 1269 struct type *type; 1270 struct pending **symlist, *osyms, *syms; 1271 int o_nsyms, nsyms = 0; 1272 dnttpointer mem; 1273 union dnttentry *memp; 1274 char *name; 1275 long n; 1276 struct symbol *sym; 1277 1278 type = hpread_alloc_type (hp_type, objfile); 1279 TYPE_LENGTH (type) = 4; 1280 1281 symlist = &file_symbols; 1282 osyms = *symlist; 1283 o_nsyms = osyms ? osyms->nsyms : 0; 1284 1285 /* Get a name for each member and add it to our list of members. */ 1286 mem = dn_bufp->denum.firstmem; 1287 while (mem.dnttp.extension && mem.word != DNTTNIL) 1288 { 1289 memp = hpread_get_lntt (mem.dnttp.index, objfile); 1290 1291 name = VT (objfile) + memp->dmember.name; 1292 sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack, 1293 sizeof (struct symbol)); 1294 memset (sym, 0, sizeof (struct symbol)); 1295 SYMBOL_NAME (sym) = obsavestring (name, strlen (name), 1296 &objfile->symbol_obstack); 1297 SYMBOL_CLASS (sym) = LOC_CONST; 1298 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE; 1299 SYMBOL_VALUE (sym) = memp->dmember.value; 1300 add_symbol_to_list (sym, symlist); 1301 nsyms++; 1302 mem = memp->dmember.nextmem; 1303 } 1304 1305 /* Now that we know more about the enum, fill in more info. */ 1306 TYPE_CODE (type) = TYPE_CODE_ENUM; 1307 TYPE_FLAGS (type) &= ~TYPE_FLAG_STUB; 1308 TYPE_NFIELDS (type) = nsyms; 1309 TYPE_FIELDS (type) = (struct field *) 1310 obstack_alloc (&objfile->type_obstack, sizeof (struct field) * nsyms); 1311 1312 /* Find the symbols for the members and put them into the type. 1313 The symbols can be found in the symlist that we put them on 1314 to cause them to be defined. osyms contains the old value 1315 of that symlist; everything up to there was defined by us. 1316 1317 Note that we preserve the order of the enum constants, so 1318 that in something like "enum {FOO, LAST_THING=FOO}" we print 1319 FOO, not LAST_THING. */ 1320 for (syms = *symlist, n = 0; syms; syms = syms->next) 1321 { 1322 int j = 0; 1323 if (syms == osyms) 1324 j = o_nsyms; 1325 for (; j < syms->nsyms; j++, n++) 1326 { 1327 struct symbol *xsym = syms->symbol[j]; 1328 SYMBOL_TYPE (xsym) = type; 1329 TYPE_FIELD_NAME (type, n) = SYMBOL_NAME (xsym); 1330 TYPE_FIELD_VALUE (type, n) = 0; 1331 TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym); 1332 TYPE_FIELD_BITSIZE (type, n) = 0; 1333 } 1334 if (syms == osyms) 1335 break; 1336 } 1337 1338 return type; 1339 } 1340 1341 /* Read and internalize a native function debug symbol. */ 1342 1343 static struct type * 1344 hpread_read_function_type (hp_type, dn_bufp, objfile) 1345 dnttpointer hp_type; 1346 union dnttentry *dn_bufp; 1347 struct objfile *objfile; 1348 { 1349 struct type *type, *type1; 1350 struct pending **symlist, *osyms, *syms; 1351 int o_nsyms, nsyms = 0; 1352 dnttpointer param; 1353 union dnttentry *paramp; 1354 char *name; 1355 long n; 1356 struct symbol *sym; 1357 1358 param = dn_bufp->dfunc.firstparam; 1359 1360 /* See if we've already read in this type. */ 1361 type = hpread_alloc_type (hp_type, objfile); 1362 if (TYPE_CODE (type) == TYPE_CODE_FUNC) 1363 return type; 1364 1365 /* Nope, so read it in and store it away. */ 1366 type1 = lookup_function_type (hpread_type_lookup (dn_bufp->dfunc.retval, 1367 objfile)); 1368 memcpy ((char *) type, (char *) type1, sizeof (struct type)); 1369 1370 symlist = &local_symbols; 1371 osyms = *symlist; 1372 o_nsyms = osyms ? osyms->nsyms : 0; 1373 1374 /* Now examine each parameter noting its type, location, and a 1375 wealth of other information. */ 1376 while (param.word && param.word != DNTTNIL) 1377 { 1378 paramp = hpread_get_lntt (param.dnttp.index, objfile); 1379 nsyms++; 1380 param = paramp->dfparam.nextparam; 1381 1382 /* Get the name. */ 1383 name = VT (objfile) + paramp->dfparam.name; 1384 sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack, 1385 sizeof (struct symbol)); 1386 (void) memset (sym, 0, sizeof (struct symbol)); 1387 SYMBOL_NAME (sym) = obsavestring (name, strlen (name), 1388 &objfile->symbol_obstack); 1389 1390 /* Figure out where it lives. */ 1391 if (paramp->dfparam.regparam) 1392 SYMBOL_CLASS (sym) = LOC_REGPARM; 1393 else if (paramp->dfparam.indirect) 1394 SYMBOL_CLASS (sym) = LOC_REF_ARG; 1395 else 1396 SYMBOL_CLASS (sym) = LOC_ARG; 1397 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE; 1398 if (paramp->dfparam.copyparam) 1399 { 1400 SYMBOL_VALUE (sym) = paramp->dfparam.location ; 1401 #ifdef HPREAD_ADJUST_STACK_ADDRESS 1402 SYMBOL_VALUE (sym) 1403 += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile)); 1404 #endif 1405 /* This is likely a pass-by-invisible reference parameter, 1406 Hack on the symbol class to make GDB happy. */ 1407 SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR; 1408 } 1409 else 1410 SYMBOL_VALUE (sym) = paramp->dfparam.location; 1411 1412 /* Get its type. */ 1413 SYMBOL_TYPE (sym) = hpread_type_lookup (paramp->dfparam.type, objfile); 1414 1415 /* Add it to the list. */ 1416 add_symbol_to_list (sym, symlist); 1417 } 1418 1419 /* Note how many parameters we found. */ 1420 TYPE_NFIELDS (type) = nsyms; 1421 TYPE_FIELDS (type) = (struct field *) 1422 obstack_alloc (&objfile->type_obstack, 1423 sizeof (struct field) * nsyms); 1424 1425 /* Find the symbols for the values and put them into the type. 1426 The symbols can be found in the symlist that we put them on 1427 to cause them to be defined. osyms contains the old value 1428 of that symlist; everything up to there was defined by us. */ 1429 /* Note that we preserve the order of the parameters, so 1430 that in something like "enum {FOO, LAST_THING=FOO}" we print 1431 FOO, not LAST_THING. */ 1432 for (syms = *symlist, n = 0; syms; syms = syms->next) 1433 { 1434 int j = 0; 1435 if (syms == osyms) 1436 j = o_nsyms; 1437 for (; j < syms->nsyms; j++, n++) 1438 { 1439 struct symbol *xsym = syms->symbol[j]; 1440 TYPE_FIELD_NAME (type, n) = SYMBOL_NAME (xsym); 1441 TYPE_FIELD_TYPE (type, n) = SYMBOL_TYPE (xsym); 1442 TYPE_FIELD_BITPOS (type, n) = n; 1443 TYPE_FIELD_BITSIZE (type, n) = 0; 1444 } 1445 if (syms == osyms) 1446 break; 1447 } 1448 return type; 1449 } 1450 1451 /* Read in and internalize a structure definition. */ 1452 1453 static struct type * 1454 hpread_read_struct_type (hp_type, dn_bufp, objfile) 1455 dnttpointer hp_type; 1456 union dnttentry *dn_bufp; 1457 struct objfile *objfile; 1458 { 1459 struct nextfield 1460 { 1461 struct nextfield *next; 1462 struct field field; 1463 }; 1464 1465 struct type *type; 1466 struct nextfield *list = 0; 1467 struct nextfield *new; 1468 int n, nfields = 0; 1469 dnttpointer field; 1470 union dnttentry *fieldp; 1471 1472 /* Is it something we've already dealt with? */ 1473 type = hpread_alloc_type (hp_type, objfile); 1474 if ((TYPE_CODE (type) == TYPE_CODE_STRUCT) || 1475 (TYPE_CODE (type) == TYPE_CODE_UNION)) 1476 return type; 1477 1478 /* Get the basic type correct. */ 1479 if (dn_bufp->dblock.kind == DNTT_TYPE_STRUCT) 1480 { 1481 TYPE_CODE (type) = TYPE_CODE_STRUCT; 1482 TYPE_LENGTH (type) = dn_bufp->dstruct.bitlength / 8; 1483 } 1484 else if (dn_bufp->dblock.kind == DNTT_TYPE_UNION) 1485 { 1486 TYPE_CODE (type) = TYPE_CODE_UNION; 1487 TYPE_LENGTH (type) = dn_bufp->dunion.bitlength / 8; 1488 } 1489 else 1490 return type; 1491 1492 1493 TYPE_FLAGS (type) &= ~TYPE_FLAG_STUB; 1494 1495 /* Read in and internalize all the fields. */ 1496 field = dn_bufp->dstruct.firstfield; 1497 while (field.word != DNTTNIL && field.dnttp.extension) 1498 { 1499 fieldp = hpread_get_lntt (field.dnttp.index, objfile); 1500 1501 /* Get space to record the next field's data. */ 1502 new = (struct nextfield *) alloca (sizeof (struct nextfield)); 1503 new->next = list; 1504 list = new; 1505 1506 list->field.name = VT (objfile) + fieldp->dfield.name; 1507 list->field.bitpos = fieldp->dfield.bitoffset; 1508 if (fieldp->dfield.bitlength % 8) 1509 list->field.bitsize = fieldp->dfield.bitlength; 1510 else 1511 list->field.bitsize = 0; 1512 nfields++; 1513 field = fieldp->dfield.nextfield; 1514 list->field.type = hpread_type_lookup (fieldp->dfield.type, objfile); 1515 } 1516 1517 TYPE_NFIELDS (type) = nfields; 1518 TYPE_FIELDS (type) = (struct field *) 1519 obstack_alloc (&objfile->type_obstack, sizeof (struct field) * nfields); 1520 1521 /* Copy the saved-up fields into the field vector. */ 1522 for (n = nfields; list; list = list->next) 1523 { 1524 n -= 1; 1525 TYPE_FIELD (type, n) = list->field; 1526 } 1527 return type; 1528 } 1529 1530 /* Read in and internalize a set debug symbol. */ 1531 1532 static struct type * 1533 hpread_read_set_type (hp_type, dn_bufp, objfile) 1534 dnttpointer hp_type; 1535 union dnttentry *dn_bufp; 1536 struct objfile *objfile; 1537 { 1538 struct type *type; 1539 1540 /* See if it's something we've already deal with. */ 1541 type = hpread_alloc_type (hp_type, objfile); 1542 if (TYPE_CODE (type) == TYPE_CODE_SET) 1543 return type; 1544 1545 /* Nope. Fill in the appropriate fields. */ 1546 TYPE_CODE (type) = TYPE_CODE_SET; 1547 TYPE_LENGTH (type) = dn_bufp->dset.bitlength / 8; 1548 TYPE_NFIELDS (type) = 0; 1549 TYPE_TARGET_TYPE (type) = hpread_type_lookup (dn_bufp->dset.subtype, 1550 objfile); 1551 return type; 1552 } 1553 1554 /* Read in and internalize an array debug symbol. */ 1555 1556 static struct type * 1557 hpread_read_array_type (hp_type, dn_bufp, objfile) 1558 dnttpointer hp_type; 1559 union dnttentry *dn_bufp; 1560 struct objfile *objfile; 1561 { 1562 struct type *type; 1563 union dnttentry save; 1564 save = *dn_bufp; 1565 1566 /* Why no check here? Because it kept us from properly determining 1567 the size of the array! */ 1568 type = hpread_alloc_type (hp_type, objfile); 1569 1570 TYPE_CODE (type) = TYPE_CODE_ARRAY; 1571 1572 /* values are not normalized. */ 1573 if (!((dn_bufp->darray.arrayisbytes && dn_bufp->darray.elemisbytes) 1574 || (!dn_bufp->darray.arrayisbytes && !dn_bufp->darray.elemisbytes))) 1575 abort (); 1576 else if (dn_bufp->darray.arraylength == 0x7fffffff) 1577 { 1578 /* The HP debug format represents char foo[]; as an array with 1579 length 0x7fffffff. Internally GDB wants to represent this 1580 as an array of length zero. */ 1581 TYPE_LENGTH (type) = 0; 1582 } 1583 else 1584 TYPE_LENGTH (type) = dn_bufp->darray.arraylength / 8; 1585 1586 TYPE_NFIELDS (type) = 1; 1587 TYPE_TARGET_TYPE (type) = hpread_type_lookup (dn_bufp->darray.elemtype, 1588 objfile); 1589 dn_bufp = &save; 1590 TYPE_FIELDS (type) = (struct field *) 1591 obstack_alloc (&objfile->type_obstack, sizeof (struct field)); 1592 TYPE_FIELD_TYPE (type, 0) = hpread_type_lookup (dn_bufp->darray.indextype, 1593 objfile); 1594 return type; 1595 } 1596 1597 /* Read in and internalize a subrange debug symbol. */ 1598 static struct type * 1599 hpread_read_subrange_type (hp_type, dn_bufp, objfile) 1600 dnttpointer hp_type; 1601 union dnttentry *dn_bufp; 1602 struct objfile *objfile; 1603 { 1604 struct type *type; 1605 1606 /* Is it something we've already dealt with. */ 1607 type = hpread_alloc_type (hp_type, objfile); 1608 if (TYPE_CODE (type) == TYPE_CODE_RANGE) 1609 return type; 1610 1611 /* Nope, internalize it. */ 1612 TYPE_CODE (type) = TYPE_CODE_RANGE; 1613 TYPE_LENGTH (type) = dn_bufp->dsubr.bitlength / 8; 1614 TYPE_NFIELDS (type) = 2; 1615 TYPE_FIELDS (type) 1616 = (struct field *) obstack_alloc (&objfile->type_obstack, 1617 2 * sizeof (struct field)); 1618 1619 if (dn_bufp->dsubr.dyn_low) 1620 TYPE_FIELD_BITPOS (type, 0) = 0; 1621 else 1622 TYPE_FIELD_BITPOS (type, 0) = dn_bufp->dsubr.lowbound; 1623 1624 if (dn_bufp->dsubr.dyn_high) 1625 TYPE_FIELD_BITPOS (type, 1) = -1; 1626 else 1627 TYPE_FIELD_BITPOS (type, 1) = dn_bufp->dsubr.highbound; 1628 TYPE_TARGET_TYPE (type) = hpread_type_lookup (dn_bufp->dsubr.subtype, 1629 objfile); 1630 return type; 1631 } 1632 1633 static struct type * 1634 hpread_type_lookup (hp_type, objfile) 1635 dnttpointer hp_type; 1636 struct objfile *objfile; 1637 { 1638 union dnttentry *dn_bufp; 1639 1640 /* First see if it's a simple builtin type. */ 1641 if (hp_type.dntti.immediate) 1642 return lookup_fundamental_type (objfile, hpread_type_translate (hp_type)); 1643 1644 /* Not a builtin type. We'll have to read it in. */ 1645 if (hp_type.dnttp.index < LNTT_SYMCOUNT (objfile)) 1646 dn_bufp = hpread_get_lntt (hp_type.dnttp.index, objfile); 1647 else 1648 return lookup_fundamental_type (objfile, FT_VOID); 1649 1650 switch (dn_bufp->dblock.kind) 1651 { 1652 case DNTT_TYPE_SRCFILE: 1653 case DNTT_TYPE_MODULE: 1654 case DNTT_TYPE_FUNCTION: 1655 case DNTT_TYPE_ENTRY: 1656 case DNTT_TYPE_BEGIN: 1657 case DNTT_TYPE_END: 1658 case DNTT_TYPE_IMPORT: 1659 case DNTT_TYPE_LABEL: 1660 case DNTT_TYPE_WITH: 1661 case DNTT_TYPE_COMMON: 1662 case DNTT_TYPE_FPARAM: 1663 case DNTT_TYPE_SVAR: 1664 case DNTT_TYPE_DVAR: 1665 case DNTT_TYPE_CONST: 1666 /* Opps. Something went very wrong. */ 1667 return lookup_fundamental_type (objfile, FT_VOID); 1668 1669 case DNTT_TYPE_TYPEDEF: 1670 { 1671 struct type *structtype = hpread_type_lookup (dn_bufp->dtype.type, 1672 objfile); 1673 char *suffix; 1674 suffix = VT (objfile) + dn_bufp->dtype.name; 1675 1676 TYPE_CPLUS_SPECIFIC (structtype) 1677 = (struct cplus_struct_type *) &cplus_struct_default; 1678 TYPE_NAME (structtype) = suffix; 1679 return structtype; 1680 } 1681 1682 case DNTT_TYPE_TAGDEF: 1683 { 1684 /* Just a little different from above. We have to tack on 1685 an identifier of some kind (struct, union, enum, etc). */ 1686 struct type *structtype = hpread_type_lookup (dn_bufp->dtype.type, 1687 objfile); 1688 char *prefix, *suffix; 1689 suffix = VT (objfile) + dn_bufp->dtype.name; 1690 1691 /* Lookup the next type in the list. It should be a structure, 1692 union, or enum type. We will need to attach that to our name. */ 1693 if (dn_bufp->dtype.type.dnttp.index < LNTT_SYMCOUNT (objfile)) 1694 dn_bufp = hpread_get_lntt (dn_bufp->dtype.type.dnttp.index, objfile); 1695 else 1696 abort (); 1697 1698 if (dn_bufp->dblock.kind == DNTT_TYPE_STRUCT) 1699 prefix = "struct "; 1700 else if (dn_bufp->dblock.kind == DNTT_TYPE_UNION) 1701 prefix = "union "; 1702 else 1703 prefix = "enum "; 1704 1705 /* Build the correct name. */ 1706 structtype->name 1707 = (char *) obstack_alloc (&objfile->type_obstack, 1708 strlen (prefix) + strlen (suffix) + 1); 1709 TYPE_NAME (structtype) = strcpy (TYPE_NAME (structtype), prefix); 1710 TYPE_NAME (structtype) = strcat (TYPE_NAME (structtype), suffix); 1711 TYPE_TAG_NAME (structtype) = suffix; 1712 1713 TYPE_CPLUS_SPECIFIC (structtype) 1714 = (struct cplus_struct_type *) &cplus_struct_default; 1715 1716 return structtype; 1717 } 1718 case DNTT_TYPE_POINTER: 1719 return lookup_pointer_type (hpread_type_lookup (dn_bufp->dptr.pointsto, 1720 objfile)); 1721 case DNTT_TYPE_ENUM: 1722 return hpread_read_enum_type (hp_type, dn_bufp, objfile); 1723 case DNTT_TYPE_MEMENUM: 1724 return lookup_fundamental_type (objfile, FT_VOID); 1725 case DNTT_TYPE_SET: 1726 return hpread_read_set_type (hp_type, dn_bufp, objfile); 1727 case DNTT_TYPE_SUBRANGE: 1728 return hpread_read_subrange_type (hp_type, dn_bufp, objfile); 1729 case DNTT_TYPE_ARRAY: 1730 return hpread_read_array_type (hp_type, dn_bufp, objfile); 1731 case DNTT_TYPE_STRUCT: 1732 case DNTT_TYPE_UNION: 1733 return hpread_read_struct_type (hp_type, dn_bufp, objfile); 1734 case DNTT_TYPE_FIELD: 1735 return hpread_type_lookup (dn_bufp->dfield.type, objfile); 1736 case DNTT_TYPE_VARIANT: 1737 case DNTT_TYPE_FILE: 1738 return lookup_fundamental_type (objfile, FT_VOID); 1739 case DNTT_TYPE_FUNCTYPE: 1740 return lookup_function_type (hpread_type_lookup (dn_bufp->dfunctype.retval, 1741 objfile)); 1742 case DNTT_TYPE_COBSTRUCT: 1743 case DNTT_TYPE_XREF: 1744 case DNTT_TYPE_SA: 1745 case DNTT_TYPE_MACRO: 1746 default: 1747 return lookup_fundamental_type (objfile, FT_VOID); 1748 } 1749 } 1750 1751 static sltpointer 1752 hpread_record_lines (subfile, s_idx, e_idx, objfile, offset) 1753 struct subfile *subfile; 1754 sltpointer s_idx, e_idx; 1755 struct objfile *objfile; 1756 CORE_ADDR offset; 1757 { 1758 union sltentry *sl_bufp; 1759 1760 while (s_idx <= e_idx) 1761 { 1762 sl_bufp = hpread_get_slt (s_idx, objfile); 1763 /* Only record "normal" entries in the SLT. */ 1764 if (sl_bufp->snorm.sltdesc == SLT_NORMAL 1765 || sl_bufp->snorm.sltdesc == SLT_EXIT) 1766 record_line (subfile, sl_bufp->snorm.line, 1767 sl_bufp->snorm.address + offset); 1768 s_idx++; 1769 } 1770 return e_idx; 1771 } 1772 1773 /* Internalize one native debug symbol. */ 1774 1775 static void 1776 hpread_process_one_debug_symbol (dn_bufp, name, section_offsets, objfile, 1777 text_offset, text_size, filename, index) 1778 union dnttentry *dn_bufp; 1779 char *name; 1780 struct section_offsets *section_offsets; 1781 struct objfile *objfile; 1782 CORE_ADDR text_offset; 1783 int text_size; 1784 char *filename; 1785 int index; 1786 { 1787 unsigned long desc; 1788 int type; 1789 CORE_ADDR valu; 1790 int offset = ANOFFSET (section_offsets, SECT_OFF_TEXT); 1791 union dnttentry *dn_temp; 1792 dnttpointer hp_type; 1793 struct symbol *sym; 1794 struct context_stack *new; 1795 1796 /* Allocate one GDB debug symbol and fill in some default values. */ 1797 sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack, 1798 sizeof (struct symbol)); 1799 memset (sym, 0, sizeof (struct symbol)); 1800 SYMBOL_NAME (sym) = obsavestring (name, strlen (name), &objfile->symbol_obstack); 1801 SYMBOL_LANGUAGE (sym) = language_auto; 1802 SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->symbol_obstack); 1803 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE; 1804 SYMBOL_LINE (sym) = 0; 1805 SYMBOL_VALUE (sym) = 0; 1806 SYMBOL_CLASS (sym) = LOC_TYPEDEF; 1807 1808 hp_type.dnttp.extension = 1; 1809 hp_type.dnttp.immediate = 0; 1810 hp_type.dnttp.global = 0; 1811 hp_type.dnttp.index = index; 1812 1813 type = dn_bufp->dblock.kind; 1814 1815 switch (type) 1816 { 1817 case DNTT_TYPE_SRCFILE: 1818 /* This type of symbol indicates from which source file or include file 1819 the following data comes. If there are no modules it also may 1820 indicate the start of a new source file, in which case we must 1821 finish the symbol table of the previous source file 1822 (if any) and start accumulating a new symbol table. */ 1823 1824 valu = text_offset; 1825 if (!last_source_file) 1826 { 1827 start_symtab (name, NULL, valu); 1828 SL_INDEX (objfile) = dn_bufp->dsfile.address; 1829 } 1830 else 1831 { 1832 SL_INDEX (objfile) = hpread_record_lines (current_subfile, 1833 SL_INDEX (objfile), 1834 dn_bufp->dsfile.address, 1835 objfile, offset); 1836 } 1837 start_subfile (name, NULL); 1838 break; 1839 1840 case DNTT_TYPE_MODULE: 1841 /* No need to do anything with these DNTT_TYPE_MODULE symbols anymore. */ 1842 break; 1843 1844 case DNTT_TYPE_FUNCTION: 1845 case DNTT_TYPE_ENTRY: 1846 /* A function or secondary entry point. */ 1847 valu = dn_bufp->dfunc.lowaddr + offset; 1848 SL_INDEX (objfile) = hpread_record_lines (current_subfile, 1849 SL_INDEX (objfile), 1850 dn_bufp->dfunc.address, 1851 objfile, offset); 1852 1853 WITHIN_FUNCTION (objfile) = 1; 1854 CURRENT_FUNCTION_VALUE (objfile) = valu; 1855 1856 /* Stack must be empty now. */ 1857 if (context_stack_depth != 0) 1858 complain (&lbrac_unmatched_complaint, (char *) symnum); 1859 new = push_context (0, valu); 1860 1861 SYMBOL_CLASS (sym) = LOC_BLOCK; 1862 SYMBOL_TYPE (sym) = hpread_read_function_type (hp_type, dn_bufp, objfile); 1863 if (dn_bufp->dfunc.global) 1864 add_symbol_to_list (sym, &global_symbols); 1865 else 1866 add_symbol_to_list (sym, &file_symbols); 1867 new->name = sym; 1868 1869 /* Search forward to the next scope beginning. */ 1870 while (dn_bufp->dblock.kind != DNTT_TYPE_BEGIN) 1871 { 1872 dn_bufp = hpread_get_lntt (++index, objfile); 1873 if (dn_bufp->dblock.extension) 1874 continue; 1875 } 1876 SL_INDEX (objfile) = hpread_record_lines (current_subfile, 1877 SL_INDEX (objfile), 1878 dn_bufp->dbegin.address, 1879 objfile, offset); 1880 SYMBOL_LINE (sym) = hpread_get_line (dn_bufp->dbegin.address, objfile); 1881 record_line (current_subfile, SYMBOL_LINE (sym), valu); 1882 break; 1883 1884 case DNTT_TYPE_BEGIN: 1885 /* Begin a new scope. */ 1886 SL_INDEX (objfile) = hpread_record_lines (current_subfile, 1887 SL_INDEX (objfile), 1888 dn_bufp->dbegin.address, 1889 objfile, offset); 1890 valu = hpread_get_location (dn_bufp->dbegin.address, objfile); 1891 valu += offset; /* Relocate for dynamic loading */ 1892 desc = hpread_get_depth (dn_bufp->dbegin.address, objfile); 1893 new = push_context (desc, valu); 1894 break; 1895 1896 case DNTT_TYPE_END: 1897 /* End a scope. */ 1898 SL_INDEX (objfile) = hpread_record_lines (current_subfile, 1899 SL_INDEX (objfile), 1900 dn_bufp->dend.address + 1, 1901 objfile, offset); 1902 switch (dn_bufp->dend.endkind) 1903 { 1904 case DNTT_TYPE_MODULE: 1905 /* Ending a module ends the symbol table for that module. */ 1906 valu = text_offset + text_size + offset; 1907 (void) end_symtab (valu, objfile, 0); 1908 break; 1909 1910 case DNTT_TYPE_FUNCTION: 1911 /* Ending a function, well, ends the function's scope. */ 1912 dn_temp = hpread_get_lntt (dn_bufp->dend.beginscope.dnttp.index, 1913 objfile); 1914 valu = dn_temp->dfunc.hiaddr + offset; 1915 new = pop_context (); 1916 /* Make a block for the local symbols within. */ 1917 finish_block (new->name, &local_symbols, new->old_blocks, 1918 new->start_addr, valu, objfile); 1919 WITHIN_FUNCTION (objfile) = 0; 1920 break; 1921 case DNTT_TYPE_BEGIN: 1922 /* Just ending a local scope. */ 1923 valu = hpread_get_location (dn_bufp->dend.address, objfile); 1924 /* Why in the hell is this needed? */ 1925 valu += offset + 9; /* Relocate for dynamic loading */ 1926 new = pop_context (); 1927 desc = dn_bufp->dend.beginscope.dnttp.index; 1928 if (desc != new->depth) 1929 complain (&lbrac_mismatch_complaint, (char *) symnum); 1930 /* Make a block for the local symbols within. */ 1931 finish_block (new->name, &local_symbols, new->old_blocks, 1932 new->start_addr, valu, objfile); 1933 local_symbols = new->locals; 1934 break; 1935 } 1936 break; 1937 case DNTT_TYPE_LABEL: 1938 SYMBOL_NAMESPACE (sym) = LABEL_NAMESPACE; 1939 break; 1940 case DNTT_TYPE_FPARAM: 1941 /* Function parameters. */ 1942 if (dn_bufp->dfparam.regparam) 1943 SYMBOL_CLASS (sym) = LOC_REGISTER; 1944 else 1945 SYMBOL_CLASS (sym) = LOC_LOCAL; 1946 if (dn_bufp->dfparam.copyparam) 1947 { 1948 SYMBOL_VALUE (sym) = dn_bufp->dfparam.location; 1949 #ifdef HPREAD_ADJUST_STACK_ADDRESS 1950 SYMBOL_VALUE (sym) 1951 += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile)); 1952 #endif 1953 } 1954 else 1955 SYMBOL_VALUE (sym) = dn_bufp->dfparam.location; 1956 SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dfparam.type, objfile); 1957 add_symbol_to_list (sym, &local_symbols); 1958 break; 1959 case DNTT_TYPE_SVAR: 1960 /* Static variables. */ 1961 SYMBOL_CLASS (sym) = LOC_STATIC; 1962 SYMBOL_VALUE_ADDRESS (sym) = dn_bufp->dsvar.location; 1963 SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dsvar.type, objfile); 1964 if (dn_bufp->dsvar.global) 1965 add_symbol_to_list (sym, &global_symbols); 1966 else if (WITHIN_FUNCTION (objfile)) 1967 add_symbol_to_list (sym, &local_symbols); 1968 else 1969 add_symbol_to_list (sym, &file_symbols); 1970 break; 1971 case DNTT_TYPE_DVAR: 1972 /* Dynamic variables. */ 1973 if (dn_bufp->ddvar.regvar) 1974 SYMBOL_CLASS (sym) = LOC_REGISTER; 1975 else 1976 SYMBOL_CLASS (sym) = LOC_LOCAL; 1977 SYMBOL_VALUE (sym) = dn_bufp->ddvar.location; 1978 #ifdef HPREAD_ADJUST_STACK_ADDRESS 1979 SYMBOL_VALUE (sym) 1980 += HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile)); 1981 #endif 1982 SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->ddvar.type, objfile); 1983 if (dn_bufp->ddvar.global) 1984 add_symbol_to_list (sym, &global_symbols); 1985 else if (WITHIN_FUNCTION (objfile)) 1986 add_symbol_to_list (sym, &local_symbols); 1987 else 1988 add_symbol_to_list (sym, &file_symbols); 1989 break; 1990 case DNTT_TYPE_CONST: 1991 /* A constant (pascal?). */ 1992 SYMBOL_CLASS (sym) = LOC_CONST; 1993 SYMBOL_VALUE (sym) = dn_bufp->dconst.location; 1994 SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dconst.type, objfile); 1995 if (dn_bufp->dconst.global) 1996 add_symbol_to_list (sym, &global_symbols); 1997 else if (WITHIN_FUNCTION (objfile)) 1998 add_symbol_to_list (sym, &local_symbols); 1999 else 2000 add_symbol_to_list (sym, &file_symbols); 2001 break; 2002 case DNTT_TYPE_TYPEDEF: 2003 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE; 2004 SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dtype.type, objfile); 2005 if (dn_bufp->dtype.global) 2006 add_symbol_to_list (sym, &global_symbols); 2007 else if (WITHIN_FUNCTION (objfile)) 2008 add_symbol_to_list (sym, &local_symbols); 2009 else 2010 add_symbol_to_list (sym, &file_symbols); 2011 break; 2012 case DNTT_TYPE_TAGDEF: 2013 SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE; 2014 SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dtype.type, objfile); 2015 TYPE_NAME (sym->type) = SYMBOL_NAME (sym); 2016 TYPE_TAG_NAME (sym->type) = SYMBOL_NAME (sym); 2017 if (dn_bufp->dtype.global) 2018 add_symbol_to_list (sym, &global_symbols); 2019 else if (WITHIN_FUNCTION (objfile)) 2020 add_symbol_to_list (sym, &local_symbols); 2021 else 2022 add_symbol_to_list (sym, &file_symbols); 2023 break; 2024 case DNTT_TYPE_POINTER: 2025 SYMBOL_TYPE (sym) = lookup_pointer_type (hpread_type_lookup 2026 (dn_bufp->dptr.pointsto, 2027 objfile)); 2028 add_symbol_to_list (sym, &file_symbols); 2029 break; 2030 case DNTT_TYPE_ENUM: 2031 SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE; 2032 SYMBOL_TYPE (sym) = hpread_read_enum_type (hp_type, dn_bufp, objfile); 2033 add_symbol_to_list (sym, &file_symbols); 2034 break; 2035 case DNTT_TYPE_MEMENUM: 2036 break; 2037 case DNTT_TYPE_SET: 2038 SYMBOL_TYPE (sym) = hpread_read_set_type (hp_type, dn_bufp, objfile); 2039 add_symbol_to_list (sym, &file_symbols); 2040 break; 2041 case DNTT_TYPE_SUBRANGE: 2042 SYMBOL_TYPE (sym) = hpread_read_subrange_type (hp_type, dn_bufp, 2043 objfile); 2044 add_symbol_to_list (sym, &file_symbols); 2045 break; 2046 case DNTT_TYPE_ARRAY: 2047 SYMBOL_TYPE (sym) = hpread_read_array_type (hp_type, dn_bufp, objfile); 2048 add_symbol_to_list (sym, &file_symbols); 2049 break; 2050 case DNTT_TYPE_STRUCT: 2051 case DNTT_TYPE_UNION: 2052 SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE; 2053 SYMBOL_TYPE (sym) = hpread_read_struct_type (hp_type, dn_bufp, objfile); 2054 add_symbol_to_list (sym, &file_symbols); 2055 break; 2056 default: 2057 break; 2058 } 2059 } 2060