/* dwarf.c -- display DWARF contents of a BFD binary file

   Copyright (C) 2005-2026 Free Software Foundation, Inc.

   This file is part of GNU Binutils.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA

   02110-1301, USA.  */

#include "sysdep.h"

#include "libiberty.h"

#include "bfd.h"

#include <stdint.h>

#include "bucomm.h"

#include "elfcomm.h"

#include "elf/common.h"

#include "dwarf2.h"

#include "dwarf.h"

#include "gdb/gdb-index.h"

#include "filenames.h"

#include "safe-ctype.h"

#include "sframe-api.h"

#include <assert.h>

#ifdef HAVE_LIBDEBUGINFOD

#include <elfutils/debuginfod.h>

#endif

#include <limits.h>

#ifndef CHAR_BIT

#define CHAR_BIT 8

#endif

#ifndef ENABLE_CHECKING

#define ENABLE_CHECKING 0

#endif

#undef MAX

#undef MIN

#define MAX(a, b) ((a) > (b) ? (a) : (b))

#define MIN(a, b) ((a) < (b) ? (a) : (b))

/* Flag values for the do_flags parameter passed

   to the process_debug_info() function.  */

#define DO_LOC         0x1

#define DO_TYPES       0x2

#define DO_GLOBAL_VARS 0x4

#define PRINT_SPACE(n) do { \

  int _i; \

  for (_i = 0; _i < (n); ++_i) \

    putchar (' '); \

} while (0)

#define PRINT_LBRACE(n) do { \

  PRINT_SPACE (n); \

  putchar ('{'); \

  putchar ('\n'); \

} while (0)

#define PRINT_RBRACE(n) do { \

  PRINT_SPACE (n); \

  putchar ('}'); \

  putchar ('\n'); \

} while (0)

static const char *regname (unsigned int regno, int row);

static const char *regname_internal_by_table_only (unsigned int regno);

static int have_frame_base;

static int frame_base_level = -1; /* To support nested DW_TAG_subprogram's.  */

static int need_base_address;

static unsigned int num_debug_info_entries = 0;

static unsigned int alloc_num_debug_info_entries = 0;

static debug_info *debug_information = NULL;

static struct base_type_l base_type_list = {NULL, NULL};

static struct type_def_l type_def_list = {NULL, NULL};

static struct enum_type_l enum_type_list = {NULL, NULL};

static struct tab_type_l tab_type_list = {NULL, NULL};

static struct member_parent_l struct_type_list = {NULL, NULL};

static struct member_parent_l union_type_list = {NULL, NULL};

static struct type_ptr_l ptr_type_list = {NULL, NULL};

static struct type_ref_l const_type_list = {NULL, NULL};

static struct type_ref_l volatile_type_list = {NULL, NULL};

static struct variable_type_l variable_type_list = {NULL, NULL};

/* Special value for num_debug_info_entries to indicate

   that the .debug_info section could not be loaded/parsed.  */

#define DEBUG_INFO_UNAVAILABLE  (unsigned int) -1

/* A .debug_info section can contain multiple links to separate

   DWO object files.  We use these structures to record these links.  */

typedef enum dwo_type

{

  DWO_NAME,

  DWO_DIR,

  DWO_ID

} dwo_type;

typedef struct dwo_info

{

  dwo_type          type;

  const char *      value;

  uint64_t          cu_offset;

  struct dwo_info * next;

} dwo_info;

static dwo_info *first_dwo_info = NULL;

static bool need_dwo_info;

separate_info * first_separate_info = NULL;

unsigned int eh_addr_size;

const char * separate_debug_info_dir = NULL;

int do_debug_info;

int do_debug_abbrevs;

int do_debug_lines;

int do_debug_pubnames;

int do_debug_pubtypes;

int do_debug_aranges;

int do_debug_ranges;

int do_debug_frames;

int do_debug_frames_interp;

int do_debug_macinfo;

