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