int
dwarf_get_abbrev_entry(Dwarf_Abbrev abbrev,
Dwarf_Signed index,
Dwarf_Half * returned_attr_num,
Dwarf_Signed * form,
Dwarf_Off * offset, Dwarf_Error * error)
{
Dwarf_Byte_Ptr abbrev_ptr;
Dwarf_Byte_Ptr abbrev_end;
Dwarf_Byte_Ptr mark_abbrev_ptr;
Dwarf_Half attr;
Dwarf_Half attr_form;
if (index < 0)
return (DW_DLV_NO_ENTRY);
if (abbrev == NULL) {
_dwarf_error(NULL, error, DW_DLE_DWARF_ABBREV_NULL);
return (DW_DLV_ERROR);
}
if (abbrev->ab_code == 0) {
return (DW_DLV_NO_ENTRY);
}
if (abbrev->ab_dbg == NULL) {
_dwarf_error(NULL, error, DW_DLE_DBG_NULL);
return (DW_DLV_ERROR);
}
abbrev_ptr = abbrev->ab_abbrev_ptr;
abbrev_end =
abbrev->ab_dbg->de_debug_abbrev +
abbrev->ab_dbg->de_debug_abbrev_size;
for (attr = 1, attr_form = 1;
index >= 0 && abbrev_ptr < abbrev_end && (attr != 0 ||
attr_form != 0);
index--) {
Dwarf_Unsigned utmp4;
mark_abbrev_ptr = abbrev_ptr;
DECODE_LEB128_UWORD(abbrev_ptr, utmp4)
attr = (Dwarf_Half) utmp4;
DECODE_LEB128_UWORD(abbrev_ptr, utmp4)
attr_form = (Dwarf_Half) utmp4;
}
if (abbrev_ptr >= abbrev_end) {
_dwarf_error(abbrev->ab_dbg, error, DW_DLE_ABBREV_DECODE_ERROR);
return (DW_DLV_ERROR);
}
if (index >= 0) {
return (DW_DLV_NO_ENTRY);
}
if (form != NULL)
*form = attr_form;
if (offset != NULL)
*offset = mark_abbrev_ptr - abbrev->ab_dbg->de_debug_abbrev;
*returned_attr_num = (attr);
return DW_DLV_OK;
}
/*
return DW_DLV_OK if ok. else DW_DLV_NO_ENTRY or DW_DLV_ERROR
*/
int
_dwarf_internal_printlines(Dwarf_Die die, Dwarf_Error * error)
{
/*
This pointer is used to scan the portion of the .debug_line
section for the current cu. */
Dwarf_Small *line_ptr;
Dwarf_Small *orig_line_ptr;
/*
This points to the last byte of the .debug_line portion for the
current cu. */
Dwarf_Small *line_ptr_end;
/*
This points to the end of the statement program prologue for the
current cu, and serves to check that the prologue was correctly
decoded. */
Dwarf_Small *check_line_ptr;
/*
Pointer to a DW_AT_stmt_list attribute in case it exists in the
die. */
Dwarf_Attribute stmt_list_attr;
/* Pointer to DW_AT_comp_dir attribute in die. */
Dwarf_Attribute comp_dir_attr;
/* Pointer to name of compilation directory. */
Dwarf_Small *comp_dir = NULL;
/*
Offset into .debug_line specified by a DW_AT_stmt_list
attribute. */
Dwarf_Unsigned line_offset;
/* These are the fields of the statement program header. */
Dwarf_Unsigned total_length;
Dwarf_Half version;
Dwarf_Unsigned prologue_length;
Dwarf_Small minimum_instruction_length;
Dwarf_Small default_is_stmt;
Dwarf_Sbyte line_base;
Dwarf_Small line_range;
Dwarf_Small opcode_base;
Dwarf_Small *opcode_length;
/* These are the state machine state variables. */
Dwarf_Addr address;
Dwarf_Word file;
Dwarf_Word line;
Dwarf_Word column;
Dwarf_Bool is_stmt;
Dwarf_Bool basic_block;
Dwarf_Bool end_sequence;
Dwarf_Sword i, file_entry_count, include_directories_count;
/*
This is the current opcode read from the statement program. */
Dwarf_Small opcode;
/*
Pointer to a Dwarf_Line_Context_s structure that contains the
context such as file names and include directories for the set
of lines being generated. */
Dwarf_Line_Context line_context;
/*
These variables are used to decode leb128 numbers. Leb128_num
holds the decoded number, and leb128_length is its length in
bytes. */
Dwarf_Word leb128_num;
Dwarf_Word leb128_length;
Dwarf_Sword advance_line;
/*
This is the operand of the latest fixed_advance_pc extended
opcode. */
Dwarf_Half fixed_advance_pc;
/* This is the length of an extended opcode instr. */
Dwarf_Word instr_length;
Dwarf_Small ext_opcode;
int local_length_size;
/*REFERENCED*/ /* Not used in this instance of the macro */
int local_extension_size;
/* The Dwarf_Debug this die belongs to. */
Dwarf_Debug dbg;
int resattr;
int lres;
int res;
/* ***** BEGIN CODE ***** */
if (error != NULL)
*error = NULL;
CHECK_DIE(die, DW_DLV_ERROR)
dbg = die->di_cu_context->cc_dbg;
res =
_dwarf_load_section(dbg,
dbg->de_debug_line_index,
&dbg->de_debug_line,
error);
if (res != DW_DLV_OK) {
return res;
}
resattr = dwarf_attr(die, DW_AT_stmt_list, &stmt_list_attr, error);
if (resattr != DW_DLV_OK) {
return resattr;
}
lres = dwarf_formudata(stmt_list_attr, &line_offset, error);
if (lres != DW_DLV_OK) {
return lres;
}
if (line_offset >= dbg->de_debug_line_size) {
_dwarf_error(dbg, error, DW_DLE_LINE_OFFSET_BAD);
return (DW_DLV_ERROR);
}
orig_line_ptr = dbg->de_debug_line;
line_ptr = dbg->de_debug_line + line_offset;
dwarf_dealloc(dbg, stmt_list_attr, DW_DLA_ATTR);
/*
If die has DW_AT_comp_dir attribute, get the string that names
the compilation directory. */
resattr = dwarf_attr(die, DW_AT_comp_dir, &comp_dir_attr, error);
if (resattr == DW_DLV_ERROR) {
return resattr;
}
if (resattr == DW_DLV_OK) {
int cres;
char *cdir;
cres = dwarf_formstring(comp_dir_attr, &cdir, error);
if (cres == DW_DLV_ERROR) {
return cres;
} else if (cres == DW_DLV_OK) {
comp_dir = (Dwarf_Small *) cdir;
}
}
if (resattr == DW_DLV_OK) {
dwarf_dealloc(dbg, comp_dir_attr, DW_DLA_ATTR);
}
/*
Following is a straightforward decoding of the statement
program prologue information. */
/* READ_AREA_LENGTH updates line_ptr for consumed bytes */
READ_AREA_LENGTH(dbg, total_length, Dwarf_Unsigned,
line_ptr, local_length_size, local_extension_size);
line_ptr_end = line_ptr + total_length;
if (line_ptr_end > dbg->de_debug_line + dbg->de_debug_line_size) {
_dwarf_error(dbg, error, DW_DLE_DEBUG_LINE_LENGTH_BAD);
return (DW_DLV_ERROR);
}
printf("total line info length %ld bytes, "
"line offset 0x%llx %lld\n",
(long) total_length,
(long long) line_offset, (long long) line_offset);
printf("compilation_directory %s\n",
comp_dir ? ((char *) comp_dir) : "");
READ_UNALIGNED(dbg, version, Dwarf_Half,
line_ptr, sizeof(Dwarf_Half));
line_ptr += sizeof(Dwarf_Half);
if (version != CURRENT_VERSION_STAMP) {
_dwarf_error(dbg, error, DW_DLE_VERSION_STAMP_ERROR);
return (DW_DLV_ERROR);
}
READ_UNALIGNED(dbg, prologue_length, Dwarf_Unsigned,
line_ptr, local_length_size);
line_ptr += local_length_size;
check_line_ptr = line_ptr;
minimum_instruction_length = *(Dwarf_Small *) line_ptr;
line_ptr = line_ptr + sizeof(Dwarf_Small);
default_is_stmt = *(Dwarf_Small *) line_ptr;
line_ptr = line_ptr + sizeof(Dwarf_Small);
line_base = *(Dwarf_Sbyte *) line_ptr;
line_ptr = line_ptr + sizeof(Dwarf_Sbyte);
line_range = *(Dwarf_Small *) line_ptr;
line_ptr = line_ptr + sizeof(Dwarf_Small);
opcode_base = *(Dwarf_Small *) line_ptr;
line_ptr = line_ptr + sizeof(Dwarf_Small);
printf(" min instruction length %d\n",
(int) minimum_instruction_length);
printf(" default is stmt %d\n", (int) default_is_stmt);
printf(" line base %d\n", (int) line_base);
printf(" line_range %d\n", (int) line_range);
opcode_length = (Dwarf_Small *)
alloca(sizeof(Dwarf_Small) * opcode_base);
for (i = 1; i < opcode_base; i++) {
opcode_length[i] = *(Dwarf_Small *) line_ptr;
printf(" opcode[%d] length %d\n", (int) i,
(int) opcode_length[i]);
line_ptr = line_ptr + sizeof(Dwarf_Small);
}
include_directories_count = 0;
while ((*(char *) line_ptr) != '\0') {
printf(" include dir[%d] %s\n",
(int) include_directories_count, line_ptr);
line_ptr = line_ptr + strlen((char *) line_ptr) + 1;
include_directories_count++;
}
line_ptr++;
file_entry_count = 0;
while (*(char *) line_ptr != '\0') {
Dwarf_Unsigned tlm2;
Dwarf_Unsigned di;
Dwarf_Unsigned fl;
printf(" file[%d] %s\n",
(int) file_entry_count, (char *) line_ptr);
line_ptr = line_ptr + strlen((char *) line_ptr) + 1;
di = _dwarf_decode_u_leb128(line_ptr, &leb128_length);
line_ptr = line_ptr + leb128_length;
tlm2 = _dwarf_decode_u_leb128(line_ptr, &leb128_length);
line_ptr = line_ptr + leb128_length;
fl = _dwarf_decode_u_leb128(line_ptr, &leb128_length);
line_ptr = line_ptr + leb128_length;
printf(" dir index %d\n", (int) di);
{
time_t tt = (time_t) tlm2;
printf(" last time 0x%x %s", /* ctime supplies
newline */
(unsigned) tlm2, ctime(&tt));
}
printf(" file length %ld 0x%lx\n",
(long) fl, (unsigned long) fl);
file_entry_count++;
}
line_ptr++;
if (line_ptr != check_line_ptr + prologue_length) {
_dwarf_error(dbg, error, DW_DLE_LINE_PROLOG_LENGTH_BAD);
return (DW_DLV_ERROR);
}
/* Set up context structure for this set of lines. */
line_context = (Dwarf_Line_Context)
_dwarf_get_alloc(dbg, DW_DLA_LINE_CONTEXT, 1);
if (line_context == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
printf(" statement prog offset in section: %lld 0x%llx\n",
(long long) (line_ptr - orig_line_ptr),
(long long) (line_ptr - orig_line_ptr));
/* Initialize the state machine. */
address = 0;
file = 1;
line = 1;
column = 0;
is_stmt = default_is_stmt;
basic_block = false;
end_sequence = false;
print_line_header();
/* Start of statement program. */
while (line_ptr < line_ptr_end) {
int type;
printf(" [0x%06llx] ", (long long) (line_ptr - orig_line_ptr));
opcode = *(Dwarf_Small *) line_ptr;
line_ptr++;
/* 'type' is the output */
WHAT_IS_OPCODE(type, opcode, opcode_base,
opcode_length, line_ptr);
if (type == LOP_DISCARD) {
/* do nothing, necessary ops done */
} else if (type == LOP_SPECIAL) {
/* This op code is a special op in the object, no matter
that it might fall into the standard op range in this
compile Thatis, these are special opcodes between
special_opcode_base and MAX_LINE_OP_CODE. (including
special_opcode_base and MAX_LINE_OP_CODE) */
char special[50];
unsigned origop = opcode;
opcode = opcode - opcode_base;
address = address + minimum_instruction_length *
(opcode / line_range);
line = line + line_base + opcode % line_range;
sprintf(special, "Specialop %3u", origop);
print_line_detail(special,
opcode, address, (int) file, line, column,
is_stmt, basic_block, end_sequence);
basic_block = false;
} else if (type == LOP_STANDARD) {
switch (opcode) {
case DW_LNS_copy:{
if (opcode_length[DW_LNS_copy] != 0) {
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
print_line_detail("DW_LNS_copy",
opcode, address, file, line,
column, is_stmt, basic_block,
end_sequence);
basic_block = false;
break;
}
case DW_LNS_advance_pc:{
Dwarf_Unsigned utmp2;
if (opcode_length[DW_LNS_advance_pc] != 1) {
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
DECODE_LEB128_UWORD(line_ptr, utmp2)
printf("DW_LNS_advance_pc val %lld 0x%llx\n",
(long long) (Dwarf_Word) utmp2,
(long long) (Dwarf_Word) utmp2);
leb128_num = (Dwarf_Word) utmp2;
address =
address +
minimum_instruction_length * leb128_num;
break;
}
case DW_LNS_advance_line:{
Dwarf_Signed stmp;
if (opcode_length[DW_LNS_advance_line] != 1) {
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
DECODE_LEB128_SWORD(line_ptr, stmp)
advance_line = (Dwarf_Sword) stmp;
printf("DW_LNS_advance_line val %lld 0x%llx\n",
(long long) advance_line,
(long long) advance_line);
line = line + advance_line;
break;
}
case DW_LNS_set_file:{
Dwarf_Unsigned utmp2;
if (opcode_length[DW_LNS_set_file] != 1) {
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
DECODE_LEB128_UWORD(line_ptr, utmp2)
file = (Dwarf_Word) utmp2;
printf("DW_LNS_set_file %ld\n", (long) file);
break;
}
case DW_LNS_set_column:{
Dwarf_Unsigned utmp2;
if (opcode_length[DW_LNS_set_column] != 1) {
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
DECODE_LEB128_UWORD(line_ptr, utmp2)
column = (Dwarf_Word) utmp2;
printf("DW_LNS_set_column val %lld 0x%llx\n",
(long long) column, (long long) column);
break;
}
case DW_LNS_negate_stmt:{
if (opcode_length[DW_LNS_negate_stmt] != 0) {
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
is_stmt = !is_stmt;
printf("DW_LNS_negate_stmt\n");
break;
}
case DW_LNS_set_basic_block:{
if (opcode_length[DW_LNS_set_basic_block] != 0) {
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
printf("DW_LNS_set_basic_block\n");
basic_block = true;
break;
}
case DW_LNS_const_add_pc:{
opcode = MAX_LINE_OP_CODE - opcode_base;
address = address + minimum_instruction_length *
(opcode / line_range);
printf("DW_LNS_const_add_pc new address 0x%llx\n",
(long long) address);
break;
}
case DW_LNS_fixed_advance_pc:{
if (opcode_length[DW_LNS_fixed_advance_pc] != 1) {
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
READ_UNALIGNED(dbg, fixed_advance_pc, Dwarf_Half,
line_ptr, sizeof(Dwarf_Half));
line_ptr += sizeof(Dwarf_Half);
address = address + fixed_advance_pc;
printf("DW_LNS_fixed_advance_pc val %lld 0x%llx"
" new address 0x%llx\n",
(long long) fixed_advance_pc,
(long long) fixed_advance_pc,
(long long) address);
break;
}
}
} else if (type == LOP_EXTENDED) {
Dwarf_Unsigned utmp3;
DECODE_LEB128_UWORD(line_ptr, utmp3)
instr_length = (Dwarf_Word) utmp3;
ext_opcode = *(Dwarf_Small *) line_ptr;
line_ptr++;
switch (ext_opcode) {
case DW_LNE_end_sequence:{
end_sequence = true;
print_line_detail("DW_LNE_end_sequence extended",
opcode, address, file, line,
column, is_stmt, basic_block,
end_sequence);
address = 0;
file = 1;
line = 1;
column = 0;
is_stmt = default_is_stmt;
basic_block = false;
end_sequence = false;
break;
}
case DW_LNE_set_address:{
if (instr_length - 1 == dbg->de_pointer_size) {
READ_UNALIGNED(dbg, address, Dwarf_Addr,
line_ptr, dbg->de_pointer_size);
line_ptr += dbg->de_pointer_size;
printf("DW_LNE_set_address address 0x%llx\n",
(long long) address);
} else {
_dwarf_error(dbg, error,
DW_DLE_LINE_SET_ADDR_ERROR);
return (DW_DLV_ERROR);
}
break;
}
case DW_LNE_define_file:{
Dwarf_Small *fn;
Dwarf_Signed di;
Dwarf_Signed tlm;
Dwarf_Unsigned fl;
fn = (Dwarf_Small *) line_ptr;
line_ptr = line_ptr + strlen((char *) line_ptr) + 1;
di = _dwarf_decode_u_leb128(line_ptr,
&leb128_length);
line_ptr = line_ptr + leb128_length;
tlm =
_dwarf_decode_u_leb128(line_ptr,
&leb128_length);
line_ptr = line_ptr + leb128_length;
fl = _dwarf_decode_u_leb128(line_ptr,
&leb128_length);
line_ptr = line_ptr + leb128_length;
printf("DW_LNE_define_file %s \n", fn);
printf(" dir index %d\n", (int) di);
{
time_t tt3 = (time_t) tlm;
/* ctime supplies newline */
printf(" last time 0x%x %s",
(unsigned) tlm, ctime(&tt3));
}
printf(" file length %ld 0x%lx\n",
(long) fl, (unsigned long) fl);
break;
}
default:{
_dwarf_error(dbg, error,
DW_DLE_LINE_EXT_OPCODE_BAD);
return (DW_DLV_ERROR);
}
}
}
}
return (DW_DLV_OK);
}
/* This function returns a pointer to a Dwarf_Abbrev_List_s
struct for the abbrev with the given code. It puts the
struct on the appropriate hash table. It also adds all
the abbrev between the last abbrev added and this one to
the hash table. In other words, the .debug_abbrev section
is scanned sequentially from the top for an abbrev with
the given code. All intervening abbrevs are also put
into the hash table.
This function hashes the given code, and checks the chain
at that hash table entry to see if a Dwarf_Abbrev_List_s
with the given code exists. If yes, it returns a pointer
to that struct. Otherwise, it scans the .debug_abbrev
section from the last byte scanned for that CU till either
an abbrev with the given code is found, or an abbrev code
of 0 is read. It puts Dwarf_Abbrev_List_s entries for all
abbrev's read till that point into the hash table. The
hash table contains both a head pointer and a tail pointer
for each entry.
While the lists can move and entries can be moved between
lists on reallocation, any given Dwarf_Abbrev_list entry
never moves once allocated, so the pointer is safe to return.
See also dwarf_get_abbrev() in dwarf_abbrev.c.
Returns NULL on error. */
int
_dwarf_get_abbrev_for_code(Dwarf_CU_Context cu_context, Dwarf_Unsigned code,
Dwarf_Abbrev_List *list_out,
Dwarf_Error *error)
{
Dwarf_Debug dbg = cu_context->cc_dbg;
Dwarf_Hash_Table hash_table_base = cu_context->cc_abbrev_hash_table;
Dwarf_Hash_Table_Entry entry_base = 0;
Dwarf_Hash_Table_Entry entry_cur = 0;
Dwarf_Word hash_num = 0;
Dwarf_Unsigned abbrev_code = 0;
Dwarf_Unsigned abbrev_tag = 0;
Dwarf_Unsigned attr_name = 0;
Dwarf_Unsigned attr_form = 0;
Dwarf_Abbrev_List hash_abbrev_entry = 0;
Dwarf_Abbrev_List inner_list_entry = 0;
Dwarf_Hash_Table_Entry inner_hash_entry = 0;
Dwarf_Byte_Ptr abbrev_ptr = 0;
Dwarf_Byte_Ptr end_abbrev_ptr = 0;
unsigned hashable_val = 0;
if (!hash_table_base->tb_entries) {
hash_table_base->tb_table_entry_count = HT_MULTIPLE;
hash_table_base->tb_total_abbrev_count= 0;
hash_table_base->tb_entries =
(struct Dwarf_Hash_Table_Entry_s *)_dwarf_get_alloc(dbg,
DW_DLA_HASH_TABLE_ENTRY,
hash_table_base->tb_table_entry_count);
if (!hash_table_base->tb_entries) {
return DW_DLV_NO_ENTRY;
}
} else if (hash_table_base->tb_total_abbrev_count >
( hash_table_base->tb_table_entry_count * HT_MULTIPLE) ) {
struct Dwarf_Hash_Table_s newht;
/* Effectively multiplies by >= HT_MULTIPLE */
newht.tb_table_entry_count = hash_table_base->tb_total_abbrev_count;
newht.tb_total_abbrev_count = 0;
newht.tb_entries =
(struct Dwarf_Hash_Table_Entry_s *)_dwarf_get_alloc(dbg,
DW_DLA_HASH_TABLE_ENTRY,
newht.tb_table_entry_count);
if (!newht.tb_entries) {
return DW_DLV_NO_ENTRY;
}
/* Copy the existing entries to the new table,
rehashing each. */
copy_abbrev_table_to_new_table(hash_table_base, &newht);
/* Dealloc only the entries hash table array, not the lists
of things pointed to by a hash table entry array. */
dwarf_dealloc(dbg, hash_table_base->tb_entries,DW_DLA_HASH_TABLE_ENTRY);
hash_table_base->tb_entries = 0;
/* Now overwrite the existing table descriptor with
the new, newly valid, contents. */
*hash_table_base = newht;
} /* Else is ok as is, add entry */
hashable_val = code;
hash_num = hashable_val %
hash_table_base->tb_table_entry_count;
entry_base = hash_table_base->tb_entries;
entry_cur = entry_base + hash_num;
/* Determine if the 'code' is the list of synonyms already. */
for (hash_abbrev_entry = entry_cur->at_head;
hash_abbrev_entry != NULL && hash_abbrev_entry->abl_code != code;
hash_abbrev_entry = hash_abbrev_entry->abl_next);
if (hash_abbrev_entry != NULL) {
/* This returns a pointer to an abbrev list entry, not
the list itself. */
*list_out = hash_abbrev_entry;
return DW_DLV_OK;
}
if (cu_context->cc_last_abbrev_ptr) {
abbrev_ptr = cu_context->cc_last_abbrev_ptr;
end_abbrev_ptr = cu_context->cc_last_abbrev_endptr;
} else {
/* This is ok because cc_abbrev_offset includes DWP
offset if appropriate. */
abbrev_ptr = dbg->de_debug_abbrev.dss_data +
cu_context->cc_abbrev_offset;
if (cu_context->cc_dwp_offsets.pcu_type) {
/* In a DWP the abbrevs
for this context are known quite precisely. */
Dwarf_Unsigned size = 0;
/* Ignore the offset returned. Already in cc_abbrev_offset. */
_dwarf_get_dwp_extra_offset(&cu_context->cc_dwp_offsets,
DW_SECT_ABBREV,&size);
/* ASSERT: size != 0 */
end_abbrev_ptr = abbrev_ptr + size;
} else {
end_abbrev_ptr = abbrev_ptr +
dbg->de_debug_abbrev.dss_size;
}
}
/* End of abbrev's as we are past the end entirely.
This can happen. */
if (abbrev_ptr > end_abbrev_ptr) {
return DW_DLV_NO_ENTRY;
}
/* End of abbrev's for this cu, since abbrev code is 0. */
if (*abbrev_ptr == 0) {
return DW_DLV_NO_ENTRY;
}
do {
unsigned new_hashable_val = 0;
Dwarf_Off abb_goff = 0;
Dwarf_Unsigned atcount = 0;
abb_goff = abbrev_ptr - dbg->de_debug_abbrev.dss_data;
DECODE_LEB128_UWORD(abbrev_ptr, abbrev_code);
DECODE_LEB128_UWORD(abbrev_ptr, abbrev_tag);
inner_list_entry = (Dwarf_Abbrev_List)
_dwarf_get_alloc(cu_context->cc_dbg, DW_DLA_ABBREV_LIST, 1);
if (inner_list_entry == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return DW_DLV_ERROR;
}
new_hashable_val = abbrev_code;
hash_num = new_hashable_val %
hash_table_base->tb_table_entry_count;
inner_hash_entry = entry_base + hash_num;
/* Move_entry_to_new_hash */
inner_list_entry->abl_next = inner_hash_entry->at_head;
inner_hash_entry->at_head = inner_list_entry;
hash_table_base->tb_total_abbrev_count++;
inner_list_entry->abl_code = abbrev_code;
inner_list_entry->abl_tag = abbrev_tag;
inner_list_entry->abl_has_child = *(abbrev_ptr++);
inner_list_entry->abl_abbrev_ptr = abbrev_ptr;
inner_list_entry->abl_goffset = abb_goff;
hash_table_base->tb_total_abbrev_count++;
/* Cycle thru the abbrev content, ignoring the content except
to find the end of the content. */
do {
DECODE_LEB128_UWORD(abbrev_ptr, attr_name);
DECODE_LEB128_UWORD(abbrev_ptr, attr_form);
if (!_dwarf_valid_form_we_know(dbg,attr_form,attr_name)) {
_dwarf_error(dbg,error,DW_DLE_UNKNOWN_FORM);
return DW_DLV_ERROR;
}
atcount++;
} while (attr_name != 0 && attr_form != 0);
/* We counted one too high, by counting the NUL
byte pair at end of list. So decrement. */
inner_list_entry->abl_count = atcount-1;
/* We may have fallen off the end of content, that is not
a botch in the section, as there is no rule that the last
abbrev need have abbrev_code of 0. */
} while ((abbrev_ptr < end_abbrev_ptr) &&
*abbrev_ptr != 0 && abbrev_code != code);
cu_context->cc_last_abbrev_ptr = abbrev_ptr;
cu_context->cc_last_abbrev_endptr = end_abbrev_ptr;
if(abbrev_code == code) {
*list_out = inner_list_entry;
return DW_DLV_OK;
}
return DW_DLV_NO_ENTRY;
}
/*
This function returns a pointer to a Dwarf_Abbrev_List_s
struct for the abbrev with the given code. It puts the
struct on the appropriate hash table. It also adds all
the abbrev between the last abbrev added and this one to
the hash table. In other words, the .debug_abbrev section
is scanned sequentially from the top for an abbrev with
the given code. All intervening abbrevs are also put
into the hash table.
This function hashes the given code, and checks the chain
at that hash table entry to see if a Dwarf_Abbrev_List_s
with the given code exists. If yes, it returns a pointer
to that struct. Otherwise, it scans the .debug_abbrev
section from the last byte scanned for that CU till either
an abbrev with the given code is found, or an abbrev code
of 0 is read. It puts Dwarf_Abbrev_List_s entries for all
abbrev's read till that point into the hash table. The
hash table contains both a head pointer and a tail pointer
for each entry.
While the lists can move and entries can be moved between
lists on reallocation, any given Dwarf_Abbrev_list entry
never moves once allocated, so the pointer is safe to return.
Returns NULL on error.
*/
Dwarf_Abbrev_List
_dwarf_get_abbrev_for_code(Dwarf_CU_Context cu_context, Dwarf_Unsigned code)
{
Dwarf_Debug dbg = cu_context->cc_dbg;
Dwarf_Hash_Table hash_table_base = cu_context->cc_abbrev_hash_table;
Dwarf_Hash_Table_Entry entry_base = 0;
Dwarf_Hash_Table_Entry entry_cur = 0;
Dwarf_Word hash_num = 0;
Dwarf_Unsigned abbrev_code = 0;
Dwarf_Unsigned abbrev_tag = 0;
Dwarf_Unsigned attr_name = 0;
Dwarf_Unsigned attr_form = 0;
Dwarf_Abbrev_List hash_abbrev_entry = 0;
Dwarf_Abbrev_List inner_list_entry = 0;
Dwarf_Hash_Table_Entry inner_hash_entry = 0;
Dwarf_Byte_Ptr abbrev_ptr = 0;
unsigned hashable_val;
if ( !hash_table_base->tb_entries ) {
hash_table_base->tb_table_entry_count = HT_MULTIPLE;
hash_table_base->tb_total_abbrev_count= 0;
hash_table_base->tb_entries = _dwarf_get_alloc(dbg,
DW_DLA_HASH_TABLE_ENTRY,
hash_table_base->tb_table_entry_count);
if(! hash_table_base->tb_entries) {
return NULL;
}
} else if (hash_table_base->tb_total_abbrev_count >
( hash_table_base->tb_table_entry_count * HT_MULTIPLE) ) {
struct Dwarf_Hash_Table_s newht;
/* Effectively multiplies by >= HT_MULTIPLE */
newht.tb_table_entry_count = hash_table_base->tb_total_abbrev_count;
newht.tb_total_abbrev_count = 0;
newht.tb_entries = _dwarf_get_alloc(dbg,
DW_DLA_HASH_TABLE_ENTRY,
newht.tb_table_entry_count);
if(! newht.tb_entries) {
return NULL;
}
/* Copy the existing entries to the new table,
rehashing each.
*/
copy_abbrev_table_to_new_table(hash_table_base, &newht);
/* Dealloc only the entries hash table array, not the lists
of things pointed to by a hash table entry array. */
dwarf_dealloc(dbg, hash_table_base->tb_entries,DW_DLA_HASH_TABLE_ENTRY);
hash_table_base->tb_entries = 0;
/* Now overwrite the existing table descriptor with
the new, newly valid, contents. */
*hash_table_base = newht;
} /* Else is ok as is, add entry */
hashable_val = code;
hash_num = hashable_val %
hash_table_base->tb_table_entry_count;
entry_base = hash_table_base->tb_entries;
entry_cur = entry_base + hash_num;
/* Determine if the 'code' is the list of synonyms already. */
for (hash_abbrev_entry = entry_cur->at_head;
hash_abbrev_entry != NULL && hash_abbrev_entry->ab_code != code;
hash_abbrev_entry = hash_abbrev_entry->ab_next);
if (hash_abbrev_entry != NULL) {
/* This returns a pointer to an abbrev list entry, not
the list itself. */
return (hash_abbrev_entry);
}
abbrev_ptr = cu_context->cc_last_abbrev_ptr != NULL ?
cu_context->cc_last_abbrev_ptr :
dbg->de_debug_abbrev.dss_data + cu_context->cc_abbrev_offset;
/* End of abbrev's for this cu, since abbrev code is 0. */
if (*abbrev_ptr == 0) {
return (NULL);
}
do {
unsigned new_hashable_val;
DECODE_LEB128_UWORD(abbrev_ptr, abbrev_code);
DECODE_LEB128_UWORD(abbrev_ptr, abbrev_tag);
inner_list_entry = (Dwarf_Abbrev_List)
_dwarf_get_alloc(cu_context->cc_dbg, DW_DLA_ABBREV_LIST, 1);
if (inner_list_entry == NULL)
return (NULL);
new_hashable_val = abbrev_code;
hash_num = new_hashable_val %
hash_table_base->tb_table_entry_count;
inner_hash_entry = entry_base + hash_num;
/* Move_entry_to_new_hash */
inner_list_entry->ab_next = inner_hash_entry->at_head;
inner_hash_entry->at_head = inner_list_entry;
hash_table_base->tb_total_abbrev_count++;
inner_list_entry->ab_code = abbrev_code;
inner_list_entry->ab_tag = abbrev_tag;
inner_list_entry->ab_has_child = *(abbrev_ptr++);
inner_list_entry->ab_abbrev_ptr = abbrev_ptr;
/* Cycle thru the abbrev content, ignoring the content except
to find the end of the content. */
do {
DECODE_LEB128_UWORD(abbrev_ptr, attr_name);
DECODE_LEB128_UWORD(abbrev_ptr, attr_form);
} while (attr_name != 0 && attr_form != 0);
} while (*abbrev_ptr != 0 && abbrev_code != code);
cu_context->cc_last_abbrev_ptr = abbrev_ptr;
return (abbrev_code == code ? inner_list_entry : NULL);
}
/*
On entry:
line_ptr must point to first
byte of a line group for one (original) .o
remaining_bytes is the size of the area pointed to
by line_ptr: may be larger than the
current original compilation unit .
length size is 4 for 32bit pointers, 8 for 64bit pointers
in the data pointed to.
On return:
return DW_DLV_OK if all ok. (ignore
*err_code in this case)
return DW_DLV_ERROR and set *err_code if an error.
If some line data was moved around, set *any_change to 1.
If error or no movement, set *any_change to 0;
Set *new_line_ptr to one-byte-past the end of the
current original compilation unit (not necessary
if returning DW_DLV_ERROR, but not harmful).
This copies the entire array to a malloc area, then
mallocs pieces of it (another malloc) for sorting a CU entries
and copying back. Then at end the whole new thing copied in.
The result is that on error, the input is not touched.
An alternative would be to just update a piece at a time
and on error stop updating but leave what was done, done.
This alternative would save some temporary malloc space.
*/
static int
_dwarf_update_line_sec(Dwarf_Small * line_ptr,
unsigned long remaining_bytes,
int *any_change,
int length_size,
int *err_code, Dwarf_Small ** new_line_ptr)
{
/*
This points to the last byte of the .debug_line portion for the
current cu. */
Dwarf_Small *line_ptr_end;
/*
This points to the end of the statement program prologue for the
current cu, and serves to check that the prologue was correctly
decoded. */
Dwarf_Small *check_line_ptr;
Dwarf_Small *orig_line_ptr;
/* These are the fields of the statement program header. */
Dwarf_Unsigned total_length;
Dwarf_Half version;
Dwarf_Unsigned prologue_length;
Dwarf_Small minimum_instruction_length;
Dwarf_Small default_is_stmt;
Dwarf_Sbyte line_base;
Dwarf_Small line_range;
Dwarf_Small opcode_base;
struct Dwarf_Debug_s dbg_data;
Dwarf_Debug dbg = &dbg_data;
Dwarf_Small *opcode_length = 0;
/* These are the state machine state variables. */
Dwarf_Addr address;
Dwarf_Word line;
Dwarf_Bool is_stmt;
struct a_line_area *area_base = 0;
struct a_line_area *area_current = 0;
long area_count = 0;
Dwarf_Addr last_address = 0;
int need_to_sort = 0;
Dwarf_Sword i;
Dwarf_Sword file_entry_count;
Dwarf_Sword include_directories_count;
/*
This is the current opcode read from the statement program. */
Dwarf_Small opcode;
/*
These variables are used to decode leb128 numbers. Leb128_num
holds the decoded number, and leb128_length is its length in
bytes. */
Dwarf_Word leb128_num;
Dwarf_Word leb128_length;
Dwarf_Sword advance_line;
/*
This is the operand of the latest fixed_advance_pc extended
opcode. */
Dwarf_Half fixed_advance_pc;
/* This is the length of an extended opcode instr. */
Dwarf_Word instr_length;
Dwarf_Small ext_opcode;
dbg->de_copy_word = memcpy;
/*
Following is a straightforward decoding of the statement
program prologue information. */
*any_change = 0;
orig_line_ptr = line_ptr;
if(remaining_bytes < MINIMUM_POSSIBLE_PROLOG_LEN) {
/* We are at the end. Remaining should be zero bytes,
padding.
This is really just 'end of CU buffer'
not an error.
The is no 'entry' left so report there is none.
We don't want to READ_UNALIGNED the total_length below
and then belatedly discover that we read off the end
already.
*/
return(DW_DLV_NO_ENTRY);
}
READ_UNALIGNED(dbg, total_length, Dwarf_Unsigned,
line_ptr, length_size);
line_ptr += length_size;
line_ptr_end = line_ptr + total_length;
if (line_ptr_end > line_ptr + remaining_bytes) {
*err_code = DW_DLE_DEBUG_LINE_LENGTH_BAD;
return (DW_DLV_ERROR);
}
*new_line_ptr = line_ptr_end;
READ_UNALIGNED(dbg, version, Dwarf_Half,
line_ptr, sizeof(Dwarf_Half));
line_ptr += sizeof(Dwarf_Half);
if (version != CURRENT_VERSION_STAMP) {
*err_code = DW_DLE_VERSION_STAMP_ERROR;
return (DW_DLV_ERROR);
}
READ_UNALIGNED(dbg, prologue_length, Dwarf_Unsigned,
line_ptr, length_size);
line_ptr += length_size;
check_line_ptr = line_ptr;
minimum_instruction_length = *(Dwarf_Small *) line_ptr;
line_ptr = line_ptr + sizeof(Dwarf_Small);
default_is_stmt = *(Dwarf_Small *) line_ptr;
line_ptr = line_ptr + sizeof(Dwarf_Small);
line_base = *(Dwarf_Sbyte *) line_ptr;
line_ptr = line_ptr + sizeof(Dwarf_Sbyte);
line_range = *(Dwarf_Small *) line_ptr;
line_ptr = line_ptr + sizeof(Dwarf_Small);
opcode_base = *(Dwarf_Small *) line_ptr;
line_ptr = line_ptr + sizeof(Dwarf_Small);
opcode_length = (Dwarf_Small *)
alloca(sizeof(Dwarf_Small) * opcode_base);
for (i = 1; i < opcode_base; i++) {
opcode_length[i] = *(Dwarf_Small *) line_ptr;
line_ptr = line_ptr + sizeof(Dwarf_Small);
}
include_directories_count = 0;
while ((*(char *) line_ptr) != '\0') {
line_ptr = line_ptr + strlen((char *) line_ptr) + 1;
include_directories_count++;
}
line_ptr++;
file_entry_count = 0;
while (*(char *) line_ptr != '\0') {
/* filename = (Dwarf_Small *)line_ptr; */
line_ptr = line_ptr + strlen((char *) line_ptr) + 1;
/* dir_index = */
_dwarf_decode_u_leb128(line_ptr, &leb128_length);
line_ptr = line_ptr + leb128_length;
/* time_last_mod = */
_dwarf_decode_u_leb128(line_ptr, &leb128_length);
line_ptr = line_ptr + leb128_length;
/* file_length = */
_dwarf_decode_u_leb128(line_ptr, &leb128_length);
line_ptr = line_ptr + leb128_length;
file_entry_count++;
}
line_ptr++;
if (line_ptr != check_line_ptr + prologue_length) {
*err_code = DW_DLE_LINE_PROLOG_LENGTH_BAD;
return (DW_DLV_ERROR);
}
/* Initialize the state machine. */
address = 0;
/* file = 1; */
line = 1;
/* column = 0; */
is_stmt = default_is_stmt;
/* basic_block = false; */
/* end_sequence = false; */
/* Start of statement program. */
while (line_ptr < line_ptr_end) {
int type;
Dwarf_Small *stmt_prog_entry_start = line_ptr;
opcode = *(Dwarf_Small *) line_ptr;
line_ptr++;
/* 'type' is the output */
WHAT_IS_OPCODE(type, opcode, opcode_base,
opcode_length, line_ptr);
if (type == LOP_DISCARD) {
/* do nothing, necessary ops done */
} else if (type == LOP_SPECIAL) {
opcode = opcode - opcode_base;
address = address + minimum_instruction_length *
(opcode / line_range);
line = line + line_base + opcode % line_range;
/* basic_block = false; */
} else if (type == LOP_STANDARD) {
switch (opcode) {
case DW_LNS_copy:{
if (opcode_length[DW_LNS_copy] != 0) {
*err_code = DW_DLE_LINE_NUM_OPERANDS_BAD;
return (DW_DLV_ERROR);
}
/* basic_block = false; */
break;
}
case DW_LNS_advance_pc:{
Dwarf_Unsigned utmp2;
if (opcode_length[DW_LNS_advance_pc] != 1) {
*err_code = DW_DLE_LINE_NUM_OPERANDS_BAD;
return (DW_DLV_ERROR);
}
DECODE_LEB128_UWORD(line_ptr, utmp2)
leb128_num = (Dwarf_Word) utmp2;
address =
address +
minimum_instruction_length * leb128_num;
break;
}
case DW_LNS_advance_line:{
Dwarf_Signed stmp;
if (opcode_length[DW_LNS_advance_line] != 1) {
*err_code = DW_DLE_LINE_NUM_OPERANDS_BAD;
return (DW_DLV_ERROR);
}
DECODE_LEB128_SWORD(line_ptr, stmp)
advance_line = (Dwarf_Sword) stmp;
line = line + advance_line;
break;
}
case DW_LNS_set_file:{
Dwarf_Unsigned utmp2;
if (opcode_length[DW_LNS_set_file] != 1) {
*err_code = DW_DLE_LINE_NUM_OPERANDS_BAD;
return (DW_DLV_ERROR);
}
DECODE_LEB128_UWORD(line_ptr, utmp2)
/* file = (Dwarf_Word)utmp2; */
break;
}
case DW_LNS_set_column:{
Dwarf_Unsigned utmp2;
if (opcode_length[DW_LNS_set_column] != 1) {
*err_code = DW_DLE_LINE_NUM_OPERANDS_BAD;
return (DW_DLV_ERROR);
}
DECODE_LEB128_UWORD(line_ptr, utmp2)
/* column = (Dwarf_Word)utmp2; */
break;
}
case DW_LNS_negate_stmt:{
if (opcode_length[DW_LNS_negate_stmt] != 0) {
*err_code = DW_DLE_LINE_NUM_OPERANDS_BAD;
return (DW_DLV_ERROR);
}
is_stmt = !is_stmt;
break;
}
case DW_LNS_set_basic_block:{
if (opcode_length[DW_LNS_set_basic_block] != 0) {
*err_code = DW_DLE_LINE_NUM_OPERANDS_BAD;
return (DW_DLV_ERROR);
}
/* basic_block = true; */
break;
}
case DW_LNS_const_add_pc:{
opcode = MAX_LINE_OP_CODE - opcode_base;
address = address + minimum_instruction_length *
(opcode / line_range);
break;
}
case DW_LNS_fixed_advance_pc:{
if (opcode_length[DW_LNS_fixed_advance_pc] != 1) {
*err_code = DW_DLE_LINE_NUM_OPERANDS_BAD;
return (DW_DLV_ERROR);
}
READ_UNALIGNED(dbg, fixed_advance_pc, Dwarf_Half,
line_ptr, sizeof(Dwarf_Half));
line_ptr += sizeof(Dwarf_Half);
address = address + fixed_advance_pc;
break;
}
}
} else if (type == LOP_EXTENDED) {
Dwarf_Unsigned utmp3;
DECODE_LEB128_UWORD(line_ptr, utmp3)
instr_length = (Dwarf_Word) utmp3;
ext_opcode = *(Dwarf_Small *) line_ptr;
line_ptr++;
switch (ext_opcode) {
case DW_LNE_end_sequence:{
/* end_sequence = true; */
address = 0;
/* file = 1; */
line = 1;
/* column = 0; */
is_stmt = default_is_stmt;
/* basic_block = false; */
/* end_sequence = false; */
break;
}
case DW_LNE_set_address:{
if (instr_length - 1 == length_size) {
struct a_line_area *area;
READ_UNALIGNED(dbg, address, Dwarf_Addr,
line_ptr, length_size);
/* Here we need to remember the offset into the
buffer and check to see if address went
down. */
if (address < last_address) {
need_to_sort = 1;
}
last_address = address;
area = alloca(sizeof(struct a_line_area));
area->ala_address = address;
area->ala_offset = stmt_prog_entry_start -
orig_line_ptr;
area->ala_entry_num = area_count;
area->ala_next = 0;
area->ala_length = 0;
if (area_current) {
area_current->ala_next = area;
area_current->ala_length =
area->ala_offset -
area_current->ala_offset;
}
++area_count;
area_current = area;
if (area_base == 0) {
area_base = area;
}
line_ptr += length_size;
} else {
*err_code = DW_DLE_LINE_SET_ADDR_ERROR;
return (DW_DLV_ERROR);
}
break;
}
case DW_LNE_define_file:{
break;
}
default:{
*err_code = DW_DLE_LINE_EXT_OPCODE_BAD;
return (DW_DLV_ERROR);
}
}
}
}
int
dwarf_create_fde_from_after_start(Dwarf_Debug dbg,
struct cie_fde_prefix_s *prefix,
Dwarf_Small * frame_ptr,
int use_gnu_cie_calc,
Dwarf_Cie cie_ptr_in,
Dwarf_Fde * fde_ptr_out,
Dwarf_Error * error)
{
Dwarf_Fde new_fde = 0;
Dwarf_Cie cieptr = cie_ptr_in;
Dwarf_Small *saved_frame_ptr = 0;
Dwarf_Small *initloc = frame_ptr;
Dwarf_Signed offset_into_exception_tables
/* must be min dwarf_sfixed in size */
= (Dwarf_Signed) DW_DLX_NO_EH_OFFSET;
Dwarf_Small *fde_aug_data = 0;
Dwarf_Unsigned fde_aug_data_len = 0;
Dwarf_Addr cie_base_offset = prefix->cf_cie_id;
Dwarf_Addr initial_location = 0; /* must be min de_pointer_size
bytes in size */
Dwarf_Addr address_range = 0; /* must be min de_pointer_size
bytes in size */
enum Dwarf_augmentation_type augt = cieptr->ci_augmentation_type;
if (augt == aug_gcc_eh_z) {
/* If z augmentation this is eh_frame, and initial_location and
address_range in the FDE are read according to the CIE
augmentation string instructions. */
{
Dwarf_Small *fp_updated = 0;
int res = res = read_encoded_ptr(dbg, frame_ptr,
cieptr->
ci_gnu_fde_begin_encoding,
&initial_location,
&fp_updated);
if (res != DW_DLV_OK) {
_dwarf_error(dbg, error,
DW_DLE_FRAME_AUGMENTATION_UNKNOWN);
return DW_DLV_ERROR;
}
frame_ptr = fp_updated;
res = read_encoded_ptr(dbg, frame_ptr,
cieptr->ci_gnu_fde_begin_encoding,
&address_range, &fp_updated);
if (res != DW_DLV_OK) {
_dwarf_error(dbg, error,
DW_DLE_FRAME_AUGMENTATION_UNKNOWN);
return DW_DLV_ERROR;
}
frame_ptr = fp_updated;
}
{
Dwarf_Unsigned adlen = 0;
DECODE_LEB128_UWORD(frame_ptr, adlen);
fde_aug_data_len = adlen;
fde_aug_data = frame_ptr;
frame_ptr += adlen;
}
} else {
READ_UNALIGNED(dbg, initial_location, Dwarf_Addr,
frame_ptr, dbg->de_pointer_size);
frame_ptr += dbg->de_pointer_size;
READ_UNALIGNED(dbg, address_range, Dwarf_Addr,
frame_ptr, dbg->de_pointer_size);
frame_ptr += dbg->de_pointer_size;
}
switch (augt) {
case aug_irix_mti_v1:
case aug_empty_string:
break;
case aug_irix_exception_table:{
Dwarf_Unsigned lreg = 0;
Dwarf_Word length_of_augmented_fields = 0;
DECODE_LEB128_UWORD(frame_ptr, lreg);
length_of_augmented_fields = (Dwarf_Word) lreg;
saved_frame_ptr = frame_ptr;
/* The first word is an offset into exception tables.
Defined as a 32bit offset even for CC -64. */
READ_UNALIGNED(dbg, offset_into_exception_tables,
Dwarf_Addr, frame_ptr, sizeof(Dwarf_sfixed));
SIGN_EXTEND(offset_into_exception_tables,
sizeof(Dwarf_sfixed));
frame_ptr = saved_frame_ptr + length_of_augmented_fields;
}
break;
case aug_eh:{
Dwarf_Unsigned eh_table_value = 0;
if (!use_gnu_cie_calc) {
/* This should be impossible. */
_dwarf_error(dbg, error,
DW_DLE_FRAME_AUGMENTATION_UNKNOWN);
return DW_DLV_ERROR;
}
/* gnu eh fde case. we do not need to do anything */
/*REFERENCED*/ /* Not used in this instance of the
macro */
READ_UNALIGNED(dbg, eh_table_value,
Dwarf_Unsigned, frame_ptr,
dbg->de_pointer_size);
frame_ptr += dbg->de_pointer_size;
}
break;
case aug_gcc_eh_z:{
/* The Augmentation Data Length is here, followed by the
Augmentation Data bytes themselves. */
}
break;
} /* End switch on augmentation type */
new_fde = (Dwarf_Fde) _dwarf_get_alloc(dbg, DW_DLA_FDE, 1);
if (new_fde == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
new_fde->fd_length = prefix->cf_length;
new_fde->fd_length_size = prefix->cf_local_length_size;
new_fde->fd_extension_size = prefix->cf_local_extension_size;
new_fde->fd_cie_offset = cie_base_offset;
new_fde->fd_cie_index = cieptr->ci_index;
new_fde->fd_cie = cieptr;
new_fde->fd_initial_location = initial_location;
new_fde->fd_initial_loc_pos = initloc;
new_fde->fd_address_range = address_range;
new_fde->fd_fde_start = prefix->cf_start_addr;
new_fde->fd_fde_instr_start = frame_ptr;
new_fde->fd_dbg = dbg;
new_fde->fd_offset_into_exception_tables =
offset_into_exception_tables;
new_fde->fd_section_ptr = prefix->cf_section_ptr;
new_fde->fd_section_index = prefix->cf_section_index;
new_fde->fd_section_length = prefix->cf_section_length;
new_fde->fd_gnu_eh_augmentation_bytes = fde_aug_data;
new_fde->fd_gnu_eh_augmentation_len = fde_aug_data_len;
*fde_ptr_out = new_fde;
return DW_DLV_OK;
}
/*
Given a Dwarf_Debug dbg, and a Dwarf_Die die, it returns
a Dwarf_Die for the sibling of die. In case die is NULL,
it returns (thru ptr) a Dwarf_Die for the first die in the current
cu in dbg. Returns DW_DLV_ERROR on error.
It is assumed that every sibling chain including those with
only one element is terminated with a NULL die, except a
chain with only a NULL die.
The algorithm moves from one die to the adjacent one. It
returns when the depth of children it sees equals the number
of sibling chain terminations. A single count, child_depth
is used to track the depth of children and sibling terminations
encountered. Child_depth is incremented when a die has the
Has-Child flag set unless the child happens to be a NULL die.
Child_depth is decremented when a die has Has-Child false,
and the adjacent die is NULL. Algorithm returns when
child_depth is 0.
**NOTE: Do not modify input die, since it is used at the end.
*/
int
dwarf_siblingof(Dwarf_Debug dbg,
Dwarf_Die die,
Dwarf_Die * caller_ret_die, Dwarf_Error * error)
{
Dwarf_Die ret_die;
Dwarf_Byte_Ptr die_info_ptr;
Dwarf_Byte_Ptr cu_info_start = 0;
Dwarf_Byte_Ptr die_info_end = 0;
Dwarf_Half abbrev_code;
Dwarf_Unsigned utmp;
if (dbg == NULL) {
_dwarf_error(NULL, error, DW_DLE_DBG_NULL);
return (DW_DLV_ERROR);
}
if (die == NULL) {
/* Find root die of cu */
/* die_info_end is untouched here, need not be set in this
branch. */
Dwarf_Off off2;
/* If we've not loaded debug_info, de_cu_context will be NULL,
so no need to laod */
if (dbg->de_cu_context == NULL) {
_dwarf_error(dbg, error, DW_DLE_DBG_NO_CU_CONTEXT);
return (DW_DLV_ERROR);
}
off2 = dbg->de_cu_context->cc_debug_info_offset;
die_info_ptr = dbg->de_debug_info +
off2 + _dwarf_length_of_cu_header(dbg, off2);
} else {
/* Find sibling die. */
Dwarf_Bool has_child;
Dwarf_Sword child_depth;
/* We cannot have a legal die unless debug_info was loaded, so
no need to load debug_info here. */
CHECK_DIE(die, DW_DLV_ERROR)
die_info_ptr = die->di_debug_info_ptr;
if (*die_info_ptr == 0) {
return (DW_DLV_NO_ENTRY);
}
cu_info_start = dbg->de_debug_info +
die->di_cu_context->cc_debug_info_offset;
die_info_end = cu_info_start + die->di_cu_context->cc_length +
die->di_cu_context->cc_length_size +
die->di_cu_context->cc_extension_size;
if ((*die_info_ptr) == 0) {
return (DW_DLV_NO_ENTRY);
}
child_depth = 0;
do {
die_info_ptr = _dwarf_next_die_info_ptr(die_info_ptr,
die->di_cu_context,
die_info_end,
cu_info_start, true,
&has_child);
if (die_info_ptr == NULL) {
_dwarf_error(dbg, error, DW_DLE_NEXT_DIE_PTR_NULL);
return (DW_DLV_ERROR);
}
if ((*die_info_ptr) == 0 && has_child) {
die_info_ptr++;
has_child = false;
}
if ((*die_info_ptr) == 0)
for (; child_depth > 0 && *die_info_ptr == 0;
child_depth--, die_info_ptr++);
else
child_depth = has_child ? child_depth + 1 : child_depth;
} while (child_depth != 0);
}
if (die != NULL && die_info_ptr >= die_info_end) {
return (DW_DLV_NO_ENTRY);
}
if ((*die_info_ptr) == 0) {
return (DW_DLV_NO_ENTRY);
}
ret_die = (Dwarf_Die) _dwarf_get_alloc(dbg, DW_DLA_DIE, 1);
if (ret_die == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
ret_die->di_debug_info_ptr = die_info_ptr;
ret_die->di_cu_context =
die == NULL ? dbg->de_cu_context : die->di_cu_context;
DECODE_LEB128_UWORD(die_info_ptr, utmp)
abbrev_code = (Dwarf_Half) utmp;
if (abbrev_code == 0) {
/* Zero means a null DIE */
return (DW_DLV_NO_ENTRY);
}
ret_die->di_abbrev_list =
_dwarf_get_abbrev_for_code(ret_die->di_cu_context, abbrev_code);
if (ret_die->di_abbrev_list == NULL || (die == NULL &&
ret_die->di_abbrev_list->
ab_tag !=
DW_TAG_compile_unit)) {
_dwarf_error(dbg, error, DW_DLE_FIRST_DIE_NOT_CU);
return (DW_DLV_ERROR);
}
*caller_ret_die = ret_die;
return (DW_DLV_OK);
}
int
dwarf_child(Dwarf_Die die,
Dwarf_Die * caller_ret_die, Dwarf_Error * error)
{
Dwarf_Byte_Ptr die_info_ptr = 0;
/* die_info_end points one-past-end of die area. */
Dwarf_Byte_Ptr die_info_end = 0;
Dwarf_Die ret_die = 0;
Dwarf_Bool has_die_child = 0;
Dwarf_Debug dbg;
Dwarf_Word abbrev_code = 0;
Dwarf_Unsigned utmp = 0;
Dwarf_Small *dataptr = 0;
Dwarf_Debug_InfoTypes dis = 0;
CHECK_DIE(die, DW_DLV_ERROR);
dbg = die->di_cu_context->cc_dbg;
dis = die->di_is_info? &dbg->de_info_reading:
&dbg->de_types_reading;
die_info_ptr = die->di_debug_ptr;
dataptr = die->di_is_info? dbg->de_debug_info.dss_data:
dbg->de_debug_types.dss_data;
/* We are saving a DIE pointer here, but the pointer
will not be presumed live later, when it is tested. */
dis->de_last_die = die;
dis->de_last_di_ptr = die_info_ptr;
/* NULL die has no child. */
if ((*die_info_ptr) == 0)
return (DW_DLV_NO_ENTRY);
die_info_end = dataptr +
die->di_cu_context->cc_debug_offset +
die->di_cu_context->cc_length +
die->di_cu_context->cc_length_size +
die->di_cu_context->cc_extension_size;
die_info_ptr =
_dwarf_next_die_info_ptr(die_info_ptr, die->di_cu_context,
die_info_end, NULL, false,
&has_die_child);
if (die_info_ptr == NULL) {
_dwarf_error(dbg, error, DW_DLE_NEXT_DIE_PTR_NULL);
return (DW_DLV_ERROR);
}
dis->de_last_di_ptr = die_info_ptr;
if (!has_die_child) {
/* Look for end of sibling chain. */
while ( dis->de_last_di_ptr < die_info_end) {
if (*dis->de_last_di_ptr) {
break;
}
++dis->de_last_di_ptr;
}
return (DW_DLV_NO_ENTRY);
}
ret_die = (Dwarf_Die) _dwarf_get_alloc(dbg, DW_DLA_DIE, 1);
if (ret_die == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
ret_die->di_debug_ptr = die_info_ptr;
ret_die->di_cu_context = die->di_cu_context;
ret_die->di_is_info = die->di_is_info;
DECODE_LEB128_UWORD(die_info_ptr, utmp);
abbrev_code = (Dwarf_Word) utmp;
dis->de_last_di_ptr = die_info_ptr;
if (abbrev_code == 0) {
/* Look for end of sibling chain */
while ( dis->de_last_di_ptr < die_info_end) {
if (*dis->de_last_di_ptr) {
break;
}
++dis->de_last_di_ptr;
}
/* We have arrived at a null DIE, at the end of a CU or the end
of a list of siblings. */
*caller_ret_die = 0;
dwarf_dealloc(dbg, ret_die, DW_DLA_DIE);
return DW_DLV_NO_ENTRY;
}
ret_die->di_abbrev_code = abbrev_code;
ret_die->di_abbrev_list =
_dwarf_get_abbrev_for_code(die->di_cu_context, abbrev_code);
if (ret_die->di_abbrev_list == NULL) {
dwarf_dealloc(dbg, ret_die, DW_DLA_DIE);
_dwarf_error(dbg, error, DW_DLE_DIE_BAD);
return (DW_DLV_ERROR);
}
*caller_ret_die = ret_die;
return (DW_DLV_OK);
}
/*
This function returns a pointer to a Dwarf_Abbrev_List_s
struct for the abbrev with the given code. It puts the
struct on the appropriate hash table. It also adds all
the abbrev between the last abbrev added and this one to
the hash table. In other words, the .debug_abbrev section
is scanned sequentially from the top for an abbrev with
the given code. All intervening abbrevs are also put
into the hash table.
This function hashes the given code, and checks the chain
at that hash table entry to see if a Dwarf_Abbrev_List_s
with the given code exists. If yes, it returns a pointer
to that struct. Otherwise, it scans the .debug_abbrev
section from the last byte scanned for that CU till either
an abbrev with the given code is found, or an abbrev code
of 0 is read. It puts Dwarf_Abbrev_List_s entries for all
abbrev's read till that point into the hash table. The
hash table contains both a head pointer and a tail pointer
for each entry.
Returns NULL on error.
*/
Dwarf_Abbrev_List
_dwarf_get_abbrev_for_code(Dwarf_CU_Context cu_context, Dwarf_Word code)
{
Dwarf_Debug dbg = cu_context->cc_dbg;
Dwarf_Hash_Table hash_table = cu_context->cc_abbrev_hash_table;
Dwarf_Word hash_num;
Dwarf_Abbrev_List hash_abbrev_list;
Dwarf_Abbrev_List abbrev_list;
Dwarf_Byte_Ptr abbrev_ptr;
Dwarf_Half abbrev_code, abbrev_tag;
Dwarf_Half attr_name, attr_form;
hash_num = code % ABBREV_HASH_TABLE_SIZE;
for (hash_abbrev_list = hash_table[hash_num].at_head;
hash_abbrev_list != NULL && hash_abbrev_list->ab_code != code;
hash_abbrev_list = hash_abbrev_list->ab_next);
if (hash_abbrev_list != NULL)
return (hash_abbrev_list);
abbrev_ptr = cu_context->cc_last_abbrev_ptr != NULL ?
cu_context->cc_last_abbrev_ptr :
dbg->de_debug_abbrev + cu_context->cc_abbrev_offset;
/* End of abbrev's for this cu, since abbrev code is 0. */
if (*abbrev_ptr == 0) {
return (NULL);
}
do {
Dwarf_Unsigned utmp;
DECODE_LEB128_UWORD(abbrev_ptr, utmp)
abbrev_code = (Dwarf_Half) utmp;
DECODE_LEB128_UWORD(abbrev_ptr, utmp)
abbrev_tag = (Dwarf_Half) utmp;
abbrev_list = (Dwarf_Abbrev_List)
_dwarf_get_alloc(cu_context->cc_dbg, DW_DLA_ABBREV_LIST, 1);
if (abbrev_list == NULL)
return (NULL);
hash_num = abbrev_code % ABBREV_HASH_TABLE_SIZE;
if (hash_table[hash_num].at_head == NULL) {
hash_table[hash_num].at_head =
hash_table[hash_num].at_tail = abbrev_list;
} else {
hash_table[hash_num].at_tail->ab_next = abbrev_list;
hash_table[hash_num].at_tail = abbrev_list;
}
abbrev_list->ab_code = abbrev_code;
abbrev_list->ab_tag = abbrev_tag;
abbrev_list->ab_has_child = *(abbrev_ptr++);
abbrev_list->ab_abbrev_ptr = abbrev_ptr;
do {
Dwarf_Unsigned utmp3;
DECODE_LEB128_UWORD(abbrev_ptr, utmp3)
attr_name = (Dwarf_Half) utmp3;
DECODE_LEB128_UWORD(abbrev_ptr, utmp3)
attr_form = (Dwarf_Half) utmp3;
} while (attr_name != 0 && attr_form != 0);
} while (*abbrev_ptr != 0 && abbrev_code != code);
cu_context->cc_last_abbrev_ptr = abbrev_ptr;
return (abbrev_code == code ? abbrev_list : NULL);
}
/* This function does two slightly different things
depending on the input flag want_AT_sibling. If
this flag is true, it checks if the input die has
a DW_AT_sibling attribute. If it does it returns
a pointer to the start of the sibling die in the
.debug_info section. Otherwise it behaves the
same as the want_AT_sibling false case.
If the want_AT_sibling flag is false, it returns
a pointer to the immediately adjacent die in the
.debug_info section.
Die_info_end points to the end of the .debug_info
portion for the cu the die belongs to. It is used
to check that the search for the next die does not
cross the end of the current cu. Cu_info_start points
to the start of the .debug_info portion for the
current cu, and is used to add to the offset for
DW_AT_sibling attributes. Finally, has_die_child
is a pointer to a Dwarf_Bool that is set true if
the present die has children, false otherwise.
However, in case want_AT_child is true and the die
has a DW_AT_sibling attribute *has_die_child is set
false to indicate that the children are being skipped.
die_info_end points to the last byte+1 of the cu. */
static Dwarf_Byte_Ptr
_dwarf_next_die_info_ptr(Dwarf_Byte_Ptr die_info_ptr,
Dwarf_CU_Context cu_context,
Dwarf_Byte_Ptr die_info_end,
Dwarf_Byte_Ptr cu_info_start,
Dwarf_Bool want_AT_sibling,
Dwarf_Bool * has_die_child)
{
Dwarf_Byte_Ptr info_ptr = 0;
Dwarf_Byte_Ptr abbrev_ptr = 0;
Dwarf_Word abbrev_code = 0;
Dwarf_Abbrev_List abbrev_list;
Dwarf_Half attr = 0;
Dwarf_Half attr_form = 0;
Dwarf_Unsigned offset = 0;
Dwarf_Word leb128_length = 0;
Dwarf_Unsigned utmp = 0;
Dwarf_Debug dbg = 0;
info_ptr = die_info_ptr;
DECODE_LEB128_UWORD(info_ptr, utmp);
abbrev_code = (Dwarf_Word) utmp;
if (abbrev_code == 0) {
return NULL;
}
abbrev_list = _dwarf_get_abbrev_for_code(cu_context, abbrev_code);
if (abbrev_list == NULL) {
return (NULL);
}
dbg = cu_context->cc_dbg;
*has_die_child = abbrev_list->ab_has_child;
abbrev_ptr = abbrev_list->ab_abbrev_ptr;
do {
Dwarf_Unsigned utmp2;
DECODE_LEB128_UWORD(abbrev_ptr, utmp2);
attr = (Dwarf_Half) utmp2;
DECODE_LEB128_UWORD(abbrev_ptr, utmp2);
attr_form = (Dwarf_Half) utmp2;
if (attr_form == DW_FORM_indirect) {
Dwarf_Unsigned utmp6;
/* DECODE_LEB128_UWORD updates info_ptr */
DECODE_LEB128_UWORD(info_ptr, utmp6);
attr_form = (Dwarf_Half) utmp6;
}
if (want_AT_sibling && attr == DW_AT_sibling) {
switch (attr_form) {
case DW_FORM_ref1:
offset = *(Dwarf_Small *) info_ptr;
break;
case DW_FORM_ref2:
/* READ_UNALIGNED does not update info_ptr */
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
info_ptr, sizeof(Dwarf_Half));
break;
case DW_FORM_ref4:
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
info_ptr, sizeof(Dwarf_ufixed));
break;
case DW_FORM_ref8:
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
info_ptr, sizeof(Dwarf_Unsigned));
break;
case DW_FORM_ref_udata:
offset =
_dwarf_decode_u_leb128(info_ptr, &leb128_length);
break;
case DW_FORM_ref_addr:
/* Very unusual. The FORM is intended to refer to
a different CU, but a different CU cannot
be a sibling, can it?
We could ignore this and treat as if no DW_AT_sibling
present. Or derive the offset from it and if
it is in the same CU use it directly.
The offset here is *supposed* to be a global offset,
so adding cu_info_start is wrong to any offset
we find here unless cu_info_start
is zero! Lets pretend there is no DW_AT_sibling
attribute. */
goto no_sibling_attr;
default:
return (NULL);
}
/* Reset *has_die_child to indicate children skipped. */
*has_die_child = false;
/* A value beyond die_info_end indicates an error. Exactly
at die_info_end means 1-past-cu-end and simply means we
are at the end, do not return NULL. Higher level code
will detect that we are at the end. */
if (cu_info_start + offset > die_info_end) {
/* Error case, bad DWARF. */
return (NULL);
}
/* At or before end-of-cu */
return (cu_info_start + offset);
}
no_sibling_attr:
if (attr_form != 0) {
info_ptr += _dwarf_get_size_of_val(cu_context->cc_dbg,
attr_form,
cu_context->cc_address_size,
info_ptr,
cu_context->cc_length_size);
/* It is ok for info_ptr == die_info_end, as we will test
later before using a too-large info_ptr */
if (info_ptr > die_info_end) {
/* More than one-past-end indicates a bug somewhere,
likely bad dwarf generation. */
return (NULL);
}
}
} while (attr != 0 || attr_form != 0);
return (info_ptr);
}
/* This is the new form, October 2011. On calling with 'die' NULL,
we cannot tell if this is debug_info or debug_types, so
we must be informed!. */
int
dwarf_siblingof_b(Dwarf_Debug dbg,
Dwarf_Die die,
Dwarf_Bool is_info,
Dwarf_Die * caller_ret_die, Dwarf_Error * error)
{
Dwarf_Die ret_die = 0;
Dwarf_Byte_Ptr die_info_ptr = 0;
Dwarf_Byte_Ptr cu_info_start = 0;
/* die_info_end points 1-past end of die (once set) */
Dwarf_Byte_Ptr die_info_end = 0;
Dwarf_Word abbrev_code = 0;
Dwarf_Unsigned utmp = 0;
/* Since die may be NULL, we rely on the input argument. */
Dwarf_Debug_InfoTypes dis = is_info? &dbg->de_info_reading:
&dbg->de_types_reading;
Dwarf_Small *dataptr = is_info? dbg->de_debug_info.dss_data:
dbg->de_debug_types.dss_data;
if (dbg == NULL) {
_dwarf_error(NULL, error, DW_DLE_DBG_NULL);
return (DW_DLV_ERROR);
}
if (die == NULL) {
/* Find root die of cu */
/* die_info_end is untouched here, need not be set in this
branch. */
Dwarf_Off off2;
Dwarf_CU_Context context=0;
/* If we've not loaded debug_info, de_cu_context will be NULL,
so no need to laod */
context = dis->de_cu_context;
if (context == NULL) {
_dwarf_error(dbg, error, DW_DLE_DBG_NO_CU_CONTEXT);
return (DW_DLV_ERROR);
}
off2 = context->cc_debug_offset;
cu_info_start = dataptr + off2;
die_info_ptr = cu_info_start +
_dwarf_length_of_cu_header(dbg, off2,is_info);
die_info_end = cu_info_start + context->cc_length +
context->cc_length_size +
context->cc_extension_size;
} else {
/* Find sibling die. */
Dwarf_Bool has_child = false;
Dwarf_Sword child_depth = 0;
Dwarf_CU_Context context=0;
/* We cannot have a legal die unless debug_info was loaded, so
no need to load debug_info here. */
CHECK_DIE(die, DW_DLV_ERROR);
die_info_ptr = die->di_debug_ptr;
if (*die_info_ptr == 0) {
return (DW_DLV_NO_ENTRY);
}
context = die->di_cu_context;
cu_info_start = dataptr+ context->cc_debug_offset;
die_info_end = cu_info_start + context->cc_length +
context->cc_length_size +
context->cc_extension_size;
if ((*die_info_ptr) == 0) {
return (DW_DLV_NO_ENTRY);
}
child_depth = 0;
do {
die_info_ptr = _dwarf_next_die_info_ptr(die_info_ptr,
die->di_cu_context, die_info_end,
cu_info_start, true, &has_child);
if (die_info_ptr == NULL) {
_dwarf_error(dbg, error, DW_DLE_NEXT_DIE_PTR_NULL);
return (DW_DLV_ERROR);
}
/* die_info_end is one past end. Do not read it!
A test for ``!= die_info_end'' would work as well,
but perhaps < reads more like the meaning. */
if(die_info_ptr < die_info_end) {
if ((*die_info_ptr) == 0 && has_child) {
die_info_ptr++;
has_child = false;
}
}
/* die_info_ptr can be one-past-end. */
if ((die_info_ptr == die_info_end) ||
((*die_info_ptr) == 0)) {
for (; child_depth > 0 && *die_info_ptr == 0;
child_depth--, die_info_ptr++);
} else {
child_depth = has_child ? child_depth + 1 : child_depth;
}
} while (child_depth != 0);
}
/* die_info_ptr > die_info_end is really a bug (possibly in dwarf
generation)(but we are past end, no more DIEs here), whereas
die_info_ptr == die_info_end means 'one past end, no more DIEs
here'. */
if (die_info_ptr >= die_info_end) {
return (DW_DLV_NO_ENTRY);
}
if ((*die_info_ptr) == 0) {
return (DW_DLV_NO_ENTRY);
}
ret_die = (Dwarf_Die) _dwarf_get_alloc(dbg, DW_DLA_DIE, 1);
if (ret_die == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
ret_die->di_is_info = is_info;
ret_die->di_debug_ptr = die_info_ptr;
ret_die->di_cu_context =
die == NULL ? dis->de_cu_context : die->di_cu_context;
DECODE_LEB128_UWORD(die_info_ptr, utmp);
if (die_info_ptr > die_info_end) {
/* We managed to go past the end of the CU!.
Something is badly wrong. */
dwarf_dealloc(dbg, ret_die, DW_DLA_DIE);
_dwarf_error(dbg, error, DW_DLE_ABBREV_DECODE_ERROR);
return (DW_DLV_ERROR);
}
abbrev_code = (Dwarf_Word) utmp;
if (abbrev_code == 0) {
/* Zero means a null DIE */
dwarf_dealloc(dbg, ret_die, DW_DLA_DIE);
return (DW_DLV_NO_ENTRY);
}
ret_die->di_abbrev_code = abbrev_code;
ret_die->di_abbrev_list =
_dwarf_get_abbrev_for_code(ret_die->di_cu_context, abbrev_code);
if (ret_die->di_abbrev_list == NULL ) {
dwarf_dealloc(dbg, ret_die, DW_DLA_DIE);
_dwarf_error(dbg, error, DW_DLE_DIE_ABBREV_LIST_NULL);
return (DW_DLV_ERROR);
}
if (die == NULL && !is_cu_tag(ret_die->di_abbrev_list->ab_tag)) {
dwarf_dealloc(dbg, ret_die, DW_DLA_DIE);
_dwarf_error(dbg, error, DW_DLE_FIRST_DIE_NOT_CU);
return (DW_DLV_ERROR);
}
*caller_ret_die = ret_die;
return (DW_DLV_OK);
}
int
dwarf_offdie_b(Dwarf_Debug dbg,
Dwarf_Off offset, Dwarf_Bool is_info,
Dwarf_Die * new_die, Dwarf_Error * error)
{
Dwarf_CU_Context cu_context = 0;
Dwarf_Off new_cu_offset = 0;
Dwarf_Die die = 0;
Dwarf_Byte_Ptr info_ptr = 0;
Dwarf_Unsigned abbrev_code = 0;
Dwarf_Unsigned utmp = 0;
Dwarf_Debug_InfoTypes dis = 0;
if (dbg == NULL) {
_dwarf_error(NULL, error, DW_DLE_DBG_NULL);
return (DW_DLV_ERROR);
}
dis = is_info? &dbg->de_info_reading:
&dbg->de_types_reading;
cu_context = _dwarf_find_CU_Context(dbg, offset,is_info);
if (cu_context == NULL)
cu_context = _dwarf_find_offdie_CU_Context(dbg, offset,is_info);
if (cu_context == NULL) {
Dwarf_Unsigned section_size = is_info? dbg->de_debug_info.dss_size:
dbg->de_debug_types.dss_size;
int res = is_info?_dwarf_load_debug_info(dbg, error):
_dwarf_load_debug_types(dbg,error);
if (res != DW_DLV_OK) {
return res;
}
if (dis->de_offdie_cu_context_end != NULL) {
Dwarf_CU_Context lcu_context =
dis->de_offdie_cu_context_end;
new_cu_offset =
lcu_context->cc_debug_offset +
lcu_context->cc_length +
lcu_context->cc_length_size +
lcu_context->cc_extension_size;
}
do {
if ((new_cu_offset +
_dwarf_length_of_cu_header_simple(dbg,is_info)) >= section_size) {
_dwarf_error(dbg, error, DW_DLE_OFFSET_BAD);
return (DW_DLV_ERROR);
}
cu_context =
_dwarf_make_CU_Context(dbg, new_cu_offset,is_info, error);
if (cu_context == NULL) {
/* Error if CU Context could not be made. Since
_dwarf_make_CU_Context has already registered an
error we do not do that here: we let the lower error
pass thru. */
return (DW_DLV_ERROR);
}
if (dis->de_offdie_cu_context == NULL) {
dis->de_offdie_cu_context = cu_context;
dis->de_offdie_cu_context_end = cu_context;
} else {
dis->de_offdie_cu_context_end->cc_next = cu_context;
dis->de_offdie_cu_context_end = cu_context;
}
new_cu_offset = new_cu_offset + cu_context->cc_length +
cu_context->cc_length_size;
} while (offset >= new_cu_offset);
}
die = (Dwarf_Die) _dwarf_get_alloc(dbg, DW_DLA_DIE, 1);
if (die == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
die->di_cu_context = cu_context;
die->di_is_info = is_info;
{
Dwarf_Small *dataptr = is_info? dbg->de_debug_info.dss_data:
dbg->de_debug_types.dss_data;
info_ptr = dataptr + offset;
}
die->di_debug_ptr = info_ptr;
DECODE_LEB128_UWORD(info_ptr, utmp);
abbrev_code = utmp;
if (abbrev_code == 0) {
/* we are at a null DIE (or there is a bug). */
*new_die = 0;
dwarf_dealloc(dbg, die, DW_DLA_DIE);
return DW_DLV_NO_ENTRY;
}
die->di_abbrev_code = abbrev_code;
die->di_abbrev_list =
_dwarf_get_abbrev_for_code(cu_context, abbrev_code);
if (die->di_abbrev_list == NULL) {
dwarf_dealloc(dbg, die, DW_DLA_DIE);
_dwarf_error(dbg, error, DW_DLE_DIE_ABBREV_LIST_NULL);
return (DW_DLV_ERROR);
}
*new_die = die;
return (DW_DLV_OK);
}
/*
Given a die offset, this returns
a pointer to a DIE thru *new_die.
It is up to the caller to do a
dwarf_dealloc(dbg,*new_die,DW_DLE_DIE);
*/
int
dwarf_offdie(Dwarf_Debug dbg,
Dwarf_Off offset, Dwarf_Die * new_die, Dwarf_Error * error)
{
Dwarf_CU_Context cu_context;
Dwarf_Off new_cu_offset = 0;
Dwarf_Die die;
Dwarf_Byte_Ptr info_ptr;
Dwarf_Half abbrev_code;
Dwarf_Unsigned utmp;
if (dbg == NULL) {
_dwarf_error(NULL, error, DW_DLE_DBG_NULL);
return (DW_DLV_ERROR);
}
cu_context = _dwarf_find_CU_Context(dbg, offset);
if (cu_context == NULL)
cu_context = _dwarf_find_offdie_CU_Context(dbg, offset);
if (cu_context == NULL) {
int res = _dwarf_load_debug_info(dbg, error);
if (res != DW_DLV_OK) {
return res;
}
if (dbg->de_cu_context_list_end != NULL)
new_cu_offset =
dbg->de_cu_context_list_end->cc_debug_info_offset +
dbg->de_cu_context_list_end->cc_length +
dbg->de_cu_context_list_end->cc_length_size +
dbg->de_cu_context_list_end->cc_extension_size;
do {
if ((new_cu_offset +
_dwarf_length_of_cu_header_simple(dbg)) >=
dbg->de_debug_info_size) {
_dwarf_error(dbg, error, DW_DLE_OFFSET_BAD);
return (DW_DLV_ERROR);
}
cu_context =
_dwarf_make_CU_Context(dbg, new_cu_offset, error);
if (cu_context == NULL) {
/* Error if CU Context could not be made. Since
_dwarf_make_CU_Context has already registered an
error we do not do that here: we let the lower error
pass thru. */
return (DW_DLV_ERROR);
}
if (dbg->de_offdie_cu_context == NULL) {
dbg->de_offdie_cu_context = cu_context;
dbg->de_offdie_cu_context_end = cu_context;
} else {
dbg->de_offdie_cu_context_end->cc_next = cu_context;
dbg->de_offdie_cu_context_end = cu_context;
}
new_cu_offset = new_cu_offset + cu_context->cc_length +
cu_context->cc_length_size;
} while (offset >= new_cu_offset);
}
die = (Dwarf_Die) _dwarf_get_alloc(dbg, DW_DLA_DIE, 1);
if (die == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
die->di_cu_context = cu_context;
info_ptr = dbg->de_debug_info + offset;
die->di_debug_info_ptr = info_ptr;
DECODE_LEB128_UWORD(info_ptr, utmp)
abbrev_code = (Dwarf_Half) utmp;
if (abbrev_code == 0) {
/* we are at a null DIE (or there is a bug). */
*new_die = 0;
return DW_DLV_NO_ENTRY;
}
die->di_abbrev_list =
_dwarf_get_abbrev_for_code(cu_context, abbrev_code);
if (die->di_abbrev_list == NULL) {
_dwarf_error(dbg, error, DW_DLE_DIE_ABBREV_LIST_NULL);
return (DW_DLV_ERROR);
}
*new_die = die;
return (DW_DLV_OK);
}
int
dwarf_child(Dwarf_Die die,
Dwarf_Die * caller_ret_die, Dwarf_Error * error)
{
Dwarf_Byte_Ptr die_info_ptr;
Dwarf_Byte_Ptr die_info_end;
Dwarf_Die ret_die;
Dwarf_Bool has_die_child;
Dwarf_Debug dbg;
Dwarf_Half abbrev_code;
Dwarf_Unsigned utmp;
CHECK_DIE(die, DW_DLV_ERROR)
dbg = die->di_cu_context->cc_dbg;
die_info_ptr = die->di_debug_info_ptr;
/* NULL die has no child. */
if ((*die_info_ptr) == 0)
return (DW_DLV_NO_ENTRY);
die_info_end = dbg->de_debug_info +
die->di_cu_context->cc_debug_info_offset +
die->di_cu_context->cc_length +
die->di_cu_context->cc_length_size +
die->di_cu_context->cc_extension_size;
die_info_ptr =
_dwarf_next_die_info_ptr(die_info_ptr, die->di_cu_context,
die_info_end, NULL, false,
&has_die_child);
if (die_info_ptr == NULL) {
_dwarf_error(dbg, error, DW_DLE_NEXT_DIE_PTR_NULL);
return (DW_DLV_ERROR);
}
if (!has_die_child)
return (DW_DLV_NO_ENTRY);
ret_die = (Dwarf_Die) _dwarf_get_alloc(dbg, DW_DLA_DIE, 1);
if (ret_die == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
ret_die->di_debug_info_ptr = die_info_ptr;
ret_die->di_cu_context = die->di_cu_context;
DECODE_LEB128_UWORD(die_info_ptr, utmp)
abbrev_code = (Dwarf_Half) utmp;
if (abbrev_code == 0) {
/* We have arrived at a null DIE, at the end of a CU or the end
of a list of siblings. */
*caller_ret_die = 0;
return DW_DLV_NO_ENTRY;
}
ret_die->di_abbrev_list =
_dwarf_get_abbrev_for_code(die->di_cu_context, abbrev_code);
if (ret_die->di_abbrev_list == NULL) {
_dwarf_error(dbg, error, DW_DLE_DIE_BAD);
return (DW_DLV_ERROR);
}
*caller_ret_die = ret_die;
return (DW_DLV_OK);
}
int
dwarf_get_abbrev(Dwarf_Debug dbg,
Dwarf_Unsigned offset,
Dwarf_Abbrev * returned_abbrev,
Dwarf_Unsigned * length,
Dwarf_Unsigned * abbr_count, Dwarf_Error * error)
{
Dwarf_Small *abbrev_ptr;
Dwarf_Small *abbrev_section_end;
Dwarf_Half attr;
Dwarf_Half attr_form;
Dwarf_Abbrev ret_abbrev;
Dwarf_Unsigned labbr_count = 0;
Dwarf_Unsigned utmp;
if (dbg == NULL) {
_dwarf_error(NULL, error, DW_DLE_DBG_NULL);
return (DW_DLV_ERROR);
}
if (dbg->de_debug_abbrev == 0) {
/* Loads abbrev section (and .debug_info as we do those
together). */
int res = _dwarf_load_debug_info(dbg, error);
if (res != DW_DLV_OK) {
return res;
}
}
if (offset >= dbg->de_debug_abbrev_size) {
return (DW_DLV_NO_ENTRY);
}
ret_abbrev = (Dwarf_Abbrev) _dwarf_get_alloc(dbg, DW_DLA_ABBREV, 1);
if (ret_abbrev == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
ret_abbrev->ab_dbg = dbg;
if (returned_abbrev == 0 || abbr_count == 0) {
dwarf_dealloc(dbg, ret_abbrev, DW_DLA_ABBREV);
_dwarf_error(dbg, error, DW_DLE_DWARF_ABBREV_NULL);
return (DW_DLV_ERROR);
}
*abbr_count = 0;
if (length != NULL)
*length = 1;
abbrev_ptr = dbg->de_debug_abbrev + offset;
abbrev_section_end =
dbg->de_debug_abbrev + dbg->de_debug_abbrev_size;
DECODE_LEB128_UWORD(abbrev_ptr, utmp);
ret_abbrev->ab_code = (Dwarf_Word) utmp;
if (ret_abbrev->ab_code == 0) {
*returned_abbrev = ret_abbrev;
*abbr_count = 0;
if (length) {
*length = 1;
}
return (DW_DLV_OK);
}
DECODE_LEB128_UWORD(abbrev_ptr, utmp);
ret_abbrev->ab_tag = utmp;
ret_abbrev->ab_has_child = *(abbrev_ptr++);
ret_abbrev->ab_abbrev_ptr = abbrev_ptr;
do {
Dwarf_Unsigned utmp2;
DECODE_LEB128_UWORD(abbrev_ptr, utmp2)
attr = (Dwarf_Half) utmp2;
DECODE_LEB128_UWORD(abbrev_ptr, utmp2)
attr_form = (Dwarf_Half) utmp2;
if (attr != 0)
(labbr_count)++;
} while (abbrev_ptr < abbrev_section_end &&
(attr != 0 || attr_form != 0));
if (abbrev_ptr > abbrev_section_end) {
dwarf_dealloc(dbg, ret_abbrev, DW_DLA_ABBREV);
_dwarf_error(dbg, error, DW_DLE_ABBREV_DECODE_ERROR);
return (DW_DLV_ERROR);
}
if (length != NULL)
*length = abbrev_ptr - dbg->de_debug_abbrev - offset;
*returned_abbrev = ret_abbrev;
*abbr_count = labbr_count;
return (DW_DLV_OK);
}
/*
return DW_DLV_OK if ok. else DW_DLV_NO_ENTRY or DW_DLV_ERROR
*/
int
_dwarf_internal_srclines(Dwarf_Die die,
Dwarf_Line ** linebuf,
Dwarf_Signed * count,
Dwarf_Bool doaddrs,
Dwarf_Bool dolines, Dwarf_Error * error)
{
/*
This pointer is used to scan the portion of the .debug_line
section for the current cu. */
Dwarf_Small *line_ptr;
/*
This points to the last byte of the .debug_line portion for the
current cu. */
Dwarf_Small *line_ptr_end;
/*
This points to the end of the statement program prologue for the
current cu, and serves to check that the prologue was correctly
decoded. */
Dwarf_Small *check_line_ptr;
/*
Pointer to a DW_AT_stmt_list attribute in case it exists in the
die. */
Dwarf_Attribute stmt_list_attr;
/* Pointer to DW_AT_comp_dir attribute in die. */
Dwarf_Attribute comp_dir_attr;
/* Pointer to name of compilation directory. */
Dwarf_Small *comp_dir = NULL;
/*
Offset into .debug_line specified by a DW_AT_stmt_list
attribute. */
Dwarf_Unsigned line_offset;
/* These are the fields of the statement program header. */
Dwarf_Unsigned total_length;
Dwarf_Half version;
Dwarf_Unsigned prologue_length;
Dwarf_Small minimum_instruction_length;
Dwarf_Small default_is_stmt;
Dwarf_Sbyte line_base;
Dwarf_Small line_range;
Dwarf_Small special_opcode_base;
Dwarf_Small *opcode_length;
Dwarf_Small *include_directories;
Dwarf_File_Entry file_entries;
/* These are the state machine state variables. */
Dwarf_Addr address;
Dwarf_Word file;
Dwarf_Word line;
Dwarf_Word column;
Dwarf_Bool is_stmt;
Dwarf_Bool basic_block;
Dwarf_Bool end_sequence;
/*
These pointers are used to build the list of files names by
this cu. cur_file_entry points to the file name being added,
and prev_file_entry to the previous one. */
Dwarf_File_Entry cur_file_entry, prev_file_entry;
Dwarf_Sword i, file_entry_count, include_directories_count;
/*
This is the current opcode read from the statement program. */
Dwarf_Small opcode;
/*
Pointer to a Dwarf_Line_Context_s structure that contains the
context such as file names and include directories for the set
of lines being generated. */
Dwarf_Line_Context line_context;
/*
This is a pointer to the current line being added to the line
matrix. */
Dwarf_Line curr_line;
/*
These variables are used to decode leb128 numbers. Leb128_num
holds the decoded number, and leb128_length is its length in
bytes. */
Dwarf_Word leb128_num;
Dwarf_Word leb128_length;
Dwarf_Sword advance_line;
/*
This is the operand of the latest fixed_advance_pc extended
opcode. */
Dwarf_Half fixed_advance_pc;
/*
Counts the number of lines in the line matrix. */
Dwarf_Sword line_count = 0;
/* This is the length of an extended opcode instr. */
Dwarf_Word instr_length;
Dwarf_Small ext_opcode;
/*
Used to chain together pointers to line table entries that are
later used to create a block of Dwarf_Line entries. */
Dwarf_Chain chain_line, head_chain = NULL, curr_chain;
/*
This points to a block of Dwarf_Lines, a pointer to which is
returned in linebuf. */
Dwarf_Line *block_line;
/* The Dwarf_Debug this die belongs to. */
Dwarf_Debug dbg;
int resattr;
int lres;
int local_length_size = 0;
/*REFERENCED*/ /* Not used in this instance of the macro */
int local_extension_size = 0;
int res;
/* ***** BEGIN CODE ***** */
if (error != NULL)
*error = NULL;
CHECK_DIE(die, DW_DLV_ERROR)
dbg = die->di_cu_context->cc_dbg;
res =
_dwarf_load_section(dbg,
dbg->de_debug_line_index,
&dbg->de_debug_line,
error);
if (res != DW_DLV_OK) {
return res;
}
resattr = dwarf_attr(die, DW_AT_stmt_list, &stmt_list_attr, error);
if (resattr != DW_DLV_OK) {
return resattr;
}
lres = dwarf_formudata(stmt_list_attr, &line_offset, error);
if (lres != DW_DLV_OK) {
return lres;
}
if (line_offset >= dbg->de_debug_line_size) {
_dwarf_error(dbg, error, DW_DLE_LINE_OFFSET_BAD);
return (DW_DLV_ERROR);
}
line_ptr = dbg->de_debug_line + line_offset;
dwarf_dealloc(dbg, stmt_list_attr, DW_DLA_ATTR);
/*
If die has DW_AT_comp_dir attribute, get the string that names
the compilation directory. */
resattr = dwarf_attr(die, DW_AT_comp_dir, &comp_dir_attr, error);
if (resattr == DW_DLV_ERROR) {
return resattr;
}
if (resattr == DW_DLV_OK) {
int cres;
char *cdir;
cres = dwarf_formstring(comp_dir_attr, &cdir, error);
if (cres == DW_DLV_ERROR) {
return cres;
} else if (cres == DW_DLV_OK) {
comp_dir = (Dwarf_Small *) cdir;
}
}
if (resattr == DW_DLV_OK) {
dwarf_dealloc(dbg, comp_dir_attr, DW_DLA_ATTR);
}
/*
Following is a straightforward decoding of the statement
program prologue information. */
/* READ_AREA_LENGTH updates line_ptr for consumed bytes */
READ_AREA_LENGTH(dbg, total_length, Dwarf_Unsigned,
line_ptr, local_length_size, local_extension_size);
line_ptr_end = line_ptr + total_length;
if (line_ptr_end > dbg->de_debug_line + dbg->de_debug_line_size) {
_dwarf_error(dbg, error, DW_DLE_DEBUG_LINE_LENGTH_BAD);
return (DW_DLV_ERROR);
}
READ_UNALIGNED(dbg, version, Dwarf_Half,
line_ptr, sizeof(Dwarf_Half));
line_ptr += sizeof(Dwarf_Half);
if (version != CURRENT_VERSION_STAMP &&
version != CURRENT_VERSION_STAMP3) {
_dwarf_error(dbg, error, DW_DLE_VERSION_STAMP_ERROR);
return (DW_DLV_ERROR);
}
READ_UNALIGNED(dbg, prologue_length, Dwarf_Unsigned,
line_ptr, local_length_size);
line_ptr += local_length_size;
check_line_ptr = line_ptr;
minimum_instruction_length = *(Dwarf_Small *) line_ptr;
line_ptr = line_ptr + sizeof(Dwarf_Small);
default_is_stmt = *(Dwarf_Small *) line_ptr;
line_ptr = line_ptr + sizeof(Dwarf_Small);
line_base = *(Dwarf_Sbyte *) line_ptr;
line_ptr = line_ptr + sizeof(Dwarf_Sbyte);
line_range = *(Dwarf_Small *) line_ptr;
line_ptr = line_ptr + sizeof(Dwarf_Small);
special_opcode_base = *(Dwarf_Small *) line_ptr;
line_ptr = line_ptr + sizeof(Dwarf_Small);
opcode_length = (Dwarf_Small *)
alloca(sizeof(Dwarf_Small) * special_opcode_base);
for (i = 1; i < special_opcode_base; i++) {
opcode_length[i] = *(Dwarf_Small *) line_ptr;
line_ptr = line_ptr + sizeof(Dwarf_Small);
}
include_directories_count = 0;
include_directories = line_ptr;
while ((*(char *) line_ptr) != '\0') {
line_ptr = line_ptr + strlen((char *) line_ptr) + 1;
include_directories_count++;
}
line_ptr++;
file_entry_count = 0;
file_entries = prev_file_entry = NULL;
while (*(char *) line_ptr != '\0') {
cur_file_entry = (Dwarf_File_Entry)
_dwarf_get_alloc(dbg, DW_DLA_FILE_ENTRY, 1);
if (cur_file_entry == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
cur_file_entry->fi_file_name = (Dwarf_Small *) line_ptr;
line_ptr = line_ptr + strlen((char *) line_ptr) + 1;
cur_file_entry->fi_dir_index =
(Dwarf_Sword) _dwarf_decode_u_leb128(line_ptr,
&leb128_length);
line_ptr = line_ptr + leb128_length;
cur_file_entry->fi_time_last_mod =
_dwarf_decode_u_leb128(line_ptr, &leb128_length);
line_ptr = line_ptr + leb128_length;
cur_file_entry->fi_file_length =
_dwarf_decode_u_leb128(line_ptr, &leb128_length);
line_ptr = line_ptr + leb128_length;
if (file_entries == NULL)
file_entries = cur_file_entry;
else
prev_file_entry->fi_next = cur_file_entry;
prev_file_entry = cur_file_entry;
file_entry_count++;
}
line_ptr++;
if (line_ptr != check_line_ptr + prologue_length) {
_dwarf_error(dbg, error, DW_DLE_LINE_PROLOG_LENGTH_BAD);
return (DW_DLV_ERROR);
}
/* Set up context structure for this set of lines. */
line_context = (Dwarf_Line_Context)
_dwarf_get_alloc(dbg, DW_DLA_LINE_CONTEXT, 1);
if (line_context == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
/* Initialize the state machine. */
address = 0;
file = 1;
line = 1;
column = 0;
is_stmt = default_is_stmt;
basic_block = false;
end_sequence = false;
/* Start of statement program. */
while (line_ptr < line_ptr_end) {
int type;
opcode = *(Dwarf_Small *) line_ptr;
line_ptr++;
/* 'type' is the output */
WHAT_IS_OPCODE(type, opcode, special_opcode_base,
opcode_length, line_ptr);
if (type == LOP_DISCARD) {
/* do nothing, necessary ops done */
} else if (type == LOP_SPECIAL) {
/* This op code is a special op in the object, no matter
that it might fall into the standard op range in this
compile Thatis, these are special opcodes between
special_opcode_base and MAX_LINE_OP_CODE. (including
special_opcode_base and MAX_LINE_OP_CODE) */
opcode = opcode - special_opcode_base;
address = address + minimum_instruction_length *
(opcode / line_range);
line = line + line_base + opcode % line_range;
if (dolines) {
curr_line =
(Dwarf_Line) _dwarf_get_alloc(dbg, DW_DLA_LINE, 1);
if (curr_line == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
curr_line->li_address = address;
curr_line->li_addr_line.li_l_data.li_file =
(Dwarf_Sword) file;
curr_line->li_addr_line.li_l_data.li_line =
(Dwarf_Sword) line;
curr_line->li_addr_line.li_l_data.li_column =
(Dwarf_Half) column;
curr_line->li_addr_line.li_l_data.li_is_stmt = is_stmt;
curr_line->li_addr_line.li_l_data.li_basic_block =
basic_block;
curr_line->li_addr_line.li_l_data.li_end_sequence =
end_sequence;
curr_line->li_context = line_context;
line_count++;
chain_line = (Dwarf_Chain)
_dwarf_get_alloc(dbg, DW_DLA_CHAIN, 1);
if (chain_line == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
chain_line->ch_item = curr_line;
if (head_chain == NULL)
head_chain = curr_chain = chain_line;
else {
curr_chain->ch_next = chain_line;
curr_chain = chain_line;
}
}
basic_block = false;
} else if (type == LOP_STANDARD) {
switch (opcode) {
case DW_LNS_copy:{
if (opcode_length[DW_LNS_copy] != 0) {
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
if (dolines) {
curr_line =
(Dwarf_Line) _dwarf_get_alloc(dbg,
DW_DLA_LINE,
1);
if (curr_line == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
curr_line->li_address = address;
curr_line->li_addr_line.li_l_data.li_file =
(Dwarf_Sword) file;
curr_line->li_addr_line.li_l_data.li_line =
(Dwarf_Sword) line;
curr_line->li_addr_line.li_l_data.li_column =
(Dwarf_Half) column;
curr_line->li_addr_line.li_l_data.li_is_stmt =
is_stmt;
curr_line->li_addr_line.li_l_data.
li_basic_block = basic_block;
curr_line->li_addr_line.li_l_data.
li_end_sequence = end_sequence;
curr_line->li_context = line_context;
line_count++;
chain_line = (Dwarf_Chain)
_dwarf_get_alloc(dbg, DW_DLA_CHAIN, 1);
if (chain_line == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
chain_line->ch_item = curr_line;
if (head_chain == NULL)
head_chain = curr_chain = chain_line;
else {
curr_chain->ch_next = chain_line;
curr_chain = chain_line;
}
}
basic_block = false;
break;
}
case DW_LNS_advance_pc:{
Dwarf_Unsigned utmp2;
if (opcode_length[DW_LNS_advance_pc] != 1) {
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
DECODE_LEB128_UWORD(line_ptr, utmp2)
leb128_num = (Dwarf_Word) utmp2;
address =
address +
minimum_instruction_length * leb128_num;
break;
}
case DW_LNS_advance_line:{
Dwarf_Signed stmp;
if (opcode_length[DW_LNS_advance_line] != 1) {
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
DECODE_LEB128_SWORD(line_ptr, stmp)
advance_line = (Dwarf_Sword) stmp;
line = line + advance_line;
break;
}
case DW_LNS_set_file:{
Dwarf_Unsigned utmp2;
if (opcode_length[DW_LNS_set_file] != 1) {
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
DECODE_LEB128_UWORD(line_ptr, utmp2)
file = (Dwarf_Word) utmp2;
break;
}
case DW_LNS_set_column:{
Dwarf_Unsigned utmp2;
if (opcode_length[DW_LNS_set_column] != 1) {
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
DECODE_LEB128_UWORD(line_ptr, utmp2)
column = (Dwarf_Word) utmp2;
break;
}
case DW_LNS_negate_stmt:{
if (opcode_length[DW_LNS_negate_stmt] != 0) {
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
is_stmt = !is_stmt;
break;
}
case DW_LNS_set_basic_block:{
if (opcode_length[DW_LNS_set_basic_block] != 0) {
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
basic_block = true;
break;
}
case DW_LNS_const_add_pc:{
opcode = MAX_LINE_OP_CODE - special_opcode_base;
address = address + minimum_instruction_length *
(opcode / line_range);
break;
}
case DW_LNS_fixed_advance_pc:{
if (opcode_length[DW_LNS_fixed_advance_pc] != 1) {
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
READ_UNALIGNED(dbg, fixed_advance_pc, Dwarf_Half,
line_ptr, sizeof(Dwarf_Half));
line_ptr += sizeof(Dwarf_Half);
address = address + fixed_advance_pc;
break;
}
}
} else if (type == LOP_EXTENDED) {
Dwarf_Unsigned utmp3;
DECODE_LEB128_UWORD(line_ptr, utmp3)
instr_length = (Dwarf_Word) utmp3;
/* Dwarf_Small is a ubyte and the extended opcode
is a ubyte, though not stated as clearly in
the 2.0.0 spec as one might hope.
*/
ext_opcode = *(Dwarf_Small *) line_ptr;
line_ptr++;
switch (ext_opcode) {
case DW_LNE_end_sequence:{
end_sequence = true;
if (dolines) {
curr_line = (Dwarf_Line)
_dwarf_get_alloc(dbg, DW_DLA_LINE, 1);
if (curr_line == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
curr_line->li_address = address;
curr_line->li_addr_line.li_l_data.li_file =
(Dwarf_Sword) file;
curr_line->li_addr_line.li_l_data.li_line =
(Dwarf_Sword) line;
curr_line->li_addr_line.li_l_data.li_column =
(Dwarf_Half) column;
curr_line->li_addr_line.li_l_data.li_is_stmt =
default_is_stmt;
curr_line->li_addr_line.li_l_data.
li_basic_block = basic_block;
curr_line->li_addr_line.li_l_data.
li_end_sequence = end_sequence;
curr_line->li_context = line_context;
line_count++;
chain_line = (Dwarf_Chain)
_dwarf_get_alloc(dbg, DW_DLA_CHAIN, 1);
if (chain_line == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
chain_line->ch_item = curr_line;
if (head_chain == NULL)
head_chain = curr_chain = chain_line;
else {
curr_chain->ch_next = chain_line;
curr_chain = chain_line;
}
}
address = 0;
file = 1;
line = 1;
column = 0;
is_stmt = default_is_stmt;
basic_block = false;
end_sequence = false;
break;
}
case DW_LNE_set_address:{
if (instr_length - 1 == dbg->de_pointer_size) {
READ_UNALIGNED(dbg, address, Dwarf_Addr,
line_ptr, dbg->de_pointer_size);
if (doaddrs) {
curr_line =
(Dwarf_Line) _dwarf_get_alloc(dbg,
DW_DLA_LINE,
1);
if (curr_line == NULL) {
_dwarf_error(dbg, error,
DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
curr_line->li_address = address;
curr_line->li_addr_line.li_offset =
line_ptr - dbg->de_debug_line;
line_count++;
chain_line = (Dwarf_Chain)
_dwarf_get_alloc(dbg, DW_DLA_CHAIN, 1);
if (chain_line == NULL) {
_dwarf_error(dbg, error,
DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
chain_line->ch_item = curr_line;
if (head_chain == NULL)
head_chain = curr_chain = chain_line;
else {
curr_chain->ch_next = chain_line;
curr_chain = chain_line;
}
}
line_ptr += dbg->de_pointer_size;
} else {
_dwarf_error(dbg, error,
DW_DLE_LINE_SET_ADDR_ERROR);
return (DW_DLV_ERROR);
}
break;
}
case DW_LNE_define_file:{
if (dolines) {
cur_file_entry = (Dwarf_File_Entry)
_dwarf_get_alloc(dbg, DW_DLA_FILE_ENTRY, 1);
if (cur_file_entry == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
cur_file_entry->fi_file_name =
(Dwarf_Small *) line_ptr;
line_ptr =
line_ptr + strlen((char *) line_ptr) + 1;
cur_file_entry->fi_dir_index =
(Dwarf_Sword)
_dwarf_decode_u_leb128(line_ptr,
&leb128_length);
line_ptr = line_ptr + leb128_length;
cur_file_entry->fi_time_last_mod =
_dwarf_decode_u_leb128(line_ptr,
&leb128_length);
line_ptr = line_ptr + leb128_length;
cur_file_entry->fi_file_length =
_dwarf_decode_u_leb128(line_ptr,
&leb128_length);
line_ptr = line_ptr + leb128_length;
if (file_entries == NULL)
file_entries = cur_file_entry;
else
prev_file_entry->fi_next = cur_file_entry;
prev_file_entry = cur_file_entry;
file_entry_count++;
}
break;
}
default:{
_dwarf_error(dbg, error,
DW_DLE_LINE_EXT_OPCODE_BAD);
return (DW_DLV_ERROR);
}
}
}
}
block_line = (Dwarf_Line *)
_dwarf_get_alloc(dbg, DW_DLA_LIST, line_count);
if (block_line == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
curr_chain = head_chain;
for (i = 0; i < line_count; i++) {
*(block_line + i) = curr_chain->ch_item;
head_chain = curr_chain;
curr_chain = curr_chain->ch_next;
dwarf_dealloc(dbg, head_chain, DW_DLA_CHAIN);
}
line_context->lc_file_entries = file_entries;
line_context->lc_file_entry_count = file_entry_count;
line_context->lc_include_directories = include_directories;
line_context->lc_include_directories_count =
include_directories_count;
line_context->lc_line_count = line_count;
line_context->lc_compilation_directory = comp_dir;
line_context->lc_version_number = version;
line_context->lc_dbg = dbg;
*count = line_count;
*linebuf = block_line;
return (DW_DLV_OK);
}
/* Internal function, not called by consumer code.
'prefix' has accumulated the info up thru the cie-id
and now we consume the rest and build a Dwarf_Cie_s structure.
*/
int
dwarf_create_cie_from_after_start(Dwarf_Debug dbg,
struct cie_fde_prefix_s *prefix,
Dwarf_Small * frame_ptr,
Dwarf_Unsigned cie_count,
int use_gnu_cie_calc,
Dwarf_Cie * cie_ptr_out,
Dwarf_Error * error)
{
Dwarf_Cie new_cie = 0;
/* egcs-1.1.2 .eh_frame uses 0 as the distinguishing id. sgi uses
-1 (in .debug_frame). .eh_frame not quite identical to
.debug_frame */
Dwarf_Small eh_fde_encoding = 0;
Dwarf_Small *augmentation = 0;
Dwarf_Sword data_alignment_factor = -1;
Dwarf_Word code_alignment_factor = 4;
Dwarf_Unsigned return_address_register = 31;
int local_length_size = 0;
Dwarf_Word leb128_length = 0;
Dwarf_Unsigned cie_aug_data_len = 0;
Dwarf_Small *cie_aug_data = 0;
Dwarf_Addr gnu_personality_handler_addr = 0;
unsigned char gnu_personality_handler_encoding = 0;
unsigned char gnu_lsda_encoding = 0;
unsigned char gnu_fde_begin_encoding = 0;
enum Dwarf_augmentation_type augt = aug_unknown;
/* this is a CIE, Common Information Entry: See the dwarf spec,
section 6.4.1 */
Dwarf_Small version = *(Dwarf_Small *) frame_ptr;
frame_ptr++;
if (version != DW_CIE_VERSION && version != DW_CIE_VERSION3 && version != DW_CIE_VERSION4) {
_dwarf_error(dbg, error, DW_DLE_FRAME_VERSION_BAD);
return (DW_DLV_ERROR);
}
augmentation = frame_ptr;
frame_ptr = frame_ptr + strlen((char *) frame_ptr) + 1;
augt = _dwarf_get_augmentation_type(dbg,
augmentation, use_gnu_cie_calc);
if (augt == aug_eh) {
/* REFERENCED *//* Not used in this instance */
Dwarf_Unsigned exception_table_addr;
/* this is per egcs-1.1.2 as on RH 6.0 */
READ_UNALIGNED(dbg, exception_table_addr,
Dwarf_Unsigned, frame_ptr, local_length_size);
frame_ptr += local_length_size;
}
{
Dwarf_Unsigned lreg = 0;
unsigned long size = 0;
DECODE_LEB128_UWORD(frame_ptr, lreg);
code_alignment_factor = (Dwarf_Word) lreg;
data_alignment_factor =
(Dwarf_Sword) _dwarf_decode_s_leb128(frame_ptr,
&leb128_length);
frame_ptr = frame_ptr + leb128_length;
return_address_register =
_dwarf_get_return_address_reg(frame_ptr, version, &size);
if (return_address_register > DW_FRAME_LAST_REG_NUM) {
_dwarf_error(dbg, error, DW_DLE_CIE_RET_ADDR_REG_ERROR);
return (DW_DLV_ERROR);
}
frame_ptr += size;
}
switch (augt) {
case aug_empty_string:
break;
case aug_irix_mti_v1:
break;
case aug_irix_exception_table:{
Dwarf_Unsigned lreg = 0;
Dwarf_Word length_of_augmented_fields;
/* Decode the length of augmented fields. */
DECODE_LEB128_UWORD(frame_ptr, lreg);
length_of_augmented_fields = (Dwarf_Word) lreg;
/* set the frame_ptr to point at the instruction start. */
frame_ptr += length_of_augmented_fields;
}
break;
case aug_eh:{
int err = 0;
unsigned long increment = 0;
if (!use_gnu_cie_calc) {
/* This should be impossible. */
_dwarf_error(dbg, error,
DW_DLE_FRAME_AUGMENTATION_UNKNOWN);
return DW_DLV_ERROR;
}
err = get_gcc_eh_augmentation(dbg, frame_ptr, &increment,
augt,
prefix->cf_section_ptr,
&eh_fde_encoding,
(char *) augmentation);
if (err == DW_DLV_ERROR) {
_dwarf_error(dbg, error,
DW_DLE_FRAME_AUGMENTATION_UNKNOWN);
return DW_DLV_ERROR;
}
frame_ptr += increment;
break;
}
case aug_gcc_eh_z:{
/* Here we have Augmentation Data Length (uleb128) followed
by Augmentation Data bytes. */
int res;
Dwarf_Unsigned adlen = 0;
DECODE_LEB128_UWORD(frame_ptr, adlen);
cie_aug_data_len = adlen;
cie_aug_data = frame_ptr;
res = gnu_aug_encodings(dbg,
(char *) augmentation,
cie_aug_data,
cie_aug_data_len,
&gnu_personality_handler_encoding,
&gnu_lsda_encoding,
&gnu_fde_begin_encoding,
&gnu_personality_handler_addr);
if (res != DW_DLV_OK) {
_dwarf_error(dbg, error,
DW_DLE_FRAME_AUGMENTATION_UNKNOWN);
return res;
}
frame_ptr += adlen;
break;
}
default:{
/* We do not understand the augmentation string. No
assumption can be made about any fields other than what
we have already read. */
frame_ptr = prefix->cf_start_addr +
prefix->cf_length + prefix->cf_local_length_size
+ prefix->cf_local_extension_size;
/* FIX -- What are the values of data_alignment_factor,
code_alignement_factor, return_address_register and
instruction start? They were clearly uninitalized in the
previous version and I am leaving them the same way. */
break;
}
} /* End switch on augmentation type. */
new_cie = (Dwarf_Cie) _dwarf_get_alloc(dbg, DW_DLA_CIE, 1);
if (new_cie == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
new_cie->ci_cie_version_number = version;
new_cie->ci_initial_table = NULL;
new_cie->ci_length = (Dwarf_Word) prefix->cf_length;
new_cie->ci_length_size = prefix->cf_local_length_size;
new_cie->ci_extension_size = prefix->cf_local_extension_size;
new_cie->ci_augmentation = (char *) augmentation;
new_cie->ci_data_alignment_factor =
(Dwarf_Sbyte) data_alignment_factor;
new_cie->ci_code_alignment_factor =
(Dwarf_Small) code_alignment_factor;
new_cie->ci_return_address_register = return_address_register;
new_cie->ci_cie_start = prefix->cf_start_addr;
new_cie->ci_cie_instr_start = frame_ptr;
new_cie->ci_dbg = dbg;
new_cie->ci_augmentation_type = augt;
new_cie->ci_gnu_eh_augmentation_len = cie_aug_data_len;
new_cie->ci_gnu_eh_augmentation_bytes = cie_aug_data;
new_cie->ci_gnu_personality_handler_encoding =
gnu_personality_handler_encoding;
new_cie->ci_gnu_personality_handler_addr =
gnu_personality_handler_addr;
new_cie->ci_gnu_lsda_encoding = gnu_lsda_encoding;
new_cie->ci_gnu_fde_begin_encoding = gnu_fde_begin_encoding;
new_cie->ci_index = cie_count;
new_cie->ci_section_ptr = prefix->cf_section_ptr;
*cie_ptr_out = new_cie;
return DW_DLV_OK;
}
/*
Although source files is supposed to return the
source files in the compilation-unit, it does
not look for any in the statement program. In
other words, it ignores those defined using the
extended opcode DW_LNE_define_file.
*/
int
dwarf_srcfiles(Dwarf_Die die,
char ***srcfiles,
Dwarf_Signed * srcfilecount, Dwarf_Error * error)
{
/*
This pointer is used to scan the portion of the .debug_line
section for the current cu. */
Dwarf_Small *line_ptr;
/*
This points to the last byte of the .debug_line portion for the
current cu. */
Dwarf_Small *line_ptr_end;
/*
This points to the end of the statement program prologue for the
current cu, and serves to check that the prologue was correctly
decoded. */
Dwarf_Small *check_line_ptr;
/*
Pointer to a DW_AT_stmt_list attribute in case it exists in the
die. */
Dwarf_Attribute stmt_list_attr;
/* Pointer to DW_AT_comp_dir attribute in die. */
Dwarf_Attribute comp_dir_attr;
/* Pointer to name of compilation directory. */
Dwarf_Small *comp_dir = 0;
/*
Offset into .debug_line specified by a DW_AT_stmt_list
attribute. */
Dwarf_Unsigned line_offset = 0;
/* Some of the fields of the statement program header. */
Dwarf_Unsigned total_length = 0;
Dwarf_Half version = 0;
Dwarf_Unsigned prologue_length = 0;
Dwarf_Small special_opcode_base= 0;
/* File name excluding included directory. */
char *file_name = 0;
/* Name of directory that the file is in. */
char *dir_name = 0;
/* Name concatenating both directory and file name. */
char *full_name = 0;
/*
This is the directory index for the file. The compilation
directory is 0, and the first included directory is 1. */
Dwarf_Sword dir_index = 0;
Dwarf_Small *include_directories = 0;
Dwarf_Sword i = 0;
Dwarf_Sword file_count = 0;
Dwarf_Sword directories_count = 0;
/*
This is the current opcode read from the statement program. */
Dwarf_Word leb128_length;
/* This is the length of an extended opcode instr. */
/*
This points to a block of char *'s, each of which points to a
file name. */
char **ret_files = 0;
/* The Dwarf_Debug this die belongs to. */
Dwarf_Debug dbg;
/* Used to chain the file names. */
Dwarf_Chain curr_chain, prev_chain, head_chain = NULL;
int resattr;
int lres;
int local_length_size = 0;
/*REFERENCED*/ /* Not used in this instance of the macro */
int local_extension_size = 0;
int res;
/* ***** BEGIN CODE ***** */
/* Reset error. */
if (error != NULL)
*error = NULL;
CHECK_DIE(die, DW_DLV_ERROR)
dbg = die->di_cu_context->cc_dbg;
resattr = dwarf_attr(die, DW_AT_stmt_list, &stmt_list_attr, error);
if (resattr != DW_DLV_OK) {
return resattr;
}
if (dbg->de_debug_line_index == 0) {
_dwarf_error(dbg, error, DW_DLE_DEBUG_LINE_NULL);
return (DW_DLV_ERROR);
}
res =
_dwarf_load_section(dbg,
dbg->de_debug_line_index,
&dbg->de_debug_line,
error);
if (res != DW_DLV_OK) {
return res;
}
lres = dwarf_formudata(stmt_list_attr, &line_offset, error);
if (lres != DW_DLV_OK) {
return lres;
}
if (line_offset >= dbg->de_debug_line_size) {
_dwarf_error(dbg, error, DW_DLE_LINE_OFFSET_BAD);
return (DW_DLV_ERROR);
}
line_ptr = dbg->de_debug_line + line_offset;
dwarf_dealloc(dbg, stmt_list_attr, DW_DLA_ATTR);
/*
If die has DW_AT_comp_dir attribute, get the string that names
the compilation directory. */
resattr = dwarf_attr(die, DW_AT_comp_dir, &comp_dir_attr, error);
if (resattr == DW_DLV_ERROR) {
return resattr;
}
if (resattr == DW_DLV_OK) {
int cres;
char *cdir;
cres = dwarf_formstring(comp_dir_attr, &cdir, error);
if (cres == DW_DLV_ERROR) {
return cres;
} else if (cres == DW_DLV_OK) {
comp_dir = (Dwarf_Small *) cdir;
}
}
if (resattr == DW_DLV_OK) {
dwarf_dealloc(dbg, comp_dir_attr, DW_DLA_ATTR);
}
/*
Following is a straightforward decoding of the statement
program prologue information. */
/* READ_AREA_LENGTH updates line_ptr for consumed bytes */
READ_AREA_LENGTH(dbg, total_length, Dwarf_Unsigned,
line_ptr, local_length_size, local_extension_size);
line_ptr_end = line_ptr + total_length;
if (line_ptr_end > dbg->de_debug_line + dbg->de_debug_line_size) {
_dwarf_error(dbg, error, DW_DLE_DEBUG_LINE_LENGTH_BAD);
return (DW_DLV_ERROR);
}
READ_UNALIGNED(dbg, version, Dwarf_Half,
line_ptr, sizeof(Dwarf_Half));
line_ptr += sizeof(Dwarf_Half);
if (version != CURRENT_VERSION_STAMP &&
version != CURRENT_VERSION_STAMP3) {
_dwarf_error(dbg, error, DW_DLE_VERSION_STAMP_ERROR);
return (DW_DLV_ERROR);
}
READ_UNALIGNED(dbg, prologue_length, Dwarf_Unsigned,
line_ptr, local_length_size);
line_ptr += local_length_size;
check_line_ptr = line_ptr;
/* Skip over minimum instruction length. */
line_ptr = line_ptr + sizeof(Dwarf_Small);
/* Skip over default_is_stmt. */
line_ptr = line_ptr + sizeof(Dwarf_Small);
/* Skip over line_base. */
line_ptr = line_ptr + sizeof(Dwarf_Sbyte);
/* Skip over line_ptr. */
line_ptr = line_ptr + sizeof(Dwarf_Small);
special_opcode_base = *(Dwarf_Small *) line_ptr;
line_ptr = line_ptr + sizeof(Dwarf_Small);
for (i = 1; i < special_opcode_base; i++) {
/* Skip over opcode lengths for standard opcodes. */
line_ptr = line_ptr + sizeof(Dwarf_Small);
}
directories_count = 0;
include_directories = line_ptr;
while ((*(char *) line_ptr) != '\0') {
line_ptr = line_ptr + strlen((char *) line_ptr) + 1;
directories_count++;
}
line_ptr++;
file_count = 0;
while (*(char *) line_ptr != '\0') {
Dwarf_Unsigned utmp;
file_name = (char *) line_ptr;
line_ptr = line_ptr + strlen((char *) line_ptr) + 1;
DECODE_LEB128_UWORD(line_ptr, utmp)
dir_index = (Dwarf_Sword) utmp;
if (dir_index > directories_count) {
_dwarf_error(dbg, error, DW_DLE_DIR_INDEX_BAD);
return (DW_DLV_ERROR);
}
if (dir_index == 0)
dir_name = (char *) comp_dir;
else {
dir_name = (char *) include_directories;
for (i = 1; i < dir_index; i++)
/* FIX: this is probably very slow: redoing strlen!
davea 9/94 */
dir_name = dir_name + strlen(dir_name) + 1;
}
/* dir_name can be NULL if there is no DW_AT_comp_dir */
if ((*file_name) == '/' || dir_name == 0)
full_name = file_name;
else {
full_name = (char *) _dwarf_get_alloc(dbg, DW_DLA_STRING,
strlen(dir_name) + 1 +
strlen(file_name) +
1);
if (full_name == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
strcpy(full_name, dir_name);
strcat(full_name, "/");
strcat(full_name, file_name);
}
/* Skip over time of last modification. */
_dwarf_decode_u_leb128(line_ptr, &leb128_length);
line_ptr = line_ptr + leb128_length;
/* Skip over file length. */
_dwarf_decode_u_leb128(line_ptr, &leb128_length);
line_ptr = line_ptr + leb128_length;
curr_chain =
(Dwarf_Chain) _dwarf_get_alloc(dbg, DW_DLA_CHAIN, 1);
if (curr_chain == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
curr_chain->ch_item = full_name;
if (head_chain == NULL)
head_chain = prev_chain = curr_chain;
else {
prev_chain->ch_next = curr_chain;
prev_chain = curr_chain;
}
file_count++;
}
line_ptr++;
if (line_ptr != check_line_ptr + prologue_length) {
_dwarf_error(dbg, error, DW_DLE_LINE_PROLOG_LENGTH_BAD);
return (DW_DLV_ERROR);
}
if (file_count == 0) {
*srcfiles = NULL;
*srcfilecount = 0;
return (DW_DLV_NO_ENTRY);
}
ret_files = (char **)
_dwarf_get_alloc(dbg, DW_DLA_LIST, file_count);
if (ret_files == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
curr_chain = head_chain;
for (i = 0; i < file_count; i++) {
*(ret_files + i) = curr_chain->ch_item;
prev_chain = curr_chain;
curr_chain = curr_chain->ch_next;
dwarf_dealloc(dbg, prev_chain, DW_DLA_CHAIN);
}
*srcfiles = ret_files;
*srcfilecount = file_count;
return (DW_DLV_OK);
}
/*
return DW_DLV_OK if ok. else DW_DLV_NO_ENTRY or DW_DLV_ERROR
If err_count_out is non-NULL, this is a special 'check'
call.
*/
int
_dwarf_internal_printlines(Dwarf_Die die, Dwarf_Error * error,
int * err_count_out, int only_line_header)
{
/*
This pointer is used to scan the portion of the .debug_line
section for the current cu. */
Dwarf_Small *line_ptr = 0;
Dwarf_Small *orig_line_ptr = 0;
/*
This points to the last byte of the .debug_line portion for the
current cu. */
Dwarf_Small *line_ptr_end = 0;
/*
Pointer to a DW_AT_stmt_list attribute in case it exists in the
die. */
Dwarf_Attribute stmt_list_attr = 0;
/* Pointer to DW_AT_comp_dir attribute in die. */
Dwarf_Attribute comp_dir_attr = 0;
/* Pointer to name of compilation directory. */
Dwarf_Small *comp_dir = NULL;
/*
Offset into .debug_line specified by a DW_AT_stmt_list
attribute. */
Dwarf_Unsigned line_offset = 0;
struct Line_Table_Prefix_s prefix;
/* These are the state machine state variables. */
Dwarf_Addr address = 0;
Dwarf_Word file = 1;
Dwarf_Word line = 1;
Dwarf_Word column = 0;
Dwarf_Bool is_stmt = false;
Dwarf_Bool basic_block = false;
Dwarf_Bool end_sequence = false;
Dwarf_Bool prologue_end = false;
Dwarf_Bool epilogue_begin = false;
Dwarf_Small isa = 0;
Dwarf_Sword i=0;
/*
This is the current opcode read from the statement program. */
Dwarf_Small opcode=0;
/*
These variables are used to decode leb128 numbers. Leb128_num
holds the decoded number, and leb128_length is its length in
bytes. */
Dwarf_Word leb128_num=0;
Dwarf_Word leb128_length=0;
Dwarf_Sword advance_line=0;
Dwarf_Half attrform = 0;
/*
This is the operand of the latest fixed_advance_pc extended
opcode. */
Dwarf_Half fixed_advance_pc=0;
/* In case there are wierd bytes 'after' the line table
* prologue this lets us print something. This is a gcc
* compiler bug and we expect the bytes count to be 12.
*/
Dwarf_Small* bogus_bytes_ptr = 0;
Dwarf_Unsigned bogus_bytes_count = 0;
/* The Dwarf_Debug this die belongs to. */
Dwarf_Debug dbg=0;
int resattr = DW_DLV_ERROR;
int lres = DW_DLV_ERROR;
int res = DW_DLV_ERROR;
/* ***** BEGIN CODE ***** */
if (error != NULL) {
*error = NULL;
}
CHECK_DIE(die, DW_DLV_ERROR);
dbg = die->di_cu_context->cc_dbg;
res = _dwarf_load_section(dbg, &dbg->de_debug_line,error);
if (res != DW_DLV_OK) {
return res;
}
resattr = dwarf_attr(die, DW_AT_stmt_list, &stmt_list_attr, error);
if (resattr != DW_DLV_OK) {
return resattr;
}
/* The list of relevant FORMs is small.
DW_FORM_data4, DW_FORM_data8, DW_FORM_sec_offset
*/
lres = dwarf_whatform(stmt_list_attr,&attrform,error);
if (lres != DW_DLV_OK) {
return lres;
}
if (attrform != DW_FORM_data4 && attrform != DW_FORM_data8 &&
attrform != DW_FORM_sec_offset ) {
_dwarf_error(dbg, error, DW_DLE_LINE_OFFSET_BAD);
return (DW_DLV_ERROR);
}
lres = dwarf_global_formref(stmt_list_attr, &line_offset, error);
if (lres != DW_DLV_OK) {
return lres;
}
if (line_offset >= dbg->de_debug_line.dss_size) {
_dwarf_error(dbg, error, DW_DLE_LINE_OFFSET_BAD);
return (DW_DLV_ERROR);
}
orig_line_ptr = dbg->de_debug_line.dss_data;
line_ptr = dbg->de_debug_line.dss_data + line_offset;
dwarf_dealloc(dbg, stmt_list_attr, DW_DLA_ATTR);
/*
If die has DW_AT_comp_dir attribute, get the string that names
the compilation directory. */
resattr = dwarf_attr(die, DW_AT_comp_dir, &comp_dir_attr, error);
if (resattr == DW_DLV_ERROR) {
return resattr;
}
if (resattr == DW_DLV_OK) {
int cres = DW_DLV_ERROR;
char *cdir = 0;
cres = dwarf_formstring(comp_dir_attr, &cdir, error);
if (cres == DW_DLV_ERROR) {
return cres;
} else if (cres == DW_DLV_OK) {
comp_dir = (Dwarf_Small *) cdir;
}
}
if (resattr == DW_DLV_OK) {
dwarf_dealloc(dbg, comp_dir_attr, DW_DLA_ATTR);
}
dwarf_init_line_table_prefix(&prefix);
{
Dwarf_Small *line_ptr_out = 0;
int dres = dwarf_read_line_table_prefix(dbg,
line_ptr,dbg->de_debug_line.dss_size - line_offset,
&line_ptr_out,
&prefix,
&bogus_bytes_ptr,
&bogus_bytes_count,
error,
err_count_out);
if (dres == DW_DLV_ERROR) {
dwarf_free_line_table_prefix(&prefix);
return dres;
}
if (dres == DW_DLV_NO_ENTRY) {
dwarf_free_line_table_prefix(&prefix);
return dres;
}
line_ptr_end = prefix.pf_line_ptr_end;
line_ptr = line_ptr_out;
}
if(only_line_header) {
/* Just checking for header errors, nothing more here.*/
dwarf_free_line_table_prefix(&prefix);
return DW_DLV_OK;
}
printf("total line info length %ld bytes, "
"line offset 0x%" DW_PR_DUx " %" DW_PR_DSd "\n",
(long) prefix.pf_total_length,
(Dwarf_Unsigned) line_offset,
(Dwarf_Signed) line_offset);
printf("line table version %d\n",(int) prefix.pf_version);
printf("line table length field length %d prologue length %d\n",
(int)prefix.pf_length_field_length,
(int)prefix.pf_prologue_length);
printf("compilation_directory %s\n",
comp_dir ? ((char *) comp_dir) : "");
printf(" min instruction length %d\n",
(int) prefix.pf_minimum_instruction_length);
printf(" default is stmt %d\n", (int)
prefix.pf_default_is_stmt);
printf(" line base %d\n", (int)
prefix.pf_line_base);
printf(" line_range %d\n", (int)
prefix.pf_line_range);
printf(" opcode base %d\n", (int)
prefix.pf_opcode_base);
printf(" standard opcode count %d\n", (int)
prefix.pf_std_op_count);
for (i = 1; i < prefix.pf_opcode_base; i++) {
printf(" opcode[%2d] length %d\n", (int) i,
(int) prefix.pf_opcode_length_table[i - 1]);
}
printf(" include directories count %d\n", (int)
prefix.pf_include_directories_count);
for (i = 0; i < prefix.pf_include_directories_count; ++i) {
printf(" include dir[%d] %s\n",
(int) i, prefix.pf_include_directories[i]);
}
printf(" files count %d\n", (int)
prefix.pf_files_count);
for (i = 0; i < prefix.pf_files_count; ++i) {
struct Line_Table_File_Entry_s *lfile =
prefix.pf_line_table_file_entries + i;
Dwarf_Unsigned tlm2 = lfile->lte_last_modification_time;
Dwarf_Unsigned di = lfile->lte_directory_index;
Dwarf_Unsigned fl = lfile->lte_length_of_file;
printf(" file[%d] %s (file-number: %d) \n",
(int) i, (char *) lfile->lte_filename,
(int)(i+1));
printf(" dir index %d\n", (int) di);
{
time_t tt = (time_t) tlm2;
printf(" last time 0x%x %s", /* ctime supplies
newline */
(unsigned) tlm2, ctime(&tt));
}
printf(" file length %ld 0x%lx\n",
(long) fl, (unsigned long) fl);
}
{
Dwarf_Unsigned offset = 0;
if(bogus_bytes_count > 0) {
Dwarf_Unsigned wcount = bogus_bytes_count;
Dwarf_Unsigned boffset = bogus_bytes_ptr - orig_line_ptr;
printf("*** DWARF CHECK: the line table prologue header_length "
" is %" DW_PR_DUu " too high, we pretend it is smaller."
"Section offset: %" DW_PR_DUu " (0x%" DW_PR_DUx ") ***\n",
wcount, boffset,boffset);
*err_count_out += 1;
}
offset = line_ptr - orig_line_ptr;
printf(" statement prog offset in section: %" DW_PR_DUu " 0x%" DW_PR_DUx "\n",
offset, offset);
}
/* Initialize the part of the state machine dependent on the
prefix. */
is_stmt = prefix.pf_default_is_stmt;
print_line_header();
/* Start of statement program. */
while (line_ptr < line_ptr_end) {
int type = 0;
printf(" [0x%06" DW_PR_DSx "] ",
(Dwarf_Signed) (line_ptr - orig_line_ptr));
opcode = *(Dwarf_Small *) line_ptr;
line_ptr++;
/* 'type' is the output */
WHAT_IS_OPCODE(type, opcode, prefix.pf_opcode_base,
prefix.pf_opcode_length_table, line_ptr,
prefix.pf_std_op_count);
if (type == LOP_DISCARD) {
int oc;
int opcnt = prefix.pf_opcode_length_table[opcode];
printf("*** DWARF CHECK: DISCARD standard opcode %d "
"with %d operands: "
"not understood.", opcode, opcnt);
*err_count_out += 1;
for (oc = 0; oc < opcnt; oc++) {
/*
* Read and discard operands we don't
* understand.
* Arbitrary choice of unsigned read.
* Signed read would work as well.
*/
Dwarf_Unsigned utmp2;
DECODE_LEB128_UWORD(line_ptr, utmp2);
printf(" %" DW_PR_DUu " (0x%" DW_PR_DUx ")",
(Dwarf_Unsigned) utmp2,
(Dwarf_Unsigned) utmp2);
}
printf("***\n");
/* do nothing, necessary ops done */
} else if (type == LOP_SPECIAL) {
/* This op code is a special op in the object, no matter
that it might fall into the standard op range in this
compile Thatis, these are special opcodes between
special_opcode_base and MAX_LINE_OP_CODE. (including
special_opcode_base and MAX_LINE_OP_CODE) */
char special[50];
unsigned origop = opcode;
opcode = opcode - prefix.pf_opcode_base;
address = address + prefix.pf_minimum_instruction_length *
(opcode / prefix.pf_line_range);
line =
line + prefix.pf_line_base +
opcode % prefix.pf_line_range;
sprintf(special, "Specialop %3u", origop);
print_line_detail(special,
opcode, address, (int) file, line, column,
is_stmt, basic_block, end_sequence,
prologue_end, epilogue_begin, isa);
basic_block = false;
} else if (type == LOP_STANDARD) {
switch (opcode) {
case DW_LNS_copy:{
print_line_detail("DW_LNS_copy",
opcode, address, file, line,
column, is_stmt, basic_block,
end_sequence, prologue_end,
epilogue_begin, isa);
basic_block = false;
break;
}
case DW_LNS_advance_pc:{
Dwarf_Unsigned utmp2;
DECODE_LEB128_UWORD(line_ptr, utmp2);
printf("DW_LNS_advance_pc val %" DW_PR_DSd " 0x%" DW_PR_DUx "\n",
(Dwarf_Signed) (Dwarf_Word) utmp2,
(Dwarf_Unsigned) (Dwarf_Word) utmp2);
leb128_num = (Dwarf_Word) utmp2;
address =
address +
prefix.pf_minimum_instruction_length *
leb128_num;
break;
}
case DW_LNS_advance_line:{
Dwarf_Signed stmp;
DECODE_LEB128_SWORD(line_ptr, stmp);
advance_line = (Dwarf_Sword) stmp;
printf("DW_LNS_advance_line val %" DW_PR_DSd " 0x%" DW_PR_DSx "\n",
(Dwarf_Signed) advance_line,
(Dwarf_Signed) advance_line);
line = line + advance_line;
break;
}
case DW_LNS_set_file:{
Dwarf_Unsigned utmp2;
DECODE_LEB128_UWORD(line_ptr, utmp2);
file = (Dwarf_Word) utmp2;
printf("DW_LNS_set_file %ld\n", (long) file);
break;
}
case DW_LNS_set_column:{
Dwarf_Unsigned utmp2;
DECODE_LEB128_UWORD(line_ptr, utmp2);
column = (Dwarf_Word) utmp2;
printf("DW_LNS_set_column val %" DW_PR_DSd " 0x%" DW_PR_DSx "\n",
(Dwarf_Signed) column, (Dwarf_Signed) column);
break;
}
case DW_LNS_negate_stmt:{
is_stmt = !is_stmt;
printf("DW_LNS_negate_stmt\n");
break;
}
case DW_LNS_set_basic_block:{
printf("DW_LNS_set_basic_block\n");
basic_block = true;
break;
}
case DW_LNS_const_add_pc:{
opcode = MAX_LINE_OP_CODE - prefix.pf_opcode_base;
address =
address +
prefix.pf_minimum_instruction_length * (opcode /
prefix.
pf_line_range);
printf("DW_LNS_const_add_pc new address 0x%" DW_PR_DSx "\n",
(Dwarf_Signed) address);
break;
}
case DW_LNS_fixed_advance_pc:{
READ_UNALIGNED(dbg, fixed_advance_pc, Dwarf_Half,
line_ptr, sizeof(Dwarf_Half));
line_ptr += sizeof(Dwarf_Half);
address = address + fixed_advance_pc;
printf("DW_LNS_fixed_advance_pc val %" DW_PR_DSd
" 0x%" DW_PR_DSx " new address 0x%" DW_PR_DSx "\n",
(Dwarf_Signed) fixed_advance_pc,
(Dwarf_Signed) fixed_advance_pc,
(Dwarf_Signed) address);
break;
}
case DW_LNS_set_prologue_end:{
prologue_end = true;
printf("DW_LNS_set_prologue_end set true.\n");
break;
}
/* New in DWARF3 */
case DW_LNS_set_epilogue_begin:{
epilogue_begin = true;
printf("DW_LNS_set_epilogue_begin set true.\n");
break;
}
/* New in DWARF3 */
case DW_LNS_set_isa:{
Dwarf_Unsigned utmp2;
DECODE_LEB128_UWORD(line_ptr, utmp2);
isa = utmp2;
printf("DW_LNS_set_isa new value 0x%" DW_PR_DUx ".\n",
(Dwarf_Unsigned) utmp2);
if (isa != utmp2) {
/* The value of the isa did not fit in our
local so we record it wrong. declare an
error. */
dwarf_free_line_table_prefix(&prefix);
_dwarf_error(dbg, error,
DW_DLE_LINE_NUM_OPERANDS_BAD);
return (DW_DLV_ERROR);
}
break;
}
}
} else if (type == LOP_EXTENDED) {
Dwarf_Unsigned utmp3 = 0;
Dwarf_Word instr_length = 0;
Dwarf_Small ext_opcode = 0;
DECODE_LEB128_UWORD(line_ptr, utmp3);
instr_length = (Dwarf_Word) utmp3;
ext_opcode = *(Dwarf_Small *) line_ptr;
line_ptr++;
switch (ext_opcode) {
case DW_LNE_end_sequence:{
end_sequence = true;
print_line_detail("DW_LNE_end_sequence extended",
opcode, address, file, line,
column, is_stmt, basic_block,
end_sequence, prologue_end,
epilogue_begin, isa);
address = 0;
file = 1;
line = 1;
column = 0;
is_stmt = prefix.pf_default_is_stmt;
basic_block = false;
end_sequence = false;
prologue_end = false;
epilogue_begin = false;
break;
}
case DW_LNE_set_address:{
{
READ_UNALIGNED(dbg, address, Dwarf_Addr,
line_ptr,
die->di_cu_context->cc_address_size);
line_ptr += die->di_cu_context->cc_address_size;
printf("DW_LNE_set_address address 0x%" DW_PR_DUx "\n",
(Dwarf_Unsigned) address);
}
break;
}
case DW_LNE_define_file:{
Dwarf_Unsigned di = 0;
Dwarf_Unsigned tlm = 0;
Dwarf_Unsigned fl = 0;
Dwarf_Small *fn = (Dwarf_Small *) line_ptr;
line_ptr = line_ptr + strlen((char *) line_ptr) + 1;
di = _dwarf_decode_u_leb128(line_ptr,
&leb128_length);
line_ptr = line_ptr + leb128_length;
tlm = _dwarf_decode_u_leb128(line_ptr,
&leb128_length);
line_ptr = line_ptr + leb128_length;
fl = _dwarf_decode_u_leb128(line_ptr,
&leb128_length);
line_ptr = line_ptr + leb128_length;
printf("DW_LNE_define_file %s \n", fn);
printf(" dir index %d\n", (int) di);
{
time_t tt3 = (time_t) tlm;
/* ctime supplies newline */
printf(" last time 0x%x %s",
(unsigned) tlm, ctime(&tt3));
}
printf(" file length %ld 0x%lx\n",
(long) fl, (unsigned long) fl);
break;
}
default:{
/* This is an extended op code we do not know about,
other than we know now many bytes it is
(and the op code and the bytes of operand). */
Dwarf_Unsigned remaining_bytes = instr_length -1;
if(instr_length < 1 || remaining_bytes > DW_LNE_LEN_MAX) {
dwarf_free_line_table_prefix(&prefix);
_dwarf_error(dbg, error,
DW_DLE_LINE_EXT_OPCODE_BAD);
return (DW_DLV_ERROR);
}
printf("DW_LNE extended op 0x%x ",ext_opcode);
printf("Bytecount: " DW_PR_DUu , instr_length);
if(remaining_bytes > 0) {
printf(" linedata: 0x");
while (remaining_bytes > 0) {
printf("%02x",(unsigned char)(*(line_ptr)));
line_ptr++;
remaining_bytes--;
}
}
printf("\n");
}
break;
}
}
}
dwarf_free_line_table_prefix(&prefix);
return (DW_DLV_OK);
}
/*
This function does two slightly different things
depending on the input flag want_AT_sibling. If
this flag is true, it checks if the input die has
a DW_AT_sibling attribute. If it does it returns
a pointer to the start of the sibling die in the
.debug_info section. Otherwise it behaves the
same as the want_AT_sibling false case.
If the want_AT_sibling flag is false, it returns
a pointer to the immediately adjacent die in the
.debug_info section.
Die_info_end points to the end of the .debug_info
portion for the cu the die belongs to. It is used
to check that the search for the next die does not
cross the end of the current cu. Cu_info_start points
to the start of the .debug_info portion for the
current cu, and is used to add to the offset for
DW_AT_sibling attributes. Finally, has_die_child
is a pointer to a Dwarf_Bool that is set true if
the present die has children, false otherwise.
However, in case want_AT_child is true and the die
has a DW_AT_sibling attribute *has_die_child is set
false to indicate that the children are being skipped.
*/
static Dwarf_Byte_Ptr
_dwarf_next_die_info_ptr(Dwarf_Byte_Ptr die_info_ptr,
Dwarf_CU_Context cu_context,
Dwarf_Byte_Ptr die_info_end,
Dwarf_Byte_Ptr cu_info_start,
Dwarf_Bool want_AT_sibling,
Dwarf_Bool * has_die_child)
{
Dwarf_Byte_Ptr info_ptr;
Dwarf_Byte_Ptr abbrev_ptr;
Dwarf_Word abbrev_code;
Dwarf_Abbrev_List abbrev_list;
Dwarf_Half attr;
Dwarf_Half attr_form;
Dwarf_Unsigned offset;
Dwarf_Word leb128_length;
Dwarf_Unsigned utmp;
Dwarf_Debug dbg;
info_ptr = die_info_ptr;
DECODE_LEB128_UWORD(info_ptr, utmp)
abbrev_code = (Dwarf_Word) utmp;
if (abbrev_code == 0) {
return NULL;
}
abbrev_list = _dwarf_get_abbrev_for_code(cu_context, abbrev_code);
if (abbrev_list == NULL) {
return (NULL);
}
dbg = cu_context->cc_dbg;
*has_die_child = abbrev_list->ab_has_child;
abbrev_ptr = abbrev_list->ab_abbrev_ptr;
do {
Dwarf_Unsigned utmp2;
DECODE_LEB128_UWORD(abbrev_ptr, utmp2)
attr = (Dwarf_Half) utmp2;
DECODE_LEB128_UWORD(abbrev_ptr, utmp2)
attr_form = (Dwarf_Half) utmp2;
if (attr_form == DW_FORM_indirect) {
Dwarf_Unsigned utmp6;
/* READ_UNALIGNED does update info_ptr */
DECODE_LEB128_UWORD(info_ptr, utmp6)
attr_form = (Dwarf_Half) utmp6;
}
if (want_AT_sibling && attr == DW_AT_sibling) {
switch (attr_form) {
case DW_FORM_ref1:
offset = *(Dwarf_Small *) info_ptr;
break;
case DW_FORM_ref2:
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
info_ptr, sizeof(Dwarf_Half));
break;
case DW_FORM_ref4:
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
info_ptr, sizeof(Dwarf_ufixed));
break;
case DW_FORM_ref8:
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
info_ptr, sizeof(Dwarf_Unsigned));
break;
case DW_FORM_ref_udata:
offset =
_dwarf_decode_u_leb128(info_ptr, &leb128_length);
break;
default:
return (NULL);
}
/* Reset *has_die_child to indicate children skipped. */
*has_die_child = false;
if (cu_info_start + offset > die_info_end) {
return (NULL);
} else {
return (cu_info_start + offset);
}
}
if (attr_form != 0) {
info_ptr += _dwarf_get_size_of_val(cu_context->cc_dbg,
attr_form, info_ptr,
cu_context->
cc_length_size);
if (info_ptr > die_info_end) {
return (NULL);
}
}
} while (attr != 0 || attr_form != 0);
return (info_ptr);
}
