int
dwarf_formsdata(Dwarf_Attribute attr,
Dwarf_Signed * return_sval, Dwarf_Error * error)
{
Dwarf_Signed ret_value = 0;
Dwarf_Debug dbg = 0;
Dwarf_CU_Context cu_context = 0;
int res = get_attr_dbg(&dbg,&cu_context,attr,error);
if (res != DW_DLV_OK) {
return res;
}
switch (attr->ar_attribute_form) {
case DW_FORM_data1:
*return_sval = (*(Dwarf_Sbyte *) attr->ar_debug_ptr);
return DW_DLV_OK;
/* READ_UNALIGNED does not sign extend.
So we have to use a cast to get the
value sign extended in the right way for each case. */
case DW_FORM_data2:{
READ_UNALIGNED(dbg, ret_value, Dwarf_Signed,
attr->ar_debug_ptr,
sizeof(Dwarf_Shalf));
*return_sval = (Dwarf_Shalf) ret_value;
return DW_DLV_OK;
}
case DW_FORM_data4:{
READ_UNALIGNED(dbg, ret_value, Dwarf_Signed,
attr->ar_debug_ptr,
sizeof(Dwarf_sfixed));
*return_sval = (Dwarf_sfixed) ret_value;
return DW_DLV_OK;
}
case DW_FORM_data8:{
READ_UNALIGNED(dbg, ret_value, Dwarf_Signed,
attr->ar_debug_ptr,
sizeof(Dwarf_Signed));
*return_sval = (Dwarf_Signed) ret_value;
return DW_DLV_OK;
}
case DW_FORM_sdata:
ret_value =
(_dwarf_decode_s_leb128(attr->ar_debug_ptr, NULL));
*return_sval = ret_value;
return DW_DLV_OK;
/* IRIX bug 583450. We do not allow reading sdata from a udata
value. Caller can retry, calling udata */
default:
break;
}
_dwarf_error(dbg, error, DW_DLE_ATTR_FORM_BAD);
return DW_DLV_ERROR;
}
int
dwarf_formsdata(Dwarf_Attribute attr,
Dwarf_Signed * return_sval, Dwarf_Error * error)
{
Dwarf_Signed ret_value;
Dwarf_Debug dbg;
Dwarf_CU_Context cu_context;
if (attr == NULL) {
_dwarf_error(NULL, error, DW_DLE_ATTR_NULL);
return (DW_DLV_ERROR);
}
cu_context = attr->ar_cu_context;
if (cu_context == NULL) {
_dwarf_error(NULL, error, DW_DLE_ATTR_NO_CU_CONTEXT);
return (DW_DLV_ERROR);
}
dbg = cu_context->cc_dbg;
if (dbg == NULL) {
_dwarf_error(NULL, error, DW_DLE_ATTR_DBG_NULL);
return (DW_DLV_ERROR);
}
switch (attr->ar_attribute_form) {
case DW_FORM_data1:
*return_sval = (*(Dwarf_Sbyte *) attr->ar_debug_info_ptr);
return DW_DLV_OK;
/* READ_UNALIGNED does not sign extend.
So we have to use a cast to get the
value sign extended in the right way for each case. */
case DW_FORM_data2:{
READ_UNALIGNED(dbg, ret_value, Dwarf_Signed,
attr->ar_debug_info_ptr,
sizeof(Dwarf_Shalf));
*return_sval = (Dwarf_Shalf) ret_value;
return DW_DLV_OK;
}
case DW_FORM_data4:{
READ_UNALIGNED(dbg, ret_value, Dwarf_Signed,
attr->ar_debug_info_ptr,
sizeof(Dwarf_sfixed));
*return_sval = (Dwarf_sfixed) ret_value;
return DW_DLV_OK;
}
case DW_FORM_data8:{
READ_UNALIGNED(dbg, ret_value, Dwarf_Signed,
attr->ar_debug_info_ptr,
sizeof(Dwarf_Signed));
*return_sval = (Dwarf_Signed) ret_value;
return DW_DLV_OK;
}
case DW_FORM_sdata:
ret_value =
(_dwarf_decode_s_leb128(attr->ar_debug_info_ptr, NULL));
*return_sval = ret_value;
return DW_DLV_OK;
/* see bug 583450. We do not allow reading sdata from a udata
value. Caller can retry, calling sdata */
default:
break;
}
_dwarf_error(dbg, error, DW_DLE_ATTR_FORM_BAD);
return (DW_DLV_ERROR);
}
/* This code was contributed some time ago
and the return
value is in the wrong form,
but we are not fixing it.
*/
void *
dwarf_uncompress_integer_block(
Dwarf_Debug dbg,
Dwarf_Bool unit_is_signed,
Dwarf_Small unit_length_in_bits,
void* input_block,
Dwarf_Unsigned input_length_in_bytes,
Dwarf_Unsigned* output_length_in_units_ptr,
Dwarf_Error* error
)
{
Dwarf_Unsigned output_length_in_units = 0;
void * output_block = 0;
unsigned i = 0;
char * ptr = 0;
int remain = 0;
Dwarf_sfixed * array = 0;
if (dbg == NULL) {
_dwarf_error(NULL, error, DW_DLE_DBG_NULL);
return((void *)DW_DLV_BADADDR);
}
if (unit_is_signed == false ||
unit_length_in_bits != 32 ||
input_block == NULL ||
input_length_in_bytes == 0 ||
output_length_in_units_ptr == NULL) {
_dwarf_error(NULL, error, DW_DLE_BADBITC);
return ((void *) DW_DLV_BADADDR);
}
/* At this point we assume the format is: signed 32 bit */
/* first uncompress everything to find the total size. */
output_length_in_units = 0;
remain = input_length_in_bytes;
ptr = input_block;
while (remain > 0) {
Dwarf_Word len = 0;
_dwarf_decode_s_leb128((unsigned char *)ptr, &len);
ptr += len;
remain -= len;
output_length_in_units++;
}
if (remain != 0) {
_dwarf_error(NULL, error, DW_DLE_ALLOC_FAIL);
return((void *)DW_DLV_BADADDR);
}
/* then alloc */
output_block = (void *)
_dwarf_get_alloc(dbg,
DW_DLA_STRING,
output_length_in_units * (unit_length_in_bits / 8));
if (output_block == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return((void*)DW_DLV_BADADDR);
}
/* then uncompress again and copy into new buffer */
array = (Dwarf_sfixed *) output_block;
remain = input_length_in_bytes;
ptr = input_block;
for (i=0; i<output_length_in_units && remain>0; i++) {
Dwarf_Signed num;
Dwarf_Word len;
num = _dwarf_decode_s_leb128((unsigned char *)ptr, &len);
ptr += len;
remain -= len;
array[i] = num;
}
if (remain != 0) {
dwarf_dealloc(dbg, (unsigned char *)output_block, DW_DLA_STRING);
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return((Dwarf_P_Attribute)DW_DLV_BADADDR);
}
*output_length_in_units_ptr = output_length_in_units;
return output_block;
}
/* Given augmentation character (the encoding) giving the
address format, read the address from input_field
and return an incremented value 1 past the input bytes of the
address.
Push the address read back thru the *addr pointer.
See LSB (Linux Standar Base) exception handling documents.
*/
static int
read_encoded_ptr(Dwarf_Debug dbg,
Dwarf_Small * input_field,
int gnu_encoding,
Dwarf_Unsigned * addr,
Dwarf_Small ** input_field_updated)
{
Dwarf_Word length = 0;
int value_type = gnu_encoding & 0xf;
if (gnu_encoding == 0xff) {
/* There is no data here. */
*addr = 0;
*input_field_updated = input_field;
/* Should we return DW_DLV_NO_ENTRY? */
return DW_DLV_OK;
}
switch (value_type) {
case DW_EH_PE_absptr:{
/* value_type is zero. Treat as pointer size of the object.
*/
Dwarf_Unsigned ret_value = 0;
READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
input_field, dbg->de_pointer_size);
*addr = ret_value;
*input_field_updated = input_field + dbg->de_pointer_size;
}
break;
case DW_EH_PE_uleb128:{
Dwarf_Unsigned val = _dwarf_decode_u_leb128(input_field,
&length);
*addr = val;
*input_field_updated = input_field + length;
}
break;
case DW_EH_PE_udata2:{
Dwarf_Unsigned ret_value = 0;
READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
input_field, 2);
*addr = ret_value;
*input_field_updated = input_field + 2;
}
break;
case DW_EH_PE_udata4:{
Dwarf_Unsigned ret_value = 0;
/* ASSERT: sizeof(Dwarf_ufixed) == 4 */
READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
input_field, sizeof(Dwarf_ufixed));
*addr = ret_value;
*input_field_updated = input_field + sizeof(Dwarf_ufixed);
}
break;
case DW_EH_PE_udata8:{
Dwarf_Unsigned ret_value = 0;
/* ASSERT: sizeof(Dwarf_Unsigned) == 8 */
READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
input_field, sizeof(Dwarf_Unsigned));
*addr = ret_value;
*input_field_updated = input_field + sizeof(Dwarf_Unsigned);
}
break;
case DW_EH_PE_sleb128:{
Dwarf_Signed val = _dwarf_decode_s_leb128(input_field,
&length);
*addr = (Dwarf_Unsigned) val;
*input_field_updated = input_field + length;
}
break;
case DW_EH_PE_sdata2:{
Dwarf_Unsigned val = 0;
READ_UNALIGNED(dbg, val, Dwarf_Unsigned, input_field, 2);
SIGN_EXTEND(val, 2);
*addr = (Dwarf_Unsigned) val;
*input_field_updated = input_field + 2;
}
break;
case DW_EH_PE_sdata4:{
Dwarf_Unsigned val = 0;
/* ASSERT: sizeof(Dwarf_ufixed) == 4 */
READ_UNALIGNED(dbg, val,
Dwarf_Unsigned, input_field,
sizeof(Dwarf_ufixed));
SIGN_EXTEND(val, sizeof(Dwarf_ufixed));
*addr = (Dwarf_Unsigned) val;
*input_field_updated = input_field + sizeof(Dwarf_ufixed);
}
break;
case DW_EH_PE_sdata8:{
Dwarf_Unsigned val = 0;
/* ASSERT: sizeof(Dwarf_Unsigned) == 8 */
READ_UNALIGNED(dbg, val,
Dwarf_Unsigned, input_field,
sizeof(Dwarf_Unsigned));
*addr = (Dwarf_Unsigned) val;
*input_field_updated = input_field + sizeof(Dwarf_Unsigned);
}
break;
default:
return DW_DLV_ERROR;
};
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;
}
/* Given a form, and a pointer to the bytes encoding
a value of that form, val_ptr, this function returns
the length, in bytes, of a value of that form.
When using this function, check for a return of 0
a recursive DW_FORM_INDIRECT value. */
int
_dwarf_get_size_of_val(Dwarf_Debug dbg,
Dwarf_Unsigned form,
Dwarf_Half cu_version,
Dwarf_Half address_size,
Dwarf_Small * val_ptr,
int v_length_size,
Dwarf_Unsigned *size_out,
Dwarf_Error*error)
{
Dwarf_Unsigned length = 0;
Dwarf_Word leb128_length = 0;
Dwarf_Unsigned form_indirect = 0;
Dwarf_Unsigned ret_value = 0;
switch (form) {
/* When we encounter a FORM here that
we know about but forgot to enter here,
we had better not just continue.
Usually means we forgot to update this function
when implementing form handling of a new FORM.
Disaster results from using a bogus value,
so generate error. */
default:
_dwarf_error(dbg,error,DW_DLE_DEBUG_FORM_HANDLING_INCOMPLETE);
return DW_DLV_ERROR;
case 0: return 0;
case DW_FORM_GNU_ref_alt:
case DW_FORM_GNU_strp_alt:
case DW_FORM_strp_sup:
*size_out = v_length_size;
return DW_DLV_OK;
case DW_FORM_addr:
if (address_size) {
*size_out = address_size;
} else {
/* This should never happen, address_size should be set. */
*size_out = dbg->de_pointer_size;
}
return DW_DLV_OK;
case DW_FORM_ref_sig8:
*size_out = 8;
/* sizeof Dwarf_Sig8 */
return DW_DLV_OK;
/* DWARF2 was wrong on the size of the attribute for
DW_FORM_ref_addr. We assume compilers are using the
corrected DWARF3 text (for 32bit pointer target objects pointer and
offsets are the same size anyway).
It is clear (as of 2014) that for 64bit folks used
the V2 spec in the way V2 was
written, so the ref_addr has to account for that.*/
case DW_FORM_ref_addr:
if (cu_version == DW_CU_VERSION2) {
*size_out = address_size;
} else {
*size_out = v_length_size;
}
return DW_DLV_OK;
case DW_FORM_block1:
*size_out = *(Dwarf_Small *) val_ptr + 1;
return DW_DLV_OK;
case DW_FORM_block2:
READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
val_ptr, sizeof(Dwarf_Half));
*size_out = ret_value + sizeof(Dwarf_Half);
return DW_DLV_OK;
case DW_FORM_block4:
READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
val_ptr, sizeof(Dwarf_ufixed));
*size_out = ret_value + sizeof(Dwarf_ufixed);
return DW_DLV_OK;
case DW_FORM_data1:
*size_out = 1;
return DW_DLV_OK;
case DW_FORM_data2:
*size_out = 2;
return DW_DLV_OK;
case DW_FORM_data4:
*size_out = 4;
return DW_DLV_OK;
case DW_FORM_data8:
*size_out = 8;
return DW_DLV_OK;
case DW_FORM_string:
*size_out = strlen((char *) val_ptr) + 1;
return DW_DLV_OK;
case DW_FORM_block:
case DW_FORM_exprloc:
length = _dwarf_decode_u_leb128(val_ptr, &leb128_length);
*size_out = length + leb128_length;
return DW_DLV_OK;
case DW_FORM_flag_present:
*size_out = 0;
return DW_DLV_OK;
case DW_FORM_flag:
*size_out = 1;
return DW_DLV_OK;
case DW_FORM_sec_offset:
/* If 32bit dwarf, is 4. Else is 64bit dwarf and is 8. */
*size_out = v_length_size;
return DW_DLV_OK;
case DW_FORM_ref_udata:
/* Discard the decoded value, we just want the length
of the value. */
_dwarf_decode_u_leb128(val_ptr, &leb128_length);
*size_out = leb128_length;
return DW_DLV_OK;
case DW_FORM_indirect:
{
Dwarf_Word indir_len = 0;
int res = 0;
Dwarf_Unsigned real_form_len = 0;
form_indirect = _dwarf_decode_u_leb128(val_ptr, &indir_len);
if (form_indirect == DW_FORM_indirect) {
/* We are in big trouble: The true form
of DW_FORM_indirect is
DW_FORM_indirect? Nonsense. Should
never happen. */
_dwarf_error(dbg,error,DW_DLE_NESTED_FORM_INDIRECT_ERROR);
return DW_DLV_ERROR;
}
res = _dwarf_get_size_of_val(dbg,
form_indirect,
cu_version,
address_size,
val_ptr + indir_len,
v_length_size,
&real_form_len,
error);
if(res != DW_DLV_OK) {
return res;
}
*size_out = indir_len + real_form_len;
return DW_DLV_OK;
}
case DW_FORM_ref1:
*size_out = 1;
return DW_DLV_OK;
case DW_FORM_ref2:
*size_out = 2;
return DW_DLV_OK;
case DW_FORM_ref4:
*size_out = 4;
return DW_DLV_OK;
case DW_FORM_ref8:
*size_out = 8;
return DW_DLV_OK;
case DW_FORM_sdata:
/* Discard the decoded value, we just want the length
of the value. */
_dwarf_decode_s_leb128(val_ptr, &leb128_length);
*size_out = (leb128_length);
return DW_DLV_OK;
case DW_FORM_addrx:
case DW_FORM_GNU_addr_index:
case DW_FORM_strx:
case DW_FORM_GNU_str_index:
_dwarf_decode_u_leb128(val_ptr, &leb128_length);
*size_out = leb128_length;
return DW_DLV_OK;
case DW_FORM_strp:
*size_out = v_length_size;
return DW_DLV_OK;
case DW_FORM_udata:
/* Discard the decoded value, we just want the length
of the value. */
_dwarf_decode_u_leb128(val_ptr, &leb128_length);
*size_out = leb128_length;
return DW_DLV_OK;
}
}
/* Return DW_DLV_NO_ENTRY when at the end of
the ops for this block (a single Dwarf_Loccesc
and multiple Dwarf_Locs will eventually result
from calling this till DW_DLV_NO_ENTRY).
All op reader code should call this to
extract operator fields. For any
DWARF version.
*/
static int
_dwarf_read_loc_expr_op(Dwarf_Debug dbg,
Dwarf_Block_c * loc_block,
/* Caller: Start numbering at 0. */
Dwarf_Signed opnumber,
/* 2 for DWARF 2 etc. */
Dwarf_Half version_stamp,
Dwarf_Half offset_size, /* 4 or 8 */
Dwarf_Half address_size, /* 2,4, 8 */
Dwarf_Signed startoffset_in, /* offset in block,
not section offset */
/* nextoffset_out so caller knows next entry startoffset */
Dwarf_Unsigned *nextoffset_out,
/* The values picked up. */
Dwarf_Loc_c curr_loc,
Dwarf_Error * error)
{
Dwarf_Small *loc_ptr = 0;
Dwarf_Unsigned loc_len = 0;
Dwarf_Unsigned offset = startoffset_in;
Dwarf_Unsigned operand1 = 0;
Dwarf_Unsigned operand2 = 0;
Dwarf_Unsigned operand3 = 0;
Dwarf_Small atom = 0;
Dwarf_Word leb128_length = 0;
loc_len = loc_block->bl_len;
loc_ptr = loc_block->bl_data + offset;
if (offset == loc_len) {
return DW_DLV_NO_ENTRY;
}
memset(curr_loc,0,sizeof(*curr_loc));
curr_loc->lr_opnumber = opnumber;
curr_loc->lr_offset = offset;
atom = *(Dwarf_Small *) loc_ptr;
loc_ptr++;
offset++;
curr_loc->lr_atom = atom;
switch (atom) {
case DW_OP_reg0:
case DW_OP_reg1:
case DW_OP_reg2:
case DW_OP_reg3:
case DW_OP_reg4:
case DW_OP_reg5:
case DW_OP_reg6:
case DW_OP_reg7:
case DW_OP_reg8:
case DW_OP_reg9:
case DW_OP_reg10:
case DW_OP_reg11:
case DW_OP_reg12:
case DW_OP_reg13:
case DW_OP_reg14:
case DW_OP_reg15:
case DW_OP_reg16:
case DW_OP_reg17:
case DW_OP_reg18:
case DW_OP_reg19:
case DW_OP_reg20:
case DW_OP_reg21:
case DW_OP_reg22:
case DW_OP_reg23:
case DW_OP_reg24:
case DW_OP_reg25:
case DW_OP_reg26:
case DW_OP_reg27:
case DW_OP_reg28:
case DW_OP_reg29:
case DW_OP_reg30:
case DW_OP_reg31:
break;
case DW_OP_regx:
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_lit0:
case DW_OP_lit1:
case DW_OP_lit2:
case DW_OP_lit3:
case DW_OP_lit4:
case DW_OP_lit5:
case DW_OP_lit6:
case DW_OP_lit7:
case DW_OP_lit8:
case DW_OP_lit9:
case DW_OP_lit10:
case DW_OP_lit11:
case DW_OP_lit12:
case DW_OP_lit13:
case DW_OP_lit14:
case DW_OP_lit15:
case DW_OP_lit16:
case DW_OP_lit17:
case DW_OP_lit18:
case DW_OP_lit19:
case DW_OP_lit20:
case DW_OP_lit21:
case DW_OP_lit22:
case DW_OP_lit23:
case DW_OP_lit24:
case DW_OP_lit25:
case DW_OP_lit26:
case DW_OP_lit27:
case DW_OP_lit28:
case DW_OP_lit29:
case DW_OP_lit30:
case DW_OP_lit31:
operand1 = atom - DW_OP_lit0;
break;
case DW_OP_addr:
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned,
loc_ptr, address_size);
loc_ptr += address_size;
offset += address_size;
break;
case DW_OP_const1u:
operand1 = *(Dwarf_Small *) loc_ptr;
loc_ptr = loc_ptr + 1;
offset = offset + 1;
break;
case DW_OP_const1s:
operand1 = *(Dwarf_Sbyte *) loc_ptr;
SIGN_EXTEND(operand1,1);
loc_ptr = loc_ptr + 1;
offset = offset + 1;
break;
case DW_OP_const2u:
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 2);
loc_ptr = loc_ptr + 2;
offset = offset + 2;
break;
case DW_OP_const2s:
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 2);
SIGN_EXTEND(operand1,2);
loc_ptr = loc_ptr + 2;
offset = offset + 2;
break;
case DW_OP_const4u:
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 4);
loc_ptr = loc_ptr + 4;
offset = offset + 4;
break;
case DW_OP_const4s:
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 4);
SIGN_EXTEND(operand1,4);
loc_ptr = loc_ptr + 4;
offset = offset + 4;
break;
case DW_OP_const8u:
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 8);
loc_ptr = loc_ptr + 8;
offset = offset + 8;
break;
case DW_OP_const8s:
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 8);
loc_ptr = loc_ptr + 8;
offset = offset + 8;
break;
case DW_OP_constu:
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_consts:
operand1 = _dwarf_decode_s_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_fbreg:
operand1 = _dwarf_decode_s_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_breg0:
case DW_OP_breg1:
case DW_OP_breg2:
case DW_OP_breg3:
case DW_OP_breg4:
case DW_OP_breg5:
case DW_OP_breg6:
case DW_OP_breg7:
case DW_OP_breg8:
case DW_OP_breg9:
case DW_OP_breg10:
case DW_OP_breg11:
case DW_OP_breg12:
case DW_OP_breg13:
case DW_OP_breg14:
case DW_OP_breg15:
case DW_OP_breg16:
case DW_OP_breg17:
case DW_OP_breg18:
case DW_OP_breg19:
case DW_OP_breg20:
case DW_OP_breg21:
case DW_OP_breg22:
case DW_OP_breg23:
case DW_OP_breg24:
case DW_OP_breg25:
case DW_OP_breg26:
case DW_OP_breg27:
case DW_OP_breg28:
case DW_OP_breg29:
case DW_OP_breg30:
case DW_OP_breg31:
operand1 = _dwarf_decode_s_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_bregx:
/* uleb reg num followed by sleb offset */
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
operand2 = _dwarf_decode_s_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_dup:
case DW_OP_drop:
break;
case DW_OP_pick:
operand1 = *(Dwarf_Small *) loc_ptr;
loc_ptr = loc_ptr + 1;
offset = offset + 1;
break;
case DW_OP_over:
case DW_OP_swap:
case DW_OP_rot:
case DW_OP_deref:
break;
case DW_OP_deref_size:
operand1 = *(Dwarf_Small *) loc_ptr;
loc_ptr = loc_ptr + 1;
offset = offset + 1;
break;
case DW_OP_xderef:
break;
case DW_OP_xderef_type: /* DWARF5 */
operand1 = *(Dwarf_Small *) loc_ptr;
loc_ptr = loc_ptr + 1;
offset = offset + 1;
operand2 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_xderef_size:
operand1 = *(Dwarf_Small *) loc_ptr;
loc_ptr = loc_ptr + 1;
offset = offset + 1;
break;
case DW_OP_abs:
case DW_OP_and:
case DW_OP_div:
case DW_OP_minus:
case DW_OP_mod:
case DW_OP_mul:
case DW_OP_neg:
case DW_OP_not:
case DW_OP_or:
case DW_OP_plus:
break;
case DW_OP_plus_uconst:
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_shl:
case DW_OP_shr:
case DW_OP_shra:
case DW_OP_xor:
break;
case DW_OP_le:
case DW_OP_ge:
case DW_OP_eq:
case DW_OP_lt:
case DW_OP_gt:
case DW_OP_ne:
break;
case DW_OP_skip:
case DW_OP_bra:
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 2);
loc_ptr = loc_ptr + 2;
offset = offset + 2;
break;
case DW_OP_piece:
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_nop:
break;
case DW_OP_push_object_address: /* DWARF3 */
break;
case DW_OP_call2: /* DWARF3 */
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 2);
loc_ptr = loc_ptr + 2;
offset = offset + 2;
break;
case DW_OP_call4: /* DWARF3 */
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 4);
loc_ptr = loc_ptr + 4;
offset = offset + 4;
break;
case DW_OP_call_ref: /* DWARF3 */
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr,
offset_size);
loc_ptr = loc_ptr + offset_size;
offset = offset + offset_size;
break;
case DW_OP_form_tls_address: /* DWARF3f */
break;
case DW_OP_call_frame_cfa: /* DWARF3f */
break;
case DW_OP_bit_piece: /* DWARF3f */
/* uleb size in bits followed by uleb offset in bits */
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
operand2 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
/* The operator means: push the currently computed
(by the operations encountered so far in this
expression) onto the expression stack as the offset
in thread-local-storage of the variable. */
case DW_OP_GNU_push_tls_address: /* 0xe0 */
/* Believed to have no operands. */
/* Unimplemented in gdb 7.5.1 ? */
break;
case DW_OP_deref_type: /* DWARF5 */
case DW_OP_GNU_deref_type: /* 0xf6 */
operand1 = *(Dwarf_Small *) loc_ptr;
loc_ptr = loc_ptr + 1;
offset = offset + 1;
/* die offset (uleb128). */
operand2 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_implicit_value: /* DWARF4 0xa0 */
/* uleb length of value bytes followed by that
number of bytes of the value. */
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
/* Second operand is block of 'operand1' bytes of stuff. */
/* This using the second operand as a pointer
is quite ugly. */
/* This gets an ugly compiler warning. Sorry. */
operand2 = (Dwarf_Unsigned)loc_ptr;
offset = offset + operand1;
loc_ptr = loc_ptr + operand1;
break;
case DW_OP_stack_value: /* DWARF4 */
break;
case DW_OP_GNU_uninit: /* 0xf0 */
/* Unimplemented in gdb 7.5.1 */
/* Carolyn Tice: Follws a DW_OP_reg or DW_OP_regx
and marks the reg as being uninitialized. */
break;
case DW_OP_GNU_encoded_addr: { /* 0xf1 */
/* Richard Henderson: The operand is an absolute
address. The first byte of the value
is an encoding length: 0 2 4 or 8. If zero
it means the following is address-size.
The address then follows immediately for
that number of bytes. */
int length = 0;
int reares = read_encoded_addr(loc_ptr,dbg,&operand1,
&length,error);
if (reares != DW_DLV_OK) {
return reares;
}
loc_ptr += length;
offset += length;
}
break;
case DW_OP_implicit_pointer: /* DWARF5 */
case DW_OP_GNU_implicit_pointer:{ /* 0xf2 */
/* Jakub Jelinek: The value is an optimized-out
pointer value. Represented as
an offset_size DIE offset
(a simple unsigned integer) in DWARF3,4
followed by a signed leb128 offset.
For DWARF2, it is actually pointer size
(address size).
http://www.dwarfstd.org/ShowIssue.php?issue=100831.1 */
Dwarf_Small iplen = offset_size;
if (version_stamp == DW_CU_VERSION2 /* 2 */ ) {
iplen = address_size;
}
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr,
iplen);
loc_ptr = loc_ptr + iplen;
offset = offset + iplen;
operand2 = _dwarf_decode_s_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
}
break;
case DW_OP_entry_value: /* DWARF5 */
case DW_OP_GNU_entry_value: /* 0xf3 */
/* Jakub Jelinek: A register reused really soon,
but the value is unchanged. So to represent
that value we have a uleb128 size followed
by a DWARF expression block that size.
http://www.dwarfstd.org/ShowIssue.php?issue=100909.1 */
/* uleb length of value bytes followed by that
number of bytes of the value. */
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
/* Second operand is block of 'operand1' bytes of stuff. */
/* This using the second operand as a pointer
is quite ugly. */
/* This gets an ugly compiler warning. Sorry. */
operand2 = (Dwarf_Unsigned)loc_ptr;
offset = offset + operand1;
loc_ptr = loc_ptr + operand1;
break;
case DW_OP_const_type: /* DWARF5 */
case DW_OP_GNU_const_type: /* 0xf4 */
{
/* die offset as uleb. */
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
/* Next byte is size of following data block. */
operand2 = *loc_ptr;
loc_ptr = loc_ptr + 1;
offset = offset + 1;
/* Operand 3 points to a value in the block of size
just gotten as operand2. */
/* This gets an ugly compiler warning. Sorry. */
operand3 = (Dwarf_Unsigned) loc_ptr;
loc_ptr = loc_ptr + operand2;
offset = offset + operand2;
}
break;
case DW_OP_regval_type: /* DWARF5 */
case DW_OP_GNU_regval_type: /* 0xf5 */
/* reg num uleb*/
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
/* cu die off uleb*/
operand2 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_convert: /* DWARF5 */
case DW_OP_GNU_convert: /* 0xf7 */
case DW_OP_reinterpret: /* DWARF5 */
case DW_OP_GNU_reinterpret: /* 0xf9 */
/* die offset or zero */
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_GNU_parameter_ref : /* 0xfa */
/* 4 byte unsigned int */
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 4);
loc_ptr = loc_ptr + 4;
offset = offset + 4;
break;
case DW_OP_addrx : /* DWARF5 */
case DW_OP_GNU_addr_index : /* 0xfb DebugFission */
/* Index into .debug_addr. The value in .debug_addr
is an address. */
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_constx : /* DWARF5 */
case DW_OP_GNU_const_index : /* 0xfc DebugFission */
/* Index into .debug_addr. The value in .debug_addr
is a constant that fits in an address. */
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
default:
_dwarf_error(dbg, error, DW_DLE_LOC_EXPR_BAD);
return DW_DLV_ERROR;
}
/* If offset == loc_len this would be normal end-of-expression. */
if (offset > loc_len) {
/* We stepped past the end of the expression.
This has to be a compiler bug.
Operators missing their values cannot be detected
as such except at the end of an expression (like this).
The results would be wrong if returned.
*/
_dwarf_error(dbg, error, DW_DLE_LOC_BAD_TERMINATION);
return DW_DLV_ERROR;
}
curr_loc->lr_atom = atom;
curr_loc->lr_number = operand1;
curr_loc->lr_number2 = operand2;
curr_loc->lr_number3 = operand3;
*nextoffset_out = offset;
return DW_DLV_OK;
}
/*
Given a Dwarf_Block that represents a location expression,
this function returns a pointer to a Dwarf_Locdesc struct
that has its ld_cents field set to the number of location
operators in the block, and its ld_s field pointing to a
contiguous block of Dwarf_Loc structs. However, the
ld_lopc and ld_hipc values are uninitialized. Returns
NULL on error. This function assumes that the length of
the block is greater than 0. Zero length location expressions
to represent variables that have been optimized away are
handled in the calling function.
*/
static Dwarf_Locdesc *
_dwarf_get_locdesc(Dwarf_Debug dbg,
Dwarf_Block * loc_block,
Dwarf_Half address_size,
Dwarf_Addr lowpc,
Dwarf_Addr highpc,
Dwarf_Error * error)
{
/* Size of the block containing the location expression. */
Dwarf_Unsigned loc_len = 0;
/* Sweeps the block containing the location expression. */
Dwarf_Small *loc_ptr = 0;
/* Current location operator. */
Dwarf_Small atom = 0;
/* Offset of current operator from start of block. */
Dwarf_Unsigned offset = 0;
/* Operands of current location operator. */
Dwarf_Unsigned operand1, operand2;
/* Used to chain the Dwarf_Loc_Chain_s structs. */
Dwarf_Loc_Chain curr_loc = NULL;
Dwarf_Loc_Chain prev_loc = NULL;
Dwarf_Loc_Chain head_loc = NULL;
/* Count of the number of location operators. */
Dwarf_Unsigned op_count = 0;
/* Contiguous block of Dwarf_Loc's for Dwarf_Locdesc. */
Dwarf_Loc *block_loc = 0;
/* Dwarf_Locdesc pointer to be returned. */
Dwarf_Locdesc *locdesc = 0;
Dwarf_Word leb128_length = 0;
Dwarf_Unsigned i = 0;
/* ***** BEGIN CODE ***** */
loc_len = loc_block->bl_len;
loc_ptr = loc_block->bl_data;
offset = 0;
op_count = 0;
while (offset < loc_len) {
operand1 = 0;
operand2 = 0;
op_count++;
atom = *(Dwarf_Small *) loc_ptr;
loc_ptr++;
offset++;
curr_loc =
(Dwarf_Loc_Chain) _dwarf_get_alloc(dbg, DW_DLA_LOC_CHAIN,
1);
if (curr_loc == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (NULL);
}
curr_loc->lc_offset = offset;
curr_loc->lc_atom = atom;
switch (atom) {
case DW_OP_reg0:
case DW_OP_reg1:
case DW_OP_reg2:
case DW_OP_reg3:
case DW_OP_reg4:
case DW_OP_reg5:
case DW_OP_reg6:
case DW_OP_reg7:
case DW_OP_reg8:
case DW_OP_reg9:
case DW_OP_reg10:
case DW_OP_reg11:
case DW_OP_reg12:
case DW_OP_reg13:
case DW_OP_reg14:
case DW_OP_reg15:
case DW_OP_reg16:
case DW_OP_reg17:
case DW_OP_reg18:
case DW_OP_reg19:
case DW_OP_reg20:
case DW_OP_reg21:
case DW_OP_reg22:
case DW_OP_reg23:
case DW_OP_reg24:
case DW_OP_reg25:
case DW_OP_reg26:
case DW_OP_reg27:
case DW_OP_reg28:
case DW_OP_reg29:
case DW_OP_reg30:
case DW_OP_reg31:
break;
case DW_OP_regx:
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_lit0:
case DW_OP_lit1:
case DW_OP_lit2:
case DW_OP_lit3:
case DW_OP_lit4:
case DW_OP_lit5:
case DW_OP_lit6:
case DW_OP_lit7:
case DW_OP_lit8:
case DW_OP_lit9:
case DW_OP_lit10:
case DW_OP_lit11:
case DW_OP_lit12:
case DW_OP_lit13:
case DW_OP_lit14:
case DW_OP_lit15:
case DW_OP_lit16:
case DW_OP_lit17:
case DW_OP_lit18:
case DW_OP_lit19:
case DW_OP_lit20:
case DW_OP_lit21:
case DW_OP_lit22:
case DW_OP_lit23:
case DW_OP_lit24:
case DW_OP_lit25:
case DW_OP_lit26:
case DW_OP_lit27:
case DW_OP_lit28:
case DW_OP_lit29:
case DW_OP_lit30:
case DW_OP_lit31:
operand1 = atom - DW_OP_lit0;
break;
case DW_OP_addr:
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned,
loc_ptr, address_size);
loc_ptr += address_size;
offset += address_size;
break;
case DW_OP_const1u:
operand1 = *(Dwarf_Small *) loc_ptr;
loc_ptr = loc_ptr + 1;
offset = offset + 1;
break;
case DW_OP_const1s:
operand1 = *(Dwarf_Sbyte *) loc_ptr;
SIGN_EXTEND(operand1,1);
loc_ptr = loc_ptr + 1;
offset = offset + 1;
break;
case DW_OP_const2u:
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 2);
loc_ptr = loc_ptr + 2;
offset = offset + 2;
break;
case DW_OP_const2s:
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 2);
SIGN_EXTEND(operand1,2);
loc_ptr = loc_ptr + 2;
offset = offset + 2;
break;
case DW_OP_const4u:
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 4);
loc_ptr = loc_ptr + 4;
offset = offset + 4;
break;
case DW_OP_const4s:
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 4);
SIGN_EXTEND(operand1,4);
loc_ptr = loc_ptr + 4;
offset = offset + 4;
break;
case DW_OP_const8u:
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 8);
loc_ptr = loc_ptr + 8;
offset = offset + 8;
break;
case DW_OP_const8s:
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 8);
loc_ptr = loc_ptr + 8;
offset = offset + 8;
break;
case DW_OP_constu:
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_consts:
operand1 = _dwarf_decode_s_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_fbreg:
operand1 = _dwarf_decode_s_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_breg0:
case DW_OP_breg1:
case DW_OP_breg2:
case DW_OP_breg3:
case DW_OP_breg4:
case DW_OP_breg5:
case DW_OP_breg6:
case DW_OP_breg7:
case DW_OP_breg8:
case DW_OP_breg9:
case DW_OP_breg10:
case DW_OP_breg11:
case DW_OP_breg12:
case DW_OP_breg13:
case DW_OP_breg14:
case DW_OP_breg15:
case DW_OP_breg16:
case DW_OP_breg17:
case DW_OP_breg18:
case DW_OP_breg19:
case DW_OP_breg20:
case DW_OP_breg21:
case DW_OP_breg22:
case DW_OP_breg23:
case DW_OP_breg24:
case DW_OP_breg25:
case DW_OP_breg26:
case DW_OP_breg27:
case DW_OP_breg28:
case DW_OP_breg29:
case DW_OP_breg30:
case DW_OP_breg31:
operand1 = _dwarf_decode_s_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_bregx:
/* uleb reg num followed by sleb offset */
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
operand2 = _dwarf_decode_s_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_dup:
case DW_OP_drop:
break;
case DW_OP_pick:
operand1 = *(Dwarf_Small *) loc_ptr;
loc_ptr = loc_ptr + 1;
offset = offset + 1;
break;
case DW_OP_over:
case DW_OP_swap:
case DW_OP_rot:
case DW_OP_deref:
break;
case DW_OP_deref_size:
operand1 = *(Dwarf_Small *) loc_ptr;
loc_ptr = loc_ptr + 1;
offset = offset + 1;
break;
case DW_OP_xderef:
break;
case DW_OP_xderef_size:
operand1 = *(Dwarf_Small *) loc_ptr;
loc_ptr = loc_ptr + 1;
offset = offset + 1;
break;
case DW_OP_abs:
case DW_OP_and:
case DW_OP_div:
case DW_OP_minus:
case DW_OP_mod:
case DW_OP_mul:
case DW_OP_neg:
case DW_OP_not:
case DW_OP_or:
case DW_OP_plus:
break;
case DW_OP_plus_uconst:
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_shl:
case DW_OP_shr:
case DW_OP_shra:
case DW_OP_xor:
break;
case DW_OP_le:
case DW_OP_ge:
case DW_OP_eq:
case DW_OP_lt:
case DW_OP_gt:
case DW_OP_ne:
break;
case DW_OP_skip:
case DW_OP_bra:
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 2);
loc_ptr = loc_ptr + 2;
offset = offset + 2;
break;
case DW_OP_piece:
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_nop:
break;
case DW_OP_push_object_address: /* DWARF3 */
break;
case DW_OP_call2: /* DWARF3 */
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 2);
loc_ptr = loc_ptr + 2;
offset = offset + 2;
break;
case DW_OP_call4: /* DWARF3 */
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 4);
loc_ptr = loc_ptr + 4;
offset = offset + 4;
break;
case DW_OP_call_ref: /* DWARF3 */
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr,
dbg->de_length_size);
loc_ptr = loc_ptr + dbg->de_length_size;
offset = offset + dbg->de_length_size;
break;
case DW_OP_form_tls_address: /* DWARF3f */
break;
case DW_OP_call_frame_cfa: /* DWARF3f */
break;
case DW_OP_bit_piece: /* DWARF3f */
/* uleb size in bits followed by uleb offset in bits */
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
operand2 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_implicit_value: /* DWARF4 */
/* uleb length of value bytes followed by that
number of bytes of the value. */
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
/* Second operand is block of 'operand1' bytes of stuff. */
/* This using the second operand as a pointer
is quite ugly. */
/* This gets an ugly compiler warning. Sorry. */
operand2 = (Dwarf_Unsigned)(uintptr_t)loc_ptr;
offset = offset + operand1;
loc_ptr = loc_ptr + operand1;
break;
case DW_OP_stack_value: /* DWARF4 */
break;
default:
_dwarf_error(dbg, error, DW_DLE_LOC_EXPR_BAD);
return (NULL);
}
curr_loc->lc_number = operand1;
curr_loc->lc_number2 = operand2;
if (head_loc == NULL)
head_loc = prev_loc = curr_loc;
else {
prev_loc->lc_next = curr_loc;
prev_loc = curr_loc;
}
}
block_loc =
(Dwarf_Loc *) _dwarf_get_alloc(dbg, DW_DLA_LOC_BLOCK, op_count);
if (block_loc == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (NULL);
}
curr_loc = head_loc;
for (i = 0; i < op_count; i++) {
(block_loc + i)->lr_atom = curr_loc->lc_atom;
(block_loc + i)->lr_number = curr_loc->lc_number;
(block_loc + i)->lr_number2 = curr_loc->lc_number2;
(block_loc + i)->lr_offset = curr_loc->lc_offset;
prev_loc = curr_loc;
curr_loc = curr_loc->lc_next;
dwarf_dealloc(dbg, prev_loc, DW_DLA_LOC_CHAIN);
}
locdesc =
(Dwarf_Locdesc *) _dwarf_get_alloc(dbg, DW_DLA_LOCDESC, 1);
if (locdesc == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (NULL);
}
locdesc->ld_cents = op_count;
locdesc->ld_s = block_loc;
locdesc->ld_from_loclist = loc_block->bl_from_loclist;
locdesc->ld_section_offset = loc_block->bl_section_offset;
locdesc->ld_lopc = lowpc;
locdesc->ld_hipc = highpc;
return (locdesc);
}
static int
_dwarf_skim_forms(Dwarf_Debug dbg,
Dwarf_Macro_Context mcontext,
Dwarf_Small *mdata_start,
unsigned formcount,
const Dwarf_Small *forms,
Dwarf_Small *section_end,
Dwarf_Unsigned *forms_length,
Dwarf_Error *error)
{
unsigned i = 0;
Dwarf_Small curform = 0 ;
Dwarf_Unsigned totallen = 0;
Dwarf_Unsigned v = 0;
Dwarf_Unsigned ret_value = 0;
Dwarf_Unsigned length;
Dwarf_Small *mdata = mdata_start;
Dwarf_Word leb128_length = 0;
for( ; i < formcount; ++i) {
curform = forms[i];
if (mdata >= section_end) {
_dwarf_error(dbg, error, DW_DLE_MACRO_OFFSET_BAD);
return DW_DLV_ERROR;
}
switch(curform) {
default:
_dwarf_error(dbg,error,DW_DLE_DEBUG_FORM_HANDLING_INCOMPLETE);
return DW_DLV_ERROR;
case DW_FORM_block1:
v = *(Dwarf_Small *) mdata;
totallen += v+1;
mdata += v+1;
break;
case DW_FORM_block2:
READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
mdata, sizeof(Dwarf_Half));
v = ret_value + sizeof(Dwarf_Half);
totallen += v;
mdata += v;
break;
case DW_FORM_block4:
READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
mdata, sizeof(Dwarf_ufixed));
v = ret_value + sizeof(Dwarf_ufixed);
totallen += v;
mdata += v;
break;
case DW_FORM_data1:
v = 1;
totallen += v;
mdata += v;
break;
case DW_FORM_data2:
v = 2;
totallen += v;
mdata += v;
break;
case DW_FORM_data4:
v = 4;
totallen += v;
mdata += v;
break;
case DW_FORM_data8:
v = 8;
totallen += v;
mdata += v;
break;
case DW_FORM_data16:
v = 8;
totallen += v;
mdata += v;
break;
case DW_FORM_string:
v = strlen((char *) mdata) + 1;
totallen += v;
mdata += v;
break;
case DW_FORM_block:
length = _dwarf_decode_u_leb128(mdata, &leb128_length);
v = length + leb128_length;
totallen += v;
mdata += v;
break;
case DW_FORM_flag:
v = 1;
totallen += v;
mdata += v;
break;
case DW_FORM_sec_offset:
/* If 32bit dwarf, is 4. Else is 64bit dwarf and is 8. */
v = mcontext->mc_offset_size;
totallen += v;
mdata += v;
break;
case DW_FORM_sdata:
/* Discard the decoded value, we just want the length
of the value. */
_dwarf_decode_s_leb128(mdata, &leb128_length);
v = leb128_length;
mdata += v;
totallen += v;
break;
case DW_FORM_strx:
_dwarf_decode_u_leb128(mdata, &leb128_length);
v = leb128_length;
mdata += v;
totallen += v;
break;
case DW_FORM_strp:
v = mcontext->mc_offset_size;
mdata += v;
totallen += v;
break;
case DW_FORM_udata:
/* Discard the decoded value, we just want the length
of the value. */
_dwarf_decode_u_leb128(mdata, &leb128_length);
v = leb128_length;
mdata += v;
totallen += v;
break;
}
}
if (mdata > section_end) {
_dwarf_error(dbg, error, DW_DLE_MACRO_OFFSET_BAD);
return DW_DLV_ERROR;
}
*forms_length = totallen;
return DW_DLV_OK;
}
/*
Given a form, and a pointer to the bytes encoding
a value of that form, val_ptr, this function returns
the length, in bytes, of a value of that form.
When using this function, check for a return of 0
a recursive DW_FORM_INDIRECT value.
*/
Dwarf_Unsigned
_dwarf_get_size_of_val(Dwarf_Debug dbg,
Dwarf_Unsigned form,
Dwarf_Half address_size,
Dwarf_Small * val_ptr, int v_length_size)
{
Dwarf_Unsigned length = 0;
Dwarf_Word leb128_length = 0;
Dwarf_Unsigned form_indirect = 0;
Dwarf_Unsigned ret_value = 0;
switch (form) {
default: /* Handles form = 0. */
return (form);
case DW_FORM_addr:
return (dbg->de_pointer_size);
/* DWARF2 was wrong on the size of the attribute for
DW_FORM_ref_addr. We assume compilers are using the
corrected DWARF3 text (for 32bit pointer target objects pointer and
offsets are the same size anyway). */
case DW_FORM_ref_addr:
return (v_length_size);
case DW_FORM_block1:
return (*(Dwarf_Small *) val_ptr + 1);
case DW_FORM_block2:
READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
val_ptr, sizeof(Dwarf_Half));
return (ret_value + sizeof(Dwarf_Half));
case DW_FORM_block4:
READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
val_ptr, sizeof(Dwarf_ufixed));
return (ret_value + sizeof(Dwarf_ufixed));
case DW_FORM_data1:
return (1);
case DW_FORM_data2:
return (2);
case DW_FORM_data4:
return (4);
case DW_FORM_data8:
return (8);
case DW_FORM_string:
return (strlen((char *) val_ptr) + 1);
case DW_FORM_block:
length = _dwarf_decode_u_leb128(val_ptr, &leb128_length);
return (length + leb128_length);
case DW_FORM_flag:
return (1);
case DW_FORM_ref_udata:
_dwarf_decode_u_leb128(val_ptr, &leb128_length);
return (leb128_length);
case DW_FORM_indirect:
{
Dwarf_Word indir_len = 0;
form_indirect = _dwarf_decode_u_leb128(val_ptr, &indir_len);
if (form_indirect == DW_FORM_indirect) {
return (0); /* We are in big trouble: The true form
of DW_FORM_indirect is
DW_FORM_indirect? Nonsense. Should
never happen. */
}
return (indir_len + _dwarf_get_size_of_val(dbg,
form_indirect,
address_size,
val_ptr + indir_len,
v_length_size));
}
case DW_FORM_ref1:
return (1);
case DW_FORM_ref2:
return (2);
case DW_FORM_ref4:
return (4);
case DW_FORM_ref8:
return (8);
case DW_FORM_sdata:
_dwarf_decode_s_leb128(val_ptr, &leb128_length);
return (leb128_length);
case DW_FORM_strp:
return (v_length_size);
case DW_FORM_udata:
_dwarf_decode_u_leb128(val_ptr, &leb128_length);
return (leb128_length);
}
}
/* Given a Dwarf_Block that represents a location expression,
this function returns a pointer to a Dwarf_Locdesc struct
that has its ld_cents field set to the number of location
operators in the block, and its ld_s field pointing to a
contiguous block of Dwarf_Loc structs. However, the
ld_lopc and ld_hipc values are uninitialized. Returns
NULL on error. This function assumes that the length of
the block is greater than 0. Zero length location expressions
to represent variables that have been optimized away are
handled in the calling function.
*/
static Dwarf_Locdesc *
_dwarf_get_locdesc(Dwarf_Debug dbg,
Dwarf_Block * loc_block,
Dwarf_Half address_size,
Dwarf_Addr lowpc,
Dwarf_Addr highpc,
Dwarf_Error * error)
{
/* Size of the block containing the location expression. */
Dwarf_Unsigned loc_len = 0;
/* Sweeps the block containing the location expression. */
Dwarf_Small *loc_ptr = 0;
/* Offset of current operator from start of block. */
Dwarf_Unsigned offset = 0;
/* Used to chain the Dwarf_Loc_Chain_s structs. */
Dwarf_Loc_Chain curr_loc = NULL;
Dwarf_Loc_Chain prev_loc = NULL;
Dwarf_Loc_Chain head_loc = NULL;
/* Count of the number of location operators. */
Dwarf_Unsigned op_count = 0;
/* Contiguous block of Dwarf_Loc's for Dwarf_Locdesc. */
Dwarf_Loc *block_loc = 0;
/* Dwarf_Locdesc pointer to be returned. */
Dwarf_Locdesc *locdesc = 0;
Dwarf_Word leb128_length = 0;
Dwarf_Unsigned i = 0;
/* ***** BEGIN CODE ***** */
loc_len = loc_block->bl_len;
loc_ptr = loc_block->bl_data;
offset = 0;
op_count = 0;
while (offset < loc_len) {
Dwarf_Unsigned operand1 = 0;
Dwarf_Unsigned operand2 = 0;
Dwarf_Small atom = 0;
op_count++;
atom = *(Dwarf_Small *) loc_ptr;
loc_ptr++;
offset++;
curr_loc =
(Dwarf_Loc_Chain) _dwarf_get_alloc(dbg, DW_DLA_LOC_CHAIN,
1);
if (curr_loc == NULL) {
/* Some memory may leak here. */
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (NULL);
}
curr_loc->lc_offset = offset;
curr_loc->lc_atom = atom;
switch (atom) {
case DW_OP_reg0:
case DW_OP_reg1:
case DW_OP_reg2:
case DW_OP_reg3:
case DW_OP_reg4:
case DW_OP_reg5:
case DW_OP_reg6:
case DW_OP_reg7:
case DW_OP_reg8:
case DW_OP_reg9:
case DW_OP_reg10:
case DW_OP_reg11:
case DW_OP_reg12:
case DW_OP_reg13:
case DW_OP_reg14:
case DW_OP_reg15:
case DW_OP_reg16:
case DW_OP_reg17:
case DW_OP_reg18:
case DW_OP_reg19:
case DW_OP_reg20:
case DW_OP_reg21:
case DW_OP_reg22:
case DW_OP_reg23:
case DW_OP_reg24:
case DW_OP_reg25:
case DW_OP_reg26:
case DW_OP_reg27:
case DW_OP_reg28:
case DW_OP_reg29:
case DW_OP_reg30:
case DW_OP_reg31:
break;
case DW_OP_regx:
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_lit0:
case DW_OP_lit1:
case DW_OP_lit2:
case DW_OP_lit3:
case DW_OP_lit4:
case DW_OP_lit5:
case DW_OP_lit6:
case DW_OP_lit7:
case DW_OP_lit8:
case DW_OP_lit9:
case DW_OP_lit10:
case DW_OP_lit11:
case DW_OP_lit12:
case DW_OP_lit13:
case DW_OP_lit14:
case DW_OP_lit15:
case DW_OP_lit16:
case DW_OP_lit17:
case DW_OP_lit18:
case DW_OP_lit19:
case DW_OP_lit20:
case DW_OP_lit21:
case DW_OP_lit22:
case DW_OP_lit23:
case DW_OP_lit24:
case DW_OP_lit25:
case DW_OP_lit26:
case DW_OP_lit27:
case DW_OP_lit28:
case DW_OP_lit29:
case DW_OP_lit30:
case DW_OP_lit31:
operand1 = atom - DW_OP_lit0;
break;
case DW_OP_addr:
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned,
loc_ptr, address_size);
loc_ptr += address_size;
offset += address_size;
break;
case DW_OP_const1u:
operand1 = *(Dwarf_Small *) loc_ptr;
loc_ptr = loc_ptr + 1;
offset = offset + 1;
break;
case DW_OP_const1s:
operand1 = *(Dwarf_Sbyte *) loc_ptr;
SIGN_EXTEND(operand1,1);
loc_ptr = loc_ptr + 1;
offset = offset + 1;
break;
case DW_OP_const2u:
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 2);
loc_ptr = loc_ptr + 2;
offset = offset + 2;
break;
case DW_OP_const2s:
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 2);
SIGN_EXTEND(operand1,2);
loc_ptr = loc_ptr + 2;
offset = offset + 2;
break;
case DW_OP_const4u:
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 4);
loc_ptr = loc_ptr + 4;
offset = offset + 4;
break;
case DW_OP_const4s:
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 4);
SIGN_EXTEND(operand1,4);
loc_ptr = loc_ptr + 4;
offset = offset + 4;
break;
case DW_OP_const8u:
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 8);
loc_ptr = loc_ptr + 8;
offset = offset + 8;
break;
case DW_OP_const8s:
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 8);
loc_ptr = loc_ptr + 8;
offset = offset + 8;
break;
case DW_OP_constu:
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_consts:
operand1 = _dwarf_decode_s_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_fbreg:
operand1 = _dwarf_decode_s_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_breg0:
case DW_OP_breg1:
case DW_OP_breg2:
case DW_OP_breg3:
case DW_OP_breg4:
case DW_OP_breg5:
case DW_OP_breg6:
case DW_OP_breg7:
case DW_OP_breg8:
case DW_OP_breg9:
case DW_OP_breg10:
case DW_OP_breg11:
case DW_OP_breg12:
case DW_OP_breg13:
case DW_OP_breg14:
case DW_OP_breg15:
case DW_OP_breg16:
case DW_OP_breg17:
case DW_OP_breg18:
case DW_OP_breg19:
case DW_OP_breg20:
case DW_OP_breg21:
case DW_OP_breg22:
case DW_OP_breg23:
case DW_OP_breg24:
case DW_OP_breg25:
case DW_OP_breg26:
case DW_OP_breg27:
case DW_OP_breg28:
case DW_OP_breg29:
case DW_OP_breg30:
case DW_OP_breg31:
operand1 = _dwarf_decode_s_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_bregx:
/* uleb reg num followed by sleb offset */
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
operand2 = _dwarf_decode_s_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_dup:
case DW_OP_drop:
break;
case DW_OP_pick:
operand1 = *(Dwarf_Small *) loc_ptr;
loc_ptr = loc_ptr + 1;
offset = offset + 1;
break;
case DW_OP_over:
case DW_OP_swap:
case DW_OP_rot:
case DW_OP_deref:
break;
case DW_OP_deref_size:
operand1 = *(Dwarf_Small *) loc_ptr;
loc_ptr = loc_ptr + 1;
offset = offset + 1;
break;
case DW_OP_xderef:
break;
case DW_OP_xderef_size:
operand1 = *(Dwarf_Small *) loc_ptr;
loc_ptr = loc_ptr + 1;
offset = offset + 1;
break;
case DW_OP_abs:
case DW_OP_and:
case DW_OP_div:
case DW_OP_minus:
case DW_OP_mod:
case DW_OP_mul:
case DW_OP_neg:
case DW_OP_not:
case DW_OP_or:
case DW_OP_plus:
break;
case DW_OP_plus_uconst:
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_shl:
case DW_OP_shr:
case DW_OP_shra:
case DW_OP_xor:
break;
case DW_OP_le:
case DW_OP_ge:
case DW_OP_eq:
case DW_OP_lt:
case DW_OP_gt:
case DW_OP_ne:
break;
case DW_OP_skip:
case DW_OP_bra:
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 2);
loc_ptr = loc_ptr + 2;
offset = offset + 2;
break;
case DW_OP_piece:
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_nop:
break;
case DW_OP_push_object_address: /* DWARF3 */
break;
case DW_OP_call2: /* DWARF3 */
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 2);
loc_ptr = loc_ptr + 2;
offset = offset + 2;
break;
case DW_OP_call4: /* DWARF3 */
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr, 4);
loc_ptr = loc_ptr + 4;
offset = offset + 4;
break;
case DW_OP_call_ref: /* DWARF3 */
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr,
dbg->de_length_size);
loc_ptr = loc_ptr + dbg->de_length_size;
offset = offset + dbg->de_length_size;
break;
case DW_OP_form_tls_address: /* DWARF3f */
break;
case DW_OP_call_frame_cfa: /* DWARF3f */
break;
case DW_OP_bit_piece: /* DWARF3f */
/* uleb size in bits followed by uleb offset in bits */
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
operand2 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
/* The operator means: push the currently computed
(by the operations encountered so far in this
expression) onto the expression stack as the offset
in thread-local-storage of the variable. */
case DW_OP_GNU_push_tls_address:
break;
case DW_OP_implicit_value: /* DWARF4 */
/* uleb length of value bytes followed by that
number of bytes of the value. */
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
/* Second operand is block of 'operand1' bytes of stuff. */
/* This using the second operand as a pointer
is quite ugly. */
/* This gets an ugly compiler warning. Sorry. */
operand2 = (Dwarf_Unsigned)loc_ptr;
offset = offset + operand1;
loc_ptr = loc_ptr + operand1;
break;
case DW_OP_stack_value: /* DWARF4 */
break;
case DW_OP_GNU_uninit: /* 0xf0 GNU */
/* Carolyn Tice: Follws a DW_OP_reg or DW_OP_regx
and marks the reg as being uninitialized. */
break;
case DW_OP_GNU_encoded_addr: { /* 0xf1 GNU */
/* Richard Henderson: The operand is an absolute
address. The first byte of the value
is an encoding length: 0 2 4 or 8. If zero
it means the following is address-size.
The address then follows immediately for
that number of bytes. */
int length = 0;
int reares = read_encoded_addr(loc_ptr,dbg,&operand1,
&length,error);
if(reares != DW_DLV_OK) {
/* Oops. The caller will notice and
will issue DW_DLV_ERROR. */
return NULL;
}
loc_ptr += length;
offset += length;
}
break;
case DW_OP_GNU_implicit_pointer: /* 0xf2 GNU */
/* Jakub Jelinek: The value is an optimized-out
pointer value. Represented as
an offset_size (address_size) DIE offset
(as simple unsigned integer) followed by
a signed leb128 offset.
http://www.dwarfstd.org/ShowIssue.php?issue=100831.1 */
READ_UNALIGNED(dbg, operand1, Dwarf_Unsigned, loc_ptr,
dbg->de_length_size);
loc_ptr = loc_ptr + dbg->de_length_size;
offset = offset + dbg->de_length_size;
operand2 = _dwarf_decode_s_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
break;
case DW_OP_GNU_entry_value: /* 0xf3 GNU */
/* Jakub Jelinek: A register reused really soon,
but the value is unchanged. So to represent
that value we have a uleb128 size followed
by a DWARF expression block that size.
http://www.dwarfstd.org/ShowIssue.php?issue=100909.1 */
/* uleb length of value bytes followed by that
number of bytes of the value. */
operand1 = _dwarf_decode_u_leb128(loc_ptr, &leb128_length);
loc_ptr = loc_ptr + leb128_length;
offset = offset + leb128_length;
/* Second operand is block of 'operand1' bytes of stuff. */
/* This using the second operand as a pointer
is quite ugly. */
/* This gets an ugly compiler warning. Sorry. */
operand2 = (Dwarf_Unsigned)loc_ptr;
offset = offset + operand1;
loc_ptr = loc_ptr + operand1;
break;
default:
/* Some memory does leak here. */
_dwarf_error(dbg, error, DW_DLE_LOC_EXPR_BAD);
return (NULL);
}
/* If offset == loc_len this would be normal end-of-expression. */
if (offset > loc_len) {
/* We stepped past the end of the expression.
This has to be a compiler bug.
Operators missing their values cannot be detected
as such except at the end of an expression (like this).
The results would be wrong if returned.
Some memory may leak here.
*/
_dwarf_error(dbg, error, DW_DLE_LOC_BAD_TERMINATION);
return (NULL);
}
curr_loc->lc_number = operand1;
curr_loc->lc_number2 = operand2;
if (head_loc == NULL)
head_loc = prev_loc = curr_loc;
else {
prev_loc->lc_next = curr_loc;
prev_loc = curr_loc;
}
}
block_loc =
(Dwarf_Loc *) _dwarf_get_alloc(dbg, DW_DLA_LOC_BLOCK, op_count);
if (block_loc == NULL) {
/* Some memory does leak here. */
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (NULL);
}
curr_loc = head_loc;
for (i = 0; i < op_count; i++) {
(block_loc + i)->lr_atom = curr_loc->lc_atom;
(block_loc + i)->lr_number = curr_loc->lc_number;
(block_loc + i)->lr_number2 = curr_loc->lc_number2;
(block_loc + i)->lr_offset = curr_loc->lc_offset;
prev_loc = curr_loc;
curr_loc = curr_loc->lc_next;
dwarf_dealloc(dbg, prev_loc, DW_DLA_LOC_CHAIN);
}
locdesc =
(Dwarf_Locdesc *) _dwarf_get_alloc(dbg, DW_DLA_LOCDESC, 1);
if (locdesc == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (NULL);
}
locdesc->ld_cents = op_count;
locdesc->ld_s = block_loc;
locdesc->ld_from_loclist = loc_block->bl_from_loclist;
locdesc->ld_section_offset = loc_block->bl_section_offset;
locdesc->ld_lopc = lowpc;
locdesc->ld_hipc = highpc;
return (locdesc);
}
/*
Given a form, and a pointer to the bytes encoding
a value of that form, val_ptr, this function returns
the length, in bytes, of a value of that form.
When using this function, check for a return of 0
a recursive DW_FORM_INDIRECT value.
*/
Dwarf_Unsigned
_dwarf_get_size_of_val(Dwarf_Debug dbg,
Dwarf_Unsigned form,
Dwarf_Small * val_ptr, int v_length_size)
{
Dwarf_Unsigned length = 0;
Dwarf_Word leb128_length = 0;
Dwarf_Unsigned form_indirect = 0;
Dwarf_Unsigned ret_value = 0;
switch (form) {
default: /* Handles form = 0. */
return (form);
case DW_FORM_addr:
return (dbg->de_pointer_size);
case DW_FORM_ref_addr:
return (v_length_size);
case DW_FORM_block1:
return (*(Dwarf_Small *) val_ptr + 1);
case DW_FORM_block2:
READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
val_ptr, sizeof(Dwarf_Half));
return (ret_value + sizeof(Dwarf_Half));
case DW_FORM_block4:
READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
val_ptr, sizeof(Dwarf_ufixed));
return (ret_value + sizeof(Dwarf_ufixed));
case DW_FORM_data1:
return (1);
case DW_FORM_data2:
return (2);
case DW_FORM_data4:
return (4);
case DW_FORM_data8:
return (8);
case DW_FORM_string:
return (strlen((char *) val_ptr) + 1);
case DW_FORM_block:
length = _dwarf_decode_u_leb128(val_ptr, &leb128_length);
return (length + leb128_length);
case DW_FORM_flag:
return (1);
case DW_FORM_ref_udata:
_dwarf_decode_u_leb128(val_ptr, &leb128_length);
return (leb128_length);
case DW_FORM_indirect:
{
Dwarf_Word indir_len = 0;
form_indirect = _dwarf_decode_u_leb128(val_ptr, &indir_len);
if (form_indirect == DW_FORM_indirect) {
return (0); /* We are in big trouble: The true form
of DW_FORM_indirect is
DW_FORM_indirect? Nonsense. Should
never happen. */
}
return (indir_len + _dwarf_get_size_of_val(dbg,
form_indirect,
val_ptr +
indir_len,
v_length_size));
}
case DW_FORM_ref1:
return (1);
case DW_FORM_ref2:
return (2);
case DW_FORM_ref4:
return (4);
case DW_FORM_ref8:
return (8);
case DW_FORM_sdata:
_dwarf_decode_s_leb128(val_ptr, &leb128_length);
return (leb128_length);
case DW_FORM_strp:
return (v_length_size);
case DW_FORM_udata:
_dwarf_decode_u_leb128(val_ptr, &leb128_length);
return (leb128_length);
}
}
