#include "bfd.h"
#include "sysdep.h"
#include "libiberty.h"
#include "libbfd.h"
#include "elf-bfd.h"
#include "elf/dwarf2.h"
struct line_head
{
bfd_vma total_length;
unsigned short version;
unsigned int prologue_length;
unsigned char minimum_instruction_length;
unsigned char default_is_stmt;
int line_base;
unsigned char line_range;
unsigned char opcode_base;
unsigned char *standard_opcode_lengths;
};
struct attribute
{
enum dwarf_attribute name;
enum dwarf_form form;
union
{
char *str;
struct dwarf_block *blk;
unsigned int unsnd;
int snd;
bfd_vma addr;
}
u;
};
#define DW_STRING(attr) ((attr)->u.str)
#define DW_UNSND(attr) ((attr)->u.unsnd)
#define DW_BLOCK(attr) ((attr)->u.blk)
#define DW_SND(attr) ((attr)->u.snd)
#define DW_ADDR(attr) ((attr)->u.addr)
struct dwarf_block
{
unsigned int size;
char *data;
};
struct dwarf2_debug
{
struct comp_unit* all_comp_units;
char* info_ptr;
char* info_ptr_end;
asection* sec;
char* sec_info_ptr;
asymbol** syms;
char* dwarf_abbrev_buffer;
unsigned long dwarf_abbrev_size;
char *dwarf_line_buffer;
unsigned long dwarf_line_size;
char* dwarf_str_buffer;
unsigned long dwarf_str_size;
};
struct arange
{
struct arange *next;
bfd_vma low;
bfd_vma high;
};
struct comp_unit
{
struct comp_unit* next_unit;
bfd* abfd;
struct arange arange;
char* name;
struct abbrev_info** abbrevs;
int error;
char* comp_dir;
int stmtlist;
unsigned long line_offset;
char *first_child_die_ptr;
char *end_ptr;
struct line_info_table* line_table;
struct funcinfo* function_table;
struct dwarf2_debug *stash;
unsigned char addr_size;
unsigned char offset_size;
};
struct abbrev_info
{
unsigned int number;
enum dwarf_tag tag;
int has_children;
unsigned int num_attrs;
struct attr_abbrev *attrs;
struct abbrev_info *next;
};
struct attr_abbrev
{
enum dwarf_attribute name;
enum dwarf_form form;
};
#ifndef ABBREV_HASH_SIZE
#define ABBREV_HASH_SIZE 121
#endif
#ifndef ATTR_ALLOC_CHUNK
#define ATTR_ALLOC_CHUNK 4
#endif
static unsigned int read_1_byte PARAMS ((bfd *, char *));
static int read_1_signed_byte PARAMS ((bfd *, char *));
static unsigned int read_2_bytes PARAMS ((bfd *, char *));
static unsigned int read_4_bytes PARAMS ((bfd *, char *));
static bfd_vma read_8_bytes PARAMS ((bfd *, char *));
static char *read_n_bytes PARAMS ((bfd *, char *, unsigned int));
static char *read_string PARAMS ((bfd *, char *, unsigned int *));
static char *read_indirect_string PARAMS ((struct comp_unit *, char *, unsigned int *));
static unsigned int read_unsigned_leb128
PARAMS ((bfd *, char *, unsigned int *));
static int read_signed_leb128
PARAMS ((bfd *, char *, unsigned int *));
static bfd_vma read_address PARAMS ((struct comp_unit *, char *));
static struct abbrev_info *lookup_abbrev
PARAMS ((unsigned int, struct abbrev_info **));
static struct abbrev_info **read_abbrevs
PARAMS ((bfd *, unsigned int, struct dwarf2_debug *));
static char *read_attribute
PARAMS ((struct attribute *, struct attr_abbrev *,
struct comp_unit *, char *));
static char *read_attribute_value
PARAMS ((struct attribute *, unsigned,
struct comp_unit *, char *));
static void add_line_info
PARAMS ((struct line_info_table *, bfd_vma, char *,
unsigned int, unsigned int, int));
static char *concat_filename PARAMS ((struct line_info_table *, unsigned int));
static void arange_add PARAMS ((struct comp_unit *, bfd_vma, bfd_vma));
static struct line_info_table *decode_line_info
PARAMS ((struct comp_unit *, struct dwarf2_debug *));
static boolean lookup_address_in_line_info_table
PARAMS ((struct line_info_table *, bfd_vma, struct funcinfo *,
const char **, unsigned int *));
static boolean lookup_address_in_function_table
PARAMS ((struct funcinfo *, bfd_vma, struct funcinfo **, const char **));
static boolean scan_unit_for_functions PARAMS ((struct comp_unit *));
static bfd_vma find_rela_addend
PARAMS ((bfd *, asection *, bfd_size_type, asymbol**));
static struct comp_unit *parse_comp_unit
PARAMS ((bfd *, struct dwarf2_debug *, bfd_vma, unsigned int));
static boolean comp_unit_contains_address
PARAMS ((struct comp_unit *, bfd_vma));
static boolean comp_unit_find_nearest_line
PARAMS ((struct comp_unit *, bfd_vma, const char **, const char **,
unsigned int *, struct dwarf2_debug *));
static asection *find_debug_info PARAMS ((bfd *, asection *));
static unsigned int
read_1_byte (abfd, buf)
bfd *abfd ATTRIBUTE_UNUSED;
char *buf;
{
return bfd_get_8 (abfd, (bfd_byte *) buf);
}
static int
read_1_signed_byte (abfd, buf)
bfd *abfd ATTRIBUTE_UNUSED;
char *buf;
{
return bfd_get_signed_8 (abfd, (bfd_byte *) buf);
}
static unsigned int
read_2_bytes (abfd, buf)
bfd *abfd;
char *buf;
{
return bfd_get_16 (abfd, (bfd_byte *) buf);
}
#if 0
static int
read_2_signed_bytes (abfd, buf)
bfd *abfd;
char *buf;
{
return bfd_get_signed_16 (abfd, (bfd_byte *) buf);
}
#endif
static unsigned int
read_4_bytes (abfd, buf)
bfd *abfd;
char *buf;
{
return bfd_get_32 (abfd, (bfd_byte *) buf);
}
#if 0
static int
read_4_signed_bytes (abfd, buf)
bfd *abfd;
char *buf;
{
return bfd_get_signed_32 (abfd, (bfd_byte *) buf);
}
#endif
static bfd_vma
read_8_bytes (abfd, buf)
bfd *abfd;
char *buf;
{
return bfd_get_64 (abfd, (bfd_byte *) buf);
}
static char *
read_n_bytes (abfd, buf, size)
bfd *abfd ATTRIBUTE_UNUSED;
char *buf;
unsigned int size ATTRIBUTE_UNUSED;
{
return buf;
}
static char *
read_string (abfd, buf, bytes_read_ptr)
bfd *abfd ATTRIBUTE_UNUSED;
char *buf;
unsigned int *bytes_read_ptr;
{
if (*buf == '\0')
{
*bytes_read_ptr = 1;
return NULL;
}
*bytes_read_ptr = strlen (buf) + 1;
return buf;
}
static char *
read_indirect_string (unit, buf, bytes_read_ptr)
struct comp_unit* unit;
char *buf;
unsigned int *bytes_read_ptr;
{
bfd_vma offset;
struct dwarf2_debug *stash = unit->stash;
if (unit->offset_size == 4)
offset = read_4_bytes (unit->abfd, buf);
else
offset = read_8_bytes (unit->abfd, buf);
*bytes_read_ptr = unit->offset_size;
if (! stash->dwarf_str_buffer)
{
asection *msec;
bfd *abfd = unit->abfd;
msec = bfd_get_section_by_name (abfd, ".debug_str");
if (! msec)
{
(*_bfd_error_handler)
(_("Dwarf Error: Can't find .debug_str section."));
bfd_set_error (bfd_error_bad_value);
return NULL;
}
stash->dwarf_str_size = msec->_raw_size;
stash->dwarf_str_buffer = (char*) bfd_alloc (abfd, msec->_raw_size);
if (! stash->dwarf_abbrev_buffer)
return NULL;
if (! bfd_get_section_contents (abfd, msec, stash->dwarf_str_buffer,
(bfd_vma) 0, msec->_raw_size))
return NULL;
}
if (offset >= stash->dwarf_str_size)
{
(*_bfd_error_handler) (_("Dwarf Error: DW_FORM_strp offset (%u) greater than or equal to .debug_str size (%u)."),
offset, stash->dwarf_str_size);
bfd_set_error (bfd_error_bad_value);
return NULL;
}
buf = stash->dwarf_str_buffer + offset;
if (*buf == '\0')
return NULL;
return buf;
}
static unsigned int
read_unsigned_leb128 (abfd, buf, bytes_read_ptr)
bfd *abfd ATTRIBUTE_UNUSED;
char *buf;
unsigned int *bytes_read_ptr;
{
unsigned int result;
unsigned int num_read;
int shift;
unsigned char byte;
result = 0;
shift = 0;
num_read = 0;
do
{
byte = bfd_get_8 (abfd, (bfd_byte *) buf);
buf ++;
num_read ++;
result |= ((byte & 0x7f) << shift);
shift += 7;
}
while (byte & 0x80);
* bytes_read_ptr = num_read;
return result;
}
static int
read_signed_leb128 (abfd, buf, bytes_read_ptr)
bfd *abfd ATTRIBUTE_UNUSED;
char *buf;
unsigned int * bytes_read_ptr;
{
int result;
int shift;
int num_read;
unsigned char byte;
result = 0;
shift = 0;
num_read = 0;
do
{
byte = bfd_get_8 (abfd, (bfd_byte *) buf);
buf ++;
num_read ++;
result |= ((byte & 0x7f) << shift);
shift += 7;
}
while (byte & 0x80);
if ((shift < 32) && (byte & 0x40))
result |= -(1 << shift);
* bytes_read_ptr = num_read;
return result;
}
static bfd_vma
read_address (unit, buf)
struct comp_unit* unit;
char *buf;
{
switch (unit->addr_size)
{
case 8:
return bfd_get_64 (unit->abfd, (bfd_byte *) buf);
case 4:
return bfd_get_32 (unit->abfd, (bfd_byte *) buf);
case 2:
return bfd_get_16 (unit->abfd, (bfd_byte *) buf);
default:
abort ();
}
}
static struct abbrev_info *
lookup_abbrev (number,abbrevs)
unsigned int number;
struct abbrev_info **abbrevs;
{
unsigned int hash_number;
struct abbrev_info *abbrev;
hash_number = number % ABBREV_HASH_SIZE;
abbrev = abbrevs[hash_number];
while (abbrev)
{
if (abbrev->number == number)
return abbrev;
else
abbrev = abbrev->next;
}
return NULL;
}
static struct abbrev_info**
read_abbrevs (abfd, offset, stash)
bfd * abfd;
unsigned int offset;
struct dwarf2_debug *stash;
{
struct abbrev_info **abbrevs;
char *abbrev_ptr;
struct abbrev_info *cur_abbrev;
unsigned int abbrev_number, bytes_read, abbrev_name;
unsigned int abbrev_form, hash_number;
bfd_size_type amt;
if (! stash->dwarf_abbrev_buffer)
{
asection *msec;
msec = bfd_get_section_by_name (abfd, ".debug_abbrev");
if (! msec)
{
(*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_abbrev section."));
bfd_set_error (bfd_error_bad_value);
return 0;
}
stash->dwarf_abbrev_size = msec->_raw_size;
stash->dwarf_abbrev_buffer = (char*) bfd_alloc (abfd, msec->_raw_size);
if (! stash->dwarf_abbrev_buffer)
return 0;
if (! bfd_get_section_contents (abfd, msec, stash->dwarf_abbrev_buffer,
(bfd_vma) 0, msec->_raw_size))
return 0;
}
if (offset >= stash->dwarf_abbrev_size)
{
(*_bfd_error_handler) (_("Dwarf Error: Abbrev offset (%u) greater than or equal to .debug_abbrev size (%u)."),
offset, stash->dwarf_abbrev_size);
bfd_set_error (bfd_error_bad_value);
return 0;
}
amt = sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE;
abbrevs = (struct abbrev_info**) bfd_zalloc (abfd, amt);
abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
abbrev_ptr += bytes_read;
while (abbrev_number)
{
amt = sizeof (struct abbrev_info);
cur_abbrev = (struct abbrev_info *) bfd_zalloc (abfd, amt);
cur_abbrev->number = abbrev_number;
cur_abbrev->tag = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
abbrev_ptr += bytes_read;
cur_abbrev->has_children = read_1_byte (abfd, abbrev_ptr);
abbrev_ptr += 1;
abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
abbrev_ptr += bytes_read;
abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
abbrev_ptr += bytes_read;
while (abbrev_name)
{
if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
{
amt = cur_abbrev->num_attrs + ATTR_ALLOC_CHUNK;
amt *= sizeof (struct attr_abbrev);
cur_abbrev->attrs = ((struct attr_abbrev *)
bfd_realloc (cur_abbrev->attrs, amt));
if (! cur_abbrev->attrs)
return 0;
}
cur_abbrev->attrs[cur_abbrev->num_attrs].name = abbrev_name;
cur_abbrev->attrs[cur_abbrev->num_attrs++].form = abbrev_form;
abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
abbrev_ptr += bytes_read;
abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
abbrev_ptr += bytes_read;
}
hash_number = abbrev_number % ABBREV_HASH_SIZE;
cur_abbrev->next = abbrevs[hash_number];
abbrevs[hash_number] = cur_abbrev;
if ((unsigned int) (abbrev_ptr - stash->dwarf_abbrev_buffer)
>= stash->dwarf_abbrev_size)
break;
abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
abbrev_ptr += bytes_read;
if (lookup_abbrev (abbrev_number,abbrevs) != NULL)
break;
}
return abbrevs;
}
static char *
read_attribute_value (attr, form, unit, info_ptr)
struct attribute *attr;
unsigned form;
struct comp_unit *unit;
char *info_ptr;
{
bfd *abfd = unit->abfd;
unsigned int bytes_read;
struct dwarf_block *blk;
bfd_size_type amt;
attr->form = form;
switch (form)
{
case DW_FORM_addr:
case DW_FORM_ref_addr:
DW_ADDR (attr) = read_address (unit, info_ptr);
info_ptr += unit->addr_size;
break;
case DW_FORM_block2:
amt = sizeof (struct dwarf_block);
blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
blk->size = read_2_bytes (abfd, info_ptr);
info_ptr += 2;
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
info_ptr += blk->size;
DW_BLOCK (attr) = blk;
break;
case DW_FORM_block4:
amt = sizeof (struct dwarf_block);
blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
blk->size = read_4_bytes (abfd, info_ptr);
info_ptr += 4;
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
info_ptr += blk->size;
DW_BLOCK (attr) = blk;
break;
case DW_FORM_data2:
DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
info_ptr += 2;
break;
case DW_FORM_data4:
DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
info_ptr += 4;
break;
case DW_FORM_data8:
DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
info_ptr += 8;
break;
case DW_FORM_string:
DW_STRING (attr) = read_string (abfd, info_ptr, &bytes_read);
info_ptr += bytes_read;
break;
case DW_FORM_strp:
DW_STRING (attr) = read_indirect_string (unit, info_ptr, &bytes_read);
info_ptr += bytes_read;
break;
case DW_FORM_block:
amt = sizeof (struct dwarf_block);
blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
blk->size = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
info_ptr += bytes_read;
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
info_ptr += blk->size;
DW_BLOCK (attr) = blk;
break;
case DW_FORM_block1:
amt = sizeof (struct dwarf_block);
blk = (struct dwarf_block *) bfd_alloc (abfd, amt);
blk->size = read_1_byte (abfd, info_ptr);
info_ptr += 1;
blk->data = read_n_bytes (abfd, info_ptr, blk->size);
info_ptr += blk->size;
DW_BLOCK (attr) = blk;
break;
case DW_FORM_data1:
DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
info_ptr += 1;
break;
case DW_FORM_flag:
DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
info_ptr += 1;
break;
case DW_FORM_sdata:
DW_SND (attr) = read_signed_leb128 (abfd, info_ptr, &bytes_read);
info_ptr += bytes_read;
break;
case DW_FORM_udata:
DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
info_ptr += bytes_read;
break;
case DW_FORM_ref1:
DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
info_ptr += 1;
break;
case DW_FORM_ref2:
DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
info_ptr += 2;
break;
case DW_FORM_ref4:
DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
info_ptr += 4;
break;
case DW_FORM_ref8:
DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
info_ptr += 8;
break;
case DW_FORM_ref_udata:
DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
info_ptr += bytes_read;
break;
case DW_FORM_indirect:
form = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
info_ptr += bytes_read;
info_ptr = read_attribute_value (attr, form, unit, info_ptr);
break;
default:
(*_bfd_error_handler) (_("Dwarf Error: Invalid or unhandled FORM value: %d."),
form);
bfd_set_error (bfd_error_bad_value);
}
return info_ptr;
}
static char *
read_attribute (attr, abbrev, unit, info_ptr)
struct attribute *attr;
struct attr_abbrev *abbrev;
struct comp_unit *unit;
char *info_ptr;
{
attr->name = abbrev->name;
info_ptr = read_attribute_value (attr, abbrev->form, unit, info_ptr);
return info_ptr;
}
#define FILE_ALLOC_CHUNK 5
#define DIR_ALLOC_CHUNK 5
struct line_info
{
struct line_info* prev_line;
bfd_vma address;
char* filename;
unsigned int line;
unsigned int column;
int end_sequence;
};
struct fileinfo
{
char *name;
unsigned int dir;
unsigned int time;
unsigned int size;
};
struct line_info_table
{
bfd* abfd;
unsigned int num_files;
unsigned int num_dirs;
char* comp_dir;
char** dirs;
struct fileinfo* files;
struct line_info* last_line;
};
struct funcinfo
{
struct funcinfo *prev_func;
char* name;
bfd_vma low;
bfd_vma high;
};
static void
add_line_info (table, address, filename, line, column, end_sequence)
struct line_info_table* table;
bfd_vma address;
char* filename;
unsigned int line;
unsigned int column;
int end_sequence;
{
bfd_size_type amt = sizeof (struct line_info);
struct line_info* info = (struct line_info*) bfd_alloc (table->abfd, amt);
info->prev_line = table->last_line;
table->last_line = info;
info->address = address;
info->filename = filename;
info->line = line;
info->column = column;
info->end_sequence = end_sequence;
}
static char *
concat_filename (table, file)
struct line_info_table* table;
unsigned int file;
{
char* filename;
if (file - 1 >= table->num_files)
{
(*_bfd_error_handler)
(_("Dwarf Error: mangled line number section (bad file number)."));
return "<unknown>";
}
filename = table->files[file - 1].name;
if (IS_ABSOLUTE_PATH(filename))
return filename;
else
{
char* dirname = (table->files[file - 1].dir
? table->dirs[table->files[file - 1].dir - 1]
: table->comp_dir);
return (char*) concat (dirname, "/", filename, NULL);
}
}
static void
arange_add (unit, low_pc, high_pc)
struct comp_unit *unit;
bfd_vma low_pc;
bfd_vma high_pc;
{
struct arange *arange;
arange = &unit->arange;
do
{
if (low_pc == arange->high)
{
arange->high = high_pc;
return;
}
if (high_pc == arange->low)
{
arange->low = low_pc;
return;
}
arange = arange->next;
}
while (arange);
if (unit->arange.high == 0)
{
unit->arange.next = 0;
unit->arange.low = low_pc;
unit->arange.high = high_pc;
return;
}
arange = bfd_zalloc (unit->abfd, (bfd_size_type) sizeof (*arange));
arange->low = low_pc;
arange->high = high_pc;
arange->next = unit->arange.next;
unit->arange.next = arange;
}
static struct line_info_table*
decode_line_info (unit, stash)
struct comp_unit *unit;
struct dwarf2_debug *stash;
{
bfd *abfd = unit->abfd;
struct line_info_table* table;
char *line_ptr;
char *line_end;
struct line_head lh;
unsigned int i, bytes_read, offset_size;
char *cur_file, *cur_dir;
unsigned char op_code, extended_op, adj_opcode;
bfd_size_type amt;
if (! stash->dwarf_line_buffer)
{
asection *msec;
msec = bfd_get_section_by_name (abfd, ".debug_line");
if (! msec)
{
(*_bfd_error_handler) (_("Dwarf Error: Can't find .debug_line section."));
bfd_set_error (bfd_error_bad_value);
return 0;
}
stash->dwarf_line_size = msec->_raw_size;
stash->dwarf_line_buffer = (char *) bfd_alloc (abfd, msec->_raw_size);
if (! stash->dwarf_line_buffer)
return 0;
if (! bfd_get_section_contents (abfd, msec, stash->dwarf_line_buffer,
(bfd_vma) 0, msec->_raw_size))
return 0;
}
if (unit->line_offset >= stash->dwarf_line_size)
{
(*_bfd_error_handler) (_("Dwarf Error: Line offset (%u) greater than or equal to .debug_line size (%u)."),
unit->line_offset, stash->dwarf_line_size);
bfd_set_error (bfd_error_bad_value);
return 0;
}
amt = sizeof (struct line_info_table);
table = (struct line_info_table*) bfd_alloc (abfd, amt);
table->abfd = abfd;
table->comp_dir = unit->comp_dir;
table->num_files = 0;
table->files = NULL;
table->num_dirs = 0;
table->dirs = NULL;
table->files = NULL;
table->last_line = NULL;
line_ptr = stash->dwarf_line_buffer + unit->line_offset;
lh.total_length = read_4_bytes (abfd, line_ptr);
line_ptr += 4;
offset_size = 4;
if (lh.total_length == 0xffffffff)
{
lh.total_length = read_8_bytes (abfd, line_ptr);
line_ptr += 8;
offset_size = 8;
}
line_end = line_ptr + lh.total_length;
lh.version = read_2_bytes (abfd, line_ptr);
line_ptr += 2;
if (offset_size == 4)
lh.prologue_length = read_4_bytes (abfd, line_ptr);
else
lh.prologue_length = read_8_bytes (abfd, line_ptr);
line_ptr += offset_size;
lh.minimum_instruction_length = read_1_byte (abfd, line_ptr);
line_ptr += 1;
lh.default_is_stmt = read_1_byte (abfd, line_ptr);
line_ptr += 1;
lh.line_base = read_1_signed_byte (abfd, line_ptr);
line_ptr += 1;
lh.line_range = read_1_byte (abfd, line_ptr);
line_ptr += 1;
lh.opcode_base = read_1_byte (abfd, line_ptr);
line_ptr += 1;
amt = lh.opcode_base * sizeof (unsigned char);
lh.standard_opcode_lengths = (unsigned char *) bfd_alloc (abfd, amt);
lh.standard_opcode_lengths[0] = 1;
for (i = 1; i < lh.opcode_base; ++i)
{
lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
line_ptr += 1;
}
while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
{
line_ptr += bytes_read;
if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
{
amt = table->num_dirs + DIR_ALLOC_CHUNK;
amt *= sizeof (char *);
table->dirs = (char **) bfd_realloc (table->dirs, amt);
if (! table->dirs)
return 0;
}
table->dirs[table->num_dirs++] = cur_dir;
}
line_ptr += bytes_read;
while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
{
line_ptr += bytes_read;
if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
{
amt = table->num_files + FILE_ALLOC_CHUNK;
amt *= sizeof (struct fileinfo);
table->files = (struct fileinfo *) bfd_realloc (table->files, amt);
if (! table->files)
return 0;
}
table->files[table->num_files].name = cur_file;
table->files[table->num_files].dir =
read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
line_ptr += bytes_read;
table->files[table->num_files].time =
read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
line_ptr += bytes_read;
table->files[table->num_files].size =
read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
line_ptr += bytes_read;
table->num_files++;
}
line_ptr += bytes_read;
while (line_ptr < line_end)
{
bfd_vma address = 0;
char* filename = concat_filename (table, 1);
unsigned int line = 1;
unsigned int column = 0;
int is_stmt = lh.default_is_stmt;
int basic_block = 0;
int end_sequence = 0, need_low_pc = 1;
bfd_vma low_pc = 0;
while (! end_sequence)
{
op_code = read_1_byte (abfd, line_ptr);
line_ptr += 1;
if (op_code >= lh.opcode_base)
{
adj_opcode = op_code - lh.opcode_base;
address += (adj_opcode / lh.line_range)
* lh.minimum_instruction_length;
line += lh.line_base + (adj_opcode % lh.line_range);
add_line_info (table, address, filename, line, column, 0);
basic_block = 1;
if (need_low_pc)
{
need_low_pc = 0;
low_pc = address;
}
}
else switch (op_code)
{
case DW_LNS_extended_op:
line_ptr += 1;
extended_op = read_1_byte (abfd, line_ptr);
line_ptr += 1;
switch (extended_op)
{
case DW_LNE_end_sequence:
end_sequence = 1;
add_line_info (table, address, filename, line, column,
end_sequence);
if (need_low_pc)
{
need_low_pc = 0;
low_pc = address;
}
arange_add (unit, low_pc, address);
break;
case DW_LNE_set_address:
address = read_address (unit, line_ptr);
line_ptr += unit->addr_size;
break;
case DW_LNE_define_file:
cur_file = read_string (abfd, line_ptr, &bytes_read);
line_ptr += bytes_read;
if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
{
amt = table->num_files + FILE_ALLOC_CHUNK;
amt *= sizeof (struct fileinfo);
table->files =
(struct fileinfo *) bfd_realloc (table->files, amt);
if (! table->files)
return 0;
}
table->files[table->num_files].name = cur_file;
table->files[table->num_files].dir =
read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
line_ptr += bytes_read;
table->files[table->num_files].time =
read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
line_ptr += bytes_read;
table->files[table->num_files].size =
read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
line_ptr += bytes_read;
table->num_files++;
break;
default:
(*_bfd_error_handler) (_("Dwarf Error: mangled line number section."));
bfd_set_error (bfd_error_bad_value);
return 0;
}
break;
case DW_LNS_copy:
add_line_info (table, address, filename, line, column, 0);
basic_block = 0;
if (need_low_pc)
{
need_low_pc = 0;
low_pc = address;
}
break;
case DW_LNS_advance_pc:
address += lh.minimum_instruction_length
* read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
line_ptr += bytes_read;
break;
case DW_LNS_advance_line:
line += read_signed_leb128 (abfd, line_ptr, &bytes_read);
line_ptr += bytes_read;
break;
case DW_LNS_set_file:
{
unsigned int file;
file = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
line_ptr += bytes_read;
filename = concat_filename (table, file);
break;
}
case DW_LNS_set_column:
column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
line_ptr += bytes_read;
break;
case DW_LNS_negate_stmt:
is_stmt = (!is_stmt);
break;
case DW_LNS_set_basic_block:
basic_block = 1;
break;
case DW_LNS_const_add_pc:
address += lh.minimum_instruction_length
* ((255 - lh.opcode_base) / lh.line_range);
break;
case DW_LNS_fixed_advance_pc:
address += read_2_bytes (abfd, line_ptr);
line_ptr += 2;
break;
default:
{
int i;
for (i = 0; i < lh.standard_opcode_lengths[op_code]; i++)
{
(void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
line_ptr += bytes_read;
}
}
}
}
}
return table;
}
static boolean
lookup_address_in_line_info_table (table,
addr,
function,
filename_ptr,
linenumber_ptr)
struct line_info_table* table;
bfd_vma addr;
struct funcinfo *function;
const char **filename_ptr;
unsigned int *linenumber_ptr;
{
struct line_info* next_line = table->last_line;
struct line_info* each_line;
if (!next_line)
return false;
each_line = next_line->prev_line;
while (each_line && next_line)
{
if (!each_line->end_sequence
&& addr >= each_line->address && addr < next_line->address)
{
if (function != NULL
&& each_line->address < function->low
&& next_line->address > function->low)
{
*filename_ptr = next_line->filename;
*linenumber_ptr = next_line->line;
}
else
{
*filename_ptr = each_line->filename;
*linenumber_ptr = each_line->line;
}
return true;
}
next_line = each_line;
each_line = each_line->prev_line;
}
if (function != NULL)
{
*filename_ptr = next_line->filename;
*linenumber_ptr = next_line->line;
return true;
}
return false;
}
static boolean
lookup_address_in_function_table (table,
addr,
function_ptr,
functionname_ptr)
struct funcinfo* table;
bfd_vma addr;
struct funcinfo** function_ptr;
const char **functionname_ptr;
{
struct funcinfo* each_func;
for (each_func = table;
each_func;
each_func = each_func->prev_func)
{
if (addr >= each_func->low && addr < each_func->high)
{
*functionname_ptr = each_func->name;
*function_ptr = each_func;
return true;
}
}
return false;
}
static boolean
scan_unit_for_functions (unit)
struct comp_unit *unit;
{
bfd *abfd = unit->abfd;
char *info_ptr = unit->first_child_die_ptr;
int nesting_level = 1;
while (nesting_level)
{
unsigned int abbrev_number, bytes_read, i;
struct abbrev_info *abbrev;
struct attribute attr;
struct funcinfo *func;
char* name = 0;
abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
info_ptr += bytes_read;
if (! abbrev_number)
{
nesting_level--;
continue;
}
abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
if (! abbrev)
{
(*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %d."),
abbrev_number);
bfd_set_error (bfd_error_bad_value);
return false;
}
if (abbrev->tag == DW_TAG_subprogram)
{
bfd_size_type amt = sizeof (struct funcinfo);
func = (struct funcinfo *) bfd_zalloc (abfd, amt);
func->prev_func = unit->function_table;
unit->function_table = func;
}
else
func = NULL;
for (i = 0; i < abbrev->num_attrs; ++i)
{
info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
if (func)
{
switch (attr.name)
{
case DW_AT_name:
name = DW_STRING (&attr);
if (func->name == NULL)
func->name = DW_STRING (&attr);
break;
case DW_AT_MIPS_linkage_name:
func->name = DW_STRING (&attr);
break;
case DW_AT_low_pc:
func->low = DW_ADDR (&attr);
break;
case DW_AT_high_pc:
func->high = DW_ADDR (&attr);
break;
default:
break;
}
}
else
{
switch (attr.name)
{
case DW_AT_name:
name = DW_STRING (&attr);
break;
default:
break;
}
}
}
if (abbrev->has_children)
nesting_level++;
}
return true;
}
static bfd_vma
find_rela_addend (abfd, sec, offset, syms)
bfd* abfd;
asection* sec;
bfd_size_type offset;
asymbol** syms;
{
long reloc_size = bfd_get_reloc_upper_bound (abfd, sec);
arelent **relocs = NULL;
long reloc_count, relc;
if (reloc_size <= 0)
return 0;
relocs = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
if (relocs == NULL)
return 0;
reloc_count = bfd_canonicalize_reloc (abfd, sec, relocs, syms);
if (reloc_count <= 0)
{
free (relocs);
return 0;
}
for (relc = 0; relc < reloc_count; relc++)
if (relocs[relc]->address == offset
&& (*relocs[relc]->sym_ptr_ptr)->flags & BSF_SECTION_SYM
&& strcmp ((*relocs[relc]->sym_ptr_ptr)->name,
".debug_abbrev") == 0)
{
bfd_vma addend = (relocs[relc]->howto->partial_inplace
? 0 : relocs[relc]->addend);
free (relocs);
return addend;
}
free (relocs);
return 0;
}
static struct comp_unit *
parse_comp_unit (abfd, stash, unit_length, offset_size)
bfd* abfd;
struct dwarf2_debug *stash;
bfd_vma unit_length;
unsigned int offset_size;
{
struct comp_unit* unit;
unsigned short version;
unsigned int abbrev_offset = 0;
unsigned char addr_size;
struct abbrev_info** abbrevs;
unsigned int abbrev_number, bytes_read, i;
struct abbrev_info *abbrev;
struct attribute attr;
char *info_ptr = stash->info_ptr;
char *end_ptr = info_ptr + unit_length;
bfd_size_type amt;
bfd_size_type off;
version = read_2_bytes (abfd, info_ptr);
info_ptr += 2;
BFD_ASSERT (offset_size == 4 || offset_size == 8);
if (offset_size == 4)
abbrev_offset = read_4_bytes (abfd, info_ptr);
else
abbrev_offset = read_8_bytes (abfd, info_ptr);
off = info_ptr - stash->sec_info_ptr;
abbrev_offset += find_rela_addend (abfd, stash->sec, off, stash->syms);
info_ptr += offset_size;
addr_size = read_1_byte (abfd, info_ptr);
info_ptr += 1;
if (version != 2)
{
(*_bfd_error_handler) (_("Dwarf Error: found dwarf version '%hu', this reader only handles version 2 information."), version);
bfd_set_error (bfd_error_bad_value);
return 0;
}
if (addr_size > sizeof (bfd_vma))
{
(*_bfd_error_handler) (_("Dwarf Error: found address size '%u', this reader can not handle sizes greater than '%u'."),
addr_size,
sizeof (bfd_vma));
bfd_set_error (bfd_error_bad_value);
return 0;
}
if (addr_size != 2 && addr_size != 4 && addr_size != 8)
{
(*_bfd_error_handler) ("Dwarf Error: found address size '%u', this reader can only handle address sizes '2', '4' and '8'.", addr_size);
bfd_set_error (bfd_error_bad_value);
return 0;
}
abbrevs = read_abbrevs (abfd, abbrev_offset, stash);
if (! abbrevs)
return 0;
abbrev_number = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
info_ptr += bytes_read;
if (! abbrev_number)
{
(*_bfd_error_handler) (_("Dwarf Error: Bad abbrev number: %d."),
abbrev_number);
bfd_set_error (bfd_error_bad_value);
return 0;
}
abbrev = lookup_abbrev (abbrev_number, abbrevs);
if (! abbrev)
{
(*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %d."),
abbrev_number);
bfd_set_error (bfd_error_bad_value);
return 0;
}
amt = sizeof (struct comp_unit);
unit = (struct comp_unit*) bfd_zalloc (abfd, amt);
unit->abfd = abfd;
unit->addr_size = addr_size;
unit->offset_size = offset_size;
unit->abbrevs = abbrevs;
unit->end_ptr = end_ptr;
unit->stash = stash;
for (i = 0; i < abbrev->num_attrs; ++i)
{
info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
switch (attr.name)
{
case DW_AT_stmt_list:
unit->stmtlist = 1;
unit->line_offset = DW_UNSND (&attr);
break;
case DW_AT_name:
unit->name = DW_STRING (&attr);
break;
case DW_AT_low_pc:
unit->arange.low = DW_ADDR (&attr);
break;
case DW_AT_high_pc:
unit->arange.high = DW_ADDR (&attr);
break;
case DW_AT_comp_dir:
{
char* comp_dir = DW_STRING (&attr);
if (comp_dir)
{
char *cp = (char*) strchr (comp_dir, ':');
if (cp && cp != comp_dir && cp[-1] == '.' && cp[1] == '/')
comp_dir = cp + 1;
}
unit->comp_dir = comp_dir;
break;
}
default:
break;
}
}
unit->first_child_die_ptr = info_ptr;
return unit;
}
static boolean
comp_unit_contains_address (unit, addr)
struct comp_unit* unit;
bfd_vma addr;
{
struct arange *arange;
if (unit->error)
return 0;
arange = &unit->arange;
do
{
if (addr >= arange->low && addr < arange->high)
return 1;
arange = arange->next;
}
while (arange);
return 0;
}
static boolean
comp_unit_find_nearest_line (unit, addr,
filename_ptr, functionname_ptr, linenumber_ptr,
stash)
struct comp_unit* unit;
bfd_vma addr;
const char **filename_ptr;
const char **functionname_ptr;
unsigned int *linenumber_ptr;
struct dwarf2_debug *stash;
{
boolean line_p;
boolean func_p;
struct funcinfo *function;
if (unit->error)
return false;
if (! unit->line_table)
{
if (! unit->stmtlist)
{
unit->error = 1;
return false;
}
unit->line_table = decode_line_info (unit, stash);
if (! unit->line_table)
{
unit->error = 1;
return false;
}
if (unit->first_child_die_ptr < unit->end_ptr
&& ! scan_unit_for_functions (unit))
{
unit->error = 1;
return false;
}
}
function = NULL;
func_p = lookup_address_in_function_table (unit->function_table,
addr,
&function,
functionname_ptr);
line_p = lookup_address_in_line_info_table (unit->line_table,
addr,
function,
filename_ptr,
linenumber_ptr);
return line_p || func_p;
}
#define DWARF2_DEBUG_INFO ".debug_info"
#define GNU_LINKONCE_INFO ".gnu.linkonce.wi."
static asection *
find_debug_info (abfd, after_sec)
bfd * abfd;
asection * after_sec;
{
asection * msec;
if (after_sec)
msec = after_sec->next;
else
msec = abfd->sections;
while (msec)
{
if (strcmp (msec->name, DWARF2_DEBUG_INFO) == 0)
return msec;
if (strncmp (msec->name, GNU_LINKONCE_INFO, strlen (GNU_LINKONCE_INFO)) == 0)
return msec;
msec = msec->next;
}
return NULL;
}
boolean
_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
filename_ptr, functionname_ptr,
linenumber_ptr,
addr_size, pinfo)
bfd *abfd;
asection *section;
asymbol **symbols;
bfd_vma offset;
const char **filename_ptr;
const char **functionname_ptr;
unsigned int *linenumber_ptr;
unsigned int addr_size;
PTR *pinfo;
{
struct dwarf2_debug *stash = (struct dwarf2_debug *) *pinfo;
bfd_vma addr = offset + section->vma;
struct comp_unit* each;
*filename_ptr = NULL;
*functionname_ptr = NULL;
*linenumber_ptr = 0;
if (addr_size == 0)
addr_size = 4;
BFD_ASSERT (addr_size == 4 || addr_size == 8);
if (! stash)
{
bfd_size_type total_size;
asection *msec;
bfd_size_type amt = sizeof (struct dwarf2_debug);
stash = (struct dwarf2_debug*) bfd_zalloc (abfd, amt);
if (! stash)
return false;
*pinfo = (PTR) stash;
msec = find_debug_info (abfd, NULL);
if (! msec)
return false;
for (total_size = 0; msec; msec = find_debug_info (abfd, msec))
total_size += msec->_raw_size;
stash->info_ptr = (char *) bfd_alloc (abfd, total_size);
if (stash->info_ptr == NULL)
return false;
stash->info_ptr_end = stash->info_ptr;
for (msec = find_debug_info (abfd, NULL);
msec;
msec = find_debug_info (abfd, msec))
{
bfd_size_type size;
bfd_size_type start;
size = msec->_raw_size;
if (size == 0)
continue;
start = stash->info_ptr_end - stash->info_ptr;
if (! bfd_get_section_contents (abfd, msec, stash->info_ptr + start,
(bfd_vma) 0, size))
continue;
stash->info_ptr_end = stash->info_ptr + start + size;
}
BFD_ASSERT (stash->info_ptr_end == stash->info_ptr + total_size);
stash->sec = find_debug_info (abfd, NULL);
stash->sec_info_ptr = stash->info_ptr;
stash->syms = symbols;
}
if (! stash->info_ptr)
return false;
for (each = stash->all_comp_units; each; each = each->next_unit)
if (comp_unit_contains_address (each, addr))
return comp_unit_find_nearest_line (each, addr, filename_ptr,
functionname_ptr, linenumber_ptr,
stash);
while (stash->info_ptr < stash->info_ptr_end)
{
bfd_vma length;
boolean found;
unsigned int offset_size = addr_size;
if (addr_size == 4)
{
length = read_4_bytes (abfd, stash->info_ptr);
if (length == 0xffffffff)
{
offset_size = 8;
length = read_8_bytes (abfd, stash->info_ptr + 4);
stash->info_ptr += 8;
}
}
else
length = read_8_bytes (abfd, stash->info_ptr);
stash->info_ptr += addr_size;
if (length > 0)
{
each = parse_comp_unit (abfd, stash, length, offset_size);
stash->info_ptr += length;
if ((bfd_vma) (stash->info_ptr - stash->sec_info_ptr)
== stash->sec->_raw_size)
{
stash->sec = find_debug_info (abfd, stash->sec);
stash->sec_info_ptr = stash->info_ptr;
}
if (each)
{
each->next_unit = stash->all_comp_units;
stash->all_comp_units = each;
if (each->arange.high > 0)
{
if (comp_unit_contains_address (each, addr))
return comp_unit_find_nearest_line (each, addr,
filename_ptr,
functionname_ptr,
linenumber_ptr,
stash);
}
else
{
found = comp_unit_find_nearest_line (each, addr,
filename_ptr,
functionname_ptr,
linenumber_ptr,
stash);
if (found)
return true;
}
}
}
}
return false;
}