/buildworker/marxinbox-gcc-clang-static-analyzer/build/libbacktrace/dwarf.c

Bug Summary

File:	build/libbacktrace/dwarf.c
Warning:	line 1516, column 7 Null pointer passed to 2nd parameter expecting 'nonnull'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-suse-linux -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name dwarf.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/libbacktrace -resource-dir /usr/lib64/clang/15.0.7 -D HAVE_CONFIG_H -I . -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/libbacktrace -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/libbacktrace/../include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/libbacktrace/../libgcc -I ../libgcc -D PIC -internal-isystem /usr/lib64/clang/15.0.7/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../x86_64-suse-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wwrite-strings -fconst-strings -fdebug-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/libbacktrace -ferror-limit 19 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=plist-html -analyzer-config silence-checkers=core.NullDereference -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2023-03-27-141847-20772-1/report-4yD2Lk.plist -x c /buildworker/marxinbox-gcc-clang-static-analyzer/build/libbacktrace/dwarf.c
1/* dwarf.c -- Get file/line information from DWARF for backtraces.
 Copyright (C) 2012-2023 Free Software Foundation, Inc.
 Written by Ian Lance Taylor, Google.

5Redistribution and use in source and binary forms, with or without
6modification, are permitted provided that the following conditions are
7met:

  (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.

21THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
23WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
25INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
26(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
27SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
29STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
30IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31POSSIBILITY OF SUCH DAMAGE.  */

33#include "config.h"

35#include <errno(*__errno_location ()).h>
36#include <stdlib.h>
37#include <string.h>
38#include <sys/types.h>

40#include "dwarf2.h"
41#include "filenames.h"

43#include "backtrace.h"
44#include "internal.h"

46#if !defined(HAVE_DECL_STRNLEN1) || !HAVE_DECL_STRNLEN1

48/* If strnlen is not declared, provide our own version.  */

50static size_t
51xstrnlen (const char *s, size_t maxlen)
52{
size_t i;

for (i = 0; i < maxlen; ++i)
  if (s[i] == '\0')
    break;
return i;
59}

61#define strnlen xstrnlen

63#endif

65/* A buffer to read DWARF info.  */

67struct dwarf_buf
68{
/* 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;
85};

87/* A single attribute in a DWARF abbreviation.  */

89struct attr
90{
/* 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;
97};

99/* A single DWARF abbreviation.  */

101struct abbrev
102{
/* 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;
113};

115/* 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.  */

122struct abbrevs
123{
/* The number of abbrevs in the vector.  */
size_t num_abbrevs;
/* The abbrevs, sorted by the code field.  */
struct abbrev *abbrevs;
128};

130/* The different kinds of attribute values.  */

132enum attr_val_encoding
133{
/* 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,
165};

167/* An attribute value.  */

169struct attr_val
170{
/* 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;
183};

185/* The line number program header.  */

187struct line_header
188{
/* 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;
213};

215/* A format description from a line header.  */

217struct line_header_format
218{
int lnct;		/* LNCT code.  */
enum dwarf_form form;	/* Form of entry data.  */
221};

223/* 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.  */

228struct line
229{
/* 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;
241};

243/* A growable vector of line number information.  This is used while
 reading the line numbers.  */

246struct line_vector
247{
/* Memory.  This is an array of struct line.  */
struct backtrace_vector vec;
/* Number of valid mappings.  */
size_t count;
252};

254/* A function described in the debug info.  */

256struct function
257{
/* 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;
269};

271/* An address range for a function.  This maps a PC value to a
 specific function.  */

274struct function_addrs
275{
/* Range is LOW <= PC < HIGH.  */
uintptr_t low;
uintptr_t high;
/* Function for this address range.  */
struct function *function;
281};

283/* A growable vector of function address ranges.  */

285struct function_vector
286{
/* Memory.  This is an array of struct function_addrs.  */
struct backtrace_vector vec;
/* Number of address ranges present.  */
size_t count;
291};

293/* A DWARF compilation unit.  This only holds the information we need
 to map a PC to a file and line.  */

296struct unit
297{
/* 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;
348};

350/* 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.  */

356struct unit_addrs
357{
/* Range is LOW <= PC < HIGH.  */
uintptr_t low;
uintptr_t high;
/* Compilation unit for this address range.  */
struct unit *u;
363};

365/* A growable vector of compilation unit address ranges.  */

367struct unit_addrs_vector
368{
/* Memory.  This is an array of struct unit_addrs.  */
struct backtrace_vector vec;
/* Number of address ranges present.  */
size_t count;
373};

375/* A growable vector of compilation unit pointer.  */

377struct unit_vector
378{
struct backtrace_vector vec;
size_t count;
381};

383/* The information we need to map a PC to a file and line.  */

385struct dwarf_data
386{
/* 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;
408};

410/* Report an error for a DWARF buffer.  */

412static void
413dwarf_buf_error (struct dwarf_buf *buf, const char *msg, int errnum)
414{
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, errnum);
420}

422/* Require at least COUNT bytes in BUF.  Return 1 if all is well, 0 on
 error.  */

425static int
426require (struct dwarf_buf *buf, size_t count)
427{
if (buf->left >= count)
  return 1;

if (!buf->reported_underflow)
  {
    dwarf_buf_error (buf, "DWARF underflow", 0);
    buf->reported_underflow = 1;
  }

return 0;
438}

440/* Advance COUNT bytes in BUF.  Return 1 if all is well, 0 on
 error.  */

443static int
444advance (struct dwarf_buf *buf, size_t count)
445{
if (!require (buf, count))
  return 0;
buf->buf += count;
buf->left -= count;
return 1;
451}

453/* Read one zero-terminated string from BUF and advance past the string.  */

455static const char *
456read_string (struct dwarf_buf *buf)
457{
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((void*)0);

return p;
470}

472/* Read one byte from BUF and advance 1 byte.  */

474static unsigned char
475read_byte (struct dwarf_buf *buf)
476{
const unsigned char *p = buf->buf;

if (!advance (buf, 1))
  return 0;
return p[0];
482}

484/* Read a signed char from BUF and advance 1 byte.  */

486static signed char
487read_sbyte (struct dwarf_buf *buf)
488{
const unsigned char *p = buf->buf;

if (!advance (buf, 1))
  return 0;
return (*p ^ 0x80) - 0x80;
494}

496/* Read a uint16 from BUF and advance 2 bytes.  */

498static uint16_t
499read_uint16 (struct dwarf_buf *buf)
500{
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];
509}

511/* Read a 24 bit value from BUF and advance 3 bytes.  */

513static uint32_t
514read_uint24 (struct dwarf_buf *buf)
515{
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]);
526}

528/* Read a uint32 from BUF and advance 4 bytes.  */

530static uint32_t
531read_uint32 (struct dwarf_buf *buf)
532{
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]);
543}

545/* Read a uint64 from BUF and advance 8 bytes.  */

547static uint64_t
548read_uint64 (struct dwarf_buf *buf)
549{
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]);
564}

566/* Read an offset from BUF and advance the appropriate number of
 bytes.  */

569static uint64_t
570read_offset (struct dwarf_buf *buf, int is_dwarf64)
571{
if (is_dwarf64)
  return read_uint64 (buf);
else
  return read_uint32 (buf);
576}

578/* Read an address from BUF and advance the appropriate number of
 bytes.  */

581static uint64_t
582read_address (struct dwarf_buf *buf, int addrsize)
583{
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", 0);
    return 0;
  }
598}

600/* Return whether a value is the highest possible address, given the
 address size.  */

603static int
604is_highest_address (uint64_t address, int addrsize)
605{
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;
  }
619}

