libdw/libdwP.h

   1 /* Internal definitions for libdwarf.
   2    Copyright (C) 2002-2011, 2013, 2014 Red Hat, Inc.
   3    This file is part of elfutils.
   4    Written by Ulrich Drepper <drepper@redhat.com>, 2002.
   5
   6    This file is free software; you can redistribute it and/or modify
   7    it under the terms of either
   8
   9      * the GNU Lesser General Public License as published by the Free
  10        Software Foundation; either version 3 of the License, or (at
  11        your option) any later version
  12
  13    or
  14
  15      * the GNU General Public License as published by the Free
  16        Software Foundation; either version 2 of the License, or (at
  17        your option) any later version
  18
  19    or both in parallel, as here.
  20
  21    elfutils is distributed in the hope that it will be useful, but
  22    WITHOUT ANY WARRANTY; without even the implied warranty of
  23    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  24    General Public License for more details.
  25
  26    You should have received copies of the GNU General Public License and
  27    the GNU Lesser General Public License along with this program.  If
  28    not, see <http://www.gnu.org/licenses/>.  */
  29
  30 #ifndef _LIBDWP_H
  31 #define _LIBDWP_H 1
  32
  33 #include <libintl.h>
  34 #include <stdbool.h>
  35
  36 #include <libdw.h>
  37 #include <dwarf.h>
  38
  39
  40 /* gettext helper macros.  */
  41 #define _(Str) dgettext ("elfutils", Str)
  42
  43
  44 /* Known location expressions already decoded.  */
  45 struct loc_s
  46 {
  47   void *addr;
  48   Dwarf_Op *loc;
  49   size_t nloc;
  50 };
  51
  52 /* Known DW_OP_implicit_value blocks already decoded.
  53    This overlaps struct loc_s exactly, but only the
  54    first member really has to match.  */
  55 struct loc_block_s
  56 {
  57   void *addr;
  58   unsigned char *data;
  59   size_t length;
  60 };
  61
  62 /* Valid indeces for the section data.  */
  63 enum
  64   {
  65     IDX_debug_info = 0,
  66     IDX_debug_types,
  67     IDX_debug_abbrev,
  68     IDX_debug_aranges,
  69     IDX_debug_line,
  70     IDX_debug_frame,
  71     IDX_debug_loc,
  72     IDX_debug_pubnames,
  73     IDX_debug_str,
  74     IDX_debug_macinfo,
  75     IDX_debug_macro,
  76     IDX_debug_ranges,
  77     IDX_gnu_debugaltlink,
  78     IDX_last
  79   };
  80
  81
  82 /* Error values.  */
  83 enum
  84 {
  85   DWARF_E_NOERROR = 0,
  86   DWARF_E_UNKNOWN_ERROR,
  87   DWARF_E_INVALID_ACCESS,
  88   DWARF_E_NO_REGFILE,
  89   DWARF_E_IO_ERROR,
  90   DWARF_E_INVALID_ELF,
  91   DWARF_E_NO_DWARF,
  92   DWARF_E_NOELF,
  93   DWARF_E_GETEHDR_ERROR,
  94   DWARF_E_NOMEM,
  95   DWARF_E_UNIMPL,
  96   DWARF_E_INVALID_CMD,
  97   DWARF_E_INVALID_VERSION,
  98   DWARF_E_INVALID_FILE,
  99   DWARF_E_NO_ENTRY,
 100   DWARF_E_INVALID_DWARF,
 101   DWARF_E_NO_STRING,
 102   DWARF_E_NO_ADDR,
 103   DWARF_E_NO_CONSTANT,
 104   DWARF_E_NO_REFERENCE,
 105   DWARF_E_INVALID_REFERENCE,
 106   DWARF_E_NO_DEBUG_LINE,
 107   DWARF_E_INVALID_DEBUG_LINE,
 108   DWARF_E_TOO_BIG,
 109   DWARF_E_VERSION,
 110   DWARF_E_INVALID_DIR_IDX,
 111   DWARF_E_ADDR_OUTOFRANGE,
 112   DWARF_E_NO_LOCLIST,
 113   DWARF_E_NO_BLOCK,
 114   DWARF_E_INVALID_LINE_IDX,
 115   DWARF_E_INVALID_ARANGE_IDX,
 116   DWARF_E_NO_MATCH,
 117   DWARF_E_NO_FLAG,
 118   DWARF_E_INVALID_OFFSET,
 119   DWARF_E_NO_DEBUG_RANGES,
 120   DWARF_E_INVALID_CFI,
 121   DWARF_E_NO_ALT_DEBUGLINK
 122 };
 123
 124
 125 #include "dwarf_sig8_hash.h"
 126
 127 /* This is the structure representing the debugging state.  */
 128 struct Dwarf
 129 {
 130   /* The underlying ELF file.  */
 131   Elf *elf;
 132
 133   /* dwz alternate DWARF file.  */
 134   Dwarf *alt_dwarf;
 135
 136   /* The section data.  */
 137   Elf_Data *sectiondata[IDX_last];
 138
 139 #if USE_ZLIB
 140   /* The 1 << N bit is set if sectiondata[N] is malloc'd decompressed data.  */
 141   unsigned int sectiondata_gzip_mask:IDX_last;
 142 #endif
 143
 144   /* True if the file has a byte order different from the host.  */
 145   bool other_byte_order;
 146
 147   /* If true, we allocated the ELF descriptor ourselves.  */
 148   bool free_elf;
 149
 150   /* Information for traversing the .debug_pubnames section.  This is
 151      an array and separately allocated with malloc.  */
 152   struct pubnames_s
 153   {
 154     Dwarf_Off cu_offset;
 155     Dwarf_Off set_start;
 156     unsigned int cu_header_size;
 157     int address_len;
 158   } *pubnames_sets;
 159   size_t pubnames_nsets;
 160
 161   /* Search tree for the CUs.  */
 162   void *cu_tree;
 163   Dwarf_Off next_cu_offset;
 164
 165   /* Search tree and sig8 hash table for .debug_types type units.  */
 166   void *tu_tree;
 167   Dwarf_Off next_tu_offset;
 168   Dwarf_Sig8_Hash sig8_hash;
 169
 170   /* Address ranges.  */
 171   Dwarf_Aranges *aranges;
 172
 173   /* Cached info from the CFI section.  */
 174   struct Dwarf_CFI_s *cfi;
 175
 176   /* Internal memory handling.  This is basically a simplified
 177      reimplementation of obstacks.  Unfortunately the standard obstack
 178      implementation is not usable in libraries.  */
 179   struct libdw_memblock
 180   {
 181     size_t size;
 182     size_t remaining;
 183     struct libdw_memblock *prev;
 184     char mem[0];
 185   } *mem_tail;
 186
 187   /* Default size of allocated memory blocks.  */
 188   size_t mem_default_size;
 189
 190   /* Registered OOM handler.  */
 191   Dwarf_OOM oom_handler;
 192 };
 193
 194
 195 /* Abbreviation representation.  */
 196 struct Dwarf_Abbrev
 197 {
 198   Dwarf_Off offset;
 199   unsigned char *attrp;
 200   unsigned int attrcnt;
 201   unsigned int code;
 202   unsigned int tag;
 203   bool has_children;
 204 };
 205
 206 #include "dwarf_abbrev_hash.h"
 207
 208
 209 /* Files in line information records.  */
 210 struct Dwarf_Files_s
 211   {
 212     unsigned int ndirs;
 213     unsigned int nfiles;
 214     struct Dwarf_Fileinfo_s
 215     {
 216       char *name;
 217       Dwarf_Word mtime;
 218       Dwarf_Word length;
 219     } info[0];
 220     /* nfiles of those, followed by char *[ndirs].  */
 221   };
 222 typedef struct Dwarf_Fileinfo_s Dwarf_Fileinfo;
 223
 224
 225 /* Representation of a row in the line table.  */
 226
 227 struct Dwarf_Line_s
 228 {
 229   Dwarf_Files *files;
 230
 231   Dwarf_Addr addr;
 232   unsigned int file;
 233   int line;
 234   unsigned short int column;
 235   unsigned int is_stmt:1;
 236   unsigned int basic_block:1;
 237   unsigned int end_sequence:1;
 238   unsigned int prologue_end:1;
 239   unsigned int epilogue_begin:1;
 240   /* The remaining bit fields are not flags, but hold values presumed to be
 241      small.  All the flags and other bit fields should add up to 48 bits
 242      to give the whole struct a nice round size.  */
 243   unsigned int op_index:8;
 244   unsigned int isa:8;
 245   unsigned int discriminator:24;
 246 };
 247
 248 struct Dwarf_Lines_s
 249 {
 250   size_t nlines;
 251   struct Dwarf_Line_s info[0];
 252 };
 253
 254 /* Representation of address ranges.  */
 255 struct Dwarf_Aranges_s
 256 {
 257   Dwarf *dbg;
 258   size_t naranges;
 259
 260   struct Dwarf_Arange_s
 261   {
 262     Dwarf_Addr addr;
 263     Dwarf_Word length;
 264     Dwarf_Off offset;
 265   } info[0];
 266 };
 267
 268
 269 /* CU representation.  */
 270 struct Dwarf_CU
 271 {
 272   Dwarf *dbg;
 273   Dwarf_Off start;
 274   Dwarf_Off end;
 275   uint8_t address_size;
 276   uint8_t offset_size;
 277   uint16_t version;
 278
 279   /* Zero if this is a normal CU.  Nonzero if it is a type unit.  */
 280   size_t type_offset;
 281   uint64_t type_sig8;
 282
 283   /* Hash table for the abbreviations.  */
 284   Dwarf_Abbrev_Hash abbrev_hash;
 285   /* Offset of the first abbreviation.  */
 286   size_t orig_abbrev_offset;
 287   /* Offset past last read abbreviation.  */
 288   size_t last_abbrev_offset;
 289
 290   /* The srcline information.  */
 291   Dwarf_Lines *lines;
 292
 293   /* The source file information.  */
 294   Dwarf_Files *files;
 295
 296   /* Known location lists.  */
 297   void *locs;
 298 };
 299
 300 /* Compute the offset of a CU's first DIE from its offset.  This
 301    is either:
 302         LEN       VER     OFFSET    ADDR
 303       4-bytes + 2-bytes + 4-bytes + 1-byte  for 32-bit dwarf
 304      12-bytes + 2-bytes + 8-bytes + 1-byte  for 64-bit dwarf
 305    or in .debug_types,                       SIGNATURE TYPE-OFFSET
 306       4-bytes + 2-bytes + 4-bytes + 1-byte + 8-bytes + 4-bytes  for 32-bit
 307      12-bytes + 2-bytes + 8-bytes + 1-byte + 8-bytes + 8-bytes  for 64-bit
 308
 309    Note the trick in the computation.  If the offset_size is 4
 310    the '- 4' term changes the '3 *' into a '2 *'.  If the
 311    offset_size is 8 it accounts for the 4-byte escape value
 312    used at the start of the length.  */
 313 #define DIE_OFFSET_FROM_CU_OFFSET(cu_offset, offset_size, type_unit)    \
 314   ((type_unit) ? ((cu_offset) + 4 * (offset_size) - 4 + 3 + 8)          \
 315    : ((cu_offset) + 3 * (offset_size) - 4 + 3))
 316
 317 #define CUDIE(fromcu)                                                         \
 318   ((Dwarf_Die)                                                                \
 319    {                                                                          \
 320      .cu = (fromcu),                                                          \
 321      .addr = ((char *) cu_data (fromcu)->d_buf                                \
 322               + DIE_OFFSET_FROM_CU_OFFSET ((fromcu)->start,                   \
 323                                            (fromcu)->offset_size,             \
 324                                            (fromcu)->type_offset != 0))       \
 325    })                                                                         \
 326
 327
 328 /* Macro information.  */
 329 struct Dwarf_Macro_s
 330 {
 331   unsigned int opcode;
 332   Dwarf_Word param1;
 333   union
 334   {
 335     Dwarf_Word u;
 336     const char *s;
 337   } param2;
 338 };
 339
 340
 341 /* We have to include the file at this point because the inline
 342    functions access internals of the Dwarf structure.  */
 343 #include "memory-access.h"
 344
 345
 346 /* Set error value.  */
 347 extern void __libdw_seterrno (int value) internal_function;
 348
 349
 350 /* Memory handling, the easy parts.  This macro does not do any locking.  */
 351 #define libdw_alloc(dbg, type, tsize, cnt) \
 352   ({ struct libdw_memblock *_tail = (dbg)->mem_tail;                          \
 353      size_t _required = (tsize) * (cnt);                                      \
 354      type *_result = (type *) (_tail->mem + (_tail->size - _tail->remaining));\
 355      size_t _padding = ((__alignof (type)                                     \
 356                          - ((uintptr_t) _result & (__alignof (type) - 1)))    \
 357                         & (__alignof (type) - 1));                            \
 358      if (unlikely (_tail->remaining < _required + _padding))                  \
 359        _result = (type *) __libdw_allocate (dbg, _required, __alignof (type));\
 360      else                                                                     \
 361        {                                                                      \
 362          _required += _padding;                                               \
 363          _result = (type *) ((char *) _result + _padding);                    \
 364          _tail->remaining -= _required;                                       \
 365        }                                                                      \
 366      _result; })
 367
 368 #define libdw_typed_alloc(dbg, type) \
 369   libdw_alloc (dbg, type, sizeof (type), 1)
 370
 371 /* Callback to allocate more.  */
 372 extern void *__libdw_allocate (Dwarf *dbg, size_t minsize, size_t align)
 373      __attribute__ ((__malloc__)) __nonnull_attribute__ (1);
 374
 375 /* Default OOM handler.  */
 376 extern void __libdw_oom (void) __attribute ((noreturn, visibility ("hidden")));
 377
 378 #if USE_ZLIB
 379 extern void __libdw_free_zdata (Dwarf *dwarf) internal_function;
 380 #else
 381 # define __libdw_free_zdata(dwarf)      ((void) (dwarf))
 382 #endif
 383
 384 /* Allocate the internal data for a unit not seen before.  */
 385 extern struct Dwarf_CU *__libdw_intern_next_unit (Dwarf *dbg, bool debug_types)
 386      __nonnull_attribute__ (1) internal_function;
 387
 388 /* Find CU for given offset.  */
 389 extern struct Dwarf_CU *__libdw_findcu (Dwarf *dbg, Dwarf_Off offset, bool tu)
 390      __nonnull_attribute__ (1) internal_function;
 391
 392 /* Return tag of given DIE.  */
 393 extern Dwarf_Abbrev *__libdw_findabbrev (struct Dwarf_CU *cu,
 394                                          unsigned int code)
 395      __nonnull_attribute__ (1) internal_function;
 396
 397 /* Get abbreviation at given offset.  */
 398 extern Dwarf_Abbrev *__libdw_getabbrev (Dwarf *dbg, struct Dwarf_CU *cu,
 399                                         Dwarf_Off offset, size_t *lengthp,
 400                                         Dwarf_Abbrev *result)
 401      __nonnull_attribute__ (1) internal_function;
 402
 403 /* Helper functions for form handling.  */
 404 extern size_t __libdw_form_val_compute_len (Dwarf *dbg, struct Dwarf_CU *cu,
 405                                             unsigned int form,
 406                                             const unsigned char *valp)
 407      __nonnull_attribute__ (1, 2, 4) internal_function;
 408
 409 /* Find the length of a form attribute.  */
 410 static inline size_t
 411 __nonnull_attribute__ (1, 2, 4)
 412 __libdw_form_val_len (Dwarf *dbg, struct Dwarf_CU *cu,
 413                       unsigned int form, const unsigned char *valp)
 414 {
 415   /* Small lookup table of forms with fixed lengths.  Absent indexes are
 416      initialized 0, so any truly desired 0 is set to 0x80 and masked.  */
 417   static const uint8_t form_lengths[] =
 418     {
 419       [DW_FORM_flag_present] = 0x80,
 420       [DW_FORM_data1] = 1, [DW_FORM_ref1] = 1, [DW_FORM_flag] = 1,
 421       [DW_FORM_data2] = 2, [DW_FORM_ref2] = 2,
 422       [DW_FORM_data4] = 4, [DW_FORM_ref4] = 4,
 423       [DW_FORM_data8] = 8, [DW_FORM_ref8] = 8, [DW_FORM_ref_sig8] = 8,
 424     };
 425
 426   /* Return immediately for forms with fixed lengths.  */
 427   if (form < sizeof form_lengths / sizeof form_lengths[0])
 428     {
 429       uint8_t len = form_lengths[form];
 430       if (len != 0)
 431         return len & 0x7f; /* Mask to allow 0x80 -> 0.  */
 432     }
 433
 434   /* Other forms require some computation.  */
 435   return __libdw_form_val_compute_len (dbg, cu, form, valp);
 436 }
 437
 438 /* Helper function for DW_FORM_ref* handling.  */
 439 extern int __libdw_formref (Dwarf_Attribute *attr, Dwarf_Off *return_offset)
 440      __nonnull_attribute__ (1, 2) internal_function;
 441
 442
 443 /* Helper function to locate attribute.  */
 444 extern unsigned char *__libdw_find_attr (Dwarf_Die *die,
 445                                          unsigned int search_name,
 446                                          unsigned int *codep,
 447                                          unsigned int *formp)
 448      __nonnull_attribute__ (1) internal_function;
 449
 450 /* Helper function to access integer attribute.  */
 451 extern int __libdw_attr_intval (Dwarf_Die *die, int *valp, int attval)
 452      __nonnull_attribute__ (1, 2) internal_function;
 453
 454 /* Helper function to walk scopes.  */
 455 struct Dwarf_Die_Chain
 456 {
 457   Dwarf_Die die;
 458   struct Dwarf_Die_Chain *parent;
 459   bool prune;                   /* The PREVISIT function can set this.  */
 460 };
 461 extern int __libdw_visit_scopes (unsigned int depth,
 462                                  struct Dwarf_Die_Chain *root,
 463                                  int (*previsit) (unsigned int depth,
 464                                                   struct Dwarf_Die_Chain *,
 465                                                   void *arg),
 466                                  int (*postvisit) (unsigned int depth,
 467                                                    struct Dwarf_Die_Chain *,
 468                                                    void *arg),
 469                                  void *arg)
 470   __nonnull_attribute__ (2, 3) internal_function;
 471
 472 /* Parse a DWARF Dwarf_Block into an array of Dwarf_Op's,
 473    and cache the result (via tsearch).  */
 474 extern int __libdw_intern_expression (Dwarf *dbg,
 475                                       bool other_byte_order,
 476                                       unsigned int address_size,
 477                                       unsigned int ref_size,
 478                                       void **cache, const Dwarf_Block *block,
 479                                       bool cfap, bool valuep,
 480                                       Dwarf_Op **llbuf, size_t *listlen,
 481                                       int sec_index)
 482   __nonnull_attribute__ (5, 6, 9, 10) internal_function;
 483
 484 extern Dwarf_Die *__libdw_offdie (Dwarf *dbg, Dwarf_Off offset,
 485                                   Dwarf_Die *result, bool debug_types)
 486   internal_function;
 487
 488
 489 /* Return error code of last failing function call.  This value is kept
 490    separately for each thread.  */
 491 extern int __dwarf_errno_internal (void);
 492
 493
 494 /* Reader hooks.  */
 495
 496 /* Relocation hooks return -1 on error (in that case the error code
 497    must already have been set), 0 if there is no relocation and 1 if a
 498    relocation was present.*/
 499
 500 static inline int
 501 __libdw_relocate_address (Dwarf *dbg __attribute__ ((unused)),
 502                           int sec_index __attribute__ ((unused)),
 503                           const void *addr __attribute__ ((unused)),
 504                           int width __attribute__ ((unused)),
 505                           Dwarf_Addr *val __attribute__ ((unused)))
 506 {
 507   return 0;
 508 }
 509
 510 static inline int
 511 __libdw_relocate_offset (Dwarf *dbg __attribute__ ((unused)),
 512                          int sec_index __attribute__ ((unused)),
 513                          const void *addr __attribute__ ((unused)),
 514                          int width __attribute__ ((unused)),
 515                          Dwarf_Off *val __attribute__ ((unused)))
 516 {
 517   return 0;
 518 }
 519
 520 static inline Elf_Data *
 521 __libdw_checked_get_data (Dwarf *dbg, int sec_index)
 522 {
 523   Elf_Data *data = dbg->sectiondata[sec_index];
 524   if (unlikely (data == NULL)
 525       || unlikely (data->d_buf == NULL))
 526     {
 527       __libdw_seterrno (DWARF_E_INVALID_DWARF);
 528       return NULL;
 529     }
 530   return data;
 531 }
 532
 533 static inline int
 534 __libdw_offset_in_section (Dwarf *dbg, int sec_index,
 535                            Dwarf_Off offset, size_t size)
 536 {
 537   Elf_Data *data = __libdw_checked_get_data (dbg, sec_index);
 538   if (data == NULL)
 539     return -1;
 540   if (unlikely (offset > data->d_size)
 541       || unlikely (data->d_size - offset < size))
 542     {
 543       __libdw_seterrno (DWARF_E_INVALID_OFFSET);
 544       return -1;
 545     }
 546
 547   return 0;
 548 }
 549
 550 static inline bool
 551 __libdw_in_section (Dwarf *dbg, int sec_index,
 552                     const void *addr, size_t size)
 553 {
 554   Elf_Data *data = __libdw_checked_get_data (dbg, sec_index);
 555   if (data == NULL)
 556     return false;
 557   if (unlikely (addr < data->d_buf)
 558       || unlikely (data->d_size - (addr - data->d_buf) < size))
 559     {
 560       __libdw_seterrno (DWARF_E_INVALID_OFFSET);
 561       return false;
 562     }
 563
 564   return true;
 565 }
 566
 567 #define READ_AND_RELOCATE(RELOC_HOOK, VAL)                              \
 568   ({                                                                    \
 569     if (!__libdw_in_section (dbg, sec_index, addr, width))              \
 570       return -1;                                                        \
 571                                                                         \
 572     const unsigned char *orig_addr = addr;                              \
 573     if (width == 4)                                                     \
 574       VAL = read_4ubyte_unaligned_inc (dbg, addr);                      \
 575     else                                                                \
 576       VAL = read_8ubyte_unaligned_inc (dbg, addr);                      \
 577                                                                         \
 578     int status = RELOC_HOOK (dbg, sec_index, orig_addr, width, &VAL);   \
 579     if (status < 0)                                                     \
 580       return status;                                                    \
 581     status > 0;                                                         \
 582    })
 583
 584 static inline int
 585 __libdw_read_address_inc (Dwarf *dbg,
 586                           int sec_index, const unsigned char **addrp,
 587                           int width, Dwarf_Addr *ret)
 588 {
 589   const unsigned char *addr = *addrp;
 590   READ_AND_RELOCATE (__libdw_relocate_address, (*ret));
 591   *addrp = addr;
 592   return 0;
 593 }
 594
 595 static inline int
 596 __libdw_read_address (Dwarf *dbg,
 597                       int sec_index, const unsigned char *addr,
 598                       int width, Dwarf_Addr *ret)
 599 {
 600   READ_AND_RELOCATE (__libdw_relocate_address, (*ret));
 601   return 0;
 602 }
 603
 604 static inline int
 605 __libdw_read_offset_inc (Dwarf *dbg,
 606                          int sec_index, const unsigned char **addrp,
 607                          int width, Dwarf_Off *ret, int sec_ret,
 608                          size_t size)
 609 {
 610   const unsigned char *addr = *addrp;
 611   READ_AND_RELOCATE (__libdw_relocate_offset, (*ret));
 612   *addrp = addr;
 613   return __libdw_offset_in_section (dbg, sec_ret, *ret, size);
 614 }
 615
 616 static inline int
 617 __libdw_read_offset (Dwarf *dbg, Dwarf *dbg_ret,
 618                      int sec_index, const unsigned char *addr,
 619                      int width, Dwarf_Off *ret, int sec_ret,
 620                      size_t size)
 621 {
 622   READ_AND_RELOCATE (__libdw_relocate_offset, (*ret));
 623   return __libdw_offset_in_section (dbg_ret, sec_ret, *ret, size);
 624 }
 625
 626 static inline size_t
 627 cu_sec_idx (struct Dwarf_CU *cu)
 628 {
 629   return cu->type_offset == 0 ? IDX_debug_info : IDX_debug_types;
 630 }
 631
 632 static inline Elf_Data *
 633 cu_data (struct Dwarf_CU *cu)
 634 {
 635   return cu->dbg->sectiondata[cu_sec_idx (cu)];
 636 }
 637
 638 /* Read up begin/end pair and increment read pointer.
 639     - If it's normal range record, set up *BEGINP and *ENDP and return 0.
 640     - If it's base address selection record, set up *BASEP and return 1.
 641     - If it's end of rangelist, don't set anything and return 2
 642     - If an error occurs, don't set anything and return <0.  */
 643 int __libdw_read_begin_end_pair_inc (Dwarf *dbg, int sec_index,
 644                                      unsigned char **addr, int width,
 645                                      Dwarf_Addr *beginp, Dwarf_Addr *endp,
 646                                      Dwarf_Addr *basep)
 647   internal_function;
 648
 649 unsigned char * __libdw_formptr (Dwarf_Attribute *attr, int sec_index,
 650                                  int err_nodata, unsigned char **endpp,
 651                                  Dwarf_Off *offsetp)
 652   internal_function;
 653
 654 /* Fills in the given attribute to point at an empty location expression.  */
 655 void __libdw_empty_loc_attr (Dwarf_Attribute *attr, struct Dwarf_CU *cu)
 656   internal_function;
 657
 658
 659 /* Aliases to avoid PLTs.  */
 660 INTDECL (dwarf_aggregate_size)
 661 INTDECL (dwarf_attr)
 662 INTDECL (dwarf_attr_integrate)
 663 INTDECL (dwarf_begin)
 664 INTDECL (dwarf_begin_elf)
 665 INTDECL (dwarf_child)
 666 INTDECL (dwarf_dieoffset)
 667 INTDECL (dwarf_diename)
 668 INTDECL (dwarf_end)
 669 INTDECL (dwarf_entrypc)
 670 INTDECL (dwarf_errmsg)
 671 INTDECL (dwarf_formaddr)
 672 INTDECL (dwarf_formblock)
 673 INTDECL (dwarf_formref_die)
 674 INTDECL (dwarf_formsdata)
 675 INTDECL (dwarf_formstring)
 676 INTDECL (dwarf_formudata)
 677 INTDECL (dwarf_getalt)
 678 INTDECL (dwarf_getarange_addr)
 679 INTDECL (dwarf_getarangeinfo)
 680 INTDECL (dwarf_getaranges)
 681 INTDECL (dwarf_getlocation_die)
 682 INTDECL (dwarf_getsrcfiles)
 683 INTDECL (dwarf_getsrclines)
 684 INTDECL (dwarf_hasattr)
 685 INTDECL (dwarf_haschildren)
 686 INTDECL (dwarf_haspc)
 687 INTDECL (dwarf_highpc)
 688 INTDECL (dwarf_lowpc)
 689 INTDECL (dwarf_nextcu)
 690 INTDECL (dwarf_next_unit)
 691 INTDECL (dwarf_offdie)
 692 INTDECL (dwarf_peel_type)
 693 INTDECL (dwarf_ranges)
 694 INTDECL (dwarf_setalt)
 695 INTDECL (dwarf_siblingof)
 696 INTDECL (dwarf_srclang)
 697 INTDECL (dwarf_tag)
 698
 699 #endif  /* libdwP.h */