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