621/* Read an unsigned LEB128 number.  */

623static uint64_t
624read_uleb128 (struct dwarf_buf *buf)
625{
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", 0);
 overflow = 1;
}
    shift += 7;
  }
while ((b & 0x80) != 0);

return ret;
654}

656/* Read a signed LEB128 number.  */

658static int64_t
659read_sleb128 (struct dwarf_buf *buf)
660{
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", 0);
 overflow = 1;
}
    shift += 7;
  }
while ((b & 0x80) != 0);

if ((b & 0x40) != 0 && shift < 64)
  val |= ((uint64_t) -1) << shift;

return (int64_t) val;
692}

694/* Return the length of an LEB128 number.  */

696static size_t
697leb128_len (const unsigned char *p)
698{
size_t ret;

ret = 1;
while ((*p & 0x80) != 0)
  {
    ++p;
    ++ret;
  }
return ret;
708}

710/* Read initial_length from BUF and advance the appropriate number of bytes.  */

712static uint64_t
713read_initial_length (struct dwarf_buf *buf, int *is_dwarf64)
714{
uint64_t len;

len = read_uint32 (buf);
if (len == 0xffffffff)
  {
    len = read_uint64 (buf);
    *is_dwarf64 = 1;
  }
else
  *is_dwarf64 = 0;

return len;
727}

729/* Free an abbreviations structure.  */

731static void
732free_abbrevs (struct backtrace_state *state, struct abbrevs *abbrevs,
     backtrace_error_callback error_callback, void *data)
734{
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((void*)0);
746}

748/* 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.  */

753static int
754read_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)
758{
/* 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((void*)0) ? 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", 0);
   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", 0);
   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",
	     0);
   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((void*)0))
{
 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((void*)0))
 {
   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", 0);
   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", -1);
    return 0;
  }
1029}

1031/* 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.  */

1037static int
1038resolve_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)
1043{
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",
	     0);
   return 0;
 }
*string = (const char *) dwarf_sections->data[DEBUG_STR] + offset;
return 1;
    }

  default:
    return 1;
  }
1087}

1089/* Set *ADDRESS to the real address for a ATTR_VAL_ADDRESS_INDEX.
 Return 1 on success, 0 on error.  */

1092static int
1093resolve_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,
    uintptr_t *address)
1098{
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 = (uintptr_t) read_address (&addr_buf, addrsize);
return 1;
1120}

1122/* Compare a unit offset against a unit for bsearch.  */

1124static int
1125units_search (const void *vkey, const void *ventry)
1126{
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;
1138}

1140/* Find a unit in PU containing OFFSET.  */

1142static struct unit *
1143find_unit (struct unit **pu, size_t units_count, size_t offset)
1144{
struct unit **u;
u = bsearch (&offset, pu, units_count, sizeof (struct unit *), units_search);
return u == NULL((void*)0) ? NULL((void*)0) : *u;
1148}

1150/* Compare function_addrs for qsort.  When ranges are nested, make the
 smallest one sort last.  */

1153static int
1154function_addrs_compare (const void *v1, const void *v2)
1155{
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);
1168}

1170/* Compare a PC against a function_addrs for bsearch.  We always
 allocate an entra entry at the end of the vector, so that this
 routine can safely look at the next entry.  Note that if there are
 multiple ranges containing PC, which one will be returned is
 unpredictable.  We compensate for that in dwarf_fileline.  */

1176static int
1177function_addrs_search (const void *vkey, const void *ventry)
1178{
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 + 1)->low)
  return 1;
else
  return 0;
1190}

1192/* Add a new compilation unit address range to a vector.  This is
 called via add_ranges.  Returns 1 on success, 0 on failure.  */

1195static int
1196add_unit_addr (struct backtrace_state *state, void *rdata,
      uintptr_t lowpc, uintptr_t highpc,
      backtrace_error_callback error_callback, void *data,
      void *pvec)
1200{
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((void*)0))
  return 0;

p->low = lowpc;
p->high = highpc;
p->u = u;

++vec->count;

return 1;
1231}

1233/* Compare unit_addrs for qsort.  When ranges are nested, make the
 smallest one sort last.  */

1236static int
1237unit_addrs_compare (const void *v1, const void *v2)
1238{
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;
1255}

1257/* Compare a PC against a unit_addrs for bsearch.  We always allocate
 an entry entry at the end of the vector, so that this routine can
 safely look at the next entry.  Note that if there are multiple
 ranges containing PC, which one will be returned is unpredictable.
 We compensate for that in dwarf_fileline.  */

1263static int
1264unit_addrs_search (const void *vkey, const void *ventry)
1265{
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 + 1)->low)
  return 1;
else
  return 0;
1277}

1279/* 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.  */

1284static int
1285line_compare (const void *v1, const void *v2)
1286{
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;
1300}

1302/* 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.  */

1307static int
1308line_search (const void *vkey, const void *ventry)
1309{
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;
1321}

1323/* Sort the abbrevs by the abbrev code.  This function is passed to
 both qsort and bsearch.  */

1326static int
1327abbrev_compare (const void *v1, const void *v2)
1328{
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;
  }
1343}

1345/* Read the abbreviation table for a compilation unit.  Returns 1 on
 success, 0 on failure.  */

1348static int
1349read_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)
1353{
struct dwarf_buf abbrev_buf;
struct dwarf_buf count_buf;
size_t num_abbrevs;

abbrevs->num_abbrevs = 0;
abbrevs->abbrevs = NULL((void*)0);
21
←
Null pointer value stored to field 'abbrevs'→

if (abbrev_offset >= dwarf_abbrev_size)
22
←
Assuming 'abbrev_offset' is < 'dwarf_abbrev_size'→
23
←
Taking false branch→
  {
    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)
24
←
Loop condition is false. Execution continues on line 1402→
  {
    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)
25
←
Assuming field 'reported_underflow' is 0→
26
←
Taking false branch→
  return 0;

if (num_abbrevs26.1
'num_abbrevs' is equal to 0
 == 0)
27
←
Taking true branch→
  return 1;

abbrevs->abbrevs = ((struct abbrev *)
      backtrace_alloc (state,
		       num_abbrevs * sizeof (struct abbrev),
		       error_callback, data));
if (abbrevs->abbrevs == NULL((void*)0))
  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((void*)0);
 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((void*)0))
   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;
1496}

1498/* Return the abbrev information for an abbrev code.  */

1500static const struct abbrev *
1501lookup_abbrev (struct abbrevs *abbrevs, uint64_t code,
      backtrace_error_callback error_callback, void *data)
1503{
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,
40
←
Null pointer passed to 2nd parameter expecting 'nonnull'
      sizeof (struct abbrev), abbrev_compare);
if (p == NULL((void*)0))
  {
    error_callback (data, "invalid abbreviation code", 0);
    return NULL((void*)0);
  }
