/* ARGSUSED */
static int
get_gcc_eh_augmentation(Dwarf_Debug dbg, Dwarf_Small * frame_ptr,
unsigned long *size_of_augmentation_data,
enum Dwarf_augmentation_type augtype,
Dwarf_Small * section_pointer,
Dwarf_Small * fde_eh_encoding_out,
char *augmentation)
{
char *suffix = 0;
unsigned long augdata_size = 0;
if (augtype == aug_gcc_eh_z) {
/* Has leading 'z'. */
Dwarf_Word leb128_length = 0;
/* Dwarf_Unsigned eh_value = */
_dwarf_decode_u_leb128(frame_ptr, &leb128_length);
augdata_size += leb128_length;
frame_ptr += leb128_length;
suffix = augmentation + 1;
} else {
/* Prefix is 'eh'. As in gcc 3.2. No suffix present
apparently. */
suffix = augmentation + 2;
}
for (; *suffix; ++suffix) {
/* We have no idea what this is as yet. Some extensions beyond
dwarf exist which we do not yet handle. */
return DW_DLV_ERROR;
}
*size_of_augmentation_data = augdata_size;
return DW_DLV_OK;
}
/* Part of DebugFission. So a dwarf dumper application
can get the index and print it for the user.
A convenience function. New May 2014*/
int
dwarf_get_debug_str_index(Dwarf_Attribute attr,
Dwarf_Unsigned *return_index,
Dwarf_Error *error)
{
int theform = attr->ar_attribute_form;
if (theform == DW_FORM_strx ||
theform == DW_FORM_GNU_str_index) {
Dwarf_Unsigned index = 0;
Dwarf_Word uleblen = 0;
Dwarf_Small *info_ptr = attr->ar_debug_ptr;
index = _dwarf_decode_u_leb128(info_ptr,&uleblen);
*return_index = index;
return DW_DLV_OK;
}
{
Dwarf_CU_Context cu_context = 0;
Dwarf_Debug dbg = 0;
int res = get_attr_dbg(&dbg,&cu_context,attr,error);
if (res != DW_DLV_OK) {
return res;
}
_dwarf_error(dbg, error, DW_DLE_ATTR_FORM_NOT_ADDR_INDEX);
}
return (DW_DLV_ERROR);
}
int
dwarf_formexprloc(Dwarf_Attribute attr,
Dwarf_Unsigned * return_exprlen,
Dwarf_Ptr * block_ptr,
Dwarf_Error * error)
{
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;
}
if (dbg == NULL) {
_dwarf_error(NULL, error, DW_DLE_ATTR_DBG_NULL);
return (DW_DLV_ERROR);
}
if (attr->ar_attribute_form == DW_FORM_exprloc ) {
Dwarf_Word leb_len = 0;
Dwarf_Unsigned exprlen =
(_dwarf_decode_u_leb128(attr->ar_debug_ptr, &leb_len));
Dwarf_Small * addr = attr->ar_debug_ptr;
*return_exprlen = exprlen;
*block_ptr = addr + leb_len;
return DW_DLV_OK;
}
_dwarf_error(dbg, error, DW_DLE_ATTR_EXPRLOC_FORM_BAD);
return (DW_DLV_ERROR);
}
int
_dwarf_extract_string_offset_via_str_offsets(Dwarf_Debug dbg,
Dwarf_Small *info_data_ptr,
Dwarf_Half attrnum,
Dwarf_Half attrform,
Dwarf_CU_Context cu_context,
Dwarf_Unsigned *str_sect_offset_out,
Dwarf_Error *error)
{
Dwarf_Unsigned offsettostr= 0;
Dwarf_Unsigned offset_base = 0;
Dwarf_Word leb_len = 0;
Dwarf_Unsigned index_to_offset_entry = 0;
Dwarf_Unsigned offsetintable = 0;
Dwarf_Unsigned end_offsetintable = 0;
Dwarf_Unsigned strofflen = 0;
int res = 0;
res = _dwarf_load_section(dbg, &dbg->de_debug_str_offsets,error);
if (res != DW_DLV_OK) {
return res;
}
index_to_offset_entry = (_dwarf_decode_u_leb128(info_data_ptr, &leb_len));
/* DW_FORM_GNU_str_index has no 'base' value.
DW_FORM_strx has a base value
for the offset table */
if( attrform == DW_FORM_strx) {
res = _dwarf_get_string_base_attr_value(dbg,cu_context,
&offset_base,error);
if (res != DW_DLV_OK) {
return res;
}
}
offsetintable = (index_to_offset_entry*cu_context->cc_length_size )
+ offset_base;
{
Dwarf_Unsigned fissoff = 0;
Dwarf_Unsigned size = 0;
fissoff = _dwarf_get_dwp_extra_offset(&cu_context->cc_dwp_offsets,
DW_SECT_STR_OFFSETS, &size);
offsetintable += fissoff;
}
end_offsetintable = offsetintable + cu_context->cc_length_size;
/* The offsets table is a series of offset-size entries. */
if ((end_offsetintable) >= dbg->de_debug_str_offsets.dss_size ) {
_dwarf_error(dbg, error, DW_DLE_ATTR_FORM_SIZE_BAD);
return (DW_DLV_ERROR);
}
/* Now read the string offset from the offset table. */
READ_UNALIGNED(dbg,offsettostr,Dwarf_Unsigned,
dbg->de_debug_str_offsets.dss_data + offsetintable,
cu_context->cc_length_size);
*str_sect_offset_out = offsettostr;
return DW_DLV_OK;
}
int
_dwarf_get_addr_index_itself(UNUSEDARG int theform,
Dwarf_Small *info_ptr,
Dwarf_Unsigned *val_out,
UNUSEDARG Dwarf_Error * error)
{
Dwarf_Unsigned index = 0;
Dwarf_Word uleblen = 0;
index = _dwarf_decode_u_leb128(info_ptr,&uleblen);
*val_out = index;
return DW_DLV_OK;
}
int
dwarf_formexprloc(Dwarf_Attribute attr,
Dwarf_Unsigned * return_exprlen,
Dwarf_Ptr * block_ptr,
Dwarf_Error * error)
{
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;
}
if (dbg == NULL) {
_dwarf_error(NULL, error, DW_DLE_ATTR_DBG_NULL);
return (DW_DLV_ERROR);
}
if (attr->ar_attribute_form == DW_FORM_exprloc ) {
Dwarf_Die die = 0;
Dwarf_Word leb_len = 0;
Dwarf_Unsigned exprlen =
(_dwarf_decode_u_leb128(attr->ar_debug_ptr, &leb_len));
Dwarf_Small * addr = attr->ar_debug_ptr;
/* Is the block entirely in the section, or is
there bug somewhere? */
die = attr->ar_die;
if (_dwarf_reference_outside_section(die,
(Dwarf_Small *)addr, ((Dwarf_Small *)addr)+exprlen +leb_len)) {
_dwarf_error(dbg, error,DW_DLE_ATTR_OUTSIDE_SECTION);
return DW_DLV_ERROR;
}
*return_exprlen = exprlen;
*block_ptr = addr + leb_len;
return DW_DLV_OK;
}
_dwarf_error(dbg, error, DW_DLE_ATTR_EXPRLOC_FORM_BAD);
return (DW_DLV_ERROR);
}
int
dwarf_formexprloc(Dwarf_Attribute attr,
Dwarf_Unsigned * return_exprlen,
Dwarf_Ptr * block_ptr,
Dwarf_Error * error)
{
Dwarf_Debug dbg = 0;
Dwarf_CU_Context cu_context = 0;
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);
}
if (attr->ar_attribute_form == DW_FORM_udata ) {
Dwarf_Unsigned exprlen =
(_dwarf_decode_u_leb128(attr->ar_debug_info_ptr, NULL));
Dwarf_Small * addr = attr->ar_debug_info_ptr;
*return_exprlen = exprlen;
*block_ptr = addr + exprlen;
return DW_DLV_OK;
}
_dwarf_error(dbg, error, DW_DLE_ATTR_EXPRLOC_FORM_BAD);
return (DW_DLV_ERROR);
}
/*
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);
}
/*
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);
}
/*
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_formblock(Dwarf_Attribute attr,
Dwarf_Block ** return_block, Dwarf_Error * error)
{
Dwarf_CU_Context cu_context = 0;
Dwarf_Debug dbg = 0;
Dwarf_Unsigned length = 0;
Dwarf_Small *data = 0;
Dwarf_Word leb128_length = 0;
Dwarf_Block *ret_block = 0;
Dwarf_Small *dataptr = 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_block1:
length = *(Dwarf_Small *) attr->ar_debug_ptr;
data = attr->ar_debug_ptr + sizeof(Dwarf_Small);
break;
case DW_FORM_block2:
READ_UNALIGNED(dbg, length, Dwarf_Unsigned,
attr->ar_debug_ptr, sizeof(Dwarf_Half));
data = attr->ar_debug_ptr + sizeof(Dwarf_Half);
break;
case DW_FORM_block4:
READ_UNALIGNED(dbg, length, Dwarf_Unsigned,
attr->ar_debug_ptr, sizeof(Dwarf_ufixed));
data = attr->ar_debug_ptr + sizeof(Dwarf_ufixed);
break;
case DW_FORM_block:
length = _dwarf_decode_u_leb128(attr->ar_debug_ptr,
&leb128_length);
data = attr->ar_debug_ptr + leb128_length;
break;
default:
_dwarf_error(cu_context->cc_dbg, error, DW_DLE_ATTR_FORM_BAD);
return (DW_DLV_ERROR);
}
/* Check that block lies within current cu in .debug_info. */
dataptr = cu_context->cc_is_info? dbg->de_debug_info.dss_data:
dbg->de_debug_types.dss_data;
if (attr->ar_debug_ptr + length >=
dataptr + cu_context->cc_debug_offset +
cu_context->cc_length + cu_context->cc_length_size +
cu_context->cc_extension_size) {
_dwarf_error(dbg, error, DW_DLE_ATTR_FORM_SIZE_BAD);
return (DW_DLV_ERROR);
}
ret_block = (Dwarf_Block *) _dwarf_get_alloc(dbg, DW_DLA_BLOCK, 1);
if (ret_block == NULL) {
_dwarf_error(dbg, error, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
ret_block->bl_len = length;
ret_block->bl_data = (Dwarf_Ptr) data;
ret_block->bl_from_loclist = 0;
ret_block->bl_section_offset = data - dataptr;
*return_block = ret_block;
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);
}
int
dwarf_formref(Dwarf_Attribute attr,
Dwarf_Off * ret_offset,
Dwarf_Error * error)
{
Dwarf_Debug dbg = 0;
Dwarf_Unsigned offset = 0;
Dwarf_CU_Context cu_context = 0;
Dwarf_Unsigned maximumoffset = 0;
int res = DW_DLV_ERROR;
*ret_offset = 0;
res = get_attr_dbg(&dbg,&cu_context,attr,error);
if (res != DW_DLV_OK) {
return res;
}
switch (attr->ar_attribute_form) {
case DW_FORM_ref1:
offset = *(Dwarf_Small *) attr->ar_debug_ptr;
break;
case DW_FORM_ref2:
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_ptr, sizeof(Dwarf_Half));
break;
case DW_FORM_ref4:
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_ptr, sizeof(Dwarf_ufixed));
break;
case DW_FORM_ref8:
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_ptr, sizeof(Dwarf_Unsigned));
break;
case DW_FORM_ref_udata:
offset = _dwarf_decode_u_leb128(attr->ar_debug_ptr, NULL);
break;
case DW_FORM_ref_sig8:
/* We cannot handle this here.
The reference is to .debug_types
not a .debug_info CU local offset. */
_dwarf_error(dbg, error, DW_DLE_REF_SIG8_NOT_HANDLED);
return (DW_DLV_ERROR);
default:
_dwarf_error(dbg, error, DW_DLE_BAD_REF_FORM);
return (DW_DLV_ERROR);
}
/* Check that offset is within current cu portion of .debug_info. */
maximumoffset = cu_context->cc_length +
cu_context->cc_length_size +
cu_context->cc_extension_size;
if (offset >= maximumoffset) {
/* For the DW_TAG_compile_unit is legal to have the
DW_AT_sibling attribute outside the current cu portion of
.debug_info.
In other words, sibling points to the end of the CU.
It is used for precompiled headers.
The valid condition will be: 'offset == maximumoffset'. */
Dwarf_Half tag = 0;
if (DW_DLV_OK != dwarf_tag(attr->ar_die,&tag,error)) {
_dwarf_error(dbg, error, DW_DLE_DIE_BAD);
return (DW_DLV_ERROR);
}
if (DW_TAG_compile_unit != tag &&
DW_AT_sibling != attr->ar_attribute &&
offset > maximumoffset) {
_dwarf_error(dbg, error, DW_DLE_ATTR_FORM_OFFSET_BAD);
/* Return the incorrect offset for better error reporting */
*ret_offset = (offset);
return (DW_DLV_ERROR);
}
}
*ret_offset = (offset);
return DW_DLV_OK;
}
int
dwarf_formudata(Dwarf_Attribute attr,
Dwarf_Unsigned * return_uval, Dwarf_Error * error)
{
Dwarf_Unsigned 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:
READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
attr->ar_debug_info_ptr, sizeof(Dwarf_Small));
*return_uval = ret_value;
return DW_DLV_OK;
/* READ_UNALIGNED does the right thing as it reads
the right number bits and generates host order.
So we can just assign to *return_uval. */
case DW_FORM_data2:{
READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
attr->ar_debug_info_ptr, sizeof(Dwarf_Half));
*return_uval = ret_value;
return DW_DLV_OK;
}
case DW_FORM_data4:{
READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
attr->ar_debug_info_ptr,
sizeof(Dwarf_ufixed));
*return_uval = ret_value;
return DW_DLV_OK;
}
case DW_FORM_data8:{
READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
attr->ar_debug_info_ptr,
sizeof(Dwarf_Unsigned));
*return_uval = ret_value;
return DW_DLV_OK;
}
case DW_FORM_udata:
ret_value =
(_dwarf_decode_u_leb128(attr->ar_debug_info_ptr, NULL));
*return_uval = 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);
}
/*
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);
}
/*
Since this returns section-relative debug_info offsets,
this can represent all REFERENCE forms correctly
and allows all forms.
DW_FORM_ref_addr has a value which was documented in
DWARF2 as address-size but which was always an offset
so should have always been offset size (wording
corrected in DWARF3).
See the DWARF4 document for the 3 cases fitting
reference forms. The caller must determine which section the
reference 'points' to.
*/
int
dwarf_global_formref(Dwarf_Attribute attr,
Dwarf_Off * ret_offset, Dwarf_Error * error)
{
Dwarf_Debug dbg;
Dwarf_Unsigned offset;
Dwarf_Unsigned max_offset;
Dwarf_Addr ref_addr;
Dwarf_CU_Context cu_context;
Dwarf_Half context_version = 0;
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);
}
context_version = cu_context->cc_version_stamp;
if (cu_context->cc_dbg == NULL) {
_dwarf_error(NULL, error, DW_DLE_ATTR_DBG_NULL);
return (DW_DLV_ERROR);
}
dbg = cu_context->cc_dbg;
switch (attr->ar_attribute_form) {
case DW_FORM_ref1:
offset = *(Dwarf_Small *) attr->ar_debug_info_ptr;
goto fixoffset;
case DW_FORM_ref2:
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_info_ptr, sizeof(Dwarf_Half));
goto fixoffset;
case DW_FORM_ref4:
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_info_ptr, sizeof(Dwarf_ufixed));
goto fixoffset;
case DW_FORM_ref8:
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_info_ptr, sizeof(Dwarf_Unsigned));
goto fixoffset;
case DW_FORM_ref_udata:
offset = _dwarf_decode_u_leb128(attr->ar_debug_info_ptr, NULL);
/* we have a local offset, make it global */
fixoffset:
/* check legality of offset */
max_offset = cu_context->cc_length
+ cu_context->cc_length_size
+ cu_context->cc_extension_size;
if (offset >= max_offset) {
_dwarf_error(dbg, error, DW_DLE_ATTR_FORM_OFFSET_BAD);
return (DW_DLV_ERROR);
}
/* globalize the offset */
offset += cu_context->cc_debug_info_offset;
break;
/*
* The DWARF2 document did not make clear that
* DW_FORM_data4( and 8) were references with
* global offsets to some section.
* That was first clearly documented in DWARF3.
* In DWARF4 these two forms are no longer references.
*/
case DW_FORM_data4:
if(context_version == CURRENT_VERSION_STAMP4) {
_dwarf_error(dbg, error, DW_DLE_NOT_REF_FORM);
return (DW_DLV_ERROR);
}
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_info_ptr, sizeof(Dwarf_ufixed));
/* The offset is global. */
break;
case DW_FORM_data8:
if(context_version == CURRENT_VERSION_STAMP4) {
_dwarf_error(dbg, error, DW_DLE_NOT_REF_FORM);
return (DW_DLV_ERROR);
}
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_info_ptr, sizeof(Dwarf_Unsigned));
/* The offset is global. */
break;
case DW_FORM_ref_addr:
case DW_FORM_sec_offset:
{
/*
* DW_FORM_sec_offset first exists in DWARF4.
* It is up to the caller to know what the offset
* of DW_FORM_sec_offset refers to,
* the offset is not going to refer to .debug_info!
*/
unsigned length_size = cu_context->cc_length_size;
if(length_size == 4) {
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_info_ptr, sizeof(Dwarf_ufixed));
} else if (length_size == 8) {
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_info_ptr, sizeof(Dwarf_Unsigned));
} else {
_dwarf_error(dbg, error, DW_DLE_FORM_SEC_OFFSET_LENGTH_BAD);
return (DW_DLV_ERROR);
}
}
break;
default:
_dwarf_error(dbg, error, DW_DLE_BAD_REF_FORM);
return (DW_DLV_ERROR);
}
/* We do not know what section the offset refers to, so
we have no way to check it for correctness. */
*ret_offset = offset;
return DW_DLV_OK;
}
int
_dwarf_extract_string_offset_via_str_offsets(Dwarf_Debug dbg,
Dwarf_Small *info_data_ptr,
UNUSEDARG Dwarf_Half attrnum,
Dwarf_Half attrform,
Dwarf_CU_Context cu_context,
Dwarf_Unsigned *str_sect_offset_out,
Dwarf_Error *error)
{
Dwarf_Unsigned offsettostr= 0;
Dwarf_Unsigned offset_base = 0;
Dwarf_Word leb_len = 0;
Dwarf_Unsigned index_to_offset_entry = 0;
Dwarf_Unsigned offsetintable = 0;
Dwarf_Unsigned end_offsetintable = 0;
int res = 0;
res = _dwarf_load_section(dbg, &dbg->de_debug_str_offsets,error);
if (res != DW_DLV_OK) {
return res;
}
index_to_offset_entry = (_dwarf_decode_u_leb128(info_data_ptr, &leb_len));
/* DW_FORM_GNU_str_index has no 'base' value.
DW_FORM_strx has a base value
for the offset table */
if( attrform == DW_FORM_strx) {
res = _dwarf_get_string_base_attr_value(dbg,cu_context,
&offset_base,error);
if (res != DW_DLV_OK) {
/* DW_DLV_NO_ENTRY could be acceptable when
a producer knows that the base offset will be zero.
Hence DW_AT_str_offsets_base missing.
DWARF5 draft as of September 2015 allows the attribute
to be missing (it's up to the compilation tools to
make sure that has the correct effect).
*/
return res;
}
}
offsetintable = (index_to_offset_entry*cu_context->cc_length_size )
+ offset_base;
{
Dwarf_Unsigned fissoff = 0;
Dwarf_Unsigned size = 0;
fissoff = _dwarf_get_dwp_extra_offset(&cu_context->cc_dwp_offsets,
DW_SECT_STR_OFFSETS, &size);
offsetintable += fissoff;
}
end_offsetintable = offsetintable + cu_context->cc_length_size;
/* The offsets table is a series of offset-size entries.
The == case in the test applies when we are at the last table
entry, so == is not an error, hence only test >
*/
if (end_offsetintable > dbg->de_debug_str_offsets.dss_size ) {
_dwarf_error(dbg, error, DW_DLE_ATTR_FORM_SIZE_BAD);
return (DW_DLV_ERROR);
}
/* Now read the string offset from the offset table. */
READ_UNALIGNED(dbg,offsettostr,Dwarf_Unsigned,
dbg->de_debug_str_offsets.dss_data + offsetintable,
cu_context->cc_length_size);
*str_sect_offset_out = offsettostr;
return DW_DLV_OK;
}
/* Here a DW_DLV_NO_ENTRY return means the macro operator
is not a def/undef operator. */
int
dwarf_get_macro_defundef(Dwarf_Macro_Context macro_context,
Dwarf_Unsigned op_number,
Dwarf_Unsigned * line_number,
Dwarf_Unsigned * index,
Dwarf_Unsigned * offset,
Dwarf_Half * forms_count,
const char ** macro_string,
Dwarf_Error *error)
{
Dwarf_Debug dbg = 0;
Dwarf_Small *mdata = 0;
int res = 0;
Dwarf_Small *startptr = 0;
Dwarf_Small *endptr = 0;
Dwarf_Half lformscount = 0;
struct Dwarf_Macro_Operator_s *curop = 0;
unsigned macop = 0;
if (!macro_context || macro_context->mc_sentinel != 0xada) {
if(macro_context) {
dbg = macro_context->mc_dbg;
}
_dwarf_error(dbg, error,DW_DLE_BAD_MACRO_HEADER_POINTER);
return DW_DLV_ERROR;
}
dbg = macro_context->mc_dbg;
if (op_number >= macro_context->mc_macro_ops_count) {
_dwarf_error(dbg, error,DW_DLE_BAD_MACRO_INDEX);
return DW_DLV_ERROR;
}
curop = macro_context->mc_ops + op_number;
macop = curop->mo_opcode;
startptr = macro_context->mc_macro_header;
endptr = startptr + macro_context->mc_total_length;
mdata = curop->mo_data;
lformscount = curop->mo_form->mf_formcount;
if (lformscount != 2) {
/*_dwarf_error(dbg, error,DW_DLE_MACRO_OPCODE_FORM_BAD);*/
return DW_DLV_NO_ENTRY;
}
switch(macop){
case DW_MACRO_define:
case DW_MACRO_undef: {
Dwarf_Unsigned linenum = 0;
Dwarf_Word uleblen = 0;
const char * content = 0;
linenum = _dwarf_decode_u_leb128(mdata,
&uleblen);
mdata += uleblen;
content = (const char *)mdata;
res = _dwarf_check_string_valid(dbg,
startptr,mdata, endptr, error);
if(res != DW_DLV_OK) {
return res;
}
*line_number = linenum;
*index = 0;
*offset = 0;
*forms_count = lformscount;
*macro_string = content;
}
return DW_DLV_OK;
case DW_MACRO_define_strp:
case DW_MACRO_undef_strp: {
Dwarf_Unsigned linenum = 0;
Dwarf_Word uleblen = 0;
Dwarf_Unsigned stringoffset = 0;
Dwarf_Small form1 = curop->mo_form->mf_formbytes[1];
char * localstr = 0;
linenum = _dwarf_decode_u_leb128(mdata,
&uleblen);
mdata += uleblen;
READ_UNALIGNED(dbg,stringoffset,Dwarf_Unsigned,
mdata,macro_context->mc_offset_size);
mdata += macro_context->mc_offset_size;
res = _dwarf_extract_local_debug_str_string_given_offset(dbg,
form1,
stringoffset,
&localstr,
error);
*index = 0;
*line_number = linenum;
*offset = stringoffset;
*forms_count = lformscount;
if (res == DW_DLV_ERROR) {
return res;
*macro_string = "<Error: getting local .debug_str>";
} else if (res == DW_DLV_NO_ENTRY) {
*macro_string = "<Error: NO_ENTRY on .debug_string (strp)>";
} else {
*macro_string = (const char *)localstr;
}
}
return DW_DLV_OK;
case DW_MACRO_define_strx:
case DW_MACRO_undef_strx: {
Dwarf_Unsigned linenum = 0;
Dwarf_Word uleblen = 0;
Dwarf_Unsigned stringindex = 0;
Dwarf_Unsigned offsettostr= 0;
int res = 0;
Dwarf_Small form1 = curop->mo_form->mf_formbytes[1];
linenum = _dwarf_decode_u_leb128(mdata,
&uleblen);
mdata += uleblen;
*line_number = linenum;
stringindex = _dwarf_decode_u_leb128(mdata,
&uleblen);
/* leave mdata uchanged for call below */
*index = stringindex;
*forms_count = lformscount;
/* FIXME */
/* Redoes the index-getting. Gets offset. */
res = _dwarf_extract_string_offset_via_str_offsets(dbg,
mdata,
DW_AT_macros, /*arbitrary, unused by called routine. */
form1,
macro_context->mc_cu_context,
&offsettostr,
error);
if (res == DW_DLV_ERROR) {
return res;
}
if (res == DW_DLV_OK) {
*index = stringindex;
*offset = offsettostr;
char *localstr = 0;
res = _dwarf_extract_local_debug_str_string_given_offset(dbg,
form1,
offsettostr,
&localstr,
error);
if(res == DW_DLV_ERROR) {
return res;
} else if (res == DW_DLV_NO_ENTRY){
*macro_string = "<:No string available>";
} else {
*macro_string = (const char *)localstr;
/* All is ok. */
}
} else {
*index = stringindex;
*offset = 0;
*macro_string = "<.debug_str_offsets not available>";
}
}
return DW_DLV_OK;
case DW_MACRO_define_sup:
case DW_MACRO_undef_sup: {
Dwarf_Unsigned linenum = 0;
Dwarf_Word uleblen = 0;
Dwarf_Unsigned supoffset = 0;
char *localstring = 0;
int res = 0;
linenum = _dwarf_decode_u_leb128(mdata,
&uleblen);
mdata += uleblen;
READ_UNALIGNED(dbg,supoffset,Dwarf_Unsigned,
mdata,macro_context->mc_offset_size);
mdata += macro_context->mc_offset_size;
*line_number = linenum;
*index = 0;
*offset = supoffset;
*forms_count = lformscount;
res = _dwarf_get_string_from_tied(dbg, supoffset,
&localstring, error);
if (res != DW_DLV_OK) {
if (res == DW_DLV_ERROR) {
if(dwarf_errno(*error) == DW_DLE_NO_TIED_FILE_AVAILABLE) {
*macro_string =
(char *)"<DW_FORM_str_sup-no-tied_file>";
} else {
*macro_string =
(char *)"<Error: DW_FORM_str_sup-got-error>";
}
dwarf_dealloc(dbg,*error,DW_DLA_ERROR);
} else {
*macro_string = "<DW_FORM_str_sup-no-entry>";
}
} else {
*macro_string = (const char *)localstring;
}
return DW_DLV_OK;
}
}
return DW_DLV_NO_ENTRY;
}
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;
}
/*
DW_FORM_ref_addr is considered an incorrect form
for this call because this function returns an
offset within the local CU thru the pointer.
DW_FORM_ref_addr is a global-offset into the debug_info section.
A DW_FORM_ref_addr cannot be returned by this interface:
see dwarf_global_formref();
DW_FORM_ref_addr has a value which was documented in
DWARF2 as address-size but which was always an offset
so should have always been offset size (wording
corrected in DWARF3).
*/
int
dwarf_formref(Dwarf_Attribute attr,
Dwarf_Off * ret_offset, Dwarf_Error * error)
{
Dwarf_Debug dbg;
Dwarf_Unsigned offset;
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);
}
if (cu_context->cc_dbg == NULL) {
_dwarf_error(NULL, error, DW_DLE_ATTR_DBG_NULL);
return (DW_DLV_ERROR);
}
dbg = cu_context->cc_dbg;
switch (attr->ar_attribute_form) {
case DW_FORM_ref1:
offset = *(Dwarf_Small *) attr->ar_debug_info_ptr;
break;
case DW_FORM_ref2:
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_info_ptr, sizeof(Dwarf_Half));
break;
case DW_FORM_ref4:
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_info_ptr, sizeof(Dwarf_ufixed));
break;
case DW_FORM_ref8:
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_info_ptr, sizeof(Dwarf_Unsigned));
break;
case DW_FORM_ref_udata:
offset = _dwarf_decode_u_leb128(attr->ar_debug_info_ptr, NULL);
break;
default:
_dwarf_error(dbg, error, DW_DLE_BAD_REF_FORM);
return (DW_DLV_ERROR);
}
/* Check that offset is within current cu portion of .debug_info. */
if (offset >= cu_context->cc_length +
cu_context->cc_length_size + cu_context->cc_extension_size) {
_dwarf_error(dbg, error, DW_DLE_ATTR_FORM_OFFSET_BAD);
return (DW_DLV_ERROR);
}
*ret_offset = (offset);
return DW_DLV_OK;
}
/*
Since this returns section-relative debug_info offsets,
this can represent all REFERENCE forms correctly
and allows all forms.
DW_FORM_ref_addr has a value which was documented in
DWARF2 as address-size but which was always an offset
so should have always been offset size (wording
corrected in DWARF3).
*/
int
dwarf_global_formref(Dwarf_Attribute attr,
Dwarf_Off * ret_offset, Dwarf_Error * error)
{
Dwarf_Debug dbg;
Dwarf_Unsigned offset;
Dwarf_Addr ref_addr;
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);
}
if (cu_context->cc_dbg == NULL) {
_dwarf_error(NULL, error, DW_DLE_ATTR_DBG_NULL);
return (DW_DLV_ERROR);
}
dbg = cu_context->cc_dbg;
switch (attr->ar_attribute_form) {
case DW_FORM_ref1:
offset = *(Dwarf_Small *) attr->ar_debug_info_ptr;
goto fixoffset;
case DW_FORM_ref2:
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_info_ptr, sizeof(Dwarf_Half));
goto fixoffset;
case DW_FORM_ref4:
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_info_ptr, sizeof(Dwarf_ufixed));
goto fixoffset;
case DW_FORM_ref8:
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_info_ptr, sizeof(Dwarf_Unsigned));
goto fixoffset;
case DW_FORM_ref_udata:
offset = _dwarf_decode_u_leb128(attr->ar_debug_info_ptr, NULL);
fixoffset: /* we have a local offset, make it
global */
/* check legality of offset */
if (offset >= cu_context->cc_length +
cu_context->cc_length_size +
cu_context->cc_extension_size) {
_dwarf_error(dbg, error, DW_DLE_ATTR_FORM_OFFSET_BAD);
return (DW_DLV_ERROR);
}
/* globalize the offset */
offset += cu_context->cc_debug_info_offset;
break;
case DW_FORM_ref_addr:
/* This offset is defined to be debug_info global already, so
use this value unaltered. */
READ_UNALIGNED(dbg, ref_addr, Dwarf_Addr,
attr->ar_debug_info_ptr,
cu_context->cc_length_size);
offset = ref_addr;
break;
default:
_dwarf_error(dbg, error, DW_DLE_BAD_REF_FORM);
return (DW_DLV_ERROR);
}
/* Check that offset is within current cu portion of .debug_info. */
*ret_offset = (offset);
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);
}
/* 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;
}
}
/* 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);
}
int
dwarf_global_formref(Dwarf_Attribute attr,
Dwarf_Off * ret_offset, Dwarf_Error * error)
{
Dwarf_Debug dbg = 0;
Dwarf_Unsigned offset = 0;
Dwarf_CU_Context cu_context = 0;
Dwarf_Half context_version = 0;
int res = get_attr_dbg(&dbg,&cu_context,attr,error);
if (res != DW_DLV_OK) {
return res;
}
context_version = cu_context->cc_version_stamp;
switch (attr->ar_attribute_form) {
case DW_FORM_ref1:
offset = *(Dwarf_Small *) attr->ar_debug_ptr;
goto fixoffset;
case DW_FORM_ref2:
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_ptr, sizeof(Dwarf_Half));
goto fixoffset;
case DW_FORM_ref4:
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_ptr, sizeof(Dwarf_ufixed));
goto fixoffset;
case DW_FORM_ref8:
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_ptr, sizeof(Dwarf_Unsigned));
goto fixoffset;
case DW_FORM_ref_udata:
{
offset = _dwarf_decode_u_leb128(attr->ar_debug_ptr, NULL);
fixoffset: /* we have a local offset, make it global */
/* check legality of offset */
if (offset >= cu_context->cc_length +
cu_context->cc_length_size +
cu_context->cc_extension_size) {
_dwarf_error(dbg, error, DW_DLE_ATTR_FORM_OFFSET_BAD);
return (DW_DLV_ERROR);
}
/* globalize the offset */
offset += cu_context->cc_debug_offset;
}
break;
/* The DWARF2 document did not make clear that
DW_FORM_data4( and 8) were references with
global offsets to some section.
That was first clearly documented in DWARF3.
In DWARF4 these two forms are no longer references. */
case DW_FORM_data4:
if (context_version == DW_CU_VERSION4) {
_dwarf_error(dbg, error, DW_DLE_NOT_REF_FORM);
return (DW_DLV_ERROR);
}
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_ptr, sizeof(Dwarf_ufixed));
/* The offset is global. */
break;
case DW_FORM_data8:
if (context_version == DW_CU_VERSION4) {
_dwarf_error(dbg, error, DW_DLE_NOT_REF_FORM);
return (DW_DLV_ERROR);
}
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_ptr, sizeof(Dwarf_Unsigned));
/* The offset is global. */
break;
case DW_FORM_ref_addr:
{
/* In Dwarf V2 DW_FORM_ref_addr was defined
as address-size even though it is a .debug_info
offset. Fixed in Dwarf V3 to be offset-size.
*/
unsigned length_size = 0;
if (context_version == 2) {
length_size = cu_context->cc_address_size;
} else {
length_size = cu_context->cc_length_size;
}
if (length_size == 4) {
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_ptr, sizeof(Dwarf_ufixed));
} else if (length_size == 8) {
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_ptr, sizeof(Dwarf_Unsigned));
} else {
_dwarf_error(dbg, error, DW_DLE_FORM_SEC_OFFSET_LENGTH_BAD);
return (DW_DLV_ERROR);
}
}
break;
case DW_FORM_sec_offset:
case DW_FORM_GNU_ref_alt: /* 2013 GNU extension */
case DW_FORM_GNU_strp_alt: /* 2013 GNU extension */
{
/* DW_FORM_sec_offset first exists in DWARF4.*/
/* It is up to the caller to know what the offset
of DW_FORM_sec_offset refers to,
the offset is not going to refer to .debug_info! */
unsigned length_size = cu_context->cc_length_size;
if (length_size == 4) {
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_ptr, sizeof(Dwarf_ufixed));
} else if (length_size == 8) {
READ_UNALIGNED(dbg, offset, Dwarf_Unsigned,
attr->ar_debug_ptr, sizeof(Dwarf_Unsigned));
} else {
_dwarf_error(dbg, error, DW_DLE_FORM_SEC_OFFSET_LENGTH_BAD);
return (DW_DLV_ERROR);
}
}
break;
case DW_FORM_ref_sig8: /* FIXME */
/* We cannot handle this yet.
The reference is to .debug_types, and
this function only returns an offset in
.debug_info at this point. */
_dwarf_error(dbg, error, DW_DLE_REF_SIG8_NOT_HANDLED);
return (DW_DLV_ERROR);
default:
_dwarf_error(dbg, error, DW_DLE_BAD_REF_FORM);
return (DW_DLV_ERROR);
}
/* We do not know what section the offset refers to, so
we have no way to check it for correctness. */
*ret_offset = offset;
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;
}
/* If the form is DW_FORM_constx and the .debug_addr section
is missing, this returns DW_DLV_ERROR and the error number
in the Dwarf_Error is DW_DLE_MISSING_NEEDED_DEBUG_ADDR_SECTION.
When that arises, a consumer should call
dwarf_get_debug_addr_index() and use that on the appropriate
.debug_addr section in the executable or another object. */
int
dwarf_formudata(Dwarf_Attribute attr,
Dwarf_Unsigned * return_uval, Dwarf_Error * error)
{
Dwarf_Unsigned 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:
READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
attr->ar_debug_ptr, sizeof(Dwarf_Small));
*return_uval = ret_value;
return DW_DLV_OK;
/* READ_UNALIGNED does the right thing as it reads
the right number bits and generates host order.
So we can just assign to *return_uval. */
case DW_FORM_data2:{
READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
attr->ar_debug_ptr, sizeof(Dwarf_Half));
*return_uval = ret_value;
return DW_DLV_OK;
}
case DW_FORM_data4:{
READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
attr->ar_debug_ptr,
sizeof(Dwarf_ufixed));
*return_uval = ret_value;
return DW_DLV_OK;
}
case DW_FORM_data8:{
READ_UNALIGNED(dbg, ret_value, Dwarf_Unsigned,
attr->ar_debug_ptr,
sizeof(Dwarf_Unsigned));
*return_uval = ret_value;
return DW_DLV_OK;
}
break;
/* real udata */
case DW_FORM_udata:
ret_value =
(_dwarf_decode_u_leb128(attr->ar_debug_ptr, NULL));
*return_uval = ret_value;
return DW_DLV_OK;
/* IRIX 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);
}
/* 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;
}
/*
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);
}
}
/*
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);
}
}