1 /* DWARF debugging format support for GDB. 2 Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996 3 Free Software Foundation, Inc. 4 Written by Fred Fish at Cygnus Support. Portions based on dbxread.c, 5 mipsread.c, coffread.c, and dwarfread.c from a Data General SVR4 gdb port. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 22 23 /* 24 25 FIXME: Do we need to generate dependencies in partial symtabs? 26 (Perhaps we don't need to). 27 28 FIXME: Resolve minor differences between what information we put in the 29 partial symbol table and what dbxread puts in. For example, we don't yet 30 put enum constants there. And dbxread seems to invent a lot of typedefs 31 we never see. Use the new printpsym command to see the partial symbol table 32 contents. 33 34 FIXME: Figure out a better way to tell gdb about the name of the function 35 contain the user's entry point (I.E. main()) 36 37 FIXME: See other FIXME's and "ifdef 0" scattered throughout the code for 38 other things to work on, if you get bored. :-) 39 40 */ 41 42 #include "defs.h" 43 #include "symtab.h" 44 #include "gdbtypes.h" 45 #include "symfile.h" 46 #include "objfiles.h" 47 #include "elf/dwarf.h" 48 #include "buildsym.h" 49 #include "demangle.h" 50 #include "expression.h" /* Needed for enum exp_opcode in language.h, sigh... */ 51 #include "language.h" 52 #include "complaints.h" 53 54 #include <fcntl.h> 55 #include "gdb_string.h" 56 57 /* Some macros to provide DIE info for complaints. */ 58 59 #define DIE_ID (curdie!=NULL ? curdie->die_ref : 0) 60 #define DIE_NAME (curdie!=NULL && curdie->at_name!=NULL) ? curdie->at_name : "" 61 62 /* Complaints that can be issued during DWARF debug info reading. */ 63 64 struct complaint no_bfd_get_N = 65 { 66 "DIE @ 0x%x \"%s\", no bfd support for %d byte data object", 0, 0 67 }; 68 69 struct complaint malformed_die = 70 { 71 "DIE @ 0x%x \"%s\", malformed DIE, bad length (%d bytes)", 0, 0 72 }; 73 74 struct complaint bad_die_ref = 75 { 76 "DIE @ 0x%x \"%s\", reference to DIE (0x%x) outside compilation unit", 0, 0 77 }; 78 79 struct complaint unknown_attribute_form = 80 { 81 "DIE @ 0x%x \"%s\", unknown attribute form (0x%x)", 0, 0 82 }; 83 84 struct complaint unknown_attribute_length = 85 { 86 "DIE @ 0x%x \"%s\", unknown attribute length, skipped remaining attributes", 0, 0 87 }; 88 89 struct complaint unexpected_fund_type = 90 { 91 "DIE @ 0x%x \"%s\", unexpected fundamental type 0x%x", 0, 0 92 }; 93 94 struct complaint unknown_type_modifier = 95 { 96 "DIE @ 0x%x \"%s\", unknown type modifier %u", 0, 0 97 }; 98 99 struct complaint volatile_ignored = 100 { 101 "DIE @ 0x%x \"%s\", type modifier 'volatile' ignored", 0, 0 102 }; 103 104 struct complaint const_ignored = 105 { 106 "DIE @ 0x%x \"%s\", type modifier 'const' ignored", 0, 0 107 }; 108 109 struct complaint botched_modified_type = 110 { 111 "DIE @ 0x%x \"%s\", botched modified type decoding (mtype 0x%x)", 0, 0 112 }; 113 114 struct complaint op_deref2 = 115 { 116 "DIE @ 0x%x \"%s\", OP_DEREF2 address 0x%x not handled", 0, 0 117 }; 118 119 struct complaint op_deref4 = 120 { 121 "DIE @ 0x%x \"%s\", OP_DEREF4 address 0x%x not handled", 0, 0 122 }; 123 124 struct complaint basereg_not_handled = 125 { 126 "DIE @ 0x%x \"%s\", BASEREG %d not handled", 0, 0 127 }; 128 129 struct complaint dup_user_type_allocation = 130 { 131 "DIE @ 0x%x \"%s\", internal error: duplicate user type allocation", 0, 0 132 }; 133 134 struct complaint dup_user_type_definition = 135 { 136 "DIE @ 0x%x \"%s\", internal error: duplicate user type definition", 0, 0 137 }; 138 139 struct complaint missing_tag = 140 { 141 "DIE @ 0x%x \"%s\", missing class, structure, or union tag", 0, 0 142 }; 143 144 struct complaint bad_array_element_type = 145 { 146 "DIE @ 0x%x \"%s\", bad array element type attribute 0x%x", 0, 0 147 }; 148 149 struct complaint subscript_data_items = 150 { 151 "DIE @ 0x%x \"%s\", can't decode subscript data items", 0, 0 152 }; 153 154 struct complaint unhandled_array_subscript_format = 155 { 156 "DIE @ 0x%x \"%s\", array subscript format 0x%x not handled yet", 0, 0 157 }; 158 159 struct complaint unknown_array_subscript_format = 160 { 161 "DIE @ 0x%x \"%s\", unknown array subscript format %x", 0, 0 162 }; 163 164 struct complaint not_row_major = 165 { 166 "DIE @ 0x%x \"%s\", array not row major; not handled correctly", 0, 0 167 }; 168 169 struct complaint missing_at_name = 170 { 171 "DIE @ 0x%x, AT_name tag missing", 0, 0 172 }; 173 174 typedef unsigned int DIE_REF; /* Reference to a DIE */ 175 176 #ifndef GCC_PRODUCER 177 #define GCC_PRODUCER "GNU C " 178 #endif 179 180 #ifndef GPLUS_PRODUCER 181 #define GPLUS_PRODUCER "GNU C++ " 182 #endif 183 184 #ifndef LCC_PRODUCER 185 #define LCC_PRODUCER "NCR C/C++" 186 #endif 187 188 #ifndef CHILL_PRODUCER 189 #define CHILL_PRODUCER "GNU Chill " 190 #endif 191 192 /* Provide a default mapping from a DWARF register number to a gdb REGNUM. */ 193 #ifndef DWARF_REG_TO_REGNUM 194 #define DWARF_REG_TO_REGNUM(num) (num) 195 #endif 196 197 /* Flags to target_to_host() that tell whether or not the data object is 198 expected to be signed. Used, for example, when fetching a signed 199 integer in the target environment which is used as a signed integer 200 in the host environment, and the two environments have different sized 201 ints. In this case, *somebody* has to sign extend the smaller sized 202 int. */ 203 204 #define GET_UNSIGNED 0 /* No sign extension required */ 205 #define GET_SIGNED 1 /* Sign extension required */ 206 207 /* Defines for things which are specified in the document "DWARF Debugging 208 Information Format" published by UNIX International, Programming Languages 209 SIG. These defines are based on revision 1.0.0, Jan 20, 1992. */ 210 211 #define SIZEOF_DIE_LENGTH 4 212 #define SIZEOF_DIE_TAG 2 213 #define SIZEOF_ATTRIBUTE 2 214 #define SIZEOF_FORMAT_SPECIFIER 1 215 #define SIZEOF_FMT_FT 2 216 #define SIZEOF_LINETBL_LENGTH 4 217 #define SIZEOF_LINETBL_LINENO 4 218 #define SIZEOF_LINETBL_STMT 2 219 #define SIZEOF_LINETBL_DELTA 4 220 #define SIZEOF_LOC_ATOM_CODE 1 221 222 #define FORM_FROM_ATTR(attr) ((attr) & 0xF) /* Implicitly specified */ 223 224 /* Macros that return the sizes of various types of data in the target 225 environment. 226 227 FIXME: Currently these are just compile time constants (as they are in 228 other parts of gdb as well). They need to be able to get the right size 229 either from the bfd or possibly from the DWARF info. It would be nice if 230 the DWARF producer inserted DIES that describe the fundamental types in 231 the target environment into the DWARF info, similar to the way dbx stabs 232 producers produce information about their fundamental types. */ 233 234 #define TARGET_FT_POINTER_SIZE(objfile) (TARGET_PTR_BIT / TARGET_CHAR_BIT) 235 #define TARGET_FT_LONG_SIZE(objfile) (TARGET_LONG_BIT / TARGET_CHAR_BIT) 236 237 /* The Amiga SVR4 header file <dwarf.h> defines AT_element_list as a 238 FORM_BLOCK2, and this is the value emitted by the AT&T compiler. 239 However, the Issue 2 DWARF specification from AT&T defines it as 240 a FORM_BLOCK4, as does the latest specification from UI/PLSIG. 241 For backwards compatibility with the AT&T compiler produced executables 242 we define AT_short_element_list for this variant. */ 243 244 #define AT_short_element_list (0x00f0|FORM_BLOCK2) 245 246 /* External variables referenced. */ 247 248 extern int info_verbose; /* From main.c; nonzero => verbose */ 249 extern char *warning_pre_print; /* From utils.c */ 250 251 /* The DWARF debugging information consists of two major pieces, 252 one is a block of DWARF Information Entries (DIE's) and the other 253 is a line number table. The "struct dieinfo" structure contains 254 the information for a single DIE, the one currently being processed. 255 256 In order to make it easier to randomly access the attribute fields 257 of the current DIE, which are specifically unordered within the DIE, 258 each DIE is scanned and an instance of the "struct dieinfo" 259 structure is initialized. 260 261 Initialization is done in two levels. The first, done by basicdieinfo(), 262 just initializes those fields that are vital to deciding whether or not 263 to use this DIE, how to skip past it, etc. The second, done by the 264 function completedieinfo(), fills in the rest of the information. 265 266 Attributes which have block forms are not interpreted at the time 267 the DIE is scanned, instead we just save pointers to the start 268 of their value fields. 269 270 Some fields have a flag <name>_p that is set when the value of the 271 field is valid (I.E. we found a matching attribute in the DIE). Since 272 we may want to test for the presence of some attributes in the DIE, 273 such as AT_low_pc, without restricting the values of the field, 274 we need someway to note that we found such an attribute. 275 276 */ 277 278 typedef char BLOCK; 279 280 struct dieinfo { 281 char * die; /* Pointer to the raw DIE data */ 282 unsigned long die_length; /* Length of the raw DIE data */ 283 DIE_REF die_ref; /* Offset of this DIE */ 284 unsigned short die_tag; /* Tag for this DIE */ 285 unsigned long at_padding; 286 unsigned long at_sibling; 287 BLOCK * at_location; 288 char * at_name; 289 unsigned short at_fund_type; 290 BLOCK * at_mod_fund_type; 291 unsigned long at_user_def_type; 292 BLOCK * at_mod_u_d_type; 293 unsigned short at_ordering; 294 BLOCK * at_subscr_data; 295 unsigned long at_byte_size; 296 unsigned short at_bit_offset; 297 unsigned long at_bit_size; 298 BLOCK * at_element_list; 299 unsigned long at_stmt_list; 300 CORE_ADDR at_low_pc; 301 CORE_ADDR at_high_pc; 302 unsigned long at_language; 303 unsigned long at_member; 304 unsigned long at_discr; 305 BLOCK * at_discr_value; 306 BLOCK * at_string_length; 307 char * at_comp_dir; 308 char * at_producer; 309 unsigned long at_start_scope; 310 unsigned long at_stride_size; 311 unsigned long at_src_info; 312 char * at_prototyped; 313 unsigned int has_at_low_pc:1; 314 unsigned int has_at_stmt_list:1; 315 unsigned int has_at_byte_size:1; 316 unsigned int short_element_list:1; 317 }; 318 319 static int diecount; /* Approximate count of dies for compilation unit */ 320 static struct dieinfo *curdie; /* For warnings and such */ 321 322 static char *dbbase; /* Base pointer to dwarf info */ 323 static int dbsize; /* Size of dwarf info in bytes */ 324 static int dbroff; /* Relative offset from start of .debug section */ 325 static char *lnbase; /* Base pointer to line section */ 326 static int isreg; /* Kludge to identify register variables */ 327 static int optimized_out; /* Kludge to identify optimized out variables */ 328 /* Kludge to identify basereg references. Nonzero if we have an offset 329 relative to a basereg. */ 330 static int offreg; 331 /* Which base register is it relative to? */ 332 static int basereg; 333 334 /* This value is added to each symbol value. FIXME: Generalize to 335 the section_offsets structure used by dbxread (once this is done, 336 pass the appropriate section number to end_symtab). */ 337 static CORE_ADDR baseaddr; /* Add to each symbol value */ 338 339 /* The section offsets used in the current psymtab or symtab. FIXME, 340 only used to pass one value (baseaddr) at the moment. */ 341 static struct section_offsets *base_section_offsets; 342 343 /* We put a pointer to this structure in the read_symtab_private field 344 of the psymtab. */ 345 346 struct dwfinfo { 347 /* Always the absolute file offset to the start of the ".debug" 348 section for the file containing the DIE's being accessed. */ 349 file_ptr dbfoff; 350 /* Relative offset from the start of the ".debug" section to the 351 first DIE to be accessed. When building the partial symbol 352 table, this value will be zero since we are accessing the 353 entire ".debug" section. When expanding a partial symbol 354 table entry, this value will be the offset to the first 355 DIE for the compilation unit containing the symbol that 356 triggers the expansion. */ 357 int dbroff; 358 /* The size of the chunk of DIE's being examined, in bytes. */ 359 int dblength; 360 /* The absolute file offset to the line table fragment. Ignored 361 when building partial symbol tables, but used when expanding 362 them, and contains the absolute file offset to the fragment 363 of the ".line" section containing the line numbers for the 364 current compilation unit. */ 365 file_ptr lnfoff; 366 }; 367 368 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff) 369 #define DBROFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbroff) 370 #define DBLENGTH(p) (((struct dwfinfo *)((p)->read_symtab_private))->dblength) 371 #define LNFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->lnfoff) 372 373 /* The generic symbol table building routines have separate lists for 374 file scope symbols and all all other scopes (local scopes). So 375 we need to select the right one to pass to add_symbol_to_list(). 376 We do it by keeping a pointer to the correct list in list_in_scope. 377 378 FIXME: The original dwarf code just treated the file scope as the first 379 local scope, and all other local scopes as nested local scopes, and worked 380 fine. Check to see if we really need to distinguish these in buildsym.c */ 381 382 struct pending **list_in_scope = &file_symbols; 383 384 /* DIES which have user defined types or modified user defined types refer to 385 other DIES for the type information. Thus we need to associate the offset 386 of a DIE for a user defined type with a pointer to the type information. 387 388 Originally this was done using a simple but expensive algorithm, with an 389 array of unsorted structures, each containing an offset/type-pointer pair. 390 This array was scanned linearly each time a lookup was done. The result 391 was that gdb was spending over half it's startup time munging through this 392 array of pointers looking for a structure that had the right offset member. 393 394 The second attempt used the same array of structures, but the array was 395 sorted using qsort each time a new offset/type was recorded, and a binary 396 search was used to find the type pointer for a given DIE offset. This was 397 even slower, due to the overhead of sorting the array each time a new 398 offset/type pair was entered. 399 400 The third attempt uses a fixed size array of type pointers, indexed by a 401 value derived from the DIE offset. Since the minimum DIE size is 4 bytes, 402 we can divide any DIE offset by 4 to obtain a unique index into this fixed 403 size array. Since each element is a 4 byte pointer, it takes exactly as 404 much memory to hold this array as to hold the DWARF info for a given 405 compilation unit. But it gets freed as soon as we are done with it. 406 This has worked well in practice, as a reasonable tradeoff between memory 407 consumption and speed, without having to resort to much more complicated 408 algorithms. */ 409 410 static struct type **utypes; /* Pointer to array of user type pointers */ 411 static int numutypes; /* Max number of user type pointers */ 412 413 /* Maintain an array of referenced fundamental types for the current 414 compilation unit being read. For DWARF version 1, we have to construct 415 the fundamental types on the fly, since no information about the 416 fundamental types is supplied. Each such fundamental type is created by 417 calling a language dependent routine to create the type, and then a 418 pointer to that type is then placed in the array at the index specified 419 by it's FT_<TYPENAME> value. The array has a fixed size set by the 420 FT_NUM_MEMBERS compile time constant, which is the number of predefined 421 fundamental types gdb knows how to construct. */ 422 423 static struct type *ftypes[FT_NUM_MEMBERS]; /* Fundamental types */ 424 425 /* Record the language for the compilation unit which is currently being 426 processed. We know it once we have seen the TAG_compile_unit DIE, 427 and we need it while processing the DIE's for that compilation unit. 428 It is eventually saved in the symtab structure, but we don't finalize 429 the symtab struct until we have processed all the DIE's for the 430 compilation unit. We also need to get and save a pointer to the 431 language struct for this language, so we can call the language 432 dependent routines for doing things such as creating fundamental 433 types. */ 434 435 static enum language cu_language; 436 static const struct language_defn *cu_language_defn; 437 438 /* Forward declarations of static functions so we don't have to worry 439 about ordering within this file. */ 440 441 static void 442 free_utypes PARAMS ((PTR)); 443 444 static int 445 attribute_size PARAMS ((unsigned int)); 446 447 static CORE_ADDR 448 target_to_host PARAMS ((char *, int, int, struct objfile *)); 449 450 static void 451 add_enum_psymbol PARAMS ((struct dieinfo *, struct objfile *)); 452 453 static void 454 handle_producer PARAMS ((char *)); 455 456 static void 457 read_file_scope PARAMS ((struct dieinfo *, char *, char *, struct objfile *)); 458 459 static void 460 read_func_scope PARAMS ((struct dieinfo *, char *, char *, struct objfile *)); 461 462 static void 463 read_lexical_block_scope PARAMS ((struct dieinfo *, char *, char *, 464 struct objfile *)); 465 466 static void 467 scan_partial_symbols PARAMS ((char *, char *, struct objfile *)); 468 469 static void 470 scan_compilation_units PARAMS ((char *, char *, file_ptr, 471 file_ptr, struct objfile *)); 472 473 static void 474 add_partial_symbol PARAMS ((struct dieinfo *, struct objfile *)); 475 476 static void 477 basicdieinfo PARAMS ((struct dieinfo *, char *, struct objfile *)); 478 479 static void 480 completedieinfo PARAMS ((struct dieinfo *, struct objfile *)); 481 482 static void 483 dwarf_psymtab_to_symtab PARAMS ((struct partial_symtab *)); 484 485 static void 486 psymtab_to_symtab_1 PARAMS ((struct partial_symtab *)); 487 488 static void 489 read_ofile_symtab PARAMS ((struct partial_symtab *)); 490 491 static void 492 process_dies PARAMS ((char *, char *, struct objfile *)); 493 494 static void 495 read_structure_scope PARAMS ((struct dieinfo *, char *, char *, 496 struct objfile *)); 497 498 static struct type * 499 decode_array_element_type PARAMS ((char *)); 500 501 static struct type * 502 decode_subscript_data_item PARAMS ((char *, char *)); 503 504 static void 505 dwarf_read_array_type PARAMS ((struct dieinfo *)); 506 507 static void 508 read_tag_pointer_type PARAMS ((struct dieinfo *dip)); 509 510 static void 511 read_tag_string_type PARAMS ((struct dieinfo *dip)); 512 513 static void 514 read_subroutine_type PARAMS ((struct dieinfo *, char *, char *)); 515 516 static void 517 read_enumeration PARAMS ((struct dieinfo *, char *, char *, struct objfile *)); 518 519 static struct type * 520 struct_type PARAMS ((struct dieinfo *, char *, char *, struct objfile *)); 521 522 static struct type * 523 enum_type PARAMS ((struct dieinfo *, struct objfile *)); 524 525 static void 526 decode_line_numbers PARAMS ((char *)); 527 528 static struct type * 529 decode_die_type PARAMS ((struct dieinfo *)); 530 531 static struct type * 532 decode_mod_fund_type PARAMS ((char *)); 533 534 static struct type * 535 decode_mod_u_d_type PARAMS ((char *)); 536 537 static struct type * 538 decode_modified_type PARAMS ((char *, unsigned int, int)); 539 540 static struct type * 541 decode_fund_type PARAMS ((unsigned int)); 542 543 static char * 544 create_name PARAMS ((char *, struct obstack *)); 545 546 static struct type * 547 lookup_utype PARAMS ((DIE_REF)); 548 549 static struct type * 550 alloc_utype PARAMS ((DIE_REF, struct type *)); 551 552 static struct symbol * 553 new_symbol PARAMS ((struct dieinfo *, struct objfile *)); 554 555 static void 556 synthesize_typedef PARAMS ((struct dieinfo *, struct objfile *, 557 struct type *)); 558 559 static int 560 locval PARAMS ((char *)); 561 562 static void 563 set_cu_language PARAMS ((struct dieinfo *)); 564 565 static struct type * 566 dwarf_fundamental_type PARAMS ((struct objfile *, int)); 567 568 569 /* 570 571 LOCAL FUNCTION 572 573 dwarf_fundamental_type -- lookup or create a fundamental type 574 575 SYNOPSIS 576 577 struct type * 578 dwarf_fundamental_type (struct objfile *objfile, int typeid) 579 580 DESCRIPTION 581 582 DWARF version 1 doesn't supply any fundamental type information, 583 so gdb has to construct such types. It has a fixed number of 584 fundamental types that it knows how to construct, which is the 585 union of all types that it knows how to construct for all languages 586 that it knows about. These are enumerated in gdbtypes.h. 587 588 As an example, assume we find a DIE that references a DWARF 589 fundamental type of FT_integer. We first look in the ftypes 590 array to see if we already have such a type, indexed by the 591 gdb internal value of FT_INTEGER. If so, we simply return a 592 pointer to that type. If not, then we ask an appropriate 593 language dependent routine to create a type FT_INTEGER, using 594 defaults reasonable for the current target machine, and install 595 that type in ftypes for future reference. 596 597 RETURNS 598 599 Pointer to a fundamental type. 600 601 */ 602 603 static struct type * 604 dwarf_fundamental_type (objfile, typeid) 605 struct objfile *objfile; 606 int typeid; 607 { 608 if (typeid < 0 || typeid >= FT_NUM_MEMBERS) 609 { 610 error ("internal error - invalid fundamental type id %d", typeid); 611 } 612 613 /* Look for this particular type in the fundamental type vector. If one is 614 not found, create and install one appropriate for the current language 615 and the current target machine. */ 616 617 if (ftypes[typeid] == NULL) 618 { 619 ftypes[typeid] = cu_language_defn -> la_fund_type(objfile, typeid); 620 } 621 622 return (ftypes[typeid]); 623 } 624 625 /* 626 627 LOCAL FUNCTION 628 629 set_cu_language -- set local copy of language for compilation unit 630 631 SYNOPSIS 632 633 void 634 set_cu_language (struct dieinfo *dip) 635 636 DESCRIPTION 637 638 Decode the language attribute for a compilation unit DIE and 639 remember what the language was. We use this at various times 640 when processing DIE's for a given compilation unit. 641 642 RETURNS 643 644 No return value. 645 646 */ 647 648 static void 649 set_cu_language (dip) 650 struct dieinfo *dip; 651 { 652 switch (dip -> at_language) 653 { 654 case LANG_C89: 655 case LANG_C: 656 cu_language = language_c; 657 break; 658 case LANG_C_PLUS_PLUS: 659 cu_language = language_cplus; 660 break; 661 case LANG_CHILL: 662 cu_language = language_chill; 663 break; 664 case LANG_MODULA2: 665 cu_language = language_m2; 666 break; 667 case LANG_ADA83: 668 case LANG_COBOL74: 669 case LANG_COBOL85: 670 case LANG_FORTRAN77: 671 case LANG_FORTRAN90: 672 case LANG_PASCAL83: 673 /* We don't know anything special about these yet. */ 674 cu_language = language_unknown; 675 break; 676 default: 677 /* If no at_language, try to deduce one from the filename */ 678 cu_language = deduce_language_from_filename (dip -> at_name); 679 break; 680 } 681 cu_language_defn = language_def (cu_language); 682 } 683 684 /* 685 686 GLOBAL FUNCTION 687 688 dwarf_build_psymtabs -- build partial symtabs from DWARF debug info 689 690 SYNOPSIS 691 692 void dwarf_build_psymtabs (struct objfile *objfile, 693 struct section_offsets *section_offsets, 694 int mainline, file_ptr dbfoff, unsigned int dbfsize, 695 file_ptr lnoffset, unsigned int lnsize) 696 697 DESCRIPTION 698 699 This function is called upon to build partial symtabs from files 700 containing DIE's (Dwarf Information Entries) and DWARF line numbers. 701 702 It is passed a bfd* containing the DIES 703 and line number information, the corresponding filename for that 704 file, a base address for relocating the symbols, a flag indicating 705 whether or not this debugging information is from a "main symbol 706 table" rather than a shared library or dynamically linked file, 707 and file offset/size pairs for the DIE information and line number 708 information. 709 710 RETURNS 711 712 No return value. 713 714 */ 715 716 void 717 dwarf_build_psymtabs (objfile, section_offsets, mainline, dbfoff, dbfsize, 718 lnoffset, lnsize) 719 struct objfile *objfile; 720 struct section_offsets *section_offsets; 721 int mainline; 722 file_ptr dbfoff; 723 unsigned int dbfsize; 724 file_ptr lnoffset; 725 unsigned int lnsize; 726 { 727 bfd *abfd = objfile->obfd; 728 struct cleanup *back_to; 729 730 current_objfile = objfile; 731 dbsize = dbfsize; 732 dbbase = xmalloc (dbsize); 733 dbroff = 0; 734 if ((bfd_seek (abfd, dbfoff, SEEK_SET) != 0) || 735 (bfd_read (dbbase, dbsize, 1, abfd) != dbsize)) 736 { 737 free (dbbase); 738 error ("can't read DWARF data from '%s'", bfd_get_filename (abfd)); 739 } 740 back_to = make_cleanup (free, dbbase); 741 742 /* If we are reinitializing, or if we have never loaded syms yet, init. 743 Since we have no idea how many DIES we are looking at, we just guess 744 some arbitrary value. */ 745 746 if (mainline || objfile -> global_psymbols.size == 0 || 747 objfile -> static_psymbols.size == 0) 748 { 749 init_psymbol_list (objfile, 1024); 750 } 751 752 /* Save the relocation factor where everybody can see it. */ 753 754 base_section_offsets = section_offsets; 755 baseaddr = ANOFFSET (section_offsets, 0); 756 757 /* Follow the compilation unit sibling chain, building a partial symbol 758 table entry for each one. Save enough information about each compilation 759 unit to locate the full DWARF information later. */ 760 761 scan_compilation_units (dbbase, dbbase + dbsize, dbfoff, lnoffset, objfile); 762 763 do_cleanups (back_to); 764 current_objfile = NULL; 765 } 766 767 /* 768 769 LOCAL FUNCTION 770 771 read_lexical_block_scope -- process all dies in a lexical block 772 773 SYNOPSIS 774 775 static void read_lexical_block_scope (struct dieinfo *dip, 776 char *thisdie, char *enddie) 777 778 DESCRIPTION 779 780 Process all the DIES contained within a lexical block scope. 781 Start a new scope, process the dies, and then close the scope. 782 783 */ 784 785 static void 786 read_lexical_block_scope (dip, thisdie, enddie, objfile) 787 struct dieinfo *dip; 788 char *thisdie; 789 char *enddie; 790 struct objfile *objfile; 791 { 792 register struct context_stack *new; 793 794 push_context (0, dip -> at_low_pc); 795 process_dies (thisdie + dip -> die_length, enddie, objfile); 796 new = pop_context (); 797 if (local_symbols != NULL) 798 { 799 finish_block (0, &local_symbols, new -> old_blocks, new -> start_addr, 800 dip -> at_high_pc, objfile); 801 } 802 local_symbols = new -> locals; 803 } 804 805 /* 806 807 LOCAL FUNCTION 808 809 lookup_utype -- look up a user defined type from die reference 810 811 SYNOPSIS 812 813 static type *lookup_utype (DIE_REF die_ref) 814 815 DESCRIPTION 816 817 Given a DIE reference, lookup the user defined type associated with 818 that DIE, if it has been registered already. If not registered, then 819 return NULL. Alloc_utype() can be called to register an empty 820 type for this reference, which will be filled in later when the 821 actual referenced DIE is processed. 822 */ 823 824 static struct type * 825 lookup_utype (die_ref) 826 DIE_REF die_ref; 827 { 828 struct type *type = NULL; 829 int utypeidx; 830 831 utypeidx = (die_ref - dbroff) / 4; 832 if ((utypeidx < 0) || (utypeidx >= numutypes)) 833 { 834 complain (&bad_die_ref, DIE_ID, DIE_NAME); 835 } 836 else 837 { 838 type = *(utypes + utypeidx); 839 } 840 return (type); 841 } 842 843 844 /* 845 846 LOCAL FUNCTION 847 848 alloc_utype -- add a user defined type for die reference 849 850 SYNOPSIS 851 852 static type *alloc_utype (DIE_REF die_ref, struct type *utypep) 853 854 DESCRIPTION 855 856 Given a die reference DIE_REF, and a possible pointer to a user 857 defined type UTYPEP, register that this reference has a user 858 defined type and either use the specified type in UTYPEP or 859 make a new empty type that will be filled in later. 860 861 We should only be called after calling lookup_utype() to verify that 862 there is not currently a type registered for DIE_REF. 863 */ 864 865 static struct type * 866 alloc_utype (die_ref, utypep) 867 DIE_REF die_ref; 868 struct type *utypep; 869 { 870 struct type **typep; 871 int utypeidx; 872 873 utypeidx = (die_ref - dbroff) / 4; 874 typep = utypes + utypeidx; 875 if ((utypeidx < 0) || (utypeidx >= numutypes)) 876 { 877 utypep = dwarf_fundamental_type (current_objfile, FT_INTEGER); 878 complain (&bad_die_ref, DIE_ID, DIE_NAME); 879 } 880 else if (*typep != NULL) 881 { 882 utypep = *typep; 883 complain (&dup_user_type_allocation, DIE_ID, DIE_NAME); 884 } 885 else 886 { 887 if (utypep == NULL) 888 { 889 utypep = alloc_type (current_objfile); 890 } 891 *typep = utypep; 892 } 893 return (utypep); 894 } 895 896 /* 897 898 LOCAL FUNCTION 899 900 free_utypes -- free the utypes array and reset pointer & count 901 902 SYNOPSIS 903 904 static void free_utypes (PTR dummy) 905 906 DESCRIPTION 907 908 Called via do_cleanups to free the utypes array, reset the pointer to NULL, 909 and set numutypes back to zero. This ensures that the utypes does not get 910 referenced after being freed. 911 */ 912 913 static void 914 free_utypes (dummy) 915 PTR dummy; 916 { 917 free (utypes); 918 utypes = NULL; 919 numutypes = 0; 920 } 921 922 923 /* 924 925 LOCAL FUNCTION 926 927 decode_die_type -- return a type for a specified die 928 929 SYNOPSIS 930 931 static struct type *decode_die_type (struct dieinfo *dip) 932 933 DESCRIPTION 934 935 Given a pointer to a die information structure DIP, decode the 936 type of the die and return a pointer to the decoded type. All 937 dies without specific types default to type int. 938 */ 939 940 static struct type * 941 decode_die_type (dip) 942 struct dieinfo *dip; 943 { 944 struct type *type = NULL; 945 946 if (dip -> at_fund_type != 0) 947 { 948 type = decode_fund_type (dip -> at_fund_type); 949 } 950 else if (dip -> at_mod_fund_type != NULL) 951 { 952 type = decode_mod_fund_type (dip -> at_mod_fund_type); 953 } 954 else if (dip -> at_user_def_type) 955 { 956 if ((type = lookup_utype (dip -> at_user_def_type)) == NULL) 957 { 958 type = alloc_utype (dip -> at_user_def_type, NULL); 959 } 960 } 961 else if (dip -> at_mod_u_d_type) 962 { 963 type = decode_mod_u_d_type (dip -> at_mod_u_d_type); 964 } 965 else 966 { 967 type = dwarf_fundamental_type (current_objfile, FT_VOID); 968 } 969 return (type); 970 } 971 972 /* 973 974 LOCAL FUNCTION 975 976 struct_type -- compute and return the type for a struct or union 977 978 SYNOPSIS 979 980 static struct type *struct_type (struct dieinfo *dip, char *thisdie, 981 char *enddie, struct objfile *objfile) 982 983 DESCRIPTION 984 985 Given pointer to a die information structure for a die which 986 defines a union or structure (and MUST define one or the other), 987 and pointers to the raw die data that define the range of dies which 988 define the members, compute and return the user defined type for the 989 structure or union. 990 */ 991 992 static struct type * 993 struct_type (dip, thisdie, enddie, objfile) 994 struct dieinfo *dip; 995 char *thisdie; 996 char *enddie; 997 struct objfile *objfile; 998 { 999 struct type *type; 1000 struct nextfield { 1001 struct nextfield *next; 1002 struct field field; 1003 }; 1004 struct nextfield *list = NULL; 1005 struct nextfield *new; 1006 int nfields = 0; 1007 int n; 1008 struct dieinfo mbr; 1009 char *nextdie; 1010 int anonymous_size; 1011 1012 if ((type = lookup_utype (dip -> die_ref)) == NULL) 1013 { 1014 /* No forward references created an empty type, so install one now */ 1015 type = alloc_utype (dip -> die_ref, NULL); 1016 } 1017 INIT_CPLUS_SPECIFIC(type); 1018 switch (dip -> die_tag) 1019 { 1020 case TAG_class_type: 1021 TYPE_CODE (type) = TYPE_CODE_CLASS; 1022 break; 1023 case TAG_structure_type: 1024 TYPE_CODE (type) = TYPE_CODE_STRUCT; 1025 break; 1026 case TAG_union_type: 1027 TYPE_CODE (type) = TYPE_CODE_UNION; 1028 break; 1029 default: 1030 /* Should never happen */ 1031 TYPE_CODE (type) = TYPE_CODE_UNDEF; 1032 complain (&missing_tag, DIE_ID, DIE_NAME); 1033 break; 1034 } 1035 /* Some compilers try to be helpful by inventing "fake" names for 1036 anonymous enums, structures, and unions, like "~0fake" or ".0fake". 1037 Thanks, but no thanks... */ 1038 if (dip -> at_name != NULL 1039 && *dip -> at_name != '~' 1040 && *dip -> at_name != '.') 1041 { 1042 TYPE_TAG_NAME (type) = obconcat (&objfile -> type_obstack, 1043 "", "", dip -> at_name); 1044 } 1045 /* Use whatever size is known. Zero is a valid size. We might however 1046 wish to check has_at_byte_size to make sure that some byte size was 1047 given explicitly, but DWARF doesn't specify that explicit sizes of 1048 zero have to present, so complaining about missing sizes should 1049 probably not be the default. */ 1050 TYPE_LENGTH (type) = dip -> at_byte_size; 1051 thisdie += dip -> die_length; 1052 while (thisdie < enddie) 1053 { 1054 basicdieinfo (&mbr, thisdie, objfile); 1055 completedieinfo (&mbr, objfile); 1056 if (mbr.die_length <= SIZEOF_DIE_LENGTH) 1057 { 1058 break; 1059 } 1060 else if (mbr.at_sibling != 0) 1061 { 1062 nextdie = dbbase + mbr.at_sibling - dbroff; 1063 } 1064 else 1065 { 1066 nextdie = thisdie + mbr.die_length; 1067 } 1068 switch (mbr.die_tag) 1069 { 1070 case TAG_member: 1071 /* Get space to record the next field's data. */ 1072 new = (struct nextfield *) alloca (sizeof (struct nextfield)); 1073 new -> next = list; 1074 list = new; 1075 /* Save the data. */ 1076 list -> field.name = 1077 obsavestring (mbr.at_name, strlen (mbr.at_name), 1078 &objfile -> type_obstack); 1079 list -> field.type = decode_die_type (&mbr); 1080 list -> field.bitpos = 8 * locval (mbr.at_location); 1081 /* Handle bit fields. */ 1082 list -> field.bitsize = mbr.at_bit_size; 1083 if (BITS_BIG_ENDIAN) 1084 { 1085 /* For big endian bits, the at_bit_offset gives the 1086 additional bit offset from the MSB of the containing 1087 anonymous object to the MSB of the field. We don't 1088 have to do anything special since we don't need to 1089 know the size of the anonymous object. */ 1090 list -> field.bitpos += mbr.at_bit_offset; 1091 } 1092 else 1093 { 1094 /* For little endian bits, we need to have a non-zero 1095 at_bit_size, so that we know we are in fact dealing 1096 with a bitfield. Compute the bit offset to the MSB 1097 of the anonymous object, subtract off the number of 1098 bits from the MSB of the field to the MSB of the 1099 object, and then subtract off the number of bits of 1100 the field itself. The result is the bit offset of 1101 the LSB of the field. */ 1102 if (mbr.at_bit_size > 0) 1103 { 1104 if (mbr.has_at_byte_size) 1105 { 1106 /* The size of the anonymous object containing 1107 the bit field is explicit, so use the 1108 indicated size (in bytes). */ 1109 anonymous_size = mbr.at_byte_size; 1110 } 1111 else 1112 { 1113 /* The size of the anonymous object containing 1114 the bit field matches the size of an object 1115 of the bit field's type. DWARF allows 1116 at_byte_size to be left out in such cases, as 1117 a debug information size optimization. */ 1118 anonymous_size = TYPE_LENGTH (list -> field.type); 1119 } 1120 list -> field.bitpos += 1121 anonymous_size * 8 - mbr.at_bit_offset - mbr.at_bit_size; 1122 } 1123 } 1124 nfields++; 1125 break; 1126 default: 1127 process_dies (thisdie, nextdie, objfile); 1128 break; 1129 } 1130 thisdie = nextdie; 1131 } 1132 /* Now create the vector of fields, and record how big it is. We may 1133 not even have any fields, if this DIE was generated due to a reference 1134 to an anonymous structure or union. In this case, TYPE_FLAG_STUB is 1135 set, which clues gdb in to the fact that it needs to search elsewhere 1136 for the full structure definition. */ 1137 if (nfields == 0) 1138 { 1139 TYPE_FLAGS (type) |= TYPE_FLAG_STUB; 1140 } 1141 else 1142 { 1143 TYPE_NFIELDS (type) = nfields; 1144 TYPE_FIELDS (type) = (struct field *) 1145 TYPE_ALLOC (type, sizeof (struct field) * nfields); 1146 /* Copy the saved-up fields into the field vector. */ 1147 for (n = nfields; list; list = list -> next) 1148 { 1149 TYPE_FIELD (type, --n) = list -> field; 1150 } 1151 } 1152 return (type); 1153 } 1154 1155 /* 1156 1157 LOCAL FUNCTION 1158 1159 read_structure_scope -- process all dies within struct or union 1160 1161 SYNOPSIS 1162 1163 static void read_structure_scope (struct dieinfo *dip, 1164 char *thisdie, char *enddie, struct objfile *objfile) 1165 1166 DESCRIPTION 1167 1168 Called when we find the DIE that starts a structure or union 1169 scope (definition) to process all dies that define the members 1170 of the structure or union. DIP is a pointer to the die info 1171 struct for the DIE that names the structure or union. 1172 1173 NOTES 1174 1175 Note that we need to call struct_type regardless of whether or not 1176 the DIE has an at_name attribute, since it might be an anonymous 1177 structure or union. This gets the type entered into our set of 1178 user defined types. 1179 1180 However, if the structure is incomplete (an opaque struct/union) 1181 then suppress creating a symbol table entry for it since gdb only 1182 wants to find the one with the complete definition. Note that if 1183 it is complete, we just call new_symbol, which does it's own 1184 checking about whether the struct/union is anonymous or not (and 1185 suppresses creating a symbol table entry itself). 1186 1187 */ 1188 1189 static void 1190 read_structure_scope (dip, thisdie, enddie, objfile) 1191 struct dieinfo *dip; 1192 char *thisdie; 1193 char *enddie; 1194 struct objfile *objfile; 1195 { 1196 struct type *type; 1197 struct symbol *sym; 1198 1199 type = struct_type (dip, thisdie, enddie, objfile); 1200 if (!(TYPE_FLAGS (type) & TYPE_FLAG_STUB)) 1201 { 1202 sym = new_symbol (dip, objfile); 1203 if (sym != NULL) 1204 { 1205 SYMBOL_TYPE (sym) = type; 1206 if (cu_language == language_cplus) 1207 { 1208 synthesize_typedef (dip, objfile, type); 1209 } 1210 } 1211 } 1212 } 1213 1214 /* 1215 1216 LOCAL FUNCTION 1217 1218 decode_array_element_type -- decode type of the array elements 1219 1220 SYNOPSIS 1221 1222 static struct type *decode_array_element_type (char *scan, char *end) 1223 1224 DESCRIPTION 1225 1226 As the last step in decoding the array subscript information for an 1227 array DIE, we need to decode the type of the array elements. We are 1228 passed a pointer to this last part of the subscript information and 1229 must return the appropriate type. If the type attribute is not 1230 recognized, just warn about the problem and return type int. 1231 */ 1232 1233 static struct type * 1234 decode_array_element_type (scan) 1235 char *scan; 1236 { 1237 struct type *typep; 1238 DIE_REF die_ref; 1239 unsigned short attribute; 1240 unsigned short fundtype; 1241 int nbytes; 1242 1243 attribute = target_to_host (scan, SIZEOF_ATTRIBUTE, GET_UNSIGNED, 1244 current_objfile); 1245 scan += SIZEOF_ATTRIBUTE; 1246 if ((nbytes = attribute_size (attribute)) == -1) 1247 { 1248 complain (&bad_array_element_type, DIE_ID, DIE_NAME, attribute); 1249 typep = dwarf_fundamental_type (current_objfile, FT_INTEGER); 1250 } 1251 else 1252 { 1253 switch (attribute) 1254 { 1255 case AT_fund_type: 1256 fundtype = target_to_host (scan, nbytes, GET_UNSIGNED, 1257 current_objfile); 1258 typep = decode_fund_type (fundtype); 1259 break; 1260 case AT_mod_fund_type: 1261 typep = decode_mod_fund_type (scan); 1262 break; 1263 case AT_user_def_type: 1264 die_ref = target_to_host (scan, nbytes, GET_UNSIGNED, 1265 current_objfile); 1266 if ((typep = lookup_utype (die_ref)) == NULL) 1267 { 1268 typep = alloc_utype (die_ref, NULL); 1269 } 1270 break; 1271 case AT_mod_u_d_type: 1272 typep = decode_mod_u_d_type (scan); 1273 break; 1274 default: 1275 complain (&bad_array_element_type, DIE_ID, DIE_NAME, attribute); 1276 typep = dwarf_fundamental_type (current_objfile, FT_INTEGER); 1277 break; 1278 } 1279 } 1280 return (typep); 1281 } 1282 1283 /* 1284 1285 LOCAL FUNCTION 1286 1287 decode_subscript_data_item -- decode array subscript item 1288 1289 SYNOPSIS 1290 1291 static struct type * 1292 decode_subscript_data_item (char *scan, char *end) 1293 1294 DESCRIPTION 1295 1296 The array subscripts and the data type of the elements of an 1297 array are described by a list of data items, stored as a block 1298 of contiguous bytes. There is a data item describing each array 1299 dimension, and a final data item describing the element type. 1300 The data items are ordered the same as their appearance in the 1301 source (I.E. leftmost dimension first, next to leftmost second, 1302 etc). 1303 1304 The data items describing each array dimension consist of four 1305 parts: (1) a format specifier, (2) type type of the subscript 1306 index, (3) a description of the low bound of the array dimension, 1307 and (4) a description of the high bound of the array dimension. 1308 1309 The last data item is the description of the type of each of 1310 the array elements. 1311 1312 We are passed a pointer to the start of the block of bytes 1313 containing the remaining data items, and a pointer to the first 1314 byte past the data. This function recursively decodes the 1315 remaining data items and returns a type. 1316 1317 If we somehow fail to decode some data, we complain about it 1318 and return a type "array of int". 1319 1320 BUGS 1321 FIXME: This code only implements the forms currently used 1322 by the AT&T and GNU C compilers. 1323 1324 The end pointer is supplied for error checking, maybe we should 1325 use it for that... 1326 */ 1327 1328 static struct type * 1329 decode_subscript_data_item (scan, end) 1330 char *scan; 1331 char *end; 1332 { 1333 struct type *typep = NULL; /* Array type we are building */ 1334 struct type *nexttype; /* Type of each element (may be array) */ 1335 struct type *indextype; /* Type of this index */ 1336 struct type *rangetype; 1337 unsigned int format; 1338 unsigned short fundtype; 1339 unsigned long lowbound; 1340 unsigned long highbound; 1341 int nbytes; 1342 1343 format = target_to_host (scan, SIZEOF_FORMAT_SPECIFIER, GET_UNSIGNED, 1344 current_objfile); 1345 scan += SIZEOF_FORMAT_SPECIFIER; 1346 switch (format) 1347 { 1348 case FMT_ET: 1349 typep = decode_array_element_type (scan); 1350 break; 1351 case FMT_FT_C_C: 1352 fundtype = target_to_host (scan, SIZEOF_FMT_FT, GET_UNSIGNED, 1353 current_objfile); 1354 indextype = decode_fund_type (fundtype); 1355 scan += SIZEOF_FMT_FT; 1356 nbytes = TARGET_FT_LONG_SIZE (current_objfile); 1357 lowbound = target_to_host (scan, nbytes, GET_UNSIGNED, current_objfile); 1358 scan += nbytes; 1359 highbound = target_to_host (scan, nbytes, GET_UNSIGNED, current_objfile); 1360 scan += nbytes; 1361 nexttype = decode_subscript_data_item (scan, end); 1362 if (nexttype == NULL) 1363 { 1364 /* Munged subscript data or other problem, fake it. */ 1365 complain (&subscript_data_items, DIE_ID, DIE_NAME); 1366 nexttype = dwarf_fundamental_type (current_objfile, FT_INTEGER); 1367 } 1368 rangetype = create_range_type ((struct type *) NULL, indextype, 1369 lowbound, highbound); 1370 typep = create_array_type ((struct type *) NULL, nexttype, rangetype); 1371 break; 1372 case FMT_FT_C_X: 1373 case FMT_FT_X_C: 1374 case FMT_FT_X_X: 1375 case FMT_UT_C_C: 1376 case FMT_UT_C_X: 1377 case FMT_UT_X_C: 1378 case FMT_UT_X_X: 1379 complain (&unhandled_array_subscript_format, DIE_ID, DIE_NAME, format); 1380 nexttype = dwarf_fundamental_type (current_objfile, FT_INTEGER); 1381 rangetype = create_range_type ((struct type *) NULL, nexttype, 0, 0); 1382 typep = create_array_type ((struct type *) NULL, nexttype, rangetype); 1383 break; 1384 default: 1385 complain (&unknown_array_subscript_format, DIE_ID, DIE_NAME, format); 1386 nexttype = dwarf_fundamental_type (current_objfile, FT_INTEGER); 1387 rangetype = create_range_type ((struct type *) NULL, nexttype, 0, 0); 1388 typep = create_array_type ((struct type *) NULL, nexttype, rangetype); 1389 break; 1390 } 1391 return (typep); 1392 } 1393 1394 /* 1395 1396 LOCAL FUNCTION 1397 1398 dwarf_read_array_type -- read TAG_array_type DIE 1399 1400 SYNOPSIS 1401 1402 static void dwarf_read_array_type (struct dieinfo *dip) 1403 1404 DESCRIPTION 1405 1406 Extract all information from a TAG_array_type DIE and add to 1407 the user defined type vector. 1408 */ 1409 1410 static void 1411 dwarf_read_array_type (dip) 1412 struct dieinfo *dip; 1413 { 1414 struct type *type; 1415 struct type *utype; 1416 char *sub; 1417 char *subend; 1418 unsigned short blocksz; 1419 int nbytes; 1420 1421 if (dip -> at_ordering != ORD_row_major) 1422 { 1423 /* FIXME: Can gdb even handle column major arrays? */ 1424 complain (¬_row_major, DIE_ID, DIE_NAME); 1425 } 1426 if ((sub = dip -> at_subscr_data) != NULL) 1427 { 1428 nbytes = attribute_size (AT_subscr_data); 1429 blocksz = target_to_host (sub, nbytes, GET_UNSIGNED, current_objfile); 1430 subend = sub + nbytes + blocksz; 1431 sub += nbytes; 1432 type = decode_subscript_data_item (sub, subend); 1433 if ((utype = lookup_utype (dip -> die_ref)) == NULL) 1434 { 1435 /* Install user defined type that has not been referenced yet. */ 1436 alloc_utype (dip -> die_ref, type); 1437 } 1438 else if (TYPE_CODE (utype) == TYPE_CODE_UNDEF) 1439 { 1440 /* Ick! A forward ref has already generated a blank type in our 1441 slot, and this type probably already has things pointing to it 1442 (which is what caused it to be created in the first place). 1443 If it's just a place holder we can plop our fully defined type 1444 on top of it. We can't recover the space allocated for our 1445 new type since it might be on an obstack, but we could reuse 1446 it if we kept a list of them, but it might not be worth it 1447 (FIXME). */ 1448 *utype = *type; 1449 } 1450 else 1451 { 1452 /* Double ick! Not only is a type already in our slot, but 1453 someone has decorated it. Complain and leave it alone. */ 1454 complain (&dup_user_type_definition, DIE_ID, DIE_NAME); 1455 } 1456 } 1457 } 1458 1459 /* 1460 1461 LOCAL FUNCTION 1462 1463 read_tag_pointer_type -- read TAG_pointer_type DIE 1464 1465 SYNOPSIS 1466 1467 static void read_tag_pointer_type (struct dieinfo *dip) 1468 1469 DESCRIPTION 1470 1471 Extract all information from a TAG_pointer_type DIE and add to 1472 the user defined type vector. 1473 */ 1474 1475 static void 1476 read_tag_pointer_type (dip) 1477 struct dieinfo *dip; 1478 { 1479 struct type *type; 1480 struct type *utype; 1481 1482 type = decode_die_type (dip); 1483 if ((utype = lookup_utype (dip -> die_ref)) == NULL) 1484 { 1485 utype = lookup_pointer_type (type); 1486 alloc_utype (dip -> die_ref, utype); 1487 } 1488 else 1489 { 1490 TYPE_TARGET_TYPE (utype) = type; 1491 TYPE_POINTER_TYPE (type) = utype; 1492 1493 /* We assume the machine has only one representation for pointers! */ 1494 /* FIXME: This confuses host<->target data representations, and is a 1495 poor assumption besides. */ 1496 1497 TYPE_LENGTH (utype) = sizeof (char *); 1498 TYPE_CODE (utype) = TYPE_CODE_PTR; 1499 } 1500 } 1501 1502 /* 1503 1504 LOCAL FUNCTION 1505 1506 read_tag_string_type -- read TAG_string_type DIE 1507 1508 SYNOPSIS 1509 1510 static void read_tag_string_type (struct dieinfo *dip) 1511 1512 DESCRIPTION 1513 1514 Extract all information from a TAG_string_type DIE and add to 1515 the user defined type vector. It isn't really a user defined 1516 type, but it behaves like one, with other DIE's using an 1517 AT_user_def_type attribute to reference it. 1518 */ 1519 1520 static void 1521 read_tag_string_type (dip) 1522 struct dieinfo *dip; 1523 { 1524 struct type *utype; 1525 struct type *indextype; 1526 struct type *rangetype; 1527 unsigned long lowbound = 0; 1528 unsigned long highbound; 1529 1530 if (dip -> has_at_byte_size) 1531 { 1532 /* A fixed bounds string */ 1533 highbound = dip -> at_byte_size - 1; 1534 } 1535 else 1536 { 1537 /* A varying length string. Stub for now. (FIXME) */ 1538 highbound = 1; 1539 } 1540 indextype = dwarf_fundamental_type (current_objfile, FT_INTEGER); 1541 rangetype = create_range_type ((struct type *) NULL, indextype, lowbound, 1542 highbound); 1543 1544 utype = lookup_utype (dip -> die_ref); 1545 if (utype == NULL) 1546 { 1547 /* No type defined, go ahead and create a blank one to use. */ 1548 utype = alloc_utype (dip -> die_ref, (struct type *) NULL); 1549 } 1550 else 1551 { 1552 /* Already a type in our slot due to a forward reference. Make sure it 1553 is a blank one. If not, complain and leave it alone. */ 1554 if (TYPE_CODE (utype) != TYPE_CODE_UNDEF) 1555 { 1556 complain (&dup_user_type_definition, DIE_ID, DIE_NAME); 1557 return; 1558 } 1559 } 1560 1561 /* Create the string type using the blank type we either found or created. */ 1562 utype = create_string_type (utype, rangetype); 1563 } 1564 1565 /* 1566 1567 LOCAL FUNCTION 1568 1569 read_subroutine_type -- process TAG_subroutine_type dies 1570 1571 SYNOPSIS 1572 1573 static void read_subroutine_type (struct dieinfo *dip, char thisdie, 1574 char *enddie) 1575 1576 DESCRIPTION 1577 1578 Handle DIES due to C code like: 1579 1580 struct foo { 1581 int (*funcp)(int a, long l); (Generates TAG_subroutine_type DIE) 1582 int b; 1583 }; 1584 1585 NOTES 1586 1587 The parameter DIES are currently ignored. See if gdb has a way to 1588 include this info in it's type system, and decode them if so. Is 1589 this what the type structure's "arg_types" field is for? (FIXME) 1590 */ 1591 1592 static void 1593 read_subroutine_type (dip, thisdie, enddie) 1594 struct dieinfo *dip; 1595 char *thisdie; 1596 char *enddie; 1597 { 1598 struct type *type; /* Type that this function returns */ 1599 struct type *ftype; /* Function that returns above type */ 1600 1601 /* Decode the type that this subroutine returns */ 1602 1603 type = decode_die_type (dip); 1604 1605 /* Check to see if we already have a partially constructed user 1606 defined type for this DIE, from a forward reference. */ 1607 1608 if ((ftype = lookup_utype (dip -> die_ref)) == NULL) 1609 { 1610 /* This is the first reference to one of these types. Make 1611 a new one and place it in the user defined types. */ 1612 ftype = lookup_function_type (type); 1613 alloc_utype (dip -> die_ref, ftype); 1614 } 1615 else if (TYPE_CODE (ftype) == TYPE_CODE_UNDEF) 1616 { 1617 /* We have an existing partially constructed type, so bash it 1618 into the correct type. */ 1619 TYPE_TARGET_TYPE (ftype) = type; 1620 TYPE_LENGTH (ftype) = 1; 1621 TYPE_CODE (ftype) = TYPE_CODE_FUNC; 1622 } 1623 else 1624 { 1625 complain (&dup_user_type_definition, DIE_ID, DIE_NAME); 1626 } 1627 } 1628 1629 /* 1630 1631 LOCAL FUNCTION 1632 1633 read_enumeration -- process dies which define an enumeration 1634 1635 SYNOPSIS 1636 1637 static void read_enumeration (struct dieinfo *dip, char *thisdie, 1638 char *enddie, struct objfile *objfile) 1639 1640 DESCRIPTION 1641 1642 Given a pointer to a die which begins an enumeration, process all 1643 the dies that define the members of the enumeration. 1644 1645 NOTES 1646 1647 Note that we need to call enum_type regardless of whether or not we 1648 have a symbol, since we might have an enum without a tag name (thus 1649 no symbol for the tagname). 1650 */ 1651 1652 static void 1653 read_enumeration (dip, thisdie, enddie, objfile) 1654 struct dieinfo *dip; 1655 char *thisdie; 1656 char *enddie; 1657 struct objfile *objfile; 1658 { 1659 struct type *type; 1660 struct symbol *sym; 1661 1662 type = enum_type (dip, objfile); 1663 sym = new_symbol (dip, objfile); 1664 if (sym != NULL) 1665 { 1666 SYMBOL_TYPE (sym) = type; 1667 if (cu_language == language_cplus) 1668 { 1669 synthesize_typedef (dip, objfile, type); 1670 } 1671 } 1672 } 1673 1674 /* 1675 1676 LOCAL FUNCTION 1677 1678 enum_type -- decode and return a type for an enumeration 1679 1680 SYNOPSIS 1681 1682 static type *enum_type (struct dieinfo *dip, struct objfile *objfile) 1683 1684 DESCRIPTION 1685 1686 Given a pointer to a die information structure for the die which 1687 starts an enumeration, process all the dies that define the members 1688 of the enumeration and return a type pointer for the enumeration. 1689 1690 At the same time, for each member of the enumeration, create a 1691 symbol for it with namespace VAR_NAMESPACE and class LOC_CONST, 1692 and give it the type of the enumeration itself. 1693 1694 NOTES 1695 1696 Note that the DWARF specification explicitly mandates that enum 1697 constants occur in reverse order from the source program order, 1698 for "consistency" and because this ordering is easier for many 1699 compilers to generate. (Draft 6, sec 3.8.5, Enumeration type 1700 Entries). Because gdb wants to see the enum members in program 1701 source order, we have to ensure that the order gets reversed while 1702 we are processing them. 1703 */ 1704 1705 static struct type * 1706 enum_type (dip, objfile) 1707 struct dieinfo *dip; 1708 struct objfile *objfile; 1709 { 1710 struct type *type; 1711 struct nextfield { 1712 struct nextfield *next; 1713 struct field field; 1714 }; 1715 struct nextfield *list = NULL; 1716 struct nextfield *new; 1717 int nfields = 0; 1718 int n; 1719 char *scan; 1720 char *listend; 1721 unsigned short blocksz; 1722 struct symbol *sym; 1723 int nbytes; 1724 int unsigned_enum = 1; 1725 1726 if ((type = lookup_utype (dip -> die_ref)) == NULL) 1727 { 1728 /* No forward references created an empty type, so install one now */ 1729 type = alloc_utype (dip -> die_ref, NULL); 1730 } 1731 TYPE_CODE (type) = TYPE_CODE_ENUM; 1732 /* Some compilers try to be helpful by inventing "fake" names for 1733 anonymous enums, structures, and unions, like "~0fake" or ".0fake". 1734 Thanks, but no thanks... */ 1735 if (dip -> at_name != NULL 1736 && *dip -> at_name != '~' 1737 && *dip -> at_name != '.') 1738 { 1739 TYPE_TAG_NAME (type) = obconcat (&objfile -> type_obstack, 1740 "", "", dip -> at_name); 1741 } 1742 if (dip -> at_byte_size != 0) 1743 { 1744 TYPE_LENGTH (type) = dip -> at_byte_size; 1745 } 1746 if ((scan = dip -> at_element_list) != NULL) 1747 { 1748 if (dip -> short_element_list) 1749 { 1750 nbytes = attribute_size (AT_short_element_list); 1751 } 1752 else 1753 { 1754 nbytes = attribute_size (AT_element_list); 1755 } 1756 blocksz = target_to_host (scan, nbytes, GET_UNSIGNED, objfile); 1757 listend = scan + nbytes + blocksz; 1758 scan += nbytes; 1759 while (scan < listend) 1760 { 1761 new = (struct nextfield *) alloca (sizeof (struct nextfield)); 1762 new -> next = list; 1763 list = new; 1764 list -> field.type = NULL; 1765 list -> field.bitsize = 0; 1766 list -> field.bitpos = 1767 target_to_host (scan, TARGET_FT_LONG_SIZE (objfile), GET_SIGNED, 1768 objfile); 1769 scan += TARGET_FT_LONG_SIZE (objfile); 1770 list -> field.name = obsavestring (scan, strlen (scan), 1771 &objfile -> type_obstack); 1772 scan += strlen (scan) + 1; 1773 nfields++; 1774 /* Handcraft a new symbol for this enum member. */ 1775 sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack, 1776 sizeof (struct symbol)); 1777 memset (sym, 0, sizeof (struct symbol)); 1778 SYMBOL_NAME (sym) = create_name (list -> field.name, 1779 &objfile->symbol_obstack); 1780 SYMBOL_INIT_LANGUAGE_SPECIFIC (sym, cu_language); 1781 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE; 1782 SYMBOL_CLASS (sym) = LOC_CONST; 1783 SYMBOL_TYPE (sym) = type; 1784 SYMBOL_VALUE (sym) = list -> field.bitpos; 1785 if (SYMBOL_VALUE (sym) < 0) 1786 unsigned_enum = 0; 1787 add_symbol_to_list (sym, list_in_scope); 1788 } 1789 /* Now create the vector of fields, and record how big it is. This is 1790 where we reverse the order, by pulling the members off the list in 1791 reverse order from how they were inserted. If we have no fields 1792 (this is apparently possible in C++) then skip building a field 1793 vector. */ 1794 if (nfields > 0) 1795 { 1796 if (unsigned_enum) 1797 TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED; 1798 TYPE_NFIELDS (type) = nfields; 1799 TYPE_FIELDS (type) = (struct field *) 1800 obstack_alloc (&objfile->symbol_obstack, sizeof (struct field) * nfields); 1801 /* Copy the saved-up fields into the field vector. */ 1802 for (n = 0; (n < nfields) && (list != NULL); list = list -> next) 1803 { 1804 TYPE_FIELD (type, n++) = list -> field; 1805 } 1806 } 1807 } 1808 return (type); 1809 } 1810 1811 /* 1812 1813 LOCAL FUNCTION 1814 1815 read_func_scope -- process all dies within a function scope 1816 1817 DESCRIPTION 1818 1819 Process all dies within a given function scope. We are passed 1820 a die information structure pointer DIP for the die which 1821 starts the function scope, and pointers into the raw die data 1822 that define the dies within the function scope. 1823 1824 For now, we ignore lexical block scopes within the function. 1825 The problem is that AT&T cc does not define a DWARF lexical 1826 block scope for the function itself, while gcc defines a 1827 lexical block scope for the function. We need to think about 1828 how to handle this difference, or if it is even a problem. 1829 (FIXME) 1830 */ 1831 1832 static void 1833 read_func_scope (dip, thisdie, enddie, objfile) 1834 struct dieinfo *dip; 1835 char *thisdie; 1836 char *enddie; 1837 struct objfile *objfile; 1838 { 1839 register struct context_stack *new; 1840 1841 /* AT_name is absent if the function is described with an 1842 AT_abstract_origin tag. 1843 Ignore the function description for now to avoid GDB core dumps. 1844 FIXME: Add code to handle AT_abstract_origin tags properly. */ 1845 if (dip -> at_name == NULL) 1846 { 1847 complain (&missing_at_name, DIE_ID); 1848 return; 1849 } 1850 1851 if (objfile -> ei.entry_point >= dip -> at_low_pc && 1852 objfile -> ei.entry_point < dip -> at_high_pc) 1853 { 1854 objfile -> ei.entry_func_lowpc = dip -> at_low_pc; 1855 objfile -> ei.entry_func_highpc = dip -> at_high_pc; 1856 } 1857 if (STREQ (dip -> at_name, "main")) /* FIXME: hardwired name */ 1858 { 1859 objfile -> ei.main_func_lowpc = dip -> at_low_pc; 1860 objfile -> ei.main_func_highpc = dip -> at_high_pc; 1861 } 1862 new = push_context (0, dip -> at_low_pc); 1863 new -> name = new_symbol (dip, objfile); 1864 list_in_scope = &local_symbols; 1865 process_dies (thisdie + dip -> die_length, enddie, objfile); 1866 new = pop_context (); 1867 /* Make a block for the local symbols within. */ 1868 finish_block (new -> name, &local_symbols, new -> old_blocks, 1869 new -> start_addr, dip -> at_high_pc, objfile); 1870 list_in_scope = &file_symbols; 1871 } 1872 1873 1874 /* 1875 1876 LOCAL FUNCTION 1877 1878 handle_producer -- process the AT_producer attribute 1879 1880 DESCRIPTION 1881 1882 Perform any operations that depend on finding a particular 1883 AT_producer attribute. 1884 1885 */ 1886 1887 static void 1888 handle_producer (producer) 1889 char *producer; 1890 { 1891 1892 /* If this compilation unit was compiled with g++ or gcc, then set the 1893 processing_gcc_compilation flag. */ 1894 1895 processing_gcc_compilation = 1896 STREQN (producer, GPLUS_PRODUCER, strlen (GPLUS_PRODUCER)) 1897 || STREQN (producer, CHILL_PRODUCER, strlen (CHILL_PRODUCER)) 1898 || STREQN (producer, GCC_PRODUCER, strlen (GCC_PRODUCER)); 1899 1900 /* Select a demangling style if we can identify the producer and if 1901 the current style is auto. We leave the current style alone if it 1902 is not auto. We also leave the demangling style alone if we find a 1903 gcc (cc1) producer, as opposed to a g++ (cc1plus) producer. */ 1904 1905 if (AUTO_DEMANGLING) 1906 { 1907 if (STREQN (producer, GPLUS_PRODUCER, strlen (GPLUS_PRODUCER))) 1908 { 1909 set_demangling_style (GNU_DEMANGLING_STYLE_STRING); 1910 } 1911 else if (STREQN (producer, LCC_PRODUCER, strlen (LCC_PRODUCER))) 1912 { 1913 set_demangling_style (LUCID_DEMANGLING_STYLE_STRING); 1914 } 1915 } 1916 } 1917 1918 1919 /* 1920 1921 LOCAL FUNCTION 1922 1923 read_file_scope -- process all dies within a file scope 1924 1925 DESCRIPTION 1926 1927 Process all dies within a given file scope. We are passed a 1928 pointer to the die information structure for the die which 1929 starts the file scope, and pointers into the raw die data which 1930 mark the range of dies within the file scope. 1931 1932 When the partial symbol table is built, the file offset for the line 1933 number table for each compilation unit is saved in the partial symbol 1934 table entry for that compilation unit. As the symbols for each 1935 compilation unit are read, the line number table is read into memory 1936 and the variable lnbase is set to point to it. Thus all we have to 1937 do is use lnbase to access the line number table for the current 1938 compilation unit. 1939 */ 1940 1941 static void 1942 read_file_scope (dip, thisdie, enddie, objfile) 1943 struct dieinfo *dip; 1944 char *thisdie; 1945 char *enddie; 1946 struct objfile *objfile; 1947 { 1948 struct cleanup *back_to; 1949 struct symtab *symtab; 1950 1951 if (objfile -> ei.entry_point >= dip -> at_low_pc && 1952 objfile -> ei.entry_point < dip -> at_high_pc) 1953 { 1954 objfile -> ei.entry_file_lowpc = dip -> at_low_pc; 1955 objfile -> ei.entry_file_highpc = dip -> at_high_pc; 1956 } 1957 set_cu_language (dip); 1958 if (dip -> at_producer != NULL) 1959 { 1960 handle_producer (dip -> at_producer); 1961 } 1962 numutypes = (enddie - thisdie) / 4; 1963 utypes = (struct type **) xmalloc (numutypes * sizeof (struct type *)); 1964 back_to = make_cleanup (free_utypes, NULL); 1965 memset (utypes, 0, numutypes * sizeof (struct type *)); 1966 memset (ftypes, 0, FT_NUM_MEMBERS * sizeof (struct type *)); 1967 start_symtab (dip -> at_name, dip -> at_comp_dir, dip -> at_low_pc); 1968 decode_line_numbers (lnbase); 1969 process_dies (thisdie + dip -> die_length, enddie, objfile); 1970 1971 symtab = end_symtab (dip -> at_high_pc, objfile, 0); 1972 if (symtab != NULL) 1973 { 1974 symtab -> language = cu_language; 1975 } 1976 do_cleanups (back_to); 1977 } 1978 1979 /* 1980 1981 LOCAL FUNCTION 1982 1983 process_dies -- process a range of DWARF Information Entries 1984 1985 SYNOPSIS 1986 1987 static void process_dies (char *thisdie, char *enddie, 1988 struct objfile *objfile) 1989 1990 DESCRIPTION 1991 1992 Process all DIE's in a specified range. May be (and almost 1993 certainly will be) called recursively. 1994 */ 1995 1996 static void 1997 process_dies (thisdie, enddie, objfile) 1998 char *thisdie; 1999 char *enddie; 2000 struct objfile *objfile; 2001 { 2002 char *nextdie; 2003 struct dieinfo di; 2004 2005 while (thisdie < enddie) 2006 { 2007 basicdieinfo (&di, thisdie, objfile); 2008 if (di.die_length < SIZEOF_DIE_LENGTH) 2009 { 2010 break; 2011 } 2012 else if (di.die_tag == TAG_padding) 2013 { 2014 nextdie = thisdie + di.die_length; 2015 } 2016 else 2017 { 2018 completedieinfo (&di, objfile); 2019 if (di.at_sibling != 0) 2020 { 2021 nextdie = dbbase + di.at_sibling - dbroff; 2022 } 2023 else 2024 { 2025 nextdie = thisdie + di.die_length; 2026 } 2027 #ifdef SMASH_TEXT_ADDRESS 2028 /* I think that these are always text, not data, addresses. */ 2029 SMASH_TEXT_ADDRESS (di.at_low_pc); 2030 SMASH_TEXT_ADDRESS (di.at_high_pc); 2031 #endif 2032 switch (di.die_tag) 2033 { 2034 case TAG_compile_unit: 2035 /* Skip Tag_compile_unit if we are already inside a compilation 2036 unit, we are unable to handle nested compilation units 2037 properly (FIXME). */ 2038 if (current_subfile == NULL) 2039 read_file_scope (&di, thisdie, nextdie, objfile); 2040 else 2041 nextdie = thisdie + di.die_length; 2042 break; 2043 case TAG_global_subroutine: 2044 case TAG_subroutine: 2045 if (di.has_at_low_pc) 2046 { 2047 read_func_scope (&di, thisdie, nextdie, objfile); 2048 } 2049 break; 2050 case TAG_lexical_block: 2051 read_lexical_block_scope (&di, thisdie, nextdie, objfile); 2052 break; 2053 case TAG_class_type: 2054 case TAG_structure_type: 2055 case TAG_union_type: 2056 read_structure_scope (&di, thisdie, nextdie, objfile); 2057 break; 2058 case TAG_enumeration_type: 2059 read_enumeration (&di, thisdie, nextdie, objfile); 2060 break; 2061 case TAG_subroutine_type: 2062 read_subroutine_type (&di, thisdie, nextdie); 2063 break; 2064 case TAG_array_type: 2065 dwarf_read_array_type (&di); 2066 break; 2067 case TAG_pointer_type: 2068 read_tag_pointer_type (&di); 2069 break; 2070 case TAG_string_type: 2071 read_tag_string_type (&di); 2072 break; 2073 default: 2074 new_symbol (&di, objfile); 2075 break; 2076 } 2077 } 2078 thisdie = nextdie; 2079 } 2080 } 2081 2082 /* 2083 2084 LOCAL FUNCTION 2085 2086 decode_line_numbers -- decode a line number table fragment 2087 2088 SYNOPSIS 2089 2090 static void decode_line_numbers (char *tblscan, char *tblend, 2091 long length, long base, long line, long pc) 2092 2093 DESCRIPTION 2094 2095 Translate the DWARF line number information to gdb form. 2096 2097 The ".line" section contains one or more line number tables, one for 2098 each ".line" section from the objects that were linked. 2099 2100 The AT_stmt_list attribute for each TAG_source_file entry in the 2101 ".debug" section contains the offset into the ".line" section for the 2102 start of the table for that file. 2103 2104 The table itself has the following structure: 2105 2106 <table length><base address><source statement entry> 2107 4 bytes 4 bytes 10 bytes 2108 2109 The table length is the total size of the table, including the 4 bytes 2110 for the length information. 2111 2112 The base address is the address of the first instruction generated 2113 for the source file. 2114 2115 Each source statement entry has the following structure: 2116 2117 <line number><statement position><address delta> 2118 4 bytes 2 bytes 4 bytes 2119 2120 The line number is relative to the start of the file, starting with 2121 line 1. 2122 2123 The statement position either -1 (0xFFFF) or the number of characters 2124 from the beginning of the line to the beginning of the statement. 2125 2126 The address delta is the difference between the base address and 2127 the address of the first instruction for the statement. 2128 2129 Note that we must copy the bytes from the packed table to our local 2130 variables before attempting to use them, to avoid alignment problems 2131 on some machines, particularly RISC processors. 2132 2133 BUGS 2134 2135 Does gdb expect the line numbers to be sorted? They are now by 2136 chance/luck, but are not required to be. (FIXME) 2137 2138 The line with number 0 is unused, gdb apparently can discover the 2139 span of the last line some other way. How? (FIXME) 2140 */ 2141 2142 static void 2143 decode_line_numbers (linetable) 2144 char *linetable; 2145 { 2146 char *tblscan; 2147 char *tblend; 2148 unsigned long length; 2149 unsigned long base; 2150 unsigned long line; 2151 unsigned long pc; 2152 2153 if (linetable != NULL) 2154 { 2155 tblscan = tblend = linetable; 2156 length = target_to_host (tblscan, SIZEOF_LINETBL_LENGTH, GET_UNSIGNED, 2157 current_objfile); 2158 tblscan += SIZEOF_LINETBL_LENGTH; 2159 tblend += length; 2160 base = target_to_host (tblscan, TARGET_FT_POINTER_SIZE (objfile), 2161 GET_UNSIGNED, current_objfile); 2162 tblscan += TARGET_FT_POINTER_SIZE (objfile); 2163 base += baseaddr; 2164 while (tblscan < tblend) 2165 { 2166 line = target_to_host (tblscan, SIZEOF_LINETBL_LINENO, GET_UNSIGNED, 2167 current_objfile); 2168 tblscan += SIZEOF_LINETBL_LINENO + SIZEOF_LINETBL_STMT; 2169 pc = target_to_host (tblscan, SIZEOF_LINETBL_DELTA, GET_UNSIGNED, 2170 current_objfile); 2171 tblscan += SIZEOF_LINETBL_DELTA; 2172 pc += base; 2173 if (line != 0) 2174 { 2175 record_line (current_subfile, line, pc); 2176 } 2177 } 2178 } 2179 } 2180 2181 /* 2182 2183 LOCAL FUNCTION 2184 2185 locval -- compute the value of a location attribute 2186 2187 SYNOPSIS 2188 2189 static int locval (char *loc) 2190 2191 DESCRIPTION 2192 2193 Given pointer to a string of bytes that define a location, compute 2194 the location and return the value. 2195 A location description containing no atoms indicates that the 2196 object is optimized out. The global optimized_out flag is set for 2197 those, the return value is meaningless. 2198 2199 When computing values involving the current value of the frame pointer, 2200 the value zero is used, which results in a value relative to the frame 2201 pointer, rather than the absolute value. This is what GDB wants 2202 anyway. 2203 2204 When the result is a register number, the global isreg flag is set, 2205 otherwise it is cleared. This is a kludge until we figure out a better 2206 way to handle the problem. Gdb's design does not mesh well with the 2207 DWARF notion of a location computing interpreter, which is a shame 2208 because the flexibility goes unused. 2209 2210 NOTES 2211 2212 Note that stack[0] is unused except as a default error return. 2213 Note that stack overflow is not yet handled. 2214 */ 2215 2216 static int 2217 locval (loc) 2218 char *loc; 2219 { 2220 unsigned short nbytes; 2221 unsigned short locsize; 2222 auto long stack[64]; 2223 int stacki; 2224 char *end; 2225 int loc_atom_code; 2226 int loc_value_size; 2227 2228 nbytes = attribute_size (AT_location); 2229 locsize = target_to_host (loc, nbytes, GET_UNSIGNED, current_objfile); 2230 loc += nbytes; 2231 end = loc + locsize; 2232 stacki = 0; 2233 stack[stacki] = 0; 2234 isreg = 0; 2235 offreg = 0; 2236 optimized_out = 1; 2237 loc_value_size = TARGET_FT_LONG_SIZE (current_objfile); 2238 while (loc < end) 2239 { 2240 optimized_out = 0; 2241 loc_atom_code = target_to_host (loc, SIZEOF_LOC_ATOM_CODE, GET_UNSIGNED, 2242 current_objfile); 2243 loc += SIZEOF_LOC_ATOM_CODE; 2244 switch (loc_atom_code) 2245 { 2246 case 0: 2247 /* error */ 2248 loc = end; 2249 break; 2250 case OP_REG: 2251 /* push register (number) */ 2252 stack[++stacki] 2253 = DWARF_REG_TO_REGNUM (target_to_host (loc, loc_value_size, 2254 GET_UNSIGNED, 2255 current_objfile)); 2256 loc += loc_value_size; 2257 isreg = 1; 2258 break; 2259 case OP_BASEREG: 2260 /* push value of register (number) */ 2261 /* Actually, we compute the value as if register has 0, so the 2262 value ends up being the offset from that register. */ 2263 offreg = 1; 2264 basereg = target_to_host (loc, loc_value_size, GET_UNSIGNED, 2265 current_objfile); 2266 loc += loc_value_size; 2267 stack[++stacki] = 0; 2268 break; 2269 case OP_ADDR: 2270 /* push address (relocated address) */ 2271 stack[++stacki] = target_to_host (loc, loc_value_size, 2272 GET_UNSIGNED, current_objfile); 2273 loc += loc_value_size; 2274 break; 2275 case OP_CONST: 2276 /* push constant (number) FIXME: signed or unsigned! */ 2277 stack[++stacki] = target_to_host (loc, loc_value_size, 2278 GET_SIGNED, current_objfile); 2279 loc += loc_value_size; 2280 break; 2281 case OP_DEREF2: 2282 /* pop, deref and push 2 bytes (as a long) */ 2283 complain (&op_deref2, DIE_ID, DIE_NAME, stack[stacki]); 2284 break; 2285 case OP_DEREF4: /* pop, deref and push 4 bytes (as a long) */ 2286 complain (&op_deref4, DIE_ID, DIE_NAME, stack[stacki]); 2287 break; 2288 case OP_ADD: /* pop top 2 items, add, push result */ 2289 stack[stacki - 1] += stack[stacki]; 2290 stacki--; 2291 break; 2292 } 2293 } 2294 return (stack[stacki]); 2295 } 2296 2297 /* 2298 2299 LOCAL FUNCTION 2300 2301 read_ofile_symtab -- build a full symtab entry from chunk of DIE's 2302 2303 SYNOPSIS 2304 2305 static void read_ofile_symtab (struct partial_symtab *pst) 2306 2307 DESCRIPTION 2308 2309 When expanding a partial symbol table entry to a full symbol table 2310 entry, this is the function that gets called to read in the symbols 2311 for the compilation unit. A pointer to the newly constructed symtab, 2312 which is now the new first one on the objfile's symtab list, is 2313 stashed in the partial symbol table entry. 2314 */ 2315 2316 static void 2317 read_ofile_symtab (pst) 2318 struct partial_symtab *pst; 2319 { 2320 struct cleanup *back_to; 2321 unsigned long lnsize; 2322 file_ptr foffset; 2323 bfd *abfd; 2324 char lnsizedata[SIZEOF_LINETBL_LENGTH]; 2325 2326 abfd = pst -> objfile -> obfd; 2327 current_objfile = pst -> objfile; 2328 2329 /* Allocate a buffer for the entire chunk of DIE's for this compilation 2330 unit, seek to the location in the file, and read in all the DIE's. */ 2331 2332 diecount = 0; 2333 dbsize = DBLENGTH (pst); 2334 dbbase = xmalloc (dbsize); 2335 dbroff = DBROFF(pst); 2336 foffset = DBFOFF(pst) + dbroff; 2337 base_section_offsets = pst->section_offsets; 2338 baseaddr = ANOFFSET (pst->section_offsets, 0); 2339 if (bfd_seek (abfd, foffset, SEEK_SET) || 2340 (bfd_read (dbbase, dbsize, 1, abfd) != dbsize)) 2341 { 2342 free (dbbase); 2343 error ("can't read DWARF data"); 2344 } 2345 back_to = make_cleanup (free, dbbase); 2346 2347 /* If there is a line number table associated with this compilation unit 2348 then read the size of this fragment in bytes, from the fragment itself. 2349 Allocate a buffer for the fragment and read it in for future 2350 processing. */ 2351 2352 lnbase = NULL; 2353 if (LNFOFF (pst)) 2354 { 2355 if (bfd_seek (abfd, LNFOFF (pst), SEEK_SET) || 2356 (bfd_read ((PTR) lnsizedata, sizeof (lnsizedata), 1, abfd) != 2357 sizeof (lnsizedata))) 2358 { 2359 error ("can't read DWARF line number table size"); 2360 } 2361 lnsize = target_to_host (lnsizedata, SIZEOF_LINETBL_LENGTH, 2362 GET_UNSIGNED, pst -> objfile); 2363 lnbase = xmalloc (lnsize); 2364 if (bfd_seek (abfd, LNFOFF (pst), SEEK_SET) || 2365 (bfd_read (lnbase, lnsize, 1, abfd) != lnsize)) 2366 { 2367 free (lnbase); 2368 error ("can't read DWARF line numbers"); 2369 } 2370 make_cleanup (free, lnbase); 2371 } 2372 2373 process_dies (dbbase, dbbase + dbsize, pst -> objfile); 2374 do_cleanups (back_to); 2375 current_objfile = NULL; 2376 pst -> symtab = pst -> objfile -> symtabs; 2377 } 2378 2379 /* 2380 2381 LOCAL FUNCTION 2382 2383 psymtab_to_symtab_1 -- do grunt work for building a full symtab entry 2384 2385 SYNOPSIS 2386 2387 static void psymtab_to_symtab_1 (struct partial_symtab *pst) 2388 2389 DESCRIPTION 2390 2391 Called once for each partial symbol table entry that needs to be 2392 expanded into a full symbol table entry. 2393 2394 */ 2395 2396 static void 2397 psymtab_to_symtab_1 (pst) 2398 struct partial_symtab *pst; 2399 { 2400 int i; 2401 struct cleanup *old_chain; 2402 2403 if (pst != NULL) 2404 { 2405 if (pst->readin) 2406 { 2407 warning ("psymtab for %s already read in. Shouldn't happen.", 2408 pst -> filename); 2409 } 2410 else 2411 { 2412 /* Read in all partial symtabs on which this one is dependent */ 2413 for (i = 0; i < pst -> number_of_dependencies; i++) 2414 { 2415 if (!pst -> dependencies[i] -> readin) 2416 { 2417 /* Inform about additional files that need to be read in. */ 2418 if (info_verbose) 2419 { 2420 fputs_filtered (" ", gdb_stdout); 2421 wrap_here (""); 2422 fputs_filtered ("and ", gdb_stdout); 2423 wrap_here (""); 2424 printf_filtered ("%s...", 2425 pst -> dependencies[i] -> filename); 2426 wrap_here (""); 2427 gdb_flush (gdb_stdout); /* Flush output */ 2428 } 2429 psymtab_to_symtab_1 (pst -> dependencies[i]); 2430 } 2431 } 2432 if (DBLENGTH (pst)) /* Otherwise it's a dummy */ 2433 { 2434 buildsym_init (); 2435 old_chain = make_cleanup (really_free_pendings, 0); 2436 read_ofile_symtab (pst); 2437 if (info_verbose) 2438 { 2439 printf_filtered ("%d DIE's, sorting...", diecount); 2440 wrap_here (""); 2441 gdb_flush (gdb_stdout); 2442 } 2443 sort_symtab_syms (pst -> symtab); 2444 do_cleanups (old_chain); 2445 } 2446 pst -> readin = 1; 2447 } 2448 } 2449 } 2450 2451 /* 2452 2453 LOCAL FUNCTION 2454 2455 dwarf_psymtab_to_symtab -- build a full symtab entry from partial one 2456 2457 SYNOPSIS 2458 2459 static void dwarf_psymtab_to_symtab (struct partial_symtab *pst) 2460 2461 DESCRIPTION 2462 2463 This is the DWARF support entry point for building a full symbol 2464 table entry from a partial symbol table entry. We are passed a 2465 pointer to the partial symbol table entry that needs to be expanded. 2466 2467 */ 2468 2469 static void 2470 dwarf_psymtab_to_symtab (pst) 2471 struct partial_symtab *pst; 2472 { 2473 2474 if (pst != NULL) 2475 { 2476 if (pst -> readin) 2477 { 2478 warning ("psymtab for %s already read in. Shouldn't happen.", 2479 pst -> filename); 2480 } 2481 else 2482 { 2483 if (DBLENGTH (pst) || pst -> number_of_dependencies) 2484 { 2485 /* Print the message now, before starting serious work, to avoid 2486 disconcerting pauses. */ 2487 if (info_verbose) 2488 { 2489 printf_filtered ("Reading in symbols for %s...", 2490 pst -> filename); 2491 gdb_flush (gdb_stdout); 2492 } 2493 2494 psymtab_to_symtab_1 (pst); 2495 2496 #if 0 /* FIXME: Check to see what dbxread is doing here and see if 2497 we need to do an equivalent or is this something peculiar to 2498 stabs/a.out format. 2499 Match with global symbols. This only needs to be done once, 2500 after all of the symtabs and dependencies have been read in. 2501 */ 2502 scan_file_globals (pst -> objfile); 2503 #endif 2504 2505 /* Finish up the verbose info message. */ 2506 if (info_verbose) 2507 { 2508 printf_filtered ("done.\n"); 2509 gdb_flush (gdb_stdout); 2510 } 2511 } 2512 } 2513 } 2514 } 2515 2516 /* 2517 2518 LOCAL FUNCTION 2519 2520 add_enum_psymbol -- add enumeration members to partial symbol table 2521 2522 DESCRIPTION 2523 2524 Given pointer to a DIE that is known to be for an enumeration, 2525 extract the symbolic names of the enumeration members and add 2526 partial symbols for them. 2527 */ 2528 2529 static void 2530 add_enum_psymbol (dip, objfile) 2531 struct dieinfo *dip; 2532 struct objfile *objfile; 2533 { 2534 char *scan; 2535 char *listend; 2536 unsigned short blocksz; 2537 int nbytes; 2538 2539 if ((scan = dip -> at_element_list) != NULL) 2540 { 2541 if (dip -> short_element_list) 2542 { 2543 nbytes = attribute_size (AT_short_element_list); 2544 } 2545 else 2546 { 2547 nbytes = attribute_size (AT_element_list); 2548 } 2549 blocksz = target_to_host (scan, nbytes, GET_UNSIGNED, objfile); 2550 scan += nbytes; 2551 listend = scan + blocksz; 2552 while (scan < listend) 2553 { 2554 scan += TARGET_FT_LONG_SIZE (objfile); 2555 add_psymbol_to_list (scan, strlen (scan), VAR_NAMESPACE, LOC_CONST, 2556 &objfile -> static_psymbols, 0, 0, cu_language, 2557 objfile); 2558 scan += strlen (scan) + 1; 2559 } 2560 } 2561 } 2562 2563 /* 2564 2565 LOCAL FUNCTION 2566 2567 add_partial_symbol -- add symbol to partial symbol table 2568 2569 DESCRIPTION 2570 2571 Given a DIE, if it is one of the types that we want to 2572 add to a partial symbol table, finish filling in the die info 2573 and then add a partial symbol table entry for it. 2574 2575 NOTES 2576 2577 The caller must ensure that the DIE has a valid name attribute. 2578 */ 2579 2580 static void 2581 add_partial_symbol (dip, objfile) 2582 struct dieinfo *dip; 2583 struct objfile *objfile; 2584 { 2585 switch (dip -> die_tag) 2586 { 2587 case TAG_global_subroutine: 2588 add_psymbol_to_list (dip -> at_name, strlen (dip -> at_name), 2589 VAR_NAMESPACE, LOC_BLOCK, 2590 &objfile -> global_psymbols, 2591 0, dip -> at_low_pc, cu_language, objfile); 2592 break; 2593 case TAG_global_variable: 2594 add_psymbol_to_list (dip -> at_name, strlen (dip -> at_name), 2595 VAR_NAMESPACE, LOC_STATIC, 2596 &objfile -> global_psymbols, 2597 0, 0, cu_language, objfile); 2598 break; 2599 case TAG_subroutine: 2600 add_psymbol_to_list (dip -> at_name, strlen (dip -> at_name), 2601 VAR_NAMESPACE, LOC_BLOCK, 2602 &objfile -> static_psymbols, 2603 0, dip -> at_low_pc, cu_language, objfile); 2604 break; 2605 case TAG_local_variable: 2606 add_psymbol_to_list (dip -> at_name, strlen (dip -> at_name), 2607 VAR_NAMESPACE, LOC_STATIC, 2608 &objfile -> static_psymbols, 2609 0, 0, cu_language, objfile); 2610 break; 2611 case TAG_typedef: 2612 add_psymbol_to_list (dip -> at_name, strlen (dip -> at_name), 2613 VAR_NAMESPACE, LOC_TYPEDEF, 2614 &objfile -> static_psymbols, 2615 0, 0, cu_language, objfile); 2616 break; 2617 case TAG_class_type: 2618 case TAG_structure_type: 2619 case TAG_union_type: 2620 case TAG_enumeration_type: 2621 /* Do not add opaque aggregate definitions to the psymtab. */ 2622 if (!dip -> has_at_byte_size) 2623 break; 2624 add_psymbol_to_list (dip -> at_name, strlen (dip -> at_name), 2625 STRUCT_NAMESPACE, LOC_TYPEDEF, 2626 &objfile -> static_psymbols, 2627 0, 0, cu_language, objfile); 2628 if (cu_language == language_cplus) 2629 { 2630 /* For C++, these implicitly act as typedefs as well. */ 2631 add_psymbol_to_list (dip -> at_name, strlen (dip -> at_name), 2632 VAR_NAMESPACE, LOC_TYPEDEF, 2633 &objfile -> static_psymbols, 2634 0, 0, cu_language, objfile); 2635 } 2636 break; 2637 } 2638 } 2639 2640 /* 2641 2642 LOCAL FUNCTION 2643 2644 scan_partial_symbols -- scan DIE's within a single compilation unit 2645 2646 DESCRIPTION 2647 2648 Process the DIE's within a single compilation unit, looking for 2649 interesting DIE's that contribute to the partial symbol table entry 2650 for this compilation unit. 2651 2652 NOTES 2653 2654 There are some DIE's that may appear both at file scope and within 2655 the scope of a function. We are only interested in the ones at file 2656 scope, and the only way to tell them apart is to keep track of the 2657 scope. For example, consider the test case: 2658 2659 static int i; 2660 main () { int j; } 2661 2662 for which the relevant DWARF segment has the structure: 2663 2664 0x51: 2665 0x23 global subrtn sibling 0x9b 2666 name main 2667 fund_type FT_integer 2668 low_pc 0x800004cc 2669 high_pc 0x800004d4 2670 2671 0x74: 2672 0x23 local var sibling 0x97 2673 name j 2674 fund_type FT_integer 2675 location OP_BASEREG 0xe 2676 OP_CONST 0xfffffffc 2677 OP_ADD 2678 0x97: 2679 0x4 2680 2681 0x9b: 2682 0x1d local var sibling 0xb8 2683 name i 2684 fund_type FT_integer 2685 location OP_ADDR 0x800025dc 2686 2687 0xb8: 2688 0x4 2689 2690 We want to include the symbol 'i' in the partial symbol table, but 2691 not the symbol 'j'. In essence, we want to skip all the dies within 2692 the scope of a TAG_global_subroutine DIE. 2693 2694 Don't attempt to add anonymous structures or unions since they have 2695 no name. Anonymous enumerations however are processed, because we 2696 want to extract their member names (the check for a tag name is 2697 done later). 2698 2699 Also, for variables and subroutines, check that this is the place 2700 where the actual definition occurs, rather than just a reference 2701 to an external. 2702 */ 2703 2704 static void 2705 scan_partial_symbols (thisdie, enddie, objfile) 2706 char *thisdie; 2707 char *enddie; 2708 struct objfile *objfile; 2709 { 2710 char *nextdie; 2711 char *temp; 2712 struct dieinfo di; 2713 2714 while (thisdie < enddie) 2715 { 2716 basicdieinfo (&di, thisdie, objfile); 2717 if (di.die_length < SIZEOF_DIE_LENGTH) 2718 { 2719 break; 2720 } 2721 else 2722 { 2723 nextdie = thisdie + di.die_length; 2724 /* To avoid getting complete die information for every die, we 2725 only do it (below) for the cases we are interested in. */ 2726 switch (di.die_tag) 2727 { 2728 case TAG_global_subroutine: 2729 case TAG_subroutine: 2730 completedieinfo (&di, objfile); 2731 if (di.at_name && (di.has_at_low_pc || di.at_location)) 2732 { 2733 add_partial_symbol (&di, objfile); 2734 /* If there is a sibling attribute, adjust the nextdie 2735 pointer to skip the entire scope of the subroutine. 2736 Apply some sanity checking to make sure we don't 2737 overrun or underrun the range of remaining DIE's */ 2738 if (di.at_sibling != 0) 2739 { 2740 temp = dbbase + di.at_sibling - dbroff; 2741 if ((temp < thisdie) || (temp >= enddie)) 2742 { 2743 complain (&bad_die_ref, DIE_ID, DIE_NAME, 2744 di.at_sibling); 2745 } 2746 else 2747 { 2748 nextdie = temp; 2749 } 2750 } 2751 } 2752 break; 2753 case TAG_global_variable: 2754 case TAG_local_variable: 2755 completedieinfo (&di, objfile); 2756 if (di.at_name && (di.has_at_low_pc || di.at_location)) 2757 { 2758 add_partial_symbol (&di, objfile); 2759 } 2760 break; 2761 case TAG_typedef: 2762 case TAG_class_type: 2763 case TAG_structure_type: 2764 case TAG_union_type: 2765 completedieinfo (&di, objfile); 2766 if (di.at_name) 2767 { 2768 add_partial_symbol (&di, objfile); 2769 } 2770 break; 2771 case TAG_enumeration_type: 2772 completedieinfo (&di, objfile); 2773 if (di.at_name) 2774 { 2775 add_partial_symbol (&di, objfile); 2776 } 2777 add_enum_psymbol (&di, objfile); 2778 break; 2779 } 2780 } 2781 thisdie = nextdie; 2782 } 2783 } 2784 2785 /* 2786 2787 LOCAL FUNCTION 2788 2789 scan_compilation_units -- build a psymtab entry for each compilation 2790 2791 DESCRIPTION 2792 2793 This is the top level dwarf parsing routine for building partial 2794 symbol tables. 2795 2796 It scans from the beginning of the DWARF table looking for the first 2797 TAG_compile_unit DIE, and then follows the sibling chain to locate 2798 each additional TAG_compile_unit DIE. 2799 2800 For each TAG_compile_unit DIE it creates a partial symtab structure, 2801 calls a subordinate routine to collect all the compilation unit's 2802 global DIE's, file scope DIEs, typedef DIEs, etc, and then links the 2803 new partial symtab structure into the partial symbol table. It also 2804 records the appropriate information in the partial symbol table entry 2805 to allow the chunk of DIE's and line number table for this compilation 2806 unit to be located and re-read later, to generate a complete symbol 2807 table entry for the compilation unit. 2808 2809 Thus it effectively partitions up a chunk of DIE's for multiple 2810 compilation units into smaller DIE chunks and line number tables, 2811 and associates them with a partial symbol table entry. 2812 2813 NOTES 2814 2815 If any compilation unit has no line number table associated with 2816 it for some reason (a missing at_stmt_list attribute, rather than 2817 just one with a value of zero, which is valid) then we ensure that 2818 the recorded file offset is zero so that the routine which later 2819 reads line number table fragments knows that there is no fragment 2820 to read. 2821 2822 RETURNS 2823 2824 Returns no value. 2825 2826 */ 2827 2828 static void 2829 scan_compilation_units (thisdie, enddie, dbfoff, lnoffset, objfile) 2830 char *thisdie; 2831 char *enddie; 2832 file_ptr dbfoff; 2833 file_ptr lnoffset; 2834 struct objfile *objfile; 2835 { 2836 char *nextdie; 2837 struct dieinfo di; 2838 struct partial_symtab *pst; 2839 int culength; 2840 int curoff; 2841 file_ptr curlnoffset; 2842 2843 while (thisdie < enddie) 2844 { 2845 basicdieinfo (&di, thisdie, objfile); 2846 if (di.die_length < SIZEOF_DIE_LENGTH) 2847 { 2848 break; 2849 } 2850 else if (di.die_tag != TAG_compile_unit) 2851 { 2852 nextdie = thisdie + di.die_length; 2853 } 2854 else 2855 { 2856 completedieinfo (&di, objfile); 2857 set_cu_language (&di); 2858 if (di.at_sibling != 0) 2859 { 2860 nextdie = dbbase + di.at_sibling - dbroff; 2861 } 2862 else 2863 { 2864 nextdie = thisdie + di.die_length; 2865 } 2866 curoff = thisdie - dbbase; 2867 culength = nextdie - thisdie; 2868 curlnoffset = di.has_at_stmt_list ? lnoffset + di.at_stmt_list : 0; 2869 2870 /* First allocate a new partial symbol table structure */ 2871 2872 pst = start_psymtab_common (objfile, base_section_offsets, 2873 di.at_name, di.at_low_pc, 2874 objfile -> global_psymbols.next, 2875 objfile -> static_psymbols.next); 2876 2877 pst -> texthigh = di.at_high_pc; 2878 pst -> read_symtab_private = (char *) 2879 obstack_alloc (&objfile -> psymbol_obstack, 2880 sizeof (struct dwfinfo)); 2881 DBFOFF (pst) = dbfoff; 2882 DBROFF (pst) = curoff; 2883 DBLENGTH (pst) = culength; 2884 LNFOFF (pst) = curlnoffset; 2885 pst -> read_symtab = dwarf_psymtab_to_symtab; 2886 2887 /* Now look for partial symbols */ 2888 2889 scan_partial_symbols (thisdie + di.die_length, nextdie, objfile); 2890 2891 pst -> n_global_syms = objfile -> global_psymbols.next - 2892 (objfile -> global_psymbols.list + pst -> globals_offset); 2893 pst -> n_static_syms = objfile -> static_psymbols.next - 2894 (objfile -> static_psymbols.list + pst -> statics_offset); 2895 sort_pst_symbols (pst); 2896 /* If there is already a psymtab or symtab for a file of this name, 2897 remove it. (If there is a symtab, more drastic things also 2898 happen.) This happens in VxWorks. */ 2899 free_named_symtabs (pst -> filename); 2900 } 2901 thisdie = nextdie; 2902 } 2903 } 2904 2905 /* 2906 2907 LOCAL FUNCTION 2908 2909 new_symbol -- make a symbol table entry for a new symbol 2910 2911 SYNOPSIS 2912 2913 static struct symbol *new_symbol (struct dieinfo *dip, 2914 struct objfile *objfile) 2915 2916 DESCRIPTION 2917 2918 Given a pointer to a DWARF information entry, figure out if we need 2919 to make a symbol table entry for it, and if so, create a new entry 2920 and return a pointer to it. 2921 */ 2922 2923 static struct symbol * 2924 new_symbol (dip, objfile) 2925 struct dieinfo *dip; 2926 struct objfile *objfile; 2927 { 2928 struct symbol *sym = NULL; 2929 2930 if (dip -> at_name != NULL) 2931 { 2932 sym = (struct symbol *) obstack_alloc (&objfile -> symbol_obstack, 2933 sizeof (struct symbol)); 2934 OBJSTAT (objfile, n_syms++); 2935 memset (sym, 0, sizeof (struct symbol)); 2936 SYMBOL_NAME (sym) = create_name (dip -> at_name, 2937 &objfile->symbol_obstack); 2938 /* default assumptions */ 2939 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE; 2940 SYMBOL_CLASS (sym) = LOC_STATIC; 2941 SYMBOL_TYPE (sym) = decode_die_type (dip); 2942 2943 /* If this symbol is from a C++ compilation, then attempt to cache the 2944 demangled form for future reference. This is a typical time versus 2945 space tradeoff, that was decided in favor of time because it sped up 2946 C++ symbol lookups by a factor of about 20. */ 2947 2948 SYMBOL_LANGUAGE (sym) = cu_language; 2949 SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile -> symbol_obstack); 2950 switch (dip -> die_tag) 2951 { 2952 case TAG_label: 2953 SYMBOL_VALUE_ADDRESS (sym) = dip -> at_low_pc; 2954 SYMBOL_CLASS (sym) = LOC_LABEL; 2955 break; 2956 case TAG_global_subroutine: 2957 case TAG_subroutine: 2958 SYMBOL_VALUE_ADDRESS (sym) = dip -> at_low_pc; 2959 SYMBOL_TYPE (sym) = lookup_function_type (SYMBOL_TYPE (sym)); 2960 if (dip -> at_prototyped) 2961 TYPE_FLAGS (SYMBOL_TYPE (sym)) |= TYPE_FLAG_PROTOTYPED; 2962 SYMBOL_CLASS (sym) = LOC_BLOCK; 2963 if (dip -> die_tag == TAG_global_subroutine) 2964 { 2965 add_symbol_to_list (sym, &global_symbols); 2966 } 2967 else 2968 { 2969 add_symbol_to_list (sym, list_in_scope); 2970 } 2971 break; 2972 case TAG_global_variable: 2973 if (dip -> at_location != NULL) 2974 { 2975 SYMBOL_VALUE (sym) = locval (dip -> at_location); 2976 add_symbol_to_list (sym, &global_symbols); 2977 SYMBOL_CLASS (sym) = LOC_STATIC; 2978 SYMBOL_VALUE (sym) += baseaddr; 2979 } 2980 break; 2981 case TAG_local_variable: 2982 if (dip -> at_location != NULL) 2983 { 2984 SYMBOL_VALUE (sym) = locval (dip -> at_location); 2985 add_symbol_to_list (sym, list_in_scope); 2986 if (optimized_out) 2987 { 2988 SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT; 2989 } 2990 else if (isreg) 2991 { 2992 SYMBOL_CLASS (sym) = LOC_REGISTER; 2993 } 2994 else if (offreg) 2995 { 2996 SYMBOL_CLASS (sym) = LOC_BASEREG; 2997 SYMBOL_BASEREG (sym) = basereg; 2998 } 2999 else 3000 { 3001 SYMBOL_CLASS (sym) = LOC_STATIC; 3002 SYMBOL_VALUE (sym) += baseaddr; 3003 } 3004 } 3005 break; 3006 case TAG_formal_parameter: 3007 if (dip -> at_location != NULL) 3008 { 3009 SYMBOL_VALUE (sym) = locval (dip -> at_location); 3010 } 3011 add_symbol_to_list (sym, list_in_scope); 3012 if (isreg) 3013 { 3014 SYMBOL_CLASS (sym) = LOC_REGPARM; 3015 } 3016 else if (offreg) 3017 { 3018 SYMBOL_CLASS (sym) = LOC_BASEREG_ARG; 3019 SYMBOL_BASEREG (sym) = basereg; 3020 } 3021 else 3022 { 3023 SYMBOL_CLASS (sym) = LOC_ARG; 3024 } 3025 break; 3026 case TAG_unspecified_parameters: 3027 /* From varargs functions; gdb doesn't seem to have any interest in 3028 this information, so just ignore it for now. (FIXME?) */ 3029 break; 3030 case TAG_class_type: 3031 case TAG_structure_type: 3032 case TAG_union_type: 3033 case TAG_enumeration_type: 3034 SYMBOL_CLASS (sym) = LOC_TYPEDEF; 3035 SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE; 3036 add_symbol_to_list (sym, list_in_scope); 3037 break; 3038 case TAG_typedef: 3039 SYMBOL_CLASS (sym) = LOC_TYPEDEF; 3040 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE; 3041 add_symbol_to_list (sym, list_in_scope); 3042 break; 3043 default: 3044 /* Not a tag we recognize. Hopefully we aren't processing trash 3045 data, but since we must specifically ignore things we don't 3046 recognize, there is nothing else we should do at this point. */ 3047 break; 3048 } 3049 } 3050 return (sym); 3051 } 3052 3053 /* 3054 3055 LOCAL FUNCTION 3056 3057 synthesize_typedef -- make a symbol table entry for a "fake" typedef 3058 3059 SYNOPSIS 3060 3061 static void synthesize_typedef (struct dieinfo *dip, 3062 struct objfile *objfile, 3063 struct type *type); 3064 3065 DESCRIPTION 3066 3067 Given a pointer to a DWARF information entry, synthesize a typedef 3068 for the name in the DIE, using the specified type. 3069 3070 This is used for C++ class, structs, unions, and enumerations to 3071 set up the tag name as a type. 3072 3073 */ 3074 3075 static void 3076 synthesize_typedef (dip, objfile, type) 3077 struct dieinfo *dip; 3078 struct objfile *objfile; 3079 struct type *type; 3080 { 3081 struct symbol *sym = NULL; 3082 3083 if (dip -> at_name != NULL) 3084 { 3085 sym = (struct symbol *) 3086 obstack_alloc (&objfile -> symbol_obstack, sizeof (struct symbol)); 3087 OBJSTAT (objfile, n_syms++); 3088 memset (sym, 0, sizeof (struct symbol)); 3089 SYMBOL_NAME (sym) = create_name (dip -> at_name, 3090 &objfile->symbol_obstack); 3091 SYMBOL_INIT_LANGUAGE_SPECIFIC (sym, cu_language); 3092 SYMBOL_TYPE (sym) = type; 3093 SYMBOL_CLASS (sym) = LOC_TYPEDEF; 3094 SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE; 3095 add_symbol_to_list (sym, list_in_scope); 3096 } 3097 } 3098 3099 /* 3100 3101 LOCAL FUNCTION 3102 3103 decode_mod_fund_type -- decode a modified fundamental type 3104 3105 SYNOPSIS 3106 3107 static struct type *decode_mod_fund_type (char *typedata) 3108 3109 DESCRIPTION 3110 3111 Decode a block of data containing a modified fundamental 3112 type specification. TYPEDATA is a pointer to the block, 3113 which starts with a length containing the size of the rest 3114 of the block. At the end of the block is a fundmental type 3115 code value that gives the fundamental type. Everything 3116 in between are type modifiers. 3117 3118 We simply compute the number of modifiers and call the general 3119 function decode_modified_type to do the actual work. 3120 */ 3121 3122 static struct type * 3123 decode_mod_fund_type (typedata) 3124 char *typedata; 3125 { 3126 struct type *typep = NULL; 3127 unsigned short modcount; 3128 int nbytes; 3129 3130 /* Get the total size of the block, exclusive of the size itself */ 3131 3132 nbytes = attribute_size (AT_mod_fund_type); 3133 modcount = target_to_host (typedata, nbytes, GET_UNSIGNED, current_objfile); 3134 typedata += nbytes; 3135 3136 /* Deduct the size of the fundamental type bytes at the end of the block. */ 3137 3138 modcount -= attribute_size (AT_fund_type); 3139 3140 /* Now do the actual decoding */ 3141 3142 typep = decode_modified_type (typedata, modcount, AT_mod_fund_type); 3143 return (typep); 3144 } 3145 3146 /* 3147 3148 LOCAL FUNCTION 3149 3150 decode_mod_u_d_type -- decode a modified user defined type 3151 3152 SYNOPSIS 3153 3154 static struct type *decode_mod_u_d_type (char *typedata) 3155 3156 DESCRIPTION 3157 3158 Decode a block of data containing a modified user defined 3159 type specification. TYPEDATA is a pointer to the block, 3160 which consists of a two byte length, containing the size 3161 of the rest of the block. At the end of the block is a 3162 four byte value that gives a reference to a user defined type. 3163 Everything in between are type modifiers. 3164 3165 We simply compute the number of modifiers and call the general 3166 function decode_modified_type to do the actual work. 3167 */ 3168 3169 static struct type * 3170 decode_mod_u_d_type (typedata) 3171 char *typedata; 3172 { 3173 struct type *typep = NULL; 3174 unsigned short modcount; 3175 int nbytes; 3176 3177 /* Get the total size of the block, exclusive of the size itself */ 3178 3179 nbytes = attribute_size (AT_mod_u_d_type); 3180 modcount = target_to_host (typedata, nbytes, GET_UNSIGNED, current_objfile); 3181 typedata += nbytes; 3182 3183 /* Deduct the size of the reference type bytes at the end of the block. */ 3184 3185 modcount -= attribute_size (AT_user_def_type); 3186 3187 /* Now do the actual decoding */ 3188 3189 typep = decode_modified_type (typedata, modcount, AT_mod_u_d_type); 3190 return (typep); 3191 } 3192 3193 /* 3194 3195 LOCAL FUNCTION 3196 3197 decode_modified_type -- decode modified user or fundamental type 3198 3199 SYNOPSIS 3200 3201 static struct type *decode_modified_type (char *modifiers, 3202 unsigned short modcount, int mtype) 3203 3204 DESCRIPTION 3205 3206 Decode a modified type, either a modified fundamental type or 3207 a modified user defined type. MODIFIERS is a pointer to the 3208 block of bytes that define MODCOUNT modifiers. Immediately 3209 following the last modifier is a short containing the fundamental 3210 type or a long containing the reference to the user defined 3211 type. Which one is determined by MTYPE, which is either 3212 AT_mod_fund_type or AT_mod_u_d_type to indicate what modified 3213 type we are generating. 3214 3215 We call ourself recursively to generate each modified type,` 3216 until MODCOUNT reaches zero, at which point we have consumed 3217 all the modifiers and generate either the fundamental type or 3218 user defined type. When the recursion unwinds, each modifier 3219 is applied in turn to generate the full modified type. 3220 3221 NOTES 3222 3223 If we find a modifier that we don't recognize, and it is not one 3224 of those reserved for application specific use, then we issue a 3225 warning and simply ignore the modifier. 3226 3227 BUGS 3228 3229 We currently ignore MOD_const and MOD_volatile. (FIXME) 3230 3231 */ 3232 3233 static struct type * 3234 decode_modified_type (modifiers, modcount, mtype) 3235 char *modifiers; 3236 unsigned int modcount; 3237 int mtype; 3238 { 3239 struct type *typep = NULL; 3240 unsigned short fundtype; 3241 DIE_REF die_ref; 3242 char modifier; 3243 int nbytes; 3244 3245 if (modcount == 0) 3246 { 3247 switch (mtype) 3248 { 3249 case AT_mod_fund_type: 3250 nbytes = attribute_size (AT_fund_type); 3251 fundtype = target_to_host (modifiers, nbytes, GET_UNSIGNED, 3252 current_objfile); 3253 typep = decode_fund_type (fundtype); 3254 break; 3255 case AT_mod_u_d_type: 3256 nbytes = attribute_size (AT_user_def_type); 3257 die_ref = target_to_host (modifiers, nbytes, GET_UNSIGNED, 3258 current_objfile); 3259 if ((typep = lookup_utype (die_ref)) == NULL) 3260 { 3261 typep = alloc_utype (die_ref, NULL); 3262 } 3263 break; 3264 default: 3265 complain (&botched_modified_type, DIE_ID, DIE_NAME, mtype); 3266 typep = dwarf_fundamental_type (current_objfile, FT_INTEGER); 3267 break; 3268 } 3269 } 3270 else 3271 { 3272 modifier = *modifiers++; 3273 typep = decode_modified_type (modifiers, --modcount, mtype); 3274 switch (modifier) 3275 { 3276 case MOD_pointer_to: 3277 typep = lookup_pointer_type (typep); 3278 break; 3279 case MOD_reference_to: 3280 typep = lookup_reference_type (typep); 3281 break; 3282 case MOD_const: 3283 complain (&const_ignored, DIE_ID, DIE_NAME); /* FIXME */ 3284 break; 3285 case MOD_volatile: 3286 complain (&volatile_ignored, DIE_ID, DIE_NAME); /* FIXME */ 3287 break; 3288 default: 3289 if (!(MOD_lo_user <= (unsigned char) modifier 3290 && (unsigned char) modifier <= MOD_hi_user)) 3291 { 3292 complain (&unknown_type_modifier, DIE_ID, DIE_NAME, modifier); 3293 } 3294 break; 3295 } 3296 } 3297 return (typep); 3298 } 3299 3300 /* 3301 3302 LOCAL FUNCTION 3303 3304 decode_fund_type -- translate basic DWARF type to gdb base type 3305 3306 DESCRIPTION 3307 3308 Given an integer that is one of the fundamental DWARF types, 3309 translate it to one of the basic internal gdb types and return 3310 a pointer to the appropriate gdb type (a "struct type *"). 3311 3312 NOTES 3313 3314 For robustness, if we are asked to translate a fundamental 3315 type that we are unprepared to deal with, we return int so 3316 callers can always depend upon a valid type being returned, 3317 and so gdb may at least do something reasonable by default. 3318 If the type is not in the range of those types defined as 3319 application specific types, we also issue a warning. 3320 */ 3321 3322 static struct type * 3323 decode_fund_type (fundtype) 3324 unsigned int fundtype; 3325 { 3326 struct type *typep = NULL; 3327 3328 switch (fundtype) 3329 { 3330 3331 case FT_void: 3332 typep = dwarf_fundamental_type (current_objfile, FT_VOID); 3333 break; 3334 3335 case FT_boolean: /* Was FT_set in AT&T version */ 3336 typep = dwarf_fundamental_type (current_objfile, FT_BOOLEAN); 3337 break; 3338 3339 case FT_pointer: /* (void *) */ 3340 typep = dwarf_fundamental_type (current_objfile, FT_VOID); 3341 typep = lookup_pointer_type (typep); 3342 break; 3343 3344 case FT_char: 3345 typep = dwarf_fundamental_type (current_objfile, FT_CHAR); 3346 break; 3347 3348 case FT_signed_char: 3349 typep = dwarf_fundamental_type (current_objfile, FT_SIGNED_CHAR); 3350 break; 3351 3352 case FT_unsigned_char: 3353 typep = dwarf_fundamental_type (current_objfile, FT_UNSIGNED_CHAR); 3354 break; 3355 3356 case FT_short: 3357 typep = dwarf_fundamental_type (current_objfile, FT_SHORT); 3358 break; 3359 3360 case FT_signed_short: 3361 typep = dwarf_fundamental_type (current_objfile, FT_SIGNED_SHORT); 3362 break; 3363 3364 case FT_unsigned_short: 3365 typep = dwarf_fundamental_type (current_objfile, FT_UNSIGNED_SHORT); 3366 break; 3367 3368 case FT_integer: 3369 typep = dwarf_fundamental_type (current_objfile, FT_INTEGER); 3370 break; 3371 3372 case FT_signed_integer: 3373 typep = dwarf_fundamental_type (current_objfile, FT_SIGNED_INTEGER); 3374 break; 3375 3376 case FT_unsigned_integer: 3377 typep = dwarf_fundamental_type (current_objfile, FT_UNSIGNED_INTEGER); 3378 break; 3379 3380 case FT_long: 3381 typep = dwarf_fundamental_type (current_objfile, FT_LONG); 3382 break; 3383 3384 case FT_signed_long: 3385 typep = dwarf_fundamental_type (current_objfile, FT_SIGNED_LONG); 3386 break; 3387 3388 case FT_unsigned_long: 3389 typep = dwarf_fundamental_type (current_objfile, FT_UNSIGNED_LONG); 3390 break; 3391 3392 case FT_long_long: 3393 typep = dwarf_fundamental_type (current_objfile, FT_LONG_LONG); 3394 break; 3395 3396 case FT_signed_long_long: 3397 typep = dwarf_fundamental_type (current_objfile, FT_SIGNED_LONG_LONG); 3398 break; 3399 3400 case FT_unsigned_long_long: 3401 typep = dwarf_fundamental_type (current_objfile, FT_UNSIGNED_LONG_LONG); 3402 break; 3403 3404 case FT_float: 3405 typep = dwarf_fundamental_type (current_objfile, FT_FLOAT); 3406 break; 3407 3408 case FT_dbl_prec_float: 3409 typep = dwarf_fundamental_type (current_objfile, FT_DBL_PREC_FLOAT); 3410 break; 3411 3412 case FT_ext_prec_float: 3413 typep = dwarf_fundamental_type (current_objfile, FT_EXT_PREC_FLOAT); 3414 break; 3415 3416 case FT_complex: 3417 typep = dwarf_fundamental_type (current_objfile, FT_COMPLEX); 3418 break; 3419 3420 case FT_dbl_prec_complex: 3421 typep = dwarf_fundamental_type (current_objfile, FT_DBL_PREC_COMPLEX); 3422 break; 3423 3424 case FT_ext_prec_complex: 3425 typep = dwarf_fundamental_type (current_objfile, FT_EXT_PREC_COMPLEX); 3426 break; 3427 3428 } 3429 3430 if (typep == NULL) 3431 { 3432 typep = dwarf_fundamental_type (current_objfile, FT_INTEGER); 3433 if (!(FT_lo_user <= fundtype && fundtype <= FT_hi_user)) 3434 { 3435 complain (&unexpected_fund_type, DIE_ID, DIE_NAME, fundtype); 3436 } 3437 } 3438 3439 return (typep); 3440 } 3441 3442 /* 3443 3444 LOCAL FUNCTION 3445 3446 create_name -- allocate a fresh copy of a string on an obstack 3447 3448 DESCRIPTION 3449 3450 Given a pointer to a string and a pointer to an obstack, allocates 3451 a fresh copy of the string on the specified obstack. 3452 3453 */ 3454 3455 static char * 3456 create_name (name, obstackp) 3457 char *name; 3458 struct obstack *obstackp; 3459 { 3460 int length; 3461 char *newname; 3462 3463 length = strlen (name) + 1; 3464 newname = (char *) obstack_alloc (obstackp, length); 3465 strcpy (newname, name); 3466 return (newname); 3467 } 3468 3469 /* 3470 3471 LOCAL FUNCTION 3472 3473 basicdieinfo -- extract the minimal die info from raw die data 3474 3475 SYNOPSIS 3476 3477 void basicdieinfo (char *diep, struct dieinfo *dip, 3478 struct objfile *objfile) 3479 3480 DESCRIPTION 3481 3482 Given a pointer to raw DIE data, and a pointer to an instance of a 3483 die info structure, this function extracts the basic information 3484 from the DIE data required to continue processing this DIE, along 3485 with some bookkeeping information about the DIE. 3486 3487 The information we absolutely must have includes the DIE tag, 3488 and the DIE length. If we need the sibling reference, then we 3489 will have to call completedieinfo() to process all the remaining 3490 DIE information. 3491 3492 Note that since there is no guarantee that the data is properly 3493 aligned in memory for the type of access required (indirection 3494 through anything other than a char pointer), and there is no 3495 guarantee that it is in the same byte order as the gdb host, 3496 we call a function which deals with both alignment and byte 3497 swapping issues. Possibly inefficient, but quite portable. 3498 3499 We also take care of some other basic things at this point, such 3500 as ensuring that the instance of the die info structure starts 3501 out completely zero'd and that curdie is initialized for use 3502 in error reporting if we have a problem with the current die. 3503 3504 NOTES 3505 3506 All DIE's must have at least a valid length, thus the minimum 3507 DIE size is SIZEOF_DIE_LENGTH. In order to have a valid tag, the 3508 DIE size must be at least SIZEOF_DIE_TAG larger, otherwise they 3509 are forced to be TAG_padding DIES. 3510 3511 Padding DIES must be at least SIZEOF_DIE_LENGTH in length, implying 3512 that if a padding DIE is used for alignment and the amount needed is 3513 less than SIZEOF_DIE_LENGTH, then the padding DIE has to be big 3514 enough to align to the next alignment boundry. 3515 3516 We do some basic sanity checking here, such as verifying that the 3517 length of the die would not cause it to overrun the recorded end of 3518 the buffer holding the DIE info. If we find a DIE that is either 3519 too small or too large, we force it's length to zero which should 3520 cause the caller to take appropriate action. 3521 */ 3522 3523 static void 3524 basicdieinfo (dip, diep, objfile) 3525 struct dieinfo *dip; 3526 char *diep; 3527 struct objfile *objfile; 3528 { 3529 curdie = dip; 3530 memset (dip, 0, sizeof (struct dieinfo)); 3531 dip -> die = diep; 3532 dip -> die_ref = dbroff + (diep - dbbase); 3533 dip -> die_length = target_to_host (diep, SIZEOF_DIE_LENGTH, GET_UNSIGNED, 3534 objfile); 3535 if ((dip -> die_length < SIZEOF_DIE_LENGTH) || 3536 ((diep + dip -> die_length) > (dbbase + dbsize))) 3537 { 3538 complain (&malformed_die, DIE_ID, DIE_NAME, dip -> die_length); 3539 dip -> die_length = 0; 3540 } 3541 else if (dip -> die_length < (SIZEOF_DIE_LENGTH + SIZEOF_DIE_TAG)) 3542 { 3543 dip -> die_tag = TAG_padding; 3544 } 3545 else 3546 { 3547 diep += SIZEOF_DIE_LENGTH; 3548 dip -> die_tag = target_to_host (diep, SIZEOF_DIE_TAG, GET_UNSIGNED, 3549 objfile); 3550 } 3551 } 3552 3553 /* 3554 3555 LOCAL FUNCTION 3556 3557 completedieinfo -- finish reading the information for a given DIE 3558 3559 SYNOPSIS 3560 3561 void completedieinfo (struct dieinfo *dip, struct objfile *objfile) 3562 3563 DESCRIPTION 3564 3565 Given a pointer to an already partially initialized die info structure, 3566 scan the raw DIE data and finish filling in the die info structure 3567 from the various attributes found. 3568 3569 Note that since there is no guarantee that the data is properly 3570 aligned in memory for the type of access required (indirection 3571 through anything other than a char pointer), and there is no 3572 guarantee that it is in the same byte order as the gdb host, 3573 we call a function which deals with both alignment and byte 3574 swapping issues. Possibly inefficient, but quite portable. 3575 3576 NOTES 3577 3578 Each time we are called, we increment the diecount variable, which 3579 keeps an approximate count of the number of dies processed for 3580 each compilation unit. This information is presented to the user 3581 if the info_verbose flag is set. 3582 3583 */ 3584 3585 static void 3586 completedieinfo (dip, objfile) 3587 struct dieinfo *dip; 3588 struct objfile *objfile; 3589 { 3590 char *diep; /* Current pointer into raw DIE data */ 3591 char *end; /* Terminate DIE scan here */ 3592 unsigned short attr; /* Current attribute being scanned */ 3593 unsigned short form; /* Form of the attribute */ 3594 int nbytes; /* Size of next field to read */ 3595 3596 diecount++; 3597 diep = dip -> die; 3598 end = diep + dip -> die_length; 3599 diep += SIZEOF_DIE_LENGTH + SIZEOF_DIE_TAG; 3600 while (diep < end) 3601 { 3602 attr = target_to_host (diep, SIZEOF_ATTRIBUTE, GET_UNSIGNED, objfile); 3603 diep += SIZEOF_ATTRIBUTE; 3604 if ((nbytes = attribute_size (attr)) == -1) 3605 { 3606 complain (&unknown_attribute_length, DIE_ID, DIE_NAME); 3607 diep = end; 3608 continue; 3609 } 3610 switch (attr) 3611 { 3612 case AT_fund_type: 3613 dip -> at_fund_type = target_to_host (diep, nbytes, GET_UNSIGNED, 3614 objfile); 3615 break; 3616 case AT_ordering: 3617 dip -> at_ordering = target_to_host (diep, nbytes, GET_UNSIGNED, 3618 objfile); 3619 break; 3620 case AT_bit_offset: 3621 dip -> at_bit_offset = target_to_host (diep, nbytes, GET_UNSIGNED, 3622 objfile); 3623 break; 3624 case AT_sibling: 3625 dip -> at_sibling = target_to_host (diep, nbytes, GET_UNSIGNED, 3626 objfile); 3627 break; 3628 case AT_stmt_list: 3629 dip -> at_stmt_list = target_to_host (diep, nbytes, GET_UNSIGNED, 3630 objfile); 3631 dip -> has_at_stmt_list = 1; 3632 break; 3633 case AT_low_pc: 3634 dip -> at_low_pc = target_to_host (diep, nbytes, GET_UNSIGNED, 3635 objfile); 3636 dip -> at_low_pc += baseaddr; 3637 dip -> has_at_low_pc = 1; 3638 break; 3639 case AT_high_pc: 3640 dip -> at_high_pc = target_to_host (diep, nbytes, GET_UNSIGNED, 3641 objfile); 3642 dip -> at_high_pc += baseaddr; 3643 break; 3644 case AT_language: 3645 dip -> at_language = target_to_host (diep, nbytes, GET_UNSIGNED, 3646 objfile); 3647 break; 3648 case AT_user_def_type: 3649 dip -> at_user_def_type = target_to_host (diep, nbytes, 3650 GET_UNSIGNED, objfile); 3651 break; 3652 case AT_byte_size: 3653 dip -> at_byte_size = target_to_host (diep, nbytes, GET_UNSIGNED, 3654 objfile); 3655 dip -> has_at_byte_size = 1; 3656 break; 3657 case AT_bit_size: 3658 dip -> at_bit_size = target_to_host (diep, nbytes, GET_UNSIGNED, 3659 objfile); 3660 break; 3661 case AT_member: 3662 dip -> at_member = target_to_host (diep, nbytes, GET_UNSIGNED, 3663 objfile); 3664 break; 3665 case AT_discr: 3666 dip -> at_discr = target_to_host (diep, nbytes, GET_UNSIGNED, 3667 objfile); 3668 break; 3669 case AT_location: 3670 dip -> at_location = diep; 3671 break; 3672 case AT_mod_fund_type: 3673 dip -> at_mod_fund_type = diep; 3674 break; 3675 case AT_subscr_data: 3676 dip -> at_subscr_data = diep; 3677 break; 3678 case AT_mod_u_d_type: 3679 dip -> at_mod_u_d_type = diep; 3680 break; 3681 case AT_element_list: 3682 dip -> at_element_list = diep; 3683 dip -> short_element_list = 0; 3684 break; 3685 case AT_short_element_list: 3686 dip -> at_element_list = diep; 3687 dip -> short_element_list = 1; 3688 break; 3689 case AT_discr_value: 3690 dip -> at_discr_value = diep; 3691 break; 3692 case AT_string_length: 3693 dip -> at_string_length = diep; 3694 break; 3695 case AT_name: 3696 dip -> at_name = diep; 3697 break; 3698 case AT_comp_dir: 3699 /* For now, ignore any "hostname:" portion, since gdb doesn't 3700 know how to deal with it. (FIXME). */ 3701 dip -> at_comp_dir = strrchr (diep, ':'); 3702 if (dip -> at_comp_dir != NULL) 3703 { 3704 dip -> at_comp_dir++; 3705 } 3706 else 3707 { 3708 dip -> at_comp_dir = diep; 3709 } 3710 break; 3711 case AT_producer: 3712 dip -> at_producer = diep; 3713 break; 3714 case AT_start_scope: 3715 dip -> at_start_scope = target_to_host (diep, nbytes, GET_UNSIGNED, 3716 objfile); 3717 break; 3718 case AT_stride_size: 3719 dip -> at_stride_size = target_to_host (diep, nbytes, GET_UNSIGNED, 3720 objfile); 3721 break; 3722 case AT_src_info: 3723 dip -> at_src_info = target_to_host (diep, nbytes, GET_UNSIGNED, 3724 objfile); 3725 break; 3726 case AT_prototyped: 3727 dip -> at_prototyped = diep; 3728 break; 3729 default: 3730 /* Found an attribute that we are unprepared to handle. However 3731 it is specifically one of the design goals of DWARF that 3732 consumers should ignore unknown attributes. As long as the 3733 form is one that we recognize (so we know how to skip it), 3734 we can just ignore the unknown attribute. */ 3735 break; 3736 } 3737 form = FORM_FROM_ATTR (attr); 3738 switch (form) 3739 { 3740 case FORM_DATA2: 3741 diep += 2; 3742 break; 3743 case FORM_DATA4: 3744 case FORM_REF: 3745 diep += 4; 3746 break; 3747 case FORM_DATA8: 3748 diep += 8; 3749 break; 3750 case FORM_ADDR: 3751 diep += TARGET_FT_POINTER_SIZE (objfile); 3752 break; 3753 case FORM_BLOCK2: 3754 diep += 2 + target_to_host (diep, nbytes, GET_UNSIGNED, objfile); 3755 break; 3756 case FORM_BLOCK4: 3757 diep += 4 + target_to_host (diep, nbytes, GET_UNSIGNED, objfile); 3758 break; 3759 case FORM_STRING: 3760 diep += strlen (diep) + 1; 3761 break; 3762 default: 3763 complain (&unknown_attribute_form, DIE_ID, DIE_NAME, form); 3764 diep = end; 3765 break; 3766 } 3767 } 3768 } 3769 3770 /* 3771 3772 LOCAL FUNCTION 3773 3774 target_to_host -- swap in target data to host 3775 3776 SYNOPSIS 3777 3778 target_to_host (char *from, int nbytes, int signextend, 3779 struct objfile *objfile) 3780 3781 DESCRIPTION 3782 3783 Given pointer to data in target format in FROM, a byte count for 3784 the size of the data in NBYTES, a flag indicating whether or not 3785 the data is signed in SIGNEXTEND, and a pointer to the current 3786 objfile in OBJFILE, convert the data to host format and return 3787 the converted value. 3788 3789 NOTES 3790 3791 FIXME: If we read data that is known to be signed, and expect to 3792 use it as signed data, then we need to explicitly sign extend the 3793 result until the bfd library is able to do this for us. 3794 3795 FIXME: Would a 32 bit target ever need an 8 byte result? 3796 3797 */ 3798 3799 static CORE_ADDR 3800 target_to_host (from, nbytes, signextend, objfile) 3801 char *from; 3802 int nbytes; 3803 int signextend; /* FIXME: Unused */ 3804 struct objfile *objfile; 3805 { 3806 CORE_ADDR rtnval; 3807 3808 switch (nbytes) 3809 { 3810 case 8: 3811 rtnval = bfd_get_64 (objfile -> obfd, (bfd_byte *) from); 3812 break; 3813 case 4: 3814 rtnval = bfd_get_32 (objfile -> obfd, (bfd_byte *) from); 3815 break; 3816 case 2: 3817 rtnval = bfd_get_16 (objfile -> obfd, (bfd_byte *) from); 3818 break; 3819 case 1: 3820 rtnval = bfd_get_8 (objfile -> obfd, (bfd_byte *) from); 3821 break; 3822 default: 3823 complain (&no_bfd_get_N, DIE_ID, DIE_NAME, nbytes); 3824 rtnval = 0; 3825 break; 3826 } 3827 return (rtnval); 3828 } 3829 3830 /* 3831 3832 LOCAL FUNCTION 3833 3834 attribute_size -- compute size of data for a DWARF attribute 3835 3836 SYNOPSIS 3837 3838 static int attribute_size (unsigned int attr) 3839 3840 DESCRIPTION 3841 3842 Given a DWARF attribute in ATTR, compute the size of the first 3843 piece of data associated with this attribute and return that 3844 size. 3845 3846 Returns -1 for unrecognized attributes. 3847 3848 */ 3849 3850 static int 3851 attribute_size (attr) 3852 unsigned int attr; 3853 { 3854 int nbytes; /* Size of next data for this attribute */ 3855 unsigned short form; /* Form of the attribute */ 3856 3857 form = FORM_FROM_ATTR (attr); 3858 switch (form) 3859 { 3860 case FORM_STRING: /* A variable length field is next */ 3861 nbytes = 0; 3862 break; 3863 case FORM_DATA2: /* Next 2 byte field is the data itself */ 3864 case FORM_BLOCK2: /* Next 2 byte field is a block length */ 3865 nbytes = 2; 3866 break; 3867 case FORM_DATA4: /* Next 4 byte field is the data itself */ 3868 case FORM_BLOCK4: /* Next 4 byte field is a block length */ 3869 case FORM_REF: /* Next 4 byte field is a DIE offset */ 3870 nbytes = 4; 3871 break; 3872 case FORM_DATA8: /* Next 8 byte field is the data itself */ 3873 nbytes = 8; 3874 break; 3875 case FORM_ADDR: /* Next field size is target sizeof(void *) */ 3876 nbytes = TARGET_FT_POINTER_SIZE (objfile); 3877 break; 3878 default: 3879 complain (&unknown_attribute_form, DIE_ID, DIE_NAME, form); 3880 nbytes = -1; 3881 break; 3882 } 3883 return (nbytes); 3884 } 3885