return (const struct abbrev *) p;
1524}

1526/* 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.  */

1532struct pcrange {
uintptr_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.  */
uintptr_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.  */
1543};

1545/* Update PCRANGE from an attribute value.  */

1547static void
1548update_pcrange (const struct attr* attr, const struct attr_val* val,
struct pcrange *pcrange)
1550{
switch (attr->name)
  {
  case DW_AT_low_pc:
    if (val->encoding == ATTR_VAL_ADDRESS)
{
 pcrange->lowpc = (uintptr_t) val->u.uint;
 pcrange->have_lowpc = 1;
}
    else if (val->encoding == ATTR_VAL_ADDRESS_INDEX)
{
 pcrange->lowpc = (uintptr_t) 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 = (uintptr_t) val->u.uint;
 pcrange->have_highpc = 1;
}
    else if (val->encoding == ATTR_VAL_UINT)
{
 pcrange->highpc = (uintptr_t) val->u.uint;
 pcrange->have_highpc = 1;
 pcrange->highpc_is_relative = 1;
}
    else if (val->encoding == ATTR_VAL_ADDRESS_INDEX)
{
 pcrange->highpc = (uintptr_t) 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;
  }
1605}

1607/* Call ADD_RANGE for a low/high PC pair.  Returns 1 on success, 0 on
error.  */

1610static int
1611add_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, uintptr_t lowpc,
		      uintptr_t highpc,
		      backtrace_error_callback error_callback,
		      void *data, void *vec),
    void *rdata,
    backtrace_error_callback error_callback, void *data,
    void *vec)
1623{
uintptr_t lowpc;
uintptr_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);
1653}

1655/* Call ADD_RANGE for each range read from .debug_ranges, as used in
 DWARF versions 2 through 4.  */

1658static int
1659add_ranges_from_ranges (
  struct backtrace_state *state,
  const struct dwarf_sections *dwarf_sections,
  uintptr_t base_address, int is_bigendian,
  struct unit *u, uintptr_t base,
  const struct pcrange *pcrange,
  int (*add_range) (struct backtrace_state *state, void *rdata,
      uintptr_t lowpc, uintptr_t highpc,
      backtrace_error_callback error_callback, void *data,
      void *vec),
  void *rdata,
  backtrace_error_callback error_callback, void *data,
  void *vec)
1672{
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 = (uintptr_t) high;
    else
{
 if (!add_range (state, rdata, 
	  (uintptr_t) low + base + base_address,
	  (uintptr_t) high + base + base_address,
	  error_callback, data, vec))
   return 0;
}
  }

if (ranges_buf.reported_underflow)
  return 0;

return 1;
1720}

1722/* Call ADD_RANGE for each range read from .debug_rnglists, as used in
 DWARF version 5.  */

1725static int
1726add_ranges_from_rnglists (
  struct backtrace_state *state,
  const struct dwarf_sections *dwarf_sections,
  uintptr_t base_address, int is_bigendian,
  struct unit *u, uintptr_t base,
  const struct pcrange *pcrange,
  int (*add_range) (struct backtrace_state *state, void *rdata,
      uintptr_t lowpc, uintptr_t highpc,
      backtrace_error_callback error_callback, void *data,
      void *vec),
  void *rdata,
  backtrace_error_callback error_callback, void *data,
  void *vec)
1739{
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;
   uintptr_t low;
   uintptr_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;
   uintptr_t low;
   uintptr_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 = (uintptr_t) read_address (&rnglists_buf, u->addrsize);
 break;

case DW_RLE_start_end:
 {
   uintptr_t low;
   uintptr_t high;

   low = (uintptr_t) read_address (&rnglists_buf, u->addrsize);
   high = (uintptr_t) 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:
 {
   uintptr_t low;
   uintptr_t length;

   low = (uintptr_t) read_address (&rnglists_buf, u->addrsize);
   length = (uintptr_t) 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", -1);
 return 0;
}
  }

if (rnglists_buf.reported_underflow)
  return 0;

return 1;
1894}

1896/* 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.  */

1902static int
1903add_ranges (struct backtrace_state *state,
   const struct dwarf_sections *dwarf_sections,
   uintptr_t base_address, int is_bigendian,
   struct unit *u, uintptr_t base, const struct pcrange *pcrange,
   int (*add_range) (struct backtrace_state *state, void *rdata, 
	      uintptr_t lowpc, uintptr_t highpc,
	      backtrace_error_callback error_callback,
	      void *data, void *vec),
   void *rdata,
   backtrace_error_callback error_callback, void *data,
   void *vec)
1914{
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);
1934}

1936/* 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.  */

1940static int
1941find_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)
1948{
while (unit_buf->left > 0)
35
←
Assuming field 'left' is > 0→
36
←
Loop condition is true.  Entering loop body→
  {
    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)
37
←
Assuming 'code' is not equal to 0→
38
←
Taking false branch→
return 1;

    abbrev = lookup_abbrev (&u->abbrevs, code, error_callback, data);
39
←
Calling 'lookup_abbrev'→
    if (abbrev == NULL((void*)0))
return 0;

    if (unit_tag != NULL((void*)0))
*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
   || abbrev->tag == DW_TAG_skeleton_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
  || abbrev->tag == DW_TAG_skeleton_unit)
{
  name_val = val;
  have_name_val = 1;
}
     break;

   case DW_AT_comp_dir:
     if (abbrev->tag == DW_TAG_compile_unit
  || abbrev->tag == DW_TAG_skeleton_unit)
{
  comp_dir_val = val;
  have_comp_dir_val = 1;
}
     break;

   case DW_AT_str_offsets_base:
     if ((abbrev->tag == DW_TAG_compile_unit
   || abbrev->tag == DW_TAG_skeleton_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
   || abbrev->tag == DW_TAG_skeleton_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
   || abbrev->tag == DW_TAG_skeleton_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
 || abbrev->tag == DW_TAG_skeleton_unit)
{
 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 or
    DW_TAG_skeleton_unit, we can stop now.  */
 if ((abbrev->tag == DW_TAG_compile_unit
      || abbrev->tag == DW_TAG_skeleton_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((void*)0)))
   return 0;
}
  }

return 1;
2089}

2091/* 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.  */

2095static int
2096build_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)
2102{
struct dwarf_buf info;
struct backtrace_vector units;
size_t units_count;
size_t i;
struct unit **pu;
size_t unit_offset = 0;
struct unit_addrs *pa;

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)
3
←
Assuming field 'left' is > 0→
4
←
Loop condition is true.  Entering loop body→
  {
    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_underflow4.1
Field 'reported_underflow' is 0
)
5
←
Taking false branch→
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))
6
←
Taking false branch→
goto fail;

    version = read_uint16 (&unit_buf);
    if (version < 2 || version > 5)
7
←
Assuming 'version' is >= 2→
8
←
Assuming 'version' is <= 5→
9
←
Taking false branch→
{
 dwarf_buf_error (&unit_buf, "unrecognized DWARF version", -1);
 goto fail;
}

    if (version < 5)
