libdw/libdwP.h

   1 /* Internal definitions for libdw.
   2    Copyright (C) 2002-2011, 2013-2018 Red Hat, Inc.
   3    This file is part of elfutils.
   4
   5    This file is free software; you can redistribute it and/or modify
   6    it under the terms of either
   7
   8      * the GNU Lesser General Public License as published by the Free
   9        Software Foundation; either version 3 of the License, or (at
  10        your option) any later version
  11
  12    or
  13
  14      * the GNU General Public License as published by the Free
  15        Software Foundation; either version 2 of the License, or (at
  16        your option) any later version
  17
  18    or both in parallel, as here.
  19
  20    elfutils is distributed in the hope that it will be useful, but
  21    WITHOUT ANY WARRANTY; without even the implied warranty of
  22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  23    General Public License for more details.
  24
  25    You should have received copies of the GNU General Public License and
  26    the GNU Lesser General Public License along with this program.  If
  27    not, see <http://www.gnu.org/licenses/>.  */
  28
  29 #ifndef _LIBDWP_H
  30 #define _LIBDWP_H 1
  31
  32 #include <libintl.h>
  33 #include <stdbool.h>
  34
  35 #include <libdw.h>
  36 #include <dwarf.h>
  37
  38
  39 /* gettext helper macros.  */
  40 #define _(Str) dgettext ("elfutils", Str)
  41
  42
  43 /* Known location expressions already decoded.  */
  44 struct loc_s
  45 {
  46   void *addr;
  47   Dwarf_Op *loc;
  48   size_t nloc;
  49 };
  50
  51 /* Known DW_OP_implicit_value blocks already decoded.
  52    This overlaps struct loc_s exactly, but only the
  53    first member really has to match.  */
  54 struct loc_block_s
  55 {
  56   void *addr;
  57   unsigned char *data;
  58   size_t length;
  59 };
  60
  61 /* Already decoded .debug_line units.  */
  62 struct files_lines_s
  63 {
  64   Dwarf_Off debug_line_offset;
  65   Dwarf_Files *files;
  66   Dwarf_Lines *lines;
  67 };
  68
  69 /* Valid indeces for the section data.  */
  70 enum
  71   {
  72     IDX_debug_info = 0,
  73     IDX_debug_types,
  74     IDX_debug_abbrev,
  75     IDX_debug_aranges,
  76     IDX_debug_addr,
  77     IDX_debug_line,
  78     IDX_debug_line_str,
  79     IDX_debug_frame,
  80     IDX_debug_loc,
  81     IDX_debug_loclists,
  82     IDX_debug_pubnames,
  83     IDX_debug_str,
  84     IDX_debug_str_offsets,
  85     IDX_debug_macinfo,
  86     IDX_debug_macro,
  87     IDX_debug_ranges,
  88     IDX_debug_rnglists,
  89     IDX_gnu_debugaltlink,
  90     IDX_last
  91   };
  92
  93
  94 /* Error values.  */
  95 enum
  96 {
  97   DWARF_E_NOERROR = 0,
  98   DWARF_E_UNKNOWN_ERROR,
  99   DWARF_E_INVALID_ACCESS,
 100   DWARF_E_NO_REGFILE,
 101   DWARF_E_IO_ERROR,
 102   DWARF_E_INVALID_ELF,
 103   DWARF_E_NO_DWARF,
 104   DWARF_E_COMPRESSED_ERROR,
 105   DWARF_E_NOELF,
 106   DWARF_E_GETEHDR_ERROR,
 107   DWARF_E_NOMEM,
 108   DWARF_E_UNIMPL,
 109   DWARF_E_INVALID_CMD,
 110   DWARF_E_INVALID_VERSION,
 111   DWARF_E_INVALID_FILE,
 112   DWARF_E_NO_ENTRY,
 113   DWARF_E_INVALID_DWARF,
 114   DWARF_E_NO_STRING,
 115   DWARF_E_NO_DEBUG_STR,
 116   DWARF_E_NO_DEBUG_LINE_STR,
 117   DWARF_E_NO_STR_OFFSETS,
 118   DWARF_E_NO_ADDR,
 119   DWARF_E_NO_CONSTANT,
 120   DWARF_E_NO_REFERENCE,
 121   DWARF_E_INVALID_REFERENCE,
 122   DWARF_E_NO_DEBUG_LINE,
 123   DWARF_E_INVALID_DEBUG_LINE,
 124   DWARF_E_TOO_BIG,
 125   DWARF_E_VERSION,
 126   DWARF_E_INVALID_DIR_IDX,
 127   DWARF_E_ADDR_OUTOFRANGE,
 128   DWARF_E_NO_DEBUG_LOC,
 129   DWARF_E_NO_DEBUG_LOCLISTS,
 130   DWARF_E_NO_LOC_VALUE,
 131   DWARF_E_NO_BLOCK,
 132   DWARF_E_INVALID_LINE_IDX,
 133   DWARF_E_INVALID_ARANGE_IDX,
 134   DWARF_E_NO_MATCH,
 135   DWARF_E_NO_FLAG,
 136   DWARF_E_INVALID_OFFSET,
 137   DWARF_E_NO_DEBUG_RANGES,
 138   DWARF_E_NO_DEBUG_RNGLISTS,
 139   DWARF_E_INVALID_CFI,
 140   DWARF_E_NO_ALT_DEBUGLINK,
 141   DWARF_E_INVALID_OPCODE,
 142   DWARF_E_NOT_CUDIE,
 143   DWARF_E_UNKNOWN_LANGUAGE,
 144   DWARF_E_NO_DEBUG_ADDR,
 145 };
 146
 147
 148 #include "dwarf_sig8_hash.h"
 149
 150 /* This is the structure representing the debugging state.  */
 151 struct Dwarf
 152 {
 153   /* The underlying ELF file.  */
 154   Elf *elf;
 155
 156   /* The (absolute) path to the ELF dir, if known.  To help locating
 157      alt and dwo files.  */
 158   char *debugdir;
 159
 160   /* dwz alternate DWARF file.  */
 161   Dwarf *alt_dwarf;
 162
 163   /* The section data.  */
 164   Elf_Data *sectiondata[IDX_last];
 165
 166   /* True if the file has a byte order different from the host.  */
 167   bool other_byte_order;
 168
 169   /* If true, we allocated the ELF descriptor ourselves.  */
 170   bool free_elf;
 171
 172   /* If >= 0, we allocated the alt_dwarf ourselves and must end it and
 173      close this file descriptor.  */
 174   int alt_fd;
 175
 176   /* Information for traversing the .debug_pubnames section.  This is
 177      an array and separately allocated with malloc.  */
 178   struct pubnames_s
 179   {
 180     Dwarf_Off cu_offset;
 181     Dwarf_Off set_start;
 182     unsigned int cu_header_size;
 183     int address_len;
 184   } *pubnames_sets;
 185   size_t pubnames_nsets;
 186
 187   /* Search tree for the CUs.  */
 188   void *cu_tree;
 189   Dwarf_Off next_cu_offset;
 190
 191   /* Search tree and sig8 hash table for .debug_types type units.  */
 192   void *tu_tree;
 193   Dwarf_Off next_tu_offset;
 194   Dwarf_Sig8_Hash sig8_hash;
 195
 196   /* Search tree for split Dwarf associated with CUs in this debug.  */
 197   void *split_tree;
 198
 199   /* Search tree for .debug_macro operator tables.  */
 200   void *macro_ops;
 201
 202   /* Search tree for decoded .debug_line units.  */
 203   void *files_lines;
 204
 205   /* Address ranges.  */
 206   Dwarf_Aranges *aranges;
 207
 208   /* Cached info from the CFI section.  */
 209   struct Dwarf_CFI_s *cfi;
 210
 211   /* Fake loc CU.  Used when synthesizing attributes for Dwarf_Ops that
 212      came from a location list entry in dwarf_getlocation_attr.
 213      Depending on version this is the .debug_loc or .debug_loclists
 214      section (could be both if mixing CUs with different DWARF versions).  */
 215   struct Dwarf_CU *fake_loc_cu;
 216   struct Dwarf_CU *fake_loclists_cu;
 217
 218   /* Similar for addrx/constx, which will come from .debug_addr section.  */
 219   struct Dwarf_CU *fake_addr_cu;
 220
 221   /* Internal memory handling.  This is basically a simplified
 222      reimplementation of obstacks.  Unfortunately the standard obstack
 223      implementation is not usable in libraries.  */
 224   struct libdw_memblock
 225   {
 226     size_t size;
 227     size_t remaining;
 228     struct libdw_memblock *prev;
 229     char mem[0];
 230   } *mem_tail;
 231
 232   /* Default size of allocated memory blocks.  */
 233   size_t mem_default_size;
 234
 235   /* Registered OOM handler.  */
 236   Dwarf_OOM oom_handler;
 237 };
 238
 239
 240 /* Abbreviation representation.  */
 241 struct Dwarf_Abbrev
 242 {
 243   Dwarf_Off offset;       /* Offset to start of abbrev into .debug_abbrev.  */
 244   unsigned char *attrp;   /* Pointer to start of attribute name/form pairs. */
 245   bool has_children : 1;  /* Whether or not the DIE has children. */
 246   unsigned int code : 31; /* The (unique) abbrev code.  */
 247   unsigned int tag;       /* The tag of the DIE. */
 248 } attribute_packed;
 249
 250 #include "dwarf_abbrev_hash.h"
 251
 252
 253 /* Files in line information records.  */
 254 struct Dwarf_Files_s
 255   {
 256     unsigned int ndirs;
 257     unsigned int nfiles;
 258     struct Dwarf_Fileinfo_s
 259     {
 260       char *name;
 261       Dwarf_Word mtime;
 262       Dwarf_Word length;
 263     } info[0];
 264     /* nfiles of those, followed by char *[ndirs].  */
 265   };
 266 typedef struct Dwarf_Fileinfo_s Dwarf_Fileinfo;
 267
 268
 269 /* Representation of a row in the line table.  */
 270
 271 struct Dwarf_Line_s
 272 {
 273   Dwarf_Files *files;
 274
 275   Dwarf_Addr addr;
 276   unsigned int file;
 277   int line;
 278   unsigned short int column;
 279   unsigned int is_stmt:1;
 280   unsigned int basic_block:1;
 281   unsigned int end_sequence:1;
 282   unsigned int prologue_end:1;
 283   unsigned int epilogue_begin:1;
 284   /* The remaining bit fields are not flags, but hold values presumed to be
 285      small.  All the flags and other bit fields should add up to 48 bits
 286      to give the whole struct a nice round size.  */
 287   unsigned int op_index:8;
 288   unsigned int isa:8;
 289   unsigned int discriminator:24;
 290 };
 291
 292 struct Dwarf_Lines_s
 293 {
 294   size_t nlines;
 295   struct Dwarf_Line_s info[0];
 296 };
 297
 298 /* Representation of address ranges.  */
 299 struct Dwarf_Aranges_s
 300 {
 301   Dwarf *dbg;
 302   size_t naranges;
 303
 304   struct Dwarf_Arange_s
 305   {
 306     Dwarf_Addr addr;
 307     Dwarf_Word length;
 308     Dwarf_Off offset;
 309   } info[0];
 310 };
 311
 312
 313 /* CU representation.  */
 314 struct Dwarf_CU
 315 {
 316   Dwarf *dbg;
 317   Dwarf_Off start;
 318   Dwarf_Off end;
 319   uint8_t address_size;
 320   uint8_t offset_size;
 321   uint16_t version;
 322
 323   size_t sec_idx; /* Normally .debug_info, could be .debug_type or "fake". */
 324
 325   /* The unit type if version >= 5.  Otherwise 0 for normal CUs (from
 326      .debug_info) or 1 for v4 type units (from .debug_types).  */
 327   uint8_t unit_type;
 328
 329   /* Zero if the unit type doesn't support a die/type offset and/or id/sig.
 330      Nonzero if it is a v4 type unit or for DWARFv5 units depending on
 331      unit_type.  */
 332   size_t subdie_offset;
 333   uint64_t unit_id8;
 334
 335   /* If this is a skeleton unit this points to the split compile unit.
 336      Or the other way around if this is a split compile unit.  Set to -1
 337      if not yet searched.  Always use __libdw_find_split_unit to access
 338      this field.  */
 339   struct Dwarf_CU *split;
 340
 341   /* Hash table for the abbreviations.  */
 342   Dwarf_Abbrev_Hash abbrev_hash;
 343   /* Offset of the first abbreviation.  */
 344   size_t orig_abbrev_offset;
 345   /* Offset past last read abbreviation.  */
 346   size_t last_abbrev_offset;
 347
 348   /* The srcline information.  */
 349   Dwarf_Lines *lines;
 350
 351   /* The source file information.  */
 352   Dwarf_Files *files;
 353
 354   /* Known location lists.  */
 355   void *locs;
 356
 357   /* Base address for use with ranges and locs.
 358      Don't access directly, call __libdw_cu_base_address.  */
 359   Dwarf_Addr base_address;
 360
 361   /* The offset into the .debug_addr section where index zero begins.
 362      Don't access directly, call __libdw_cu_addr_base.  */
 363   Dwarf_Off addr_base;
 364
 365   /* The offset into the .debug_str_offsets section where index zero begins.
 366      Don't access directly, call __libdw_cu_str_off_base.  */
 367   Dwarf_Off str_off_base;
 368
 369   /* The offset into the .debug_ranges section to use for GNU
 370      DebugFission split units.  Don't access directly, call
 371      __libdw_cu_ranges_base.  */
 372   Dwarf_Off ranges_base;
 373
 374   /* The start of the offset table in .debug_loclists.
 375      Don't access directly, call __libdw_cu_locs_base.  */
 376   Dwarf_Off locs_base;
 377
 378   /* Memory boundaries of this CU.  */
 379   void *startp;
 380   void *endp;
 381 };
 382
 383 #define ISV4TU(cu) ((cu)->version == 4 && (cu)->sec_idx == IDX_debug_types)
 384
 385 /* Compute the offset of a CU's first DIE from the CU offset.
 386    CU must be a valid/known version/unit_type.  */
 387 static inline Dwarf_Off
 388 __libdw_first_die_from_cu_start (Dwarf_Off cu_start,
 389                                  uint8_t offset_size,
 390                                  uint16_t version,
 391                                  uint8_t unit_type)
 392 {
 393 /*
 394   assert (offset_size == 4 || offset_size == 8);
 395   assert (version >= 2 && version <= 5);
 396   assert (unit_type == DW_UT_compile
 397           || unit_type == DW_UT_partial
 398           || unit_type == DW_UT_skeleton
 399           || unit_type == DW_UT_split_compile
 400           || unit_type == DW_UT_type
 401           || unit_type == DW_UT_split_type);
 402 */
 403
 404   Dwarf_Off off = cu_start;
 405   if (version < 5)
 406     {
 407    /*
 408         LEN       VER     OFFSET    ADDR
 409       4-bytes + 2-bytes + 4-bytes + 1-byte  for 32-bit dwarf
 410      12-bytes + 2-bytes + 8-bytes + 1-byte  for 64-bit dwarf
 411    or in .debug_types,                       SIGNATURE TYPE-OFFSET
 412       4-bytes + 2-bytes + 4-bytes + 1-byte + 8-bytes + 4-bytes  for 32-bit
 413      12-bytes + 2-bytes + 8-bytes + 1-byte + 8-bytes + 8-bytes  for 64-bit
 414
 415    Note the trick in the computation.  If the offset_size is 4
 416    the '- 4' term changes the '3 *' (or '4 *') into a '2 *' (or '3 *).
 417    If the offset_size is 8 it accounts for the 4-byte escape value
 418    used at the start of the length.  */
 419       if (unit_type != DW_UT_type)
 420         off += 3 * offset_size - 4 + 3;
 421       else
 422         off += 4 * offset_size - 4 + 3 + 8;
 423     }
 424   else
 425     {
 426      /*
 427         LEN       VER      TYPE     ADDR     OFFSET   SIGNATURE  TYPE-OFFSET
 428       4-bytes + 2-bytes + 1-byte + 1-byte + 4-bytes + 8-bytes + 4-bytes 32-bit
 429      12-bytes + 2-bytes + 1-byte + 1-byte + 8-bytes + 8-bytes + 8-bytes 64-bit
 430         Both signature and type offset are optional.
 431
 432         Note same 4/8 offset size trick as above.
 433         We explicitly ignore unknow unit types (see asserts above).  */
 434       off += 3 * offset_size - 4 + 4;
 435       if (unit_type == DW_UT_skeleton || unit_type == DW_UT_split_compile
 436           || unit_type == DW_UT_type || unit_type == DW_UT_split_type)
 437         {
 438           off += 8;
 439           if (unit_type == DW_UT_type || unit_type == DW_UT_split_type)
 440             off += offset_size;
 441         }
 442     }
 443
 444   return off;
 445 }
 446
 447 static inline Dwarf_Off
 448 __libdw_first_die_off_from_cu (struct Dwarf_CU *cu)
 449 {
 450   return __libdw_first_die_from_cu_start (cu->start,
 451                                           cu->offset_size,
 452                                           cu->version,
 453                                           cu->unit_type);
 454 }
 455
 456 #define CUDIE(fromcu)                                                         \
 457   ((Dwarf_Die)                                                                \
 458    {                                                                          \
 459      .cu = (fromcu),                                                          \
 460      .addr = ((char *) (fromcu)->dbg->sectiondata[cu_sec_idx (fromcu)]->d_buf \
 461               + __libdw_first_die_off_from_cu (fromcu))                       \
 462    })
 463
 464 #define SUBDIE(fromcu)                                                        \
 465   ((Dwarf_Die)                                                                \
 466    {                                                                          \
 467      .cu = (fromcu),                                                          \
 468      .addr = ((char *) (fromcu)->dbg->sectiondata[cu_sec_idx (fromcu)]->d_buf \
 469               + (fromcu)->start + (fromcu)->subdie_offset)                    \
 470    })
 471
 472
 473 /* Prototype of a single .debug_macro operator.  */
 474 typedef struct
 475 {
 476   Dwarf_Word nforms;
 477   unsigned char const *forms;
 478 } Dwarf_Macro_Op_Proto;
 479
 480 /* Prototype table.  */
 481 typedef struct
 482 {
 483   /* Offset of .debug_macro section.  */
 484   Dwarf_Off offset;
 485
 486   /* Offset of associated .debug_line section.  */
 487   Dwarf_Off line_offset;
 488
 489   /* The source file information.  */
 490   Dwarf_Files *files;
 491
 492   /* If this macro unit was opened through dwarf_getmacros or
 493      dwarf_getmacros_die, this caches value of DW_AT_comp_dir, if
 494      present.  */
 495   const char *comp_dir;
 496
 497   /* Header length.  */
 498   Dwarf_Half header_len;
 499
 500   uint16_t version;
 501   bool is_64bit;
 502   uint8_t sec_index;    /* IDX_debug_macro or IDX_debug_macinfo.  */
 503
 504   /* Shows where in TABLE each opcode is defined.  Since opcode 0 is
 505      never used, it stores index of opcode X in X-1'th element.  The
 506      value of 0xff means not stored at all.  */
 507   unsigned char opcodes[255];
 508
 509   /* Individual opcode prototypes.  */
 510   Dwarf_Macro_Op_Proto table[];
 511 } Dwarf_Macro_Op_Table;
 512
 513 struct Dwarf_Macro_s
 514 {
 515   Dwarf_Macro_Op_Table *table;
 516   Dwarf_Attribute *attributes;
 517   uint8_t opcode;
 518 };
 519
 520 static inline Dwarf_Word
 521 libdw_macro_nforms (Dwarf_Macro *macro)
 522 {
 523   return macro->table->table[macro->table->opcodes[macro->opcode - 1]].nforms;
 524 }
 525
 526 /* Returns true for any allowed FORM in the opcode_operands_table as
 527    mentioned in the DWARF5 spec (6.3.1 Macro Information Header).
 528    Or those mentioned in DWARF5 spec (6.2.4.2 Vendor-defined Content
 529    Descriptions) for the directory/file table (plus DW_FORM_strp_sup).  */
 530 static inline bool
 531 libdw_valid_user_form (int form)
 532 {
 533   switch (form)
 534     {
 535       case DW_FORM_block:
 536       case DW_FORM_block1:
 537       case DW_FORM_block2:
 538       case DW_FORM_block4:
 539       case DW_FORM_data1:
 540       case DW_FORM_data2:
 541       case DW_FORM_data4:
 542       case DW_FORM_data8:
 543       case DW_FORM_data16:
 544       case DW_FORM_flag:
 545       case DW_FORM_line_strp:
 546       case DW_FORM_sdata:
 547       case DW_FORM_sec_offset:
 548       case DW_FORM_string:
 549       case DW_FORM_strp:
 550       case DW_FORM_strp_sup:
 551       case DW_FORM_strx:
 552       case DW_FORM_strx1:
 553       case DW_FORM_strx2:
 554       case DW_FORM_strx3:
 555       case DW_FORM_strx4:
 556       case DW_FORM_udata:
 557         return true;
 558       default:
 559         return false;
 560     }
 561 }
 562
 563
 564 /* We have to include the file at this point because the inline
 565    functions access internals of the Dwarf structure.  */
 566 #include "memory-access.h"
 567
 568
 569 /* Set error value.  */
 570 extern void __libdw_seterrno (int value) internal_function;
 571
 572
 573 /* Memory handling, the easy parts.  This macro does not do any locking.  */
 574 #define libdw_alloc(dbg, type, tsize, cnt) \
 575   ({ struct libdw_memblock *_tail = (dbg)->mem_tail;                          \
 576      size_t _required = (tsize) * (cnt);                                      \
 577      type *_result = (type *) (_tail->mem + (_tail->size - _tail->remaining));\
 578      size_t _padding = ((__alignof (type)                                     \
 579                          - ((uintptr_t) _result & (__alignof (type) - 1)))    \
 580                         & (__alignof (type) - 1));                            \
 581      if (unlikely (_tail->remaining < _required + _padding))                  \
 582        _result = (type *) __libdw_allocate (dbg, _required, __alignof (type));\
 583      else                                                                     \
 584        {                                                                      \
 585          _required += _padding;                                               \
 586          _result = (type *) ((char *) _result + _padding);                    \
 587          _tail->remaining -= _required;                                       \
 588        }                                                                      \
 589      _result; })
 590
 591 #define libdw_typed_alloc(dbg, type) \
 592   libdw_alloc (dbg, type, sizeof (type), 1)
 593
 594 /* Callback to allocate more.  */
 595 extern void *__libdw_allocate (Dwarf *dbg, size_t minsize, size_t align)
 596      __attribute__ ((__malloc__)) __nonnull_attribute__ (1);
 597
 598 /* Default OOM handler.  */
 599 extern void __libdw_oom (void) __attribute ((noreturn)) attribute_hidden;
 600
 601 /* Read next unit (or v4 debug type) and return next offset.  Doesn't
 602    create an actual Dwarf_CU just provides necessary header fields.  */
 603 extern int
 604 internal_function
 605 __libdw_next_unit (Dwarf *dbg, bool v4_debug_types, Dwarf_Off off,
 606                    Dwarf_Off *next_off, size_t *header_sizep,
 607                    Dwarf_Half *versionp, uint8_t *unit_typep,
 608                    Dwarf_Off *abbrev_offsetp, uint8_t *address_sizep,
 609                    uint8_t *offset_sizep, uint64_t *unit_id8p,
 610                    Dwarf_Off *subdie_offsetp)
 611      __nonnull_attribute__ (4) internal_function;
 612
 613 /* Allocate the internal data for a unit not seen before.  */
 614 extern struct Dwarf_CU *__libdw_intern_next_unit (Dwarf *dbg, bool debug_types)
 615      __nonnull_attribute__ (1) internal_function;
 616
 617 /* Find CU for given offset.  */
 618 extern struct Dwarf_CU *__libdw_findcu (Dwarf *dbg, Dwarf_Off offset, bool tu)
 619      __nonnull_attribute__ (1) internal_function;
 620
 621 /* Find CU for given DIE address.  */
 622 extern struct Dwarf_CU *__libdw_findcu_addr (Dwarf *dbg, void *addr)
 623      __nonnull_attribute__ (1) internal_function;
 624
 625 /* Find split Dwarf for given DIE address.  */
 626 extern struct Dwarf *__libdw_find_split_dbg_addr (Dwarf *dbg, void *addr)
 627      __nonnull_attribute__ (1) internal_function;
 628
 629 /* Find the split (or skeleton) unit.  */
 630 extern struct Dwarf_CU *__libdw_find_split_unit (Dwarf_CU *cu)
 631      internal_function;
 632
 633 /* Get abbreviation with given code.  */
 634 extern Dwarf_Abbrev *__libdw_findabbrev (struct Dwarf_CU *cu,
 635                                          unsigned int code)
 636      __nonnull_attribute__ (1) internal_function;
 637
 638 /* Get abbreviation at given offset.  */
 639 extern Dwarf_Abbrev *__libdw_getabbrev (Dwarf *dbg, struct Dwarf_CU *cu,
 640                                         Dwarf_Off offset, size_t *lengthp,
 641                                         Dwarf_Abbrev *result)
 642      __nonnull_attribute__ (1) internal_function;
 643
 644 /* Get abbreviation of given DIE, and optionally set *READP to the DIE memory
 645    just past the abbreviation code.  */
 646 static inline Dwarf_Abbrev *
 647 __nonnull_attribute__ (1)
 648 __libdw_dieabbrev (Dwarf_Die *die, const unsigned char **readp)
 649 {
 650   /* Do we need to get the abbreviation, or need to read after the code?  */
 651   if (die->abbrev == NULL || readp != NULL)
 652     {
 653       /* Get the abbreviation code.  */
 654       unsigned int code;
 655       const unsigned char *addr = die->addr;
 656       if (unlikely (die->cu == NULL
 657                     || addr >= (const unsigned char *) die->cu->endp))
 658         return die->abbrev = DWARF_END_ABBREV;
 659       get_uleb128 (code, addr, die->cu->endp);
 660       if (readp != NULL)
 661         *readp = addr;
 662
 663       /* Find the abbreviation.  */
 664       if (die->abbrev == NULL)
 665         die->abbrev = __libdw_findabbrev (die->cu, code);
 666     }
 667   return die->abbrev;
 668 }
 669
 670 /* Helper functions for form handling.  */
 671 extern size_t __libdw_form_val_compute_len (struct Dwarf_CU *cu,
 672                                             unsigned int form,
 673                                             const unsigned char *valp)
 674      __nonnull_attribute__ (1, 3) internal_function;
 675
 676 /* Find the length of a form attribute in DIE/info data.  */
 677 static inline size_t
 678 __nonnull_attribute__ (1, 3)
 679 __libdw_form_val_len (struct Dwarf_CU *cu, unsigned int form,
 680                       const unsigned char *valp)
 681 {
 682   /* Small lookup table of forms with fixed lengths.  Absent indexes are
 683      initialized 0, so any truly desired 0 is set to 0x80 and masked.  */
 684   static const uint8_t form_lengths[] =
 685     {
 686       [DW_FORM_flag_present] = 0x80,
 687       [DW_FORM_implicit_const] = 0x80, /* Value is in abbrev, not in info.  */
 688
 689       [DW_FORM_flag] = 1,
 690       [DW_FORM_data1] = 1, [DW_FORM_ref1] = 1,
 691       [DW_FORM_addrx1] = 1, [DW_FORM_strx1] = 1,
 692
 693       [DW_FORM_data2] = 2, [DW_FORM_ref2] = 2,
 694       [DW_FORM_addrx2] = 2, [DW_FORM_strx2] = 2,
 695
 696       [DW_FORM_addrx3] = 3, [DW_FORM_strx3] = 3,
 697
 698       [DW_FORM_data4] = 4, [DW_FORM_ref4] = 4, [DW_FORM_ref_sup4] = 4,
 699       [DW_FORM_addrx4] = 4, [DW_FORM_strx4] = 4,
 700
 701       [DW_FORM_ref_sig8] = 8,
 702       [DW_FORM_data8] = 8, [DW_FORM_ref8] = 8, [DW_FORM_ref_sup8] = 8,
 703
 704       [DW_FORM_data16] = 16,
 705     };
 706
 707   /* Return immediately for forms with fixed lengths.  */
 708   if (form < sizeof form_lengths / sizeof form_lengths[0])
 709     {
 710       uint8_t len = form_lengths[form];
 711       if (len != 0)
 712         {
 713           const unsigned char *endp = cu->endp;
 714           len &= 0x7f; /* Mask to allow 0x80 -> 0.  */
 715           if (unlikely (len > (size_t) (endp - valp)))
 716             {
 717               __libdw_seterrno (DWARF_E_INVALID_DWARF);
 718               return -1;
 719             }
 720           return len;
 721         }
 722     }
 723
 724   /* Other forms require some computation.  */
 725   return __libdw_form_val_compute_len (cu, form, valp);
 726 }
 727
 728 /* Helper function for DW_FORM_ref* handling.  */
 729 extern int __libdw_formref (Dwarf_Attribute *attr, Dwarf_Off *return_offset)
 730      __nonnull_attribute__ (1, 2) internal_function;
 731
 732
 733 /* Helper function to locate attribute.  */
 734 extern unsigned char *__libdw_find_attr (Dwarf_Die *die,
 735                                          unsigned int search_name,
 736                                          unsigned int *codep,
 737                                          unsigned int *formp)
 738      __nonnull_attribute__ (1) internal_function;
 739
 740 /* Helper function to access integer attribute.  */
 741 extern int __libdw_attr_intval (Dwarf_Die *die, int *valp, int attval)
 742      __nonnull_attribute__ (1, 2) internal_function;
 743
 744 /* Helper function to walk scopes.  */
 745 struct Dwarf_Die_Chain
 746 {
 747   Dwarf_Die die;
 748   struct Dwarf_Die_Chain *parent;
 749   bool prune;                   /* The PREVISIT function can set this.  */
 750 };
 751 extern int __libdw_visit_scopes (unsigned int depth,
 752                                  struct Dwarf_Die_Chain *root,
 753                                  struct Dwarf_Die_Chain *imports,
 754                                  int (*previsit) (unsigned int depth,
 755                                                   struct Dwarf_Die_Chain *,
 756                                                   void *arg),
 757                                  int (*postvisit) (unsigned int depth,
 758                                                    struct Dwarf_Die_Chain *,
 759                                                    void *arg),
 760                                  void *arg)
 761   __nonnull_attribute__ (2, 4) internal_function;
 762
 763 /* Parse a DWARF Dwarf_Block into an array of Dwarf_Op's,
 764    and cache the result (via tsearch).  */
 765 extern int __libdw_intern_expression (Dwarf *dbg,
 766                                       bool other_byte_order,
 767                                       unsigned int address_size,
 768                                       unsigned int ref_size,
 769                                       void **cache, const Dwarf_Block *block,
 770                                       bool cfap, bool valuep,
 771                                       Dwarf_Op **llbuf, size_t *listlen,
 772                                       int sec_index)
 773   __nonnull_attribute__ (5, 6, 9, 10) internal_function;
 774
 775 extern Dwarf_Die *__libdw_offdie (Dwarf *dbg, Dwarf_Off offset,
 776                                   Dwarf_Die *result, bool debug_types)
 777   internal_function;
 778
 779
 780 /* Return error code of last failing function call.  This value is kept
 781    separately for each thread.  */
 782 extern int __dwarf_errno_internal (void);
 783
 784
 785 /* Reader hooks.  */
 786
 787 /* Relocation hooks return -1 on error (in that case the error code
 788    must already have been set), 0 if there is no relocation and 1 if a
 789    relocation was present.*/
 790
 791 static inline int
 792 __libdw_relocate_address (Dwarf *dbg __attribute__ ((unused)),
 793                           int sec_index __attribute__ ((unused)),
 794                           const void *addr __attribute__ ((unused)),
 795                           int width __attribute__ ((unused)),
 796                           Dwarf_Addr *val __attribute__ ((unused)))
 797 {
 798   return 0;
 799 }
 800
 801 static inline int
 802 __libdw_relocate_offset (Dwarf *dbg __attribute__ ((unused)),
 803                          int sec_index __attribute__ ((unused)),
 804                          const void *addr __attribute__ ((unused)),
 805                          int width __attribute__ ((unused)),
 806                          Dwarf_Off *val __attribute__ ((unused)))
 807 {
 808   return 0;
 809 }
 810
 811 static inline Elf_Data *
 812 __libdw_checked_get_data (Dwarf *dbg, int sec_index)
 813 {
 814   Elf_Data *data = dbg->sectiondata[sec_index];
 815   if (unlikely (data == NULL)
 816       || unlikely (data->d_buf == NULL))
 817     {
 818       __libdw_seterrno (DWARF_E_INVALID_DWARF);
 819       return NULL;
 820     }
 821   return data;
 822 }
 823
 824 static inline int
 825 __libdw_offset_in_section (Dwarf *dbg, int sec_index,
 826                            Dwarf_Off offset, size_t size)
 827 {
 828   Elf_Data *data = __libdw_checked_get_data (dbg, sec_index);
 829   if (data == NULL)
 830     return -1;
 831   if (unlikely (offset > data->d_size)
 832       || unlikely (data->d_size < size)
 833       || unlikely (offset > data->d_size - size))
 834     {
 835       __libdw_seterrno (DWARF_E_INVALID_OFFSET);
 836       return -1;
 837     }
 838
 839   return 0;
 840 }
 841
 842 static inline bool
 843 __libdw_in_section (Dwarf *dbg, int sec_index,
 844                     const void *addr, size_t size)
 845 {
 846   Elf_Data *data = __libdw_checked_get_data (dbg, sec_index);
 847   if (data == NULL)
 848     return false;
 849   if (unlikely (addr < data->d_buf)
 850       || unlikely (data->d_size < size)
 851       || unlikely ((size_t)(addr - data->d_buf) > data->d_size - size))
 852     {
 853       __libdw_seterrno (DWARF_E_INVALID_OFFSET);
 854       return false;
 855     }
 856
 857   return true;
 858 }
 859
 860 #define READ_AND_RELOCATE(RELOC_HOOK, VAL)                              \
 861   ({                                                                    \
 862     if (!__libdw_in_section (dbg, sec_index, addr, width))              \
 863       return -1;                                                        \
 864                                                                         \
 865     const unsigned char *orig_addr = addr;                              \
 866     if (width == 4)                                                     \
 867       VAL = read_4ubyte_unaligned_inc (dbg, addr);                      \
 868     else                                                                \
 869       VAL = read_8ubyte_unaligned_inc (dbg, addr);                      \
 870                                                                         \
 871     int status = RELOC_HOOK (dbg, sec_index, orig_addr, width, &VAL);   \
 872     if (status < 0)                                                     \
 873       return status;                                                    \
 874     status > 0;                                                         \
 875    })
 876
 877 static inline int
 878 __libdw_read_address_inc (Dwarf *dbg,
 879                           int sec_index, const unsigned char **addrp,
 880                           int width, Dwarf_Addr *ret)
 881 {
 882   const unsigned char *addr = *addrp;
 883   READ_AND_RELOCATE (__libdw_relocate_address, (*ret));
 884   *addrp = addr;
 885   return 0;
 886 }
 887
 888 static inline int
 889 __libdw_read_address (Dwarf *dbg,
 890                       int sec_index, const unsigned char *addr,
 891                       int width, Dwarf_Addr *ret)
 892 {
 893   READ_AND_RELOCATE (__libdw_relocate_address, (*ret));
 894   return 0;
 895 }
 896
 897 static inline int
 898 __libdw_read_offset_inc (Dwarf *dbg,
 899                          int sec_index, const unsigned char **addrp,
 900                          int width, Dwarf_Off *ret, int sec_ret,
 901                          size_t size)
 902 {
 903   const unsigned char *addr = *addrp;
 904   READ_AND_RELOCATE (__libdw_relocate_offset, (*ret));
 905   *addrp = addr;
 906   return __libdw_offset_in_section (dbg, sec_ret, *ret, size);
 907 }
 908
 909 static inline int
 910 __libdw_read_offset (Dwarf *dbg, Dwarf *dbg_ret,
 911                      int sec_index, const unsigned char *addr,
 912                      int width, Dwarf_Off *ret, int sec_ret,
 913                      size_t size)
 914 {
 915   READ_AND_RELOCATE (__libdw_relocate_offset, (*ret));
 916   return __libdw_offset_in_section (dbg_ret, sec_ret, *ret, size);
 917 }
 918
 919 static inline size_t
 920 cu_sec_idx (struct Dwarf_CU *cu)
 921 {
 922   return cu->sec_idx;
 923 }
 924
 925 static inline bool
 926 is_cudie (Dwarf_Die *cudie)
 927 {
 928   return cudie->cu != NULL && CUDIE (cudie->cu).addr == cudie->addr;
 929 }
 930
 931 /* Read up begin/end pair and increment read pointer.
 932     - If it's normal range record, set up *BEGINP and *ENDP and return 0.
 933     - If it's base address selection record, set up *BASEP and return 1.
 934     - If it's end of rangelist, don't set anything and return 2
 935     - If an error occurs, don't set anything and return <0.  */
 936 int __libdw_read_begin_end_pair_inc (Dwarf_CU *cu, int sec_index,
 937                                      const unsigned char **readp,
 938                                      const unsigned char *readend,
 939                                      int width,
 940                                      Dwarf_Addr *beginp, Dwarf_Addr *endp,
 941                                      Dwarf_Addr *basep)
 942   internal_function;
 943
 944 const unsigned char * __libdw_formptr (Dwarf_Attribute *attr, int sec_index,
 945                                        int err_nodata,
 946                                        const unsigned char **endpp,
 947                                        Dwarf_Off *offsetp)
 948   internal_function;
 949
 950 /* Fills in the given attribute to point at an empty location expression.  */
 951 void __libdw_empty_loc_attr (Dwarf_Attribute *attr)
 952   internal_function;
 953
 954 /* Load .debug_line unit at DEBUG_LINE_OFFSET.  COMP_DIR is a value of
 955    DW_AT_comp_dir or NULL if that attribute is not available.  Caches
 956    the loaded unit and optionally set *LINESP and/or *FILESP (if not
 957    NULL) with loaded information.  Returns 0 for success or a negative
 958    value for failure.  */
 959 int __libdw_getsrclines (Dwarf *dbg, Dwarf_Off debug_line_offset,
 960                          const char *comp_dir, unsigned address_size,
 961                          Dwarf_Lines **linesp, Dwarf_Files **filesp)
 962   internal_function
 963   __nonnull_attribute__ (1);
 964
 965 /* Load and return value of DW_AT_comp_dir from CUDIE.  */
 966 const char *__libdw_getcompdir (Dwarf_Die *cudie);
 967
 968 /* Get the base address for the CU, fetches it when not yet set.
 969    This is used as initial base address for ranges and loclists.  */
 970 Dwarf_Addr __libdw_cu_base_address (Dwarf_CU *cu);
 971
 972 /* Get the address base for the CU, fetches it when not yet set.  */
 973 static inline Dwarf_Off
 974 __libdw_cu_addr_base (Dwarf_CU *cu)
 975 {
 976   if (cu->addr_base == (Dwarf_Off) -1)
 977     {
 978       Dwarf_Die cu_die = CUDIE(cu);
 979       Dwarf_Attribute attr;
 980       Dwarf_Off offset = 0;
 981       if (dwarf_attr (&cu_die, DW_AT_GNU_addr_base, &attr) != NULL
 982           || dwarf_attr (&cu_die, DW_AT_addr_base, &attr) != NULL)
 983         {
 984           Dwarf_Word off;
 985           if (dwarf_formudata (&attr, &off) == 0)
 986             offset = off;
 987         }
 988       cu->addr_base = offset;
 989     }
 990
 991   return cu->addr_base;
 992 }
 993
 994 /* Gets the .debug_str_offsets base offset to use.  static inline to
 995    be shared between libdw and eu-readelf.  */
 996 static inline Dwarf_Off
 997 str_offsets_base_off (Dwarf *dbg, Dwarf_CU *cu)
 998 {
 999   /* If we don't have a CU, then find and use the first one in the
1000      debug file (when we support .dwp files, we must actually find the
1001      one matching our "caller" - aka macro or line).  If we (now) have
1002      a cu and str_offsets_base attribute, just use that.  Otherwise
1003      use the first offset.  But we might have to parse the header
1004      first, but only if this is version 5.  Assume if all else fails,
1005      this is version 4, without header.  */
1006
1007   if (cu == NULL && dbg != NULL)
1008     {
1009       Dwarf_CU *first_cu;
1010       if (dwarf_get_units (dbg, NULL, &first_cu,
1011                            NULL, NULL, NULL, NULL) == 0)
1012         cu = first_cu;
1013     }
1014
1015   if (cu != NULL)
1016     {
1017       if (cu->str_off_base == (Dwarf_Off) -1)
1018         {
1019           Dwarf_Die cu_die = CUDIE(cu);
1020           Dwarf_Attribute attr;
1021           if (dwarf_attr (&cu_die, DW_AT_str_offsets_base, &attr) != NULL)
1022             {
1023               Dwarf_Word off;
1024               if (dwarf_formudata (&attr, &off) == 0)
1025                 {
1026                   cu->str_off_base = off;
1027                   return cu->str_off_base;
1028                 }
1029             }
1030           /* For older DWARF simply assume zero (no header).  */
1031           if (cu->version < 5)
1032             {
1033               cu->str_off_base = 0;
1034               return cu->str_off_base;
1035             }
1036
1037           if (dbg == NULL)
1038             dbg = cu->dbg;
1039         }
1040       else
1041         return cu->str_off_base;
1042     }
1043
1044   /* No str_offsets_base attribute, we have to assume "zero".
1045      But there could be a header first.  */
1046   Dwarf_Off off = 0;
1047   if (dbg == NULL)
1048     goto no_header;
1049
1050   Elf_Data *data =  dbg->sectiondata[IDX_debug_str_offsets];
1051   if (data == NULL)
1052     goto no_header;
1053
1054   const unsigned char *start;
1055   const unsigned char *readp;
1056   const unsigned char *readendp;
1057   start = readp = (const unsigned char *) data->d_buf;
1058   readendp = (const unsigned char *) data->d_buf + data->d_size;
1059
1060   uint64_t unit_length;
1061   uint16_t version;
1062
1063   unit_length = read_4ubyte_unaligned_inc (dbg, readp);
1064   if (unlikely (unit_length == 0xffffffff))
1065     {
1066       if (unlikely (readendp - readp < 8))
1067         goto no_header;
1068       unit_length = read_8ubyte_unaligned_inc (dbg, readp);
1069       /* In theory the offset size could be different
1070          between CU and str_offsets unit.  But we just
1071          ignore that here. */
1072     }
1073
1074   /* We need at least 2-bytes (version) + 2-bytes (padding) =
1075      4 bytes to complete the header.  And this unit cannot go
1076      beyond the section data.  */
1077   if (readendp - readp < 4
1078       || unit_length < 4
1079       || (uint64_t) (readendp - readp) < unit_length)
1080     goto no_header;
1081
1082   version = read_2ubyte_unaligned_inc (dbg, readp);
1083   if (version != 5)
1084     goto no_header;
1085   /* padding */
1086   read_2ubyte_unaligned_inc (dbg, readp);
1087
1088   off = (Dwarf_Off) (readp - start);
1089
1090  no_header:
1091   if (cu != NULL)
1092     cu->str_off_base = off;
1093
1094   return off;
1095 }
1096
1097
1098 /* Get the string offsets base for the CU, fetches it when not yet set.  */
1099 static inline Dwarf_Off __libdw_cu_str_off_base (Dwarf_CU *cu)
1100 {
1101   return str_offsets_base_off (NULL, cu);
1102 }
1103
1104
1105 /* Either a direct offset into .debug_ranges for version < 5, or the
1106    start of the offset table in .debug_rnglists for version > 5.  */
1107 static inline Dwarf_Off
1108 __libdw_cu_ranges_base (Dwarf_CU *cu)
1109 {
1110   if (cu->ranges_base == (Dwarf_Off) -1)
1111     {
1112       Dwarf_Off offset = 0;
1113       Dwarf_Die cu_die = CUDIE(cu);
1114       Dwarf_Attribute attr;
1115       if (cu->version < 5)
1116         {
1117           if (dwarf_attr (&cu_die, DW_AT_GNU_ranges_base, &attr) != NULL)
1118             {
1119               Dwarf_Word off;
1120               if (dwarf_formudata (&attr, &off) == 0)
1121                 offset = off;
1122             }
1123         }
1124       else
1125         {
1126           if (dwarf_attr (&cu_die, DW_AT_rnglists_base, &attr) != NULL)
1127             {
1128               Dwarf_Word off;
1129               if (dwarf_formudata (&attr, &off) == 0)
1130                 offset = off;
1131             }
1132
1133           /* There wasn't an rnglists_base, if the Dwarf does have a
1134              .debug_rnglists section, then it might be we need the
1135              base after the first header. */
1136           Elf_Data *data = cu->dbg->sectiondata[IDX_debug_rnglists];
1137           if (offset == 0 && data != NULL)
1138             {
1139               Dwarf *dbg = cu->dbg;
1140               const unsigned char *readp = data->d_buf;
1141               const unsigned char *const dataend
1142                 = (unsigned char *) data->d_buf + data->d_size;
1143
1144               uint64_t unit_length = read_4ubyte_unaligned_inc (dbg, readp);
1145               unsigned int offset_size = 4;
1146               if (unlikely (unit_length == 0xffffffff))
1147                 {
1148                   if (unlikely (readp > dataend - 8))
1149                     goto no_header;
1150
1151                   unit_length = read_8ubyte_unaligned_inc (dbg, readp);
1152                   offset_size = 8;
1153                 }
1154
1155               if (readp > dataend - 8
1156                   || unit_length < 8
1157                   || unit_length > (uint64_t) (dataend - readp))
1158                 goto no_header;
1159
1160               uint16_t version = read_2ubyte_unaligned_inc (dbg, readp);
1161               if (version != 5)
1162                 goto no_header;
1163
1164               uint8_t address_size = *readp++;
1165               if (address_size != 4 && address_size != 8)
1166                 goto no_header;
1167
1168               uint8_t segment_size = *readp++;
1169               if (segment_size != 0)
1170                 goto no_header;
1171
1172               uint32_t offset_entry_count;
1173               offset_entry_count = read_4ubyte_unaligned_inc (dbg, readp);
1174
1175               const unsigned char *offset_array_start = readp;
1176               if (offset_entry_count <= 0)
1177                 goto no_header;
1178
1179               uint64_t needed = offset_entry_count * offset_size;
1180               if (unit_length - 8 < needed)
1181                 goto no_header;
1182
1183               offset = (Dwarf_Off) (offset_array_start
1184                                     - (unsigned char *) data->d_buf);
1185             }
1186         }
1187     no_header:
1188       cu->ranges_base = offset;
1189     }
1190
1191   return cu->ranges_base;
1192 }
1193
1194
1195 /* The start of the offset table in .debug_loclists for DWARF5.  */
1196 static inline Dwarf_Off
1197 __libdw_cu_locs_base (Dwarf_CU *cu)
1198 {
1199   if (cu->locs_base == (Dwarf_Off) -1)
1200     {
1201       Dwarf_Off offset = 0;
1202       Dwarf_Die cu_die = CUDIE(cu);
1203       Dwarf_Attribute attr;
1204       if (dwarf_attr (&cu_die, DW_AT_loclists_base, &attr) != NULL)
1205         {
1206           Dwarf_Word off;
1207           if (dwarf_formudata (&attr, &off) == 0)
1208             offset = off;
1209         }
1210
1211       /* There wasn't an loclists_base, if the Dwarf does have a
1212          .debug_loclists section, then it might be we need the
1213          base after the first header. */
1214       Elf_Data *data = cu->dbg->sectiondata[IDX_debug_loclists];
1215       if (offset == 0 && data != NULL)
1216         {
1217           Dwarf *dbg = cu->dbg;
1218           const unsigned char *readp = data->d_buf;
1219           const unsigned char *const dataend
1220             = (unsigned char *) data->d_buf + data->d_size;
1221
1222           uint64_t unit_length = read_4ubyte_unaligned_inc (dbg, readp);
1223           unsigned int offset_size = 4;
1224           if (unlikely (unit_length == 0xffffffff))
1225             {
1226               if (unlikely (readp > dataend - 8))
1227                 goto no_header;
1228
1229               unit_length = read_8ubyte_unaligned_inc (dbg, readp);
1230               offset_size = 8;
1231             }
1232
1233           if (readp > dataend - 8
1234               || unit_length < 8
1235               || unit_length > (uint64_t) (dataend - readp))
1236             goto no_header;
1237
1238           uint16_t version = read_2ubyte_unaligned_inc (dbg, readp);
1239           if (version != 5)
1240             goto no_header;
1241
1242           uint8_t address_size = *readp++;
1243           if (address_size != 4 && address_size != 8)
1244             goto no_header;
1245
1246           uint8_t segment_size = *readp++;
1247           if (segment_size != 0)
1248             goto no_header;
1249
1250           uint32_t offset_entry_count;
1251           offset_entry_count = read_4ubyte_unaligned_inc (dbg, readp);
1252
1253           const unsigned char *offset_array_start = readp;
1254           if (offset_entry_count <= 0)
1255             goto no_header;
1256
1257           uint64_t needed = offset_entry_count * offset_size;
1258           if (unit_length - 8 < needed)
1259             goto no_header;
1260
1261           offset = (Dwarf_Off) (offset_array_start
1262                                 - (unsigned char *) data->d_buf);
1263         }
1264
1265     no_header:
1266       cu->locs_base = offset;
1267     }
1268
1269   return cu->locs_base;
1270 }
1271
1272 /* Helper function for tsearch/tfind split_tree Dwarf.  */
1273 int __libdw_finddbg_cb (const void *arg1, const void *arg2);
1274
1275 /* Link skeleton and split compile units.  */
1276 static inline void
1277 __libdw_link_skel_split (Dwarf_CU *skel, Dwarf_CU *split)
1278 {
1279   skel->split = split;
1280   split->split = skel;
1281
1282   /* Get .debug_addr and addr_base greedy.
1283      We also need it for the fake addr cu.
1284      There is only one per split debug.  */
1285   Dwarf *dbg = skel->dbg;
1286   Dwarf *sdbg = split->dbg;
1287   if (sdbg->sectiondata[IDX_debug_addr] == NULL
1288       && dbg->sectiondata[IDX_debug_addr] != NULL)
1289     {
1290       sdbg->sectiondata[IDX_debug_addr]
1291         = dbg->sectiondata[IDX_debug_addr];
1292       split->addr_base = __libdw_cu_addr_base (skel);
1293       sdbg->fake_addr_cu = dbg->fake_addr_cu;
1294     }
1295 }
1296
1297
1298 /* Given an address index for a CU return the address.
1299    Returns -1 and sets libdw_errno if an error occurs.  */
1300 int __libdw_addrx (Dwarf_CU *cu, Dwarf_Word idx, Dwarf_Addr *addr);
1301
1302
1303 /* Helper function to set debugdir field in Dwarf, used from dwarf_begin_elf
1304    and libdwfl process_file.  */
1305 char * __libdw_debugdir (int fd);
1306
1307
1308 /* Given the directory of a debug file, an absolute or relative dir
1309    to look in, and file returns a full path.
1310
1311    If the file is absolute (starts with a /) a copy of file is returned.
1312    the file isn't absolute, but dir is absolute, then a path that is
1313    the concatenation of dir and file is returned.  If neither file,
1314    nor dir is absolute, the path will be constructed using dir (if not
1315    NULL) and file relative to the debugdir (if valid).
1316
1317    The debugdir and the dir may be NULL (in which case they aren't used).
1318    If file is NULL, or no full path can be constructed NULL is returned.
1319
1320    The caller is responsible for freeing the result if not NULL.  */
1321 char * __libdw_filepath (const char *debugdir, const char *dir,
1322                          const char *file)
1323   internal_function;
1324
1325
1326 /* Aliases to avoid PLTs.  */
1327 INTDECL (dwarf_aggregate_size)
1328 INTDECL (dwarf_attr)
1329 INTDECL (dwarf_attr_integrate)
1330 INTDECL (dwarf_begin)
1331 INTDECL (dwarf_begin_elf)
1332 INTDECL (dwarf_child)
1333 INTDECL (dwarf_default_lower_bound)
1334 INTDECL (dwarf_dieoffset)
1335 INTDECL (dwarf_diename)
1336 INTDECL (dwarf_end)
1337 INTDECL (dwarf_entrypc)
1338 INTDECL (dwarf_errmsg)
1339 INTDECL (dwarf_formaddr)
1340 INTDECL (dwarf_formblock)
1341 INTDECL (dwarf_formref_die)
1342 INTDECL (dwarf_formsdata)
1343 INTDECL (dwarf_formstring)
1344 INTDECL (dwarf_formudata)
1345 INTDECL (dwarf_getabbrevattr_data)
1346 INTDECL (dwarf_getalt)
1347 INTDECL (dwarf_getarange_addr)
1348 INTDECL (dwarf_getarangeinfo)
1349 INTDECL (dwarf_getaranges)
1350 INTDECL (dwarf_getlocation_die)
1351 INTDECL (dwarf_getsrcfiles)
1352 INTDECL (dwarf_getsrclines)
1353 INTDECL (dwarf_hasattr)
1354 INTDECL (dwarf_haschildren)
1355 INTDECL (dwarf_haspc)
1356 INTDECL (dwarf_highpc)
1357 INTDECL (dwarf_lowpc)
1358 INTDECL (dwarf_nextcu)
1359 INTDECL (dwarf_next_unit)
1360 INTDECL (dwarf_offdie)
1361 INTDECL (dwarf_peel_type)
1362 INTDECL (dwarf_ranges)
1363 INTDECL (dwarf_setalt)
1364 INTDECL (dwarf_siblingof)
1365 INTDECL (dwarf_srclang)
1366 INTDECL (dwarf_tag)
1367
1368 #endif  /* libdwP.h */