1/* DWARF 2 debugging format support for GDB. 2 Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 3 2004 4 Free Software Foundation, Inc. 5 6 Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology, 7 Inc. with support from Florida State University (under contract 8 with the Ada Joint Program Office), and Silicon Graphics, Inc. 9 Initial contribution by Brent Benson, Harris Computer Systems, Inc., 10 based on Fred Fish's (Cygnus Support) implementation of DWARF 1 11 support in dwarfread.c 12 13 This file is part of GDB. 14 15 This program is free software; you can redistribute it and/or modify 16 it under the terms of the GNU General Public License as published by 17 the Free Software Foundation; either version 2 of the License, or (at 18 your option) any later version. 19 20 This program is distributed in the hope that it will be useful, but 21 WITHOUT ANY WARRANTY; without even the implied warranty of 22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 23 General Public License for more details. 24 25 You should have received a copy of the GNU General Public License 26 along with this program; if not, write to the Free Software 27 Foundation, Inc., 59 Temple Place - Suite 330, 28 Boston, MA 02111-1307, USA. */ 29 30#include "defs.h" 31#include "bfd.h" 32#include "symtab.h" 33#include "gdbtypes.h" 34#include "objfiles.h" 35#include "elf/dwarf2.h" 36#include "buildsym.h" 37#include "demangle.h" 38#include "expression.h" 39#include "filenames.h" /* for DOSish file names */ 40#include "macrotab.h" 41#include "language.h" 42#include "complaints.h" 43#include "bcache.h" 44#include "dwarf2expr.h" 45#include "dwarf2loc.h" 46#include "cp-support.h" 47#include "hashtab.h" 48#include "command.h" 49#include "gdbcmd.h" 50 51#include <fcntl.h> 52#include "gdb_string.h" 53#include "gdb_assert.h" 54#include <sys/types.h> 55 56/* A note on memory usage for this file. 57 58 At the present time, this code reads the debug info sections into 59 the objfile's objfile_obstack. A definite improvement for startup 60 time, on platforms which do not emit relocations for debug 61 sections, would be to use mmap instead. The object's complete 62 debug information is loaded into memory, partly to simplify 63 absolute DIE references. 64 65 Whether using obstacks or mmap, the sections should remain loaded 66 until the objfile is released, and pointers into the section data 67 can be used for any other data associated to the objfile (symbol 68 names, type names, location expressions to name a few). */ 69 70#ifndef DWARF2_REG_TO_REGNUM 71#define DWARF2_REG_TO_REGNUM(REG) (REG) 72#endif 73 74#if 0 75/* .debug_info header for a compilation unit 76 Because of alignment constraints, this structure has padding and cannot 77 be mapped directly onto the beginning of the .debug_info section. */ 78typedef struct comp_unit_header 79 { 80 unsigned int length; /* length of the .debug_info 81 contribution */ 82 unsigned short version; /* version number -- 2 for DWARF 83 version 2 */ 84 unsigned int abbrev_offset; /* offset into .debug_abbrev section */ 85 unsigned char addr_size; /* byte size of an address -- 4 */ 86 } 87_COMP_UNIT_HEADER; 88#define _ACTUAL_COMP_UNIT_HEADER_SIZE 11 89#endif 90 91/* .debug_pubnames header 92 Because of alignment constraints, this structure has padding and cannot 93 be mapped directly onto the beginning of the .debug_info section. */ 94typedef struct pubnames_header 95 { 96 unsigned int length; /* length of the .debug_pubnames 97 contribution */ 98 unsigned char version; /* version number -- 2 for DWARF 99 version 2 */ 100 unsigned int info_offset; /* offset into .debug_info section */ 101 unsigned int info_size; /* byte size of .debug_info section 102 portion */ 103 } 104_PUBNAMES_HEADER; 105#define _ACTUAL_PUBNAMES_HEADER_SIZE 13 106 107/* .debug_pubnames header 108 Because of alignment constraints, this structure has padding and cannot 109 be mapped directly onto the beginning of the .debug_info section. */ 110typedef struct aranges_header 111 { 112 unsigned int length; /* byte len of the .debug_aranges 113 contribution */ 114 unsigned short version; /* version number -- 2 for DWARF 115 version 2 */ 116 unsigned int info_offset; /* offset into .debug_info section */ 117 unsigned char addr_size; /* byte size of an address */ 118 unsigned char seg_size; /* byte size of segment descriptor */ 119 } 120_ARANGES_HEADER; 121#define _ACTUAL_ARANGES_HEADER_SIZE 12 122 123/* .debug_line statement program prologue 124 Because of alignment constraints, this structure has padding and cannot 125 be mapped directly onto the beginning of the .debug_info section. */ 126typedef struct statement_prologue 127 { 128 unsigned int total_length; /* byte length of the statement 129 information */ 130 unsigned short version; /* version number -- 2 for DWARF 131 version 2 */ 132 unsigned int prologue_length; /* # bytes between prologue & 133 stmt program */ 134 unsigned char minimum_instruction_length; /* byte size of 135 smallest instr */ 136 unsigned char default_is_stmt; /* initial value of is_stmt 137 register */ 138 char line_base; 139 unsigned char line_range; 140 unsigned char opcode_base; /* number assigned to first special 141 opcode */ 142 unsigned char *standard_opcode_lengths; 143 } 144_STATEMENT_PROLOGUE; 145 146static const struct objfile_data *dwarf2_objfile_data_key; 147 148struct dwarf2_per_objfile 149{ 150 /* Sizes of debugging sections. */ 151 unsigned int info_size; 152 unsigned int abbrev_size; 153 unsigned int line_size; 154 unsigned int pubnames_size; 155 unsigned int aranges_size; 156 unsigned int loc_size; 157 unsigned int macinfo_size; 158 unsigned int str_size; 159 unsigned int ranges_size; 160 unsigned int frame_size; 161 unsigned int eh_frame_size; 162 163 /* Loaded data from the sections. */ 164 char *info_buffer; 165 char *abbrev_buffer; 166 char *line_buffer; 167 char *str_buffer; 168 char *macinfo_buffer; 169 char *ranges_buffer; 170 char *loc_buffer; 171 172 /* A list of all the compilation units. This is used to locate 173 the target compilation unit of a particular reference. */ 174 struct dwarf2_per_cu_data **all_comp_units; 175 176 /* The number of compilation units in ALL_COMP_UNITS. */ 177 int n_comp_units; 178 179 /* A chain of compilation units that are currently read in, so that 180 they can be freed later. */ 181 struct dwarf2_per_cu_data *read_in_chain; 182}; 183 184static struct dwarf2_per_objfile *dwarf2_per_objfile; 185 186static asection *dwarf_info_section; 187static asection *dwarf_abbrev_section; 188static asection *dwarf_line_section; 189static asection *dwarf_pubnames_section; 190static asection *dwarf_aranges_section; 191static asection *dwarf_loc_section; 192static asection *dwarf_macinfo_section; 193static asection *dwarf_str_section; 194static asection *dwarf_ranges_section; 195asection *dwarf_frame_section; 196asection *dwarf_eh_frame_section; 197 198/* names of the debugging sections */ 199 200#define INFO_SECTION ".debug_info" 201#define ABBREV_SECTION ".debug_abbrev" 202#define LINE_SECTION ".debug_line" 203#define PUBNAMES_SECTION ".debug_pubnames" 204#define ARANGES_SECTION ".debug_aranges" 205#define LOC_SECTION ".debug_loc" 206#define MACINFO_SECTION ".debug_macinfo" 207#define STR_SECTION ".debug_str" 208#define RANGES_SECTION ".debug_ranges" 209#define FRAME_SECTION ".debug_frame" 210#define EH_FRAME_SECTION ".eh_frame" 211 212/* local data types */ 213 214/* We hold several abbreviation tables in memory at the same time. */ 215#ifndef ABBREV_HASH_SIZE 216#define ABBREV_HASH_SIZE 121 217#endif 218 219/* The data in a compilation unit header, after target2host 220 translation, looks like this. */ 221struct comp_unit_head 222 { 223 unsigned long length; 224 short version; 225 unsigned int abbrev_offset; 226 unsigned char addr_size; 227 unsigned char signed_addr_p; 228 unsigned int offset_size; /* size of file offsets; either 4 or 8 */ 229 unsigned int initial_length_size; /* size of the length field; either 230 4 or 12 */ 231 232 /* Offset to the first byte of this compilation unit header in the 233 * .debug_info section, for resolving relative reference dies. */ 234 235 unsigned int offset; 236 237 /* Pointer to this compilation unit header in the .debug_info 238 * section */ 239 240 char *cu_head_ptr; 241 242 /* Pointer to the first die of this compilatio unit. This will 243 * be the first byte following the compilation unit header. */ 244 245 char *first_die_ptr; 246 247 /* Pointer to the next compilation unit header in the program. */ 248 249 struct comp_unit_head *next; 250 251 /* Base address of this compilation unit. */ 252 253 CORE_ADDR base_address; 254 255 /* Non-zero if base_address has been set. */ 256 257 int base_known; 258 }; 259 260/* Fixed size for the DIE hash table. */ 261#ifndef REF_HASH_SIZE 262#define REF_HASH_SIZE 1021 263#endif 264 265/* Internal state when decoding a particular compilation unit. */ 266struct dwarf2_cu 267{ 268 /* The objfile containing this compilation unit. */ 269 struct objfile *objfile; 270 271 /* The header of the compilation unit. 272 273 FIXME drow/2003-11-10: Some of the things from the comp_unit_head 274 should logically be moved to the dwarf2_cu structure. */ 275 struct comp_unit_head header; 276 277 struct function_range *first_fn, *last_fn, *cached_fn; 278 279 /* The language we are debugging. */ 280 enum language language; 281 const struct language_defn *language_defn; 282 283 const char *producer; 284 285 /* The generic symbol table building routines have separate lists for 286 file scope symbols and all all other scopes (local scopes). So 287 we need to select the right one to pass to add_symbol_to_list(). 288 We do it by keeping a pointer to the correct list in list_in_scope. 289 290 FIXME: The original dwarf code just treated the file scope as the 291 first local scope, and all other local scopes as nested local 292 scopes, and worked fine. Check to see if we really need to 293 distinguish these in buildsym.c. */ 294 struct pending **list_in_scope; 295 296 /* Maintain an array of referenced fundamental types for the current 297 compilation unit being read. For DWARF version 1, we have to construct 298 the fundamental types on the fly, since no information about the 299 fundamental types is supplied. Each such fundamental type is created by 300 calling a language dependent routine to create the type, and then a 301 pointer to that type is then placed in the array at the index specified 302 by it's FT_<TYPENAME> value. The array has a fixed size set by the 303 FT_NUM_MEMBERS compile time constant, which is the number of predefined 304 fundamental types gdb knows how to construct. */ 305 struct type *ftypes[FT_NUM_MEMBERS]; /* Fundamental types */ 306 307 /* DWARF abbreviation table associated with this compilation unit. */ 308 struct abbrev_info **dwarf2_abbrevs; 309 310 /* Storage for the abbrev table. */ 311 struct obstack abbrev_obstack; 312 313 /* Hash table holding all the loaded partial DIEs. */ 314 htab_t partial_dies; 315 316 /* Storage for things with the same lifetime as this read-in compilation 317 unit, including partial DIEs. */ 318 struct obstack comp_unit_obstack; 319 320 /* When multiple dwarf2_cu structures are living in memory, this field 321 chains them all together, so that they can be released efficiently. 322 We will probably also want a generation counter so that most-recently-used 323 compilation units are cached... */ 324 struct dwarf2_per_cu_data *read_in_chain; 325 326 /* Backchain to our per_cu entry if the tree has been built. */ 327 struct dwarf2_per_cu_data *per_cu; 328 329 /* How many compilation units ago was this CU last referenced? */ 330 int last_used; 331 332 /* A hash table of die offsets for following references. */ 333 struct die_info *die_ref_table[REF_HASH_SIZE]; 334 335 /* Full DIEs if read in. */ 336 struct die_info *dies; 337 338 /* A set of pointers to dwarf2_per_cu_data objects for compilation 339 units referenced by this one. Only set during full symbol processing; 340 partial symbol tables do not have dependencies. */ 341 htab_t dependencies; 342 343 /* Mark used when releasing cached dies. */ 344 unsigned int mark : 1; 345 346 /* This flag will be set if this compilation unit might include 347 inter-compilation-unit references. */ 348 unsigned int has_form_ref_addr : 1; 349 350 /* This flag will be set if this compilation unit includes any 351 DW_TAG_namespace DIEs. If we know that there are explicit 352 DIEs for namespaces, we don't need to try to infer them 353 from mangled names. */ 354 unsigned int has_namespace_info : 1; 355}; 356 357/* Persistent data held for a compilation unit, even when not 358 processing it. We put a pointer to this structure in the 359 read_symtab_private field of the psymtab. If we encounter 360 inter-compilation-unit references, we also maintain a sorted 361 list of all compilation units. */ 362 363struct dwarf2_per_cu_data 364{ 365 /* The start offset and length of this compilation unit. 2**31-1 366 bytes should suffice to store the length of any compilation unit 367 - if it doesn't, GDB will fall over anyway. */ 368 unsigned long offset; 369 unsigned long length : 31; 370 371 /* Flag indicating this compilation unit will be read in before 372 any of the current compilation units are processed. */ 373 unsigned long queued : 1; 374 375 /* Set iff currently read in. */ 376 struct dwarf2_cu *cu; 377 378 /* If full symbols for this CU have been read in, then this field 379 holds a map of DIE offsets to types. It isn't always possible 380 to reconstruct this information later, so we have to preserve 381 it. */ 382 htab_t type_hash; 383 384 /* The partial symbol table associated with this compilation unit. */ 385 struct partial_symtab *psymtab; 386}; 387 388/* The line number information for a compilation unit (found in the 389 .debug_line section) begins with a "statement program header", 390 which contains the following information. */ 391struct line_header 392{ 393 unsigned int total_length; 394 unsigned short version; 395 unsigned int header_length; 396 unsigned char minimum_instruction_length; 397 unsigned char default_is_stmt; 398 int line_base; 399 unsigned char line_range; 400 unsigned char opcode_base; 401 402 /* standard_opcode_lengths[i] is the number of operands for the 403 standard opcode whose value is i. This means that 404 standard_opcode_lengths[0] is unused, and the last meaningful 405 element is standard_opcode_lengths[opcode_base - 1]. */ 406 unsigned char *standard_opcode_lengths; 407 408 /* The include_directories table. NOTE! These strings are not 409 allocated with xmalloc; instead, they are pointers into 410 debug_line_buffer. If you try to free them, `free' will get 411 indigestion. */ 412 unsigned int num_include_dirs, include_dirs_size; 413 char **include_dirs; 414 415 /* The file_names table. NOTE! These strings are not allocated 416 with xmalloc; instead, they are pointers into debug_line_buffer. 417 Don't try to free them directly. */ 418 unsigned int num_file_names, file_names_size; 419 struct file_entry 420 { 421 char *name; 422 unsigned int dir_index; 423 unsigned int mod_time; 424 unsigned int length; 425 int included_p; /* Non-zero if referenced by the Line Number Program. */ 426 } *file_names; 427 428 /* The start and end of the statement program following this 429 header. These point into dwarf2_per_objfile->line_buffer. */ 430 char *statement_program_start, *statement_program_end; 431}; 432 433/* When we construct a partial symbol table entry we only 434 need this much information. */ 435struct partial_die_info 436 { 437 /* Offset of this DIE. */ 438 unsigned int offset; 439 440 /* DWARF-2 tag for this DIE. */ 441 ENUM_BITFIELD(dwarf_tag) tag : 16; 442 443 /* Language code associated with this DIE. This is only used 444 for the compilation unit DIE. */ 445 unsigned int language : 8; 446 447 /* Assorted flags describing the data found in this DIE. */ 448 unsigned int has_children : 1; 449 unsigned int is_external : 1; 450 unsigned int is_declaration : 1; 451 unsigned int has_type : 1; 452 unsigned int has_specification : 1; 453 unsigned int has_stmt_list : 1; 454 unsigned int has_pc_info : 1; 455 456 /* Flag set if the SCOPE field of this structure has been 457 computed. */ 458 unsigned int scope_set : 1; 459 460 /* The name of this DIE. Normally the value of DW_AT_name, but 461 sometimes DW_TAG_MIPS_linkage_name or a string computed in some 462 other fashion. */ 463 char *name; 464 char *dirname; 465 466 /* The scope to prepend to our children. This is generally 467 allocated on the comp_unit_obstack, so will disappear 468 when this compilation unit leaves the cache. */ 469 char *scope; 470 471 /* The location description associated with this DIE, if any. */ 472 struct dwarf_block *locdesc; 473 474 /* If HAS_PC_INFO, the PC range associated with this DIE. */ 475 CORE_ADDR lowpc; 476 CORE_ADDR highpc; 477 478 /* Pointer into the info_buffer pointing at the target of 479 DW_AT_sibling, if any. */ 480 char *sibling; 481 482 /* If HAS_SPECIFICATION, the offset of the DIE referred to by 483 DW_AT_specification (or DW_AT_abstract_origin or 484 DW_AT_extension). */ 485 unsigned int spec_offset; 486 487 /* If HAS_STMT_LIST, the offset of the Line Number Information data. */ 488 unsigned int line_offset; 489 490 /* Pointers to this DIE's parent, first child, and next sibling, 491 if any. */ 492 struct partial_die_info *die_parent, *die_child, *die_sibling; 493 }; 494 495/* This data structure holds the information of an abbrev. */ 496struct abbrev_info 497 { 498 unsigned int number; /* number identifying abbrev */ 499 enum dwarf_tag tag; /* dwarf tag */ 500 unsigned short has_children; /* boolean */ 501 unsigned short num_attrs; /* number of attributes */ 502 struct attr_abbrev *attrs; /* an array of attribute descriptions */ 503 struct abbrev_info *next; /* next in chain */ 504 }; 505 506struct attr_abbrev 507 { 508 enum dwarf_attribute name; 509 enum dwarf_form form; 510 }; 511 512/* This data structure holds a complete die structure. */ 513struct die_info 514 { 515 enum dwarf_tag tag; /* Tag indicating type of die */ 516 unsigned int abbrev; /* Abbrev number */ 517 unsigned int offset; /* Offset in .debug_info section */ 518 unsigned int num_attrs; /* Number of attributes */ 519 struct attribute *attrs; /* An array of attributes */ 520 struct die_info *next_ref; /* Next die in ref hash table */ 521 522 /* The dies in a compilation unit form an n-ary tree. PARENT 523 points to this die's parent; CHILD points to the first child of 524 this node; and all the children of a given node are chained 525 together via their SIBLING fields, terminated by a die whose 526 tag is zero. */ 527 struct die_info *child; /* Its first child, if any. */ 528 struct die_info *sibling; /* Its next sibling, if any. */ 529 struct die_info *parent; /* Its parent, if any. */ 530 531 struct type *type; /* Cached type information */ 532 }; 533 534/* Attributes have a name and a value */ 535struct attribute 536 { 537 enum dwarf_attribute name; 538 enum dwarf_form form; 539 union 540 { 541 char *str; 542 struct dwarf_block *blk; 543 unsigned long unsnd; 544 long int snd; 545 CORE_ADDR addr; 546 } 547 u; 548 }; 549 550struct function_range 551{ 552 const char *name; 553 CORE_ADDR lowpc, highpc; 554 int seen_line; 555 struct function_range *next; 556}; 557 558/* Get at parts of an attribute structure */ 559 560#define DW_STRING(attr) ((attr)->u.str) 561#define DW_UNSND(attr) ((attr)->u.unsnd) 562#define DW_BLOCK(attr) ((attr)->u.blk) 563#define DW_SND(attr) ((attr)->u.snd) 564#define DW_ADDR(attr) ((attr)->u.addr) 565 566/* Blocks are a bunch of untyped bytes. */ 567struct dwarf_block 568 { 569 unsigned int size; 570 char *data; 571 }; 572 573#ifndef ATTR_ALLOC_CHUNK 574#define ATTR_ALLOC_CHUNK 4 575#endif 576 577/* Allocate fields for structs, unions and enums in this size. */ 578#ifndef DW_FIELD_ALLOC_CHUNK 579#define DW_FIELD_ALLOC_CHUNK 4 580#endif 581 582/* A zeroed version of a partial die for initialization purposes. */ 583static struct partial_die_info zeroed_partial_die; 584 585/* FIXME: decode_locdesc sets these variables to describe the location 586 to the caller. These ought to be a structure or something. If 587 none of the flags are set, the object lives at the address returned 588 by decode_locdesc. */ 589 590static int isreg; /* Object lives in register. 591 decode_locdesc's return value is 592 the register number. */ 593 594/* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte, 595 but this would require a corresponding change in unpack_field_as_long 596 and friends. */ 597static int bits_per_byte = 8; 598 599/* The routines that read and process dies for a C struct or C++ class 600 pass lists of data member fields and lists of member function fields 601 in an instance of a field_info structure, as defined below. */ 602struct field_info 603 { 604 /* List of data member and baseclasses fields. */ 605 struct nextfield 606 { 607 struct nextfield *next; 608 int accessibility; 609 int virtuality; 610 struct field field; 611 } 612 *fields; 613 614 /* Number of fields. */ 615 int nfields; 616 617 /* Number of baseclasses. */ 618 int nbaseclasses; 619 620 /* Set if the accesibility of one of the fields is not public. */ 621 int non_public_fields; 622 623 /* Member function fields array, entries are allocated in the order they 624 are encountered in the object file. */ 625 struct nextfnfield 626 { 627 struct nextfnfield *next; 628 struct fn_field fnfield; 629 } 630 *fnfields; 631 632 /* Member function fieldlist array, contains name of possibly overloaded 633 member function, number of overloaded member functions and a pointer 634 to the head of the member function field chain. */ 635 struct fnfieldlist 636 { 637 char *name; 638 int length; 639 struct nextfnfield *head; 640 } 641 *fnfieldlists; 642 643 /* Number of entries in the fnfieldlists array. */ 644 int nfnfields; 645 }; 646 647/* One item on the queue of compilation units to read in full symbols 648 for. */ 649struct dwarf2_queue_item 650{ 651 struct dwarf2_per_cu_data *per_cu; 652 struct dwarf2_queue_item *next; 653}; 654 655/* The current queue. */ 656static struct dwarf2_queue_item *dwarf2_queue, *dwarf2_queue_tail; 657 658/* Loaded secondary compilation units are kept in memory until they 659 have not been referenced for the processing of this many 660 compilation units. Set this to zero to disable caching. Cache 661 sizes of up to at least twenty will improve startup time for 662 typical inter-CU-reference binaries, at an obvious memory cost. */ 663static int dwarf2_max_cache_age = 5; 664 665/* Various complaints about symbol reading that don't abort the process */ 666 667static void 668dwarf2_statement_list_fits_in_line_number_section_complaint (void) 669{ 670 complaint (&symfile_complaints, 671 "statement list doesn't fit in .debug_line section"); 672} 673 674static void 675dwarf2_complex_location_expr_complaint (void) 676{ 677 complaint (&symfile_complaints, "location expression too complex"); 678} 679 680static void 681dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2, 682 int arg3) 683{ 684 complaint (&symfile_complaints, 685 "const value length mismatch for '%s', got %d, expected %d", arg1, 686 arg2, arg3); 687} 688 689static void 690dwarf2_macros_too_long_complaint (void) 691{ 692 complaint (&symfile_complaints, 693 "macro info runs off end of `.debug_macinfo' section"); 694} 695 696static void 697dwarf2_macro_malformed_definition_complaint (const char *arg1) 698{ 699 complaint (&symfile_complaints, 700 "macro debug info contains a malformed macro definition:\n`%s'", 701 arg1); 702} 703 704static void 705dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2) 706{ 707 complaint (&symfile_complaints, 708 "invalid attribute class or form for '%s' in '%s'", arg1, arg2); 709} 710 711/* local function prototypes */ 712 713static void dwarf2_locate_sections (bfd *, asection *, void *); 714 715#if 0 716static void dwarf2_build_psymtabs_easy (struct objfile *, int); 717#endif 718 719static void dwarf2_create_include_psymtab (char *, struct partial_symtab *, 720 struct objfile *); 721 722static void dwarf2_build_include_psymtabs (struct dwarf2_cu *, 723 struct partial_die_info *, 724 struct partial_symtab *); 725 726static void dwarf2_build_psymtabs_hard (struct objfile *, int); 727 728static void scan_partial_symbols (struct partial_die_info *, 729 CORE_ADDR *, CORE_ADDR *, 730 struct dwarf2_cu *); 731 732static void add_partial_symbol (struct partial_die_info *, 733 struct dwarf2_cu *); 734 735static int pdi_needs_namespace (enum dwarf_tag tag); 736 737static void add_partial_namespace (struct partial_die_info *pdi, 738 CORE_ADDR *lowpc, CORE_ADDR *highpc, 739 struct dwarf2_cu *cu); 740 741static void add_partial_enumeration (struct partial_die_info *enum_pdi, 742 struct dwarf2_cu *cu); 743 744static char *locate_pdi_sibling (struct partial_die_info *orig_pdi, 745 char *info_ptr, 746 bfd *abfd, 747 struct dwarf2_cu *cu); 748 749static void dwarf2_psymtab_to_symtab (struct partial_symtab *); 750 751static void psymtab_to_symtab_1 (struct partial_symtab *); 752 753char *dwarf2_read_section (struct objfile *, asection *); 754 755static void dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu); 756 757static void dwarf2_free_abbrev_table (void *); 758 759static struct abbrev_info *peek_die_abbrev (char *, int *, struct dwarf2_cu *); 760 761static struct abbrev_info *dwarf2_lookup_abbrev (unsigned int, 762 struct dwarf2_cu *); 763 764static struct partial_die_info *load_partial_dies (bfd *, char *, int, 765 struct dwarf2_cu *); 766 767static char *read_partial_die (struct partial_die_info *, 768 struct abbrev_info *abbrev, unsigned int, 769 bfd *, char *, struct dwarf2_cu *); 770 771static struct partial_die_info *find_partial_die (unsigned long, 772 struct dwarf2_cu *); 773 774static void fixup_partial_die (struct partial_die_info *, 775 struct dwarf2_cu *); 776 777static char *read_full_die (struct die_info **, bfd *, char *, 778 struct dwarf2_cu *, int *); 779 780static char *read_attribute (struct attribute *, struct attr_abbrev *, 781 bfd *, char *, struct dwarf2_cu *); 782 783static char *read_attribute_value (struct attribute *, unsigned, 784 bfd *, char *, struct dwarf2_cu *); 785 786static unsigned int read_1_byte (bfd *, char *); 787 788static int read_1_signed_byte (bfd *, char *); 789 790static unsigned int read_2_bytes (bfd *, char *); 791 792static unsigned int read_4_bytes (bfd *, char *); 793 794static unsigned long read_8_bytes (bfd *, char *); 795 796static CORE_ADDR read_address (bfd *, char *ptr, struct dwarf2_cu *, 797 int *bytes_read); 798 799static LONGEST read_initial_length (bfd *, char *, 800 struct comp_unit_head *, int *bytes_read); 801 802static LONGEST read_offset (bfd *, char *, const struct comp_unit_head *, 803 int *bytes_read); 804 805static char *read_n_bytes (bfd *, char *, unsigned int); 806 807static char *read_string (bfd *, char *, unsigned int *); 808 809static char *read_indirect_string (bfd *, char *, const struct comp_unit_head *, 810 unsigned int *); 811 812static unsigned long read_unsigned_leb128 (bfd *, char *, unsigned int *); 813 814static long read_signed_leb128 (bfd *, char *, unsigned int *); 815 816static char *skip_leb128 (bfd *, char *); 817 818static void set_cu_language (unsigned int, struct dwarf2_cu *); 819 820static struct attribute *dwarf2_attr (struct die_info *, unsigned int, 821 struct dwarf2_cu *); 822 823static int dwarf2_flag_true_p (struct die_info *die, unsigned name, 824 struct dwarf2_cu *cu); 825 826static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu); 827 828static struct die_info *die_specification (struct die_info *die, 829 struct dwarf2_cu *); 830 831static void free_line_header (struct line_header *lh); 832 833static void add_file_name (struct line_header *, char *, unsigned int, 834 unsigned int, unsigned int); 835 836static struct line_header *(dwarf_decode_line_header 837 (unsigned int offset, 838 bfd *abfd, struct dwarf2_cu *cu)); 839 840static void dwarf_decode_lines (struct line_header *, char *, bfd *, 841 struct dwarf2_cu *, struct partial_symtab *); 842 843static void dwarf2_start_subfile (char *, char *); 844 845static struct symbol *new_symbol (struct die_info *, struct type *, 846 struct dwarf2_cu *); 847 848static void dwarf2_const_value (struct attribute *, struct symbol *, 849 struct dwarf2_cu *); 850 851static void dwarf2_const_value_data (struct attribute *attr, 852 struct symbol *sym, 853 int bits); 854 855static struct type *die_type (struct die_info *, struct dwarf2_cu *); 856 857static struct type *die_containing_type (struct die_info *, 858 struct dwarf2_cu *); 859 860static struct type *tag_type_to_type (struct die_info *, struct dwarf2_cu *); 861 862static void read_type_die (struct die_info *, struct dwarf2_cu *); 863 864static char *determine_prefix (struct die_info *die, struct dwarf2_cu *); 865 866static char *typename_concat (struct obstack *, const char *prefix, const char *suffix, 867 struct dwarf2_cu *); 868 869static void read_typedef (struct die_info *, struct dwarf2_cu *); 870 871static void read_base_type (struct die_info *, struct dwarf2_cu *); 872 873static void read_subrange_type (struct die_info *die, struct dwarf2_cu *cu); 874 875static void read_file_scope (struct die_info *, struct dwarf2_cu *); 876 877static void read_func_scope (struct die_info *, struct dwarf2_cu *); 878 879static void read_lexical_block_scope (struct die_info *, struct dwarf2_cu *); 880 881static int dwarf2_get_pc_bounds (struct die_info *, 882 CORE_ADDR *, CORE_ADDR *, struct dwarf2_cu *); 883 884static void get_scope_pc_bounds (struct die_info *, 885 CORE_ADDR *, CORE_ADDR *, 886 struct dwarf2_cu *); 887 888static void dwarf2_add_field (struct field_info *, struct die_info *, 889 struct dwarf2_cu *); 890 891static void dwarf2_attach_fields_to_type (struct field_info *, 892 struct type *, struct dwarf2_cu *); 893 894static void dwarf2_add_member_fn (struct field_info *, 895 struct die_info *, struct type *, 896 struct dwarf2_cu *); 897 898static void dwarf2_attach_fn_fields_to_type (struct field_info *, 899 struct type *, struct dwarf2_cu *); 900 901static void read_structure_type (struct die_info *, struct dwarf2_cu *); 902 903static void process_structure_scope (struct die_info *, struct dwarf2_cu *); 904 905static char *determine_class_name (struct die_info *die, struct dwarf2_cu *cu); 906 907static void read_common_block (struct die_info *, struct dwarf2_cu *); 908 909static void read_namespace (struct die_info *die, struct dwarf2_cu *); 910 911static const char *namespace_name (struct die_info *die, 912 int *is_anonymous, struct dwarf2_cu *); 913 914static void read_enumeration_type (struct die_info *, struct dwarf2_cu *); 915 916static void process_enumeration_scope (struct die_info *, struct dwarf2_cu *); 917 918static struct type *dwarf_base_type (int, int, struct dwarf2_cu *); 919 920static CORE_ADDR decode_locdesc (struct dwarf_block *, struct dwarf2_cu *); 921 922static void read_array_type (struct die_info *, struct dwarf2_cu *); 923 924static enum dwarf_array_dim_ordering read_array_order (struct die_info *, 925 struct dwarf2_cu *); 926 927static void read_tag_pointer_type (struct die_info *, struct dwarf2_cu *); 928 929static void read_tag_ptr_to_member_type (struct die_info *, 930 struct dwarf2_cu *); 931 932static void read_tag_reference_type (struct die_info *, struct dwarf2_cu *); 933 934static void read_tag_const_type (struct die_info *, struct dwarf2_cu *); 935 936static void read_tag_volatile_type (struct die_info *, struct dwarf2_cu *); 937 938static void read_tag_string_type (struct die_info *, struct dwarf2_cu *); 939 940static void read_subroutine_type (struct die_info *, struct dwarf2_cu *); 941 942static struct die_info *read_comp_unit (char *, bfd *, struct dwarf2_cu *); 943 944static struct die_info *read_die_and_children (char *info_ptr, bfd *abfd, 945 struct dwarf2_cu *, 946 char **new_info_ptr, 947 struct die_info *parent); 948 949static struct die_info *read_die_and_siblings (char *info_ptr, bfd *abfd, 950 struct dwarf2_cu *, 951 char **new_info_ptr, 952 struct die_info *parent); 953 954static void free_die_list (struct die_info *); 955 956static void process_die (struct die_info *, struct dwarf2_cu *); 957 958static char *dwarf2_linkage_name (struct die_info *, struct dwarf2_cu *); 959 960static char *dwarf2_name (struct die_info *die, struct dwarf2_cu *); 961 962static struct die_info *dwarf2_extension (struct die_info *die, 963 struct dwarf2_cu *); 964 965static char *dwarf_tag_name (unsigned int); 966 967static char *dwarf_attr_name (unsigned int); 968 969static char *dwarf_form_name (unsigned int); 970 971static char *dwarf_stack_op_name (unsigned int); 972 973static char *dwarf_bool_name (unsigned int); 974 975static char *dwarf_type_encoding_name (unsigned int); 976 977#if 0 978static char *dwarf_cfi_name (unsigned int); 979 980struct die_info *copy_die (struct die_info *); 981#endif 982 983static struct die_info *sibling_die (struct die_info *); 984 985static void dump_die (struct die_info *); 986 987static void dump_die_list (struct die_info *); 988 989static void store_in_ref_table (unsigned int, struct die_info *, 990 struct dwarf2_cu *); 991 992static unsigned int dwarf2_get_ref_die_offset (struct attribute *, 993 struct dwarf2_cu *); 994 995static int dwarf2_get_attr_constant_value (struct attribute *, int); 996 997static struct die_info *follow_die_ref (struct die_info *, 998 struct attribute *, 999 struct dwarf2_cu *); 1000 1001static struct type *dwarf2_fundamental_type (struct objfile *, int, 1002 struct dwarf2_cu *); 1003 1004/* memory allocation interface */ 1005 1006static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *); 1007 1008static struct abbrev_info *dwarf_alloc_abbrev (struct dwarf2_cu *); 1009 1010static struct die_info *dwarf_alloc_die (void); 1011 1012static void initialize_cu_func_list (struct dwarf2_cu *); 1013 1014static void add_to_cu_func_list (const char *, CORE_ADDR, CORE_ADDR, 1015 struct dwarf2_cu *); 1016 1017static void dwarf_decode_macros (struct line_header *, unsigned int, 1018 char *, bfd *, struct dwarf2_cu *); 1019 1020static int attr_form_is_block (struct attribute *); 1021 1022static void 1023dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym, 1024 struct dwarf2_cu *cu); 1025 1026static char *skip_one_die (char *info_ptr, struct abbrev_info *abbrev, 1027 struct dwarf2_cu *cu); 1028 1029static void free_stack_comp_unit (void *); 1030 1031static void *hashtab_obstack_allocate (void *data, size_t size, size_t count); 1032 1033static void dummy_obstack_deallocate (void *object, void *data); 1034 1035static hashval_t partial_die_hash (const void *item); 1036 1037static int partial_die_eq (const void *item_lhs, const void *item_rhs); 1038 1039static struct dwarf2_per_cu_data *dwarf2_find_containing_comp_unit 1040 (unsigned long offset, struct objfile *objfile); 1041 1042static struct dwarf2_per_cu_data *dwarf2_find_comp_unit 1043 (unsigned long offset, struct objfile *objfile); 1044 1045static void free_one_comp_unit (void *); 1046 1047static void free_cached_comp_units (void *); 1048 1049static void age_cached_comp_units (void); 1050 1051static void free_one_cached_comp_unit (void *); 1052 1053static void set_die_type (struct die_info *, struct type *, 1054 struct dwarf2_cu *); 1055 1056static void reset_die_and_siblings_types (struct die_info *, 1057 struct dwarf2_cu *); 1058 1059static void create_all_comp_units (struct objfile *); 1060 1061static struct dwarf2_cu *load_full_comp_unit (struct dwarf2_per_cu_data *); 1062 1063static void process_full_comp_unit (struct dwarf2_per_cu_data *); 1064 1065static void dwarf2_add_dependence (struct dwarf2_cu *, 1066 struct dwarf2_per_cu_data *); 1067 1068static void dwarf2_mark (struct dwarf2_cu *); 1069 1070static void dwarf2_clear_marks (struct dwarf2_per_cu_data *); 1071 1072/* Try to locate the sections we need for DWARF 2 debugging 1073 information and return true if we have enough to do something. */ 1074 1075int 1076dwarf2_has_info (struct objfile *objfile) 1077{ 1078 struct dwarf2_per_objfile *data; 1079 1080 /* Initialize per-objfile state. */ 1081 data = obstack_alloc (&objfile->objfile_obstack, sizeof (*data)); 1082 memset (data, 0, sizeof (*data)); 1083 set_objfile_data (objfile, dwarf2_objfile_data_key, data); 1084 dwarf2_per_objfile = data; 1085 1086 dwarf_info_section = 0; 1087 dwarf_abbrev_section = 0; 1088 dwarf_line_section = 0; 1089 dwarf_str_section = 0; 1090 dwarf_macinfo_section = 0; 1091 dwarf_frame_section = 0; 1092 dwarf_eh_frame_section = 0; 1093 dwarf_ranges_section = 0; 1094 dwarf_loc_section = 0; 1095 1096 bfd_map_over_sections (objfile->obfd, dwarf2_locate_sections, NULL); 1097 return (dwarf_info_section != NULL && dwarf_abbrev_section != NULL); 1098} 1099 1100/* This function is mapped across the sections and remembers the 1101 offset and size of each of the debugging sections we are interested 1102 in. */ 1103 1104static void 1105dwarf2_locate_sections (bfd *ignore_abfd, asection *sectp, void *ignore_ptr) 1106{ 1107 if (strcmp (sectp->name, INFO_SECTION) == 0) 1108 { 1109 dwarf2_per_objfile->info_size = bfd_get_section_size (sectp); 1110 dwarf_info_section = sectp; 1111 } 1112 else if (strcmp (sectp->name, ABBREV_SECTION) == 0) 1113 { 1114 dwarf2_per_objfile->abbrev_size = bfd_get_section_size (sectp); 1115 dwarf_abbrev_section = sectp; 1116 } 1117 else if (strcmp (sectp->name, LINE_SECTION) == 0) 1118 { 1119 dwarf2_per_objfile->line_size = bfd_get_section_size (sectp); 1120 dwarf_line_section = sectp; 1121 } 1122 else if (strcmp (sectp->name, PUBNAMES_SECTION) == 0) 1123 { 1124 dwarf2_per_objfile->pubnames_size = bfd_get_section_size (sectp); 1125 dwarf_pubnames_section = sectp; 1126 } 1127 else if (strcmp (sectp->name, ARANGES_SECTION) == 0) 1128 { 1129 dwarf2_per_objfile->aranges_size = bfd_get_section_size (sectp); 1130 dwarf_aranges_section = sectp; 1131 } 1132 else if (strcmp (sectp->name, LOC_SECTION) == 0) 1133 { 1134 dwarf2_per_objfile->loc_size = bfd_get_section_size (sectp); 1135 dwarf_loc_section = sectp; 1136 } 1137 else if (strcmp (sectp->name, MACINFO_SECTION) == 0) 1138 { 1139 dwarf2_per_objfile->macinfo_size = bfd_get_section_size (sectp); 1140 dwarf_macinfo_section = sectp; 1141 } 1142 else if (strcmp (sectp->name, STR_SECTION) == 0) 1143 { 1144 dwarf2_per_objfile->str_size = bfd_get_section_size (sectp); 1145 dwarf_str_section = sectp; 1146 } 1147 else if (strcmp (sectp->name, FRAME_SECTION) == 0) 1148 { 1149 dwarf2_per_objfile->frame_size = bfd_get_section_size (sectp); 1150 dwarf_frame_section = sectp; 1151 } 1152 else if (strcmp (sectp->name, EH_FRAME_SECTION) == 0) 1153 { 1154 flagword aflag = bfd_get_section_flags (ignore_abfd, sectp); 1155 if (aflag & SEC_HAS_CONTENTS) 1156 { 1157 dwarf2_per_objfile->eh_frame_size = bfd_get_section_size (sectp); 1158 dwarf_eh_frame_section = sectp; 1159 } 1160 } 1161 else if (strcmp (sectp->name, RANGES_SECTION) == 0) 1162 { 1163 dwarf2_per_objfile->ranges_size = bfd_get_section_size (sectp); 1164 dwarf_ranges_section = sectp; 1165 } 1166} 1167 1168/* Build a partial symbol table. */ 1169 1170void 1171dwarf2_build_psymtabs (struct objfile *objfile, int mainline) 1172{ 1173 /* We definitely need the .debug_info and .debug_abbrev sections */ 1174 1175 dwarf2_per_objfile->info_buffer = dwarf2_read_section (objfile, dwarf_info_section); 1176 dwarf2_per_objfile->abbrev_buffer = dwarf2_read_section (objfile, dwarf_abbrev_section); 1177 1178 if (dwarf_line_section) 1179 dwarf2_per_objfile->line_buffer = dwarf2_read_section (objfile, dwarf_line_section); 1180 else 1181 dwarf2_per_objfile->line_buffer = NULL; 1182 1183 if (dwarf_str_section) 1184 dwarf2_per_objfile->str_buffer = dwarf2_read_section (objfile, dwarf_str_section); 1185 else 1186 dwarf2_per_objfile->str_buffer = NULL; 1187 1188 if (dwarf_macinfo_section) 1189 dwarf2_per_objfile->macinfo_buffer = dwarf2_read_section (objfile, 1190 dwarf_macinfo_section); 1191 else 1192 dwarf2_per_objfile->macinfo_buffer = NULL; 1193 1194 if (dwarf_ranges_section) 1195 dwarf2_per_objfile->ranges_buffer = dwarf2_read_section (objfile, dwarf_ranges_section); 1196 else 1197 dwarf2_per_objfile->ranges_buffer = NULL; 1198 1199 if (dwarf_loc_section) 1200 dwarf2_per_objfile->loc_buffer = dwarf2_read_section (objfile, dwarf_loc_section); 1201 else 1202 dwarf2_per_objfile->loc_buffer = NULL; 1203 1204 if (mainline 1205 || (objfile->global_psymbols.size == 0 1206 && objfile->static_psymbols.size == 0)) 1207 { 1208 init_psymbol_list (objfile, 1024); 1209 } 1210 1211#if 0 1212 if (dwarf_aranges_offset && dwarf_pubnames_offset) 1213 { 1214 /* Things are significantly easier if we have .debug_aranges and 1215 .debug_pubnames sections */ 1216 1217 dwarf2_build_psymtabs_easy (objfile, mainline); 1218 } 1219 else 1220#endif 1221 /* only test this case for now */ 1222 { 1223 /* In this case we have to work a bit harder */ 1224 dwarf2_build_psymtabs_hard (objfile, mainline); 1225 } 1226} 1227 1228#if 0 1229/* Build the partial symbol table from the information in the 1230 .debug_pubnames and .debug_aranges sections. */ 1231 1232static void 1233dwarf2_build_psymtabs_easy (struct objfile *objfile, int mainline) 1234{ 1235 bfd *abfd = objfile->obfd; 1236 char *aranges_buffer, *pubnames_buffer; 1237 char *aranges_ptr, *pubnames_ptr; 1238 unsigned int entry_length, version, info_offset, info_size; 1239 1240 pubnames_buffer = dwarf2_read_section (objfile, 1241 dwarf_pubnames_section); 1242 pubnames_ptr = pubnames_buffer; 1243 while ((pubnames_ptr - pubnames_buffer) < dwarf2_per_objfile->pubnames_size) 1244 { 1245 struct comp_unit_head cu_header; 1246 int bytes_read; 1247 1248 entry_length = read_initial_length (abfd, pubnames_ptr, &cu_header, 1249 &bytes_read); 1250 pubnames_ptr += bytes_read; 1251 version = read_1_byte (abfd, pubnames_ptr); 1252 pubnames_ptr += 1; 1253 info_offset = read_4_bytes (abfd, pubnames_ptr); 1254 pubnames_ptr += 4; 1255 info_size = read_4_bytes (abfd, pubnames_ptr); 1256 pubnames_ptr += 4; 1257 } 1258 1259 aranges_buffer = dwarf2_read_section (objfile, 1260 dwarf_aranges_section); 1261 1262} 1263#endif 1264 1265/* Read in the comp unit header information from the debug_info at 1266 info_ptr. */ 1267 1268static char * 1269read_comp_unit_head (struct comp_unit_head *cu_header, 1270 char *info_ptr, bfd *abfd) 1271{ 1272 int signed_addr; 1273 int bytes_read; 1274 cu_header->length = read_initial_length (abfd, info_ptr, cu_header, 1275 &bytes_read); 1276 info_ptr += bytes_read; 1277 cu_header->version = read_2_bytes (abfd, info_ptr); 1278 info_ptr += 2; 1279 cu_header->abbrev_offset = read_offset (abfd, info_ptr, cu_header, 1280 &bytes_read); 1281 info_ptr += bytes_read; 1282 cu_header->addr_size = read_1_byte (abfd, info_ptr); 1283 info_ptr += 1; 1284 signed_addr = bfd_get_sign_extend_vma (abfd); 1285 if (signed_addr < 0) 1286 internal_error (__FILE__, __LINE__, 1287 "read_comp_unit_head: dwarf from non elf file"); 1288 cu_header->signed_addr_p = signed_addr; 1289 return info_ptr; 1290} 1291 1292static char * 1293partial_read_comp_unit_head (struct comp_unit_head *header, char *info_ptr, 1294 bfd *abfd) 1295{ 1296 char *beg_of_comp_unit = info_ptr; 1297 1298 info_ptr = read_comp_unit_head (header, info_ptr, abfd); 1299 1300 if (header->version != 2) 1301 error ("Dwarf Error: wrong version in compilation unit header " 1302 "(is %d, should be %d) [in module %s]", header->version, 1303 2, bfd_get_filename (abfd)); 1304 1305 if (header->abbrev_offset >= dwarf2_per_objfile->abbrev_size) 1306 error ("Dwarf Error: bad offset (0x%lx) in compilation unit header " 1307 "(offset 0x%lx + 6) [in module %s]", 1308 (long) header->abbrev_offset, 1309 (long) (beg_of_comp_unit - dwarf2_per_objfile->info_buffer), 1310 bfd_get_filename (abfd)); 1311 1312 if (beg_of_comp_unit + header->length + header->initial_length_size 1313 > dwarf2_per_objfile->info_buffer + dwarf2_per_objfile->info_size) 1314 error ("Dwarf Error: bad length (0x%lx) in compilation unit header " 1315 "(offset 0x%lx + 0) [in module %s]", 1316 (long) header->length, 1317 (long) (beg_of_comp_unit - dwarf2_per_objfile->info_buffer), 1318 bfd_get_filename (abfd)); 1319 1320 return info_ptr; 1321} 1322 1323/* Allocate a new partial symtab for file named NAME and mark this new 1324 partial symtab as being an include of PST. */ 1325 1326static void 1327dwarf2_create_include_psymtab (char *name, struct partial_symtab *pst, 1328 struct objfile *objfile) 1329{ 1330 struct partial_symtab *subpst = allocate_psymtab (name, objfile); 1331 1332 subpst->section_offsets = pst->section_offsets; 1333 subpst->textlow = 0; 1334 subpst->texthigh = 0; 1335 1336 subpst->dependencies = (struct partial_symtab **) 1337 obstack_alloc (&objfile->objfile_obstack, 1338 sizeof (struct partial_symtab *)); 1339 subpst->dependencies[0] = pst; 1340 subpst->number_of_dependencies = 1; 1341 1342 subpst->globals_offset = 0; 1343 subpst->n_global_syms = 0; 1344 subpst->statics_offset = 0; 1345 subpst->n_static_syms = 0; 1346 subpst->symtab = NULL; 1347 subpst->read_symtab = pst->read_symtab; 1348 subpst->readin = 0; 1349 1350 /* No private part is necessary for include psymtabs. This property 1351 can be used to differentiate between such include psymtabs and 1352 the regular ones. */ 1353 subpst->read_symtab_private = NULL; 1354} 1355 1356/* Read the Line Number Program data and extract the list of files 1357 included by the source file represented by PST. Build an include 1358 partial symtab for each of these included files. 1359 1360 This procedure assumes that there *is* a Line Number Program in 1361 the given CU. Callers should check that PDI->HAS_STMT_LIST is set 1362 before calling this procedure. */ 1363 1364static void 1365dwarf2_build_include_psymtabs (struct dwarf2_cu *cu, 1366 struct partial_die_info *pdi, 1367 struct partial_symtab *pst) 1368{ 1369 struct objfile *objfile = cu->objfile; 1370 bfd *abfd = objfile->obfd; 1371 struct line_header *lh; 1372 1373 lh = dwarf_decode_line_header (pdi->line_offset, abfd, cu); 1374 if (lh == NULL) 1375 return; /* No linetable, so no includes. */ 1376 1377 dwarf_decode_lines (lh, NULL, abfd, cu, pst); 1378 1379 free_line_header (lh); 1380} 1381 1382 1383/* Build the partial symbol table by doing a quick pass through the 1384 .debug_info and .debug_abbrev sections. */ 1385 1386static void 1387dwarf2_build_psymtabs_hard (struct objfile *objfile, int mainline) 1388{ 1389 /* Instead of reading this into a big buffer, we should probably use 1390 mmap() on architectures that support it. (FIXME) */ 1391 bfd *abfd = objfile->obfd; 1392 char *info_ptr; 1393 char *beg_of_comp_unit; 1394 struct partial_die_info comp_unit_die; 1395 struct partial_symtab *pst; 1396 struct cleanup *back_to; 1397 CORE_ADDR lowpc, highpc, baseaddr; 1398 1399 info_ptr = dwarf2_per_objfile->info_buffer; 1400 1401 /* Any cached compilation units will be linked by the per-objfile 1402 read_in_chain. Make sure to free them when we're done. */ 1403 back_to = make_cleanup (free_cached_comp_units, NULL); 1404 1405 create_all_comp_units (objfile); 1406 1407 /* Since the objects we're extracting from .debug_info vary in 1408 length, only the individual functions to extract them (like 1409 read_comp_unit_head and load_partial_die) can really know whether 1410 the buffer is large enough to hold another complete object. 1411 1412 At the moment, they don't actually check that. If .debug_info 1413 holds just one extra byte after the last compilation unit's dies, 1414 then read_comp_unit_head will happily read off the end of the 1415 buffer. read_partial_die is similarly casual. Those functions 1416 should be fixed. 1417 1418 For this loop condition, simply checking whether there's any data 1419 left at all should be sufficient. */ 1420 while (info_ptr < (dwarf2_per_objfile->info_buffer 1421 + dwarf2_per_objfile->info_size)) 1422 { 1423 struct cleanup *back_to_inner; 1424 struct dwarf2_cu cu; 1425 struct abbrev_info *abbrev; 1426 unsigned int bytes_read; 1427 struct dwarf2_per_cu_data *this_cu; 1428 1429 beg_of_comp_unit = info_ptr; 1430 1431 memset (&cu, 0, sizeof (cu)); 1432 1433 obstack_init (&cu.comp_unit_obstack); 1434 1435 back_to_inner = make_cleanup (free_stack_comp_unit, &cu); 1436 1437 cu.objfile = objfile; 1438 info_ptr = partial_read_comp_unit_head (&cu.header, info_ptr, abfd); 1439 1440 /* Complete the cu_header */ 1441 cu.header.offset = beg_of_comp_unit - dwarf2_per_objfile->info_buffer; 1442 cu.header.first_die_ptr = info_ptr; 1443 cu.header.cu_head_ptr = beg_of_comp_unit; 1444 1445 cu.list_in_scope = &file_symbols; 1446 1447 /* Read the abbrevs for this compilation unit into a table */ 1448 dwarf2_read_abbrevs (abfd, &cu); 1449 make_cleanup (dwarf2_free_abbrev_table, &cu); 1450 1451 this_cu = dwarf2_find_comp_unit (cu.header.offset, objfile); 1452 1453 /* Read the compilation unit die */ 1454 abbrev = peek_die_abbrev (info_ptr, &bytes_read, &cu); 1455 info_ptr = read_partial_die (&comp_unit_die, abbrev, bytes_read, 1456 abfd, info_ptr, &cu); 1457 1458 /* Set the language we're debugging */ 1459 set_cu_language (comp_unit_die.language, &cu); 1460 1461 /* Allocate a new partial symbol table structure */ 1462 pst = start_psymtab_common (objfile, objfile->section_offsets, 1463 comp_unit_die.name ? comp_unit_die.name : "", 1464 comp_unit_die.lowpc, 1465 objfile->global_psymbols.next, 1466 objfile->static_psymbols.next); 1467 1468 if (comp_unit_die.dirname) 1469 pst->dirname = xstrdup (comp_unit_die.dirname); 1470 1471 pst->read_symtab_private = (char *) this_cu; 1472 1473 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 1474 1475 /* Store the function that reads in the rest of the symbol table */ 1476 pst->read_symtab = dwarf2_psymtab_to_symtab; 1477 1478 /* If this compilation unit was already read in, free the 1479 cached copy in order to read it in again. This is 1480 necessary because we skipped some symbols when we first 1481 read in the compilation unit (see load_partial_dies). 1482 This problem could be avoided, but the benefit is 1483 unclear. */ 1484 if (this_cu->cu != NULL) 1485 free_one_cached_comp_unit (this_cu->cu); 1486 1487 cu.per_cu = this_cu; 1488 1489 /* Note that this is a pointer to our stack frame, being 1490 added to a global data structure. It will be cleaned up 1491 in free_stack_comp_unit when we finish with this 1492 compilation unit. */ 1493 this_cu->cu = &cu; 1494 1495 this_cu->psymtab = pst; 1496 1497 /* Check if comp unit has_children. 1498 If so, read the rest of the partial symbols from this comp unit. 1499 If not, there's no more debug_info for this comp unit. */ 1500 if (comp_unit_die.has_children) 1501 { 1502 struct partial_die_info *first_die; 1503 1504 lowpc = ((CORE_ADDR) -1); 1505 highpc = ((CORE_ADDR) 0); 1506 1507 first_die = load_partial_dies (abfd, info_ptr, 1, &cu); 1508 1509 scan_partial_symbols (first_die, &lowpc, &highpc, &cu); 1510 1511 /* If we didn't find a lowpc, set it to highpc to avoid 1512 complaints from `maint check'. */ 1513 if (lowpc == ((CORE_ADDR) -1)) 1514 lowpc = highpc; 1515 1516 /* If the compilation unit didn't have an explicit address range, 1517 then use the information extracted from its child dies. */ 1518 if (! comp_unit_die.has_pc_info) 1519 { 1520 comp_unit_die.lowpc = lowpc; 1521 comp_unit_die.highpc = highpc; 1522 } 1523 } 1524 pst->textlow = comp_unit_die.lowpc + baseaddr; 1525 pst->texthigh = comp_unit_die.highpc + baseaddr; 1526 1527 pst->n_global_syms = objfile->global_psymbols.next - 1528 (objfile->global_psymbols.list + pst->globals_offset); 1529 pst->n_static_syms = objfile->static_psymbols.next - 1530 (objfile->static_psymbols.list + pst->statics_offset); 1531 sort_pst_symbols (pst); 1532 1533 /* If there is already a psymtab or symtab for a file of this 1534 name, remove it. (If there is a symtab, more drastic things 1535 also happen.) This happens in VxWorks. */ 1536 free_named_symtabs (pst->filename); 1537 1538 if (comp_unit_die.has_stmt_list) 1539 { 1540 /* Get the list of files included in the current compilation unit, 1541 and build a psymtab for each of them. */ 1542 dwarf2_build_include_psymtabs (&cu, &comp_unit_die, pst); 1543 } 1544 1545 info_ptr = beg_of_comp_unit + cu.header.length 1546 + cu.header.initial_length_size; 1547 1548 do_cleanups (back_to_inner); 1549 } 1550 do_cleanups (back_to); 1551} 1552 1553/* Load the DIEs for a secondary CU into memory. */ 1554 1555static void 1556load_comp_unit (struct dwarf2_per_cu_data *this_cu, struct objfile *objfile) 1557{ 1558 bfd *abfd = objfile->obfd; 1559 char *info_ptr, *beg_of_comp_unit; 1560 struct partial_die_info comp_unit_die; 1561 struct dwarf2_cu *cu; 1562 struct abbrev_info *abbrev; 1563 unsigned int bytes_read; 1564 struct cleanup *back_to; 1565 1566 info_ptr = dwarf2_per_objfile->info_buffer + this_cu->offset; 1567 beg_of_comp_unit = info_ptr; 1568 1569 cu = xmalloc (sizeof (struct dwarf2_cu)); 1570 memset (cu, 0, sizeof (struct dwarf2_cu)); 1571 1572 obstack_init (&cu->comp_unit_obstack); 1573 1574 cu->objfile = objfile; 1575 info_ptr = partial_read_comp_unit_head (&cu->header, info_ptr, abfd); 1576 1577 /* Complete the cu_header. */ 1578 cu->header.offset = beg_of_comp_unit - dwarf2_per_objfile->info_buffer; 1579 cu->header.first_die_ptr = info_ptr; 1580 cu->header.cu_head_ptr = beg_of_comp_unit; 1581 1582 /* Read the abbrevs for this compilation unit into a table. */ 1583 dwarf2_read_abbrevs (abfd, cu); 1584 back_to = make_cleanup (dwarf2_free_abbrev_table, cu); 1585 1586 /* Read the compilation unit die. */ 1587 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu); 1588 info_ptr = read_partial_die (&comp_unit_die, abbrev, bytes_read, 1589 abfd, info_ptr, cu); 1590 1591 /* Set the language we're debugging. */ 1592 set_cu_language (comp_unit_die.language, cu); 1593 1594 /* Link this compilation unit into the compilation unit tree. */ 1595 this_cu->cu = cu; 1596 cu->per_cu = this_cu; 1597 1598 /* Check if comp unit has_children. 1599 If so, read the rest of the partial symbols from this comp unit. 1600 If not, there's no more debug_info for this comp unit. */ 1601 if (comp_unit_die.has_children) 1602 load_partial_dies (abfd, info_ptr, 0, cu); 1603 1604 do_cleanups (back_to); 1605} 1606 1607/* Create a list of all compilation units in OBJFILE. We do this only 1608 if an inter-comp-unit reference is found; presumably if there is one, 1609 there will be many, and one will occur early in the .debug_info section. 1610 So there's no point in building this list incrementally. */ 1611 1612static void 1613create_all_comp_units (struct objfile *objfile) 1614{ 1615 int n_allocated; 1616 int n_comp_units; 1617 struct dwarf2_per_cu_data **all_comp_units; 1618 char *info_ptr = dwarf2_per_objfile->info_buffer; 1619 1620 n_comp_units = 0; 1621 n_allocated = 10; 1622 all_comp_units = xmalloc (n_allocated 1623 * sizeof (struct dwarf2_per_cu_data *)); 1624 1625 while (info_ptr < dwarf2_per_objfile->info_buffer + dwarf2_per_objfile->info_size) 1626 { 1627 struct comp_unit_head cu_header; 1628 char *beg_of_comp_unit; 1629 struct dwarf2_per_cu_data *this_cu; 1630 unsigned long offset; 1631 int bytes_read; 1632 1633 offset = info_ptr - dwarf2_per_objfile->info_buffer; 1634 1635 /* Read just enough information to find out where the next 1636 compilation unit is. */ 1637 cu_header.length = read_initial_length (objfile->obfd, info_ptr, 1638 &cu_header, &bytes_read); 1639 1640 /* Save the compilation unit for later lookup. */ 1641 this_cu = obstack_alloc (&objfile->objfile_obstack, 1642 sizeof (struct dwarf2_per_cu_data)); 1643 memset (this_cu, 0, sizeof (*this_cu)); 1644 this_cu->offset = offset; 1645 this_cu->length = cu_header.length + cu_header.initial_length_size; 1646 1647 if (n_comp_units == n_allocated) 1648 { 1649 n_allocated *= 2; 1650 all_comp_units = xrealloc (all_comp_units, 1651 n_allocated 1652 * sizeof (struct dwarf2_per_cu_data *)); 1653 } 1654 all_comp_units[n_comp_units++] = this_cu; 1655 1656 info_ptr = info_ptr + this_cu->length; 1657 } 1658 1659 dwarf2_per_objfile->all_comp_units 1660 = obstack_alloc (&objfile->objfile_obstack, 1661 n_comp_units * sizeof (struct dwarf2_per_cu_data *)); 1662 memcpy (dwarf2_per_objfile->all_comp_units, all_comp_units, 1663 n_comp_units * sizeof (struct dwarf2_per_cu_data *)); 1664 xfree (all_comp_units); 1665 dwarf2_per_objfile->n_comp_units = n_comp_units; 1666} 1667 1668/* Process all loaded DIEs for compilation unit CU, starting at FIRST_DIE. 1669 Also set *LOWPC and *HIGHPC to the lowest and highest PC values found 1670 in CU. */ 1671 1672static void 1673scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc, 1674 CORE_ADDR *highpc, struct dwarf2_cu *cu) 1675{ 1676 struct objfile *objfile = cu->objfile; 1677 bfd *abfd = objfile->obfd; 1678 struct partial_die_info *pdi; 1679 1680 /* Now, march along the PDI's, descending into ones which have 1681 interesting children but skipping the children of the other ones, 1682 until we reach the end of the compilation unit. */ 1683 1684 pdi = first_die; 1685 1686 while (pdi != NULL) 1687 { 1688 fixup_partial_die (pdi, cu); 1689 1690 /* Anonymous namespaces have no name but have interesting 1691 children, so we need to look at them. Ditto for anonymous 1692 enums. */ 1693 1694 if (pdi->name != NULL || pdi->tag == DW_TAG_namespace 1695 || pdi->tag == DW_TAG_enumeration_type) 1696 { 1697 switch (pdi->tag) 1698 { 1699 case DW_TAG_subprogram: 1700 if (pdi->has_pc_info) 1701 { 1702 if (pdi->lowpc < *lowpc) 1703 { 1704 *lowpc = pdi->lowpc; 1705 } 1706 if (pdi->highpc > *highpc) 1707 { 1708 *highpc = pdi->highpc; 1709 } 1710 if (!pdi->is_declaration) 1711 { 1712 add_partial_symbol (pdi, cu); 1713 } 1714 } 1715 break; 1716 case DW_TAG_variable: 1717 case DW_TAG_typedef: 1718 case DW_TAG_union_type: 1719 if (!pdi->is_declaration) 1720 { 1721 add_partial_symbol (pdi, cu); 1722 } 1723 break; 1724 case DW_TAG_class_type: 1725 case DW_TAG_structure_type: 1726 if (!pdi->is_declaration) 1727 { 1728 add_partial_symbol (pdi, cu); 1729 } 1730 break; 1731 case DW_TAG_enumeration_type: 1732 if (!pdi->is_declaration) 1733 add_partial_enumeration (pdi, cu); 1734 break; 1735 case DW_TAG_base_type: 1736 case DW_TAG_subrange_type: 1737 /* File scope base type definitions are added to the partial 1738 symbol table. */ 1739 add_partial_symbol (pdi, cu); 1740 break; 1741 case DW_TAG_namespace: 1742 add_partial_namespace (pdi, lowpc, highpc, cu); 1743 break; 1744 default: 1745 break; 1746 } 1747 } 1748 1749 /* If the die has a sibling, skip to the sibling. */ 1750 1751 pdi = pdi->die_sibling; 1752 } 1753} 1754 1755/* Functions used to compute the fully scoped name of a partial DIE. 1756 1757 Normally, this is simple. For C++, the parent DIE's fully scoped 1758 name is concatenated with "::" and the partial DIE's name. For 1759 Java, the same thing occurs except that "." is used instead of "::". 1760 Enumerators are an exception; they use the scope of their parent 1761 enumeration type, i.e. the name of the enumeration type is not 1762 prepended to the enumerator. 1763 1764 There are two complexities. One is DW_AT_specification; in this 1765 case "parent" means the parent of the target of the specification, 1766 instead of the direct parent of the DIE. The other is compilers 1767 which do not emit DW_TAG_namespace; in this case we try to guess 1768 the fully qualified name of structure types from their members' 1769 linkage names. This must be done using the DIE's children rather 1770 than the children of any DW_AT_specification target. We only need 1771 to do this for structures at the top level, i.e. if the target of 1772 any DW_AT_specification (if any; otherwise the DIE itself) does not 1773 have a parent. */ 1774 1775/* Compute the scope prefix associated with PDI's parent, in 1776 compilation unit CU. The result will be allocated on CU's 1777 comp_unit_obstack, or a copy of the already allocated PDI->NAME 1778 field. NULL is returned if no prefix is necessary. */ 1779static char * 1780partial_die_parent_scope (struct partial_die_info *pdi, 1781 struct dwarf2_cu *cu) 1782{ 1783 char *grandparent_scope; 1784 struct partial_die_info *parent, *real_pdi; 1785 1786 /* We need to look at our parent DIE; if we have a DW_AT_specification, 1787 then this means the parent of the specification DIE. */ 1788 1789 real_pdi = pdi; 1790 while (real_pdi->has_specification) 1791 real_pdi = find_partial_die (real_pdi->spec_offset, cu); 1792 1793 parent = real_pdi->die_parent; 1794 if (parent == NULL) 1795 return NULL; 1796 1797 if (parent->scope_set) 1798 return parent->scope; 1799 1800 fixup_partial_die (parent, cu); 1801 1802 grandparent_scope = partial_die_parent_scope (parent, cu); 1803 1804 if (parent->tag == DW_TAG_namespace 1805 || parent->tag == DW_TAG_structure_type 1806 || parent->tag == DW_TAG_class_type 1807 || parent->tag == DW_TAG_union_type) 1808 { 1809 if (grandparent_scope == NULL) 1810 parent->scope = parent->name; 1811 else 1812 parent->scope = typename_concat (&cu->comp_unit_obstack, grandparent_scope, 1813 parent->name, cu); 1814 } 1815 else if (parent->tag == DW_TAG_enumeration_type) 1816 /* Enumerators should not get the name of the enumeration as a prefix. */ 1817 parent->scope = grandparent_scope; 1818 else 1819 { 1820 /* FIXME drow/2004-04-01: What should we be doing with 1821 function-local names? For partial symbols, we should probably be 1822 ignoring them. */ 1823 complaint (&symfile_complaints, 1824 "unhandled containing DIE tag %d for DIE at %d", 1825 parent->tag, pdi->offset); 1826 parent->scope = grandparent_scope; 1827 } 1828 1829 parent->scope_set = 1; 1830 return parent->scope; 1831} 1832 1833/* Return the fully scoped name associated with PDI, from compilation unit 1834 CU. The result will be allocated with malloc. */ 1835static char * 1836partial_die_full_name (struct partial_die_info *pdi, 1837 struct dwarf2_cu *cu) 1838{ 1839 char *parent_scope; 1840 1841 parent_scope = partial_die_parent_scope (pdi, cu); 1842 if (parent_scope == NULL) 1843 return NULL; 1844 else 1845 return typename_concat (NULL, parent_scope, pdi->name, cu); 1846} 1847 1848static void 1849add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) 1850{ 1851 struct objfile *objfile = cu->objfile; 1852 CORE_ADDR addr = 0; 1853 char *actual_name; 1854 const char *my_prefix; 1855 const struct partial_symbol *psym = NULL; 1856 CORE_ADDR baseaddr; 1857 int built_actual_name = 0; 1858 1859 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 1860 1861 actual_name = NULL; 1862 1863 if (pdi_needs_namespace (pdi->tag)) 1864 { 1865 actual_name = partial_die_full_name (pdi, cu); 1866 if (actual_name) 1867 built_actual_name = 1; 1868 } 1869 1870 if (actual_name == NULL) 1871 actual_name = pdi->name; 1872 1873 switch (pdi->tag) 1874 { 1875 case DW_TAG_subprogram: 1876 if (pdi->is_external) 1877 { 1878 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr, 1879 mst_text, objfile); */ 1880 psym = add_psymbol_to_list (actual_name, strlen (actual_name), 1881 VAR_DOMAIN, LOC_BLOCK, 1882 &objfile->global_psymbols, 1883 0, pdi->lowpc + baseaddr, 1884 cu->language, objfile); 1885 } 1886 else 1887 { 1888 /*prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr, 1889 mst_file_text, objfile); */ 1890 psym = add_psymbol_to_list (actual_name, strlen (actual_name), 1891 VAR_DOMAIN, LOC_BLOCK, 1892 &objfile->static_psymbols, 1893 0, pdi->lowpc + baseaddr, 1894 cu->language, objfile); 1895 } 1896 break; 1897 case DW_TAG_variable: 1898 if (pdi->is_external) 1899 { 1900 /* Global Variable. 1901 Don't enter into the minimal symbol tables as there is 1902 a minimal symbol table entry from the ELF symbols already. 1903 Enter into partial symbol table if it has a location 1904 descriptor or a type. 1905 If the location descriptor is missing, new_symbol will create 1906 a LOC_UNRESOLVED symbol, the address of the variable will then 1907 be determined from the minimal symbol table whenever the variable 1908 is referenced. 1909 The address for the partial symbol table entry is not 1910 used by GDB, but it comes in handy for debugging partial symbol 1911 table building. */ 1912 1913 if (pdi->locdesc) 1914 addr = decode_locdesc (pdi->locdesc, cu); 1915 if (pdi->locdesc || pdi->has_type) 1916 psym = add_psymbol_to_list (actual_name, strlen (actual_name), 1917 VAR_DOMAIN, LOC_STATIC, 1918 &objfile->global_psymbols, 1919 0, addr + baseaddr, 1920 cu->language, objfile); 1921 } 1922 else 1923 { 1924 /* Static Variable. Skip symbols without location descriptors. */ 1925 if (pdi->locdesc == NULL) 1926 return; 1927 addr = decode_locdesc (pdi->locdesc, cu); 1928 /*prim_record_minimal_symbol (actual_name, addr + baseaddr, 1929 mst_file_data, objfile); */ 1930 psym = add_psymbol_to_list (actual_name, strlen (actual_name), 1931 VAR_DOMAIN, LOC_STATIC, 1932 &objfile->static_psymbols, 1933 0, addr + baseaddr, 1934 cu->language, objfile); 1935 } 1936 break; 1937 case DW_TAG_typedef: 1938 case DW_TAG_base_type: 1939 case DW_TAG_subrange_type: 1940 add_psymbol_to_list (actual_name, strlen (actual_name), 1941 VAR_DOMAIN, LOC_TYPEDEF, 1942 &objfile->static_psymbols, 1943 0, (CORE_ADDR) 0, cu->language, objfile); 1944 break; 1945 case DW_TAG_namespace: 1946 add_psymbol_to_list (actual_name, strlen (actual_name), 1947 VAR_DOMAIN, LOC_TYPEDEF, 1948 &objfile->global_psymbols, 1949 0, (CORE_ADDR) 0, cu->language, objfile); 1950 break; 1951 case DW_TAG_class_type: 1952 case DW_TAG_structure_type: 1953 case DW_TAG_union_type: 1954 case DW_TAG_enumeration_type: 1955 /* Skip aggregate types without children, these are external 1956 references. */ 1957 /* NOTE: carlton/2003-10-07: See comment in new_symbol about 1958 static vs. global. */ 1959 if (pdi->has_children == 0) 1960 return; 1961 add_psymbol_to_list (actual_name, strlen (actual_name), 1962 STRUCT_DOMAIN, LOC_TYPEDEF, 1963 (cu->language == language_cplus 1964 || cu->language == language_java) 1965 ? &objfile->global_psymbols 1966 : &objfile->static_psymbols, 1967 0, (CORE_ADDR) 0, cu->language, objfile); 1968 1969 if (cu->language == language_cplus 1970 || cu->language == language_java) 1971 { 1972 /* For C++ and Java, these implicitly act as typedefs as well. */ 1973 add_psymbol_to_list (actual_name, strlen (actual_name), 1974 VAR_DOMAIN, LOC_TYPEDEF, 1975 &objfile->global_psymbols, 1976 0, (CORE_ADDR) 0, cu->language, objfile); 1977 } 1978 break; 1979 case DW_TAG_enumerator: 1980 add_psymbol_to_list (actual_name, strlen (actual_name), 1981 VAR_DOMAIN, LOC_CONST, 1982 (cu->language == language_cplus 1983 || cu->language == language_java) 1984 ? &objfile->global_psymbols 1985 : &objfile->static_psymbols, 1986 0, (CORE_ADDR) 0, cu->language, objfile); 1987 break; 1988 default: 1989 break; 1990 } 1991 1992 /* Check to see if we should scan the name for possible namespace 1993 info. Only do this if this is C++, if we don't have namespace 1994 debugging info in the file, if the psym is of an appropriate type 1995 (otherwise we'll have psym == NULL), and if we actually had a 1996 mangled name to begin with. */ 1997 1998 /* FIXME drow/2004-02-22: Why don't we do this for classes, i.e. the 1999 cases which do not set PSYM above? */ 2000 2001 if (cu->language == language_cplus 2002 && cu->has_namespace_info == 0 2003 && psym != NULL 2004 && SYMBOL_CPLUS_DEMANGLED_NAME (psym) != NULL) 2005 cp_check_possible_namespace_symbols (SYMBOL_CPLUS_DEMANGLED_NAME (psym), 2006 objfile); 2007 2008 if (built_actual_name) 2009 xfree (actual_name); 2010} 2011 2012/* Determine whether a die of type TAG living in a C++ class or 2013 namespace needs to have the name of the scope prepended to the 2014 name listed in the die. */ 2015 2016static int 2017pdi_needs_namespace (enum dwarf_tag tag) 2018{ 2019 switch (tag) 2020 { 2021 case DW_TAG_namespace: 2022 case DW_TAG_typedef: 2023 case DW_TAG_class_type: 2024 case DW_TAG_structure_type: 2025 case DW_TAG_union_type: 2026 case DW_TAG_enumeration_type: 2027 case DW_TAG_enumerator: 2028 return 1; 2029 default: 2030 return 0; 2031 } 2032} 2033 2034/* Read a partial die corresponding to a namespace; also, add a symbol 2035 corresponding to that namespace to the symbol table. NAMESPACE is 2036 the name of the enclosing namespace. */ 2037 2038static void 2039add_partial_namespace (struct partial_die_info *pdi, 2040 CORE_ADDR *lowpc, CORE_ADDR *highpc, 2041 struct dwarf2_cu *cu) 2042{ 2043 struct objfile *objfile = cu->objfile; 2044 2045 /* Add a symbol for the namespace. */ 2046 2047 add_partial_symbol (pdi, cu); 2048 2049 /* Now scan partial symbols in that namespace. */ 2050 2051 if (pdi->has_children) 2052 scan_partial_symbols (pdi->die_child, lowpc, highpc, cu); 2053} 2054 2055/* See if we can figure out if the class lives in a namespace. We do 2056 this by looking for a member function; its demangled name will 2057 contain namespace info, if there is any. */ 2058 2059static void 2060guess_structure_name (struct partial_die_info *struct_pdi, 2061 struct dwarf2_cu *cu) 2062{ 2063 if ((cu->language == language_cplus 2064 || cu->language == language_java) 2065 && cu->has_namespace_info == 0 2066 && struct_pdi->has_children) 2067 { 2068 /* NOTE: carlton/2003-10-07: Getting the info this way changes 2069 what template types look like, because the demangler 2070 frequently doesn't give the same name as the debug info. We 2071 could fix this by only using the demangled name to get the 2072 prefix (but see comment in read_structure_type). */ 2073 2074 struct partial_die_info *child_pdi = struct_pdi->die_child; 2075 struct partial_die_info *real_pdi; 2076 2077 /* If this DIE (this DIE's specification, if any) has a parent, then 2078 we should not do this. We'll prepend the parent's fully qualified 2079 name when we create the partial symbol. */ 2080 2081 real_pdi = struct_pdi; 2082 while (real_pdi->has_specification) 2083 real_pdi = find_partial_die (real_pdi->spec_offset, cu); 2084 2085 if (real_pdi->die_parent != NULL) 2086 return; 2087 2088 while (child_pdi != NULL) 2089 { 2090 if (child_pdi->tag == DW_TAG_subprogram) 2091 { 2092 char *actual_class_name 2093 = language_class_name_from_physname (cu->language_defn, 2094 child_pdi->name); 2095 if (actual_class_name != NULL) 2096 { 2097 struct_pdi->name 2098 = obsavestring (actual_class_name, 2099 strlen (actual_class_name), 2100 &cu->comp_unit_obstack); 2101 xfree (actual_class_name); 2102 } 2103 break; 2104 } 2105 2106 child_pdi = child_pdi->die_sibling; 2107 } 2108 } 2109} 2110 2111/* Read a partial die corresponding to an enumeration type. */ 2112 2113static void 2114add_partial_enumeration (struct partial_die_info *enum_pdi, 2115 struct dwarf2_cu *cu) 2116{ 2117 struct objfile *objfile = cu->objfile; 2118 bfd *abfd = objfile->obfd; 2119 struct partial_die_info *pdi; 2120 2121 if (enum_pdi->name != NULL) 2122 add_partial_symbol (enum_pdi, cu); 2123 2124 pdi = enum_pdi->die_child; 2125 while (pdi) 2126 { 2127 if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL) 2128 complaint (&symfile_complaints, "malformed enumerator DIE ignored"); 2129 else 2130 add_partial_symbol (pdi, cu); 2131 pdi = pdi->die_sibling; 2132 } 2133} 2134 2135/* Read the initial uleb128 in the die at INFO_PTR in compilation unit CU. 2136 Return the corresponding abbrev, or NULL if the number is zero (indicating 2137 an empty DIE). In either case *BYTES_READ will be set to the length of 2138 the initial number. */ 2139 2140static struct abbrev_info * 2141peek_die_abbrev (char *info_ptr, int *bytes_read, struct dwarf2_cu *cu) 2142{ 2143 bfd *abfd = cu->objfile->obfd; 2144 unsigned int abbrev_number; 2145 struct abbrev_info *abbrev; 2146 2147 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, bytes_read); 2148 2149 if (abbrev_number == 0) 2150 return NULL; 2151 2152 abbrev = dwarf2_lookup_abbrev (abbrev_number, cu); 2153 if (!abbrev) 2154 { 2155 error ("Dwarf Error: Could not find abbrev number %d [in module %s]", abbrev_number, 2156 bfd_get_filename (abfd)); 2157 } 2158 2159 return abbrev; 2160} 2161 2162/* Scan the debug information for CU starting at INFO_PTR. Returns a 2163 pointer to the end of a series of DIEs, terminated by an empty 2164 DIE. Any children of the skipped DIEs will also be skipped. */ 2165 2166static char * 2167skip_children (char *info_ptr, struct dwarf2_cu *cu) 2168{ 2169 struct abbrev_info *abbrev; 2170 unsigned int bytes_read; 2171 2172 while (1) 2173 { 2174 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu); 2175 if (abbrev == NULL) 2176 return info_ptr + bytes_read; 2177 else 2178 info_ptr = skip_one_die (info_ptr + bytes_read, abbrev, cu); 2179 } 2180} 2181 2182/* Scan the debug information for CU starting at INFO_PTR. INFO_PTR 2183 should point just after the initial uleb128 of a DIE, and the 2184 abbrev corresponding to that skipped uleb128 should be passed in 2185 ABBREV. Returns a pointer to this DIE's sibling, skipping any 2186 children. */ 2187 2188static char * 2189skip_one_die (char *info_ptr, struct abbrev_info *abbrev, 2190 struct dwarf2_cu *cu) 2191{ 2192 unsigned int bytes_read; 2193 struct attribute attr; 2194 bfd *abfd = cu->objfile->obfd; 2195 unsigned int form, i; 2196 2197 for (i = 0; i < abbrev->num_attrs; i++) 2198 { 2199 /* The only abbrev we care about is DW_AT_sibling. */ 2200 if (abbrev->attrs[i].name == DW_AT_sibling) 2201 { 2202 read_attribute (&attr, &abbrev->attrs[i], 2203 abfd, info_ptr, cu); 2204 if (attr.form == DW_FORM_ref_addr) 2205 complaint (&symfile_complaints, "ignoring absolute DW_AT_sibling"); 2206 else 2207 return dwarf2_per_objfile->info_buffer 2208 + dwarf2_get_ref_die_offset (&attr, cu); 2209 } 2210 2211 /* If it isn't DW_AT_sibling, skip this attribute. */ 2212 form = abbrev->attrs[i].form; 2213 skip_attribute: 2214 switch (form) 2215 { 2216 case DW_FORM_addr: 2217 case DW_FORM_ref_addr: 2218 info_ptr += cu->header.addr_size; 2219 break; 2220 case DW_FORM_data1: 2221 case DW_FORM_ref1: 2222 case DW_FORM_flag: 2223 info_ptr += 1; 2224 break; 2225 case DW_FORM_data2: 2226 case DW_FORM_ref2: 2227 info_ptr += 2; 2228 break; 2229 case DW_FORM_data4: 2230 case DW_FORM_ref4: 2231 info_ptr += 4; 2232 break; 2233 case DW_FORM_data8: 2234 case DW_FORM_ref8: 2235 info_ptr += 8; 2236 break; 2237 case DW_FORM_string: 2238 read_string (abfd, info_ptr, &bytes_read); 2239 info_ptr += bytes_read; 2240 break; 2241 case DW_FORM_strp: 2242 info_ptr += cu->header.offset_size; 2243 break; 2244 case DW_FORM_block: 2245 info_ptr += read_unsigned_leb128 (abfd, info_ptr, &bytes_read); 2246 info_ptr += bytes_read; 2247 break; 2248 case DW_FORM_block1: 2249 info_ptr += 1 + read_1_byte (abfd, info_ptr); 2250 break; 2251 case DW_FORM_block2: 2252 info_ptr += 2 + read_2_bytes (abfd, info_ptr); 2253 break; 2254 case DW_FORM_block4: 2255 info_ptr += 4 + read_4_bytes (abfd, info_ptr); 2256 break; 2257 case DW_FORM_sdata: 2258 case DW_FORM_udata: 2259 case DW_FORM_ref_udata: 2260 info_ptr = skip_leb128 (abfd, info_ptr); 2261 break; 2262 case DW_FORM_indirect: 2263 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); 2264 info_ptr += bytes_read; 2265 /* We need to continue parsing from here, so just go back to 2266 the top. */ 2267 goto skip_attribute; 2268 2269 default: 2270 error ("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]", 2271 dwarf_form_name (form), 2272 bfd_get_filename (abfd)); 2273 } 2274 } 2275 2276 if (abbrev->has_children) 2277 return skip_children (info_ptr, cu); 2278 else 2279 return info_ptr; 2280} 2281 2282/* Locate ORIG_PDI's sibling; INFO_PTR should point to the start of 2283 the next DIE after ORIG_PDI. */ 2284 2285static char * 2286locate_pdi_sibling (struct partial_die_info *orig_pdi, char *info_ptr, 2287 bfd *abfd, struct dwarf2_cu *cu) 2288{ 2289 /* Do we know the sibling already? */ 2290 2291 if (orig_pdi->sibling) 2292 return orig_pdi->sibling; 2293 2294 /* Are there any children to deal with? */ 2295 2296 if (!orig_pdi->has_children) 2297 return info_ptr; 2298 2299 /* Skip the children the long way. */ 2300 2301 return skip_children (info_ptr, cu); 2302} 2303 2304/* Expand this partial symbol table into a full symbol table. */ 2305 2306static void 2307dwarf2_psymtab_to_symtab (struct partial_symtab *pst) 2308{ 2309 /* FIXME: This is barely more than a stub. */ 2310 if (pst != NULL) 2311 { 2312 if (pst->readin) 2313 { 2314 warning ("bug: psymtab for %s is already read in.", pst->filename); 2315 } 2316 else 2317 { 2318 if (info_verbose) 2319 { 2320 printf_filtered ("Reading in symbols for %s...", pst->filename); 2321 gdb_flush (gdb_stdout); 2322 } 2323 2324 /* Restore our global data. */ 2325 dwarf2_per_objfile = objfile_data (pst->objfile, 2326 dwarf2_objfile_data_key); 2327 2328 psymtab_to_symtab_1 (pst); 2329 2330 /* Finish up the debug error message. */ 2331 if (info_verbose) 2332 printf_filtered ("done.\n"); 2333 } 2334 } 2335} 2336 2337/* Add PER_CU to the queue. */ 2338 2339static void 2340queue_comp_unit (struct dwarf2_per_cu_data *per_cu) 2341{ 2342 struct dwarf2_queue_item *item; 2343 2344 per_cu->queued = 1; 2345 item = xmalloc (sizeof (*item)); 2346 item->per_cu = per_cu; 2347 item->next = NULL; 2348 2349 if (dwarf2_queue == NULL) 2350 dwarf2_queue = item; 2351 else 2352 dwarf2_queue_tail->next = item; 2353 2354 dwarf2_queue_tail = item; 2355} 2356 2357/* Process the queue. */ 2358 2359static void 2360process_queue (struct objfile *objfile) 2361{ 2362 struct dwarf2_queue_item *item, *next_item; 2363 2364 /* Initially, there is just one item on the queue. Load its DIEs, 2365 and the DIEs of any other compilation units it requires, 2366 transitively. */ 2367 2368 for (item = dwarf2_queue; item != NULL; item = item->next) 2369 { 2370 /* Read in this compilation unit. This may add new items to 2371 the end of the queue. */ 2372 load_full_comp_unit (item->per_cu); 2373 2374 item->per_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain; 2375 dwarf2_per_objfile->read_in_chain = item->per_cu; 2376 2377 /* If this compilation unit has already had full symbols created, 2378 reset the TYPE fields in each DIE. */ 2379 if (item->per_cu->psymtab->readin) 2380 reset_die_and_siblings_types (item->per_cu->cu->dies, 2381 item->per_cu->cu); 2382 } 2383 2384 /* Now everything left on the queue needs to be read in. Process 2385 them, one at a time, removing from the queue as we finish. */ 2386 for (item = dwarf2_queue; item != NULL; dwarf2_queue = item = next_item) 2387 { 2388 if (!item->per_cu->psymtab->readin) 2389 process_full_comp_unit (item->per_cu); 2390 2391 item->per_cu->queued = 0; 2392 next_item = item->next; 2393 xfree (item); 2394 } 2395 2396 dwarf2_queue_tail = NULL; 2397} 2398 2399/* Free all allocated queue entries. This function only releases anything if 2400 an error was thrown; if the queue was processed then it would have been 2401 freed as we went along. */ 2402 2403static void 2404dwarf2_release_queue (void *dummy) 2405{ 2406 struct dwarf2_queue_item *item, *last; 2407 2408 item = dwarf2_queue; 2409 while (item) 2410 { 2411 /* Anything still marked queued is likely to be in an 2412 inconsistent state, so discard it. */ 2413 if (item->per_cu->queued) 2414 { 2415 if (item->per_cu->cu != NULL) 2416 free_one_cached_comp_unit (item->per_cu->cu); 2417 item->per_cu->queued = 0; 2418 } 2419 2420 last = item; 2421 item = item->next; 2422 xfree (last); 2423 } 2424 2425 dwarf2_queue = dwarf2_queue_tail = NULL; 2426} 2427 2428/* Read in full symbols for PST, and anything it depends on. */ 2429 2430static void 2431psymtab_to_symtab_1 (struct partial_symtab *pst) 2432{ 2433 struct dwarf2_per_cu_data *per_cu; 2434 struct cleanup *back_to; 2435 int i; 2436 2437 for (i = 0; i < pst->number_of_dependencies; i++) 2438 if (!pst->dependencies[i]->readin) 2439 { 2440 /* Inform about additional files that need to be read in. */ 2441 if (info_verbose) 2442 { 2443 fputs_filtered (" ", gdb_stdout); 2444 wrap_here (""); 2445 fputs_filtered ("and ", gdb_stdout); 2446 wrap_here (""); 2447 printf_filtered ("%s...", pst->dependencies[i]->filename); 2448 wrap_here (""); /* Flush output */ 2449 gdb_flush (gdb_stdout); 2450 } 2451 psymtab_to_symtab_1 (pst->dependencies[i]); 2452 } 2453 2454 per_cu = (struct dwarf2_per_cu_data *) pst->read_symtab_private; 2455 2456 if (per_cu == NULL) 2457 { 2458 /* It's an include file, no symbols to read for it. 2459 Everything is in the parent symtab. */ 2460 pst->readin = 1; 2461 return; 2462 } 2463 2464 back_to = make_cleanup (dwarf2_release_queue, NULL); 2465 2466 queue_comp_unit (per_cu); 2467 2468 process_queue (pst->objfile); 2469 2470 /* Age the cache, releasing compilation units that have not 2471 been used recently. */ 2472 age_cached_comp_units (); 2473 2474 do_cleanups (back_to); 2475} 2476 2477/* Load the DIEs associated with PST and PER_CU into memory. */ 2478 2479static struct dwarf2_cu * 2480load_full_comp_unit (struct dwarf2_per_cu_data *per_cu) 2481{ 2482 struct partial_symtab *pst = per_cu->psymtab; 2483 bfd *abfd = pst->objfile->obfd; 2484 struct dwarf2_cu *cu; 2485 unsigned long offset; 2486 char *info_ptr; 2487 struct cleanup *back_to, *free_cu_cleanup; 2488 struct attribute *attr; 2489 CORE_ADDR baseaddr; 2490 2491 /* Set local variables from the partial symbol table info. */ 2492 offset = per_cu->offset; 2493 2494 info_ptr = dwarf2_per_objfile->info_buffer + offset; 2495 2496 cu = xmalloc (sizeof (struct dwarf2_cu)); 2497 memset (cu, 0, sizeof (struct dwarf2_cu)); 2498 2499 /* If an error occurs while loading, release our storage. */ 2500 free_cu_cleanup = make_cleanup (free_one_comp_unit, cu); 2501 2502 cu->objfile = pst->objfile; 2503 2504 /* read in the comp_unit header */ 2505 info_ptr = read_comp_unit_head (&cu->header, info_ptr, abfd); 2506 2507 /* Read the abbrevs for this compilation unit */ 2508 dwarf2_read_abbrevs (abfd, cu); 2509 back_to = make_cleanup (dwarf2_free_abbrev_table, cu); 2510 2511 cu->header.offset = offset; 2512 2513 cu->per_cu = per_cu; 2514 per_cu->cu = cu; 2515 2516 /* We use this obstack for block values in dwarf_alloc_block. */ 2517 obstack_init (&cu->comp_unit_obstack); 2518 2519 cu->dies = read_comp_unit (info_ptr, abfd, cu); 2520 2521 /* We try not to read any attributes in this function, because not 2522 all objfiles needed for references have been loaded yet, and symbol 2523 table processing isn't initialized. But we have to set the CU language, 2524 or we won't be able to build types correctly. */ 2525 attr = dwarf2_attr (cu->dies, DW_AT_language, cu); 2526 if (attr) 2527 set_cu_language (DW_UNSND (attr), cu); 2528 else 2529 set_cu_language (language_minimal, cu); 2530 2531 do_cleanups (back_to); 2532 2533 /* We've successfully allocated this compilation unit. Let our caller 2534 clean it up when finished with it. */ 2535 discard_cleanups (free_cu_cleanup); 2536 2537 return cu; 2538} 2539 2540/* Generate full symbol information for PST and CU, whose DIEs have 2541 already been loaded into memory. */ 2542 2543static void 2544process_full_comp_unit (struct dwarf2_per_cu_data *per_cu) 2545{ 2546 struct partial_symtab *pst = per_cu->psymtab; 2547 struct dwarf2_cu *cu = per_cu->cu; 2548 struct objfile *objfile = pst->objfile; 2549 bfd *abfd = objfile->obfd; 2550 CORE_ADDR lowpc, highpc; 2551 struct symtab *symtab; 2552 struct cleanup *back_to; 2553 struct attribute *attr; 2554 CORE_ADDR baseaddr; 2555 2556 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 2557 2558 /* We're in the global namespace. */ 2559 processing_current_prefix = ""; 2560 2561 buildsym_init (); 2562 back_to = make_cleanup (really_free_pendings, NULL); 2563 2564 cu->list_in_scope = &file_symbols; 2565 2566 /* Find the base address of the compilation unit for range lists and 2567 location lists. It will normally be specified by DW_AT_low_pc. 2568 In DWARF-3 draft 4, the base address could be overridden by 2569 DW_AT_entry_pc. It's been removed, but GCC still uses this for 2570 compilation units with discontinuous ranges. */ 2571 2572 cu->header.base_known = 0; 2573 cu->header.base_address = 0; 2574 2575 attr = dwarf2_attr (cu->dies, DW_AT_entry_pc, cu); 2576 if (attr) 2577 { 2578 cu->header.base_address = DW_ADDR (attr); 2579 cu->header.base_known = 1; 2580 } 2581 else 2582 { 2583 attr = dwarf2_attr (cu->dies, DW_AT_low_pc, cu); 2584 if (attr) 2585 { 2586 cu->header.base_address = DW_ADDR (attr); 2587 cu->header.base_known = 1; 2588 } 2589 } 2590 2591 /* Do line number decoding in read_file_scope () */ 2592 process_die (cu->dies, cu); 2593 2594 /* Some compilers don't define a DW_AT_high_pc attribute for the 2595 compilation unit. If the DW_AT_high_pc is missing, synthesize 2596 it, by scanning the DIE's below the compilation unit. */ 2597 get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu); 2598 2599 symtab = end_symtab (highpc + baseaddr, objfile, SECT_OFF_TEXT (objfile)); 2600 2601 /* Set symtab language to language from DW_AT_language. 2602 If the compilation is from a C file generated by language preprocessors, 2603 do not set the language if it was already deduced by start_subfile. */ 2604 if (symtab != NULL 2605 && !(cu->language == language_c && symtab->language != language_c)) 2606 { 2607 symtab->language = cu->language; 2608 } 2609 pst->symtab = symtab; 2610 pst->readin = 1; 2611 2612 do_cleanups (back_to); 2613} 2614 2615/* Process a die and its children. */ 2616 2617static void 2618process_die (struct die_info *die, struct dwarf2_cu *cu) 2619{ 2620 switch (die->tag) 2621 { 2622 case DW_TAG_padding: 2623 break; 2624 case DW_TAG_compile_unit: 2625 read_file_scope (die, cu); 2626 break; 2627 case DW_TAG_subprogram: 2628 read_subroutine_type (die, cu); 2629 read_func_scope (die, cu); 2630 break; 2631 case DW_TAG_inlined_subroutine: 2632 /* FIXME: These are ignored for now. 2633 They could be used to set breakpoints on all inlined instances 2634 of a function and make GDB `next' properly over inlined functions. */ 2635 break; 2636 case DW_TAG_lexical_block: 2637 case DW_TAG_try_block: 2638 case DW_TAG_catch_block: 2639 read_lexical_block_scope (die, cu); 2640 break; 2641 case DW_TAG_class_type: 2642 case DW_TAG_structure_type: 2643 case DW_TAG_union_type: 2644 read_structure_type (die, cu); 2645 process_structure_scope (die, cu); 2646 break; 2647 case DW_TAG_enumeration_type: 2648 read_enumeration_type (die, cu); 2649 process_enumeration_scope (die, cu); 2650 break; 2651 2652 /* FIXME drow/2004-03-14: These initialize die->type, but do not create 2653 a symbol or process any children. Therefore it doesn't do anything 2654 that won't be done on-demand by read_type_die. */ 2655 case DW_TAG_subroutine_type: 2656 read_subroutine_type (die, cu); 2657 break; 2658 case DW_TAG_array_type: 2659 read_array_type (die, cu); 2660 break; 2661 case DW_TAG_pointer_type: 2662 read_tag_pointer_type (die, cu); 2663 break; 2664 case DW_TAG_ptr_to_member_type: 2665 read_tag_ptr_to_member_type (die, cu); 2666 break; 2667 case DW_TAG_reference_type: 2668 read_tag_reference_type (die, cu); 2669 break; 2670 case DW_TAG_string_type: 2671 read_tag_string_type (die, cu); 2672 break; 2673 /* END FIXME */ 2674 2675 case DW_TAG_base_type: 2676 read_base_type (die, cu); 2677 /* Add a typedef symbol for the type definition, if it has a 2678 DW_AT_name. */ 2679 new_symbol (die, die->type, cu); 2680 break; 2681 case DW_TAG_subrange_type: 2682 read_subrange_type (die, cu); 2683 /* Add a typedef symbol for the type definition, if it has a 2684 DW_AT_name. */ 2685 new_symbol (die, die->type, cu); 2686 break; 2687 case DW_TAG_common_block: 2688 read_common_block (die, cu); 2689 break; 2690 case DW_TAG_common_inclusion: 2691 break; 2692 case DW_TAG_namespace: 2693 processing_has_namespace_info = 1; 2694 read_namespace (die, cu); 2695 break; 2696 case DW_TAG_imported_declaration: 2697 case DW_TAG_imported_module: 2698 /* FIXME: carlton/2002-10-16: Eventually, we should use the 2699 information contained in these. DW_TAG_imported_declaration 2700 dies shouldn't have children; DW_TAG_imported_module dies 2701 shouldn't in the C++ case, but conceivably could in the 2702 Fortran case, so we'll have to replace this gdb_assert if 2703 Fortran compilers start generating that info. */ 2704 processing_has_namespace_info = 1; 2705 gdb_assert (die->child == NULL); 2706 break; 2707 default: 2708 new_symbol (die, NULL, cu); 2709 break; 2710 } 2711} 2712 2713static void 2714initialize_cu_func_list (struct dwarf2_cu *cu) 2715{ 2716 cu->first_fn = cu->last_fn = cu->cached_fn = NULL; 2717} 2718 2719static void 2720read_file_scope (struct die_info *die, struct dwarf2_cu *cu) 2721{ 2722 struct objfile *objfile = cu->objfile; 2723 struct comp_unit_head *cu_header = &cu->header; 2724 struct cleanup *back_to = make_cleanup (null_cleanup, 0); 2725 CORE_ADDR lowpc = ((CORE_ADDR) -1); 2726 CORE_ADDR highpc = ((CORE_ADDR) 0); 2727 struct attribute *attr; 2728 char *name = "<unknown>"; 2729 char *comp_dir = NULL; 2730 struct die_info *child_die; 2731 bfd *abfd = objfile->obfd; 2732 struct line_header *line_header = 0; 2733 CORE_ADDR baseaddr; 2734 2735 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 2736 2737 get_scope_pc_bounds (die, &lowpc, &highpc, cu); 2738 2739 /* If we didn't find a lowpc, set it to highpc to avoid complaints 2740 from finish_block. */ 2741 if (lowpc == ((CORE_ADDR) -1)) 2742 lowpc = highpc; 2743 lowpc += baseaddr; 2744 highpc += baseaddr; 2745 2746 attr = dwarf2_attr (die, DW_AT_name, cu); 2747 if (attr) 2748 { 2749 name = DW_STRING (attr); 2750 } 2751 attr = dwarf2_attr (die, DW_AT_comp_dir, cu); 2752 if (attr) 2753 { 2754 comp_dir = DW_STRING (attr); 2755 if (comp_dir) 2756 { 2757 /* Irix 6.2 native cc prepends <machine>.: to the compilation 2758 directory, get rid of it. */ 2759 char *cp = strchr (comp_dir, ':'); 2760 2761 if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/') 2762 comp_dir = cp + 1; 2763 } 2764 } 2765 2766 attr = dwarf2_attr (die, DW_AT_language, cu); 2767 if (attr) 2768 { 2769 set_cu_language (DW_UNSND (attr), cu); 2770 } 2771 2772 attr = dwarf2_attr (die, DW_AT_producer, cu); 2773 if (attr) 2774 cu->producer = DW_STRING (attr); 2775 2776 /* We assume that we're processing GCC output. */ 2777 processing_gcc_compilation = 2; 2778#if 0 2779 /* FIXME:Do something here. */ 2780 if (dip->at_producer != NULL) 2781 { 2782 handle_producer (dip->at_producer); 2783 } 2784#endif 2785 2786 /* The compilation unit may be in a different language or objfile, 2787 zero out all remembered fundamental types. */ 2788 memset (cu->ftypes, 0, FT_NUM_MEMBERS * sizeof (struct type *)); 2789 2790 start_symtab (name, comp_dir, lowpc); 2791 record_debugformat ("DWARF 2"); 2792 2793 initialize_cu_func_list (cu); 2794 2795 /* Process all dies in compilation unit. */ 2796 if (die->child != NULL) 2797 { 2798 child_die = die->child; 2799 while (child_die && child_die->tag) 2800 { 2801 process_die (child_die, cu); 2802 child_die = sibling_die (child_die); 2803 } 2804 } 2805 2806 /* Decode line number information if present. */ 2807 attr = dwarf2_attr (die, DW_AT_stmt_list, cu); 2808 if (attr) 2809 { 2810 unsigned int line_offset = DW_UNSND (attr); 2811 line_header = dwarf_decode_line_header (line_offset, abfd, cu); 2812 if (line_header) 2813 { 2814 make_cleanup ((make_cleanup_ftype *) free_line_header, 2815 (void *) line_header); 2816 dwarf_decode_lines (line_header, comp_dir, abfd, cu, NULL); 2817 } 2818 } 2819 2820 /* Decode macro information, if present. Dwarf 2 macro information 2821 refers to information in the line number info statement program 2822 header, so we can only read it if we've read the header 2823 successfully. */ 2824 attr = dwarf2_attr (die, DW_AT_macro_info, cu); 2825 if (attr && line_header) 2826 { 2827 unsigned int macro_offset = DW_UNSND (attr); 2828 dwarf_decode_macros (line_header, macro_offset, 2829 comp_dir, abfd, cu); 2830 } 2831 do_cleanups (back_to); 2832} 2833 2834static void 2835add_to_cu_func_list (const char *name, CORE_ADDR lowpc, CORE_ADDR highpc, 2836 struct dwarf2_cu *cu) 2837{ 2838 struct function_range *thisfn; 2839 2840 thisfn = (struct function_range *) 2841 obstack_alloc (&cu->comp_unit_obstack, sizeof (struct function_range)); 2842 thisfn->name = name; 2843 thisfn->lowpc = lowpc; 2844 thisfn->highpc = highpc; 2845 thisfn->seen_line = 0; 2846 thisfn->next = NULL; 2847 2848 if (cu->last_fn == NULL) 2849 cu->first_fn = thisfn; 2850 else 2851 cu->last_fn->next = thisfn; 2852 2853 cu->last_fn = thisfn; 2854} 2855 2856static void 2857read_func_scope (struct die_info *die, struct dwarf2_cu *cu) 2858{ 2859 struct objfile *objfile = cu->objfile; 2860 struct context_stack *new; 2861 CORE_ADDR lowpc; 2862 CORE_ADDR highpc; 2863 struct die_info *child_die; 2864 struct attribute *attr; 2865 char *name; 2866 const char *previous_prefix = processing_current_prefix; 2867 struct cleanup *back_to = NULL; 2868 CORE_ADDR baseaddr; 2869 2870 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 2871 2872 name = dwarf2_linkage_name (die, cu); 2873 2874 /* Ignore functions with missing or empty names and functions with 2875 missing or invalid low and high pc attributes. */ 2876 if (name == NULL || !dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu)) 2877 return; 2878 2879 if (cu->language == language_cplus 2880 || cu->language == language_java) 2881 { 2882 struct die_info *spec_die = die_specification (die, cu); 2883 2884 /* NOTE: carlton/2004-01-23: We have to be careful in the 2885 presence of DW_AT_specification. For example, with GCC 3.4, 2886 given the code 2887 2888 namespace N { 2889 void foo() { 2890 // Definition of N::foo. 2891 } 2892 } 2893 2894 then we'll have a tree of DIEs like this: 2895 2896 1: DW_TAG_compile_unit 2897 2: DW_TAG_namespace // N 2898 3: DW_TAG_subprogram // declaration of N::foo 2899 4: DW_TAG_subprogram // definition of N::foo 2900 DW_AT_specification // refers to die #3 2901 2902 Thus, when processing die #4, we have to pretend that we're 2903 in the context of its DW_AT_specification, namely the contex 2904 of die #3. */ 2905 2906 if (spec_die != NULL) 2907 { 2908 char *specification_prefix = determine_prefix (spec_die, cu); 2909 processing_current_prefix = specification_prefix; 2910 back_to = make_cleanup (xfree, specification_prefix); 2911 } 2912 } 2913 2914 lowpc += baseaddr; 2915 highpc += baseaddr; 2916 2917 /* Record the function range for dwarf_decode_lines. */ 2918 add_to_cu_func_list (name, lowpc, highpc, cu); 2919 2920 new = push_context (0, lowpc); 2921 new->name = new_symbol (die, die->type, cu); 2922 2923 /* If there is a location expression for DW_AT_frame_base, record 2924 it. */ 2925 attr = dwarf2_attr (die, DW_AT_frame_base, cu); 2926 if (attr) 2927 /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location 2928 expression is being recorded directly in the function's symbol 2929 and not in a separate frame-base object. I guess this hack is 2930 to avoid adding some sort of frame-base adjunct/annex to the 2931 function's symbol :-(. The problem with doing this is that it 2932 results in a function symbol with a location expression that 2933 has nothing to do with the location of the function, ouch! The 2934 relationship should be: a function's symbol has-a frame base; a 2935 frame-base has-a location expression. */ 2936 dwarf2_symbol_mark_computed (attr, new->name, cu); 2937 2938 cu->list_in_scope = &local_symbols; 2939 2940 if (die->child != NULL) 2941 { 2942 child_die = die->child; 2943 while (child_die && child_die->tag) 2944 { 2945 process_die (child_die, cu); 2946 child_die = sibling_die (child_die); 2947 } 2948 } 2949 2950 new = pop_context (); 2951 /* Make a block for the local symbols within. */ 2952 finish_block (new->name, &local_symbols, new->old_blocks, 2953 lowpc, highpc, objfile); 2954 2955 /* In C++, we can have functions nested inside functions (e.g., when 2956 a function declares a class that has methods). This means that 2957 when we finish processing a function scope, we may need to go 2958 back to building a containing block's symbol lists. */ 2959 local_symbols = new->locals; 2960 param_symbols = new->params; 2961 2962 /* If we've finished processing a top-level function, subsequent 2963 symbols go in the file symbol list. */ 2964 if (outermost_context_p ()) 2965 cu->list_in_scope = &file_symbols; 2966 2967 processing_current_prefix = previous_prefix; 2968 if (back_to != NULL) 2969 do_cleanups (back_to); 2970} 2971 2972/* Process all the DIES contained within a lexical block scope. Start 2973 a new scope, process the dies, and then close the scope. */ 2974 2975static void 2976read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu) 2977{ 2978 struct objfile *objfile = cu->objfile; 2979 struct context_stack *new; 2980 CORE_ADDR lowpc, highpc; 2981 struct die_info *child_die; 2982 CORE_ADDR baseaddr; 2983 2984 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 2985 2986 /* Ignore blocks with missing or invalid low and high pc attributes. */ 2987 /* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges 2988 as multiple lexical blocks? Handling children in a sane way would 2989 be nasty. Might be easier to properly extend generic blocks to 2990 describe ranges. */ 2991 if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu)) 2992 return; 2993 lowpc += baseaddr; 2994 highpc += baseaddr; 2995 2996 push_context (0, lowpc); 2997 if (die->child != NULL) 2998 { 2999 child_die = die->child; 3000 while (child_die && child_die->tag) 3001 { 3002 process_die (child_die, cu); 3003 child_die = sibling_die (child_die); 3004 } 3005 } 3006 new = pop_context (); 3007 3008 if (local_symbols != NULL) 3009 { 3010 finish_block (0, &local_symbols, new->old_blocks, new->start_addr, 3011 highpc, objfile); 3012 } 3013 local_symbols = new->locals; 3014} 3015 3016/* Get low and high pc attributes from a die. Return 1 if the attributes 3017 are present and valid, otherwise, return 0. Return -1 if the range is 3018 discontinuous, i.e. derived from DW_AT_ranges information. */ 3019static int 3020dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc, 3021 CORE_ADDR *highpc, struct dwarf2_cu *cu) 3022{ 3023 struct objfile *objfile = cu->objfile; 3024 struct comp_unit_head *cu_header = &cu->header; 3025 struct attribute *attr; 3026 bfd *obfd = objfile->obfd; 3027 CORE_ADDR low = 0; 3028 CORE_ADDR high = 0; 3029 int ret = 0; 3030 3031 attr = dwarf2_attr (die, DW_AT_high_pc, cu); 3032 if (attr) 3033 { 3034 high = DW_ADDR (attr); 3035 attr = dwarf2_attr (die, DW_AT_low_pc, cu); 3036 if (attr) 3037 low = DW_ADDR (attr); 3038 else 3039 /* Found high w/o low attribute. */ 3040 return 0; 3041 3042 /* Found consecutive range of addresses. */ 3043 ret = 1; 3044 } 3045 else 3046 { 3047 attr = dwarf2_attr (die, DW_AT_ranges, cu); 3048 if (attr != NULL) 3049 { 3050 unsigned int addr_size = cu_header->addr_size; 3051 CORE_ADDR mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1)); 3052 /* Value of the DW_AT_ranges attribute is the offset in the 3053 .debug_ranges section. */ 3054 unsigned int offset = DW_UNSND (attr); 3055 /* Base address selection entry. */ 3056 CORE_ADDR base; 3057 int found_base; 3058 int dummy; 3059 char *buffer; 3060 CORE_ADDR marker; 3061 int low_set; 3062 3063 found_base = cu_header->base_known; 3064 base = cu_header->base_address; 3065 3066 if (offset >= dwarf2_per_objfile->ranges_size) 3067 { 3068 complaint (&symfile_complaints, 3069 "Offset %d out of bounds for DW_AT_ranges attribute", 3070 offset); 3071 return 0; 3072 } 3073 buffer = dwarf2_per_objfile->ranges_buffer + offset; 3074 3075 /* Read in the largest possible address. */ 3076 marker = read_address (obfd, buffer, cu, &dummy); 3077 if ((marker & mask) == mask) 3078 { 3079 /* If we found the largest possible address, then 3080 read the base address. */ 3081 base = read_address (obfd, buffer + addr_size, cu, &dummy); 3082 buffer += 2 * addr_size; 3083 offset += 2 * addr_size; 3084 found_base = 1; 3085 } 3086 3087 low_set = 0; 3088 3089 while (1) 3090 { 3091 CORE_ADDR range_beginning, range_end; 3092 3093 range_beginning = read_address (obfd, buffer, cu, &dummy); 3094 buffer += addr_size; 3095 range_end = read_address (obfd, buffer, cu, &dummy); 3096 buffer += addr_size; 3097 offset += 2 * addr_size; 3098 3099 /* An end of list marker is a pair of zero addresses. */ 3100 if (range_beginning == 0 && range_end == 0) 3101 /* Found the end of list entry. */ 3102 break; 3103 3104 /* Each base address selection entry is a pair of 2 values. 3105 The first is the largest possible address, the second is 3106 the base address. Check for a base address here. */ 3107 if ((range_beginning & mask) == mask) 3108 { 3109 /* If we found the largest possible address, then 3110 read the base address. */ 3111 base = read_address (obfd, buffer + addr_size, cu, &dummy); 3112 found_base = 1; 3113 continue; 3114 } 3115 3116 if (!found_base) 3117 { 3118 /* We have no valid base address for the ranges 3119 data. */ 3120 complaint (&symfile_complaints, 3121 "Invalid .debug_ranges data (no base address)"); 3122 return 0; 3123 } 3124 3125 range_beginning += base; 3126 range_end += base; 3127 3128 /* FIXME: This is recording everything as a low-high 3129 segment of consecutive addresses. We should have a 3130 data structure for discontiguous block ranges 3131 instead. */ 3132 if (! low_set) 3133 { 3134 low = range_beginning; 3135 high = range_end; 3136 low_set = 1; 3137 } 3138 else 3139 { 3140 if (range_beginning < low) 3141 low = range_beginning; 3142 if (range_end > high) 3143 high = range_end; 3144 } 3145 } 3146 3147 if (! low_set) 3148 /* If the first entry is an end-of-list marker, the range 3149 describes an empty scope, i.e. no instructions. */ 3150 return 0; 3151 3152 ret = -1; 3153 } 3154 } 3155 3156 if (high < low) 3157 return 0; 3158 3159 /* When using the GNU linker, .gnu.linkonce. sections are used to 3160 eliminate duplicate copies of functions and vtables and such. 3161 The linker will arbitrarily choose one and discard the others. 3162 The AT_*_pc values for such functions refer to local labels in 3163 these sections. If the section from that file was discarded, the 3164 labels are not in the output, so the relocs get a value of 0. 3165 If this is a discarded function, mark the pc bounds as invalid, 3166 so that GDB will ignore it. */ 3167 if (low == 0 && (bfd_get_file_flags (obfd) & HAS_RELOC) == 0) 3168 return 0; 3169 3170 *lowpc = low; 3171 *highpc = high; 3172 return ret; 3173} 3174 3175/* Get the low and high pc's represented by the scope DIE, and store 3176 them in *LOWPC and *HIGHPC. If the correct values can't be 3177 determined, set *LOWPC to -1 and *HIGHPC to 0. */ 3178 3179static void 3180get_scope_pc_bounds (struct die_info *die, 3181 CORE_ADDR *lowpc, CORE_ADDR *highpc, 3182 struct dwarf2_cu *cu) 3183{ 3184 CORE_ADDR best_low = (CORE_ADDR) -1; 3185 CORE_ADDR best_high = (CORE_ADDR) 0; 3186 CORE_ADDR current_low, current_high; 3187 3188 if (dwarf2_get_pc_bounds (die, ¤t_low, ¤t_high, cu)) 3189 { 3190 best_low = current_low; 3191 best_high = current_high; 3192 } 3193 else 3194 { 3195 struct die_info *child = die->child; 3196 3197 while (child && child->tag) 3198 { 3199 switch (child->tag) { 3200 case DW_TAG_subprogram: 3201 if (dwarf2_get_pc_bounds (child, ¤t_low, ¤t_high, cu)) 3202 { 3203 best_low = min (best_low, current_low); 3204 best_high = max (best_high, current_high); 3205 } 3206 break; 3207 case DW_TAG_namespace: 3208 /* FIXME: carlton/2004-01-16: Should we do this for 3209 DW_TAG_class_type/DW_TAG_structure_type, too? I think 3210 that current GCC's always emit the DIEs corresponding 3211 to definitions of methods of classes as children of a 3212 DW_TAG_compile_unit or DW_TAG_namespace (as opposed to 3213 the DIEs giving the declarations, which could be 3214 anywhere). But I don't see any reason why the 3215 standards says that they have to be there. */ 3216 get_scope_pc_bounds (child, ¤t_low, ¤t_high, cu); 3217 3218 if (current_low != ((CORE_ADDR) -1)) 3219 { 3220 best_low = min (best_low, current_low); 3221 best_high = max (best_high, current_high); 3222 } 3223 break; 3224 default: 3225 /* Ignore. */ 3226 break; 3227 } 3228 3229 child = sibling_die (child); 3230 } 3231 } 3232 3233 *lowpc = best_low; 3234 *highpc = best_high; 3235} 3236 3237/* Add an aggregate field to the field list. */ 3238 3239static void 3240dwarf2_add_field (struct field_info *fip, struct die_info *die, 3241 struct dwarf2_cu *cu) 3242{ 3243 struct objfile *objfile = cu->objfile; 3244 struct nextfield *new_field; 3245 struct attribute *attr; 3246 struct field *fp; 3247 char *fieldname = ""; 3248 3249 /* Allocate a new field list entry and link it in. */ 3250 new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield)); 3251 make_cleanup (xfree, new_field); 3252 memset (new_field, 0, sizeof (struct nextfield)); 3253 new_field->next = fip->fields; 3254 fip->fields = new_field; 3255 fip->nfields++; 3256 3257 /* Handle accessibility and virtuality of field. 3258 The default accessibility for members is public, the default 3259 accessibility for inheritance is private. */ 3260 if (die->tag != DW_TAG_inheritance) 3261 new_field->accessibility = DW_ACCESS_public; 3262 else 3263 new_field->accessibility = DW_ACCESS_private; 3264 new_field->virtuality = DW_VIRTUALITY_none; 3265 3266 attr = dwarf2_attr (die, DW_AT_accessibility, cu); 3267 if (attr) 3268 new_field->accessibility = DW_UNSND (attr); 3269 if (new_field->accessibility != DW_ACCESS_public) 3270 fip->non_public_fields = 1; 3271 attr = dwarf2_attr (die, DW_AT_virtuality, cu); 3272 if (attr) 3273 new_field->virtuality = DW_UNSND (attr); 3274 3275 fp = &new_field->field; 3276 3277 if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu)) 3278 { 3279 /* Data member other than a C++ static data member. */ 3280 3281 /* Get type of field. */ 3282 fp->type = die_type (die, cu); 3283 3284 FIELD_STATIC_KIND (*fp) = 0; 3285 3286 /* Get bit size of field (zero if none). */ 3287 attr = dwarf2_attr (die, DW_AT_bit_size, cu); 3288 if (attr) 3289 { 3290 FIELD_BITSIZE (*fp) = DW_UNSND (attr); 3291 } 3292 else 3293 { 3294 FIELD_BITSIZE (*fp) = 0; 3295 } 3296 3297 /* Get bit offset of field. */ 3298 attr = dwarf2_attr (die, DW_AT_data_member_location, cu); 3299 if (attr) 3300 { 3301 FIELD_BITPOS (*fp) = 3302 decode_locdesc (DW_BLOCK (attr), cu) * bits_per_byte; 3303 } 3304 else 3305 FIELD_BITPOS (*fp) = 0; 3306 attr = dwarf2_attr (die, DW_AT_bit_offset, cu); 3307 if (attr) 3308 { 3309 if (BITS_BIG_ENDIAN) 3310 { 3311 /* For big endian bits, the DW_AT_bit_offset gives the 3312 additional bit offset from the MSB of the containing 3313 anonymous object to the MSB of the field. We don't 3314 have to do anything special since we don't need to 3315 know the size of the anonymous object. */ 3316 FIELD_BITPOS (*fp) += DW_UNSND (attr); 3317 } 3318 else 3319 { 3320 /* For little endian bits, compute the bit offset to the 3321 MSB of the anonymous object, subtract off the number of 3322 bits from the MSB of the field to the MSB of the 3323 object, and then subtract off the number of bits of 3324 the field itself. The result is the bit offset of 3325 the LSB of the field. */ 3326 int anonymous_size; 3327 int bit_offset = DW_UNSND (attr); 3328 3329 attr = dwarf2_attr (die, DW_AT_byte_size, cu); 3330 if (attr) 3331 { 3332 /* The size of the anonymous object containing 3333 the bit field is explicit, so use the 3334 indicated size (in bytes). */ 3335 anonymous_size = DW_UNSND (attr); 3336 } 3337 else 3338 { 3339 /* The size of the anonymous object containing 3340 the bit field must be inferred from the type 3341 attribute of the data member containing the 3342 bit field. */ 3343 anonymous_size = TYPE_LENGTH (fp->type); 3344 } 3345 FIELD_BITPOS (*fp) += anonymous_size * bits_per_byte 3346 - bit_offset - FIELD_BITSIZE (*fp); 3347 } 3348 } 3349 3350 /* Get name of field. */ 3351 attr = dwarf2_attr (die, DW_AT_name, cu); 3352 if (attr && DW_STRING (attr)) 3353 fieldname = DW_STRING (attr); 3354 3355 /* The name is already allocated along with this objfile, so we don't 3356 need to duplicate it for the type. */ 3357 fp->name = fieldname; 3358 3359 /* Change accessibility for artificial fields (e.g. virtual table 3360 pointer or virtual base class pointer) to private. */ 3361 if (dwarf2_attr (die, DW_AT_artificial, cu)) 3362 { 3363 new_field->accessibility = DW_ACCESS_private; 3364 fip->non_public_fields = 1; 3365 } 3366 } 3367 else if (die->tag == DW_TAG_member || die->tag == DW_TAG_variable) 3368 { 3369 /* C++ static member. */ 3370 3371 /* NOTE: carlton/2002-11-05: It should be a DW_TAG_member that 3372 is a declaration, but all versions of G++ as of this writing 3373 (so through at least 3.2.1) incorrectly generate 3374 DW_TAG_variable tags. */ 3375 3376 char *physname; 3377 3378 /* Get name of field. */ 3379 attr = dwarf2_attr (die, DW_AT_name, cu); 3380 if (attr && DW_STRING (attr)) 3381 fieldname = DW_STRING (attr); 3382 else 3383 return; 3384 3385 /* Get physical name. */ 3386 physname = dwarf2_linkage_name (die, cu); 3387 3388 /* The name is already allocated along with this objfile, so we don't 3389 need to duplicate it for the type. */ 3390 SET_FIELD_PHYSNAME (*fp, physname ? physname : ""); 3391 FIELD_TYPE (*fp) = die_type (die, cu); 3392 FIELD_NAME (*fp) = fieldname; 3393 } 3394 else if (die->tag == DW_TAG_inheritance) 3395 { 3396 /* C++ base class field. */ 3397 attr = dwarf2_attr (die, DW_AT_data_member_location, cu); 3398 if (attr) 3399 FIELD_BITPOS (*fp) = (decode_locdesc (DW_BLOCK (attr), cu) 3400 * bits_per_byte); 3401 FIELD_BITSIZE (*fp) = 0; 3402 FIELD_STATIC_KIND (*fp) = 0; 3403 FIELD_TYPE (*fp) = die_type (die, cu); 3404 FIELD_NAME (*fp) = type_name_no_tag (fp->type); 3405 fip->nbaseclasses++; 3406 } 3407} 3408 3409/* Create the vector of fields, and attach it to the type. */ 3410 3411static void 3412dwarf2_attach_fields_to_type (struct field_info *fip, struct type *type, 3413 struct dwarf2_cu *cu) 3414{ 3415 int nfields = fip->nfields; 3416 3417 /* Record the field count, allocate space for the array of fields, 3418 and create blank accessibility bitfields if necessary. */ 3419 TYPE_NFIELDS (type) = nfields; 3420 TYPE_FIELDS (type) = (struct field *) 3421 TYPE_ALLOC (type, sizeof (struct field) * nfields); 3422 memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields); 3423 3424 if (fip->non_public_fields) 3425 { 3426 ALLOCATE_CPLUS_STRUCT_TYPE (type); 3427 3428 TYPE_FIELD_PRIVATE_BITS (type) = 3429 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields)); 3430 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields); 3431 3432 TYPE_FIELD_PROTECTED_BITS (type) = 3433 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields)); 3434 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields); 3435 3436 TYPE_FIELD_IGNORE_BITS (type) = 3437 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields)); 3438 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields); 3439 } 3440 3441 /* If the type has baseclasses, allocate and clear a bit vector for 3442 TYPE_FIELD_VIRTUAL_BITS. */ 3443 if (fip->nbaseclasses) 3444 { 3445 int num_bytes = B_BYTES (fip->nbaseclasses); 3446 char *pointer; 3447 3448 ALLOCATE_CPLUS_STRUCT_TYPE (type); 3449 pointer = (char *) TYPE_ALLOC (type, num_bytes); 3450 TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *) pointer; 3451 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->nbaseclasses); 3452 TYPE_N_BASECLASSES (type) = fip->nbaseclasses; 3453 } 3454 3455 /* Copy the saved-up fields into the field vector. Start from the head 3456 of the list, adding to the tail of the field array, so that they end 3457 up in the same order in the array in which they were added to the list. */ 3458 while (nfields-- > 0) 3459 { 3460 TYPE_FIELD (type, nfields) = fip->fields->field; 3461 switch (fip->fields->accessibility) 3462 { 3463 case DW_ACCESS_private: 3464 SET_TYPE_FIELD_PRIVATE (type, nfields); 3465 break; 3466 3467 case DW_ACCESS_protected: 3468 SET_TYPE_FIELD_PROTECTED (type, nfields); 3469 break; 3470 3471 case DW_ACCESS_public: 3472 break; 3473 3474 default: 3475 /* Unknown accessibility. Complain and treat it as public. */ 3476 { 3477 complaint (&symfile_complaints, "unsupported accessibility %d", 3478 fip->fields->accessibility); 3479 } 3480 break; 3481 } 3482 if (nfields < fip->nbaseclasses) 3483 { 3484 switch (fip->fields->virtuality) 3485 { 3486 case DW_VIRTUALITY_virtual: 3487 case DW_VIRTUALITY_pure_virtual: 3488 SET_TYPE_FIELD_VIRTUAL (type, nfields); 3489 break; 3490 } 3491 } 3492 fip->fields = fip->fields->next; 3493 } 3494} 3495 3496/* Add a member function to the proper fieldlist. */ 3497 3498static void 3499dwarf2_add_member_fn (struct field_info *fip, struct die_info *die, 3500 struct type *type, struct dwarf2_cu *cu) 3501{ 3502 struct objfile *objfile = cu->objfile; 3503 struct attribute *attr; 3504 struct fnfieldlist *flp; 3505 int i; 3506 struct fn_field *fnp; 3507 char *fieldname; 3508 char *physname; 3509 struct nextfnfield *new_fnfield; 3510 3511 /* Get name of member function. */ 3512 attr = dwarf2_attr (die, DW_AT_name, cu); 3513 if (attr && DW_STRING (attr)) 3514 fieldname = DW_STRING (attr); 3515 else 3516 return; 3517 3518 /* Get the mangled name. */ 3519 physname = dwarf2_linkage_name (die, cu); 3520 3521 /* Look up member function name in fieldlist. */ 3522 for (i = 0; i < fip->nfnfields; i++) 3523 { 3524 if (strcmp (fip->fnfieldlists[i].name, fieldname) == 0) 3525 break; 3526 } 3527 3528 /* Create new list element if necessary. */ 3529 if (i < fip->nfnfields) 3530 flp = &fip->fnfieldlists[i]; 3531 else 3532 { 3533 if ((fip->nfnfields % DW_FIELD_ALLOC_CHUNK) == 0) 3534 { 3535 fip->fnfieldlists = (struct fnfieldlist *) 3536 xrealloc (fip->fnfieldlists, 3537 (fip->nfnfields + DW_FIELD_ALLOC_CHUNK) 3538 * sizeof (struct fnfieldlist)); 3539 if (fip->nfnfields == 0) 3540 make_cleanup (free_current_contents, &fip->fnfieldlists); 3541 } 3542 flp = &fip->fnfieldlists[fip->nfnfields]; 3543 flp->name = fieldname; 3544 flp->length = 0; 3545 flp->head = NULL; 3546 fip->nfnfields++; 3547 } 3548 3549 /* Create a new member function field and chain it to the field list 3550 entry. */ 3551 new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield)); 3552 make_cleanup (xfree, new_fnfield); 3553 memset (new_fnfield, 0, sizeof (struct nextfnfield)); 3554 new_fnfield->next = flp->head; 3555 flp->head = new_fnfield; 3556 flp->length++; 3557 3558 /* Fill in the member function field info. */ 3559 fnp = &new_fnfield->fnfield; 3560 /* The name is already allocated along with this objfile, so we don't 3561 need to duplicate it for the type. */ 3562 fnp->physname = physname ? physname : ""; 3563 fnp->type = alloc_type (objfile); 3564 if (die->type && TYPE_CODE (die->type) == TYPE_CODE_FUNC) 3565 { 3566 int nparams = TYPE_NFIELDS (die->type); 3567 3568 /* TYPE is the domain of this method, and DIE->TYPE is the type 3569 of the method itself (TYPE_CODE_METHOD). */ 3570 smash_to_method_type (fnp->type, type, 3571 TYPE_TARGET_TYPE (die->type), 3572 TYPE_FIELDS (die->type), 3573 TYPE_NFIELDS (die->type), 3574 TYPE_VARARGS (die->type)); 3575 3576 /* Handle static member functions. 3577 Dwarf2 has no clean way to discern C++ static and non-static 3578 member functions. G++ helps GDB by marking the first 3579 parameter for non-static member functions (which is the 3580 this pointer) as artificial. We obtain this information 3581 from read_subroutine_type via TYPE_FIELD_ARTIFICIAL. */ 3582 if (nparams == 0 || TYPE_FIELD_ARTIFICIAL (die->type, 0) == 0) 3583 fnp->voffset = VOFFSET_STATIC; 3584 } 3585 else 3586 complaint (&symfile_complaints, "member function type missing for '%s'", 3587 physname); 3588 3589 /* Get fcontext from DW_AT_containing_type if present. */ 3590 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL) 3591 fnp->fcontext = die_containing_type (die, cu); 3592 3593 /* dwarf2 doesn't have stubbed physical names, so the setting of is_const 3594 and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */ 3595 3596 /* Get accessibility. */ 3597 attr = dwarf2_attr (die, DW_AT_accessibility, cu); 3598 if (attr) 3599 { 3600 switch (DW_UNSND (attr)) 3601 { 3602 case DW_ACCESS_private: 3603 fnp->is_private = 1; 3604 break; 3605 case DW_ACCESS_protected: 3606 fnp->is_protected = 1; 3607 break; 3608 } 3609 } 3610 3611 /* Check for artificial methods. */ 3612 attr = dwarf2_attr (die, DW_AT_artificial, cu); 3613 if (attr && DW_UNSND (attr) != 0) 3614 fnp->is_artificial = 1; 3615 3616 /* Get index in virtual function table if it is a virtual member function. */ 3617 attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu); 3618 if (attr) 3619 { 3620 /* Support the .debug_loc offsets */ 3621 if (attr_form_is_block (attr)) 3622 { 3623 fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu) + 2; 3624 } 3625 else if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8) 3626 { 3627 dwarf2_complex_location_expr_complaint (); 3628 } 3629 else 3630 { 3631 dwarf2_invalid_attrib_class_complaint ("DW_AT_vtable_elem_location", 3632 fieldname); 3633 } 3634 } 3635} 3636 3637/* Create the vector of member function fields, and attach it to the type. */ 3638 3639static void 3640dwarf2_attach_fn_fields_to_type (struct field_info *fip, struct type *type, 3641 struct dwarf2_cu *cu) 3642{ 3643 struct fnfieldlist *flp; 3644 int total_length = 0; 3645 int i; 3646 3647 ALLOCATE_CPLUS_STRUCT_TYPE (type); 3648 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *) 3649 TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * fip->nfnfields); 3650 3651 for (i = 0, flp = fip->fnfieldlists; i < fip->nfnfields; i++, flp++) 3652 { 3653 struct nextfnfield *nfp = flp->head; 3654 struct fn_fieldlist *fn_flp = &TYPE_FN_FIELDLIST (type, i); 3655 int k; 3656 3657 TYPE_FN_FIELDLIST_NAME (type, i) = flp->name; 3658 TYPE_FN_FIELDLIST_LENGTH (type, i) = flp->length; 3659 fn_flp->fn_fields = (struct fn_field *) 3660 TYPE_ALLOC (type, sizeof (struct fn_field) * flp->length); 3661 for (k = flp->length; (k--, nfp); nfp = nfp->next) 3662 fn_flp->fn_fields[k] = nfp->fnfield; 3663 3664 total_length += flp->length; 3665 } 3666 3667 TYPE_NFN_FIELDS (type) = fip->nfnfields; 3668 TYPE_NFN_FIELDS_TOTAL (type) = total_length; 3669} 3670 3671 3672/* Returns non-zero if NAME is the name of a vtable member in CU's 3673 language, zero otherwise. */ 3674static int 3675is_vtable_name (const char *name, struct dwarf2_cu *cu) 3676{ 3677 static const char vptr[] = "_vptr"; 3678 static const char vtable[] = "vtable"; 3679 3680 /* Look for the C++ and Java forms of the vtable. */ 3681 if ((cu->language == language_java 3682 && strncmp (name, vtable, sizeof (vtable) - 1) == 0) 3683 || (strncmp (name, vptr, sizeof (vptr) - 1) == 0 3684 && is_cplus_marker (name[sizeof (vptr) - 1]))) 3685 return 1; 3686 3687 return 0; 3688} 3689 3690 3691/* Called when we find the DIE that starts a structure or union scope 3692 (definition) to process all dies that define the members of the 3693 structure or union. 3694 3695 NOTE: we need to call struct_type regardless of whether or not the 3696 DIE has an at_name attribute, since it might be an anonymous 3697 structure or union. This gets the type entered into our set of 3698 user defined types. 3699 3700 However, if the structure is incomplete (an opaque struct/union) 3701 then suppress creating a symbol table entry for it since gdb only 3702 wants to find the one with the complete definition. Note that if 3703 it is complete, we just call new_symbol, which does it's own 3704 checking about whether the struct/union is anonymous or not (and 3705 suppresses creating a symbol table entry itself). */ 3706 3707static void 3708read_structure_type (struct die_info *die, struct dwarf2_cu *cu) 3709{ 3710 struct objfile *objfile = cu->objfile; 3711 struct type *type; 3712 struct attribute *attr; 3713 const char *previous_prefix = processing_current_prefix; 3714 struct cleanup *back_to = NULL; 3715 3716 if (die->type) 3717 return; 3718 3719 type = alloc_type (objfile); 3720 3721 INIT_CPLUS_SPECIFIC (type); 3722 attr = dwarf2_attr (die, DW_AT_name, cu); 3723 if (attr && DW_STRING (attr)) 3724 { 3725 if (cu->language == language_cplus 3726 || cu->language == language_java) 3727 { 3728 char *new_prefix = determine_class_name (die, cu); 3729 TYPE_TAG_NAME (type) = obsavestring (new_prefix, 3730 strlen (new_prefix), 3731 &objfile->objfile_obstack); 3732 back_to = make_cleanup (xfree, new_prefix); 3733 processing_current_prefix = new_prefix; 3734 } 3735 else 3736 { 3737 /* The name is already allocated along with this objfile, so 3738 we don't need to duplicate it for the type. */ 3739 TYPE_TAG_NAME (type) = DW_STRING (attr); 3740 } 3741 } 3742 3743 if (die->tag == DW_TAG_structure_type) 3744 { 3745 TYPE_CODE (type) = TYPE_CODE_STRUCT; 3746 } 3747 else if (die->tag == DW_TAG_union_type) 3748 { 3749 TYPE_CODE (type) = TYPE_CODE_UNION; 3750 } 3751 else 3752 { 3753 /* FIXME: TYPE_CODE_CLASS is currently defined to TYPE_CODE_STRUCT 3754 in gdbtypes.h. */ 3755 TYPE_CODE (type) = TYPE_CODE_CLASS; 3756 } 3757 3758 attr = dwarf2_attr (die, DW_AT_byte_size, cu); 3759 if (attr) 3760 { 3761 TYPE_LENGTH (type) = DW_UNSND (attr); 3762 } 3763 else 3764 { 3765 TYPE_LENGTH (type) = 0; 3766 } 3767 3768 if (die_is_declaration (die, cu)) 3769 TYPE_FLAGS (type) |= TYPE_FLAG_STUB; 3770 3771 /* We need to add the type field to the die immediately so we don't 3772 infinitely recurse when dealing with pointers to the structure 3773 type within the structure itself. */ 3774 set_die_type (die, type, cu); 3775 3776 if (die->child != NULL && ! die_is_declaration (die, cu)) 3777 { 3778 struct field_info fi; 3779 struct die_info *child_die; 3780 struct cleanup *back_to = make_cleanup (null_cleanup, NULL); 3781 3782 memset (&fi, 0, sizeof (struct field_info)); 3783 3784 child_die = die->child; 3785 3786 while (child_die && child_die->tag) 3787 { 3788 if (child_die->tag == DW_TAG_member 3789 || child_die->tag == DW_TAG_variable) 3790 { 3791 /* NOTE: carlton/2002-11-05: A C++ static data member 3792 should be a DW_TAG_member that is a declaration, but 3793 all versions of G++ as of this writing (so through at 3794 least 3.2.1) incorrectly generate DW_TAG_variable 3795 tags for them instead. */ 3796 dwarf2_add_field (&fi, child_die, cu); 3797 } 3798 else if (child_die->tag == DW_TAG_subprogram) 3799 { 3800 /* C++ member function. */ 3801 read_type_die (child_die, cu); 3802 dwarf2_add_member_fn (&fi, child_die, type, cu); 3803 } 3804 else if (child_die->tag == DW_TAG_inheritance) 3805 { 3806 /* C++ base class field. */ 3807 dwarf2_add_field (&fi, child_die, cu); 3808 } 3809 child_die = sibling_die (child_die); 3810 } 3811 3812 /* Attach fields and member functions to the type. */ 3813 if (fi.nfields) 3814 dwarf2_attach_fields_to_type (&fi, type, cu); 3815 if (fi.nfnfields) 3816 { 3817 dwarf2_attach_fn_fields_to_type (&fi, type, cu); 3818 3819 /* Get the type which refers to the base class (possibly this 3820 class itself) which contains the vtable pointer for the current 3821 class from the DW_AT_containing_type attribute. */ 3822 3823 if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL) 3824 { 3825 struct type *t = die_containing_type (die, cu); 3826 3827 TYPE_VPTR_BASETYPE (type) = t; 3828 if (type == t) 3829 { 3830 int i; 3831 3832 /* Our own class provides vtbl ptr. */ 3833 for (i = TYPE_NFIELDS (t) - 1; 3834 i >= TYPE_N_BASECLASSES (t); 3835 --i) 3836 { 3837 char *fieldname = TYPE_FIELD_NAME (t, i); 3838 3839 if (is_vtable_name (fieldname, cu)) 3840 { 3841 TYPE_VPTR_FIELDNO (type) = i; 3842 break; 3843 } 3844 } 3845 3846 /* Complain if virtual function table field not found. */ 3847 if (i < TYPE_N_BASECLASSES (t)) 3848 complaint (&symfile_complaints, 3849 "virtual function table pointer not found when defining class '%s'", 3850 TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) : 3851 ""); 3852 } 3853 else 3854 { 3855 TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t); 3856 } 3857 } 3858 } 3859 3860 do_cleanups (back_to); 3861 } 3862 3863 processing_current_prefix = previous_prefix; 3864 if (back_to != NULL) 3865 do_cleanups (back_to); 3866} 3867 3868static void 3869process_structure_scope (struct die_info *die, struct dwarf2_cu *cu) 3870{ 3871 struct objfile *objfile = cu->objfile; 3872 const char *previous_prefix = processing_current_prefix; 3873 struct die_info *child_die = die->child; 3874 3875 if (TYPE_TAG_NAME (die->type) != NULL) 3876 processing_current_prefix = TYPE_TAG_NAME (die->type); 3877 3878 /* NOTE: carlton/2004-03-16: GCC 3.4 (or at least one of its 3879 snapshots) has been known to create a die giving a declaration 3880 for a class that has, as a child, a die giving a definition for a 3881 nested class. So we have to process our children even if the 3882 current die is a declaration. Normally, of course, a declaration 3883 won't have any children at all. */ 3884 3885 while (child_die != NULL && child_die->tag) 3886 { 3887 if (child_die->tag == DW_TAG_member 3888 || child_die->tag == DW_TAG_variable 3889 || child_die->tag == DW_TAG_inheritance) 3890 { 3891 /* Do nothing. */ 3892 } 3893 else 3894 process_die (child_die, cu); 3895 3896 child_die = sibling_die (child_die); 3897 } 3898 3899 if (die->child != NULL && ! die_is_declaration (die, cu)) 3900 new_symbol (die, die->type, cu); 3901 3902 processing_current_prefix = previous_prefix; 3903} 3904 3905/* Given a DW_AT_enumeration_type die, set its type. We do not 3906 complete the type's fields yet, or create any symbols. */ 3907 3908static void 3909read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu) 3910{ 3911 struct objfile *objfile = cu->objfile; 3912 struct type *type; 3913 struct attribute *attr; 3914 3915 if (die->type) 3916 return; 3917 3918 type = alloc_type (objfile); 3919 3920 TYPE_CODE (type) = TYPE_CODE_ENUM; 3921 attr = dwarf2_attr (die, DW_AT_name, cu); 3922 if (attr && DW_STRING (attr)) 3923 { 3924 char *name = DW_STRING (attr); 3925 3926 if (processing_has_namespace_info) 3927 { 3928 TYPE_TAG_NAME (type) = typename_concat (&objfile->objfile_obstack, 3929 processing_current_prefix, 3930 name, cu); 3931 } 3932 else 3933 { 3934 /* The name is already allocated along with this objfile, so 3935 we don't need to duplicate it for the type. */ 3936 TYPE_TAG_NAME (type) = name; 3937 } 3938 } 3939 3940 attr = dwarf2_attr (die, DW_AT_byte_size, cu); 3941 if (attr) 3942 { 3943 TYPE_LENGTH (type) = DW_UNSND (attr); 3944 } 3945 else 3946 { 3947 TYPE_LENGTH (type) = 0; 3948 } 3949 3950 set_die_type (die, type, cu); 3951} 3952 3953/* Determine the name of the type represented by DIE, which should be 3954 a named C++ or Java compound type. Return the name in question; the caller 3955 is responsible for xfree()'ing it. */ 3956 3957static char * 3958determine_class_name (struct die_info *die, struct dwarf2_cu *cu) 3959{ 3960 struct cleanup *back_to = NULL; 3961 struct die_info *spec_die = die_specification (die, cu); 3962 char *new_prefix = NULL; 3963 3964 /* If this is the definition of a class that is declared by another 3965 die, then processing_current_prefix may not be accurate; see 3966 read_func_scope for a similar example. */ 3967 if (spec_die != NULL) 3968 { 3969 char *specification_prefix = determine_prefix (spec_die, cu); 3970 processing_current_prefix = specification_prefix; 3971 back_to = make_cleanup (xfree, specification_prefix); 3972 } 3973 3974 /* If we don't have namespace debug info, guess the name by trying 3975 to demangle the names of members, just like we did in 3976 guess_structure_name. */ 3977 if (!processing_has_namespace_info) 3978 { 3979 struct die_info *child; 3980 3981 for (child = die->child; 3982 child != NULL && child->tag != 0; 3983 child = sibling_die (child)) 3984 { 3985 if (child->tag == DW_TAG_subprogram) 3986 { 3987 new_prefix 3988 = language_class_name_from_physname (cu->language_defn, 3989 dwarf2_linkage_name 3990 (child, cu)); 3991 3992 if (new_prefix != NULL) 3993 break; 3994 } 3995 } 3996 } 3997 3998 if (new_prefix == NULL) 3999 { 4000 const char *name = dwarf2_name (die, cu); 4001 new_prefix = typename_concat (NULL, processing_current_prefix, 4002 name ? name : "<<anonymous>>", 4003 cu); 4004 } 4005 4006 if (back_to != NULL) 4007 do_cleanups (back_to); 4008 4009 return new_prefix; 4010} 4011 4012/* Given a pointer to a die which begins an enumeration, process all 4013 the dies that define the members of the enumeration, and create the 4014 symbol for the enumeration type. 4015 4016 NOTE: We reverse the order of the element list. */ 4017 4018static void 4019process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu) 4020{ 4021 struct objfile *objfile = cu->objfile; 4022 struct die_info *child_die; 4023 struct field *fields; 4024 struct attribute *attr; 4025 struct symbol *sym; 4026 int num_fields; 4027 int unsigned_enum = 1; 4028 4029 num_fields = 0; 4030 fields = NULL; 4031 if (die->child != NULL) 4032 { 4033 child_die = die->child; 4034 while (child_die && child_die->tag) 4035 { 4036 if (child_die->tag != DW_TAG_enumerator) 4037 { 4038 process_die (child_die, cu); 4039 } 4040 else 4041 { 4042 attr = dwarf2_attr (child_die, DW_AT_name, cu); 4043 if (attr) 4044 { 4045 sym = new_symbol (child_die, die->type, cu); 4046 if (SYMBOL_VALUE (sym) < 0) 4047 unsigned_enum = 0; 4048 4049 if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0) 4050 { 4051 fields = (struct field *) 4052 xrealloc (fields, 4053 (num_fields + DW_FIELD_ALLOC_CHUNK) 4054 * sizeof (struct field)); 4055 } 4056 4057 FIELD_NAME (fields[num_fields]) = DEPRECATED_SYMBOL_NAME (sym); 4058 FIELD_TYPE (fields[num_fields]) = NULL; 4059 FIELD_BITPOS (fields[num_fields]) = SYMBOL_VALUE (sym); 4060 FIELD_BITSIZE (fields[num_fields]) = 0; 4061 FIELD_STATIC_KIND (fields[num_fields]) = 0; 4062 4063 num_fields++; 4064 } 4065 } 4066 4067 child_die = sibling_die (child_die); 4068 } 4069 4070 if (num_fields) 4071 { 4072 TYPE_NFIELDS (die->type) = num_fields; 4073 TYPE_FIELDS (die->type) = (struct field *) 4074 TYPE_ALLOC (die->type, sizeof (struct field) * num_fields); 4075 memcpy (TYPE_FIELDS (die->type), fields, 4076 sizeof (struct field) * num_fields); 4077 xfree (fields); 4078 } 4079 if (unsigned_enum) 4080 TYPE_FLAGS (die->type) |= TYPE_FLAG_UNSIGNED; 4081 } 4082 4083 new_symbol (die, die->type, cu); 4084} 4085 4086/* Extract all information from a DW_TAG_array_type DIE and put it in 4087 the DIE's type field. For now, this only handles one dimensional 4088 arrays. */ 4089 4090static void 4091read_array_type (struct die_info *die, struct dwarf2_cu *cu) 4092{ 4093 struct objfile *objfile = cu->objfile; 4094 struct die_info *child_die; 4095 struct type *type = NULL; 4096 struct type *element_type, *range_type, *index_type; 4097 struct type **range_types = NULL; 4098 struct attribute *attr; 4099 int ndim = 0; 4100 struct cleanup *back_to; 4101 4102 /* Return if we've already decoded this type. */ 4103 if (die->type) 4104 { 4105 return; 4106 } 4107 4108 element_type = die_type (die, cu); 4109 4110 /* Irix 6.2 native cc creates array types without children for 4111 arrays with unspecified length. */ 4112 if (die->child == NULL) 4113 { 4114 index_type = dwarf2_fundamental_type (objfile, FT_INTEGER, cu); 4115 range_type = create_range_type (NULL, index_type, 0, -1); 4116 set_die_type (die, create_array_type (NULL, element_type, range_type), 4117 cu); 4118 return; 4119 } 4120 4121 back_to = make_cleanup (null_cleanup, NULL); 4122 child_die = die->child; 4123 while (child_die && child_die->tag) 4124 { 4125 if (child_die->tag == DW_TAG_subrange_type) 4126 { 4127 read_subrange_type (child_die, cu); 4128 4129 if (child_die->type != NULL) 4130 { 4131 /* The range type was succesfully read. Save it for 4132 the array type creation. */ 4133 if ((ndim % DW_FIELD_ALLOC_CHUNK) == 0) 4134 { 4135 range_types = (struct type **) 4136 xrealloc (range_types, (ndim + DW_FIELD_ALLOC_CHUNK) 4137 * sizeof (struct type *)); 4138 if (ndim == 0) 4139 make_cleanup (free_current_contents, &range_types); 4140 } 4141 range_types[ndim++] = child_die->type; 4142 } 4143 } 4144 child_die = sibling_die (child_die); 4145 } 4146 4147 /* Dwarf2 dimensions are output from left to right, create the 4148 necessary array types in backwards order. */ 4149 4150 type = element_type; 4151 4152 if (read_array_order (die, cu) == DW_ORD_col_major) 4153 { 4154 int i = 0; 4155 while (i < ndim) 4156 type = create_array_type (NULL, type, range_types[i++]); 4157 } 4158 else 4159 { 4160 while (ndim-- > 0) 4161 type = create_array_type (NULL, type, range_types[ndim]); 4162 } 4163 4164 /* Understand Dwarf2 support for vector types (like they occur on 4165 the PowerPC w/ AltiVec). Gcc just adds another attribute to the 4166 array type. This is not part of the Dwarf2/3 standard yet, but a 4167 custom vendor extension. The main difference between a regular 4168 array and the vector variant is that vectors are passed by value 4169 to functions. */ 4170 attr = dwarf2_attr (die, DW_AT_GNU_vector, cu); 4171 if (attr) 4172 TYPE_FLAGS (type) |= TYPE_FLAG_VECTOR; 4173 4174 do_cleanups (back_to); 4175 4176 /* Install the type in the die. */ 4177 set_die_type (die, type, cu); 4178} 4179 4180static enum dwarf_array_dim_ordering 4181read_array_order (struct die_info *die, struct dwarf2_cu *cu) 4182{ 4183 struct attribute *attr; 4184 4185 attr = dwarf2_attr (die, DW_AT_ordering, cu); 4186 4187 if (attr) return DW_SND (attr); 4188 4189 /* 4190 GNU F77 is a special case, as at 08/2004 array type info is the 4191 opposite order to the dwarf2 specification, but data is still 4192 laid out as per normal fortran. 4193 4194 FIXME: dsl/2004-8-20: If G77 is ever fixed, this will also need 4195 version checking. 4196 */ 4197 4198 if (cu->language == language_fortran && 4199 cu->producer && strstr (cu->producer, "GNU F77")) 4200 { 4201 return DW_ORD_row_major; 4202 } 4203 4204 switch (cu->language_defn->la_array_ordering) 4205 { 4206 case array_column_major: 4207 return DW_ORD_col_major; 4208 case array_row_major: 4209 default: 4210 return DW_ORD_row_major; 4211 }; 4212} 4213 4214 4215/* First cut: install each common block member as a global variable. */ 4216 4217static void 4218read_common_block (struct die_info *die, struct dwarf2_cu *cu) 4219{ 4220 struct die_info *child_die; 4221 struct attribute *attr; 4222 struct symbol *sym; 4223 CORE_ADDR base = (CORE_ADDR) 0; 4224 4225 attr = dwarf2_attr (die, DW_AT_location, cu); 4226 if (attr) 4227 { 4228 /* Support the .debug_loc offsets */ 4229 if (attr_form_is_block (attr)) 4230 { 4231 base = decode_locdesc (DW_BLOCK (attr), cu); 4232 } 4233 else if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8) 4234 { 4235 dwarf2_complex_location_expr_complaint (); 4236 } 4237 else 4238 { 4239 dwarf2_invalid_attrib_class_complaint ("DW_AT_location", 4240 "common block member"); 4241 } 4242 } 4243 if (die->child != NULL) 4244 { 4245 child_die = die->child; 4246 while (child_die && child_die->tag) 4247 { 4248 sym = new_symbol (child_die, NULL, cu); 4249 attr = dwarf2_attr (child_die, DW_AT_data_member_location, cu); 4250 if (attr) 4251 { 4252 SYMBOL_VALUE_ADDRESS (sym) = 4253 base + decode_locdesc (DW_BLOCK (attr), cu); 4254 add_symbol_to_list (sym, &global_symbols); 4255 } 4256 child_die = sibling_die (child_die); 4257 } 4258 } 4259} 4260 4261/* Read a C++ namespace. */ 4262 4263static void 4264read_namespace (struct die_info *die, struct dwarf2_cu *cu) 4265{ 4266 struct objfile *objfile = cu->objfile; 4267 const char *previous_prefix = processing_current_prefix; 4268 const char *name; 4269 int is_anonymous; 4270 struct die_info *current_die; 4271 struct cleanup *back_to = make_cleanup (null_cleanup, 0); 4272 4273 name = namespace_name (die, &is_anonymous, cu); 4274 4275 /* Now build the name of the current namespace. */ 4276 4277 if (previous_prefix[0] == '\0') 4278 { 4279 processing_current_prefix = name; 4280 } 4281 else 4282 { 4283 char *temp_name = typename_concat (NULL, previous_prefix, name, cu); 4284 make_cleanup (xfree, temp_name); 4285 processing_current_prefix = temp_name; 4286 } 4287 4288 /* Add a symbol associated to this if we haven't seen the namespace 4289 before. Also, add a using directive if it's an anonymous 4290 namespace. */ 4291 4292 if (dwarf2_extension (die, cu) == NULL) 4293 { 4294 struct type *type; 4295 4296 /* FIXME: carlton/2003-06-27: Once GDB is more const-correct, 4297 this cast will hopefully become unnecessary. */ 4298 type = init_type (TYPE_CODE_NAMESPACE, 0, 0, 4299 (char *) processing_current_prefix, 4300 objfile); 4301 TYPE_TAG_NAME (type) = TYPE_NAME (type); 4302 4303 new_symbol (die, type, cu); 4304 set_die_type (die, type, cu); 4305 4306 if (is_anonymous) 4307 cp_add_using_directive (processing_current_prefix, 4308 strlen (previous_prefix), 4309 strlen (processing_current_prefix)); 4310 } 4311 4312 if (die->child != NULL) 4313 { 4314 struct die_info *child_die = die->child; 4315 4316 while (child_die && child_die->tag) 4317 { 4318 process_die (child_die, cu); 4319 child_die = sibling_die (child_die); 4320 } 4321 } 4322 4323 processing_current_prefix = previous_prefix; 4324 do_cleanups (back_to); 4325} 4326 4327/* Return the name of the namespace represented by DIE. Set 4328 *IS_ANONYMOUS to tell whether or not the namespace is an anonymous 4329 namespace. */ 4330 4331static const char * 4332namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu) 4333{ 4334 struct die_info *current_die; 4335 const char *name = NULL; 4336 4337 /* Loop through the extensions until we find a name. */ 4338 4339 for (current_die = die; 4340 current_die != NULL; 4341 current_die = dwarf2_extension (die, cu)) 4342 { 4343 name = dwarf2_name (current_die, cu); 4344 if (name != NULL) 4345 break; 4346 } 4347 4348 /* Is it an anonymous namespace? */ 4349 4350 *is_anonymous = (name == NULL); 4351 if (*is_anonymous) 4352 name = "(anonymous namespace)"; 4353 4354 return name; 4355} 4356 4357/* Extract all information from a DW_TAG_pointer_type DIE and add to 4358 the user defined type vector. */ 4359 4360static void 4361read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu) 4362{ 4363 struct comp_unit_head *cu_header = &cu->header; 4364 struct type *type; 4365 struct attribute *attr_byte_size; 4366 struct attribute *attr_address_class; 4367 int byte_size, addr_class; 4368 4369 if (die->type) 4370 { 4371 return; 4372 } 4373 4374 type = lookup_pointer_type (die_type (die, cu)); 4375 4376 attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu); 4377 if (attr_byte_size) 4378 byte_size = DW_UNSND (attr_byte_size); 4379 else 4380 byte_size = cu_header->addr_size; 4381 4382 attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu); 4383 if (attr_address_class) 4384 addr_class = DW_UNSND (attr_address_class); 4385 else 4386 addr_class = DW_ADDR_none; 4387 4388 /* If the pointer size or address class is different than the 4389 default, create a type variant marked as such and set the 4390 length accordingly. */ 4391 if (TYPE_LENGTH (type) != byte_size || addr_class != DW_ADDR_none) 4392 { 4393 if (ADDRESS_CLASS_TYPE_FLAGS_P ()) 4394 { 4395 int type_flags; 4396 4397 type_flags = ADDRESS_CLASS_TYPE_FLAGS (byte_size, addr_class); 4398 gdb_assert ((type_flags & ~TYPE_FLAG_ADDRESS_CLASS_ALL) == 0); 4399 type = make_type_with_address_space (type, type_flags); 4400 } 4401 else if (TYPE_LENGTH (type) != byte_size) 4402 { 4403 complaint (&symfile_complaints, "invalid pointer size %d", byte_size); 4404 } 4405 else { 4406 /* Should we also complain about unhandled address classes? */ 4407 } 4408 } 4409 4410 TYPE_LENGTH (type) = byte_size; 4411 set_die_type (die, type, cu); 4412} 4413 4414/* Extract all information from a DW_TAG_ptr_to_member_type DIE and add to 4415 the user defined type vector. */ 4416 4417static void 4418read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu) 4419{ 4420 struct objfile *objfile = cu->objfile; 4421 struct type *type; 4422 struct type *to_type; 4423 struct type *domain; 4424 4425 if (die->type) 4426 { 4427 return; 4428 } 4429 4430 type = alloc_type (objfile); 4431 to_type = die_type (die, cu); 4432 domain = die_containing_type (die, cu); 4433 smash_to_member_type (type, domain, to_type); 4434 4435 set_die_type (die, type, cu); 4436} 4437 4438/* Extract all information from a DW_TAG_reference_type DIE and add to 4439 the user defined type vector. */ 4440 4441static void 4442read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu) 4443{ 4444 struct comp_unit_head *cu_header = &cu->header; 4445 struct type *type; 4446 struct attribute *attr; 4447 4448 if (die->type) 4449 { 4450 return; 4451 } 4452 4453 type = lookup_reference_type (die_type (die, cu)); 4454 attr = dwarf2_attr (die, DW_AT_byte_size, cu); 4455 if (attr) 4456 { 4457 TYPE_LENGTH (type) = DW_UNSND (attr); 4458 } 4459 else 4460 { 4461 TYPE_LENGTH (type) = cu_header->addr_size; 4462 } 4463 set_die_type (die, type, cu); 4464} 4465 4466static void 4467read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu) 4468{ 4469 struct type *base_type; 4470 4471 if (die->type) 4472 { 4473 return; 4474 } 4475 4476 base_type = die_type (die, cu); 4477 set_die_type (die, make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0), 4478 cu); 4479} 4480 4481static void 4482read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu) 4483{ 4484 struct type *base_type; 4485 4486 if (die->type) 4487 { 4488 return; 4489 } 4490 4491 base_type = die_type (die, cu); 4492 set_die_type (die, make_cv_type (TYPE_CONST (base_type), 1, base_type, 0), 4493 cu); 4494} 4495 4496/* Extract all information from a DW_TAG_string_type DIE and add to 4497 the user defined type vector. It isn't really a user defined type, 4498 but it behaves like one, with other DIE's using an AT_user_def_type 4499 attribute to reference it. */ 4500 4501static void 4502read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu) 4503{ 4504 struct objfile *objfile = cu->objfile; 4505 struct type *type, *range_type, *index_type, *char_type; 4506 struct attribute *attr; 4507 unsigned int length; 4508 4509 if (die->type) 4510 { 4511 return; 4512 } 4513 4514 attr = dwarf2_attr (die, DW_AT_string_length, cu); 4515 if (attr) 4516 { 4517 length = DW_UNSND (attr); 4518 } 4519 else 4520 { 4521 /* check for the DW_AT_byte_size attribute */ 4522 attr = dwarf2_attr (die, DW_AT_byte_size, cu); 4523 if (attr) 4524 { 4525 length = DW_UNSND (attr); 4526 } 4527 else 4528 { 4529 length = 1; 4530 } 4531 } 4532 index_type = dwarf2_fundamental_type (objfile, FT_INTEGER, cu); 4533 range_type = create_range_type (NULL, index_type, 1, length); 4534 if (cu->language == language_fortran) 4535 { 4536 /* Need to create a unique string type for bounds 4537 information */ 4538 type = create_string_type (0, range_type); 4539 } 4540 else 4541 { 4542 char_type = dwarf2_fundamental_type (objfile, FT_CHAR, cu); 4543 type = create_string_type (char_type, range_type); 4544 } 4545 set_die_type (die, type, cu); 4546} 4547 4548/* Handle DIES due to C code like: 4549 4550 struct foo 4551 { 4552 int (*funcp)(int a, long l); 4553 int b; 4554 }; 4555 4556 ('funcp' generates a DW_TAG_subroutine_type DIE) 4557 */ 4558 4559static void 4560read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu) 4561{ 4562 struct type *type; /* Type that this function returns */ 4563 struct type *ftype; /* Function that returns above type */ 4564 struct attribute *attr; 4565 4566 /* Decode the type that this subroutine returns */ 4567 if (die->type) 4568 { 4569 return; 4570 } 4571 type = die_type (die, cu); 4572 ftype = make_function_type (type, (struct type **) 0); 4573 4574 /* All functions in C++ and Java have prototypes. */ 4575 attr = dwarf2_attr (die, DW_AT_prototyped, cu); 4576 if ((attr && (DW_UNSND (attr) != 0)) 4577 || cu->language == language_cplus 4578 || cu->language == language_java) 4579 TYPE_FLAGS (ftype) |= TYPE_FLAG_PROTOTYPED; 4580 4581 if (die->child != NULL) 4582 { 4583 struct die_info *child_die; 4584 int nparams = 0; 4585 int iparams = 0; 4586 4587 /* Count the number of parameters. 4588 FIXME: GDB currently ignores vararg functions, but knows about 4589 vararg member functions. */ 4590 child_die = die->child; 4591 while (child_die && child_die->tag) 4592 { 4593 if (child_die->tag == DW_TAG_formal_parameter) 4594 nparams++; 4595 else if (child_die->tag == DW_TAG_unspecified_parameters) 4596 TYPE_FLAGS (ftype) |= TYPE_FLAG_VARARGS; 4597 child_die = sibling_die (child_die); 4598 } 4599 4600 /* Allocate storage for parameters and fill them in. */ 4601 TYPE_NFIELDS (ftype) = nparams; 4602 TYPE_FIELDS (ftype) = (struct field *) 4603 TYPE_ALLOC (ftype, nparams * sizeof (struct field)); 4604 4605 child_die = die->child; 4606 while (child_die && child_die->tag) 4607 { 4608 if (child_die->tag == DW_TAG_formal_parameter) 4609 { 4610 /* Dwarf2 has no clean way to discern C++ static and non-static 4611 member functions. G++ helps GDB by marking the first 4612 parameter for non-static member functions (which is the 4613 this pointer) as artificial. We pass this information 4614 to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */ 4615 attr = dwarf2_attr (child_die, DW_AT_artificial, cu); 4616 if (attr) 4617 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr); 4618 else 4619 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0; 4620 TYPE_FIELD_TYPE (ftype, iparams) = die_type (child_die, cu); 4621 iparams++; 4622 } 4623 child_die = sibling_die (child_die); 4624 } 4625 } 4626 4627 set_die_type (die, ftype, cu); 4628} 4629 4630static void 4631read_typedef (struct die_info *die, struct dwarf2_cu *cu) 4632{ 4633 struct objfile *objfile = cu->objfile; 4634 struct attribute *attr; 4635 char *name = NULL; 4636 4637 if (!die->type) 4638 { 4639 attr = dwarf2_attr (die, DW_AT_name, cu); 4640 if (attr && DW_STRING (attr)) 4641 { 4642 name = DW_STRING (attr); 4643 } 4644 set_die_type (die, init_type (TYPE_CODE_TYPEDEF, 0, 4645 TYPE_FLAG_TARGET_STUB, name, objfile), 4646 cu); 4647 TYPE_TARGET_TYPE (die->type) = die_type (die, cu); 4648 } 4649} 4650 4651/* Find a representation of a given base type and install 4652 it in the TYPE field of the die. */ 4653 4654static void 4655read_base_type (struct die_info *die, struct dwarf2_cu *cu) 4656{ 4657 struct objfile *objfile = cu->objfile; 4658 struct type *type; 4659 struct attribute *attr; 4660 int encoding = 0, size = 0; 4661 4662 /* If we've already decoded this die, this is a no-op. */ 4663 if (die->type) 4664 { 4665 return; 4666 } 4667 4668 attr = dwarf2_attr (die, DW_AT_encoding, cu); 4669 if (attr) 4670 { 4671 encoding = DW_UNSND (attr); 4672 } 4673 attr = dwarf2_attr (die, DW_AT_byte_size, cu); 4674 if (attr) 4675 { 4676 size = DW_UNSND (attr); 4677 } 4678 attr = dwarf2_attr (die, DW_AT_name, cu); 4679 if (attr && DW_STRING (attr)) 4680 { 4681 enum type_code code = TYPE_CODE_INT; 4682 int type_flags = 0; 4683 4684 switch (encoding) 4685 { 4686 case DW_ATE_address: 4687 /* Turn DW_ATE_address into a void * pointer. */ 4688 code = TYPE_CODE_PTR; 4689 type_flags |= TYPE_FLAG_UNSIGNED; 4690 break; 4691 case DW_ATE_boolean: 4692 code = TYPE_CODE_BOOL; 4693 type_flags |= TYPE_FLAG_UNSIGNED; 4694 break; 4695 case DW_ATE_complex_float: 4696 code = TYPE_CODE_COMPLEX; 4697 break; 4698 case DW_ATE_float: 4699 code = TYPE_CODE_FLT; 4700 break; 4701 case DW_ATE_signed: 4702 case DW_ATE_signed_char: 4703 break; 4704 case DW_ATE_unsigned: 4705 case DW_ATE_unsigned_char: 4706 type_flags |= TYPE_FLAG_UNSIGNED; 4707 break; 4708 default: 4709 complaint (&symfile_complaints, "unsupported DW_AT_encoding: '%s'", 4710 dwarf_type_encoding_name (encoding)); 4711 break; 4712 } 4713 type = init_type (code, size, type_flags, DW_STRING (attr), objfile); 4714 if (encoding == DW_ATE_address) 4715 TYPE_TARGET_TYPE (type) = dwarf2_fundamental_type (objfile, FT_VOID, 4716 cu); 4717 else if (encoding == DW_ATE_complex_float) 4718 { 4719 if (size == 32) 4720 TYPE_TARGET_TYPE (type) 4721 = dwarf2_fundamental_type (objfile, FT_EXT_PREC_FLOAT, cu); 4722 else if (size == 16) 4723 TYPE_TARGET_TYPE (type) 4724 = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT, cu); 4725 else if (size == 8) 4726 TYPE_TARGET_TYPE (type) 4727 = dwarf2_fundamental_type (objfile, FT_FLOAT, cu); 4728 } 4729 } 4730 else 4731 { 4732 type = dwarf_base_type (encoding, size, cu); 4733 } 4734 set_die_type (die, type, cu); 4735} 4736 4737/* Read the given DW_AT_subrange DIE. */ 4738 4739static void 4740read_subrange_type (struct die_info *die, struct dwarf2_cu *cu) 4741{ 4742 struct type *base_type; 4743 struct type *range_type; 4744 struct attribute *attr; 4745 int low = 0; 4746 int high = -1; 4747 4748 /* If we have already decoded this die, then nothing more to do. */ 4749 if (die->type) 4750 return; 4751 4752 base_type = die_type (die, cu); 4753 if (base_type == NULL) 4754 { 4755 complaint (&symfile_complaints, 4756 "DW_AT_type missing from DW_TAG_subrange_type"); 4757 return; 4758 } 4759 4760 if (TYPE_CODE (base_type) == TYPE_CODE_VOID) 4761 base_type = alloc_type (NULL); 4762 4763 if (cu->language == language_fortran) 4764 { 4765 /* FORTRAN implies a lower bound of 1, if not given. */ 4766 low = 1; 4767 } 4768 4769 /* FIXME: For variable sized arrays either of these could be 4770 a variable rather than a constant value. We'll allow it, 4771 but we don't know how to handle it. */ 4772 attr = dwarf2_attr (die, DW_AT_lower_bound, cu); 4773 if (attr) 4774 low = dwarf2_get_attr_constant_value (attr, 0); 4775 4776 attr = dwarf2_attr (die, DW_AT_upper_bound, cu); 4777 if (attr) 4778 { 4779 if (attr->form == DW_FORM_block1) 4780 { 4781 /* GCC encodes arrays with unspecified or dynamic length 4782 with a DW_FORM_block1 attribute. 4783 FIXME: GDB does not yet know how to handle dynamic 4784 arrays properly, treat them as arrays with unspecified 4785 length for now. 4786 4787 FIXME: jimb/2003-09-22: GDB does not really know 4788 how to handle arrays of unspecified length 4789 either; we just represent them as zero-length 4790 arrays. Choose an appropriate upper bound given 4791 the lower bound we've computed above. */ 4792 high = low - 1; 4793 } 4794 else 4795 high = dwarf2_get_attr_constant_value (attr, 1); 4796 } 4797 4798 range_type = create_range_type (NULL, base_type, low, high); 4799 4800 attr = dwarf2_attr (die, DW_AT_name, cu); 4801 if (attr && DW_STRING (attr)) 4802 TYPE_NAME (range_type) = DW_STRING (attr); 4803 4804 attr = dwarf2_attr (die, DW_AT_byte_size, cu); 4805 if (attr) 4806 TYPE_LENGTH (range_type) = DW_UNSND (attr); 4807 4808 set_die_type (die, range_type, cu); 4809} 4810 4811 4812/* Read a whole compilation unit into a linked list of dies. */ 4813 4814static struct die_info * 4815read_comp_unit (char *info_ptr, bfd *abfd, struct dwarf2_cu *cu) 4816{ 4817 return read_die_and_children (info_ptr, abfd, cu, &info_ptr, NULL); 4818} 4819 4820/* Read a single die and all its descendents. Set the die's sibling 4821 field to NULL; set other fields in the die correctly, and set all 4822 of the descendents' fields correctly. Set *NEW_INFO_PTR to the 4823 location of the info_ptr after reading all of those dies. PARENT 4824 is the parent of the die in question. */ 4825 4826static struct die_info * 4827read_die_and_children (char *info_ptr, bfd *abfd, 4828 struct dwarf2_cu *cu, 4829 char **new_info_ptr, 4830 struct die_info *parent) 4831{ 4832 struct die_info *die; 4833 char *cur_ptr; 4834 int has_children; 4835 4836 cur_ptr = read_full_die (&die, abfd, info_ptr, cu, &has_children); 4837 store_in_ref_table (die->offset, die, cu); 4838 4839 if (has_children) 4840 { 4841 die->child = read_die_and_siblings (cur_ptr, abfd, cu, 4842 new_info_ptr, die); 4843 } 4844 else 4845 { 4846 die->child = NULL; 4847 *new_info_ptr = cur_ptr; 4848 } 4849 4850 die->sibling = NULL; 4851 die->parent = parent; 4852 return die; 4853} 4854 4855/* Read a die, all of its descendents, and all of its siblings; set 4856 all of the fields of all of the dies correctly. Arguments are as 4857 in read_die_and_children. */ 4858 4859static struct die_info * 4860read_die_and_siblings (char *info_ptr, bfd *abfd, 4861 struct dwarf2_cu *cu, 4862 char **new_info_ptr, 4863 struct die_info *parent) 4864{ 4865 struct die_info *first_die, *last_sibling; 4866 char *cur_ptr; 4867 4868 cur_ptr = info_ptr; 4869 first_die = last_sibling = NULL; 4870 4871 while (1) 4872 { 4873 struct die_info *die 4874 = read_die_and_children (cur_ptr, abfd, cu, &cur_ptr, parent); 4875 4876 if (!first_die) 4877 { 4878 first_die = die; 4879 } 4880 else 4881 { 4882 last_sibling->sibling = die; 4883 } 4884 4885 if (die->tag == 0) 4886 { 4887 *new_info_ptr = cur_ptr; 4888 return first_die; 4889 } 4890 else 4891 { 4892 last_sibling = die; 4893 } 4894 } 4895} 4896 4897/* Free a linked list of dies. */ 4898 4899static void 4900free_die_list (struct die_info *dies) 4901{ 4902 struct die_info *die, *next; 4903 4904 die = dies; 4905 while (die) 4906 { 4907 if (die->child != NULL) 4908 free_die_list (die->child); 4909 next = die->sibling; 4910 xfree (die->attrs); 4911 xfree (die); 4912 die = next; 4913 } 4914} 4915 4916/* Read the contents of the section at OFFSET and of size SIZE from the 4917 object file specified by OBJFILE into the objfile_obstack and return it. */ 4918 4919char * 4920dwarf2_read_section (struct objfile *objfile, asection *sectp) 4921{ 4922 bfd *abfd = objfile->obfd; 4923 char *buf, *retbuf; 4924 bfd_size_type size = bfd_get_section_size (sectp); 4925 4926 if (size == 0) 4927 return NULL; 4928 4929 buf = (char *) obstack_alloc (&objfile->objfile_obstack, size); 4930 retbuf 4931 = (char *) symfile_relocate_debug_section (abfd, sectp, (bfd_byte *) buf); 4932 if (retbuf != NULL) 4933 return retbuf; 4934 4935 if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0 4936 || bfd_bread (buf, size, abfd) != size) 4937 error ("Dwarf Error: Can't read DWARF data from '%s'", 4938 bfd_get_filename (abfd)); 4939 4940 return buf; 4941} 4942 4943/* In DWARF version 2, the description of the debugging information is 4944 stored in a separate .debug_abbrev section. Before we read any 4945 dies from a section we read in all abbreviations and install them 4946 in a hash table. This function also sets flags in CU describing 4947 the data found in the abbrev table. */ 4948 4949static void 4950dwarf2_read_abbrevs (bfd *abfd, struct dwarf2_cu *cu) 4951{ 4952 struct comp_unit_head *cu_header = &cu->header; 4953 char *abbrev_ptr; 4954 struct abbrev_info *cur_abbrev; 4955 unsigned int abbrev_number, bytes_read, abbrev_name; 4956 unsigned int abbrev_form, hash_number; 4957 struct attr_abbrev *cur_attrs; 4958 unsigned int allocated_attrs; 4959 4960 /* Initialize dwarf2 abbrevs */ 4961 obstack_init (&cu->abbrev_obstack); 4962 cu->dwarf2_abbrevs = obstack_alloc (&cu->abbrev_obstack, 4963 (ABBREV_HASH_SIZE 4964 * sizeof (struct abbrev_info *))); 4965 memset (cu->dwarf2_abbrevs, 0, 4966 ABBREV_HASH_SIZE * sizeof (struct abbrev_info *)); 4967 4968 abbrev_ptr = dwarf2_per_objfile->abbrev_buffer + cu_header->abbrev_offset; 4969 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); 4970 abbrev_ptr += bytes_read; 4971 4972 allocated_attrs = ATTR_ALLOC_CHUNK; 4973 cur_attrs = xmalloc (allocated_attrs * sizeof (struct attr_abbrev)); 4974 4975 /* loop until we reach an abbrev number of 0 */ 4976 while (abbrev_number) 4977 { 4978 cur_abbrev = dwarf_alloc_abbrev (cu); 4979 4980 /* read in abbrev header */ 4981 cur_abbrev->number = abbrev_number; 4982 cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); 4983 abbrev_ptr += bytes_read; 4984 cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr); 4985 abbrev_ptr += 1; 4986 4987 if (cur_abbrev->tag == DW_TAG_namespace) 4988 cu->has_namespace_info = 1; 4989 4990 /* now read in declarations */ 4991 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); 4992 abbrev_ptr += bytes_read; 4993 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); 4994 abbrev_ptr += bytes_read; 4995 while (abbrev_name) 4996 { 4997 if (cur_abbrev->num_attrs == allocated_attrs) 4998 { 4999 allocated_attrs += ATTR_ALLOC_CHUNK; 5000 cur_attrs 5001 = xrealloc (cur_attrs, (allocated_attrs 5002 * sizeof (struct attr_abbrev))); 5003 } 5004 5005 /* Record whether this compilation unit might have 5006 inter-compilation-unit references. If we don't know what form 5007 this attribute will have, then it might potentially be a 5008 DW_FORM_ref_addr, so we conservatively expect inter-CU 5009 references. */ 5010 5011 if (abbrev_form == DW_FORM_ref_addr 5012 || abbrev_form == DW_FORM_indirect) 5013 cu->has_form_ref_addr = 1; 5014 5015 cur_attrs[cur_abbrev->num_attrs].name = abbrev_name; 5016 cur_attrs[cur_abbrev->num_attrs++].form = abbrev_form; 5017 abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); 5018 abbrev_ptr += bytes_read; 5019 abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); 5020 abbrev_ptr += bytes_read; 5021 } 5022 5023 cur_abbrev->attrs = obstack_alloc (&cu->abbrev_obstack, 5024 (cur_abbrev->num_attrs 5025 * sizeof (struct attr_abbrev))); 5026 memcpy (cur_abbrev->attrs, cur_attrs, 5027 cur_abbrev->num_attrs * sizeof (struct attr_abbrev)); 5028 5029 hash_number = abbrev_number % ABBREV_HASH_SIZE; 5030 cur_abbrev->next = cu->dwarf2_abbrevs[hash_number]; 5031 cu->dwarf2_abbrevs[hash_number] = cur_abbrev; 5032 5033 /* Get next abbreviation. 5034 Under Irix6 the abbreviations for a compilation unit are not 5035 always properly terminated with an abbrev number of 0. 5036 Exit loop if we encounter an abbreviation which we have 5037 already read (which means we are about to read the abbreviations 5038 for the next compile unit) or if the end of the abbreviation 5039 table is reached. */ 5040 if ((unsigned int) (abbrev_ptr - dwarf2_per_objfile->abbrev_buffer) 5041 >= dwarf2_per_objfile->abbrev_size) 5042 break; 5043 abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read); 5044 abbrev_ptr += bytes_read; 5045 if (dwarf2_lookup_abbrev (abbrev_number, cu) != NULL) 5046 break; 5047 } 5048 5049 xfree (cur_attrs); 5050} 5051 5052/* Release the memory used by the abbrev table for a compilation unit. */ 5053 5054static void 5055dwarf2_free_abbrev_table (void *ptr_to_cu) 5056{ 5057 struct dwarf2_cu *cu = ptr_to_cu; 5058 5059 obstack_free (&cu->abbrev_obstack, NULL); 5060 cu->dwarf2_abbrevs = NULL; 5061} 5062 5063/* Lookup an abbrev_info structure in the abbrev hash table. */ 5064 5065static struct abbrev_info * 5066dwarf2_lookup_abbrev (unsigned int number, struct dwarf2_cu *cu) 5067{ 5068 unsigned int hash_number; 5069 struct abbrev_info *abbrev; 5070 5071 hash_number = number % ABBREV_HASH_SIZE; 5072 abbrev = cu->dwarf2_abbrevs[hash_number]; 5073 5074 while (abbrev) 5075 { 5076 if (abbrev->number == number) 5077 return abbrev; 5078 else 5079 abbrev = abbrev->next; 5080 } 5081 return NULL; 5082} 5083 5084/* Returns nonzero if TAG represents a type that we might generate a partial 5085 symbol for. */ 5086 5087static int 5088is_type_tag_for_partial (int tag) 5089{ 5090 switch (tag) 5091 { 5092#if 0 5093 /* Some types that would be reasonable to generate partial symbols for, 5094 that we don't at present. */ 5095 case DW_TAG_array_type: 5096 case DW_TAG_file_type: 5097 case DW_TAG_ptr_to_member_type: 5098 case DW_TAG_set_type: 5099 case DW_TAG_string_type: 5100 case DW_TAG_subroutine_type: 5101#endif 5102 case DW_TAG_base_type: 5103 case DW_TAG_class_type: 5104 case DW_TAG_enumeration_type: 5105 case DW_TAG_structure_type: 5106 case DW_TAG_subrange_type: 5107 case DW_TAG_typedef: 5108 case DW_TAG_union_type: 5109 return 1; 5110 default: 5111 return 0; 5112 } 5113} 5114 5115/* Load all DIEs that are interesting for partial symbols into memory. */ 5116 5117static struct partial_die_info * 5118load_partial_dies (bfd *abfd, char *info_ptr, int building_psymtab, 5119 struct dwarf2_cu *cu) 5120{ 5121 struct partial_die_info *part_die; 5122 struct partial_die_info *parent_die, *last_die, *first_die = NULL; 5123 struct abbrev_info *abbrev; 5124 unsigned int bytes_read; 5125 5126 int nesting_level = 1; 5127 5128 parent_die = NULL; 5129 last_die = NULL; 5130 5131 cu->partial_dies 5132 = htab_create_alloc_ex (cu->header.length / 12, 5133 partial_die_hash, 5134 partial_die_eq, 5135 NULL, 5136 &cu->comp_unit_obstack, 5137 hashtab_obstack_allocate, 5138 dummy_obstack_deallocate); 5139 5140 part_die = obstack_alloc (&cu->comp_unit_obstack, 5141 sizeof (struct partial_die_info)); 5142 5143 while (1) 5144 { 5145 abbrev = peek_die_abbrev (info_ptr, &bytes_read, cu); 5146 5147 /* A NULL abbrev means the end of a series of children. */ 5148 if (abbrev == NULL) 5149 { 5150 if (--nesting_level == 0) 5151 { 5152 /* PART_DIE was probably the last thing allocated on the 5153 comp_unit_obstack, so we could call obstack_free 5154 here. We don't do that because the waste is small, 5155 and will be cleaned up when we're done with this 5156 compilation unit. This way, we're also more robust 5157 against other users of the comp_unit_obstack. */ 5158 return first_die; 5159 } 5160 info_ptr += bytes_read; 5161 last_die = parent_die; 5162 parent_die = parent_die->die_parent; 5163 continue; 5164 } 5165 5166 /* Check whether this DIE is interesting enough to save. */ 5167 if (!is_type_tag_for_partial (abbrev->tag) 5168 && abbrev->tag != DW_TAG_enumerator 5169 && abbrev->tag != DW_TAG_subprogram 5170 && abbrev->tag != DW_TAG_variable 5171 && abbrev->tag != DW_TAG_namespace) 5172 { 5173 /* Otherwise we skip to the next sibling, if any. */ 5174 info_ptr = skip_one_die (info_ptr + bytes_read, abbrev, cu); 5175 continue; 5176 } 5177 5178 info_ptr = read_partial_die (part_die, abbrev, bytes_read, 5179 abfd, info_ptr, cu); 5180 5181 /* This two-pass algorithm for processing partial symbols has a 5182 high cost in cache pressure. Thus, handle some simple cases 5183 here which cover the majority of C partial symbols. DIEs 5184 which neither have specification tags in them, nor could have 5185 specification tags elsewhere pointing at them, can simply be 5186 processed and discarded. 5187 5188 This segment is also optional; scan_partial_symbols and 5189 add_partial_symbol will handle these DIEs if we chain 5190 them in normally. When compilers which do not emit large 5191 quantities of duplicate debug information are more common, 5192 this code can probably be removed. */ 5193 5194 /* Any complete simple types at the top level (pretty much all 5195 of them, for a language without namespaces), can be processed 5196 directly. */ 5197 if (parent_die == NULL 5198 && part_die->has_specification == 0 5199 && part_die->is_declaration == 0 5200 && (part_die->tag == DW_TAG_typedef 5201 || part_die->tag == DW_TAG_base_type 5202 || part_die->tag == DW_TAG_subrange_type)) 5203 { 5204 if (building_psymtab && part_die->name != NULL) 5205 add_psymbol_to_list (part_die->name, strlen (part_die->name), 5206 VAR_DOMAIN, LOC_TYPEDEF, 5207 &cu->objfile->static_psymbols, 5208 0, (CORE_ADDR) 0, cu->language, cu->objfile); 5209 info_ptr = locate_pdi_sibling (part_die, info_ptr, abfd, cu); 5210 continue; 5211 } 5212 5213 /* If we're at the second level, and we're an enumerator, and 5214 our parent has no specification (meaning possibly lives in a 5215 namespace elsewhere), then we can add the partial symbol now 5216 instead of queueing it. */ 5217 if (part_die->tag == DW_TAG_enumerator 5218 && parent_die != NULL 5219 && parent_die->die_parent == NULL 5220 && parent_die->tag == DW_TAG_enumeration_type 5221 && parent_die->has_specification == 0) 5222 { 5223 if (part_die->name == NULL) 5224 complaint (&symfile_complaints, "malformed enumerator DIE ignored"); 5225 else if (building_psymtab) 5226 add_psymbol_to_list (part_die->name, strlen (part_die->name), 5227 VAR_DOMAIN, LOC_CONST, 5228 (cu->language == language_cplus 5229 || cu->language == language_java) 5230 ? &cu->objfile->global_psymbols 5231 : &cu->objfile->static_psymbols, 5232 0, (CORE_ADDR) 0, cu->language, cu->objfile); 5233 5234 info_ptr = locate_pdi_sibling (part_die, info_ptr, abfd, cu); 5235 continue; 5236 } 5237 5238 /* We'll save this DIE so link it in. */ 5239 part_die->die_parent = parent_die; 5240 part_die->die_sibling = NULL; 5241 part_die->die_child = NULL; 5242 5243 if (last_die && last_die == parent_die) 5244 last_die->die_child = part_die; 5245 else if (last_die) 5246 last_die->die_sibling = part_die; 5247 5248 last_die = part_die; 5249 5250 if (first_die == NULL) 5251 first_die = part_die; 5252 5253 /* Maybe add the DIE to the hash table. Not all DIEs that we 5254 find interesting need to be in the hash table, because we 5255 also have the parent/sibling/child chains; only those that we 5256 might refer to by offset later during partial symbol reading. 5257 5258 For now this means things that might have be the target of a 5259 DW_AT_specification, DW_AT_abstract_origin, or 5260 DW_AT_extension. DW_AT_extension will refer only to 5261 namespaces; DW_AT_abstract_origin refers to functions (and 5262 many things under the function DIE, but we do not recurse 5263 into function DIEs during partial symbol reading) and 5264 possibly variables as well; DW_AT_specification refers to 5265 declarations. Declarations ought to have the DW_AT_declaration 5266 flag. It happens that GCC forgets to put it in sometimes, but 5267 only for functions, not for types. 5268 5269 Adding more things than necessary to the hash table is harmless 5270 except for the performance cost. Adding too few will result in 5271 internal errors in find_partial_die. */ 5272 5273 if (abbrev->tag == DW_TAG_subprogram 5274 || abbrev->tag == DW_TAG_variable 5275 || abbrev->tag == DW_TAG_namespace 5276 || part_die->is_declaration) 5277 { 5278 void **slot; 5279 5280 slot = htab_find_slot_with_hash (cu->partial_dies, part_die, 5281 part_die->offset, INSERT); 5282 *slot = part_die; 5283 } 5284 5285 part_die = obstack_alloc (&cu->comp_unit_obstack, 5286 sizeof (struct partial_die_info)); 5287 5288 /* For some DIEs we want to follow their children (if any). For C 5289 we have no reason to follow the children of structures; for other 5290 languages we have to, both so that we can get at method physnames 5291 to infer fully qualified class names, and for DW_AT_specification. */ 5292 if (last_die->has_children 5293 && (last_die->tag == DW_TAG_namespace 5294 || last_die->tag == DW_TAG_enumeration_type 5295 || (cu->language != language_c 5296 && (last_die->tag == DW_TAG_class_type 5297 || last_die->tag == DW_TAG_structure_type 5298 || last_die->tag == DW_TAG_union_type)))) 5299 { 5300 nesting_level++; 5301 parent_die = last_die; 5302 continue; 5303 } 5304 5305 /* Otherwise we skip to the next sibling, if any. */ 5306 info_ptr = locate_pdi_sibling (last_die, info_ptr, abfd, cu); 5307 5308 /* Back to the top, do it again. */ 5309 } 5310} 5311 5312/* Read a minimal amount of information into the minimal die structure. */ 5313 5314static char * 5315read_partial_die (struct partial_die_info *part_die, 5316 struct abbrev_info *abbrev, 5317 unsigned int abbrev_len, bfd *abfd, 5318 char *info_ptr, struct dwarf2_cu *cu) 5319{ 5320 unsigned int bytes_read, i; 5321 struct attribute attr; 5322 int has_low_pc_attr = 0; 5323 int has_high_pc_attr = 0; 5324 5325 memset (part_die, 0, sizeof (struct partial_die_info)); 5326 5327 part_die->offset = info_ptr - dwarf2_per_objfile->info_buffer; 5328 5329 info_ptr += abbrev_len; 5330 5331 if (abbrev == NULL) 5332 return info_ptr; 5333 5334 part_die->tag = abbrev->tag; 5335 part_die->has_children = abbrev->has_children; 5336 5337 for (i = 0; i < abbrev->num_attrs; ++i) 5338 { 5339 info_ptr = read_attribute (&attr, &abbrev->attrs[i], abfd, info_ptr, cu); 5340 5341 /* Store the data if it is of an attribute we want to keep in a 5342 partial symbol table. */ 5343 switch (attr.name) 5344 { 5345 case DW_AT_name: 5346 5347 /* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */ 5348 if (part_die->name == NULL) 5349 part_die->name = DW_STRING (&attr); 5350 break; 5351 case DW_AT_comp_dir: 5352 if (part_die->dirname == NULL) 5353 part_die->dirname = DW_STRING (&attr); 5354 break; 5355 case DW_AT_MIPS_linkage_name: 5356 part_die->name = DW_STRING (&attr); 5357 break; 5358 case DW_AT_low_pc: 5359 has_low_pc_attr = 1; 5360 part_die->lowpc = DW_ADDR (&attr); 5361 break; 5362 case DW_AT_high_pc: 5363 has_high_pc_attr = 1; 5364 part_die->highpc = DW_ADDR (&attr); 5365 break; 5366 case DW_AT_location: 5367 /* Support the .debug_loc offsets */ 5368 if (attr_form_is_block (&attr)) 5369 { 5370 part_die->locdesc = DW_BLOCK (&attr); 5371 } 5372 else if (attr.form == DW_FORM_data4 || attr.form == DW_FORM_data8) 5373 { 5374 dwarf2_complex_location_expr_complaint (); 5375 } 5376 else 5377 { 5378 dwarf2_invalid_attrib_class_complaint ("DW_AT_location", 5379 "partial symbol information"); 5380 } 5381 break; 5382 case DW_AT_language: 5383 part_die->language = DW_UNSND (&attr); 5384 break; 5385 case DW_AT_external: 5386 part_die->is_external = DW_UNSND (&attr); 5387 break; 5388 case DW_AT_declaration: 5389 part_die->is_declaration = DW_UNSND (&attr); 5390 break; 5391 case DW_AT_type: 5392 part_die->has_type = 1; 5393 break; 5394 case DW_AT_abstract_origin: 5395 case DW_AT_specification: 5396 case DW_AT_extension: 5397 part_die->has_specification = 1; 5398 part_die->spec_offset = dwarf2_get_ref_die_offset (&attr, cu); 5399 break; 5400 case DW_AT_sibling: 5401 /* Ignore absolute siblings, they might point outside of 5402 the current compile unit. */ 5403 if (attr.form == DW_FORM_ref_addr) 5404 complaint (&symfile_complaints, "ignoring absolute DW_AT_sibling"); 5405 else 5406 part_die->sibling = dwarf2_per_objfile->info_buffer 5407 + dwarf2_get_ref_die_offset (&attr, cu); 5408 break; 5409 case DW_AT_stmt_list: 5410 part_die->has_stmt_list = 1; 5411 part_die->line_offset = DW_UNSND (&attr); 5412 break; 5413 default: 5414 break; 5415 } 5416 } 5417 5418 /* When using the GNU linker, .gnu.linkonce. sections are used to 5419 eliminate duplicate copies of functions and vtables and such. 5420 The linker will arbitrarily choose one and discard the others. 5421 The AT_*_pc values for such functions refer to local labels in 5422 these sections. If the section from that file was discarded, the 5423 labels are not in the output, so the relocs get a value of 0. 5424 If this is a discarded function, mark the pc bounds as invalid, 5425 so that GDB will ignore it. */ 5426 if (has_low_pc_attr && has_high_pc_attr 5427 && part_die->lowpc < part_die->highpc 5428 && (part_die->lowpc != 0 5429 || (bfd_get_file_flags (abfd) & HAS_RELOC))) 5430 part_die->has_pc_info = 1; 5431 return info_ptr; 5432} 5433 5434/* Find a cached partial DIE at OFFSET in CU. */ 5435 5436static struct partial_die_info * 5437find_partial_die_in_comp_unit (unsigned long offset, struct dwarf2_cu *cu) 5438{ 5439 struct partial_die_info *lookup_die = NULL; 5440 struct partial_die_info part_die; 5441 5442 part_die.offset = offset; 5443 lookup_die = htab_find_with_hash (cu->partial_dies, &part_die, offset); 5444 5445 if (lookup_die == NULL) 5446 internal_error (__FILE__, __LINE__, 5447 "could not find partial DIE in cache\n"); 5448 5449 return lookup_die; 5450} 5451 5452/* Find a partial DIE at OFFSET, which may or may not be in CU. */ 5453 5454static struct partial_die_info * 5455find_partial_die (unsigned long offset, struct dwarf2_cu *cu) 5456{ 5457 struct dwarf2_per_cu_data *per_cu; 5458 5459 if (offset >= cu->header.offset 5460 && offset < cu->header.offset + cu->header.length) 5461 return find_partial_die_in_comp_unit (offset, cu); 5462 5463 per_cu = dwarf2_find_containing_comp_unit (offset, cu->objfile); 5464 5465 if (per_cu->cu == NULL) 5466 { 5467 load_comp_unit (per_cu, cu->objfile); 5468 per_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain; 5469 dwarf2_per_objfile->read_in_chain = per_cu; 5470 } 5471 5472 per_cu->cu->last_used = 0; 5473 return find_partial_die_in_comp_unit (offset, per_cu->cu); 5474} 5475 5476/* Adjust PART_DIE before generating a symbol for it. This function 5477 may set the is_external flag or change the DIE's name. */ 5478 5479static void 5480fixup_partial_die (struct partial_die_info *part_die, 5481 struct dwarf2_cu *cu) 5482{ 5483 /* If we found a reference attribute and the DIE has no name, try 5484 to find a name in the referred to DIE. */ 5485 5486 if (part_die->name == NULL && part_die->has_specification) 5487 { 5488 struct partial_die_info *spec_die; 5489 5490 spec_die = find_partial_die (part_die->spec_offset, cu); 5491 5492 fixup_partial_die (spec_die, cu); 5493 5494 if (spec_die->name) 5495 { 5496 part_die->name = spec_die->name; 5497 5498 /* Copy DW_AT_external attribute if it is set. */ 5499 if (spec_die->is_external) 5500 part_die->is_external = spec_die->is_external; 5501 } 5502 } 5503 5504 /* Set default names for some unnamed DIEs. */ 5505 if (part_die->name == NULL && (part_die->tag == DW_TAG_structure_type 5506 || part_die->tag == DW_TAG_class_type)) 5507 part_die->name = "(anonymous class)"; 5508 5509 if (part_die->name == NULL && part_die->tag == DW_TAG_namespace) 5510 part_die->name = "(anonymous namespace)"; 5511 5512 if (part_die->tag == DW_TAG_structure_type 5513 || part_die->tag == DW_TAG_class_type 5514 || part_die->tag == DW_TAG_union_type) 5515 guess_structure_name (part_die, cu); 5516} 5517 5518/* Read the die from the .debug_info section buffer. Set DIEP to 5519 point to a newly allocated die with its information, except for its 5520 child, sibling, and parent fields. Set HAS_CHILDREN to tell 5521 whether the die has children or not. */ 5522 5523static char * 5524read_full_die (struct die_info **diep, bfd *abfd, char *info_ptr, 5525 struct dwarf2_cu *cu, int *has_children) 5526{ 5527 unsigned int abbrev_number, bytes_read, i, offset; 5528 struct abbrev_info *abbrev; 5529 struct die_info *die; 5530 5531 offset = info_ptr - dwarf2_per_objfile->info_buffer; 5532 abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); 5533 info_ptr += bytes_read; 5534 if (!abbrev_number) 5535 { 5536 die = dwarf_alloc_die (); 5537 die->tag = 0; 5538 die->abbrev = abbrev_number; 5539 die->type = NULL; 5540 *diep = die; 5541 *has_children = 0; 5542 return info_ptr; 5543 } 5544 5545 abbrev = dwarf2_lookup_abbrev (abbrev_number, cu); 5546 if (!abbrev) 5547 { 5548 error ("Dwarf Error: could not find abbrev number %d [in module %s]", 5549 abbrev_number, 5550 bfd_get_filename (abfd)); 5551 } 5552 die = dwarf_alloc_die (); 5553 die->offset = offset; 5554 die->tag = abbrev->tag; 5555 die->abbrev = abbrev_number; 5556 die->type = NULL; 5557 5558 die->num_attrs = abbrev->num_attrs; 5559 die->attrs = (struct attribute *) 5560 xmalloc (die->num_attrs * sizeof (struct attribute)); 5561 5562 for (i = 0; i < abbrev->num_attrs; ++i) 5563 { 5564 info_ptr = read_attribute (&die->attrs[i], &abbrev->attrs[i], 5565 abfd, info_ptr, cu); 5566 5567 /* If this attribute is an absolute reference to a different 5568 compilation unit, make sure that compilation unit is loaded 5569 also. */ 5570 if (die->attrs[i].form == DW_FORM_ref_addr 5571 && (DW_ADDR (&die->attrs[i]) < cu->header.offset 5572 || (DW_ADDR (&die->attrs[i]) 5573 >= cu->header.offset + cu->header.length))) 5574 { 5575 struct dwarf2_per_cu_data *per_cu; 5576 per_cu = dwarf2_find_containing_comp_unit (DW_ADDR (&die->attrs[i]), 5577 cu->objfile); 5578 5579 /* Mark the dependence relation so that we don't flush PER_CU 5580 too early. */ 5581 dwarf2_add_dependence (cu, per_cu); 5582 5583 /* If it's already on the queue, we have nothing to do. */ 5584 if (per_cu->queued) 5585 continue; 5586 5587 /* If the compilation unit is already loaded, just mark it as 5588 used. */ 5589 if (per_cu->cu != NULL) 5590 { 5591 per_cu->cu->last_used = 0; 5592 continue; 5593 } 5594 5595 /* Add it to the queue. */ 5596 queue_comp_unit (per_cu); 5597 } 5598 } 5599 5600 *diep = die; 5601 *has_children = abbrev->has_children; 5602 return info_ptr; 5603} 5604 5605/* Read an attribute value described by an attribute form. */ 5606 5607static char * 5608read_attribute_value (struct attribute *attr, unsigned form, 5609 bfd *abfd, char *info_ptr, 5610 struct dwarf2_cu *cu) 5611{ 5612 struct comp_unit_head *cu_header = &cu->header; 5613 unsigned int bytes_read; 5614 struct dwarf_block *blk; 5615 5616 attr->form = form; 5617 switch (form) 5618 { 5619 case DW_FORM_addr: 5620 case DW_FORM_ref_addr: 5621 DW_ADDR (attr) = read_address (abfd, info_ptr, cu, &bytes_read); 5622 info_ptr += bytes_read; 5623 break; 5624 case DW_FORM_block2: 5625 blk = dwarf_alloc_block (cu); 5626 blk->size = read_2_bytes (abfd, info_ptr); 5627 info_ptr += 2; 5628 blk->data = read_n_bytes (abfd, info_ptr, blk->size); 5629 info_ptr += blk->size; 5630 DW_BLOCK (attr) = blk; 5631 break; 5632 case DW_FORM_block4: 5633 blk = dwarf_alloc_block (cu); 5634 blk->size = read_4_bytes (abfd, info_ptr); 5635 info_ptr += 4; 5636 blk->data = read_n_bytes (abfd, info_ptr, blk->size); 5637 info_ptr += blk->size; 5638 DW_BLOCK (attr) = blk; 5639 break; 5640 case DW_FORM_data2: 5641 DW_UNSND (attr) = read_2_bytes (abfd, info_ptr); 5642 info_ptr += 2; 5643 break; 5644 case DW_FORM_data4: 5645 DW_UNSND (attr) = read_4_bytes (abfd, info_ptr); 5646 info_ptr += 4; 5647 break; 5648 case DW_FORM_data8: 5649 DW_UNSND (attr) = read_8_bytes (abfd, info_ptr); 5650 info_ptr += 8; 5651 break; 5652 case DW_FORM_string: 5653 DW_STRING (attr) = read_string (abfd, info_ptr, &bytes_read); 5654 info_ptr += bytes_read; 5655 break; 5656 case DW_FORM_strp: 5657 DW_STRING (attr) = read_indirect_string (abfd, info_ptr, cu_header, 5658 &bytes_read); 5659 info_ptr += bytes_read; 5660 break; 5661 case DW_FORM_block: 5662 blk = dwarf_alloc_block (cu); 5663 blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); 5664 info_ptr += bytes_read; 5665 blk->data = read_n_bytes (abfd, info_ptr, blk->size); 5666 info_ptr += blk->size; 5667 DW_BLOCK (attr) = blk; 5668 break; 5669 case DW_FORM_block1: 5670 blk = dwarf_alloc_block (cu); 5671 blk->size = read_1_byte (abfd, info_ptr); 5672 info_ptr += 1; 5673 blk->data = read_n_bytes (abfd, info_ptr, blk->size); 5674 info_ptr += blk->size; 5675 DW_BLOCK (attr) = blk; 5676 break; 5677 case DW_FORM_data1: 5678 DW_UNSND (attr) = read_1_byte (abfd, info_ptr); 5679 info_ptr += 1; 5680 break; 5681 case DW_FORM_flag: 5682 DW_UNSND (attr) = read_1_byte (abfd, info_ptr); 5683 info_ptr += 1; 5684 break; 5685 case DW_FORM_sdata: 5686 DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read); 5687 info_ptr += bytes_read; 5688 break; 5689 case DW_FORM_udata: 5690 DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); 5691 info_ptr += bytes_read; 5692 break; 5693 case DW_FORM_ref1: 5694 DW_ADDR (attr) = cu->header.offset + read_1_byte (abfd, info_ptr); 5695 info_ptr += 1; 5696 break; 5697 case DW_FORM_ref2: 5698 DW_ADDR (attr) = cu->header.offset + read_2_bytes (abfd, info_ptr); 5699 info_ptr += 2; 5700 break; 5701 case DW_FORM_ref4: 5702 DW_ADDR (attr) = cu->header.offset + read_4_bytes (abfd, info_ptr); 5703 info_ptr += 4; 5704 break; 5705 case DW_FORM_ref8: 5706 DW_ADDR (attr) = cu->header.offset + read_8_bytes (abfd, info_ptr); 5707 info_ptr += 8; 5708 break; 5709 case DW_FORM_ref_udata: 5710 DW_ADDR (attr) = (cu->header.offset 5711 + read_unsigned_leb128 (abfd, info_ptr, &bytes_read)); 5712 info_ptr += bytes_read; 5713 break; 5714 case DW_FORM_indirect: 5715 form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); 5716 info_ptr += bytes_read; 5717 info_ptr = read_attribute_value (attr, form, abfd, info_ptr, cu); 5718 break; 5719 default: 5720 error ("Dwarf Error: Cannot handle %s in DWARF reader [in module %s]", 5721 dwarf_form_name (form), 5722 bfd_get_filename (abfd)); 5723 } 5724 return info_ptr; 5725} 5726 5727/* Read an attribute described by an abbreviated attribute. */ 5728 5729static char * 5730read_attribute (struct attribute *attr, struct attr_abbrev *abbrev, 5731 bfd *abfd, char *info_ptr, struct dwarf2_cu *cu) 5732{ 5733 attr->name = abbrev->name; 5734 return read_attribute_value (attr, abbrev->form, abfd, info_ptr, cu); 5735} 5736 5737/* read dwarf information from a buffer */ 5738 5739static unsigned int 5740read_1_byte (bfd *abfd, char *buf) 5741{ 5742 return bfd_get_8 (abfd, (bfd_byte *) buf); 5743} 5744 5745static int 5746read_1_signed_byte (bfd *abfd, char *buf) 5747{ 5748 return bfd_get_signed_8 (abfd, (bfd_byte *) buf); 5749} 5750 5751static unsigned int 5752read_2_bytes (bfd *abfd, char *buf) 5753{ 5754 return bfd_get_16 (abfd, (bfd_byte *) buf); 5755} 5756 5757static int 5758read_2_signed_bytes (bfd *abfd, char *buf) 5759{ 5760 return bfd_get_signed_16 (abfd, (bfd_byte *) buf); 5761} 5762 5763static unsigned int 5764read_4_bytes (bfd *abfd, char *buf) 5765{ 5766 return bfd_get_32 (abfd, (bfd_byte *) buf); 5767} 5768 5769static int 5770read_4_signed_bytes (bfd *abfd, char *buf) 5771{ 5772 return bfd_get_signed_32 (abfd, (bfd_byte *) buf); 5773} 5774 5775static unsigned long 5776read_8_bytes (bfd *abfd, char *buf) 5777{ 5778 return bfd_get_64 (abfd, (bfd_byte *) buf); 5779} 5780 5781static CORE_ADDR 5782read_address (bfd *abfd, char *buf, struct dwarf2_cu *cu, int *bytes_read) 5783{ 5784 struct comp_unit_head *cu_header = &cu->header; 5785 CORE_ADDR retval = 0; 5786 5787 if (cu_header->signed_addr_p) 5788 { 5789 switch (cu_header->addr_size) 5790 { 5791 case 2: 5792 retval = bfd_get_signed_16 (abfd, (bfd_byte *) buf); 5793 break; 5794 case 4: 5795 retval = bfd_get_signed_32 (abfd, (bfd_byte *) buf); 5796 break; 5797 case 8: 5798 retval = bfd_get_signed_64 (abfd, (bfd_byte *) buf); 5799 break; 5800 default: 5801 internal_error (__FILE__, __LINE__, 5802 "read_address: bad switch, signed [in module %s]", 5803 bfd_get_filename (abfd)); 5804 } 5805 } 5806 else 5807 { 5808 switch (cu_header->addr_size) 5809 { 5810 case 2: 5811 retval = bfd_get_16 (abfd, (bfd_byte *) buf); 5812 break; 5813 case 4: 5814 retval = bfd_get_32 (abfd, (bfd_byte *) buf); 5815 break; 5816 case 8: 5817 retval = bfd_get_64 (abfd, (bfd_byte *) buf); 5818 break; 5819 default: 5820 internal_error (__FILE__, __LINE__, 5821 "read_address: bad switch, unsigned [in module %s]", 5822 bfd_get_filename (abfd)); 5823 } 5824 } 5825 5826 *bytes_read = cu_header->addr_size; 5827 return retval; 5828} 5829 5830/* Read the initial length from a section. The (draft) DWARF 3 5831 specification allows the initial length to take up either 4 bytes 5832 or 12 bytes. If the first 4 bytes are 0xffffffff, then the next 8 5833 bytes describe the length and all offsets will be 8 bytes in length 5834 instead of 4. 5835 5836 An older, non-standard 64-bit format is also handled by this 5837 function. The older format in question stores the initial length 5838 as an 8-byte quantity without an escape value. Lengths greater 5839 than 2^32 aren't very common which means that the initial 4 bytes 5840 is almost always zero. Since a length value of zero doesn't make 5841 sense for the 32-bit format, this initial zero can be considered to 5842 be an escape value which indicates the presence of the older 64-bit 5843 format. As written, the code can't detect (old format) lengths 5844 greater than 4GB. If it becomes necessary to handle lengths somewhat 5845 larger than 4GB, we could allow other small values (such as the 5846 non-sensical values of 1, 2, and 3) to also be used as escape values 5847 indicating the presence of the old format. 5848 5849 The value returned via bytes_read should be used to increment 5850 the relevant pointer after calling read_initial_length(). 5851 5852 As a side effect, this function sets the fields initial_length_size 5853 and offset_size in cu_header to the values appropriate for the 5854 length field. (The format of the initial length field determines 5855 the width of file offsets to be fetched later with fetch_offset().) 5856 5857 [ Note: read_initial_length() and read_offset() are based on the 5858 document entitled "DWARF Debugging Information Format", revision 5859 3, draft 8, dated November 19, 2001. This document was obtained 5860 from: 5861 5862 http://reality.sgiweb.org/davea/dwarf3-draft8-011125.pdf 5863 5864 This document is only a draft and is subject to change. (So beware.) 5865 5866 Details regarding the older, non-standard 64-bit format were 5867 determined empirically by examining 64-bit ELF files produced 5868 by the SGI toolchain on an IRIX 6.5 machine. 5869 5870 - Kevin, July 16, 2002 5871 ] */ 5872 5873static LONGEST 5874read_initial_length (bfd *abfd, char *buf, struct comp_unit_head *cu_header, 5875 int *bytes_read) 5876{ 5877 LONGEST retval = 0; 5878 5879 retval = bfd_get_32 (abfd, (bfd_byte *) buf); 5880 5881 if (retval == 0xffffffff) 5882 { 5883 retval = bfd_get_64 (abfd, (bfd_byte *) buf + 4); 5884 *bytes_read = 12; 5885 if (cu_header != NULL) 5886 { 5887 cu_header->initial_length_size = 12; 5888 cu_header->offset_size = 8; 5889 } 5890 } 5891 else if (retval == 0) 5892 { 5893 /* Handle (non-standard) 64-bit DWARF2 formats such as that used 5894 by IRIX. */ 5895 retval = bfd_get_64 (abfd, (bfd_byte *) buf); 5896 *bytes_read = 8; 5897 if (cu_header != NULL) 5898 { 5899 cu_header->initial_length_size = 8; 5900 cu_header->offset_size = 8; 5901 } 5902 } 5903 else 5904 { 5905 *bytes_read = 4; 5906 if (cu_header != NULL) 5907 { 5908 cu_header->initial_length_size = 4; 5909 cu_header->offset_size = 4; 5910 } 5911 } 5912 5913 return retval; 5914} 5915 5916/* Read an offset from the data stream. The size of the offset is 5917 given by cu_header->offset_size. */ 5918 5919static LONGEST 5920read_offset (bfd *abfd, char *buf, const struct comp_unit_head *cu_header, 5921 int *bytes_read) 5922{ 5923 LONGEST retval = 0; 5924 5925 switch (cu_header->offset_size) 5926 { 5927 case 4: 5928 retval = bfd_get_32 (abfd, (bfd_byte *) buf); 5929 *bytes_read = 4; 5930 break; 5931 case 8: 5932 retval = bfd_get_64 (abfd, (bfd_byte *) buf); 5933 *bytes_read = 8; 5934 break; 5935 default: 5936 internal_error (__FILE__, __LINE__, 5937 "read_offset: bad switch [in module %s]", 5938 bfd_get_filename (abfd)); 5939 } 5940 5941 return retval; 5942} 5943 5944static char * 5945read_n_bytes (bfd *abfd, char *buf, unsigned int size) 5946{ 5947 /* If the size of a host char is 8 bits, we can return a pointer 5948 to the buffer, otherwise we have to copy the data to a buffer 5949 allocated on the temporary obstack. */ 5950 gdb_assert (HOST_CHAR_BIT == 8); 5951 return buf; 5952} 5953 5954static char * 5955read_string (bfd *abfd, char *buf, unsigned int *bytes_read_ptr) 5956{ 5957 /* If the size of a host char is 8 bits, we can return a pointer 5958 to the string, otherwise we have to copy the string to a buffer 5959 allocated on the temporary obstack. */ 5960 gdb_assert (HOST_CHAR_BIT == 8); 5961 if (*buf == '\0') 5962 { 5963 *bytes_read_ptr = 1; 5964 return NULL; 5965 } 5966 *bytes_read_ptr = strlen (buf) + 1; 5967 return buf; 5968} 5969 5970static char * 5971read_indirect_string (bfd *abfd, char *buf, 5972 const struct comp_unit_head *cu_header, 5973 unsigned int *bytes_read_ptr) 5974{ 5975 LONGEST str_offset = read_offset (abfd, buf, cu_header, 5976 (int *) bytes_read_ptr); 5977 5978 if (dwarf2_per_objfile->str_buffer == NULL) 5979 { 5980 error ("DW_FORM_strp used without .debug_str section [in module %s]", 5981 bfd_get_filename (abfd)); 5982 return NULL; 5983 } 5984 if (str_offset >= dwarf2_per_objfile->str_size) 5985 { 5986 error ("DW_FORM_strp pointing outside of .debug_str section [in module %s]", 5987 bfd_get_filename (abfd)); 5988 return NULL; 5989 } 5990 gdb_assert (HOST_CHAR_BIT == 8); 5991 if (dwarf2_per_objfile->str_buffer[str_offset] == '\0') 5992 return NULL; 5993 return dwarf2_per_objfile->str_buffer + str_offset; 5994} 5995 5996static unsigned long 5997read_unsigned_leb128 (bfd *abfd, char *buf, unsigned int *bytes_read_ptr) 5998{ 5999 unsigned long result; 6000 unsigned int num_read; 6001 int i, shift; 6002 unsigned char byte; 6003 6004 result = 0; 6005 shift = 0; 6006 num_read = 0; 6007 i = 0; 6008 while (1) 6009 { 6010 byte = bfd_get_8 (abfd, (bfd_byte *) buf); 6011 buf++; 6012 num_read++; 6013 result |= ((unsigned long)(byte & 127) << shift); 6014 if ((byte & 128) == 0) 6015 { 6016 break; 6017 } 6018 shift += 7; 6019 } 6020 *bytes_read_ptr = num_read; 6021 return result; 6022} 6023 6024static long 6025read_signed_leb128 (bfd *abfd, char *buf, unsigned int *bytes_read_ptr) 6026{ 6027 long result; 6028 int i, shift, size, num_read; 6029 unsigned char byte; 6030 6031 result = 0; 6032 shift = 0; 6033 size = 32; 6034 num_read = 0; 6035 i = 0; 6036 while (1) 6037 { 6038 byte = bfd_get_8 (abfd, (bfd_byte *) buf); 6039 buf++; 6040 num_read++; 6041 result |= ((long)(byte & 127) << shift); 6042 shift += 7; 6043 if ((byte & 128) == 0) 6044 { 6045 break; 6046 } 6047 } 6048 if ((shift < size) && (byte & 0x40)) 6049 { 6050 result |= -(1 << shift); 6051 } 6052 *bytes_read_ptr = num_read; 6053 return result; 6054} 6055 6056/* Return a pointer to just past the end of an LEB128 number in BUF. */ 6057 6058static char * 6059skip_leb128 (bfd *abfd, char *buf) 6060{ 6061 int byte; 6062 6063 while (1) 6064 { 6065 byte = bfd_get_8 (abfd, (bfd_byte *) buf); 6066 buf++; 6067 if ((byte & 128) == 0) 6068 return buf; 6069 } 6070} 6071 6072static void 6073set_cu_language (unsigned int lang, struct dwarf2_cu *cu) 6074{ 6075 switch (lang) 6076 { 6077 case DW_LANG_C89: 6078 case DW_LANG_C: 6079 cu->language = language_c; 6080 break; 6081 case DW_LANG_C_plus_plus: 6082 cu->language = language_cplus; 6083 break; 6084 case DW_LANG_Fortran77: 6085 case DW_LANG_Fortran90: 6086 case DW_LANG_Fortran95: 6087 cu->language = language_fortran; 6088 break; 6089 case DW_LANG_Mips_Assembler: 6090 cu->language = language_asm; 6091 break; 6092 case DW_LANG_Java: 6093 cu->language = language_java; 6094 break; 6095 case DW_LANG_Ada83: 6096 case DW_LANG_Ada95: 6097 cu->language = language_ada; 6098 break; 6099 case DW_LANG_Cobol74: 6100 case DW_LANG_Cobol85: 6101 case DW_LANG_Pascal83: 6102 case DW_LANG_Modula2: 6103 default: 6104 cu->language = language_minimal; 6105 break; 6106 } 6107 cu->language_defn = language_def (cu->language); 6108} 6109 6110/* Return the named attribute or NULL if not there. */ 6111 6112static struct attribute * 6113dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu) 6114{ 6115 unsigned int i; 6116 struct attribute *spec = NULL; 6117 6118 for (i = 0; i < die->num_attrs; ++i) 6119 { 6120 if (die->attrs[i].name == name) 6121 return &die->attrs[i]; 6122 if (die->attrs[i].name == DW_AT_specification 6123 || die->attrs[i].name == DW_AT_abstract_origin) 6124 spec = &die->attrs[i]; 6125 } 6126 6127 if (spec) 6128 return dwarf2_attr (follow_die_ref (die, spec, cu), name, cu); 6129 6130 return NULL; 6131} 6132 6133/* Return non-zero iff the attribute NAME is defined for the given DIE, 6134 and holds a non-zero value. This function should only be used for 6135 DW_FORM_flag attributes. */ 6136 6137static int 6138dwarf2_flag_true_p (struct die_info *die, unsigned name, struct dwarf2_cu *cu) 6139{ 6140 struct attribute *attr = dwarf2_attr (die, name, cu); 6141 6142 return (attr && DW_UNSND (attr)); 6143} 6144 6145static int 6146die_is_declaration (struct die_info *die, struct dwarf2_cu *cu) 6147{ 6148 /* A DIE is a declaration if it has a DW_AT_declaration attribute 6149 which value is non-zero. However, we have to be careful with 6150 DIEs having a DW_AT_specification attribute, because dwarf2_attr() 6151 (via dwarf2_flag_true_p) follows this attribute. So we may 6152 end up accidently finding a declaration attribute that belongs 6153 to a different DIE referenced by the specification attribute, 6154 even though the given DIE does not have a declaration attribute. */ 6155 return (dwarf2_flag_true_p (die, DW_AT_declaration, cu) 6156 && dwarf2_attr (die, DW_AT_specification, cu) == NULL); 6157} 6158 6159/* Return the die giving the specification for DIE, if there is 6160 one. */ 6161 6162static struct die_info * 6163die_specification (struct die_info *die, struct dwarf2_cu *cu) 6164{ 6165 struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification, cu); 6166 6167 if (spec_attr == NULL) 6168 return NULL; 6169 else 6170 return follow_die_ref (die, spec_attr, cu); 6171} 6172 6173/* Free the line_header structure *LH, and any arrays and strings it 6174 refers to. */ 6175static void 6176free_line_header (struct line_header *lh) 6177{ 6178 if (lh->standard_opcode_lengths) 6179 xfree (lh->standard_opcode_lengths); 6180 6181 /* Remember that all the lh->file_names[i].name pointers are 6182 pointers into debug_line_buffer, and don't need to be freed. */ 6183 if (lh->file_names) 6184 xfree (lh->file_names); 6185 6186 /* Similarly for the include directory names. */ 6187 if (lh->include_dirs) 6188 xfree (lh->include_dirs); 6189 6190 xfree (lh); 6191} 6192 6193 6194/* Add an entry to LH's include directory table. */ 6195static void 6196add_include_dir (struct line_header *lh, char *include_dir) 6197{ 6198 /* Grow the array if necessary. */ 6199 if (lh->include_dirs_size == 0) 6200 { 6201 lh->include_dirs_size = 1; /* for testing */ 6202 lh->include_dirs = xmalloc (lh->include_dirs_size 6203 * sizeof (*lh->include_dirs)); 6204 } 6205 else if (lh->num_include_dirs >= lh->include_dirs_size) 6206 { 6207 lh->include_dirs_size *= 2; 6208 lh->include_dirs = xrealloc (lh->include_dirs, 6209 (lh->include_dirs_size 6210 * sizeof (*lh->include_dirs))); 6211 } 6212 6213 lh->include_dirs[lh->num_include_dirs++] = include_dir; 6214} 6215 6216 6217/* Add an entry to LH's file name table. */ 6218static void 6219add_file_name (struct line_header *lh, 6220 char *name, 6221 unsigned int dir_index, 6222 unsigned int mod_time, 6223 unsigned int length) 6224{ 6225 struct file_entry *fe; 6226 6227 /* Grow the array if necessary. */ 6228 if (lh->file_names_size == 0) 6229 { 6230 lh->file_names_size = 1; /* for testing */ 6231 lh->file_names = xmalloc (lh->file_names_size 6232 * sizeof (*lh->file_names)); 6233 } 6234 else if (lh->num_file_names >= lh->file_names_size) 6235 { 6236 lh->file_names_size *= 2; 6237 lh->file_names = xrealloc (lh->file_names, 6238 (lh->file_names_size 6239 * sizeof (*lh->file_names))); 6240 } 6241 6242 fe = &lh->file_names[lh->num_file_names++]; 6243 fe->name = name; 6244 fe->dir_index = dir_index; 6245 fe->mod_time = mod_time; 6246 fe->length = length; 6247 fe->included_p = 0; 6248} 6249 6250 6251/* Read the statement program header starting at OFFSET in 6252 .debug_line, according to the endianness of ABFD. Return a pointer 6253 to a struct line_header, allocated using xmalloc. 6254 6255 NOTE: the strings in the include directory and file name tables of 6256 the returned object point into debug_line_buffer, and must not be 6257 freed. */ 6258static struct line_header * 6259dwarf_decode_line_header (unsigned int offset, bfd *abfd, 6260 struct dwarf2_cu *cu) 6261{ 6262 struct cleanup *back_to; 6263 struct line_header *lh; 6264 char *line_ptr; 6265 int bytes_read; 6266 int i; 6267 char *cur_dir, *cur_file; 6268 6269 if (dwarf2_per_objfile->line_buffer == NULL) 6270 { 6271 complaint (&symfile_complaints, "missing .debug_line section"); 6272 return 0; 6273 } 6274 6275 /* Make sure that at least there's room for the total_length field. That 6276 could be 12 bytes long, but we're just going to fudge that. */ 6277 if (offset + 4 >= dwarf2_per_objfile->line_size) 6278 { 6279 dwarf2_statement_list_fits_in_line_number_section_complaint (); 6280 return 0; 6281 } 6282 6283 lh = xmalloc (sizeof (*lh)); 6284 memset (lh, 0, sizeof (*lh)); 6285 back_to = make_cleanup ((make_cleanup_ftype *) free_line_header, 6286 (void *) lh); 6287 6288 line_ptr = dwarf2_per_objfile->line_buffer + offset; 6289 6290 /* read in the header */ 6291 lh->total_length = read_initial_length (abfd, line_ptr, NULL, &bytes_read); 6292 line_ptr += bytes_read; 6293 if (line_ptr + lh->total_length > (dwarf2_per_objfile->line_buffer 6294 + dwarf2_per_objfile->line_size)) 6295 { 6296 dwarf2_statement_list_fits_in_line_number_section_complaint (); 6297 return 0; 6298 } 6299 lh->statement_program_end = line_ptr + lh->total_length; 6300 lh->version = read_2_bytes (abfd, line_ptr); 6301 line_ptr += 2; 6302 lh->header_length = read_offset (abfd, line_ptr, &cu->header, &bytes_read); 6303 line_ptr += bytes_read; 6304 lh->minimum_instruction_length = read_1_byte (abfd, line_ptr); 6305 line_ptr += 1; 6306 lh->default_is_stmt = read_1_byte (abfd, line_ptr); 6307 line_ptr += 1; 6308 lh->line_base = read_1_signed_byte (abfd, line_ptr); 6309 line_ptr += 1; 6310 lh->line_range = read_1_byte (abfd, line_ptr); 6311 line_ptr += 1; 6312 lh->opcode_base = read_1_byte (abfd, line_ptr); 6313 line_ptr += 1; 6314 lh->standard_opcode_lengths 6315 = (unsigned char *) xmalloc (lh->opcode_base * sizeof (unsigned char)); 6316 6317 lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */ 6318 for (i = 1; i < lh->opcode_base; ++i) 6319 { 6320 lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr); 6321 line_ptr += 1; 6322 } 6323 6324 /* Read directory table */ 6325 while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL) 6326 { 6327 line_ptr += bytes_read; 6328 add_include_dir (lh, cur_dir); 6329 } 6330 line_ptr += bytes_read; 6331 6332 /* Read file name table */ 6333 while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL) 6334 { 6335 unsigned int dir_index, mod_time, length; 6336 6337 line_ptr += bytes_read; 6338 dir_index = read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 6339 line_ptr += bytes_read; 6340 mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 6341 line_ptr += bytes_read; 6342 length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 6343 line_ptr += bytes_read; 6344 6345 add_file_name (lh, cur_file, dir_index, mod_time, length); 6346 } 6347 line_ptr += bytes_read; 6348 lh->statement_program_start = line_ptr; 6349 6350 if (line_ptr > (dwarf2_per_objfile->line_buffer 6351 + dwarf2_per_objfile->line_size)) 6352 complaint (&symfile_complaints, 6353 "line number info header doesn't fit in `.debug_line' section"); 6354 6355 discard_cleanups (back_to); 6356 return lh; 6357} 6358 6359/* This function exists to work around a bug in certain compilers 6360 (particularly GCC 2.95), in which the first line number marker of a 6361 function does not show up until after the prologue, right before 6362 the second line number marker. This function shifts ADDRESS down 6363 to the beginning of the function if necessary, and is called on 6364 addresses passed to record_line. */ 6365 6366static CORE_ADDR 6367check_cu_functions (CORE_ADDR address, struct dwarf2_cu *cu) 6368{ 6369 struct function_range *fn; 6370 6371 /* Find the function_range containing address. */ 6372 if (!cu->first_fn) 6373 return address; 6374 6375 if (!cu->cached_fn) 6376 cu->cached_fn = cu->first_fn; 6377 6378 fn = cu->cached_fn; 6379 while (fn) 6380 if (fn->lowpc <= address && fn->highpc > address) 6381 goto found; 6382 else 6383 fn = fn->next; 6384 6385 fn = cu->first_fn; 6386 while (fn && fn != cu->cached_fn) 6387 if (fn->lowpc <= address && fn->highpc > address) 6388 goto found; 6389 else 6390 fn = fn->next; 6391 6392 return address; 6393 6394 found: 6395 if (fn->seen_line) 6396 return address; 6397 if (address != fn->lowpc) 6398 complaint (&symfile_complaints, 6399 "misplaced first line number at 0x%lx for '%s'", 6400 (unsigned long) address, fn->name); 6401 fn->seen_line = 1; 6402 return fn->lowpc; 6403} 6404 6405/* Decode the Line Number Program (LNP) for the given line_header 6406 structure and CU. The actual information extracted and the type 6407 of structures created from the LNP depends on the value of PST. 6408 6409 1. If PST is NULL, then this procedure uses the data from the program 6410 to create all necessary symbol tables, and their linetables. 6411 The compilation directory of the file is passed in COMP_DIR, 6412 and must not be NULL. 6413 6414 2. If PST is not NULL, this procedure reads the program to determine 6415 the list of files included by the unit represented by PST, and 6416 builds all the associated partial symbol tables. In this case, 6417 the value of COMP_DIR is ignored, and can thus be NULL (the COMP_DIR 6418 is not used to compute the full name of the symtab, and therefore 6419 omitting it when building the partial symtab does not introduce 6420 the potential for inconsistency - a partial symtab and its associated 6421 symbtab having a different fullname -). */ 6422 6423static void 6424dwarf_decode_lines (struct line_header *lh, char *comp_dir, bfd *abfd, 6425 struct dwarf2_cu *cu, struct partial_symtab *pst) 6426{ 6427 char *line_ptr; 6428 char *line_end; 6429 unsigned int bytes_read; 6430 unsigned char op_code, extended_op, adj_opcode; 6431 CORE_ADDR baseaddr; 6432 struct objfile *objfile = cu->objfile; 6433 const int decode_for_pst_p = (pst != NULL); 6434 6435 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 6436 6437 line_ptr = lh->statement_program_start; 6438 line_end = lh->statement_program_end; 6439 6440 /* Read the statement sequences until there's nothing left. */ 6441 while (line_ptr < line_end) 6442 { 6443 /* state machine registers */ 6444 CORE_ADDR address = 0; 6445 unsigned int file = 1; 6446 unsigned int line = 1; 6447 unsigned int column = 0; 6448 int is_stmt = lh->default_is_stmt; 6449 int basic_block = 0; 6450 int end_sequence = 0; 6451 6452 if (!decode_for_pst_p && lh->num_file_names >= file) 6453 { 6454 /* Start a subfile for the current file of the state machine. */ 6455 /* lh->include_dirs and lh->file_names are 0-based, but the 6456 directory and file name numbers in the statement program 6457 are 1-based. */ 6458 struct file_entry *fe = &lh->file_names[file - 1]; 6459 char *dir; 6460 if (fe->dir_index) 6461 dir = lh->include_dirs[fe->dir_index - 1]; 6462 else 6463 dir = comp_dir; 6464 dwarf2_start_subfile (fe->name, dir); 6465 } 6466 6467 /* Decode the table. */ 6468 while (!end_sequence) 6469 { 6470 op_code = read_1_byte (abfd, line_ptr); 6471 line_ptr += 1; 6472 6473 if (op_code >= lh->opcode_base) 6474 { /* Special operand. */ 6475 adj_opcode = op_code - lh->opcode_base; 6476 address += (adj_opcode / lh->line_range) 6477 * lh->minimum_instruction_length; 6478 line += lh->line_base + (adj_opcode % lh->line_range); 6479 lh->file_names[file - 1].included_p = 1; 6480 if (!decode_for_pst_p) 6481 { 6482 /* append row to matrix using current values */ 6483 record_line (current_subfile, line, 6484 check_cu_functions (address, cu)); 6485 } 6486 basic_block = 1; 6487 } 6488 else switch (op_code) 6489 { 6490 case DW_LNS_extended_op: 6491 read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 6492 line_ptr += bytes_read; 6493 extended_op = read_1_byte (abfd, line_ptr); 6494 line_ptr += 1; 6495 switch (extended_op) 6496 { 6497 case DW_LNE_end_sequence: 6498 end_sequence = 1; 6499 lh->file_names[file - 1].included_p = 1; 6500 if (!decode_for_pst_p) 6501 record_line (current_subfile, 0, address); 6502 break; 6503 case DW_LNE_set_address: 6504 address = read_address (abfd, line_ptr, cu, &bytes_read); 6505 line_ptr += bytes_read; 6506 address += baseaddr; 6507 break; 6508 case DW_LNE_define_file: 6509 { 6510 char *cur_file; 6511 unsigned int dir_index, mod_time, length; 6512 6513 cur_file = read_string (abfd, line_ptr, &bytes_read); 6514 line_ptr += bytes_read; 6515 dir_index = 6516 read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 6517 line_ptr += bytes_read; 6518 mod_time = 6519 read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 6520 line_ptr += bytes_read; 6521 length = 6522 read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 6523 line_ptr += bytes_read; 6524 add_file_name (lh, cur_file, dir_index, mod_time, length); 6525 } 6526 break; 6527 default: 6528 complaint (&symfile_complaints, 6529 "mangled .debug_line section"); 6530 return; 6531 } 6532 break; 6533 case DW_LNS_copy: 6534 lh->file_names[file - 1].included_p = 1; 6535 if (!decode_for_pst_p) 6536 record_line (current_subfile, line, 6537 check_cu_functions (address, cu)); 6538 basic_block = 0; 6539 break; 6540 case DW_LNS_advance_pc: 6541 address += lh->minimum_instruction_length 6542 * read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 6543 line_ptr += bytes_read; 6544 break; 6545 case DW_LNS_advance_line: 6546 line += read_signed_leb128 (abfd, line_ptr, &bytes_read); 6547 line_ptr += bytes_read; 6548 break; 6549 case DW_LNS_set_file: 6550 { 6551 /* lh->include_dirs and lh->file_names are 0-based, 6552 but the directory and file name numbers in the 6553 statement program are 1-based. */ 6554 struct file_entry *fe; 6555 char *dir; 6556 file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 6557 line_ptr += bytes_read; 6558 fe = &lh->file_names[file - 1]; 6559 if (fe->dir_index) 6560 dir = lh->include_dirs[fe->dir_index - 1]; 6561 else 6562 dir = comp_dir; 6563 if (!decode_for_pst_p) 6564 dwarf2_start_subfile (fe->name, dir); 6565 } 6566 break; 6567 case DW_LNS_set_column: 6568 column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 6569 line_ptr += bytes_read; 6570 break; 6571 case DW_LNS_negate_stmt: 6572 is_stmt = (!is_stmt); 6573 break; 6574 case DW_LNS_set_basic_block: 6575 basic_block = 1; 6576 break; 6577 /* Add to the address register of the state machine the 6578 address increment value corresponding to special opcode 6579 255. Ie, this value is scaled by the minimum instruction 6580 length since special opcode 255 would have scaled the 6581 the increment. */ 6582 case DW_LNS_const_add_pc: 6583 address += (lh->minimum_instruction_length 6584 * ((255 - lh->opcode_base) / lh->line_range)); 6585 break; 6586 case DW_LNS_fixed_advance_pc: 6587 address += read_2_bytes (abfd, line_ptr); 6588 line_ptr += 2; 6589 break; 6590 default: 6591 { /* Unknown standard opcode, ignore it. */ 6592 int i; 6593 for (i = 0; i < lh->standard_opcode_lengths[op_code]; i++) 6594 { 6595 (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read); 6596 line_ptr += bytes_read; 6597 } 6598 } 6599 } 6600 } 6601 } 6602 6603 if (decode_for_pst_p) 6604 { 6605 int file_index; 6606 6607 /* Now that we're done scanning the Line Header Program, we can 6608 create the psymtab of each included file. */ 6609 for (file_index = 0; file_index < lh->num_file_names; file_index++) 6610 if (lh->file_names[file_index].included_p == 1) 6611 { 6612 char *include_name = lh->file_names [file_index].name; 6613 6614 if (strcmp (include_name, pst->filename) != 0) 6615 dwarf2_create_include_psymtab (include_name, pst, objfile); 6616 } 6617 } 6618} 6619 6620/* Start a subfile for DWARF. FILENAME is the name of the file and 6621 DIRNAME the name of the source directory which contains FILENAME 6622 or NULL if not known. 6623 This routine tries to keep line numbers from identical absolute and 6624 relative file names in a common subfile. 6625 6626 Using the `list' example from the GDB testsuite, which resides in 6627 /srcdir and compiling it with Irix6.2 cc in /compdir using a filename 6628 of /srcdir/list0.c yields the following debugging information for list0.c: 6629 6630 DW_AT_name: /srcdir/list0.c 6631 DW_AT_comp_dir: /compdir 6632 files.files[0].name: list0.h 6633 files.files[0].dir: /srcdir 6634 files.files[1].name: list0.c 6635 files.files[1].dir: /srcdir 6636 6637 The line number information for list0.c has to end up in a single 6638 subfile, so that `break /srcdir/list0.c:1' works as expected. */ 6639 6640static void 6641dwarf2_start_subfile (char *filename, char *dirname) 6642{ 6643 /* If the filename isn't absolute, try to match an existing subfile 6644 with the full pathname. */ 6645 6646 if (!IS_ABSOLUTE_PATH (filename) && dirname != NULL) 6647 { 6648 struct subfile *subfile; 6649 char *fullname = concat (dirname, "/", filename, NULL); 6650 6651 for (subfile = subfiles; subfile; subfile = subfile->next) 6652 { 6653 if (FILENAME_CMP (subfile->name, fullname) == 0) 6654 { 6655 current_subfile = subfile; 6656 xfree (fullname); 6657 return; 6658 } 6659 } 6660 xfree (fullname); 6661 } 6662 start_subfile (filename, dirname); 6663} 6664 6665static void 6666var_decode_location (struct attribute *attr, struct symbol *sym, 6667 struct dwarf2_cu *cu) 6668{ 6669 struct objfile *objfile = cu->objfile; 6670 struct comp_unit_head *cu_header = &cu->header; 6671 6672 /* NOTE drow/2003-01-30: There used to be a comment and some special 6673 code here to turn a symbol with DW_AT_external and a 6674 SYMBOL_VALUE_ADDRESS of 0 into a LOC_UNRESOLVED symbol. This was 6675 necessary for platforms (maybe Alpha, certainly PowerPC GNU/Linux 6676 with some versions of binutils) where shared libraries could have 6677 relocations against symbols in their debug information - the 6678 minimal symbol would have the right address, but the debug info 6679 would not. It's no longer necessary, because we will explicitly 6680 apply relocations when we read in the debug information now. */ 6681 6682 /* A DW_AT_location attribute with no contents indicates that a 6683 variable has been optimized away. */ 6684 if (attr_form_is_block (attr) && DW_BLOCK (attr)->size == 0) 6685 { 6686 SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT; 6687 return; 6688 } 6689 6690 /* Handle one degenerate form of location expression specially, to 6691 preserve GDB's previous behavior when section offsets are 6692 specified. If this is just a DW_OP_addr then mark this symbol 6693 as LOC_STATIC. */ 6694 6695 if (attr_form_is_block (attr) 6696 && DW_BLOCK (attr)->size == 1 + cu_header->addr_size 6697 && DW_BLOCK (attr)->data[0] == DW_OP_addr) 6698 { 6699 int dummy; 6700 6701 SYMBOL_VALUE_ADDRESS (sym) = 6702 read_address (objfile->obfd, DW_BLOCK (attr)->data + 1, cu, &dummy); 6703 fixup_symbol_section (sym, objfile); 6704 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets, 6705 SYMBOL_SECTION (sym)); 6706 SYMBOL_CLASS (sym) = LOC_STATIC; 6707 return; 6708 } 6709 6710 /* NOTE drow/2002-01-30: It might be worthwhile to have a static 6711 expression evaluator, and use LOC_COMPUTED only when necessary 6712 (i.e. when the value of a register or memory location is 6713 referenced, or a thread-local block, etc.). Then again, it might 6714 not be worthwhile. I'm assuming that it isn't unless performance 6715 or memory numbers show me otherwise. */ 6716 6717 dwarf2_symbol_mark_computed (attr, sym, cu); 6718 SYMBOL_CLASS (sym) = LOC_COMPUTED; 6719} 6720 6721/* Given a pointer to a DWARF information entry, figure out if we need 6722 to make a symbol table entry for it, and if so, create a new entry 6723 and return a pointer to it. 6724 If TYPE is NULL, determine symbol type from the die, otherwise 6725 used the passed type. */ 6726 6727static struct symbol * 6728new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu) 6729{ 6730 struct objfile *objfile = cu->objfile; 6731 struct symbol *sym = NULL; 6732 char *name; 6733 struct attribute *attr = NULL; 6734 struct attribute *attr2 = NULL; 6735 CORE_ADDR baseaddr; 6736 6737 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 6738 6739 if (die->tag != DW_TAG_namespace) 6740 name = dwarf2_linkage_name (die, cu); 6741 else 6742 name = TYPE_NAME (type); 6743 6744 if (name) 6745 { 6746 sym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack, 6747 sizeof (struct symbol)); 6748 OBJSTAT (objfile, n_syms++); 6749 memset (sym, 0, sizeof (struct symbol)); 6750 6751 /* Cache this symbol's name and the name's demangled form (if any). */ 6752 SYMBOL_LANGUAGE (sym) = cu->language; 6753 SYMBOL_SET_NAMES (sym, name, strlen (name), objfile); 6754 6755 /* Default assumptions. 6756 Use the passed type or decode it from the die. */ 6757 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 6758 SYMBOL_CLASS (sym) = LOC_STATIC; 6759 if (type != NULL) 6760 SYMBOL_TYPE (sym) = type; 6761 else 6762 SYMBOL_TYPE (sym) = die_type (die, cu); 6763 attr = dwarf2_attr (die, DW_AT_decl_line, cu); 6764 if (attr) 6765 { 6766 SYMBOL_LINE (sym) = DW_UNSND (attr); 6767 } 6768 switch (die->tag) 6769 { 6770 case DW_TAG_label: 6771 attr = dwarf2_attr (die, DW_AT_low_pc, cu); 6772 if (attr) 6773 { 6774 SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr) + baseaddr; 6775 } 6776 SYMBOL_CLASS (sym) = LOC_LABEL; 6777 break; 6778 case DW_TAG_subprogram: 6779 /* SYMBOL_BLOCK_VALUE (sym) will be filled in later by 6780 finish_block. */ 6781 SYMBOL_CLASS (sym) = LOC_BLOCK; 6782 attr2 = dwarf2_attr (die, DW_AT_external, cu); 6783 if (attr2 && (DW_UNSND (attr2) != 0)) 6784 { 6785 add_symbol_to_list (sym, &global_symbols); 6786 } 6787 else 6788 { 6789 add_symbol_to_list (sym, cu->list_in_scope); 6790 } 6791 break; 6792 case DW_TAG_variable: 6793 /* Compilation with minimal debug info may result in variables 6794 with missing type entries. Change the misleading `void' type 6795 to something sensible. */ 6796 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID) 6797 SYMBOL_TYPE (sym) = init_type (TYPE_CODE_INT, 6798 TARGET_INT_BIT / HOST_CHAR_BIT, 0, 6799 "<variable, no debug info>", 6800 objfile); 6801 attr = dwarf2_attr (die, DW_AT_const_value, cu); 6802 if (attr) 6803 { 6804 dwarf2_const_value (attr, sym, cu); 6805 attr2 = dwarf2_attr (die, DW_AT_external, cu); 6806 if (attr2 && (DW_UNSND (attr2) != 0)) 6807 add_symbol_to_list (sym, &global_symbols); 6808 else 6809 add_symbol_to_list (sym, cu->list_in_scope); 6810 break; 6811 } 6812 attr = dwarf2_attr (die, DW_AT_location, cu); 6813 if (attr) 6814 { 6815 var_decode_location (attr, sym, cu); 6816 attr2 = dwarf2_attr (die, DW_AT_external, cu); 6817 if (attr2 && (DW_UNSND (attr2) != 0)) 6818 add_symbol_to_list (sym, &global_symbols); 6819 else 6820 add_symbol_to_list (sym, cu->list_in_scope); 6821 } 6822 else 6823 { 6824 /* We do not know the address of this symbol. 6825 If it is an external symbol and we have type information 6826 for it, enter the symbol as a LOC_UNRESOLVED symbol. 6827 The address of the variable will then be determined from 6828 the minimal symbol table whenever the variable is 6829 referenced. */ 6830 attr2 = dwarf2_attr (die, DW_AT_external, cu); 6831 if (attr2 && (DW_UNSND (attr2) != 0) 6832 && dwarf2_attr (die, DW_AT_type, cu) != NULL) 6833 { 6834 SYMBOL_CLASS (sym) = LOC_UNRESOLVED; 6835 add_symbol_to_list (sym, &global_symbols); 6836 } 6837 } 6838 break; 6839 case DW_TAG_formal_parameter: 6840 attr = dwarf2_attr (die, DW_AT_location, cu); 6841 if (attr) 6842 { 6843 var_decode_location (attr, sym, cu); 6844 /* FIXME drow/2003-07-31: Is LOC_COMPUTED_ARG necessary? */ 6845 if (SYMBOL_CLASS (sym) == LOC_COMPUTED) 6846 SYMBOL_CLASS (sym) = LOC_COMPUTED_ARG; 6847 } 6848 attr = dwarf2_attr (die, DW_AT_const_value, cu); 6849 if (attr) 6850 { 6851 dwarf2_const_value (attr, sym, cu); 6852 } 6853 add_symbol_to_list (sym, cu->list_in_scope); 6854 break; 6855 case DW_TAG_unspecified_parameters: 6856 /* From varargs functions; gdb doesn't seem to have any 6857 interest in this information, so just ignore it for now. 6858 (FIXME?) */ 6859 break; 6860 case DW_TAG_class_type: 6861 case DW_TAG_structure_type: 6862 case DW_TAG_union_type: 6863 case DW_TAG_enumeration_type: 6864 SYMBOL_CLASS (sym) = LOC_TYPEDEF; 6865 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN; 6866 6867 /* Make sure that the symbol includes appropriate enclosing 6868 classes/namespaces in its name. These are calculated in 6869 read_structure_type, and the correct name is saved in 6870 the type. */ 6871 6872 if (cu->language == language_cplus 6873 || cu->language == language_java) 6874 { 6875 struct type *type = SYMBOL_TYPE (sym); 6876 6877 if (TYPE_TAG_NAME (type) != NULL) 6878 { 6879 /* FIXME: carlton/2003-11-10: Should this use 6880 SYMBOL_SET_NAMES instead? (The same problem also 6881 arises further down in this function.) */ 6882 /* The type's name is already allocated along with 6883 this objfile, so we don't need to duplicate it 6884 for the symbol. */ 6885 SYMBOL_LINKAGE_NAME (sym) = TYPE_TAG_NAME (type); 6886 } 6887 } 6888 6889 { 6890 /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't 6891 really ever be static objects: otherwise, if you try 6892 to, say, break of a class's method and you're in a file 6893 which doesn't mention that class, it won't work unless 6894 the check for all static symbols in lookup_symbol_aux 6895 saves you. See the OtherFileClass tests in 6896 gdb.c++/namespace.exp. */ 6897 6898 struct pending **list_to_add; 6899 6900 list_to_add = (cu->list_in_scope == &file_symbols 6901 && (cu->language == language_cplus 6902 || cu->language == language_java) 6903 ? &global_symbols : cu->list_in_scope); 6904 6905 add_symbol_to_list (sym, list_to_add); 6906 6907 /* The semantics of C++ state that "struct foo { ... }" also 6908 defines a typedef for "foo". A Java class declaration also 6909 defines a typedef for the class. Synthesize a typedef symbol 6910 so that "ptype foo" works as expected. */ 6911 if (cu->language == language_cplus 6912 || cu->language == language_java) 6913 { 6914 struct symbol *typedef_sym = (struct symbol *) 6915 obstack_alloc (&objfile->objfile_obstack, 6916 sizeof (struct symbol)); 6917 *typedef_sym = *sym; 6918 SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN; 6919 /* The symbol's name is already allocated along with 6920 this objfile, so we don't need to duplicate it for 6921 the type. */ 6922 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0) 6923 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_NATURAL_NAME (sym); 6924 add_symbol_to_list (typedef_sym, list_to_add); 6925 } 6926 } 6927 break; 6928 case DW_TAG_typedef: 6929 if (processing_has_namespace_info 6930 && processing_current_prefix[0] != '\0') 6931 { 6932 SYMBOL_LINKAGE_NAME (sym) = typename_concat (&objfile->objfile_obstack, 6933 processing_current_prefix, 6934 name, cu); 6935 } 6936 SYMBOL_CLASS (sym) = LOC_TYPEDEF; 6937 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 6938 add_symbol_to_list (sym, cu->list_in_scope); 6939 break; 6940 case DW_TAG_base_type: 6941 case DW_TAG_subrange_type: 6942 SYMBOL_CLASS (sym) = LOC_TYPEDEF; 6943 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 6944 add_symbol_to_list (sym, cu->list_in_scope); 6945 break; 6946 case DW_TAG_enumerator: 6947 if (processing_has_namespace_info 6948 && processing_current_prefix[0] != '\0') 6949 { 6950 SYMBOL_LINKAGE_NAME (sym) = typename_concat (&objfile->objfile_obstack, 6951 processing_current_prefix, 6952 name, cu); 6953 } 6954 attr = dwarf2_attr (die, DW_AT_const_value, cu); 6955 if (attr) 6956 { 6957 dwarf2_const_value (attr, sym, cu); 6958 } 6959 { 6960 /* NOTE: carlton/2003-11-10: See comment above in the 6961 DW_TAG_class_type, etc. block. */ 6962 6963 struct pending **list_to_add; 6964 6965 list_to_add = (cu->list_in_scope == &file_symbols 6966 && (cu->language == language_cplus 6967 || cu->language == language_java) 6968 ? &global_symbols : cu->list_in_scope); 6969 6970 add_symbol_to_list (sym, list_to_add); 6971 } 6972 break; 6973 case DW_TAG_namespace: 6974 SYMBOL_CLASS (sym) = LOC_TYPEDEF; 6975 add_symbol_to_list (sym, &global_symbols); 6976 break; 6977 default: 6978 /* Not a tag we recognize. Hopefully we aren't processing 6979 trash data, but since we must specifically ignore things 6980 we don't recognize, there is nothing else we should do at 6981 this point. */ 6982 complaint (&symfile_complaints, "unsupported tag: '%s'", 6983 dwarf_tag_name (die->tag)); 6984 break; 6985 } 6986 } 6987 return (sym); 6988} 6989 6990/* Copy constant value from an attribute to a symbol. */ 6991 6992static void 6993dwarf2_const_value (struct attribute *attr, struct symbol *sym, 6994 struct dwarf2_cu *cu) 6995{ 6996 struct objfile *objfile = cu->objfile; 6997 struct comp_unit_head *cu_header = &cu->header; 6998 struct dwarf_block *blk; 6999 7000 switch (attr->form) 7001 { 7002 case DW_FORM_addr: 7003 if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != cu_header->addr_size) 7004 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym), 7005 cu_header->addr_size, 7006 TYPE_LENGTH (SYMBOL_TYPE 7007 (sym))); 7008 SYMBOL_VALUE_BYTES (sym) = (char *) 7009 obstack_alloc (&objfile->objfile_obstack, cu_header->addr_size); 7010 /* NOTE: cagney/2003-05-09: In-lined store_address call with 7011 it's body - store_unsigned_integer. */ 7012 store_unsigned_integer (SYMBOL_VALUE_BYTES (sym), cu_header->addr_size, 7013 DW_ADDR (attr)); 7014 SYMBOL_CLASS (sym) = LOC_CONST_BYTES; 7015 break; 7016 case DW_FORM_block1: 7017 case DW_FORM_block2: 7018 case DW_FORM_block4: 7019 case DW_FORM_block: 7020 blk = DW_BLOCK (attr); 7021 if (TYPE_LENGTH (SYMBOL_TYPE (sym)) != blk->size) 7022 dwarf2_const_value_length_mismatch_complaint (DEPRECATED_SYMBOL_NAME (sym), 7023 blk->size, 7024 TYPE_LENGTH (SYMBOL_TYPE 7025 (sym))); 7026 SYMBOL_VALUE_BYTES (sym) = (char *) 7027 obstack_alloc (&objfile->objfile_obstack, blk->size); 7028 memcpy (SYMBOL_VALUE_BYTES (sym), blk->data, blk->size); 7029 SYMBOL_CLASS (sym) = LOC_CONST_BYTES; 7030 break; 7031 7032 /* The DW_AT_const_value attributes are supposed to carry the 7033 symbol's value "represented as it would be on the target 7034 architecture." By the time we get here, it's already been 7035 converted to host endianness, so we just need to sign- or 7036 zero-extend it as appropriate. */ 7037 case DW_FORM_data1: 7038 dwarf2_const_value_data (attr, sym, 8); 7039 break; 7040 case DW_FORM_data2: 7041 dwarf2_const_value_data (attr, sym, 16); 7042 break; 7043 case DW_FORM_data4: 7044 dwarf2_const_value_data (attr, sym, 32); 7045 break; 7046 case DW_FORM_data8: 7047 dwarf2_const_value_data (attr, sym, 64); 7048 break; 7049 7050 case DW_FORM_sdata: 7051 SYMBOL_VALUE (sym) = DW_SND (attr); 7052 SYMBOL_CLASS (sym) = LOC_CONST; 7053 break; 7054 7055 case DW_FORM_udata: 7056 SYMBOL_VALUE (sym) = DW_UNSND (attr); 7057 SYMBOL_CLASS (sym) = LOC_CONST; 7058 break; 7059 7060 default: 7061 complaint (&symfile_complaints, 7062 "unsupported const value attribute form: '%s'", 7063 dwarf_form_name (attr->form)); 7064 SYMBOL_VALUE (sym) = 0; 7065 SYMBOL_CLASS (sym) = LOC_CONST; 7066 break; 7067 } 7068} 7069 7070 7071/* Given an attr with a DW_FORM_dataN value in host byte order, sign- 7072 or zero-extend it as appropriate for the symbol's type. */ 7073static void 7074dwarf2_const_value_data (struct attribute *attr, 7075 struct symbol *sym, 7076 int bits) 7077{ 7078 LONGEST l = DW_UNSND (attr); 7079 7080 if (bits < sizeof (l) * 8) 7081 { 7082 if (TYPE_UNSIGNED (SYMBOL_TYPE (sym))) 7083 l &= ((LONGEST) 1 << bits) - 1; 7084 else 7085 l = (l << (sizeof (l) * 8 - bits)) >> (sizeof (l) * 8 - bits); 7086 } 7087 7088 SYMBOL_VALUE (sym) = l; 7089 SYMBOL_CLASS (sym) = LOC_CONST; 7090} 7091 7092 7093/* Return the type of the die in question using its DW_AT_type attribute. */ 7094 7095static struct type * 7096die_type (struct die_info *die, struct dwarf2_cu *cu) 7097{ 7098 struct type *type; 7099 struct attribute *type_attr; 7100 struct die_info *type_die; 7101 7102 type_attr = dwarf2_attr (die, DW_AT_type, cu); 7103 if (!type_attr) 7104 { 7105 /* A missing DW_AT_type represents a void type. */ 7106 return dwarf2_fundamental_type (cu->objfile, FT_VOID, cu); 7107 } 7108 else 7109 type_die = follow_die_ref (die, type_attr, cu); 7110 7111 type = tag_type_to_type (type_die, cu); 7112 if (!type) 7113 { 7114 dump_die (type_die); 7115 error ("Dwarf Error: Problem turning type die at offset into gdb type [in module %s]", 7116 cu->objfile->name); 7117 } 7118 return type; 7119} 7120 7121/* Return the containing type of the die in question using its 7122 DW_AT_containing_type attribute. */ 7123 7124static struct type * 7125die_containing_type (struct die_info *die, struct dwarf2_cu *cu) 7126{ 7127 struct type *type = NULL; 7128 struct attribute *type_attr; 7129 struct die_info *type_die = NULL; 7130 7131 type_attr = dwarf2_attr (die, DW_AT_containing_type, cu); 7132 if (type_attr) 7133 { 7134 type_die = follow_die_ref (die, type_attr, cu); 7135 type = tag_type_to_type (type_die, cu); 7136 } 7137 if (!type) 7138 { 7139 if (type_die) 7140 dump_die (type_die); 7141 error ("Dwarf Error: Problem turning containing type into gdb type [in module %s]", 7142 cu->objfile->name); 7143 } 7144 return type; 7145} 7146 7147static struct type * 7148tag_type_to_type (struct die_info *die, struct dwarf2_cu *cu) 7149{ 7150 if (die->type) 7151 { 7152 return die->type; 7153 } 7154 else 7155 { 7156 read_type_die (die, cu); 7157 if (!die->type) 7158 { 7159 dump_die (die); 7160 error ("Dwarf Error: Cannot find type of die [in module %s]", 7161 cu->objfile->name); 7162 } 7163 return die->type; 7164 } 7165} 7166 7167static void 7168read_type_die (struct die_info *die, struct dwarf2_cu *cu) 7169{ 7170 char *prefix = determine_prefix (die, cu); 7171 const char *old_prefix = processing_current_prefix; 7172 struct cleanup *back_to = make_cleanup (xfree, prefix); 7173 processing_current_prefix = prefix; 7174 7175 switch (die->tag) 7176 { 7177 case DW_TAG_class_type: 7178 case DW_TAG_structure_type: 7179 case DW_TAG_union_type: 7180 read_structure_type (die, cu); 7181 break; 7182 case DW_TAG_enumeration_type: 7183 read_enumeration_type (die, cu); 7184 break; 7185 case DW_TAG_subprogram: 7186 case DW_TAG_subroutine_type: 7187 read_subroutine_type (die, cu); 7188 break; 7189 case DW_TAG_array_type: 7190 read_array_type (die, cu); 7191 break; 7192 case DW_TAG_pointer_type: 7193 read_tag_pointer_type (die, cu); 7194 break; 7195 case DW_TAG_ptr_to_member_type: 7196 read_tag_ptr_to_member_type (die, cu); 7197 break; 7198 case DW_TAG_reference_type: 7199 read_tag_reference_type (die, cu); 7200 break; 7201 case DW_TAG_const_type: 7202 read_tag_const_type (die, cu); 7203 break; 7204 case DW_TAG_volatile_type: 7205 read_tag_volatile_type (die, cu); 7206 break; 7207 case DW_TAG_string_type: 7208 read_tag_string_type (die, cu); 7209 break; 7210 case DW_TAG_typedef: 7211 read_typedef (die, cu); 7212 break; 7213 case DW_TAG_subrange_type: 7214 read_subrange_type (die, cu); 7215 break; 7216 case DW_TAG_base_type: 7217 read_base_type (die, cu); 7218 break; 7219 default: 7220 complaint (&symfile_complaints, "unexepected tag in read_type_die: '%s'", 7221 dwarf_tag_name (die->tag)); 7222 break; 7223 } 7224 7225 processing_current_prefix = old_prefix; 7226 do_cleanups (back_to); 7227} 7228 7229/* Return the name of the namespace/class that DIE is defined within, 7230 or "" if we can't tell. The caller should xfree the result. */ 7231 7232/* NOTE: carlton/2004-01-23: See read_func_scope (and the comment 7233 therein) for an example of how to use this function to deal with 7234 DW_AT_specification. */ 7235 7236static char * 7237determine_prefix (struct die_info *die, struct dwarf2_cu *cu) 7238{ 7239 struct die_info *parent; 7240 7241 if (cu->language != language_cplus 7242 && cu->language != language_java) 7243 return NULL; 7244 7245 parent = die->parent; 7246 7247 if (parent == NULL) 7248 { 7249 return xstrdup (""); 7250 } 7251 else 7252 { 7253 switch (parent->tag) { 7254 case DW_TAG_namespace: 7255 { 7256 /* FIXME: carlton/2004-03-05: Should I follow extension dies 7257 before doing this check? */ 7258 if (parent->type != NULL && TYPE_TAG_NAME (parent->type) != NULL) 7259 { 7260 return xstrdup (TYPE_TAG_NAME (parent->type)); 7261 } 7262 else 7263 { 7264 int dummy; 7265 char *parent_prefix = determine_prefix (parent, cu); 7266 char *retval = typename_concat (NULL, parent_prefix, 7267 namespace_name (parent, &dummy, 7268 cu), 7269 cu); 7270 xfree (parent_prefix); 7271 return retval; 7272 } 7273 } 7274 break; 7275 case DW_TAG_class_type: 7276 case DW_TAG_structure_type: 7277 { 7278 if (parent->type != NULL && TYPE_TAG_NAME (parent->type) != NULL) 7279 { 7280 return xstrdup (TYPE_TAG_NAME (parent->type)); 7281 } 7282 else 7283 { 7284 const char *old_prefix = processing_current_prefix; 7285 char *new_prefix = determine_prefix (parent, cu); 7286 char *retval; 7287 7288 processing_current_prefix = new_prefix; 7289 retval = determine_class_name (parent, cu); 7290 processing_current_prefix = old_prefix; 7291 7292 xfree (new_prefix); 7293 return retval; 7294 } 7295 } 7296 default: 7297 return determine_prefix (parent, cu); 7298 } 7299 } 7300} 7301 7302/* Return a newly-allocated string formed by concatenating PREFIX and 7303 SUFFIX with appropriate separator. If PREFIX or SUFFIX is NULL or empty, then 7304 simply copy the SUFFIX or PREFIX, respectively. If OBS is non-null, 7305 perform an obconcat, otherwise allocate storage for the result. The CU argument 7306 is used to determine the language and hence, the appropriate separator. */ 7307 7308#define MAX_SEP_LEN 2 /* sizeof ("::") */ 7309 7310static char * 7311typename_concat (struct obstack *obs, const char *prefix, const char *suffix, 7312 struct dwarf2_cu *cu) 7313{ 7314 char *sep; 7315 7316 if (suffix == NULL || suffix[0] == '\0' || prefix == NULL || prefix[0] == '\0') 7317 sep = ""; 7318 else if (cu->language == language_java) 7319 sep = "."; 7320 else 7321 sep = "::"; 7322 7323 if (obs == NULL) 7324 { 7325 char *retval = xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1); 7326 retval[0] = '\0'; 7327 7328 if (prefix) 7329 { 7330 strcpy (retval, prefix); 7331 strcat (retval, sep); 7332 } 7333 if (suffix) 7334 strcat (retval, suffix); 7335 7336 return retval; 7337 } 7338 else 7339 { 7340 /* We have an obstack. */ 7341 return obconcat (obs, prefix, sep, suffix); 7342 } 7343} 7344 7345static struct type * 7346dwarf_base_type (int encoding, int size, struct dwarf2_cu *cu) 7347{ 7348 struct objfile *objfile = cu->objfile; 7349 7350 /* FIXME - this should not produce a new (struct type *) 7351 every time. It should cache base types. */ 7352 struct type *type; 7353 switch (encoding) 7354 { 7355 case DW_ATE_address: 7356 type = dwarf2_fundamental_type (objfile, FT_VOID, cu); 7357 return type; 7358 case DW_ATE_boolean: 7359 type = dwarf2_fundamental_type (objfile, FT_BOOLEAN, cu); 7360 return type; 7361 case DW_ATE_complex_float: 7362 if (size == 16) 7363 { 7364 type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_COMPLEX, cu); 7365 } 7366 else 7367 { 7368 type = dwarf2_fundamental_type (objfile, FT_COMPLEX, cu); 7369 } 7370 return type; 7371 case DW_ATE_float: 7372 if (size == 8) 7373 { 7374 type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT, cu); 7375 } 7376 else 7377 { 7378 type = dwarf2_fundamental_type (objfile, FT_FLOAT, cu); 7379 } 7380 return type; 7381 case DW_ATE_signed: 7382 switch (size) 7383 { 7384 case 1: 7385 type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR, cu); 7386 break; 7387 case 2: 7388 type = dwarf2_fundamental_type (objfile, FT_SIGNED_SHORT, cu); 7389 break; 7390 default: 7391 case 4: 7392 type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER, cu); 7393 break; 7394 } 7395 return type; 7396 case DW_ATE_signed_char: 7397 type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR, cu); 7398 return type; 7399 case DW_ATE_unsigned: 7400 switch (size) 7401 { 7402 case 1: 7403 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR, cu); 7404 break; 7405 case 2: 7406 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_SHORT, cu); 7407 break; 7408 default: 7409 case 4: 7410 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_INTEGER, cu); 7411 break; 7412 } 7413 return type; 7414 case DW_ATE_unsigned_char: 7415 type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR, cu); 7416 return type; 7417 default: 7418 type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER, cu); 7419 return type; 7420 } 7421} 7422 7423#if 0 7424struct die_info * 7425copy_die (struct die_info *old_die) 7426{ 7427 struct die_info *new_die; 7428 int i, num_attrs; 7429 7430 new_die = (struct die_info *) xmalloc (sizeof (struct die_info)); 7431 memset (new_die, 0, sizeof (struct die_info)); 7432 7433 new_die->tag = old_die->tag; 7434 new_die->has_children = old_die->has_children; 7435 new_die->abbrev = old_die->abbrev; 7436 new_die->offset = old_die->offset; 7437 new_die->type = NULL; 7438 7439 num_attrs = old_die->num_attrs; 7440 new_die->num_attrs = num_attrs; 7441 new_die->attrs = (struct attribute *) 7442 xmalloc (num_attrs * sizeof (struct attribute)); 7443 7444 for (i = 0; i < old_die->num_attrs; ++i) 7445 { 7446 new_die->attrs[i].name = old_die->attrs[i].name; 7447 new_die->attrs[i].form = old_die->attrs[i].form; 7448 new_die->attrs[i].u.addr = old_die->attrs[i].u.addr; 7449 } 7450 7451 new_die->next = NULL; 7452 return new_die; 7453} 7454#endif 7455 7456/* Return sibling of die, NULL if no sibling. */ 7457 7458static struct die_info * 7459sibling_die (struct die_info *die) 7460{ 7461 return die->sibling; 7462} 7463 7464/* Get linkage name of a die, return NULL if not found. */ 7465 7466static char * 7467dwarf2_linkage_name (struct die_info *die, struct dwarf2_cu *cu) 7468{ 7469 struct attribute *attr; 7470 7471 attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu); 7472 if (attr && DW_STRING (attr)) 7473 return DW_STRING (attr); 7474 attr = dwarf2_attr (die, DW_AT_name, cu); 7475 if (attr && DW_STRING (attr)) 7476 return DW_STRING (attr); 7477 return NULL; 7478} 7479 7480/* Get name of a die, return NULL if not found. */ 7481 7482static char * 7483dwarf2_name (struct die_info *die, struct dwarf2_cu *cu) 7484{ 7485 struct attribute *attr; 7486 7487 attr = dwarf2_attr (die, DW_AT_name, cu); 7488 if (attr && DW_STRING (attr)) 7489 return DW_STRING (attr); 7490 return NULL; 7491} 7492 7493/* Return the die that this die in an extension of, or NULL if there 7494 is none. */ 7495 7496static struct die_info * 7497dwarf2_extension (struct die_info *die, struct dwarf2_cu *cu) 7498{ 7499 struct attribute *attr; 7500 7501 attr = dwarf2_attr (die, DW_AT_extension, cu); 7502 if (attr == NULL) 7503 return NULL; 7504 7505 return follow_die_ref (die, attr, cu); 7506} 7507 7508/* Convert a DIE tag into its string name. */ 7509 7510static char * 7511dwarf_tag_name (unsigned tag) 7512{ 7513 switch (tag) 7514 { 7515 case DW_TAG_padding: 7516 return "DW_TAG_padding"; 7517 case DW_TAG_array_type: 7518 return "DW_TAG_array_type"; 7519 case DW_TAG_class_type: 7520 return "DW_TAG_class_type"; 7521 case DW_TAG_entry_point: 7522 return "DW_TAG_entry_point"; 7523 case DW_TAG_enumeration_type: 7524 return "DW_TAG_enumeration_type"; 7525 case DW_TAG_formal_parameter: 7526 return "DW_TAG_formal_parameter"; 7527 case DW_TAG_imported_declaration: 7528 return "DW_TAG_imported_declaration"; 7529 case DW_TAG_label: 7530 return "DW_TAG_label"; 7531 case DW_TAG_lexical_block: 7532 return "DW_TAG_lexical_block"; 7533 case DW_TAG_member: 7534 return "DW_TAG_member"; 7535 case DW_TAG_pointer_type: 7536 return "DW_TAG_pointer_type"; 7537 case DW_TAG_reference_type: 7538 return "DW_TAG_reference_type"; 7539 case DW_TAG_compile_unit: 7540 return "DW_TAG_compile_unit"; 7541 case DW_TAG_string_type: 7542 return "DW_TAG_string_type"; 7543 case DW_TAG_structure_type: 7544 return "DW_TAG_structure_type"; 7545 case DW_TAG_subroutine_type: 7546 return "DW_TAG_subroutine_type"; 7547 case DW_TAG_typedef: 7548 return "DW_TAG_typedef"; 7549 case DW_TAG_union_type: 7550 return "DW_TAG_union_type"; 7551 case DW_TAG_unspecified_parameters: 7552 return "DW_TAG_unspecified_parameters"; 7553 case DW_TAG_variant: 7554 return "DW_TAG_variant"; 7555 case DW_TAG_common_block: 7556 return "DW_TAG_common_block"; 7557 case DW_TAG_common_inclusion: 7558 return "DW_TAG_common_inclusion"; 7559 case DW_TAG_inheritance: 7560 return "DW_TAG_inheritance"; 7561 case DW_TAG_inlined_subroutine: 7562 return "DW_TAG_inlined_subroutine"; 7563 case DW_TAG_module: 7564 return "DW_TAG_module"; 7565 case DW_TAG_ptr_to_member_type: 7566 return "DW_TAG_ptr_to_member_type"; 7567 case DW_TAG_set_type: 7568 return "DW_TAG_set_type"; 7569 case DW_TAG_subrange_type: 7570 return "DW_TAG_subrange_type"; 7571 case DW_TAG_with_stmt: 7572 return "DW_TAG_with_stmt"; 7573 case DW_TAG_access_declaration: 7574 return "DW_TAG_access_declaration"; 7575 case DW_TAG_base_type: 7576 return "DW_TAG_base_type"; 7577 case DW_TAG_catch_block: 7578 return "DW_TAG_catch_block"; 7579 case DW_TAG_const_type: 7580 return "DW_TAG_const_type"; 7581 case DW_TAG_constant: 7582 return "DW_TAG_constant"; 7583 case DW_TAG_enumerator: 7584 return "DW_TAG_enumerator"; 7585 case DW_TAG_file_type: 7586 return "DW_TAG_file_type"; 7587 case DW_TAG_friend: 7588 return "DW_TAG_friend"; 7589 case DW_TAG_namelist: 7590 return "DW_TAG_namelist"; 7591 case DW_TAG_namelist_item: 7592 return "DW_TAG_namelist_item"; 7593 case DW_TAG_packed_type: 7594 return "DW_TAG_packed_type"; 7595 case DW_TAG_subprogram: 7596 return "DW_TAG_subprogram"; 7597 case DW_TAG_template_type_param: 7598 return "DW_TAG_template_type_param"; 7599 case DW_TAG_template_value_param: 7600 return "DW_TAG_template_value_param"; 7601 case DW_TAG_thrown_type: 7602 return "DW_TAG_thrown_type"; 7603 case DW_TAG_try_block: 7604 return "DW_TAG_try_block"; 7605 case DW_TAG_variant_part: 7606 return "DW_TAG_variant_part"; 7607 case DW_TAG_variable: 7608 return "DW_TAG_variable"; 7609 case DW_TAG_volatile_type: 7610 return "DW_TAG_volatile_type"; 7611 case DW_TAG_dwarf_procedure: 7612 return "DW_TAG_dwarf_procedure"; 7613 case DW_TAG_restrict_type: 7614 return "DW_TAG_restrict_type"; 7615 case DW_TAG_interface_type: 7616 return "DW_TAG_interface_type"; 7617 case DW_TAG_namespace: 7618 return "DW_TAG_namespace"; 7619 case DW_TAG_imported_module: 7620 return "DW_TAG_imported_module"; 7621 case DW_TAG_unspecified_type: 7622 return "DW_TAG_unspecified_type"; 7623 case DW_TAG_partial_unit: 7624 return "DW_TAG_partial_unit"; 7625 case DW_TAG_imported_unit: 7626 return "DW_TAG_imported_unit"; 7627 case DW_TAG_MIPS_loop: 7628 return "DW_TAG_MIPS_loop"; 7629 case DW_TAG_format_label: 7630 return "DW_TAG_format_label"; 7631 case DW_TAG_function_template: 7632 return "DW_TAG_function_template"; 7633 case DW_TAG_class_template: 7634 return "DW_TAG_class_template"; 7635 default: 7636 return "DW_TAG_<unknown>"; 7637 } 7638} 7639 7640/* Convert a DWARF attribute code into its string name. */ 7641 7642static char * 7643dwarf_attr_name (unsigned attr) 7644{ 7645 switch (attr) 7646 { 7647 case DW_AT_sibling: 7648 return "DW_AT_sibling"; 7649 case DW_AT_location: 7650 return "DW_AT_location"; 7651 case DW_AT_name: 7652 return "DW_AT_name"; 7653 case DW_AT_ordering: 7654 return "DW_AT_ordering"; 7655 case DW_AT_subscr_data: 7656 return "DW_AT_subscr_data"; 7657 case DW_AT_byte_size: 7658 return "DW_AT_byte_size"; 7659 case DW_AT_bit_offset: 7660 return "DW_AT_bit_offset"; 7661 case DW_AT_bit_size: 7662 return "DW_AT_bit_size"; 7663 case DW_AT_element_list: 7664 return "DW_AT_element_list"; 7665 case DW_AT_stmt_list: 7666 return "DW_AT_stmt_list"; 7667 case DW_AT_low_pc: 7668 return "DW_AT_low_pc"; 7669 case DW_AT_high_pc: 7670 return "DW_AT_high_pc"; 7671 case DW_AT_language: 7672 return "DW_AT_language"; 7673 case DW_AT_member: 7674 return "DW_AT_member"; 7675 case DW_AT_discr: 7676 return "DW_AT_discr"; 7677 case DW_AT_discr_value: 7678 return "DW_AT_discr_value"; 7679 case DW_AT_visibility: 7680 return "DW_AT_visibility"; 7681 case DW_AT_import: 7682 return "DW_AT_import"; 7683 case DW_AT_string_length: 7684 return "DW_AT_string_length"; 7685 case DW_AT_common_reference: 7686 return "DW_AT_common_reference"; 7687 case DW_AT_comp_dir: 7688 return "DW_AT_comp_dir"; 7689 case DW_AT_const_value: 7690 return "DW_AT_const_value"; 7691 case DW_AT_containing_type: 7692 return "DW_AT_containing_type"; 7693 case DW_AT_default_value: 7694 return "DW_AT_default_value"; 7695 case DW_AT_inline: 7696 return "DW_AT_inline"; 7697 case DW_AT_is_optional: 7698 return "DW_AT_is_optional"; 7699 case DW_AT_lower_bound: 7700 return "DW_AT_lower_bound"; 7701 case DW_AT_producer: 7702 return "DW_AT_producer"; 7703 case DW_AT_prototyped: 7704 return "DW_AT_prototyped"; 7705 case DW_AT_return_addr: 7706 return "DW_AT_return_addr"; 7707 case DW_AT_start_scope: 7708 return "DW_AT_start_scope"; 7709 case DW_AT_stride_size: 7710 return "DW_AT_stride_size"; 7711 case DW_AT_upper_bound: 7712 return "DW_AT_upper_bound"; 7713 case DW_AT_abstract_origin: 7714 return "DW_AT_abstract_origin"; 7715 case DW_AT_accessibility: 7716 return "DW_AT_accessibility"; 7717 case DW_AT_address_class: 7718 return "DW_AT_address_class"; 7719 case DW_AT_artificial: 7720 return "DW_AT_artificial"; 7721 case DW_AT_base_types: 7722 return "DW_AT_base_types"; 7723 case DW_AT_calling_convention: 7724 return "DW_AT_calling_convention"; 7725 case DW_AT_count: 7726 return "DW_AT_count"; 7727 case DW_AT_data_member_location: 7728 return "DW_AT_data_member_location"; 7729 case DW_AT_decl_column: 7730 return "DW_AT_decl_column"; 7731 case DW_AT_decl_file: 7732 return "DW_AT_decl_file"; 7733 case DW_AT_decl_line: 7734 return "DW_AT_decl_line"; 7735 case DW_AT_declaration: 7736 return "DW_AT_declaration"; 7737 case DW_AT_discr_list: 7738 return "DW_AT_discr_list"; 7739 case DW_AT_encoding: 7740 return "DW_AT_encoding"; 7741 case DW_AT_external: 7742 return "DW_AT_external"; 7743 case DW_AT_frame_base: 7744 return "DW_AT_frame_base"; 7745 case DW_AT_friend: 7746 return "DW_AT_friend"; 7747 case DW_AT_identifier_case: 7748 return "DW_AT_identifier_case"; 7749 case DW_AT_macro_info: 7750 return "DW_AT_macro_info"; 7751 case DW_AT_namelist_items: 7752 return "DW_AT_namelist_items"; 7753 case DW_AT_priority: 7754 return "DW_AT_priority"; 7755 case DW_AT_segment: 7756 return "DW_AT_segment"; 7757 case DW_AT_specification: 7758 return "DW_AT_specification"; 7759 case DW_AT_static_link: 7760 return "DW_AT_static_link"; 7761 case DW_AT_type: 7762 return "DW_AT_type"; 7763 case DW_AT_use_location: 7764 return "DW_AT_use_location"; 7765 case DW_AT_variable_parameter: 7766 return "DW_AT_variable_parameter"; 7767 case DW_AT_virtuality: 7768 return "DW_AT_virtuality"; 7769 case DW_AT_vtable_elem_location: 7770 return "DW_AT_vtable_elem_location"; 7771 case DW_AT_allocated: 7772 return "DW_AT_allocated"; 7773 case DW_AT_associated: 7774 return "DW_AT_associated"; 7775 case DW_AT_data_location: 7776 return "DW_AT_data_location"; 7777 case DW_AT_stride: 7778 return "DW_AT_stride"; 7779 case DW_AT_entry_pc: 7780 return "DW_AT_entry_pc"; 7781 case DW_AT_use_UTF8: 7782 return "DW_AT_use_UTF8"; 7783 case DW_AT_extension: 7784 return "DW_AT_extension"; 7785 case DW_AT_ranges: 7786 return "DW_AT_ranges"; 7787 case DW_AT_trampoline: 7788 return "DW_AT_trampoline"; 7789 case DW_AT_call_column: 7790 return "DW_AT_call_column"; 7791 case DW_AT_call_file: 7792 return "DW_AT_call_file"; 7793 case DW_AT_call_line: 7794 return "DW_AT_call_line"; 7795#ifdef MIPS 7796 case DW_AT_MIPS_fde: 7797 return "DW_AT_MIPS_fde"; 7798 case DW_AT_MIPS_loop_begin: 7799 return "DW_AT_MIPS_loop_begin"; 7800 case DW_AT_MIPS_tail_loop_begin: 7801 return "DW_AT_MIPS_tail_loop_begin"; 7802 case DW_AT_MIPS_epilog_begin: 7803 return "DW_AT_MIPS_epilog_begin"; 7804 case DW_AT_MIPS_loop_unroll_factor: 7805 return "DW_AT_MIPS_loop_unroll_factor"; 7806 case DW_AT_MIPS_software_pipeline_depth: 7807 return "DW_AT_MIPS_software_pipeline_depth"; 7808#endif 7809 case DW_AT_MIPS_linkage_name: 7810 return "DW_AT_MIPS_linkage_name"; 7811 7812 case DW_AT_sf_names: 7813 return "DW_AT_sf_names"; 7814 case DW_AT_src_info: 7815 return "DW_AT_src_info"; 7816 case DW_AT_mac_info: 7817 return "DW_AT_mac_info"; 7818 case DW_AT_src_coords: 7819 return "DW_AT_src_coords"; 7820 case DW_AT_body_begin: 7821 return "DW_AT_body_begin"; 7822 case DW_AT_body_end: 7823 return "DW_AT_body_end"; 7824 case DW_AT_GNU_vector: 7825 return "DW_AT_GNU_vector"; 7826 default: 7827 return "DW_AT_<unknown>"; 7828 } 7829} 7830 7831/* Convert a DWARF value form code into its string name. */ 7832 7833static char * 7834dwarf_form_name (unsigned form) 7835{ 7836 switch (form) 7837 { 7838 case DW_FORM_addr: 7839 return "DW_FORM_addr"; 7840 case DW_FORM_block2: 7841 return "DW_FORM_block2"; 7842 case DW_FORM_block4: 7843 return "DW_FORM_block4"; 7844 case DW_FORM_data2: 7845 return "DW_FORM_data2"; 7846 case DW_FORM_data4: 7847 return "DW_FORM_data4"; 7848 case DW_FORM_data8: 7849 return "DW_FORM_data8"; 7850 case DW_FORM_string: 7851 return "DW_FORM_string"; 7852 case DW_FORM_block: 7853 return "DW_FORM_block"; 7854 case DW_FORM_block1: 7855 return "DW_FORM_block1"; 7856 case DW_FORM_data1: 7857 return "DW_FORM_data1"; 7858 case DW_FORM_flag: 7859 return "DW_FORM_flag"; 7860 case DW_FORM_sdata: 7861 return "DW_FORM_sdata"; 7862 case DW_FORM_strp: 7863 return "DW_FORM_strp"; 7864 case DW_FORM_udata: 7865 return "DW_FORM_udata"; 7866 case DW_FORM_ref_addr: 7867 return "DW_FORM_ref_addr"; 7868 case DW_FORM_ref1: 7869 return "DW_FORM_ref1"; 7870 case DW_FORM_ref2: 7871 return "DW_FORM_ref2"; 7872 case DW_FORM_ref4: 7873 return "DW_FORM_ref4"; 7874 case DW_FORM_ref8: 7875 return "DW_FORM_ref8"; 7876 case DW_FORM_ref_udata: 7877 return "DW_FORM_ref_udata"; 7878 case DW_FORM_indirect: 7879 return "DW_FORM_indirect"; 7880 default: 7881 return "DW_FORM_<unknown>"; 7882 } 7883} 7884 7885/* Convert a DWARF stack opcode into its string name. */ 7886 7887static char * 7888dwarf_stack_op_name (unsigned op) 7889{ 7890 switch (op) 7891 { 7892 case DW_OP_addr: 7893 return "DW_OP_addr"; 7894 case DW_OP_deref: 7895 return "DW_OP_deref"; 7896 case DW_OP_const1u: 7897 return "DW_OP_const1u"; 7898 case DW_OP_const1s: 7899 return "DW_OP_const1s"; 7900 case DW_OP_const2u: 7901 return "DW_OP_const2u"; 7902 case DW_OP_const2s: 7903 return "DW_OP_const2s"; 7904 case DW_OP_const4u: 7905 return "DW_OP_const4u"; 7906 case DW_OP_const4s: 7907 return "DW_OP_const4s"; 7908 case DW_OP_const8u: 7909 return "DW_OP_const8u"; 7910 case DW_OP_const8s: 7911 return "DW_OP_const8s"; 7912 case DW_OP_constu: 7913 return "DW_OP_constu"; 7914 case DW_OP_consts: 7915 return "DW_OP_consts"; 7916 case DW_OP_dup: 7917 return "DW_OP_dup"; 7918 case DW_OP_drop: 7919 return "DW_OP_drop"; 7920 case DW_OP_over: 7921 return "DW_OP_over"; 7922 case DW_OP_pick: 7923 return "DW_OP_pick"; 7924 case DW_OP_swap: 7925 return "DW_OP_swap"; 7926 case DW_OP_rot: 7927 return "DW_OP_rot"; 7928 case DW_OP_xderef: 7929 return "DW_OP_xderef"; 7930 case DW_OP_abs: 7931 return "DW_OP_abs"; 7932 case DW_OP_and: 7933 return "DW_OP_and"; 7934 case DW_OP_div: 7935 return "DW_OP_div"; 7936 case DW_OP_minus: 7937 return "DW_OP_minus"; 7938 case DW_OP_mod: 7939 return "DW_OP_mod"; 7940 case DW_OP_mul: 7941 return "DW_OP_mul"; 7942 case DW_OP_neg: 7943 return "DW_OP_neg"; 7944 case DW_OP_not: 7945 return "DW_OP_not"; 7946 case DW_OP_or: 7947 return "DW_OP_or"; 7948 case DW_OP_plus: 7949 return "DW_OP_plus"; 7950 case DW_OP_plus_uconst: 7951 return "DW_OP_plus_uconst"; 7952 case DW_OP_shl: 7953 return "DW_OP_shl"; 7954 case DW_OP_shr: 7955 return "DW_OP_shr"; 7956 case DW_OP_shra: 7957 return "DW_OP_shra"; 7958 case DW_OP_xor: 7959 return "DW_OP_xor"; 7960 case DW_OP_bra: 7961 return "DW_OP_bra"; 7962 case DW_OP_eq: 7963 return "DW_OP_eq"; 7964 case DW_OP_ge: 7965 return "DW_OP_ge"; 7966 case DW_OP_gt: 7967 return "DW_OP_gt"; 7968 case DW_OP_le: 7969 return "DW_OP_le"; 7970 case DW_OP_lt: 7971 return "DW_OP_lt"; 7972 case DW_OP_ne: 7973 return "DW_OP_ne"; 7974 case DW_OP_skip: 7975 return "DW_OP_skip"; 7976 case DW_OP_lit0: 7977 return "DW_OP_lit0"; 7978 case DW_OP_lit1: 7979 return "DW_OP_lit1"; 7980 case DW_OP_lit2: 7981 return "DW_OP_lit2"; 7982 case DW_OP_lit3: 7983 return "DW_OP_lit3"; 7984 case DW_OP_lit4: 7985 return "DW_OP_lit4"; 7986 case DW_OP_lit5: 7987 return "DW_OP_lit5"; 7988 case DW_OP_lit6: 7989 return "DW_OP_lit6"; 7990 case DW_OP_lit7: 7991 return "DW_OP_lit7"; 7992 case DW_OP_lit8: 7993 return "DW_OP_lit8"; 7994 case DW_OP_lit9: 7995 return "DW_OP_lit9"; 7996 case DW_OP_lit10: 7997 return "DW_OP_lit10"; 7998 case DW_OP_lit11: 7999 return "DW_OP_lit11"; 8000 case DW_OP_lit12: 8001 return "DW_OP_lit12"; 8002 case DW_OP_lit13: 8003 return "DW_OP_lit13"; 8004 case DW_OP_lit14: 8005 return "DW_OP_lit14"; 8006 case DW_OP_lit15: 8007 return "DW_OP_lit15"; 8008 case DW_OP_lit16: 8009 return "DW_OP_lit16"; 8010 case DW_OP_lit17: 8011 return "DW_OP_lit17"; 8012 case DW_OP_lit18: 8013 return "DW_OP_lit18"; 8014 case DW_OP_lit19: 8015 return "DW_OP_lit19"; 8016 case DW_OP_lit20: 8017 return "DW_OP_lit20"; 8018 case DW_OP_lit21: 8019 return "DW_OP_lit21"; 8020 case DW_OP_lit22: 8021 return "DW_OP_lit22"; 8022 case DW_OP_lit23: 8023 return "DW_OP_lit23"; 8024 case DW_OP_lit24: 8025 return "DW_OP_lit24"; 8026 case DW_OP_lit25: 8027 return "DW_OP_lit25"; 8028 case DW_OP_lit26: 8029 return "DW_OP_lit26"; 8030 case DW_OP_lit27: 8031 return "DW_OP_lit27"; 8032 case DW_OP_lit28: 8033 return "DW_OP_lit28"; 8034 case DW_OP_lit29: 8035 return "DW_OP_lit29"; 8036 case DW_OP_lit30: 8037 return "DW_OP_lit30"; 8038 case DW_OP_lit31: 8039 return "DW_OP_lit31"; 8040 case DW_OP_reg0: 8041 return "DW_OP_reg0"; 8042 case DW_OP_reg1: 8043 return "DW_OP_reg1"; 8044 case DW_OP_reg2: 8045 return "DW_OP_reg2"; 8046 case DW_OP_reg3: 8047 return "DW_OP_reg3"; 8048 case DW_OP_reg4: 8049 return "DW_OP_reg4"; 8050 case DW_OP_reg5: 8051 return "DW_OP_reg5"; 8052 case DW_OP_reg6: 8053 return "DW_OP_reg6"; 8054 case DW_OP_reg7: 8055 return "DW_OP_reg7"; 8056 case DW_OP_reg8: 8057 return "DW_OP_reg8"; 8058 case DW_OP_reg9: 8059 return "DW_OP_reg9"; 8060 case DW_OP_reg10: 8061 return "DW_OP_reg10"; 8062 case DW_OP_reg11: 8063 return "DW_OP_reg11"; 8064 case DW_OP_reg12: 8065 return "DW_OP_reg12"; 8066 case DW_OP_reg13: 8067 return "DW_OP_reg13"; 8068 case DW_OP_reg14: 8069 return "DW_OP_reg14"; 8070 case DW_OP_reg15: 8071 return "DW_OP_reg15"; 8072 case DW_OP_reg16: 8073 return "DW_OP_reg16"; 8074 case DW_OP_reg17: 8075 return "DW_OP_reg17"; 8076 case DW_OP_reg18: 8077 return "DW_OP_reg18"; 8078 case DW_OP_reg19: 8079 return "DW_OP_reg19"; 8080 case DW_OP_reg20: 8081 return "DW_OP_reg20"; 8082 case DW_OP_reg21: 8083 return "DW_OP_reg21"; 8084 case DW_OP_reg22: 8085 return "DW_OP_reg22"; 8086 case DW_OP_reg23: 8087 return "DW_OP_reg23"; 8088 case DW_OP_reg24: 8089 return "DW_OP_reg24"; 8090 case DW_OP_reg25: 8091 return "DW_OP_reg25"; 8092 case DW_OP_reg26: 8093 return "DW_OP_reg26"; 8094 case DW_OP_reg27: 8095 return "DW_OP_reg27"; 8096 case DW_OP_reg28: 8097 return "DW_OP_reg28"; 8098 case DW_OP_reg29: 8099 return "DW_OP_reg29"; 8100 case DW_OP_reg30: 8101 return "DW_OP_reg30"; 8102 case DW_OP_reg31: 8103 return "DW_OP_reg31"; 8104 case DW_OP_breg0: 8105 return "DW_OP_breg0"; 8106 case DW_OP_breg1: 8107 return "DW_OP_breg1"; 8108 case DW_OP_breg2: 8109 return "DW_OP_breg2"; 8110 case DW_OP_breg3: 8111 return "DW_OP_breg3"; 8112 case DW_OP_breg4: 8113 return "DW_OP_breg4"; 8114 case DW_OP_breg5: 8115 return "DW_OP_breg5"; 8116 case DW_OP_breg6: 8117 return "DW_OP_breg6"; 8118 case DW_OP_breg7: 8119 return "DW_OP_breg7"; 8120 case DW_OP_breg8: 8121 return "DW_OP_breg8"; 8122 case DW_OP_breg9: 8123 return "DW_OP_breg9"; 8124 case DW_OP_breg10: 8125 return "DW_OP_breg10"; 8126 case DW_OP_breg11: 8127 return "DW_OP_breg11"; 8128 case DW_OP_breg12: 8129 return "DW_OP_breg12"; 8130 case DW_OP_breg13: 8131 return "DW_OP_breg13"; 8132 case DW_OP_breg14: 8133 return "DW_OP_breg14"; 8134 case DW_OP_breg15: 8135 return "DW_OP_breg15"; 8136 case DW_OP_breg16: 8137 return "DW_OP_breg16"; 8138 case DW_OP_breg17: 8139 return "DW_OP_breg17"; 8140 case DW_OP_breg18: 8141 return "DW_OP_breg18"; 8142 case DW_OP_breg19: 8143 return "DW_OP_breg19"; 8144 case DW_OP_breg20: 8145 return "DW_OP_breg20"; 8146 case DW_OP_breg21: 8147 return "DW_OP_breg21"; 8148 case DW_OP_breg22: 8149 return "DW_OP_breg22"; 8150 case DW_OP_breg23: 8151 return "DW_OP_breg23"; 8152 case DW_OP_breg24: 8153 return "DW_OP_breg24"; 8154 case DW_OP_breg25: 8155 return "DW_OP_breg25"; 8156 case DW_OP_breg26: 8157 return "DW_OP_breg26"; 8158 case DW_OP_breg27: 8159 return "DW_OP_breg27"; 8160 case DW_OP_breg28: 8161 return "DW_OP_breg28"; 8162 case DW_OP_breg29: 8163 return "DW_OP_breg29"; 8164 case DW_OP_breg30: 8165 return "DW_OP_breg30"; 8166 case DW_OP_breg31: 8167 return "DW_OP_breg31"; 8168 case DW_OP_regx: 8169 return "DW_OP_regx"; 8170 case DW_OP_fbreg: 8171 return "DW_OP_fbreg"; 8172 case DW_OP_bregx: 8173 return "DW_OP_bregx"; 8174 case DW_OP_piece: 8175 return "DW_OP_piece"; 8176 case DW_OP_deref_size: 8177 return "DW_OP_deref_size"; 8178 case DW_OP_xderef_size: 8179 return "DW_OP_xderef_size"; 8180 case DW_OP_nop: 8181 return "DW_OP_nop"; 8182 /* DWARF 3 extensions. */ 8183 case DW_OP_push_object_address: 8184 return "DW_OP_push_object_address"; 8185 case DW_OP_call2: 8186 return "DW_OP_call2"; 8187 case DW_OP_call4: 8188 return "DW_OP_call4"; 8189 case DW_OP_call_ref: 8190 return "DW_OP_call_ref"; 8191 /* GNU extensions. */ 8192 case DW_OP_GNU_push_tls_address: 8193 return "DW_OP_GNU_push_tls_address"; 8194 default: 8195 return "OP_<unknown>"; 8196 } 8197} 8198 8199static char * 8200dwarf_bool_name (unsigned mybool) 8201{ 8202 if (mybool) 8203 return "TRUE"; 8204 else 8205 return "FALSE"; 8206} 8207 8208/* Convert a DWARF type code into its string name. */ 8209 8210static char * 8211dwarf_type_encoding_name (unsigned enc) 8212{ 8213 switch (enc) 8214 { 8215 case DW_ATE_address: 8216 return "DW_ATE_address"; 8217 case DW_ATE_boolean: 8218 return "DW_ATE_boolean"; 8219 case DW_ATE_complex_float: 8220 return "DW_ATE_complex_float"; 8221 case DW_ATE_float: 8222 return "DW_ATE_float"; 8223 case DW_ATE_signed: 8224 return "DW_ATE_signed"; 8225 case DW_ATE_signed_char: 8226 return "DW_ATE_signed_char"; 8227 case DW_ATE_unsigned: 8228 return "DW_ATE_unsigned"; 8229 case DW_ATE_unsigned_char: 8230 return "DW_ATE_unsigned_char"; 8231 case DW_ATE_imaginary_float: 8232 return "DW_ATE_imaginary_float"; 8233 default: 8234 return "DW_ATE_<unknown>"; 8235 } 8236} 8237 8238/* Convert a DWARF call frame info operation to its string name. */ 8239 8240#if 0 8241static char * 8242dwarf_cfi_name (unsigned cfi_opc) 8243{ 8244 switch (cfi_opc) 8245 { 8246 case DW_CFA_advance_loc: 8247 return "DW_CFA_advance_loc"; 8248 case DW_CFA_offset: 8249 return "DW_CFA_offset"; 8250 case DW_CFA_restore: 8251 return "DW_CFA_restore"; 8252 case DW_CFA_nop: 8253 return "DW_CFA_nop"; 8254 case DW_CFA_set_loc: 8255 return "DW_CFA_set_loc"; 8256 case DW_CFA_advance_loc1: 8257 return "DW_CFA_advance_loc1"; 8258 case DW_CFA_advance_loc2: 8259 return "DW_CFA_advance_loc2"; 8260 case DW_CFA_advance_loc4: 8261 return "DW_CFA_advance_loc4"; 8262 case DW_CFA_offset_extended: 8263 return "DW_CFA_offset_extended"; 8264 case DW_CFA_restore_extended: 8265 return "DW_CFA_restore_extended"; 8266 case DW_CFA_undefined: 8267 return "DW_CFA_undefined"; 8268 case DW_CFA_same_value: 8269 return "DW_CFA_same_value"; 8270 case DW_CFA_register: 8271 return "DW_CFA_register"; 8272 case DW_CFA_remember_state: 8273 return "DW_CFA_remember_state"; 8274 case DW_CFA_restore_state: 8275 return "DW_CFA_restore_state"; 8276 case DW_CFA_def_cfa: 8277 return "DW_CFA_def_cfa"; 8278 case DW_CFA_def_cfa_register: 8279 return "DW_CFA_def_cfa_register"; 8280 case DW_CFA_def_cfa_offset: 8281 return "DW_CFA_def_cfa_offset"; 8282 8283 /* DWARF 3 */ 8284 case DW_CFA_def_cfa_expression: 8285 return "DW_CFA_def_cfa_expression"; 8286 case DW_CFA_expression: 8287 return "DW_CFA_expression"; 8288 case DW_CFA_offset_extended_sf: 8289 return "DW_CFA_offset_extended_sf"; 8290 case DW_CFA_def_cfa_sf: 8291 return "DW_CFA_def_cfa_sf"; 8292 case DW_CFA_def_cfa_offset_sf: 8293 return "DW_CFA_def_cfa_offset_sf"; 8294 8295 /* SGI/MIPS specific */ 8296 case DW_CFA_MIPS_advance_loc8: 8297 return "DW_CFA_MIPS_advance_loc8"; 8298 8299 /* GNU extensions */ 8300 case DW_CFA_GNU_window_save: 8301 return "DW_CFA_GNU_window_save"; 8302 case DW_CFA_GNU_args_size: 8303 return "DW_CFA_GNU_args_size"; 8304 case DW_CFA_GNU_negative_offset_extended: 8305 return "DW_CFA_GNU_negative_offset_extended"; 8306 8307 default: 8308 return "DW_CFA_<unknown>"; 8309 } 8310} 8311#endif 8312 8313static void 8314dump_die (struct die_info *die) 8315{ 8316 unsigned int i; 8317 8318 fprintf_unfiltered (gdb_stderr, "Die: %s (abbrev = %d, offset = %d)\n", 8319 dwarf_tag_name (die->tag), die->abbrev, die->offset); 8320 fprintf_unfiltered (gdb_stderr, "\thas children: %s\n", 8321 dwarf_bool_name (die->child != NULL)); 8322 8323 fprintf_unfiltered (gdb_stderr, "\tattributes:\n"); 8324 for (i = 0; i < die->num_attrs; ++i) 8325 { 8326 fprintf_unfiltered (gdb_stderr, "\t\t%s (%s) ", 8327 dwarf_attr_name (die->attrs[i].name), 8328 dwarf_form_name (die->attrs[i].form)); 8329 switch (die->attrs[i].form) 8330 { 8331 case DW_FORM_ref_addr: 8332 case DW_FORM_addr: 8333 fprintf_unfiltered (gdb_stderr, "address: "); 8334 print_address_numeric (DW_ADDR (&die->attrs[i]), 1, gdb_stderr); 8335 break; 8336 case DW_FORM_block2: 8337 case DW_FORM_block4: 8338 case DW_FORM_block: 8339 case DW_FORM_block1: 8340 fprintf_unfiltered (gdb_stderr, "block: size %d", DW_BLOCK (&die->attrs[i])->size); 8341 break; 8342 case DW_FORM_ref1: 8343 case DW_FORM_ref2: 8344 case DW_FORM_ref4: 8345 fprintf_unfiltered (gdb_stderr, "constant ref: %ld (adjusted)", 8346 (long) (DW_ADDR (&die->attrs[i]))); 8347 break; 8348 case DW_FORM_data1: 8349 case DW_FORM_data2: 8350 case DW_FORM_data4: 8351 case DW_FORM_data8: 8352 case DW_FORM_udata: 8353 case DW_FORM_sdata: 8354 fprintf_unfiltered (gdb_stderr, "constant: %ld", DW_UNSND (&die->attrs[i])); 8355 break; 8356 case DW_FORM_string: 8357 case DW_FORM_strp: 8358 fprintf_unfiltered (gdb_stderr, "string: \"%s\"", 8359 DW_STRING (&die->attrs[i]) 8360 ? DW_STRING (&die->attrs[i]) : ""); 8361 break; 8362 case DW_FORM_flag: 8363 if (DW_UNSND (&die->attrs[i])) 8364 fprintf_unfiltered (gdb_stderr, "flag: TRUE"); 8365 else 8366 fprintf_unfiltered (gdb_stderr, "flag: FALSE"); 8367 break; 8368 case DW_FORM_indirect: 8369 /* the reader will have reduced the indirect form to 8370 the "base form" so this form should not occur */ 8371 fprintf_unfiltered (gdb_stderr, "unexpected attribute form: DW_FORM_indirect"); 8372 break; 8373 default: 8374 fprintf_unfiltered (gdb_stderr, "unsupported attribute form: %d.", 8375 die->attrs[i].form); 8376 } 8377 fprintf_unfiltered (gdb_stderr, "\n"); 8378 } 8379} 8380 8381static void 8382dump_die_list (struct die_info *die) 8383{ 8384 while (die) 8385 { 8386 dump_die (die); 8387 if (die->child != NULL) 8388 dump_die_list (die->child); 8389 if (die->sibling != NULL) 8390 dump_die_list (die->sibling); 8391 } 8392} 8393 8394static void 8395store_in_ref_table (unsigned int offset, struct die_info *die, 8396 struct dwarf2_cu *cu) 8397{ 8398 int h; 8399 struct die_info *old; 8400 8401 h = (offset % REF_HASH_SIZE); 8402 old = cu->die_ref_table[h]; 8403 die->next_ref = old; 8404 cu->die_ref_table[h] = die; 8405} 8406 8407static unsigned int 8408dwarf2_get_ref_die_offset (struct attribute *attr, struct dwarf2_cu *cu) 8409{ 8410 unsigned int result = 0; 8411 8412 switch (attr->form) 8413 { 8414 case DW_FORM_ref_addr: 8415 case DW_FORM_ref1: 8416 case DW_FORM_ref2: 8417 case DW_FORM_ref4: 8418 case DW_FORM_ref8: 8419 case DW_FORM_ref_udata: 8420 result = DW_ADDR (attr); 8421 break; 8422 default: 8423 complaint (&symfile_complaints, 8424 "unsupported die ref attribute form: '%s'", 8425 dwarf_form_name (attr->form)); 8426 } 8427 return result; 8428} 8429 8430/* Return the constant value held by the given attribute. Return -1 8431 if the value held by the attribute is not constant. */ 8432 8433static int 8434dwarf2_get_attr_constant_value (struct attribute *attr, int default_value) 8435{ 8436 if (attr->form == DW_FORM_sdata) 8437 return DW_SND (attr); 8438 else if (attr->form == DW_FORM_udata 8439 || attr->form == DW_FORM_data1 8440 || attr->form == DW_FORM_data2 8441 || attr->form == DW_FORM_data4 8442 || attr->form == DW_FORM_data8) 8443 return DW_UNSND (attr); 8444 else 8445 { 8446 complaint (&symfile_complaints, "Attribute value is not a constant (%s)", 8447 dwarf_form_name (attr->form)); 8448 return default_value; 8449 } 8450} 8451 8452static struct die_info * 8453follow_die_ref (struct die_info *src_die, struct attribute *attr, 8454 struct dwarf2_cu *cu) 8455{ 8456 struct die_info *die; 8457 unsigned int offset; 8458 int h; 8459 struct die_info temp_die; 8460 struct dwarf2_cu *target_cu; 8461 8462 offset = dwarf2_get_ref_die_offset (attr, cu); 8463 8464 if (DW_ADDR (attr) < cu->header.offset 8465 || DW_ADDR (attr) >= cu->header.offset + cu->header.length) 8466 { 8467 struct dwarf2_per_cu_data *per_cu; 8468 per_cu = dwarf2_find_containing_comp_unit (DW_ADDR (attr), 8469 cu->objfile); 8470 target_cu = per_cu->cu; 8471 } 8472 else 8473 target_cu = cu; 8474 8475 h = (offset % REF_HASH_SIZE); 8476 die = target_cu->die_ref_table[h]; 8477 while (die) 8478 { 8479 if (die->offset == offset) 8480 return die; 8481 die = die->next_ref; 8482 } 8483 8484 error ("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE " 8485 "at 0x%lx [in module %s]", 8486 (long) src_die->offset, (long) offset, cu->objfile->name); 8487 8488 return NULL; 8489} 8490 8491static struct type * 8492dwarf2_fundamental_type (struct objfile *objfile, int typeid, 8493 struct dwarf2_cu *cu) 8494{ 8495 if (typeid < 0 || typeid >= FT_NUM_MEMBERS) 8496 { 8497 error ("Dwarf Error: internal error - invalid fundamental type id %d [in module %s]", 8498 typeid, objfile->name); 8499 } 8500 8501 /* Look for this particular type in the fundamental type vector. If 8502 one is not found, create and install one appropriate for the 8503 current language and the current target machine. */ 8504 8505 if (cu->ftypes[typeid] == NULL) 8506 { 8507 cu->ftypes[typeid] = cu->language_defn->la_fund_type (objfile, typeid); 8508 } 8509 8510 return (cu->ftypes[typeid]); 8511} 8512 8513/* Decode simple location descriptions. 8514 Given a pointer to a dwarf block that defines a location, compute 8515 the location and return the value. 8516 8517 NOTE drow/2003-11-18: This function is called in two situations 8518 now: for the address of static or global variables (partial symbols 8519 only) and for offsets into structures which are expected to be 8520 (more or less) constant. The partial symbol case should go away, 8521 and only the constant case should remain. That will let this 8522 function complain more accurately. A few special modes are allowed 8523 without complaint for global variables (for instance, global 8524 register values and thread-local values). 8525 8526 A location description containing no operations indicates that the 8527 object is optimized out. The return value is 0 for that case. 8528 FIXME drow/2003-11-16: No callers check for this case any more; soon all 8529 callers will only want a very basic result and this can become a 8530 complaint. 8531 8532 When the result is a register number, the global isreg flag is set, 8533 otherwise it is cleared. 8534 8535 Note that stack[0] is unused except as a default error return. 8536 Note that stack overflow is not yet handled. */ 8537 8538static CORE_ADDR 8539decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu) 8540{ 8541 struct objfile *objfile = cu->objfile; 8542 struct comp_unit_head *cu_header = &cu->header; 8543 int i; 8544 int size = blk->size; 8545 char *data = blk->data; 8546 CORE_ADDR stack[64]; 8547 int stacki; 8548 unsigned int bytes_read, unsnd; 8549 unsigned char op; 8550 8551 i = 0; 8552 stacki = 0; 8553 stack[stacki] = 0; 8554 isreg = 0; 8555 8556 while (i < size) 8557 { 8558 op = data[i++]; 8559 switch (op) 8560 { 8561 case DW_OP_lit0: 8562 case DW_OP_lit1: 8563 case DW_OP_lit2: 8564 case DW_OP_lit3: 8565 case DW_OP_lit4: 8566 case DW_OP_lit5: 8567 case DW_OP_lit6: 8568 case DW_OP_lit7: 8569 case DW_OP_lit8: 8570 case DW_OP_lit9: 8571 case DW_OP_lit10: 8572 case DW_OP_lit11: 8573 case DW_OP_lit12: 8574 case DW_OP_lit13: 8575 case DW_OP_lit14: 8576 case DW_OP_lit15: 8577 case DW_OP_lit16: 8578 case DW_OP_lit17: 8579 case DW_OP_lit18: 8580 case DW_OP_lit19: 8581 case DW_OP_lit20: 8582 case DW_OP_lit21: 8583 case DW_OP_lit22: 8584 case DW_OP_lit23: 8585 case DW_OP_lit24: 8586 case DW_OP_lit25: 8587 case DW_OP_lit26: 8588 case DW_OP_lit27: 8589 case DW_OP_lit28: 8590 case DW_OP_lit29: 8591 case DW_OP_lit30: 8592 case DW_OP_lit31: 8593 stack[++stacki] = op - DW_OP_lit0; 8594 break; 8595 8596 case DW_OP_reg0: 8597 case DW_OP_reg1: 8598 case DW_OP_reg2: 8599 case DW_OP_reg3: 8600 case DW_OP_reg4: 8601 case DW_OP_reg5: 8602 case DW_OP_reg6: 8603 case DW_OP_reg7: 8604 case DW_OP_reg8: 8605 case DW_OP_reg9: 8606 case DW_OP_reg10: 8607 case DW_OP_reg11: 8608 case DW_OP_reg12: 8609 case DW_OP_reg13: 8610 case DW_OP_reg14: 8611 case DW_OP_reg15: 8612 case DW_OP_reg16: 8613 case DW_OP_reg17: 8614 case DW_OP_reg18: 8615 case DW_OP_reg19: 8616 case DW_OP_reg20: 8617 case DW_OP_reg21: 8618 case DW_OP_reg22: 8619 case DW_OP_reg23: 8620 case DW_OP_reg24: 8621 case DW_OP_reg25: 8622 case DW_OP_reg26: 8623 case DW_OP_reg27: 8624 case DW_OP_reg28: 8625 case DW_OP_reg29: 8626 case DW_OP_reg30: 8627 case DW_OP_reg31: 8628 isreg = 1; 8629 stack[++stacki] = op - DW_OP_reg0; 8630 if (i < size) 8631 dwarf2_complex_location_expr_complaint (); 8632 break; 8633 8634 case DW_OP_regx: 8635 isreg = 1; 8636 unsnd = read_unsigned_leb128 (NULL, (data + i), &bytes_read); 8637 i += bytes_read; 8638 stack[++stacki] = unsnd; 8639 if (i < size) 8640 dwarf2_complex_location_expr_complaint (); 8641 break; 8642 8643 case DW_OP_addr: 8644 stack[++stacki] = read_address (objfile->obfd, &data[i], 8645 cu, &bytes_read); 8646 i += bytes_read; 8647 break; 8648 8649 case DW_OP_const1u: 8650 stack[++stacki] = read_1_byte (objfile->obfd, &data[i]); 8651 i += 1; 8652 break; 8653 8654 case DW_OP_const1s: 8655 stack[++stacki] = read_1_signed_byte (objfile->obfd, &data[i]); 8656 i += 1; 8657 break; 8658 8659 case DW_OP_const2u: 8660 stack[++stacki] = read_2_bytes (objfile->obfd, &data[i]); 8661 i += 2; 8662 break; 8663 8664 case DW_OP_const2s: 8665 stack[++stacki] = read_2_signed_bytes (objfile->obfd, &data[i]); 8666 i += 2; 8667 break; 8668 8669 case DW_OP_const4u: 8670 stack[++stacki] = read_4_bytes (objfile->obfd, &data[i]); 8671 i += 4; 8672 break; 8673 8674 case DW_OP_const4s: 8675 stack[++stacki] = read_4_signed_bytes (objfile->obfd, &data[i]); 8676 i += 4; 8677 break; 8678 8679 case DW_OP_constu: 8680 stack[++stacki] = read_unsigned_leb128 (NULL, (data + i), 8681 &bytes_read); 8682 i += bytes_read; 8683 break; 8684 8685 case DW_OP_consts: 8686 stack[++stacki] = read_signed_leb128 (NULL, (data + i), &bytes_read); 8687 i += bytes_read; 8688 break; 8689 8690 case DW_OP_dup: 8691 stack[stacki + 1] = stack[stacki]; 8692 stacki++; 8693 break; 8694 8695 case DW_OP_plus: 8696 stack[stacki - 1] += stack[stacki]; 8697 stacki--; 8698 break; 8699 8700 case DW_OP_plus_uconst: 8701 stack[stacki] += read_unsigned_leb128 (NULL, (data + i), &bytes_read); 8702 i += bytes_read; 8703 break; 8704 8705 case DW_OP_minus: 8706 stack[stacki - 1] -= stack[stacki]; 8707 stacki--; 8708 break; 8709 8710 case DW_OP_deref: 8711 /* If we're not the last op, then we definitely can't encode 8712 this using GDB's address_class enum. This is valid for partial 8713 global symbols, although the variable's address will be bogus 8714 in the psymtab. */ 8715 if (i < size) 8716 dwarf2_complex_location_expr_complaint (); 8717 break; 8718 8719 case DW_OP_GNU_push_tls_address: 8720 /* The top of the stack has the offset from the beginning 8721 of the thread control block at which the variable is located. */ 8722 /* Nothing should follow this operator, so the top of stack would 8723 be returned. */ 8724 /* This is valid for partial global symbols, but the variable's 8725 address will be bogus in the psymtab. */ 8726 if (i < size) 8727 dwarf2_complex_location_expr_complaint (); 8728 break; 8729 8730 default: 8731 complaint (&symfile_complaints, "unsupported stack op: '%s'", 8732 dwarf_stack_op_name (op)); 8733 return (stack[stacki]); 8734 } 8735 } 8736 return (stack[stacki]); 8737} 8738 8739/* memory allocation interface */ 8740 8741static struct dwarf_block * 8742dwarf_alloc_block (struct dwarf2_cu *cu) 8743{ 8744 struct dwarf_block *blk; 8745 8746 blk = (struct dwarf_block *) 8747 obstack_alloc (&cu->comp_unit_obstack, sizeof (struct dwarf_block)); 8748 return (blk); 8749} 8750 8751static struct abbrev_info * 8752dwarf_alloc_abbrev (struct dwarf2_cu *cu) 8753{ 8754 struct abbrev_info *abbrev; 8755 8756 abbrev = (struct abbrev_info *) 8757 obstack_alloc (&cu->abbrev_obstack, sizeof (struct abbrev_info)); 8758 memset (abbrev, 0, sizeof (struct abbrev_info)); 8759 return (abbrev); 8760} 8761 8762static struct die_info * 8763dwarf_alloc_die (void) 8764{ 8765 struct die_info *die; 8766 8767 die = (struct die_info *) xmalloc (sizeof (struct die_info)); 8768 memset (die, 0, sizeof (struct die_info)); 8769 return (die); 8770} 8771 8772 8773/* Macro support. */ 8774 8775 8776/* Return the full name of file number I in *LH's file name table. 8777 Use COMP_DIR as the name of the current directory of the 8778 compilation. The result is allocated using xmalloc; the caller is 8779 responsible for freeing it. */ 8780static char * 8781file_full_name (int file, struct line_header *lh, const char *comp_dir) 8782{ 8783 struct file_entry *fe = &lh->file_names[file - 1]; 8784 8785 if (IS_ABSOLUTE_PATH (fe->name)) 8786 return xstrdup (fe->name); 8787 else 8788 { 8789 const char *dir; 8790 int dir_len; 8791 char *full_name; 8792 8793 if (fe->dir_index) 8794 dir = lh->include_dirs[fe->dir_index - 1]; 8795 else 8796 dir = comp_dir; 8797 8798 if (dir) 8799 { 8800 dir_len = strlen (dir); 8801 full_name = xmalloc (dir_len + 1 + strlen (fe->name) + 1); 8802 strcpy (full_name, dir); 8803 full_name[dir_len] = '/'; 8804 strcpy (full_name + dir_len + 1, fe->name); 8805 return full_name; 8806 } 8807 else 8808 return xstrdup (fe->name); 8809 } 8810} 8811 8812 8813static struct macro_source_file * 8814macro_start_file (int file, int line, 8815 struct macro_source_file *current_file, 8816 const char *comp_dir, 8817 struct line_header *lh, struct objfile *objfile) 8818{ 8819 /* The full name of this source file. */ 8820 char *full_name = file_full_name (file, lh, comp_dir); 8821 8822 /* We don't create a macro table for this compilation unit 8823 at all until we actually get a filename. */ 8824 if (! pending_macros) 8825 pending_macros = new_macro_table (&objfile->objfile_obstack, 8826 objfile->macro_cache); 8827 8828 if (! current_file) 8829 /* If we have no current file, then this must be the start_file 8830 directive for the compilation unit's main source file. */ 8831 current_file = macro_set_main (pending_macros, full_name); 8832 else 8833 current_file = macro_include (current_file, line, full_name); 8834 8835 xfree (full_name); 8836 8837 return current_file; 8838} 8839 8840 8841/* Copy the LEN characters at BUF to a xmalloc'ed block of memory, 8842 followed by a null byte. */ 8843static char * 8844copy_string (const char *buf, int len) 8845{ 8846 char *s = xmalloc (len + 1); 8847 memcpy (s, buf, len); 8848 s[len] = '\0'; 8849 8850 return s; 8851} 8852 8853 8854static const char * 8855consume_improper_spaces (const char *p, const char *body) 8856{ 8857 if (*p == ' ') 8858 { 8859 complaint (&symfile_complaints, 8860 "macro definition contains spaces in formal argument list:\n`%s'", 8861 body); 8862 8863 while (*p == ' ') 8864 p++; 8865 } 8866 8867 return p; 8868} 8869 8870 8871static void 8872parse_macro_definition (struct macro_source_file *file, int line, 8873 const char *body) 8874{ 8875 const char *p; 8876 8877 /* The body string takes one of two forms. For object-like macro 8878 definitions, it should be: 8879 8880 <macro name> " " <definition> 8881 8882 For function-like macro definitions, it should be: 8883 8884 <macro name> "() " <definition> 8885 or 8886 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition> 8887 8888 Spaces may appear only where explicitly indicated, and in the 8889 <definition>. 8890 8891 The Dwarf 2 spec says that an object-like macro's name is always 8892 followed by a space, but versions of GCC around March 2002 omit 8893 the space when the macro's definition is the empty string. 8894 8895 The Dwarf 2 spec says that there should be no spaces between the 8896 formal arguments in a function-like macro's formal argument list, 8897 but versions of GCC around March 2002 include spaces after the 8898 commas. */ 8899 8900 8901 /* Find the extent of the macro name. The macro name is terminated 8902 by either a space or null character (for an object-like macro) or 8903 an opening paren (for a function-like macro). */ 8904 for (p = body; *p; p++) 8905 if (*p == ' ' || *p == '(') 8906 break; 8907 8908 if (*p == ' ' || *p == '\0') 8909 { 8910 /* It's an object-like macro. */ 8911 int name_len = p - body; 8912 char *name = copy_string (body, name_len); 8913 const char *replacement; 8914 8915 if (*p == ' ') 8916 replacement = body + name_len + 1; 8917 else 8918 { 8919 dwarf2_macro_malformed_definition_complaint (body); 8920 replacement = body + name_len; 8921 } 8922 8923 macro_define_object (file, line, name, replacement); 8924 8925 xfree (name); 8926 } 8927 else if (*p == '(') 8928 { 8929 /* It's a function-like macro. */ 8930 char *name = copy_string (body, p - body); 8931 int argc = 0; 8932 int argv_size = 1; 8933 char **argv = xmalloc (argv_size * sizeof (*argv)); 8934 8935 p++; 8936 8937 p = consume_improper_spaces (p, body); 8938 8939 /* Parse the formal argument list. */ 8940 while (*p && *p != ')') 8941 { 8942 /* Find the extent of the current argument name. */ 8943 const char *arg_start = p; 8944 8945 while (*p && *p != ',' && *p != ')' && *p != ' ') 8946 p++; 8947 8948 if (! *p || p == arg_start) 8949 dwarf2_macro_malformed_definition_complaint (body); 8950 else 8951 { 8952 /* Make sure argv has room for the new argument. */ 8953 if (argc >= argv_size) 8954 { 8955 argv_size *= 2; 8956 argv = xrealloc (argv, argv_size * sizeof (*argv)); 8957 } 8958 8959 argv[argc++] = copy_string (arg_start, p - arg_start); 8960 } 8961 8962 p = consume_improper_spaces (p, body); 8963 8964 /* Consume the comma, if present. */ 8965 if (*p == ',') 8966 { 8967 p++; 8968 8969 p = consume_improper_spaces (p, body); 8970 } 8971 } 8972 8973 if (*p == ')') 8974 { 8975 p++; 8976 8977 if (*p == ' ') 8978 /* Perfectly formed definition, no complaints. */ 8979 macro_define_function (file, line, name, 8980 argc, (const char **) argv, 8981 p + 1); 8982 else if (*p == '\0') 8983 { 8984 /* Complain, but do define it. */ 8985 dwarf2_macro_malformed_definition_complaint (body); 8986 macro_define_function (file, line, name, 8987 argc, (const char **) argv, 8988 p); 8989 } 8990 else 8991 /* Just complain. */ 8992 dwarf2_macro_malformed_definition_complaint (body); 8993 } 8994 else 8995 /* Just complain. */ 8996 dwarf2_macro_malformed_definition_complaint (body); 8997 8998 xfree (name); 8999 { 9000 int i; 9001 9002 for (i = 0; i < argc; i++) 9003 xfree (argv[i]); 9004 } 9005 xfree (argv); 9006 } 9007 else 9008 dwarf2_macro_malformed_definition_complaint (body); 9009} 9010 9011 9012static void 9013dwarf_decode_macros (struct line_header *lh, unsigned int offset, 9014 char *comp_dir, bfd *abfd, 9015 struct dwarf2_cu *cu) 9016{ 9017 char *mac_ptr, *mac_end; 9018 struct macro_source_file *current_file = 0; 9019 9020 if (dwarf2_per_objfile->macinfo_buffer == NULL) 9021 { 9022 complaint (&symfile_complaints, "missing .debug_macinfo section"); 9023 return; 9024 } 9025 9026 mac_ptr = dwarf2_per_objfile->macinfo_buffer + offset; 9027 mac_end = dwarf2_per_objfile->macinfo_buffer 9028 + dwarf2_per_objfile->macinfo_size; 9029 9030 for (;;) 9031 { 9032 enum dwarf_macinfo_record_type macinfo_type; 9033 9034 /* Do we at least have room for a macinfo type byte? */ 9035 if (mac_ptr >= mac_end) 9036 { 9037 dwarf2_macros_too_long_complaint (); 9038 return; 9039 } 9040 9041 macinfo_type = read_1_byte (abfd, mac_ptr); 9042 mac_ptr++; 9043 9044 switch (macinfo_type) 9045 { 9046 /* A zero macinfo type indicates the end of the macro 9047 information. */ 9048 case 0: 9049 return; 9050 9051 case DW_MACINFO_define: 9052 case DW_MACINFO_undef: 9053 { 9054 int bytes_read; 9055 int line; 9056 char *body; 9057 9058 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); 9059 mac_ptr += bytes_read; 9060 body = read_string (abfd, mac_ptr, &bytes_read); 9061 mac_ptr += bytes_read; 9062 9063 if (! current_file) 9064 complaint (&symfile_complaints, 9065 "debug info gives macro %s outside of any file: %s", 9066 macinfo_type == 9067 DW_MACINFO_define ? "definition" : macinfo_type == 9068 DW_MACINFO_undef ? "undefinition" : 9069 "something-or-other", body); 9070 else 9071 { 9072 if (macinfo_type == DW_MACINFO_define) 9073 parse_macro_definition (current_file, line, body); 9074 else if (macinfo_type == DW_MACINFO_undef) 9075 macro_undef (current_file, line, body); 9076 } 9077 } 9078 break; 9079 9080 case DW_MACINFO_start_file: 9081 { 9082 int bytes_read; 9083 int line, file; 9084 9085 line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); 9086 mac_ptr += bytes_read; 9087 file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); 9088 mac_ptr += bytes_read; 9089 9090 current_file = macro_start_file (file, line, 9091 current_file, comp_dir, 9092 lh, cu->objfile); 9093 } 9094 break; 9095 9096 case DW_MACINFO_end_file: 9097 if (! current_file) 9098 complaint (&symfile_complaints, 9099 "macro debug info has an unmatched `close_file' directive"); 9100 else 9101 { 9102 current_file = current_file->included_by; 9103 if (! current_file) 9104 { 9105 enum dwarf_macinfo_record_type next_type; 9106 9107 /* GCC circa March 2002 doesn't produce the zero 9108 type byte marking the end of the compilation 9109 unit. Complain if it's not there, but exit no 9110 matter what. */ 9111 9112 /* Do we at least have room for a macinfo type byte? */ 9113 if (mac_ptr >= mac_end) 9114 { 9115 dwarf2_macros_too_long_complaint (); 9116 return; 9117 } 9118 9119 /* We don't increment mac_ptr here, so this is just 9120 a look-ahead. */ 9121 next_type = read_1_byte (abfd, mac_ptr); 9122 if (next_type != 0) 9123 complaint (&symfile_complaints, 9124 "no terminating 0-type entry for macros in `.debug_macinfo' section"); 9125 9126 return; 9127 } 9128 } 9129 break; 9130 9131 case DW_MACINFO_vendor_ext: 9132 { 9133 int bytes_read; 9134 int constant; 9135 char *string; 9136 9137 constant = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); 9138 mac_ptr += bytes_read; 9139 string = read_string (abfd, mac_ptr, &bytes_read); 9140 mac_ptr += bytes_read; 9141 9142 /* We don't recognize any vendor extensions. */ 9143 } 9144 break; 9145 } 9146 } 9147} 9148 9149/* Check if the attribute's form is a DW_FORM_block* 9150 if so return true else false. */ 9151static int 9152attr_form_is_block (struct attribute *attr) 9153{ 9154 return (attr == NULL ? 0 : 9155 attr->form == DW_FORM_block1 9156 || attr->form == DW_FORM_block2 9157 || attr->form == DW_FORM_block4 9158 || attr->form == DW_FORM_block); 9159} 9160 9161static void 9162dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym, 9163 struct dwarf2_cu *cu) 9164{ 9165 if (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8) 9166 { 9167 struct dwarf2_loclist_baton *baton; 9168 9169 baton = obstack_alloc (&cu->objfile->objfile_obstack, 9170 sizeof (struct dwarf2_loclist_baton)); 9171 baton->objfile = cu->objfile; 9172 9173 /* We don't know how long the location list is, but make sure we 9174 don't run off the edge of the section. */ 9175 baton->size = dwarf2_per_objfile->loc_size - DW_UNSND (attr); 9176 baton->data = dwarf2_per_objfile->loc_buffer + DW_UNSND (attr); 9177 baton->base_address = cu->header.base_address; 9178 if (cu->header.base_known == 0) 9179 complaint (&symfile_complaints, 9180 "Location list used without specifying the CU base address."); 9181 9182 SYMBOL_OPS (sym) = &dwarf2_loclist_funcs; 9183 SYMBOL_LOCATION_BATON (sym) = baton; 9184 } 9185 else 9186 { 9187 struct dwarf2_locexpr_baton *baton; 9188 9189 baton = obstack_alloc (&cu->objfile->objfile_obstack, 9190 sizeof (struct dwarf2_locexpr_baton)); 9191 baton->objfile = cu->objfile; 9192 9193 if (attr_form_is_block (attr)) 9194 { 9195 /* Note that we're just copying the block's data pointer 9196 here, not the actual data. We're still pointing into the 9197 info_buffer for SYM's objfile; right now we never release 9198 that buffer, but when we do clean up properly this may 9199 need to change. */ 9200 baton->size = DW_BLOCK (attr)->size; 9201 baton->data = DW_BLOCK (attr)->data; 9202 } 9203 else 9204 { 9205 dwarf2_invalid_attrib_class_complaint ("location description", 9206 SYMBOL_NATURAL_NAME (sym)); 9207 baton->size = 0; 9208 baton->data = NULL; 9209 } 9210 9211 SYMBOL_OPS (sym) = &dwarf2_locexpr_funcs; 9212 SYMBOL_LOCATION_BATON (sym) = baton; 9213 } 9214} 9215 9216/* Locate the compilation unit from CU's objfile which contains the 9217 DIE at OFFSET. Raises an error on failure. */ 9218 9219static struct dwarf2_per_cu_data * 9220dwarf2_find_containing_comp_unit (unsigned long offset, 9221 struct objfile *objfile) 9222{ 9223 struct dwarf2_per_cu_data *this_cu; 9224 int low, high; 9225 9226 low = 0; 9227 high = dwarf2_per_objfile->n_comp_units - 1; 9228 while (high > low) 9229 { 9230 int mid = low + (high - low) / 2; 9231 if (dwarf2_per_objfile->all_comp_units[mid]->offset >= offset) 9232 high = mid; 9233 else 9234 low = mid + 1; 9235 } 9236 gdb_assert (low == high); 9237 if (dwarf2_per_objfile->all_comp_units[low]->offset > offset) 9238 { 9239 if (low == 0) 9240 error ("Dwarf Error: could not find partial DIE containing " 9241 "offset 0x%lx [in module %s]", 9242 (long) offset, bfd_get_filename (objfile->obfd)); 9243 9244 gdb_assert (dwarf2_per_objfile->all_comp_units[low-1]->offset <= offset); 9245 return dwarf2_per_objfile->all_comp_units[low-1]; 9246 } 9247 else 9248 { 9249 this_cu = dwarf2_per_objfile->all_comp_units[low]; 9250 if (low == dwarf2_per_objfile->n_comp_units - 1 9251 && offset >= this_cu->offset + this_cu->length) 9252 error ("invalid dwarf2 offset %ld", offset); 9253 gdb_assert (offset < this_cu->offset + this_cu->length); 9254 return this_cu; 9255 } 9256} 9257 9258/* Locate the compilation unit from OBJFILE which is located at exactly 9259 OFFSET. Raises an error on failure. */ 9260 9261static struct dwarf2_per_cu_data * 9262dwarf2_find_comp_unit (unsigned long offset, struct objfile *objfile) 9263{ 9264 struct dwarf2_per_cu_data *this_cu; 9265 this_cu = dwarf2_find_containing_comp_unit (offset, objfile); 9266 if (this_cu->offset != offset) 9267 error ("no compilation unit with offset %ld\n", offset); 9268 return this_cu; 9269} 9270 9271/* Release one cached compilation unit, CU. We unlink it from the tree 9272 of compilation units, but we don't remove it from the read_in_chain; 9273 the caller is responsible for that. */ 9274 9275static void 9276free_one_comp_unit (void *data) 9277{ 9278 struct dwarf2_cu *cu = data; 9279 9280 if (cu->per_cu != NULL) 9281 cu->per_cu->cu = NULL; 9282 cu->per_cu = NULL; 9283 9284 obstack_free (&cu->comp_unit_obstack, NULL); 9285 if (cu->dies) 9286 free_die_list (cu->dies); 9287 9288 xfree (cu); 9289} 9290 9291/* This cleanup function is passed the address of a dwarf2_cu on the stack 9292 when we're finished with it. We can't free the pointer itself, but be 9293 sure to unlink it from the cache. Also release any associated storage 9294 and perform cache maintenance. 9295 9296 Only used during partial symbol parsing. */ 9297 9298static void 9299free_stack_comp_unit (void *data) 9300{ 9301 struct dwarf2_cu *cu = data; 9302 9303 obstack_free (&cu->comp_unit_obstack, NULL); 9304 cu->partial_dies = NULL; 9305 9306 if (cu->per_cu != NULL) 9307 { 9308 /* This compilation unit is on the stack in our caller, so we 9309 should not xfree it. Just unlink it. */ 9310 cu->per_cu->cu = NULL; 9311 cu->per_cu = NULL; 9312 9313 /* If we had a per-cu pointer, then we may have other compilation 9314 units loaded, so age them now. */ 9315 age_cached_comp_units (); 9316 } 9317} 9318 9319/* Free all cached compilation units. */ 9320 9321static void 9322free_cached_comp_units (void *data) 9323{ 9324 struct dwarf2_per_cu_data *per_cu, **last_chain; 9325 9326 per_cu = dwarf2_per_objfile->read_in_chain; 9327 last_chain = &dwarf2_per_objfile->read_in_chain; 9328 while (per_cu != NULL) 9329 { 9330 struct dwarf2_per_cu_data *next_cu; 9331 9332 next_cu = per_cu->cu->read_in_chain; 9333 9334 free_one_comp_unit (per_cu->cu); 9335 *last_chain = next_cu; 9336 9337 per_cu = next_cu; 9338 } 9339} 9340 9341/* Increase the age counter on each cached compilation unit, and free 9342 any that are too old. */ 9343 9344static void 9345age_cached_comp_units (void) 9346{ 9347 struct dwarf2_per_cu_data *per_cu, **last_chain; 9348 9349 dwarf2_clear_marks (dwarf2_per_objfile->read_in_chain); 9350 per_cu = dwarf2_per_objfile->read_in_chain; 9351 while (per_cu != NULL) 9352 { 9353 per_cu->cu->last_used ++; 9354 if (per_cu->cu->last_used <= dwarf2_max_cache_age) 9355 dwarf2_mark (per_cu->cu); 9356 per_cu = per_cu->cu->read_in_chain; 9357 } 9358 9359 per_cu = dwarf2_per_objfile->read_in_chain; 9360 last_chain = &dwarf2_per_objfile->read_in_chain; 9361 while (per_cu != NULL) 9362 { 9363 struct dwarf2_per_cu_data *next_cu; 9364 9365 next_cu = per_cu->cu->read_in_chain; 9366 9367 if (!per_cu->cu->mark) 9368 { 9369 free_one_comp_unit (per_cu->cu); 9370 *last_chain = next_cu; 9371 } 9372 else 9373 last_chain = &per_cu->cu->read_in_chain; 9374 9375 per_cu = next_cu; 9376 } 9377} 9378 9379/* Remove a single compilation unit from the cache. */ 9380 9381static void 9382free_one_cached_comp_unit (void *target_cu) 9383{ 9384 struct dwarf2_per_cu_data *per_cu, **last_chain; 9385 9386 per_cu = dwarf2_per_objfile->read_in_chain; 9387 last_chain = &dwarf2_per_objfile->read_in_chain; 9388 while (per_cu != NULL) 9389 { 9390 struct dwarf2_per_cu_data *next_cu; 9391 9392 next_cu = per_cu->cu->read_in_chain; 9393 9394 if (per_cu->cu == target_cu) 9395 { 9396 free_one_comp_unit (per_cu->cu); 9397 *last_chain = next_cu; 9398 break; 9399 } 9400 else 9401 last_chain = &per_cu->cu->read_in_chain; 9402 9403 per_cu = next_cu; 9404 } 9405} 9406 9407/* A pair of DIE offset and GDB type pointer. We store these 9408 in a hash table separate from the DIEs, and preserve them 9409 when the DIEs are flushed out of cache. */ 9410 9411struct dwarf2_offset_and_type 9412{ 9413 unsigned int offset; 9414 struct type *type; 9415}; 9416 9417/* Hash function for a dwarf2_offset_and_type. */ 9418 9419static hashval_t 9420offset_and_type_hash (const void *item) 9421{ 9422 const struct dwarf2_offset_and_type *ofs = item; 9423 return ofs->offset; 9424} 9425 9426/* Equality function for a dwarf2_offset_and_type. */ 9427 9428static int 9429offset_and_type_eq (const void *item_lhs, const void *item_rhs) 9430{ 9431 const struct dwarf2_offset_and_type *ofs_lhs = item_lhs; 9432 const struct dwarf2_offset_and_type *ofs_rhs = item_rhs; 9433 return ofs_lhs->offset == ofs_rhs->offset; 9434} 9435 9436/* Set the type associated with DIE to TYPE. Save it in CU's hash 9437 table if necessary. */ 9438 9439static void 9440set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu) 9441{ 9442 struct dwarf2_offset_and_type **slot, ofs; 9443 9444 die->type = type; 9445 9446 if (cu->per_cu == NULL) 9447 return; 9448 9449 if (cu->per_cu->type_hash == NULL) 9450 cu->per_cu->type_hash 9451 = htab_create_alloc_ex (cu->header.length / 24, 9452 offset_and_type_hash, 9453 offset_and_type_eq, 9454 NULL, 9455 &cu->objfile->objfile_obstack, 9456 hashtab_obstack_allocate, 9457 dummy_obstack_deallocate); 9458 9459 ofs.offset = die->offset; 9460 ofs.type = type; 9461 slot = (struct dwarf2_offset_and_type **) 9462 htab_find_slot_with_hash (cu->per_cu->type_hash, &ofs, ofs.offset, INSERT); 9463 *slot = obstack_alloc (&cu->objfile->objfile_obstack, sizeof (**slot)); 9464 **slot = ofs; 9465} 9466 9467/* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not 9468 have a saved type. */ 9469 9470static struct type * 9471get_die_type (struct die_info *die, htab_t type_hash) 9472{ 9473 struct dwarf2_offset_and_type *slot, ofs; 9474 9475 ofs.offset = die->offset; 9476 slot = htab_find_with_hash (type_hash, &ofs, ofs.offset); 9477 if (slot) 9478 return slot->type; 9479 else 9480 return NULL; 9481} 9482 9483/* Restore the types of the DIE tree starting at START_DIE from the hash 9484 table saved in CU. */ 9485 9486static void 9487reset_die_and_siblings_types (struct die_info *start_die, struct dwarf2_cu *cu) 9488{ 9489 struct die_info *die; 9490 9491 if (cu->per_cu->type_hash == NULL) 9492 return; 9493 9494 for (die = start_die; die != NULL; die = die->sibling) 9495 { 9496 die->type = get_die_type (die, cu->per_cu->type_hash); 9497 if (die->child != NULL) 9498 reset_die_and_siblings_types (die->child, cu); 9499 } 9500} 9501 9502/* Set the mark field in CU and in every other compilation unit in the 9503 cache that we must keep because we are keeping CU. */ 9504 9505/* Add a dependence relationship from CU to REF_PER_CU. */ 9506 9507static void 9508dwarf2_add_dependence (struct dwarf2_cu *cu, 9509 struct dwarf2_per_cu_data *ref_per_cu) 9510{ 9511 void **slot; 9512 9513 if (cu->dependencies == NULL) 9514 cu->dependencies 9515 = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer, 9516 NULL, &cu->comp_unit_obstack, 9517 hashtab_obstack_allocate, 9518 dummy_obstack_deallocate); 9519 9520 slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT); 9521 if (*slot == NULL) 9522 *slot = ref_per_cu; 9523} 9524 9525/* Set the mark field in CU and in every other compilation unit in the 9526 cache that we must keep because we are keeping CU. */ 9527 9528static int 9529dwarf2_mark_helper (void **slot, void *data) 9530{ 9531 struct dwarf2_per_cu_data *per_cu; 9532 9533 per_cu = (struct dwarf2_per_cu_data *) *slot; 9534 if (per_cu->cu->mark) 9535 return 1; 9536 per_cu->cu->mark = 1; 9537 9538 if (per_cu->cu->dependencies != NULL) 9539 htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL); 9540 9541 return 1; 9542} 9543 9544static void 9545dwarf2_mark (struct dwarf2_cu *cu) 9546{ 9547 if (cu->mark) 9548 return; 9549 cu->mark = 1; 9550 if (cu->dependencies != NULL) 9551 htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL); 9552} 9553 9554static void 9555dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu) 9556{ 9557 while (per_cu) 9558 { 9559 per_cu->cu->mark = 0; 9560 per_cu = per_cu->cu->read_in_chain; 9561 } 9562} 9563 9564/* Allocation function for the libiberty hash table which uses an 9565 obstack. */ 9566 9567static void * 9568hashtab_obstack_allocate (void *data, size_t size, size_t count) 9569{ 9570 unsigned int total = size * count; 9571 void *ptr = obstack_alloc ((struct obstack *) data, total); 9572 memset (ptr, 0, total); 9573 return ptr; 9574} 9575 9576/* Trivial deallocation function for the libiberty splay tree and hash 9577 table - don't deallocate anything. Rely on later deletion of the 9578 obstack. */ 9579 9580static void 9581dummy_obstack_deallocate (void *object, void *data) 9582{ 9583 return; 9584} 9585 9586/* Trivial hash function for partial_die_info: the hash value of a DIE 9587 is its offset in .debug_info for this objfile. */ 9588 9589static hashval_t 9590partial_die_hash (const void *item) 9591{ 9592 const struct partial_die_info *part_die = item; 9593 return part_die->offset; 9594} 9595 9596/* Trivial comparison function for partial_die_info structures: two DIEs 9597 are equal if they have the same offset. */ 9598 9599static int 9600partial_die_eq (const void *item_lhs, const void *item_rhs) 9601{ 9602 const struct partial_die_info *part_die_lhs = item_lhs; 9603 const struct partial_die_info *part_die_rhs = item_rhs; 9604 return part_die_lhs->offset == part_die_rhs->offset; 9605} 9606 9607static struct cmd_list_element *set_dwarf2_cmdlist; 9608static struct cmd_list_element *show_dwarf2_cmdlist; 9609 9610static void 9611set_dwarf2_cmd (char *args, int from_tty) 9612{ 9613 help_list (set_dwarf2_cmdlist, "maintenance set dwarf2 ", -1, gdb_stdout); 9614} 9615 9616static void 9617show_dwarf2_cmd (char *args, int from_tty) 9618{ 9619 cmd_show_list (show_dwarf2_cmdlist, from_tty, ""); 9620} 9621 9622void _initialize_dwarf2_read (void); 9623 9624void 9625_initialize_dwarf2_read (void) 9626{ 9627 dwarf2_objfile_data_key = register_objfile_data (); 9628 9629 add_prefix_cmd ("dwarf2", class_maintenance, set_dwarf2_cmd, 9630 "Set DWARF 2 specific variables.\n" 9631 "Configure DWARF 2 variables such as the cache size", 9632 &set_dwarf2_cmdlist, "maintenance set dwarf2 ", 9633 0/*allow-unknown*/, &maintenance_set_cmdlist); 9634 9635 add_prefix_cmd ("dwarf2", class_maintenance, show_dwarf2_cmd, 9636 "Show DWARF 2 specific variables\n" 9637 "Show DWARF 2 variables such as the cache size", 9638 &show_dwarf2_cmdlist, "maintenance show dwarf2 ", 9639 0/*allow-unknown*/, &maintenance_show_cmdlist); 9640 9641 add_setshow_zinteger_cmd ("max-cache-age", class_obscure, 9642 &dwarf2_max_cache_age, 9643 "Set the upper bound on the age of cached " 9644 "dwarf2 compilation units.", 9645 "Show the upper bound on the age of cached " 9646 "dwarf2 compilation units.", 9647 "A higher limit means that cached " 9648 "compilation units will be stored\n" 9649 "in memory longer, and more total memory will " 9650 "be used. Zero disables\n" 9651 "caching, which can slow down startup.", 9652 "The upper bound on the age of cached " 9653 "dwarf2 compilation units is %d.", 9654 NULL, NULL, &set_dwarf2_cmdlist, 9655 &show_dwarf2_cmdlist); 9656} 9657