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