#include "sysdep.h"

#include "libiberty.h"

#include "bfd.h"

#include "bfd_stdint.h"

#include "bucomm.h"

#include "elfcomm.h"

#include "elf/common.h"

#include "dwarf2.h"

#include "dwarf.h"

#include "gdb/gdb-index.h"

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

static int have_frame_base;

static int need_base_address;

static unsigned int last_pointer_size = 0;

static int warned_about_missing_comp_units = FALSE;

static unsigned int num_debug_info_entries = 0;

static unsigned int alloc_num_debug_info_entries = 0;

static debug_info *debug_information = NULL;

#define DEBUG_INFO_UNAVAILABLE (unsigned int) -1

unsigned int eh_addr_size;

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_loc;

int do_gdb_index;

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 dwarf_cutoff_level = -1;

unsigned long dwarf_start_die;

int dwarf_check = 0;

static int cu_tu_indexes_read = 0;

static unsigned int *shndx_pool = NULL;

static unsigned int shndx_pool_size = 0;

static unsigned int shndx_pool_used = 0;

struct cu_tu_set

};

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 void load_cu_tu_indexes (void *file);

#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 dwarf_vma

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);

dwarf_vma val;

if (data + size >= end)

{

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;

}

#if defined HAVE_LONG_LONG && SIZEOF_LONG_LONG > SIZEOF_LONG

# ifndef __MINGW32__

# define DWARF_VMA_FMT "ll"

# define DWARF_VMA_FMT_LONG "%16.16llx"

# define DWARF_VMA_FMT "I64"

# define DWARF_VMA_FMT_LONG "%016I64x"

# define DWARF_VMA_FMT "l"

# define DWARF_VMA_FMT_LONG "%16.16lx"

static const char *

dwarf_vmatoa_1 (const char *fmtch, dwarf_vma value, unsigned num_bytes)

