1 /* Interfaces for libdw.
2 Copyright (C) 2002-2010, 2013, 2014 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 _LIBDW_H
30 #define _LIBDW_H 1
31
32 #include <gelf.h>
33 #include <stdbool.h>
34 #include <stddef.h>
35 #include <stdint.h>
36
37
38 #if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)
39 # define __nonnull_attribute__(...) __attribute__ ((__nonnull__ (__VA_ARGS__)))
40 # define __deprecated_attribute__ __attribute__ ((__deprecated__))
41 #else
42 # define __nonnull_attribute__(args...)
43 # define __deprecated_attribute__
44 #endif
45
46
47 #ifdef __GNUC_STDC_INLINE__
48 # define __libdw_extern_inline extern __inline __attribute__ ((__gnu_inline__))
49 #else
50 # define __libdw_extern_inline extern __inline
51 #endif
52
53
54 /* Mode for the session. */
55 typedef enum
56 {
57 DWARF_C_READ, /* Read .. */
58 DWARF_C_RDWR, /* Read and write .. */
59 DWARF_C_WRITE, /* Write .. */
60 }
61 Dwarf_Cmd;
62
63
64 /* Callback results. */
65 enum
66 {
67 DWARF_CB_OK = 0,
68 DWARF_CB_ABORT
69 };
70
71
72 /* Error values. */
73 enum
74 {
75 DW_TAG_invalid = 0
76 #define DW_TAG_invalid DW_TAG_invalid
77 };
78
79
80 /* Type for offset in DWARF file. */
81 typedef GElf_Off Dwarf_Off;
82
83 /* Type for address in DWARF file. */
84 typedef GElf_Addr Dwarf_Addr;
85
86 /* Integer types. Big enough to hold any numeric value. */
87 typedef GElf_Xword Dwarf_Word;
88 typedef GElf_Sxword Dwarf_Sword;
89 /* For the times we know we do not need that much. */
90 typedef GElf_Half Dwarf_Half;
91
92
93 /* DWARF abbreviation record. */
94 typedef struct Dwarf_Abbrev Dwarf_Abbrev;
95
96 /* Returned to show the last DIE has be returned. */
97 #define DWARF_END_ABBREV ((Dwarf_Abbrev *) -1l)
98
99 /* Source code line information for CU. */
100 typedef struct Dwarf_Lines_s Dwarf_Lines;
101
102 /* One source code line information. */
103 typedef struct Dwarf_Line_s Dwarf_Line;
104
105 /* Source file information. */
106 typedef struct Dwarf_Files_s Dwarf_Files;
107
108 /* One address range record. */
109 typedef struct Dwarf_Arange_s Dwarf_Arange;
110
111 /* Address ranges of a file. */
112 typedef struct Dwarf_Aranges_s Dwarf_Aranges;
113
114 /* CU representation. */
115 struct Dwarf_CU;
116 typedef struct Dwarf_CU Dwarf_CU;
117
118 /* Macro information. */
119 typedef struct Dwarf_Macro_s Dwarf_Macro;
120
121 /* Attribute representation. */
122 typedef struct
123 {
124 unsigned int code;
125 unsigned int form;
126 unsigned char *valp;
127 struct Dwarf_CU *cu;
128 } Dwarf_Attribute;
129
130
131 /* Data block representation. */
132 typedef struct
133 {
134 Dwarf_Word length;
135 unsigned char *data;
136 } Dwarf_Block;
137
138
139 /* DIE information. */
140 typedef struct
141 {
142 /* The offset can be computed from the address. */
143 void *addr;
144 struct Dwarf_CU *cu;
145 Dwarf_Abbrev *abbrev;
146 // XXX We'll see what other information will be needed.
147 long int padding__;
148 } Dwarf_Die;
149
150 /* Returned to show the last DIE has be returned. */
151 #define DWARF_END_DIE ((Dwarf_Die *) -1l)
152
153
154 /* Global symbol information. */
155 typedef struct
156 {
157 Dwarf_Off cu_offset;
158 Dwarf_Off die_offset;
159 const char *name;
160 } Dwarf_Global;
161
162
163 /* One operation in a DWARF location expression.
164 A location expression is an array of these. */
165 typedef struct
166 {
167 uint8_t atom; /* Operation */
168 Dwarf_Word number; /* Operand */
169 Dwarf_Word number2; /* Possible second operand */
170 Dwarf_Word offset; /* Offset in location expression */
171 } Dwarf_Op;
172
173
174 /* This describes one Common Information Entry read from a CFI section.
175 Pointers here point into the DATA->d_buf block passed to dwarf_next_cfi. */
176 typedef struct
177 {
178 Dwarf_Off CIE_id; /* Always DW_CIE_ID_64 in Dwarf_CIE structures. */
179
180 /* Instruction stream describing initial state used by FDEs. If
181 we did not understand the whole augmentation string and it did
182 not use 'z', then there might be more augmentation data here
183 (and in FDEs) before the actual instructions. */
184 const uint8_t *initial_instructions;
185 const uint8_t *initial_instructions_end;
186
187 Dwarf_Word code_alignment_factor;
188 Dwarf_Sword data_alignment_factor;
189 Dwarf_Word return_address_register;
190
191 const char *augmentation; /* Augmentation string. */
192
193 /* Augmentation data, might be NULL. The size is correct only if
194 we understood the augmentation string sufficiently. */
195 const uint8_t *augmentation_data;
196 size_t augmentation_data_size;
197 size_t fde_augmentation_data_size;
198 } Dwarf_CIE;
199
200 /* This describes one Frame Description Entry read from a CFI section.
201 Pointers here point into the DATA->d_buf block passed to dwarf_next_cfi. */
202 typedef struct
203 {
204 /* Section offset of CIE this FDE refers to. This will never be
205 DW_CIE_ID_64 in an FDE. If this value is DW_CIE_ID_64, this is
206 actually a Dwarf_CIE structure. */
207 Dwarf_Off CIE_pointer;
208
209 /* We can't really decode anything further without looking up the CIE
210 and checking its augmentation string. Here follows the encoded
211 initial_location and address_range, then any augmentation data,
212 then the instruction stream. This FDE describes PC locations in
213 the byte range [initial_location, initial_location+address_range).
214 When the CIE augmentation string uses 'z', the augmentation data is
215 a DW_FORM_block (self-sized). Otherwise, when we understand the
216 augmentation string completely, fde_augmentation_data_size gives
217 the number of bytes of augmentation data before the instructions. */
218 const uint8_t *start;
219 const uint8_t *end;
220 } Dwarf_FDE;
221
222 /* Each entry in a CFI section is either a CIE described by Dwarf_CIE or
223 an FDE described by Dward_FDE. Check CIE_id to see which you have. */
224 typedef union
225 {
226 Dwarf_Off CIE_id; /* Always DW_CIE_ID_64 in Dwarf_CIE structures. */
227 Dwarf_CIE cie;
228 Dwarf_FDE fde;
229 } Dwarf_CFI_Entry;
230
231 #define dwarf_cfi_cie_p(entry) ((entry)->cie.CIE_id == DW_CIE_ID_64)
232
233 /* Opaque type representing a frame state described by CFI. */
234 typedef struct Dwarf_Frame_s Dwarf_Frame;
235
236 /* Opaque type representing a CFI section found in a DWARF or ELF file. */
237 typedef struct Dwarf_CFI_s Dwarf_CFI;
238
239
240 /* Handle for debug sessions. */
241 typedef struct Dwarf Dwarf;
242
243
244 /* Out-Of-Memory handler. */
245 #if __GNUC__ < 4
246 typedef void (*Dwarf_OOM) (void);
247 #else
248 typedef void (*__attribute__ ((noreturn)) Dwarf_OOM) (void);
249 #endif
250
251
252 #ifdef __cplusplus
253 extern "C" {
254 #endif
255
256 /* Create a handle for a new debug session. */
257 extern Dwarf *dwarf_begin (int fildes, Dwarf_Cmd cmd);
258
259 /* Create a handle for a new debug session for an ELF file. */
260 extern Dwarf *dwarf_begin_elf (Elf *elf, Dwarf_Cmd cmd, Elf_Scn *scngrp);
261
262 /* Retrieve ELF descriptor used for DWARF access. */
263 extern Elf *dwarf_getelf (Dwarf *dwarf);
264
265 /* Retieve DWARF descriptor used for a Dwarf_Die or Dwarf_Attribute.
266 A Dwarf_Die or a Dwarf_Attribute is associated with a particular
267 Dwarf_CU handle. This function returns the DWARF descriptor for
268 that Dwarf_CU. */
269 extern Dwarf *dwarf_cu_getdwarf (Dwarf_CU *cu);
270
271 /* Retrieves the DWARF descriptor for debugaltlink data. Returns NULL
272 if no alternate debug data has been supplied. */
273 extern Dwarf *dwarf_getalt (Dwarf *main);
274
275 /* Provides the data referenced by the .gnu_debugaltlink section. The
276 caller should check that MAIN and ALT match (i.e., they have the
277 same build ID). It is the responsibility of the caller to ensure
278 that the data referenced by ALT stays valid while it is used by
279 MAIN, until dwarf_setalt is called on MAIN with a different
280 descriptor, or dwarf_end. */
281 extern void dwarf_setalt (Dwarf *main, Dwarf *alt);
282
283 /* Release debugging handling context. */
284 extern int dwarf_end (Dwarf *dwarf);
285
286
287 /* Get the data block for the .debug_info section. */
288 extern Elf_Data *dwarf_getscn_info (Dwarf *dwarf);
289
290 /* Read the header for the DWARF CU. */
291 extern int dwarf_nextcu (Dwarf *dwarf, Dwarf_Off off, Dwarf_Off *next_off,
292 size_t *header_sizep, Dwarf_Off *abbrev_offsetp,
293 uint8_t *address_sizep, uint8_t *offset_sizep)
294 __nonnull_attribute__ (3);
295
296 /* Read the header of a DWARF CU or type unit. If TYPE_SIGNATUREP is not
297 null, this reads a type unit from the .debug_types section; otherwise
298 this reads a CU from the .debug_info section. */
299 extern int dwarf_next_unit (Dwarf *dwarf, Dwarf_Off off, Dwarf_Off *next_off,
300 size_t *header_sizep, Dwarf_Half *versionp,
301 Dwarf_Off *abbrev_offsetp,
302 uint8_t *address_sizep, uint8_t *offset_sizep,
303 uint64_t *type_signaturep, Dwarf_Off *type_offsetp)
304 __nonnull_attribute__ (3);
305
306
307 /* Decode one DWARF CFI entry (CIE or FDE) from the raw section data.
308 The E_IDENT from the originating ELF file indicates the address
309 size and byte order used in the CFI section contained in DATA;
310 EH_FRAME_P should be true for .eh_frame format and false for
311 .debug_frame format. OFFSET is the byte position in the section
312 to start at; on return *NEXT_OFFSET is filled in with the byte
313 position immediately after this entry.
314
315 On success, returns 0 and fills in *ENTRY; use dwarf_cfi_cie_p to
316 see whether ENTRY->cie or ENTRY->fde is valid.
317
318 On errors, returns -1. Some format errors will permit safely
319 skipping to the next CFI entry though the current one is unusable.
320 In that case, *NEXT_OFF will be updated before a -1 return.
321
322 If there are no more CFI entries left in the section,
323 returns 1 and sets *NEXT_OFFSET to (Dwarf_Off) -1. */
324 extern int dwarf_next_cfi (const unsigned char e_ident[],
325 Elf_Data *data, bool eh_frame_p,
326 Dwarf_Off offset, Dwarf_Off *next_offset,
327 Dwarf_CFI_Entry *entry)
328 __nonnull_attribute__ (1, 2, 5, 6);
329
330 /* Use the CFI in the DWARF .debug_frame section.
331 Returns NULL if there is no such section (not an error).
332 The pointer returned can be used until dwarf_end is called on DWARF,
333 and must not be passed to dwarf_cfi_end.
334 Calling this more than once returns the same pointer. */
335 extern Dwarf_CFI *dwarf_getcfi (Dwarf *dwarf);
336
337 /* Use the CFI in the ELF file's exception-handling data.
338 Returns NULL if there is no such data.
339 The pointer returned can be used until elf_end is called on ELF,
340 and must be passed to dwarf_cfi_end before then.
341 Calling this more than once allocates independent data structures. */
342 extern Dwarf_CFI *dwarf_getcfi_elf (Elf *elf);
343
344 /* Release resources allocated by dwarf_getcfi_elf. */
345 extern int dwarf_cfi_end (Dwarf_CFI *cache);
346
347
348 /* Return DIE at given offset in .debug_info section. */
349 extern Dwarf_Die *dwarf_offdie (Dwarf *dbg, Dwarf_Off offset,
350 Dwarf_Die *result) __nonnull_attribute__ (3);
351
352 /* Return DIE at given offset in .debug_types section. */
353 extern Dwarf_Die *dwarf_offdie_types (Dwarf *dbg, Dwarf_Off offset,
354 Dwarf_Die *result)
355 __nonnull_attribute__ (3);
356
357 /* Return offset of DIE. */
358 extern Dwarf_Off dwarf_dieoffset (Dwarf_Die *die);
359
360 /* Return offset of DIE in CU. */
361 extern Dwarf_Off dwarf_cuoffset (Dwarf_Die *die);
362
363 /* Return CU DIE containing given DIE. */
364 extern Dwarf_Die *dwarf_diecu (Dwarf_Die *die, Dwarf_Die *result,
365 uint8_t *address_sizep, uint8_t *offset_sizep)
366 __nonnull_attribute__ (2);
367
368 /* Return the CU DIE and the header info associated with a Dwarf_Die
369 or Dwarf_Attribute. A Dwarf_Die or a Dwarf_Attribute is associated
370 with a particular Dwarf_CU handle. This function returns the CU or
371 type unit DIE and header information for that Dwarf_CU. The
372 returned DIE is either a compile_unit, partial_unit or type_unit.
373 If it is a type_unit, then the type signature and type offset are
374 also provided, otherwise type_offset will be set to zero. See also
375 dwarf_diecu and dwarf_next_unit. */
376 extern Dwarf_Die *dwarf_cu_die (Dwarf_CU *cu, Dwarf_Die *result,
377 Dwarf_Half *versionp,
378 Dwarf_Off *abbrev_offsetp,
379 uint8_t *address_sizep,
380 uint8_t *offset_sizep,
381 uint64_t *type_signaturep,
382 Dwarf_Off *type_offsetp)
383 __nonnull_attribute__ (2);
384
385 /* Return CU DIE containing given address. */
386 extern Dwarf_Die *dwarf_addrdie (Dwarf *dbg, Dwarf_Addr addr,
387 Dwarf_Die *result) __nonnull_attribute__ (3);
388
389 /* Return child of current DIE. */
390 extern int dwarf_child (Dwarf_Die *die, Dwarf_Die *result)
391 __nonnull_attribute__ (2);
392
393 /* Locates the first sibling of DIE and places it in RESULT.
394 Returns 0 if a sibling was found, -1 if something went wrong.
395 Returns 1 if no sibling could be found and, if RESULT is not
396 the same as DIE, it sets RESULT->addr to the address of the
397 (non-sibling) DIE that follows this one, or NULL if this DIE
398 was the last one in the compilation unit. */
399 extern int dwarf_siblingof (Dwarf_Die *die, Dwarf_Die *result)
400 __nonnull_attribute__ (2);
401
402 /* For type aliases and qualifier type DIEs follow the DW_AT_type
403 attribute (recursively) and return the underlying type Dwarf_Die.
404 Returns 0 when RESULT contains a Dwarf_Die (possibly equal to the
405 given DIE) that isn't a type alias or qualifier type. Returns 1
406 when RESULT contains a type alias or qualifier Dwarf_Die that
407 couldn't be peeled further (it doesn't have a DW_TAG_type
408 attribute). Returns -1 when an error occured.
409
410 The current DWARF specification defines one type alias tag
411 (DW_TAG_typedef) and three qualifier type tags (DW_TAG_const_type,
412 DW_TAG_volatile_type, DW_TAG_restrict_type). A future version of
413 this function might peel other alias or qualifier type tags if a
414 future DWARF version or GNU extension defines other type aliases or
415 qualifier type tags that don't modify or change the structural
416 layout of the underlying type. */
417 extern int dwarf_peel_type (Dwarf_Die *die, Dwarf_Die *result)
418 __nonnull_attribute__ (2);
419
420 /* Check whether the DIE has children. */
421 extern int dwarf_haschildren (Dwarf_Die *die) __nonnull_attribute__ (1);
422
423 /* Walks the attributes of DIE, starting at the one OFFSET bytes in,
424 calling the CALLBACK function for each one. Stops if the callback
425 function ever returns a value other than DWARF_CB_OK and returns the
426 offset of the offending attribute. If the end of the attributes
427 is reached 1 is returned. If something goes wrong -1 is returned and
428 the dwarf error number is set. */
429 extern ptrdiff_t dwarf_getattrs (Dwarf_Die *die,
430 int (*callback) (Dwarf_Attribute *, void *),
431 void *arg, ptrdiff_t offset)
432 __nonnull_attribute__ (2);
433
434 /* Return tag of given DIE. */
435 extern int dwarf_tag (Dwarf_Die *die) __nonnull_attribute__ (1);
436
437
438 /* Return specific attribute of DIE. */
439 extern Dwarf_Attribute *dwarf_attr (Dwarf_Die *die, unsigned int search_name,
440 Dwarf_Attribute *result)
441 __nonnull_attribute__ (3);
442
443 /* Check whether given DIE has specific attribute. */
444 extern int dwarf_hasattr (Dwarf_Die *die, unsigned int search_name);
445
446 /* These are the same as dwarf_attr and dwarf_hasattr, respectively,
447 but they resolve an indirect attribute through DW_AT_abstract_origin. */
448 extern Dwarf_Attribute *dwarf_attr_integrate (Dwarf_Die *die,
449 unsigned int search_name,
450 Dwarf_Attribute *result)
451 __nonnull_attribute__ (3);
452 extern int dwarf_hasattr_integrate (Dwarf_Die *die, unsigned int search_name);
453
454
455
456
457 /* Check whether given attribute has specific form. */
458 extern int dwarf_hasform (Dwarf_Attribute *attr, unsigned int search_form);
459
460 /* Return attribute code of given attribute. */
461 extern unsigned int dwarf_whatattr (Dwarf_Attribute *attr);
462
463 /* Return form code of given attribute. */
464 extern unsigned int dwarf_whatform (Dwarf_Attribute *attr);
465
466
467 /* Return string associated with given attribute. */
468 extern const char *dwarf_formstring (Dwarf_Attribute *attrp);
469
470 /* Return unsigned constant represented by attribute. */
471 extern int dwarf_formudata (Dwarf_Attribute *attr, Dwarf_Word *return_uval)
472 __nonnull_attribute__ (2);
473
474 /* Return signed constant represented by attribute. */
475 extern int dwarf_formsdata (Dwarf_Attribute *attr, Dwarf_Sword *return_uval)
476 __nonnull_attribute__ (2);
477
478 /* Return address represented by attribute. */
479 extern int dwarf_formaddr (Dwarf_Attribute *attr, Dwarf_Addr *return_addr)
480 __nonnull_attribute__ (2);
481
482 /* This function is deprecated. Always use dwarf_formref_die instead.
483 Return reference offset represented by attribute. */
484 extern int dwarf_formref (Dwarf_Attribute *attr, Dwarf_Off *return_offset)
485 __nonnull_attribute__ (2) __deprecated_attribute__;
486
487 /* Look up the DIE in a reference-form attribute. */
488 extern Dwarf_Die *dwarf_formref_die (Dwarf_Attribute *attr, Dwarf_Die *die_mem)
489 __nonnull_attribute__ (2);
490
491 /* Return block represented by attribute. */
492 extern int dwarf_formblock (Dwarf_Attribute *attr, Dwarf_Block *return_block)
493 __nonnull_attribute__ (2);
494
495 /* Return flag represented by attribute. */
496 extern int dwarf_formflag (Dwarf_Attribute *attr, bool *return_bool)
497 __nonnull_attribute__ (2);
498
499
500 /* Simplified attribute value access functions. */
501
502 /* Return string in name attribute of DIE. */
503 extern const char *dwarf_diename (Dwarf_Die *die);
504
505 /* Return high PC attribute of DIE. */
506 extern int dwarf_highpc (Dwarf_Die *die, Dwarf_Addr *return_addr)
507 __nonnull_attribute__ (2);
508
509 /* Return low PC attribute of DIE. */
510 extern int dwarf_lowpc (Dwarf_Die *die, Dwarf_Addr *return_addr)
511 __nonnull_attribute__ (2);
512
513 /* Return entry_pc or low_pc attribute of DIE. */
514 extern int dwarf_entrypc (Dwarf_Die *die, Dwarf_Addr *return_addr)
515 __nonnull_attribute__ (2);
516
517 /* Return 1 if DIE's lowpc/highpc or ranges attributes match the PC address,
518 0 if not, or -1 for errors. */
519 extern int dwarf_haspc (Dwarf_Die *die, Dwarf_Addr pc);
520
521 /* Enumerate the PC address ranges covered by this DIE, covering all
522 addresses where dwarf_haspc returns true. In the first call OFFSET
523 should be zero and *BASEP need not be initialized. Returns -1 for
524 errors, zero when there are no more address ranges to report, or a
525 nonzero OFFSET value to pass to the next call. Each subsequent call
526 must preserve *BASEP from the prior call. Successful calls fill in
527 *STARTP and *ENDP with a contiguous address range. */
528 extern ptrdiff_t dwarf_ranges (Dwarf_Die *die,
529 ptrdiff_t offset, Dwarf_Addr *basep,
530 Dwarf_Addr *startp, Dwarf_Addr *endp);
531
532
533 /* Return byte size attribute of DIE. */
534 extern int dwarf_bytesize (Dwarf_Die *die);
535
536 /* Return bit size attribute of DIE. */
537 extern int dwarf_bitsize (Dwarf_Die *die);
538
539 /* Return bit offset attribute of DIE. */
540 extern int dwarf_bitoffset (Dwarf_Die *die);
541
542 /* Return array order attribute of DIE. */
543 extern int dwarf_arrayorder (Dwarf_Die *die);
544
545 /* Return source language attribute of DIE. */
546 extern int dwarf_srclang (Dwarf_Die *die);
547
548
549 /* Get abbreviation at given offset for given DIE. */
550 extern Dwarf_Abbrev *dwarf_getabbrev (Dwarf_Die *die, Dwarf_Off offset,
551 size_t *lengthp);
552
553 /* Get abbreviation at given offset in .debug_abbrev section. */
554 extern int dwarf_offabbrev (Dwarf *dbg, Dwarf_Off offset, size_t *lengthp,
555 Dwarf_Abbrev *abbrevp)
556 __nonnull_attribute__ (4);
557
558 /* Get abbreviation code. */
559 extern unsigned int dwarf_getabbrevcode (Dwarf_Abbrev *abbrev);
560
561 /* Get abbreviation tag. */
562 extern unsigned int dwarf_getabbrevtag (Dwarf_Abbrev *abbrev);
563
564 /* Return true if abbreviation is children flag set. */
565 extern int dwarf_abbrevhaschildren (Dwarf_Abbrev *abbrev);
566
567 /* Get number of attributes of abbreviation. */
568 extern int dwarf_getattrcnt (Dwarf_Abbrev *abbrev, size_t *attrcntp)
569 __nonnull_attribute__ (2);
570
571 /* Get specific attribute of abbreviation. */
572 extern int dwarf_getabbrevattr (Dwarf_Abbrev *abbrev, size_t idx,
573 unsigned int *namep, unsigned int *formp,
574 Dwarf_Off *offset);
575
576
577 /* Get string from-debug_str section. */
578 extern const char *dwarf_getstring (Dwarf *dbg, Dwarf_Off offset,
579 size_t *lenp);
580
581
582 /* Get public symbol information. */
583 extern ptrdiff_t dwarf_getpubnames (Dwarf *dbg,
584 int (*callback) (Dwarf *, Dwarf_Global *,
585 void *),
586 void *arg, ptrdiff_t offset)
587 __nonnull_attribute__ (2);
588
589
590 /* Get source file information for CU. */
591 extern int dwarf_getsrclines (Dwarf_Die *cudie, Dwarf_Lines **lines,
592 size_t *nlines) __nonnull_attribute__ (2, 3);
593
594 /* Return one of the source lines of the CU. */
595 extern Dwarf_Line *dwarf_onesrcline (Dwarf_Lines *lines, size_t idx);
596
597 /* Get the file source files used in the CU. */
598 extern int dwarf_getsrcfiles (Dwarf_Die *cudie, Dwarf_Files **files,
599 size_t *nfiles)
600 __nonnull_attribute__ (2);
601
602
603 /* Get source for address in CU. */
604 extern Dwarf_Line *dwarf_getsrc_die (Dwarf_Die *cudie, Dwarf_Addr addr);
605
606 /* Get source for file and line number. */
607 extern int dwarf_getsrc_file (Dwarf *dbg, const char *fname, int line, int col,
608 Dwarf_Line ***srcsp, size_t *nsrcs)
609 __nonnull_attribute__ (2, 5, 6);
610
611
612 /* Return line address. */
613 extern int dwarf_lineaddr (Dwarf_Line *line, Dwarf_Addr *addrp);
614
615 /* Return line VLIW operation index. */
616 extern int dwarf_lineop_index (Dwarf_Line *line, unsigned int *op_indexp);
617
618 /* Return line number. */
619 extern int dwarf_lineno (Dwarf_Line *line, int *linep)
620 __nonnull_attribute__ (2);
621
622 /* Return column in line. */
623 extern int dwarf_linecol (Dwarf_Line *line, int *colp)
624 __nonnull_attribute__ (2);
625
626 /* Return true if record is for beginning of a statement. */
627 extern int dwarf_linebeginstatement (Dwarf_Line *line, bool *flagp)
628 __nonnull_attribute__ (2);
629
630 /* Return true if record is for end of sequence. */
631 extern int dwarf_lineendsequence (Dwarf_Line *line, bool *flagp)
632 __nonnull_attribute__ (2);
633
634 /* Return true if record is for beginning of a basic block. */
635 extern int dwarf_lineblock (Dwarf_Line *line, bool *flagp)
636 __nonnull_attribute__ (2);
637
638 /* Return true if record is for end of prologue. */
639 extern int dwarf_lineprologueend (Dwarf_Line *line, bool *flagp)
640 __nonnull_attribute__ (2);
641
642 /* Return true if record is for beginning of epilogue. */
643 extern int dwarf_lineepiloguebegin (Dwarf_Line *line, bool *flagp)
644 __nonnull_attribute__ (2);
645
646 /* Return instruction-set architecture in this record. */
647 extern int dwarf_lineisa (Dwarf_Line *line, unsigned int *isap)
648 __nonnull_attribute__ (2);
649
650 /* Return code path discriminator in this record. */
651 extern int dwarf_linediscriminator (Dwarf_Line *line, unsigned int *discp)
652 __nonnull_attribute__ (2);
653
654
655 /* Find line information for address. */
656 extern const char *dwarf_linesrc (Dwarf_Line *line,
657 Dwarf_Word *mtime, Dwarf_Word *length);
658
659 /* Return file information. */
660 extern const char *dwarf_filesrc (Dwarf_Files *file, size_t idx,
661 Dwarf_Word *mtime, Dwarf_Word *length);
662
663 /* Return the directory list used in the file information extracted.
664 (*RESULT)[0] is the CU's DW_AT_comp_dir value, and may be null.
665 (*RESULT)[0..*NDIRS-1] are the compile-time include directory path
666 encoded by the compiler. */
667 extern int dwarf_getsrcdirs (Dwarf_Files *files,
668 const char *const **result, size_t *ndirs)
669 __nonnull_attribute__ (2, 3);
670
671
672 /* Return location expression, decoded as a list of operations. */
673 extern int dwarf_getlocation (Dwarf_Attribute *attr, Dwarf_Op **expr,
674 size_t *exprlen) __nonnull_attribute__ (2, 3);
675
676 /* Return location expressions. If the attribute uses a location list,
677 ADDRESS selects the relevant location expressions from the list.
678 There can be multiple matches, resulting in multiple expressions to
679 return. EXPRS and EXPRLENS are parallel arrays of NLOCS slots to
680 fill in. Returns the number of locations filled in, or -1 for
681 errors. If EXPRS is a null pointer, stores nothing and returns the
682 total number of locations. A return value of zero means that the
683 location list indicated no value is accessible. */
684 extern int dwarf_getlocation_addr (Dwarf_Attribute *attr, Dwarf_Addr address,
685 Dwarf_Op **exprs, size_t *exprlens,
686 size_t nlocs);
687
688 /* Enumerate the locations ranges and descriptions covered by the
689 given attribute. In the first call OFFSET should be zero and
690 *BASEP need not be initialized. Returns -1 for errors, zero when
691 there are no more locations to report, or a nonzero OFFSET
692 value to pass to the next call. Each subsequent call must preserve
693 *BASEP from the prior call. Successful calls fill in *STARTP and
694 *ENDP with a contiguous address range and *EXPR with a pointer to
695 an array of operations with length *EXPRLEN. If the attribute
696 describes a single location description and not a location list the
697 first call (with OFFSET zero) will return the location description
698 in *EXPR with *STARTP set to zero and *ENDP set to minus one. */
699 extern ptrdiff_t dwarf_getlocations (Dwarf_Attribute *attr,
700 ptrdiff_t offset, Dwarf_Addr *basep,
701 Dwarf_Addr *startp, Dwarf_Addr *endp,
702 Dwarf_Op **expr, size_t *exprlen);
703
704 /* Return the block associated with a DW_OP_implicit_value operation.
705 The OP pointer must point into an expression that dwarf_getlocation
706 or dwarf_getlocation_addr has returned given the same ATTR. */
707 extern int dwarf_getlocation_implicit_value (Dwarf_Attribute *attr,
708 const Dwarf_Op *op,
709 Dwarf_Block *return_block)
710 __nonnull_attribute__ (2, 3);
711
712 /* Return the attribute indicated by a DW_OP_GNU_implicit_pointer operation.
713 The OP pointer must point into an expression that dwarf_getlocation
714 or dwarf_getlocation_addr has returned given the same ATTR.
715 The result is the DW_AT_location or DW_AT_const_value attribute
716 of the OP->number DIE. */
717 extern int dwarf_getlocation_implicit_pointer (Dwarf_Attribute *attr,
718 const Dwarf_Op *op,
719 Dwarf_Attribute *result)
720 __nonnull_attribute__ (2, 3);
721
722 /* Return the DIE associated with an operation such as
723 DW_OP_GNU_implicit_pointer, DW_OP_GNU_parameter_ref, DW_OP_GNU_convert,
724 DW_OP_GNU_reinterpret, DW_OP_GNU_const_type, DW_OP_GNU_regval_type or
725 DW_OP_GNU_deref_type. The OP pointer must point into an expression that
726 dwarf_getlocation or dwarf_getlocation_addr has returned given the same
727 ATTR. The RESULT is a DIE that expresses a type or value needed by the
728 given OP. */
729 extern int dwarf_getlocation_die (Dwarf_Attribute *attr,
730 const Dwarf_Op *op,
731 Dwarf_Die *result)
732 __nonnull_attribute__ (2, 3);
733
734 /* Return the attribute expressing a value associated with an operation such
735 as DW_OP_implicit_value, DW_OP_GNU_entry_value or DW_OP_GNU_const_type.
736 The OP pointer must point into an expression that dwarf_getlocation
737 or dwarf_getlocation_addr has returned given the same ATTR.
738 The RESULT is a value expressed by an attribute such as DW_AT_location
739 or DW_AT_const_value. */
740 extern int dwarf_getlocation_attr (Dwarf_Attribute *attr,
741 const Dwarf_Op *op,
742 Dwarf_Attribute *result)
743 __nonnull_attribute__ (2, 3);
744
745
746 /* Compute the byte-size of a type DIE according to DWARF rules.
747 For most types, this is just DW_AT_byte_size.
748 For DW_TAG_array_type it can apply much more complex rules. */
749 extern int dwarf_aggregate_size (Dwarf_Die *die, Dwarf_Word *size);
750
751
752 /* Return scope DIEs containing PC address.
753 Sets *SCOPES to a malloc'd array of Dwarf_Die structures,
754 and returns the number of elements in the array.
755 (*SCOPES)[0] is the DIE for the innermost scope containing PC,
756 (*SCOPES)[1] is the DIE for the scope containing that scope, and so on.
757 Returns -1 for errors or 0 if no scopes match PC. */
758 extern int dwarf_getscopes (Dwarf_Die *cudie, Dwarf_Addr pc,
759 Dwarf_Die **scopes);
760
761 /* Return scope DIEs containing the given DIE.
762 Sets *SCOPES to a malloc'd array of Dwarf_Die structures,
763 and returns the number of elements in the array.
764 (*SCOPES)[0] is a copy of DIE.
765 (*SCOPES)[1] is the DIE for the scope containing that scope, and so on.
766 Returns -1 for errors or 0 if DIE is not found in any scope entry. */
767 extern int dwarf_getscopes_die (Dwarf_Die *die, Dwarf_Die **scopes);
768
769
770 /* Search SCOPES[0..NSCOPES-1] for a variable called NAME.
771 Ignore the first SKIP_SHADOWS scopes that match the name.
772 If MATCH_FILE is not null, accept only declaration in that source file;
773 if MATCH_LINENO or MATCH_LINECOL are also nonzero, accept only declaration
774 at that line and column.
775
776 If successful, fill in *RESULT with the DIE of the variable found,
777 and return N where SCOPES[N] is the scope defining the variable.
778 Return -1 for errors or -2 for no matching variable found. */
779 extern int dwarf_getscopevar (Dwarf_Die *scopes, int nscopes,
780 const char *name, int skip_shadows,
781 const char *match_file,
782 int match_lineno, int match_linecol,
783 Dwarf_Die *result);
784
785
786
787 /* Return list address ranges. */
788 extern int dwarf_getaranges (Dwarf *dbg, Dwarf_Aranges **aranges,
789 size_t *naranges)
790 __nonnull_attribute__ (2);
791
792 /* Return one of the address range entries. */
793 extern Dwarf_Arange *dwarf_onearange (Dwarf_Aranges *aranges, size_t idx);
794
795 /* Return information in address range record. */
796 extern int dwarf_getarangeinfo (Dwarf_Arange *arange, Dwarf_Addr *addrp,
797 Dwarf_Word *lengthp, Dwarf_Off *offsetp);
798
799 /* Get address range which includes given address. */
800 extern Dwarf_Arange *dwarf_getarange_addr (Dwarf_Aranges *aranges,
801 Dwarf_Addr addr);
802
803
804
805 /* Get functions in CUDIE. The given callback will be called for all
806 defining DW_TAG_subprograms in the CU DIE tree. If the callback
807 returns DWARF_CB_ABORT the return value can be used as offset argument
808 to resume the function to find all remaining functions (this is not
809 really recommended, since it needs to rewalk the CU DIE tree first till
810 that offset is found again). If the callback returns DWARF_CB_OK
811 dwarf_getfuncs will not return but keep calling the callback for each
812 function DIE it finds. Pass zero for offset on the first call to walk
813 the full CU DIE tree. If no more functions can be found and the callback
814 returned DWARF_CB_OK then the function returns zero. */
815 extern ptrdiff_t dwarf_getfuncs (Dwarf_Die *cudie,
816 int (*callback) (Dwarf_Die *, void *),
817 void *arg, ptrdiff_t offset);
818
819
820 /* Return file name containing definition of the given declaration. */
821 extern const char *dwarf_decl_file (Dwarf_Die *decl);
822
823 /* Get line number of beginning of given declaration. */
824 extern int dwarf_decl_line (Dwarf_Die *decl, int *linep)
825 __nonnull_attribute__ (2);
826
827 /* Get column number of beginning of given declaration. */
828 extern int dwarf_decl_column (Dwarf_Die *decl, int *colp)
829 __nonnull_attribute__ (2);
830
831
832 /* Return nonzero if given function is an abstract inline definition. */
833 extern int dwarf_func_inline (Dwarf_Die *func);
834
835 /* Find each concrete inlined instance of the abstract inline definition. */
836 extern int dwarf_func_inline_instances (Dwarf_Die *func,
837 int (*callback) (Dwarf_Die *, void *),
838 void *arg);
839
840
841 /* Find the appropriate PC location or locations for function entry
842 breakpoints for the given DW_TAG_subprogram DIE. Returns -1 for errors.
843 On success, returns the number of breakpoint locations (never zero)
844 and sets *BKPTS to a malloc'd vector of addresses. */
845 extern int dwarf_entry_breakpoints (Dwarf_Die *die, Dwarf_Addr **bkpts);
846
847
848 /* Iterate through the macro unit referenced by CUDIE and call
849 CALLBACK for each macro information entry. To start the iteration,
850 one would pass DWARF_GETMACROS_START for TOKEN.
851
852 The iteration continues while CALLBACK returns DWARF_CB_OK. If the
853 callback returns DWARF_CB_ABORT, the iteration stops and a
854 continuation token is returned, which can be used to restart the
855 iteration at the point where it ended. Returns -1 for errors or 0
856 if there are no more macro entries.
857
858 Note that the Dwarf_Macro pointer passed to the callback is only
859 valid for the duration of the callback invocation.
860
861 For backward compatibility, a token of 0 is accepted for starting
862 the iteration as well, but in that case this interface will refuse
863 to serve opcode 0xff from .debug_macro sections. Such opcode would
864 be considered invalid and would cause dwarf_getmacros to return
865 with error. */
866 #define DWARF_GETMACROS_START PTRDIFF_MIN
867 extern ptrdiff_t dwarf_getmacros (Dwarf_Die *cudie,
868 int (*callback) (Dwarf_Macro *, void *),
869 void *arg, ptrdiff_t token)
870 __nonnull_attribute__ (2);
871
872 /* This is similar in operation to dwarf_getmacros, but selects the
873 unit to iterate through by offset instead of by CU, and always
874 iterates .debug_macro. This can be used for handling
875 DW_MACRO_GNU_transparent_include's or similar opcodes.
876
877 TOKEN value of DWARF_GETMACROS_START can be used to start the
878 iteration.
879
880 It is not appropriate to obtain macro unit offset by hand from a CU
881 DIE and then request iteration through this interface. The reason
882 for this is that if a dwarf_macro_getsrcfiles is later called,
883 there would be no way to figure out what DW_AT_comp_dir was present
884 on the CU DIE, and file names referenced in either the macro unit
885 itself, or the .debug_line unit that it references, might be wrong.
886 Use dwarf_getmacros. */
887 extern ptrdiff_t dwarf_getmacros_off (Dwarf *dbg, Dwarf_Off macoff,
888 int (*callback) (Dwarf_Macro *, void *),
889 void *arg, ptrdiff_t token)
890 __nonnull_attribute__ (3);
891
892 /* Get the source files used by the macro entry. You shouldn't assume
893 that Dwarf_Files references will remain valid after MACRO becomes
894 invalid. (Which is to say it's only valid within the
895 dwarf_getmacros* callback.) Returns 0 for success or a negative
896 value in case of an error. */
897 extern int dwarf_macro_getsrcfiles (Dwarf *dbg, Dwarf_Macro *macro,
898 Dwarf_Files **files, size_t *nfiles)
899 __nonnull_attribute__ (2, 3, 4);
900
901 /* Return macro opcode. That's a constant that can be either from
902 DW_MACINFO_* domain or DW_MACRO_GNU_* domain. The two domains have
903 compatible values, so it's OK to use either of them for
904 comparisons. The only differences is 0xff, which could be either
905 DW_MACINFO_vendor_ext or a vendor-defined DW_MACRO_* constant. One
906 would need to look if the CU DIE which the iteration was requested
907 for has attribute DW_AT_macro_info, or either of DW_AT_GNU_macros
908 or DW_AT_macros to differentiate the two interpretations. */
909 extern int dwarf_macro_opcode (Dwarf_Macro *macro, unsigned int *opcodep)
910 __nonnull_attribute__ (2);
911
912 /* Get number of parameters of MACRO and store it to *PARAMCNTP. */
913 extern int dwarf_macro_getparamcnt (Dwarf_Macro *macro, size_t *paramcntp);
914
915 /* Get IDX-th parameter of MACRO (numbered from zero), and stores it
916 to *ATTRIBUTE. Returns 0 on success or -1 for errors.
917
918 After a successful call, you can query ATTRIBUTE by dwarf_whatform
919 to determine which of the dwarf_formX calls to make to get actual
920 value out of ATTRIBUTE. Note that calling dwarf_whatattr is not
921 meaningful for pseudo-attributes formed this way. */
922 extern int dwarf_macro_param (Dwarf_Macro *macro, size_t idx,
923 Dwarf_Attribute *attribute);
924
925 /* Return macro parameter with index 0. This will return -1 if the
926 parameter is not an integral value. Use dwarf_macro_param for more
927 general access. */
928 extern int dwarf_macro_param1 (Dwarf_Macro *macro, Dwarf_Word *paramp)
929 __nonnull_attribute__ (2);
930
931 /* Return macro parameter with index 1. This will return -1 if the
932 parameter is not an integral or string value. Use
933 dwarf_macro_param for more general access. */
934 extern int dwarf_macro_param2 (Dwarf_Macro *macro, Dwarf_Word *paramp,
935 const char **strp);
936
937 /* Compute what's known about a call frame when the PC is at ADDRESS.
938 Returns 0 for success or -1 for errors.
939 On success, *FRAME is a malloc'd pointer. */
940 extern int dwarf_cfi_addrframe (Dwarf_CFI *cache,
941 Dwarf_Addr address, Dwarf_Frame **frame)
942 __nonnull_attribute__ (3);
943
944 /* Return the DWARF register number used in FRAME to denote
945 the return address in FRAME's caller frame. The remaining
946 arguments can be non-null to fill in more information.
947
948 Fill [*START, *END) with the PC range to which FRAME's information applies.
949 Fill in *SIGNALP to indicate whether this is a signal-handling frame.
950 If true, this is the implicit call frame that calls a signal handler.
951 This frame's "caller" is actually the interrupted state, not a call;
952 its return address is an exact PC, not a PC after a call instruction. */
953 extern int dwarf_frame_info (Dwarf_Frame *frame,
954 Dwarf_Addr *start, Dwarf_Addr *end, bool *signalp);
955
956 /* Return a DWARF expression that yields the Canonical Frame Address at
957 this frame state. Returns -1 for errors, or zero for success, with
958 *NOPS set to the number of operations stored at *OPS. That pointer
959 can be used only as long as FRAME is alive and unchanged. *NOPS is
960 zero if the CFA cannot be determined here. Note that if nonempty,
961 *OPS is a DWARF expression, not a location description--append
962 DW_OP_stack_value to a get a location description for the CFA. */
963 extern int dwarf_frame_cfa (Dwarf_Frame *frame, Dwarf_Op **ops, size_t *nops)
964 __nonnull_attribute__ (2);
965
966 /* Deliver a DWARF location description that yields the location or
967 value of DWARF register number REGNO in the state described by FRAME.
968
969 Returns -1 for errors or zero for success, setting *NOPS to the
970 number of operations in the array stored at *OPS. Note the last
971 operation is DW_OP_stack_value if there is no mutable location but
972 only a computable value.
973
974 *NOPS zero with *OPS set to OPS_MEM means CFI says the caller's
975 REGNO is "undefined", i.e. it's call-clobbered and cannot be recovered.
976
977 *NOPS zero with *OPS set to a null pointer means CFI says the
978 caller's REGNO is "same_value", i.e. this frame did not change it;
979 ask the caller frame where to find it.
980
981 For common simple expressions *OPS is OPS_MEM. For arbitrary DWARF
982 expressions in the CFI, *OPS is an internal pointer that can be used as
983 long as the Dwarf_CFI used to create FRAME remains alive. */
984 extern int dwarf_frame_register (Dwarf_Frame *frame, int regno,
985 Dwarf_Op ops_mem[3],
986 Dwarf_Op **ops, size_t *nops)
987 __nonnull_attribute__ (3, 4, 5);
988
989
990 /* Return error code of last failing function call. This value is kept
991 separately for each thread. */
992 extern int dwarf_errno (void);
993
994 /* Return error string for ERROR. If ERROR is zero, return error string
995 for most recent error or NULL is none occurred. If ERROR is -1 the
996 behaviour is similar to the last case except that not NULL but a legal
997 string is returned. */
998 extern const char *dwarf_errmsg (int err);
999
1000
1001 /* Register new Out-Of-Memory handler. The old handler is returned. */
1002 extern Dwarf_OOM dwarf_new_oom_handler (Dwarf *dbg, Dwarf_OOM handler);
1003
1004
1005 /* Inline optimizations. */
1006 #ifdef __OPTIMIZE__
1007 /* Return attribute code of given attribute. */
1008 __libdw_extern_inline unsigned int
dwarf_whatattr(Dwarf_Attribute * attr)1009 dwarf_whatattr (Dwarf_Attribute *attr)
1010 {
1011 return attr == NULL ? 0 : attr->code;
1012 }
1013
1014 /* Return attribute code of given attribute. */
1015 __libdw_extern_inline unsigned int
dwarf_whatform(Dwarf_Attribute * attr)1016 dwarf_whatform (Dwarf_Attribute *attr)
1017 {
1018 return attr == NULL ? 0 : attr->form;
1019 }
1020 #endif /* Optimize. */
1021
1022 #ifdef __cplusplus
1023 }
1024 #endif
1025
1026 #endif /* libdw.h */
1027