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   /* When dwarf2_per_bfd::using_index is true, the 'quick' field
 416      is active.  Otherwise, the 'psymtab' field is active.  */
 417   union
 418   {
 419     /* The partial symbol table associated with this compilation unit,
 420        or NULL for unread partial units.  */
 421     dwarf2_psymtab *psymtab;
 422
 423     /* Data needed by the "quick" functions.  */
 424     struct dwarf2_per_cu_quick_data *quick;
 425   } v;
 426
 427   /* The CUs we import using DW_TAG_imported_unit.  This is filled in
 428      while reading psymtabs, used to compute the psymtab dependencies,
 429      and then cleared.  Then it is filled in again while reading full
 430      symbols, and only deleted when the objfile is destroyed.
 431
 432      This is also used to work around a difference between the way gold
 433      generates .gdb_index version <=7 and the way gdb does.  Arguably this
 434      is a gold bug.  For symbols coming from TUs, gold records in the index
 435      the CU that includes the TU instead of the TU itself.  This breaks
 436      dw2_lookup_symbol: It assumes that if the index says symbol X lives
 437      in CU/TU Y, then one need only expand Y and a subsequent lookup in Y
 438      will find X.  Alas TUs live in their own symtab, so after expanding CU Y
 439      we need to look in TU Z to find X.  Fortunately, this is akin to
 440      DW_TAG_imported_unit, so we just use the same mechanism: For
 441      .gdb_index version <=7 this also records the TUs that the CU referred
 442      to.  Concurrently with this change gdb was modified to emit version 8
 443      indices so we only pay a price for gold generated indices.
 444      http://sourceware.org/bugzilla/show_bug.cgi?id=15021.
 445
 446      This currently needs to be a public member due to how
 447      dwarf2_per_cu_data is allocated and used.  Ideally in future things
 448      could be refactored to make this private.  Until then please try to
 449      avoid direct access to this member, and instead use the helper
 450      functions above.  */
 451   std::vector <dwarf2_per_cu_data *> *imported_symtabs;
 452
 453   /* Return true of IMPORTED_SYMTABS is empty or not yet allocated.  */
 454   bool imported_symtabs_empty () const
 455   {
 456     return (imported_symtabs == nullptr || imported_symtabs->empty ());
 457   }
 458
 459   /* Push P to the back of IMPORTED_SYMTABS, allocated IMPORTED_SYMTABS
 460      first if required.  */
 461   void imported_symtabs_push (dwarf2_per_cu_data *p)
 462   {
 463     if (imported_symtabs == nullptr)
 464       imported_symtabs = new std::vector <dwarf2_per_cu_data *>;
 465     imported_symtabs->push_back (p);
 466   }
 467
 468   /* Return the size of IMPORTED_SYMTABS if it is allocated, otherwise
 469      return 0.  */
 470   size_t imported_symtabs_size () const
 471   {
 472     if (imported_symtabs == nullptr)
 473       return 0;
 474     return imported_symtabs->size ();
 475   }
 476
 477   /* Delete IMPORTED_SYMTABS and set the pointer back to nullptr.  */
 478   void imported_symtabs_free ()
 479   {
 480     delete imported_symtabs;
 481     imported_symtabs = nullptr;
 482   }
 483
 484   /* Return the OBJFILE associated with this compilation unit.  If
 485      this compilation unit came from a separate debuginfo file, then
 486      the master objfile is returned.  */
 487   struct objfile *objfile () const;
 488
 489   /* Return the address size given in the compilation unit header for
 490      this CU.  */
 491   int addr_size () const;
 492
 493   /* Return the offset size given in the compilation unit header for
 494      this CU.  */
 495   int offset_size () const;
 496
 497   /* Return the DW_FORM_ref_addr size given in the compilation unit
 498      header for this CU.  */
 499   int ref_addr_size () const;
 500
 501   /* Return the text offset of the CU.  The returned offset comes from
 502      this CU's objfile.  If this objfile came from a separate
 503      debuginfo file, then the offset may be different from the
 504      corresponding offset in the parent objfile.  */
 505   CORE_ADDR text_offset () const;
 506
 507   /* Return a type that is a generic pointer type, the size of which
 508      matches the address size given in the compilation unit header for
 509      this CU.  */
 510   struct type *addr_type () const;
 511
 512   /* Find an integer type SIZE_IN_BYTES bytes in size and return it.
 513      UNSIGNED_P controls if the integer is unsigned or not.  */
 514   struct type *int_type (int size_in_bytes, bool unsigned_p) const;
 515
 516   /* Find an integer type the same size as the address size given in
 517      the compilation unit header for this CU.  UNSIGNED_P controls if
 518      the integer is unsigned or not.  */
 519   struct type *addr_sized_int_type (bool unsigned_p) const;
 520
 521   /* Return DWARF version number of this CU.  */
 522   short version () const
 523   {
 524     return dwarf_version;
 525   }
 526
 527   /* A type unit group has a per_cu object that is recognized by
 528      having no section.  */
 529   bool type_unit_group_p () const
 530   {
 531     return section == nullptr;
 532   }
 533 };
 534
 535 /* Entry in the signatured_types hash table.  */
 536
 537 struct signatured_type
 538 {
 539   /* The "per_cu" object of this type.
 540      This struct is used iff per_cu.is_debug_types.
 541      N.B.: This is the first member so that it's easy to convert pointers
 542      between them.  */
 543   struct dwarf2_per_cu_data per_cu;
 544
 545   /* The type's signature.  */
 546   ULONGEST signature;
 547
 548   /* Offset in the TU of the type's DIE, as read from the TU header.
 549      If this TU is a DWO stub and the definition lives in a DWO file
 550      (specified by DW_AT_GNU_dwo_name), this value is unusable.  */
 551   cu_offset type_offset_in_tu;
 552
 553   /* Offset in the section of the type's DIE.
 554      If the definition lives in a DWO file, this is the offset in the
 555      .debug_types.dwo section.
 556      The value is zero until the actual value is known.
 557      Zero is otherwise not a valid section offset.  */
 558   sect_offset type_offset_in_section;
 559
 560   /* Type units are grouped by their DW_AT_stmt_list entry so that they
 561      can share them.  This points to the containing symtab.  */
 562   struct type_unit_group *type_unit_group;
 563
 564   /* The type.
 565      The first time we encounter this type we fully read it in and install it
 566      in the symbol tables.  Subsequent times we only need the type.  */
 567   struct type *type;
 568
 569   /* Containing DWO unit.
 570      This field is valid iff per_cu.reading_dwo_directly.  */
 571   struct dwo_unit *dwo_unit;
 572 };
 573
 574 /* Open the separate '.dwz' debug file, if needed.  Return NULL if
 575    there is no .gnu_debugaltlink section in the file.  Error if there
 576    is such a section but the file cannot be found.  */
 577
 578 extern struct dwz_file *dwarf2_get_dwz_file
 579     (struct dwarf2_per_objfile *dwarf2_per_objfile);
 580
 581 /* Return the type of the DIE at DIE_OFFSET in the CU named by
 582    PER_CU.  */
 583
 584 struct type *dwarf2_get_die_type (cu_offset die_offset,
 585                                   struct dwarf2_per_cu_data *per_cu);
 586
 587 /* Given an index in .debug_addr, fetch the value.
 588    NOTE: This can be called during dwarf expression evaluation,
 589    long after the debug information has been read, and thus per_cu->cu
 590    may no longer exist.  */
 591
 592 CORE_ADDR dwarf2_read_addr_index (dwarf2_per_cu_data *per_cu,
 593                                   unsigned int addr_index);
 594
 595 /* Return DWARF block referenced by DW_AT_location of DIE at SECT_OFF at PER_CU.
 596    Returned value is intended for DW_OP_call*.  Returned
 597    dwarf2_locexpr_baton->data has lifetime of
 598    PER_CU->DWARF2_PER_OBJFILE->OBJFILE.  */
 599
 600 struct dwarf2_locexpr_baton dwarf2_fetch_die_loc_sect_off
 601   (sect_offset sect_off, dwarf2_per_cu_data *per_cu,
 602    CORE_ADDR (*get_frame_pc) (void *baton),
 603    void *baton, bool resolve_abstract_p = false);
 604
 605 /* Like dwarf2_fetch_die_loc_sect_off, but take a CU
 606    offset.  */
 607
 608 struct dwarf2_locexpr_baton dwarf2_fetch_die_loc_cu_off
 609   (cu_offset offset_in_cu, dwarf2_per_cu_data *per_cu,
 610    CORE_ADDR (*get_frame_pc) (void *baton),
 611    void *baton);
 612
 613 /* If the DIE at SECT_OFF in PER_CU has a DW_AT_const_value, return a
 614    pointer to the constant bytes and set LEN to the length of the
 615    data.  If memory is needed, allocate it on OBSTACK.  If the DIE
 616    does not have a DW_AT_const_value, return NULL.  */
 617
 618 extern const gdb_byte *dwarf2_fetch_constant_bytes
 619   (sect_offset sect_off, dwarf2_per_cu_data *per_cu, obstack *obstack,
 620    LONGEST *len);
 621
 622 /* Return the type of the die at SECT_OFF in PER_CU.  Return NULL if no
 623    valid type for this die is found.  */
 624
 625 struct type *dwarf2_fetch_die_type_sect_off
 626   (sect_offset sect_off, dwarf2_per_cu_data *per_cu);
 627
 628 /* When non-zero, dump line number entries as they are read in.  */
 629 extern unsigned int dwarf_line_debug;
 630
 631 #endif /* DWARF2READ_H */