{

/* As dwarf_vmatoa is used more then once in a printf call

static int buf_pos = 0;

static struct dwarf_vmatoa_buf

{

char place[64];

} buf[16];

char *ret;

ret = buf[buf_pos++].place;

buf_pos %= ARRAY_SIZE (buf);

if (num_bytes)

{

/* Printf does not have a way of specifiying a maximum field width for an

snprintf (ret, sizeof (buf[0].place), DWARF_VMA_FMT_LONG, value);

if (num_bytes > 8)

num_bytes = 8;

return ret + (16 - 2 * num_bytes);

}

else

{

char fmt[32];

sprintf (fmt, "%%%s%s", DWARF_VMA_FMT, fmtch);

snprintf (ret, sizeof (buf[0].place), fmt, value);

return ret;

}

}

static inline const char *

dwarf_vmatoa (const char * fmtch, dwarf_vma value)

{

return dwarf_vmatoa_1 (fmtch, value, 0);

}

static void

print_dwarf_vma (dwarf_vma value, unsigned num_bytes)

{

printf ("%s ", dwarf_vmatoa_1 (NULL, value, num_bytes));

}

static const char *

dwarf_vmatoa64 (dwarf_vma hvalue, dwarf_vma lvalue, char *buf,

unsigned int buf_len)

{

int len = 0;

if (hvalue == 0)

snprintf (buf, buf_len, "%" DWARF_VMA_FMT "x", lvalue);

else

{

len = snprintf (buf, buf_len, "%" DWARF_VMA_FMT "x", hvalue);

snprintf (buf + len, buf_len - len,

"%08" DWARF_VMA_FMT "x", lvalue);

}

return buf;

}

read_leb128 (unsigned char *data,

unsigned int *length_return,

bfd_boolean sign,

const unsigned char * const end)

{

dwarf_vma result = 0;

unsigned int num_read = 0;

unsigned int shift = 0;

unsigned char byte = 0;

while (data < end)

{

byte = *data++;

num_read++;

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

shift += 7;

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

break;

/* PR 17512: file: 0ca183b8.

if (shift >= sizeof (result) * 8)

break;

}

if (length_return != NULL)

*length_return = num_read;

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

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

return result;

}

static inline dwarf_signed_vma

read_sleb128 (unsigned char * data,

unsigned int * length_return,

const unsigned char * const end)

{

return (dwarf_signed_vma) read_leb128 (data, length_return, TRUE, end);

}

static inline dwarf_vma

read_uleb128 (unsigned char * data,

unsigned int * length_return,

const unsigned char * const end)

{

return read_leb128 (data, length_return, FALSE, end);

}

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

do \

{ \

unsigned int amount = (AMOUNT); \

if (sizeof (VAL) < amount) \

{ \

error (_("internal error: attempt to read %d bytes of data in to %d sized variable"),\

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

amount = sizeof (VAL); \

} \

if (((PTR) + amount) >= (END)) \

{ \

if ((PTR) < (END)) \

amount = (END) - (PTR); \

else \

amount = 0; \

} \

if (amount == 0 || amount > 8) \

VAL = 0; \

else \

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

} \

while (0)

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

do \

{ \

SAFE_BYTE_GET (VAL, PTR, AMOUNT, END); \

PTR += AMOUNT; \

} \

while (0)

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

do \

{ \

unsigned int amount = (AMOUNT); \

if (((PTR) + amount) >= (END)) \

{ \

if ((PTR) < (END)) \

amount = (END) - (PTR); \

else \

amount = 0; \

} \

if (amount) \

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

else \

VAL = 0; \

} \

while (0)

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

do \

{ \

SAFE_SIGNED_BYTE_GET (VAL, PTR, AMOUNT, END); \

PTR += AMOUNT; \

} \

while (0)

#define SAFE_BYTE_GET64(PTR, HIGH, LOW, END) \

do \

{ \

if (((PTR) + 8) <= (END)) \

{ \

byte_get_64 ((PTR), (HIGH), (LOW)); \

} \

else \

{ \

* (LOW) = * (HIGH) = 0; \

} \

} \

while (0)

typedef struct State_Machine_Registers

} SMR;

static SMR state_machine_regs;

static void

reset_state_machine (int is_stmt)

{

state_machine_regs.address = 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;

}

static int

process_extended_line_op (unsigned char * data,

int is_stmt,

unsigned char * end)

{

unsigned char op_code;

unsigned int bytes_read;

unsigned int len;

unsigned char *name;

unsigned char *orig_data = data;

dwarf_vma adr;

len = read_uleb128 (data, & bytes_read, end);

data += bytes_read;

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

{

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

return bytes_read;

}

len += bytes_read;

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 - bytes_read - 1 > 8)

{

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

len - bytes_read - 1);

adr = 0;

}

else

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

printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr));

state_machine_regs.address = adr;

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);

name = data;

data += strnlen ((char *) data, end - data) + 1;

printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));

data += bytes_read;

printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));

data += bytes_read;

printf ("%s\t", dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));

data += bytes_read;

printf ("%s\n\n", name);

if (((unsigned int) (data - orig_data) != len) || data == end)

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

break;

case DW_LNE_set_discriminator:

printf (_("set Discriminator to %s\n"),

dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end)));

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 - bytes_read - 1;

printf ("DW_LNE_HP_source_file_correlation\n");

while (data < edata)

{

unsigned int opc;

opc = read_uleb128 (data, & bytes_read, edata);

data += bytes_read;

switch (opc)

{

case DW_LNE_HP_SFC_formfeed:

printf (" DW_LNE_HP_SFC_formfeed\n");

break;

case DW_LNE_HP_SFC_set_listing_line:

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

dwarf_vmatoa ("u",

read_uleb128 (data, & bytes_read, edata)));

data += bytes_read;

break;

case DW_LNE_HP_SFC_associate:

printf (" DW_LNE_HP_SFC_associate ");

printf ("(%s",

dwarf_vmatoa ("u",

read_uleb128 (data, & bytes_read, edata)));

data += bytes_read;

printf (",%s",

dwarf_vmatoa ("u",

read_uleb128 (data, & bytes_read, edata)));

data += bytes_read;

printf (",%s)\n",

dwarf_vmatoa ("u",

read_uleb128 (data, & bytes_read, edata)));

data += bytes_read;

break;

default:

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

data = edata;

break;

}

}

}

break;

default:

{

unsigned int rlen = len - bytes_read - 1;

if (op_code >= DW_LNE_lo_user

/* The test against DW_LNW_hi_user is redundant due to

/*&& 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;

}

static const unsigned char *

fetch_indirect_string (dwarf_vma offset)

{

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

if (section->start == NULL)

return (const unsigned char *) _("<no .debug_str section>");

if (offset > section->size)

{

warn (_("DW_FORM_strp offset too big: %s\n"),

dwarf_vmatoa ("x", offset));

return (const unsigned char *) _("<offset is too big>");

}

return (const unsigned char *) section->start + offset;

}

static const char *

fetch_indexed_string (dwarf_vma idx, struct cu_tu_set *this_set,

dwarf_vma offset_size, int dwo)

{

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;

dwarf_vma index_offset = idx * offset_size;

dwarf_vma str_offset;

if (index_section->start == NULL)

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

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

if (this_set != NULL)

index_offset += this_set->section_offsets [DW_SECT_STR_OFFSETS];

if (index_offset > index_section->size)

{

warn (_("DW_FORM_GNU_str_index offset too big: %s\n"),

dwarf_vmatoa ("x", index_offset));

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

}

if (str_section->start == NULL)

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

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

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

str_offset -= str_section->address;

if (str_offset > str_section->size)

{

warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"),

dwarf_vmatoa ("x", str_offset));

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

}

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

}

static const char *

fetch_indexed_value (dwarf_vma offset, dwarf_vma bytes)

{

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

if (section->start == NULL)

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

if (offset + bytes > section->size)

{

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

section->name, dwarf_vmatoa ("x", offset));

return "<offset too big>";

}

return dwarf_vmatoa ("x", byte_get (section->start + offset, bytes));

}

typedef struct abbrev_attr

}

abbrev_attr;

typedef struct abbrev_entry

}

abbrev_entry;

static abbrev_entry *first_abbrev = NULL;

static abbrev_entry *last_abbrev = NULL;

static void

free_abbrevs (void)

{

abbrev_entry *abbrv;

for (abbrv = first_abbrev; abbrv;)

{

abbrev_entry *next_abbrev = abbrv->next;

abbrev_attr *attr;

for (attr = abbrv->first_attr; attr;)

{

abbrev_attr *next_attr = attr->next;

free (attr);

attr = next_attr;

}

free (abbrv);

abbrv = next_abbrev;

}

last_abbrev = first_abbrev = NULL;

}

static void

add_abbrev (unsigned long number, unsigned long tag, int children)

{

abbrev_entry *entry;

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

if (entry == NULL)

/* ugg */

return;

entry->entry = number;

entry->tag = tag;

entry->children = children;

entry->first_attr = NULL;

entry->last_attr = NULL;

entry->next = NULL;

if (first_abbrev == NULL)

first_abbrev = entry;

else

last_abbrev->next = entry;

last_abbrev = entry;

}

