Branch data Line data Source code
1 : : /* Internal definitions for libdw.
2 : : Copyright (C) 2002-2011, 2013-2018 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 _LIBDWP_H
30 : : #define _LIBDWP_H 1
31 : :
32 : : #include <libintl.h>
33 : : #include <stdbool.h>
34 : : #include <pthread.h>
35 : :
36 : : #include <libdw.h>
37 : : #include <dwarf.h>
38 : : #include "atomics.h"
39 : :
40 : :
41 : : /* Known location expressions already decoded. */
42 : : struct loc_s
43 : : {
44 : : void *addr;
45 : : Dwarf_Op *loc;
46 : : size_t nloc;
47 : : };
48 : :
49 : : /* Known DW_OP_implicit_value blocks already decoded.
50 : : This overlaps struct loc_s exactly, but only the
51 : : first member really has to match. */
52 : : struct loc_block_s
53 : : {
54 : : void *addr;
55 : : unsigned char *data;
56 : : size_t length;
57 : : };
58 : :
59 : : /* Already decoded .debug_line units. */
60 : : struct files_lines_s
61 : : {
62 : : Dwarf_Off debug_line_offset;
63 : : Dwarf_Files *files;
64 : : Dwarf_Lines *lines;
65 : : };
66 : :
67 : : /* Valid indices for the section data. */
68 : : enum
69 : : {
70 : : IDX_debug_info = 0,
71 : : IDX_debug_types,
72 : : IDX_debug_abbrev,
73 : : IDX_debug_aranges,
74 : : IDX_debug_addr,
75 : : IDX_debug_line,
76 : : IDX_debug_line_str,
77 : : IDX_debug_frame,
78 : : IDX_debug_loc,
79 : : IDX_debug_loclists,
80 : : IDX_debug_pubnames,
81 : : IDX_debug_str,
82 : : IDX_debug_str_offsets,
83 : : IDX_debug_macinfo,
84 : : IDX_debug_macro,
85 : : IDX_debug_ranges,
86 : : IDX_debug_rnglists,
87 : : IDX_gnu_debugaltlink,
88 : : IDX_last
89 : : };
90 : :
91 : :
92 : : /* Error values. */
93 : : enum
94 : : {
95 : : DWARF_E_NOERROR = 0,
96 : : DWARF_E_UNKNOWN_ERROR,
97 : : DWARF_E_INVALID_ACCESS,
98 : : DWARF_E_NO_REGFILE,
99 : : DWARF_E_IO_ERROR,
100 : : DWARF_E_INVALID_ELF,
101 : : DWARF_E_NO_DWARF,
102 : : DWARF_E_COMPRESSED_ERROR,
103 : : DWARF_E_NOELF,
104 : : DWARF_E_GETEHDR_ERROR,
105 : : DWARF_E_NOMEM,
106 : : DWARF_E_UNIMPL,
107 : : DWARF_E_INVALID_CMD,
108 : : DWARF_E_INVALID_VERSION,
109 : : DWARF_E_INVALID_FILE,
110 : : DWARF_E_NO_ENTRY,
111 : : DWARF_E_INVALID_DWARF,
112 : : DWARF_E_NO_STRING,
113 : : DWARF_E_NO_DEBUG_STR,
114 : : DWARF_E_NO_DEBUG_LINE_STR,
115 : : DWARF_E_NO_STR_OFFSETS,
116 : : DWARF_E_NO_ADDR,
117 : : DWARF_E_NO_CONSTANT,
118 : : DWARF_E_NO_REFERENCE,
119 : : DWARF_E_INVALID_REFERENCE,
120 : : DWARF_E_NO_DEBUG_LINE,
121 : : DWARF_E_INVALID_DEBUG_LINE,
122 : : DWARF_E_TOO_BIG,
123 : : DWARF_E_VERSION,
124 : : DWARF_E_INVALID_DIR_IDX,
125 : : DWARF_E_ADDR_OUTOFRANGE,
126 : : DWARF_E_NO_DEBUG_LOC,
127 : : DWARF_E_NO_DEBUG_LOCLISTS,
128 : : DWARF_E_NO_LOC_VALUE,
129 : : DWARF_E_NO_BLOCK,
130 : : DWARF_E_INVALID_LINE_IDX,
131 : : DWARF_E_INVALID_ARANGE_IDX,
132 : : DWARF_E_NO_MATCH,
133 : : DWARF_E_NO_FLAG,
134 : : DWARF_E_INVALID_OFFSET,
135 : : DWARF_E_NO_DEBUG_RANGES,
136 : : DWARF_E_NO_DEBUG_RNGLISTS,
137 : : DWARF_E_INVALID_CFI,
138 : : DWARF_E_NO_ALT_DEBUGLINK,
139 : : DWARF_E_INVALID_OPCODE,
140 : : DWARF_E_NOT_CUDIE,
141 : : DWARF_E_UNKNOWN_LANGUAGE,
142 : : DWARF_E_NO_DEBUG_ADDR,
143 : : };
144 : :
145 : :
146 : : #include "dwarf_sig8_hash.h"
147 : :
148 : : /* This is the structure representing the debugging state. */
149 : : struct Dwarf
150 : : {
151 : : /* The underlying ELF file. */
152 : : Elf *elf;
153 : :
154 : : /* The (absolute) path to the ELF dir, if known. To help locating
155 : : alt and dwo files. */
156 : : char *debugdir;
157 : :
158 : : /* dwz alternate DWARF file. */
159 : : Dwarf *alt_dwarf;
160 : :
161 : : /* The section data. */
162 : : Elf_Data *sectiondata[IDX_last];
163 : :
164 : : /* True if the file has a byte order different from the host. */
165 : : bool other_byte_order;
166 : :
167 : : /* If true, we allocated the ELF descriptor ourselves. */
168 : : bool free_elf;
169 : :
170 : : /* If >= 0, we allocated the alt_dwarf ourselves and must end it and
171 : : close this file descriptor. */
172 : : int alt_fd;
173 : :
174 : : /* Information for traversing the .debug_pubnames section. This is
175 : : an array and separately allocated with malloc. */
176 : : struct pubnames_s
177 : : {
178 : : Dwarf_Off cu_offset;
179 : : Dwarf_Off set_start;
180 : : unsigned int cu_header_size;
181 : : int address_len;
182 : : } *pubnames_sets;
183 : : size_t pubnames_nsets;
184 : :
185 : : /* Search tree for the CUs. */
186 : : void *cu_tree;
187 : : Dwarf_Off next_cu_offset;
188 : :
189 : : /* Search tree and sig8 hash table for .debug_types type units. */
190 : : void *tu_tree;
191 : : Dwarf_Off next_tu_offset;
192 : : Dwarf_Sig8_Hash sig8_hash;
193 : :
194 : : /* Search tree for split Dwarf associated with CUs in this debug. */
195 : : void *split_tree;
196 : :
197 : : /* Search tree for .debug_macro operator tables. */
198 : : void *macro_ops;
199 : :
200 : : /* Search tree for decoded .debug_line units. */
201 : : void *files_lines;
202 : :
203 : : /* Address ranges. */
204 : : Dwarf_Aranges *aranges;
205 : :
206 : : /* Cached info from the CFI section. */
207 : : struct Dwarf_CFI_s *cfi;
208 : :
209 : : /* Fake loc CU. Used when synthesizing attributes for Dwarf_Ops that
210 : : came from a location list entry in dwarf_getlocation_attr.
211 : : Depending on version this is the .debug_loc or .debug_loclists
212 : : section (could be both if mixing CUs with different DWARF versions). */
213 : : struct Dwarf_CU *fake_loc_cu;
214 : : struct Dwarf_CU *fake_loclists_cu;
215 : :
216 : : /* Similar for addrx/constx, which will come from .debug_addr section. */
217 : : struct Dwarf_CU *fake_addr_cu;
218 : :
219 : : /* Supporting lock for internal memory handling. Ensures threads that have
220 : : an entry in the mem_tails array are not disturbed by new threads doing
221 : : allocations for this Dwarf. */
222 : : pthread_rwlock_t mem_rwl;
223 : :
224 : : /* Internal memory handling. This is basically a simplified thread-local
225 : : reimplementation of obstacks. Unfortunately the standard obstack
226 : : implementation is not usable in libraries. */
227 : : size_t mem_stacks;
228 : : struct libdw_memblock
229 : : {
230 : : size_t size;
231 : : size_t remaining;
232 : : struct libdw_memblock *prev;
233 : : char mem[0];
234 : : } **mem_tails;
235 : :
236 : : /* Default size of allocated memory blocks. */
237 : : size_t mem_default_size;
238 : :
239 : : /* Registered OOM handler. */
240 : : Dwarf_OOM oom_handler;
241 : : };
242 : :
243 : :
244 : : /* Abbreviation representation. */
245 : : struct Dwarf_Abbrev
246 : : {
247 : : Dwarf_Off offset; /* Offset to start of abbrev into .debug_abbrev. */
248 : : unsigned char *attrp; /* Pointer to start of attribute name/form pairs. */
249 : : bool has_children : 1; /* Whether or not the DIE has children. */
250 : : unsigned int code : 31; /* The (unique) abbrev code. */
251 : : unsigned int tag; /* The tag of the DIE. */
252 : : } attribute_packed;
253 : :
254 : : #include "dwarf_abbrev_hash.h"
255 : :
256 : :
257 : : /* Files in line information records. */
258 : : struct Dwarf_Files_s
259 : : {
260 : : unsigned int ndirs;
261 : : unsigned int nfiles;
262 : : struct Dwarf_Fileinfo_s
263 : : {
264 : : char *name;
265 : : Dwarf_Word mtime;
266 : : Dwarf_Word length;
267 : : } info[0];
268 : : /* nfiles of those, followed by char *[ndirs]. */
269 : : };
270 : : typedef struct Dwarf_Fileinfo_s Dwarf_Fileinfo;
271 : :
272 : :
273 : : /* Representation of a row in the line table. */
274 : :
275 : : struct Dwarf_Line_s
276 : : {
277 : : Dwarf_Files *files;
278 : :
279 : : Dwarf_Addr addr;
280 : : unsigned int file;
281 : : int line;
282 : : unsigned short int column;
283 : : unsigned int is_stmt:1;
284 : : unsigned int basic_block:1;
285 : : unsigned int end_sequence:1;
286 : : unsigned int prologue_end:1;
287 : : unsigned int epilogue_begin:1;
288 : : /* The remaining bit fields are not flags, but hold values presumed to be
289 : : small. All the flags and other bit fields should add up to 48 bits
290 : : to give the whole struct a nice round size. */
291 : : unsigned int op_index:8;
292 : : unsigned int isa:8;
293 : : unsigned int discriminator:24;
294 : : };
295 : :
296 : : struct Dwarf_Lines_s
297 : : {
298 : : size_t nlines;
299 : : struct Dwarf_Line_s info[0];
300 : : };
301 : :
302 : : /* Representation of address ranges. */
303 : : struct Dwarf_Aranges_s
304 : : {
305 : : Dwarf *dbg;
306 : : size_t naranges;
307 : :
308 : : struct Dwarf_Arange_s
309 : : {
310 : : Dwarf_Addr addr;
311 : : Dwarf_Word length;
312 : : Dwarf_Off offset;
313 : : } info[0];
314 : : };
315 : :
316 : :
317 : : /* CU representation. */
318 : : struct Dwarf_CU
319 : : {
320 : : Dwarf *dbg;
321 : : Dwarf_Off start;
322 : : Dwarf_Off end;
323 : : uint8_t address_size;
324 : : uint8_t offset_size;
325 : : uint16_t version;
326 : :
327 : : size_t sec_idx; /* Normally .debug_info, could be .debug_type or "fake". */
328 : :
329 : : /* The unit type if version >= 5. Otherwise 0 for normal CUs (from
330 : : .debug_info) or 1 for v4 type units (from .debug_types). */
331 : : uint8_t unit_type;
332 : :
333 : : /* Zero if the unit type doesn't support a die/type offset and/or id/sig.
334 : : Nonzero if it is a v4 type unit or for DWARFv5 units depending on
335 : : unit_type. */
336 : : size_t subdie_offset;
337 : : uint64_t unit_id8;
338 : :
339 : : /* If this is a skeleton unit this points to the split compile unit.
340 : : Or the other way around if this is a split compile unit. Set to -1
341 : : if not yet searched. Always use __libdw_find_split_unit to access
342 : : this field. */
343 : : struct Dwarf_CU *split;
344 : :
345 : : /* Hash table for the abbreviations. */
346 : : Dwarf_Abbrev_Hash abbrev_hash;
347 : : /* Offset of the first abbreviation. */
348 : : size_t orig_abbrev_offset;
349 : : /* Offset past last read abbreviation. */
350 : : size_t last_abbrev_offset;
351 : :
352 : : /* The srcline information. */
353 : : Dwarf_Lines *lines;
354 : :
355 : : /* The source file information. */
356 : : Dwarf_Files *files;
357 : :
358 : : /* Known location lists. */
359 : : void *locs;
360 : :
361 : : /* Base address for use with ranges and locs.
362 : : Don't access directly, call __libdw_cu_base_address. */
363 : : Dwarf_Addr base_address;
364 : :
365 : : /* The offset into the .debug_addr section where index zero begins.
366 : : Don't access directly, call __libdw_cu_addr_base. */
367 : : Dwarf_Off addr_base;
368 : :
369 : : /* The offset into the .debug_str_offsets section where index zero begins.
370 : : Don't access directly, call __libdw_cu_str_off_base. */
371 : : Dwarf_Off str_off_base;
372 : :
373 : : /* The offset into the .debug_ranges section to use for GNU
374 : : DebugFission split units. Don't access directly, call
375 : : __libdw_cu_ranges_base. */
376 : : Dwarf_Off ranges_base;
377 : :
378 : : /* The start of the offset table in .debug_loclists.
379 : : Don't access directly, call __libdw_cu_locs_base. */
380 : : Dwarf_Off locs_base;
381 : :
382 : : /* Memory boundaries of this CU. */
383 : : void *startp;
384 : : void *endp;
385 : : };
386 : :
387 : : #define ISV4TU(cu) ((cu)->version == 4 && (cu)->sec_idx == IDX_debug_types)
388 : :
389 : : /* Compute the offset of a CU's first DIE from the CU offset.
390 : : CU must be a valid/known version/unit_type. */
391 : : static inline Dwarf_Off
392 : 3038402 : __libdw_first_die_from_cu_start (Dwarf_Off cu_start,
393 : : uint8_t offset_size,
394 : : uint16_t version,
395 : : uint8_t unit_type)
396 : : {
397 : : /*
398 : : assert (offset_size == 4 || offset_size == 8);
399 : : assert (version >= 2 && version <= 5);
400 : : assert (unit_type == DW_UT_compile
401 : : || unit_type == DW_UT_partial
402 : : || unit_type == DW_UT_skeleton
403 : : || unit_type == DW_UT_split_compile
404 : : || unit_type == DW_UT_type
405 : : || unit_type == DW_UT_split_type);
406 : : */
407 : :
408 : 3038402 : Dwarf_Off off = cu_start;
409 [ + + ]: 3038402 : if (version < 5)
410 : : {
411 : : /*
412 : : LEN VER OFFSET ADDR
413 : : 4-bytes + 2-bytes + 4-bytes + 1-byte for 32-bit dwarf
414 : : 12-bytes + 2-bytes + 8-bytes + 1-byte for 64-bit dwarf
415 : : or in .debug_types, SIGNATURE TYPE-OFFSET
416 : : 4-bytes + 2-bytes + 4-bytes + 1-byte + 8-bytes + 4-bytes for 32-bit
417 : : 12-bytes + 2-bytes + 8-bytes + 1-byte + 8-bytes + 8-bytes for 64-bit
418 : :
419 : : Note the trick in the computation. If the offset_size is 4
420 : : the '- 4' term changes the '3 *' (or '4 *') into a '2 *' (or '3 *).
421 : : If the offset_size is 8 it accounts for the 4-byte escape value
422 : : used at the start of the length. */
423 [ + + ]: 3037680 : if (unit_type != DW_UT_type)
424 : 3037629 : off += 3 * offset_size - 4 + 3;
425 : : else
426 : 51 : off += 4 * offset_size - 4 + 3 + 8;
427 : : }
428 : : else
429 : : {
430 : : /*
431 : : LEN VER TYPE ADDR OFFSET SIGNATURE TYPE-OFFSET
432 : : 4-bytes + 2-bytes + 1-byte + 1-byte + 4-bytes + 8-bytes + 4-bytes 32-bit
433 : : 12-bytes + 2-bytes + 1-byte + 1-byte + 8-bytes + 8-bytes + 8-bytes 64-bit
434 : : Both signature and type offset are optional.
435 : :
436 : : Note same 4/8 offset size trick as above.
437 : : We explicitly ignore unknown unit types (see asserts above). */
438 : 722 : off += 3 * offset_size - 4 + 4;
439 : 722 : if (unit_type == DW_UT_skeleton || unit_type == DW_UT_split_compile
440 [ + + - + ]: 722 : || unit_type == DW_UT_type || unit_type == DW_UT_split_type)
441 : : {
442 : 601 : off += 8;
443 [ - + ]: 601 : if (unit_type == DW_UT_type || unit_type == DW_UT_split_type)
444 : 0 : off += offset_size;
445 : : }
446 : : }
447 : :
448 : 3038402 : return off;
449 : : }
450 : :
451 : : static inline Dwarf_Off
452 : 3002391 : __libdw_first_die_off_from_cu (struct Dwarf_CU *cu)
453 : : {
454 : 3002391 : return __libdw_first_die_from_cu_start (cu->start,
455 : : cu->offset_size,
456 : : cu->version,
457 : : cu->unit_type);
458 : : }
459 : :
460 : : #define CUDIE(fromcu) \
461 : : ((Dwarf_Die) \
462 : : { \
463 : : .cu = (fromcu), \
464 : : .addr = ((char *) (fromcu)->dbg->sectiondata[cu_sec_idx (fromcu)]->d_buf \
465 : : + __libdw_first_die_off_from_cu (fromcu)) \
466 : : })
467 : :
468 : : #define SUBDIE(fromcu) \
469 : : ((Dwarf_Die) \
470 : : { \
471 : : .cu = (fromcu), \
472 : : .addr = ((char *) (fromcu)->dbg->sectiondata[cu_sec_idx (fromcu)]->d_buf \
473 : : + (fromcu)->start + (fromcu)->subdie_offset) \
474 : : })
475 : :
476 : :
477 : : /* Prototype of a single .debug_macro operator. */
478 : : typedef struct
479 : : {
480 : : Dwarf_Word nforms;
481 : : unsigned char const *forms;
482 : : } Dwarf_Macro_Op_Proto;
483 : :
484 : : /* Prototype table. */
485 : : typedef struct
486 : : {
487 : : /* Offset of .debug_macro section. */
488 : : Dwarf_Off offset;
489 : :
490 : : /* Offset of associated .debug_line section. */
491 : : Dwarf_Off line_offset;
492 : :
493 : : /* The source file information. */
494 : : Dwarf_Files *files;
495 : :
496 : : /* If this macro unit was opened through dwarf_getmacros or
497 : : dwarf_getmacros_die, this caches value of DW_AT_comp_dir, if
498 : : present. */
499 : : const char *comp_dir;
500 : :
501 : : /* Header length. */
502 : : Dwarf_Half header_len;
503 : :
504 : : uint16_t version;
505 : : bool is_64bit;
506 : : uint8_t sec_index; /* IDX_debug_macro or IDX_debug_macinfo. */
507 : :
508 : : /* Shows where in TABLE each opcode is defined. Since opcode 0 is
509 : : never used, it stores index of opcode X in X-1'th element. The
510 : : value of 0xff means not stored at all. */
511 : : unsigned char opcodes[255];
512 : :
513 : : /* Individual opcode prototypes. */
514 : : Dwarf_Macro_Op_Proto table[];
515 : : } Dwarf_Macro_Op_Table;
516 : :
517 : : struct Dwarf_Macro_s
518 : : {
519 : : Dwarf_Macro_Op_Table *table;
520 : : Dwarf_Attribute *attributes;
521 : : uint8_t opcode;
522 : : };
523 : :
524 : : static inline Dwarf_Word
525 : 648 : libdw_macro_nforms (Dwarf_Macro *macro)
526 : : {
527 [ + - ]: 648 : return macro->table->table[macro->table->opcodes[macro->opcode - 1]].nforms;
528 : : }
529 : :
530 : : /* Returns true for any allowed FORM in the opcode_operands_table as
531 : : mentioned in the DWARF5 spec (6.3.1 Macro Information Header).
532 : : Or those mentioned in DWARF5 spec (6.2.4.2 Vendor-defined Content
533 : : Descriptions) for the directory/file table (plus DW_FORM_strp_sup). */
534 : : static inline bool
535 : 1394 : libdw_valid_user_form (int form)
536 : : {
537 [ - + ]: 1394 : switch (form)
538 : : {
539 : : case DW_FORM_block:
540 : : case DW_FORM_block1:
541 : : case DW_FORM_block2:
542 : : case DW_FORM_block4:
543 : : case DW_FORM_data1:
544 : : case DW_FORM_data2:
545 : : case DW_FORM_data4:
546 : : case DW_FORM_data8:
547 : : case DW_FORM_data16:
548 : : case DW_FORM_flag:
549 : : case DW_FORM_line_strp:
550 : : case DW_FORM_sdata:
551 : : case DW_FORM_sec_offset:
552 : : case DW_FORM_string:
553 : : case DW_FORM_strp:
554 : : case DW_FORM_strp_sup:
555 : : case DW_FORM_strx:
556 : : case DW_FORM_strx1:
557 : : case DW_FORM_strx2:
558 : : case DW_FORM_strx3:
559 : : case DW_FORM_strx4:
560 : : case DW_FORM_udata:
561 : : return true;
562 : 0 : default:
563 : 0 : return false;
564 : : }
565 : : }
566 : :
567 : :
568 : : /* We have to include the file at this point because the inline
569 : : functions access internals of the Dwarf structure. */
570 : : #include "memory-access.h"
571 : :
572 : :
573 : : /* Set error value. */
574 : : extern void __libdw_seterrno (int value) internal_function;
575 : :
576 : :
577 : : /* Memory handling, the easy parts. */
578 : : #define libdw_alloc(dbg, type, tsize, cnt) \
579 : : ({ struct libdw_memblock *_tail = __libdw_alloc_tail(dbg); \
580 : : size_t _required = (tsize) * (cnt); \
581 : : type *_result = (type *) (_tail->mem + (_tail->size - _tail->remaining));\
582 : : size_t _padding = ((__alignof (type) \
583 : : - ((uintptr_t) _result & (__alignof (type) - 1))) \
584 : : & (__alignof (type) - 1)); \
585 : : if (unlikely (_tail->remaining < _required + _padding)) \
586 : : _result = (type *) __libdw_allocate (dbg, _required, __alignof (type));\
587 : : else \
588 : : { \
589 : : _required += _padding; \
590 : : _result = (type *) ((char *) _result + _padding); \
591 : : _tail->remaining -= _required; \
592 : : } \
593 : : _result; })
594 : :
595 : : #define libdw_typed_alloc(dbg, type) \
596 : : libdw_alloc (dbg, type, sizeof (type), 1)
597 : :
598 : : /* Can only be used to undo the last libdw_alloc. */
599 : : #define libdw_unalloc(dbg, type, tsize, cnt) \
600 : : ({ struct libdw_memblock *_tail = __libdw_thread_tail (dbg); \
601 : : size_t _required = (tsize) * (cnt); \
602 : : /* We cannot know the padding, it is lost. */ \
603 : : _tail->remaining += _required; }) \
604 : :
605 : : #define libdw_typed_unalloc(dbg, type) \
606 : : libdw_unalloc (dbg, type, sizeof (type), 1)
607 : :
608 : : /* Callback to choose a thread-local memory allocation stack. */
609 : : extern struct libdw_memblock *__libdw_alloc_tail (Dwarf* dbg)
610 : : __nonnull_attribute__ (1);
611 : :
612 : : extern struct libdw_memblock *__libdw_thread_tail (Dwarf* dbg)
613 : : __nonnull_attribute__ (1);
614 : :
615 : : /* Callback to allocate more. */
616 : : extern void *__libdw_allocate (Dwarf *dbg, size_t minsize, size_t align)
617 : : __attribute__ ((__malloc__)) __nonnull_attribute__ (1);
618 : :
619 : : /* Default OOM handler. */
620 : : extern void __libdw_oom (void) __attribute ((noreturn)) attribute_hidden;
621 : :
622 : : /* Read next unit (or v4 debug type) and return next offset. Doesn't
623 : : create an actual Dwarf_CU just provides necessary header fields. */
624 : : extern int
625 : : internal_function
626 : : __libdw_next_unit (Dwarf *dbg, bool v4_debug_types, Dwarf_Off off,
627 : : Dwarf_Off *next_off, size_t *header_sizep,
628 : : Dwarf_Half *versionp, uint8_t *unit_typep,
629 : : Dwarf_Off *abbrev_offsetp, uint8_t *address_sizep,
630 : : uint8_t *offset_sizep, uint64_t *unit_id8p,
631 : : Dwarf_Off *subdie_offsetp)
632 : : __nonnull_attribute__ (4) internal_function;
633 : :
634 : : /* Allocate the internal data for a unit not seen before. */
635 : : extern struct Dwarf_CU *__libdw_intern_next_unit (Dwarf *dbg, bool debug_types)
636 : : __nonnull_attribute__ (1) internal_function;
637 : :
638 : : /* Find CU for given offset. */
639 : : extern struct Dwarf_CU *__libdw_findcu (Dwarf *dbg, Dwarf_Off offset, bool tu)
640 : : __nonnull_attribute__ (1) internal_function;
641 : :
642 : : /* Find CU for given DIE address. */
643 : : extern struct Dwarf_CU *__libdw_findcu_addr (Dwarf *dbg, void *addr)
644 : : __nonnull_attribute__ (1) internal_function;
645 : :
646 : : /* Find split Dwarf for given DIE address. */
647 : : extern struct Dwarf *__libdw_find_split_dbg_addr (Dwarf *dbg, void *addr)
648 : : __nonnull_attribute__ (1) internal_function;
649 : :
650 : : /* Find the split (or skeleton) unit. */
651 : : extern struct Dwarf_CU *__libdw_find_split_unit (Dwarf_CU *cu)
652 : : internal_function;
653 : :
654 : : /* Get abbreviation with given code. */
655 : : extern Dwarf_Abbrev *__libdw_findabbrev (struct Dwarf_CU *cu,
656 : : unsigned int code)
657 : : __nonnull_attribute__ (1) internal_function;
658 : :
659 : : /* Get abbreviation at given offset. */
660 : : extern Dwarf_Abbrev *__libdw_getabbrev (Dwarf *dbg, struct Dwarf_CU *cu,
661 : : Dwarf_Off offset, size_t *lengthp,
662 : : Dwarf_Abbrev *result)
663 : : __nonnull_attribute__ (1) internal_function;
664 : :
665 : : /* Get abbreviation of given DIE, and optionally set *READP to the DIE memory
666 : : just past the abbreviation code. */
667 : : static inline Dwarf_Abbrev *
668 : : __nonnull_attribute__ (1)
669 : 66779331 : __libdw_dieabbrev (Dwarf_Die *die, const unsigned char **readp)
670 : : {
671 : : /* Do we need to get the abbreviation, or need to read after the code? */
672 [ + + + + ]: 66779331 : if (die->abbrev == NULL || readp != NULL)
673 : : {
674 : : /* Get the abbreviation code. */
675 : 36179302 : unsigned int code;
676 : 36179302 : const unsigned char *addr = die->addr;
677 [ + + - + ]: 36179302 : if (unlikely (die->cu == NULL
678 : : || addr >= (const unsigned char *) die->cu->endp))
679 : 11128 : return die->abbrev = DWARF_END_ABBREV;
680 : 36168174 : get_uleb128 (code, addr, die->cu->endp);
681 [ + + ]: 36168174 : if (readp != NULL)
682 : 23631116 : *readp = addr;
683 : :
684 : : /* Find the abbreviation. */
685 [ + + ]: 36168174 : if (die->abbrev == NULL)
686 : 16478654 : die->abbrev = __libdw_findabbrev (die->cu, code);
687 : : }
688 : 66768203 : return die->abbrev;
689 : : }
690 : :
691 : : /* Helper functions for form handling. */
692 : : extern size_t __libdw_form_val_compute_len (struct Dwarf_CU *cu,
693 : : unsigned int form,
694 : : const unsigned char *valp)
695 : : __nonnull_attribute__ (1, 3) internal_function;
696 : :
697 : : /* Find the length of a form attribute in DIE/info data. */
698 : : static inline size_t
699 : : __nonnull_attribute__ (1, 3)
700 : 91898482 : __libdw_form_val_len (struct Dwarf_CU *cu, unsigned int form,
701 : : const unsigned char *valp)
702 : : {
703 : : /* Small lookup table of forms with fixed lengths. Absent indexes are
704 : : initialized 0, so any truly desired 0 is set to 0x80 and masked. */
705 : 91898482 : static const uint8_t form_lengths[] =
706 : : {
707 : : [DW_FORM_flag_present] = 0x80,
708 : : [DW_FORM_implicit_const] = 0x80, /* Value is in abbrev, not in info. */
709 : :
710 : : [DW_FORM_flag] = 1,
711 : : [DW_FORM_data1] = 1, [DW_FORM_ref1] = 1,
712 : : [DW_FORM_addrx1] = 1, [DW_FORM_strx1] = 1,
713 : :
714 : : [DW_FORM_data2] = 2, [DW_FORM_ref2] = 2,
715 : : [DW_FORM_addrx2] = 2, [DW_FORM_strx2] = 2,
716 : :
717 : : [DW_FORM_addrx3] = 3, [DW_FORM_strx3] = 3,
718 : :
719 : : [DW_FORM_data4] = 4, [DW_FORM_ref4] = 4, [DW_FORM_ref_sup4] = 4,
720 : : [DW_FORM_addrx4] = 4, [DW_FORM_strx4] = 4,
721 : :
722 : : [DW_FORM_ref_sig8] = 8,
723 : : [DW_FORM_data8] = 8, [DW_FORM_ref8] = 8, [DW_FORM_ref_sup8] = 8,
724 : :
725 : : [DW_FORM_data16] = 16,
726 : : };
727 : :
728 : : /* Return immediately for forms with fixed lengths. */
729 [ + + ]: 91898482 : if (form < sizeof form_lengths / sizeof form_lengths[0])
730 : : {
731 : 91895938 : uint8_t len = form_lengths[form];
732 [ + + ]: 91895938 : if (len != 0)
733 : : {
734 : 65639679 : const unsigned char *endp = cu->endp;
735 : 65639679 : len &= 0x7f; /* Mask to allow 0x80 -> 0. */
736 [ - + ]: 65639679 : if (unlikely (len > (size_t) (endp - valp)))
737 : : {
738 : 0 : __libdw_seterrno (DWARF_E_INVALID_DWARF);
739 : 0 : return -1;
740 : : }
741 : : return len;
742 : : }
743 : : }
744 : :
745 : : /* Other forms require some computation. */
746 : 26258803 : return __libdw_form_val_compute_len (cu, form, valp);
747 : : }
748 : :
749 : : /* Helper function for DW_FORM_ref* handling. */
750 : : extern int __libdw_formref (Dwarf_Attribute *attr, Dwarf_Off *return_offset)
751 : : __nonnull_attribute__ (1, 2) internal_function;
752 : :
753 : :
754 : : /* Helper function to locate attribute. */
755 : : extern unsigned char *__libdw_find_attr (Dwarf_Die *die,
756 : : unsigned int search_name,
757 : : unsigned int *codep,
758 : : unsigned int *formp)
759 : : __nonnull_attribute__ (1) internal_function;
760 : :
761 : : /* Helper function to access integer attribute. */
762 : : extern int __libdw_attr_intval (Dwarf_Die *die, int *valp, int attval)
763 : : __nonnull_attribute__ (1, 2) internal_function;
764 : :
765 : : /* Helper function to walk scopes. */
766 : : struct Dwarf_Die_Chain
767 : : {
768 : : Dwarf_Die die;
769 : : struct Dwarf_Die_Chain *parent;
770 : : bool prune; /* The PREVISIT function can set this. */
771 : : };
772 : : extern int __libdw_visit_scopes (unsigned int depth,
773 : : struct Dwarf_Die_Chain *root,
774 : : struct Dwarf_Die_Chain *imports,
775 : : int (*previsit) (unsigned int depth,
776 : : struct Dwarf_Die_Chain *,
777 : : void *arg),
778 : : int (*postvisit) (unsigned int depth,
779 : : struct Dwarf_Die_Chain *,
780 : : void *arg),
781 : : void *arg)
782 : : __nonnull_attribute__ (2, 4) internal_function;
783 : :
784 : : /* Parse a DWARF Dwarf_Block into an array of Dwarf_Op's,
785 : : and cache the result (via tsearch). */
786 : : extern int __libdw_intern_expression (Dwarf *dbg,
787 : : bool other_byte_order,
788 : : unsigned int address_size,
789 : : unsigned int ref_size,
790 : : void **cache, const Dwarf_Block *block,
791 : : bool cfap, bool valuep,
792 : : Dwarf_Op **llbuf, size_t *listlen,
793 : : int sec_index)
794 : : __nonnull_attribute__ (5, 6, 9, 10) internal_function;
795 : :
796 : : extern Dwarf_Die *__libdw_offdie (Dwarf *dbg, Dwarf_Off offset,
797 : : Dwarf_Die *result, bool debug_types)
798 : : internal_function;
799 : :
800 : :
801 : : /* Return error code of last failing function call. This value is kept
802 : : separately for each thread. */
803 : : extern int __dwarf_errno_internal (void);
804 : :
805 : :
806 : : /* Reader hooks. */
807 : :
808 : : /* Relocation hooks return -1 on error (in that case the error code
809 : : must already have been set), 0 if there is no relocation and 1 if a
810 : : relocation was present.*/
811 : :
812 : : static inline int
813 : 5195920 : __libdw_relocate_address (Dwarf *dbg __attribute__ ((unused)),
814 : : int sec_index __attribute__ ((unused)),
815 : : const void *addr __attribute__ ((unused)),
816 : : int width __attribute__ ((unused)),
817 : : Dwarf_Addr *val __attribute__ ((unused)))
818 : : {
819 [ + + ]: 5195889 : return 0;
820 : : }
821 : :
822 : : static inline int
823 : 1627758 : __libdw_relocate_offset (Dwarf *dbg __attribute__ ((unused)),
824 : : int sec_index __attribute__ ((unused)),
825 : : const void *addr __attribute__ ((unused)),
826 : : int width __attribute__ ((unused)),
827 : : Dwarf_Off *val __attribute__ ((unused)))
828 : : {
829 : 1627758 : return 0;
830 : : }
831 : :
832 : : static inline Elf_Data *
833 : 8821067 : __libdw_checked_get_data (Dwarf *dbg, int sec_index)
834 : : {
835 : 8821067 : Elf_Data *data = dbg->sectiondata[sec_index];
836 [ + - ]: 8821067 : if (unlikely (data == NULL)
837 [ - + ]: 8821067 : || unlikely (data->d_buf == NULL))
838 : : {
839 : 0 : __libdw_seterrno (DWARF_E_INVALID_DWARF);
840 : 0 : return NULL;
841 : : }
842 : : return data;
843 : : }
844 : :
845 : : static inline int
846 : 1635878 : __libdw_offset_in_section (Dwarf *dbg, int sec_index,
847 : : Dwarf_Off offset, size_t size)
848 : : {
849 : 1635878 : Elf_Data *data = __libdw_checked_get_data (dbg, sec_index);
850 [ + - ]: 1635878 : if (data == NULL)
851 : : return -1;
852 [ + - ]: 1635878 : if (unlikely (offset > data->d_size)
853 [ + - ]: 1635878 : || unlikely (data->d_size < size)
854 [ - + ]: 1635878 : || unlikely (offset > data->d_size - size))
855 : : {
856 : 0 : __libdw_seterrno (DWARF_E_INVALID_OFFSET);
857 : 0 : return -1;
858 : : }
859 : :
860 : : return 0;
861 : : }
862 : :
863 : : static inline bool
864 : 7177139 : __libdw_in_section (Dwarf *dbg, int sec_index,
865 : : const void *addr, size_t size)
866 : : {
867 : 7177139 : Elf_Data *data = __libdw_checked_get_data (dbg, sec_index);
868 [ + - ]: 7177139 : if (data == NULL)
869 : : return false;
870 [ + - ]: 7177139 : if (unlikely (addr < data->d_buf)
871 [ + - ]: 7177139 : || unlikely (data->d_size < size)
872 [ - + ]: 7177139 : || unlikely ((size_t)(addr - data->d_buf) > data->d_size - size))
873 : : {
874 : 0 : __libdw_seterrno (DWARF_E_INVALID_OFFSET);
875 : 0 : return false;
876 : : }
877 : :
878 : : return true;
879 : : }
880 : :
881 : : #define READ_AND_RELOCATE(RELOC_HOOK, VAL) \
882 : : ({ \
883 : : if (!__libdw_in_section (dbg, sec_index, addr, width)) \
884 : : return -1; \
885 : : \
886 : : const unsigned char *orig_addr = addr; \
887 : : if (width == 4) \
888 : : VAL = read_4ubyte_unaligned_inc (dbg, addr); \
889 : : else \
890 : : VAL = read_8ubyte_unaligned_inc (dbg, addr); \
891 : : \
892 : : int status = RELOC_HOOK (dbg, sec_index, orig_addr, width, &VAL); \
893 : : if (status < 0) \
894 : : return status; \
895 : : status > 0; \
896 : : })
897 : :
898 : : static inline int
899 : 22180 : __libdw_read_address_inc (Dwarf *dbg,
900 : : int sec_index, const unsigned char **addrp,
901 : : int width, Dwarf_Addr *ret)
902 : : {
903 : 22180 : const unsigned char *addr = *addrp;
904 [ + - + + : 44360 : READ_AND_RELOCATE (__libdw_relocate_address, (*ret));
+ + + + ]
905 : 22180 : *addrp = addr;
906 : 22180 : return 0;
907 : : }
908 : :
909 : : static inline int
910 : 353461 : __libdw_read_address (Dwarf *dbg,
911 : : int sec_index, const unsigned char *addr,
912 : : int width, Dwarf_Addr *ret)
913 : : {
914 [ + - + + : 706922 : READ_AND_RELOCATE (__libdw_relocate_address, (*ret));
+ + + + ]
915 : : return 0;
916 : : }
917 : :
918 : : static inline int
919 : 39640 : __libdw_read_offset_inc (Dwarf *dbg,
920 : : int sec_index, const unsigned char **addrp,
921 : : int width, Dwarf_Off *ret, int sec_ret,
922 : : size_t size)
923 : : {
924 : 39640 : const unsigned char *addr = *addrp;
925 [ + - + - : 79280 : READ_AND_RELOCATE (__libdw_relocate_offset, (*ret));
+ + - - ]
926 : 39640 : *addrp = addr;
927 : 39640 : return __libdw_offset_in_section (dbg, sec_ret, *ret, size);
928 : : }
929 : :
930 : : static inline int
931 : 1588118 : __libdw_read_offset (Dwarf *dbg, Dwarf *dbg_ret,
932 : : int sec_index, const unsigned char *addr,
933 : : int width, Dwarf_Off *ret, int sec_ret,
934 : : size_t size)
935 : : {
936 [ + - + - : 3176236 : READ_AND_RELOCATE (__libdw_relocate_offset, (*ret));
+ + - - ]
937 : 1588118 : return __libdw_offset_in_section (dbg_ret, sec_ret, *ret, size);
938 : : }
939 : :
940 : : static inline size_t
941 : 4894270 : cu_sec_idx (struct Dwarf_CU *cu)
942 : : {
943 [ + + + + : 4111695 : return cu->sec_idx;
+ - - + ]
944 : : }
945 : :
946 : : static inline bool
947 : 2193269 : is_cudie (Dwarf_Die *cudie)
948 : : {
949 [ + + + + ]: 2193269 : return cudie->cu != NULL && CUDIE (cudie->cu).addr == cudie->addr;
950 : : }
951 : :
952 : : /* Read up begin/end pair and increment read pointer.
953 : : - If it's normal range record, set up *BEGINP and *ENDP and return 0.
954 : : - If it's base address selection record, set up *BASEP and return 1.
955 : : - If it's end of rangelist, don't set anything and return 2
956 : : - If an error occurs, don't set anything and return <0. */
957 : : int __libdw_read_begin_end_pair_inc (Dwarf_CU *cu, int sec_index,
958 : : const unsigned char **readp,
959 : : const unsigned char *readend,
960 : : int width,
961 : : Dwarf_Addr *beginp, Dwarf_Addr *endp,
962 : : Dwarf_Addr *basep)
963 : : internal_function;
964 : :
965 : : const unsigned char * __libdw_formptr (Dwarf_Attribute *attr, int sec_index,
966 : : int err_nodata,
967 : : const unsigned char **endpp,
968 : : Dwarf_Off *offsetp)
969 : : internal_function;
970 : :
971 : : /* Fills in the given attribute to point at an empty location expression. */
972 : : void __libdw_empty_loc_attr (Dwarf_Attribute *attr)
973 : : internal_function;
974 : :
975 : : /* Load .debug_line unit at DEBUG_LINE_OFFSET. COMP_DIR is a value of
976 : : DW_AT_comp_dir or NULL if that attribute is not available. Caches
977 : : the loaded unit and optionally set *LINESP and/or *FILESP (if not
978 : : NULL) with loaded information. Returns 0 for success or a negative
979 : : value for failure. */
980 : : int __libdw_getsrclines (Dwarf *dbg, Dwarf_Off debug_line_offset,
981 : : const char *comp_dir, unsigned address_size,
982 : : Dwarf_Lines **linesp, Dwarf_Files **filesp)
983 : : internal_function
984 : : __nonnull_attribute__ (1);
985 : :
986 : : /* Load and return value of DW_AT_comp_dir from CUDIE. */
987 : : const char *__libdw_getcompdir (Dwarf_Die *cudie);
988 : :
989 : : /* Get the base address for the CU, fetches it when not yet set.
990 : : This is used as initial base address for ranges and loclists. */
991 : : Dwarf_Addr __libdw_cu_base_address (Dwarf_CU *cu);
992 : :
993 : : /* Get the address base for the CU, fetches it when not yet set. */
994 : : static inline Dwarf_Off
995 : 631 : __libdw_cu_addr_base (Dwarf_CU *cu)
996 : : {
997 [ + + ]: 631 : if (cu->addr_base == (Dwarf_Off) -1)
998 : : {
999 : 48 : Dwarf_Die cu_die = CUDIE(cu);
1000 : 48 : Dwarf_Attribute attr;
1001 : 48 : Dwarf_Off offset = 0;
1002 [ + + ]: 48 : if (dwarf_attr (&cu_die, DW_AT_GNU_addr_base, &attr) != NULL
1003 [ + - ]: 22 : || dwarf_attr (&cu_die, DW_AT_addr_base, &attr) != NULL)
1004 : : {
1005 : 48 : Dwarf_Word off;
1006 [ + - ]: 48 : if (dwarf_formudata (&attr, &off) == 0)
1007 : 48 : offset = off;
1008 : : }
1009 : 48 : cu->addr_base = offset;
1010 : : }
1011 : :
1012 : 631 : return cu->addr_base;
1013 : : }
1014 : :
1015 : : /* Gets the .debug_str_offsets base offset to use. static inline to
1016 : : be shared between libdw and eu-readelf. */
1017 : : static inline Dwarf_Off
1018 : 2489 : str_offsets_base_off (Dwarf *dbg, Dwarf_CU *cu)
1019 : : {
1020 : : /* If we don't have a CU, then find and use the first one in the
1021 : : debug file (when we support .dwp files, we must actually find the
1022 : : one matching our "caller" - aka macro or line). If we (now) have
1023 : : a cu and str_offsets_base attribute, just use that. Otherwise
1024 : : use the first offset. But we might have to parse the header
1025 : : first, but only if this is version 5. Assume if all else fails,
1026 : : this is version 4, without header. */
1027 : :
1028 [ + + ]: 2489 : if (cu == NULL && dbg != NULL)
1029 : : {
1030 : 1813 : Dwarf_CU *first_cu;
1031 [ + - ]: 1813 : if (dwarf_get_units (dbg, NULL, &first_cu,
1032 : : NULL, NULL, NULL, NULL) == 0)
1033 : 1813 : cu = first_cu;
1034 : : }
1035 : :
1036 [ + - ]: 2489 : if (cu != NULL)
1037 : : {
1038 [ + + ]: 2489 : if (cu->str_off_base == (Dwarf_Off) -1)
1039 : : {
1040 : 85 : Dwarf_Die cu_die = CUDIE(cu);
1041 : 85 : Dwarf_Attribute attr;
1042 [ - + ]: 85 : if (dwarf_attr (&cu_die, DW_AT_str_offsets_base, &attr) != NULL)
1043 : : {
1044 : 0 : Dwarf_Word off;
1045 [ # # ]: 0 : if (dwarf_formudata (&attr, &off) == 0)
1046 : : {
1047 : 0 : cu->str_off_base = off;
1048 : 0 : return cu->str_off_base;
1049 : : }
1050 : : }
1051 : : /* For older DWARF simply assume zero (no header). */
1052 [ + + ]: 85 : if (cu->version < 5)
1053 : : {
1054 : 70 : cu->str_off_base = 0;
1055 : 70 : return cu->str_off_base;
1056 : : }
1057 : :
1058 [ + + ]: 15 : if (dbg == NULL)
1059 : 14 : dbg = cu->dbg;
1060 : : }
1061 : : else
1062 : : return cu->str_off_base;
1063 : : }
1064 : :
1065 : : /* No str_offsets_base attribute, we have to assume "zero".
1066 : : But there could be a header first. */
1067 : 15 : Dwarf_Off off = 0;
1068 [ - + ]: 15 : if (dbg == NULL)
1069 : 0 : goto no_header;
1070 : :
1071 : 15 : Elf_Data *data = dbg->sectiondata[IDX_debug_str_offsets];
1072 [ + + ]: 15 : if (data == NULL)
1073 : 1 : goto no_header;
1074 : :
1075 : 14 : const unsigned char *start;
1076 : 14 : const unsigned char *readp;
1077 : 14 : const unsigned char *readendp;
1078 : 14 : start = readp = (const unsigned char *) data->d_buf;
1079 : 14 : readendp = (const unsigned char *) data->d_buf + data->d_size;
1080 : :
1081 : 14 : uint64_t unit_length;
1082 : 14 : uint16_t version;
1083 : :
1084 [ - + ]: 14 : unit_length = read_4ubyte_unaligned_inc (dbg, readp);
1085 [ - + ]: 14 : if (unlikely (unit_length == 0xffffffff))
1086 : : {
1087 [ # # ]: 0 : if (unlikely (readendp - readp < 8))
1088 : 0 : goto no_header;
1089 [ # # ]: 0 : unit_length = read_8ubyte_unaligned_inc (dbg, readp);
1090 : : /* In theory the offset size could be different
1091 : : between CU and str_offsets unit. But we just
1092 : : ignore that here. */
1093 : : }
1094 : :
1095 : : /* We need at least 2-bytes (version) + 2-bytes (padding) =
1096 : : 4 bytes to complete the header. And this unit cannot go
1097 : : beyond the section data. */
1098 [ + - ]: 14 : if (readendp - readp < 4
1099 [ + - ]: 14 : || unit_length < 4
1100 [ - + ]: 14 : || (uint64_t) (readendp - readp) < unit_length)
1101 : 0 : goto no_header;
1102 : :
1103 [ - + ]: 14 : version = read_2ubyte_unaligned_inc (dbg, readp);
1104 [ - + ]: 14 : if (version != 5)
1105 : 0 : goto no_header;
1106 : : /* padding */
1107 : 14 : read_2ubyte_unaligned_inc (dbg, readp);
1108 : :
1109 : 14 : off = (Dwarf_Off) (readp - start);
1110 : :
1111 : 15 : no_header:
1112 [ + - ]: 15 : if (cu != NULL)
1113 : 15 : cu->str_off_base = off;
1114 : :
1115 : : return off;
1116 : : }
1117 : :
1118 : :
1119 : : /* Get the string offsets base for the CU, fetches it when not yet set. */
1120 : 142 : static inline Dwarf_Off __libdw_cu_str_off_base (Dwarf_CU *cu)
1121 : : {
1122 : 142 : return str_offsets_base_off (NULL, cu);
1123 : : }
1124 : :
1125 : :
1126 : : /* Either a direct offset into .debug_ranges for version < 5, or the
1127 : : start of the offset table in .debug_rnglists for version > 5. */
1128 : : static inline Dwarf_Off
1129 : 14 : __libdw_cu_ranges_base (Dwarf_CU *cu)
1130 : : {
1131 [ + + ]: 14 : if (cu->ranges_base == (Dwarf_Off) -1)
1132 : : {
1133 : 5 : Dwarf_Off offset = 0;
1134 : 5 : Dwarf_Die cu_die = CUDIE(cu);
1135 : 5 : Dwarf_Attribute attr;
1136 [ + + ]: 5 : if (cu->version < 5)
1137 : : {
1138 [ + - ]: 4 : if (dwarf_attr (&cu_die, DW_AT_GNU_ranges_base, &attr) != NULL)
1139 : : {
1140 : 4 : Dwarf_Word off;
1141 [ + - ]: 4 : if (dwarf_formudata (&attr, &off) == 0)
1142 : 4 : offset = off;
1143 : : }
1144 : : }
1145 : : else
1146 : : {
1147 [ + - ]: 1 : if (dwarf_attr (&cu_die, DW_AT_rnglists_base, &attr) != NULL)
1148 : : {
1149 : 1 : Dwarf_Word off;
1150 [ + - ]: 1 : if (dwarf_formudata (&attr, &off) == 0)
1151 : 1 : offset = off;
1152 : : }
1153 : :
1154 : : /* There wasn't an rnglists_base, if the Dwarf does have a
1155 : : .debug_rnglists section, then it might be we need the
1156 : : base after the first header. */
1157 : 1 : Elf_Data *data = cu->dbg->sectiondata[IDX_debug_rnglists];
1158 [ + - ]: 1 : if (offset == 0 && data != NULL)
1159 : : {
1160 : 0 : Dwarf *dbg = cu->dbg;
1161 : 0 : const unsigned char *readp = data->d_buf;
1162 : 0 : const unsigned char *const dataend
1163 : 0 : = (unsigned char *) data->d_buf + data->d_size;
1164 : :
1165 [ # # ]: 0 : uint64_t unit_length = read_4ubyte_unaligned_inc (dbg, readp);
1166 : 0 : unsigned int offset_size = 4;
1167 [ # # ]: 0 : if (unlikely (unit_length == 0xffffffff))
1168 : : {
1169 [ # # ]: 0 : if (unlikely (readp > dataend - 8))
1170 : 0 : goto no_header;
1171 : :
1172 [ # # ]: 0 : unit_length = read_8ubyte_unaligned_inc (dbg, readp);
1173 : 0 : offset_size = 8;
1174 : : }
1175 : :
1176 [ # # ]: 0 : if (readp > dataend - 8
1177 [ # # ]: 0 : || unit_length < 8
1178 [ # # ]: 0 : || unit_length > (uint64_t) (dataend - readp))
1179 : 0 : goto no_header;
1180 : :
1181 [ # # ]: 0 : uint16_t version = read_2ubyte_unaligned_inc (dbg, readp);
1182 [ # # ]: 0 : if (version != 5)
1183 : 0 : goto no_header;
1184 : :
1185 : 0 : uint8_t address_size = *readp++;
1186 [ # # ]: 0 : if (address_size != 4 && address_size != 8)
1187 : 0 : goto no_header;
1188 : :
1189 : 0 : uint8_t segment_size = *readp++;
1190 [ # # ]: 0 : if (segment_size != 0)
1191 : 0 : goto no_header;
1192 : :
1193 : 0 : uint32_t offset_entry_count;
1194 [ # # ]: 0 : offset_entry_count = read_4ubyte_unaligned_inc (dbg, readp);
1195 : :
1196 : 0 : const unsigned char *offset_array_start = readp;
1197 [ # # ]: 0 : if (offset_entry_count <= 0)
1198 : 0 : goto no_header;
1199 : :
1200 : 0 : uint64_t needed = offset_entry_count * offset_size;
1201 [ # # ]: 0 : if (unit_length - 8 < needed)
1202 : 0 : goto no_header;
1203 : :
1204 : 0 : offset = (Dwarf_Off) (offset_array_start
1205 : 0 : - (unsigned char *) data->d_buf);
1206 : : }
1207 : : }
1208 : 1 : no_header:
1209 : 5 : cu->ranges_base = offset;
1210 : : }
1211 : :
1212 : 14 : return cu->ranges_base;
1213 : : }
1214 : :
1215 : :
1216 : : /* The start of the offset table in .debug_loclists for DWARF5. */
1217 : : static inline Dwarf_Off
1218 : 67 : __libdw_cu_locs_base (Dwarf_CU *cu)
1219 : : {
1220 [ + + ]: 67 : if (cu->locs_base == (Dwarf_Off) -1)
1221 : : {
1222 : 2 : Dwarf_Off offset = 0;
1223 : 2 : Dwarf_Die cu_die = CUDIE(cu);
1224 : 2 : Dwarf_Attribute attr;
1225 [ + - ]: 2 : if (dwarf_attr (&cu_die, DW_AT_loclists_base, &attr) != NULL)
1226 : : {
1227 : 2 : Dwarf_Word off;
1228 [ + - ]: 2 : if (dwarf_formudata (&attr, &off) == 0)
1229 : 2 : offset = off;
1230 : : }
1231 : :
1232 : : /* There wasn't an loclists_base, if the Dwarf does have a
1233 : : .debug_loclists section, then it might be we need the
1234 : : base after the first header. */
1235 : 2 : Elf_Data *data = cu->dbg->sectiondata[IDX_debug_loclists];
1236 [ - + ]: 2 : if (offset == 0 && data != NULL)
1237 : : {
1238 : 2 : Dwarf *dbg = cu->dbg;
1239 : 2 : const unsigned char *readp = data->d_buf;
1240 : 2 : const unsigned char *const dataend
1241 : 2 : = (unsigned char *) data->d_buf + data->d_size;
1242 : :
1243 [ - + ]: 2 : uint64_t unit_length = read_4ubyte_unaligned_inc (dbg, readp);
1244 : 2 : unsigned int offset_size = 4;
1245 [ - + ]: 2 : if (unlikely (unit_length == 0xffffffff))
1246 : : {
1247 [ # # ]: 0 : if (unlikely (readp > dataend - 8))
1248 : 0 : goto no_header;
1249 : :
1250 [ # # ]: 0 : unit_length = read_8ubyte_unaligned_inc (dbg, readp);
1251 : 0 : offset_size = 8;
1252 : : }
1253 : :
1254 [ + - ]: 2 : if (readp > dataend - 8
1255 [ + - ]: 2 : || unit_length < 8
1256 [ - + ]: 2 : || unit_length > (uint64_t) (dataend - readp))
1257 : 0 : goto no_header;
1258 : :
1259 [ - + ]: 2 : uint16_t version = read_2ubyte_unaligned_inc (dbg, readp);
1260 [ - + ]: 2 : if (version != 5)
1261 : 0 : goto no_header;
1262 : :
1263 : 2 : uint8_t address_size = *readp++;
1264 [ - + ]: 2 : if (address_size != 4 && address_size != 8)
1265 : 0 : goto no_header;
1266 : :
1267 : 2 : uint8_t segment_size = *readp++;
1268 [ - + ]: 2 : if (segment_size != 0)
1269 : 0 : goto no_header;
1270 : :
1271 : 2 : uint32_t offset_entry_count;
1272 [ - + ]: 2 : offset_entry_count = read_4ubyte_unaligned_inc (dbg, readp);
1273 : :
1274 : 2 : const unsigned char *offset_array_start = readp;
1275 [ - + ]: 2 : if (offset_entry_count <= 0)
1276 : 0 : goto no_header;
1277 : :
1278 : 2 : uint64_t needed = offset_entry_count * offset_size;
1279 [ - + ]: 2 : if (unit_length - 8 < needed)
1280 : 0 : goto no_header;
1281 : :
1282 : 2 : offset = (Dwarf_Off) (offset_array_start
1283 : 2 : - (unsigned char *) data->d_buf);
1284 : : }
1285 : :
1286 : 0 : no_header:
1287 : 2 : cu->locs_base = offset;
1288 : : }
1289 : :
1290 : 67 : return cu->locs_base;
1291 : : }
1292 : :
1293 : : /* Helper function for tsearch/tfind split_tree Dwarf. */
1294 : : int __libdw_finddbg_cb (const void *arg1, const void *arg2);
1295 : :
1296 : : /* Link skeleton and split compile units. */
1297 : : static inline void
1298 : 48 : __libdw_link_skel_split (Dwarf_CU *skel, Dwarf_CU *split)
1299 : : {
1300 : 48 : skel->split = split;
1301 : 48 : split->split = skel;
1302 : :
1303 : : /* Get .debug_addr and addr_base greedy.
1304 : : We also need it for the fake addr cu.
1305 : : There is only one per split debug. */
1306 : 48 : Dwarf *dbg = skel->dbg;
1307 : 48 : Dwarf *sdbg = split->dbg;
1308 [ + - ]: 48 : if (sdbg->sectiondata[IDX_debug_addr] == NULL
1309 [ + - ]: 48 : && dbg->sectiondata[IDX_debug_addr] != NULL)
1310 : : {
1311 : 48 : sdbg->sectiondata[IDX_debug_addr]
1312 : 48 : = dbg->sectiondata[IDX_debug_addr];
1313 : 48 : split->addr_base = __libdw_cu_addr_base (skel);
1314 : 48 : sdbg->fake_addr_cu = dbg->fake_addr_cu;
1315 : : }
1316 : 48 : }
1317 : :
1318 : :
1319 : : /* Given an address index for a CU return the address.
1320 : : Returns -1 and sets libdw_errno if an error occurs. */
1321 : : int __libdw_addrx (Dwarf_CU *cu, Dwarf_Word idx, Dwarf_Addr *addr);
1322 : :
1323 : :
1324 : : /* Helper function to set debugdir field in Dwarf, used from dwarf_begin_elf
1325 : : and libdwfl process_file. */
1326 : : char * __libdw_debugdir (int fd);
1327 : :
1328 : :
1329 : : /* Given the directory of a debug file, an absolute or relative dir
1330 : : to look in, and file returns a full path.
1331 : :
1332 : : If the file is absolute (starts with a /) a copy of file is returned.
1333 : : the file isn't absolute, but dir is absolute, then a path that is
1334 : : the concatenation of dir and file is returned. If neither file,
1335 : : nor dir is absolute, the path will be constructed using dir (if not
1336 : : NULL) and file relative to the debugdir (if valid).
1337 : :
1338 : : The debugdir and the dir may be NULL (in which case they aren't used).
1339 : : If file is NULL, or no full path can be constructed NULL is returned.
1340 : :
1341 : : The caller is responsible for freeing the result if not NULL. */
1342 : : char * __libdw_filepath (const char *debugdir, const char *dir,
1343 : : const char *file)
1344 : : internal_function;
1345 : :
1346 : :
1347 : : /* Aliases to avoid PLTs. */
1348 : : INTDECL (dwarf_aggregate_size)
1349 : : INTDECL (dwarf_attr)
1350 : : INTDECL (dwarf_attr_integrate)
1351 : : INTDECL (dwarf_begin)
1352 : : INTDECL (dwarf_begin_elf)
1353 : : INTDECL (dwarf_child)
1354 : : INTDECL (dwarf_default_lower_bound)
1355 : : INTDECL (dwarf_dieoffset)
1356 : : INTDECL (dwarf_diename)
1357 : : INTDECL (dwarf_end)
1358 : : INTDECL (dwarf_entrypc)
1359 : : INTDECL (dwarf_errmsg)
1360 : : INTDECL (dwarf_formaddr)
1361 : : INTDECL (dwarf_formblock)
1362 : : INTDECL (dwarf_formref_die)
1363 : : INTDECL (dwarf_formsdata)
1364 : : INTDECL (dwarf_formstring)
1365 : : INTDECL (dwarf_formudata)
1366 : : INTDECL (dwarf_getabbrevattr_data)
1367 : : INTDECL (dwarf_getalt)
1368 : : INTDECL (dwarf_getarange_addr)
1369 : : INTDECL (dwarf_getarangeinfo)
1370 : : INTDECL (dwarf_getaranges)
1371 : : INTDECL (dwarf_getlocation_die)
1372 : : INTDECL (dwarf_getsrcfiles)
1373 : : INTDECL (dwarf_getsrclines)
1374 : : INTDECL (dwarf_hasattr)
1375 : : INTDECL (dwarf_haschildren)
1376 : : INTDECL (dwarf_haspc)
1377 : : INTDECL (dwarf_highpc)
1378 : : INTDECL (dwarf_lowpc)
1379 : : INTDECL (dwarf_nextcu)
1380 : : INTDECL (dwarf_next_unit)
1381 : : INTDECL (dwarf_offdie)
1382 : : INTDECL (dwarf_peel_type)
1383 : : INTDECL (dwarf_ranges)
1384 : : INTDECL (dwarf_setalt)
1385 : : INTDECL (dwarf_siblingof)
1386 : : INTDECL (dwarf_srclang)
1387 : : INTDECL (dwarf_tag)
1388 : :
1389 : : #endif /* libdwP.h */
|
