|
111
|
1 /* dwarf.c -- Get file/line information from DWARF for backtraces.
|
|
145
|
2 Copyright (C) 2012-2020 Free Software Foundation, Inc.
|
|
111
|
3 Written by Ian Lance Taylor, Google.
|
|
|
4
|
|
|
5 Redistribution and use in source and binary forms, with or without
|
|
|
6 modification, are permitted provided that the following conditions are
|
|
|
7 met:
|
|
|
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
|
|
|
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. */
|
|
|
32
|
|
|
33 #include "config.h"
|
|
|
34
|
|
|
35 #include <errno.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_STRNLEN) || !HAVE_DECL_STRNLEN
|
|
|
47
|
|
|
48 /* If strnlen is not declared, provide our own version. */
|
|
|
49
|
|
|
50 static size_t
|
|
|
51 xstrnlen (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
|
|
|
67 struct 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
|
|
|
89 struct attr
|
|
|
90 {
|
|
|
91 /* The attribute name. */
|
|
|
92 enum dwarf_attribute name;
|
|
|
93 /* The attribute form. */
|
|
|
94 enum dwarf_form form;
|
|
145
|
95 /* The attribute value, for DW_FORM_implicit_const. */
|
|
|
96 int64_t val;
|
|
111
|
97 };
|
|
|
98
|
|
|
99 /* A single DWARF abbreviation. */
|
|
|
100
|
|
|
101 struct abbrev
|
|
|
102 {
|
|
|
103 /* The abbrev code--the number used to refer to the abbrev. */
|
|
|
104 uint64_t code;
|
|
|
105 /* The entry tag. */
|
|
|
106 enum dwarf_tag tag;
|
|
|
107 /* Non-zero if this abbrev has child entries. */
|
|
|
108 int has_children;
|
|
|
109 /* The number of attributes. */
|
|
|
110 size_t num_attrs;
|
|
|
111 /* The attributes. */
|
|
|
112 struct attr *attrs;
|
|
|
113 };
|
|
|
114
|
|
|
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. */
|
|
|
121
|
|
|
122 struct abbrevs
|
|
|
123 {
|
|
|
124 /* The number of abbrevs in the vector. */
|
|
|
125 size_t num_abbrevs;
|
|
|
126 /* The abbrevs, sorted by the code field. */
|
|
|
127 struct abbrev *abbrevs;
|
|
|
128 };
|
|
|
129
|
|
|
130 /* The different kinds of attribute values. */
|
|
|
131
|
|
|
132 enum attr_val_encoding
|
|
|
133 {
|
|
145
|
134 /* No attribute value. */
|
|
|
135 ATTR_VAL_NONE,
|
|
111
|
136 /* An address. */
|
|
|
137 ATTR_VAL_ADDRESS,
|
|
145
|
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,
|
|
111
|
141 /* A unsigned integer. */
|
|
|
142 ATTR_VAL_UINT,
|
|
|
143 /* A sigd integer. */
|
|
|
144 ATTR_VAL_SINT,
|
|
|
145 /* A string. */
|
|
|
146 ATTR_VAL_STRING,
|
|
145
|
147 /* An index into the .debug_str_offsets section. */
|
|
|
148 ATTR_VAL_STRING_INDEX,
|
|
111
|
149 /* An offset to other data in the containing unit. */
|
|
|
150 ATTR_VAL_REF_UNIT,
|
|
145
|
151 /* An offset to other data within the .debug_info section. */
|
|
111
|
152 ATTR_VAL_REF_INFO,
|
|
145
|
153 /* An offset to other data within the alt .debug_info section. */
|
|
|
154 ATTR_VAL_REF_ALT_INFO,
|
|
111
|
155 /* An offset to data in some other section. */
|
|
|
156 ATTR_VAL_REF_SECTION,
|
|
|
157 /* A type signature. */
|
|
|
158 ATTR_VAL_REF_TYPE,
|
|
145
|
159 /* An index into the .debug_rnglists section. */
|
|
|
160 ATTR_VAL_RNGLISTS_INDEX,
|
|
111
|
161 /* A block of data (not represented). */
|
|
|
162 ATTR_VAL_BLOCK,
|
|
|
163 /* An expression (not represented). */
|
|
|
164 ATTR_VAL_EXPR,
|
|
|
165 };
|
|
|
166
|
|
|
167 /* An attribute value. */
|
|
|
168
|
|
|
169 struct attr_val
|
|
|
170 {
|
|
|
171 /* How the value is stored in the field u. */
|
|
|
172 enum attr_val_encoding encoding;
|
|
|
173 union
|
|
|
174 {
|
|
145
|
175 /* ATTR_VAL_ADDRESS*, ATTR_VAL_UINT, ATTR_VAL_REF*. */
|
|
111
|
176 uint64_t uint;
|
|
|
177 /* ATTR_VAL_SINT. */
|
|
|
178 int64_t sint;
|
|
|
179 /* ATTR_VAL_STRING. */
|
|
|
180 const char *string;
|
|
|
181 /* ATTR_VAL_BLOCK not stored. */
|
|
|
182 } u;
|
|
|
183 };
|
|
|
184
|
|
|
185 /* The line number program header. */
|
|
|
186
|
|
|
187 struct line_header
|
|
|
188 {
|
|
|
189 /* The version of the line number information. */
|
|
|
190 int version;
|
|
145
|
191 /* Address size. */
|
|
|
192 int addrsize;
|
|
111
|
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. */
|
|
|
198 int line_base;
|
|
|
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. */
|
|
|
206 size_t dirs_count;
|
|
|
207 /* The directory entries. */
|
|
|
208 const char **dirs;
|
|
|
209 /* The number of filenames. */
|
|
|
210 size_t filenames_count;
|
|
|
211 /* The filenames. */
|
|
|
212 const char **filenames;
|
|
|
213 };
|
|
|
214
|
|
145
|
215 /* A format description from a line header. */
|
|
|
216
|
|
|
217 struct line_header_format
|
|
|
218 {
|
|
|
219 int lnct; /* LNCT code. */
|
|
|
220 enum dwarf_form form; /* Form of entry data. */
|
|
|
221 };
|
|
|
222
|
|
111
|
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. */
|
|
|
227
|
|
|
228 struct line
|
|
|
229 {
|
|
|
230 /* PC. */
|
|
|
231 uintptr_t pc;
|
|
|
232 /* File name. Many entries in the array are expected to point to
|
|
|
233 the same file name. */
|
|
|
234 const char *filename;
|
|
|
235 /* Line number. */
|
|
|
236 int lineno;
|
|
|
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. */
|
|
|
240 int idx;
|
|
|
241 };
|
|
|
242
|
|
|
243 /* A growable vector of line number information. This is used while
|
|
|
244 reading the line numbers. */
|
|
|
245
|
|
|
246 struct line_vector
|
|
|
247 {
|
|
|
248 /* Memory. This is an array of struct line. */
|
|
|
249 struct backtrace_vector vec;
|
|
|
250 /* Number of valid mappings. */
|
|
|
251 size_t count;
|
|
|
252 };
|
|
|
253
|
|
|
254 /* A function described in the debug info. */
|
|
|
255
|
|
|
256 struct function
|
|
|
257 {
|
|
|
258 /* The name of the function. */
|
|
|
259 const char *name;
|
|
|
260 /* If this is an inlined function, the filename of the call
|
|
|
261 site. */
|
|
|
262 const char *caller_filename;
|
|
|
263 /* If this is an inlined function, the line number of the call
|
|
|
264 site. */
|
|
|
265 int caller_lineno;
|
|
|
266 /* Map PC ranges to inlined functions. */
|
|
|
267 struct function_addrs *function_addrs;
|
|
|
268 size_t function_addrs_count;
|
|
|
269 };
|
|
|
270
|
|
|
271 /* An address range for a function. This maps a PC value to a
|
|
|
272 specific function. */
|
|
|
273
|
|
|
274 struct function_addrs
|
|
|
275 {
|
|
|
276 /* Range is LOW <= PC < HIGH. */
|
|
|
277 uint64_t low;
|
|
|
278 uint64_t high;
|
|
|
279 /* Function for this address range. */
|
|
|
280 struct function *function;
|
|
|
281 };
|
|
|
282
|
|
|
283 /* A growable vector of function address ranges. */
|
|
|
284
|
|
|
285 struct function_vector
|
|
|
286 {
|
|
|
287 /* Memory. This is an array of struct function_addrs. */
|
|
|
288 struct backtrace_vector vec;
|
|
|
289 /* Number of address ranges present. */
|
|
|
290 size_t count;
|
|
|
291 };
|
|
|
292
|
|
|
293 /* A DWARF compilation unit. This only holds the information we need
|
|
|
294 to map a PC to a file and line. */
|
|
|
295
|
|
|
296 struct unit
|
|
|
297 {
|
|
|
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;
|
|
145
|
305 /* Offset of the start of the compilation unit from the start of the
|
|
|
306 .debug_info section. */
|
|
|
307 size_t low_offset;
|
|
|
308 /* Offset of the end of the compilation unit from the start of the
|
|
|
309 .debug_info section. */
|
|
|
310 size_t high_offset;
|
|
111
|
311 /* DWARF version. */
|
|
|
312 int version;
|
|
|
313 /* Whether unit is DWARF64. */
|
|
|
314 int is_dwarf64;
|
|
|
315 /* Address size. */
|
|
|
316 int addrsize;
|
|
|
317 /* Offset into line number information. */
|
|
|
318 off_t lineoff;
|
|
145
|
319 /* Offset of compilation unit in .debug_str_offsets. */
|
|
|
320 uint64_t str_offsets_base;
|
|
|
321 /* Offset of compilation unit in .debug_addr. */
|
|
|
322 uint64_t addr_base;
|
|
|
323 /* Offset of compilation unit in .debug_rnglists. */
|
|
|
324 uint64_t rnglists_base;
|
|
111
|
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;
|
|
|
333
|
|
|
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. */
|
|
|
338
|
|
|
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. */
|
|
|
342 struct line *lines;
|
|
|
343 /* Number of entries in lines. */
|
|
|
344 size_t lines_count;
|
|
|
345 /* PC ranges to function. */
|
|
|
346 struct function_addrs *function_addrs;
|
|
|
347 size_t function_addrs_count;
|
|
|
348 };
|
|
|
349
|
|
|
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. */
|
|
|
355
|
|
|
356 struct unit_addrs
|
|
|
357 {
|
|
|
358 /* Range is LOW <= PC < HIGH. */
|
|
|
359 uint64_t low;
|
|
|
360 uint64_t high;
|
|
|
361 /* Compilation unit for this address range. */
|
|
|
362 struct unit *u;
|
|
|
363 };
|
|
|
364
|
|
|
365 /* A growable vector of compilation unit address ranges. */
|
|
|
366
|
|
|
367 struct unit_addrs_vector
|
|
|
368 {
|
|
|
369 /* Memory. This is an array of struct unit_addrs. */
|
|
|
370 struct backtrace_vector vec;
|
|
|
371 /* Number of address ranges present. */
|
|
|
372 size_t count;
|
|
|
373 };
|
|
|
374
|
|
145
|
375 /* A growable vector of compilation unit pointer. */
|
|
|
376
|
|
|
377 struct unit_vector
|
|
|
378 {
|
|
|
379 struct backtrace_vector vec;
|
|
|
380 size_t count;
|
|
|
381 };
|
|
|
382
|
|
111
|
383 /* The information we need to map a PC to a file and line. */
|
|
|
384
|
|
|
385 struct dwarf_data
|
|
|
386 {
|
|
|
387 /* The data for the next file we know about. */
|
|
|
388 struct dwarf_data *next;
|
|
145
|
389 /* The data for .gnu_debugaltlink. */
|
|
|
390 struct dwarf_data *altlink;
|
|
111
|
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. */
|
|
|
396 size_t addrs_count;
|
|
145
|
397 /* A sorted list of units. */
|
|
|
398 struct unit **units;
|
|
|
399 /* Number of units in the list. */
|
|
|
400 size_t units_count;
|
|
|
401 /* The unparsed DWARF debug data. */
|
|
|
402 struct dwarf_sections dwarf_sections;
|
|
111
|
403 /* Whether the data is big-endian or not. */
|
|
|
404 int is_bigendian;
|
|
|
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;
|
|
|
408 };
|
|
|
409
|
|
|
410 /* Report an error for a DWARF buffer. */
|
|
|
411
|
|
|
412 static void
|
|
|
413 dwarf_buf_error (struct dwarf_buf *buf, const char *msg)
|
|
|
414 {
|
|
|
415 char b[200];
|
|
|
416
|
|
|
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);
|
|
|
420 }
|
|
|
421
|
|
|
422 /* Require at least COUNT bytes in BUF. Return 1 if all is well, 0 on
|
|
|
423 error. */
|
|
|
424
|
|
|
425 static int
|
|
|
426 require (struct dwarf_buf *buf, size_t count)
|
|
|
427 {
|
|
|
428 if (buf->left >= count)
|
|
|
429 return 1;
|
|
|
430
|
|
|
431 if (!buf->reported_underflow)
|
|
|
432 {
|
|
|
433 dwarf_buf_error (buf, "DWARF underflow");
|
|
|
434 buf->reported_underflow = 1;
|
|
|
435 }
|
|
|
436
|
|
|
437 return 0;
|
|
|
438 }
|
|
|
439
|
|
|
440 /* Advance COUNT bytes in BUF. Return 1 if all is well, 0 on
|
|
|
441 error. */
|
|
|
442
|
|
|
443 static int
|
|
|
444 advance (struct dwarf_buf *buf, size_t count)
|
|
|
445 {
|
|
|
446 if (!require (buf, count))
|
|
|
447 return 0;
|
|
|
448 buf->buf += count;
|
|
|
449 buf->left -= count;
|
|
|
450 return 1;
|
|
|
451 }
|
|
|
452
|
|
145
|
453 /* Read one zero-terminated string from BUF and advance past the string. */
|
|
|
454
|
|
|
455 static const char *
|
|
|
456 read_string (struct dwarf_buf *buf)
|
|
|
457 {
|
|
|
458 const char *p = (const char *)buf->buf;
|
|
|
459 size_t len = strnlen (p, buf->left);
|
|
|
460
|
|
|
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;
|
|
|
465
|
|
|
466 if (!advance (buf, count))
|
|
|
467 return NULL;
|
|
|
468
|
|
|
469 return p;
|
|
|
470 }
|
|
|
471
|
|
111
|
472 /* Read one byte from BUF and advance 1 byte. */
|
|
|
473
|
|
|
474 static unsigned char
|
|
|
475 read_byte (struct dwarf_buf *buf)
|
|
|
476 {
|
|
|
477 const unsigned char *p = buf->buf;
|
|
|
478
|
|
|
479 if (!advance (buf, 1))
|
|
|
480 return 0;
|
|
|
481 return p[0];
|
|
|
482 }
|
|
|
483
|
|
|
484 /* Read a signed char from BUF and advance 1 byte. */
|
|
|
485
|
|
|
486 static signed char
|
|
|
487 read_sbyte (struct dwarf_buf *buf)
|
|
|
488 {
|
|
|
489 const unsigned char *p = buf->buf;
|
|
|
490
|
|
|
491 if (!advance (buf, 1))
|
|
|
492 return 0;
|
|
|
493 return (*p ^ 0x80) - 0x80;
|
|
|
494 }
|
|
|
495
|
|
|
496 /* Read a uint16 from BUF and advance 2 bytes. */
|
|
|
497
|
|
|
498 static uint16_t
|
|
|
499 read_uint16 (struct dwarf_buf *buf)
|
|
|
500 {
|
|
|
501 const unsigned char *p = buf->buf;
|
|
|
502
|
|
|
503 if (!advance (buf, 2))
|
|
|
504 return 0;
|
|
|
505 if (buf->is_bigendian)
|
|
|
506 return ((uint16_t) p[0] << 8) | (uint16_t) p[1];
|
|
|
507 else
|
|
|
508 return ((uint16_t) p[1] << 8) | (uint16_t) p[0];
|
|
|
509 }
|
|
|
510
|
|
145
|
511 /* Read a 24 bit value from BUF and advance 3 bytes. */
|
|
|
512
|
|
|
513 static uint32_t
|
|
|
514 read_uint24 (struct dwarf_buf *buf)
|
|
|
515 {
|
|
|
516 const unsigned char *p = buf->buf;
|
|
|
517
|
|
|
518 if (!advance (buf, 3))
|
|
|
519 return 0;
|
|
|
520 if (buf->is_bigendian)
|
|
|
521 return (((uint32_t) p[0] << 16) | ((uint32_t) p[1] << 8)
|
|
|
522 | (uint32_t) p[2]);
|
|
|
523 else
|
|
|
524 return (((uint32_t) p[2] << 16) | ((uint32_t) p[1] << 8)
|
|
|
525 | (uint32_t) p[0]);
|
|
|
526 }
|
|
|
527
|
|
111
|
528 /* Read a uint32 from BUF and advance 4 bytes. */
|
|
|
529
|
|
|
530 static uint32_t
|
|
|
531 read_uint32 (struct dwarf_buf *buf)
|
|
|
532 {
|
|
|
533 const unsigned char *p = buf->buf;
|
|
|
534
|
|
|
535 if (!advance (buf, 4))
|
|
|
536 return 0;
|
|
|
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]);
|
|
|
540 else
|
|
|
541 return (((uint32_t) p[3] << 24) | ((uint32_t) p[2] << 16)
|
|
|
542 | ((uint32_t) p[1] << 8) | (uint32_t) p[0]);
|
|
|
543 }
|
|
|
544
|
|
|
545 /* Read a uint64 from BUF and advance 8 bytes. */
|
|
|
546
|
|
|
547 static uint64_t
|
|
|
548 read_uint64 (struct dwarf_buf *buf)
|
|
|
549 {
|
|
|
550 const unsigned char *p = buf->buf;
|
|
|
551
|
|
|
552 if (!advance (buf, 8))
|
|
|
553 return 0;
|
|
|
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]);
|
|
|
559 else
|
|
|
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]);
|
|
|
564 }
|
|
|
565
|
|
|
566 /* Read an offset from BUF and advance the appropriate number of
|
|
|
567 bytes. */
|
|
|
568
|
|
|
569 static uint64_t
|
|
|
570 read_offset (struct dwarf_buf *buf, int is_dwarf64)
|
|
|
571 {
|
|
|
572 if (is_dwarf64)
|
|
|
573 return read_uint64 (buf);
|
|
|
574 else
|
|
|
575 return read_uint32 (buf);
|
|
|
576 }
|
|
|
577
|
|
|
578 /* Read an address from BUF and advance the appropriate number of
|
|
|
579 bytes. */
|
|
|
580
|
|
|
581 static uint64_t
|
|
|
582 read_address (struct dwarf_buf *buf, int addrsize)
|
|
|
583 {
|
|
|
584 switch (addrsize)
|
|
|
585 {
|
|
|
586 case 1:
|
|
|
587 return read_byte (buf);
|
|
|
588 case 2:
|
|
|
589 return read_uint16 (buf);
|
|
|
590 case 4:
|
|
|
591 return read_uint32 (buf);
|
|
|
592 case 8:
|
|
|
593 return read_uint64 (buf);
|
|
|
594 default:
|
|
|
595 dwarf_buf_error (buf, "unrecognized address size");
|
|
|
596 return 0;
|
|
|
597 }
|
|
|
598 }
|
|
|
599
|
|
|
600 /* Return whether a value is the highest possible address, given the
|
|
|
601 address size. */
|
|
|
602
|
|
|
603 static int
|
|
|
604 is_highest_address (uint64_t address, int addrsize)
|
|
|
605 {
|
|
|
606 switch (addrsize)
|
|
|
607 {
|
|
|
608 case 1:
|
|
|
609 return address == (unsigned char) -1;
|
|
|
610 case 2:
|
|
|
611 return address == (uint16_t) -1;
|
|
|
612 case 4:
|
|
|
613 return address == (uint32_t) -1;
|
|
|
614 case 8:
|
|
|
615 return address == (uint64_t) -1;
|
|
|
616 default:
|
|
|
617 return 0;
|
|
|
618 }
|
|
|
619 }
|
|
|
620
|
|
|
621 /* Read an unsigned LEB128 number. */
|
|
|
622
|
|
|
623 static uint64_t
|
|
|
624 read_uleb128 (struct dwarf_buf *buf)
|
|
|
625 {
|
|
|
626 uint64_t ret;
|
|
|
627 unsigned int shift;
|
|
|
628 int overflow;
|
|
|
629 unsigned char b;
|
|
|
630
|
|
|
631 ret = 0;
|
|
|
632 shift = 0;
|
|
|
633 overflow = 0;
|
|
|
634 do
|
|
|
635 {
|
|
|
636 const unsigned char *p;
|
|
|
637
|
|
|
638 p = buf->buf;
|
|
|
639 if (!advance (buf, 1))
|
|
|
640 return 0;
|
|
|
641 b = *p;
|
|
|
642 if (shift < 64)
|
|
|
643 ret |= ((uint64_t) (b & 0x7f)) << shift;
|
|
|
644 else if (!overflow)
|
|
|
645 {
|
|
|
646 dwarf_buf_error (buf, "LEB128 overflows uint64_t");
|
|
|
647 overflow = 1;
|
|
|
648 }
|
|
|
649 shift += 7;
|
|
|
650 }
|
|
|
651 while ((b & 0x80) != 0);
|
|
|
652
|
|
|
653 return ret;
|
|
|
654 }
|
|
|
655
|
|
|
656 /* Read a signed LEB128 number. */
|
|
|
657
|
|
|
658 static int64_t
|
|
|
659 read_sleb128 (struct dwarf_buf *buf)
|
|
|
660 {
|
|
|
661 uint64_t val;
|
|
|
662 unsigned int shift;
|
|
|
663 int overflow;
|
|
|
664 unsigned char b;
|
|
|
665
|
|
|
666 val = 0;
|
|
|
667 shift = 0;
|
|
|
668 overflow = 0;
|
|
|
669 do
|
|
|
670 {
|
|
|
671 const unsigned char *p;
|
|
|
672
|
|
|
673 p = buf->buf;
|
|
|
674 if (!advance (buf, 1))
|
|
|
675 return 0;
|
|
|
676 b = *p;
|
|
|
677 if (shift < 64)
|
|
|
678 val |= ((uint64_t) (b & 0x7f)) << shift;
|
|
|
679 else if (!overflow)
|
|
|
680 {
|
|
|
681 dwarf_buf_error (buf, "signed LEB128 overflows uint64_t");
|
|
|
682 overflow = 1;
|
|
|
683 }
|
|
|
684 shift += 7;
|
|
|
685 }
|
|
|
686 while ((b & 0x80) != 0);
|
|
|
687
|
|
|
688 if ((b & 0x40) != 0 && shift < 64)
|
|
|
689 val |= ((uint64_t) -1) << shift;
|
|
|
690
|
|
|
691 return (int64_t) val;
|
|
|
692 }
|
|
|
693
|
|
|
694 /* Return the length of an LEB128 number. */
|
|
|
695
|
|
|
696 static size_t
|
|
|
697 leb128_len (const unsigned char *p)
|
|
|
698 {
|
|
|
699 size_t ret;
|
|
|
700
|
|
|
701 ret = 1;
|
|
|
702 while ((*p & 0x80) != 0)
|
|
|
703 {
|
|
|
704 ++p;
|
|
|
705 ++ret;
|
|
|
706 }
|
|
|
707 return ret;
|
|
|
708 }
|
|
|
709
|
|
145
|
710 /* Read initial_length from BUF and advance the appropriate number of bytes. */
|
|
|
711
|
|
|
712 static uint64_t
|
|
|
713 read_initial_length (struct dwarf_buf *buf, int *is_dwarf64)
|
|
|
714 {
|
|
|
715 uint64_t len;
|
|
|
716
|
|
|
717 len = read_uint32 (buf);
|
|
|
718 if (len == 0xffffffff)
|
|
|
719 {
|
|
|
720 len = read_uint64 (buf);
|
|
|
721 *is_dwarf64 = 1;
|
|
|
722 }
|
|
|
723 else
|
|
|
724 *is_dwarf64 = 0;
|
|
|
725
|
|
|
726 return len;
|
|
|
727 }
|
|
|
728
|
|
111
|
729 /* Free an abbreviations structure. */
|
|
|
730
|
|
|
731 static void
|
|
|
732 free_abbrevs (struct backtrace_state *state, struct abbrevs *abbrevs,
|
|
|
733 backtrace_error_callback error_callback, void *data)
|
|
|
734 {
|
|
|
735 size_t i;
|
|
|
736
|
|
|
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;
|
|
|
746 }
|
|
|
747
|
|
|
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. */
|
|
|
752
|
|
|
753 static int
|
|
145
|
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)
|
|
111
|
758 {
|
|
|
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
|
|
|
762 conditionally. */
|
|
|
763 memset (val, 0, sizeof *val);
|
|
|
764
|
|
|
765 switch (form)
|
|
|
766 {
|
|
|
767 case DW_FORM_addr:
|
|
|
768 val->encoding = ATTR_VAL_ADDRESS;
|
|
|
769 val->u.uint = read_address (buf, addrsize);
|
|
|
770 return 1;
|
|
|
771 case DW_FORM_block2:
|
|
|
772 val->encoding = ATTR_VAL_BLOCK;
|
|
|
773 return advance (buf, read_uint16 (buf));
|
|
|
774 case DW_FORM_block4:
|
|
|
775 val->encoding = ATTR_VAL_BLOCK;
|
|
|
776 return advance (buf, read_uint32 (buf));
|
|
|
777 case DW_FORM_data2:
|
|
|
778 val->encoding = ATTR_VAL_UINT;
|
|
|
779 val->u.uint = read_uint16 (buf);
|
|
|
780 return 1;
|
|
|
781 case DW_FORM_data4:
|
|
|
782 val->encoding = ATTR_VAL_UINT;
|
|
|
783 val->u.uint = read_uint32 (buf);
|
|
|
784 return 1;
|
|
|
785 case DW_FORM_data8:
|
|
|
786 val->encoding = ATTR_VAL_UINT;
|
|
|
787 val->u.uint = read_uint64 (buf);
|
|
|
788 return 1;
|
|
145
|
789 case DW_FORM_data16:
|
|
|
790 val->encoding = ATTR_VAL_BLOCK;
|
|
|
791 return advance (buf, 16);
|
|
111
|
792 case DW_FORM_string:
|
|
|
793 val->encoding = ATTR_VAL_STRING;
|
|
145
|
794 val->u.string = read_string (buf);
|
|
|
795 return val->u.string == NULL ? 0 : 1;
|
|
111
|
796 case DW_FORM_block:
|
|
|
797 val->encoding = ATTR_VAL_BLOCK;
|
|
|
798 return advance (buf, read_uleb128 (buf));
|
|
|
799 case DW_FORM_block1:
|
|
|
800 val->encoding = ATTR_VAL_BLOCK;
|
|
|
801 return advance (buf, read_byte (buf));
|
|
|
802 case DW_FORM_data1:
|
|
|
803 val->encoding = ATTR_VAL_UINT;
|
|
|
804 val->u.uint = read_byte (buf);
|
|
|
805 return 1;
|
|
|
806 case DW_FORM_flag:
|
|
|
807 val->encoding = ATTR_VAL_UINT;
|
|
|
808 val->u.uint = read_byte (buf);
|
|
|
809 return 1;
|
|
|
810 case DW_FORM_sdata:
|
|
|
811 val->encoding = ATTR_VAL_SINT;
|
|
|
812 val->u.sint = read_sleb128 (buf);
|
|
|
813 return 1;
|
|
|
814 case DW_FORM_strp:
|
|
|
815 {
|
|
|
816 uint64_t offset;
|
|
|
817
|
|
|
818 offset = read_offset (buf, is_dwarf64);
|
|
145
|
819 if (offset >= dwarf_sections->size[DEBUG_STR])
|
|
111
|
820 {
|
|
|
821 dwarf_buf_error (buf, "DW_FORM_strp out of range");
|
|
|
822 return 0;
|
|
|
823 }
|
|
|
824 val->encoding = ATTR_VAL_STRING;
|
|
145
|
825 val->u.string =
|
|
|
826 (const char *) dwarf_sections->data[DEBUG_STR] + offset;
|
|
|
827 return 1;
|
|
|
828 }
|
|
|
829 case DW_FORM_line_strp:
|
|
|
830 {
|
|
|
831 uint64_t offset;
|
|
|
832
|
|
|
833 offset = read_offset (buf, is_dwarf64);
|
|
|
834 if (offset >= dwarf_sections->size[DEBUG_LINE_STR])
|
|
|
835 {
|
|
|
836 dwarf_buf_error (buf, "DW_FORM_line_strp out of range");
|
|
|
837 return 0;
|
|
|
838 }
|
|
|
839 val->encoding = ATTR_VAL_STRING;
|
|
|
840 val->u.string =
|
|
|
841 (const char *) dwarf_sections->data[DEBUG_LINE_STR] + offset;
|
|
111
|
842 return 1;
|
|
|
843 }
|
|
|
844 case DW_FORM_udata:
|
|
|
845 val->encoding = ATTR_VAL_UINT;
|
|
|
846 val->u.uint = read_uleb128 (buf);
|
|
|
847 return 1;
|
|
|
848 case DW_FORM_ref_addr:
|
|
|
849 val->encoding = ATTR_VAL_REF_INFO;
|
|
|
850 if (version == 2)
|
|
|
851 val->u.uint = read_address (buf, addrsize);
|
|
|
852 else
|
|
|
853 val->u.uint = read_offset (buf, is_dwarf64);
|
|
|
854 return 1;
|
|
|
855 case DW_FORM_ref1:
|
|
|
856 val->encoding = ATTR_VAL_REF_UNIT;
|
|
|
857 val->u.uint = read_byte (buf);
|
|
|
858 return 1;
|
|
|
859 case DW_FORM_ref2:
|
|
|
860 val->encoding = ATTR_VAL_REF_UNIT;
|
|
|
861 val->u.uint = read_uint16 (buf);
|
|
|
862 return 1;
|
|
|
863 case DW_FORM_ref4:
|
|
|
864 val->encoding = ATTR_VAL_REF_UNIT;
|
|
|
865 val->u.uint = read_uint32 (buf);
|
|
|
866 return 1;
|
|
|
867 case DW_FORM_ref8:
|
|
|
868 val->encoding = ATTR_VAL_REF_UNIT;
|
|
|
869 val->u.uint = read_uint64 (buf);
|
|
|
870 return 1;
|
|
|
871 case DW_FORM_ref_udata:
|
|
|
872 val->encoding = ATTR_VAL_REF_UNIT;
|
|
|
873 val->u.uint = read_uleb128 (buf);
|
|
|
874 return 1;
|
|
|
875 case DW_FORM_indirect:
|
|
|
876 {
|
|
|
877 uint64_t form;
|
|
|
878
|
|
|
879 form = read_uleb128 (buf);
|
|
145
|
880 if (form == DW_FORM_implicit_const)
|
|
|
881 {
|
|
|
882 dwarf_buf_error (buf,
|
|
|
883 "DW_FORM_indirect to DW_FORM_implicit_const");
|
|
|
884 return 0;
|
|
|
885 }
|
|
|
886 return read_attribute ((enum dwarf_form) form, 0, buf, is_dwarf64,
|
|
|
887 version, addrsize, dwarf_sections, altlink,
|
|
111
|
888 val);
|
|
|
889 }
|
|
|
890 case DW_FORM_sec_offset:
|
|
|
891 val->encoding = ATTR_VAL_REF_SECTION;
|
|
|
892 val->u.uint = read_offset (buf, is_dwarf64);
|
|
|
893 return 1;
|
|
|
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;
|
|
|
899 val->u.uint = 1;
|
|
|
900 return 1;
|
|
|
901 case DW_FORM_ref_sig8:
|
|
|
902 val->encoding = ATTR_VAL_REF_TYPE;
|
|
|
903 val->u.uint = read_uint64 (buf);
|
|
|
904 return 1;
|
|
145
|
905 case DW_FORM_strx: case DW_FORM_strx1: case DW_FORM_strx2:
|
|
|
906 case DW_FORM_strx3: case DW_FORM_strx4:
|
|
|
907 {
|
|
|
908 uint64_t offset;
|
|
|
909
|
|
|
910 switch (form)
|
|
|
911 {
|
|
|
912 case DW_FORM_strx:
|
|
|
913 offset = read_uleb128 (buf);
|
|
|
914 break;
|
|
|
915 case DW_FORM_strx1:
|
|
|
916 offset = read_byte (buf);
|
|
|
917 break;
|
|
|
918 case DW_FORM_strx2:
|
|
|
919 offset = read_uint16 (buf);
|
|
|
920 break;
|
|
|
921 case DW_FORM_strx3:
|
|
|
922 offset = read_uint24 (buf);
|
|
|
923 break;
|
|
|
924 case DW_FORM_strx4:
|
|
|
925 offset = read_uint32 (buf);
|
|
|
926 break;
|
|
|
927 default:
|
|
|
928 /* This case can't happen. */
|
|
|
929 return 0;
|
|
|
930 }
|
|
|
931 val->encoding = ATTR_VAL_STRING_INDEX;
|
|
|
932 val->u.uint = offset;
|
|
|
933 return 1;
|
|
|
934 }
|
|
|
935 case DW_FORM_addrx: case DW_FORM_addrx1: case DW_FORM_addrx2:
|
|
|
936 case DW_FORM_addrx3: case DW_FORM_addrx4:
|
|
|
937 {
|
|
|
938 uint64_t offset;
|
|
|
939
|
|
|
940 switch (form)
|
|
|
941 {
|
|
|
942 case DW_FORM_addrx:
|
|
|
943 offset = read_uleb128 (buf);
|
|
|
944 break;
|
|
|
945 case DW_FORM_addrx1:
|
|
|
946 offset = read_byte (buf);
|
|
|
947 break;
|
|
|
948 case DW_FORM_addrx2:
|
|
|
949 offset = read_uint16 (buf);
|
|
|
950 break;
|
|
|
951 case DW_FORM_addrx3:
|
|
|
952 offset = read_uint24 (buf);
|
|
|
953 break;
|
|
|
954 case DW_FORM_addrx4:
|
|
|
955 offset = read_uint32 (buf);
|
|
|
956 break;
|
|
|
957 default:
|
|
|
958 /* This case can't happen. */
|
|
|
959 return 0;
|
|
|
960 }
|
|
|
961 val->encoding = ATTR_VAL_ADDRESS_INDEX;
|
|
|
962 val->u.uint = offset;
|
|
|
963 return 1;
|
|
|
964 }
|
|
|
965 case DW_FORM_ref_sup4:
|
|
|
966 val->encoding = ATTR_VAL_REF_SECTION;
|
|
|
967 val->u.uint = read_uint32 (buf);
|
|
|
968 return 1;
|
|
|
969 case DW_FORM_ref_sup8:
|
|
|
970 val->encoding = ATTR_VAL_REF_SECTION;
|
|
|
971 val->u.uint = read_uint64 (buf);
|
|
|
972 return 1;
|
|
|
973 case DW_FORM_implicit_const:
|
|
|
974 val->encoding = ATTR_VAL_UINT;
|
|
|
975 val->u.uint = implicit_val;
|
|
|
976 return 1;
|
|
|
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);
|
|
|
982 return 1;
|
|
|
983 case DW_FORM_rnglistx:
|
|
|
984 val->encoding = ATTR_VAL_RNGLISTS_INDEX;
|
|
|
985 val->u.uint = read_uleb128 (buf);
|
|
|
986 return 1;
|
|
111
|
987 case DW_FORM_GNU_addr_index:
|
|
|
988 val->encoding = ATTR_VAL_REF_SECTION;
|
|
|
989 val->u.uint = read_uleb128 (buf);
|
|
|
990 return 1;
|
|
|
991 case DW_FORM_GNU_str_index:
|
|
|
992 val->encoding = ATTR_VAL_REF_SECTION;
|
|
|
993 val->u.uint = read_uleb128 (buf);
|
|
|
994 return 1;
|
|
|
995 case DW_FORM_GNU_ref_alt:
|
|
|
996 val->u.uint = read_offset (buf, is_dwarf64);
|
|
145
|
997 if (altlink == NULL)
|
|
|
998 {
|
|
|
999 val->encoding = ATTR_VAL_NONE;
|
|
|
1000 return 1;
|
|
|
1001 }
|
|
|
1002 val->encoding = ATTR_VAL_REF_ALT_INFO;
|
|
111
|
1003 return 1;
|
|
145
|
1004 case DW_FORM_strp_sup: case DW_FORM_GNU_strp_alt:
|
|
|
1005 {
|
|
|
1006 uint64_t offset;
|
|
|
1007
|
|
|
1008 offset = read_offset (buf, is_dwarf64);
|
|
|
1009 if (altlink == NULL)
|
|
|
1010 {
|
|
|
1011 val->encoding = ATTR_VAL_NONE;
|
|
|
1012 return 1;
|
|
|
1013 }
|
|
|
1014 if (offset >= altlink->dwarf_sections.size[DEBUG_STR])
|
|
|
1015 {
|
|
|
1016 dwarf_buf_error (buf, "DW_FORM_strp_sup out of range");
|
|
|
1017 return 0;
|
|
|
1018 }
|
|
|
1019 val->encoding = ATTR_VAL_STRING;
|
|
|
1020 val->u.string =
|
|
|
1021 (const char *) altlink->dwarf_sections.data[DEBUG_STR] + offset;
|
|
|
1022 return 1;
|
|
|
1023 }
|
|
111
|
1024 default:
|
|
|
1025 dwarf_buf_error (buf, "unrecognized DWARF form");
|
|
|
1026 return 0;
|
|
|
1027 }
|
|
|
1028 }
|
|
|
1029
|
|
145
|
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
|
|
|
1034 offset. */
|
|
|
1035
|
|
|
1036 static int
|
|
|
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)
|
|
|
1042 {
|
|
|
1043 switch (val->encoding)
|
|
|
1044 {
|
|
|
1045 case ATTR_VAL_STRING:
|
|
|
1046 *string = val->u.string;
|
|
|
1047 return 1;
|
|
|
1048
|
|
|
1049 case ATTR_VAL_STRING_INDEX:
|
|
|
1050 {
|
|
|
1051 uint64_t offset;
|
|
|
1052 struct dwarf_buf offset_buf;
|
|
|
1053
|
|
|
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])
|
|
|
1057 {
|
|
|
1058 error_callback (data, "DW_FORM_strx value out of range", 0);
|
|
|
1059 return 0;
|
|
|
1060 }
|
|
|
1061
|
|
|
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;
|
|
|
1070
|
|
|
1071 offset = read_offset (&offset_buf, is_dwarf64);
|
|
|
1072 if (offset >= dwarf_sections->size[DEBUG_STR])
|
|
|
1073 {
|
|
|
1074 dwarf_buf_error (&offset_buf, "DW_FORM_strx offset out of range");
|
|
|
1075 return 0;
|
|
|
1076 }
|
|
|
1077 *string = (const char *) dwarf_sections->data[DEBUG_STR] + offset;
|
|
|
1078 return 1;
|
|
|
1079 }
|
|
|
1080
|
|
|
1081 default:
|
|
|
1082 return 1;
|
|
|
1083 }
|
|
|
1084 }
|
|
|
1085
|
|
|
1086 /* Set *ADDRESS to the real address for a ATTR_VAL_ADDRESS_INDEX.
|
|
|
1087 Return 1 on success, 0 on error. */
|
|
|
1088
|
|
|
1089 static int
|
|
|
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,
|
|
|
1094 uint64_t *address)
|
|
|
1095 {
|
|
|
1096 uint64_t offset;
|
|
|
1097 struct dwarf_buf addr_buf;
|
|
|
1098
|
|
|
1099 offset = addr_index * addrsize + addr_base;
|
|
|
1100 if (offset + addrsize >= dwarf_sections->size[DEBUG_ADDR])
|
|
|
1101 {
|
|
|
1102 error_callback (data, "DW_FORM_addrx value out of range", 0);
|
|
|
1103 return 0;
|
|
|
1104 }
|
|
|
1105
|
|
|
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;
|
|
|
1114
|
|
|
1115 *address = read_address (&addr_buf, addrsize);
|
|
|
1116 return 1;
|
|
|
1117 }
|
|
|
1118
|
|
|
1119 /* Compare a unit offset against a unit for bsearch. */
|
|
|
1120
|
|
|
1121 static int
|
|
|
1122 units_search (const void *vkey, const void *ventry)
|
|
|
1123 {
|
|
|
1124 const size_t *key = (const size_t *) vkey;
|
|
|
1125 const struct unit *entry = *((const struct unit *const *) ventry);
|
|
|
1126 size_t offset;
|
|
|
1127
|
|
|
1128 offset = *key;
|
|
|
1129 if (offset < entry->low_offset)
|
|
|
1130 return -1;
|
|
|
1131 else if (offset >= entry->high_offset)
|
|
|
1132 return 1;
|
|
|
1133 else
|
|
|
1134 return 0;
|
|
|
1135 }
|
|
|
1136
|
|
|
1137 /* Find a unit in PU containing OFFSET. */
|
|
|
1138
|
|
|
1139 static struct unit *
|
|
|
1140 find_unit (struct unit **pu, size_t units_count, size_t offset)
|
|
|
1141 {
|
|
|
1142 struct unit **u;
|
|
|
1143 u = bsearch (&offset, pu, units_count, sizeof (struct unit *), units_search);
|
|
|
1144 return u == NULL ? NULL : *u;
|
|
|
1145 }
|
|
|
1146
|
|
111
|
1147 /* Compare function_addrs for qsort. When ranges are nested, make the
|
|
|
1148 smallest one sort last. */
|
|
|
1149
|
|
|
1150 static int
|
|
|
1151 function_addrs_compare (const void *v1, const void *v2)
|
|
|
1152 {
|
|
|
1153 const struct function_addrs *a1 = (const struct function_addrs *) v1;
|
|
|
1154 const struct function_addrs *a2 = (const struct function_addrs *) v2;
|
|
|
1155
|
|
|
1156 if (a1->low < a2->low)
|
|
|
1157 return -1;
|
|
|
1158 if (a1->low > a2->low)
|
|
|
1159 return 1;
|
|
|
1160 if (a1->high < a2->high)
|
|
|
1161 return 1;
|
|
|
1162 if (a1->high > a2->high)
|
|
|
1163 return -1;
|
|
|
1164 return strcmp (a1->function->name, a2->function->name);
|
|
|
1165 }
|
|
|
1166
|
|
|
1167 /* Compare a PC against a function_addrs for bsearch. Note that if
|
|
|
1168 there are multiple ranges containing PC, which one will be returned
|
|
|
1169 is unpredictable. We compensate for that in dwarf_fileline. */
|
|
|
1170
|
|
|
1171 static int
|
|
|
1172 function_addrs_search (const void *vkey, const void *ventry)
|
|
|
1173 {
|
|
|
1174 const uintptr_t *key = (const uintptr_t *) vkey;
|
|
|
1175 const struct function_addrs *entry = (const struct function_addrs *) ventry;
|
|
|
1176 uintptr_t pc;
|
|
|
1177
|
|
|
1178 pc = *key;
|
|
|
1179 if (pc < entry->low)
|
|
|
1180 return -1;
|
|
|
1181 else if (pc >= entry->high)
|
|
|
1182 return 1;
|
|
|
1183 else
|
|
|
1184 return 0;
|
|
|
1185 }
|
|
|
1186
|
|
145
|
1187 /* Add a new compilation unit address range to a vector. This is
|
|
|
1188 called via add_ranges. Returns 1 on success, 0 on failure. */
|
|
111
|
1189
|
|
|
1190 static int
|
|
145
|
1191 add_unit_addr (struct backtrace_state *state, void *rdata,
|
|
|
1192 uint64_t lowpc, uint64_t highpc,
|
|
111
|
1193 backtrace_error_callback error_callback, void *data,
|
|
145
|
1194 void *pvec)
|
|
111
|
1195 {
|
|
145
|
1196 struct unit *u = (struct unit *) rdata;
|
|
|
1197 struct unit_addrs_vector *vec = (struct unit_addrs_vector *) pvec;
|
|
111
|
1198 struct unit_addrs *p;
|
|
|
1199
|
|
|
1200 /* Try to merge with the last entry. */
|
|
|
1201 if (vec->count > 0)
|
|
|
1202 {
|
|
|
1203 p = (struct unit_addrs *) vec->vec.base + (vec->count - 1);
|
|
145
|
1204 if ((lowpc == p->high || lowpc == p->high + 1)
|
|
|
1205 && u == p->u)
|
|
111
|
1206 {
|
|
145
|
1207 if (highpc > p->high)
|
|
|
1208 p->high = highpc;
|
|
111
|
1209 return 1;
|
|
|
1210 }
|
|
|
1211 }
|
|
|
1212
|
|
|
1213 p = ((struct unit_addrs *)
|
|
|
1214 backtrace_vector_grow (state, sizeof (struct unit_addrs),
|
|
|
1215 error_callback, data, &vec->vec));
|
|
|
1216 if (p == NULL)
|
|
|
1217 return 0;
|
|
|
1218
|
|
145
|
1219 p->low = lowpc;
|
|
|
1220 p->high = highpc;
|
|
|
1221 p->u = u;
|
|
|
1222
|
|
111
|
1223 ++vec->count;
|
|
145
|
1224
|
|
111
|
1225 return 1;
|
|
|
1226 }
|
|
|
1227
|
|
|
1228 /* Compare unit_addrs for qsort. When ranges are nested, make the
|
|
|
1229 smallest one sort last. */
|
|
|
1230
|
|
|
1231 static int
|
|
|
1232 unit_addrs_compare (const void *v1, const void *v2)
|
|
|
1233 {
|
|
|
1234 const struct unit_addrs *a1 = (const struct unit_addrs *) v1;
|
|
|
1235 const struct unit_addrs *a2 = (const struct unit_addrs *) v2;
|
|
|
1236
|
|
|
1237 if (a1->low < a2->low)
|
|
|
1238 return -1;
|
|
|
1239 if (a1->low > a2->low)
|
|
|
1240 return 1;
|
|
|
1241 if (a1->high < a2->high)
|
|
|
1242 return 1;
|
|
|
1243 if (a1->high > a2->high)
|
|
|
1244 return -1;
|
|
|
1245 if (a1->u->lineoff < a2->u->lineoff)
|
|
|
1246 return -1;
|
|
|
1247 if (a1->u->lineoff > a2->u->lineoff)
|
|
|
1248 return 1;
|
|
|
1249 return 0;
|
|
|
1250 }
|
|
|
1251
|
|
|
1252 /* Compare a PC against a unit_addrs for bsearch. Note that if there
|
|
|
1253 are multiple ranges containing PC, which one will be returned is
|
|
|
1254 unpredictable. We compensate for that in dwarf_fileline. */
|
|
|
1255
|
|
|
1256 static int
|
|
|
1257 unit_addrs_search (const void *vkey, const void *ventry)
|
|
|
1258 {
|
|
|
1259 const uintptr_t *key = (const uintptr_t *) vkey;
|
|
|
1260 const struct unit_addrs *entry = (const struct unit_addrs *) ventry;
|
|
|
1261 uintptr_t pc;
|
|
|
1262
|
|
|
1263 pc = *key;
|
|
|
1264 if (pc < entry->low)
|
|
|
1265 return -1;
|
|
|
1266 else if (pc >= entry->high)
|
|
|
1267 return 1;
|
|
|
1268 else
|
|
|
1269 return 0;
|
|
|
1270 }
|
|
|
1271
|
|
|
1272 /* Sort the line vector by PC. We want a stable sort here to maintain
|
|
|
1273 the order of lines for the same PC values. Since the sequence is
|
|
|
1274 being sorted in place, their addresses cannot be relied on to
|
|
|
1275 maintain stability. That is the purpose of the index member. */
|
|
|
1276
|
|
|
1277 static int
|
|
|
1278 line_compare (const void *v1, const void *v2)
|
|
|
1279 {
|
|
|
1280 const struct line *ln1 = (const struct line *) v1;
|
|
|
1281 const struct line *ln2 = (const struct line *) v2;
|
|
|
1282
|
|
|
1283 if (ln1->pc < ln2->pc)
|
|
|
1284 return -1;
|
|
|
1285 else if (ln1->pc > ln2->pc)
|
|
|
1286 return 1;
|
|
|
1287 else if (ln1->idx < ln2->idx)
|
|
|
1288 return -1;
|
|
|
1289 else if (ln1->idx > ln2->idx)
|
|
|
1290 return 1;
|
|
|
1291 else
|
|
|
1292 return 0;
|
|
|
1293 }
|
|
|
1294
|
|
|
1295 /* Find a PC in a line vector. We always allocate an extra entry at
|
|
|
1296 the end of the lines vector, so that this routine can safely look
|
|
|
1297 at the next entry. Note that when there are multiple mappings for
|
|
|
1298 the same PC value, this will return the last one. */
|
|
|
1299
|
|
|
1300 static int
|
|
|
1301 line_search (const void *vkey, const void *ventry)
|
|
|
1302 {
|
|
|
1303 const uintptr_t *key = (const uintptr_t *) vkey;
|
|
|
1304 const struct line *entry = (const struct line *) ventry;
|
|
|
1305 uintptr_t pc;
|
|
|
1306
|
|
|
1307 pc = *key;
|
|
|
1308 if (pc < entry->pc)
|
|
|
1309 return -1;
|
|
|
1310 else if (pc >= (entry + 1)->pc)
|
|
|
1311 return 1;
|
|
|
1312 else
|
|
|
1313 return 0;
|
|
|
1314 }
|
|
|
1315
|
|
|
1316 /* Sort the abbrevs by the abbrev code. This function is passed to
|
|
|
1317 both qsort and bsearch. */
|
|
|
1318
|
|
|
1319 static int
|
|
|
1320 abbrev_compare (const void *v1, const void *v2)
|
|
|
1321 {
|
|
|
1322 const struct abbrev *a1 = (const struct abbrev *) v1;
|
|
|
1323 const struct abbrev *a2 = (const struct abbrev *) v2;
|
|
|
1324
|
|
|
1325 if (a1->code < a2->code)
|
|
|
1326 return -1;
|
|
|
1327 else if (a1->code > a2->code)
|
|
|
1328 return 1;
|
|
|
1329 else
|
|
|
1330 {
|
|
|
1331 /* This really shouldn't happen. It means there are two
|
|
|
1332 different abbrevs with the same code, and that means we don't
|
|
|
1333 know which one lookup_abbrev should return. */
|
|
|
1334 return 0;
|
|
|
1335 }
|
|
|
1336 }
|
|
|
1337
|
|
|
1338 /* Read the abbreviation table for a compilation unit. Returns 1 on
|
|
|
1339 success, 0 on failure. */
|
|
|
1340
|
|
|
1341 static int
|
|
|
1342 read_abbrevs (struct backtrace_state *state, uint64_t abbrev_offset,
|
|
|
1343 const unsigned char *dwarf_abbrev, size_t dwarf_abbrev_size,
|
|
|
1344 int is_bigendian, backtrace_error_callback error_callback,
|
|
|
1345 void *data, struct abbrevs *abbrevs)
|
|
|
1346 {
|
|
|
1347 struct dwarf_buf abbrev_buf;
|
|
|
1348 struct dwarf_buf count_buf;
|
|
|
1349 size_t num_abbrevs;
|
|
|
1350
|
|
|
1351 abbrevs->num_abbrevs = 0;
|
|
|
1352 abbrevs->abbrevs = NULL;
|
|
|
1353
|
|
|
1354 if (abbrev_offset >= dwarf_abbrev_size)
|
|
|
1355 {
|
|
|
1356 error_callback (data, "abbrev offset out of range", 0);
|
|
|
1357 return 0;
|
|
|
1358 }
|
|
|
1359
|
|
|
1360 abbrev_buf.name = ".debug_abbrev";
|
|
|
1361 abbrev_buf.start = dwarf_abbrev;
|
|
|
1362 abbrev_buf.buf = dwarf_abbrev + abbrev_offset;
|
|
|
1363 abbrev_buf.left = dwarf_abbrev_size - abbrev_offset;
|
|
|
1364 abbrev_buf.is_bigendian = is_bigendian;
|
|
|
1365 abbrev_buf.error_callback = error_callback;
|
|
|
1366 abbrev_buf.data = data;
|
|
|
1367 abbrev_buf.reported_underflow = 0;
|
|
|
1368
|
|
|
1369 /* Count the number of abbrevs in this list. */
|
|
|
1370
|
|
|
1371 count_buf = abbrev_buf;
|
|
|
1372 num_abbrevs = 0;
|
|
|
1373 while (read_uleb128 (&count_buf) != 0)
|
|
|
1374 {
|
|
|
1375 if (count_buf.reported_underflow)
|
|
|
1376 return 0;
|
|
|
1377 ++num_abbrevs;
|
|
|
1378 // Skip tag.
|
|
|
1379 read_uleb128 (&count_buf);
|
|
|
1380 // Skip has_children.
|
|
|
1381 read_byte (&count_buf);
|
|
|
1382 // Skip attributes.
|
|
|
1383 while (read_uleb128 (&count_buf) != 0)
|
|
145
|
1384 {
|
|
|
1385 uint64_t form;
|
|
|
1386
|
|
|
1387 form = read_uleb128 (&count_buf);
|
|
|
1388 if ((enum dwarf_form) form == DW_FORM_implicit_const)
|
|
|
1389 read_sleb128 (&count_buf);
|
|
|
1390 }
|
|
111
|
1391 // Skip form of last attribute.
|
|
|
1392 read_uleb128 (&count_buf);
|
|
|
1393 }
|
|
|
1394
|
|
|
1395 if (count_buf.reported_underflow)
|
|
|
1396 return 0;
|
|
|
1397
|
|
|
1398 if (num_abbrevs == 0)
|
|
|
1399 return 1;
|
|
|
1400
|
|
|
1401 abbrevs->abbrevs = ((struct abbrev *)
|
|
|
1402 backtrace_alloc (state,
|
|
|
1403 num_abbrevs * sizeof (struct abbrev),
|
|
|
1404 error_callback, data));
|
|
|
1405 if (abbrevs->abbrevs == NULL)
|
|
|
1406 return 0;
|
|
145
|
1407 abbrevs->num_abbrevs = num_abbrevs;
|
|
111
|
1408 memset (abbrevs->abbrevs, 0, num_abbrevs * sizeof (struct abbrev));
|
|
|
1409
|
|
|
1410 num_abbrevs = 0;
|
|
|
1411 while (1)
|
|
|
1412 {
|
|
|
1413 uint64_t code;
|
|
|
1414 struct abbrev a;
|
|
|
1415 size_t num_attrs;
|
|
|
1416 struct attr *attrs;
|
|
|
1417
|
|
|
1418 if (abbrev_buf.reported_underflow)
|
|
|
1419 goto fail;
|
|
|
1420
|
|
|
1421 code = read_uleb128 (&abbrev_buf);
|
|
|
1422 if (code == 0)
|
|
|
1423 break;
|
|
|
1424
|
|
|
1425 a.code = code;
|
|
|
1426 a.tag = (enum dwarf_tag) read_uleb128 (&abbrev_buf);
|
|
|
1427 a.has_children = read_byte (&abbrev_buf);
|
|
|
1428
|
|
|
1429 count_buf = abbrev_buf;
|
|
|
1430 num_attrs = 0;
|
|
|
1431 while (read_uleb128 (&count_buf) != 0)
|
|
|
1432 {
|
|
145
|
1433 uint64_t form;
|
|
|
1434
|
|
111
|
1435 ++num_attrs;
|
|
145
|
1436 form = read_uleb128 (&count_buf);
|
|
|
1437 if ((enum dwarf_form) form == DW_FORM_implicit_const)
|
|
|
1438 read_sleb128 (&count_buf);
|
|
111
|
1439 }
|
|
|
1440
|
|
|
1441 if (num_attrs == 0)
|
|
|
1442 {
|
|
|
1443 attrs = NULL;
|
|
|
1444 read_uleb128 (&abbrev_buf);
|
|
|
1445 read_uleb128 (&abbrev_buf);
|
|
|
1446 }
|
|
|
1447 else
|
|
|
1448 {
|
|
|
1449 attrs = ((struct attr *)
|
|
|
1450 backtrace_alloc (state, num_attrs * sizeof *attrs,
|
|
|
1451 error_callback, data));
|
|
|
1452 if (attrs == NULL)
|
|
|
1453 goto fail;
|
|
|
1454 num_attrs = 0;
|
|
|
1455 while (1)
|
|
|
1456 {
|
|
|
1457 uint64_t name;
|
|
|
1458 uint64_t form;
|
|
|
1459
|
|
|
1460 name = read_uleb128 (&abbrev_buf);
|
|
|
1461 form = read_uleb128 (&abbrev_buf);
|
|
|
1462 if (name == 0)
|
|
|
1463 break;
|
|
|
1464 attrs[num_attrs].name = (enum dwarf_attribute) name;
|
|
|
1465 attrs[num_attrs].form = (enum dwarf_form) form;
|
|
145
|
1466 if ((enum dwarf_form) form == DW_FORM_implicit_const)
|
|
|
1467 attrs[num_attrs].val = read_sleb128 (&abbrev_buf);
|
|
|
1468 else
|
|
|
1469 attrs[num_attrs].val = 0;
|
|
111
|
1470 ++num_attrs;
|
|
|
1471 }
|
|
|
1472 }
|
|
|
1473
|
|
|
1474 a.num_attrs = num_attrs;
|
|
|
1475 a.attrs = attrs;
|
|
|
1476
|
|
|
1477 abbrevs->abbrevs[num_abbrevs] = a;
|
|
|
1478 ++num_abbrevs;
|
|
|
1479 }
|
|
|
1480
|
|
|
1481 backtrace_qsort (abbrevs->abbrevs, abbrevs->num_abbrevs,
|
|
|
1482 sizeof (struct abbrev), abbrev_compare);
|
|
|
1483
|
|
|
1484 return 1;
|
|
|
1485
|
|
|
1486 fail:
|
|
|
1487 free_abbrevs (state, abbrevs, error_callback, data);
|
|
|
1488 return 0;
|
|
|
1489 }
|
|
|
1490
|
|
|
1491 /* Return the abbrev information for an abbrev code. */
|
|
|
1492
|
|
|
1493 static const struct abbrev *
|
|
|
1494 lookup_abbrev (struct abbrevs *abbrevs, uint64_t code,
|
|
|
1495 backtrace_error_callback error_callback, void *data)
|
|
|
1496 {
|
|
|
1497 struct abbrev key;
|
|
|
1498 void *p;
|
|
|
1499
|
|
|
1500 /* With GCC, where abbrevs are simply numbered in order, we should
|
|
|
1501 be able to just look up the entry. */
|
|
|
1502 if (code - 1 < abbrevs->num_abbrevs
|
|
|
1503 && abbrevs->abbrevs[code - 1].code == code)
|
|
|
1504 return &abbrevs->abbrevs[code - 1];
|
|
|
1505
|
|
|
1506 /* Otherwise we have to search. */
|
|
|
1507 memset (&key, 0, sizeof key);
|
|
|
1508 key.code = code;
|
|
|
1509 p = bsearch (&key, abbrevs->abbrevs, abbrevs->num_abbrevs,
|
|
|
1510 sizeof (struct abbrev), abbrev_compare);
|
|
|
1511 if (p == NULL)
|
|
|
1512 {
|
|
|
1513 error_callback (data, "invalid abbreviation code", 0);
|
|
|
1514 return NULL;
|
|
|
1515 }
|
|
|
1516 return (const struct abbrev *) p;
|
|
|
1517 }
|
|
|
1518
|
|
145
|
1519 /* This struct is used to gather address range information while
|
|
|
1520 reading attributes. We use this while building a mapping from
|
|
|
1521 address ranges to compilation units and then again while mapping
|
|
|
1522 from address ranges to function entries. Normally either
|
|
|
1523 lowpc/highpc is set or ranges is set. */
|
|
|
1524
|
|
|
1525 struct pcrange {
|
|
|
1526 uint64_t lowpc; /* The low PC value. */
|
|
|
1527 int have_lowpc; /* Whether a low PC value was found. */
|
|
|
1528 int lowpc_is_addr_index; /* Whether lowpc is in .debug_addr. */
|
|
|
1529 uint64_t highpc; /* The high PC value. */
|
|
|
1530 int have_highpc; /* Whether a high PC value was found. */
|
|
|
1531 int highpc_is_relative; /* Whether highpc is relative to lowpc. */
|
|
|
1532 int highpc_is_addr_index; /* Whether highpc is in .debug_addr. */
|
|
|
1533 uint64_t ranges; /* Offset in ranges section. */
|
|
|
1534 int have_ranges; /* Whether ranges is valid. */
|
|
|
1535 int ranges_is_index; /* Whether ranges is DW_FORM_rnglistx. */
|
|
|
1536 };
|
|
|
1537
|
|
|
1538 /* Update PCRANGE from an attribute value. */
|
|
|
1539
|
|
|
1540 static void
|
|
|
1541 update_pcrange (const struct attr* attr, const struct attr_val* val,
|
|
|
1542 struct pcrange *pcrange)
|
|
|
1543 {
|
|
|
1544 switch (attr->name)
|
|
|
1545 {
|
|
|
1546 case DW_AT_low_pc:
|
|
|
1547 if (val->encoding == ATTR_VAL_ADDRESS)
|
|
|
1548 {
|
|
|
1549 pcrange->lowpc = val->u.uint;
|
|
|
1550 pcrange->have_lowpc = 1;
|
|
|
1551 }
|
|
|
1552 else if (val->encoding == ATTR_VAL_ADDRESS_INDEX)
|
|
|
1553 {
|
|
|
1554 pcrange->lowpc = val->u.uint;
|
|
|
1555 pcrange->have_lowpc = 1;
|
|
|
1556 pcrange->lowpc_is_addr_index = 1;
|
|
|
1557 }
|
|
|
1558 break;
|
|
|
1559
|
|
|
1560 case DW_AT_high_pc:
|
|
|
1561 if (val->encoding == ATTR_VAL_ADDRESS)
|
|
|
1562 {
|
|
|
1563 pcrange->highpc = val->u.uint;
|
|
|
1564 pcrange->have_highpc = 1;
|
|
|
1565 }
|
|
|
1566 else if (val->encoding == ATTR_VAL_UINT)
|
|
|
1567 {
|
|
|
1568 pcrange->highpc = val->u.uint;
|
|
|
1569 pcrange->have_highpc = 1;
|
|
|
1570 pcrange->highpc_is_relative = 1;
|
|
|
1571 }
|
|
|
1572 else if (val->encoding == ATTR_VAL_ADDRESS_INDEX)
|
|
|
1573 {
|
|
|
1574 pcrange->highpc = val->u.uint;
|
|
|
1575 pcrange->have_highpc = 1;
|
|
|
1576 pcrange->highpc_is_addr_index = 1;
|
|
|
1577 }
|
|
|
1578 break;
|
|
|
1579
|
|
|
1580 case DW_AT_ranges:
|
|
|
1581 if (val->encoding == ATTR_VAL_UINT
|
|
|
1582 || val->encoding == ATTR_VAL_REF_SECTION)
|
|
|
1583 {
|
|
|
1584 pcrange->ranges = val->u.uint;
|
|
|
1585 pcrange->have_ranges = 1;
|
|
|
1586 }
|
|
|
1587 else if (val->encoding == ATTR_VAL_RNGLISTS_INDEX)
|
|
|
1588 {
|
|
|
1589 pcrange->ranges = val->u.uint;
|
|
|
1590 pcrange->have_ranges = 1;
|
|
|
1591 pcrange->ranges_is_index = 1;
|
|
|
1592 }
|
|
|
1593 break;
|
|
|
1594
|
|
|
1595 default:
|
|
|
1596 break;
|
|
|
1597 }
|
|
|
1598 }
|
|
|
1599
|
|
|
1600 /* Call ADD_RANGE for a low/high PC pair. Returns 1 on success, 0 on
|
|
|
1601 error. */
|
|
111
|
1602
|
|
|
1603 static int
|
|
145
|
1604 add_low_high_range (struct backtrace_state *state,
|
|
|
1605 const struct dwarf_sections *dwarf_sections,
|
|
|
1606 uintptr_t base_address, int is_bigendian,
|
|
|
1607 struct unit *u, const struct pcrange *pcrange,
|
|
|
1608 int (*add_range) (struct backtrace_state *state,
|
|
|
1609 void *rdata, uint64_t lowpc,
|
|
|
1610 uint64_t highpc,
|
|
|
1611 backtrace_error_callback error_callback,
|
|
|
1612 void *data, void *vec),
|
|
|
1613 void *rdata,
|
|
|
1614 backtrace_error_callback error_callback, void *data,
|
|
|
1615 void *vec)
|
|
|
1616 {
|
|
|
1617 uint64_t lowpc;
|
|
|
1618 uint64_t highpc;
|
|
|
1619
|
|
|
1620 lowpc = pcrange->lowpc;
|
|
|
1621 if (pcrange->lowpc_is_addr_index)
|
|
|
1622 {
|
|
|
1623 if (!resolve_addr_index (dwarf_sections, u->addr_base, u->addrsize,
|
|
|
1624 is_bigendian, lowpc, error_callback, data,
|
|
|
1625 &lowpc))
|
|
|
1626 return 0;
|
|
|
1627 }
|
|
|
1628
|
|
|
1629 highpc = pcrange->highpc;
|
|
|
1630 if (pcrange->highpc_is_addr_index)
|
|
|
1631 {
|
|
|
1632 if (!resolve_addr_index (dwarf_sections, u->addr_base, u->addrsize,
|
|
|
1633 is_bigendian, highpc, error_callback, data,
|
|
|
1634 &highpc))
|
|
|
1635 return 0;
|
|
|
1636 }
|
|
|
1637 if (pcrange->highpc_is_relative)
|
|
|
1638 highpc += lowpc;
|
|
|
1639
|
|
|
1640 /* Add in the base address of the module when recording PC values,
|
|
|
1641 so that we can look up the PC directly. */
|
|
|
1642 lowpc += base_address;
|
|
|
1643 highpc += base_address;
|
|
|
1644
|
|
|
1645 return add_range (state, rdata, lowpc, highpc, error_callback, data, vec);
|
|
|
1646 }
|
|
|
1647
|
|
|
1648 /* Call ADD_RANGE for each range read from .debug_ranges, as used in
|
|
|
1649 DWARF versions 2 through 4. */
|
|
|
1650
|
|
|
1651 static int
|
|
|
1652 add_ranges_from_ranges (
|
|
|
1653 struct backtrace_state *state,
|
|
|
1654 const struct dwarf_sections *dwarf_sections,
|
|
|
1655 uintptr_t base_address, int is_bigendian,
|
|
|
1656 struct unit *u, uint64_t base,
|
|
|
1657 const struct pcrange *pcrange,
|
|
|
1658 int (*add_range) (struct backtrace_state *state, void *rdata,
|
|
|
1659 uint64_t lowpc, uint64_t highpc,
|
|
|
1660 backtrace_error_callback error_callback, void *data,
|
|
|
1661 void *vec),
|
|
|
1662 void *rdata,
|
|
|
1663 backtrace_error_callback error_callback, void *data,
|
|
|
1664 void *vec)
|
|
111
|
1665 {
|
|
|
1666 struct dwarf_buf ranges_buf;
|
|
|
1667
|
|
145
|
1668 if (pcrange->ranges >= dwarf_sections->size[DEBUG_RANGES])
|
|
111
|
1669 {
|
|
|
1670 error_callback (data, "ranges offset out of range", 0);
|
|
|
1671 return 0;
|
|
|
1672 }
|
|
|
1673
|
|
|
1674 ranges_buf.name = ".debug_ranges";
|
|
145
|
1675 ranges_buf.start = dwarf_sections->data[DEBUG_RANGES];
|
|
|
1676 ranges_buf.buf = dwarf_sections->data[DEBUG_RANGES] + pcrange->ranges;
|
|
|
1677 ranges_buf.left = dwarf_sections->size[DEBUG_RANGES] - pcrange->ranges;
|
|
111
|
1678 ranges_buf.is_bigendian = is_bigendian;
|
|
|
1679 ranges_buf.error_callback = error_callback;
|
|
|
1680 ranges_buf.data = data;
|
|
|
1681 ranges_buf.reported_underflow = 0;
|
|
|
1682
|
|
|
1683 while (1)
|
|
|
1684 {
|
|
|
1685 uint64_t low;
|
|
|
1686 uint64_t high;
|
|
|
1687
|
|
|
1688 if (ranges_buf.reported_underflow)
|
|
|
1689 return 0;
|
|
|
1690
|
|
|
1691 low = read_address (&ranges_buf, u->addrsize);
|
|
|
1692 high = read_address (&ranges_buf, u->addrsize);
|
|
|
1693
|
|
|
1694 if (low == 0 && high == 0)
|
|
|
1695 break;
|
|
|
1696
|
|
|
1697 if (is_highest_address (low, u->addrsize))
|
|
|
1698 base = high;
|
|
|
1699 else
|
|
|
1700 {
|
|
145
|
1701 if (!add_range (state, rdata,
|
|
|
1702 low + base + base_address,
|
|
|
1703 high + base + base_address,
|
|
|
1704 error_callback, data, vec))
|
|
111
|
1705 return 0;
|
|
|
1706 }
|
|
|
1707 }
|
|
|
1708
|
|
|
1709 if (ranges_buf.reported_underflow)
|
|
|
1710 return 0;
|
|
|
1711
|
|
|
1712 return 1;
|
|
|
1713 }
|
|
|
1714
|
|
145
|
1715 /* Call ADD_RANGE for each range read from .debug_rnglists, as used in
|
|
|
1716 DWARF version 5. */
|
|
|
1717
|
|
|
1718 static int
|
|
|
1719 add_ranges_from_rnglists (
|
|
|
1720 struct backtrace_state *state,
|
|
|
1721 const struct dwarf_sections *dwarf_sections,
|
|
|
1722 uintptr_t base_address, int is_bigendian,
|
|
|
1723 struct unit *u, uint64_t base,
|
|
|
1724 const struct pcrange *pcrange,
|
|
|
1725 int (*add_range) (struct backtrace_state *state, void *rdata,
|
|
|
1726 uint64_t lowpc, uint64_t highpc,
|
|
|
1727 backtrace_error_callback error_callback, void *data,
|
|
|
1728 void *vec),
|
|
|
1729 void *rdata,
|
|
|
1730 backtrace_error_callback error_callback, void *data,
|
|
|
1731 void *vec)
|
|
|
1732 {
|
|
|
1733 uint64_t offset;
|
|
|
1734 struct dwarf_buf rnglists_buf;
|
|
|
1735
|
|
|
1736 if (!pcrange->ranges_is_index)
|
|
|
1737 offset = pcrange->ranges;
|
|
|
1738 else
|
|
|
1739 offset = u->rnglists_base + pcrange->ranges * (u->is_dwarf64 ? 8 : 4);
|
|
|
1740 if (offset >= dwarf_sections->size[DEBUG_RNGLISTS])
|
|
|
1741 {
|
|
|
1742 error_callback (data, "rnglists offset out of range", 0);
|
|
|
1743 return 0;
|
|
|
1744 }
|
|
|
1745
|
|
|
1746 rnglists_buf.name = ".debug_rnglists";
|
|
|
1747 rnglists_buf.start = dwarf_sections->data[DEBUG_RNGLISTS];
|
|
|
1748 rnglists_buf.buf = dwarf_sections->data[DEBUG_RNGLISTS] + offset;
|
|
|
1749 rnglists_buf.left = dwarf_sections->size[DEBUG_RNGLISTS] - offset;
|
|
|
1750 rnglists_buf.is_bigendian = is_bigendian;
|
|
|
1751 rnglists_buf.error_callback = error_callback;
|
|
|
1752 rnglists_buf.data = data;
|
|
|
1753 rnglists_buf.reported_underflow = 0;
|
|
|
1754
|
|
|
1755 if (pcrange->ranges_is_index)
|
|
|
1756 {
|
|
|
1757 offset = read_offset (&rnglists_buf, u->is_dwarf64);
|
|
|
1758 offset += u->rnglists_base;
|
|
|
1759 if (offset >= dwarf_sections->size[DEBUG_RNGLISTS])
|
|
|
1760 {
|
|
|
1761 error_callback (data, "rnglists index offset out of range", 0);
|
|
|
1762 return 0;
|
|
|
1763 }
|
|
|
1764 rnglists_buf.buf = dwarf_sections->data[DEBUG_RNGLISTS] + offset;
|
|
|
1765 rnglists_buf.left = dwarf_sections->size[DEBUG_RNGLISTS] - offset;
|
|
|
1766 }
|
|
|
1767
|
|
|
1768 while (1)
|
|
|
1769 {
|
|
|
1770 unsigned char rle;
|
|
|
1771
|
|
|
1772 rle = read_byte (&rnglists_buf);
|
|
|
1773 if (rle == DW_RLE_end_of_list)
|
|
|
1774 break;
|
|
|
1775 switch (rle)
|
|
|
1776 {
|
|
|
1777 case DW_RLE_base_addressx:
|
|
|
1778 {
|
|
|
1779 uint64_t index;
|
|
|
1780
|
|
|
1781 index = read_uleb128 (&rnglists_buf);
|
|
|
1782 if (!resolve_addr_index (dwarf_sections, u->addr_base,
|
|
|
1783 u->addrsize, is_bigendian, index,
|
|
|
1784 error_callback, data, &base))
|
|
|
1785 return 0;
|
|
|
1786 }
|
|
|
1787 break;
|
|
|
1788
|
|
|
1789 case DW_RLE_startx_endx:
|
|
|
1790 {
|
|
|
1791 uint64_t index;
|
|
|
1792 uint64_t low;
|
|
|
1793 uint64_t high;
|
|
|
1794
|
|
|
1795 index = read_uleb128 (&rnglists_buf);
|
|
|
1796 if (!resolve_addr_index (dwarf_sections, u->addr_base,
|
|
|
1797 u->addrsize, is_bigendian, index,
|
|
|
1798 error_callback, data, &low))
|
|
|
1799 return 0;
|
|
|
1800 index = read_uleb128 (&rnglists_buf);
|
|
|
1801 if (!resolve_addr_index (dwarf_sections, u->addr_base,
|
|
|
1802 u->addrsize, is_bigendian, index,
|
|
|
1803 error_callback, data, &high))
|
|
|
1804 return 0;
|
|
|
1805 if (!add_range (state, rdata, low + base_address,
|
|
|
1806 high + base_address, error_callback, data,
|
|
|
1807 vec))
|
|
|
1808 return 0;
|
|
|
1809 }
|
|
|
1810 break;
|
|
|
1811
|
|
|
1812 case DW_RLE_startx_length:
|
|
|
1813 {
|
|
|
1814 uint64_t index;
|
|
|
1815 uint64_t low;
|
|
|
1816 uint64_t length;
|
|
|
1817
|
|
|
1818 index = read_uleb128 (&rnglists_buf);
|
|
|
1819 if (!resolve_addr_index (dwarf_sections, u->addr_base,
|
|
|
1820 u->addrsize, is_bigendian, index,
|
|
|
1821 error_callback, data, &low))
|
|
|
1822 return 0;
|
|
|
1823 length = read_uleb128 (&rnglists_buf);
|
|
|
1824 low += base_address;
|
|
|
1825 if (!add_range (state, rdata, low, low + length,
|
|
|
1826 error_callback, data, vec))
|
|
|
1827 return 0;
|
|
|
1828 }
|
|
|
1829 break;
|
|
|
1830
|
|
|
1831 case DW_RLE_offset_pair:
|
|
|
1832 {
|
|
|
1833 uint64_t low;
|
|
|
1834 uint64_t high;
|
|
|
1835
|
|
|
1836 low = read_uleb128 (&rnglists_buf);
|
|
|
1837 high = read_uleb128 (&rnglists_buf);
|
|
|
1838 if (!add_range (state, rdata, low + base + base_address,
|
|
|
1839 high + base + base_address,
|
|
|
1840 error_callback, data, vec))
|
|
|
1841 return 0;
|
|
|
1842 }
|
|
|
1843 break;
|
|
|
1844
|
|
|
1845 case DW_RLE_base_address:
|
|
|
1846 base = read_address (&rnglists_buf, u->addrsize);
|
|
|
1847 break;
|
|
|
1848
|
|
|
1849 case DW_RLE_start_end:
|
|
|
1850 {
|
|
|
1851 uint64_t low;
|
|
|
1852 uint64_t high;
|
|
|
1853
|
|
|
1854 low = read_address (&rnglists_buf, u->addrsize);
|
|
|
1855 high = read_address (&rnglists_buf, u->addrsize);
|
|
|
1856 if (!add_range (state, rdata, low + base_address,
|
|
|
1857 high + base_address, error_callback, data,
|
|
|
1858 vec))
|
|
|
1859 return 0;
|
|
|
1860 }
|
|
|
1861 break;
|
|
|
1862
|
|
|
1863 case DW_RLE_start_length:
|
|
|
1864 {
|
|
|
1865 uint64_t low;
|
|
|
1866 uint64_t length;
|
|
|
1867
|
|
|
1868 low = read_address (&rnglists_buf, u->addrsize);
|
|
|
1869 length = read_uleb128 (&rnglists_buf);
|
|
|
1870 low += base_address;
|
|
|
1871 if (!add_range (state, rdata, low, low + length,
|
|
|
1872 error_callback, data, vec))
|
|
|
1873 return 0;
|
|
|
1874 }
|
|
|
1875 break;
|
|
|
1876
|
|
|
1877 default:
|
|
|
1878 dwarf_buf_error (&rnglists_buf, "unrecognized DW_RLE value");
|
|
|
1879 return 0;
|
|
|
1880 }
|
|
|
1881 }
|
|
|
1882
|
|
|
1883 if (rnglists_buf.reported_underflow)
|
|
|
1884 return 0;
|
|
|
1885
|
|
|
1886 return 1;
|
|
|
1887 }
|
|
|
1888
|
|
|
1889 /* Call ADD_RANGE for each lowpc/highpc pair in PCRANGE. RDATA is
|
|
|
1890 passed to ADD_RANGE, and is either a struct unit * or a struct
|
|
|
1891 function *. VEC is the vector we are adding ranges to, and is
|
|
|
1892 either a struct unit_addrs_vector * or a struct function_vector *.
|
|
|
1893 Returns 1 on success, 0 on error. */
|
|
|
1894
|
|
|
1895 static int
|
|
|
1896 add_ranges (struct backtrace_state *state,
|
|
|
1897 const struct dwarf_sections *dwarf_sections,
|
|
|
1898 uintptr_t base_address, int is_bigendian,
|
|
|
1899 struct unit *u, uint64_t base, const struct pcrange *pcrange,
|
|
|
1900 int (*add_range) (struct backtrace_state *state, void *rdata,
|
|
|
1901 uint64_t lowpc, uint64_t highpc,
|
|
|
1902 backtrace_error_callback error_callback,
|
|
|
1903 void *data, void *vec),
|
|
|
1904 void *rdata,
|
|
|
1905 backtrace_error_callback error_callback, void *data,
|
|
|
1906 void *vec)
|
|
|
1907 {
|
|
|
1908 if (pcrange->have_lowpc && pcrange->have_highpc)
|
|
|
1909 return add_low_high_range (state, dwarf_sections, base_address,
|
|
|
1910 is_bigendian, u, pcrange, add_range, rdata,
|
|
|
1911 error_callback, data, vec);
|
|
|
1912
|
|
|
1913 if (!pcrange->have_ranges)
|
|
|
1914 {
|
|
|
1915 /* Did not find any address ranges to add. */
|
|
|
1916 return 1;
|
|
|
1917 }
|
|
|
1918
|
|
|
1919 if (u->version < 5)
|
|
|
1920 return add_ranges_from_ranges (state, dwarf_sections, base_address,
|
|
|
1921 is_bigendian, u, base, pcrange, add_range,
|
|
|
1922 rdata, error_callback, data, vec);
|
|
|
1923 else
|
|
|
1924 return add_ranges_from_rnglists (state, dwarf_sections, base_address,
|
|
|
1925 is_bigendian, u, base, pcrange, add_range,
|
|
|
1926 rdata, error_callback, data, vec);
|
|
|
1927 }
|
|
|
1928
|
|
111
|
1929 /* Find the address range covered by a compilation unit, reading from
|
|
|
1930 UNIT_BUF and adding values to U. Returns 1 if all data could be
|
|
|
1931 read, 0 if there is some error. */
|
|
|
1932
|
|
|
1933 static int
|
|
|
1934 find_address_ranges (struct backtrace_state *state, uintptr_t base_address,
|
|
|
1935 struct dwarf_buf *unit_buf,
|
|
145
|
1936 const struct dwarf_sections *dwarf_sections,
|
|
|
1937 int is_bigendian, struct dwarf_data *altlink,
|
|
|
1938 backtrace_error_callback error_callback, void *data,
|
|
|
1939 struct unit *u, struct unit_addrs_vector *addrs,
|
|
|
1940 enum dwarf_tag *unit_tag)
|
|
111
|
1941 {
|
|
|
1942 while (unit_buf->left > 0)
|
|
|
1943 {
|
|
|
1944 uint64_t code;
|
|
|
1945 const struct abbrev *abbrev;
|
|
145
|
1946 struct pcrange pcrange;
|
|
|
1947 struct attr_val name_val;
|
|
|
1948 int have_name_val;
|
|
|
1949 struct attr_val comp_dir_val;
|
|
|
1950 int have_comp_dir_val;
|
|
111
|
1951 size_t i;
|
|
|
1952
|
|
|
1953 code = read_uleb128 (unit_buf);
|
|
|
1954 if (code == 0)
|
|
|
1955 return 1;
|
|
|
1956
|
|
|
1957 abbrev = lookup_abbrev (&u->abbrevs, code, error_callback, data);
|
|
|
1958 if (abbrev == NULL)
|
|
|
1959 return 0;
|
|
|
1960
|
|
145
|
1961 if (unit_tag != NULL)
|
|
|
1962 *unit_tag = abbrev->tag;
|
|
|
1963
|
|
|
1964 memset (&pcrange, 0, sizeof pcrange);
|
|
|
1965 memset (&name_val, 0, sizeof name_val);
|
|
|
1966 have_name_val = 0;
|
|
|
1967 memset (&comp_dir_val, 0, sizeof comp_dir_val);
|
|
|
1968 have_comp_dir_val = 0;
|
|
111
|
1969 for (i = 0; i < abbrev->num_attrs; ++i)
|
|
|
1970 {
|
|
|
1971 struct attr_val val;
|
|
|
1972
|
|
145
|
1973 if (!read_attribute (abbrev->attrs[i].form, abbrev->attrs[i].val,
|
|
|
1974 unit_buf, u->is_dwarf64, u->version,
|
|
|
1975 u->addrsize, dwarf_sections, altlink, &val))
|
|
111
|
1976 return 0;
|
|
|
1977
|
|
|
1978 switch (abbrev->attrs[i].name)
|
|
|
1979 {
|
|
145
|
1980 case DW_AT_low_pc: case DW_AT_high_pc: case DW_AT_ranges:
|
|
|
1981 update_pcrange (&abbrev->attrs[i], &val, &pcrange);
|
|
111
|
1982 break;
|
|
|
1983
|
|
|
1984 case DW_AT_stmt_list:
|
|
|
1985 if (abbrev->tag == DW_TAG_compile_unit
|
|
|
1986 && (val.encoding == ATTR_VAL_UINT
|
|
|
1987 || val.encoding == ATTR_VAL_REF_SECTION))
|
|
|
1988 u->lineoff = val.u.uint;
|
|
|
1989 break;
|
|
|
1990
|
|
|
1991 case DW_AT_name:
|
|
145
|
1992 if (abbrev->tag == DW_TAG_compile_unit)
|
|
|
1993 {
|
|
|
1994 name_val = val;
|
|
|
1995 have_name_val = 1;
|
|
|
1996 }
|
|
111
|
1997 break;
|
|
|
1998
|
|
|
1999 case DW_AT_comp_dir:
|
|
145
|
2000 if (abbrev->tag == DW_TAG_compile_unit)
|
|
|
2001 {
|
|
|
2002 comp_dir_val = val;
|
|
|
2003 have_comp_dir_val = 1;
|
|
|
2004 }
|
|
|
2005 break;
|
|
|
2006
|
|
|
2007 case DW_AT_str_offsets_base:
|
|
111
|
2008 if (abbrev->tag == DW_TAG_compile_unit
|
|
145
|
2009 && val.encoding == ATTR_VAL_REF_SECTION)
|
|
|
2010 u->str_offsets_base = val.u.uint;
|
|
|
2011 break;
|
|
|
2012
|
|
|
2013 case DW_AT_addr_base:
|
|
|
2014 if (abbrev->tag == DW_TAG_compile_unit
|
|
|
2015 && val.encoding == ATTR_VAL_REF_SECTION)
|
|
|
2016 u->addr_base = val.u.uint;
|
|
|
2017 break;
|
|
|
2018
|
|
|
2019 case DW_AT_rnglists_base:
|
|
|
2020 if (abbrev->tag == DW_TAG_compile_unit
|
|
|
2021 && val.encoding == ATTR_VAL_REF_SECTION)
|
|
|
2022 u->rnglists_base = val.u.uint;
|
|
111
|
2023 break;
|
|
|
2024
|
|
|
2025 default:
|
|
|
2026 break;
|
|
|
2027 }
|
|
|
2028 }
|
|
|
2029
|
|
145
|
2030 // Resolve strings after we're sure that we have seen
|
|
|
2031 // DW_AT_str_offsets_base.
|
|
|
2032 if (have_name_val)
|
|
|
2033 {
|
|
|
2034 if (!resolve_string (dwarf_sections, u->is_dwarf64, is_bigendian,
|
|
|
2035 u->str_offsets_base, &name_val,
|
|
|
2036 error_callback, data, &u->filename))
|
|
|
2037 return 0;
|
|
|
2038 }
|
|
|
2039 if (have_comp_dir_val)
|
|
|
2040 {
|
|
|
2041 if (!resolve_string (dwarf_sections, u->is_dwarf64, is_bigendian,
|
|
|
2042 u->str_offsets_base, &comp_dir_val,
|
|
|
2043 error_callback, data, &u->comp_dir))
|
|
|
2044 return 0;
|
|
|
2045 }
|
|
|
2046
|
|
111
|
2047 if (abbrev->tag == DW_TAG_compile_unit
|
|
|
2048 || abbrev->tag == DW_TAG_subprogram)
|
|
|
2049 {
|
|
145
|
2050 if (!add_ranges (state, dwarf_sections, base_address,
|
|
|
2051 is_bigendian, u, pcrange.lowpc, &pcrange,
|
|
|
2052 add_unit_addr, (void *) u, error_callback, data,
|
|
|
2053 (void *) addrs))
|
|
|
2054 return 0;
|
|
111
|
2055
|
|
|
2056 /* If we found the PC range in the DW_TAG_compile_unit, we
|
|
|
2057 can stop now. */
|
|
|
2058 if (abbrev->tag == DW_TAG_compile_unit
|
|
145
|
2059 && (pcrange.have_ranges
|
|
|
2060 || (pcrange.have_lowpc && pcrange.have_highpc)))
|
|
111
|
2061 return 1;
|
|
|
2062 }
|
|
|
2063
|
|
|
2064 if (abbrev->has_children)
|
|
|
2065 {
|
|
|
2066 if (!find_address_ranges (state, base_address, unit_buf,
|
|
145
|
2067 dwarf_sections, is_bigendian, altlink,
|
|
|
2068 error_callback, data, u, addrs, NULL))
|
|
111
|
2069 return 0;
|
|
|
2070 }
|
|
|
2071 }
|
|
|
2072
|
|
|
2073 return 1;
|
|
|
2074 }
|
|
|
2075
|
|
|
2076 /* Build a mapping from address ranges to the compilation units where
|
|
|
2077 the line number information for that range can be found. Returns 1
|
|
|
2078 on success, 0 on failure. */
|
|
|
2079
|
|
|
2080 static int
|
|
|
2081 build_address_map (struct backtrace_state *state, uintptr_t base_address,
|
|
145
|
2082 const struct dwarf_sections *dwarf_sections,
|
|
|
2083 int is_bigendian, struct dwarf_data *altlink,
|
|
|
2084 backtrace_error_callback error_callback, void *data,
|
|
|
2085 struct unit_addrs_vector *addrs,
|
|
|
2086 struct unit_vector *unit_vec)
|
|
111
|
2087 {
|
|
|
2088 struct dwarf_buf info;
|
|
145
|
2089 struct backtrace_vector units;
|
|
|
2090 size_t units_count;
|
|
|
2091 size_t i;
|
|
|
2092 struct unit **pu;
|
|
|
2093 size_t unit_offset = 0;
|
|
111
|
2094
|
|
|
2095 memset (&addrs->vec, 0, sizeof addrs->vec);
|
|
145
|
2096 memset (&unit_vec->vec, 0, sizeof unit_vec->vec);
|
|
111
|
2097 addrs->count = 0;
|
|
145
|
2098 unit_vec->count = 0;
|
|
111
|
2099
|
|
|
2100 /* Read through the .debug_info section. FIXME: Should we use the
|
|
|
2101 .debug_aranges section? gdb and addr2line don't use it, but I'm
|
|
|
2102 not sure why. */
|
|
|
2103
|
|
|
2104 info.name = ".debug_info";
|
|
145
|
2105 info.start = dwarf_sections->data[DEBUG_INFO];
|
|
|
2106 info.buf = info.start;
|
|
|
2107 info.left = dwarf_sections->size[DEBUG_INFO];
|
|
111
|
2108 info.is_bigendian = is_bigendian;
|
|
|
2109 info.error_callback = error_callback;
|
|
|
2110 info.data = data;
|
|
|
2111 info.reported_underflow = 0;
|
|
|
2112
|
|
145
|
2113 memset (&units, 0, sizeof units);
|
|
|
2114 units_count = 0;
|
|
|
2115
|
|
111
|
2116 while (info.left > 0)
|
|
|
2117 {
|
|
|
2118 const unsigned char *unit_data_start;
|
|
|
2119 uint64_t len;
|
|
|
2120 int is_dwarf64;
|
|
|
2121 struct dwarf_buf unit_buf;
|
|
|
2122 int version;
|
|
145
|
2123 int unit_type;
|
|
111
|
2124 uint64_t abbrev_offset;
|
|
|
2125 int addrsize;
|
|
|
2126 struct unit *u;
|
|
145
|
2127 enum dwarf_tag unit_tag;
|
|
111
|
2128
|
|
|
2129 if (info.reported_underflow)
|
|
|
2130 goto fail;
|
|
|
2131
|
|
|
2132 unit_data_start = info.buf;
|
|
|
2133
|
|
145
|
2134 len = read_initial_length (&info, &is_dwarf64);
|
|
111
|
2135 unit_buf = info;
|
|
|
2136 unit_buf.left = len;
|
|
|
2137
|
|
|
2138 if (!advance (&info, len))
|
|
|
2139 goto fail;
|
|
|
2140
|
|
|
2141 version = read_uint16 (&unit_buf);
|
|
145
|
2142 if (version < 2 || version > 5)
|
|
111
|
2143 {
|
|
|
2144 dwarf_buf_error (&unit_buf, "unrecognized DWARF version");
|
|
|
2145 goto fail;
|
|
|
2146 }
|
|
|
2147
|
|
145
|
2148 if (version < 5)
|
|
|
2149 unit_type = 0;
|
|
|
2150 else
|
|
|
2151 {
|
|
|
2152 unit_type = read_byte (&unit_buf);
|
|
|
2153 if (unit_type == DW_UT_type || unit_type == DW_UT_split_type)
|
|
|
2154 {
|
|
|
2155 /* This unit doesn't have anything we need. */
|
|
|
2156 continue;
|
|
|
2157 }
|
|
|
2158 }
|
|
|
2159
|
|
|
2160 pu = ((struct unit **)
|
|
|
2161 backtrace_vector_grow (state, sizeof (struct unit *),
|
|
|
2162 error_callback, data, &units));
|
|
|
2163 if (pu == NULL)
|
|
|
2164 goto fail;
|
|
111
|
2165
|
|
|
2166 u = ((struct unit *)
|
|
|
2167 backtrace_alloc (state, sizeof *u, error_callback, data));
|
|
|
2168 if (u == NULL)
|
|
|
2169 goto fail;
|
|
145
|
2170
|
|
|
2171 *pu = u;
|
|
|
2172 ++units_count;
|
|
|
2173
|
|
|
2174 if (version < 5)
|
|
|
2175 addrsize = 0; /* Set below. */
|
|
|
2176 else
|
|
|
2177 addrsize = read_byte (&unit_buf);
|
|
|
2178
|
|
|
2179 memset (&u->abbrevs, 0, sizeof u->abbrevs);
|
|
|
2180 abbrev_offset = read_offset (&unit_buf, is_dwarf64);
|
|
|
2181 if (!read_abbrevs (state, abbrev_offset,
|
|
|
2182 dwarf_sections->data[DEBUG_ABBREV],
|
|
|
2183 dwarf_sections->size[DEBUG_ABBREV],
|
|
|
2184 is_bigendian, error_callback, data, &u->abbrevs))
|
|
|
2185 goto fail;
|
|
|
2186
|
|
|
2187 if (version < 5)
|
|
|
2188 addrsize = read_byte (&unit_buf);
|
|
|
2189
|
|
|
2190 switch (unit_type)
|
|
|
2191 {
|
|
|
2192 case 0:
|
|
|
2193 break;
|
|
|
2194 case DW_UT_compile: case DW_UT_partial:
|
|
|
2195 break;
|
|
|
2196 case DW_UT_skeleton: case DW_UT_split_compile:
|
|
|
2197 read_uint64 (&unit_buf); /* dwo_id */
|
|
|
2198 break;
|
|
|
2199 default:
|
|
|
2200 break;
|
|
|
2201 }
|
|
|
2202
|
|
|
2203 u->low_offset = unit_offset;
|
|
|
2204 unit_offset += len + (is_dwarf64 ? 12 : 4);
|
|
|
2205 u->high_offset = unit_offset;
|
|
111
|
2206 u->unit_data = unit_buf.buf;
|
|
|
2207 u->unit_data_len = unit_buf.left;
|
|
|
2208 u->unit_data_offset = unit_buf.buf - unit_data_start;
|
|
|
2209 u->version = version;
|
|
|
2210 u->is_dwarf64 = is_dwarf64;
|
|
|
2211 u->addrsize = addrsize;
|
|
|
2212 u->filename = NULL;
|
|
|
2213 u->comp_dir = NULL;
|
|
|
2214 u->abs_filename = NULL;
|
|
|
2215 u->lineoff = 0;
|
|
|
2216
|
|
|
2217 /* The actual line number mappings will be read as needed. */
|
|
|
2218 u->lines = NULL;
|
|
|
2219 u->lines_count = 0;
|
|
|
2220 u->function_addrs = NULL;
|
|
|
2221 u->function_addrs_count = 0;
|
|
|
2222
|
|
145
|
2223 if (!find_address_ranges (state, base_address, &unit_buf, dwarf_sections,
|
|
|
2224 is_bigendian, altlink, error_callback, data,
|
|
|
2225 u, addrs, &unit_tag))
|
|
|
2226 goto fail;
|
|
111
|
2227
|
|
|
2228 if (unit_buf.reported_underflow)
|
|
145
|
2229 goto fail;
|
|
111
|
2230 }
|
|
|
2231 if (info.reported_underflow)
|
|
|
2232 goto fail;
|
|
|
2233
|
|
145
|
2234 unit_vec->vec = units;
|
|
|
2235 unit_vec->count = units_count;
|
|
111
|
2236 return 1;
|
|
|
2237
|
|
|
2238 fail:
|
|
145
|
2239 if (units_count > 0)
|
|
|
2240 {
|
|
|
2241 pu = (struct unit **) units.base;
|
|
|
2242 for (i = 0; i < units_count; i++)
|
|
|
2243 {
|
|
|
2244 free_abbrevs (state, &pu[i]->abbrevs, error_callback, data);
|
|
|
2245 backtrace_free (state, pu[i], sizeof **pu, error_callback, data);
|
|
|
2246 }
|
|
|
2247 backtrace_vector_free (state, &units, error_callback, data);
|
|
|
2248 }
|
|
|
2249 if (addrs->count > 0)
|
|
|
2250 {
|
|
|
2251 backtrace_vector_free (state, &addrs->vec, error_callback, data);
|
|
|
2252 addrs->count = 0;
|
|
|
2253 }
|
|
111
|
2254 return 0;
|
|
|
2255 }
|
|
|
2256
|
|
|
2257 /* Add a new mapping to the vector of line mappings that we are
|
|
|
2258 building. Returns 1 on success, 0 on failure. */
|
|
|
2259
|
|
|
2260 static int
|
|
|
2261 add_line (struct backtrace_state *state, struct dwarf_data *ddata,
|
|
|
2262 uintptr_t pc, const char *filename, int lineno,
|
|
|
2263 backtrace_error_callback error_callback, void *data,
|
|
|
2264 struct line_vector *vec)
|
|
|
2265 {
|
|
|
2266 struct line *ln;
|
|
|
2267
|
|
|
2268 /* If we are adding the same mapping, ignore it. This can happen
|
|
|
2269 when using discriminators. */
|
|
|
2270 if (vec->count > 0)
|
|
|
2271 {
|
|
|
2272 ln = (struct line *) vec->vec.base + (vec->count - 1);
|
|
|
2273 if (pc == ln->pc && filename == ln->filename && lineno == ln->lineno)
|
|
|
2274 return 1;
|
|
|
2275 }
|
|
|
2276
|
|
|
2277 ln = ((struct line *)
|
|
|
2278 backtrace_vector_grow (state, sizeof (struct line), error_callback,
|
|
|
2279 data, &vec->vec));
|
|
|
2280 if (ln == NULL)
|
|
|
2281 return 0;
|
|
|
2282
|
|
|
2283 /* Add in the base address here, so that we can look up the PC
|
|
|
2284 directly. */
|
|
|
2285 ln->pc = pc + ddata->base_address;
|
|
|
2286
|
|
|
2287 ln->filename = filename;
|
|
|
2288 ln->lineno = lineno;
|
|
|
2289 ln->idx = vec->count;
|
|
|
2290
|
|
|
2291 ++vec->count;
|
|
|
2292
|
|
|
2293 return 1;
|
|
|
2294 }
|
|
|
2295
|
|
|
2296 /* Free the line header information. */
|
|
|
2297
|
|
|
2298 static void
|
|
|
2299 free_line_header (struct backtrace_state *state, struct line_header *hdr,
|
|
|
2300 backtrace_error_callback error_callback, void *data)
|
|
|
2301 {
|
|
|
2302 if (hdr->dirs_count != 0)
|
|
|
2303 backtrace_free (state, hdr->dirs, hdr->dirs_count * sizeof (const char *),
|
|
|
2304 error_callback, data);
|
|
|
2305 backtrace_free (state, hdr->filenames,
|
|
|
2306 hdr->filenames_count * sizeof (char *),
|
|
|
2307 error_callback, data);
|
|
|
2308 }
|
|
|
2309
|
|
145
|
2310 /* Read the directories and file names for a line header for version
|
|
|
2311 2, setting fields in HDR. Return 1 on success, 0 on failure. */
|
|
|
2312
|
|
|
2313 static int
|
|
|
2314 read_v2_paths (struct backtrace_state *state, struct unit *u,
|
|
|
2315 struct dwarf_buf *hdr_buf, struct line_header *hdr)
|
|
|
2316 {
|
|
|
2317 const unsigned char *p;
|
|
|
2318 const unsigned char *pend;
|
|
|
2319 size_t i;
|
|
|
2320
|
|
|
2321 /* Count the number of directory entries. */
|
|
|
2322 hdr->dirs_count = 0;
|
|
|
2323 p = hdr_buf->buf;
|
|
|
2324 pend = p + hdr_buf->left;
|
|
|
2325 while (p < pend && *p != '\0')
|
|
|
2326 {
|
|
|
2327 p += strnlen((const char *) p, pend - p) + 1;
|
|
|
2328 ++hdr->dirs_count;
|
|
|
2329 }
|
|
|
2330
|
|
|
2331 hdr->dirs = NULL;
|
|
|
2332 if (hdr->dirs_count != 0)
|
|
|
2333 {
|
|
|
2334 hdr->dirs = ((const char **)
|
|
|
2335 backtrace_alloc (state,
|
|
|
2336 hdr->dirs_count * sizeof (const char *),
|
|
|
2337 hdr_buf->error_callback,
|
|
|
2338 hdr_buf->data));
|
|
|
2339 if (hdr->dirs == NULL)
|
|
|
2340 return 0;
|
|
|
2341 }
|
|
|
2342
|
|
|
2343 i = 0;
|
|
|
2344 while (*hdr_buf->buf != '\0')
|
|
|
2345 {
|
|
|
2346 if (hdr_buf->reported_underflow)
|
|
|
2347 return 0;
|
|
|
2348
|
|
|
2349 hdr->dirs[i] = read_string (hdr_buf);
|
|
|
2350 if (hdr->dirs[i] == NULL)
|
|
|
2351 return 0;
|
|
|
2352 ++i;
|
|
|
2353 }
|
|
|
2354 if (!advance (hdr_buf, 1))
|
|
|
2355 return 0;
|
|
|
2356
|
|
|
2357 /* Count the number of file entries. */
|
|
|
2358 hdr->filenames_count = 0;
|
|
|
2359 p = hdr_buf->buf;
|
|
|
2360 pend = p + hdr_buf->left;
|
|
|
2361 while (p < pend && *p != '\0')
|
|
|
2362 {
|
|
|
2363 p += strnlen ((const char *) p, pend - p) + 1;
|
|
|
2364 p += leb128_len (p);
|
|
|
2365 p += leb128_len (p);
|
|
|
2366 p += leb128_len (p);
|
|
|
2367 ++hdr->filenames_count;
|
|
|
2368 }
|
|
|
2369
|
|
|
2370 hdr->filenames = ((const char **)
|
|
|
2371 backtrace_alloc (state,
|
|
|
2372 hdr->filenames_count * sizeof (char *),
|
|
|
2373 hdr_buf->error_callback,
|
|
|
2374 hdr_buf->data));
|
|
|
2375 if (hdr->filenames == NULL)
|
|
|
2376 return 0;
|
|
|
2377 i = 0;
|
|
|
2378 while (*hdr_buf->buf != '\0')
|
|
|
2379 {
|
|
|
2380 const char *filename;
|
|
|
2381 uint64_t dir_index;
|
|
|
2382
|
|
|
2383 if (hdr_buf->reported_underflow)
|
|
|
2384 return 0;
|
|
|
2385
|
|
|
2386 filename = read_string (hdr_buf);
|
|
|
2387 if (filename == NULL)
|
|
|
2388 return 0;
|
|
|
2389 dir_index = read_uleb128 (hdr_buf);
|
|
|
2390 if (IS_ABSOLUTE_PATH (filename)
|
|
|
2391 || (dir_index == 0 && u->comp_dir == NULL))
|
|
|
2392 hdr->filenames[i] = filename;
|
|
|
2393 else
|
|
|
2394 {
|
|
|
2395 const char *dir;
|
|
|
2396 size_t dir_len;
|
|
|
2397 size_t filename_len;
|
|
|
2398 char *s;
|
|
|
2399
|
|
|
2400 if (dir_index == 0)
|
|
|
2401 dir = u->comp_dir;
|
|
|
2402 else if (dir_index - 1 < hdr->dirs_count)
|
|
|
2403 dir = hdr->dirs[dir_index - 1];
|
|
|
2404 else
|
|
|
2405 {
|
|
|
2406 dwarf_buf_error (hdr_buf,
|
|
|
2407 ("invalid directory index in "
|
|
|
2408 "line number program header"));
|
|
|
2409 return 0;
|
|
|
2410 }
|
|
|
2411 dir_len = strlen (dir);
|
|
|
2412 filename_len = strlen (filename);
|
|
|
2413 s = ((char *) backtrace_alloc (state, dir_len + filename_len + 2,
|
|
|
2414 hdr_buf->error_callback,
|
|
|
2415 hdr_buf->data));
|
|
|
2416 if (s == NULL)
|
|
|
2417 return 0;
|
|
|
2418 memcpy (s, dir, dir_len);
|
|
|
2419 /* FIXME: If we are on a DOS-based file system, and the
|
|
|
2420 directory or the file name use backslashes, then we
|
|
|
2421 should use a backslash here. */
|
|
|
2422 s[dir_len] = '/';
|
|
|
2423 memcpy (s + dir_len + 1, filename, filename_len + 1);
|
|
|
2424 hdr->filenames[i] = s;
|
|
|
2425 }
|
|
|
2426
|
|
|
2427 /* Ignore the modification time and size. */
|
|
|
2428 read_uleb128 (hdr_buf);
|
|
|
2429 read_uleb128 (hdr_buf);
|
|
|
2430
|
|
|
2431 ++i;
|
|
|
2432 }
|
|
|
2433
|
|
|
2434 return 1;
|
|
|
2435 }
|
|
|
2436
|
|
|
2437 /* Read a single version 5 LNCT entry for a directory or file name in a
|
|
|
2438 line header. Sets *STRING to the resulting name, ignoring other
|
|
|
2439 data. Return 1 on success, 0 on failure. */
|
|
|
2440
|
|
|
2441 static int
|
|
|
2442 read_lnct (struct backtrace_state *state, struct dwarf_data *ddata,
|
|
|
2443 struct unit *u, struct dwarf_buf *hdr_buf,
|
|
|
2444 const struct line_header *hdr, size_t formats_count,
|
|
|
2445 const struct line_header_format *formats, const char **string)
|
|
|
2446 {
|
|
|
2447 size_t i;
|
|
|
2448 const char *dir;
|
|
|
2449 const char *path;
|
|
|
2450
|
|
|
2451 dir = NULL;
|
|
|
2452 path = NULL;
|
|
|
2453 for (i = 0; i < formats_count; i++)
|
|
|
2454 {
|
|
|
2455 struct attr_val val;
|
|
|
2456
|
|
|
2457 if (!read_attribute (formats[i].form, 0, hdr_buf, u->is_dwarf64,
|
|
|
2458 u->version, hdr->addrsize, &ddata->dwarf_sections,
|
|
|
2459 ddata->altlink, &val))
|
|
|
2460 return 0;
|
|
|
2461 switch (formats[i].lnct)
|
|
|
2462 {
|
|
|
2463 case DW_LNCT_path:
|
|
|
2464 if (!resolve_string (&ddata->dwarf_sections, u->is_dwarf64,
|
|
|
2465 ddata->is_bigendian, u->str_offsets_base,
|
|
|
2466 &val, hdr_buf->error_callback, hdr_buf->data,
|
|
|
2467 &path))
|
|
|
2468 return 0;
|
|
|
2469 break;
|
|
|
2470 case DW_LNCT_directory_index:
|
|
|
2471 if (val.encoding == ATTR_VAL_UINT)
|
|
|
2472 {
|
|
|
2473 if (val.u.uint >= hdr->dirs_count)
|
|
|
2474 {
|
|
|
2475 dwarf_buf_error (hdr_buf,
|
|
|
2476 ("invalid directory index in "
|
|
|
2477 "line number program header"));
|
|
|
2478 return 0;
|
|
|
2479 }
|
|
|
2480 dir = hdr->dirs[val.u.uint];
|
|
|
2481 }
|
|
|
2482 break;
|
|
|
2483 default:
|
|
|
2484 /* We don't care about timestamps or sizes or hashes. */
|
|
|
2485 break;
|
|
|
2486 }
|
|
|
2487 }
|
|
|
2488
|
|
|
2489 if (path == NULL)
|
|
|
2490 {
|
|
|
2491 dwarf_buf_error (hdr_buf,
|
|
|
2492 "missing file name in line number program header");
|
|
|
2493 return 0;
|
|
|
2494 }
|
|
|
2495
|
|
|
2496 if (dir == NULL)
|
|
|
2497 *string = path;
|
|
|
2498 else
|
|
|
2499 {
|
|
|
2500 size_t dir_len;
|
|
|
2501 size_t path_len;
|
|
|
2502 char *s;
|
|
|
2503
|
|
|
2504 dir_len = strlen (dir);
|
|
|
2505 path_len = strlen (path);
|
|
|
2506 s = (char *) backtrace_alloc (state, dir_len + path_len + 2,
|
|
|
2507 hdr_buf->error_callback, hdr_buf->data);
|
|
|
2508 if (s == NULL)
|
|
|
2509 return 0;
|
|
|
2510 memcpy (s, dir, dir_len);
|
|
|
2511 /* FIXME: If we are on a DOS-based file system, and the
|
|
|
2512 directory or the path name use backslashes, then we should
|
|
|
2513 use a backslash here. */
|
|
|
2514 s[dir_len] = '/';
|
|
|
2515 memcpy (s + dir_len + 1, path, path_len + 1);
|
|
|
2516 *string = s;
|
|
|
2517 }
|
|
|
2518
|
|
|
2519 return 1;
|
|
|
2520 }
|
|
|
2521
|
|
|
2522 /* Read a set of DWARF 5 line header format entries, setting *PCOUNT
|
|
|
2523 and *PPATHS. Return 1 on success, 0 on failure. */
|
|
|
2524
|
|
|
2525 static int
|
|
|
2526 read_line_header_format_entries (struct backtrace_state *state,
|
|
|
2527 struct dwarf_data *ddata,
|
|
|
2528 struct unit *u,
|
|
|
2529 struct dwarf_buf *hdr_buf,
|
|
|
2530 struct line_header *hdr,
|
|
|
2531 size_t *pcount,
|
|
|
2532 const char ***ppaths)
|
|
|
2533 {
|
|
|
2534 size_t formats_count;
|
|
|
2535 struct line_header_format *formats;
|
|
|
2536 size_t paths_count;
|
|
|
2537 const char **paths;
|
|
|
2538 size_t i;
|
|
|
2539 int ret;
|
|
|
2540
|
|
|
2541 formats_count = read_byte (hdr_buf);
|
|
|
2542 if (formats_count == 0)
|
|
|
2543 formats = NULL;
|
|
|
2544 else
|
|
|
2545 {
|
|
|
2546 formats = ((struct line_header_format *)
|
|
|
2547 backtrace_alloc (state,
|
|
|
2548 (formats_count
|
|
|
2549 * sizeof (struct line_header_format)),
|
|
|
2550 hdr_buf->error_callback,
|
|
|
2551 hdr_buf->data));
|
|
|
2552 if (formats == NULL)
|
|
|
2553 return 0;
|
|
|
2554
|
|
|
2555 for (i = 0; i < formats_count; i++)
|
|
|
2556 {
|
|
|
2557 formats[i].lnct = (int) read_uleb128(hdr_buf);
|
|
|
2558 formats[i].form = (enum dwarf_form) read_uleb128 (hdr_buf);
|
|
|
2559 }
|
|
|
2560 }
|
|
|
2561
|
|
|
2562 paths_count = read_uleb128 (hdr_buf);
|
|
|
2563 if (paths_count == 0)
|
|
|
2564 {
|
|
|
2565 *pcount = 0;
|
|
|
2566 *ppaths = NULL;
|
|
|
2567 ret = 1;
|
|
|
2568 goto exit;
|
|
|
2569 }
|
|
|
2570
|
|
|
2571 paths = ((const char **)
|
|
|
2572 backtrace_alloc (state, paths_count * sizeof (const char *),
|
|
|
2573 hdr_buf->error_callback, hdr_buf->data));
|
|
|
2574 if (paths == NULL)
|
|
|
2575 {
|
|
|
2576 ret = 0;
|
|
|
2577 goto exit;
|
|
|
2578 }
|
|
|
2579 for (i = 0; i < paths_count; i++)
|
|
|
2580 {
|
|
|
2581 if (!read_lnct (state, ddata, u, hdr_buf, hdr, formats_count,
|
|
|
2582 formats, &paths[i]))
|
|
|
2583 {
|
|
|
2584 backtrace_free (state, paths,
|
|
|
2585 paths_count * sizeof (const char *),
|
|
|
2586 hdr_buf->error_callback, hdr_buf->data);
|
|
|
2587 ret = 0;
|
|
|
2588 goto exit;
|
|
|
2589 }
|
|
|
2590 }
|
|
|
2591
|
|
|
2592 *pcount = paths_count;
|
|
|
2593 *ppaths = paths;
|
|
|
2594
|
|
|
2595 ret = 1;
|
|
|
2596
|
|
|
2597 exit:
|
|
|
2598 if (formats != NULL)
|
|
|
2599 backtrace_free (state, formats,
|
|
|
2600 formats_count * sizeof (struct line_header_format),
|
|
|
2601 hdr_buf->error_callback, hdr_buf->data);
|
|
|
2602
|
|
|
2603 return ret;
|
|
|
2604 }
|
|
|
2605
|
|
111
|
2606 /* Read the line header. Return 1 on success, 0 on failure. */
|
|
|
2607
|
|
|
2608 static int
|
|
145
|
2609 read_line_header (struct backtrace_state *state, struct dwarf_data *ddata,
|
|
|
2610 struct unit *u, int is_dwarf64, struct dwarf_buf *line_buf,
|
|
111
|
2611 struct line_header *hdr)
|
|
|
2612 {
|
|
|
2613 uint64_t hdrlen;
|
|
|
2614 struct dwarf_buf hdr_buf;
|
|
|
2615
|
|
|
2616 hdr->version = read_uint16 (line_buf);
|
|
145
|
2617 if (hdr->version < 2 || hdr->version > 5)
|
|
111
|
2618 {
|
|
|
2619 dwarf_buf_error (line_buf, "unsupported line number version");
|
|
|
2620 return 0;
|
|
|
2621 }
|
|
|
2622
|
|
145
|
2623 if (hdr->version < 5)
|
|
|
2624 hdr->addrsize = u->addrsize;
|
|
|
2625 else
|
|
|
2626 {
|
|
|
2627 hdr->addrsize = read_byte (line_buf);
|
|
|
2628 /* We could support a non-zero segment_selector_size but I doubt
|
|
|
2629 we'll ever see it. */
|
|
|
2630 if (read_byte (line_buf) != 0)
|
|
|
2631 {
|
|
|
2632 dwarf_buf_error (line_buf,
|
|
|
2633 "non-zero segment_selector_size not supported");
|
|
|
2634 return 0;
|
|
|
2635 }
|
|
|
2636 }
|
|
|
2637
|
|
111
|
2638 hdrlen = read_offset (line_buf, is_dwarf64);
|
|
|
2639
|
|
|
2640 hdr_buf = *line_buf;
|
|
|
2641 hdr_buf.left = hdrlen;
|
|
|
2642
|
|
|
2643 if (!advance (line_buf, hdrlen))
|
|
|
2644 return 0;
|
|
|
2645
|
|
|
2646 hdr->min_insn_len = read_byte (&hdr_buf);
|
|
|
2647 if (hdr->version < 4)
|
|
|
2648 hdr->max_ops_per_insn = 1;
|
|
|
2649 else
|
|
|
2650 hdr->max_ops_per_insn = read_byte (&hdr_buf);
|
|
|
2651
|
|
|
2652 /* We don't care about default_is_stmt. */
|
|
|
2653 read_byte (&hdr_buf);
|
|
|
2654
|
|
|
2655 hdr->line_base = read_sbyte (&hdr_buf);
|
|
|
2656 hdr->line_range = read_byte (&hdr_buf);
|
|
|
2657
|
|
|
2658 hdr->opcode_base = read_byte (&hdr_buf);
|
|
|
2659 hdr->opcode_lengths = hdr_buf.buf;
|
|
|
2660 if (!advance (&hdr_buf, hdr->opcode_base - 1))
|
|
|
2661 return 0;
|
|
|
2662
|
|
145
|
2663 if (hdr->version < 5)
|
|
111
|
2664 {
|
|
145
|
2665 if (!read_v2_paths (state, u, &hdr_buf, hdr))
|
|
111
|
2666 return 0;
|
|
|
2667 }
|
|
145
|
2668 else
|
|
111
|
2669 {
|
|
145
|
2670 if (!read_line_header_format_entries (state, ddata, u, &hdr_buf, hdr,
|
|
|
2671 &hdr->dirs_count,
|
|
|
2672 &hdr->dirs))
|
|
111
|
2673 return 0;
|
|
145
|
2674 if (!read_line_header_format_entries (state, ddata, u, &hdr_buf, hdr,
|
|
|
2675 &hdr->filenames_count,
|
|
|
2676 &hdr->filenames))
|
|
|
2677 return 0;
|
|
111
|
2678 }
|
|
|
2679
|
|
|
2680 if (hdr_buf.reported_underflow)
|
|
|
2681 return 0;
|
|
|
2682
|
|
|
2683 return 1;
|
|
|
2684 }
|
|
|
2685
|
|
|
2686 /* Read the line program, adding line mappings to VEC. Return 1 on
|
|
|
2687 success, 0 on failure. */
|
|
|
2688
|
|
|
2689 static int
|
|
|
2690 read_line_program (struct backtrace_state *state, struct dwarf_data *ddata,
|
|
|
2691 struct unit *u, const struct line_header *hdr,
|
|
|
2692 struct dwarf_buf *line_buf, struct line_vector *vec)
|
|
|
2693 {
|
|
|
2694 uint64_t address;
|
|
|
2695 unsigned int op_index;
|
|
|
2696 const char *reset_filename;
|
|
|
2697 const char *filename;
|
|
|
2698 int lineno;
|
|
|
2699
|
|
|
2700 address = 0;
|
|
|
2701 op_index = 0;
|
|
|
2702 if (hdr->filenames_count > 0)
|
|
|
2703 reset_filename = hdr->filenames[0];
|
|
|
2704 else
|
|
|
2705 reset_filename = "";
|
|
|
2706 filename = reset_filename;
|
|
|
2707 lineno = 1;
|
|
|
2708 while (line_buf->left > 0)
|
|
|
2709 {
|
|
|
2710 unsigned int op;
|
|
|
2711
|
|
|
2712 op = read_byte (line_buf);
|
|
|
2713 if (op >= hdr->opcode_base)
|
|
|
2714 {
|
|
|
2715 unsigned int advance;
|
|
|
2716
|
|
|
2717 /* Special opcode. */
|
|
|
2718 op -= hdr->opcode_base;
|
|
|
2719 advance = op / hdr->line_range;
|
|
|
2720 address += (hdr->min_insn_len * (op_index + advance)
|
|
|
2721 / hdr->max_ops_per_insn);
|
|
|
2722 op_index = (op_index + advance) % hdr->max_ops_per_insn;
|
|
|
2723 lineno += hdr->line_base + (int) (op % hdr->line_range);
|
|
|
2724 add_line (state, ddata, address, filename, lineno,
|
|
|
2725 line_buf->error_callback, line_buf->data, vec);
|
|
|
2726 }
|
|
|
2727 else if (op == DW_LNS_extended_op)
|
|
|
2728 {
|
|
|
2729 uint64_t len;
|
|
|
2730
|
|
|
2731 len = read_uleb128 (line_buf);
|
|
|
2732 op = read_byte (line_buf);
|
|
|
2733 switch (op)
|
|
|
2734 {
|
|
|
2735 case DW_LNE_end_sequence:
|
|
|
2736 /* FIXME: Should we mark the high PC here? It seems
|
|
|
2737 that we already have that information from the
|
|
|
2738 compilation unit. */
|
|
|
2739 address = 0;
|
|
|
2740 op_index = 0;
|
|
|
2741 filename = reset_filename;
|
|
|
2742 lineno = 1;
|
|
|
2743 break;
|
|
|
2744 case DW_LNE_set_address:
|
|
145
|
2745 address = read_address (line_buf, hdr->addrsize);
|
|
111
|
2746 break;
|
|
|
2747 case DW_LNE_define_file:
|
|
|
2748 {
|
|
|
2749 const char *f;
|
|
|
2750 unsigned int dir_index;
|
|
|
2751
|
|
145
|
2752 f = read_string (line_buf);
|
|
|
2753 if (f == NULL)
|
|
111
|
2754 return 0;
|
|
|
2755 dir_index = read_uleb128 (line_buf);
|
|
|
2756 /* Ignore that time and length. */
|
|
|
2757 read_uleb128 (line_buf);
|
|
|
2758 read_uleb128 (line_buf);
|
|
|
2759 if (IS_ABSOLUTE_PATH (f))
|
|
|
2760 filename = f;
|
|
|
2761 else
|
|
|
2762 {
|
|
|
2763 const char *dir;
|
|
|
2764 size_t dir_len;
|
|
|
2765 size_t f_len;
|
|
|
2766 char *p;
|
|
|
2767
|
|
145
|
2768 if (dir_index == 0 && hdr->version < 5)
|
|
111
|
2769 dir = u->comp_dir;
|
|
|
2770 else if (dir_index - 1 < hdr->dirs_count)
|
|
|
2771 dir = hdr->dirs[dir_index - 1];
|
|
|
2772 else
|
|
|
2773 {
|
|
|
2774 dwarf_buf_error (line_buf,
|
|
|
2775 ("invalid directory index "
|
|
|
2776 "in line number program"));
|
|
|
2777 return 0;
|
|
|
2778 }
|
|
|
2779 dir_len = strlen (dir);
|
|
|
2780 f_len = strlen (f);
|
|
|
2781 p = ((char *)
|
|
|
2782 backtrace_alloc (state, dir_len + f_len + 2,
|
|
|
2783 line_buf->error_callback,
|
|
|
2784 line_buf->data));
|
|
|
2785 if (p == NULL)
|
|
|
2786 return 0;
|
|
|
2787 memcpy (p, dir, dir_len);
|
|
|
2788 /* FIXME: If we are on a DOS-based file system,
|
|
|
2789 and the directory or the file name use
|
|
|
2790 backslashes, then we should use a backslash
|
|
|
2791 here. */
|
|
|
2792 p[dir_len] = '/';
|
|
|
2793 memcpy (p + dir_len + 1, f, f_len + 1);
|
|
|
2794 filename = p;
|
|
|
2795 }
|
|
|
2796 }
|
|
|
2797 break;
|
|
|
2798 case DW_LNE_set_discriminator:
|
|
|
2799 /* We don't care about discriminators. */
|
|
|
2800 read_uleb128 (line_buf);
|
|
|
2801 break;
|
|
|
2802 default:
|
|
|
2803 if (!advance (line_buf, len - 1))
|
|
|
2804 return 0;
|
|
|
2805 break;
|
|
|
2806 }
|
|
|
2807 }
|
|
|
2808 else
|
|
|
2809 {
|
|
|
2810 switch (op)
|
|
|
2811 {
|
|
|
2812 case DW_LNS_copy:
|
|
|
2813 add_line (state, ddata, address, filename, lineno,
|
|
|
2814 line_buf->error_callback, line_buf->data, vec);
|
|
|
2815 break;
|
|
|
2816 case DW_LNS_advance_pc:
|
|
|
2817 {
|
|
|
2818 uint64_t advance;
|
|
|
2819
|
|
|
2820 advance = read_uleb128 (line_buf);
|
|
|
2821 address += (hdr->min_insn_len * (op_index + advance)
|
|
|
2822 / hdr->max_ops_per_insn);
|
|
|
2823 op_index = (op_index + advance) % hdr->max_ops_per_insn;
|
|
|
2824 }
|
|
|
2825 break;
|
|
|
2826 case DW_LNS_advance_line:
|
|
|
2827 lineno += (int) read_sleb128 (line_buf);
|
|
|
2828 break;
|
|
|
2829 case DW_LNS_set_file:
|
|
|
2830 {
|
|
|
2831 uint64_t fileno;
|
|
|
2832
|
|
|
2833 fileno = read_uleb128 (line_buf);
|
|
|
2834 if (fileno == 0)
|
|
|
2835 filename = "";
|
|
|
2836 else
|
|
|
2837 {
|
|
|
2838 if (fileno - 1 >= hdr->filenames_count)
|
|
|
2839 {
|
|
|
2840 dwarf_buf_error (line_buf,
|
|
|
2841 ("invalid file number in "
|
|
|
2842 "line number program"));
|
|
|
2843 return 0;
|
|
|
2844 }
|
|
|
2845 filename = hdr->filenames[fileno - 1];
|
|
|
2846 }
|
|
|
2847 }
|
|
|
2848 break;
|
|
|
2849 case DW_LNS_set_column:
|
|
|
2850 read_uleb128 (line_buf);
|
|
|
2851 break;
|
|
|
2852 case DW_LNS_negate_stmt:
|
|
|
2853 break;
|
|
|
2854 case DW_LNS_set_basic_block:
|
|
|
2855 break;
|
|
|
2856 case DW_LNS_const_add_pc:
|
|
|
2857 {
|
|
|
2858 unsigned int advance;
|
|
|
2859
|
|
|
2860 op = 255 - hdr->opcode_base;
|
|
|
2861 advance = op / hdr->line_range;
|
|
|
2862 address += (hdr->min_insn_len * (op_index + advance)
|
|
|
2863 / hdr->max_ops_per_insn);
|
|
|
2864 op_index = (op_index + advance) % hdr->max_ops_per_insn;
|
|
|
2865 }
|
|
|
2866 break;
|
|
|
2867 case DW_LNS_fixed_advance_pc:
|
|
|
2868 address += read_uint16 (line_buf);
|
|
|
2869 op_index = 0;
|
|
|
2870 break;
|
|
|
2871 case DW_LNS_set_prologue_end:
|
|
|
2872 break;
|
|
|
2873 case DW_LNS_set_epilogue_begin:
|
|
|
2874 break;
|
|
|
2875 case DW_LNS_set_isa:
|
|
|
2876 read_uleb128 (line_buf);
|
|
|
2877 break;
|
|
|
2878 default:
|
|
|
2879 {
|
|
|
2880 unsigned int i;
|
|
|
2881
|
|
|
2882 for (i = hdr->opcode_lengths[op - 1]; i > 0; --i)
|
|
|
2883 read_uleb128 (line_buf);
|
|
|
2884 }
|
|
|
2885 break;
|
|
|
2886 }
|
|
|
2887 }
|
|
|
2888 }
|
|
|
2889
|
|
|
2890 return 1;
|
|
|
2891 }
|
|
|
2892
|
|
|
2893 /* Read the line number information for a compilation unit. Returns 1
|
|
|
2894 on success, 0 on failure. */
|
|
|
2895
|
|
|
2896 static int
|
|
|
2897 read_line_info (struct backtrace_state *state, struct dwarf_data *ddata,
|
|
|
2898 backtrace_error_callback error_callback, void *data,
|
|
|
2899 struct unit *u, struct line_header *hdr, struct line **lines,
|
|
|
2900 size_t *lines_count)
|
|
|
2901 {
|
|
|
2902 struct line_vector vec;
|
|
|
2903 struct dwarf_buf line_buf;
|
|
|
2904 uint64_t len;
|
|
|
2905 int is_dwarf64;
|
|
|
2906 struct line *ln;
|
|
|
2907
|
|
|
2908 memset (&vec.vec, 0, sizeof vec.vec);
|
|
|
2909 vec.count = 0;
|
|
|
2910
|
|
|
2911 memset (hdr, 0, sizeof *hdr);
|
|
|
2912
|
|
|
2913 if (u->lineoff != (off_t) (size_t) u->lineoff
|
|
145
|
2914 || (size_t) u->lineoff >= ddata->dwarf_sections.size[DEBUG_LINE])
|
|
111
|
2915 {
|
|
|
2916 error_callback (data, "unit line offset out of range", 0);
|
|
|
2917 goto fail;
|
|
|
2918 }
|
|
|
2919
|
|
|
2920 line_buf.name = ".debug_line";
|
|
145
|
2921 line_buf.start = ddata->dwarf_sections.data[DEBUG_LINE];
|
|
|
2922 line_buf.buf = ddata->dwarf_sections.data[DEBUG_LINE] + u->lineoff;
|
|
|
2923 line_buf.left = ddata->dwarf_sections.size[DEBUG_LINE] - u->lineoff;
|
|
111
|
2924 line_buf.is_bigendian = ddata->is_bigendian;
|
|
|
2925 line_buf.error_callback = error_callback;
|
|
|
2926 line_buf.data = data;
|
|
|
2927 line_buf.reported_underflow = 0;
|
|
|
2928
|
|
145
|
2929 len = read_initial_length (&line_buf, &is_dwarf64);
|
|
111
|
2930 line_buf.left = len;
|
|
|
2931
|
|
145
|
2932 if (!read_line_header (state, ddata, u, is_dwarf64, &line_buf, hdr))
|
|
111
|
2933 goto fail;
|
|
|
2934
|
|
|
2935 if (!read_line_program (state, ddata, u, hdr, &line_buf, &vec))
|
|
|
2936 goto fail;
|
|
|
2937
|
|
|
2938 if (line_buf.reported_underflow)
|
|
|
2939 goto fail;
|
|
|
2940
|
|
|
2941 if (vec.count == 0)
|
|
|
2942 {
|
|
|
2943 /* This is not a failure in the sense of a generating an error,
|
|
|
2944 but it is a failure in that sense that we have no useful
|
|
|
2945 information. */
|
|
|
2946 goto fail;
|
|
|
2947 }
|
|
|
2948
|
|
|
2949 /* Allocate one extra entry at the end. */
|
|
|
2950 ln = ((struct line *)
|
|
|
2951 backtrace_vector_grow (state, sizeof (struct line), error_callback,
|
|
|
2952 data, &vec.vec));
|
|
|
2953 if (ln == NULL)
|
|
|
2954 goto fail;
|
|
|
2955 ln->pc = (uintptr_t) -1;
|
|
|
2956 ln->filename = NULL;
|
|
|
2957 ln->lineno = 0;
|
|
|
2958 ln->idx = 0;
|
|
|
2959
|
|
|
2960 if (!backtrace_vector_release (state, &vec.vec, error_callback, data))
|
|
|
2961 goto fail;
|
|
|
2962
|
|
|
2963 ln = (struct line *) vec.vec.base;
|
|
|
2964 backtrace_qsort (ln, vec.count, sizeof (struct line), line_compare);
|
|
|
2965
|
|
|
2966 *lines = ln;
|
|
|
2967 *lines_count = vec.count;
|
|
|
2968
|
|
|
2969 return 1;
|
|
|
2970
|
|
|
2971 fail:
|
|
145
|
2972 backtrace_vector_free (state, &vec.vec, error_callback, data);
|
|
111
|
2973 free_line_header (state, hdr, error_callback, data);
|
|
|
2974 *lines = (struct line *) (uintptr_t) -1;
|
|
|
2975 *lines_count = 0;
|
|
|
2976 return 0;
|
|
|
2977 }
|
|
|
2978
|
|
145
|
2979 static const char *read_referenced_name (struct dwarf_data *, struct unit *,
|
|
|
2980 uint64_t, backtrace_error_callback,
|
|
|
2981 void *);
|
|
|
2982
|
|
|
2983 /* Read the name of a function from a DIE referenced by ATTR with VAL. */
|
|
|
2984
|
|
|
2985 static const char *
|
|
|
2986 read_referenced_name_from_attr (struct dwarf_data *ddata, struct unit *u,
|
|
|
2987 struct attr *attr, struct attr_val *val,
|
|
|
2988 backtrace_error_callback error_callback,
|
|
|
2989 void *data)
|
|
|
2990 {
|
|
|
2991 switch (attr->name)
|
|
|
2992 {
|
|
|
2993 case DW_AT_abstract_origin:
|
|
|
2994 case DW_AT_specification:
|
|
|
2995 break;
|
|
|
2996 default:
|
|
|
2997 return NULL;
|
|
|
2998 }
|
|
|
2999
|
|
|
3000 if (attr->form == DW_FORM_ref_sig8)
|
|
|
3001 return NULL;
|
|
|
3002
|
|
|
3003 if (val->encoding == ATTR_VAL_REF_INFO)
|
|
|
3004 {
|
|
|
3005 struct unit *unit
|
|
|
3006 = find_unit (ddata->units, ddata->units_count,
|
|
|
3007 val->u.uint);
|
|
|
3008 if (unit == NULL)
|
|
|
3009 return NULL;
|
|
|
3010
|
|
|
3011 uint64_t offset = val->u.uint - unit->low_offset;
|
|
|
3012 return read_referenced_name (ddata, unit, offset, error_callback, data);
|
|
|
3013 }
|
|
|
3014
|
|
|
3015 if (val->encoding == ATTR_VAL_UINT
|
|
|
3016 || val->encoding == ATTR_VAL_REF_UNIT)
|
|
|
3017 return read_referenced_name (ddata, u, val->u.uint, error_callback, data);
|
|
|
3018
|
|
|
3019 if (val->encoding == ATTR_VAL_REF_ALT_INFO)
|
|
|
3020 {
|
|
|
3021 struct unit *alt_unit
|
|
|
3022 = find_unit (ddata->altlink->units, ddata->altlink->units_count,
|
|
|
3023 val->u.uint);
|
|
|
3024 if (alt_unit == NULL)
|
|
|
3025 return NULL;
|
|
|
3026
|
|
|
3027 uint64_t offset = val->u.uint - alt_unit->low_offset;
|
|
|
3028 return read_referenced_name (ddata->altlink, alt_unit, offset,
|
|
|
3029 error_callback, data);
|
|
|
3030 }
|
|
|
3031
|
|
|
3032 return NULL;
|
|
|
3033 }
|
|
|
3034
|
|
111
|
3035 /* Read the name of a function from a DIE referenced by a
|
|
|
3036 DW_AT_abstract_origin or DW_AT_specification tag. OFFSET is within
|
|
|
3037 the same compilation unit. */
|
|
|
3038
|
|
|
3039 static const char *
|
|
|
3040 read_referenced_name (struct dwarf_data *ddata, struct unit *u,
|
|
|
3041 uint64_t offset, backtrace_error_callback error_callback,
|
|
|
3042 void *data)
|
|
|
3043 {
|
|
|
3044 struct dwarf_buf unit_buf;
|
|
|
3045 uint64_t code;
|
|
|
3046 const struct abbrev *abbrev;
|
|
|
3047 const char *ret;
|
|
|
3048 size_t i;
|
|
|
3049
|
|
|
3050 /* OFFSET is from the start of the data for this compilation unit.
|
|
|
3051 U->unit_data is the data, but it starts U->unit_data_offset bytes
|
|
|
3052 from the beginning. */
|
|
|
3053
|
|
|
3054 if (offset < u->unit_data_offset
|
|
|
3055 || offset - u->unit_data_offset >= u->unit_data_len)
|
|
|
3056 {
|
|
|
3057 error_callback (data,
|
|
|
3058 "abstract origin or specification out of range",
|
|
|
3059 0);
|
|
|
3060 return NULL;
|
|
|
3061 }
|
|
|
3062
|
|
|
3063 offset -= u->unit_data_offset;
|
|
|
3064
|
|
|
3065 unit_buf.name = ".debug_info";
|
|
145
|
3066 unit_buf.start = ddata->dwarf_sections.data[DEBUG_INFO];
|
|
111
|
3067 unit_buf.buf = u->unit_data + offset;
|
|
|
3068 unit_buf.left = u->unit_data_len - offset;
|
|
|
3069 unit_buf.is_bigendian = ddata->is_bigendian;
|
|
|
3070 unit_buf.error_callback = error_callback;
|
|
|
3071 unit_buf.data = data;
|
|
|
3072 unit_buf.reported_underflow = 0;
|
|
|
3073
|
|
|
3074 code = read_uleb128 (&unit_buf);
|
|
|
3075 if (code == 0)
|
|
|
3076 {
|
|
|
3077 dwarf_buf_error (&unit_buf, "invalid abstract origin or specification");
|
|
|
3078 return NULL;
|
|
|
3079 }
|
|
|
3080
|
|
|
3081 abbrev = lookup_abbrev (&u->abbrevs, code, error_callback, data);
|
|
|
3082 if (abbrev == NULL)
|
|
|
3083 return NULL;
|
|
|
3084
|
|
|
3085 ret = NULL;
|
|
|
3086 for (i = 0; i < abbrev->num_attrs; ++i)
|
|
|
3087 {
|
|
|
3088 struct attr_val val;
|
|
|
3089
|
|
145
|
3090 if (!read_attribute (abbrev->attrs[i].form, abbrev->attrs[i].val,
|
|
|
3091 &unit_buf, u->is_dwarf64, u->version, u->addrsize,
|
|
|
3092 &ddata->dwarf_sections, ddata->altlink, &val))
|
|
111
|
3093 return NULL;
|
|
|
3094
|
|
|
3095 switch (abbrev->attrs[i].name)
|
|
|
3096 {
|
|
|
3097 case DW_AT_name:
|
|
145
|
3098 /* Third name preference: don't override. A name we found in some
|
|
|
3099 other way, will normally be more useful -- e.g., this name is
|
|
|
3100 normally not mangled. */
|
|
|
3101 if (ret != NULL)
|
|
|
3102 break;
|
|
|
3103 if (!resolve_string (&ddata->dwarf_sections, u->is_dwarf64,
|
|
|
3104 ddata->is_bigendian, u->str_offsets_base,
|
|
|
3105 &val, error_callback, data, &ret))
|
|
|
3106 return NULL;
|
|
111
|
3107 break;
|
|
|
3108
|
|
|
3109 case DW_AT_linkage_name:
|
|
|
3110 case DW_AT_MIPS_linkage_name:
|
|
145
|
3111 /* First name preference: override all. */
|
|
|
3112 {
|
|
|
3113 const char *s;
|
|
|
3114
|
|
|
3115 s = NULL;
|
|
|
3116 if (!resolve_string (&ddata->dwarf_sections, u->is_dwarf64,
|
|
|
3117 ddata->is_bigendian, u->str_offsets_base,
|
|
|
3118 &val, error_callback, data, &s))
|
|
|
3119 return NULL;
|
|
|
3120 if (s != NULL)
|
|
|
3121 return s;
|
|
|
3122 }
|
|
111
|
3123 break;
|
|
|
3124
|
|
|
3125 case DW_AT_specification:
|
|
145
|
3126 /* Second name preference: override DW_AT_name, don't override
|
|
|
3127 DW_AT_linkage_name. */
|
|
|
3128 {
|
|
|
3129 const char *name;
|
|
|
3130
|
|
|
3131 name = read_referenced_name_from_attr (ddata, u, &abbrev->attrs[i],
|
|
|
3132 &val, error_callback, data);
|
|
|
3133 if (name != NULL)
|
|
|
3134 ret = name;
|
|
|
3135 }
|
|
111
|
3136 break;
|
|
|
3137
|
|
|
3138 default:
|
|
|
3139 break;
|
|
|
3140 }
|
|
|
3141 }
|
|
|
3142
|
|
|
3143 return ret;
|
|
|
3144 }
|
|
|
3145
|
|
145
|
3146 /* Add a range to a unit that maps to a function. This is called via
|
|
|
3147 add_ranges. Returns 1 on success, 0 on error. */
|
|
111
|
3148
|
|
|
3149 static int
|
|
145
|
3150 add_function_range (struct backtrace_state *state, void *rdata,
|
|
|
3151 uint64_t lowpc, uint64_t highpc,
|
|
|
3152 backtrace_error_callback error_callback, void *data,
|
|
|
3153 void *pvec)
|
|
111
|
3154 {
|
|
145
|
3155 struct function *function = (struct function *) rdata;
|
|
|
3156 struct function_vector *vec = (struct function_vector *) pvec;
|
|
111
|
3157 struct function_addrs *p;
|
|
|
3158
|
|
|
3159 if (vec->count > 0)
|
|
|
3160 {
|
|
145
|
3161 p = (struct function_addrs *) vec->vec.base + (vec->count - 1);
|
|
111
|
3162 if ((lowpc == p->high || lowpc == p->high + 1)
|
|
|
3163 && function == p->function)
|
|
|
3164 {
|
|
|
3165 if (highpc > p->high)
|
|
|
3166 p->high = highpc;
|
|
|
3167 return 1;
|
|
|
3168 }
|
|
|
3169 }
|
|
|
3170
|
|
|
3171 p = ((struct function_addrs *)
|
|
|
3172 backtrace_vector_grow (state, sizeof (struct function_addrs),
|
|
|
3173 error_callback, data, &vec->vec));
|
|
|
3174 if (p == NULL)
|
|
|
3175 return 0;
|
|
|
3176
|
|
|
3177 p->low = lowpc;
|
|
|
3178 p->high = highpc;
|
|
|
3179 p->function = function;
|
|
145
|
3180
|
|
111
|
3181 ++vec->count;
|
|
|
3182
|
|
|
3183 return 1;
|
|
|
3184 }
|
|
|
3185
|
|
|
3186 /* Read one entry plus all its children. Add function addresses to
|
|
|
3187 VEC. Returns 1 on success, 0 on error. */
|
|
|
3188
|
|
|
3189 static int
|
|
|
3190 read_function_entry (struct backtrace_state *state, struct dwarf_data *ddata,
|
|
|
3191 struct unit *u, uint64_t base, struct dwarf_buf *unit_buf,
|
|
|
3192 const struct line_header *lhdr,
|
|
|
3193 backtrace_error_callback error_callback, void *data,
|
|
|
3194 struct function_vector *vec_function,
|
|
|
3195 struct function_vector *vec_inlined)
|
|
|
3196 {
|
|
|
3197 while (unit_buf->left > 0)
|
|
|
3198 {
|
|
|
3199 uint64_t code;
|
|
|
3200 const struct abbrev *abbrev;
|
|
|
3201 int is_function;
|
|
|
3202 struct function *function;
|
|
|
3203 struct function_vector *vec;
|
|
|
3204 size_t i;
|
|
145
|
3205 struct pcrange pcrange;
|
|
|
3206 int have_linkage_name;
|
|
111
|
3207
|
|
|
3208 code = read_uleb128 (unit_buf);
|
|
|
3209 if (code == 0)
|
|
|
3210 return 1;
|
|
|
3211
|
|
|
3212 abbrev = lookup_abbrev (&u->abbrevs, code, error_callback, data);
|
|
|
3213 if (abbrev == NULL)
|
|
|
3214 return 0;
|
|
|
3215
|
|
|
3216 is_function = (abbrev->tag == DW_TAG_subprogram
|
|
|
3217 || abbrev->tag == DW_TAG_entry_point
|
|
|
3218 || abbrev->tag == DW_TAG_inlined_subroutine);
|
|
|
3219
|
|
|
3220 if (abbrev->tag == DW_TAG_inlined_subroutine)
|
|
|
3221 vec = vec_inlined;
|
|
|
3222 else
|
|
|
3223 vec = vec_function;
|
|
|
3224
|
|
|
3225 function = NULL;
|
|
|
3226 if (is_function)
|
|
|
3227 {
|
|
|
3228 function = ((struct function *)
|
|
|
3229 backtrace_alloc (state, sizeof *function,
|
|
|
3230 error_callback, data));
|
|
|
3231 if (function == NULL)
|
|
|
3232 return 0;
|
|
|
3233 memset (function, 0, sizeof *function);
|
|
|
3234 }
|
|
|
3235
|
|
145
|
3236 memset (&pcrange, 0, sizeof pcrange);
|
|
|
3237 have_linkage_name = 0;
|
|
111
|
3238 for (i = 0; i < abbrev->num_attrs; ++i)
|
|
|
3239 {
|
|
|
3240 struct attr_val val;
|
|
|
3241
|
|
145
|
3242 if (!read_attribute (abbrev->attrs[i].form, abbrev->attrs[i].val,
|
|
|
3243 unit_buf, u->is_dwarf64, u->version,
|
|
|
3244 u->addrsize, &ddata->dwarf_sections,
|
|
|
3245 ddata->altlink, &val))
|
|
111
|
3246 return 0;
|
|
|
3247
|
|
|
3248 /* The compile unit sets the base address for any address
|
|
|
3249 ranges in the function entries. */
|
|
|
3250 if (abbrev->tag == DW_TAG_compile_unit
|
|
145
|
3251 && abbrev->attrs[i].name == DW_AT_low_pc)
|
|
|
3252 {
|
|
|
3253 if (val.encoding == ATTR_VAL_ADDRESS)
|
|
|
3254 base = val.u.uint;
|
|
|
3255 else if (val.encoding == ATTR_VAL_ADDRESS_INDEX)
|
|
|
3256 {
|
|
|
3257 if (!resolve_addr_index (&ddata->dwarf_sections,
|
|
|
3258 u->addr_base, u->addrsize,
|
|
|
3259 ddata->is_bigendian, val.u.uint,
|
|
|
3260 error_callback, data, &base))
|
|
|
3261 return 0;
|
|
|
3262 }
|
|
|
3263 }
|
|
111
|
3264
|
|
|
3265 if (is_function)
|
|
|
3266 {
|
|
|
3267 switch (abbrev->attrs[i].name)
|
|
|
3268 {
|
|
|
3269 case DW_AT_call_file:
|
|
|
3270 if (val.encoding == ATTR_VAL_UINT)
|
|
|
3271 {
|
|
|
3272 if (val.u.uint == 0)
|
|
|
3273 function->caller_filename = "";
|
|
|
3274 else
|
|
|
3275 {
|
|
|
3276 if (val.u.uint - 1 >= lhdr->filenames_count)
|
|
|
3277 {
|
|
|
3278 dwarf_buf_error (unit_buf,
|
|
|
3279 ("invalid file number in "
|
|
|
3280 "DW_AT_call_file attribute"));
|
|
|
3281 return 0;
|
|
|
3282 }
|
|
|
3283 function->caller_filename =
|
|
|
3284 lhdr->filenames[val.u.uint - 1];
|
|
|
3285 }
|
|
|
3286 }
|
|
|
3287 break;
|
|
|
3288
|
|
|
3289 case DW_AT_call_line:
|
|
|
3290 if (val.encoding == ATTR_VAL_UINT)
|
|
|
3291 function->caller_lineno = val.u.uint;
|
|
|
3292 break;
|
|
|
3293
|
|
|
3294 case DW_AT_abstract_origin:
|
|
|
3295 case DW_AT_specification:
|
|
145
|
3296 /* Second name preference: override DW_AT_name, don't override
|
|
|
3297 DW_AT_linkage_name. */
|
|
|
3298 if (have_linkage_name)
|
|
|
3299 break;
|
|
|
3300 {
|
|
|
3301 const char *name;
|
|
|
3302
|
|
|
3303 name
|
|
|
3304 = read_referenced_name_from_attr (ddata, u,
|
|
|
3305 &abbrev->attrs[i], &val,
|
|
|
3306 error_callback, data);
|
|
|
3307 if (name != NULL)
|
|
|
3308 function->name = name;
|
|
|
3309 }
|
|
111
|
3310 break;
|
|
|
3311
|
|
|
3312 case DW_AT_name:
|
|
145
|
3313 /* Third name preference: don't override. */
|
|
|
3314 if (function->name != NULL)
|
|
|
3315 break;
|
|
|
3316 if (!resolve_string (&ddata->dwarf_sections, u->is_dwarf64,
|
|
|
3317 ddata->is_bigendian,
|
|
|
3318 u->str_offsets_base, &val,
|
|
|
3319 error_callback, data, &function->name))
|
|
|
3320 return 0;
|
|
111
|
3321 break;
|
|
|
3322
|
|
|
3323 case DW_AT_linkage_name:
|
|
|
3324 case DW_AT_MIPS_linkage_name:
|
|
145
|
3325 /* First name preference: override all. */
|
|
|
3326 {
|
|
|
3327 const char *s;
|
|
|
3328
|
|
|
3329 s = NULL;
|
|
|
3330 if (!resolve_string (&ddata->dwarf_sections, u->is_dwarf64,
|
|
|
3331 ddata->is_bigendian,
|
|
|
3332 u->str_offsets_base, &val,
|
|
|
3333 error_callback, data, &s))
|
|
|
3334 return 0;
|
|
|
3335 if (s != NULL)
|
|
|
3336 {
|
|
|
3337 function->name = s;
|
|
|
3338 have_linkage_name = 1;
|
|
|
3339 }
|
|
|
3340 }
|
|
111
|
3341 break;
|
|
|
3342
|
|
145
|
3343 case DW_AT_low_pc: case DW_AT_high_pc: case DW_AT_ranges:
|
|
|
3344 update_pcrange (&abbrev->attrs[i], &val, &pcrange);
|
|
111
|
3345 break;
|
|
|
3346
|
|
|
3347 default:
|
|
|
3348 break;
|
|
|
3349 }
|
|
|
3350 }
|
|
|
3351 }
|
|
|
3352
|
|
|
3353 /* If we couldn't find a name for the function, we have no use
|
|
|
3354 for it. */
|
|
|
3355 if (is_function && function->name == NULL)
|
|
|
3356 {
|
|
|
3357 backtrace_free (state, function, sizeof *function,
|
|
|
3358 error_callback, data);
|
|
|
3359 is_function = 0;
|
|
|
3360 }
|
|
|
3361
|
|
|
3362 if (is_function)
|
|
|
3363 {
|
|
145
|
3364 if (pcrange.have_ranges
|
|
|
3365 || (pcrange.have_lowpc && pcrange.have_highpc))
|
|
111
|
3366 {
|
|
145
|
3367 if (!add_ranges (state, &ddata->dwarf_sections,
|
|
|
3368 ddata->base_address, ddata->is_bigendian,
|
|
|
3369 u, base, &pcrange, add_function_range,
|
|
|
3370 (void *) function, error_callback, data,
|
|
|
3371 (void *) vec))
|
|
111
|
3372 return 0;
|
|
|
3373 }
|
|
|
3374 else
|
|
|
3375 {
|
|
|
3376 backtrace_free (state, function, sizeof *function,
|
|
|
3377 error_callback, data);
|
|
|
3378 is_function = 0;
|
|
|
3379 }
|
|
|
3380 }
|
|
|
3381
|
|
|
3382 if (abbrev->has_children)
|
|
|
3383 {
|
|
|
3384 if (!is_function)
|
|
|
3385 {
|
|
|
3386 if (!read_function_entry (state, ddata, u, base, unit_buf, lhdr,
|
|
|
3387 error_callback, data, vec_function,
|
|
|
3388 vec_inlined))
|
|
|
3389 return 0;
|
|
|
3390 }
|
|
|
3391 else
|
|
|
3392 {
|
|
|
3393 struct function_vector fvec;
|
|
|
3394
|
|
|
3395 /* Gather any information for inlined functions in
|
|
|
3396 FVEC. */
|
|
|
3397
|
|
|
3398 memset (&fvec, 0, sizeof fvec);
|
|
|
3399
|
|
|
3400 if (!read_function_entry (state, ddata, u, base, unit_buf, lhdr,
|
|
|
3401 error_callback, data, vec_function,
|
|
|
3402 &fvec))
|
|
|
3403 return 0;
|
|
|
3404
|
|
|
3405 if (fvec.count > 0)
|
|
|
3406 {
|
|
|
3407 struct function_addrs *faddrs;
|
|
|
3408
|
|
|
3409 if (!backtrace_vector_release (state, &fvec.vec,
|
|
|
3410 error_callback, data))
|
|
|
3411 return 0;
|
|
|
3412
|
|
|
3413 faddrs = (struct function_addrs *) fvec.vec.base;
|
|
|
3414 backtrace_qsort (faddrs, fvec.count,
|
|
|
3415 sizeof (struct function_addrs),
|
|
|
3416 function_addrs_compare);
|
|
|
3417
|
|
|
3418 function->function_addrs = faddrs;
|
|
|
3419 function->function_addrs_count = fvec.count;
|
|
|
3420 }
|
|
|
3421 }
|
|
|
3422 }
|
|
|
3423 }
|
|
|
3424
|
|
|
3425 return 1;
|
|
|
3426 }
|
|
|
3427
|
|
|
3428 /* Read function name information for a compilation unit. We look
|
|
|
3429 through the whole unit looking for function tags. */
|
|
|
3430
|
|
|
3431 static void
|
|
|
3432 read_function_info (struct backtrace_state *state, struct dwarf_data *ddata,
|
|
|
3433 const struct line_header *lhdr,
|
|
|
3434 backtrace_error_callback error_callback, void *data,
|
|
|
3435 struct unit *u, struct function_vector *fvec,
|
|
|
3436 struct function_addrs **ret_addrs,
|
|
|
3437 size_t *ret_addrs_count)
|
|
|
3438 {
|
|
|
3439 struct function_vector lvec;
|
|
|
3440 struct function_vector *pfvec;
|
|
|
3441 struct dwarf_buf unit_buf;
|
|
|
3442 struct function_addrs *addrs;
|
|
|
3443 size_t addrs_count;
|
|
|
3444
|
|
|
3445 /* Use FVEC if it is not NULL. Otherwise use our own vector. */
|
|
|
3446 if (fvec != NULL)
|
|
|
3447 pfvec = fvec;
|
|
|
3448 else
|
|
|
3449 {
|
|
|
3450 memset (&lvec, 0, sizeof lvec);
|
|
|
3451 pfvec = &lvec;
|
|
|
3452 }
|
|
|
3453
|
|
|
3454 unit_buf.name = ".debug_info";
|
|
145
|
3455 unit_buf.start = ddata->dwarf_sections.data[DEBUG_INFO];
|
|
111
|
3456 unit_buf.buf = u->unit_data;
|
|
|
3457 unit_buf.left = u->unit_data_len;
|
|
|
3458 unit_buf.is_bigendian = ddata->is_bigendian;
|
|
|
3459 unit_buf.error_callback = error_callback;
|
|
|
3460 unit_buf.data = data;
|
|
|
3461 unit_buf.reported_underflow = 0;
|
|
|
3462
|
|
|
3463 while (unit_buf.left > 0)
|
|
|
3464 {
|
|
|
3465 if (!read_function_entry (state, ddata, u, 0, &unit_buf, lhdr,
|
|
|
3466 error_callback, data, pfvec, pfvec))
|
|
|
3467 return;
|
|
|
3468 }
|
|
|
3469
|
|
|
3470 if (pfvec->count == 0)
|
|
|
3471 return;
|
|
|
3472
|
|
|
3473 addrs_count = pfvec->count;
|
|
|
3474
|
|
|
3475 if (fvec == NULL)
|
|
|
3476 {
|
|
|
3477 if (!backtrace_vector_release (state, &lvec.vec, error_callback, data))
|
|
|
3478 return;
|
|
|
3479 addrs = (struct function_addrs *) pfvec->vec.base;
|
|
|
3480 }
|
|
|
3481 else
|
|
|
3482 {
|
|
|
3483 /* Finish this list of addresses, but leave the remaining space in
|
|
|
3484 the vector available for the next function unit. */
|
|
|
3485 addrs = ((struct function_addrs *)
|
|
|
3486 backtrace_vector_finish (state, &fvec->vec,
|
|
|
3487 error_callback, data));
|
|
|
3488 if (addrs == NULL)
|
|
|
3489 return;
|
|
|
3490 fvec->count = 0;
|
|
|
3491 }
|
|
|
3492
|
|
|
3493 backtrace_qsort (addrs, addrs_count, sizeof (struct function_addrs),
|
|
|
3494 function_addrs_compare);
|
|
|
3495
|
|
|
3496 *ret_addrs = addrs;
|
|
|
3497 *ret_addrs_count = addrs_count;
|
|
|
3498 }
|
|
|
3499
|
|
|
3500 /* See if PC is inlined in FUNCTION. If it is, print out the inlined
|
|
|
3501 information, and update FILENAME and LINENO for the caller.
|
|
|
3502 Returns whatever CALLBACK returns, or 0 to keep going. */
|
|
|
3503
|
|
|
3504 static int
|
|
|
3505 report_inlined_functions (uintptr_t pc, struct function *function,
|
|
|
3506 backtrace_full_callback callback, void *data,
|
|
|
3507 const char **filename, int *lineno)
|
|
|
3508 {
|
|
|
3509 struct function_addrs *function_addrs;
|
|
|
3510 struct function *inlined;
|
|
|
3511 int ret;
|
|
|
3512
|
|
|
3513 if (function->function_addrs_count == 0)
|
|
|
3514 return 0;
|
|
|
3515
|
|
|
3516 function_addrs = ((struct function_addrs *)
|
|
|
3517 bsearch (&pc, function->function_addrs,
|
|
|
3518 function->function_addrs_count,
|
|
|
3519 sizeof (struct function_addrs),
|
|
|
3520 function_addrs_search));
|
|
|
3521 if (function_addrs == NULL)
|
|
|
3522 return 0;
|
|
|
3523
|
|
|
3524 while (((size_t) (function_addrs - function->function_addrs) + 1
|
|
|
3525 < function->function_addrs_count)
|
|
|
3526 && pc >= (function_addrs + 1)->low
|
|
|
3527 && pc < (function_addrs + 1)->high)
|
|
|
3528 ++function_addrs;
|
|
|
3529
|
|
|
3530 /* We found an inlined call. */
|
|
|
3531
|
|
|
3532 inlined = function_addrs->function;
|
|
|
3533
|
|
|
3534 /* Report any calls inlined into this one. */
|
|
|
3535 ret = report_inlined_functions (pc, inlined, callback, data,
|
|
|
3536 filename, lineno);
|
|
|
3537 if (ret != 0)
|
|
|
3538 return ret;
|
|
|
3539
|
|
|
3540 /* Report this inlined call. */
|
|
|
3541 ret = callback (data, pc, *filename, *lineno, inlined->name);
|
|
|
3542 if (ret != 0)
|
|
|
3543 return ret;
|
|
|
3544
|
|
|
3545 /* Our caller will report the caller of the inlined function; tell
|
|
|
3546 it the appropriate filename and line number. */
|
|
|
3547 *filename = inlined->caller_filename;
|
|
|
3548 *lineno = inlined->caller_lineno;
|
|
|
3549
|
|
|
3550 return 0;
|
|
|
3551 }
|
|
|
3552
|
|
|
3553 /* Look for a PC in the DWARF mapping for one module. On success,
|
|
|
3554 call CALLBACK and return whatever it returns. On error, call
|
|
|
3555 ERROR_CALLBACK and return 0. Sets *FOUND to 1 if the PC is found,
|
|
|
3556 0 if not. */
|
|
|
3557
|
|
|
3558 static int
|
|
|
3559 dwarf_lookup_pc (struct backtrace_state *state, struct dwarf_data *ddata,
|
|
|
3560 uintptr_t pc, backtrace_full_callback callback,
|
|
|
3561 backtrace_error_callback error_callback, void *data,
|
|
|
3562 int *found)
|
|
|
3563 {
|
|
|
3564 struct unit_addrs *entry;
|
|
|
3565 struct unit *u;
|
|
|
3566 int new_data;
|
|
|
3567 struct line *lines;
|
|
|
3568 struct line *ln;
|
|
|
3569 struct function_addrs *function_addrs;
|
|
|
3570 struct function *function;
|
|
|
3571 const char *filename;
|
|
|
3572 int lineno;
|
|
|
3573 int ret;
|
|
|
3574
|
|
|
3575 *found = 1;
|
|
|
3576
|
|
|
3577 /* Find an address range that includes PC. */
|
|
145
|
3578 entry = (ddata->addrs_count == 0
|
|
|
3579 ? NULL
|
|
|
3580 : bsearch (&pc, ddata->addrs, ddata->addrs_count,
|
|
|
3581 sizeof (struct unit_addrs), unit_addrs_search));
|
|
111
|
3582
|
|
|
3583 if (entry == NULL)
|
|
|
3584 {
|
|
|
3585 *found = 0;
|
|
|
3586 return 0;
|
|
|
3587 }
|
|
|
3588
|
|
|
3589 /* If there are multiple ranges that contain PC, use the last one,
|
|
|
3590 in order to produce predictable results. If we assume that all
|
|
|
3591 ranges are properly nested, then the last range will be the
|
|
|
3592 smallest one. */
|
|
|
3593 while ((size_t) (entry - ddata->addrs) + 1 < ddata->addrs_count
|
|
|
3594 && pc >= (entry + 1)->low
|
|
|
3595 && pc < (entry + 1)->high)
|
|
|
3596 ++entry;
|
|
|
3597
|
|
|
3598 /* We need the lines, lines_count, function_addrs,
|
|
|
3599 function_addrs_count fields of u. If they are not set, we need
|
|
|
3600 to set them. When running in threaded mode, we need to allow for
|
|
|
3601 the possibility that some other thread is setting them
|
|
|
3602 simultaneously. */
|
|
|
3603
|
|
|
3604 u = entry->u;
|
|
|
3605 lines = u->lines;
|
|
|
3606
|
|
|
3607 /* Skip units with no useful line number information by walking
|
|
|
3608 backward. Useless line number information is marked by setting
|
|
|
3609 lines == -1. */
|
|
|
3610 while (entry > ddata->addrs
|
|
|
3611 && pc >= (entry - 1)->low
|
|
|
3612 && pc < (entry - 1)->high)
|
|
|
3613 {
|
|
|
3614 if (state->threaded)
|
|
|
3615 lines = (struct line *) backtrace_atomic_load_pointer (&u->lines);
|
|
|
3616
|
|
|
3617 if (lines != (struct line *) (uintptr_t) -1)
|
|
|
3618 break;
|
|
|
3619
|
|
|
3620 --entry;
|
|
|
3621
|
|
|
3622 u = entry->u;
|
|
|
3623 lines = u->lines;
|
|
|
3624 }
|
|
|
3625
|
|
|
3626 if (state->threaded)
|
|
|
3627 lines = backtrace_atomic_load_pointer (&u->lines);
|
|
|
3628
|
|
|
3629 new_data = 0;
|
|
|
3630 if (lines == NULL)
|
|
|
3631 {
|
|
|
3632 size_t function_addrs_count;
|
|
|
3633 struct line_header lhdr;
|
|
|
3634 size_t count;
|
|
|
3635
|
|
|
3636 /* We have never read the line information for this unit. Read
|
|
|
3637 it now. */
|
|
|
3638
|
|
|
3639 function_addrs = NULL;
|
|
|
3640 function_addrs_count = 0;
|
|
|
3641 if (read_line_info (state, ddata, error_callback, data, entry->u, &lhdr,
|
|
|
3642 &lines, &count))
|
|
|
3643 {
|
|
|
3644 struct function_vector *pfvec;
|
|
|
3645
|
|
|
3646 /* If not threaded, reuse DDATA->FVEC for better memory
|
|
|
3647 consumption. */
|
|
|
3648 if (state->threaded)
|
|
|
3649 pfvec = NULL;
|
|
|
3650 else
|
|
|
3651 pfvec = &ddata->fvec;
|
|
|
3652 read_function_info (state, ddata, &lhdr, error_callback, data,
|
|
|
3653 entry->u, pfvec, &function_addrs,
|
|
|
3654 &function_addrs_count);
|
|
|
3655 free_line_header (state, &lhdr, error_callback, data);
|
|
|
3656 new_data = 1;
|
|
|
3657 }
|
|
|
3658
|
|
|
3659 /* Atomically store the information we just read into the unit.
|
|
|
3660 If another thread is simultaneously writing, it presumably
|
|
|
3661 read the same information, and we don't care which one we
|
|
|
3662 wind up with; we just leak the other one. We do have to
|
|
|
3663 write the lines field last, so that the acquire-loads above
|
|
|
3664 ensure that the other fields are set. */
|
|
|
3665
|
|
|
3666 if (!state->threaded)
|
|
|
3667 {
|
|
|
3668 u->lines_count = count;
|
|
|
3669 u->function_addrs = function_addrs;
|
|
|
3670 u->function_addrs_count = function_addrs_count;
|
|
|
3671 u->lines = lines;
|
|
|
3672 }
|
|
|
3673 else
|
|
|
3674 {
|
|
|
3675 backtrace_atomic_store_size_t (&u->lines_count, count);
|
|
|
3676 backtrace_atomic_store_pointer (&u->function_addrs, function_addrs);
|
|
|
3677 backtrace_atomic_store_size_t (&u->function_addrs_count,
|
|
|
3678 function_addrs_count);
|
|
|
3679 backtrace_atomic_store_pointer (&u->lines, lines);
|
|
|
3680 }
|
|
|
3681 }
|
|
|
3682
|
|
|
3683 /* Now all fields of U have been initialized. */
|
|
|
3684
|
|
|
3685 if (lines == (struct line *) (uintptr_t) -1)
|
|
|
3686 {
|
|
|
3687 /* If reading the line number information failed in some way,
|
|
|
3688 try again to see if there is a better compilation unit for
|
|
|
3689 this PC. */
|
|
|
3690 if (new_data)
|
|
|
3691 return dwarf_lookup_pc (state, ddata, pc, callback, error_callback,
|
|
|
3692 data, found);
|
|
|
3693 return callback (data, pc, NULL, 0, NULL);
|
|
|
3694 }
|
|
|
3695
|
|
|
3696 /* Search for PC within this unit. */
|
|
|
3697
|
|
|
3698 ln = (struct line *) bsearch (&pc, lines, entry->u->lines_count,
|
|
|
3699 sizeof (struct line), line_search);
|
|
|
3700 if (ln == NULL)
|
|
|
3701 {
|
|
|
3702 /* The PC is between the low_pc and high_pc attributes of the
|
|
|
3703 compilation unit, but no entry in the line table covers it.
|
|
|
3704 This implies that the start of the compilation unit has no
|
|
|
3705 line number information. */
|
|
|
3706
|
|
|
3707 if (entry->u->abs_filename == NULL)
|
|
|
3708 {
|
|
|
3709 const char *filename;
|
|
|
3710
|
|
|
3711 filename = entry->u->filename;
|
|
|
3712 if (filename != NULL
|
|
|
3713 && !IS_ABSOLUTE_PATH (filename)
|
|
|
3714 && entry->u->comp_dir != NULL)
|
|
|
3715 {
|
|
|
3716 size_t filename_len;
|
|
|
3717 const char *dir;
|
|
|
3718 size_t dir_len;
|
|
|
3719 char *s;
|
|
|
3720
|
|
|
3721 filename_len = strlen (filename);
|
|
|
3722 dir = entry->u->comp_dir;
|
|
|
3723 dir_len = strlen (dir);
|
|
|
3724 s = (char *) backtrace_alloc (state, dir_len + filename_len + 2,
|
|
|
3725 error_callback, data);
|
|
|
3726 if (s == NULL)
|
|
|
3727 {
|
|
|
3728 *found = 0;
|
|
|
3729 return 0;
|
|
|
3730 }
|
|
|
3731 memcpy (s, dir, dir_len);
|
|
|
3732 /* FIXME: Should use backslash if DOS file system. */
|
|
|
3733 s[dir_len] = '/';
|
|
|
3734 memcpy (s + dir_len + 1, filename, filename_len + 1);
|
|
|
3735 filename = s;
|
|
|
3736 }
|
|
|
3737 entry->u->abs_filename = filename;
|
|
|
3738 }
|
|
|
3739
|
|
|
3740 return callback (data, pc, entry->u->abs_filename, 0, NULL);
|
|
|
3741 }
|
|
|
3742
|
|
|
3743 /* Search for function name within this unit. */
|
|
|
3744
|
|
|
3745 if (entry->u->function_addrs_count == 0)
|
|
|
3746 return callback (data, pc, ln->filename, ln->lineno, NULL);
|
|
|
3747
|
|
|
3748 function_addrs = ((struct function_addrs *)
|
|
|
3749 bsearch (&pc, entry->u->function_addrs,
|
|
|
3750 entry->u->function_addrs_count,
|
|
|
3751 sizeof (struct function_addrs),
|
|
|
3752 function_addrs_search));
|
|
|
3753 if (function_addrs == NULL)
|
|
|
3754 return callback (data, pc, ln->filename, ln->lineno, NULL);
|
|
|
3755
|
|
|
3756 /* If there are multiple function ranges that contain PC, use the
|
|
|
3757 last one, in order to produce predictable results. */
|
|
|
3758
|
|
|
3759 while (((size_t) (function_addrs - entry->u->function_addrs + 1)
|
|
|
3760 < entry->u->function_addrs_count)
|
|
|
3761 && pc >= (function_addrs + 1)->low
|
|
|
3762 && pc < (function_addrs + 1)->high)
|
|
|
3763 ++function_addrs;
|
|
|
3764
|
|
|
3765 function = function_addrs->function;
|
|
|
3766
|
|
|
3767 filename = ln->filename;
|
|
|
3768 lineno = ln->lineno;
|
|
|
3769
|
|
|
3770 ret = report_inlined_functions (pc, function, callback, data,
|
|
|
3771 &filename, &lineno);
|
|
|
3772 if (ret != 0)
|
|
|
3773 return ret;
|
|
|
3774
|
|
|
3775 return callback (data, pc, filename, lineno, function->name);
|
|
|
3776 }
|
|
|
3777
|
|
|
3778
|
|
|
3779 /* Return the file/line information for a PC using the DWARF mapping
|
|
|
3780 we built earlier. */
|
|
|
3781
|
|
|
3782 static int
|
|
|
3783 dwarf_fileline (struct backtrace_state *state, uintptr_t pc,
|
|
|
3784 backtrace_full_callback callback,
|
|
|
3785 backtrace_error_callback error_callback, void *data)
|
|
|
3786 {
|
|
|
3787 struct dwarf_data *ddata;
|
|
|
3788 int found;
|
|
|
3789 int ret;
|
|
|
3790
|
|
|
3791 if (!state->threaded)
|
|
|
3792 {
|
|
|
3793 for (ddata = (struct dwarf_data *) state->fileline_data;
|
|
|
3794 ddata != NULL;
|
|
|
3795 ddata = ddata->next)
|
|
|
3796 {
|
|
|
3797 ret = dwarf_lookup_pc (state, ddata, pc, callback, error_callback,
|
|
|
3798 data, &found);
|
|
|
3799 if (ret != 0 || found)
|
|
|
3800 return ret;
|
|
|
3801 }
|
|
|
3802 }
|
|
|
3803 else
|
|
|
3804 {
|
|
|
3805 struct dwarf_data **pp;
|
|
|
3806
|
|
|
3807 pp = (struct dwarf_data **) (void *) &state->fileline_data;
|
|
|
3808 while (1)
|
|
|
3809 {
|
|
|
3810 ddata = backtrace_atomic_load_pointer (pp);
|
|
|
3811 if (ddata == NULL)
|
|
|
3812 break;
|
|
|
3813
|
|
|
3814 ret = dwarf_lookup_pc (state, ddata, pc, callback, error_callback,
|
|
|
3815 data, &found);
|
|
|
3816 if (ret != 0 || found)
|
|
|
3817 return ret;
|
|
|
3818
|
|
|
3819 pp = &ddata->next;
|
|
|
3820 }
|
|
|
3821 }
|
|
|
3822
|
|
|
3823 /* FIXME: See if any libraries have been dlopen'ed. */
|
|
|
3824
|
|
|
3825 return callback (data, pc, NULL, 0, NULL);
|
|
|
3826 }
|
|
|
3827
|
|
|
3828 /* Initialize our data structures from the DWARF debug info for a
|
|
|
3829 file. Return NULL on failure. */
|
|
|
3830
|
|
|
3831 static struct dwarf_data *
|
|
|
3832 build_dwarf_data (struct backtrace_state *state,
|
|
|
3833 uintptr_t base_address,
|
|
145
|
3834 const struct dwarf_sections *dwarf_sections,
|
|
111
|
3835 int is_bigendian,
|
|
145
|
3836 struct dwarf_data *altlink,
|
|
111
|
3837 backtrace_error_callback error_callback,
|
|
|
3838 void *data)
|
|
|
3839 {
|
|
|
3840 struct unit_addrs_vector addrs_vec;
|
|
|
3841 struct unit_addrs *addrs;
|
|
|
3842 size_t addrs_count;
|
|
145
|
3843 struct unit_vector units_vec;
|
|
|
3844 struct unit **units;
|
|
|
3845 size_t units_count;
|
|
111
|
3846 struct dwarf_data *fdata;
|
|
|
3847
|
|
145
|
3848 if (!build_address_map (state, base_address, dwarf_sections, is_bigendian,
|
|
|
3849 altlink, error_callback, data, &addrs_vec,
|
|
|
3850 &units_vec))
|
|
111
|
3851 return NULL;
|
|
|
3852
|
|
|
3853 if (!backtrace_vector_release (state, &addrs_vec.vec, error_callback, data))
|
|
|
3854 return NULL;
|
|
145
|
3855 if (!backtrace_vector_release (state, &units_vec.vec, error_callback, data))
|
|
|
3856 return NULL;
|
|
111
|
3857 addrs = (struct unit_addrs *) addrs_vec.vec.base;
|
|
145
|
3858 units = (struct unit **) units_vec.vec.base;
|
|
111
|
3859 addrs_count = addrs_vec.count;
|
|
145
|
3860 units_count = units_vec.count;
|
|
111
|
3861 backtrace_qsort (addrs, addrs_count, sizeof (struct unit_addrs),
|
|
|
3862 unit_addrs_compare);
|
|
145
|
3863 /* No qsort for units required, already sorted. */
|
|
111
|
3864
|
|
|
3865 fdata = ((struct dwarf_data *)
|
|
|
3866 backtrace_alloc (state, sizeof (struct dwarf_data),
|
|
|
3867 error_callback, data));
|
|
|
3868 if (fdata == NULL)
|
|
|
3869 return NULL;
|
|
|
3870
|
|
|
3871 fdata->next = NULL;
|
|
145
|
3872 fdata->altlink = altlink;
|
|
111
|
3873 fdata->base_address = base_address;
|
|
|
3874 fdata->addrs = addrs;
|
|
|
3875 fdata->addrs_count = addrs_count;
|
|
145
|
3876 fdata->units = units;
|
|
|
3877 fdata->units_count = units_count;
|
|
|
3878 fdata->dwarf_sections = *dwarf_sections;
|
|
111
|
3879 fdata->is_bigendian = is_bigendian;
|
|
|
3880 memset (&fdata->fvec, 0, sizeof fdata->fvec);
|
|
|
3881
|
|
|
3882 return fdata;
|
|
|
3883 }
|
|
|
3884
|
|
|
3885 /* Build our data structures from the DWARF sections for a module.
|
|
|
3886 Set FILELINE_FN and STATE->FILELINE_DATA. Return 1 on success, 0
|
|
|
3887 on failure. */
|
|
|
3888
|
|
|
3889 int
|
|
|
3890 backtrace_dwarf_add (struct backtrace_state *state,
|
|
|
3891 uintptr_t base_address,
|
|
145
|
3892 const struct dwarf_sections *dwarf_sections,
|
|
111
|
3893 int is_bigendian,
|
|
145
|
3894 struct dwarf_data *fileline_altlink,
|
|
111
|
3895 backtrace_error_callback error_callback,
|
|
145
|
3896 void *data, fileline *fileline_fn,
|
|
|
3897 struct dwarf_data **fileline_entry)
|
|
111
|
3898 {
|
|
|
3899 struct dwarf_data *fdata;
|
|
|
3900
|
|
145
|
3901 fdata = build_dwarf_data (state, base_address, dwarf_sections, is_bigendian,
|
|
|
3902 fileline_altlink, error_callback, data);
|
|
111
|
3903 if (fdata == NULL)
|
|
|
3904 return 0;
|
|
|
3905
|
|
145
|
3906 if (fileline_entry != NULL)
|
|
|
3907 *fileline_entry = fdata;
|
|
|
3908
|
|
111
|
3909 if (!state->threaded)
|
|
|
3910 {
|
|
|
3911 struct dwarf_data **pp;
|
|
|
3912
|
|
|
3913 for (pp = (struct dwarf_data **) (void *) &state->fileline_data;
|
|
|
3914 *pp != NULL;
|
|
|
3915 pp = &(*pp)->next)
|
|
|
3916 ;
|
|
|
3917 *pp = fdata;
|
|
|
3918 }
|
|
|
3919 else
|
|
|
3920 {
|
|
|
3921 while (1)
|
|
|
3922 {
|
|
|
3923 struct dwarf_data **pp;
|
|
|
3924
|
|
|
3925 pp = (struct dwarf_data **) (void *) &state->fileline_data;
|
|
|
3926
|
|
|
3927 while (1)
|
|
|
3928 {
|
|
|
3929 struct dwarf_data *p;
|
|
|
3930
|
|
|
3931 p = backtrace_atomic_load_pointer (pp);
|
|
|
3932
|
|
|
3933 if (p == NULL)
|
|
|
3934 break;
|
|
|
3935
|
|
|
3936 pp = &p->next;
|
|
|
3937 }
|
|
|
3938
|
|
|
3939 if (__sync_bool_compare_and_swap (pp, NULL, fdata))
|
|
|
3940 break;
|
|
|
3941 }
|
|
|
3942 }
|
|
|
3943
|
|
|
3944 *fileline_fn = dwarf_fileline;
|
|
|
3945
|
|
|
3946 return 1;
|
|
|
3947 }
|