10
←
Assuming 'version' is >= 5→
11
←
Taking false branch→
unit_type = 0;
    else
{
 unit_type = read_byte (&unit_buf);
 if (unit_type == DW_UT_type || unit_type == DW_UT_split_type)
12
←
Assuming 'unit_type' is not equal to DW_UT_type→
13
←
Assuming 'unit_type' is not equal to DW_UT_split_type→
14
←
Taking false branch→
   {
     /* 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((void*)0))
15
←
Assuming 'pu' is not equal to NULL→
16
←
Taking false branch→
 goto fail;

    u = ((struct unit *)
  backtrace_alloc (state, sizeof *u, error_callback, data));
    if (u == NULL((void*)0))
17
←
Assuming 'u' is not equal to NULL→
18
←
Taking false branch→
goto fail;

    *pu = u;
    ++units_count;

    if (version18.1
'version' is >= 5
 < 5)
19
←
Taking false branch→
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,
20
←
Calling 'read_abbrevs'→
28
←
Returning from 'read_abbrevs'→
29
←
Taking false branch→
	 dwarf_sections->data[DEBUG_ABBREV],
	 dwarf_sections->size[DEBUG_ABBREV],
	 is_bigendian, error_callback, data, &u->abbrevs))
goto fail;

    if (version29.1
'version' is >= 5
 < 5)
30
←
Taking false branch→
addrsize = read_byte (&unit_buf);

    switch (unit_type)
31
←
Control jumps to the 'default' case at line 2215→
{
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;
32
←
 Execution continues on line 2219→
}

    u->low_offset = unit_offset;
    unit_offset += len + (is_dwarf6432.1
'is_dwarf64' is 0
 ? 12 : 4);
33
←
'?' condition is false→
    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((void*)0);
    u->comp_dir = NULL((void*)0);
    u->abs_filename = NULL((void*)0);
    u->lineoff = 0;
    u->str_offsets_base = 0;
    u->addr_base = 0;
    u->rnglists_base = 0;

    /* The actual line number mappings will be read as needed.  */
    u->lines = NULL((void*)0);
    u->lines_count = 0;
    u->function_addrs = NULL((void*)0);
    u->function_addrs_count = 0;

    if (!find_address_ranges (state, base_address, &unit_buf, dwarf_sections,
34
←
Calling 'find_address_ranges'→
		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;

/* Add a trailing addrs entry, but don't include it in addrs->count.  */
pa = ((struct unit_addrs *)
backtrace_vector_grow (state, sizeof (struct unit_addrs),
	       error_callback, data, &addrs->vec));
if (pa == NULL((void*)0))
  goto fail;
pa->low = 0;
--pa->low;
pa->high = pa->low;
pa->u = NULL((void*)0);

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;
2285}

2287/* Add a new mapping to the vector of line mappings that we are
 building.  Returns 1 on success, 0 on failure.  */

2290static int
2291add_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)
2295{
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((void*)0))
  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;
2324}

2326/* Free the line header information.  */

2328static void
2329free_line_header (struct backtrace_state *state, struct line_header *hdr,
  backtrace_error_callback error_callback, void *data)
2331{
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);
2338}

2340/* Read the directories and file names for a line header for version
 2, setting fields in HDR.  Return 1 on success, 0 on failure.  */

2343static int
2344read_v2_paths (struct backtrace_state *state, struct unit *u,
      struct dwarf_buf *hdr_buf, struct line_header *hdr)
2346{
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;
  }

/* The index of the first entry in the list of directories is 1.  Index 0 is
   used for the current directory of the compilation.  To simplify index
   handling, we set entry 0 to the compilation unit directory.  */
++hdr->dirs_count;
hdr->dirs = ((const char **)
      backtrace_alloc (state,
		hdr->dirs_count * sizeof (const char *),
		hdr_buf->error_callback,
		hdr_buf->data));
if (hdr->dirs == NULL((void*)0))
  return 0;

hdr->dirs[0] = u->comp_dir;
i = 1;
while (*hdr_buf->buf != '\0')
  {
    if (hdr_buf->reported_underflow)
return 0;

    hdr->dirs[i] = read_string (hdr_buf);
    if (hdr->dirs[i] == NULL((void*)0))
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;
  }

/* The index of the first entry in the list of file names is 1.  Index 0 is
   used for the DW_AT_name of the compilation unit.  To simplify index
   handling, we set entry 0 to the compilation unit file name.  */
++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((void*)0))
  return 0;
hdr->filenames[0] = u->filename;
i = 1;
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((void*)0))
return 0;
    dir_index = read_uleb128 (hdr_buf);
    if (IS_ABSOLUTE_PATH (filename)(((((filename)[0]) == '/') || ((((filename)[0]) == '\\') &&
 (0))) || ((filename)[0] && ((filename)[1] == ':') &&
 (0)))
 || (dir_index < hdr->dirs_count && hdr->dirs[dir_index] == NULL((void*)0)))
hdr->filenames[i] = filename;
    else
{
 const char *dir;
 size_t dir_len;
 size_t filename_len;
 char *s;

 if (dir_index < hdr->dirs_count)
   dir = hdr->dirs[dir_index];
 else
   {
     dwarf_buf_error (hdr_buf,
	       ("invalid directory index in "
		"line number program header"),
	       0);
     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((void*)0))
   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;
2470}

2472/* 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.  */

2476static int
2477read_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)
2481{
size_t i;
const char *dir;
const char *path;

dir = NULL((void*)0);
path = NULL((void*)0);
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"),
		   0);
  return 0;
}
     dir = hdr->dirs[val.u.uint];
   }
 break;
default:
 /* We don't care about timestamps or sizes or hashes.  */
 break;
}
  }

if (path == NULL((void*)0))
  {
    dwarf_buf_error (hdr_buf,
       "missing file name in line number program header",
       0);
    return 0;
  }

if (dir == NULL((void*)0))
  *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((void*)0))
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;
2557}

2559/* Read a set of DWARF 5 line header format entries, setting *PCOUNT
 and *PPATHS.  Return 1 on success, 0 on failure.  */

2562static int
2563read_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)
2570{
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((void*)0);
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((void*)0))
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((void*)0);
    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((void*)0))
  {
    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((void*)0))
  backtrace_free (state, formats,
    formats_count * sizeof (struct line_header_format),
    hdr_buf->error_callback, hdr_buf->data);

return  ret;
2641}

2643/* Read the line header.  Return 1 on success, 0 on failure.  */

2645static int
2646read_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)
2649{
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", -1);
    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",
	   -1);
 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;
2722}

2724/* Read the line program, adding line mappings to VEC.  Return 1 on
 success, 0 on failure.  */

2727static int
2728read_line_program (struct backtrace_state *state, struct dwarf_data *ddata,
   const struct line_header *hdr, struct dwarf_buf *line_buf,
   struct line_vector *vec)
2731{
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 > 1)
  reset_filename = hdr->filenames[1];
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((void*)0))
  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)(((((f)[0]) == '/') || ((((f)[0]) == '\\') && (0))) ||
 ((f)[0] && ((f)[1] == ':') && (0))))
  filename = f;
else
  {
    const char *dir;
    size_t dir_len;
    size_t f_len;
    char *p;

    if (dir_index < hdr->dirs_count)
      dir = hdr->dirs[dir_index];
    else
      {
	dwarf_buf_error (line_buf,
			 ("invalid directory index "
			  "in line number program"),
			 0);
	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((void*)0))
      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 >= hdr->filenames_count)
  {
    dwarf_buf_error (line_buf,
		     ("invalid file number in "
		      "line number program"),
		     0);
    return 0;
  }
