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