1 /* dwarf.c -- Get file/line information from DWARF for backtraces.
2 Copyright (C) 2012-2021 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Google.
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions are
9 (1) Redistributions of source code must retain the above copyright
10 notice, this list of conditions and the following disclaimer.
12 (2) Redistributions in binary form must reproduce the above copyright
13 notice, this list of conditions and the following disclaimer in
14 the documentation and/or other materials provided with the
17 (3) The name of the author may not be used to
18 endorse or promote products derived from this software without
19 specific prior written permission.
21 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
23 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24 DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
25 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
26 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
27 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
29 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
30 IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 POSSIBILITY OF SUCH DAMAGE. */
38 #include <sys/types.h>
41 #include "filenames.h"
43 #include "backtrace.h"
46 #if !defined(HAVE_DECL_STRNLEN) || !HAVE_DECL_STRNLEN
48 /* If strnlen is not declared, provide our own version. */
51 xstrnlen (const char *s
, size_t maxlen
)
55 for (i
= 0; i
< maxlen
; ++i
)
61 #define strnlen xstrnlen
65 /* A buffer to read DWARF info. */
69 /* Buffer name for error messages. */
71 /* Start of the buffer. */
72 const unsigned char *start
;
73 /* Next byte to read. */
74 const unsigned char *buf
;
75 /* The number of bytes remaining. */
77 /* Whether the data is big-endian. */
79 /* Error callback routine. */
80 backtrace_error_callback error_callback
;
81 /* Data for error_callback. */
83 /* Non-zero if we've reported an underflow error. */
84 int reported_underflow
;
87 /* A single attribute in a DWARF abbreviation. */
91 /* The attribute name. */
92 enum dwarf_attribute name
;
93 /* The attribute form. */
95 /* The attribute value, for DW_FORM_implicit_const. */
99 /* A single DWARF abbreviation. */
103 /* The abbrev code--the number used to refer to the abbrev. */
107 /* Non-zero if this abbrev has child entries. */
109 /* The number of attributes. */
111 /* The attributes. */
115 /* The DWARF abbreviations for a compilation unit. This structure
116 only exists while reading the compilation unit. Most DWARF readers
117 seem to a hash table to map abbrev ID's to abbrev entries.
118 However, we primarily care about GCC, and GCC simply issues ID's in
119 numerical order starting at 1. So we simply keep a sorted vector,
120 and try to just look up the code. */
124 /* The number of abbrevs in the vector. */
126 /* The abbrevs, sorted by the code field. */
127 struct abbrev
*abbrevs
;
130 /* The different kinds of attribute values. */
132 enum attr_val_encoding
134 /* No attribute value. */
138 /* An index into the .debug_addr section, whose value is relative to
139 * the DW_AT_addr_base attribute of the compilation unit. */
140 ATTR_VAL_ADDRESS_INDEX
,
141 /* A unsigned integer. */
143 /* A sigd integer. */
147 /* An index into the .debug_str_offsets section. */
148 ATTR_VAL_STRING_INDEX
,
149 /* An offset to other data in the containing unit. */
151 /* An offset to other data within the .debug_info section. */
153 /* An offset to other data within the alt .debug_info section. */
154 ATTR_VAL_REF_ALT_INFO
,
155 /* An offset to data in some other section. */
156 ATTR_VAL_REF_SECTION
,
157 /* A type signature. */
159 /* An index into the .debug_rnglists section. */
160 ATTR_VAL_RNGLISTS_INDEX
,
161 /* A block of data (not represented). */
163 /* An expression (not represented). */
167 /* An attribute value. */
171 /* How the value is stored in the field u. */
172 enum attr_val_encoding encoding
;
175 /* ATTR_VAL_ADDRESS*, ATTR_VAL_UINT, ATTR_VAL_REF*. */
179 /* ATTR_VAL_STRING. */
181 /* ATTR_VAL_BLOCK not stored. */
185 /* The line number program header. */
189 /* The version of the line number information. */
193 /* The minimum instruction length. */
194 unsigned int min_insn_len
;
195 /* The maximum number of ops per instruction. */
196 unsigned int max_ops_per_insn
;
197 /* The line base for special opcodes. */
199 /* The line range for special opcodes. */
200 unsigned int line_range
;
201 /* The opcode base--the first special opcode. */
202 unsigned int opcode_base
;
203 /* Opcode lengths, indexed by opcode - 1. */
204 const unsigned char *opcode_lengths
;
205 /* The number of directory entries. */
207 /* The directory entries. */
209 /* The number of filenames. */
210 size_t filenames_count
;
212 const char **filenames
;
215 /* A format description from a line header. */
217 struct line_header_format
219 int lnct
; /* LNCT code. */
220 enum dwarf_form form
; /* Form of entry data. */
223 /* Map a single PC value to a file/line. We will keep a vector of
224 these sorted by PC value. Each file/line will be correct from the
225 PC up to the PC of the next entry if there is one. We allocate one
226 extra entry at the end so that we can use bsearch. */
232 /* File name. Many entries in the array are expected to point to
233 the same file name. */
234 const char *filename
;
237 /* Index of the object in the original array read from the DWARF
238 section, before it has been sorted. The index makes it possible
239 to use Quicksort and maintain stability. */
243 /* A growable vector of line number information. This is used while
244 reading the line numbers. */
248 /* Memory. This is an array of struct line. */
249 struct backtrace_vector vec
;
250 /* Number of valid mappings. */
254 /* A function described in the debug info. */
258 /* The name of the function. */
260 /* If this is an inlined function, the filename of the call
262 const char *caller_filename
;
263 /* If this is an inlined function, the line number of the call
266 /* Map PC ranges to inlined functions. */
267 struct function_addrs
*function_addrs
;
268 size_t function_addrs_count
;
271 /* An address range for a function. This maps a PC value to a
272 specific function. */
274 struct function_addrs
276 /* Range is LOW <= PC < HIGH. */
279 /* Function for this address range. */
280 struct function
*function
;
283 /* A growable vector of function address ranges. */
285 struct function_vector
287 /* Memory. This is an array of struct function_addrs. */
288 struct backtrace_vector vec
;
289 /* Number of address ranges present. */
293 /* A DWARF compilation unit. This only holds the information we need
294 to map a PC to a file and line. */
298 /* The first entry for this compilation unit. */
299 const unsigned char *unit_data
;
300 /* The length of the data for this compilation unit. */
301 size_t unit_data_len
;
302 /* The offset of UNIT_DATA from the start of the information for
303 this compilation unit. */
304 size_t unit_data_offset
;
305 /* Offset of the start of the compilation unit from the start of the
306 .debug_info section. */
308 /* Offset of the end of the compilation unit from the start of the
309 .debug_info section. */
313 /* Whether unit is DWARF64. */
317 /* Offset into line number information. */
319 /* Offset of compilation unit in .debug_str_offsets. */
320 uint64_t str_offsets_base
;
321 /* Offset of compilation unit in .debug_addr. */
323 /* Offset of compilation unit in .debug_rnglists. */
324 uint64_t rnglists_base
;
325 /* Primary source file. */
326 const char *filename
;
327 /* Compilation command working directory. */
328 const char *comp_dir
;
329 /* Absolute file name, only set if needed. */
330 const char *abs_filename
;
331 /* The abbreviations for this unit. */
332 struct abbrevs abbrevs
;
334 /* The fields above this point are read in during initialization and
335 may be accessed freely. The fields below this point are read in
336 as needed, and therefore require care, as different threads may
337 try to initialize them simultaneously. */
339 /* PC to line number mapping. This is NULL if the values have not
340 been read. This is (struct line *) -1 if there was an error
341 reading the values. */
343 /* Number of entries in lines. */
345 /* PC ranges to function. */
346 struct function_addrs
*function_addrs
;
347 size_t function_addrs_count
;
350 /* An address range for a compilation unit. This maps a PC value to a
351 specific compilation unit. Note that we invert the representation
352 in DWARF: instead of listing the units and attaching a list of
353 ranges, we list the ranges and have each one point to the unit.
354 This lets us do a binary search to find the unit. */
358 /* Range is LOW <= PC < HIGH. */
361 /* Compilation unit for this address range. */
365 /* A growable vector of compilation unit address ranges. */
367 struct unit_addrs_vector
369 /* Memory. This is an array of struct unit_addrs. */
370 struct backtrace_vector vec
;
371 /* Number of address ranges present. */
375 /* A growable vector of compilation unit pointer. */
379 struct backtrace_vector vec
;
383 /* The information we need to map a PC to a file and line. */
387 /* The data for the next file we know about. */
388 struct dwarf_data
*next
;
389 /* The data for .gnu_debugaltlink. */
390 struct dwarf_data
*altlink
;
391 /* The base address for this file. */
392 uintptr_t base_address
;
393 /* A sorted list of address ranges. */
394 struct unit_addrs
*addrs
;
395 /* Number of address ranges in list. */
397 /* A sorted list of units. */
399 /* Number of units in the list. */
401 /* The unparsed DWARF debug data. */
402 struct dwarf_sections dwarf_sections
;
403 /* Whether the data is big-endian or not. */
405 /* A vector used for function addresses. We keep this here so that
406 we can grow the vector as we read more functions. */
407 struct function_vector fvec
;
410 /* Report an error for a DWARF buffer. */
413 dwarf_buf_error (struct dwarf_buf
*buf
, const char *msg
)
417 snprintf (b
, sizeof b
, "%s in %s at %d",
418 msg
, buf
->name
, (int) (buf
->buf
- buf
->start
));
419 buf
->error_callback (buf
->data
, b
, 0);
422 /* Require at least COUNT bytes in BUF. Return 1 if all is well, 0 on
426 require (struct dwarf_buf
*buf
, size_t count
)
428 if (buf
->left
>= count
)
431 if (!buf
->reported_underflow
)
433 dwarf_buf_error (buf
, "DWARF underflow");
434 buf
->reported_underflow
= 1;
440 /* Advance COUNT bytes in BUF. Return 1 if all is well, 0 on
444 advance (struct dwarf_buf
*buf
, size_t count
)
446 if (!require (buf
, count
))
453 /* Read one zero-terminated string from BUF and advance past the string. */
456 read_string (struct dwarf_buf
*buf
)
458 const char *p
= (const char *)buf
->buf
;
459 size_t len
= strnlen (p
, buf
->left
);
461 /* - If len == left, we ran out of buffer before finding the zero terminator.
462 Generate an error by advancing len + 1.
463 - If len < left, advance by len + 1 to skip past the zero terminator. */
464 size_t count
= len
+ 1;
466 if (!advance (buf
, count
))
472 /* Read one byte from BUF and advance 1 byte. */
475 read_byte (struct dwarf_buf
*buf
)
477 const unsigned char *p
= buf
->buf
;
479 if (!advance (buf
, 1))
484 /* Read a signed char from BUF and advance 1 byte. */
487 read_sbyte (struct dwarf_buf
*buf
)
489 const unsigned char *p
= buf
->buf
;
491 if (!advance (buf
, 1))
493 return (*p
^ 0x80) - 0x80;
496 /* Read a uint16 from BUF and advance 2 bytes. */
499 read_uint16 (struct dwarf_buf
*buf
)
501 const unsigned char *p
= buf
->buf
;
503 if (!advance (buf
, 2))
505 if (buf
->is_bigendian
)
506 return ((uint16_t) p
[0] << 8) | (uint16_t) p
[1];
508 return ((uint16_t) p
[1] << 8) | (uint16_t) p
[0];
511 /* Read a 24 bit value from BUF and advance 3 bytes. */
514 read_uint24 (struct dwarf_buf
*buf
)
516 const unsigned char *p
= buf
->buf
;
518 if (!advance (buf
, 3))
520 if (buf
->is_bigendian
)
521 return (((uint32_t) p
[0] << 16) | ((uint32_t) p
[1] << 8)
524 return (((uint32_t) p
[2] << 16) | ((uint32_t) p
[1] << 8)
528 /* Read a uint32 from BUF and advance 4 bytes. */
531 read_uint32 (struct dwarf_buf
*buf
)
533 const unsigned char *p
= buf
->buf
;
535 if (!advance (buf
, 4))
537 if (buf
->is_bigendian
)
538 return (((uint32_t) p
[0] << 24) | ((uint32_t) p
[1] << 16)
539 | ((uint32_t) p
[2] << 8) | (uint32_t) p
[3]);
541 return (((uint32_t) p
[3] << 24) | ((uint32_t) p
[2] << 16)
542 | ((uint32_t) p
[1] << 8) | (uint32_t) p
[0]);
545 /* Read a uint64 from BUF and advance 8 bytes. */
548 read_uint64 (struct dwarf_buf
*buf
)
550 const unsigned char *p
= buf
->buf
;
552 if (!advance (buf
, 8))
554 if (buf
->is_bigendian
)
555 return (((uint64_t) p
[0] << 56) | ((uint64_t) p
[1] << 48)
556 | ((uint64_t) p
[2] << 40) | ((uint64_t) p
[3] << 32)
557 | ((uint64_t) p
[4] << 24) | ((uint64_t) p
[5] << 16)
558 | ((uint64_t) p
[6] << 8) | (uint64_t) p
[7]);
560 return (((uint64_t) p
[7] << 56) | ((uint64_t) p
[6] << 48)
561 | ((uint64_t) p
[5] << 40) | ((uint64_t) p
[4] << 32)
562 | ((uint64_t) p
[3] << 24) | ((uint64_t) p
[2] << 16)
563 | ((uint64_t) p
[1] << 8) | (uint64_t) p
[0]);
566 /* Read an offset from BUF and advance the appropriate number of
570 read_offset (struct dwarf_buf
*buf
, int is_dwarf64
)
573 return read_uint64 (buf
);
575 return read_uint32 (buf
);
578 /* Read an address from BUF and advance the appropriate number of
582 read_address (struct dwarf_buf
*buf
, int addrsize
)
587 return read_byte (buf
);
589 return read_uint16 (buf
);
591 return read_uint32 (buf
);
593 return read_uint64 (buf
);
595 dwarf_buf_error (buf
, "unrecognized address size");
600 /* Return whether a value is the highest possible address, given the
604 is_highest_address (uint64_t address
, int addrsize
)
609 return address
== (unsigned char) -1;
611 return address
== (uint16_t) -1;
613 return address
== (uint32_t) -1;
615 return address
== (uint64_t) -1;
621 /* Read an unsigned LEB128 number. */
624 read_uleb128 (struct dwarf_buf
*buf
)
636 const unsigned char *p
;
639 if (!advance (buf
, 1))
643 ret
|= ((uint64_t) (b
& 0x7f)) << shift
;
646 dwarf_buf_error (buf
, "LEB128 overflows uint64_t");
651 while ((b
& 0x80) != 0);
656 /* Read a signed LEB128 number. */
659 read_sleb128 (struct dwarf_buf
*buf
)
671 const unsigned char *p
;
674 if (!advance (buf
, 1))
678 val
|= ((uint64_t) (b
& 0x7f)) << shift
;
681 dwarf_buf_error (buf
, "signed LEB128 overflows uint64_t");
686 while ((b
& 0x80) != 0);
688 if ((b
& 0x40) != 0 && shift
< 64)
689 val
|= ((uint64_t) -1) << shift
;
691 return (int64_t) val
;
694 /* Return the length of an LEB128 number. */
697 leb128_len (const unsigned char *p
)
702 while ((*p
& 0x80) != 0)
710 /* Read initial_length from BUF and advance the appropriate number of bytes. */
713 read_initial_length (struct dwarf_buf
*buf
, int *is_dwarf64
)
717 len
= read_uint32 (buf
);
718 if (len
== 0xffffffff)
720 len
= read_uint64 (buf
);
729 /* Free an abbreviations structure. */
732 free_abbrevs (struct backtrace_state
*state
, struct abbrevs
*abbrevs
,
733 backtrace_error_callback error_callback
, void *data
)
737 for (i
= 0; i
< abbrevs
->num_abbrevs
; ++i
)
738 backtrace_free (state
, abbrevs
->abbrevs
[i
].attrs
,
739 abbrevs
->abbrevs
[i
].num_attrs
* sizeof (struct attr
),
740 error_callback
, data
);
741 backtrace_free (state
, abbrevs
->abbrevs
,
742 abbrevs
->num_abbrevs
* sizeof (struct abbrev
),
743 error_callback
, data
);
744 abbrevs
->num_abbrevs
= 0;
745 abbrevs
->abbrevs
= NULL
;
748 /* Read an attribute value. Returns 1 on success, 0 on failure. If
749 the value can be represented as a uint64_t, sets *VAL and sets
750 *IS_VALID to 1. We don't try to store the value of other attribute
751 forms, because we don't care about them. */
754 read_attribute (enum dwarf_form form
, uint64_t implicit_val
,
755 struct dwarf_buf
*buf
, int is_dwarf64
, int version
,
756 int addrsize
, const struct dwarf_sections
*dwarf_sections
,
757 struct dwarf_data
*altlink
, struct attr_val
*val
)
759 /* Avoid warnings about val.u.FIELD may be used uninitialized if
760 this function is inlined. The warnings aren't valid but can
761 occur because the different fields are set and used
763 memset (val
, 0, sizeof *val
);
768 val
->encoding
= ATTR_VAL_ADDRESS
;
769 val
->u
.uint
= read_address (buf
, addrsize
);
772 val
->encoding
= ATTR_VAL_BLOCK
;
773 return advance (buf
, read_uint16 (buf
));
775 val
->encoding
= ATTR_VAL_BLOCK
;
776 return advance (buf
, read_uint32 (buf
));
778 val
->encoding
= ATTR_VAL_UINT
;
779 val
->u
.uint
= read_uint16 (buf
);
782 val
->encoding
= ATTR_VAL_UINT
;
783 val
->u
.uint
= read_uint32 (buf
);
786 val
->encoding
= ATTR_VAL_UINT
;
787 val
->u
.uint
= read_uint64 (buf
);
790 val
->encoding
= ATTR_VAL_BLOCK
;
791 return advance (buf
, 16);
793 val
->encoding
= ATTR_VAL_STRING
;
794 val
->u
.string
= read_string (buf
);
795 return val
->u
.string
== NULL
? 0 : 1;
797 val
->encoding
= ATTR_VAL_BLOCK
;
798 return advance (buf
, read_uleb128 (buf
));
800 val
->encoding
= ATTR_VAL_BLOCK
;
801 return advance (buf
, read_byte (buf
));
803 val
->encoding
= ATTR_VAL_UINT
;
804 val
->u
.uint
= read_byte (buf
);
807 val
->encoding
= ATTR_VAL_UINT
;
808 val
->u
.uint
= read_byte (buf
);
811 val
->encoding
= ATTR_VAL_SINT
;
812 val
->u
.sint
= read_sleb128 (buf
);
818 offset
= read_offset (buf
, is_dwarf64
);
819 if (offset
>= dwarf_sections
->size
[DEBUG_STR
])
821 dwarf_buf_error (buf
, "DW_FORM_strp out of range");
824 val
->encoding
= ATTR_VAL_STRING
;
826 (const char *) dwarf_sections
->data
[DEBUG_STR
] + offset
;
829 case DW_FORM_line_strp
:
833 offset
= read_offset (buf
, is_dwarf64
);
834 if (offset
>= dwarf_sections
->size
[DEBUG_LINE_STR
])
836 dwarf_buf_error (buf
, "DW_FORM_line_strp out of range");
839 val
->encoding
= ATTR_VAL_STRING
;
841 (const char *) dwarf_sections
->data
[DEBUG_LINE_STR
] + offset
;
845 val
->encoding
= ATTR_VAL_UINT
;
846 val
->u
.uint
= read_uleb128 (buf
);
848 case DW_FORM_ref_addr
:
849 val
->encoding
= ATTR_VAL_REF_INFO
;
851 val
->u
.uint
= read_address (buf
, addrsize
);
853 val
->u
.uint
= read_offset (buf
, is_dwarf64
);
856 val
->encoding
= ATTR_VAL_REF_UNIT
;
857 val
->u
.uint
= read_byte (buf
);
860 val
->encoding
= ATTR_VAL_REF_UNIT
;
861 val
->u
.uint
= read_uint16 (buf
);
864 val
->encoding
= ATTR_VAL_REF_UNIT
;
865 val
->u
.uint
= read_uint32 (buf
);
868 val
->encoding
= ATTR_VAL_REF_UNIT
;
869 val
->u
.uint
= read_uint64 (buf
);
871 case DW_FORM_ref_udata
:
872 val
->encoding
= ATTR_VAL_REF_UNIT
;
873 val
->u
.uint
= read_uleb128 (buf
);
875 case DW_FORM_indirect
:
879 form
= read_uleb128 (buf
);
880 if (form
== DW_FORM_implicit_const
)
882 dwarf_buf_error (buf
,
883 "DW_FORM_indirect to DW_FORM_implicit_const");
886 return read_attribute ((enum dwarf_form
) form
, 0, buf
, is_dwarf64
,
887 version
, addrsize
, dwarf_sections
, altlink
,
890 case DW_FORM_sec_offset
:
891 val
->encoding
= ATTR_VAL_REF_SECTION
;
892 val
->u
.uint
= read_offset (buf
, is_dwarf64
);
894 case DW_FORM_exprloc
:
895 val
->encoding
= ATTR_VAL_EXPR
;
896 return advance (buf
, read_uleb128 (buf
));
897 case DW_FORM_flag_present
:
898 val
->encoding
= ATTR_VAL_UINT
;
901 case DW_FORM_ref_sig8
:
902 val
->encoding
= ATTR_VAL_REF_TYPE
;
903 val
->u
.uint
= read_uint64 (buf
);
905 case DW_FORM_strx
: case DW_FORM_strx1
: case DW_FORM_strx2
:
906 case DW_FORM_strx3
: case DW_FORM_strx4
:
913 offset
= read_uleb128 (buf
);
916 offset
= read_byte (buf
);
919 offset
= read_uint16 (buf
);
922 offset
= read_uint24 (buf
);
925 offset
= read_uint32 (buf
);
928 /* This case can't happen. */
931 val
->encoding
= ATTR_VAL_STRING_INDEX
;
932 val
->u
.uint
= offset
;
935 case DW_FORM_addrx
: case DW_FORM_addrx1
: case DW_FORM_addrx2
:
936 case DW_FORM_addrx3
: case DW_FORM_addrx4
:
943 offset
= read_uleb128 (buf
);
946 offset
= read_byte (buf
);
949 offset
= read_uint16 (buf
);
952 offset
= read_uint24 (buf
);
955 offset
= read_uint32 (buf
);
958 /* This case can't happen. */
961 val
->encoding
= ATTR_VAL_ADDRESS_INDEX
;
962 val
->u
.uint
= offset
;
965 case DW_FORM_ref_sup4
:
966 val
->encoding
= ATTR_VAL_REF_SECTION
;
967 val
->u
.uint
= read_uint32 (buf
);
969 case DW_FORM_ref_sup8
:
970 val
->encoding
= ATTR_VAL_REF_SECTION
;
971 val
->u
.uint
= read_uint64 (buf
);
973 case DW_FORM_implicit_const
:
974 val
->encoding
= ATTR_VAL_UINT
;
975 val
->u
.uint
= implicit_val
;
977 case DW_FORM_loclistx
:
978 /* We don't distinguish this from DW_FORM_sec_offset. It
979 * shouldn't matter since we don't care about loclists. */
980 val
->encoding
= ATTR_VAL_REF_SECTION
;
981 val
->u
.uint
= read_uleb128 (buf
);
983 case DW_FORM_rnglistx
:
984 val
->encoding
= ATTR_VAL_RNGLISTS_INDEX
;
985 val
->u
.uint
= read_uleb128 (buf
);
987 case DW_FORM_GNU_addr_index
:
988 val
->encoding
= ATTR_VAL_REF_SECTION
;
989 val
->u
.uint
= read_uleb128 (buf
);
991 case DW_FORM_GNU_str_index
:
992 val
->encoding
= ATTR_VAL_REF_SECTION
;
993 val
->u
.uint
= read_uleb128 (buf
);
995 case DW_FORM_GNU_ref_alt
:
996 val
->u
.uint
= read_offset (buf
, is_dwarf64
);
999 val
->encoding
= ATTR_VAL_NONE
;
1002 val
->encoding
= ATTR_VAL_REF_ALT_INFO
;
1004 case DW_FORM_strp_sup
: case DW_FORM_GNU_strp_alt
:
1008 offset
= read_offset (buf
, is_dwarf64
);
1009 if (altlink
== NULL
)
1011 val
->encoding
= ATTR_VAL_NONE
;
1014 if (offset
>= altlink
->dwarf_sections
.size
[DEBUG_STR
])
1016 dwarf_buf_error (buf
, "DW_FORM_strp_sup out of range");
1019 val
->encoding
= ATTR_VAL_STRING
;
1021 (const char *) altlink
->dwarf_sections
.data
[DEBUG_STR
] + offset
;
1025 dwarf_buf_error (buf
, "unrecognized DWARF form");
1030 /* If we can determine the value of a string attribute, set *STRING to
1031 point to the string. Return 1 on success, 0 on error. If we don't
1032 know the value, we consider that a success, and we don't change
1033 *STRING. An error is only reported for some sort of out of range
1037 resolve_string (const struct dwarf_sections
*dwarf_sections
, int is_dwarf64
,
1038 int is_bigendian
, uint64_t str_offsets_base
,
1039 const struct attr_val
*val
,
1040 backtrace_error_callback error_callback
, void *data
,
1041 const char **string
)
1043 switch (val
->encoding
)
1045 case ATTR_VAL_STRING
:
1046 *string
= val
->u
.string
;
1049 case ATTR_VAL_STRING_INDEX
:
1052 struct dwarf_buf offset_buf
;
1054 offset
= val
->u
.uint
* (is_dwarf64
? 8 : 4) + str_offsets_base
;
1055 if (offset
+ (is_dwarf64
? 8 : 4)
1056 > dwarf_sections
->size
[DEBUG_STR_OFFSETS
])
1058 error_callback (data
, "DW_FORM_strx value out of range", 0);
1062 offset_buf
.name
= ".debug_str_offsets";
1063 offset_buf
.start
= dwarf_sections
->data
[DEBUG_STR_OFFSETS
];
1064 offset_buf
.buf
= dwarf_sections
->data
[DEBUG_STR_OFFSETS
] + offset
;
1065 offset_buf
.left
= dwarf_sections
->size
[DEBUG_STR_OFFSETS
] - offset
;
1066 offset_buf
.is_bigendian
= is_bigendian
;
1067 offset_buf
.error_callback
= error_callback
;
1068 offset_buf
.data
= data
;
1069 offset_buf
.reported_underflow
= 0;
1071 offset
= read_offset (&offset_buf
, is_dwarf64
);
1072 if (offset
>= dwarf_sections
->size
[DEBUG_STR
])
1074 dwarf_buf_error (&offset_buf
, "DW_FORM_strx offset out of range");
1077 *string
= (const char *) dwarf_sections
->data
[DEBUG_STR
] + offset
;
1086 /* Set *ADDRESS to the real address for a ATTR_VAL_ADDRESS_INDEX.
1087 Return 1 on success, 0 on error. */
1090 resolve_addr_index (const struct dwarf_sections
*dwarf_sections
,
1091 uint64_t addr_base
, int addrsize
, int is_bigendian
,
1092 uint64_t addr_index
,
1093 backtrace_error_callback error_callback
, void *data
,
1097 struct dwarf_buf addr_buf
;
1099 offset
= addr_index
* addrsize
+ addr_base
;
1100 if (offset
+ addrsize
> dwarf_sections
->size
[DEBUG_ADDR
])
1102 error_callback (data
, "DW_FORM_addrx value out of range", 0);
1106 addr_buf
.name
= ".debug_addr";
1107 addr_buf
.start
= dwarf_sections
->data
[DEBUG_ADDR
];
1108 addr_buf
.buf
= dwarf_sections
->data
[DEBUG_ADDR
] + offset
;
1109 addr_buf
.left
= dwarf_sections
->size
[DEBUG_ADDR
] - offset
;
1110 addr_buf
.is_bigendian
= is_bigendian
;
1111 addr_buf
.error_callback
= error_callback
;
1112 addr_buf
.data
= data
;
1113 addr_buf
.reported_underflow
= 0;
1115 *address
= read_address (&addr_buf
, addrsize
);
1119 /* Compare a unit offset against a unit for bsearch. */
1122 units_search (const void *vkey
, const void *ventry
)
1124 const size_t *key
= (const size_t *) vkey
;
1125 const struct unit
*entry
= *((const struct unit
*const *) ventry
);
1129 if (offset
< entry
->low_offset
)
1131 else if (offset
>= entry
->high_offset
)
1137 /* Find a unit in PU containing OFFSET. */
1139 static struct unit
*
1140 find_unit (struct unit
**pu
, size_t units_count
, size_t offset
)
1143 u
= bsearch (&offset
, pu
, units_count
, sizeof (struct unit
*), units_search
);
1144 return u
== NULL
? NULL
: *u
;
1147 /* Compare function_addrs for qsort. When ranges are nested, make the
1148 smallest one sort last. */
1151 function_addrs_compare (const void *v1
, const void *v2
)
1153 const struct function_addrs
*a1
= (const struct function_addrs
*) v1
;
1154 const struct function_addrs
*a2
= (const struct function_addrs
*) v2
;
1156 if (a1
->low
< a2
->low
)
1158 if (a1
->low
> a2
->low
)
1160 if (a1
->high
< a2
->high
)
1162 if (a1
->high
> a2
->high
)
1164 return strcmp (a1
->function
->name
, a2
->function
->name
);
1167 /* Compare a PC against a function_addrs for bsearch. We always
1168 allocate an entra entry at the end of the vector, so that this
1169 routine can safely look at the next entry. Note that if there are
1170 multiple ranges containing PC, which one will be returned is
1171 unpredictable. We compensate for that in dwarf_fileline. */
1174 function_addrs_search (const void *vkey
, const void *ventry
)
1176 const uintptr_t *key
= (const uintptr_t *) vkey
;
1177 const struct function_addrs
*entry
= (const struct function_addrs
*) ventry
;
1181 if (pc
< entry
->low
)
1183 else if (pc
> (entry
+ 1)->low
)
1189 /* Add a new compilation unit address range to a vector. This is
1190 called via add_ranges. Returns 1 on success, 0 on failure. */
1193 add_unit_addr (struct backtrace_state
*state
, void *rdata
,
1194 uint64_t lowpc
, uint64_t highpc
,
1195 backtrace_error_callback error_callback
, void *data
,
1198 struct unit
*u
= (struct unit
*) rdata
;
1199 struct unit_addrs_vector
*vec
= (struct unit_addrs_vector
*) pvec
;
1200 struct unit_addrs
*p
;
1202 /* Try to merge with the last entry. */
1205 p
= (struct unit_addrs
*) vec
->vec
.base
+ (vec
->count
- 1);
1206 if ((lowpc
== p
->high
|| lowpc
== p
->high
+ 1)
1209 if (highpc
> p
->high
)
1215 p
= ((struct unit_addrs
*)
1216 backtrace_vector_grow (state
, sizeof (struct unit_addrs
),
1217 error_callback
, data
, &vec
->vec
));
1230 /* Compare unit_addrs for qsort. When ranges are nested, make the
1231 smallest one sort last. */
1234 unit_addrs_compare (const void *v1
, const void *v2
)
1236 const struct unit_addrs
*a1
= (const struct unit_addrs
*) v1
;
1237 const struct unit_addrs
*a2
= (const struct unit_addrs
*) v2
;
1239 if (a1
->low
< a2
->low
)
1241 if (a1
->low
> a2
->low
)
1243 if (a1
->high
< a2
->high
)
1245 if (a1
->high
> a2
->high
)
1247 if (a1
->u
->lineoff
< a2
->u
->lineoff
)
1249 if (a1
->u
->lineoff
> a2
->u
->lineoff
)
1254 /* Compare a PC against a unit_addrs for bsearch. We always allocate
1255 an entry entry at the end of the vector, so that this routine can
1256 safely look at the next entry. Note that if there are multiple
1257 ranges containing PC, which one will be returned is unpredictable.
1258 We compensate for that in dwarf_fileline. */
1261 unit_addrs_search (const void *vkey
, const void *ventry
)
1263 const uintptr_t *key
= (const uintptr_t *) vkey
;
1264 const struct unit_addrs
*entry
= (const struct unit_addrs
*) ventry
;
1268 if (pc
< entry
->low
)
1270 else if (pc
> (entry
+ 1)->low
)
1276 /* Sort the line vector by PC. We want a stable sort here to maintain
1277 the order of lines for the same PC values. Since the sequence is
1278 being sorted in place, their addresses cannot be relied on to
1279 maintain stability. That is the purpose of the index member. */
1282 line_compare (const void *v1
, const void *v2
)
1284 const struct line
*ln1
= (const struct line
*) v1
;
1285 const struct line
*ln2
= (const struct line
*) v2
;
1287 if (ln1
->pc
< ln2
->pc
)
1289 else if (ln1
->pc
> ln2
->pc
)
1291 else if (ln1
->idx
< ln2
->idx
)
1293 else if (ln1
->idx
> ln2
->idx
)
1299 /* Find a PC in a line vector. We always allocate an extra entry at
1300 the end of the lines vector, so that this routine can safely look
1301 at the next entry. Note that when there are multiple mappings for
1302 the same PC value, this will return the last one. */
1305 line_search (const void *vkey
, const void *ventry
)
1307 const uintptr_t *key
= (const uintptr_t *) vkey
;
1308 const struct line
*entry
= (const struct line
*) ventry
;
1314 else if (pc
>= (entry
+ 1)->pc
)
1320 /* Sort the abbrevs by the abbrev code. This function is passed to
1321 both qsort and bsearch. */
1324 abbrev_compare (const void *v1
, const void *v2
)
1326 const struct abbrev
*a1
= (const struct abbrev
*) v1
;
1327 const struct abbrev
*a2
= (const struct abbrev
*) v2
;
1329 if (a1
->code
< a2
->code
)
1331 else if (a1
->code
> a2
->code
)
1335 /* This really shouldn't happen. It means there are two
1336 different abbrevs with the same code, and that means we don't
1337 know which one lookup_abbrev should return. */
1342 /* Read the abbreviation table for a compilation unit. Returns 1 on
1343 success, 0 on failure. */
1346 read_abbrevs (struct backtrace_state
*state
, uint64_t abbrev_offset
,
1347 const unsigned char *dwarf_abbrev
, size_t dwarf_abbrev_size
,
1348 int is_bigendian
, backtrace_error_callback error_callback
,
1349 void *data
, struct abbrevs
*abbrevs
)
1351 struct dwarf_buf abbrev_buf
;
1352 struct dwarf_buf count_buf
;
1355 abbrevs
->num_abbrevs
= 0;
1356 abbrevs
->abbrevs
= NULL
;
1358 if (abbrev_offset
>= dwarf_abbrev_size
)
1360 error_callback (data
, "abbrev offset out of range", 0);
1364 abbrev_buf
.name
= ".debug_abbrev";
1365 abbrev_buf
.start
= dwarf_abbrev
;
1366 abbrev_buf
.buf
= dwarf_abbrev
+ abbrev_offset
;
1367 abbrev_buf
.left
= dwarf_abbrev_size
- abbrev_offset
;
1368 abbrev_buf
.is_bigendian
= is_bigendian
;
1369 abbrev_buf
.error_callback
= error_callback
;
1370 abbrev_buf
.data
= data
;
1371 abbrev_buf
.reported_underflow
= 0;
1373 /* Count the number of abbrevs in this list. */
1375 count_buf
= abbrev_buf
;
1377 while (read_uleb128 (&count_buf
) != 0)
1379 if (count_buf
.reported_underflow
)
1383 read_uleb128 (&count_buf
);
1384 // Skip has_children.
1385 read_byte (&count_buf
);
1387 while (read_uleb128 (&count_buf
) != 0)
1391 form
= read_uleb128 (&count_buf
);
1392 if ((enum dwarf_form
) form
== DW_FORM_implicit_const
)
1393 read_sleb128 (&count_buf
);
1395 // Skip form of last attribute.
1396 read_uleb128 (&count_buf
);
1399 if (count_buf
.reported_underflow
)
1402 if (num_abbrevs
== 0)
1405 abbrevs
->abbrevs
= ((struct abbrev
*)
1406 backtrace_alloc (state
,
1407 num_abbrevs
* sizeof (struct abbrev
),
1408 error_callback
, data
));
1409 if (abbrevs
->abbrevs
== NULL
)
1411 abbrevs
->num_abbrevs
= num_abbrevs
;
1412 memset (abbrevs
->abbrevs
, 0, num_abbrevs
* sizeof (struct abbrev
));
1422 if (abbrev_buf
.reported_underflow
)
1425 code
= read_uleb128 (&abbrev_buf
);
1430 a
.tag
= (enum dwarf_tag
) read_uleb128 (&abbrev_buf
);
1431 a
.has_children
= read_byte (&abbrev_buf
);
1433 count_buf
= abbrev_buf
;
1435 while (read_uleb128 (&count_buf
) != 0)
1440 form
= read_uleb128 (&count_buf
);
1441 if ((enum dwarf_form
) form
== DW_FORM_implicit_const
)
1442 read_sleb128 (&count_buf
);
1448 read_uleb128 (&abbrev_buf
);
1449 read_uleb128 (&abbrev_buf
);
1453 attrs
= ((struct attr
*)
1454 backtrace_alloc (state
, num_attrs
* sizeof *attrs
,
1455 error_callback
, data
));
1464 name
= read_uleb128 (&abbrev_buf
);
1465 form
= read_uleb128 (&abbrev_buf
);
1468 attrs
[num_attrs
].name
= (enum dwarf_attribute
) name
;
1469 attrs
[num_attrs
].form
= (enum dwarf_form
) form
;
1470 if ((enum dwarf_form
) form
== DW_FORM_implicit_const
)
1471 attrs
[num_attrs
].val
= read_sleb128 (&abbrev_buf
);
1473 attrs
[num_attrs
].val
= 0;
1478 a
.num_attrs
= num_attrs
;
1481 abbrevs
->abbrevs
[num_abbrevs
] = a
;
1485 backtrace_qsort (abbrevs
->abbrevs
, abbrevs
->num_abbrevs
,
1486 sizeof (struct abbrev
), abbrev_compare
);
1491 free_abbrevs (state
, abbrevs
, error_callback
, data
);
1495 /* Return the abbrev information for an abbrev code. */
1497 static const struct abbrev
*
1498 lookup_abbrev (struct abbrevs
*abbrevs
, uint64_t code
,
1499 backtrace_error_callback error_callback
, void *data
)
1504 /* With GCC, where abbrevs are simply numbered in order, we should
1505 be able to just look up the entry. */
1506 if (code
- 1 < abbrevs
->num_abbrevs
1507 && abbrevs
->abbrevs
[code
- 1].code
== code
)
1508 return &abbrevs
->abbrevs
[code
- 1];
1510 /* Otherwise we have to search. */
1511 memset (&key
, 0, sizeof key
);
1513 p
= bsearch (&key
, abbrevs
->abbrevs
, abbrevs
->num_abbrevs
,
1514 sizeof (struct abbrev
), abbrev_compare
);
1517 error_callback (data
, "invalid abbreviation code", 0);
1520 return (const struct abbrev
*) p
;
1523 /* This struct is used to gather address range information while
1524 reading attributes. We use this while building a mapping from
1525 address ranges to compilation units and then again while mapping
1526 from address ranges to function entries. Normally either
1527 lowpc/highpc is set or ranges is set. */
1530 uint64_t lowpc
; /* The low PC value. */
1531 int have_lowpc
; /* Whether a low PC value was found. */
1532 int lowpc_is_addr_index
; /* Whether lowpc is in .debug_addr. */
1533 uint64_t highpc
; /* The high PC value. */
1534 int have_highpc
; /* Whether a high PC value was found. */
1535 int highpc_is_relative
; /* Whether highpc is relative to lowpc. */
1536 int highpc_is_addr_index
; /* Whether highpc is in .debug_addr. */
1537 uint64_t ranges
; /* Offset in ranges section. */
1538 int have_ranges
; /* Whether ranges is valid. */
1539 int ranges_is_index
; /* Whether ranges is DW_FORM_rnglistx. */
1542 /* Update PCRANGE from an attribute value. */
1545 update_pcrange (const struct attr
* attr
, const struct attr_val
* val
,
1546 struct pcrange
*pcrange
)
1551 if (val
->encoding
== ATTR_VAL_ADDRESS
)
1553 pcrange
->lowpc
= val
->u
.uint
;
1554 pcrange
->have_lowpc
= 1;
1556 else if (val
->encoding
== ATTR_VAL_ADDRESS_INDEX
)
1558 pcrange
->lowpc
= val
->u
.uint
;
1559 pcrange
->have_lowpc
= 1;
1560 pcrange
->lowpc_is_addr_index
= 1;
1565 if (val
->encoding
== ATTR_VAL_ADDRESS
)
1567 pcrange
->highpc
= val
->u
.uint
;
1568 pcrange
->have_highpc
= 1;
1570 else if (val
->encoding
== ATTR_VAL_UINT
)
1572 pcrange
->highpc
= val
->u
.uint
;
1573 pcrange
->have_highpc
= 1;
1574 pcrange
->highpc_is_relative
= 1;
1576 else if (val
->encoding
== ATTR_VAL_ADDRESS_INDEX
)
1578 pcrange
->highpc
= val
->u
.uint
;
1579 pcrange
->have_highpc
= 1;
1580 pcrange
->highpc_is_addr_index
= 1;
1585 if (val
->encoding
== ATTR_VAL_UINT
1586 || val
->encoding
== ATTR_VAL_REF_SECTION
)
1588 pcrange
->ranges
= val
->u
.uint
;
1589 pcrange
->have_ranges
= 1;
1591 else if (val
->encoding
== ATTR_VAL_RNGLISTS_INDEX
)
1593 pcrange
->ranges
= val
->u
.uint
;
1594 pcrange
->have_ranges
= 1;
1595 pcrange
->ranges_is_index
= 1;
1604 /* Call ADD_RANGE for a low/high PC pair. Returns 1 on success, 0 on
1608 add_low_high_range (struct backtrace_state
*state
,
1609 const struct dwarf_sections
*dwarf_sections
,
1610 uintptr_t base_address
, int is_bigendian
,
1611 struct unit
*u
, const struct pcrange
*pcrange
,
1612 int (*add_range
) (struct backtrace_state
*state
,
1613 void *rdata
, uint64_t lowpc
,
1615 backtrace_error_callback error_callback
,
1616 void *data
, void *vec
),
1618 backtrace_error_callback error_callback
, void *data
,
1624 lowpc
= pcrange
->lowpc
;
1625 if (pcrange
->lowpc_is_addr_index
)
1627 if (!resolve_addr_index (dwarf_sections
, u
->addr_base
, u
->addrsize
,
1628 is_bigendian
, lowpc
, error_callback
, data
,
1633 highpc
= pcrange
->highpc
;
1634 if (pcrange
->highpc_is_addr_index
)
1636 if (!resolve_addr_index (dwarf_sections
, u
->addr_base
, u
->addrsize
,
1637 is_bigendian
, highpc
, error_callback
, data
,
1641 if (pcrange
->highpc_is_relative
)
1644 /* Add in the base address of the module when recording PC values,
1645 so that we can look up the PC directly. */
1646 lowpc
+= base_address
;
1647 highpc
+= base_address
;
1649 return add_range (state
, rdata
, lowpc
, highpc
, error_callback
, data
, vec
);
1652 /* Call ADD_RANGE for each range read from .debug_ranges, as used in
1653 DWARF versions 2 through 4. */
1656 add_ranges_from_ranges (
1657 struct backtrace_state
*state
,
1658 const struct dwarf_sections
*dwarf_sections
,
1659 uintptr_t base_address
, int is_bigendian
,
1660 struct unit
*u
, uint64_t base
,
1661 const struct pcrange
*pcrange
,
1662 int (*add_range
) (struct backtrace_state
*state
, void *rdata
,
1663 uint64_t lowpc
, uint64_t highpc
,
1664 backtrace_error_callback error_callback
, void *data
,
1667 backtrace_error_callback error_callback
, void *data
,
1670 struct dwarf_buf ranges_buf
;
1672 if (pcrange
->ranges
>= dwarf_sections
->size
[DEBUG_RANGES
])
1674 error_callback (data
, "ranges offset out of range", 0);
1678 ranges_buf
.name
= ".debug_ranges";
1679 ranges_buf
.start
= dwarf_sections
->data
[DEBUG_RANGES
];
1680 ranges_buf
.buf
= dwarf_sections
->data
[DEBUG_RANGES
] + pcrange
->ranges
;
1681 ranges_buf
.left
= dwarf_sections
->size
[DEBUG_RANGES
] - pcrange
->ranges
;
1682 ranges_buf
.is_bigendian
= is_bigendian
;
1683 ranges_buf
.error_callback
= error_callback
;
1684 ranges_buf
.data
= data
;
1685 ranges_buf
.reported_underflow
= 0;
1692 if (ranges_buf
.reported_underflow
)
1695 low
= read_address (&ranges_buf
, u
->addrsize
);
1696 high
= read_address (&ranges_buf
, u
->addrsize
);
1698 if (low
== 0 && high
== 0)
1701 if (is_highest_address (low
, u
->addrsize
))
1705 if (!add_range (state
, rdata
,
1706 low
+ base
+ base_address
,
1707 high
+ base
+ base_address
,
1708 error_callback
, data
, vec
))
1713 if (ranges_buf
.reported_underflow
)
1719 /* Call ADD_RANGE for each range read from .debug_rnglists, as used in
1723 add_ranges_from_rnglists (
1724 struct backtrace_state
*state
,
1725 const struct dwarf_sections
*dwarf_sections
,
1726 uintptr_t base_address
, int is_bigendian
,
1727 struct unit
*u
, uint64_t base
,
1728 const struct pcrange
*pcrange
,
1729 int (*add_range
) (struct backtrace_state
*state
, void *rdata
,
1730 uint64_t lowpc
, uint64_t highpc
,
1731 backtrace_error_callback error_callback
, void *data
,
1734 backtrace_error_callback error_callback
, void *data
,
1738 struct dwarf_buf rnglists_buf
;
1740 if (!pcrange
->ranges_is_index
)
1741 offset
= pcrange
->ranges
;
1743 offset
= u
->rnglists_base
+ pcrange
->ranges
* (u
->is_dwarf64
? 8 : 4);
1744 if (offset
>= dwarf_sections
->size
[DEBUG_RNGLISTS
])
1746 error_callback (data
, "rnglists offset out of range", 0);
1750 rnglists_buf
.name
= ".debug_rnglists";
1751 rnglists_buf
.start
= dwarf_sections
->data
[DEBUG_RNGLISTS
];
1752 rnglists_buf
.buf
= dwarf_sections
->data
[DEBUG_RNGLISTS
] + offset
;
1753 rnglists_buf
.left
= dwarf_sections
->size
[DEBUG_RNGLISTS
] - offset
;
1754 rnglists_buf
.is_bigendian
= is_bigendian
;
1755 rnglists_buf
.error_callback
= error_callback
;
1756 rnglists_buf
.data
= data
;
1757 rnglists_buf
.reported_underflow
= 0;
1759 if (pcrange
->ranges_is_index
)
1761 offset
= read_offset (&rnglists_buf
, u
->is_dwarf64
);
1762 offset
+= u
->rnglists_base
;
1763 if (offset
>= dwarf_sections
->size
[DEBUG_RNGLISTS
])
1765 error_callback (data
, "rnglists index offset out of range", 0);
1768 rnglists_buf
.buf
= dwarf_sections
->data
[DEBUG_RNGLISTS
] + offset
;
1769 rnglists_buf
.left
= dwarf_sections
->size
[DEBUG_RNGLISTS
] - offset
;
1776 rle
= read_byte (&rnglists_buf
);
1777 if (rle
== DW_RLE_end_of_list
)
1781 case DW_RLE_base_addressx
:
1785 index
= read_uleb128 (&rnglists_buf
);
1786 if (!resolve_addr_index (dwarf_sections
, u
->addr_base
,
1787 u
->addrsize
, is_bigendian
, index
,
1788 error_callback
, data
, &base
))
1793 case DW_RLE_startx_endx
:
1799 index
= read_uleb128 (&rnglists_buf
);
1800 if (!resolve_addr_index (dwarf_sections
, u
->addr_base
,
1801 u
->addrsize
, is_bigendian
, index
,
1802 error_callback
, data
, &low
))
1804 index
= read_uleb128 (&rnglists_buf
);
1805 if (!resolve_addr_index (dwarf_sections
, u
->addr_base
,
1806 u
->addrsize
, is_bigendian
, index
,
1807 error_callback
, data
, &high
))
1809 if (!add_range (state
, rdata
, low
+ base_address
,
1810 high
+ base_address
, error_callback
, data
,
1816 case DW_RLE_startx_length
:
1822 index
= read_uleb128 (&rnglists_buf
);
1823 if (!resolve_addr_index (dwarf_sections
, u
->addr_base
,
1824 u
->addrsize
, is_bigendian
, index
,
1825 error_callback
, data
, &low
))
1827 length
= read_uleb128 (&rnglists_buf
);
1828 low
+= base_address
;
1829 if (!add_range (state
, rdata
, low
, low
+ length
,
1830 error_callback
, data
, vec
))
1835 case DW_RLE_offset_pair
:
1840 low
= read_uleb128 (&rnglists_buf
);
1841 high
= read_uleb128 (&rnglists_buf
);
1842 if (!add_range (state
, rdata
, low
+ base
+ base_address
,
1843 high
+ base
+ base_address
,
1844 error_callback
, data
, vec
))
1849 case DW_RLE_base_address
:
1850 base
= read_address (&rnglists_buf
, u
->addrsize
);
1853 case DW_RLE_start_end
:
1858 low
= read_address (&rnglists_buf
, u
->addrsize
);
1859 high
= read_address (&rnglists_buf
, u
->addrsize
);
1860 if (!add_range (state
, rdata
, low
+ base_address
,
1861 high
+ base_address
, error_callback
, data
,
1867 case DW_RLE_start_length
:
1872 low
= read_address (&rnglists_buf
, u
->addrsize
);
1873 length
= read_uleb128 (&rnglists_buf
);
1874 low
+= base_address
;
1875 if (!add_range (state
, rdata
, low
, low
+ length
,
1876 error_callback
, data
, vec
))
1882 dwarf_buf_error (&rnglists_buf
, "unrecognized DW_RLE value");
1887 if (rnglists_buf
.reported_underflow
)
1893 /* Call ADD_RANGE for each lowpc/highpc pair in PCRANGE. RDATA is
1894 passed to ADD_RANGE, and is either a struct unit * or a struct
1895 function *. VEC is the vector we are adding ranges to, and is
1896 either a struct unit_addrs_vector * or a struct function_vector *.
1897 Returns 1 on success, 0 on error. */
1900 add_ranges (struct backtrace_state
*state
,
1901 const struct dwarf_sections
*dwarf_sections
,
1902 uintptr_t base_address
, int is_bigendian
,
1903 struct unit
*u
, uint64_t base
, const struct pcrange
*pcrange
,
1904 int (*add_range
) (struct backtrace_state
*state
, void *rdata
,
1905 uint64_t lowpc
, uint64_t highpc
,
1906 backtrace_error_callback error_callback
,
1907 void *data
, void *vec
),
1909 backtrace_error_callback error_callback
, void *data
,
1912 if (pcrange
->have_lowpc
&& pcrange
->have_highpc
)
1913 return add_low_high_range (state
, dwarf_sections
, base_address
,
1914 is_bigendian
, u
, pcrange
, add_range
, rdata
,
1915 error_callback
, data
, vec
);
1917 if (!pcrange
->have_ranges
)
1919 /* Did not find any address ranges to add. */
1924 return add_ranges_from_ranges (state
, dwarf_sections
, base_address
,
1925 is_bigendian
, u
, base
, pcrange
, add_range
,
1926 rdata
, error_callback
, data
, vec
);
1928 return add_ranges_from_rnglists (state
, dwarf_sections
, base_address
,
1929 is_bigendian
, u
, base
, pcrange
, add_range
,
1930 rdata
, error_callback
, data
, vec
);
1933 /* Find the address range covered by a compilation unit, reading from
1934 UNIT_BUF and adding values to U. Returns 1 if all data could be
1935 read, 0 if there is some error. */
1938 find_address_ranges (struct backtrace_state
*state
, uintptr_t base_address
,
1939 struct dwarf_buf
*unit_buf
,
1940 const struct dwarf_sections
*dwarf_sections
,
1941 int is_bigendian
, struct dwarf_data
*altlink
,
1942 backtrace_error_callback error_callback
, void *data
,
1943 struct unit
*u
, struct unit_addrs_vector
*addrs
,
1944 enum dwarf_tag
*unit_tag
)
1946 while (unit_buf
->left
> 0)
1949 const struct abbrev
*abbrev
;
1950 struct pcrange pcrange
;
1951 struct attr_val name_val
;
1953 struct attr_val comp_dir_val
;
1954 int have_comp_dir_val
;
1957 code
= read_uleb128 (unit_buf
);
1961 abbrev
= lookup_abbrev (&u
->abbrevs
, code
, error_callback
, data
);
1965 if (unit_tag
!= NULL
)
1966 *unit_tag
= abbrev
->tag
;
1968 memset (&pcrange
, 0, sizeof pcrange
);
1969 memset (&name_val
, 0, sizeof name_val
);
1971 memset (&comp_dir_val
, 0, sizeof comp_dir_val
);
1972 have_comp_dir_val
= 0;
1973 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
1975 struct attr_val val
;
1977 if (!read_attribute (abbrev
->attrs
[i
].form
, abbrev
->attrs
[i
].val
,
1978 unit_buf
, u
->is_dwarf64
, u
->version
,
1979 u
->addrsize
, dwarf_sections
, altlink
, &val
))
1982 switch (abbrev
->attrs
[i
].name
)
1984 case DW_AT_low_pc
: case DW_AT_high_pc
: case DW_AT_ranges
:
1985 update_pcrange (&abbrev
->attrs
[i
], &val
, &pcrange
);
1988 case DW_AT_stmt_list
:
1989 if (abbrev
->tag
== DW_TAG_compile_unit
1990 && (val
.encoding
== ATTR_VAL_UINT
1991 || val
.encoding
== ATTR_VAL_REF_SECTION
))
1992 u
->lineoff
= val
.u
.uint
;
1996 if (abbrev
->tag
== DW_TAG_compile_unit
)
2003 case DW_AT_comp_dir
:
2004 if (abbrev
->tag
== DW_TAG_compile_unit
)
2007 have_comp_dir_val
= 1;
2011 case DW_AT_str_offsets_base
:
2012 if (abbrev
->tag
== DW_TAG_compile_unit
2013 && val
.encoding
== ATTR_VAL_REF_SECTION
)
2014 u
->str_offsets_base
= val
.u
.uint
;
2017 case DW_AT_addr_base
:
2018 if (abbrev
->tag
== DW_TAG_compile_unit
2019 && val
.encoding
== ATTR_VAL_REF_SECTION
)
2020 u
->addr_base
= val
.u
.uint
;
2023 case DW_AT_rnglists_base
:
2024 if (abbrev
->tag
== DW_TAG_compile_unit
2025 && val
.encoding
== ATTR_VAL_REF_SECTION
)
2026 u
->rnglists_base
= val
.u
.uint
;
2034 // Resolve strings after we're sure that we have seen
2035 // DW_AT_str_offsets_base.
2038 if (!resolve_string (dwarf_sections
, u
->is_dwarf64
, is_bigendian
,
2039 u
->str_offsets_base
, &name_val
,
2040 error_callback
, data
, &u
->filename
))
2043 if (have_comp_dir_val
)
2045 if (!resolve_string (dwarf_sections
, u
->is_dwarf64
, is_bigendian
,
2046 u
->str_offsets_base
, &comp_dir_val
,
2047 error_callback
, data
, &u
->comp_dir
))
2051 if (abbrev
->tag
== DW_TAG_compile_unit
2052 || abbrev
->tag
== DW_TAG_subprogram
)
2054 if (!add_ranges (state
, dwarf_sections
, base_address
,
2055 is_bigendian
, u
, pcrange
.lowpc
, &pcrange
,
2056 add_unit_addr
, (void *) u
, error_callback
, data
,
2060 /* If we found the PC range in the DW_TAG_compile_unit, we
2062 if (abbrev
->tag
== DW_TAG_compile_unit
2063 && (pcrange
.have_ranges
2064 || (pcrange
.have_lowpc
&& pcrange
.have_highpc
)))
2068 if (abbrev
->has_children
)
2070 if (!find_address_ranges (state
, base_address
, unit_buf
,
2071 dwarf_sections
, is_bigendian
, altlink
,
2072 error_callback
, data
, u
, addrs
, NULL
))
2080 /* Build a mapping from address ranges to the compilation units where
2081 the line number information for that range can be found. Returns 1
2082 on success, 0 on failure. */
2085 build_address_map (struct backtrace_state
*state
, uintptr_t base_address
,
2086 const struct dwarf_sections
*dwarf_sections
,
2087 int is_bigendian
, struct dwarf_data
*altlink
,
2088 backtrace_error_callback error_callback
, void *data
,
2089 struct unit_addrs_vector
*addrs
,
2090 struct unit_vector
*unit_vec
)
2092 struct dwarf_buf info
;
2093 struct backtrace_vector units
;
2097 size_t unit_offset
= 0;
2098 struct unit_addrs
*pa
;
2100 memset (&addrs
->vec
, 0, sizeof addrs
->vec
);
2101 memset (&unit_vec
->vec
, 0, sizeof unit_vec
->vec
);
2103 unit_vec
->count
= 0;
2105 /* Read through the .debug_info section. FIXME: Should we use the
2106 .debug_aranges section? gdb and addr2line don't use it, but I'm
2109 info
.name
= ".debug_info";
2110 info
.start
= dwarf_sections
->data
[DEBUG_INFO
];
2111 info
.buf
= info
.start
;
2112 info
.left
= dwarf_sections
->size
[DEBUG_INFO
];
2113 info
.is_bigendian
= is_bigendian
;
2114 info
.error_callback
= error_callback
;
2116 info
.reported_underflow
= 0;
2118 memset (&units
, 0, sizeof units
);
2121 while (info
.left
> 0)
2123 const unsigned char *unit_data_start
;
2126 struct dwarf_buf unit_buf
;
2129 uint64_t abbrev_offset
;
2132 enum dwarf_tag unit_tag
;
2134 if (info
.reported_underflow
)
2137 unit_data_start
= info
.buf
;
2139 len
= read_initial_length (&info
, &is_dwarf64
);
2141 unit_buf
.left
= len
;
2143 if (!advance (&info
, len
))
2146 version
= read_uint16 (&unit_buf
);
2147 if (version
< 2 || version
> 5)
2149 dwarf_buf_error (&unit_buf
, "unrecognized DWARF version");
2157 unit_type
= read_byte (&unit_buf
);
2158 if (unit_type
== DW_UT_type
|| unit_type
== DW_UT_split_type
)
2160 /* This unit doesn't have anything we need. */
2165 pu
= ((struct unit
**)
2166 backtrace_vector_grow (state
, sizeof (struct unit
*),
2167 error_callback
, data
, &units
));
2171 u
= ((struct unit
*)
2172 backtrace_alloc (state
, sizeof *u
, error_callback
, data
));
2180 addrsize
= 0; /* Set below. */
2182 addrsize
= read_byte (&unit_buf
);
2184 memset (&u
->abbrevs
, 0, sizeof u
->abbrevs
);
2185 abbrev_offset
= read_offset (&unit_buf
, is_dwarf64
);
2186 if (!read_abbrevs (state
, abbrev_offset
,
2187 dwarf_sections
->data
[DEBUG_ABBREV
],
2188 dwarf_sections
->size
[DEBUG_ABBREV
],
2189 is_bigendian
, error_callback
, data
, &u
->abbrevs
))
2193 addrsize
= read_byte (&unit_buf
);
2199 case DW_UT_compile
: case DW_UT_partial
:
2201 case DW_UT_skeleton
: case DW_UT_split_compile
:
2202 read_uint64 (&unit_buf
); /* dwo_id */
2208 u
->low_offset
= unit_offset
;
2209 unit_offset
+= len
+ (is_dwarf64
? 12 : 4);
2210 u
->high_offset
= unit_offset
;
2211 u
->unit_data
= unit_buf
.buf
;
2212 u
->unit_data_len
= unit_buf
.left
;
2213 u
->unit_data_offset
= unit_buf
.buf
- unit_data_start
;
2214 u
->version
= version
;
2215 u
->is_dwarf64
= is_dwarf64
;
2216 u
->addrsize
= addrsize
;
2219 u
->abs_filename
= NULL
;
2222 /* The actual line number mappings will be read as needed. */
2225 u
->function_addrs
= NULL
;
2226 u
->function_addrs_count
= 0;
2228 if (!find_address_ranges (state
, base_address
, &unit_buf
, dwarf_sections
,
2229 is_bigendian
, altlink
, error_callback
, data
,
2230 u
, addrs
, &unit_tag
))
2233 if (unit_buf
.reported_underflow
)
2236 if (info
.reported_underflow
)
2239 /* Add a trailing addrs entry, but don't include it in addrs->count. */
2240 pa
= ((struct unit_addrs
*)
2241 backtrace_vector_grow (state
, sizeof (struct unit_addrs
),
2242 error_callback
, data
, &addrs
->vec
));
2250 unit_vec
->vec
= units
;
2251 unit_vec
->count
= units_count
;
2255 if (units_count
> 0)
2257 pu
= (struct unit
**) units
.base
;
2258 for (i
= 0; i
< units_count
; i
++)
2260 free_abbrevs (state
, &pu
[i
]->abbrevs
, error_callback
, data
);
2261 backtrace_free (state
, pu
[i
], sizeof **pu
, error_callback
, data
);
2263 backtrace_vector_free (state
, &units
, error_callback
, data
);
2265 if (addrs
->count
> 0)
2267 backtrace_vector_free (state
, &addrs
->vec
, error_callback
, data
);
2273 /* Add a new mapping to the vector of line mappings that we are
2274 building. Returns 1 on success, 0 on failure. */
2277 add_line (struct backtrace_state
*state
, struct dwarf_data
*ddata
,
2278 uintptr_t pc
, const char *filename
, int lineno
,
2279 backtrace_error_callback error_callback
, void *data
,
2280 struct line_vector
*vec
)
2284 /* If we are adding the same mapping, ignore it. This can happen
2285 when using discriminators. */
2288 ln
= (struct line
*) vec
->vec
.base
+ (vec
->count
- 1);
2289 if (pc
== ln
->pc
&& filename
== ln
->filename
&& lineno
== ln
->lineno
)
2293 ln
= ((struct line
*)
2294 backtrace_vector_grow (state
, sizeof (struct line
), error_callback
,
2299 /* Add in the base address here, so that we can look up the PC
2301 ln
->pc
= pc
+ ddata
->base_address
;
2303 ln
->filename
= filename
;
2304 ln
->lineno
= lineno
;
2305 ln
->idx
= vec
->count
;
2312 /* Free the line header information. */
2315 free_line_header (struct backtrace_state
*state
, struct line_header
*hdr
,
2316 backtrace_error_callback error_callback
, void *data
)
2318 if (hdr
->dirs_count
!= 0)
2319 backtrace_free (state
, hdr
->dirs
, hdr
->dirs_count
* sizeof (const char *),
2320 error_callback
, data
);
2321 backtrace_free (state
, hdr
->filenames
,
2322 hdr
->filenames_count
* sizeof (char *),
2323 error_callback
, data
);
2326 /* Read the directories and file names for a line header for version
2327 2, setting fields in HDR. Return 1 on success, 0 on failure. */
2330 read_v2_paths (struct backtrace_state
*state
, struct unit
*u
,
2331 struct dwarf_buf
*hdr_buf
, struct line_header
*hdr
)
2333 const unsigned char *p
;
2334 const unsigned char *pend
;
2337 /* Count the number of directory entries. */
2338 hdr
->dirs_count
= 0;
2340 pend
= p
+ hdr_buf
->left
;
2341 while (p
< pend
&& *p
!= '\0')
2343 p
+= strnlen((const char *) p
, pend
- p
) + 1;
2347 /* The index of the first entry in the list of directories is 1. Index 0 is
2348 used for the current directory of the compilation. To simplify index
2349 handling, we set entry 0 to the compilation unit directory. */
2351 hdr
->dirs
= ((const char **)
2352 backtrace_alloc (state
,
2353 hdr
->dirs_count
* sizeof (const char *),
2354 hdr_buf
->error_callback
,
2356 if (hdr
->dirs
== NULL
)
2359 hdr
->dirs
[0] = u
->comp_dir
;
2361 while (*hdr_buf
->buf
!= '\0')
2363 if (hdr_buf
->reported_underflow
)
2366 hdr
->dirs
[i
] = read_string (hdr_buf
);
2367 if (hdr
->dirs
[i
] == NULL
)
2371 if (!advance (hdr_buf
, 1))
2374 /* Count the number of file entries. */
2375 hdr
->filenames_count
= 0;
2377 pend
= p
+ hdr_buf
->left
;
2378 while (p
< pend
&& *p
!= '\0')
2380 p
+= strnlen ((const char *) p
, pend
- p
) + 1;
2381 p
+= leb128_len (p
);
2382 p
+= leb128_len (p
);
2383 p
+= leb128_len (p
);
2384 ++hdr
->filenames_count
;
2387 /* The index of the first entry in the list of file names is 1. Index 0 is
2388 used for the DW_AT_name of the compilation unit. To simplify index
2389 handling, we set entry 0 to the compilation unit file name. */
2390 ++hdr
->filenames_count
;
2391 hdr
->filenames
= ((const char **)
2392 backtrace_alloc (state
,
2393 hdr
->filenames_count
* sizeof (char *),
2394 hdr_buf
->error_callback
,
2396 if (hdr
->filenames
== NULL
)
2398 hdr
->filenames
[0] = u
->filename
;
2400 while (*hdr_buf
->buf
!= '\0')
2402 const char *filename
;
2405 if (hdr_buf
->reported_underflow
)
2408 filename
= read_string (hdr_buf
);
2409 if (filename
== NULL
)
2411 dir_index
= read_uleb128 (hdr_buf
);
2412 if (IS_ABSOLUTE_PATH (filename
)
2413 || (dir_index
< hdr
->dirs_count
&& hdr
->dirs
[dir_index
] == NULL
))
2414 hdr
->filenames
[i
] = filename
;
2419 size_t filename_len
;
2422 if (dir_index
< hdr
->dirs_count
)
2423 dir
= hdr
->dirs
[dir_index
];
2426 dwarf_buf_error (hdr_buf
,
2427 ("invalid directory index in "
2428 "line number program header"));
2431 dir_len
= strlen (dir
);
2432 filename_len
= strlen (filename
);
2433 s
= ((char *) backtrace_alloc (state
, dir_len
+ filename_len
+ 2,
2434 hdr_buf
->error_callback
,
2438 memcpy (s
, dir
, dir_len
);
2439 /* FIXME: If we are on a DOS-based file system, and the
2440 directory or the file name use backslashes, then we
2441 should use a backslash here. */
2443 memcpy (s
+ dir_len
+ 1, filename
, filename_len
+ 1);
2444 hdr
->filenames
[i
] = s
;
2447 /* Ignore the modification time and size. */
2448 read_uleb128 (hdr_buf
);
2449 read_uleb128 (hdr_buf
);
2457 /* Read a single version 5 LNCT entry for a directory or file name in a
2458 line header. Sets *STRING to the resulting name, ignoring other
2459 data. Return 1 on success, 0 on failure. */
2462 read_lnct (struct backtrace_state
*state
, struct dwarf_data
*ddata
,
2463 struct unit
*u
, struct dwarf_buf
*hdr_buf
,
2464 const struct line_header
*hdr
, size_t formats_count
,
2465 const struct line_header_format
*formats
, const char **string
)
2473 for (i
= 0; i
< formats_count
; i
++)
2475 struct attr_val val
;
2477 if (!read_attribute (formats
[i
].form
, 0, hdr_buf
, u
->is_dwarf64
,
2478 u
->version
, hdr
->addrsize
, &ddata
->dwarf_sections
,
2479 ddata
->altlink
, &val
))
2481 switch (formats
[i
].lnct
)
2484 if (!resolve_string (&ddata
->dwarf_sections
, u
->is_dwarf64
,
2485 ddata
->is_bigendian
, u
->str_offsets_base
,
2486 &val
, hdr_buf
->error_callback
, hdr_buf
->data
,
2490 case DW_LNCT_directory_index
:
2491 if (val
.encoding
== ATTR_VAL_UINT
)
2493 if (val
.u
.uint
>= hdr
->dirs_count
)
2495 dwarf_buf_error (hdr_buf
,
2496 ("invalid directory index in "
2497 "line number program header"));
2500 dir
= hdr
->dirs
[val
.u
.uint
];
2504 /* We don't care about timestamps or sizes or hashes. */
2511 dwarf_buf_error (hdr_buf
,
2512 "missing file name in line number program header");
2524 dir_len
= strlen (dir
);
2525 path_len
= strlen (path
);
2526 s
= (char *) backtrace_alloc (state
, dir_len
+ path_len
+ 2,
2527 hdr_buf
->error_callback
, hdr_buf
->data
);
2530 memcpy (s
, dir
, dir_len
);
2531 /* FIXME: If we are on a DOS-based file system, and the
2532 directory or the path name use backslashes, then we should
2533 use a backslash here. */
2535 memcpy (s
+ dir_len
+ 1, path
, path_len
+ 1);
2542 /* Read a set of DWARF 5 line header format entries, setting *PCOUNT
2543 and *PPATHS. Return 1 on success, 0 on failure. */
2546 read_line_header_format_entries (struct backtrace_state
*state
,
2547 struct dwarf_data
*ddata
,
2549 struct dwarf_buf
*hdr_buf
,
2550 struct line_header
*hdr
,
2552 const char ***ppaths
)
2554 size_t formats_count
;
2555 struct line_header_format
*formats
;
2561 formats_count
= read_byte (hdr_buf
);
2562 if (formats_count
== 0)
2566 formats
= ((struct line_header_format
*)
2567 backtrace_alloc (state
,
2569 * sizeof (struct line_header_format
)),
2570 hdr_buf
->error_callback
,
2572 if (formats
== NULL
)
2575 for (i
= 0; i
< formats_count
; i
++)
2577 formats
[i
].lnct
= (int) read_uleb128(hdr_buf
);
2578 formats
[i
].form
= (enum dwarf_form
) read_uleb128 (hdr_buf
);
2582 paths_count
= read_uleb128 (hdr_buf
);
2583 if (paths_count
== 0)
2591 paths
= ((const char **)
2592 backtrace_alloc (state
, paths_count
* sizeof (const char *),
2593 hdr_buf
->error_callback
, hdr_buf
->data
));
2599 for (i
= 0; i
< paths_count
; i
++)
2601 if (!read_lnct (state
, ddata
, u
, hdr_buf
, hdr
, formats_count
,
2602 formats
, &paths
[i
]))
2604 backtrace_free (state
, paths
,
2605 paths_count
* sizeof (const char *),
2606 hdr_buf
->error_callback
, hdr_buf
->data
);
2612 *pcount
= paths_count
;
2618 if (formats
!= NULL
)
2619 backtrace_free (state
, formats
,
2620 formats_count
* sizeof (struct line_header_format
),
2621 hdr_buf
->error_callback
, hdr_buf
->data
);
2626 /* Read the line header. Return 1 on success, 0 on failure. */
2629 read_line_header (struct backtrace_state
*state
, struct dwarf_data
*ddata
,
2630 struct unit
*u
, int is_dwarf64
, struct dwarf_buf
*line_buf
,
2631 struct line_header
*hdr
)
2634 struct dwarf_buf hdr_buf
;
2636 hdr
->version
= read_uint16 (line_buf
);
2637 if (hdr
->version
< 2 || hdr
->version
> 5)
2639 dwarf_buf_error (line_buf
, "unsupported line number version");
2643 if (hdr
->version
< 5)
2644 hdr
->addrsize
= u
->addrsize
;
2647 hdr
->addrsize
= read_byte (line_buf
);
2648 /* We could support a non-zero segment_selector_size but I doubt
2649 we'll ever see it. */
2650 if (read_byte (line_buf
) != 0)
2652 dwarf_buf_error (line_buf
,
2653 "non-zero segment_selector_size not supported");
2658 hdrlen
= read_offset (line_buf
, is_dwarf64
);
2660 hdr_buf
= *line_buf
;
2661 hdr_buf
.left
= hdrlen
;
2663 if (!advance (line_buf
, hdrlen
))
2666 hdr
->min_insn_len
= read_byte (&hdr_buf
);
2667 if (hdr
->version
< 4)
2668 hdr
->max_ops_per_insn
= 1;
2670 hdr
->max_ops_per_insn
= read_byte (&hdr_buf
);
2672 /* We don't care about default_is_stmt. */
2673 read_byte (&hdr_buf
);
2675 hdr
->line_base
= read_sbyte (&hdr_buf
);
2676 hdr
->line_range
= read_byte (&hdr_buf
);
2678 hdr
->opcode_base
= read_byte (&hdr_buf
);
2679 hdr
->opcode_lengths
= hdr_buf
.buf
;
2680 if (!advance (&hdr_buf
, hdr
->opcode_base
- 1))
2683 if (hdr
->version
< 5)
2685 if (!read_v2_paths (state
, u
, &hdr_buf
, hdr
))
2690 if (!read_line_header_format_entries (state
, ddata
, u
, &hdr_buf
, hdr
,
2694 if (!read_line_header_format_entries (state
, ddata
, u
, &hdr_buf
, hdr
,
2695 &hdr
->filenames_count
,
2700 if (hdr_buf
.reported_underflow
)
2706 /* Read the line program, adding line mappings to VEC. Return 1 on
2707 success, 0 on failure. */
2710 read_line_program (struct backtrace_state
*state
, struct dwarf_data
*ddata
,
2711 const struct line_header
*hdr
, struct dwarf_buf
*line_buf
,
2712 struct line_vector
*vec
)
2715 unsigned int op_index
;
2716 const char *reset_filename
;
2717 const char *filename
;
2722 if (hdr
->filenames_count
> 1)
2723 reset_filename
= hdr
->filenames
[1];
2725 reset_filename
= "";
2726 filename
= reset_filename
;
2728 while (line_buf
->left
> 0)
2732 op
= read_byte (line_buf
);
2733 if (op
>= hdr
->opcode_base
)
2735 unsigned int advance
;
2737 /* Special opcode. */
2738 op
-= hdr
->opcode_base
;
2739 advance
= op
/ hdr
->line_range
;
2740 address
+= (hdr
->min_insn_len
* (op_index
+ advance
)
2741 / hdr
->max_ops_per_insn
);
2742 op_index
= (op_index
+ advance
) % hdr
->max_ops_per_insn
;
2743 lineno
+= hdr
->line_base
+ (int) (op
% hdr
->line_range
);
2744 add_line (state
, ddata
, address
, filename
, lineno
,
2745 line_buf
->error_callback
, line_buf
->data
, vec
);
2747 else if (op
== DW_LNS_extended_op
)
2751 len
= read_uleb128 (line_buf
);
2752 op
= read_byte (line_buf
);
2755 case DW_LNE_end_sequence
:
2756 /* FIXME: Should we mark the high PC here? It seems
2757 that we already have that information from the
2758 compilation unit. */
2761 filename
= reset_filename
;
2764 case DW_LNE_set_address
:
2765 address
= read_address (line_buf
, hdr
->addrsize
);
2767 case DW_LNE_define_file
:
2770 unsigned int dir_index
;
2772 f
= read_string (line_buf
);
2775 dir_index
= read_uleb128 (line_buf
);
2776 /* Ignore that time and length. */
2777 read_uleb128 (line_buf
);
2778 read_uleb128 (line_buf
);
2779 if (IS_ABSOLUTE_PATH (f
))
2788 if (dir_index
< hdr
->dirs_count
)
2789 dir
= hdr
->dirs
[dir_index
];
2792 dwarf_buf_error (line_buf
,
2793 ("invalid directory index "
2794 "in line number program"));
2797 dir_len
= strlen (dir
);
2800 backtrace_alloc (state
, dir_len
+ f_len
+ 2,
2801 line_buf
->error_callback
,
2805 memcpy (p
, dir
, dir_len
);
2806 /* FIXME: If we are on a DOS-based file system,
2807 and the directory or the file name use
2808 backslashes, then we should use a backslash
2811 memcpy (p
+ dir_len
+ 1, f
, f_len
+ 1);
2816 case DW_LNE_set_discriminator
:
2817 /* We don't care about discriminators. */
2818 read_uleb128 (line_buf
);
2821 if (!advance (line_buf
, len
- 1))
2831 add_line (state
, ddata
, address
, filename
, lineno
,
2832 line_buf
->error_callback
, line_buf
->data
, vec
);
2834 case DW_LNS_advance_pc
:
2838 advance
= read_uleb128 (line_buf
);
2839 address
+= (hdr
->min_insn_len
* (op_index
+ advance
)
2840 / hdr
->max_ops_per_insn
);
2841 op_index
= (op_index
+ advance
) % hdr
->max_ops_per_insn
;
2844 case DW_LNS_advance_line
:
2845 lineno
+= (int) read_sleb128 (line_buf
);
2847 case DW_LNS_set_file
:
2851 fileno
= read_uleb128 (line_buf
);
2856 if (fileno
>= hdr
->filenames_count
)
2858 dwarf_buf_error (line_buf
,
2859 ("invalid file number in "
2860 "line number program"));
2863 filename
= hdr
->filenames
[fileno
];
2867 case DW_LNS_set_column
:
2868 read_uleb128 (line_buf
);
2870 case DW_LNS_negate_stmt
:
2872 case DW_LNS_set_basic_block
:
2874 case DW_LNS_const_add_pc
:
2876 unsigned int advance
;
2878 op
= 255 - hdr
->opcode_base
;
2879 advance
= op
/ hdr
->line_range
;
2880 address
+= (hdr
->min_insn_len
* (op_index
+ advance
)
2881 / hdr
->max_ops_per_insn
);
2882 op_index
= (op_index
+ advance
) % hdr
->max_ops_per_insn
;
2885 case DW_LNS_fixed_advance_pc
:
2886 address
+= read_uint16 (line_buf
);
2889 case DW_LNS_set_prologue_end
:
2891 case DW_LNS_set_epilogue_begin
:
2893 case DW_LNS_set_isa
:
2894 read_uleb128 (line_buf
);
2900 for (i
= hdr
->opcode_lengths
[op
- 1]; i
> 0; --i
)
2901 read_uleb128 (line_buf
);
2911 /* Read the line number information for a compilation unit. Returns 1
2912 on success, 0 on failure. */
2915 read_line_info (struct backtrace_state
*state
, struct dwarf_data
*ddata
,
2916 backtrace_error_callback error_callback
, void *data
,
2917 struct unit
*u
, struct line_header
*hdr
, struct line
**lines
,
2918 size_t *lines_count
)
2920 struct line_vector vec
;
2921 struct dwarf_buf line_buf
;
2926 memset (&vec
.vec
, 0, sizeof vec
.vec
);
2929 memset (hdr
, 0, sizeof *hdr
);
2931 if (u
->lineoff
!= (off_t
) (size_t) u
->lineoff
2932 || (size_t) u
->lineoff
>= ddata
->dwarf_sections
.size
[DEBUG_LINE
])
2934 error_callback (data
, "unit line offset out of range", 0);
2938 line_buf
.name
= ".debug_line";
2939 line_buf
.start
= ddata
->dwarf_sections
.data
[DEBUG_LINE
];
2940 line_buf
.buf
= ddata
->dwarf_sections
.data
[DEBUG_LINE
] + u
->lineoff
;
2941 line_buf
.left
= ddata
->dwarf_sections
.size
[DEBUG_LINE
] - u
->lineoff
;
2942 line_buf
.is_bigendian
= ddata
->is_bigendian
;
2943 line_buf
.error_callback
= error_callback
;
2944 line_buf
.data
= data
;
2945 line_buf
.reported_underflow
= 0;
2947 len
= read_initial_length (&line_buf
, &is_dwarf64
);
2948 line_buf
.left
= len
;
2950 if (!read_line_header (state
, ddata
, u
, is_dwarf64
, &line_buf
, hdr
))
2953 if (!read_line_program (state
, ddata
, hdr
, &line_buf
, &vec
))
2956 if (line_buf
.reported_underflow
)
2961 /* This is not a failure in the sense of a generating an error,
2962 but it is a failure in that sense that we have no useful
2967 /* Allocate one extra entry at the end. */
2968 ln
= ((struct line
*)
2969 backtrace_vector_grow (state
, sizeof (struct line
), error_callback
,
2973 ln
->pc
= (uintptr_t) -1;
2974 ln
->filename
= NULL
;
2978 if (!backtrace_vector_release (state
, &vec
.vec
, error_callback
, data
))
2981 ln
= (struct line
*) vec
.vec
.base
;
2982 backtrace_qsort (ln
, vec
.count
, sizeof (struct line
), line_compare
);
2985 *lines_count
= vec
.count
;
2990 backtrace_vector_free (state
, &vec
.vec
, error_callback
, data
);
2991 free_line_header (state
, hdr
, error_callback
, data
);
2992 *lines
= (struct line
*) (uintptr_t) -1;
2997 static const char *read_referenced_name (struct dwarf_data
*, struct unit
*,
2998 uint64_t, backtrace_error_callback
,
3001 /* Read the name of a function from a DIE referenced by ATTR with VAL. */
3004 read_referenced_name_from_attr (struct dwarf_data
*ddata
, struct unit
*u
,
3005 struct attr
*attr
, struct attr_val
*val
,
3006 backtrace_error_callback error_callback
,
3011 case DW_AT_abstract_origin
:
3012 case DW_AT_specification
:
3018 if (attr
->form
== DW_FORM_ref_sig8
)
3021 if (val
->encoding
== ATTR_VAL_REF_INFO
)
3024 = find_unit (ddata
->units
, ddata
->units_count
,
3029 uint64_t offset
= val
->u
.uint
- unit
->low_offset
;
3030 return read_referenced_name (ddata
, unit
, offset
, error_callback
, data
);
3033 if (val
->encoding
== ATTR_VAL_UINT
3034 || val
->encoding
== ATTR_VAL_REF_UNIT
)
3035 return read_referenced_name (ddata
, u
, val
->u
.uint
, error_callback
, data
);
3037 if (val
->encoding
== ATTR_VAL_REF_ALT_INFO
)
3039 struct unit
*alt_unit
3040 = find_unit (ddata
->altlink
->units
, ddata
->altlink
->units_count
,
3042 if (alt_unit
== NULL
)
3045 uint64_t offset
= val
->u
.uint
- alt_unit
->low_offset
;
3046 return read_referenced_name (ddata
->altlink
, alt_unit
, offset
,
3047 error_callback
, data
);
3053 /* Read the name of a function from a DIE referenced by a
3054 DW_AT_abstract_origin or DW_AT_specification tag. OFFSET is within
3055 the same compilation unit. */
3058 read_referenced_name (struct dwarf_data
*ddata
, struct unit
*u
,
3059 uint64_t offset
, backtrace_error_callback error_callback
,
3062 struct dwarf_buf unit_buf
;
3064 const struct abbrev
*abbrev
;
3068 /* OFFSET is from the start of the data for this compilation unit.
3069 U->unit_data is the data, but it starts U->unit_data_offset bytes
3070 from the beginning. */
3072 if (offset
< u
->unit_data_offset
3073 || offset
- u
->unit_data_offset
>= u
->unit_data_len
)
3075 error_callback (data
,
3076 "abstract origin or specification out of range",
3081 offset
-= u
->unit_data_offset
;
3083 unit_buf
.name
= ".debug_info";
3084 unit_buf
.start
= ddata
->dwarf_sections
.data
[DEBUG_INFO
];
3085 unit_buf
.buf
= u
->unit_data
+ offset
;
3086 unit_buf
.left
= u
->unit_data_len
- offset
;
3087 unit_buf
.is_bigendian
= ddata
->is_bigendian
;
3088 unit_buf
.error_callback
= error_callback
;
3089 unit_buf
.data
= data
;
3090 unit_buf
.reported_underflow
= 0;
3092 code
= read_uleb128 (&unit_buf
);
3095 dwarf_buf_error (&unit_buf
, "invalid abstract origin or specification");
3099 abbrev
= lookup_abbrev (&u
->abbrevs
, code
, error_callback
, data
);
3104 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3106 struct attr_val val
;
3108 if (!read_attribute (abbrev
->attrs
[i
].form
, abbrev
->attrs
[i
].val
,
3109 &unit_buf
, u
->is_dwarf64
, u
->version
, u
->addrsize
,
3110 &ddata
->dwarf_sections
, ddata
->altlink
, &val
))
3113 switch (abbrev
->attrs
[i
].name
)
3116 /* Third name preference: don't override. A name we found in some
3117 other way, will normally be more useful -- e.g., this name is
3118 normally not mangled. */
3121 if (!resolve_string (&ddata
->dwarf_sections
, u
->is_dwarf64
,
3122 ddata
->is_bigendian
, u
->str_offsets_base
,
3123 &val
, error_callback
, data
, &ret
))
3127 case DW_AT_linkage_name
:
3128 case DW_AT_MIPS_linkage_name
:
3129 /* First name preference: override all. */
3134 if (!resolve_string (&ddata
->dwarf_sections
, u
->is_dwarf64
,
3135 ddata
->is_bigendian
, u
->str_offsets_base
,
3136 &val
, error_callback
, data
, &s
))
3143 case DW_AT_specification
:
3144 /* Second name preference: override DW_AT_name, don't override
3145 DW_AT_linkage_name. */
3149 name
= read_referenced_name_from_attr (ddata
, u
, &abbrev
->attrs
[i
],
3150 &val
, error_callback
, data
);
3164 /* Add a range to a unit that maps to a function. This is called via
3165 add_ranges. Returns 1 on success, 0 on error. */
3168 add_function_range (struct backtrace_state
*state
, void *rdata
,
3169 uint64_t lowpc
, uint64_t highpc
,
3170 backtrace_error_callback error_callback
, void *data
,
3173 struct function
*function
= (struct function
*) rdata
;
3174 struct function_vector
*vec
= (struct function_vector
*) pvec
;
3175 struct function_addrs
*p
;
3179 p
= (struct function_addrs
*) vec
->vec
.base
+ (vec
->count
- 1);
3180 if ((lowpc
== p
->high
|| lowpc
== p
->high
+ 1)
3181 && function
== p
->function
)
3183 if (highpc
> p
->high
)
3189 p
= ((struct function_addrs
*)
3190 backtrace_vector_grow (state
, sizeof (struct function_addrs
),
3191 error_callback
, data
, &vec
->vec
));
3197 p
->function
= function
;
3204 /* Read one entry plus all its children. Add function addresses to
3205 VEC. Returns 1 on success, 0 on error. */
3208 read_function_entry (struct backtrace_state
*state
, struct dwarf_data
*ddata
,
3209 struct unit
*u
, uint64_t base
, struct dwarf_buf
*unit_buf
,
3210 const struct line_header
*lhdr
,
3211 backtrace_error_callback error_callback
, void *data
,
3212 struct function_vector
*vec_function
,
3213 struct function_vector
*vec_inlined
)
3215 while (unit_buf
->left
> 0)
3218 const struct abbrev
*abbrev
;
3220 struct function
*function
;
3221 struct function_vector
*vec
;
3223 struct pcrange pcrange
;
3224 int have_linkage_name
;
3226 code
= read_uleb128 (unit_buf
);
3230 abbrev
= lookup_abbrev (&u
->abbrevs
, code
, error_callback
, data
);
3234 is_function
= (abbrev
->tag
== DW_TAG_subprogram
3235 || abbrev
->tag
== DW_TAG_entry_point
3236 || abbrev
->tag
== DW_TAG_inlined_subroutine
);
3238 if (abbrev
->tag
== DW_TAG_inlined_subroutine
)
3246 function
= ((struct function
*)
3247 backtrace_alloc (state
, sizeof *function
,
3248 error_callback
, data
));
3249 if (function
== NULL
)
3251 memset (function
, 0, sizeof *function
);
3254 memset (&pcrange
, 0, sizeof pcrange
);
3255 have_linkage_name
= 0;
3256 for (i
= 0; i
< abbrev
->num_attrs
; ++i
)
3258 struct attr_val val
;
3260 if (!read_attribute (abbrev
->attrs
[i
].form
, abbrev
->attrs
[i
].val
,
3261 unit_buf
, u
->is_dwarf64
, u
->version
,
3262 u
->addrsize
, &ddata
->dwarf_sections
,
3263 ddata
->altlink
, &val
))
3266 /* The compile unit sets the base address for any address
3267 ranges in the function entries. */
3268 if (abbrev
->tag
== DW_TAG_compile_unit
3269 && abbrev
->attrs
[i
].name
== DW_AT_low_pc
)
3271 if (val
.encoding
== ATTR_VAL_ADDRESS
)
3273 else if (val
.encoding
== ATTR_VAL_ADDRESS_INDEX
)
3275 if (!resolve_addr_index (&ddata
->dwarf_sections
,
3276 u
->addr_base
, u
->addrsize
,
3277 ddata
->is_bigendian
, val
.u
.uint
,
3278 error_callback
, data
, &base
))
3285 switch (abbrev
->attrs
[i
].name
)
3287 case DW_AT_call_file
:
3288 if (val
.encoding
== ATTR_VAL_UINT
)
3290 if (val
.u
.uint
== 0)
3291 function
->caller_filename
= "";
3294 if (val
.u
.uint
>= lhdr
->filenames_count
)
3296 dwarf_buf_error (unit_buf
,
3297 ("invalid file number in "
3298 "DW_AT_call_file attribute"));
3301 function
->caller_filename
=
3302 lhdr
->filenames
[val
.u
.uint
];
3307 case DW_AT_call_line
:
3308 if (val
.encoding
== ATTR_VAL_UINT
)
3309 function
->caller_lineno
= val
.u
.uint
;
3312 case DW_AT_abstract_origin
:
3313 case DW_AT_specification
:
3314 /* Second name preference: override DW_AT_name, don't override
3315 DW_AT_linkage_name. */
3316 if (have_linkage_name
)
3322 = read_referenced_name_from_attr (ddata
, u
,
3323 &abbrev
->attrs
[i
], &val
,
3324 error_callback
, data
);
3326 function
->name
= name
;
3331 /* Third name preference: don't override. */
3332 if (function
->name
!= NULL
)
3334 if (!resolve_string (&ddata
->dwarf_sections
, u
->is_dwarf64
,
3335 ddata
->is_bigendian
,
3336 u
->str_offsets_base
, &val
,
3337 error_callback
, data
, &function
->name
))
3341 case DW_AT_linkage_name
:
3342 case DW_AT_MIPS_linkage_name
:
3343 /* First name preference: override all. */
3348 if (!resolve_string (&ddata
->dwarf_sections
, u
->is_dwarf64
,
3349 ddata
->is_bigendian
,
3350 u
->str_offsets_base
, &val
,
3351 error_callback
, data
, &s
))
3356 have_linkage_name
= 1;
3361 case DW_AT_low_pc
: case DW_AT_high_pc
: case DW_AT_ranges
:
3362 update_pcrange (&abbrev
->attrs
[i
], &val
, &pcrange
);
3371 /* If we couldn't find a name for the function, we have no use
3373 if (is_function
&& function
->name
== NULL
)
3375 backtrace_free (state
, function
, sizeof *function
,
3376 error_callback
, data
);
3382 if (pcrange
.have_ranges
3383 || (pcrange
.have_lowpc
&& pcrange
.have_highpc
))
3385 if (!add_ranges (state
, &ddata
->dwarf_sections
,
3386 ddata
->base_address
, ddata
->is_bigendian
,
3387 u
, base
, &pcrange
, add_function_range
,
3388 (void *) function
, error_callback
, data
,
3394 backtrace_free (state
, function
, sizeof *function
,
3395 error_callback
, data
);
3400 if (abbrev
->has_children
)
3404 if (!read_function_entry (state
, ddata
, u
, base
, unit_buf
, lhdr
,
3405 error_callback
, data
, vec_function
,
3411 struct function_vector fvec
;
3413 /* Gather any information for inlined functions in
3416 memset (&fvec
, 0, sizeof fvec
);
3418 if (!read_function_entry (state
, ddata
, u
, base
, unit_buf
, lhdr
,
3419 error_callback
, data
, vec_function
,
3425 struct function_addrs
*p
;
3426 struct function_addrs
*faddrs
;
3428 /* Allocate a trailing entry, but don't include it
3430 p
= ((struct function_addrs
*)
3431 backtrace_vector_grow (state
,
3432 sizeof (struct function_addrs
),
3433 error_callback
, data
,
3442 if (!backtrace_vector_release (state
, &fvec
.vec
,
3443 error_callback
, data
))
3446 faddrs
= (struct function_addrs
*) fvec
.vec
.base
;
3447 backtrace_qsort (faddrs
, fvec
.count
,
3448 sizeof (struct function_addrs
),
3449 function_addrs_compare
);
3451 function
->function_addrs
= faddrs
;
3452 function
->function_addrs_count
= fvec
.count
;
3461 /* Read function name information for a compilation unit. We look
3462 through the whole unit looking for function tags. */
3465 read_function_info (struct backtrace_state
*state
, struct dwarf_data
*ddata
,
3466 const struct line_header
*lhdr
,
3467 backtrace_error_callback error_callback
, void *data
,
3468 struct unit
*u
, struct function_vector
*fvec
,
3469 struct function_addrs
**ret_addrs
,
3470 size_t *ret_addrs_count
)
3472 struct function_vector lvec
;
3473 struct function_vector
*pfvec
;
3474 struct dwarf_buf unit_buf
;
3475 struct function_addrs
*p
;
3476 struct function_addrs
*addrs
;
3479 /* Use FVEC if it is not NULL. Otherwise use our own vector. */
3484 memset (&lvec
, 0, sizeof lvec
);
3488 unit_buf
.name
= ".debug_info";
3489 unit_buf
.start
= ddata
->dwarf_sections
.data
[DEBUG_INFO
];
3490 unit_buf
.buf
= u
->unit_data
;
3491 unit_buf
.left
= u
->unit_data_len
;
3492 unit_buf
.is_bigendian
= ddata
->is_bigendian
;
3493 unit_buf
.error_callback
= error_callback
;
3494 unit_buf
.data
= data
;
3495 unit_buf
.reported_underflow
= 0;
3497 while (unit_buf
.left
> 0)
3499 if (!read_function_entry (state
, ddata
, u
, 0, &unit_buf
, lhdr
,
3500 error_callback
, data
, pfvec
, pfvec
))
3504 if (pfvec
->count
== 0)
3507 /* Allocate a trailing entry, but don't include it in
3509 p
= ((struct function_addrs
*)
3510 backtrace_vector_grow (state
, sizeof (struct function_addrs
),
3511 error_callback
, data
, &pfvec
->vec
));
3519 addrs_count
= pfvec
->count
;
3523 if (!backtrace_vector_release (state
, &lvec
.vec
, error_callback
, data
))
3525 addrs
= (struct function_addrs
*) pfvec
->vec
.base
;
3529 /* Finish this list of addresses, but leave the remaining space in
3530 the vector available for the next function unit. */
3531 addrs
= ((struct function_addrs
*)
3532 backtrace_vector_finish (state
, &fvec
->vec
,
3533 error_callback
, data
));
3539 backtrace_qsort (addrs
, addrs_count
, sizeof (struct function_addrs
),
3540 function_addrs_compare
);
3543 *ret_addrs_count
= addrs_count
;
3546 /* See if PC is inlined in FUNCTION. If it is, print out the inlined
3547 information, and update FILENAME and LINENO for the caller.
3548 Returns whatever CALLBACK returns, or 0 to keep going. */
3551 report_inlined_functions (uintptr_t pc
, struct function
*function
,
3552 backtrace_full_callback callback
, void *data
,
3553 const char **filename
, int *lineno
)
3555 struct function_addrs
*p
;
3556 struct function_addrs
*match
;
3557 struct function
*inlined
;
3560 if (function
->function_addrs_count
== 0)
3563 /* Our search isn't safe if pc == -1, as that is the sentinel
3568 p
= ((struct function_addrs
*)
3569 bsearch (&pc
, function
->function_addrs
,
3570 function
->function_addrs_count
,
3571 sizeof (struct function_addrs
),
3572 function_addrs_search
));
3576 /* Here pc >= p->low && pc < (p + 1)->low. The function_addrs are
3577 sorted by low, so if pc > p->low we are at the end of a range of
3578 function_addrs with the same low value. If pc == p->low walk
3579 forward to the end of the range with that low value. Then walk
3580 backward and use the first range that includes pc. */
3581 while (pc
== (p
+ 1)->low
)
3591 if (p
== function
->function_addrs
)
3593 if ((p
- 1)->low
< p
->low
)
3600 /* We found an inlined call. */
3602 inlined
= match
->function
;
3604 /* Report any calls inlined into this one. */
3605 ret
= report_inlined_functions (pc
, inlined
, callback
, data
,
3610 /* Report this inlined call. */
3611 ret
= callback (data
, pc
, *filename
, *lineno
, inlined
->name
);
3615 /* Our caller will report the caller of the inlined function; tell
3616 it the appropriate filename and line number. */
3617 *filename
= inlined
->caller_filename
;
3618 *lineno
= inlined
->caller_lineno
;
3623 /* Look for a PC in the DWARF mapping for one module. On success,
3624 call CALLBACK and return whatever it returns. On error, call
3625 ERROR_CALLBACK and return 0. Sets *FOUND to 1 if the PC is found,
3629 dwarf_lookup_pc (struct backtrace_state
*state
, struct dwarf_data
*ddata
,
3630 uintptr_t pc
, backtrace_full_callback callback
,
3631 backtrace_error_callback error_callback
, void *data
,
3634 struct unit_addrs
*entry
;
3640 struct function_addrs
*p
;
3641 struct function_addrs
*fmatch
;
3642 struct function
*function
;
3643 const char *filename
;
3649 /* Find an address range that includes PC. Our search isn't safe if
3650 PC == -1, as we use that as a sentinel value, so skip the search
3652 entry
= (ddata
->addrs_count
== 0 || pc
+ 1 == 0
3654 : bsearch (&pc
, ddata
->addrs
, ddata
->addrs_count
,
3655 sizeof (struct unit_addrs
), unit_addrs_search
));
3663 /* Here pc >= entry->low && pc < (entry + 1)->low. The unit_addrs
3664 are sorted by low, so if pc > p->low we are at the end of a range
3665 of unit_addrs with the same low value. If pc == p->low walk
3666 forward to the end of the range with that low value. Then walk
3667 backward and use the first range that includes pc. */
3668 while (pc
== (entry
+ 1)->low
)
3673 if (pc
< entry
->high
)
3678 if (entry
== ddata
->addrs
)
3680 if ((entry
- 1)->low
< entry
->low
)
3690 /* We need the lines, lines_count, function_addrs,
3691 function_addrs_count fields of u. If they are not set, we need
3692 to set them. When running in threaded mode, we need to allow for
3693 the possibility that some other thread is setting them
3699 /* Skip units with no useful line number information by walking
3700 backward. Useless line number information is marked by setting
3702 while (entry
> ddata
->addrs
3703 && pc
>= (entry
- 1)->low
3704 && pc
< (entry
- 1)->high
)
3706 if (state
->threaded
)
3707 lines
= (struct line
*) backtrace_atomic_load_pointer (&u
->lines
);
3709 if (lines
!= (struct line
*) (uintptr_t) -1)
3718 if (state
->threaded
)
3719 lines
= backtrace_atomic_load_pointer (&u
->lines
);
3724 struct function_addrs
*function_addrs
;
3725 size_t function_addrs_count
;
3726 struct line_header lhdr
;
3729 /* We have never read the line information for this unit. Read
3732 function_addrs
= NULL
;
3733 function_addrs_count
= 0;
3734 if (read_line_info (state
, ddata
, error_callback
, data
, entry
->u
, &lhdr
,
3737 struct function_vector
*pfvec
;
3739 /* If not threaded, reuse DDATA->FVEC for better memory
3741 if (state
->threaded
)
3744 pfvec
= &ddata
->fvec
;
3745 read_function_info (state
, ddata
, &lhdr
, error_callback
, data
,
3746 entry
->u
, pfvec
, &function_addrs
,
3747 &function_addrs_count
);
3748 free_line_header (state
, &lhdr
, error_callback
, data
);
3752 /* Atomically store the information we just read into the unit.
3753 If another thread is simultaneously writing, it presumably
3754 read the same information, and we don't care which one we
3755 wind up with; we just leak the other one. We do have to
3756 write the lines field last, so that the acquire-loads above
3757 ensure that the other fields are set. */
3759 if (!state
->threaded
)
3761 u
->lines_count
= count
;
3762 u
->function_addrs
= function_addrs
;
3763 u
->function_addrs_count
= function_addrs_count
;
3768 backtrace_atomic_store_size_t (&u
->lines_count
, count
);
3769 backtrace_atomic_store_pointer (&u
->function_addrs
, function_addrs
);
3770 backtrace_atomic_store_size_t (&u
->function_addrs_count
,
3771 function_addrs_count
);
3772 backtrace_atomic_store_pointer (&u
->lines
, lines
);
3776 /* Now all fields of U have been initialized. */
3778 if (lines
== (struct line
*) (uintptr_t) -1)
3780 /* If reading the line number information failed in some way,
3781 try again to see if there is a better compilation unit for
3784 return dwarf_lookup_pc (state
, ddata
, pc
, callback
, error_callback
,
3786 return callback (data
, pc
, NULL
, 0, NULL
);
3789 /* Search for PC within this unit. */
3791 ln
= (struct line
*) bsearch (&pc
, lines
, entry
->u
->lines_count
,
3792 sizeof (struct line
), line_search
);
3795 /* The PC is between the low_pc and high_pc attributes of the
3796 compilation unit, but no entry in the line table covers it.
3797 This implies that the start of the compilation unit has no
3798 line number information. */
3800 if (entry
->u
->abs_filename
== NULL
)
3802 const char *filename
;
3804 filename
= entry
->u
->filename
;
3805 if (filename
!= NULL
3806 && !IS_ABSOLUTE_PATH (filename
)
3807 && entry
->u
->comp_dir
!= NULL
)
3809 size_t filename_len
;
3814 filename_len
= strlen (filename
);
3815 dir
= entry
->u
->comp_dir
;
3816 dir_len
= strlen (dir
);
3817 s
= (char *) backtrace_alloc (state
, dir_len
+ filename_len
+ 2,
3818 error_callback
, data
);
3824 memcpy (s
, dir
, dir_len
);
3825 /* FIXME: Should use backslash if DOS file system. */
3827 memcpy (s
+ dir_len
+ 1, filename
, filename_len
+ 1);
3830 entry
->u
->abs_filename
= filename
;
3833 return callback (data
, pc
, entry
->u
->abs_filename
, 0, NULL
);
3836 /* Search for function name within this unit. */
3838 if (entry
->u
->function_addrs_count
== 0)
3839 return callback (data
, pc
, ln
->filename
, ln
->lineno
, NULL
);
3841 p
= ((struct function_addrs
*)
3842 bsearch (&pc
, entry
->u
->function_addrs
,
3843 entry
->u
->function_addrs_count
,
3844 sizeof (struct function_addrs
),
3845 function_addrs_search
));
3847 return callback (data
, pc
, ln
->filename
, ln
->lineno
, NULL
);
3849 /* Here pc >= p->low && pc < (p + 1)->low. The function_addrs are
3850 sorted by low, so if pc > p->low we are at the end of a range of
3851 function_addrs with the same low value. If pc == p->low walk
3852 forward to the end of the range with that low value. Then walk
3853 backward and use the first range that includes pc. */
3854 while (pc
== (p
+ 1)->low
)
3864 if (p
== entry
->u
->function_addrs
)
3866 if ((p
- 1)->low
< p
->low
)
3871 return callback (data
, pc
, ln
->filename
, ln
->lineno
, NULL
);
3873 function
= fmatch
->function
;
3875 filename
= ln
->filename
;
3876 lineno
= ln
->lineno
;
3878 ret
= report_inlined_functions (pc
, function
, callback
, data
,
3879 &filename
, &lineno
);
3883 return callback (data
, pc
, filename
, lineno
, function
->name
);
3887 /* Return the file/line information for a PC using the DWARF mapping
3888 we built earlier. */
3891 dwarf_fileline (struct backtrace_state
*state
, uintptr_t pc
,
3892 backtrace_full_callback callback
,
3893 backtrace_error_callback error_callback
, void *data
)
3895 struct dwarf_data
*ddata
;
3899 if (!state
->threaded
)
3901 for (ddata
= (struct dwarf_data
*) state
->fileline_data
;
3903 ddata
= ddata
->next
)
3905 ret
= dwarf_lookup_pc (state
, ddata
, pc
, callback
, error_callback
,
3907 if (ret
!= 0 || found
)
3913 struct dwarf_data
**pp
;
3915 pp
= (struct dwarf_data
**) (void *) &state
->fileline_data
;
3918 ddata
= backtrace_atomic_load_pointer (pp
);
3922 ret
= dwarf_lookup_pc (state
, ddata
, pc
, callback
, error_callback
,
3924 if (ret
!= 0 || found
)
3931 /* FIXME: See if any libraries have been dlopen'ed. */
3933 return callback (data
, pc
, NULL
, 0, NULL
);
3936 /* Initialize our data structures from the DWARF debug info for a
3937 file. Return NULL on failure. */
3939 static struct dwarf_data
*
3940 build_dwarf_data (struct backtrace_state
*state
,
3941 uintptr_t base_address
,
3942 const struct dwarf_sections
*dwarf_sections
,
3944 struct dwarf_data
*altlink
,
3945 backtrace_error_callback error_callback
,
3948 struct unit_addrs_vector addrs_vec
;
3949 struct unit_addrs
*addrs
;
3951 struct unit_vector units_vec
;
3952 struct unit
**units
;
3954 struct dwarf_data
*fdata
;
3956 if (!build_address_map (state
, base_address
, dwarf_sections
, is_bigendian
,
3957 altlink
, error_callback
, data
, &addrs_vec
,
3961 if (!backtrace_vector_release (state
, &addrs_vec
.vec
, error_callback
, data
))
3963 if (!backtrace_vector_release (state
, &units_vec
.vec
, error_callback
, data
))
3965 addrs
= (struct unit_addrs
*) addrs_vec
.vec
.base
;
3966 units
= (struct unit
**) units_vec
.vec
.base
;
3967 addrs_count
= addrs_vec
.count
;
3968 units_count
= units_vec
.count
;
3969 backtrace_qsort (addrs
, addrs_count
, sizeof (struct unit_addrs
),
3970 unit_addrs_compare
);
3971 /* No qsort for units required, already sorted. */
3973 fdata
= ((struct dwarf_data
*)
3974 backtrace_alloc (state
, sizeof (struct dwarf_data
),
3975 error_callback
, data
));
3980 fdata
->altlink
= altlink
;
3981 fdata
->base_address
= base_address
;
3982 fdata
->addrs
= addrs
;
3983 fdata
->addrs_count
= addrs_count
;
3984 fdata
->units
= units
;
3985 fdata
->units_count
= units_count
;
3986 fdata
->dwarf_sections
= *dwarf_sections
;
3987 fdata
->is_bigendian
= is_bigendian
;
3988 memset (&fdata
->fvec
, 0, sizeof fdata
->fvec
);
3993 /* Build our data structures from the DWARF sections for a module.
3994 Set FILELINE_FN and STATE->FILELINE_DATA. Return 1 on success, 0
3998 backtrace_dwarf_add (struct backtrace_state
*state
,
3999 uintptr_t base_address
,
4000 const struct dwarf_sections
*dwarf_sections
,
4002 struct dwarf_data
*fileline_altlink
,
4003 backtrace_error_callback error_callback
,
4004 void *data
, fileline
*fileline_fn
,
4005 struct dwarf_data
**fileline_entry
)
4007 struct dwarf_data
*fdata
;
4009 fdata
= build_dwarf_data (state
, base_address
, dwarf_sections
, is_bigendian
,
4010 fileline_altlink
, error_callback
, data
);
4014 if (fileline_entry
!= NULL
)
4015 *fileline_entry
= fdata
;
4017 if (!state
->threaded
)
4019 struct dwarf_data
**pp
;
4021 for (pp
= (struct dwarf_data
**) (void *) &state
->fileline_data
;
4031 struct dwarf_data
**pp
;
4033 pp
= (struct dwarf_data
**) (void *) &state
->fileline_data
;
4037 struct dwarf_data
*p
;
4039 p
= backtrace_atomic_load_pointer (pp
);
4047 if (__sync_bool_compare_and_swap (pp
, NULL
, fdata
))
4052 *fileline_fn
= dwarf_fileline
;