filename = hdr->filenames[fileno];
     }
     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;
2924}

2926/* Read the line number information for a compilation unit.  Returns 1
 on success, 0 on failure.  */

2929static int
2930read_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)
2934{
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, 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((void*)0))
  goto fail;
ln->pc = (uintptr_t) -1;
ln->filename = NULL((void*)0);
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;
3010}

3012static const char *read_referenced_name (struct dwarf_data *, struct unit *,
			 uint64_t, backtrace_error_callback,
			 void *);

3016/* Read the name of a function from a DIE referenced by ATTR with VAL.  */

3018static const char *
3019read_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)
3023{
switch (attr->name)
  {
  case DW_AT_abstract_origin:
  case DW_AT_specification:
    break;
  default:
    return NULL((void*)0);
  }

if (attr->form == DW_FORM_ref_sig8)
  return NULL((void*)0);

if (val->encoding == ATTR_VAL_REF_INFO)
  {
    struct unit *unit
= find_unit (ddata->units, ddata->units_count,
     val->u.uint);
    if (unit == NULL((void*)0))
return NULL((void*)0);

    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((void*)0))
return NULL((void*)0);

    uint64_t offset = val->u.uint - alt_unit->low_offset;
    return read_referenced_name (ddata->altlink, alt_unit, offset,
		   error_callback, data);
  }

return NULL((void*)0);
3066}

3068/* 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.  */

3072static const char *
3073read_referenced_name (struct dwarf_data *ddata, struct unit *u,
      uint64_t offset, backtrace_error_callback error_callback,
      void *data)
3076{
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((void*)0);
  }

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)
  {
    dwarf_buf_error (&unit_buf,
       "invalid abstract origin or specification",
       0);
    return NULL((void*)0);
  }

abbrev = lookup_abbrev (&u->abbrevs, code, error_callback, data);
if (abbrev == NULL((void*)0))
  return NULL((void*)0);

ret = NULL((void*)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,
	   &ddata->dwarf_sections, ddata->altlink, &val))
return NULL((void*)0);

    switch (abbrev->attrs[i].name)
{
case DW_AT_name:
 /* Third name preference: don't override.  A name we found in some
    other way, will normally be more useful -- e.g., this name is
    normally not mangled.  */
 if (ret != NULL((void*)0))
   break;
 if (!resolve_string (&ddata->dwarf_sections, u->is_dwarf64,
	       ddata->is_bigendian, u->str_offsets_base,
	       &val, error_callback, data, &ret))
   return NULL((void*)0);
 break;

case DW_AT_linkage_name:
case DW_AT_MIPS_linkage_name:
 /* First name preference: override all.  */
 {
   const char *s;

   s = NULL((void*)0);
   if (!resolve_string (&ddata->dwarf_sections, u->is_dwarf64,
		 ddata->is_bigendian, u->str_offsets_base,
		 &val, error_callback, data, &s))
     return NULL((void*)0);
   if (s != NULL((void*)0))
     return s;
 }
 break;

case DW_AT_specification:
 /* Second name preference: override DW_AT_name, don't override
    DW_AT_linkage_name.  */
 {
   const char *name;

   name = read_referenced_name_from_attr (ddata, u, &abbrev->attrs[i],
				   &val, error_callback, data);
   if (name != NULL((void*)0))
     ret = name;
 }
 break;

default:
 break;
}
  }

return ret;
3179}

3181/* Add a range to a unit that maps to a function.  This is called via
 add_ranges.  Returns 1 on success, 0 on error.  */

3184static int
3185add_function_range (struct backtrace_state *state, void *rdata,
    uintptr_t lowpc, uintptr_t highpc,
    backtrace_error_callback error_callback, void *data,
    void *pvec)
3189{
struct function *function = (struct function *) rdata;
struct function_vector *vec = (struct function_vector *) pvec;
struct function_addrs *p;

if (vec->count > 0)
  {
    p = (struct function_addrs *) vec->vec.base + (vec->count - 1);
    if ((lowpc == p->high || lowpc == p->high + 1)
 && function == p->function)
{
 if (highpc > p->high)
   p->high = highpc;
 return 1;
}
  }

p = ((struct function_addrs *)
     backtrace_vector_grow (state, sizeof (struct function_addrs),
	      error_callback, data, &vec->vec));
if (p == NULL((void*)0))
  return 0;

p->low = lowpc;
p->high = highpc;
p->function = function;

++vec->count;

return 1;
3219}

3221/* Read one entry plus all its children.  Add function addresses to
 VEC.  Returns 1 on success, 0 on error.  */

3224static int
3225read_function_entry (struct backtrace_state *state, struct dwarf_data *ddata,
     struct unit *u, uintptr_t base, struct dwarf_buf *unit_buf,
     const struct line_header *lhdr,
     backtrace_error_callback error_callback, void *data,
     struct function_vector *vec_function,
     struct function_vector *vec_inlined)
