gdb/dwarf2read.h

   1 /* DWARF 2 debugging format support for GDB.
   2
   3    Copyright (C) 1994-2020 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef DWARF2READ_H
  21 #define DWARF2READ_H
  22
  23 #include <unordered_map>
  24 #include "dwarf-index-cache.h"
  25 #include "filename-seen-cache.h"
  26 #include "gdb_obstack.h"
  27 #include "gdbsupport/hash_enum.h"
  28
  29 /* Hold 'maintenance (set|show) dwarf' commands.  */
  30 extern struct cmd_list_element *set_dwarf_cmdlist;
  31 extern struct cmd_list_element *show_dwarf_cmdlist;
  32
  33 extern bool dwarf_always_disassemble;
  34
  35 /* A descriptor for dwarf sections.
  36
  37    S.ASECTION, SIZE are typically initialized when the objfile is first
  38    scanned.  BUFFER, READIN are filled in later when the section is read.
  39    If the section contained compressed data then SIZE is updated to record
  40    the uncompressed size of the section.
  41
  42    DWP file format V2 introduces a wrinkle that is easiest to handle by
  43    creating the concept of virtual sections contained within a real section.
  44    In DWP V2 the sections of the input DWO files are concatenated together
  45    into one section, but section offsets are kept relative to the original
  46    input section.
  47    If this is a virtual dwp-v2 section, S.CONTAINING_SECTION is a backlink to
  48    the real section this "virtual" section is contained in, and BUFFER,SIZE
  49    describe the virtual section.  */
  50
  51 struct dwarf2_section_info
  52 {
  53   union
  54   {
  55     /* If this is a real section, the bfd section.  */
  56     asection *section;
  57     /* If this is a virtual section, pointer to the containing ("real")
  58        section.  */
  59     struct dwarf2_section_info *containing_section;
  60   } s;
  61   /* Pointer to section data, only valid if readin.  */
  62   const gdb_byte *buffer;
  63   /* The size of the section, real or virtual.  */
  64   bfd_size_type size;
  65   /* If this is a virtual section, the offset in the real section.
  66      Only valid if is_virtual.  */
  67   bfd_size_type virtual_offset;
  68   /* True if we have tried to read this section.  */
  69   bool readin;
  70   /* True if this is a virtual section, False otherwise.
  71      This specifies which of s.section and s.containing_section to use.  */
  72   bool is_virtual;
  73 };
  74
  75 /* Read the contents of the section INFO.
  76    OBJFILE is the main object file, but not necessarily the file where
  77    the section comes from.  E.g., for DWO files the bfd of INFO is the bfd
  78    of the DWO file.
  79    If the section is compressed, uncompress it before returning.  */
  80
  81 void dwarf2_read_section (struct objfile *objfile, dwarf2_section_info *info);
  82
  83 struct tu_stats
  84 {
  85   int nr_uniq_abbrev_tables;
  86   int nr_symtabs;
  87   int nr_symtab_sharers;
  88   int nr_stmt_less_type_units;
  89   int nr_all_type_units_reallocs;
  90 };
  91
  92 struct dwarf2_debug_sections;
  93 struct mapped_index;
  94 struct mapped_debug_names;
  95 struct signatured_type;
  96 struct die_info;
  97 typedef struct die_info *die_info_ptr;
  98
  99 /* Collection of data recorded per objfile.
 100    This hangs off of dwarf2_objfile_data_key.  */
 101
 102 struct dwarf2_per_objfile
 103 {
 104   /* Construct a dwarf2_per_objfile for OBJFILE.  NAMES points to the
 105      dwarf2 section names, or is NULL if the standard ELF names are
 106      used.  CAN_COPY is true for formats where symbol
 107      interposition is possible and so symbol values must follow copy
 108      relocation rules.  */
 109   dwarf2_per_objfile (struct objfile *objfile,
 110                       const dwarf2_debug_sections *names,
 111                       bool can_copy);
 112
 113   ~dwarf2_per_objfile ();
 114
 115   DISABLE_COPY_AND_ASSIGN (dwarf2_per_objfile);
 116
 117   /* Return the CU/TU given its index.
 118
 119      This is intended for loops like:
 120
 121      for (i = 0; i < (dwarf2_per_objfile->n_comp_units
 122                       + dwarf2_per_objfile->n_type_units); ++i)
 123        {
 124          dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
 125
 126          ...;
 127        }
 128   */
 129   dwarf2_per_cu_data *get_cutu (int index);
 130
 131   /* Return the CU given its index.
 132      This differs from get_cutu in that it's for when you know INDEX refers to a
 133      CU.  */
 134   dwarf2_per_cu_data *get_cu (int index);
 135
 136   /* Return the TU given its index.
 137      This differs from get_cutu in that it's for when you know INDEX refers to a
 138      TU.  */
 139   signatured_type *get_tu (int index);
 140
 141   /* Free all cached compilation units.  */
 142   void free_cached_comp_units ();
 143 private:
 144   /* This function is mapped across the sections and remembers the
 145      offset and size of each of the debugging sections we are
 146      interested in.  */
 147   void locate_sections (bfd *abfd, asection *sectp,
 148                         const dwarf2_debug_sections &names);
 149
 150 public:
 151   dwarf2_section_info info {};
 152   dwarf2_section_info abbrev {};
 153   dwarf2_section_info line {};
 154   dwarf2_section_info loc {};
 155   dwarf2_section_info loclists {};
 156   dwarf2_section_info macinfo {};
 157   dwarf2_section_info macro {};
 158   dwarf2_section_info str {};
 159   dwarf2_section_info line_str {};
 160   dwarf2_section_info ranges {};
 161   dwarf2_section_info rnglists {};
 162   dwarf2_section_info addr {};
 163   dwarf2_section_info frame {};
 164   dwarf2_section_info eh_frame {};
 165   dwarf2_section_info gdb_index {};
 166   dwarf2_section_info debug_names {};
 167   dwarf2_section_info debug_aranges {};
 168
 169   std::vector<dwarf2_section_info> types;
 170
 171   /* Back link.  */
 172   struct objfile *objfile = NULL;
 173
 174   /* Table of all the compilation units.  This is used to locate
 175      the target compilation unit of a particular reference.  */
 176   std::vector<dwarf2_per_cu_data *> all_comp_units;
 177
 178   /* The .debug_types-related CUs (TUs).  */
 179   std::vector<signatured_type *> all_type_units;
 180
 181   /* Table of struct type_unit_group objects.
 182      The hash key is the DW_AT_stmt_list value.  */
 183   htab_t type_unit_groups {};
 184
 185   /* A table mapping .debug_types signatures to its signatured_type entry.
 186      This is NULL if the .debug_types section hasn't been read in yet.  */
 187   htab_t signatured_types {};
 188
 189   /* Type unit statistics, to see how well the scaling improvements
 190      are doing.  */
 191   struct tu_stats tu_stats {};
 192
 193   /* A chain of compilation units that are currently read in, so that
 194      they can be freed later.  */
 195   dwarf2_per_cu_data *read_in_chain = NULL;
 196
 197   /* A table mapping DW_AT_dwo_name values to struct dwo_file objects.
 198      This is NULL if the table hasn't been allocated yet.  */
 199   htab_up dwo_files;
 200
 201   /* True if we've checked for whether there is a DWP file.  */
 202   bool dwp_checked = false;
 203
 204   /* The DWP file if there is one, or NULL.  */
 205   std::unique_ptr<struct dwp_file> dwp_file;
 206
 207   /* The shared '.dwz' file, if one exists.  This is used when the
 208      original data was compressed using 'dwz -m'.  */
 209   std::unique_ptr<struct dwz_file> dwz_file;
 210
 211   /* Whether copy relocations are supported by this object format.  */
 212   bool can_copy;
 213
 214   /* A flag indicating whether this objfile has a section loaded at a
 215      VMA of 0.  */
 216   bool has_section_at_zero = false;
 217
 218   /* True if we are using the mapped index,
 219      or we are faking it for OBJF_READNOW's sake.  */
 220   bool using_index = false;
 221
 222   /* The mapped index, or NULL if .gdb_index is missing or not being used.  */
 223   std::unique_ptr<mapped_index> index_table;
 224
 225   /* The mapped index, or NULL if .debug_names is missing or not being used.  */
 226   std::unique_ptr<mapped_debug_names> debug_names_table;
 227
 228   /* When using index_table, this keeps track of all quick_file_names entries.
 229      TUs typically share line table entries with a CU, so we maintain a
 230      separate table of all line table entries to support the sharing.
 231      Note that while there can be way more TUs than CUs, we've already
 232      sorted all the TUs into "type unit groups", grouped by their
 233      DW_AT_stmt_list value.  Therefore the only sharing done here is with a
 234      CU and its associated TU group if there is one.  */
 235   htab_t quick_file_names_table {};
 236
 237   /* Set during partial symbol reading, to prevent queueing of full
 238      symbols.  */
 239   bool reading_partial_symbols = false;
 240
 241   /* Table mapping type DIEs to their struct type *.
 242      This is NULL if not allocated yet.
 243      The mapping is done via (CU/TU + DIE offset) -> type.  */
 244   htab_t die_type_hash {};
 245
 246   /* The CUs we recently read.  */
 247   std::vector<dwarf2_per_cu_data *> just_read_cus;
 248
 249   /* Table containing line_header indexed by offset and offset_in_dwz.  */
 250   htab_t line_header_hash {};
 251
 252   /* Table containing all filenames.  This is an optional because the
 253      table is lazily constructed on first access.  */
 254   gdb::optional<filename_seen_cache> filenames_cache;
 255
 256   /* If we loaded the index from an external file, this contains the
 257      resources associated to the open file, memory mapping, etc.  */
 258   std::unique_ptr<index_cache_resource> index_cache_res;
 259
 260   /* Mapping from abstract origin DIE to concrete DIEs that reference it as
 261      DW_AT_abstract_origin.  */
 262   std::unordered_map<sect_offset, std::vector<sect_offset>,
 263                      gdb::hash_enum<sect_offset>>
 264     abstract_to_concrete;
 265 };
 266
 267 /* Get the dwarf2_per_objfile associated to OBJFILE.  */
 268
 269 dwarf2_per_objfile *get_dwarf2_per_objfile (struct objfile *objfile);
 270
 271 /* Persistent data held for a compilation unit, even when not
 272    processing it.  We put a pointer to this structure in the
 273    read_symtab_private field of the psymtab.  */
 274
 275 struct dwarf2_per_cu_data
 276 {
 277   /* The start offset and length of this compilation unit.
 278      NOTE: Unlike comp_unit_head.length, this length includes
 279      initial_length_size.
 280      If the DIE refers to a DWO file, this is always of the original die,
 281      not the DWO file.  */
 282   sect_offset sect_off;
 283   unsigned int length;
 284
 285   /* DWARF standard version this data has been read from (such as 4 or 5).  */
 286   short dwarf_version;
 287
 288   /* Flag indicating this compilation unit will be read in before
 289      any of the current compilation units are processed.  */
 290   unsigned int queued : 1;
 291
 292   /* This flag will be set when reading partial DIEs if we need to load
 293      absolutely all DIEs for this compilation unit, instead of just the ones
 294      we think are interesting.  It gets set if we look for a DIE in the
 295      hash table and don't find it.  */
 296   unsigned int load_all_dies : 1;
 297
 298   /* Non-zero if this CU is from .debug_types.
 299      Struct dwarf2_per_cu_data is contained in struct signatured_type iff
 300      this is non-zero.  */
 301   unsigned int is_debug_types : 1;
 302
 303   /* Non-zero if this CU is from the .dwz file.  */
 304   unsigned int is_dwz : 1;
 305
 306   /* Non-zero if reading a TU directly from a DWO file, bypassing the stub.
 307      This flag is only valid if is_debug_types is true.
 308      We can't read a CU directly from a DWO file: There are required
 309      attributes in the stub.  */
 310   unsigned int reading_dwo_directly : 1;
 311
 312   /* Non-zero if the TU has been read.
 313      This is used to assist the "Stay in DWO Optimization" for Fission:
 314      When reading a DWO, it's faster to read TUs from the DWO instead of
 315      fetching them from random other DWOs (due to comdat folding).
 316      If the TU has already been read, the optimization is unnecessary
 317      (and unwise - we don't want to change where gdb thinks the TU lives
 318      "midflight").
 319      This flag is only valid if is_debug_types is true.  */
 320   unsigned int tu_read : 1;
 321
 322   /* The section this CU/TU lives in.
 323      If the DIE refers to a DWO file, this is always the original die,
 324      not the DWO file.  */
 325   struct dwarf2_section_info *section;
 326
 327   /* Set to non-NULL iff this CU is currently loaded.  When it gets freed out
 328      of the CU cache it gets reset to NULL again.  This is left as NULL for
 329      dummy CUs (a CU header, but nothing else).  */
 330   struct dwarf2_cu *cu;
 331
 332   /* The corresponding dwarf2_per_objfile.  */
 333   struct dwarf2_per_objfile *dwarf2_per_objfile;
 334
 335   /* When dwarf2_per_objfile->using_index is true, the 'quick' field
 336      is active.  Otherwise, the 'psymtab' field is active.  */
 337   union
 338   {
 339     /* The partial symbol table associated with this compilation unit,
 340        or NULL for unread partial units.  */
 341     struct partial_symtab *psymtab;
 342
 343     /* Data needed by the "quick" functions.  */
 344     struct dwarf2_per_cu_quick_data *quick;
 345   } v;
 346
 347   /* Return true of IMPORTED_SYMTABS is empty or not yet allocated.  */
 348   bool imported_symtabs_empty () const
 349   {
 350     return (imported_symtabs == nullptr || imported_symtabs->empty ());
 351   }
 352
 353   /* Push P to the back of IMPORTED_SYMTABS, allocated IMPORTED_SYMTABS
 354      first if required.  */
 355   void imported_symtabs_push (dwarf2_per_cu_data *p)
 356   {
 357     if (imported_symtabs == nullptr)
 358       imported_symtabs = new std::vector <dwarf2_per_cu_data *>;
 359     imported_symtabs->push_back (p);
 360   }
 361
 362   /* Return the size of IMPORTED_SYMTABS if it is allocated, otherwise
 363      return 0.  */
 364   size_t imported_symtabs_size () const
 365   {
 366     if (imported_symtabs == nullptr)
 367       return 0;
 368     return imported_symtabs->size ();
 369   }
 370
 371   /* Delete IMPORTED_SYMTABS and set the pointer back to nullptr.  */
 372   void imported_symtabs_free ()
 373   {
 374     delete imported_symtabs;
 375     imported_symtabs = nullptr;
 376   }
 377
 378   /* The CUs we import using DW_TAG_imported_unit.  This is filled in
 379      while reading psymtabs, used to compute the psymtab dependencies,
 380      and then cleared.  Then it is filled in again while reading full
 381      symbols, and only deleted when the objfile is destroyed.
 382
 383      This is also used to work around a difference between the way gold
 384      generates .gdb_index version <=7 and the way gdb does.  Arguably this
 385      is a gold bug.  For symbols coming from TUs, gold records in the index
 386      the CU that includes the TU instead of the TU itself.  This breaks
 387      dw2_lookup_symbol: It assumes that if the index says symbol X lives
 388      in CU/TU Y, then one need only expand Y and a subsequent lookup in Y
 389      will find X.  Alas TUs live in their own symtab, so after expanding CU Y
 390      we need to look in TU Z to find X.  Fortunately, this is akin to
 391      DW_TAG_imported_unit, so we just use the same mechanism: For
 392      .gdb_index version <=7 this also records the TUs that the CU referred
 393      to.  Concurrently with this change gdb was modified to emit version 8
 394      indices so we only pay a price for gold generated indices.
 395      http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
 396
 397      This currently needs to be a public member due to how
 398      dwarf2_per_cu_data is allocated and used.  Ideally in future things
 399      could be refactored to make this private.  Until then please try to
 400      avoid direct access to this member, and instead use the helper
 401      functions above.  */
 402   std::vector <dwarf2_per_cu_data *> *imported_symtabs;
 403 };
 404
 405 /* Entry in the signatured_types hash table.  */
 406
 407 struct signatured_type
 408 {
 409   /* The "per_cu" object of this type.
 410      This struct is used iff per_cu.is_debug_types.
 411      N.B.: This is the first member so that it's easy to convert pointers
 412      between them.  */
 413   struct dwarf2_per_cu_data per_cu;
 414
 415   /* The type's signature.  */
 416   ULONGEST signature;
 417
 418   /* Offset in the TU of the type's DIE, as read from the TU header.
 419      If this TU is a DWO stub and the definition lives in a DWO file
 420      (specified by DW_AT_GNU_dwo_name), this value is unusable.  */
 421   cu_offset type_offset_in_tu;
 422
 423   /* Offset in the section of the type's DIE.
 424      If the definition lives in a DWO file, this is the offset in the
 425      .debug_types.dwo section.
 426      The value is zero until the actual value is known.
 427      Zero is otherwise not a valid section offset.  */
 428   sect_offset type_offset_in_section;
 429
 430   /* Type units are grouped by their DW_AT_stmt_list entry so that they
 431      can share them.  This points to the containing symtab.  */
 432   struct type_unit_group *type_unit_group;
 433
 434   /* The type.
 435      The first time we encounter this type we fully read it in and install it
 436      in the symbol tables.  Subsequent times we only need the type.  */
 437   struct type *type;
 438
 439   /* Containing DWO unit.
 440      This field is valid iff per_cu.reading_dwo_directly.  */
 441   struct dwo_unit *dwo_unit;
 442 };
 443
 444 ULONGEST read_unsigned_leb128 (bfd *, const gdb_byte *, unsigned int *);
 445
 446 /* This represents a '.dwz' file.  */
 447
 448 struct dwz_file
 449 {
 450   dwz_file (gdb_bfd_ref_ptr &&bfd)
 451     : dwz_bfd (std::move (bfd))
 452   {
 453   }
 454
 455   const char *filename () const
 456   {
 457     return bfd_get_filename (this->dwz_bfd.get ());
 458   }
 459
 460   /* A dwz file can only contain a few sections.  */
 461   struct dwarf2_section_info abbrev {};
 462   struct dwarf2_section_info info {};
 463   struct dwarf2_section_info str {};
 464   struct dwarf2_section_info line {};
 465   struct dwarf2_section_info macro {};
 466   struct dwarf2_section_info gdb_index {};
 467   struct dwarf2_section_info debug_names {};
 468
 469   /* The dwz's BFD.  */
 470   gdb_bfd_ref_ptr dwz_bfd;
 471
 472   /* If we loaded the index from an external file, this contains the
 473      resources associated to the open file, memory mapping, etc.  */
 474   std::unique_ptr<index_cache_resource> index_cache_res;
 475 };
 476
 477 /* Open the separate '.dwz' debug file, if needed.  Return NULL if
 478    there is no .gnu_debugaltlink section in the file.  Error if there
 479    is such a section but the file cannot be found.  */
 480
 481 extern struct dwz_file *dwarf2_get_dwz_file
 482     (struct dwarf2_per_objfile *dwarf2_per_objfile);
 483
 484 #endif /* DWARF2READ_H */