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