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