libdw/libdwP.h

   1 /* Internal definitions for libdwarf.
   2    Copyright (C) 2002-2011, 2013-2015 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 /* Already decoded .debug_line units.  */
  63 struct files_lines_s
  64 {
  65   Dwarf_Off debug_line_offset;
  66   Dwarf_Files *files;
  67   Dwarf_Lines *lines;
  68 };
  69
  70 /* Valid indeces for the section data.  */
  71 enum
  72   {
  73     IDX_debug_info = 0,
  74     IDX_debug_types,
  75     IDX_debug_abbrev,
  76     IDX_debug_aranges,
  77     IDX_debug_line,
  78     IDX_debug_frame,
  79     IDX_debug_loc,
  80     IDX_debug_pubnames,
  81     IDX_debug_str,
  82     IDX_debug_macinfo,
  83     IDX_debug_macro,
  84     IDX_debug_ranges,
  85     IDX_gnu_debugaltlink,
  86     IDX_last
  87   };
  88
  89
  90 /* Error values.  */
  91 enum
  92 {
  93   DWARF_E_NOERROR = 0,
  94   DWARF_E_UNKNOWN_ERROR,
  95   DWARF_E_INVALID_ACCESS,
  96   DWARF_E_NO_REGFILE,
  97   DWARF_E_IO_ERROR,
  98   DWARF_E_INVALID_ELF,
  99   DWARF_E_NO_DWARF,
 100   DWARF_E_COMPRESSED_ERROR,
 101   DWARF_E_NOELF,
 102   DWARF_E_GETEHDR_ERROR,
 103   DWARF_E_NOMEM,
 104   DWARF_E_UNIMPL,
 105   DWARF_E_INVALID_CMD,
 106   DWARF_E_INVALID_VERSION,
 107   DWARF_E_INVALID_FILE,
 108   DWARF_E_NO_ENTRY,
 109   DWARF_E_INVALID_DWARF,
 110   DWARF_E_NO_STRING,
 111   DWARF_E_NO_ADDR,
 112   DWARF_E_NO_CONSTANT,
 113   DWARF_E_NO_REFERENCE,
 114   DWARF_E_INVALID_REFERENCE,
 115   DWARF_E_NO_DEBUG_LINE,
 116   DWARF_E_INVALID_DEBUG_LINE,
 117   DWARF_E_TOO_BIG,
 118   DWARF_E_VERSION,
 119   DWARF_E_INVALID_DIR_IDX,
 120   DWARF_E_ADDR_OUTOFRANGE,
 121   DWARF_E_NO_LOCLIST,
 122   DWARF_E_NO_BLOCK,
 123   DWARF_E_INVALID_LINE_IDX,
 124   DWARF_E_INVALID_ARANGE_IDX,
 125   DWARF_E_NO_MATCH,
 126   DWARF_E_NO_FLAG,
 127   DWARF_E_INVALID_OFFSET,
 128   DWARF_E_NO_DEBUG_RANGES,
 129   DWARF_E_INVALID_CFI,
 130   DWARF_E_NO_ALT_DEBUGLINK,
 131   DWARF_E_INVALID_OPCODE,
 132   DWARF_E_NOT_CUDIE,
 133 };
 134
 135
 136 #include "dwarf_sig8_hash.h"
 137
 138 /* This is the structure representing the debugging state.  */
 139 struct Dwarf
 140 {
 141   /* The underlying ELF file.  */
 142   Elf *elf;
 143
 144   /* dwz alternate DWARF file.  */
 145   Dwarf *alt_dwarf;
 146
 147   /* The section data.  */
 148   Elf_Data *sectiondata[IDX_last];
 149
 150   /* True if the file has a byte order different from the host.  */
 151   bool other_byte_order;
 152
 153   /* If true, we allocated the ELF descriptor ourselves.  */
 154   bool free_elf;
 155
 156   /* Information for traversing the .debug_pubnames section.  This is
 157      an array and separately allocated with malloc.  */
 158   struct pubnames_s
 159   {
 160     Dwarf_Off cu_offset;
 161     Dwarf_Off set_start;
 162     unsigned int cu_header_size;
 163     int address_len;
 164   } *pubnames_sets;
 165   size_t pubnames_nsets;
 166
 167   /* Search tree for the CUs.  */
 168   void *cu_tree;
 169   Dwarf_Off next_cu_offset;
 170
 171   /* Search tree and sig8 hash table for .debug_types type units.  */
 172   void *tu_tree;
 173   Dwarf_Off next_tu_offset;
 174   Dwarf_Sig8_Hash sig8_hash;
 175
 176   /* Search tree for .debug_macro operator tables.  */
 177   void *macro_ops;
 178
 179   /* Search tree for decoded .debug_line units.  */
 180   void *files_lines;
 181
 182   /* Address ranges.  */
 183   Dwarf_Aranges *aranges;
 184
 185   /* Cached info from the CFI section.  */
 186   struct Dwarf_CFI_s *cfi;
 187
 188   /* Fake loc CU.  Used when synthesizing attributes for Dwarf_Ops that
 189      came from a location list entry in dwarf_getlocation_attr.  */
 190   struct Dwarf_CU *fake_loc_cu;
 191
 192   /* Internal memory handling.  This is basically a simplified
 193      reimplementation of obstacks.  Unfortunately the standard obstack
 194      implementation is not usable in libraries.  */
 195   struct libdw_memblock
 196   {
 197     size_t size;
 198     size_t remaining;
 199     struct libdw_memblock *prev;
 200     char mem[0];
 201   } *mem_tail;
 202
 203   /* Default size of allocated memory blocks.  */
 204   size_t mem_default_size;
 205
 206   /* Registered OOM handler.  */
 207   Dwarf_OOM oom_handler;
 208 };
 209
 210
 211 /* Abbreviation representation.  */
 212 struct Dwarf_Abbrev
 213 {
 214   Dwarf_Off offset;
 215   unsigned char *attrp;
 216   unsigned int attrcnt;
 217   unsigned int code;
 218   unsigned int tag;
 219   bool has_children;
 220 };
 221
 222 #include "dwarf_abbrev_hash.h"
 223
 224
 225 /* Files in line information records.  */
 226 struct Dwarf_Files_s
 227   {
 228     unsigned int ndirs;
 229     unsigned int nfiles;
 230     struct Dwarf_Fileinfo_s
 231     {
 232       char *name;
 233       Dwarf_Word mtime;
 234       Dwarf_Word length;
 235     } info[0];
 236     /* nfiles of those, followed by char *[ndirs].  */
 237   };
 238 typedef struct Dwarf_Fileinfo_s Dwarf_Fileinfo;
 239
 240
 241 /* Representation of a row in the line table.  */
 242
 243 struct Dwarf_Line_s
 244 {
 245   Dwarf_Files *files;
 246
 247   Dwarf_Addr addr;
 248   unsigned int file;
 249   int line;
 250   unsigned short int column;
 251   unsigned int is_stmt:1;
 252   unsigned int basic_block:1;
 253   unsigned int end_sequence:1;
 254   unsigned int prologue_end:1;
 255   unsigned int epilogue_begin:1;
 256   /* The remaining bit fields are not flags, but hold values presumed to be
 257      small.  All the flags and other bit fields should add up to 48 bits
 258      to give the whole struct a nice round size.  */
 259   unsigned int op_index:8;
 260   unsigned int isa:8;
 261   unsigned int discriminator:24;
 262 };
 263
 264 struct Dwarf_Lines_s
 265 {
 266   size_t nlines;
 267   struct Dwarf_Line_s info[0];
 268 };
 269
 270 /* Representation of address ranges.  */
 271 struct Dwarf_Aranges_s
 272 {
 273   Dwarf *dbg;
 274   size_t naranges;
 275
 276   struct Dwarf_Arange_s
 277   {
 278     Dwarf_Addr addr;
 279     Dwarf_Word length;
 280     Dwarf_Off offset;
 281   } info[0];
 282 };
 283
 284
 285 /* CU representation.  */
 286 struct Dwarf_CU
 287 {
 288   Dwarf *dbg;
 289   Dwarf_Off start;
 290   Dwarf_Off end;
 291   uint8_t address_size;
 292   uint8_t offset_size;
 293   uint16_t version;
 294
 295   /* Zero if this is a normal CU.  Nonzero if it is a type unit.  */
 296   size_t type_offset;
 297   uint64_t type_sig8;
 298
 299   /* Hash table for the abbreviations.  */
 300   Dwarf_Abbrev_Hash abbrev_hash;
 301   /* Offset of the first abbreviation.  */
 302   size_t orig_abbrev_offset;
 303   /* Offset past last read abbreviation.  */
 304   size_t last_abbrev_offset;
 305
 306   /* The srcline information.  */
 307   Dwarf_Lines *lines;
 308
 309   /* The source file information.  */
 310   Dwarf_Files *files;
 311
 312   /* Known location lists.  */
 313   void *locs;
 314
 315   /* Memory boundaries of this CU.  */
 316   void *startp;
 317   void *endp;
 318 };
 319
 320 /* Compute the offset of a CU's first DIE from its offset.  This
 321    is either:
 322         LEN       VER     OFFSET    ADDR
 323       4-bytes + 2-bytes + 4-bytes + 1-byte  for 32-bit dwarf
 324      12-bytes + 2-bytes + 8-bytes + 1-byte  for 64-bit dwarf
 325    or in .debug_types,                       SIGNATURE TYPE-OFFSET
 326       4-bytes + 2-bytes + 4-bytes + 1-byte + 8-bytes + 4-bytes  for 32-bit
 327      12-bytes + 2-bytes + 8-bytes + 1-byte + 8-bytes + 8-bytes  for 64-bit
 328
 329    Note the trick in the computation.  If the offset_size is 4
 330    the '- 4' term changes the '3 *' into a '2 *'.  If the
 331    offset_size is 8 it accounts for the 4-byte escape value
 332    used at the start of the length.  */
 333 #define DIE_OFFSET_FROM_CU_OFFSET(cu_offset, offset_size, type_unit)    \
 334   ((type_unit) ? ((cu_offset) + 4 * (offset_size) - 4 + 3 + 8)          \
 335    : ((cu_offset) + 3 * (offset_size) - 4 + 3))
 336
 337 #define CUDIE(fromcu)                                                         \
 338   ((Dwarf_Die)                                                                \
 339    {                                                                          \
 340      .cu = (fromcu),                                                          \
 341      .addr = ((char *) fromcu->dbg->sectiondata[cu_sec_idx (fromcu)]->d_buf   \
 342               + DIE_OFFSET_FROM_CU_OFFSET ((fromcu)->start,                   \
 343                                            (fromcu)->offset_size,             \
 344                                            (fromcu)->type_offset != 0))       \
 345    })                                                                         \
 346
 347
 348 /* Prototype of a single .debug_macro operator.  */
 349 typedef struct
 350 {
 351   Dwarf_Word nforms;
 352   unsigned char const *forms;
 353 } Dwarf_Macro_Op_Proto;
 354
 355 /* Prototype table.  */
 356 typedef struct
 357 {
 358   /* Offset of .debug_macro section.  */
 359   Dwarf_Off offset;
 360
 361   /* Offset of associated .debug_line section.  */
 362   Dwarf_Off line_offset;
 363
 364   /* The source file information.  */
 365   Dwarf_Files *files;
 366
 367   /* If this macro unit was opened through dwarf_getmacros or
 368      dwarf_getmacros_die, this caches value of DW_AT_comp_dir, if
 369      present.  */
 370   const char *comp_dir;
 371
 372   /* Header length.  */
 373   Dwarf_Half header_len;
 374
 375   uint16_t version;
 376   bool is_64bit;
 377   uint8_t sec_index;    /* IDX_debug_macro or IDX_debug_macinfo.  */
 378
 379   /* Shows where in TABLE each opcode is defined.  Since opcode 0 is
 380      never used, it stores index of opcode X in X-1'th element.  The
 381      value of 0xff means not stored at all.  */
 382   unsigned char opcodes[255];
 383
 384   /* Individual opcode prototypes.  */
 385   Dwarf_Macro_Op_Proto table[];
 386 } Dwarf_Macro_Op_Table;
 387
 388 struct Dwarf_Macro_s
 389 {
 390   Dwarf_Macro_Op_Table *table;
 391   Dwarf_Attribute *attributes;
 392   uint8_t opcode;
 393 };
 394
 395 static inline Dwarf_Word
 396 libdw_macro_nforms (Dwarf_Macro *macro)
 397 {
 398   return macro->table->table[macro->table->opcodes[macro->opcode - 1]].nforms;
 399 }
 400
 401 /* We have to include the file at this point because the inline
 402    functions access internals of the Dwarf structure.  */
 403 #include "memory-access.h"
 404
 405
 406 /* Set error value.  */
 407 extern void __libdw_seterrno (int value) internal_function;
 408
 409
 410 /* Memory handling, the easy parts.  This macro does not do any locking.  */
 411 #define libdw_alloc(dbg, type, tsize, cnt) \
 412   ({ struct libdw_memblock *_tail = (dbg)->mem_tail;                          \
 413      size_t _required = (tsize) * (cnt);                                      \
 414      type *_result = (type *) (_tail->mem + (_tail->size - _tail->remaining));\
 415      size_t _padding = ((__alignof (type)                                     \
 416                          - ((uintptr_t) _result & (__alignof (type) - 1)))    \
 417                         & (__alignof (type) - 1));                            \
 418      if (unlikely (_tail->remaining < _required + _padding))                  \
 419        _result = (type *) __libdw_allocate (dbg, _required, __alignof (type));\
 420      else                                                                     \
 421        {                                                                      \
 422          _required += _padding;                                               \
 423          _result = (type *) ((char *) _result + _padding);                    \
 424          _tail->remaining -= _required;                                       \
 425        }                                                                      \
 426      _result; })
 427
 428 #define libdw_typed_alloc(dbg, type) \
 429   libdw_alloc (dbg, type, sizeof (type), 1)
 430
 431 /* Callback to allocate more.  */
 432 extern void *__libdw_allocate (Dwarf *dbg, size_t minsize, size_t align)
 433      __attribute__ ((__malloc__)) __nonnull_attribute__ (1);
 434
 435 /* Default OOM handler.  */
 436 extern void __libdw_oom (void) __attribute ((noreturn, visibility ("hidden")));
 437
 438 /* Allocate the internal data for a unit not seen before.  */
 439 extern struct Dwarf_CU *__libdw_intern_next_unit (Dwarf *dbg, bool debug_types)
 440      __nonnull_attribute__ (1) internal_function;
 441
 442 /* Find CU for given offset.  */
 443 extern struct Dwarf_CU *__libdw_findcu (Dwarf *dbg, Dwarf_Off offset, bool tu)
 444      __nonnull_attribute__ (1) internal_function;
 445
 446 /* Get abbreviation with given code.  */
 447 extern Dwarf_Abbrev *__libdw_findabbrev (struct Dwarf_CU *cu,
 448                                          unsigned int code)
 449      __nonnull_attribute__ (1) internal_function;
 450
 451 /* Get abbreviation at given offset.  */
 452 extern Dwarf_Abbrev *__libdw_getabbrev (Dwarf *dbg, struct Dwarf_CU *cu,
 453                                         Dwarf_Off offset, size_t *lengthp,
 454                                         Dwarf_Abbrev *result)
 455      __nonnull_attribute__ (1) internal_function;
 456
 457 /* Get abbreviation of given DIE, and optionally set *READP to the DIE memory
 458    just past the abbreviation code.  */
 459 static inline Dwarf_Abbrev *
 460 __nonnull_attribute__ (1)
 461 __libdw_dieabbrev (Dwarf_Die *die, const unsigned char **readp)
 462 {
 463   /* Do we need to get the abbreviation, or need to read after the code?  */
 464   if (die->abbrev == NULL || readp != NULL)
 465     {
 466       /* Get the abbreviation code.  */
 467       unsigned int code;
 468       const unsigned char *addr = die->addr;
 469       get_uleb128 (code, addr, die->cu->endp);
 470       if (readp != NULL)
 471         *readp = addr;
 472
 473       /* Find the abbreviation.  */
 474       if (die->abbrev == NULL)
 475         die->abbrev = __libdw_findabbrev (die->cu, code);
 476     }
 477   return die->abbrev;
 478 }
 479
 480 /* Helper functions for form handling.  */
 481 extern size_t __libdw_form_val_compute_len (struct Dwarf_CU *cu,
 482                                             unsigned int form,
 483                                             const unsigned char *valp)
 484      __nonnull_attribute__ (1, 3) internal_function;
 485
 486 /* Find the length of a form attribute.  */
 487 static inline size_t
 488 __nonnull_attribute__ (1, 3)
 489 __libdw_form_val_len (struct Dwarf_CU *cu, unsigned int form,
 490                       const unsigned char *valp)
 491 {
 492   /* Small lookup table of forms with fixed lengths.  Absent indexes are
 493      initialized 0, so any truly desired 0 is set to 0x80 and masked.  */
 494   static const uint8_t form_lengths[] =
 495     {
 496       [DW_FORM_flag_present] = 0x80,
 497       [DW_FORM_data1] = 1, [DW_FORM_ref1] = 1, [DW_FORM_flag] = 1,
 498       [DW_FORM_data2] = 2, [DW_FORM_ref2] = 2,
 499       [DW_FORM_data4] = 4, [DW_FORM_ref4] = 4,
 500       [DW_FORM_data8] = 8, [DW_FORM_ref8] = 8, [DW_FORM_ref_sig8] = 8,
 501     };
 502
 503   /* Return immediately for forms with fixed lengths.  */
 504   if (form < sizeof form_lengths / sizeof form_lengths[0])
 505     {
 506       uint8_t len = form_lengths[form];
 507       if (len != 0)
 508         {
 509           const unsigned char *endp = cu->endp;
 510           len &= 0x7f; /* Mask to allow 0x80 -> 0.  */
 511           if (unlikely (len > (size_t) (endp - valp)))
 512             {
 513               __libdw_seterrno (DWARF_E_INVALID_DWARF);
 514               return -1;
 515             }
 516           return len;
 517         }
 518     }
 519
 520   /* Other forms require some computation.  */
 521   return __libdw_form_val_compute_len (cu, form, valp);
 522 }
 523
 524 /* Helper function for DW_FORM_ref* handling.  */
 525 extern int __libdw_formref (Dwarf_Attribute *attr, Dwarf_Off *return_offset)
 526      __nonnull_attribute__ (1, 2) internal_function;
 527
 528
 529 /* Helper function to locate attribute.  */
 530 extern unsigned char *__libdw_find_attr (Dwarf_Die *die,
 531                                          unsigned int search_name,
 532                                          unsigned int *codep,
 533                                          unsigned int *formp)
 534      __nonnull_attribute__ (1) internal_function;
 535
 536 /* Helper function to access integer attribute.  */
 537 extern int __libdw_attr_intval (Dwarf_Die *die, int *valp, int attval)
 538      __nonnull_attribute__ (1, 2) internal_function;
 539
 540 /* Helper function to walk scopes.  */
 541 struct Dwarf_Die_Chain
 542 {
 543   Dwarf_Die die;
 544   struct Dwarf_Die_Chain *parent;
 545   bool prune;                   /* The PREVISIT function can set this.  */
 546 };
 547 extern int __libdw_visit_scopes (unsigned int depth,
 548                                  struct Dwarf_Die_Chain *root,
 549                                  struct Dwarf_Die_Chain *imports,
 550                                  int (*previsit) (unsigned int depth,
 551                                                   struct Dwarf_Die_Chain *,
 552                                                   void *arg),
 553                                  int (*postvisit) (unsigned int depth,
 554                                                    struct Dwarf_Die_Chain *,
 555                                                    void *arg),
 556                                  void *arg)
 557   __nonnull_attribute__ (2, 4) internal_function;
 558
 559 /* Parse a DWARF Dwarf_Block into an array of Dwarf_Op's,
 560    and cache the result (via tsearch).  */
 561 extern int __libdw_intern_expression (Dwarf *dbg,
 562                                       bool other_byte_order,
 563                                       unsigned int address_size,
 564                                       unsigned int ref_size,
 565                                       void **cache, const Dwarf_Block *block,
 566                                       bool cfap, bool valuep,
 567                                       Dwarf_Op **llbuf, size_t *listlen,
 568                                       int sec_index)
 569   __nonnull_attribute__ (5, 6, 9, 10) internal_function;
 570
 571 extern Dwarf_Die *__libdw_offdie (Dwarf *dbg, Dwarf_Off offset,
 572                                   Dwarf_Die *result, bool debug_types)
 573   internal_function;
 574
 575
 576 /* Return error code of last failing function call.  This value is kept
 577    separately for each thread.  */
 578 extern int __dwarf_errno_internal (void);
 579
 580
 581 /* Reader hooks.  */
 582
 583 /* Relocation hooks return -1 on error (in that case the error code
 584    must already have been set), 0 if there is no relocation and 1 if a
 585    relocation was present.*/
 586
 587 static inline int
 588 __libdw_relocate_address (Dwarf *dbg __attribute__ ((unused)),
 589                           int sec_index __attribute__ ((unused)),
 590                           const void *addr __attribute__ ((unused)),
 591                           int width __attribute__ ((unused)),
 592                           Dwarf_Addr *val __attribute__ ((unused)))
 593 {
 594   return 0;
 595 }
 596
 597 static inline int
 598 __libdw_relocate_offset (Dwarf *dbg __attribute__ ((unused)),
 599                          int sec_index __attribute__ ((unused)),
 600                          const void *addr __attribute__ ((unused)),
 601                          int width __attribute__ ((unused)),
 602                          Dwarf_Off *val __attribute__ ((unused)))
 603 {
 604   return 0;
 605 }
 606
 607 static inline Elf_Data *
 608 __libdw_checked_get_data (Dwarf *dbg, int sec_index)
 609 {
 610   Elf_Data *data = dbg->sectiondata[sec_index];
 611   if (unlikely (data == NULL)
 612       || unlikely (data->d_buf == NULL))
 613     {
 614       __libdw_seterrno (DWARF_E_INVALID_DWARF);
 615       return NULL;
 616     }
 617   return data;
 618 }
 619
 620 static inline int
 621 __libdw_offset_in_section (Dwarf *dbg, int sec_index,
 622                            Dwarf_Off offset, size_t size)
 623 {
 624   Elf_Data *data = __libdw_checked_get_data (dbg, sec_index);
 625   if (data == NULL)
 626     return -1;
 627   if (unlikely (offset > data->d_size)
 628       || unlikely (data->d_size - offset < size))
 629     {
 630       __libdw_seterrno (DWARF_E_INVALID_OFFSET);
 631       return -1;
 632     }
 633
 634   return 0;
 635 }
 636
 637 static inline bool
 638 __libdw_in_section (Dwarf *dbg, int sec_index,
 639                     const void *addr, size_t size)
 640 {
 641   Elf_Data *data = __libdw_checked_get_data (dbg, sec_index);
 642   if (data == NULL)
 643     return false;
 644   if (unlikely (addr < data->d_buf)
 645       || unlikely (data->d_size - (addr - data->d_buf) < size))
 646     {
 647       __libdw_seterrno (DWARF_E_INVALID_OFFSET);
 648       return false;
 649     }
 650
 651   return true;
 652 }
 653
 654 #define READ_AND_RELOCATE(RELOC_HOOK, VAL)                              \
 655   ({                                                                    \
 656     if (!__libdw_in_section (dbg, sec_index, addr, width))              \
 657       return -1;                                                        \
 658                                                                         \
 659     const unsigned char *orig_addr = addr;                              \
 660     if (width == 4)                                                     \
 661       VAL = read_4ubyte_unaligned_inc (dbg, addr);                      \
 662     else                                                                \
 663       VAL = read_8ubyte_unaligned_inc (dbg, addr);                      \
 664                                                                         \
 665     int status = RELOC_HOOK (dbg, sec_index, orig_addr, width, &VAL);   \
 666     if (status < 0)                                                     \
 667       return status;                                                    \
 668     status > 0;                                                         \
 669    })
 670
 671 static inline int
 672 __libdw_read_address_inc (Dwarf *dbg,
 673                           int sec_index, const unsigned char **addrp,
 674                           int width, Dwarf_Addr *ret)
 675 {
 676   const unsigned char *addr = *addrp;
 677   READ_AND_RELOCATE (__libdw_relocate_address, (*ret));
 678   *addrp = addr;
 679   return 0;
 680 }
 681
 682 static inline int
 683 __libdw_read_address (Dwarf *dbg,
 684                       int sec_index, const unsigned char *addr,
 685                       int width, Dwarf_Addr *ret)
 686 {
 687   READ_AND_RELOCATE (__libdw_relocate_address, (*ret));
 688   return 0;
 689 }
 690
 691 static inline int
 692 __libdw_read_offset_inc (Dwarf *dbg,
 693                          int sec_index, const unsigned char **addrp,
 694                          int width, Dwarf_Off *ret, int sec_ret,
 695                          size_t size)
 696 {
 697   const unsigned char *addr = *addrp;
 698   READ_AND_RELOCATE (__libdw_relocate_offset, (*ret));
 699   *addrp = addr;
 700   return __libdw_offset_in_section (dbg, sec_ret, *ret, size);
 701 }
 702
 703 static inline int
 704 __libdw_read_offset (Dwarf *dbg, Dwarf *dbg_ret,
 705                      int sec_index, const unsigned char *addr,
 706                      int width, Dwarf_Off *ret, int sec_ret,
 707                      size_t size)
 708 {
 709   READ_AND_RELOCATE (__libdw_relocate_offset, (*ret));
 710   return __libdw_offset_in_section (dbg_ret, sec_ret, *ret, size);
 711 }
 712
 713 static inline size_t
 714 cu_sec_idx (struct Dwarf_CU *cu)
 715 {
 716   return cu->type_offset == 0 ? IDX_debug_info : IDX_debug_types;
 717 }
 718
 719 static inline bool
 720 is_cudie (Dwarf_Die *cudie)
 721 {
 722   return CUDIE (cudie->cu).addr == cudie->addr;
 723 }
 724
 725 /* Read up begin/end pair and increment read pointer.
 726     - If it's normal range record, set up *BEGINP and *ENDP and return 0.
 727     - If it's base address selection record, set up *BASEP and return 1.
 728     - If it's end of rangelist, don't set anything and return 2
 729     - If an error occurs, don't set anything and return <0.  */
 730 int __libdw_read_begin_end_pair_inc (Dwarf *dbg, int sec_index,
 731                                      unsigned char **addr, int width,
 732                                      Dwarf_Addr *beginp, Dwarf_Addr *endp,
 733                                      Dwarf_Addr *basep)
 734   internal_function;
 735
 736 unsigned char * __libdw_formptr (Dwarf_Attribute *attr, int sec_index,
 737                                  int err_nodata, unsigned char **endpp,
 738                                  Dwarf_Off *offsetp)
 739   internal_function;
 740
 741 /* Fills in the given attribute to point at an empty location expression.  */
 742 void __libdw_empty_loc_attr (Dwarf_Attribute *attr)
 743   internal_function;
 744
 745 /* Load .debug_line unit at DEBUG_LINE_OFFSET.  COMP_DIR is a value of
 746    DW_AT_comp_dir or NULL if that attribute is not available.  Caches
 747    the loaded unit and optionally set *LINESP and/or *FILESP (if not
 748    NULL) with loaded information.  Returns 0 for success or a negative
 749    value for failure.  */
 750 int __libdw_getsrclines (Dwarf *dbg, Dwarf_Off debug_line_offset,
 751                          const char *comp_dir, unsigned address_size,
 752                          Dwarf_Lines **linesp, Dwarf_Files **filesp)
 753   internal_function
 754   __nonnull_attribute__ (1);
 755
 756 /* Load and return value of DW_AT_comp_dir from CUDIE.  */
 757 const char *__libdw_getcompdir (Dwarf_Die *cudie);
 758
 759
 760 /* Aliases to avoid PLTs.  */
 761 INTDECL (dwarf_aggregate_size)
 762 INTDECL (dwarf_attr)
 763 INTDECL (dwarf_attr_integrate)
 764 INTDECL (dwarf_begin)
 765 INTDECL (dwarf_begin_elf)
 766 INTDECL (dwarf_child)
 767 INTDECL (dwarf_dieoffset)
 768 INTDECL (dwarf_diename)
 769 INTDECL (dwarf_end)
 770 INTDECL (dwarf_entrypc)
 771 INTDECL (dwarf_errmsg)
 772 INTDECL (dwarf_formaddr)
 773 INTDECL (dwarf_formblock)
 774 INTDECL (dwarf_formref_die)
 775 INTDECL (dwarf_formsdata)
 776 INTDECL (dwarf_formstring)
 777 INTDECL (dwarf_formudata)
 778 INTDECL (dwarf_getalt)
 779 INTDECL (dwarf_getarange_addr)
 780 INTDECL (dwarf_getarangeinfo)
 781 INTDECL (dwarf_getaranges)
 782 INTDECL (dwarf_getlocation_die)
 783 INTDECL (dwarf_getsrcfiles)
 784 INTDECL (dwarf_getsrclines)
 785 INTDECL (dwarf_hasattr)
 786 INTDECL (dwarf_haschildren)
 787 INTDECL (dwarf_haspc)
 788 INTDECL (dwarf_highpc)
 789 INTDECL (dwarf_lowpc)
 790 INTDECL (dwarf_nextcu)
 791 INTDECL (dwarf_next_unit)
 792 INTDECL (dwarf_offdie)
 793 INTDECL (dwarf_peel_type)
 794 INTDECL (dwarf_ranges)
 795 INTDECL (dwarf_setalt)
 796 INTDECL (dwarf_siblingof)
 797 INTDECL (dwarf_srclang)
 798 INTDECL (dwarf_tag)
 799
 800 #endif  /* libdwP.h */