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