int do_debug_str;

int do_debug_str_offsets;

int do_debug_loc;

int do_gdb_index;

int do_sframe;

int do_trace_info;

int do_trace_abbrevs;

int do_trace_aranges;

int do_debug_addr;

int do_debug_cu_index;

int do_wide;

int do_debug_links;

int do_follow_links = DEFAULT_FOR_FOLLOW_LINKS;

#ifdef HAVE_LIBDEBUGINFOD

int use_debuginfod = 1;

#endif

bool do_checks;

int dwarf_cutoff_level = -1;

unsigned long dwarf_start_die;

int dwarf_check = 0;

/* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index

   sections.  For version 1 package files, each set is stored in SHNDX_POOL

   as a zero-terminated list of section indexes comprising one set of debug

   sections from a .dwo file.  */

static unsigned int *shndx_pool = NULL;

static unsigned int shndx_pool_size = 0;

static unsigned int shndx_pool_used = 0;

/* For version 2 package files, each set contains an array of section offsets

   and an array of section sizes, giving the offset and size of the

   contribution from a CU or TU within one of the debug sections.

   When displaying debug info from a package file, we need to use these

   tables to locate the corresponding contributions to each section.  */

struct cu_tu_set

{

  uint64_t signature;

  uint64_t section_offsets[DW_SECT_MAX];

  size_t   section_sizes[DW_SECT_MAX];

};

static int cu_count = 0;

static int tu_count = 0;

static struct cu_tu_set *cu_sets = NULL;

static struct cu_tu_set *tu_sets = NULL;

static bool load_cu_tu_indexes (void *);

/* An array that indicates for a given level of CU nesting whether

   the latest DW_AT_type seen for that level was a signed type or

   an unsigned type.  */

#define MAX_CU_NESTING (1 << 8)

static bool level_type_signed[MAX_CU_NESTING];

/* Values for do_debug_lines.  */

#define FLAG_DEBUG_LINES_RAW   1

#define FLAG_DEBUG_LINES_DECODED 2

static unsigned int

size_of_encoded_value (int encoding)

{

  switch (encoding & 0x7)

    {

    default:  /* ??? */

    case 0: return eh_addr_size;

    case 2: return 2;

    case 3: return 4;

    case 4: return 8;

    }

}

static uint64_t

get_encoded_value (unsigned char **pdata,

       int encoding,

       struct dwarf_section *section,

       unsigned char * end)

{

  unsigned char * data = * pdata;

  unsigned int size = size_of_encoded_value (encoding);

  uint64_t val;

  if (data >= end || size > (size_t) (end - data))

    {

      warn (_("Encoded value extends past end of section\n"));

      * pdata = end;

      return 0;

    }

  /* PR 17512: file: 002-829853-0.004.  */

  if (size > 8)

    {

      warn (_("Encoded size of %d is too large to read\n"), size);

      * pdata = end;

      return 0;

    }

  /* PR 17512: file: 1085-5603-0.004.  */

  if (size == 0)

    {

      warn (_("Encoded size of 0 is too small to read\n"));

      * pdata = end;

      return 0;

    }

  if (encoding & DW_EH_PE_signed)

    val = byte_get_signed (data, size);

  else

    val = byte_get (data, size);

  if ((encoding & 0x70) == DW_EH_PE_pcrel)

    val += section->address + (data - section->start);

  * pdata = data + size;

  return val;

}

/* Print a uint64_t value (typically an address, offset or length) in

   hexadecimal format, followed by a space.  The precision displayed is

   determined by the NUM_BYTES parameter.  */

static void

print_hex (uint64_t value, unsigned num_bytes)

{

  if (num_bytes == 0)

    num_bytes = 2;

  printf ("%0*" PRIx64 " ", num_bytes * 2,

    value & ~(~(uint64_t) 0 << num_bytes * 4 << num_bytes * 4));

}

/* Like print_hex, but no trailing space.  */

static void

print_hex_ns (uint64_t value, unsigned num_bytes)

{

  if (num_bytes == 0)

    num_bytes = 2;

  printf ("%0*" PRIx64, num_bytes * 2,

    value & ~(~(uint64_t) 0 << num_bytes * 4 << num_bytes * 4));

}

/* Print a view number in hexadecimal value, with the same width as

   print_hex would have printed it.  */

static void

print_view (uint64_t value, unsigned num_bytes)

{

  if (num_bytes == 0)

    num_bytes = 2;

  printf ("v%0*" PRIx64 " ", num_bytes * 2 - 1,

    value & ~(~(uint64_t) 0 << num_bytes * 4 << num_bytes * 4));

}

static const char *

null_name (const char *p)

{

  if (p == NULL)

    p = _("unknown");

  return p;

}

/* Read in a LEB128 encoded value starting at address DATA.

   If SIGN is true, return a signed LEB128 value.

   If LENGTH_RETURN is not NULL, return in it the number of bytes read.

   If STATUS_RETURN is not NULL, return with bit 0 (LSB) set if the

   terminating byte was not found and with bit 1 set if the value

   overflows a uint64_t.

   No bytes will be read at address END or beyond.  */

uint64_t

read_leb128 (const unsigned char *data,

       const unsigned char *const end,

       bool sign,

       unsigned int *length_return,

       int *status_return)

{

  uint64_t result = 0;

  unsigned int num_read = 0;

  unsigned int shift = 0;

  int status = 1;

  while (data < end)

    {

      unsigned char byte = *data++;

      unsigned char lost, mask;

      num_read++;

      if (shift < CHAR_BIT * sizeof (result))

  {

    result |= ((uint64_t) (byte & 0x7f)) << shift;

    /* These bits overflowed.  */

    lost = byte ^ (result >> shift);

    /* And this is the mask of possible overflow bits.  */

    mask = 0x7f ^ ((uint64_t) 0x7f << shift >> shift);

    shift += 7;

  }

      else

  {

    lost = byte;

    mask = 0x7f;

  }

      if ((lost & mask) != (sign && (int64_t) result < 0 ? mask : 0))

  status |= 2;

      if ((byte & 0x80) == 0)

  {

    status &= ~1;

    if (sign && shift < CHAR_BIT * sizeof (result) && (byte & 0x40))

      result |= -((uint64_t) 1 << shift);

    break;

  }

    }

  if (length_return != NULL)

    *length_return = num_read;

  if (status_return != NULL)

    *status_return = status;

  return result;

}

/* Read AMOUNT bytes from PTR and store them in VAL.

   Checks to make sure that the read will not reach or pass END.

   FUNC chooses whether the value read is unsigned or signed, and may

   be either byte_get or byte_get_signed.  If INC is true, PTR is

   incremented after reading the value.

   This macro cannot protect against PTR values derived from user input.

   The C standard sections 6.5.6 and 6.5.8 say attempts to do so using

   pointers is undefined behaviour.  */

#define SAFE_BYTE_GET_INTERNAL(VAL, PTR, AMOUNT, END, FUNC, INC)  \

  do                  \

    {                 \

      size_t amount = (AMOUNT);            \

      if (sizeof (VAL) < amount)         \

  {               \

    error (ngettext ("internal error: attempt to read %d byte " \

         "of data in to %d sized variable",   \

         "internal error: attempt to read %d bytes "  \

         "of data in to %d sized variable",   \

         amount),         \

     (int) amount, (int) sizeof (VAL));     \

    amount = sizeof (VAL);          \

  }                \

      if (ENABLE_CHECKING)           \

  assert ((PTR) <= (END));          \

      size_t avail = (END) - (PTR);         \

      if ((PTR) > (END))           \

  avail = 0;             \

      if (amount > avail)           \

  amount = avail;             \

      if (amount == 0)             \

  (VAL) = 0;             \

      else                \

  (VAL) = (FUNC) ((PTR), amount);         \

      if (INC)               \

  (PTR) += amount;           \

    }                 \

  while (0)

#define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END)  \

  SAFE_BYTE_GET_INTERNAL (VAL, PTR, AMOUNT, END, byte_get, false)

#define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END)  \

  SAFE_BYTE_GET_INTERNAL (VAL, PTR, AMOUNT, END, byte_get, true)

#define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \

  SAFE_BYTE_GET_INTERNAL (VAL, PTR, AMOUNT, END, byte_get_signed, false)

#define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \

  SAFE_BYTE_GET_INTERNAL (VAL, PTR, AMOUNT, END, byte_get_signed, true)

typedef struct State_Machine_Registers

{

  uint64_t address;

  unsigned int view;

  unsigned int file;

  unsigned int line;

  unsigned int column;

  int is_stmt;

  int basic_block;

  unsigned char op_index;

  unsigned char end_sequence;

  /* This variable hold the number of the last entry seen

     in the File Table.  */

  unsigned int last_file_entry;

} SMR;

static SMR state_machine_regs;

static void

reset_state_machine (int is_stmt)

{

  state_machine_regs.address = 0;

  state_machine_regs.view = 0;

  state_machine_regs.op_index = 0;

  state_machine_regs.file = 1;

  state_machine_regs.line = 1;

  state_machine_regs.column = 0;

  state_machine_regs.is_stmt = is_stmt;

  state_machine_regs.basic_block = 0;

  state_machine_regs.end_sequence = 0;

  state_machine_regs.last_file_entry = 0;

}

/* Handled an extend line op.

   Returns the number of bytes read.  */

static size_t

process_extended_line_op (unsigned char * data,

        int is_stmt,

        unsigned char * end)