3231{
while (unit_buf->left > 0)
  {
    uint64_t code;
    const struct abbrev *abbrev;
    int is_function;
    struct function *function;
    struct function_vector *vec;
    size_t i;
    struct pcrange pcrange;
    int have_linkage_name;

    code = read_uleb128 (unit_buf);
    if (code == 0)
return 1;

    abbrev = lookup_abbrev (&u->abbrevs, code, error_callback, data);
    if (abbrev == NULL((void*)0))
return 0;

    is_function = (abbrev->tag == DW_TAG_subprogram
     || abbrev->tag == DW_TAG_entry_point
     || abbrev->tag == DW_TAG_inlined_subroutine);

    if (abbrev->tag == DW_TAG_inlined_subroutine)
vec = vec_inlined;
    else
vec = vec_function;

    function = NULL((void*)0);
    if (is_function)
{
 function = ((struct function *)
      backtrace_alloc (state, sizeof *function,
		       error_callback, data));
 if (function == NULL((void*)0))
   return 0;
 memset (function, 0, sizeof *function);
}

    memset (&pcrange, 0, sizeof pcrange);
    have_linkage_name = 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, &ddata->dwarf_sections,
	       ddata->altlink, &val))
   return 0;

 /* The compile unit sets the base address for any address
    ranges in the function entries.  */
 if ((abbrev->tag == DW_TAG_compile_unit
      || abbrev->tag == DW_TAG_skeleton_unit)
     && abbrev->attrs[i].name == DW_AT_low_pc)
   {
     if (val.encoding == ATTR_VAL_ADDRESS)
base = (uintptr_t) val.u.uint;
     else if (val.encoding == ATTR_VAL_ADDRESS_INDEX)
{
  if (!resolve_addr_index (&ddata->dwarf_sections,
			   u->addr_base, u->addrsize,
			   ddata->is_bigendian, val.u.uint,
			   error_callback, data, &base))
    return 0;
}
   }

 if (is_function)
   {
     switch (abbrev->attrs[i].name)
{
case DW_AT_call_file:
  if (val.encoding == ATTR_VAL_UINT)
    {
      if (val.u.uint >= lhdr->filenames_count)
	{
	  dwarf_buf_error (unit_buf,
			   ("invalid file number in "
			    "DW_AT_call_file attribute"),
			   0);
	  return 0;
	}
      function->caller_filename = lhdr->filenames[val.u.uint];
    }
  break;

case DW_AT_call_line:
  if (val.encoding == ATTR_VAL_UINT)
    function->caller_lineno = val.u.uint;
  break;

case DW_AT_abstract_origin:
case DW_AT_specification:
  /* Second name preference: override DW_AT_name, don't override
     DW_AT_linkage_name.  */
  if (have_linkage_name)
    break;
  {
    const char *name;

    name
      = read_referenced_name_from_attr (ddata, u,
					&abbrev->attrs[i], &val,
					error_callback, data);
    if (name != NULL((void*)0))
      function->name = name;
  }
  break;

case DW_AT_name:
  /* Third name preference: don't override.  */
  if (function->name != NULL((void*)0))
    break;
  if (!resolve_string (&ddata->dwarf_sections, u->is_dwarf64,
		       ddata->is_bigendian,
		       u->str_offsets_base, &val,
		       error_callback, data, &function->name))
    return 0;
  break;

case DW_AT_linkage_name:
case DW_AT_MIPS_linkage_name:
  /* First name preference: override all.  */
  {
    const char *s;

    s = NULL((void*)0);
    if (!resolve_string (&ddata->dwarf_sections, u->is_dwarf64,
			 ddata->is_bigendian,
			 u->str_offsets_base, &val,
			 error_callback, data, &s))
      return 0;
    if (s != NULL((void*)0))
      {
	function->name = s;
	have_linkage_name = 1;
      }
  }
  break;

case DW_AT_low_pc: case DW_AT_high_pc: case DW_AT_ranges:
  update_pcrange (&abbrev->attrs[i], &val, &pcrange);
  break;

default:
  break;
}
   }
}

    /* If we couldn't find a name for the function, we have no use
for it.  */
    if (is_function && function->name == NULL((void*)0))
{
 backtrace_free (state, function, sizeof *function,
	  error_callback, data);
 is_function = 0;
}

    if (is_function)
{
 if (pcrange.have_ranges
     || (pcrange.have_lowpc && pcrange.have_highpc))
   {
     if (!add_ranges (state, &ddata->dwarf_sections,
	       ddata->base_address, ddata->is_bigendian,
	       u, base, &pcrange, add_function_range,
	       (void *) function, error_callback, data,
	       (void *) vec))
return 0;
   }
 else
   {
     backtrace_free (state, function, sizeof *function,
	      error_callback, data);
     is_function = 0;
   }
}

    if (abbrev->has_children)
{
 if (!is_function)
   {
     if (!read_function_entry (state, ddata, u, base, unit_buf, lhdr,
			error_callback, data, vec_function,
			vec_inlined))
return 0;
   }
 else
   {
     struct function_vector fvec;

     /* Gather any information for inlined functions in
 FVEC.  */

     memset (&fvec, 0, sizeof fvec);

     if (!read_function_entry (state, ddata, u, base, unit_buf, lhdr,
			error_callback, data, vec_function,
			&fvec))
return 0;

     if (fvec.count > 0)
{
  struct function_addrs *p;
  struct function_addrs *faddrs;

  /* Allocate a trailing entry, but don't include it
     in fvec.count.  */
  p = ((struct function_addrs *)
       backtrace_vector_grow (state,
			      sizeof (struct function_addrs),
			      error_callback, data,
			      &fvec.vec));
  if (p == NULL((void*)0))
    return 0;
  p->low = 0;
  --p->low;
  p->high = p->low;
  p->function = NULL((void*)0);

  if (!backtrace_vector_release (state, &fvec.vec,
				 error_callback, data))
    return 0;

  faddrs = (struct function_addrs *) fvec.vec.base;
  backtrace_qsort (faddrs, fvec.count,
		   sizeof (struct function_addrs),
		   function_addrs_compare);

  function->function_addrs = faddrs;
  function->function_addrs_count = fvec.count;
}
   }
}
  }

return 1;
3472}

3474/* Read function name information for a compilation unit.  We look
 through the whole unit looking for function tags.  */

3477static void
3478read_function_info (struct backtrace_state *state, struct dwarf_data *ddata,
    const struct line_header *lhdr,
    backtrace_error_callback error_callback, void *data,
    struct unit *u, struct function_vector *fvec,
    struct function_addrs **ret_addrs,
    size_t *ret_addrs_count)
3484{
struct function_vector lvec;
struct function_vector *pfvec;
struct dwarf_buf unit_buf;
struct function_addrs *p;
struct function_addrs *addrs;
size_t addrs_count;

/* Use FVEC if it is not NULL.  Otherwise use our own vector.  */
if (fvec != NULL((void*)0))
  pfvec = fvec;
else
  {
    memset (&lvec, 0, sizeof lvec);
    pfvec = &lvec;
  }

unit_buf.name = ".debug_info";
unit_buf.start = ddata->dwarf_sections.data[DEBUG_INFO];
unit_buf.buf = u->unit_data;
unit_buf.left = u->unit_data_len;
unit_buf.is_bigendian = ddata->is_bigendian;
unit_buf.error_callback = error_callback;
unit_buf.data = data;
unit_buf.reported_underflow = 0;

while (unit_buf.left > 0)
  {
    if (!read_function_entry (state, ddata, u, 0, &unit_buf, lhdr,
		error_callback, data, pfvec, pfvec))
return;
  }

if (pfvec->count == 0)
  return;

/* Allocate a trailing entry, but don't include it in
   pfvec->count.  */
p = ((struct function_addrs *)
     backtrace_vector_grow (state, sizeof (struct function_addrs),
	      error_callback, data, &pfvec->vec));
if (p == NULL((void*)0))
  return;
p->low = 0;
--p->low;
p->high = p->low;
p->function = NULL((void*)0);

addrs_count = pfvec->count;

if (fvec == NULL((void*)0))
  {
    if (!backtrace_vector_release (state, &lvec.vec, error_callback, data))
return;
    addrs = (struct function_addrs *) pfvec->vec.base;
  }
else
  {
    /* Finish this list of addresses, but leave the remaining space in
the vector available for the next function unit.  */
    addrs = ((struct function_addrs *)
      backtrace_vector_finish (state, &fvec->vec,
			error_callback, data));
    if (addrs == NULL((void*)0))
return;
    fvec->count = 0;
  }

backtrace_qsort (addrs, addrs_count, sizeof (struct function_addrs),
   function_addrs_compare);

*ret_addrs = addrs;
*ret_addrs_count = addrs_count;
3557}

3559/* See if PC is inlined in FUNCTION.  If it is, print out the inlined
 information, and update FILENAME and LINENO for the caller.
 Returns whatever CALLBACK returns, or 0 to keep going.  */

3563static int
3564report_inlined_functions (uintptr_t pc, struct function *function,
	  backtrace_full_callback callback, void *data,
	  const char **filename, int *lineno)