static void

add_abbrev_attr (unsigned long attribute, unsigned long form)

{

abbrev_attr *attr;

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

if (attr == NULL)

/* ugg */

return;

attr->attribute = attribute;

attr->form = form;

attr->next = NULL;

if (last_abbrev->first_attr == NULL)

last_abbrev->first_attr = attr;

else

last_abbrev->last_attr->next = attr;

last_abbrev->last_attr = attr;

}

static unsigned char *

process_abbrev_section (unsigned char *start, unsigned char *end)

{

if (first_abbrev != NULL)

return NULL;

while (start < end)

{

unsigned int bytes_read;

unsigned long entry;

unsigned long tag;

unsigned long attribute;

int children;

entry = read_uleb128 (start, & bytes_read, end);

start += bytes_read;

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

if (start == end)

return NULL;

if (entry == 0)

return start;

tag = read_uleb128 (start, & bytes_read, end);

start += bytes_read;

if (start == end)

return NULL;

children = *start++;

add_abbrev (entry, tag, children);

do

{

unsigned long form;

attribute = read_uleb128 (start, & bytes_read, end);

start += bytes_read;

if (start == end)

break;

form = read_uleb128 (start, & bytes_read, end);

start += bytes_read;

if (start == end)

break;

add_abbrev_attr (attribute, form);

}

while (attribute != 0);

}

/* Report the missing single zero which ends the section. */

error (_(".debug_abbrev section not zero terminated\n"));

return NULL;

}

