Bug Summary

File:dwarf.c
Warning:line 1170, column 7
Null pointer passed as an argument to a 'nonnull' parameter

Annotated Source Code

[?] Use j/k keys for keyboard navigation

1/* dwarf.c -- Get file/line information from DWARF for backtraces.
2 Copyright (C) 2012-2016 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Google.
4
5Redistribution and use in source and binary forms, with or without
6modification, are permitted provided that the following conditions are
7met:
8
9 (1) Redistributions of source code must retain the above copyright
10 notice, this list of conditions and the following disclaimer.
11
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
15 distribution.
16
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.
20
21THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
23WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
25INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
26(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
27SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
29STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
30IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31POSSIBILITY OF SUCH DAMAGE. */
32
33#include "config.h"
34
35#include <errno(*__errno_location ()).h>
36#include <stdlib.h>
37#include <string.h>
38#include <sys/types.h>
39
40#include "dwarf2.h"
41#include "filenames.h"
42
43#include "backtrace.h"
44#include "internal.h"
45
46#if !defined(HAVE_DECL_STRNLEN1) || !HAVE_DECL_STRNLEN1
47
48/* If strnlen is not declared, provide our own version. */
49
50static size_t
51xstrnlen (const char *s, size_t maxlen)
52{
53 size_t i;
54
55 for (i = 0; i < maxlen; ++i)
56 if (s[i] == '\0')
57 break;
58 return i;
59}
60
61#define strnlen xstrnlen
62
63#endif
64
65/* A buffer to read DWARF info. */
66
67struct dwarf_buf
68{
69 /* Buffer name for error messages. */
70 const char *name;
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. */
76 size_t left;
77 /* Whether the data is big-endian. */
78 int is_bigendian;
79 /* Error callback routine. */
80 backtrace_error_callback error_callback;
81 /* Data for error_callback. */
82 void *data;
83 /* Non-zero if we've reported an underflow error. */
84 int reported_underflow;
85};
86
87/* A single attribute in a DWARF abbreviation. */
88
89struct attr
90{
91 /* The attribute name. */
92 enum dwarf_attribute name;
93 /* The attribute form. */
94 enum dwarf_form form;
95};
96
97/* A single DWARF abbreviation. */
98
99struct abbrev
100{
101 /* The abbrev code--the number used to refer to the abbrev. */
102 uint64_t code;
103 /* The entry tag. */
104 enum dwarf_tag tag;
105 /* Non-zero if this abbrev has child entries. */
106 int has_children;
107 /* The number of attributes. */
108 size_t num_attrs;
109 /* The attributes. */
110 struct attr *attrs;
111};
112
113/* The DWARF abbreviations for a compilation unit. This structure
114 only exists while reading the compilation unit. Most DWARF readers
115 seem to a hash table to map abbrev ID's to abbrev entries.
116 However, we primarily care about GCC, and GCC simply issues ID's in
117 numerical order starting at 1. So we simply keep a sorted vector,
118 and try to just look up the code. */
119
120struct abbrevs
121{
122 /* The number of abbrevs in the vector. */
123 size_t num_abbrevs;
124 /* The abbrevs, sorted by the code field. */
125 struct abbrev *abbrevs;
126};
127
128/* The different kinds of attribute values. */
129
130enum attr_val_encoding
131{
132 /* An address. */
133 ATTR_VAL_ADDRESS,
134 /* A unsigned integer. */
135 ATTR_VAL_UINT,
136 /* A sigd integer. */
137 ATTR_VAL_SINT,
138 /* A string. */
139 ATTR_VAL_STRING,
140 /* An offset to other data in the containing unit. */
141 ATTR_VAL_REF_UNIT,
142 /* An offset to other data within the .dwarf_info section. */
143 ATTR_VAL_REF_INFO,
144 /* An offset to data in some other section. */
145 ATTR_VAL_REF_SECTION,
146 /* A type signature. */
147 ATTR_VAL_REF_TYPE,
148 /* A block of data (not represented). */
149 ATTR_VAL_BLOCK,
150 /* An expression (not represented). */
151 ATTR_VAL_EXPR,
152};
153
154/* An attribute value. */
155
156struct attr_val
157{
158 /* How the value is stored in the field u. */
159 enum attr_val_encoding encoding;
160 union
161 {
162 /* ATTR_VAL_ADDRESS, ATTR_VAL_UINT, ATTR_VAL_REF*. */
163 uint64_t uint;
164 /* ATTR_VAL_SINT. */
165 int64_t sint;
166 /* ATTR_VAL_STRING. */
167 const char *string;
168 /* ATTR_VAL_BLOCK not stored. */
169 } u;
170};
171
172/* The line number program header. */
173
174struct line_header
175{
176 /* The version of the line number information. */
177 int version;
178 /* The minimum instruction length. */
179 unsigned int min_insn_len;
180 /* The maximum number of ops per instruction. */
181 unsigned int max_ops_per_insn;
182 /* The line base for special opcodes. */
183 int line_base;
184 /* The line range for special opcodes. */
185 unsigned int line_range;
186 /* The opcode base--the first special opcode. */
187 unsigned int opcode_base;
188 /* Opcode lengths, indexed by opcode - 1. */
189 const unsigned char *opcode_lengths;
190 /* The number of directory entries. */
191 size_t dirs_count;
192 /* The directory entries. */
193 const char **dirs;
194 /* The number of filenames. */
195 size_t filenames_count;
196 /* The filenames. */
197 const char **filenames;
198};
199
200/* Map a single PC value to a file/line. We will keep a vector of
201 these sorted by PC value. Each file/line will be correct from the
202 PC up to the PC of the next entry if there is one. We allocate one
203 extra entry at the end so that we can use bsearch. */
204
205struct line
206{
207 /* PC. */
208 uintptr_t pc;
209 /* File name. Many entries in the array are expected to point to
210 the same file name. */
211 const char *filename;
212 /* Line number. */
213 int lineno;
214 /* Index of the object in the original array read from the DWARF
215 section, before it has been sorted. The index makes it possible
216 to use Quicksort and maintain stability. */
217 int idx;
218};
219
220/* A growable vector of line number information. This is used while
221 reading the line numbers. */
222
223struct line_vector
224{
225 /* Memory. This is an array of struct line. */
226 struct backtrace_vector vec;
227 /* Number of valid mappings. */
228 size_t count;
229};
230
231/* A function described in the debug info. */
232
233struct function
234{
235 /* The name of the function. */
236 const char *name;
237 /* If this is an inlined function, the filename of the call
238 site. */
239 const char *caller_filename;
240 /* If this is an inlined function, the line number of the call
241 site. */
242 int caller_lineno;
243 /* Map PC ranges to inlined functions. */
244 struct function_addrs *function_addrs;
245 size_t function_addrs_count;
246};
247
248/* An address range for a function. This maps a PC value to a
249 specific function. */
250
251struct function_addrs
252{
253 /* Range is LOW <= PC < HIGH. */
254 uint64_t low;
255 uint64_t high;
256 /* Function for this address range. */
257 struct function *function;
258};
259
260/* A growable vector of function address ranges. */
261
262struct function_vector
263{
264 /* Memory. This is an array of struct function_addrs. */
265 struct backtrace_vector vec;
266 /* Number of address ranges present. */
267 size_t count;
268};
269
270/* A DWARF compilation unit. This only holds the information we need
271 to map a PC to a file and line. */
272
273struct unit
274{
275 /* The first entry for this compilation unit. */
276 const unsigned char *unit_data;
277 /* The length of the data for this compilation unit. */
278 size_t unit_data_len;
279 /* The offset of UNIT_DATA from the start of the information for
280 this compilation unit. */
281 size_t unit_data_offset;
282 /* DWARF version. */
283 int version;
284 /* Whether unit is DWARF64. */
285 int is_dwarf64;
286 /* Address size. */
287 int addrsize;
288 /* Offset into line number information. */
289 off_t lineoff;
290 /* Primary source file. */
291 const char *filename;
292 /* Compilation command working directory. */
293 const char *comp_dir;
294 /* Absolute file name, only set if needed. */
295 const char *abs_filename;
296 /* The abbreviations for this unit. */
297 struct abbrevs abbrevs;
298
299 /* The fields above this point are read in during initialization and
300 may be accessed freely. The fields below this point are read in
301 as needed, and therefore require care, as different threads may
302 try to initialize them simultaneously. */
303
304 /* PC to line number mapping. This is NULL if the values have not
305 been read. This is (struct line *) -1 if there was an error
306 reading the values. */
307 struct line *lines;
308 /* Number of entries in lines. */
309 size_t lines_count;
310 /* PC ranges to function. */
311 struct function_addrs *function_addrs;
312 size_t function_addrs_count;
313};
314
315/* An address range for a compilation unit. This maps a PC value to a
316 specific compilation unit. Note that we invert the representation
317 in DWARF: instead of listing the units and attaching a list of
318 ranges, we list the ranges and have each one point to the unit.
319 This lets us do a binary search to find the unit. */
320
321struct unit_addrs
322{
323 /* Range is LOW <= PC < HIGH. */
324 uint64_t low;
325 uint64_t high;
326 /* Compilation unit for this address range. */
327 struct unit *u;
328};
329
330/* A growable vector of compilation unit address ranges. */
331
332struct unit_addrs_vector
333{
334 /* Memory. This is an array of struct unit_addrs. */
335 struct backtrace_vector vec;
336 /* Number of address ranges present. */
337 size_t count;
338};
339
340/* The information we need to map a PC to a file and line. */
341
342struct dwarf_data
343{
344 /* The data for the next file we know about. */
345 struct dwarf_data *next;
346 /* The base address for this file. */
347 uintptr_t base_address;
348 /* A sorted list of address ranges. */
349 struct unit_addrs *addrs;
350 /* Number of address ranges in list. */
351 size_t addrs_count;
352 /* The unparsed .debug_info section. */
353 const unsigned char *dwarf_info;
354 size_t dwarf_info_size;
355 /* The unparsed .debug_line section. */
356 const unsigned char *dwarf_line;
357 size_t dwarf_line_size;
358 /* The unparsed .debug_ranges section. */
359 const unsigned char *dwarf_ranges;
360 size_t dwarf_ranges_size;
361 /* The unparsed .debug_str section. */
362 const unsigned char *dwarf_str;
363 size_t dwarf_str_size;
364 /* Whether the data is big-endian or not. */
365 int is_bigendian;
366 /* A vector used for function addresses. We keep this here so that
367 we can grow the vector as we read more functions. */
368 struct function_vector fvec;
369};
370
371/* Report an error for a DWARF buffer. */
372
373static void
374dwarf_buf_error (struct dwarf_buf *buf, const char *msg)
375{
376 char b[200];
377
378 snprintf (b, sizeof b, "%s in %s at %d",
379 msg, buf->name, (int) (buf->buf - buf->start));
380 buf->error_callback (buf->data, b, 0);
381}
382
383/* Require at least COUNT bytes in BUF. Return 1 if all is well, 0 on
384 error. */
385
386static int
387require (struct dwarf_buf *buf, size_t count)
388{
389 if (buf->left >= count)
390 return 1;
391
392 if (!buf->reported_underflow)
393 {
394 dwarf_buf_error (buf, "DWARF underflow");
395 buf->reported_underflow = 1;
396 }
397
398 return 0;
399}
400
401/* Advance COUNT bytes in BUF. Return 1 if all is well, 0 on
402 error. */
403
404static int
405advance (struct dwarf_buf *buf, size_t count)
406{
407 if (!require (buf, count))
408 return 0;
409 buf->buf += count;
410 buf->left -= count;
411 return 1;
412}
413
414/* Read one byte from BUF and advance 1 byte. */
415
416static unsigned char
417read_byte (struct dwarf_buf *buf)
418{
419 const unsigned char *p = buf->buf;
420
421 if (!advance (buf, 1))
422 return 0;
423 return p[0];
424}
425
426/* Read a signed char from BUF and advance 1 byte. */
427
428static signed char
429read_sbyte (struct dwarf_buf *buf)
430{
431 const unsigned char *p = buf->buf;
432
433 if (!advance (buf, 1))
434 return 0;
435 return (*p ^ 0x80) - 0x80;
436}
437
438/* Read a uint16 from BUF and advance 2 bytes. */
439
440static uint16_t
441read_uint16 (struct dwarf_buf *buf)
442{
443 const unsigned char *p = buf->buf;
444
445 if (!advance (buf, 2))
446 return 0;
447 if (buf->is_bigendian)
448 return ((uint16_t) p[0] << 8) | (uint16_t) p[1];
449 else
450 return ((uint16_t) p[1] << 8) | (uint16_t) p[0];
451}
452
453/* Read a uint32 from BUF and advance 4 bytes. */
454
455static uint32_t
456read_uint32 (struct dwarf_buf *buf)
457{
458 const unsigned char *p = buf->buf;
459
460 if (!advance (buf, 4))
461 return 0;
462 if (buf->is_bigendian)
463 return (((uint32_t) p[0] << 24) | ((uint32_t) p[1] << 16)
464 | ((uint32_t) p[2] << 8) | (uint32_t) p[3]);
465 else
466 return (((uint32_t) p[3] << 24) | ((uint32_t) p[2] << 16)
467 | ((uint32_t) p[1] << 8) | (uint32_t) p[0]);
468}
469
470/* Read a uint64 from BUF and advance 8 bytes. */
471
472static uint64_t
473read_uint64 (struct dwarf_buf *buf)
474{
475 const unsigned char *p = buf->buf;
476
477 if (!advance (buf, 8))
478 return 0;
479 if (buf->is_bigendian)
480 return (((uint64_t) p[0] << 56) | ((uint64_t) p[1] << 48)
481 | ((uint64_t) p[2] << 40) | ((uint64_t) p[3] << 32)
482 | ((uint64_t) p[4] << 24) | ((uint64_t) p[5] << 16)
483 | ((uint64_t) p[6] << 8) | (uint64_t) p[7]);
484 else
485 return (((uint64_t) p[7] << 56) | ((uint64_t) p[6] << 48)
486 | ((uint64_t) p[5] << 40) | ((uint64_t) p[4] << 32)
487 | ((uint64_t) p[3] << 24) | ((uint64_t) p[2] << 16)
488 | ((uint64_t) p[1] << 8) | (uint64_t) p[0]);
489}
490
491/* Read an offset from BUF and advance the appropriate number of
492 bytes. */
493
494static uint64_t
495read_offset (struct dwarf_buf *buf, int is_dwarf64)
496{
497 if (is_dwarf64)
498 return read_uint64 (buf);
499 else
500 return read_uint32 (buf);
501}
502
503/* Read an address from BUF and advance the appropriate number of
504 bytes. */
505
506static uint64_t
507read_address (struct dwarf_buf *buf, int addrsize)
508{
509 switch (addrsize)
510 {
511 case 1:
512 return read_byte (buf);
513 case 2:
514 return read_uint16 (buf);
515 case 4:
516 return read_uint32 (buf);
517 case 8:
518 return read_uint64 (buf);
519 default:
520 dwarf_buf_error (buf, "unrecognized address size");
521 return 0;
522 }
523}
524
525/* Return whether a value is the highest possible address, given the
526 address size. */
527
528static int
529is_highest_address (uint64_t address, int addrsize)
530{
531 switch (addrsize)
532 {
533 case 1:
534 return address == (unsigned char) -1;
535 case 2:
536 return address == (uint16_t) -1;
537 case 4:
538 return address == (uint32_t) -1;
539 case 8:
540 return address == (uint64_t) -1;
541 default:
542 return 0;
543 }
544}
545
546/* Read an unsigned LEB128 number. */
547
548static uint64_t
549read_uleb128 (struct dwarf_buf *buf)
550{
551 uint64_t ret;
552 unsigned int shift;
553 int overflow;
554 unsigned char b;
555
556 ret = 0;
557 shift = 0;
558 overflow = 0;
559 do
560 {
561 const unsigned char *p;
562
563 p = buf->buf;
564 if (!advance (buf, 1))
565 return 0;
566 b = *p;
567 if (shift < 64)
568 ret |= ((uint64_t) (b & 0x7f)) << shift;
569 else if (!overflow)
570 {
571 dwarf_buf_error (buf, "LEB128 overflows uint64_t");
572 overflow = 1;
573 }
574 shift += 7;
575 }
576 while ((b & 0x80) != 0);
577
578 return ret;
579}
580
581/* Read a signed LEB128 number. */
582
583static int64_t
584read_sleb128 (struct dwarf_buf *buf)
585{
586 uint64_t val;
587 unsigned int shift;
588 int overflow;
589 unsigned char b;
590
591 val = 0;
592 shift = 0;
593 overflow = 0;
594 do
595 {
596 const unsigned char *p;
597
598 p = buf->buf;
599 if (!advance (buf, 1))
600 return 0;
601 b = *p;
602 if (shift < 64)
603 val |= ((uint64_t) (b & 0x7f)) << shift;
604 else if (!overflow)
605 {
606 dwarf_buf_error (buf, "signed LEB128 overflows uint64_t");
607 overflow = 1;
608 }
609 shift += 7;
610 }
611 while ((b & 0x80) != 0);
612
613 if ((b & 0x40) != 0 && shift < 64)
614 val |= ((uint64_t) -1) << shift;
615
616 return (int64_t) val;
617}
618
619/* Return the length of an LEB128 number. */
620
621static size_t
622leb128_len (const unsigned char *p)
623{
624 size_t ret;
625
626 ret = 1;
627 while ((*p & 0x80) != 0)
628 {
629 ++p;
630 ++ret;
631 }
632 return ret;
633}
634
635/* Free an abbreviations structure. */
636
637static void
638free_abbrevs (struct backtrace_state *state, struct abbrevs *abbrevs,
639 backtrace_error_callback error_callback, void *data)
640{
641 size_t i;
642
643 for (i = 0; i < abbrevs->num_abbrevs; ++i)
644 backtrace_free (state, abbrevs->abbrevs[i].attrs,
645 abbrevs->abbrevs[i].num_attrs * sizeof (struct attr),
646 error_callback, data);
647 backtrace_free (state, abbrevs->abbrevs,
648 abbrevs->num_abbrevs * sizeof (struct abbrev),
649 error_callback, data);
650 abbrevs->num_abbrevs = 0;
651 abbrevs->abbrevs = NULL((void*)0);
652}
653
654/* Read an attribute value. Returns 1 on success, 0 on failure. If
655 the value can be represented as a uint64_t, sets *VAL and sets
656 *IS_VALID to 1. We don't try to store the value of other attribute
657 forms, because we don't care about them. */
658
659static int
660read_attribute (enum dwarf_form form, struct dwarf_buf *buf,
661 int is_dwarf64, int version, int addrsize,
662 const unsigned char *dwarf_str, size_t dwarf_str_size,
663 struct attr_val *val)
664{
665 /* Avoid warnings about val.u.FIELD may be used uninitialized if
666 this function is inlined. The warnings aren't valid but can
667 occur because the different fields are set and used
668 conditionally. */
669 memset (val, 0, sizeof *val);
670
671 switch (form)
672 {
673 case DW_FORM_addr:
674 val->encoding = ATTR_VAL_ADDRESS;
675 val->u.uint = read_address (buf, addrsize);
676 return 1;
677 case DW_FORM_block2:
678 val->encoding = ATTR_VAL_BLOCK;
679 return advance (buf, read_uint16 (buf));
680 case DW_FORM_block4:
681 val->encoding = ATTR_VAL_BLOCK;
682 return advance (buf, read_uint32 (buf));
683 case DW_FORM_data2:
684 val->encoding = ATTR_VAL_UINT;
685 val->u.uint = read_uint16 (buf);
686 return 1;
687 case DW_FORM_data4:
688 val->encoding = ATTR_VAL_UINT;
689 val->u.uint = read_uint32 (buf);
690 return 1;
691 case DW_FORM_data8:
692 val->encoding = ATTR_VAL_UINT;
693 val->u.uint = read_uint64 (buf);
694 return 1;
695 case DW_FORM_string:
696 val->encoding = ATTR_VAL_STRING;
697 val->u.string = (const char *) buf->buf;
698 return advance (buf, strnlen ((const char *) buf->buf, buf->left) + 1);
699 case DW_FORM_block:
700 val->encoding = ATTR_VAL_BLOCK;
701 return advance (buf, read_uleb128 (buf));
702 case DW_FORM_block1:
703 val->encoding = ATTR_VAL_BLOCK;
704 return advance (buf, read_byte (buf));
705 case DW_FORM_data1:
706 val->encoding = ATTR_VAL_UINT;
707 val->u.uint = read_byte (buf);
708 return 1;
709 case DW_FORM_flag:
710 val->encoding = ATTR_VAL_UINT;
711 val->u.uint = read_byte (buf);
712 return 1;
713 case DW_FORM_sdata:
714 val->encoding = ATTR_VAL_SINT;
715 val->u.sint = read_sleb128 (buf);
716 return 1;
717 case DW_FORM_strp:
718 {
719 uint64_t offset;
720
721 offset = read_offset (buf, is_dwarf64);
722 if (offset >= dwarf_str_size)
723 {
724 dwarf_buf_error (buf, "DW_FORM_strp out of range");
725 return 0;
726 }
727 val->encoding = ATTR_VAL_STRING;
728 val->u.string = (const char *) dwarf_str + offset;
729 return 1;
730 }
731 case DW_FORM_udata:
732 val->encoding = ATTR_VAL_UINT;
733 val->u.uint = read_uleb128 (buf);
734 return 1;
735 case DW_FORM_ref_addr:
736 val->encoding = ATTR_VAL_REF_INFO;
737 if (version == 2)
738 val->u.uint = read_address (buf, addrsize);
739 else
740 val->u.uint = read_offset (buf, is_dwarf64);
741 return 1;
742 case DW_FORM_ref1:
743 val->encoding = ATTR_VAL_REF_UNIT;
744 val->u.uint = read_byte (buf);
745 return 1;
746 case DW_FORM_ref2:
747 val->encoding = ATTR_VAL_REF_UNIT;
748 val->u.uint = read_uint16 (buf);
749 return 1;
750 case DW_FORM_ref4:
751 val->encoding = ATTR_VAL_REF_UNIT;
752 val->u.uint = read_uint32 (buf);
753 return 1;
754 case DW_FORM_ref8:
755 val->encoding = ATTR_VAL_REF_UNIT;
756 val->u.uint = read_uint64 (buf);
757 return 1;
758 case DW_FORM_ref_udata:
759 val->encoding = ATTR_VAL_REF_UNIT;
760 val->u.uint = read_uleb128 (buf);
761 return 1;
762 case DW_FORM_indirect:
763 {
764 uint64_t form;
765
766 form = read_uleb128 (buf);
767 return read_attribute ((enum dwarf_form) form, buf, is_dwarf64,
768 version, addrsize, dwarf_str, dwarf_str_size,
769 val);
770 }
771 case DW_FORM_sec_offset:
772 val->encoding = ATTR_VAL_REF_SECTION;
773 val->u.uint = read_offset (buf, is_dwarf64);
774 return 1;
775 case DW_FORM_exprloc:
776 val->encoding = ATTR_VAL_EXPR;
777 return advance (buf, read_uleb128 (buf));
778 case DW_FORM_flag_present:
779 val->encoding = ATTR_VAL_UINT;
780 val->u.uint = 1;
781 return 1;
782 case DW_FORM_ref_sig8:
783 val->encoding = ATTR_VAL_REF_TYPE;
784 val->u.uint = read_uint64 (buf);
785 return 1;
786 case DW_FORM_GNU_addr_index:
787 val->encoding = ATTR_VAL_REF_SECTION;
788 val->u.uint = read_uleb128 (buf);
789 return 1;
790 case DW_FORM_GNU_str_index:
791 val->encoding = ATTR_VAL_REF_SECTION;
792 val->u.uint = read_uleb128 (buf);
793 return 1;
794 case DW_FORM_GNU_ref_alt:
795 val->encoding = ATTR_VAL_REF_SECTION;
796 val->u.uint = read_offset (buf, is_dwarf64);
797 return 1;
798 case DW_FORM_GNU_strp_alt:
799 val->encoding = ATTR_VAL_REF_SECTION;
800 val->u.uint = read_offset (buf, is_dwarf64);
801 return 1;
802 default:
803 dwarf_buf_error (buf, "unrecognized DWARF form");
804 return 0;
805 }
806}
807
808/* Compare function_addrs for qsort. When ranges are nested, make the
809 smallest one sort last. */
810
811static int
812function_addrs_compare (const void *v1, const void *v2)
813{
814 const struct function_addrs *a1 = (const struct function_addrs *) v1;
815 const struct function_addrs *a2 = (const struct function_addrs *) v2;
816
817 if (a1->low < a2->low)
818 return -1;
819 if (a1->low > a2->low)
820 return 1;
821 if (a1->high < a2->high)
822 return 1;
823 if (a1->high > a2->high)
824 return -1;
825 return strcmp (a1->function->name, a2->function->name);
826}
827
828/* Compare a PC against a function_addrs for bsearch. Note that if
829 there are multiple ranges containing PC, which one will be returned
830 is unpredictable. We compensate for that in dwarf_fileline. */
831
832static int
833function_addrs_search (const void *vkey, const void *ventry)
834{
835 const uintptr_t *key = (const uintptr_t *) vkey;
836 const struct function_addrs *entry = (const struct function_addrs *) ventry;
837 uintptr_t pc;
838
839 pc = *key;
840 if (pc < entry->low)
841 return -1;
842 else if (pc >= entry->high)
843 return 1;
844 else
845 return 0;
846}
847
848/* Add a new compilation unit address range to a vector. Returns 1 on
849 success, 0 on failure. */
850
851static int
852add_unit_addr (struct backtrace_state *state, uintptr_t base_address,
853 struct unit_addrs addrs,
854 backtrace_error_callback error_callback, void *data,
855 struct unit_addrs_vector *vec)
856{
857 struct unit_addrs *p;
858
859 /* Add in the base address of the module here, so that we can look
860 up the PC directly. */
861 addrs.low += base_address;
862 addrs.high += base_address;
863
864 /* Try to merge with the last entry. */
865 if (vec->count > 0)
866 {
867 p = (struct unit_addrs *) vec->vec.base + (vec->count - 1);
868 if ((addrs.low == p->high || addrs.low == p->high + 1)
869 && addrs.u == p->u)
870 {
871 if (addrs.high > p->high)
872 p->high = addrs.high;
873 return 1;
874 }
875 }
876
877 p = ((struct unit_addrs *)
878 backtrace_vector_grow (state, sizeof (struct unit_addrs),
879 error_callback, data, &vec->vec));
880 if (p == NULL((void*)0))
881 return 0;
882
883 *p = addrs;
884 ++vec->count;
885 return 1;
886}
887
888/* Free a unit address vector. */
889
890static void
891free_unit_addrs_vector (struct backtrace_state *state,
892 struct unit_addrs_vector *vec,
893 backtrace_error_callback error_callback, void *data)
894{
895 struct unit_addrs *addrs;
896 size_t i;
897
898 addrs = (struct unit_addrs *) vec->vec.base;
899 for (i = 0; i < vec->count; ++i)
900 free_abbrevs (state, &addrs[i].u->abbrevs, error_callback, data);
901}
902
903/* Compare unit_addrs for qsort. When ranges are nested, make the
904 smallest one sort last. */
905
906static int
907unit_addrs_compare (const void *v1, const void *v2)
908{
909 const struct unit_addrs *a1 = (const struct unit_addrs *) v1;
910 const struct unit_addrs *a2 = (const struct unit_addrs *) v2;
911
912 if (a1->low < a2->low)
913 return -1;
914 if (a1->low > a2->low)
915 return 1;
916 if (a1->high < a2->high)
917 return 1;
918 if (a1->high > a2->high)
919 return -1;
920 if (a1->u->lineoff < a2->u->lineoff)
921 return -1;
922 if (a1->u->lineoff > a2->u->lineoff)
923 return 1;
924 return 0;
925}
926
927/* Compare a PC against a unit_addrs for bsearch. Note that if there
928 are multiple ranges containing PC, which one will be returned is
929 unpredictable. We compensate for that in dwarf_fileline. */
930
931static int
932unit_addrs_search (const void *vkey, const void *ventry)
933{
934 const uintptr_t *key = (const uintptr_t *) vkey;
935 const struct unit_addrs *entry = (const struct unit_addrs *) ventry;
936 uintptr_t pc;
937
938 pc = *key;
939 if (pc < entry->low)
940 return -1;
941 else if (pc >= entry->high)
942 return 1;
943 else
944 return 0;
945}
946
947/* Sort the line vector by PC. We want a stable sort here to maintain
948 the order of lines for the same PC values. Since the sequence is
949 being sorted in place, their addresses cannot be relied on to
950 maintain stability. That is the purpose of the index member. */
951
952static int
953line_compare (const void *v1, const void *v2)
954{
955 const struct line *ln1 = (const struct line *) v1;
956 const struct line *ln2 = (const struct line *) v2;
957
958 if (ln1->pc < ln2->pc)
959 return -1;
960 else if (ln1->pc > ln2->pc)
961 return 1;
962 else if (ln1->idx < ln2->idx)
963 return -1;
964 else if (ln1->idx > ln2->idx)
965 return 1;
966 else
967 return 0;
968}
969
970/* Find a PC in a line vector. We always allocate an extra entry at
971 the end of the lines vector, so that this routine can safely look
972 at the next entry. Note that when there are multiple mappings for
973 the same PC value, this will return the last one. */
974
975static int
976line_search (const void *vkey, const void *ventry)
977{
978 const uintptr_t *key = (const uintptr_t *) vkey;
979 const struct line *entry = (const struct line *) ventry;
980 uintptr_t pc;
981
982 pc = *key;
983 if (pc < entry->pc)
984 return -1;
985 else if (pc >= (entry + 1)->pc)
986 return 1;
987 else
988 return 0;
989}
990
991/* Sort the abbrevs by the abbrev code. This function is passed to
992 both qsort and bsearch. */
993
994static int
995abbrev_compare (const void *v1, const void *v2)
996{
997 const struct abbrev *a1 = (const struct abbrev *) v1;
998 const struct abbrev *a2 = (const struct abbrev *) v2;
999
1000 if (a1->code < a2->code)
1001 return -1;
1002 else if (a1->code > a2->code)
1003 return 1;
1004 else
1005 {
1006 /* This really shouldn't happen. It means there are two
1007 different abbrevs with the same code, and that means we don't
1008 know which one lookup_abbrev should return. */
1009 return 0;
1010 }
1011}
1012
1013/* Read the abbreviation table for a compilation unit. Returns 1 on
1014 success, 0 on failure. */
1015
1016static int
1017read_abbrevs (struct backtrace_state *state, uint64_t abbrev_offset,
1018 const unsigned char *dwarf_abbrev, size_t dwarf_abbrev_size,
1019 int is_bigendian, backtrace_error_callback error_callback,
1020 void *data, struct abbrevs *abbrevs)
1021{
1022 struct dwarf_buf abbrev_buf;
1023 struct dwarf_buf count_buf;
1024 size_t num_abbrevs;
1025
1026 abbrevs->num_abbrevs = 0;
1027 abbrevs->abbrevs = NULL((void*)0);
1028
1029 if (abbrev_offset >= dwarf_abbrev_size)
1030 {
1031 error_callback (data, "abbrev offset out of range", 0);
1032 return 0;
1033 }
1034
1035 abbrev_buf.name = ".debug_abbrev";
1036 abbrev_buf.start = dwarf_abbrev;
1037 abbrev_buf.buf = dwarf_abbrev + abbrev_offset;
1038 abbrev_buf.left = dwarf_abbrev_size - abbrev_offset;
1039 abbrev_buf.is_bigendian = is_bigendian;
1040 abbrev_buf.error_callback = error_callback;
1041 abbrev_buf.data = data;
1042 abbrev_buf.reported_underflow = 0;
1043
1044 /* Count the number of abbrevs in this list. */
1045
1046 count_buf = abbrev_buf;
1047 num_abbrevs = 0;
1048 while (read_uleb128 (&count_buf) != 0)
1049 {
1050 if (count_buf.reported_underflow)
1051 return 0;
1052 ++num_abbrevs;
1053 // Skip tag.
1054 read_uleb128 (&count_buf);
1055 // Skip has_children.
1056 read_byte (&count_buf);
1057 // Skip attributes.
1058 while (read_uleb128 (&count_buf) != 0)
1059 read_uleb128 (&count_buf);
1060 // Skip form of last attribute.
1061 read_uleb128 (&count_buf);
1062 }
1063
1064 if (count_buf.reported_underflow)
1065 return 0;
1066
1067 if (num_abbrevs == 0)
1068 return 1;
1069
1070 abbrevs->num_abbrevs = num_abbrevs;
1071 abbrevs->abbrevs = ((struct abbrev *)
1072 backtrace_alloc (state,
1073 num_abbrevs * sizeof (struct abbrev),
1074 error_callback, data));
1075 if (abbrevs->abbrevs == NULL((void*)0))
1076 return 0;
1077 memset (abbrevs->abbrevs, 0, num_abbrevs * sizeof (struct abbrev));
1078
1079 num_abbrevs = 0;
1080 while (1)
1081 {
1082 uint64_t code;
1083 struct abbrev a;
1084 size_t num_attrs;
1085 struct attr *attrs;
1086
1087 if (abbrev_buf.reported_underflow)
1088 goto fail;
1089
1090 code = read_uleb128 (&abbrev_buf);
1091 if (code == 0)
1092 break;
1093
1094 a.code = code;
1095 a.tag = (enum dwarf_tag) read_uleb128 (&abbrev_buf);
1096 a.has_children = read_byte (&abbrev_buf);
1097
1098 count_buf = abbrev_buf;
1099 num_attrs = 0;
1100 while (read_uleb128 (&count_buf) != 0)
1101 {
1102 ++num_attrs;
1103 read_uleb128 (&count_buf);
1104 }
1105
1106 if (num_attrs == 0)
1107 {
1108 attrs = NULL((void*)0);
1109 read_uleb128 (&abbrev_buf);
1110 read_uleb128 (&abbrev_buf);
1111 }
1112 else
1113 {
1114 attrs = ((struct attr *)
1115 backtrace_alloc (state, num_attrs * sizeof *attrs,
1116 error_callback, data));
1117 if (attrs == NULL((void*)0))
1118 goto fail;
1119 num_attrs = 0;
1120 while (1)
1121 {
1122 uint64_t name;
1123 uint64_t form;
1124
1125 name = read_uleb128 (&abbrev_buf);
1126 form = read_uleb128 (&abbrev_buf);
1127 if (name == 0)
1128 break;
1129 attrs[num_attrs].name = (enum dwarf_attribute) name;
1130 attrs[num_attrs].form = (enum dwarf_form) form;
1131 ++num_attrs;
1132 }
1133 }
1134
1135 a.num_attrs = num_attrs;
1136 a.attrs = attrs;
1137
1138 abbrevs->abbrevs[num_abbrevs] = a;
1139 ++num_abbrevs;
1140 }
1141
1142 backtrace_qsort (abbrevs->abbrevs, abbrevs->num_abbrevs,
1143 sizeof (struct abbrev), abbrev_compare);
1144
1145 return 1;
1146
1147 fail:
1148 free_abbrevs (state, abbrevs, error_callback, data);
1149 return 0;
1150}
1151
1152/* Return the abbrev information for an abbrev code. */
1153
1154static const struct abbrev *
1155lookup_abbrev (struct abbrevs *abbrevs, uint64_t code,
1156 backtrace_error_callback error_callback, void *data)
1157{
1158 struct abbrev key;
1159 void *p;
1160
1161 /* With GCC, where abbrevs are simply numbered in order, we should
1162 be able to just look up the entry. */
1163 if (code - 1 < abbrevs->num_abbrevs
1164 && abbrevs->abbrevs[code - 1].code == code)
1165 return &abbrevs->abbrevs[code - 1];
1166
1167 /* Otherwise we have to search. */
1168 memset (&key, 0, sizeof key);
1169 key.code = code;
1170 p = bsearch (&key, abbrevs->abbrevs, abbrevs->num_abbrevs,
83
←
Null pointer passed as an argument to a 'nonnull' parameter
1171 sizeof (struct abbrev), abbrev_compare);
1172 if (p == NULL((void*)0))
1173 {
1174 error_callback (data, "invalid abbreviation code", 0);
1175 return NULL((void*)0);
1176 }
1177 return (const struct abbrev *) p;
1178}
1179
1180/* Add non-contiguous address ranges for a compilation unit. Returns
1181 1 on success, 0 on failure. */
1182
1183static int
1184add_unit_ranges (struct backtrace_state *state, uintptr_t base_address,
1185 struct unit *u, uint64_t ranges, uint64_t base,
1186 int is_bigendian, const unsigned char *dwarf_ranges,
1187 size_t dwarf_ranges_size,
1188 backtrace_error_callback error_callback, void *data,
1189 struct unit_addrs_vector *addrs)
1190{
1191 struct dwarf_buf ranges_buf;
1192
1193 if (ranges >= dwarf_ranges_size)
1194 {
1195 error_callback (data, "ranges offset out of range", 0);
1196 return 0;
1197 }
1198
1199 ranges_buf.name = ".debug_ranges";
1200 ranges_buf.start = dwarf_ranges;
1201 ranges_buf.buf = dwarf_ranges + ranges;
1202 ranges_buf.left = dwarf_ranges_size - ranges;
1203 ranges_buf.is_bigendian = is_bigendian;
1204 ranges_buf.error_callback = error_callback;
1205 ranges_buf.data = data;
1206 ranges_buf.reported_underflow = 0;
1207
1208 while (1)
1209 {
1210 uint64_t low;
1211 uint64_t high;
1212
1213 if (ranges_buf.reported_underflow)
1214 return 0;
1215
1216 low = read_address (&ranges_buf, u->addrsize);
1217 high = read_address (&ranges_buf, u->addrsize);
1218
1219 if (low == 0 && high == 0)
1220 break;
1221
1222 if (is_highest_address (low, u->addrsize))
1223 base = high;
1224 else
1225 {
1226 struct unit_addrs a;
1227
1228 a.low = low + base;
1229 a.high = high + base;
1230 a.u = u;
1231 if (!add_unit_addr (state, base_address, a, error_callback, data,
1232 addrs))
1233 return 0;
1234 }
1235 }
1236
1237 if (ranges_buf.reported_underflow)
1238 return 0;
1239
1240 return 1;
1241}
1242
1243/* Find the address range covered by a compilation unit, reading from
1244 UNIT_BUF and adding values to U. Returns 1 if all data could be
1245 read, 0 if there is some error. */
1246
1247static int
1248find_address_ranges (struct backtrace_state *state, uintptr_t base_address,
1249 struct dwarf_buf *unit_buf,
1250 const unsigned char *dwarf_str, size_t dwarf_str_size,
1251 const unsigned char *dwarf_ranges,
1252 size_t dwarf_ranges_size,
1253 int is_bigendian, backtrace_error_callback error_callback,
1254 void *data, struct unit *u,
1255 struct unit_addrs_vector *addrs)
1256{
1257 while (unit_buf->left > 0)
16
←
Assuming the condition is false
→
17
←
Loop condition is false. Execution continues on line 1395
→
36
←
Assuming the condition is false
→
37
←
Loop condition is false. Execution continues on line 1395
→
56
←
Assuming the condition is false
→
57
←
Loop condition is false. Execution continues on line 1395
→
78
←
Assuming the condition is true
→
79
←
Loop condition is true. Entering loop body
→
1258 {
1259 uint64_t code;
1260 const struct abbrev *abbrev;
1261 uint64_t lowpc;
1262 int have_lowpc;
1263 uint64_t highpc;
1264 int have_highpc;
1265 int highpc_is_relative;
1266 uint64_t ranges;
1267 int have_ranges;
1268 size_t i;
1269
1270 code = read_uleb128 (unit_buf);
1271 if (code == 0)
80
←
Assuming 'code' is not equal to 0
→
81
←
Taking false branch
→
1272 return 1;
1273
1274 abbrev = lookup_abbrev (&u->abbrevs, code, error_callback, data);
82
←
Calling 'lookup_abbrev'
→
1275 if (abbrev == NULL((void*)0))
1276 return 0;
1277
1278 lowpc = 0;
1279 have_lowpc = 0;
1280 highpc = 0;
1281 have_highpc = 0;
1282 highpc_is_relative = 0;
1283 ranges = 0;
1284 have_ranges = 0;
1285 for (i = 0; i < abbrev->num_attrs; ++i)
1286 {
1287 struct attr_val val;
1288
1289 if (!read_attribute (abbrev->attrs[i].form, unit_buf,
1290 u->is_dwarf64, u->version, u->addrsize,
1291 dwarf_str, dwarf_str_size, &val))
1292 return 0;
1293
1294 switch (abbrev->attrs[i].name)
1295 {
1296 case DW_AT_low_pc:
1297 if (val.encoding == ATTR_VAL_ADDRESS)
1298 {
1299 lowpc = val.u.uint;
1300 have_lowpc = 1;
1301 }
1302 break;
1303
1304 case DW_AT_high_pc:
1305 if (val.encoding == ATTR_VAL_ADDRESS)
1306 {
1307 highpc = val.u.uint;
1308 have_highpc = 1;
1309 }
1310 else if (val.encoding == ATTR_VAL_UINT)
1311 {
1312 highpc = val.u.uint;
1313 have_highpc = 1;
1314 highpc_is_relative = 1;
1315 }
1316 break;
1317
1318 case DW_AT_ranges:
1319 if (val.encoding == ATTR_VAL_UINT
1320 || val.encoding == ATTR_VAL_REF_SECTION)
1321 {
1322 ranges = val.u.uint;
1323 have_ranges = 1;
1324 }
1325 break;
1326
1327 case DW_AT_stmt_list:
1328 if (abbrev->tag == DW_TAG_compile_unit
1329 && (val.encoding == ATTR_VAL_UINT
1330 || val.encoding == ATTR_VAL_REF_SECTION))
1331 u->lineoff = val.u.uint;
1332 break;
1333
1334 case DW_AT_name:
1335 if (abbrev->tag == DW_TAG_compile_unit
1336 && val.encoding == ATTR_VAL_STRING)
1337 u->filename = val.u.string;
1338 break;
1339
1340 case DW_AT_comp_dir:
1341 if (abbrev->tag == DW_TAG_compile_unit
1342 && val.encoding == ATTR_VAL_STRING)
1343 u->comp_dir = val.u.string;
1344 break;
1345
1346 default:
1347 break;
1348 }
1349 }
1350
1351 if (abbrev->tag == DW_TAG_compile_unit
1352 || abbrev->tag == DW_TAG_subprogram)
1353 {
1354 if (have_ranges)
1355 {
1356 if (!add_unit_ranges (state, base_address, u, ranges, lowpc,
1357 is_bigendian, dwarf_ranges,
1358 dwarf_ranges_size, error_callback,
1359 data, addrs))
1360 return 0;
1361 }
1362 else if (have_lowpc && have_highpc)
1363 {
1364 struct unit_addrs a;
1365
1366 if (highpc_is_relative)
1367 highpc += lowpc;
1368 a.low = lowpc;
1369 a.high = highpc;
1370 a.u = u;
1371
1372 if (!add_unit_addr (state, base_address, a, error_callback, data,
1373 addrs))
1374 return 0;
1375 }
1376
1377 /* If we found the PC range in the DW_TAG_compile_unit, we
1378 can stop now. */
1379 if (abbrev->tag == DW_TAG_compile_unit
1380 && (have_ranges || (have_lowpc && have_highpc)))
1381 return 1;
1382 }
1383
1384 if (abbrev->has_children)
1385 {
1386 if (!find_address_ranges (state, base_address, unit_buf,
1387 dwarf_str, dwarf_str_size,
1388 dwarf_ranges, dwarf_ranges_size,
1389 is_bigendian, error_callback, data,
1390 u, addrs))
1391 return 0;
1392 }
1393 }
1394
1395 return 1;
1396}
1397
1398/* Build a mapping from address ranges to the compilation units where
1399 the line number information for that range can be found. Returns 1
1400 on success, 0 on failure. */
1401
1402static int
1403build_address_map (struct backtrace_state *state, uintptr_t base_address,
1404 const unsigned char *dwarf_info, size_t dwarf_info_size,
1405 const unsigned char *dwarf_abbrev, size_t dwarf_abbrev_size,
1406 const unsigned char *dwarf_ranges, size_t dwarf_ranges_size,
1407 const unsigned char *dwarf_str, size_t dwarf_str_size,
1408 int is_bigendian, backtrace_error_callback error_callback,
1409 void *data, struct unit_addrs_vector *addrs)
1410{
1411 struct dwarf_buf info;
1412 struct abbrevs abbrevs;
1413
1414 memset (&addrs->vec, 0, sizeof addrs->vec);
1415 addrs->count = 0;
1416
1417 /* Read through the .debug_info section. FIXME: Should we use the
1418 .debug_aranges section? gdb and addr2line don't use it, but I'm
1419 not sure why. */
1420
1421 info.name = ".debug_info";
1422 info.start = dwarf_info;
1423 info.buf = dwarf_info;
1424 info.left = dwarf_info_size;
1425 info.is_bigendian = is_bigendian;
1426 info.error_callback = error_callback;
1427 info.data = data;
1428 info.reported_underflow = 0;
1429
1430 memset (&abbrevs, 0, sizeof abbrevs);
1431 while (info.left > 0)
3
←
Assuming the condition is true
→
4
←
Loop condition is true. Entering loop body
→
22
←
Assuming the condition is true
→
23
←
Loop condition is true. Entering loop body
→
42
←
Assuming the condition is true
→
43
←
Loop condition is true. Entering loop body
→
62
←
Assuming the condition is true
→
63
←
Loop condition is true. Entering loop body
→
1432 {
1433 const unsigned char *unit_data_start;
1434 uint64_t len;
1435 int is_dwarf64;
1436 struct dwarf_buf unit_buf;
1437 int version;
1438 uint64_t abbrev_offset;
1439 int addrsize;
1440 struct unit *u;
1441
1442 if (info.reported_underflow)
5
←
Taking false branch
→
24
←
Assuming the condition is false
→
25
←
Taking false branch
→
44
←
Assuming the condition is false
→
45
←
Taking false branch
→
64
←
Assuming the condition is false
→
65
←
Taking false branch
→
1443 goto fail;
1444
1445 unit_data_start = info.buf;
1446
1447 is_dwarf64 = 0;
1448 len = read_uint32 (&info);
1449 if (len == 0xffffffff)
6
←
Assuming 'len' is not equal to -1
→
7
←
Taking false branch
→
26
←
Assuming 'len' is not equal to -1
→
27
←
Taking false branch
→
46
←
Assuming 'len' is not equal to -1
→
47
←
Taking false branch
→
66
←
Assuming 'len' is not equal to -1
→
67
←
Taking false branch
→
1450 {
1451 len = read_uint64 (&info);
1452 is_dwarf64 = 1;
1453 }
1454
1455 unit_buf = info;
1456 unit_buf.left = len;
1457
1458 if (!advance (&info, len))
8
←
Taking false branch
→
28
←
Taking false branch
→
48
←
Taking false branch
→
68
←
Taking false branch
→
1459 goto fail;
1460
1461 version = read_uint16 (&unit_buf);
1462 if (version < 2 || version > 4)
9
←
Assuming 'version' is >= 2
→
10
←
Assuming 'version' is <= 4
→
11
←
Taking false branch
→
29
←
Assuming 'version' is >= 2
→
30
←
Assuming 'version' is <= 4
→
31
←
Taking false branch
→
49
←
Assuming 'version' is >= 2
→
50
←
Assuming 'version' is <= 4
→
51
←
Taking false branch
→
69
←
Assuming 'version' is >= 2
→
70
←
Assuming 'version' is <= 4
→
71
←
Taking false branch
→
1463 {
1464 dwarf_buf_error (&unit_buf, "unrecognized DWARF version");
1465 goto fail;
1466 }
1467
1468 abbrev_offset = read_offset (&unit_buf, is_dwarf64);
1469 if (!read_abbrevs (state, abbrev_offset, dwarf_abbrev, dwarf_abbrev_size,
12
←
Taking false branch
→
32
←
Taking false branch
→
52
←
Taking false branch
→
72
←
Taking false branch
→
1470 is_bigendian, error_callback, data, &abbrevs))
1471 goto fail;
1472
1473 addrsize = read_byte (&unit_buf);
1474
1475 u = ((struct unit *)
1476 backtrace_alloc (state, sizeof *u, error_callback, data));
1477 if (u == NULL((void*)0))
13
←
Assuming 'u' is not equal to NULL
→
14
←
Taking false branch
→
33
←
Assuming 'u' is not equal to NULL
→
34
←
Taking false branch
→
53
←
Assuming 'u' is not equal to NULL
→
54
←
Taking false branch
→
73
←
Assuming 'u' is not equal to NULL
→
74
←
Taking false branch
→
1478 goto fail;
1479 u->unit_data = unit_buf.buf;
1480 u->unit_data_len = unit_buf.left;
1481 u->unit_data_offset = unit_buf.buf - unit_data_start;
1482 u->version = version;
1483 u->is_dwarf64 = is_dwarf64;
1484 u->addrsize = addrsize;
1485 u->filename = NULL((void*)0);
1486 u->comp_dir = NULL((void*)0);
1487 u->abs_filename = NULL((void*)0);
1488 u->lineoff = 0;
75
←
Value assigned to 'abbrevs'
→
1489 u->abbrevs = abbrevs;
76
←
Null pointer value stored to field 'abbrevs'
→
1490 memset (&abbrevs, 0, sizeof abbrevs);
1491
1492 /* The actual line number mappings will be read as needed. */
1493 u->lines = NULL((void*)0);
1494 u->lines_count = 0;
1495 u->function_addrs = NULL((void*)0);
1496 u->function_addrs_count = 0;
1497
1498 if (!find_address_ranges (state, base_address, &unit_buf,
15
←
Calling 'find_address_ranges'
→
18
←
Returning from 'find_address_ranges'
→
19
←
Taking false branch
→
35
←
Calling 'find_address_ranges'
→
38
←
Returning from 'find_address_ranges'
→
39
←
Taking false branch
→
55
←
Calling 'find_address_ranges'
→
58
←
Returning from 'find_address_ranges'
→
59
←
Taking false branch
→
77
←
Calling 'find_address_ranges'
→
1499 dwarf_str, dwarf_str_size,
1500 dwarf_ranges, dwarf_ranges_size,
1501 is_bigendian, error_callback, data,
1502 u, addrs))
1503 {
1504 free_abbrevs (state, &u->abbrevs, error_callback, data);
1505 backtrace_free (state, u, sizeof *u, error_callback, data);
1506 goto fail;
1507 }
1508
1509 if (unit_buf.reported_underflow)
20
←
Assuming the condition is false
→
21
←
Taking false branch
→
40
←
Assuming the condition is false
→
41
←
Taking false branch
→
60
←
Assuming the condition is false
→
61
←
Taking false branch
→
1510 {
1511 free_abbrevs (state, &u->abbrevs, error_callback, data);
1512 backtrace_free (state, u, sizeof *u, error_callback, data);
1513 goto fail;
1514 }
1515 }
1516 if (info.reported_underflow)
1517 goto fail;
1518
1519 return 1;
1520
1521 fail:
1522 free_abbrevs (state, &abbrevs, error_callback, data);
1523 free_unit_addrs_vector (state, addrs, error_callback, data);
1524 return 0;
1525}
1526
1527/* Add a new mapping to the vector of line mappings that we are
1528 building. Returns 1 on success, 0 on failure. */
1529
1530static int
1531add_line (struct backtrace_state *state, struct dwarf_data *ddata,
1532 uintptr_t pc, const char *filename, int lineno,
1533 backtrace_error_callback error_callback, void *data,
1534 struct line_vector *vec)
1535{
1536 struct line *ln;
1537
1538 /* If we are adding the same mapping, ignore it. This can happen
1539 when using discriminators. */
1540 if (vec->count > 0)
1541 {
1542 ln = (struct line *) vec->vec.base + (vec->count - 1);
1543 if (pc == ln->pc && filename == ln->filename && lineno == ln->lineno)
1544 return 1;
1545 }
1546
1547 ln = ((struct line *)
1548 backtrace_vector_grow (state, sizeof (struct line), error_callback,
1549 data, &vec->vec));
1550 if (ln == NULL((void*)0))
1551 return 0;
1552
1553 /* Add in the base address here, so that we can look up the PC
1554 directly. */
1555 ln->pc = pc + ddata->base_address;
1556
1557 ln->filename = filename;
1558 ln->lineno = lineno;
1559 ln->idx = vec->count;
1560
1561 ++vec->count;
1562
1563 return 1;
1564}
1565
1566/* Free the line header information. If FREE_FILENAMES is true we
1567 free the file names themselves, otherwise we leave them, as there
1568 may be line structures pointing to them. */
1569
1570static void
1571free_line_header (struct backtrace_state *state, struct line_header *hdr,
1572 backtrace_error_callback error_callback, void *data)
1573{
1574 backtrace_free (state, hdr->dirs, hdr->dirs_count * sizeof (const char *),
1575 error_callback, data);
1576 backtrace_free (state, hdr->filenames,
1577 hdr->filenames_count * sizeof (char *),
1578 error_callback, data);
1579}
1580
1581/* Read the line header. Return 1 on success, 0 on failure. */
1582
1583static int
1584read_line_header (struct backtrace_state *state, struct unit *u,
1585 int is_dwarf64, struct dwarf_buf *line_buf,
1586 struct line_header *hdr)
1587{
1588 uint64_t hdrlen;
1589 struct dwarf_buf hdr_buf;
1590 const unsigned char *p;
1591 const unsigned char *pend;
1592 size_t i;
1593
1594 hdr->version = read_uint16 (line_buf);
1595 if (hdr->version < 2 || hdr->version > 4)
1596 {
1597 dwarf_buf_error (line_buf, "unsupported line number version");
1598 return 0;
1599 }
1600
1601 hdrlen = read_offset (line_buf, is_dwarf64);
1602
1603 hdr_buf = *line_buf;
1604 hdr_buf.left = hdrlen;
1605
1606 if (!advance (line_buf, hdrlen))
1607 return 0;
1608
1609 hdr->min_insn_len = read_byte (&hdr_buf);
1610 if (hdr->version < 4)
1611 hdr->max_ops_per_insn = 1;
1612 else
1613 hdr->max_ops_per_insn = read_byte (&hdr_buf);
1614
1615 /* We don't care about default_is_stmt. */
1616 read_byte (&hdr_buf);
1617
1618 hdr->line_base = read_sbyte (&hdr_buf);
1619 hdr->line_range = read_byte (&hdr_buf);
1620
1621 hdr->opcode_base = read_byte (&hdr_buf);
1622 hdr->opcode_lengths = hdr_buf.buf;
1623 if (!advance (&hdr_buf, hdr->opcode_base - 1))
1624 return 0;
1625
1626 /* Count the number of directory entries. */
1627 hdr->dirs_count = 0;
1628 p = hdr_buf.buf;
1629 pend = p + hdr_buf.left;
1630 while (p < pend && *p != '\0')
1631 {
1632 p += strnlen((const char *) p, pend - p) + 1;
1633 ++hdr->dirs_count;
1634 }
1635
1636 hdr->dirs = ((const char **)
1637 backtrace_alloc (state,
1638 hdr->dirs_count * sizeof (const char *),
1639 line_buf->error_callback, line_buf->data));
1640 if (hdr->dirs == NULL((void*)0))
1641 return 0;
1642
1643 i = 0;
1644 while (*hdr_buf.buf != '\0')
1645 {
1646 if (hdr_buf.reported_underflow)
1647 return 0;
1648
1649 hdr->dirs[i] = (const char *) hdr_buf.buf;
1650 ++i;
1651 if (!advance (&hdr_buf,
1652 strnlen ((const char *) hdr_buf.buf, hdr_buf.left) + 1))
1653 return 0;
1654 }
1655 if (!advance (&hdr_buf, 1))
1656 return 0;
1657
1658 /* Count the number of file entries. */
1659 hdr->filenames_count = 0;
1660 p = hdr_buf.buf;
1661 pend = p + hdr_buf.left;
1662 while (p < pend && *p != '\0')
1663 {
1664 p += strnlen ((const char *) p, pend - p) + 1;
1665 p += leb128_len (p);
1666 p += leb128_len (p);
1667 p += leb128_len (p);
1668 ++hdr->filenames_count;
1669 }
1670
1671 hdr->filenames = ((const char **)
1672 backtrace_alloc (state,
1673 hdr->filenames_count * sizeof (char *),
1674 line_buf->error_callback,
1675 line_buf->data));
1676 if (hdr->filenames == NULL((void*)0))
1677 return 0;
1678 i = 0;
1679 while (*hdr_buf.buf != '\0')
1680 {
1681 const char *filename;
1682 uint64_t dir_index;
1683
1684 if (hdr_buf.reported_underflow)
1685 return 0;
1686
1687 filename = (const char *) hdr_buf.buf;
1688 if (!advance (&hdr_buf,
1689 strnlen ((const char *) hdr_buf.buf, hdr_buf.left) + 1))
1690 return 0;
1691 dir_index = read_uleb128 (&hdr_buf);
1692 if (IS_ABSOLUTE_PATH (filename)((filename)[0] == '/')
1693 || (dir_index == 0 && u->comp_dir == NULL((void*)0)))
1694 hdr->filenames[i] = filename;
1695 else
1696 {
1697 const char *dir;
1698 size_t dir_len;
1699 size_t filename_len;
1700 char *s;
1701
1702 if (dir_index == 0)
1703 dir = u->comp_dir;
1704 else if (dir_index - 1 < hdr->dirs_count)
1705 dir = hdr->dirs[dir_index - 1];
1706 else
1707 {
1708 dwarf_buf_error (line_buf,
1709 ("invalid directory index in "
1710 "line number program header"));
1711 return 0;
1712 }
1713 dir_len = strlen (dir);
1714 filename_len = strlen (filename);
1715 s = ((char *)
1716 backtrace_alloc (state, dir_len + filename_len + 2,
1717 line_buf->error_callback, line_buf->data));
1718 if (s == NULL((void*)0))
1719 return 0;
1720 memcpy (s, dir, dir_len);
1721 /* FIXME: If we are on a DOS-based file system, and the
1722 directory or the file name use backslashes, then we
1723 should use a backslash here. */
1724 s[dir_len] = '/';
1725 memcpy (s + dir_len + 1, filename, filename_len + 1);
1726 hdr->filenames[i] = s;
1727 }
1728
1729 /* Ignore the modification time and size. */
1730 read_uleb128 (&hdr_buf);
1731 read_uleb128 (&hdr_buf);
1732
1733 ++i;
1734 }
1735
1736 if (hdr_buf.reported_underflow)
1737 return 0;
1738
1739 return 1;
1740}
1741
1742/* Read the line program, adding line mappings to VEC. Return 1 on
1743 success, 0 on failure. */
1744
1745static int
1746read_line_program (struct backtrace_state *state, struct dwarf_data *ddata,
1747 struct unit *u, const struct line_header *hdr,
1748 struct dwarf_buf *line_buf, struct line_vector *vec)
1749{
1750 uint64_t address;
1751 unsigned int op_index;
1752 const char *reset_filename;
1753 const char *filename;
1754 int lineno;
1755
1756 address = 0;
1757 op_index = 0;
1758 if (hdr->filenames_count > 0)
1759 reset_filename = hdr->filenames[0];
1760 else
1761 reset_filename = "";
1762 filename = reset_filename;
1763 lineno = 1;
1764 while (line_buf->left > 0)
1765 {
1766 unsigned int op;
1767
1768 op = read_byte (line_buf);
1769 if (op >= hdr->opcode_base)
1770 {
1771 unsigned int advance;
1772
1773 /* Special opcode. */
1774 op -= hdr->opcode_base;
1775 advance = op / hdr->line_range;
1776 address += (hdr->min_insn_len * (op_index + advance)
1777 / hdr->max_ops_per_insn);
1778 op_index = (op_index + advance) % hdr->max_ops_per_insn;
1779 lineno += hdr->line_base + (int) (op % hdr->line_range);
1780 add_line (state, ddata, address, filename, lineno,
1781 line_buf->error_callback, line_buf->data, vec);
1782 }
1783 else if (op == DW_LNS_extended_op)
1784 {
1785 uint64_t len;
1786
1787 len = read_uleb128 (line_buf);
1788 op = read_byte (line_buf);
1789 switch (op)
1790 {
1791 case DW_LNE_end_sequence:
1792 /* FIXME: Should we mark the high PC here? It seems
1793 that we already have that information from the
1794 compilation unit. */
1795 address = 0;
1796 op_index = 0;
1797 filename = reset_filename;
1798 lineno = 1;
1799 break;
1800 case DW_LNE_set_address:
1801 address = read_address (line_buf, u->addrsize);
1802 break;
1803 case DW_LNE_define_file:
1804 {
1805 const char *f;
1806 unsigned int dir_index;
1807
1808 f = (const char *) line_buf->buf;
1809 if (!advance (line_buf, strnlen (f, line_buf->left) + 1))
1810 return 0;
1811 dir_index = read_uleb128 (line_buf);
1812 /* Ignore that time and length. */
1813 read_uleb128 (line_buf);
1814 read_uleb128 (line_buf);
1815 if (IS_ABSOLUTE_PATH (f)((f)[0] == '/'))
1816 filename = f;
1817 else
1818 {
1819 const char *dir;
1820 size_t dir_len;
1821 size_t f_len;
1822 char *p;
1823
1824 if (dir_index == 0)
1825 dir = u->comp_dir;
1826 else if (dir_index - 1 < hdr->dirs_count)
1827 dir = hdr->dirs[dir_index - 1];
1828 else
1829 {
1830 dwarf_buf_error (line_buf,
1831 ("invalid directory index "
1832 "in line number program"));
1833 return 0;
1834 }
1835 dir_len = strlen (dir);
1836 f_len = strlen (f);
1837 p = ((char *)
1838 backtrace_alloc (state, dir_len + f_len + 2,
1839 line_buf->error_callback,
1840 line_buf->data));
1841 if (p == NULL((void*)0))
1842 return 0;
1843 memcpy (p, dir, dir_len);
1844 /* FIXME: If we are on a DOS-based file system,
1845 and the directory or the file name use
1846 backslashes, then we should use a backslash
1847 here. */
1848 p[dir_len] = '/';
1849 memcpy (p + dir_len + 1, f, f_len + 1);
1850 filename = p;
1851 }
1852 }
1853 break;
1854 case DW_LNE_set_discriminator:
1855 /* We don't care about discriminators. */
1856 read_uleb128 (line_buf);
1857 break;
1858 default:
1859 if (!advance (line_buf, len - 1))
1860 return 0;
1861 break;
1862 }
1863 }
1864 else
1865 {
1866 switch (op)
1867 {
1868 case DW_LNS_copy:
1869 add_line (state, ddata, address, filename, lineno,
1870 line_buf->error_callback, line_buf->data, vec);
1871 break;
1872 case DW_LNS_advance_pc:
1873 {
1874 uint64_t advance;
1875
1876 advance = read_uleb128 (line_buf);
1877 address += (hdr->min_insn_len * (op_index + advance)
1878 / hdr->max_ops_per_insn);
1879 op_index = (op_index + advance) % hdr->max_ops_per_insn;
1880 }
1881 break;
1882 case DW_LNS_advance_line:
1883 lineno += (int) read_sleb128 (line_buf);
1884 break;
1885 case DW_LNS_set_file:
1886 {
1887 uint64_t fileno;
1888
1889 fileno = read_uleb128 (line_buf);
1890 if (fileno == 0)
1891 filename = "";
1892 else
1893 {
1894 if (fileno - 1 >= hdr->filenames_count)
1895 {
1896 dwarf_buf_error (line_buf,
1897 ("invalid file number in "
1898 "line number program"));
1899 return 0;
1900 }
1901 filename = hdr->filenames[fileno - 1];
1902 }
1903 }
1904 break;
1905 case DW_LNS_set_column:
1906 read_uleb128 (line_buf);
1907 break;
1908 case DW_LNS_negate_stmt:
1909 break;
1910 case DW_LNS_set_basic_block:
1911 break;
1912 case DW_LNS_const_add_pc:
1913 {
1914 unsigned int advance;
1915
1916 op = 255 - hdr->opcode_base;
1917 advance = op / hdr->line_range;
1918 address += (hdr->min_insn_len * (op_index + advance)
1919 / hdr->max_ops_per_insn);
1920 op_index = (op_index + advance) % hdr->max_ops_per_insn;
1921 }
1922 break;
1923 case DW_LNS_fixed_advance_pc:
1924 address += read_uint16 (line_buf);
1925 op_index = 0;
1926 break;
1927 case DW_LNS_set_prologue_end:
1928 break;
1929 case DW_LNS_set_epilogue_begin:
1930 break;
1931 case DW_LNS_set_isa:
1932 read_uleb128 (line_buf);
1933 break;
1934 default:
1935 {
1936 unsigned int i;
1937
1938 for (i = hdr->opcode_lengths[op - 1]; i > 0; --i)
1939 read_uleb128 (line_buf);
1940 }
1941 break;
1942 }
1943 }
1944 }
1945
1946 return 1;
1947}
1948
1949/* Read the line number information for a compilation unit. Returns 1
1950 on success, 0 on failure. */
1951
1952static int
1953read_line_info (struct backtrace_state *state, struct dwarf_data *ddata,
1954 backtrace_error_callback error_callback, void *data,
1955 struct unit *u, struct line_header *hdr, struct line **lines,
1956 size_t *lines_count)
1957{
1958 struct line_vector vec;
1959 struct dwarf_buf line_buf;
1960 uint64_t len;
1961 int is_dwarf64;
1962 struct line *ln;
1963
1964 memset (&vec.vec, 0, sizeof vec.vec);
1965 vec.count = 0;
1966
1967 memset (hdr, 0, sizeof *hdr);
1968
1969 if (u->lineoff != (off_t) (size_t) u->lineoff
1970 || (size_t) u->lineoff >= ddata->dwarf_line_size)
1971 {
1972 error_callback (data, "unit line offset out of range", 0);
1973 goto fail;
1974 }
1975
1976 line_buf.name = ".debug_line";
1977 line_buf.start = ddata->dwarf_line;
1978 line_buf.buf = ddata->dwarf_line + u->lineoff;
1979 line_buf.left = ddata->dwarf_line_size - u->lineoff;
1980 line_buf.is_bigendian = ddata->is_bigendian;
1981 line_buf.error_callback = error_callback;
1982 line_buf.data = data;
1983 line_buf.reported_underflow = 0;
1984
1985 is_dwarf64 = 0;
1986 len = read_uint32 (&line_buf);
1987 if (len == 0xffffffff)
1988 {
1989 len = read_uint64 (&line_buf);
1990 is_dwarf64 = 1;
1991 }
1992 line_buf.left = len;
1993
1994 if (!read_line_header (state, u, is_dwarf64, &line_buf, hdr))
1995 goto fail;
1996
1997 if (!read_line_program (state, ddata, u, hdr, &line_buf, &vec))
1998 goto fail;
1999
2000 if (line_buf.reported_underflow)
2001 goto fail;
2002
2003 if (vec.count == 0)
2004 {
2005 /* This is not a failure in the sense of a generating an error,
2006 but it is a failure in that sense that we have no useful
2007 information. */
2008 goto fail;
2009 }
2010
2011 /* Allocate one extra entry at the end. */
2012 ln = ((struct line *)
2013 backtrace_vector_grow (state, sizeof (struct line), error_callback,
2014 data, &vec.vec));
2015 if (ln == NULL((void*)0))
2016 goto fail;
2017 ln->pc = (uintptr_t) -1;
2018 ln->filename = NULL((void*)0);
2019 ln->lineno = 0;
2020 ln->idx = 0;
2021
2022 if (!backtrace_vector_release (state, &vec.vec, error_callback, data))
2023 goto fail;
2024
2025 ln = (struct line *) vec.vec.base;
2026 backtrace_qsort (ln, vec.count, sizeof (struct line), line_compare);
2027
2028 *lines = ln;
2029 *lines_count = vec.count;
2030
2031 return 1;
2032
2033 fail:
2034 vec.vec.alc += vec.vec.size;
2035 vec.vec.size = 0;
2036 backtrace_vector_release (state, &vec.vec, error_callback, data);
2037 free_line_header (state, hdr, error_callback, data);
2038 *lines = (struct line *) (uintptr_t) -1;
2039 *lines_count = 0;
2040 return 0;
2041}
2042
2043/* Read the name of a function from a DIE referenced by a
2044 DW_AT_abstract_origin or DW_AT_specification tag. OFFSET is within
2045 the same compilation unit. */
2046
2047static const char *
2048read_referenced_name (struct dwarf_data *ddata, struct unit *u,
2049 uint64_t offset, backtrace_error_callback error_callback,
2050 void *data)
2051{
2052 struct dwarf_buf unit_buf;
2053 uint64_t code;
2054 const struct abbrev *abbrev;
2055 const char *ret;
2056 size_t i;
2057
2058 /* OFFSET is from the start of the data for this compilation unit.
2059 U->unit_data is the data, but it starts U->unit_data_offset bytes
2060 from the beginning. */
2061
2062 if (offset < u->unit_data_offset
2063 || offset - u->unit_data_offset >= u->unit_data_len)
2064 {
2065 error_callback (data,
2066 "abstract origin or specification out of range",
2067 0);
2068 return NULL((void*)0);
2069 }
2070
2071 offset -= u->unit_data_offset;
2072
2073 unit_buf.name = ".debug_info";
2074 unit_buf.start = ddata->dwarf_info;
2075 unit_buf.buf = u->unit_data + offset;
2076 unit_buf.left = u->unit_data_len - offset;
2077 unit_buf.is_bigendian = ddata->is_bigendian;
2078 unit_buf.error_callback = error_callback;
2079 unit_buf.data = data;
2080 unit_buf.reported_underflow = 0;
2081
2082 code = read_uleb128 (&unit_buf);
2083 if (code == 0)
2084 {
2085 dwarf_buf_error (&unit_buf, "invalid abstract origin or specification");
2086 return NULL((void*)0);
2087 }
2088
2089 abbrev = lookup_abbrev (&u->abbrevs, code, error_callback, data);
2090 if (abbrev == NULL((void*)0))
2091 return NULL((void*)0);
2092
2093 ret = NULL((void*)0);
2094 for (i = 0; i < abbrev->num_attrs; ++i)
2095 {
2096 struct attr_val val;
2097
2098 if (!read_attribute (abbrev->attrs[i].form, &unit_buf,
2099 u->is_dwarf64, u->version, u->addrsize,
2100 ddata->dwarf_str, ddata->dwarf_str_size,
2101 &val))
2102 return NULL((void*)0);
2103
2104 switch (abbrev->attrs[i].name)
2105 {
2106 case DW_AT_name:
2107 /* We prefer the linkage name if get one. */
2108 if (val.encoding == ATTR_VAL_STRING)
2109 ret = val.u.string;
2110 break;
2111
2112 case DW_AT_linkage_name:
2113 case DW_AT_MIPS_linkage_name:
2114 if (val.encoding == ATTR_VAL_STRING)
2115 return val.u.string;
2116 break;
2117
2118 case DW_AT_specification:
2119 if (abbrev->attrs[i].form == DW_FORM_ref_addr
2120 || abbrev->attrs[i].form == DW_FORM_ref_sig8)
2121 {
2122 /* This refers to a specification defined in some other
2123 compilation unit. We can handle this case if we
2124 must, but it's harder. */
2125 break;
2126 }
2127 if (val.encoding == ATTR_VAL_UINT
2128 || val.encoding == ATTR_VAL_REF_UNIT)
2129 {
2130 const char *name;
2131
2132 name = read_referenced_name (ddata, u, val.u.uint,
2133 error_callback, data);
2134 if (name != NULL((void*)0))
2135 ret = name;
2136 }
2137 break;
2138
2139 default:
2140 break;
2141 }
2142 }
2143
2144 return ret;
2145}
2146
2147/* Add a single range to U that maps to function. Returns 1 on
2148 success, 0 on error. */
2149
2150static int
2151add_function_range (struct backtrace_state *state, struct dwarf_data *ddata,
2152 struct function *function, uint64_t lowpc, uint64_t highpc,
2153 backtrace_error_callback error_callback,
2154 void *data, struct function_vector *vec)
2155{
2156 struct function_addrs *p;
2157
2158 /* Add in the base address here, so that we can look up the PC
2159 directly. */
2160 lowpc += ddata->base_address;
2161 highpc += ddata->base_address;
2162
2163 if (vec->count > 0)
2164 {
2165 p = (struct function_addrs *) vec->vec.base + vec->count - 1;
2166 if ((lowpc == p->high || lowpc == p->high + 1)
2167 && function == p->function)
2168 {
2169 if (highpc > p->high)
2170 p->high = highpc;
2171 return 1;
2172 }
2173 }
2174
2175 p = ((struct function_addrs *)
2176 backtrace_vector_grow (state, sizeof (struct function_addrs),
2177 error_callback, data, &vec->vec));
2178 if (p == NULL((void*)0))
2179 return 0;
2180
2181 p->low = lowpc;
2182 p->high = highpc;
2183 p->function = function;
2184 ++vec->count;
2185 return 1;
2186}
2187
2188/* Add PC ranges to U that map to FUNCTION. Returns 1 on success, 0
2189 on error. */
2190
2191static int
2192add_function_ranges (struct backtrace_state *state, struct dwarf_data *ddata,
2193 struct unit *u, struct function *function,
2194 uint64_t ranges, uint64_t base,
2195 backtrace_error_callback error_callback, void *data,
2196 struct function_vector *vec)
2197{
2198 struct dwarf_buf ranges_buf;
2199
2200 if (ranges >= ddata->dwarf_ranges_size)
2201 {
2202 error_callback (data, "function ranges offset out of range", 0);
2203 return 0;
2204 }
2205
2206 ranges_buf.name = ".debug_ranges";
2207 ranges_buf.start = ddata->dwarf_ranges;
2208 ranges_buf.buf = ddata->dwarf_ranges + ranges;
2209 ranges_buf.left = ddata->dwarf_ranges_size - ranges;
2210 ranges_buf.is_bigendian = ddata->is_bigendian;
2211 ranges_buf.error_callback = error_callback;
2212 ranges_buf.data = data;
2213 ranges_buf.reported_underflow = 0;
2214
2215 while (1)
2216 {
2217 uint64_t low;
2218 uint64_t high;
2219
2220 if (ranges_buf.reported_underflow)
2221 return 0;
2222
2223 low = read_address (&ranges_buf, u->addrsize);
2224 high = read_address (&ranges_buf, u->addrsize);
2225
2226 if (low == 0 && high == 0)
2227 break;
2228
2229 if (is_highest_address (low, u->addrsize))
2230 base = high;
2231 else
2232 {
2233 if (!add_function_range (state, ddata, function, low + base,
2234 high + base, error_callback, data, vec))
2235 return 0;
2236 }
2237 }
2238
2239 if (ranges_buf.reported_underflow)
2240 return 0;
2241
2242 return 1;
2243}
2244
2245/* Read one entry plus all its children. Add function addresses to
2246 VEC. Returns 1 on success, 0 on error. */
2247
2248static int
2249read_function_entry (struct backtrace_state *state, struct dwarf_data *ddata,
2250 struct unit *u, uint64_t base, struct dwarf_buf *unit_buf,
2251 const struct line_header *lhdr,
2252 backtrace_error_callback error_callback, void *data,
2253 struct function_vector *vec_function,
2254 struct function_vector *vec_inlined)
2255{
2256 while (unit_buf->left > 0)
2257 {
2258 uint64_t code;
2259 const struct abbrev *abbrev;
2260 int is_function;
2261 struct function *function;
2262 struct function_vector *vec;
2263 size_t i;
2264 uint64_t lowpc;
2265 int have_lowpc;
2266 uint64_t highpc;
2267 int have_highpc;
2268 int highpc_is_relative;
2269 uint64_t ranges;
2270 int have_ranges;
2271
2272 code = read_uleb128 (unit_buf);
2273 if (code == 0)
2274 return 1;
2275
2276 abbrev = lookup_abbrev (&u->abbrevs, code, error_callback, data);
2277 if (abbrev == NULL((void*)0))
2278 return 0;
2279
2280 is_function = (abbrev->tag == DW_TAG_subprogram
2281 || abbrev->tag == DW_TAG_entry_point
2282 || abbrev->tag == DW_TAG_inlined_subroutine);
2283
2284 if (abbrev->tag == DW_TAG_inlined_subroutine)
2285 vec = vec_inlined;
2286 else
2287 vec = vec_function;
2288
2289 function = NULL((void*)0);
2290 if (is_function)
2291 {
2292 function = ((struct function *)
2293 backtrace_alloc (state, sizeof *function,
2294 error_callback, data));
2295 if (function == NULL((void*)0))
2296 return 0;
2297 memset (function, 0, sizeof *function);
2298 }
2299
2300 lowpc = 0;
2301 have_lowpc = 0;
2302 highpc = 0;
2303 have_highpc = 0;
2304 highpc_is_relative = 0;
2305 ranges = 0;
2306 have_ranges = 0;
2307 for (i = 0; i < abbrev->num_attrs; ++i)
2308 {
2309 struct attr_val val;
2310
2311 if (!read_attribute (abbrev->attrs[i].form, unit_buf,
2312 u->is_dwarf64, u->version, u->addrsize,
2313 ddata->dwarf_str, ddata->dwarf_str_size,
2314 &val))
2315 return 0;
2316
2317 /* The compile unit sets the base address for any address
2318 ranges in the function entries. */
2319 if (abbrev->tag == DW_TAG_compile_unit
2320 && abbrev->attrs[i].name == DW_AT_low_pc
2321 && val.encoding == ATTR_VAL_ADDRESS)
2322 base = val.u.uint;
2323
2324 if (is_function)
2325 {
2326 switch (abbrev->attrs[i].name)
2327 {
2328 case DW_AT_call_file:
2329 if (val.encoding == ATTR_VAL_UINT)
2330 {
2331 if (val.u.uint == 0)
2332 function->caller_filename = "";
2333 else
2334 {
2335 if (val.u.uint - 1 >= lhdr->filenames_count)
2336 {
2337 dwarf_buf_error (unit_buf,
2338 ("invalid file number in "
2339 "DW_AT_call_file attribute"));
2340 return 0;
2341 }
2342 function->caller_filename =
2343 lhdr->filenames[val.u.uint - 1];
2344 }
2345 }
2346 break;
2347
2348 case DW_AT_call_line:
2349 if (val.encoding == ATTR_VAL_UINT)
2350 function->caller_lineno = val.u.uint;
2351 break;
2352
2353 case DW_AT_abstract_origin:
2354 case DW_AT_specification:
2355 if (abbrev->attrs[i].form == DW_FORM_ref_addr
2356 || abbrev->attrs[i].form == DW_FORM_ref_sig8)
2357 {
2358 /* This refers to an abstract origin defined in
2359 some other compilation unit. We can handle
2360 this case if we must, but it's harder. */
2361 break;
2362 }
2363 if (val.encoding == ATTR_VAL_UINT
2364 || val.encoding == ATTR_VAL_REF_UNIT)
2365 {
2366 const char *name;
2367
2368 name = read_referenced_name (ddata, u, val.u.uint,
2369 error_callback, data);
2370 if (name != NULL((void*)0))
2371 function->name = name;
2372 }
2373 break;
2374
2375 case DW_AT_name:
2376 if (val.encoding == ATTR_VAL_STRING)
2377 {
2378 /* Don't override a name we found in some other
2379 way, as it will normally be more
2380 useful--e.g., this name is normally not
2381 mangled. */
2382 if (function->name == NULL((void*)0))
2383 function->name = val.u.string;
2384 }
2385 break;
2386
2387 case DW_AT_linkage_name:
2388 case DW_AT_MIPS_linkage_name:
2389 if (val.encoding == ATTR_VAL_STRING)
2390 function->name = val.u.string;
2391 break;
2392
2393 case DW_AT_low_pc:
2394 if (val.encoding == ATTR_VAL_ADDRESS)
2395 {
2396 lowpc = val.u.uint;
2397 have_lowpc = 1;
2398 }
2399 break;
2400
2401 case DW_AT_high_pc:
2402 if (val.encoding == ATTR_VAL_ADDRESS)
2403 {
2404 highpc = val.u.uint;
2405 have_highpc = 1;
2406 }
2407 else if (val.encoding == ATTR_VAL_UINT)
2408 {
2409 highpc = val.u.uint;
2410 have_highpc = 1;
2411 highpc_is_relative = 1;
2412 }
2413 break;
2414
2415 case DW_AT_ranges:
2416 if (val.encoding == ATTR_VAL_UINT
2417 || val.encoding == ATTR_VAL_REF_SECTION)
2418 {
2419 ranges = val.u.uint;
2420 have_ranges = 1;
2421 }
2422 break;
2423
2424 default:
2425 break;
2426 }
2427 }
2428 }
2429
2430 /* If we couldn't find a name for the function, we have no use
2431 for it. */
2432 if (is_function && function->name == NULL((void*)0))
2433 {
2434 backtrace_free (state, function, sizeof *function,
2435 error_callback, data);
2436 is_function = 0;
2437 }
2438
2439 if (is_function)
2440 {
2441 if (have_ranges)
2442 {
2443 if (!add_function_ranges (state, ddata, u, function, ranges,
2444 base, error_callback, data, vec))
2445 return 0;
2446 }
2447 else if (have_lowpc && have_highpc)
2448 {
2449 if (highpc_is_relative)
2450 highpc += lowpc;
2451 if (!add_function_range (state, ddata, function, lowpc, highpc,
2452 error_callback, data, vec))
2453 return 0;
2454 }
2455 else
2456 {
2457 backtrace_free (state, function, sizeof *function,
2458 error_callback, data);
2459 is_function = 0;
2460 }
2461 }
2462
2463 if (abbrev->has_children)
2464 {
2465 if (!is_function)
2466 {
2467 if (!read_function_entry (state, ddata, u, base, unit_buf, lhdr,
2468 error_callback, data, vec_function,
2469 vec_inlined))
2470 return 0;
2471 }
2472 else
2473 {
2474 struct function_vector fvec;
2475
2476 /* Gather any information for inlined functions in
2477 FVEC. */
2478
2479 memset (&fvec, 0, sizeof fvec);
2480
2481 if (!read_function_entry (state, ddata, u, base, unit_buf, lhdr,
2482 error_callback, data, vec_function,
2483 &fvec))
2484 return 0;
2485
2486 if (fvec.count > 0)
2487 {
2488 struct function_addrs *faddrs;
2489
2490 if (!backtrace_vector_release (state, &fvec.vec,
2491 error_callback, data))
2492 return 0;
2493
2494 faddrs = (struct function_addrs *) fvec.vec.base;
2495 backtrace_qsort (faddrs, fvec.count,
2496 sizeof (struct function_addrs),
2497 function_addrs_compare);
2498
2499 function->function_addrs = faddrs;
2500 function->function_addrs_count = fvec.count;
2501 }
2502 }
2503 }
2504 }
2505
2506 return 1;
2507}
2508
2509/* Read function name information for a compilation unit. We look
2510 through the whole unit looking for function tags. */
2511
2512static void
2513read_function_info (struct backtrace_state *state, struct dwarf_data *ddata,
2514 const struct line_header *lhdr,
2515 backtrace_error_callback error_callback, void *data,
2516 struct unit *u, struct function_vector *fvec,
2517 struct function_addrs **ret_addrs,
2518 size_t *ret_addrs_count)
2519{
2520 struct function_vector lvec;
2521 struct function_vector *pfvec;
2522 struct dwarf_buf unit_buf;
2523 struct function_addrs *addrs;
2524 size_t addrs_count;
2525
2526 /* Use FVEC if it is not NULL. Otherwise use our own vector. */
2527 if (fvec != NULL((void*)0))
2528 pfvec = fvec;
2529 else
2530 {
2531 memset (&lvec, 0, sizeof lvec);
2532 pfvec = &lvec;
2533 }
2534
2535 unit_buf.name = ".debug_info";
2536 unit_buf.start = ddata->dwarf_info;
2537 unit_buf.buf = u->unit_data;
2538 unit_buf.left = u->unit_data_len;
2539 unit_buf.is_bigendian = ddata->is_bigendian;
2540 unit_buf.error_callback = error_callback;
2541 unit_buf.data = data;
2542 unit_buf.reported_underflow = 0;
2543
2544 while (unit_buf.left > 0)
2545 {
2546 if (!read_function_entry (state, ddata, u, 0, &unit_buf, lhdr,
2547 error_callback, data, pfvec, pfvec))
2548 return;
2549 }
2550
2551 if (pfvec->count == 0)
2552 return;
2553
2554 addrs_count = pfvec->count;
2555
2556 if (fvec == NULL((void*)0))
2557 {
2558 if (!backtrace_vector_release (state, &lvec.vec, error_callback, data))
2559 return;
2560 addrs = (struct function_addrs *) pfvec->vec.base;
2561 }
2562 else
2563 {
2564 /* Finish this list of addresses, but leave the remaining space in
2565 the vector available for the next function unit. */
2566 addrs = ((struct function_addrs *)
2567 backtrace_vector_finish (state, &fvec->vec,
2568 error_callback, data));
2569 if (addrs == NULL((void*)0))
2570 return;
2571 fvec->count = 0;
2572 }
2573
2574 backtrace_qsort (addrs, addrs_count, sizeof (struct function_addrs),
2575 function_addrs_compare);
2576
2577 *ret_addrs = addrs;
2578 *ret_addrs_count = addrs_count;
2579}
2580
2581/* See if PC is inlined in FUNCTION. If it is, print out the inlined
2582 information, and update FILENAME and LINENO for the caller.
2583 Returns whatever CALLBACK returns, or 0 to keep going. */
2584
2585static int
2586report_inlined_functions (uintptr_t pc, struct function *function,
2587 backtrace_full_callback callback, void *data,
2588 const char **filename, int *lineno)
2589{
2590 struct function_addrs *function_addrs;
2591 struct function *inlined;
2592 int ret;
2593
2594 if (function->function_addrs_count == 0)
2595 return 0;
2596
2597 function_addrs = ((struct function_addrs *)
2598 bsearch (&pc, function->function_addrs,
2599 function->function_addrs_count,
2600 sizeof (struct function_addrs),
2601 function_addrs_search));
2602 if (function_addrs == NULL((void*)0))
2603 return 0;
2604
2605 while (((size_t) (function_addrs - function->function_addrs) + 1
2606 < function->function_addrs_count)
2607 && pc >= (function_addrs + 1)->low
2608 && pc < (function_addrs + 1)->high)
2609 ++function_addrs;
2610
2611 /* We found an inlined call. */
2612
2613 inlined = function_addrs->function;
2614
2615 /* Report any calls inlined into this one. */
2616 ret = report_inlined_functions (pc, inlined, callback, data,
2617 filename, lineno);
2618 if (ret != 0)
2619 return ret;
2620
2621 /* Report this inlined call. */
2622 ret = callback (data, pc, *filename, *lineno, inlined->name);
2623 if (ret != 0)
2624 return ret;
2625
2626 /* Our caller will report the caller of the inlined function; tell
2627 it the appropriate filename and line number. */
2628 *filename = inlined->caller_filename;
2629 *lineno = inlined->caller_lineno;
2630
2631 return 0;
2632}
2633
2634/* Look for a PC in the DWARF mapping for one module. On success,
2635 call CALLBACK and return whatever it returns. On error, call
2636 ERROR_CALLBACK and return 0. Sets *FOUND to 1 if the PC is found,
2637 0 if not. */
2638
2639static int
2640dwarf_lookup_pc (struct backtrace_state *state, struct dwarf_data *ddata,
2641 uintptr_t pc, backtrace_full_callback callback,
2642 backtrace_error_callback error_callback, void *data,
2643 int *found)
2644{
2645 struct unit_addrs *entry;
2646 struct unit *u;
2647 int new_data;
2648 struct line *lines;
2649 struct line *ln;
2650 struct function_addrs *function_addrs;
2651 struct function *function;
2652 const char *filename;
2653 int lineno;
2654 int ret;
2655
2656 *found = 1;
2657
2658 /* Find an address range that includes PC. */
2659 entry = bsearch (&pc, ddata->addrs, ddata->addrs_count,
2660 sizeof (struct unit_addrs), unit_addrs_search);
2661
2662 if (entry == NULL((void*)0))
2663 {
2664 *found = 0;
2665 return 0;
2666 }
2667
2668 /* If there are multiple ranges that contain PC, use the last one,
2669 in order to produce predictable results. If we assume that all
2670 ranges are properly nested, then the last range will be the
2671 smallest one. */
2672 while ((size_t) (entry - ddata->addrs) + 1 < ddata->addrs_count
2673 && pc >= (entry + 1)->low
2674 && pc < (entry + 1)->high)
2675 ++entry;
2676
2677 /* We need the lines, lines_count, function_addrs,
2678 function_addrs_count fields of u. If they are not set, we need
2679 to set them. When running in threaded mode, we need to allow for
2680 the possibility that some other thread is setting them
2681 simultaneously. */
2682
2683 u = entry->u;
2684 lines = u->lines;
2685
2686 /* Skip units with no useful line number information by walking
2687 backward. Useless line number information is marked by setting
2688 lines == -1. */
2689 while (entry > ddata->addrs
2690 && pc >= (entry - 1)->low
2691 && pc < (entry - 1)->high)
2692 {
2693 if (state->threaded)
2694 lines = (struct line *) backtrace_atomic_load_pointer (&u->lines);
2695
2696 if (lines != (struct line *) (uintptr_t) -1)
2697 break;
2698
2699 --entry;
2700
2701 u = entry->u;
2702 lines = u->lines;
2703 }
2704
2705 if (state->threaded)
2706 lines = backtrace_atomic_load_pointer (&u->lines);
2707
2708 new_data = 0;
2709 if (lines == NULL((void*)0))
2710 {
2711 size_t function_addrs_count;
2712 struct line_header lhdr;
2713 size_t count;
2714
2715 /* We have never read the line information for this unit. Read
2716 it now. */
2717
2718 function_addrs = NULL((void*)0);
2719 function_addrs_count = 0;
2720 if (read_line_info (state, ddata, error_callback, data, entry->u, &lhdr,
2721 &lines, &count))
2722 {
2723 struct function_vector *pfvec;
2724
2725 /* If not threaded, reuse DDATA->FVEC for better memory
2726 consumption. */
2727 if (state->threaded)
2728 pfvec = NULL((void*)0);
2729 else
2730 pfvec = &ddata->fvec;
2731 read_function_info (state, ddata, &lhdr, error_callback, data,
2732 entry->u, pfvec, &function_addrs,
2733 &function_addrs_count);
2734 free_line_header (state, &lhdr, error_callback, data);
2735 new_data = 1;
2736 }
2737
2738 /* Atomically store the information we just read into the unit.
2739 If another thread is simultaneously writing, it presumably
2740 read the same information, and we don't care which one we
2741 wind up with; we just leak the other one. We do have to
2742 write the lines field last, so that the acquire-loads above
2743 ensure that the other fields are set. */
2744
2745 if (!state->threaded)
2746 {
2747 u->lines_count = count;
2748 u->function_addrs = function_addrs;
2749 u->function_addrs_count = function_addrs_count;
2750 u->lines = lines;
2751 }
2752 else
2753 {
2754 backtrace_atomic_store_size_t (&u->lines_count, count);
2755 backtrace_atomic_store_pointer (&u->function_addrs, function_addrs);
2756 backtrace_atomic_store_size_t (&u->function_addrs_count,
2757 function_addrs_count);
2758 backtrace_atomic_store_pointer (&u->lines, lines);
2759 }
2760 }
2761
2762 /* Now all fields of U have been initialized. */
2763
2764 if (lines == (struct line *) (uintptr_t) -1)
2765 {
2766 /* If reading the line number information failed in some way,
2767 try again to see if there is a better compilation unit for
2768 this PC. */
2769 if (new_data)
2770 return dwarf_lookup_pc (state, ddata, pc, callback, error_callback,
2771 data, found);
2772 return callback (data, pc, NULL((void*)0), 0, NULL((void*)0));
2773 }
2774
2775 /* Search for PC within this unit. */
2776
2777 ln = (struct line *) bsearch (&pc, lines, entry->u->lines_count,
2778 sizeof (struct line), line_search);
2779 if (ln == NULL((void*)0))
2780 {
2781 /* The PC is between the low_pc and high_pc attributes of the
2782 compilation unit, but no entry in the line table covers it.
2783 This implies that the start of the compilation unit has no
2784 line number information. */
2785
2786 if (entry->u->abs_filename == NULL((void*)0))
2787 {
2788 const char *filename;
2789
2790 filename = entry->u->filename;
2791 if (filename != NULL((void*)0)
2792 && !IS_ABSOLUTE_PATH (filename)((filename)[0] == '/')
2793 && entry->u->comp_dir != NULL((void*)0))
2794 {
2795 size_t filename_len;
2796 const char *dir;
2797 size_t dir_len;
2798 char *s;
2799
2800 filename_len = strlen (filename);
2801 dir = entry->u->comp_dir;
2802 dir_len = strlen (dir);
2803 s = (char *) backtrace_alloc (state, dir_len + filename_len + 2,
2804 error_callback, data);
2805 if (s == NULL((void*)0))
2806 {
2807 *found = 0;
2808 return 0;
2809 }
2810 memcpy (s, dir, dir_len);
2811 /* FIXME: Should use backslash if DOS file system. */
2812 s[dir_len] = '/';
2813 memcpy (s + dir_len + 1, filename, filename_len + 1);
2814 filename = s;
2815 }
2816 entry->u->abs_filename = filename;
2817 }
2818
2819 return callback (data, pc, entry->u->abs_filename, 0, NULL((void*)0));
2820 }
2821
2822 /* Search for function name within this unit. */
2823
2824 if (entry->u->function_addrs_count == 0)
2825 return callback (data, pc, ln->filename, ln->lineno, NULL((void*)0));
2826
2827 function_addrs = ((struct function_addrs *)
2828 bsearch (&pc, entry->u->function_addrs,
2829 entry->u->function_addrs_count,
2830 sizeof (struct function_addrs),
2831 function_addrs_search));
2832 if (function_addrs == NULL((void*)0))
2833 return callback (data, pc, ln->filename, ln->lineno, NULL((void*)0));
2834
2835 /* If there are multiple function ranges that contain PC, use the
2836 last one, in order to produce predictable results. */
2837
2838 while (((size_t) (function_addrs - entry->u->function_addrs + 1)
2839 < entry->u->function_addrs_count)
2840 && pc >= (function_addrs + 1)->low
2841 && pc < (function_addrs + 1)->high)
2842 ++function_addrs;
2843
2844 function = function_addrs->function;
2845
2846 filename = ln->filename;
2847 lineno = ln->lineno;
2848
2849 ret = report_inlined_functions (pc, function, callback, data,
2850 &filename, &lineno);
2851 if (ret != 0)
2852 return ret;
2853
2854 return callback (data, pc, filename, lineno, function->name);
2855}
2856
2857
2858/* Return the file/line information for a PC using the DWARF mapping
2859 we built earlier. */
2860
2861static int
2862dwarf_fileline (struct backtrace_state *state, uintptr_t pc,
2863 backtrace_full_callback callback,
2864 backtrace_error_callback error_callback, void *data)
2865{
2866 struct dwarf_data *ddata;
2867 int found;
2868 int ret;
2869
2870 if (!state->threaded)
2871 {
2872 for (ddata = (struct dwarf_data *) state->fileline_data;
2873 ddata != NULL((void*)0);
2874 ddata = ddata->next)
2875 {
2876 ret = dwarf_lookup_pc (state, ddata, pc, callback, error_callback,
2877 data, &found);
2878 if (ret != 0 || found)
2879 return ret;
2880 }
2881 }
2882 else
2883 {
2884 struct dwarf_data **pp;
2885
2886 pp = (struct dwarf_data **) (void *) &state->fileline_data;
2887 while (1)
2888 {
2889 ddata = backtrace_atomic_load_pointer (pp);
2890 if (ddata == NULL((void*)0))
2891 break;
2892
2893 ret = dwarf_lookup_pc (state, ddata, pc, callback, error_callback,
2894 data, &found);
2895 if (ret != 0 || found)
2896 return ret;
2897
2898 pp = &ddata->next;
2899 }
2900 }
2901
2902 /* FIXME: See if any libraries have been dlopen'ed. */
2903
2904 return callback (data, pc, NULL((void*)0), 0, NULL((void*)0));
2905}
2906
2907/* Initialize our data structures from the DWARF debug info for a
2908 file. Return NULL on failure. */
2909
2910static struct dwarf_data *
2911build_dwarf_data (struct backtrace_state *state,
2912 uintptr_t base_address,
2913 const unsigned char *dwarf_info,
2914 size_t dwarf_info_size,
2915 const unsigned char *dwarf_line,
2916 size_t dwarf_line_size,
2917 const unsigned char *dwarf_abbrev,
2918 size_t dwarf_abbrev_size,
2919 const unsigned char *dwarf_ranges,
2920 size_t dwarf_ranges_size,
2921 const unsigned char *dwarf_str,
2922 size_t dwarf_str_size,
2923 int is_bigendian,
2924 backtrace_error_callback error_callback,
2925 void *data)
2926{
2927 struct unit_addrs_vector addrs_vec;
2928 struct unit_addrs *addrs;
2929 size_t addrs_count;
2930 struct dwarf_data *fdata;
2931
2932 if (!build_address_map (state, base_address, dwarf_info, dwarf_info_size,
2
←
Calling 'build_address_map'
→
2933 dwarf_abbrev, dwarf_abbrev_size, dwarf_ranges,
2934 dwarf_ranges_size, dwarf_str, dwarf_str_size,
2935 is_bigendian, error_callback, data, &addrs_vec))
2936 return NULL((void*)0);
2937
2938 if (!backtrace_vector_release (state, &addrs_vec.vec, error_callback, data))
2939 return NULL((void*)0);
2940 addrs = (struct unit_addrs *) addrs_vec.vec.base;
2941 addrs_count = addrs_vec.count;
2942 backtrace_qsort (addrs, addrs_count, sizeof (struct unit_addrs),
2943 unit_addrs_compare);
2944
2945 fdata = ((struct dwarf_data *)
2946 backtrace_alloc (state, sizeof (struct dwarf_data),
2947 error_callback, data));
2948 if (fdata == NULL((void*)0))
2949 return NULL((void*)0);
2950
2951 fdata->next = NULL((void*)0);
2952 fdata->base_address = base_address;
2953 fdata->addrs = addrs;
2954 fdata->addrs_count = addrs_count;
2955 fdata->dwarf_info = dwarf_info;
2956 fdata->dwarf_info_size = dwarf_info_size;
2957 fdata->dwarf_line = dwarf_line;
2958 fdata->dwarf_line_size = dwarf_line_size;
2959 fdata->dwarf_ranges = dwarf_ranges;
2960 fdata->dwarf_ranges_size = dwarf_ranges_size;
2961 fdata->dwarf_str = dwarf_str;
2962 fdata->dwarf_str_size = dwarf_str_size;
2963 fdata->is_bigendian = is_bigendian;
2964 memset (&fdata->fvec, 0, sizeof fdata->fvec);
2965
2966 return fdata;
2967}
2968
2969/* Build our data structures from the DWARF sections for a module.
2970 Set FILELINE_FN and STATE->FILELINE_DATA. Return 1 on success, 0
2971 on failure. */
2972
2973int
2974backtrace_dwarf_add (struct backtrace_state *state,
2975 uintptr_t base_address,
2976 const unsigned char *dwarf_info,
2977 size_t dwarf_info_size,
2978 const unsigned char *dwarf_line,
2979 size_t dwarf_line_size,
2980 const unsigned char *dwarf_abbrev,
2981 size_t dwarf_abbrev_size,
2982 const unsigned char *dwarf_ranges,
2983 size_t dwarf_ranges_size,
2984 const unsigned char *dwarf_str,
2985 size_t dwarf_str_size,
2986 int is_bigendian,
2987 backtrace_error_callback error_callback,
2988 void *data, fileline *fileline_fn)
2989{
2990 struct dwarf_data *fdata;
2991
2992 fdata = build_dwarf_data (state, base_address, dwarf_info, dwarf_info_size,
1
Calling 'build_dwarf_data'
→
2993 dwarf_line, dwarf_line_size, dwarf_abbrev,
2994 dwarf_abbrev_size, dwarf_ranges, dwarf_ranges_size,
2995 dwarf_str, dwarf_str_size, is_bigendian,
2996 error_callback, data);
2997 if (fdata == NULL((void*)0))
2998 return 0;
2999
3000 if (!state->threaded)
3001 {
3002 struct dwarf_data **pp;
3003
3004 for (pp = (struct dwarf_data **) (void *) &state->fileline_data;
3005 *pp != NULL((void*)0);
3006 pp = &(*pp)->next)
3007 ;
3008 *pp = fdata;
3009 }
3010 else
3011 {
3012 while (1)
3013 {
3014 struct dwarf_data **pp;
3015
3016 pp = (struct dwarf_data **) (void *) &state->fileline_data;
3017
3018 while (1)
3019 {
3020 struct dwarf_data *p;
3021
3022 p = backtrace_atomic_load_pointer (pp);
3023
3024 if (p == NULL((void*)0))
3025 break;
3026
3027 pp = &p->next;
3028 }
3029
3030 if (__sync_bool_compare_and_swap (pp, NULL((void*)0), fdata))
3031 break;
3032 }
3033 }
3034
3035 *fileline_fn = dwarf_fileline;
3036
3037 return 1;
3038}