3567{
struct function_addrs *p;
struct function_addrs *match;
struct function *inlined;
int ret;

if (function->function_addrs_count == 0)
  return 0;

/* Our search isn't safe if pc == -1, as that is the sentinel
   value.  */
if (pc + 1 == 0)
  return 0;

p = ((struct function_addrs *)
     bsearch (&pc, function->function_addrs,
function->function_addrs_count,
sizeof (struct function_addrs),
function_addrs_search));
if (p == NULL((void*)0))
  return 0;

/* Here pc >= p->low && pc < (p + 1)->low.  The function_addrs are
   sorted by low, so if pc > p->low we are at the end of a range of
   function_addrs with the same low value.  If pc == p->low walk
   forward to the end of the range with that low value.  Then walk
   backward and use the first range that includes pc.  */
while (pc == (p + 1)->low)
  ++p;
match = NULL((void*)0);
while (1)
  {
    if (pc < p->high)
{
 match = p;
 break;
}
    if (p == function->function_addrs)
break;
    if ((p - 1)->low < p->low)
break;
    --p;
  }
if (match == NULL((void*)0))
  return 0;

/* We found an inlined call.  */

inlined = match->function;

/* Report any calls inlined into this one.  */
ret = report_inlined_functions (pc, inlined, callback, data,
		  filename, lineno);
if (ret != 0)
  return ret;

/* Report this inlined call.  */
ret = callback (data, pc, *filename, *lineno, inlined->name);
if (ret != 0)
  return ret;

/* Our caller will report the caller of the inlined function; tell
   it the appropriate filename and line number.  */
*filename = inlined->caller_filename;
*lineno = inlined->caller_lineno;

return 0;
3634}

3636/* Look for a PC in the DWARF mapping for one module.  On success,
 call CALLBACK and return whatever it returns.  On error, call
 ERROR_CALLBACK and return 0.  Sets *FOUND to 1 if the PC is found,
 0 if not.  */

3641static int
3642dwarf_lookup_pc (struct backtrace_state *state, struct dwarf_data *ddata,
 uintptr_t pc, backtrace_full_callback callback,
 backtrace_error_callback error_callback, void *data,
 int *found)
3646{
struct unit_addrs *entry;
int found_entry;
struct unit *u;
int new_data;
struct line *lines;
struct line *ln;
struct function_addrs *p;
struct function_addrs *fmatch;
struct function *function;
const char *filename;
int lineno;
int ret;

*found = 1;

/* Find an address range that includes PC.  Our search isn't safe if
   PC == -1, as we use that as a sentinel value, so skip the search
   in that case.  */
entry = (ddata->addrs_count == 0 || pc + 1 == 0
  ? NULL((void*)0)
  : bsearch (&pc, ddata->addrs, ddata->addrs_count,
      sizeof (struct unit_addrs), unit_addrs_search));

if (entry == NULL((void*)0))
  {
    *found = 0;
    return 0;
  }

/* Here pc >= entry->low && pc < (entry + 1)->low.  The unit_addrs
   are sorted by low, so if pc > p->low we are at the end of a range
   of unit_addrs with the same low value.  If pc == p->low walk
   forward to the end of the range with that low value.  Then walk
   backward and use the first range that includes pc.  */
while (pc == (entry + 1)->low)
  ++entry;
found_entry = 0;
while (1)
  {
    if (pc < entry->high)
{
 found_entry = 1;
 break;
}
    if (entry == ddata->addrs)
break;
    if ((entry - 1)->low < entry->low)
break;
    --entry;
  }
if (!found_entry)
  {
    *found = 0;
    return 0;
  }

/* We need the lines, lines_count, function_addrs,
   function_addrs_count fields of u.  If they are not set, we need
   to set them.  When running in threaded mode, we need to allow for
   the possibility that some other thread is setting them
   simultaneously.  */

u = entry->u;
lines = u->lines;

/* Skip units with no useful line number information by walking
   backward.  Useless line number information is marked by setting
   lines == -1.  */
while (entry > ddata->addrs
&& pc >= (entry - 1)->low
&& pc < (entry - 1)->high)
  {
    if (state->threaded)
lines = (struct line *) backtrace_atomic_load_pointer (&u->lines)__atomic_load_n ((&u->lines), 2);

    if (lines != (struct line *) (uintptr_t) -1)
break;

    --entry;

    u = entry->u;
    lines = u->lines;
  }

if (state->threaded)
  lines = backtrace_atomic_load_pointer (&u->lines)__atomic_load_n ((&u->lines), 2);

new_data = 0;
if (lines == NULL((void*)0))
  {
    struct function_addrs *function_addrs;
    size_t function_addrs_count;
    struct line_header lhdr;
    size_t count;

    /* We have never read the line information for this unit.  Read
it now.  */

    function_addrs = NULL((void*)0);
    function_addrs_count = 0;
    if (read_line_info (state, ddata, error_callback, data, entry->u, &lhdr,
	  &lines, &count))
{
 struct function_vector *pfvec;

 /* If not threaded, reuse DDATA->FVEC for better memory
    consumption.  */
 if (state->threaded)
   pfvec = NULL((void*)0);
 else
   pfvec = &ddata->fvec;
 read_function_info (state, ddata, &lhdr, error_callback, data,
	      entry->u, pfvec, &function_addrs,
	      &function_addrs_count);
 free_line_header (state, &lhdr, error_callback, data);
 new_data = 1;
}

    /* Atomically store the information we just read into the unit.
If another thread is simultaneously writing, it presumably
read the same information, and we don't care which one we
wind up with; we just leak the other one.  We do have to
write the lines field last, so that the acquire-loads above
ensure that the other fields are set.  */

    if (!state->threaded)
{
 u->lines_count = count;
 u->function_addrs = function_addrs;
 u->function_addrs_count = function_addrs_count;
 u->lines = lines;
}
    else
{
 backtrace_atomic_store_size_t (&u->lines_count, count)__atomic_store_n ((&u->lines_count), (count), 3);
 backtrace_atomic_store_pointer (&u->function_addrs, function_addrs)__atomic_store_n ((&u->function_addrs), (function_addrs
), 3);
 backtrace_atomic_store_size_t (&u->function_addrs_count,__atomic_store_n ((&u->function_addrs_count), (function_addrs_count
), 3)
			 function_addrs_count)__atomic_store_n ((&u->function_addrs_count), (function_addrs_count
), 3);
 backtrace_atomic_store_pointer (&u->lines, lines)__atomic_store_n ((&u->lines), (lines), 3);
}
  }

/* Now all fields of U have been initialized.  */

if (lines == (struct line *) (uintptr_t) -1)
  {
    /* If reading the line number information failed in some way,
try again to see if there is a better compilation unit for
this PC.  */
    if (new_data)
return dwarf_lookup_pc (state, ddata, pc, callback, error_callback,
		data, found);
    return callback (data, pc, NULL((void*)0), 0, NULL((void*)0));
  }

/* Search for PC within this unit.  */

ln = (struct line *) bsearch (&pc, lines, entry->u->lines_count,
		sizeof (struct line), line_search);
if (ln == NULL((void*)0))
  {
    /* The PC is between the low_pc and high_pc attributes of the
compilation unit, but no entry in the line table covers it.
This implies that the start of the compilation unit has no
line number information.  */

    if (entry->u->abs_filename == NULL((void*)0))
{
 const char *filename;

 filename = entry->u->filename;
 if (filename != NULL((void*)0)
     && !IS_ABSOLUTE_PATH (filename)(((((filename)[0]) == '/') || ((((filename)[0]) == '\\') &&
 (0))) || ((filename)[0] && ((filename)[1] == ':') &&
 (0)))
     && entry->u->comp_dir != NULL((void*)0))
   {
     size_t filename_len;
     const char *dir;
     size_t dir_len;
     char *s;

     filename_len = strlen (filename);
     dir = entry->u->comp_dir;
     dir_len = strlen (dir);
     s = (char *) backtrace_alloc (state, dir_len + filename_len + 2,
			    error_callback, data);
     if (s == NULL((void*)0))
{
  *found = 0;
  return 0;
}
     memcpy (s, dir, dir_len);
     /* FIXME: Should use backslash if DOS file system.  */
     s[dir_len] = '/';
     memcpy (s + dir_len + 1, filename, filename_len + 1);
     filename = s;
   }
 entry->u->abs_filename = filename;
}

    return callback (data, pc, entry->u->abs_filename, 0, NULL((void*)0));
  }

/* Search for function name within this unit.  */

if (entry->u->function_addrs_count == 0)
  return callback (data, pc, ln->filename, ln->lineno, NULL((void*)0));

p = ((struct function_addrs *)
     bsearch (&pc, entry->u->function_addrs,
entry->u->function_addrs_count,
sizeof (struct function_addrs),
function_addrs_search));
if (p == NULL((void*)0))
  return callback (data, pc, ln->filename, ln->lineno, NULL((void*)0));

/* Here pc >= p->low && pc < (p + 1)->low.  The function_addrs are
   sorted by low, so if pc > p->low we are at the end of a range of
   function_addrs with the same low value.  If pc == p->low walk
   forward to the end of the range with that low value.  Then walk
   backward and use the first range that includes pc.  */
while (pc == (p + 1)->low)
  ++p;
fmatch = NULL((void*)0);
while (1)
  {
    if (pc < p->high)
{
 fmatch = p;
 break;
}
    if (p == entry->u->function_addrs)
break;
    if ((p - 1)->low < p->low)
break;
    --p;
  }
if (fmatch == NULL((void*)0))
  return callback (data, pc, ln->filename, ln->lineno, NULL((void*)0));

function = fmatch->function;

filename = ln->filename;
lineno = ln->lineno;

ret = report_inlined_functions (pc, function, callback, data,
		  &filename, &lineno);
if (ret != 0)
  return ret;

return callback (data, pc, filename, lineno, function->name);
3897}