static const char *

get_TAG_name (unsigned long tag)

{

const char *name = get_DW_TAG_name ((unsigned int)tag);

if (name == NULL)

{

static char buffer[100];

snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag);

return buffer;

}

return name;

}

static const char *

get_FORM_name (unsigned long form)

{

const char *name;

if (form == 0)

return "DW_FORM value: 0";

name = get_DW_FORM_name (form);

if (name == NULL)

{

static char buffer[100];

snprintf (buffer, sizeof (buffer), _("Unknown FORM value: %lx"), form);

return buffer;

}

return name;

}

static unsigned char *

display_block (unsigned char *data,

dwarf_vma length,

const unsigned char * const end)

{

dwarf_vma maxlen;

printf (_(" %s byte block: "), dwarf_vmatoa ("u", length));

if (data > end)

return (unsigned char *) end;

maxlen = (dwarf_vma) (end - data);

length = length > maxlen ? maxlen : length;

while (length --)

printf ("%lx ", (unsigned long) byte_get (data++, 1));

return data;

}

static int

decode_location_expression (unsigned char * data,

struct dwarf_section * section)

{

unsigned op;

unsigned int bytes_read;

dwarf_vma uvalue;

dwarf_signed_vma svalue;

unsigned char *end = data + length;

int need_frame_base = 0;

while (data < end)

{

op = *data++;

switch (op)

{

case DW_OP_addr:

SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end);

printf ("DW_OP_addr: %s", dwarf_vmatoa ("x", uvalue));

break;

case DW_OP_deref:

printf ("DW_OP_deref");

break;

case DW_OP_const1u:

SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);

printf ("DW_OP_const1u: %lu", (unsigned long) uvalue);

break;

case DW_OP_const1s:

SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 1, end);

printf ("DW_OP_const1s: %ld", (long) svalue);

break;

case DW_OP_const2u:

SAFE_BYTE_GET_AND_INC (uvalue, data, 2, end);

printf ("DW_OP_const2u: %lu", (unsigned long) uvalue);

break;

case DW_OP_const2s:

SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end);

printf ("DW_OP_const2s: %ld", (long) svalue);

break;

case DW_OP_const4u:

SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);

printf ("DW_OP_const4u: %lu", (unsigned long) uvalue);

break;

case DW_OP_const4s:

SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);

printf ("DW_OP_const4s: %ld", (long) svalue);

break;

case DW_OP_const8u:

SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);

printf ("DW_OP_const8u: %lu ", (unsigned long) uvalue);

SAFE_BYTE_GET_AND_INC (uvalue, data, 4, end);

printf ("%lu", (unsigned long) uvalue);

break;

case DW_OP_const8s:

SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);

printf ("DW_OP_const8s: %ld ", (long) svalue);

SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end);

printf ("%ld", (long) svalue);

break;

case DW_OP_constu:

printf ("DW_OP_constu: %s",

dwarf_vmatoa ("u", read_uleb128 (data, &bytes_read, end)));

data += bytes_read;

break;

case DW_OP_consts:

printf ("DW_OP_consts: %s",

dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read, end)));

data += bytes_read;

break;

case DW_OP_dup:

printf ("DW_OP_dup");

break;

case DW_OP_drop:

printf ("DW_OP_drop");

break;

case DW_OP_over:

printf ("DW_OP_over");

break;

case DW_OP_pick:

SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end);

printf ("DW_OP_pick: %ld", (unsigned long) uvalue);

break;

case DW_OP_swap:

printf ("DW_OP_swap");

break;

case DW_OP_rot:

printf ("DW_OP_rot");

break;

case DW_OP_xderef:

printf ("DW_OP_xderef");

break;

case DW_OP_abs:

printf ("DW_OP_abs");

break;

case DW_OP_and:

printf ("DW_OP_and");

break;

case DW_OP_div:

printf ("DW_OP_div");

break;

case DW_OP_minus:

printf ("DW_OP_minus");

break;

case DW_OP_mod: