gdb/dwarf2/read.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 <queue>
  24 #include <unordered_map>
  25 #include "dwarf2/index-cache.h"
  26 #include "dwarf2/section.h"
  27 #include "filename-seen-cache.h"
  28 #include "gdb_obstack.h"
  29 #include "gdbsupport/hash_enum.h"
  30 #include "psympriv.h"
  31
  32 /* Hold 'maintenance (set|show) dwarf' commands.  */
  33 extern struct cmd_list_element *set_dwarf_cmdlist;
  34 extern struct cmd_list_element *show_dwarf_cmdlist;
  35
  36 struct tu_stats
  37 {
  38   int nr_uniq_abbrev_tables;
  39   int nr_symtabs;
  40   int nr_symtab_sharers;
  41   int nr_stmt_less_type_units;
  42   int nr_all_type_units_reallocs;
  43 };
  44
  45 struct dwarf2_debug_sections;
  46 struct dwarf2_per_cu_data;
  47 struct mapped_index;
  48 struct mapped_debug_names;
  49 struct signatured_type;
  50
  51 /* One item on the queue of compilation units to read in full symbols
  52    for.  */
  53 struct dwarf2_queue_item
  54 {
  55   dwarf2_queue_item (dwarf2_per_cu_data *cu, enum language lang)
  56     : per_cu (cu),
  57       pretend_language (lang)
  58   {
  59   }
  60
  61   ~dwarf2_queue_item ();
  62
  63   DISABLE_COPY_AND_ASSIGN (dwarf2_queue_item);
  64
  65   struct dwarf2_per_cu_data *per_cu;
  66   enum language pretend_language;
  67 };
  68
  69 /* Some DWARF data can be shared across objfiles who share the same BFD,
  70    this data is stored in this object.
  71
  72    Two dwarf2_per_objfile objects representing objfiles sharing the same BFD
  73    will point to the same instance of dwarf2_per_bfd, unless the BFD requires
  74    relocation.  */
  75
  76 struct dwarf2_per_bfd
  77 {
  78   /* Construct a dwarf2_per_bfd for OBFD.  NAMES points to the
  79      dwarf2 section names, or is NULL if the standard ELF names are
  80      used.  CAN_COPY is true for formats where symbol
  81      interposition is possible and so symbol values must follow copy
  82      relocation rules.  */
  83   dwarf2_per_bfd (bfd *obfd, const dwarf2_debug_sections *names, bool can_copy);
  84
  85   ~dwarf2_per_bfd ();
  86
  87   DISABLE_COPY_AND_ASSIGN (dwarf2_per_bfd);
  88
  89   /* Return the CU/TU given its index.
  90
  91      This is intended for loops like:
  92
  93      for (i = 0; i < (dwarf2_per_bfd->n_comp_units
  94                       + dwarf2_per_bfd->n_type_units); ++i)
  95        {
  96          dwarf2_per_cu_data *per_cu = dwarf2_per_bfd->get_cutu (i);
  97
  98          ...;
  99        }
 100   */
 101   dwarf2_per_cu_data *get_cutu (int index);
 102
 103   /* Return the CU given its index.
 104      This differs from get_cutu in that it's for when you know INDEX refers to a
 105      CU.  */
 106   dwarf2_per_cu_data *get_cu (int index);
 107
 108   /* Return the TU given its index.
 109      This differs from get_cutu in that it's for when you know INDEX refers to a
 110      TU.  */
 111   signatured_type *get_tu (int index);
 112
 113   /* Free all cached compilation units.  */
 114   void free_cached_comp_units ();
 115
 116   /* A convenience function to allocate a dwarf2_per_cu_data.  The
 117      returned object has its "index" field set properly.  The object
 118      is allocated on the dwarf2_per_bfd obstack.  */
 119   dwarf2_per_cu_data *allocate_per_cu ();
 120
 121   /* A convenience function to allocate a signatured_type.  The
 122      returned object has its "index" field set properly.  The object
 123      is allocated on the dwarf2_per_bfd obstack.  */
 124   signatured_type *allocate_signatured_type ();
 125
 126   /* Return the number of partial symtabs allocated with allocate_per_cu
 127      and allocate_signatured_type so far.  */
 128   int num_psymtabs () const
 129   { return m_num_psymtabs; }
 130
 131 private:
 132   /* This function is mapped across the sections and remembers the
 133      offset and size of each of the debugging sections we are
 134      interested in.  */
 135   void locate_sections (bfd *abfd, asection *sectp,
 136                         const dwarf2_debug_sections &names);
 137
 138 public:
 139   /* Objects that can be shared across objfiles are stored in this
 140      obstack or on the psymtab obstack, while objects that are
 141      objfile-specific are stored on the objfile obstack.  */
 142   auto_obstack obstack;
 143
 144   dwarf2_section_info info {};
 145   dwarf2_section_info abbrev {};
 146   dwarf2_section_info line {};
 147   dwarf2_section_info loc {};
 148   dwarf2_section_info loclists {};
 149   dwarf2_section_info macinfo {};
 150   dwarf2_section_info macro {};
 151   dwarf2_section_info str {};
 152   dwarf2_section_info str_offsets {};
 153   dwarf2_section_info line_str {};
 154   dwarf2_section_info ranges {};
 155   dwarf2_section_info rnglists {};
 156   dwarf2_section_info addr {};
 157   dwarf2_section_info frame {};
 158   dwarf2_section_info eh_frame {};
 159   dwarf2_section_info gdb_index {};
 160   dwarf2_section_info debug_names {};
 161   dwarf2_section_info debug_aranges {};
 162
 163   std::vector<dwarf2_section_info> types;
 164
 165   /* Table of all the compilation units.  This is used to locate
 166      the target compilation unit of a particular reference.  */
 167   std::vector<dwarf2_per_cu_data *> all_comp_units;
 168
 169   /* The .debug_types-related CUs (TUs).  */
 170   std::vector<signatured_type *> all_type_units;
 171
 172   /* Table of struct type_unit_group objects.
 173      The hash key is the DW_AT_stmt_list value.  */
 174   htab_up type_unit_groups;
 175
 176   /* A table mapping .debug_types signatures to its signatured_type entry.
 177      This is NULL if the .debug_types section hasn't been read in yet.  */
 178   htab_up signatured_types;
 179
 180   /* Type unit statistics, to see how well the scaling improvements
 181      are doing.  */
 182   struct tu_stats tu_stats {};
 183
 184   /* A chain of compilation units that are currently read in, so that
 185      they can be freed later.  */
 186   dwarf2_per_cu_data *read_in_chain = NULL;
 187
 188   /* A table mapping DW_AT_dwo_name values to struct dwo_file objects.
 189      This is NULL if the table hasn't been allocated yet.  */
 190   htab_up dwo_files;
 191
 192   /* True if we've checked for whether there is a DWP file.  */
 193   bool dwp_checked = false;
 194
 195   /* The DWP file if there is one, or NULL.  */
 196   std::unique_ptr<struct dwp_file> dwp_file;
 197
 198   /* The shared '.dwz' file, if one exists.  This is used when the
 199      original data was compressed using 'dwz -m'.  */
 200   std::unique_ptr<struct dwz_file> dwz_file;
 201
 202   /* Whether copy relocations are supported by this object format.  */
 203   bool can_copy;
 204
 205   /* A flag indicating whether this objfile has a section loaded at a
 206      VMA of 0.  */
 207   bool has_section_at_zero = false;
 208
 209   /* True if we are using the mapped index,
 210      or we are faking it for OBJF_READNOW's sake.  */
 211   bool using_index = false;
 212
 213   /* The mapped index, or NULL if .gdb_index is missing or not being used.  */
 214   std::unique_ptr<mapped_index> index_table;
 215
 216   /* The mapped index, or NULL if .debug_names is missing or not being used.  */
 217   std::unique_ptr<mapped_debug_names> debug_names_table;
 218
 219   /* When using index_table, this keeps track of all quick_file_names entries.
 220      TUs typically share line table entries with a CU, so we maintain a
 221      separate table of all line table entries to support the sharing.
 222      Note that while there can be way more TUs than CUs, we've already
 223      sorted all the TUs into "type unit groups", grouped by their
 224      DW_AT_stmt_list value.  Therefore the only sharing done here is with a
 225      CU and its associated TU group if there is one.  */
 226   htab_up quick_file_names_table;
 227
 228   /* Set during partial symbol reading, to prevent queueing of full
 229      symbols.  */
 230   bool reading_partial_symbols = false;
 231
 232   /* The CUs we recently read.  */
 233   std::vector<dwarf2_per_cu_data *> just_read_cus;
 234
 235   /* Table containing line_header indexed by offset and offset_in_dwz.  */
 236   htab_up line_header_hash;
 237
 238   /* Table containing all filenames.  This is an optional because the
 239      table is lazily constructed on first access.  */
 240   gdb::optional<filename_seen_cache> filenames_cache;
 241
 242   /* If we loaded the index from an external file, this contains the
 243      resources associated to the open file, memory mapping, etc.  */
 244   std::unique_ptr<index_cache_resource> index_cache_res;
 245
 246   /* Mapping from abstract origin DIE to concrete DIEs that reference it as
 247      DW_AT_abstract_origin.  */
 248   std::unordered_map<sect_offset, std::vector<sect_offset>,
 249                      gdb::hash_enum<sect_offset>>
 250     abstract_to_concrete;
 251
 252   /* CUs that are queued to be read.  */
 253   std::queue<dwarf2_queue_item> queue;
 254
 255 private:
 256
 257   /* The total number of per_cu and signatured_type objects that have
 258      been created so far for this reader.  */
 259   size_t m_num_psymtabs = 0;
 260 };
 261
 262 /* Collection of data recorded per objfile.
 263    This hangs off of dwarf2_objfile_data_key.
 264
 265    Some DWARF data cannot (currently) be shared across objfiles.  Such
 266    data is stored in this object.  */
 267
 268 struct dwarf2_per_objfile
 269 {
 270   dwarf2_per_objfile (struct objfile *objfile, dwarf2_per_bfd *per_bfd)
 271     : objfile (objfile), per_bfd (per_bfd)
 272   {}
 273
 274   /* Return pointer to string at .debug_line_str offset as read from BUF.
 275      BUF is assumed to be in a compilation unit described by CU_HEADER.
 276      Return *BYTES_READ_PTR count of bytes read from BUF.  */
 277   const char *read_line_string (const gdb_byte *buf,
 278                                 const struct comp_unit_head *cu_header,
 279                                 unsigned int *bytes_read_ptr);
 280
 281   /* Resize the M_SYMTABS vector to the needed size (the number of partial
 282      symtabs allocated by the per-bfd).  */
 283   void resize_symtabs ()
 284   {
 285     /* The symtabs vector should only grow, not shrink.  */
 286     gdb_assert (per_bfd->num_psymtabs () >= m_symtabs.size ());
 287
 288     m_symtabs.resize (per_bfd->num_psymtabs ());
 289   }
 290
 291   /* Return true if the symtab corresponding to PER_CU has been set,
 292      false otherwise.  */
 293   bool symtab_set_p (const dwarf2_per_cu_data *per_cu) const;
 294
 295   /* Return the compunit_symtab associated to PER_CU, if it has been created.  */
 296   compunit_symtab *get_symtab (const dwarf2_per_cu_data *per_cu) const;
 297
 298   /* Set the compunit_symtab associated to PER_CU.  */
 299   void set_symtab (const dwarf2_per_cu_data *per_cu, compunit_symtab *symtab);
 300
 301   /* Back link.  */
 302   struct objfile *objfile;
 303
 304   /* Pointer to the data that is (possibly) shared between this objfile and
 305      other objfiles backed by the same BFD.  */
 306   struct dwarf2_per_bfd *per_bfd;
 307
 308   /* Table mapping type DIEs to their struct type *.
 309      This is nullptr if not allocated yet.
 310      The mapping is done via (CU/TU + DIE offset) -> type.  */
 311   htab_up die_type_hash;
 312
 313 private:
 314   /* Hold the corresponding compunit_symtab for each CU or TU.  This
 315      is indexed by dwarf2_per_cu_data::index.  A NULL value means
 316      that the CU/TU has not been expanded yet.  */
 317   std::vector<compunit_symtab *> m_symtabs;
 318 };
 319
 320 /* Get the dwarf2_per_objfile associated to OBJFILE.  */
 321
 322 dwarf2_per_objfile *get_dwarf2_per_objfile (struct objfile *objfile);
 323
 324 /* A partial symtab specialized for DWARF.  */
 325 struct dwarf2_psymtab : public partial_symtab
 326 {
 327   dwarf2_psymtab (const char *filename, struct objfile *objfile,
 328                   dwarf2_per_cu_data *per_cu)
 329     : partial_symtab (filename, objfile, 0),
 330       per_cu_data (per_cu)
 331   {
 332   }
 333
 334   void read_symtab (struct objfile *) override;
 335   void expand_psymtab (struct objfile *) override;
 336   bool readin_p (struct objfile *) const override;
 337   compunit_symtab *get_compunit_symtab (struct objfile *) const override;
 338
 339   struct dwarf2_per_cu_data *per_cu_data;
 340 };
 341
 342 /* Persistent data held for a compilation unit, even when not
 343    processing it.  We put a pointer to this structure in the
 344    psymtab.  */
 345
 346 struct dwarf2_per_cu_data
 347 {
 348   /* The start offset and length of this compilation unit.
 349      NOTE: Unlike comp_unit_head.length, this length includes
 350      initial_length_size.
 351      If the DIE refers to a DWO file, this is always of the original die,
 352      not the DWO file.  */
 353   sect_offset sect_off;
 354   unsigned int length;
 355
 356   /* DWARF standard version this data has been read from (such as 4 or 5).  */
 357   short dwarf_version;
 358
 359   /* Flag indicating this compilation unit will be read in before
 360      any of the current compilation units are processed.  */
 361   unsigned int queued : 1;
 362
 363   /* This flag will be set when reading partial DIEs if we need to load
 364      absolutely all DIEs for this compilation unit, instead of just the ones
 365      we think are interesting.  It gets set if we look for a DIE in the
 366      hash table and don't find it.  */
 367   unsigned int load_all_dies : 1;
 368
 369   /* Non-zero if this CU is from .debug_types.
 370      Struct dwarf2_per_cu_data is contained in struct signatured_type iff
 371      this is non-zero.  */
 372   unsigned int is_debug_types : 1;
 373
 374   /* Non-zero if this CU is from the .dwz file.  */
 375   unsigned int is_dwz : 1;
 376
 377   /* Non-zero if reading a TU directly from a DWO file, bypassing the stub.
 378      This flag is only valid if is_debug_types is true.
 379      We can't read a CU directly from a DWO file: There are required
 380      attributes in the stub.  */
 381   unsigned int reading_dwo_directly : 1;
 382
 383   /* Non-zero if the TU has been read.
 384      This is used to assist the "Stay in DWO Optimization" for Fission:
 385      When reading a DWO, it's faster to read TUs from the DWO instead of
 386      fetching them from random other DWOs (due to comdat folding).
 387      If the TU has already been read, the optimization is unnecessary
 388      (and unwise - we don't want to change where gdb thinks the TU lives
 389      "midflight").
 390      This flag is only valid if is_debug_types is true.  */
 391   unsigned int tu_read : 1;
 392
 393   /* Our index in the unshared "symtabs" vector.  */
 394   unsigned index;
 395
 396   /* The section this CU/TU lives in.
 397      If the DIE refers to a DWO file, this is always the original die,
 398      not the DWO file.  */
 399   struct dwarf2_section_info *section;
 400
 401   /* Set to non-NULL iff this CU is currently loaded.  When it gets freed out
 402      of the CU cache it gets reset to NULL again.  This is left as NULL for
 403      dummy CUs (a CU header, but nothing else).  */
 404   struct dwarf2_cu *cu;
 405
 406   /* The unit type of this CU.  */
 407   enum dwarf_unit_type unit_type;
 408
 409   /* The language of this CU.  */
 410   enum language lang;
 411
 412   /* The corresponding dwarf2_per_objfile.  */
 413   struct dwarf2_per_objfile *dwarf2_per_objfile;
 414
 415   /* Backlink to the owner of this.  */
 416   dwarf2_per_bfd *per_bfd;
 417
 418   /* When dwarf2_per_bfd::using_index is true, the 'quick' field
 419      is active.  Otherwise, the 'psymtab' field is active.  */
 420   union
 421   {
 422     /* The partial symbol table associated with this compilation unit,
 423        or NULL for unread partial units.  */
 424     dwarf2_psymtab *psymtab;
 425
 426     /* Data needed by the "quick" functions.  */
 427     struct dwarf2_per_cu_quick_data *quick;
 428   } v;
 429
 430   /* The CUs we import using DW_TAG_imported_unit.  This is filled in
 431      while reading psymtabs, used to compute the psymtab dependencies,
 432      and then cleared.  Then it is filled in again while reading full
 433      symbols, and only deleted when the objfile is destroyed.
 434
 435      This is also used to work around a difference between the way gold
 436      generates .gdb_index version <=7 and the way gdb does.  Arguably this
 437      is a gold bug.  For symbols coming from TUs, gold records in the index
 438      the CU that includes the TU instead of the TU itself.  This breaks
 439      dw2_lookup_symbol: It assumes that if the index says symbol X lives
 440      in CU/TU Y, then one need only expand Y and a subsequent lookup in Y
 441      will find X.  Alas TUs live in their own symtab, so after expanding CU Y
 442      we need to look in TU Z to find X.  Fortunately, this is akin to
 443      DW_TAG_imported_unit, so we just use the same mechanism: For
 444      .gdb_index version <=7 this also records the TUs that the CU referred
 445      to.  Concurrently with this change gdb was modified to emit version 8
 446      indices so we only pay a price for gold generated indices.
 447      http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
 448
 449      This currently needs to be a public member due to how
 450      dwarf2_per_cu_data is allocated and used.  Ideally in future things
 451      could be refactored to make this private.  Until then please try to
 452      avoid direct access to this member, and instead use the helper
 453      functions above.  */
 454   std::vector <dwarf2_per_cu_data *> *imported_symtabs;
 455
 456   /* Return true of IMPORTED_SYMTABS is empty or not yet allocated.  */
 457   bool imported_symtabs_empty () const
 458   {
 459     return (imported_symtabs == nullptr || imported_symtabs->empty ());
 460   }
 461
 462   /* Push P to the back of IMPORTED_SYMTABS, allocated IMPORTED_SYMTABS
 463      first if required.  */
 464   void imported_symtabs_push (dwarf2_per_cu_data *p)
 465   {
 466     if (imported_symtabs == nullptr)
 467       imported_symtabs = new std::vector <dwarf2_per_cu_data *>;
 468     imported_symtabs->push_back (p);
 469   }
 470
 471   /* Return the size of IMPORTED_SYMTABS if it is allocated, otherwise
 472      return 0.  */
 473   size_t imported_symtabs_size () const
 474   {
 475     if (imported_symtabs == nullptr)
 476       return 0;
 477     return imported_symtabs->size ();
 478   }
 479
 480   /* Delete IMPORTED_SYMTABS and set the pointer back to nullptr.  */
 481   void imported_symtabs_free ()
 482   {
 483     delete imported_symtabs;
 484     imported_symtabs = nullptr;
 485   }
 486
 487   /* Return the OBJFILE associated with this compilation unit.  If
 488      this compilation unit came from a separate debuginfo file, then
 489      the master objfile is returned.  */
 490   struct objfile *objfile () const;
 491
 492   /* Return the address size given in the compilation unit header for
 493      this CU.  */
 494   int addr_size () const;
 495
 496   /* Return the offset size given in the compilation unit header for
 497      this CU.  */
 498   int offset_size () const;
 499
 500   /* Return the DW_FORM_ref_addr size given in the compilation unit
 501      header for this CU.  */
 502   int ref_addr_size () const;
 503
 504   /* Return the text offset of the CU.  The returned offset comes from
 505      this CU's objfile.  If this objfile came from a separate
 506      debuginfo file, then the offset may be different from the
 507      corresponding offset in the parent objfile.  */
 508   CORE_ADDR text_offset () const;
 509
 510   /* Return a type that is a generic pointer type, the size of which
 511      matches the address size given in the compilation unit header for
 512      this CU.  */
 513   struct type *addr_type () const;
 514
 515   /* Find an integer type SIZE_IN_BYTES bytes in size and return it.
 516      UNSIGNED_P controls if the integer is unsigned or not.  */
 517   struct type *int_type (int size_in_bytes, bool unsigned_p) const;
 518
 519   /* Find an integer type the same size as the address size given in
 520      the compilation unit header for this CU.  UNSIGNED_P controls if
 521      the integer is unsigned or not.  */
 522   struct type *addr_sized_int_type (bool unsigned_p) const;
 523
 524   /* Return DWARF version number of this CU.  */
 525   short version () const
 526   {
 527     return dwarf_version;
 528   }
 529
 530   /* A type unit group has a per_cu object that is recognized by
 531      having no section.  */
 532   bool type_unit_group_p () const
 533   {
 534     return section == nullptr;
 535   }
 536 };
 537
 538 /* Entry in the signatured_types hash table.  */
 539
 540 struct signatured_type
 541 {
 542   /* The "per_cu" object of this type.
 543      This struct is used iff per_cu.is_debug_types.
 544      N.B.: This is the first member so that it's easy to convert pointers
 545      between them.  */
 546   struct dwarf2_per_cu_data per_cu;
 547
 548   /* The type's signature.  */
 549   ULONGEST signature;
 550
 551   /* Offset in the TU of the type's DIE, as read from the TU header.
 552      If this TU is a DWO stub and the definition lives in a DWO file
 553      (specified by DW_AT_GNU_dwo_name), this value is unusable.  */
 554   cu_offset type_offset_in_tu;
 555
 556   /* Offset in the section of the type's DIE.
 557      If the definition lives in a DWO file, this is the offset in the
 558      .debug_types.dwo section.
 559      The value is zero until the actual value is known.
 560      Zero is otherwise not a valid section offset.  */
 561   sect_offset type_offset_in_section;
 562
 563   /* Type units are grouped by their DW_AT_stmt_list entry so that they
 564      can share them.  This points to the containing symtab.  */
 565   struct type_unit_group *type_unit_group;
 566
 567   /* The type.
 568      The first time we encounter this type we fully read it in and install it
 569      in the symbol tables.  Subsequent times we only need the type.  */
 570   struct type *type;
 571
 572   /* Containing DWO unit.
 573      This field is valid iff per_cu.reading_dwo_directly.  */
 574   struct dwo_unit *dwo_unit;
 575 };
 576
 577 /* Open the separate '.dwz' debug file, if needed.  Return NULL if
 578    there is no .gnu_debugaltlink section in the file.  Error if there
 579    is such a section but the file cannot be found.  */
 580
 581 extern struct dwz_file *dwarf2_get_dwz_file
 582     (struct dwarf2_per_objfile *dwarf2_per_objfile);
 583
 584 /* Return the type of the DIE at DIE_OFFSET in the CU named by
 585    PER_CU.  */
 586
 587 struct type *dwarf2_get_die_type (cu_offset die_offset,
 588                                   struct dwarf2_per_cu_data *per_cu);
 589
 590 /* Given an index in .debug_addr, fetch the value.
 591    NOTE: This can be called during dwarf expression evaluation,
 592    long after the debug information has been read, and thus per_cu->cu
 593    may no longer exist.  */
 594
 595 CORE_ADDR dwarf2_read_addr_index (dwarf2_per_cu_data *per_cu,
 596                                   unsigned int addr_index);
 597
 598 /* Return DWARF block referenced by DW_AT_location of DIE at SECT_OFF at PER_CU.
 599    Returned value is intended for DW_OP_call*.  Returned
 600    dwarf2_locexpr_baton->data has lifetime of
 601    PER_CU->DWARF2_PER_OBJFILE->OBJFILE.  */
 602
 603 struct dwarf2_locexpr_baton dwarf2_fetch_die_loc_sect_off
 604   (sect_offset sect_off, dwarf2_per_cu_data *per_cu,
 605    CORE_ADDR (*get_frame_pc) (void *baton),
 606    void *baton, bool resolve_abstract_p = false);
 607
 608 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
 609    offset.  */
 610
 611 struct dwarf2_locexpr_baton dwarf2_fetch_die_loc_cu_off
 612   (cu_offset offset_in_cu, dwarf2_per_cu_data *per_cu,
 613    CORE_ADDR (*get_frame_pc) (void *baton),
 614    void *baton);
 615
 616 /* If the DIE at SECT_OFF in PER_CU has a DW_AT_const_value, return a
 617    pointer to the constant bytes and set LEN to the length of the
 618    data.  If memory is needed, allocate it on OBSTACK.  If the DIE
 619    does not have a DW_AT_const_value, return NULL.  */
 620
 621 extern const gdb_byte *dwarf2_fetch_constant_bytes
 622   (sect_offset sect_off, dwarf2_per_cu_data *per_cu, obstack *obstack,
 623    LONGEST *len);
 624
 625 /* Return the type of the die at SECT_OFF in PER_CU.  Return NULL if no
 626    valid type for this die is found.  */
 627
 628 struct type *dwarf2_fetch_die_type_sect_off
 629   (sect_offset sect_off, dwarf2_per_cu_data *per_cu);
 630
 631 /* When non-zero, dump line number entries as they are read in.  */
 632 extern unsigned int dwarf_line_debug;
 633
 634 #endif /* DWARF2READ_H */