{

  unsigned char op_code;

  size_t len, header_len;

  unsigned char *name;

  unsigned char *orig_data = data;

  uint64_t adr, val;

  READ_ULEB (len, data, end);

  header_len = data - orig_data;

  if (len == 0 || data >= end || len > (size_t) (end - data))

    {

      warn (_("Badly formed extended line op encountered!\n"));

      return header_len;

    }

  op_code = *data++;

  printf (_("  Extended opcode %d: "), op_code);

  switch (op_code)

    {

    case DW_LNE_end_sequence:

      printf (_("End of Sequence\n\n"));

      reset_state_machine (is_stmt);

      break;

    case DW_LNE_set_address:

      /* PR 17512: file: 002-100480-0.004.  */

      if (len - 1 > 8)

  {

    warn (_("Length (%zu) of DW_LNE_set_address op is too long\n"),

    len - 1);

    adr = 0;

  }

      else

  SAFE_BYTE_GET (adr, data, len - 1, end);

      printf (_("set Address to %#" PRIx64 "\n"), adr);

      state_machine_regs.address = adr;

      state_machine_regs.view = 0;

      state_machine_regs.op_index = 0;

      break;

    case DW_LNE_define_file:

      printf (_("define new File Table entry\n"));

      printf (_("  Entry\tDir\tTime\tSize\tName\n"));

      printf ("   %d\t", ++state_machine_regs.last_file_entry);

      {

  size_t l;

  name = data;

  l = strnlen ((char *) data, end - data);

  data += l;

  if (data < end)

    data++;

  READ_ULEB (val, data, end);

  printf ("%" PRIu64 "\t", val);

  READ_ULEB (val, data, end);

  printf ("%" PRIu64 "\t", val);

  READ_ULEB (val, data, end);

  printf ("%" PRIu64 "\t", val);

  printf ("%.*s\n\n", (int) l, name);

      }

      if (((size_t) (data - orig_data) != len + header_len) || data >= end)

  warn (_("DW_LNE_define_file: Bad opcode length\n"));

      break;

    case DW_LNE_set_discriminator:

      READ_ULEB (val, data, end);

      printf (_("set Discriminator to %" PRIu64 "\n"), val);

      break;

      /* HP extensions.  */

    case DW_LNE_HP_negate_is_UV_update:

      printf ("DW_LNE_HP_negate_is_UV_update\n");

      break;

    case DW_LNE_HP_push_context:

      printf ("DW_LNE_HP_push_context\n");

      break;

    case DW_LNE_HP_pop_context:

      printf ("DW_LNE_HP_pop_context\n");

      break;

    case DW_LNE_HP_set_file_line_column:

      printf ("DW_LNE_HP_set_file_line_column\n");

      break;

    case DW_LNE_HP_set_routine_name:

      printf ("DW_LNE_HP_set_routine_name\n");

      break;

    case DW_LNE_HP_set_sequence:

      printf ("DW_LNE_HP_set_sequence\n");

      break;

    case DW_LNE_HP_negate_post_semantics:

      printf ("DW_LNE_HP_negate_post_semantics\n");

      break;

    case DW_LNE_HP_negate_function_exit:

      printf ("DW_LNE_HP_negate_function_exit\n");

      break;

    case DW_LNE_HP_negate_front_end_logical:

      printf ("DW_LNE_HP_negate_front_end_logical\n");

      break;

    case DW_LNE_HP_define_proc:

      printf ("DW_LNE_HP_define_proc\n");

      break;

    case DW_LNE_HP_source_file_correlation:

      {

  unsigned char *edata = data + len - 1;

  printf ("DW_LNE_HP_source_file_correlation\n");

  while (data < edata)

    {

      unsigned int opc;

      READ_ULEB (opc, data, edata);

      switch (opc)

        {

        case DW_LNE_HP_SFC_formfeed:

    printf ("    DW_LNE_HP_SFC_formfeed\n");

    break;

        case DW_LNE_HP_SFC_set_listing_line:

    READ_ULEB (val, data, edata);

    printf ("    DW_LNE_HP_SFC_set_listing_line (%" PRIu64 ")\n",

      val);

    break;

        case DW_LNE_HP_SFC_associate:

    printf ("    DW_LNE_HP_SFC_associate ");

    READ_ULEB (val, data, edata);

    printf ("(%" PRIu64 , val);

    READ_ULEB (val, data, edata);

    printf (",%" PRIu64, val);

    READ_ULEB (val, data, edata);

    printf (",%" PRIu64 ")\n", val);

    break;

        default:

    printf (_("    UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc);

    data = edata;

    break;

        }

    }

      }

      break;

    default:

      {

  unsigned int rlen = len - 1;

  if (op_code >= DW_LNE_lo_user

      /* The test against DW_LNW_hi_user is redundant due to

         the limited range of the unsigned char data type used

         for op_code.  */

      /*&& op_code <= DW_LNE_hi_user*/)

    printf (_("user defined: "));

  else

    printf (_("UNKNOWN: "));

  printf (_("length %d ["), rlen);

  for (; rlen; rlen--)

    printf (" %02x", *data++);

  printf ("]\n");

      }

      break;

    }

  return len + header_len;

}

static const char *

fetch_indirect_string (uint64_t offset)

{

  struct dwarf_section *section = &debug_displays [str].section;

  const char *ret;

  if (section->start == NULL)

    return _("<no .debug_str section>");

  if (offset >= section->size)

    {

      warn (_("DW_FORM_strp offset too big: %#" PRIx64 "\n"), offset);

      return _("<offset is too big>");

    }

  ret = (const char *) (section->start + offset);

  /* Unfortunately we cannot rely upon the .debug_str section ending with a

     NUL byte.  Since our caller is expecting to receive a well formed C

     string we test for the lack of a terminating byte here.  */

  if (strnlen (ret, section->size - offset)

      == section->size - offset)

    ret = _("<no NUL byte at end of .debug_str section>");

  return ret;

}

static const char *

fetch_indirect_line_string (uint64_t offset)

{

  struct dwarf_section *section = &debug_displays [line_str].section;

  const char *ret;

  if (section->start == NULL)

    return _("<no .debug_line_str section>");

  if (offset >= section->size)

    {

      warn (_("DW_FORM_line_strp offset too big: %#" PRIx64 "\n"), offset);

      return _("<offset is too big>");

    }

  ret = (const char *) (section->start + offset);

  /* Unfortunately we cannot rely upon the .debug_line_str section ending

     with a NUL byte.  Since our caller is expecting to receive a well formed

     C string we test for the lack of a terminating byte here.  */

  if (strnlen (ret, section->size - offset)

      == section->size - offset)

    ret = _("<no NUL byte at end of .debug_line_str section>");

  return ret;

}

static const char *

fetch_indexed_string (uint64_t idx,

          struct cu_tu_set *this_set,

          uint64_t offset_size,

          bool dwo,

          uint64_t str_offsets_base)

{

  enum dwarf_section_display_enum str_sec_idx = dwo ? str_dwo : str;

  enum dwarf_section_display_enum idx_sec_idx = dwo ? str_index_dwo : str_index;

  struct dwarf_section *index_section = &debug_displays [idx_sec_idx].section;

  struct dwarf_section *str_section = &debug_displays [str_sec_idx].section;

  uint64_t index_offset;

  uint64_t str_offset;

  const char * ret;

  if (index_section->start == NULL)

    return (dwo ? _("<no .debug_str_offsets.dwo section>")

    : _("<no .debug_str_offsets section>"));

  if (str_section->start == NULL)

    return (dwo ? _("<no .debug_str.dwo section>")

    : _("<no .debug_str section>"));

  if (_mul_overflow (idx, offset_size, &index_offset)

      || (this_set != NULL

    && ((index_offset += this_set->section_offsets [DW_SECT_STR_OFFSETS])

        < this_set->section_offsets [DW_SECT_STR_OFFSETS]))

      || (index_offset += str_offsets_base) < str_offsets_base

      || index_offset + offset_size < offset_size

      || index_offset + offset_size > index_section->size)

    {

      warn (_("string index of %" PRIu64 " converts to an offset of %#" PRIx64

        " which is too big for section %s\n"),

      idx, index_offset, str_section->name);

      return _("<string index too big>");

    }

  str_offset = byte_get (index_section->start + index_offset, offset_size);

  if (str_offset >= str_section->size)

    {

      warn (_("indirect offset too big: %#" PRIx64 "\n"), str_offset);

      return _("<indirect index offset is too big>");

    }

  ret = (const char *) str_section->start + str_offset;

  /* Unfortunately we cannot rely upon str_section ending with a NUL byte.

     Since our caller is expecting to receive a well formed C string we test

     for the lack of a terminating byte here.  */

  if (strnlen (ret, str_section->size - str_offset)

      == str_section->size - str_offset)

    return _("<no NUL byte at end of section>");

  return ret;

}

static uint64_t

fetch_indexed_addr (uint64_t offset, uint32_t num_bytes)

{

  struct dwarf_section *section = &debug_displays [debug_addr].section;

  if (section->start == NULL)

    {

      warn (_("Cannot fetch indexed address: the .debug_addr section is missing\n"));

      return 0;

    }

  if (offset > section->size

      || num_bytes > section->size - offset)

    {

      warn (_("Offset into section %s too big: %#" PRIx64 "\n"),

      section->name, offset);

      return 0;

    }

  return byte_get (section->start + offset, num_bytes);

}

/* This is for resolving DW_FORM_rnglistx and DW_FORM_loclistx.

   The memory layout is: base_address (taken from the CU's top DIE) points at a table of offsets,

   relative to the section start.

   The table of offsets contains the offsets of objects of interest relative to the table of offsets.

   IDX is the index of the desired object in said table of offsets.

   This returns the offset of the desired object relative to the section start or -1 upon failure.  */

static uint64_t

fetch_indexed_offset (uint64_t                         idx,

          enum dwarf_section_display_enum  sec_enum,

          uint64_t                         base_address,

          uint64_t                         offset_size)

{

  uint64_t offset_of_offset;

  struct dwarf_section *section = &debug_displays [sec_enum].section;

  if (section->start == NULL)

    {

      warn (_("Unable to locate %s section\n"), section->uncompressed_name);

      return -1;

    }

  if (_bfd_mul_overflow (idx, offset_size, &offset_of_offset)

      || (offset_of_offset += base_address) < base_address

      || offset_of_offset > section->size

      || offset_size > section->size - offset_of_offset)

    {

      warn (_("Base %#" PRIx64 " with index %#" PRIx64 " is too big for section %s\n"),

      base_address, idx, section->name);

      return -1;

    }

  return base_address + byte_get (section->start + offset_of_offset, offset_size);

}

/* FIXME:  There are better and more efficient ways to handle

   these structures.  For now though, I just want something that

   is simple to implement.  */

/* Records a single attribute in an abbrev.  */

typedef struct abbrev_attr

{

  unsigned long attribute;

  unsigned long form;

  int64_t implicit_const;

  struct abbrev_attr *next;

}

abbrev_attr;

/* Records a single abbrev.  */

typedef struct abbrev_entry

{

  unsigned long          number;

  unsigned long          tag;

  int                    children;

  struct abbrev_attr *   first_attr;

  struct abbrev_attr *   last_attr;

  struct abbrev_entry *  next;

}

abbrev_entry;

/* Records a set of abbreviations.  */

typedef struct abbrev_list

{

  abbrev_entry *        first_abbrev;

  abbrev_entry *        last_abbrev;

  unsigned char *       raw;

  struct abbrev_list *  next;

  unsigned char *       start_of_next_abbrevs;

}

abbrev_list;

/* Records all the abbrevs found so far.  */

static struct abbrev_list * abbrev_lists = NULL;

typedef struct abbrev_map

{

  uint64_t start;

  uint64_t end;

  abbrev_list *list;

} abbrev_map;

/* Maps between CU offsets and abbrev sets.  */

static abbrev_map *   cu_abbrev_map = NULL;

static unsigned long  num_abbrev_map_entries = 0;

static unsigned long  next_free_abbrev_map_entry = 0;

#define INITIAL_NUM_ABBREV_MAP_ENTRIES 8

#define ABBREV_MAP_ENTRIES_INCREMENT   8

static void

record_abbrev_list_for_cu (uint64_t start, uint64_t end,

         abbrev_list *list, abbrev_list *free_list)

{

  if (free_list != NULL)

    {

      list->next = abbrev_lists;

      abbrev_lists = list;

    }

  if (cu_abbrev_map == NULL)

    {

      num_abbrev_map_entries = INITIAL_NUM_ABBREV_MAP_ENTRIES;

      cu_abbrev_map = xmalloc (num_abbrev_map_entries * sizeof (* cu_abbrev_map));

    }

  else if (next_free_abbrev_map_entry == num_abbrev_map_entries)

    {

      num_abbrev_map_entries += ABBREV_MAP_ENTRIES_INCREMENT;

      cu_abbrev_map = xrealloc (cu_abbrev_map, num_abbrev_map_entries * sizeof (* cu_abbrev_map));

    }

  cu_abbrev_map[next_free_abbrev_map_entry].start = start;

  cu_abbrev_map[next_free_abbrev_map_entry].end = end;

  cu_abbrev_map[next_free_abbrev_map_entry].list = list;

  next_free_abbrev_map_entry ++;

}

static abbrev_list *

free_abbrev_list (abbrev_list *list)

{

  abbrev_entry *abbrv = list->first_abbrev;

  while (abbrv)

    {

      abbrev_attr *attr = abbrv->first_attr;

      while (attr)

  {

    abbrev_attr *next_attr = attr->next;

    free (attr);

    attr = next_attr;

  }

      abbrev_entry *next_abbrev = abbrv->next;

      free (abbrv);

      abbrv = next_abbrev;

    }

  abbrev_list *next = list->next;

  free (list);

  return next;

}

static void

free_all_abbrevs (void)

{

  while (abbrev_lists)

    abbrev_lists = free_abbrev_list (abbrev_lists);

  free (cu_abbrev_map);

  cu_abbrev_map = NULL;

  next_free_abbrev_map_entry = 0;

}

static abbrev_list *

find_abbrev_list_by_raw_abbrev (unsigned char *raw)

{

  abbrev_list * list;

  for (list = abbrev_lists; list != NULL; list = list->next)

    if (list->raw == raw)

      return list;

  return NULL;

}

/* Find the abbreviation map for the CU that includes OFFSET.

   OFFSET is an absolute offset from the start of the .debug_info section.  */

/* FIXME: This function is going to slow down readelf & objdump.

   Not caching abbrevs is likely the answer.  */

static  abbrev_map *

find_abbrev_map_by_offset (uint64_t offset)

{

  unsigned long i;

  for (i = 0; i < next_free_abbrev_map_entry; i++)

    if (cu_abbrev_map[i].start <= offset

  && cu_abbrev_map[i].end > offset)

      return cu_abbrev_map + i;

  return NULL;

}

static void

add_abbrev (unsigned long  number,

      unsigned long  tag,

      int            children,

      abbrev_list *  list)

{

  abbrev_entry *  entry;

  entry = (abbrev_entry *) xmalloc (sizeof (*entry));

  entry->number     = number;

  entry->tag        = tag;

  entry->children   = children;

  entry->first_attr = NULL;

  entry->last_attr  = NULL;

  entry->next       = NULL;

  assert (list != NULL);

  if (list->first_abbrev == NULL)

    list->first_abbrev = entry;

  else

    list->last_abbrev->next = entry;

  list->last_abbrev = entry;

}

static void

add_abbrev_attr (unsigned long attribute,

     unsigned long form,

     int64_t implicit_const,

     abbrev_list *list)

{

  abbrev_attr *attr;

  attr = (abbrev_attr *) xmalloc (sizeof (*attr));

  attr->attribute      = attribute;

  attr->form           = form;

  attr->implicit_const = implicit_const;

  attr->next           = NULL;

  assert (list != NULL && list->last_abbrev != NULL);

  if (list->last_abbrev->first_attr == NULL)

    list->last_abbrev->first_attr = attr;

  else

    list->last_abbrev->last_attr->next = attr;

  list->last_abbrev->last_attr = attr;

}

/* Return processed (partial) contents of a .debug_abbrev section.

   Returns NULL on errors.  */

static abbrev_list *

process_abbrev_set (struct dwarf_section *section,

        unsigned char *start,

        unsigned char *end)

{

  abbrev_list *list = xmalloc (sizeof (*list));

  list->first_abbrev = NULL;

  list->last_abbrev = NULL;

  list->raw = start;

  list->next = NULL;

  while (start < end)

    {

      unsigned long entry;

      unsigned long tag;

      unsigned long attribute;

      int children;

      READ_ULEB (entry, start, end);

      /* A single zero is supposed to end the set according

   to the standard.  If there's more, then signal that to

   the caller.  */

      if (start == end || entry == 0)

  {

    list->start_of_next_abbrevs = start != end ? start : NULL;

    return list;

  }

      READ_ULEB (tag, start, end);

      if (start == end)

  return free_abbrev_list (list);

      children = *start++;

      add_abbrev (entry, tag, children, list);

      do

  {

    unsigned long form;