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 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);
}
/*
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);
}
/*
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);
}