3900/* Return the file/line information for a PC using the DWARF mapping
 we built earlier.  */

3903static int
3904dwarf_fileline (struct backtrace_state *state, uintptr_t pc,
backtrace_full_callback callback,
backtrace_error_callback error_callback, void *data)
3907{
struct dwarf_data *ddata;
int found;
int ret;

if (!state->threaded)
  {
    for (ddata = (struct dwarf_data *) state->fileline_data;
  ddata != NULL((void*)0);
  ddata = ddata->next)
{
 ret = dwarf_lookup_pc (state, ddata, pc, callback, error_callback,
		 data, &found);
 if (ret != 0 || found)
   return ret;
}
  }
else
  {
    struct dwarf_data **pp;

    pp = (struct dwarf_data **) (void *) &state->fileline_data;
    while (1)
{
 ddata = backtrace_atomic_load_pointer (pp)__atomic_load_n ((pp), 2);
 if (ddata == NULL((void*)0))
   break;

 ret = dwarf_lookup_pc (state, ddata, pc, callback, error_callback,
		 data, &found);
 if (ret != 0 || found)
   return ret;

 pp = &ddata->next;
}
  }

/* FIXME: See if any libraries have been dlopen'ed.  */

return callback (data, pc, NULL((void*)0), 0, NULL((void*)0));
3947}

3949/* Initialize our data structures from the DWARF debug info for a
 file.  Return NULL on failure.  */

3952static struct dwarf_data *
3953build_dwarf_data (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)
3960{
struct unit_addrs_vector addrs_vec;
struct unit_addrs *addrs;
size_t addrs_count;
struct unit_vector units_vec;
struct unit **units;
size_t units_count;
struct dwarf_data *fdata;

if (!build_address_map (state, base_address, dwarf_sections, is_bigendian,
2
←
Calling 'build_address_map'→
	  altlink, error_callback, data, &addrs_vec,
	  &units_vec))
  return NULL((void*)0);

if (!backtrace_vector_release (state, &addrs_vec.vec, error_callback, data))
  return NULL((void*)0);
if (!backtrace_vector_release (state, &units_vec.vec, error_callback, data))
  return NULL((void*)0);
addrs = (struct unit_addrs *) addrs_vec.vec.base;
units = (struct unit **) units_vec.vec.base;
addrs_count = addrs_vec.count;
units_count = units_vec.count;
backtrace_qsort (addrs, addrs_count, sizeof (struct unit_addrs),
   unit_addrs_compare);
/* No qsort for units required, already sorted.  */

fdata = ((struct dwarf_data *)
  backtrace_alloc (state, sizeof (struct dwarf_data),
	    error_callback, data));
if (fdata == NULL((void*)0))
  return NULL((void*)0);

fdata->next = NULL((void*)0);
fdata->altlink = altlink;
fdata->base_address = base_address;
fdata->addrs = addrs;
fdata->addrs_count = addrs_count;
fdata->units = units;
fdata->units_count = units_count;
fdata->dwarf_sections = *dwarf_sections;
fdata->is_bigendian = is_bigendian;
memset (&fdata->fvec, 0, sizeof fdata->fvec);

return fdata;
4004}

4006/* Build our data structures from the DWARF sections for a module.
 Set FILELINE_FN and STATE->FILELINE_DATA.  Return 1 on success, 0
 on failure.  */

4010int
4011backtrace_dwarf_add (struct backtrace_state *state,
     uintptr_t base_address,
     const struct dwarf_sections *dwarf_sections,
     int is_bigendian,
     struct dwarf_data *fileline_altlink,
     backtrace_error_callback error_callback,
     void *data, fileline *fileline_fn,
     struct dwarf_data **fileline_entry)
4019{
struct dwarf_data *fdata;

fdata = build_dwarf_data (state, base_address, dwarf_sections, is_bigendian,
1
Calling 'build_dwarf_data'→
	    fileline_altlink, error_callback, data);
if (fdata == NULL((void*)0))
  return 0;

if (fileline_entry != NULL((void*)0))
  *fileline_entry = fdata;

if (!state->threaded)
  {
    struct dwarf_data **pp;

    for (pp = (struct dwarf_data **) (void *) &state->fileline_data;
  *pp != NULL((void*)0);
  pp = &(*pp)->next)
;
    *pp = fdata;
  }
else
  {
    while (1)
{
 struct dwarf_data **pp;

 pp = (struct dwarf_data **) (void *) &state->fileline_data;

 while (1)
   {
     struct dwarf_data *p;

     p = backtrace_atomic_load_pointer (pp)__atomic_load_n ((pp), 2);

     if (p == NULL((void*)0))
break;

     pp = &p->next;
   }

 if (__sync_bool_compare_and_swap (pp, NULL((void*)0), fdata))
   break;
}
  }

*fileline_fn = dwarf_fileline;

return 1;
4068}