| /* dwarf.c -- Get file/line information from DWARF for backtraces. |
| Copyright (C) 2012-2020 Free Software Foundation, Inc. |
| Written by Ian Lance Taylor, Google. |
| |
| Redistribution and use in source and binary forms, with or without |
| modification, are permitted provided that the following conditions are |
| met: |
| |
| (1) Redistributions of source code must retain the above copyright |
| notice, this list of conditions and the following disclaimer. |
| |
| (2) Redistributions in binary form must reproduce the above copyright |
| notice, this list of conditions and the following disclaimer in |
| the documentation and/or other materials provided with the |
| distribution. |
| |
| (3) The name of the author may not be used to |
| endorse or promote products derived from this software without |
| specific prior written permission. |
| |
| THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
| WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, |
| INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
| (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
| SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
| STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING |
| IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| POSSIBILITY OF SUCH DAMAGE. */ |
| |
| #include "config.h" |
| |
| #include <errno.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <sys/types.h> |
| |
| #include "dwarf2.h" |
| #include "filenames.h" |
| |
| #include "backtrace.h" |
| #include "internal.h" |
| |
| #if !defined(HAVE_DECL_STRNLEN) || !HAVE_DECL_STRNLEN |
| |
| /* If strnlen is not declared, provide our own version. */ |
| |
| static size_t |
| xstrnlen (const char *s, size_t maxlen) |
| { |
| size_t i; |
| |
| for (i = 0; i < maxlen; ++i) |
| if (s[i] == '\0') |
| break; |
| return i; |
| } |
| |
| #define strnlen xstrnlen |
| |
| #endif |
| |
| /* A buffer to read DWARF info. */ |
| |
| struct dwarf_buf |
| { |
| /* Buffer name for error messages. */ |
| const char *name; |
| /* Start of the buffer. */ |
| const unsigned char *start; |
| /* Next byte to read. */ |
| const unsigned char *buf; |
| /* The number of bytes remaining. */ |
| size_t left; |
| /* Whether the data is big-endian. */ |
| int is_bigendian; |
| /* Error callback routine. */ |
| backtrace_error_callback error_callback; |
| /* Data for error_callback. */ |
| void *data; |
| /* Non-zero if we've reported an underflow error. */ |
| int reported_underflow; |
| }; |
| |
| /* A single attribute in a DWARF abbreviation. */ |
| |
| struct attr |
| { |
| /* The attribute name. */ |
| enum dwarf_attribute name; |
| /* The attribute form. */ |
| enum dwarf_form form; |
| /* The attribute value, for DW_FORM_implicit_const. */ |
| int64_t val; |
| }; |
| |
| /* A single DWARF abbreviation. */ |
| |
| struct abbrev |
| { |
| /* The abbrev code--the number used to refer to the abbrev. */ |
| uint64_t code; |
| /* The entry tag. */ |
| enum dwarf_tag tag; |
| /* Non-zero if this abbrev has child entries. */ |
| int has_children; |
| /* The number of attributes. */ |
| size_t num_attrs; |
| /* The attributes. */ |
| struct attr *attrs; |
| }; |
| |
| /* The DWARF abbreviations for a compilation unit. This structure |
| only exists while reading the compilation unit. Most DWARF readers |
| seem to a hash table to map abbrev ID's to abbrev entries. |
| However, we primarily care about GCC, and GCC simply issues ID's in |
| numerical order starting at 1. So we simply keep a sorted vector, |
| and try to just look up the code. */ |
| |
| struct abbrevs |
| { |
| /* The number of abbrevs in the vector. */ |
| size_t num_abbrevs; |
| /* The abbrevs, sorted by the code field. */ |
| struct abbrev *abbrevs; |
| }; |
| |
| /* The different kinds of attribute values. */ |
| |
| enum attr_val_encoding |
| { |
| /* No attribute value. */ |
| ATTR_VAL_NONE, |
| /* An address. */ |
| ATTR_VAL_ADDRESS, |
| /* An index into the .debug_addr section, whose value is relative to |
| * the DW_AT_addr_base attribute of the compilation unit. */ |
| ATTR_VAL_ADDRESS_INDEX, |
| /* A unsigned integer. */ |
| ATTR_VAL_UINT, |
| /* A sigd integer. */ |
| ATTR_VAL_SINT, |
| /* A string. */ |
| ATTR_VAL_STRING, |
| /* An index into the .debug_str_offsets section. */ |
| ATTR_VAL_STRING_INDEX, |
| /* An offset to other data in the containing unit. */ |
| ATTR_VAL_REF_UNIT, |
| /* An offset to other data within the .debug_info section. */ |
| ATTR_VAL_REF_INFO, |
| /* An offset to other data within the alt .debug_info section. */ |
| ATTR_VAL_REF_ALT_INFO, |
| /* An offset to data in some other section. */ |
| ATTR_VAL_REF_SECTION, |
| /* A type signature. */ |
| ATTR_VAL_REF_TYPE, |
| /* An index into the .debug_rnglists section. */ |
| ATTR_VAL_RNGLISTS_INDEX, |
| /* A block of data (not represented). */ |
| ATTR_VAL_BLOCK, |
| /* An expression (not represented). */ |
| ATTR_VAL_EXPR, |
| }; |
| |
| /* An attribute value. */ |
| |
| struct attr_val |
| { |
| /* How the value is stored in the field u. */ |
| enum attr_val_encoding encoding; |
| union |
| { |
| /* ATTR_VAL_ADDRESS*, ATTR_VAL_UINT, ATTR_VAL_REF*. */ |
| uint64_t uint; |
| /* ATTR_VAL_SINT. */ |
| int64_t sint; |
| /* ATTR_VAL_STRING. */ |
| const char *string; |
| /* ATTR_VAL_BLOCK not stored. */ |
| } u; |
| }; |
| |
| /* The line number program header. */ |
| |
| struct line_header |
| { |
| /* The version of the line number information. */ |
| int version; |
| /* Address size. */ |
| int addrsize; |
| /* The minimum instruction length. */ |
| unsigned int min_insn_len; |
| /* The maximum number of ops per instruction. */ |
| unsigned int max_ops_per_insn; |
| /* The line base for special opcodes. */ |
| int line_base; |
| /* The line range for special opcodes. */ |
| unsigned int line_range; |
| /* The opcode base--the first special opcode. */ |
| unsigned int opcode_base; |
| /* Opcode lengths, indexed by opcode - 1. */ |
| const unsigned char *opcode_lengths; |
| /* The number of directory entries. */ |
| size_t dirs_count; |
| /* The directory entries. */ |
| const char **dirs; |
| /* The number of filenames. */ |
| size_t filenames_count; |
| /* The filenames. */ |
| const char **filenames; |
| }; |
| |
| /* A format description from a line header. */ |
| |
| struct line_header_format |
| { |
| int lnct; /* LNCT code. */ |
| enum dwarf_form form; /* Form of entry data. */ |
| }; |
| |
| /* Map a single PC value to a file/line. We will keep a vector of |
| these sorted by PC value. Each file/line will be correct from the |
| PC up to the PC of the next entry if there is one. We allocate one |
| extra entry at the end so that we can use bsearch. */ |
| |
| struct line |
| { |
| /* PC. */ |
| uintptr_t pc; |
| /* File name. Many entries in the array are expected to point to |
| the same file name. */ |
| const char *filename; |
| /* Line number. */ |
| int lineno; |
| /* Index of the object in the original array read from the DWARF |
| section, before it has been sorted. The index makes it possible |
| to use Quicksort and maintain stability. */ |
| int idx; |
| }; |
| |
| /* A growable vector of line number information. This is used while |
| reading the line numbers. */ |
| |
| struct line_vector |
| { |
| /* Memory. This is an array of struct line. */ |
| struct backtrace_vector vec; |
| /* Number of valid mappings. */ |
| size_t count; |
| }; |
| |
| /* A function described in the debug info. */ |
| |
| struct function |
| { |
| /* The name of the function. */ |
| const char *name; |
| /* If this is an inlined function, the filename of the call |
| site. */ |
| const char *caller_filename; |
| /* If this is an inlined function, the line number of the call |
| site. */ |
| int caller_lineno; |
| /* Map PC ranges to inlined functions. */ |
| struct function_addrs *function_addrs; |
| size_t function_addrs_count; |
| }; |
| |
| /* An address range for a function. This maps a PC value to a |
| specific function. */ |
| |
| struct function_addrs |
| { |
| /* Range is LOW <= PC < HIGH. */ |
| uint64_t low; |
| uint64_t high; |
| /* Function for this address range. */ |
| struct function *function; |
| }; |
| |
| /* A growable vector of function address ranges. */ |
| |
| struct function_vector |
| { |
| /* Memory. This is an array of struct function_addrs. */ |
| struct backtrace_vector vec; |
| /* Number of address ranges present. */ |
| size_t count; |
| }; |
| |
| /* A DWARF compilation unit. This only holds the information we need |
| to map a PC to a file and line. */ |
| |
| struct unit |
| { |
| /* The first entry for this compilation unit. */ |
| const unsigned char *unit_data; |
| /* The length of the data for this compilation unit. */ |
| size_t unit_data_len; |
| /* The offset of UNIT_DATA from the start of the information for |
| this compilation unit. */ |
| size_t unit_data_offset; |
| /* Offset of the start of the compilation unit from the start of the |
| .debug_info section. */ |
| size_t low_offset; |
| /* Offset of the end of the compilation unit from the start of the |
| .debug_info section. */ |
| size_t high_offset; |
| /* DWARF version. */ |
| int version; |
| /* Whether unit is DWARF64. */ |
| int is_dwarf64; |
| /* Address size. */ |
| int addrsize; |
| /* Offset into line number information. */ |
| off_t lineoff; |
| /* Offset of compilation unit in .debug_str_offsets. */ |
| uint64_t str_offsets_base; |
| /* Offset of compilation unit in .debug_addr. */ |
| uint64_t addr_base; |
| /* Offset of compilation unit in .debug_rnglists. */ |
| uint64_t rnglists_base; |
| /* Primary source file. */ |
| const char *filename; |
| /* Compilation command working directory. */ |
| const char *comp_dir; |
| /* Absolute file name, only set if needed. */ |
| const char *abs_filename; |
| /* The abbreviations for this unit. */ |
| struct abbrevs abbrevs; |
| |
| /* The fields above this point are read in during initialization and |
| may be accessed freely. The fields below this point are read in |
| as needed, and therefore require care, as different threads may |
| try to initialize them simultaneously. */ |
| |
| /* PC to line number mapping. This is NULL if the values have not |
| been read. This is (struct line *) -1 if there was an error |
| reading the values. */ |
| struct line *lines; |
| /* Number of entries in lines. */ |
| size_t lines_count; |
| /* PC ranges to function. */ |
| struct function_addrs *function_addrs; |
| size_t function_addrs_count; |
| }; |
| |
| /* An address range for a compilation unit. This maps a PC value to a |
| specific compilation unit. Note that we invert the representation |
| in DWARF: instead of listing the units and attaching a list of |
| ranges, we list the ranges and have each one point to the unit. |
| This lets us do a binary search to find the unit. */ |
| |
| struct unit_addrs |
| { |
| /* Range is LOW <= PC < HIGH. */ |
| uint64_t low; |
| uint64_t high; |
| /* Compilation unit for this address range. */ |
| struct unit *u; |
| }; |
| |
| /* A growable vector of compilation unit address ranges. */ |
| |
| struct unit_addrs_vector |
| { |
| /* Memory. This is an array of struct unit_addrs. */ |
| struct backtrace_vector vec; |
| /* Number of address ranges present. */ |
| size_t count; |
| }; |
| |
| /* A growable vector of compilation unit pointer. */ |
| |
| struct unit_vector |
| { |
| struct backtrace_vector vec; |
| size_t count; |
| }; |
| |
| /* The information we need to map a PC to a file and line. */ |
| |
| struct dwarf_data |
| { |
| /* The data for the next file we know about. */ |
| struct dwarf_data *next; |
| /* The data for .gnu_debugaltlink. */ |
| struct dwarf_data *altlink; |
| /* The base address for this file. */ |
| uintptr_t base_address; |
| /* A sorted list of address ranges. */ |
| struct unit_addrs *addrs; |
| /* Number of address ranges in list. */ |
| size_t addrs_count; |
| /* A sorted list of units. */ |
| struct unit **units; |
| /* Number of units in the list. */ |
| size_t units_count; |
| /* The unparsed DWARF debug data. */ |
| struct dwarf_sections dwarf_sections; |
| /* Whether the data is big-endian or not. */ |
| int is_bigendian; |
| /* A vector used for function addresses. We keep this here so that |
| we can grow the vector as we read more functions. */ |
| struct function_vector fvec; |
| }; |
| |
| /* Report an error for a DWARF buffer. */ |
| |
| static void |
| dwarf_buf_error (struct dwarf_buf *buf, const char *msg) |
| { |
| char b[200]; |
| |
| snprintf (b, sizeof b, "%s in %s at %d", |
| msg, buf->name, (int) (buf->buf - buf->start)); |
| buf->error_callback (buf->data, b, 0); |
| } |
| |
| /* Require at least COUNT bytes in BUF. Return 1 if all is well, 0 on |
| error. */ |
| |
| static int |
| require (struct dwarf_buf *buf, size_t count) |
| { |
| if (buf->left >= count) |
| return 1; |
| |
| if (!buf->reported_underflow) |
| { |
| dwarf_buf_error (buf, "DWARF underflow"); |
| buf->reported_underflow = 1; |
| } |
| |
| return 0; |
| } |
| |
| /* Advance COUNT bytes in BUF. Return 1 if all is well, 0 on |
| error. */ |
| |
| static int |
| advance (struct dwarf_buf *buf, size_t count) |
| { |
| if (!require (buf, count)) |
| return 0; |
| buf->buf += count; |
| buf->left -= count; |
| return 1; |
| } |
| |
| /* Read one zero-terminated string from BUF and advance past the string. */ |
| |
| static const char * |
| read_string (struct dwarf_buf *buf) |
| { |
| const char *p = (const char *)buf->buf; |
| size_t len = strnlen (p, buf->left); |
| |
| /* - If len == left, we ran out of buffer before finding the zero terminator. |
| Generate an error by advancing len + 1. |
| - If len < left, advance by len + 1 to skip past the zero terminator. */ |
| size_t count = len + 1; |
| |
| if (!advance (buf, count)) |
| return NULL; |
| |
| return p; |
| } |
| |
| /* Read one byte from BUF and advance 1 byte. */ |
| |
| static unsigned char |
| read_byte (struct dwarf_buf *buf) |
| { |
| const unsigned char *p = buf->buf; |
| |
| if (!advance (buf, 1)) |
| return 0; |
| return p[0]; |
| } |
| |
| /* Read a signed char from BUF and advance 1 byte. */ |
| |
| static signed char |
| read_sbyte (struct dwarf_buf *buf) |
| { |
| const unsigned char *p = buf->buf; |
| |
| if (!advance (buf, 1)) |
| return 0; |
| return (*p ^ 0x80) - 0x80; |
| } |
| |
| /* Read a uint16 from BUF and advance 2 bytes. */ |
| |
| static uint16_t |
| read_uint16 (struct dwarf_buf *buf) |
| { |
| const unsigned char *p = buf->buf; |
| |
| if (!advance (buf, 2)) |
| return 0; |
| if (buf->is_bigendian) |
| return ((uint16_t) p[0] << 8) | (uint16_t) p[1]; |
| else |
| return ((uint16_t) p[1] << 8) | (uint16_t) p[0]; |
| } |
| |
| /* Read a 24 bit value from BUF and advance 3 bytes. */ |
| |
| static uint32_t |
| read_uint24 (struct dwarf_buf *buf) |
| { |
| const unsigned char *p = buf->buf; |
| |
| if (!advance (buf, 3)) |
| return 0; |
| if (buf->is_bigendian) |
| return (((uint32_t) p[0] << 16) | ((uint32_t) p[1] << 8) |
| | (uint32_t) p[2]); |
| else |
| return (((uint32_t) p[2] << 16) | ((uint32_t) p[1] << 8) |
| | (uint32_t) p[0]); |
| } |
| |
| /* Read a uint32 from BUF and advance 4 bytes. */ |
| |
| static uint32_t |
| read_uint32 (struct dwarf_buf *buf) |
| { |
| const unsigned char *p = buf->buf; |
| |
| if (!advance (buf, 4)) |
| return 0; |
| if (buf->is_bigendian) |
| return (((uint32_t) p[0] << 24) | ((uint32_t) p[1] << 16) |
| | ((uint32_t) p[2] << 8) | (uint32_t) p[3]); |
| else |
| return (((uint32_t) p[3] << 24) | ((uint32_t) p[2] << 16) |
| | ((uint32_t) p[1] << 8) | (uint32_t) p[0]); |
| } |
| |
| /* Read a uint64 from BUF and advance 8 bytes. */ |
| |
| static uint64_t |
| read_uint64 (struct dwarf_buf *buf) |
| { |
| const unsigned char *p = buf->buf; |
| |
| if (!advance (buf, 8)) |
| return 0; |
| if (buf->is_bigendian) |
| return (((uint64_t) p[0] << 56) | ((uint64_t) p[1] << 48) |
| | ((uint64_t) p[2] << 40) | ((uint64_t) p[3] << 32) |
| | ((uint64_t) p[4] << 24) | ((uint64_t) p[5] << 16) |
| | ((uint64_t) p[6] << 8) | (uint64_t) p[7]); |
| else |
| return (((uint64_t) p[7] << 56) | ((uint64_t) p[6] << 48) |
| | ((uint64_t) p[5] << 40) | ((uint64_t) p[4] << 32) |
| | ((uint64_t) p[3] << 24) | ((uint64_t) p[2] << 16) |
| | ((uint64_t) p[1] << 8) | (uint64_t) p[0]); |
| } |
| |
| /* Read an offset from BUF and advance the appropriate number of |
| bytes. */ |
| |
| static uint64_t |
| read_offset (struct dwarf_buf *buf, int is_dwarf64) |
| { |
| if (is_dwarf64) |
| return read_uint64 (buf); |
| else |
| return read_uint32 (buf); |
| } |
| |
| /* Read an address from BUF and advance the appropriate number of |
| bytes. */ |
| |
| static uint64_t |
| read_address (struct dwarf_buf *buf, int addrsize) |
| { |
| switch (addrsize) |
| { |
| case 1: |
| return read_byte (buf); |
| case 2: |
| return read_uint16 (buf); |
| case 4: |
| return read_uint32 (buf); |
| case 8: |
| return read_uint64 (buf); |
| default: |
| dwarf_buf_error (buf, "unrecognized address size"); |
| return 0; |
| } |
| } |
| |
| /* Return whether a value is the highest possible address, given the |
| address size. */ |
| |
| static int |
| is_highest_address (uint64_t address, int addrsize) |
| { |
| switch (addrsize) |
| { |
| case 1: |
| return address == (unsigned char) -1; |
| case 2: |
| return address == (uint16_t) -1; |
| case 4: |
| return address == (uint32_t) -1; |
| case 8: |
| return address == (uint64_t) -1; |
| default: |
| return 0; |
| } |
| } |
| |
| /* Read an unsigned LEB128 number. */ |
| |
| static uint64_t |
| read_uleb128 (struct dwarf_buf *buf) |
| { |
| uint64_t ret; |
| unsigned int shift; |
| int overflow; |
| unsigned char b; |
| |
| ret = 0; |
| shift = 0; |
| overflow = 0; |
| do |
| { |
| const unsigned char *p; |
| |
| p = buf->buf; |
| if (!advance (buf, 1)) |
| return 0; |
| b = *p; |
| if (shift < 64) |
| ret |= ((uint64_t) (b & 0x7f)) << shift; |
| else if (!overflow) |
| { |
| dwarf_buf_error (buf, "LEB128 overflows uint64_t"); |
| overflow = 1; |
| } |
| shift += 7; |
| } |
| while ((b & 0x80) != 0); |
| |
| return ret; |
| } |
| |
| /* Read a signed LEB128 number. */ |
| |
| static int64_t |
| read_sleb128 (struct dwarf_buf *buf) |
| { |
| uint64_t val; |
| unsigned int shift; |
| int overflow; |
| unsigned char b; |
| |
| val = 0; |
| shift = 0; |
| overflow = 0; |
| do |
| { |
| const unsigned char *p; |
| |
| p = buf->buf; |
| if (!advance (buf, 1)) |
| return 0; |
| b = *p; |
| if (shift < 64) |
| val |= ((uint64_t) (b & 0x7f)) << shift; |
| else if (!overflow) |
| { |
| dwarf_buf_error (buf, "signed LEB128 overflows uint64_t"); |
| overflow = 1; |
| } |
| shift += 7; |
| } |
| while ((b & 0x80) != 0); |
| |
| if ((b & 0x40) != 0 && shift < 64) |
| val |= ((uint64_t) -1) << shift; |
| |
| return (int64_t) val; |
| } |
| |
| /* Return the length of an LEB128 number. */ |
| |
| static size_t |
| leb128_len (const unsigned char *p) |
| { |
| size_t ret; |
| |
| ret = 1; |
| while ((*p & 0x80) != 0) |
| { |
| ++p; |
| ++ret; |
| } |
| return ret; |
| } |
| |
| /* Read initial_length from BUF and advance the appropriate number of bytes. */ |
| |
| static uint64_t |
| read_initial_length (struct dwarf_buf *buf, int *is_dwarf64) |
| { |
| uint64_t len; |
| |
| len = read_uint32 (buf); |
| if (len == 0xffffffff) |
| { |
| len = read_uint64 (buf); |
| *is_dwarf64 = 1; |
| } |
| else |
| *is_dwarf64 = 0; |
| |
| return len; |
| } |
| |
| /* Free an abbreviations structure. */ |
| |
| static void |
| free_abbrevs (struct backtrace_state *state, struct abbrevs *abbrevs, |
| backtrace_error_callback error_callback, void *data) |
| { |
| size_t i; |
| |
| for (i = 0; i < abbrevs->num_abbrevs; ++i) |
| backtrace_free (state, abbrevs->abbrevs[i].attrs, |
| abbrevs->abbrevs[i].num_attrs * sizeof (struct attr), |
| error_callback, data); |
| backtrace_free (state, abbrevs->abbrevs, |
| abbrevs->num_abbrevs * sizeof (struct abbrev), |
| error_callback, data); |
| abbrevs->num_abbrevs = 0; |
| abbrevs->abbrevs = NULL; |
| } |
| |
| /* Read an attribute value. Returns 1 on success, 0 on failure. If |
| the value can be represented as a uint64_t, sets *VAL and sets |
| *IS_VALID to 1. We don't try to store the value of other attribute |
| forms, because we don't care about them. */ |
| |
| static int |
| read_attribute (enum dwarf_form form, uint64_t implicit_val, |
| struct dwarf_buf *buf, int is_dwarf64, int version, |
| int addrsize, const struct dwarf_sections *dwarf_sections, |
| struct dwarf_data *altlink, struct attr_val *val) |
| { |
| /* Avoid warnings about val.u.FIELD may be used uninitialized if |
| this function is inlined. The warnings aren't valid but can |
| occur because the different fields are set and used |
| conditionally. */ |
| memset (val, 0, sizeof *val); |
| |
| switch (form) |
| { |
| case DW_FORM_addr: |
| val->encoding = ATTR_VAL_ADDRESS; |
| val->u.uint = read_address (buf, addrsize); |
| return 1; |
| case DW_FORM_block2: |
| val->encoding = ATTR_VAL_BLOCK; |
| return advance (buf, read_uint16 (buf)); |
| case DW_FORM_block4: |
| val->encoding = ATTR_VAL_BLOCK; |
| return advance (buf, read_uint32 (buf)); |
| case DW_FORM_data2: |
| val->encoding = ATTR_VAL_UINT; |
| val->u.uint = read_uint16 (buf); |
| return 1; |
| case DW_FORM_data4: |
| val->encoding = ATTR_VAL_UINT; |
| val->u.uint = read_uint32 (buf); |
| return 1; |
| case DW_FORM_data8: |
| val->encoding = ATTR_VAL_UINT; |
| val->u.uint = read_uint64 (buf); |
| return 1; |
| case DW_FORM_data16: |
| val->encoding = ATTR_VAL_BLOCK; |
| return advance (buf, 16); |
| case DW_FORM_string: |
| val->encoding = ATTR_VAL_STRING; |
| val->u.string = read_string (buf); |
| return val->u.string == NULL ? 0 : 1; |
| case DW_FORM_block: |
| val->encoding = ATTR_VAL_BLOCK; |
| return advance (buf, read_uleb128 (buf)); |
| case DW_FORM_block1: |
| val->encoding = ATTR_VAL_BLOCK; |
| return advance (buf, read_byte (buf)); |
| case DW_FORM_data1: |
| val->encoding = ATTR_VAL_UINT; |
| val->u.uint = read_byte (buf); |
| return 1; |
| case DW_FORM_flag: |
| val->encoding = ATTR_VAL_UINT; |
| val->u.uint = read_byte (buf); |
| return 1; |
| case DW_FORM_sdata: |
| val->encoding = ATTR_VAL_SINT; |
| val->u.sint = read_sleb128 (buf); |
| return 1; |
| case DW_FORM_strp: |
| { |
| uint64_t offset; |
| |
| offset = read_offset (buf, is_dwarf64); |
| if (offset >= dwarf_sections->size[DEBUG_STR]) |
| { |
| dwarf_buf_error (buf, "DW_FORM_strp out of range"); |
| return 0; |
| } |
| val->encoding = ATTR_VAL_STRING; |
| val->u.string = |
| (const char *) dwarf_sections->data[DEBUG_STR] + offset; |
| return 1; |
| } |
| case DW_FORM_line_strp: |
| { |
| uint64_t offset; |
| |
| offset = read_offset (buf, is_dwarf64); |
| if (offset >= dwarf_sections->size[DEBUG_LINE_STR]) |
| { |
| dwarf_buf_error (buf, "DW_FORM_line_strp out of range"); |
| return 0; |
| } |
| val->encoding = ATTR_VAL_STRING; |
| val->u.string = |
| (const char *) dwarf_sections->data[DEBUG_LINE_STR] + offset; |
| return 1; |
| } |
| case DW_FORM_udata: |
| val->encoding = ATTR_VAL_UINT; |
| val->u.uint = read_uleb128 (buf); |
| return 1; |
| case DW_FORM_ref_addr: |
| val->encoding = ATTR_VAL_REF_INFO; |
| if (version == 2) |
| val->u.uint = read_address (buf, addrsize); |
| else |
| val->u.uint = read_offset (buf, is_dwarf64); |
| return 1; |
| case DW_FORM_ref1: |
| val->encoding = ATTR_VAL_REF_UNIT; |
| val->u.uint = read_byte (buf); |
| return 1; |
| case DW_FORM_ref2: |
| val->encoding = ATTR_VAL_REF_UNIT; |
| val->u.uint = read_uint16 (buf); |
| return 1; |
| case DW_FORM_ref4: |
| val->encoding = ATTR_VAL_REF_UNIT; |
| val->u.uint = read_uint32 (buf); |
| return 1; |
| case DW_FORM_ref8: |
| val->encoding = ATTR_VAL_REF_UNIT; |
| val->u.uint = read_uint64 (buf); |
| return 1; |
| case DW_FORM_ref_udata: |
| val->encoding = ATTR_VAL_REF_UNIT; |
| val->u.uint = read_uleb128 (buf); |
| return 1; |
| case DW_FORM_indirect: |
| { |
| uint64_t form; |
| |
| form = read_uleb128 (buf); |
| if (form == DW_FORM_implicit_const) |
| { |
| dwarf_buf_error (buf, |
| "DW_FORM_indirect to DW_FORM_implicit_const"); |
| return 0; |
| } |
| return read_attribute ((enum dwarf_form) form, 0, buf, is_dwarf64, |
| version, addrsize, dwarf_sections, altlink, |
| val); |
| } |
| case DW_FORM_sec_offset: |
| val->encoding = ATTR_VAL_REF_SECTION; |
| val->u.uint = read_offset (buf, is_dwarf64); |
| return 1; |
| case DW_FORM_exprloc: |
| val->encoding = ATTR_VAL_EXPR; |
| return advance (buf, read_uleb128 (buf)); |
| case DW_FORM_flag_present: |
| val->encoding = ATTR_VAL_UINT; |
| val->u.uint = 1; |
| return 1; |
| case DW_FORM_ref_sig8: |
| val->encoding = ATTR_VAL_REF_TYPE; |
| val->u.uint = read_uint64 (buf); |
| return 1; |
| case DW_FORM_strx: case DW_FORM_strx1: case DW_FORM_strx2: |
| case DW_FORM_strx3: case DW_FORM_strx4: |
| { |
| uint64_t offset; |
| |
| switch (form) |
| { |
| case DW_FORM_strx: |
| offset = read_uleb128 (buf); |
| break; |
| case DW_FORM_strx1: |
| offset = read_byte (buf); |
| break; |
| case DW_FORM_strx2: |
| offset = read_uint16 (buf); |
| break; |
| case DW_FORM_strx3: |
| offset = read_uint24 (buf); |
| break; |
| case DW_FORM_strx4: |
| offset = read_uint32 (buf); |
| break; |
| default: |
| /* This case can't happen. */ |
| return 0; |
| } |
| val->encoding = ATTR_VAL_STRING_INDEX; |
| val->u.uint = offset; |
| return 1; |
| } |
| case DW_FORM_addrx: case DW_FORM_addrx1: case DW_FORM_addrx2: |
| case DW_FORM_addrx3: case DW_FORM_addrx4: |
| { |
| uint64_t offset; |
| |
| switch (form) |
| { |
| case DW_FORM_addrx: |
| offset = read_uleb128 (buf); |
| break; |
| case DW_FORM_addrx1: |
| offset = read_byte (buf); |
| break; |
| case DW_FORM_addrx2: |
| offset = read_uint16 (buf); |
| break; |
| case DW_FORM_addrx3: |
| offset = read_uint24 (buf); |
| break; |
| case DW_FORM_addrx4: |
| offset = read_uint32 (buf); |
| break; |
| default: |
| /* This case can't happen. */ |
| return 0; |
| } |
| val->encoding = ATTR_VAL_ADDRESS_INDEX; |
| val->u.uint = offset; |
| return 1; |
| } |
| case DW_FORM_ref_sup4: |
| val->encoding = ATTR_VAL_REF_SECTION; |
| val->u.uint = read_uint32 (buf); |
| return 1; |
| case DW_FORM_ref_sup8: |
| val->encoding = ATTR_VAL_REF_SECTION; |
| val->u.uint = read_uint64 (buf); |
| return 1; |
| case DW_FORM_implicit_const: |
| val->encoding = ATTR_VAL_UINT; |
| val->u.uint = implicit_val; |
| return 1; |
| case DW_FORM_loclistx: |
| /* We don't distinguish this from DW_FORM_sec_offset. It |
| * shouldn't matter since we don't care about loclists. */ |
| val->encoding = ATTR_VAL_REF_SECTION; |
| val->u.uint = read_uleb128 (buf); |
| return 1; |
| case DW_FORM_rnglistx: |
| val->encoding = ATTR_VAL_RNGLISTS_INDEX; |
| val->u.uint = read_uleb128 (buf); |
| return 1; |
| case DW_FORM_GNU_addr_index: |
| val->encoding = ATTR_VAL_REF_SECTION; |
| val->u.uint = read_uleb128 (buf); |
| return 1; |
| case DW_FORM_GNU_str_index: |
| val->encoding = ATTR_VAL_REF_SECTION; |
| val->u.uint = read_uleb128 (buf); |
| return 1; |
| case DW_FORM_GNU_ref_alt: |
| val->u.uint = read_offset (buf, is_dwarf64); |
| if (altlink == NULL) |
| { |
| val->encoding = ATTR_VAL_NONE; |
| return 1; |
| } |
| val->encoding = ATTR_VAL_REF_ALT_INFO; |
| return 1; |
| case DW_FORM_strp_sup: case DW_FORM_GNU_strp_alt: |
| { |
| uint64_t offset; |
| |
| offset = read_offset (buf, is_dwarf64); |
| if (altlink == NULL) |
| { |
| val->encoding = ATTR_VAL_NONE; |
| return 1; |
| } |
| if (offset >= altlink->dwarf_sections.size[DEBUG_STR]) |
| { |
| dwarf_buf_error (buf, "DW_FORM_strp_sup out of range"); |
| return 0; |
| } |
| val->encoding = ATTR_VAL_STRING; |
| val->u.string = |
| (const char *) altlink->dwarf_sections.data[DEBUG_STR] + offset; |
| return 1; |
| } |
| default: |
| dwarf_buf_error (buf, "unrecognized DWARF form"); |
| return 0; |
| } |
| } |
| |
| /* If we can determine the value of a string attribute, set *STRING to |
| point to the string. Return 1 on success, 0 on error. If we don't |
| know the value, we consider that a success, and we don't change |
| *STRING. An error is only reported for some sort of out of range |
| offset. */ |
| |
| static int |
| resolve_string (const struct dwarf_sections *dwarf_sections, int is_dwarf64, |
| int is_bigendian, uint64_t str_offsets_base, |
| const struct attr_val *val, |
| backtrace_error_callback error_callback, void *data, |
| const char **string) |
| { |
| switch (val->encoding) |
| { |
| case ATTR_VAL_STRING: |
| *string = val->u.string; |
| return 1; |
| |
| case ATTR_VAL_STRING_INDEX: |
| { |
| uint64_t offset; |
| struct dwarf_buf offset_buf; |
| |
| offset = val->u.uint * (is_dwarf64 ? 8 : 4) + str_offsets_base; |
| if (offset + (is_dwarf64 ? 8 : 4) |
| >= dwarf_sections->size[DEBUG_STR_OFFSETS]) |
| { |
| error_callback (data, "DW_FORM_strx value out of range", 0); |
| return 0; |
| } |
| |
| offset_buf.name = ".debug_str_offsets"; |
| offset_buf.start = dwarf_sections->data[DEBUG_STR_OFFSETS]; |
| offset_buf.buf = dwarf_sections->data[DEBUG_STR_OFFSETS] + offset; |
| offset_buf.left = dwarf_sections->size[DEBUG_STR_OFFSETS] - offset; |
| offset_buf.is_bigendian = is_bigendian; |
| offset_buf.error_callback = error_callback; |
| offset_buf.data = data; |
| offset_buf.reported_underflow = 0; |
| |
| offset = read_offset (&offset_buf, is_dwarf64); |
| if (offset >= dwarf_sections->size[DEBUG_STR]) |
| { |
| dwarf_buf_error (&offset_buf, "DW_FORM_strx offset out of range"); |
| return 0; |
| } |
| *string = (const char *) dwarf_sections->data[DEBUG_STR] + offset; |
| return 1; |
| } |
| |
| default: |
| return 1; |
| } |
| } |
| |
| /* Set *ADDRESS to the real address for a ATTR_VAL_ADDRESS_INDEX. |
| Return 1 on success, 0 on error. */ |
| |
| static int |
| resolve_addr_index (const struct dwarf_sections *dwarf_sections, |
| uint64_t addr_base, int addrsize, int is_bigendian, |
| uint64_t addr_index, |
| backtrace_error_callback error_callback, void *data, |
| uint64_t *address) |
| { |
| uint64_t offset; |
| struct dwarf_buf addr_buf; |
| |
| offset = addr_index * addrsize + addr_base; |
| if (offset + addrsize >= dwarf_sections->size[DEBUG_ADDR]) |
| { |
| error_callback (data, "DW_FORM_addrx value out of range", 0); |
| return 0; |
| } |
| |
| addr_buf.name = ".debug_addr"; |
| addr_buf.start = dwarf_sections->data[DEBUG_ADDR]; |
| addr_buf.buf = dwarf_sections->data[DEBUG_ADDR] + offset; |
| addr_buf.left = dwarf_sections->size[DEBUG_ADDR] - offset; |
| addr_buf.is_bigendian = is_bigendian; |
| addr_buf.error_callback = error_callback; |
| addr_buf.data = data; |
| addr_buf.reported_underflow = 0; |
| |
| *address = read_address (&addr_buf, addrsize); |
| return 1; |
| } |
| |
| /* Compare a unit offset against a unit for bsearch. */ |
| |
| static int |
| units_search (const void *vkey, const void *ventry) |
| { |
| const size_t *key = (const size_t *) vkey; |
| const struct unit *entry = *((const struct unit *const *) ventry); |
| size_t offset; |
| |
| offset = *key; |
| if (offset < entry->low_offset) |
| return -1; |
| else if (offset >= entry->high_offset) |
| return 1; |
| else |
| return 0; |
| } |
| |
| /* Find a unit in PU containing OFFSET. */ |
| |
| static struct unit * |
| find_unit (struct unit **pu, size_t units_count, size_t offset) |
| { |
| struct unit **u; |
| u = bsearch (&offset, pu, units_count, sizeof (struct unit *), units_search); |
| return u == NULL ? NULL : *u; |
| } |
| |
| /* Compare function_addrs for qsort. When ranges are nested, make the |
| smallest one sort last. */ |
| |
| static int |
| function_addrs_compare (const void *v1, const void *v2) |
| { |
| const struct function_addrs *a1 = (const struct function_addrs *) v1; |
| const struct function_addrs *a2 = (const struct function_addrs *) v2; |
| |
| if (a1->low < a2->low) |
| return -1; |
| if (a1->low > a2->low) |
| return 1; |
| if (a1->high < a2->high) |
| return 1; |
| if (a1->high > a2->high) |
| return -1; |
| return strcmp (a1->function->name, a2->function->name); |
| } |
| |
| /* Compare a PC against a function_addrs for bsearch. Note that if |
| there are multiple ranges containing PC, which one will be returned |
| is unpredictable. We compensate for that in dwarf_fileline. */ |
| |
| static int |
| function_addrs_search (const void *vkey, const void *ventry) |
| { |
| const uintptr_t *key = (const uintptr_t *) vkey; |
| const struct function_addrs *entry = (const struct function_addrs *) ventry; |
| uintptr_t pc; |
| |
| pc = *key; |
| if (pc < entry->low) |
| return -1; |
| else if (pc >= entry->high) |
| return 1; |
| else |
| return 0; |
| } |
| |
| /* Add a new compilation unit address range to a vector. This is |
| called via add_ranges. Returns 1 on success, 0 on failure. */ |
| |
| static int |
| add_unit_addr (struct backtrace_state *state, void *rdata, |
| uint64_t lowpc, uint64_t highpc, |
| backtrace_error_callback error_callback, void *data, |
| void *pvec) |
| { |
| struct unit *u = (struct unit *) rdata; |
| struct unit_addrs_vector *vec = (struct unit_addrs_vector *) pvec; |
| struct unit_addrs *p; |
| |
| /* Try to merge with the last entry. */ |
| if (vec->count > 0) |
| { |
| p = (struct unit_addrs *) vec->vec.base + (vec->count - 1); |
| if ((lowpc == p->high || lowpc == p->high + 1) |
| && u == p->u) |
| { |
| if (highpc > p->high) |
| p->high = highpc; |
| return 1; |
| } |
| } |
| |
| p = ((struct unit_addrs *) |
| backtrace_vector_grow (state, sizeof (struct unit_addrs), |
| error_callback, data, &vec->vec)); |
| if (p == NULL) |
| return 0; |
| |
| p->low = lowpc; |
| p->high = highpc; |
| p->u = u; |
| |
| ++vec->count; |
| |
| return 1; |
| } |
| |
| /* Compare unit_addrs for qsort. When ranges are nested, make the |
| smallest one sort last. */ |
| |
| static int |
| unit_addrs_compare (const void *v1, const void *v2) |
| { |
| const struct unit_addrs *a1 = (const struct unit_addrs *) v1; |
| const struct unit_addrs *a2 = (const struct unit_addrs *) v2; |
| |
| if (a1->low < a2->low) |
| return -1; |
| if (a1->low > a2->low) |
| return 1; |
| if (a1->high < a2->high) |
| return 1; |
| if (a1->high > a2->high) |
| return -1; |
| if (a1->u->lineoff < a2->u->lineoff) |
| return -1; |
| if (a1->u->lineoff > a2->u->lineoff) |
| return 1; |
| return 0; |
| } |
| |
| /* Compare a PC against a unit_addrs for bsearch. Note that if there |
| are multiple ranges containing PC, which one will be returned is |
| unpredictable. We compensate for that in dwarf_fileline. */ |
| |
| static int |
| unit_addrs_search (const void *vkey, const void *ventry) |
| { |
| const uintptr_t *key = (const uintptr_t *) vkey; |
| const struct unit_addrs *entry = (const struct unit_addrs *) ventry; |
| uintptr_t pc; |
| |
| pc = *key; |
| if (pc < entry->low) |
| return -1; |
| else if (pc >= entry->high) |
| return 1; |
| else |
| return 0; |
| } |
| |
| /* Sort the line vector by PC. We want a stable sort here to maintain |
| the order of lines for the same PC values. Since the sequence is |
| being sorted in place, their addresses cannot be relied on to |
| maintain stability. That is the purpose of the index member. */ |
| |
| static int |
| line_compare (const void *v1, const void *v2) |
| { |
| const struct line *ln1 = (const struct line *) v1; |
| const struct line *ln2 = (const struct line *) v2; |
| |
| if (ln1->pc < ln2->pc) |
| return -1; |
| else if (ln1->pc > ln2->pc) |
| return 1; |
| else if (ln1->idx < ln2->idx) |
| return -1; |
| else if (ln1->idx > ln2->idx) |
| return 1; |
| else |
| return 0; |
| } |
| |
| /* Find a PC in a line vector. We always allocate an extra entry at |
| the end of the lines vector, so that this routine can safely look |
| at the next entry. Note that when there are multiple mappings for |
| the same PC value, this will return the last one. */ |
| |
| static int |
| line_search (const void *vkey, const void *ventry) |
| { |
| const uintptr_t *key = (const uintptr_t *) vkey; |
| const struct line *entry = (const struct line *) ventry; |
| uintptr_t pc; |
| |
| pc = *key; |
| if (pc < entry->pc) |
| return -1; |
| else if (pc >= (entry + 1)->pc) |
| return 1; |
| else |
| return 0; |
| } |
| |
| /* Sort the abbrevs by the abbrev code. This function is passed to |
| both qsort and bsearch. */ |
| |
| static int |
| abbrev_compare (const void *v1, const void *v2) |
| { |
| const struct abbrev *a1 = (const struct abbrev *) v1; |
| const struct abbrev *a2 = (const struct abbrev *) v2; |
| |
| if (a1->code < a2->code) |
| return -1; |
| else if (a1->code > a2->code) |
| return 1; |
| else |
| { |
| /* This really shouldn't happen. It means there are two |
| different abbrevs with the same code, and that means we don't |
| know which one lookup_abbrev should return. */ |
| return 0; |
| } |
| } |
| |
| /* Read the abbreviation table for a compilation unit. Returns 1 on |
| success, 0 on failure. */ |
| |
| static int |
| read_abbrevs (struct backtrace_state *state, uint64_t abbrev_offset, |
| const unsigned char *dwarf_abbrev, size_t dwarf_abbrev_size, |
| int is_bigendian, backtrace_error_callback error_callback, |
| void *data, struct abbrevs *abbrevs) |
| { |
| struct dwarf_buf abbrev_buf; |
| struct dwarf_buf count_buf; |
| size_t num_abbrevs; |
| |
| abbrevs->num_abbrevs = 0; |
| abbrevs->abbrevs = NULL; |
| |
| if (abbrev_offset >= dwarf_abbrev_size) |
| { |
| error_callback (data, "abbrev offset out of range", 0); |
| return 0; |
| } |
| |
| abbrev_buf.name = ".debug_abbrev"; |
| abbrev_buf.start = dwarf_abbrev; |
| abbrev_buf.buf = dwarf_abbrev + abbrev_offset; |
| abbrev_buf.left = dwarf_abbrev_size - abbrev_offset; |
| abbrev_buf.is_bigendian = is_bigendian; |
| abbrev_buf.error_callback = error_callback; |
| abbrev_buf.data = data; |
| abbrev_buf.reported_underflow = 0; |
| |
| /* Count the number of abbrevs in this list. */ |
| |
| count_buf = abbrev_buf; |
| num_abbrevs = 0; |
| while (read_uleb128 (&count_buf) != 0) |
| { |
| if (count_buf.reported_underflow) |
| return 0; |
| ++num_abbrevs; |
| // Skip tag. |
| read_uleb128 (&count_buf); |
| // Skip has_children. |
| read_byte (&count_buf); |
| // Skip attributes. |
| while (read_uleb128 (&count_buf) != 0) |
| { |
| uint64_t form; |
| |
| form = read_uleb128 (&count_buf); |
| if ((enum dwarf_form) form == DW_FORM_implicit_const) |
| read_sleb128 (&count_buf); |
| } |
| // Skip form of last attribute. |
| read_uleb128 (&count_buf); |
| } |
| |
| if (count_buf.reported_underflow) |
| return 0; |
| |
| if (num_abbrevs == 0) |
| return 1; |
| |
| abbrevs->abbrevs = ((struct abbrev *) |
| backtrace_alloc (state, |
| num_abbrevs * sizeof (struct abbrev), |
| error_callback, data)); |
| if (abbrevs->abbrevs == NULL) |
| return 0; |
| abbrevs->num_abbrevs = num_abbrevs; |
| memset (abbrevs->abbrevs, 0, num_abbrevs * sizeof (struct abbrev)); |
| |
| num_abbrevs = 0; |
| while (1) |
| { |
| uint64_t code; |
| struct abbrev a; |
| size_t num_attrs; |
| struct attr *attrs; |
| |
| if (abbrev_buf.reported_underflow) |
| goto fail; |
| |
| code = read_uleb128 (&abbrev_buf); |
| if (code == 0) |
| break; |
| |
| a.code = code; |
| a.tag = (enum dwarf_tag) read_uleb128 (&abbrev_buf); |
| a.has_children = read_byte (&abbrev_buf); |
| |
| count_buf = abbrev_buf; |
| num_attrs = 0; |
| while (read_uleb128 (&count_buf) != 0) |
| { |
| uint64_t form; |
| |
| ++num_attrs; |
| form = read_uleb128 (&count_buf); |
| if ((enum dwarf_form) form == DW_FORM_implicit_const) |
| read_sleb128 (&count_buf); |
| } |
| |
| if (num_attrs == 0) |
| { |
| attrs = NULL; |
| read_uleb128 (&abbrev_buf); |
| read_uleb128 (&abbrev_buf); |
| } |
| else |
| { |
| attrs = ((struct attr *) |
| backtrace_alloc (state, num_attrs * sizeof *attrs, |
| error_callback, data)); |
| if (attrs == NULL) |
| goto fail; |
| num_attrs = 0; |
| while (1) |
| { |
| uint64_t name; |
| uint64_t form; |
| |
| name = read_uleb128 (&abbrev_buf); |
| form = read_uleb128 (&abbrev_buf); |
| if (name == 0) |
| break; |
| attrs[num_attrs].name = (enum dwarf_attribute) name; |
| attrs[num_attrs].form = (enum dwarf_form) form; |
| if ((enum dwarf_form) form == DW_FORM_implicit_const) |
| attrs[num_attrs].val = read_sleb128 (&abbrev_buf); |
| else |
| attrs[num_attrs].val = 0; |
| ++num_attrs; |
| } |
| } |
| |
| a.num_attrs = num_attrs; |
| a.attrs = attrs; |
| |
| abbrevs->abbrevs[num_abbrevs] = a; |
| ++num_abbrevs; |
| } |
| |
| backtrace_qsort (abbrevs->abbrevs, abbrevs->num_abbrevs, |
| sizeof (struct abbrev), abbrev_compare); |
| |
| return 1; |
| |
| fail: |
| free_abbrevs (state, abbrevs, error_callback, data); |
| return 0; |
| } |
| |
| /* Return the abbrev information for an abbrev code. */ |
| |
| static const struct abbrev * |
| lookup_abbrev (struct abbrevs *abbrevs, uint64_t code, |
| backtrace_error_callback error_callback, void *data) |
| { |
| struct abbrev key; |
| void *p; |
| |
| /* With GCC, where abbrevs are simply numbered in order, we should |
| be able to just look up the entry. */ |
| if (code - 1 < abbrevs->num_abbrevs |
| && abbrevs->abbrevs[code - 1].code == code) |
| return &abbrevs->abbrevs[code - 1]; |
| |
| /* Otherwise we have to search. */ |
| memset (&key, 0, sizeof key); |
| key.code = code; |
| p = bsearch (&key, abbrevs->abbrevs, abbrevs->num_abbrevs, |
| sizeof (struct abbrev), abbrev_compare); |
| if (p == NULL) |
| { |
| error_callback (data, "invalid abbreviation code", 0); |
| return NULL; |
| } |
| return (const struct abbrev *) p; |
| } |
| |
| /* This struct is used to gather address range information while |
| reading attributes. We use this while building a mapping from |
| address ranges to compilation units and then again while mapping |
| from address ranges to function entries. Normally either |
| lowpc/highpc is set or ranges is set. */ |
| |
| struct pcrange { |
| uint64_t lowpc; /* The low PC value. */ |
| int have_lowpc; /* Whether a low PC value was found. */ |
| int lowpc_is_addr_index; /* Whether lowpc is in .debug_addr. */ |
| uint64_t highpc; /* The high PC value. */ |
| int have_highpc; /* Whether a high PC value was found. */ |
| int highpc_is_relative; /* Whether highpc is relative to lowpc. */ |
| int highpc_is_addr_index; /* Whether highpc is in .debug_addr. */ |
| uint64_t ranges; /* Offset in ranges section. */ |
| int have_ranges; /* Whether ranges is valid. */ |
| int ranges_is_index; /* Whether ranges is DW_FORM_rnglistx. */ |
| }; |
| |
| /* Update PCRANGE from an attribute value. */ |
| |
| static void |
| update_pcrange (const struct attr* attr, const struct attr_val* val, |
| struct pcrange *pcrange) |
| { |
| switch (attr->name) |
| { |
| case DW_AT_low_pc: |
| if (val->encoding == ATTR_VAL_ADDRESS) |
| { |
| pcrange->lowpc = val->u.uint; |
| pcrange->have_lowpc = 1; |
| } |
| else if (val->encoding == ATTR_VAL_ADDRESS_INDEX) |
| { |
| pcrange->lowpc = val->u.uint; |
| pcrange->have_lowpc = 1; |
| pcrange->lowpc_is_addr_index = 1; |
| } |
| break; |
| |
| case DW_AT_high_pc: |
| if (val->encoding == ATTR_VAL_ADDRESS) |
| { |
| pcrange->highpc = val->u.uint; |
| pcrange->have_highpc = 1; |
| } |
| else if (val->encoding == ATTR_VAL_UINT) |
| { |
| pcrange->highpc = val->u.uint; |
| pcrange->have_highpc = 1; |
| pcrange->highpc_is_relative = 1; |
| } |
| else if (val->encoding == ATTR_VAL_ADDRESS_INDEX) |
| { |
| pcrange->highpc = val->u.uint; |
| pcrange->have_highpc = 1; |
| pcrange->highpc_is_addr_index = 1; |
| } |
| break; |
| |
| case DW_AT_ranges: |
| if (val->encoding == ATTR_VAL_UINT |
| || val->encoding == ATTR_VAL_REF_SECTION) |
| { |
| pcrange->ranges = val->u.uint; |
| pcrange->have_ranges = 1; |
| } |
| else if (val->encoding == ATTR_VAL_RNGLISTS_INDEX) |
| { |
| pcrange->ranges = val->u.uint; |
| pcrange->have_ranges = 1; |
| pcrange->ranges_is_index = 1; |
| } |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| /* Call ADD_RANGE for a low/high PC pair. Returns 1 on success, 0 on |
| error. */ |
| |
| static int |
| add_low_high_range (struct backtrace_state *state, |
| const struct dwarf_sections *dwarf_sections, |
| uintptr_t base_address, int is_bigendian, |
| struct unit *u, const struct pcrange *pcrange, |
| int (*add_range) (struct backtrace_state *state, |
| void *rdata, uint64_t lowpc, |
| uint64_t highpc, |
| backtrace_error_callback error_callback, |
| void *data, void *vec), |
| void *rdata, |
| backtrace_error_callback error_callback, void *data, |
| void *vec) |
| { |
| uint64_t lowpc; |
| uint64_t highpc; |
| |
| lowpc = pcrange->lowpc; |
| if (pcrange->lowpc_is_addr_index) |
| { |
| if (!resolve_addr_index (dwarf_sections, u->addr_base, u->addrsize, |
| is_bigendian, lowpc, error_callback, data, |
| &lowpc)) |
| return 0; |
| } |
| |
| highpc = pcrange->highpc; |
| if (pcrange->highpc_is_addr_index) |
| { |
| if (!resolve_addr_index (dwarf_sections, u->addr_base, u->addrsize, |
| is_bigendian, highpc, error_callback, data, |
| &highpc)) |
| return 0; |
| } |
| if (pcrange->highpc_is_relative) |
| highpc += lowpc; |
| |
| /* Add in the base address of the module when recording PC values, |
| so that we can look up the PC directly. */ |
| lowpc += base_address; |
| highpc += base_address; |
| |
| return add_range (state, rdata, lowpc, highpc, error_callback, data, vec); |
| } |
| |
| /* Call ADD_RANGE for each range read from .debug_ranges, as used in |
| DWARF versions 2 through 4. */ |
| |
| static int |
| add_ranges_from_ranges ( |
| struct backtrace_state *state, |
| const struct dwarf_sections *dwarf_sections, |
| uintptr_t base_address, int is_bigendian, |
| struct unit *u, uint64_t base, |
| const struct pcrange *pcrange, |
| int (*add_range) (struct backtrace_state *state, void *rdata, |
| uint64_t lowpc, uint64_t highpc, |
| backtrace_error_callback error_callback, void *data, |
| void *vec), |
| void *rdata, |
| backtrace_error_callback error_callback, void *data, |
| void *vec) |
| { |
| struct dwarf_buf ranges_buf; |
| |
| if (pcrange->ranges >= dwarf_sections->size[DEBUG_RANGES]) |
| { |
| error_callback (data, "ranges offset out of range", 0); |
| return 0; |
| } |
| |
| ranges_buf.name = ".debug_ranges"; |
| ranges_buf.start = dwarf_sections->data[DEBUG_RANGES]; |
| ranges_buf.buf = dwarf_sections->data[DEBUG_RANGES] + pcrange->ranges; |
| ranges_buf.left = dwarf_sections->size[DEBUG_RANGES] - pcrange->ranges; |
| ranges_buf.is_bigendian = is_bigendian; |
| ranges_buf.error_callback = error_callback; |
| ranges_buf.data = data; |
| ranges_buf.reported_underflow = 0; |
| |
| while (1) |
| { |
| uint64_t low; |
| uint64_t high; |
| |
| if (ranges_buf.reported_underflow) |
| return 0; |
| |
| low = read_address (&ranges_buf, u->addrsize); |
| high = read_address (&ranges_buf, u->addrsize); |
| |
| if (low == 0 && high == 0) |
| break; |
| |
| if (is_highest_address (low, u->addrsize)) |
| base = high; |
| else |
| { |
| if (!add_range (state, rdata, |
| low + base + base_address, |
| high + base + base_address, |
| error_callback, data, vec)) |
| return 0; |
| } |
| } |
| |
| if (ranges_buf.reported_underflow) |
| return 0; |
| |
| return 1; |
| } |
| |
| /* Call ADD_RANGE for each range read from .debug_rnglists, as used in |
| DWARF version 5. */ |
| |
| static int |
| add_ranges_from_rnglists ( |
| struct backtrace_state *state, |
| const struct dwarf_sections *dwarf_sections, |
| uintptr_t base_address, int is_bigendian, |
| struct unit *u, uint64_t base, |
| const struct pcrange *pcrange, |
| int (*add_range) (struct backtrace_state *state, void *rdata, |
| uint64_t lowpc, uint64_t highpc, |
| backtrace_error_callback error_callback, void *data, |
| void *vec), |
| void *rdata, |
| backtrace_error_callback error_callback, void *data, |
| void *vec) |
| { |
| uint64_t offset; |
| struct dwarf_buf rnglists_buf; |
| |
| if (!pcrange->ranges_is_index) |
| offset = pcrange->ranges; |
| else |
| offset = u->rnglists_base + pcrange->ranges * (u->is_dwarf64 ? 8 : 4); |
| if (offset >= dwarf_sections->size[DEBUG_RNGLISTS]) |
| { |
| error_callback (data, "rnglists offset out of range", 0); |
| return 0; |
| } |
| |
| rnglists_buf.name = ".debug_rnglists"; |
| rnglists_buf.start = dwarf_sections->data[DEBUG_RNGLISTS]; |
| rnglists_buf.buf = dwarf_sections->data[DEBUG_RNGLISTS] + offset; |
| rnglists_buf.left = dwarf_sections->size[DEBUG_RNGLISTS] - offset; |
| rnglists_buf.is_bigendian = is_bigendian; |
| rnglists_buf.error_callback = error_callback; |
| rnglists_buf.data = data; |
| rnglists_buf.reported_underflow = 0; |
| |
| if (pcrange->ranges_is_index) |
| { |
| offset = read_offset (&rnglists_buf, u->is_dwarf64); |
| offset += u->rnglists_base; |
| if (offset >= dwarf_sections->size[DEBUG_RNGLISTS]) |
| { |
| error_callback (data, "rnglists index offset out of range", 0); |
| return 0; |
| } |
| rnglists_buf.buf = dwarf_sections->data[DEBUG_RNGLISTS] + offset; |
| rnglists_buf.left = dwarf_sections->size[DEBUG_RNGLISTS] - offset; |
| } |
| |
| while (1) |
| { |
| unsigned char rle; |
| |
| rle = read_byte (&rnglists_buf); |
| if (rle == DW_RLE_end_of_list) |
| break; |
| switch (rle) |
| { |
| case DW_RLE_base_addressx: |
| { |
| uint64_t index; |
| |
| index = read_uleb128 (&rnglists_buf); |
| if (!resolve_addr_index (dwarf_sections, u->addr_base, |
| u->addrsize, is_bigendian, index, |
| error_callback, data, &base)) |
| return 0; |
| } |
| break; |
| |
| case DW_RLE_startx_endx: |
| { |
| uint64_t index; |
| uint64_t low; |
| uint64_t high; |
| |
| index = read_uleb128 (&rnglists_buf); |
| if (!resolve_addr_index (dwarf_sections, u->addr_base, |
| u->addrsize, is_bigendian, index, |
| error_callback, data, &low)) |
| return 0; |
| index = read_uleb128 (&rnglists_buf); |
| if (!resolve_addr_index (dwarf_sections, u->addr_base, |
| u->addrsize, is_bigendian, index, |
| error_callback, data, &high)) |
| return 0; |
| if (!add_range (state, rdata, low + base_address, |
| high + base_address, error_callback, data, |
| vec)) |
| return 0; |
| } |
| break; |
| |
| case DW_RLE_startx_length: |
| { |
| uint64_t index; |
| uint64_t low; |
| uint64_t length; |
| |
| index = read_uleb128 (&rnglists_buf); |
| if (!resolve_addr_index (dwarf_sections, u->addr_base, |
| u->addrsize, is_bigendian, index, |
| error_callback, data, &low)) |
| return 0; |
| length = read_uleb128 (&rnglists_buf); |
| low += base_address; |
| if (!add_range (state, rdata, low, low + length, |
| error_callback, data, vec)) |
| return 0; |
| } |
| break; |
| |
| case DW_RLE_offset_pair: |
| { |
| uint64_t low; |
| uint64_t high; |
| |
| low = read_uleb128 (&rnglists_buf); |
| high = read_uleb128 (&rnglists_buf); |
| if (!add_range (state, rdata, low + base + base_address, |
| high + base + base_address, |
| error_callback, data, vec)) |
| return 0; |
| } |
| break; |
| |
| case DW_RLE_base_address: |
| base = read_address (&rnglists_buf, u->addrsize); |
| break; |
| |
| case DW_RLE_start_end: |
| { |
| uint64_t low; |
| uint64_t high; |
| |
| low = read_address (&rnglists_buf, u->addrsize); |
| high = read_address (&rnglists_buf, u->addrsize); |
| if (!add_range (state, rdata, low + base_address, |
| high + base_address, error_callback, data, |
| vec)) |
| return 0; |
| } |
| break; |
| |
| case DW_RLE_start_length: |
| { |
| uint64_t low; |
| uint64_t length; |
| |
| low = read_address (&rnglists_buf, u->addrsize); |
| length = read_uleb128 (&rnglists_buf); |
| low += base_address; |
| if (!add_range (state, rdata, low, low + length, |
| error_callback, data, vec)) |
| return 0; |
| } |
| break; |
| |
| default: |
| dwarf_buf_error (&rnglists_buf, "unrecognized DW_RLE value"); |
| return 0; |
| } |
| } |
| |
| if (rnglists_buf.reported_underflow) |
| return 0; |
| |
| return 1; |
| } |
| |
| /* Call ADD_RANGE for each lowpc/highpc pair in PCRANGE. RDATA is |
| passed to ADD_RANGE, and is either a struct unit * or a struct |
| function *. VEC is the vector we are adding ranges to, and is |
| either a struct unit_addrs_vector * or a struct function_vector *. |
| Returns 1 on success, 0 on error. */ |
| |
| static int |
| add_ranges (struct backtrace_state *state, |
| const struct dwarf_sections *dwarf_sections, |
| uintptr_t base_address, int is_bigendian, |
| struct unit *u, uint64_t base, const struct pcrange *pcrange, |
| int (*add_range) (struct backtrace_state *state, void *rdata, |
| uint64_t lowpc, uint64_t highpc, |
| backtrace_error_callback error_callback, |
| void *data, void *vec), |
| void *rdata, |
| backtrace_error_callback error_callback, void *data, |
| void *vec) |
| { |
| if (pcrange->have_lowpc && pcrange->have_highpc) |
| return add_low_high_range (state, dwarf_sections, base_address, |
| is_bigendian, u, pcrange, add_range, rdata, |
| error_callback, data, vec); |
| |
| if (!pcrange->have_ranges) |
| { |
| /* Did not find any address ranges to add. */ |
| return 1; |
| } |
| |
| if (u->version < 5) |
| return add_ranges_from_ranges (state, dwarf_sections, base_address, |
| is_bigendian, u, base, pcrange, add_range, |
| rdata, error_callback, data, vec); |
| else |
| return add_ranges_from_rnglists (state, dwarf_sections, base_address, |
| is_bigendian, u, base, pcrange, add_range, |
| rdata, error_callback, data, vec); |
| } |
| |
| /* Find the address range covered by a compilation unit, reading from |
| UNIT_BUF and adding values to U. Returns 1 if all data could be |
| read, 0 if there is some error. */ |
| |
| static int |
| find_address_ranges (struct backtrace_state *state, uintptr_t base_address, |
| struct dwarf_buf *unit_buf, |
| const struct dwarf_sections *dwarf_sections, |
| int is_bigendian, struct dwarf_data *altlink, |
| backtrace_error_callback error_callback, void *data, |
| struct unit *u, struct unit_addrs_vector *addrs, |
| enum dwarf_tag *unit_tag) |
| { |
| while (unit_buf->left > 0) |
| { |
| uint64_t code; |
| const struct abbrev *abbrev; |
| struct pcrange pcrange; |
| struct attr_val name_val; |
| int have_name_val; |
| struct attr_val comp_dir_val; |
| int have_comp_dir_val; |
| size_t i; |
| |
| code = read_uleb128 (unit_buf); |
| if (code == 0) |
| return 1; |
| |
| abbrev = lookup_abbrev (&u->abbrevs, code, error_callback, data); |
| if (abbrev == NULL) |
| return 0; |
| |
| if (unit_tag != NULL) |
| *unit_tag = abbrev->tag; |
| |
| memset (&pcrange, 0, sizeof pcrange); |
| memset (&name_val, 0, sizeof name_val); |
| have_name_val = 0; |
| memset (&comp_dir_val, 0, sizeof comp_dir_val); |
| have_comp_dir_val = 0; |
| for (i = 0; i < abbrev->num_attrs; ++i) |
| { |
| struct attr_val val; |
| |
| if (!read_attribute (abbrev->attrs[i].form, abbrev->attrs[i].val, |
| unit_buf, u->is_dwarf64, u->version, |
| u->addrsize, dwarf_sections, altlink, &val)) |
| return 0; |
| |
| switch (abbrev->attrs[i].name) |
| { |
| case DW_AT_low_pc: case DW_AT_high_pc: case DW_AT_ranges: |
| update_pcrange (&abbrev->attrs[i], &val, &pcrange); |
| break; |
| |
| case DW_AT_stmt_list: |
| if (abbrev->tag == DW_TAG_compile_unit |
| && (val.encoding == ATTR_VAL_UINT |
| || val.encoding == ATTR_VAL_REF_SECTION)) |
| u->lineoff = val.u.uint; |
| break; |
| |
| case DW_AT_name: |
| if (abbrev->tag == DW_TAG_compile_unit) |
| { |
| name_val = val; |
| have_name_val = 1; |
| } |
| break; |
| |
| case DW_AT_comp_dir: |
| if (abbrev->tag == DW_TAG_compile_unit) |
| { |
| comp_dir_val = val; |
| have_comp_dir_val = 1; |
| } |
| break; |
| |
| case DW_AT_str_offsets_base: |
| if (abbrev->tag == DW_TAG_compile_unit |
| && val.encoding == ATTR_VAL_REF_SECTION) |
| u->str_offsets_base = val.u.uint; |
| break; |
| |
| case DW_AT_addr_base: |
| if (abbrev->tag == DW_TAG_compile_unit |
| && val.encoding == ATTR_VAL_REF_SECTION) |
| u->addr_base = val.u.uint; |
| break; |
| |
| case DW_AT_rnglists_base: |
| if (abbrev->tag == DW_TAG_compile_unit |
| && val.encoding == ATTR_VAL_REF_SECTION) |
| u->rnglists_base = val.u.uint; |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| // Resolve strings after we're sure that we have seen |
| // DW_AT_str_offsets_base. |
| if (have_name_val) |
| { |
| if (!resolve_string (dwarf_sections, u->is_dwarf64, is_bigendian, |
| u->str_offsets_base, &name_val, |
| error_callback, data, &u->filename)) |
| return 0; |
| } |
| if (have_comp_dir_val) |
| { |
| if (!resolve_string (dwarf_sections, u->is_dwarf64, is_bigendian, |
| u->str_offsets_base, &comp_dir_val, |
| error_callback, data, &u->comp_dir)) |
| return 0; |
| } |
| |
| if (abbrev->tag == DW_TAG_compile_unit |
| || abbrev->tag == DW_TAG_subprogram) |
| { |
| if (!add_ranges (state, dwarf_sections, base_address, |
| is_bigendian, u, pcrange.lowpc, &pcrange, |
| add_unit_addr, (void *) u, error_callback, data, |
| (void *) addrs)) |
| return 0; |
| |
| /* If we found the PC range in the DW_TAG_compile_unit, we |
| can stop now. */ |
| if (abbrev->tag == DW_TAG_compile_unit |
| && (pcrange.have_ranges |
| || (pcrange.have_lowpc && pcrange.have_highpc))) |
| return 1; |
| } |
| |
| if (abbrev->has_children) |
| { |
| if (!find_address_ranges (state, base_address, unit_buf, |
| dwarf_sections, is_bigendian, altlink, |
| error_callback, data, u, addrs, NULL)) |
| return 0; |
| } |
| } |
| |
| return 1; |
| } |
| |
| /* Build a mapping from address ranges to the compilation units where |
| the line number information for that range can be found. Returns 1 |
| on success, 0 on failure. */ |
| |
| static int |
| build_address_map (struct backtrace_state *state, uintptr_t base_address, |
| const struct dwarf_sections *dwarf_sections, |
| int is_bigendian, struct dwarf_data *altlink, |
| backtrace_error_callback error_callback, void *data, |
| struct unit_addrs_vector *addrs, |
| struct unit_vector *unit_vec) |
| { |
| struct dwarf_buf info; |
| struct backtrace_vector units; |
| size_t units_count; |
| size_t i; |
| struct unit **pu; |
| size_t unit_offset = 0; |
| |
| memset (&addrs->vec, 0, sizeof addrs->vec); |
| memset (&unit_vec->vec, 0, sizeof unit_vec->vec); |
| addrs->count = 0; |
| unit_vec->count = 0; |
| |
| /* Read through the .debug_info section. FIXME: Should we use the |
| .debug_aranges section? gdb and addr2line don't use it, but I'm |
| not sure why. */ |
| |
| info.name = ".debug_info"; |
| info.start = dwarf_sections->data[DEBUG_INFO]; |
| info.buf = info.start; |
| info.left = dwarf_sections->size[DEBUG_INFO]; |
| info.is_bigendian = is_bigendian; |
| info.error_callback = error_callback; |
| info.data = data; |
| info.reported_underflow = 0; |
| |
| memset (&units, 0, sizeof units); |
| units_count = 0; |
| |
| while (info.left > 0) |
| { |
| const unsigned char *unit_data_start; |
| uint64_t len; |
| int is_dwarf64; |
| struct dwarf_buf unit_buf; |
| int version; |
| int unit_type; |
| uint64_t abbrev_offset; |
| int addrsize; |
| struct unit *u; |
| enum dwarf_tag unit_tag; |
| |
| if (info.reported_underflow) |
| goto fail; |
| |
| unit_data_start = info.buf; |
| |
| len = read_initial_length (&info, &is_dwarf64); |
| unit_buf = info; |
| unit_buf.left = len; |
| |
| if (!advance (&info, len)) |
| goto fail; |
| |
| version = read_uint16 (&unit_buf); |
| if (version < 2 || version > 5) |
| { |
| dwarf_buf_error (&unit_buf, "unrecognized DWARF version"); |
| goto fail; |
| } |
| |
| if (version < 5) |
| unit_type = 0; |
| else |
| { |
| unit_type = read_byte (&unit_buf); |
| if (unit_type == DW_UT_type || unit_type == DW_UT_split_type) |
| { |
| /* This unit doesn't have anything we need. */ |
| continue; |
| } |
| } |
| |
| pu = ((struct unit **) |
| backtrace_vector_grow (state, sizeof (struct unit *), |
| error_callback, data, &units)); |
| if (pu == NULL) |
| goto fail; |
| |
| u = ((struct unit *) |
| backtrace_alloc (state, sizeof *u, error_callback, data)); |
| if (u == NULL) |
| goto fail; |
| |
| *pu = u; |
| ++units_count; |
| |
| if (version < 5) |
| addrsize = 0; /* Set below. */ |
| else |
| addrsize = read_byte (&unit_buf); |
| |
| memset (&u->abbrevs, 0, sizeof u->abbrevs); |
| abbrev_offset = read_offset (&unit_buf, is_dwarf64); |
| if (!read_abbrevs (state, abbrev_offset, |
| dwarf_sections->data[DEBUG_ABBREV], |
| dwarf_sections->size[DEBUG_ABBREV], |
| is_bigendian, error_callback, data, &u->abbrevs)) |
| goto fail; |
| |
| if (version < 5) |
| addrsize = read_byte (&unit_buf); |
| |
| switch (unit_type) |
| { |
| case 0: |
| break; |
| case DW_UT_compile: case DW_UT_partial: |
| break; |
| case DW_UT_skeleton: case DW_UT_split_compile: |
| read_uint64 (&unit_buf); /* dwo_id */ |
| break; |
| default: |
| break; |
| } |
| |
| u->low_offset = unit_offset; |
| unit_offset += len + (is_dwarf64 ? 12 : 4); |
| u->high_offset = unit_offset; |
| u->unit_data = unit_buf.buf; |
| u->unit_data_len = unit_buf.left; |
| u->unit_data_offset = unit_buf.buf - unit_data_start; |
| u->version = version; |
| u->is_dwarf64 = is_dwarf64; |
| u->addrsize = addrsize; |
| u->filename = NULL; |
| u->comp_dir = NULL; |
| u->abs_filename = NULL; |
| u->lineoff = 0; |
| |
| /* The actual line number mappings will be read as needed. */ |
| u->lines = NULL; |
| u->lines_count = 0; |
| u->function_addrs = NULL; |
| u->function_addrs_count = 0; |
| |
| if (!find_address_ranges (state, base_address, &unit_buf, dwarf_sections, |
| is_bigendian, altlink, error_callback, data, |
| u, addrs, &unit_tag)) |
| goto fail; |
| |
| if (unit_buf.reported_underflow) |
| goto fail; |
| } |
| if (info.reported_underflow) |
| goto fail; |
| |
| unit_vec->vec = units; |
| unit_vec->count = units_count; |
| return 1; |
| |
| fail: |
| if (units_count > 0) |
| { |
| pu = (struct unit **) units.base; |
| for (i = 0; i < units_count; i++) |
| { |
| free_abbrevs (state, &pu[i]->abbrevs, error_callback, data); |
| backtrace_free (state, pu[i], sizeof **pu, error_callback, data); |
| } |
| backtrace_vector_free (state, &units, error_callback, data); |
| } |
| if (addrs->count > 0) |
| { |
| backtrace_vector_free (state, &addrs->vec, error_callback, data); |
| addrs->count = 0; |
| } |
| return 0; |
| } |
| |
| /* Add a new mapping to the vector of line mappings that we are |
| building. Returns 1 on success, 0 on failure. */ |
| |
| static int |
| add_line (struct backtrace_state *state, struct dwarf_data *ddata, |
| uintptr_t pc, const char *filename, int lineno, |
| backtrace_error_callback error_callback, void *data, |
| struct line_vector *vec) |
| { |
| struct line *ln; |
| |
| /* If we are adding the same mapping, ignore it. This can happen |
| when using discriminators. */ |
| if (vec->count > 0) |
| { |
| ln = (struct line *) vec->vec.base + (vec->count - 1); |
| if (pc == ln->pc && filename == ln->filename && lineno == ln->lineno) |
| return 1; |
| } |
| |
| ln = ((struct line *) |
| backtrace_vector_grow (state, sizeof (struct line), error_callback, |
| data, &vec->vec)); |
| if (ln == NULL) |
| return 0; |
| |
| /* Add in the base address here, so that we can look up the PC |
| directly. */ |
| ln->pc = pc + ddata->base_address; |
| |
| ln->filename = filename; |
| ln->lineno = lineno; |
| ln->idx = vec->count; |
| |
| ++vec->count; |
| |
| return 1; |
| } |
| |
| /* Free the line header information. */ |
| |
| static void |
| free_line_header (struct backtrace_state *state, struct line_header *hdr, |
| backtrace_error_callback error_callback, void *data) |
| { |
| if (hdr->dirs_count != 0) |
| backtrace_free (state, hdr->dirs, hdr->dirs_count * sizeof (const char *), |
| error_callback, data); |
| backtrace_free (state, hdr->filenames, |
| hdr->filenames_count * sizeof (char *), |
| error_callback, data); |
| } |
| |
| /* Read the directories and file names for a line header for version |
| 2, setting fields in HDR. Return 1 on success, 0 on failure. */ |
| |
| static int |
| read_v2_paths (struct backtrace_state *state, struct unit *u, |
| struct dwarf_buf *hdr_buf, struct line_header *hdr) |
| { |
| const unsigned char *p; |
| const unsigned char *pend; |
| size_t i; |
| |
| /* Count the number of directory entries. */ |
| hdr->dirs_count = 0; |
| p = hdr_buf->buf; |
| pend = p + hdr_buf->left; |
| while (p < pend && *p != '\0') |
| { |
| p += strnlen((const char *) p, pend - p) + 1; |
| ++hdr->dirs_count; |
| } |
| |
| hdr->dirs = NULL; |
| if (hdr->dirs_count != 0) |
| { |
| hdr->dirs = ((const char **) |
| backtrace_alloc (state, |
| hdr->dirs_count * sizeof (const char *), |
| hdr_buf->error_callback, |
| hdr_buf->data)); |
| if (hdr->dirs == NULL) |
| return 0; |
| } |
| |
| i = 0; |
| while (*hdr_buf->buf != '\0') |
| { |
| if (hdr_buf->reported_underflow) |
| return 0; |
| |
| hdr->dirs[i] = read_string (hdr_buf); |
| if (hdr->dirs[i] == NULL) |
| return 0; |
| ++i; |
| } |
| if (!advance (hdr_buf, 1)) |
| return 0; |
| |
| /* Count the number of file entries. */ |
| hdr->filenames_count = 0; |
| p = hdr_buf->buf; |
| pend = p + hdr_buf->left; |
| while (p < pend && *p != '\0') |
| { |
| p += strnlen ((const char *) p, pend - p) + 1; |
| p += leb128_len (p); |
| p += leb128_len (p); |
| p += leb128_len (p); |
| ++hdr->filenames_count; |
| } |
| |
| hdr->filenames = ((const char **) |
| backtrace_alloc (state, |
| hdr->filenames_count * sizeof (char *), |
| hdr_buf->error_callback, |
| hdr_buf->data)); |
| if (hdr->filenames == NULL) |
| return 0; |
| i = 0; |
| while (*hdr_buf->buf != '\0') |
| { |
| const char *filename; |
| uint64_t dir_index; |
| |
| if (hdr_buf->reported_underflow) |
| return 0; |
| |
| filename = read_string (hdr_buf); |
| if (filename == NULL) |
| return 0; |
| dir_index = read_uleb128 (hdr_buf); |
| if (IS_ABSOLUTE_PATH (filename) |
| || (dir_index == 0 && u->comp_dir == NULL)) |
| hdr->filenames[i] = filename; |
| else |
| { |
| const char *dir; |
| size_t dir_len; |
| size_t filename_len; |
| char *s; |
| |
| if (dir_index == 0) |
| dir = u->comp_dir; |
| else if (dir_index - 1 < hdr->dirs_count) |
| dir = hdr->dirs[dir_index - 1]; |
| else |
| { |
| dwarf_buf_error (hdr_buf, |
| ("invalid directory index in " |
| "line number program header")); |
| return 0; |
| } |
| dir_len = strlen (dir); |
| filename_len = strlen (filename); |
| s = ((char *) backtrace_alloc (state, dir_len + filename_len + 2, |
| hdr_buf->error_callback, |
| hdr_buf->data)); |
| if (s == NULL) |
| return 0; |
| memcpy (s, dir, dir_len); |
| /* FIXME: If we are on a DOS-based file system, and the |
| directory or the file name use backslashes, then we |
| should use a backslash here. */ |
| s[dir_len] = '/'; |
| memcpy (s + dir_len + 1, filename, filename_len + 1); |
| hdr->filenames[i] = s; |
| } |
| |
| /* Ignore the modification time and size. */ |
| read_uleb128 (hdr_buf); |
| read_uleb128 (hdr_buf); |
| |
| ++i; |
| } |
| |
| return 1; |
| } |
| |
| /* Read a single version 5 LNCT entry for a directory or file name in a |
| line header. Sets *STRING to the resulting name, ignoring other |
| data. Return 1 on success, 0 on failure. */ |
| |
| static int |
| read_lnct (struct backtrace_state *state, struct dwarf_data *ddata, |
| struct unit *u, struct dwarf_buf *hdr_buf, |
| const struct line_header *hdr, size_t formats_count, |
| const struct line_header_format *formats, const char **string) |
| { |
| size_t i; |
| const char *dir; |
| const char *path; |
| |
| dir = NULL; |
| path = NULL; |
| for (i = 0; i < formats_count; i++) |
| { |
| struct attr_val val; |
| |
| if (!read_attribute (formats[i].form, 0, hdr_buf, u->is_dwarf64, |
| u->version, hdr->addrsize, &ddata->dwarf_sections, |
| ddata->altlink, &val)) |
| return 0; |
| switch (formats[i].lnct) |
| { |
| case DW_LNCT_path: |
| if (!resolve_string (&ddata->dwarf_sections, u->is_dwarf64, |
| ddata->is_bigendian, u->str_offsets_base, |
| &val, hdr_buf->error_callback, hdr_buf->data, |
| &path)) |
| return 0; |
| break; |
| case DW_LNCT_directory_index: |
| if (val.encoding == ATTR_VAL_UINT) |
| { |
| if (val.u.uint >= hdr->dirs_count) |
| { |
| dwarf_buf_error (hdr_buf, |
| ("invalid directory index in " |
| "line number program header")); |
| return 0; |
| } |
| dir = hdr->dirs[val.u.uint]; |
| } |
| break; |
| default: |
| /* We don't care about timestamps or sizes or hashes. */ |
| break; |
| } |
| } |
| |
| if (path == NULL) |
| { |
| dwarf_buf_error (hdr_buf, |
| "missing file name in line number program header"); |
| return 0; |
| } |
| |
| if (dir == NULL) |
| *string = path; |
| else |
| { |
| size_t dir_len; |
| size_t path_len; |
| char *s; |
| |
| dir_len = strlen (dir); |
| path_len = strlen (path); |
| s = (char *) backtrace_alloc (state, dir_len + path_len + 2, |
| hdr_buf->error_callback, hdr_buf->data); |
| if (s == NULL) |
| return 0; |
| memcpy (s, dir, dir_len); |
| /* FIXME: If we are on a DOS-based file system, and the |
| directory or the path name use backslashes, then we should |
| use a backslash here. */ |
| s[dir_len] = '/'; |
| memcpy (s + dir_len + 1, path, path_len + 1); |
| *string = s; |
| } |
| |
| return 1; |
| } |
| |
| /* Read a set of DWARF 5 line header format entries, setting *PCOUNT |
| and *PPATHS. Return 1 on success, 0 on failure. */ |
| |
| static int |
| read_line_header_format_entries (struct backtrace_state *state, |
| struct dwarf_data *ddata, |
| struct unit *u, |
| struct dwarf_buf *hdr_buf, |
| struct line_header *hdr, |
| size_t *pcount, |
| const char ***ppaths) |
| { |
| size_t formats_count; |
| struct line_header_format *formats; |
| size_t paths_count; |
| const char **paths; |
| size_t i; |
| int ret; |
| |
| formats_count = read_byte (hdr_buf); |
| if (formats_count == 0) |
| formats = NULL; |
| else |
| { |
| formats = ((struct line_header_format *) |
| backtrace_alloc (state, |
| (formats_count |
| * sizeof (struct line_header_format)), |
| hdr_buf->error_callback, |
| hdr_buf->data)); |
| if (formats == NULL) |
| return 0; |
| |
| for (i = 0; i < formats_count; i++) |
| { |
| formats[i].lnct = (int) read_uleb128(hdr_buf); |
| formats[i].form = (enum dwarf_form) read_uleb128 (hdr_buf); |
| } |
| } |
| |
| paths_count = read_uleb128 (hdr_buf); |
| if (paths_count == 0) |
| { |
| *pcount = 0; |
| *ppaths = NULL; |
| ret = 1; |
| goto exit; |
| } |
| |
| paths = ((const char **) |
| backtrace_alloc (state, paths_count * sizeof (const char *), |
| hdr_buf->error_callback, hdr_buf->data)); |
| if (paths == NULL) |
| { |
| ret = 0; |
| goto exit; |
| } |
| for (i = 0; i < paths_count; i++) |
| { |
| if (!read_lnct (state, ddata, u, hdr_buf, hdr, formats_count, |
| formats, &paths[i])) |
| { |
| backtrace_free (state, paths, |
| paths_count * sizeof (const char *), |
| hdr_buf->error_callback, hdr_buf->data); |
| ret = 0; |
| goto exit; |
| } |
| } |
| |
| *pcount = paths_count; |
| *ppaths = paths; |
| |
| ret = 1; |
| |
| exit: |
| if (formats != NULL) |
| backtrace_free (state, formats, |
| formats_count * sizeof (struct line_header_format), |
| hdr_buf->error_callback, hdr_buf->data); |
| |
| return ret; |
| } |
| |
| /* Read the line header. Return 1 on success, 0 on failure. */ |
| |
| static int |
| read_line_header (struct backtrace_state *state, struct dwarf_data *ddata, |
| struct unit *u, int is_dwarf64, struct dwarf_buf *line_buf, |
| struct line_header *hdr) |
| { |
| uint64_t hdrlen; |
| struct dwarf_buf hdr_buf; |
| |
| hdr->version = read_uint16 (line_buf); |
| if (hdr->version < 2 || hdr->version > 5) |
| { |
| dwarf_buf_error (line_buf, "unsupported line number version"); |
| return 0; |
| } |
| |
| if (hdr->version < 5) |
| hdr->addrsize = u->addrsize; |
| else |
| { |
| hdr->addrsize = read_byte (line_buf); |
| /* We could support a non-zero segment_selector_size but I doubt |
| we'll ever see it. */ |
| if (read_byte (line_buf) != 0) |
| { |
| dwarf_buf_error (line_buf, |
| "non-zero segment_selector_size not supported"); |
| return 0; |
| } |
| } |
| |
| hdrlen = read_offset (line_buf, is_dwarf64); |
| |
| hdr_buf = *line_buf; |
| hdr_buf.left = hdrlen; |
| |
| if (!advance (line_buf, hdrlen)) |
| return 0; |
| |
| hdr->min_insn_len = read_byte (&hdr_buf); |
| if (hdr->version < 4) |
| hdr->max_ops_per_insn = 1; |
| else |
| hdr->max_ops_per_insn = read_byte (&hdr_buf); |
| |
| /* We don't care about default_is_stmt. */ |
| read_byte (&hdr_buf); |
| |
| hdr->line_base = read_sbyte (&hdr_buf); |
| hdr->line_range = read_byte (&hdr_buf); |
| |
| hdr->opcode_base = read_byte (&hdr_buf); |
| hdr->opcode_lengths = hdr_buf.buf; |
| if (!advance (&hdr_buf, hdr->opcode_base - 1)) |
| return 0; |
| |
| if (hdr->version < 5) |
| { |
| if (!read_v2_paths (state, u, &hdr_buf, hdr)) |
| return 0; |
| } |
| else |
| { |
| if (!read_line_header_format_entries (state, ddata, u, &hdr_buf, hdr, |
| &hdr->dirs_count, |
| &hdr->dirs)) |
| return 0; |
| if (!read_line_header_format_entries (state, ddata, u, &hdr_buf, hdr, |
| &hdr->filenames_count, |
| &hdr->filenames)) |
| return 0; |
| } |
| |
| if (hdr_buf.reported_underflow) |
| return 0; |
| |
| return 1; |
| } |
| |
| /* Read the line program, adding line mappings to VEC. Return 1 on |
| success, 0 on failure. */ |
| |
| static int |
| read_line_program (struct backtrace_state *state, struct dwarf_data *ddata, |
| struct unit *u, const struct line_header *hdr, |
| struct dwarf_buf *line_buf, struct line_vector *vec) |
| { |
| uint64_t address; |
| unsigned int op_index; |
| const char *reset_filename; |
| const char *filename; |
| int lineno; |
| |
| address = 0; |
| op_index = 0; |
| if (hdr->filenames_count > 0) |
| reset_filename = hdr->filenames[0]; |
| else |
| reset_filename = ""; |
| filename = reset_filename; |
| lineno = 1; |
| while (line_buf->left > 0) |
| { |
| unsigned int op; |
| |
| op = read_byte (line_buf); |
| if (op >= hdr->opcode_base) |
| { |
| unsigned int advance; |
| |
| /* Special opcode. */ |
| op -= hdr->opcode_base; |
| advance = op / hdr->line_range; |
| address += (hdr->min_insn_len * (op_index + advance) |
| / hdr->max_ops_per_insn); |
| op_index = (op_index + advance) % hdr->max_ops_per_insn; |
| lineno += hdr->line_base + (int) (op % hdr->line_range); |
| add_line (state, ddata, address, filename, lineno, |
| line_buf->error_callback, line_buf->data, vec); |
| } |
| else if (op == DW_LNS_extended_op) |
| { |
| uint64_t len; |
| |
| len = read_uleb128 (line_buf); |
| op = read_byte (line_buf); |
| switch (op) |
| { |
| case DW_LNE_end_sequence: |
| /* FIXME: Should we mark the high PC here? It seems |
| that we already have that information from the |
| compilation unit. */ |
| address = 0; |
| op_index = 0; |
| filename = reset_filename; |
| lineno = 1; |
| break; |
| case DW_LNE_set_address: |
| address = read_address (line_buf, hdr->addrsize); |
| break; |
| case DW_LNE_define_file: |
| { |
| const char *f; |
| unsigned int dir_index; |
| |
| f = read_string (line_buf); |
| if (f == NULL) |
| return 0; |
| dir_index = read_uleb128 (line_buf); |
| /* Ignore that time and length. */ |
| read_uleb128 (line_buf); |
| read_uleb128 (line_buf); |
| if (IS_ABSOLUTE_PATH (f)) |
| filename = f; |
| else |
| { |
| const char *dir; |
| size_t dir_len; |
| size_t f_len; |
| char *p; |
| |
| if (dir_index == 0 && hdr->version < 5) |
| dir = u->comp_dir; |
| else if (dir_index - 1 < hdr->dirs_count) |
| dir = hdr->dirs[dir_index - 1]; |
| else |
| { |
| dwarf_buf_error (line_buf, |
| ("invalid directory index " |
| "in line number program")); |
| return 0; |
| } |
| dir_len = strlen (dir); |
| f_len = strlen (f); |
| p = ((char *) |
| backtrace_alloc (state, dir_len + f_len + 2, |
| line_buf->error_callback, |
| line_buf->data)); |
| if (p == NULL) |
| return 0; |
| memcpy (p, dir, dir_len); |
| /* FIXME: If we are on a DOS-based file system, |
| and the directory or the file name use |
| backslashes, then we should use a backslash |
| here. */ |
| p[dir_len] = '/'; |
| memcpy (p + dir_len + 1, f, f_len + 1); |
| filename = p; |
| } |
| } |
| break; |
| case DW_LNE_set_discriminator: |
| /* We don't care about discriminators. */ |
| read_uleb128 (line_buf); |
| break; |
| default: |
| if (!advance (line_buf, len - 1)) |
| return 0; |
| break; |
| } |
| } |
| else |
| { |
| switch (op) |
| { |
| case DW_LNS_copy: |
| add_line (state, ddata, address, filename, lineno, |
| line_buf->error_callback, line_buf->data, vec); |
| break; |
| case DW_LNS_advance_pc: |
| { |
| uint64_t advance; |
| |
| advance = read_uleb128 (line_buf); |
| address += (hdr->min_insn_len * (op_index + advance) |
| / hdr->max_ops_per_insn); |
| op_index = (op_index + advance) % hdr->max_ops_per_insn; |
| } |
| break; |
| case DW_LNS_advance_line: |
| lineno += (int) read_sleb128 (line_buf); |
| break; |
| case DW_LNS_set_file: |
| { |
| uint64_t fileno; |
| |
| fileno = read_uleb128 (line_buf); |
| if (fileno == 0) |
| filename = ""; |
| else |
| { |
| if (fileno - 1 >= hdr->filenames_count) |
| { |
| dwarf_buf_error (line_buf, |
| ("invalid file number in " |
| "line number program")); |
| return 0; |
| } |
| filename = hdr->filenames[fileno - 1]; |
| } |
| } |
| break; |
| case DW_LNS_set_column: |
| read_uleb128 (line_buf); |
| break; |
| case DW_LNS_negate_stmt: |
| break; |
| case DW_LNS_set_basic_block: |
| break; |
| case DW_LNS_const_add_pc: |
| { |
| unsigned int advance; |
| |
| op = 255 - hdr->opcode_base; |
| advance = op / hdr->line_range; |
| address += (hdr->min_insn_len * (op_index + advance) |
| / hdr->max_ops_per_insn); |
| op_index = (op_index + advance) % hdr->max_ops_per_insn; |
| } |
| break; |
| case DW_LNS_fixed_advance_pc: |
| address += read_uint16 (line_buf); |
| op_index = 0; |
| break; |
| case DW_LNS_set_prologue_end: |
| break; |
| case DW_LNS_set_epilogue_begin: |
| break; |
| case DW_LNS_set_isa: |
| read_uleb128 (line_buf); |
| break; |
| default: |
| { |
| unsigned int i; |
| |
| for (i = hdr->opcode_lengths[op - 1]; i > 0; --i) |
| read_uleb128 (line_buf); |
| } |
| break; |
| } |
| } |
| } |
| |
| return 1; |
| } |
| |
| /* Read the line number information for a compilation unit. Returns 1 |
| on success, 0 on failure. */ |
| |
| static int |
| read_line_info (struct backtrace_state *state, struct dwarf_data *ddata, |
| backtrace_error_callback error_callback, void *data, |
| struct unit *u, struct line_header *hdr, struct line **lines, |
| size_t *lines_count) |
| { |
| struct line_vector vec; |
| struct dwarf_buf line_buf; |
| uint64_t len; |
| int is_dwarf64; |
| struct line *ln; |
| |
| memset (&vec.vec, 0, sizeof vec.vec); |
| vec.count = 0; |
| |
| memset (hdr, 0, sizeof *hdr); |
| |
| if (u->lineoff != (off_t) (size_t) u->lineoff |
| || (size_t) u->lineoff >= ddata->dwarf_sections.size[DEBUG_LINE]) |
| { |
| error_callback (data, "unit line offset out of range", 0); |
| goto fail; |
| } |
| |
| line_buf.name = ".debug_line"; |
| line_buf.start = ddata->dwarf_sections.data[DEBUG_LINE]; |
| line_buf.buf = ddata->dwarf_sections.data[DEBUG_LINE] + u->lineoff; |
| line_buf.left = ddata->dwarf_sections.size[DEBUG_LINE] - u->lineoff; |
| line_buf.is_bigendian = ddata->is_bigendian; |
| line_buf.error_callback = error_callback; |
| line_buf.data = data; |
| line_buf.reported_underflow = 0; |
| |
| len = read_initial_length (&line_buf, &is_dwarf64); |
| line_buf.left = len; |
| |
| if (!read_line_header (state, ddata, u, is_dwarf64, &line_buf, hdr)) |
| goto fail; |
| |
| if (!read_line_program (state, ddata, u, hdr, &line_buf, &vec)) |
| goto fail; |
| |
| if (line_buf.reported_underflow) |
| goto fail; |
| |
| if (vec.count == 0) |
| { |
| /* This is not a failure in the sense of a generating an error, |
| but it is a failure in that sense that we have no useful |
| information. */ |
| goto fail; |
| } |
| |
| /* Allocate one extra entry at the end. */ |
| ln = ((struct line *) |
| backtrace_vector_grow (state, sizeof (struct line), error_callback, |
| data, &vec.vec)); |
| if (ln == NULL) |
| goto fail; |
| ln->pc = (uintptr_t) -1; |
| ln->filename = NULL; |
| ln->lineno = 0; |
| ln->idx = 0; |
| |
| if (!backtrace_vector_release (state, &vec.vec, error_callback, data)) |
| goto fail; |
| |
| ln = (struct line *) vec.vec.base; |
| backtrace_qsort (ln, vec.count, sizeof (struct line), line_compare); |
| |
| *lines = ln; |
| *lines_count = vec.count; |
| |
| return 1; |
| |
| fail: |
| backtrace_vector_free (state, &vec.vec, error_callback, data); |
| free_line_header (state, hdr, error_callback, data); |
| *lines = (struct line *) (uintptr_t) -1; |
| *lines_count = 0; |
| return 0; |
| } |
| |
| static const char *read_referenced_name (struct dwarf_data *, struct unit *, |
| uint64_t, backtrace_error_callback, |
| void *); |
| |
| /* Read the name of a function from a DIE referenced by ATTR with VAL. */ |
| |
| static const char * |
| read_referenced_name_from_attr (struct dwarf_data *ddata, struct unit *u, |
| struct attr *attr, struct attr_val *val, |
| backtrace_error_callback error_callback, |
| void *data) |
| { |
| switch (attr->name) |
| { |
| case DW_AT_abstract_origin: |
| case DW_AT_specification: |
| break; |
| default: |
| return NULL; |
| } |
| |
| if (attr->form == DW_FORM_ref_sig8) |
| return NULL; |
| |
| if (val->encoding == ATTR_VAL_REF_INFO) |
| { |
| struct unit *unit |
| = find_unit (ddata->units, ddata->units_count, |
| val->u.uint); |
| if (unit == NULL) |
| return NULL; |
| |
| uint64_t offset = val->u.uint - unit->low_offset; |
| return read_referenced_name (ddata, unit, offset, error_callback, data); |
| } |
| |
| if (val->encoding == ATTR_VAL_UINT |
| || val->encoding == ATTR_VAL_REF_UNIT) |
| return read_referenced_name (ddata, u, val->u.uint, error_callback, data); |
| |
| if (val->encoding == ATTR_VAL_REF_ALT_INFO) |
| { |
| struct unit *alt_unit |
| = find_unit (ddata->altlink->units, ddata->altlink->units_count, |
| val->u.uint); |
| if (alt_unit == NULL) |
| return NULL; |
| |
| uint64_t offset = val->u.uint - alt_unit->low_offset; |
| return read_referenced_name (ddata->altlink, alt_unit, offset, |
| error_callback, data); |
| } |
| |
| return NULL; |
| } |
| |
| /* Read the name of a function from a DIE referenced by a |
| DW_AT_abstract_origin or DW_AT_specification tag. OFFSET is within |
| the same compilation unit. */ |
| |
| static const char * |
| read_referenced_name (struct dwarf_data *ddata, struct unit *u, |
| uint64_t offset, backtrace_error_callback error_callback, |
| void *data) |
| { |
| struct dwarf_buf unit_buf; |
| uint64_t code; |
| const struct abbrev *abbrev; |
| const char *ret; |
| size_t i; |
| |
| /* OFFSET is from the start of the data for this compilation unit. |
| U->unit_data is the data, but it starts U->unit_data_offset bytes |
| from the beginning. */ |
| |
| if (offset < u->unit_data_offset |
| || offset - u->unit_data_offset >= u->unit_data_len) |
| { |
| error_callback (data, |
| "abstract origin or specification out of range", |
| 0); |
| return NULL; |
| } |
| |
| offset -= u->unit_data_offset; |
| |
| unit_buf.name = ".debug_info"; |
| unit_buf.start = ddata->dwarf_sections.data[DEBUG_INFO]; |
| unit_buf.buf = u->unit_data + offset; |
| unit_buf.left = u->unit_data_len - offset; |
| unit_buf.is_bigendian = ddata->is_bigendian; |
| unit_buf.error_callback = error_callback; |
| unit_buf.data = data; |
| unit_buf.reported_underflow = 0; |
| |
| code = read_uleb128 (&unit_buf); |
| if (code == 0) |
| { |
|