/*
Return DW_DLV_OK or, if error,
DW_DLV_ERROR.
Thru pointers, return 2 arrays and a count
for rqs.
*/
int
_dwarf_line_address_offsets(Dwarf_Debug dbg,
Dwarf_Die die,
Dwarf_Addr ** addrs,
Dwarf_Off ** offs,
Dwarf_Unsigned * returncount,
Dwarf_Error * err)
{
Dwarf_Addr *laddrs;
Dwarf_Off *loffsets;
Dwarf_Signed lcount;
Dwarf_Signed i;
int res;
Dwarf_Line *linebuf;
res = _dwarf_internal_srclines(die, &linebuf, &lcount, /* addrlist=
*/ true,
/* linelist= */ false, err);
if (res != DW_DLV_OK) {
return res;
}
laddrs = (Dwarf_Addr *)
_dwarf_get_alloc(dbg, DW_DLA_ADDR, lcount);
if (laddrs == NULL) {
dwarf_srclines_dealloc(dbg, linebuf, lcount);
_dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
loffsets = (Dwarf_Off *)
_dwarf_get_alloc(dbg, DW_DLA_ADDR, lcount);
if (loffsets == NULL) {
dwarf_srclines_dealloc(dbg, linebuf, lcount);
/* We already allocated what laddrs points at, so we'e better
deallocate that space since we are not going to return the
pointer to the caller. */
dwarf_dealloc(dbg, laddrs, DW_DLA_ADDR);
_dwarf_error(dbg, err, DW_DLE_ALLOC_FAIL);
return (DW_DLV_ERROR);
}
for (i = 0; i < lcount; i++) {
laddrs[i] = linebuf[i]->li_address;
loffsets[i] = linebuf[i]->li_addr_line.li_offset;
}
dwarf_srclines_dealloc(dbg, linebuf, lcount);
*returncount = lcount;
*offs = loffsets;
*addrs = laddrs;
return DW_DLV_OK;
}
/**
* @brief Get line number information from compilation unit DIE.
* @param cu_die Compilation unit DIE.
* @param lvl Level (depth) of this die.
* @return Loaded line element pointer or nullptr if some problem.
*/
DwarfLine *DwarfLineContainer::loadAndGetDie(Dwarf_Die cu_die, unsigned)
{
// Get all lines to buffer.
Dwarf_Signed lineCnt = 0;
Dwarf_Line *lineBuf = nullptr;
m_res = dwarf_srclines(cu_die, &lineBuf, &lineCnt, &m_error);
if (m_res == DW_DLV_NO_ENTRY)
{
return nullptr;
}
else if (m_res != DW_DLV_OK)
{
DWARF_ERROR(getDwarfError(m_error));
return nullptr;
}
// Iterate through lines and load each one of them.
for (int i=0; i<lineCnt; i++)
{
loadLine(lineBuf[i]);
}
dwarf_srclines_dealloc(m_parentFile->m_dbg, lineBuf, lineCnt);
return nullptr;
}
extern void
print_line_numbers_this_cu(Dwarf_Debug dbg, Dwarf_Die cu_die)
{
Dwarf_Unsigned lineversion = 0;
Dwarf_Signed linecount = 0;
Dwarf_Line *linebuf = NULL;
Dwarf_Signed linecount_actuals = 0;
Dwarf_Line *linebuf_actuals = NULL;
Dwarf_Small table_count = 0;
int lres = 0;
int line_errs = 0;
Dwarf_Line_Context line_context = 0;
const char *sec_name = 0;
current_section_id = DEBUG_LINE;
/* line_flag is TRUE */
lres = dwarf_get_line_section_name_from_die(cu_die,
&sec_name,&err);
if (lres != DW_DLV_OK || !sec_name || !strlen(sec_name)) {
sec_name = ".debug_line";
}
if (do_print_dwarf) {
printf("\n%s: line number info for a single cu\n", sec_name);
} else {
/* We are checking, not printing. */
Dwarf_Half tag = 0;
int tres = dwarf_tag(cu_die, &tag, &err);
if (tres != DW_DLV_OK) {
/* Something broken here. */
print_error(dbg,"Unable to see CU DIE tag "
"though we could see it earlier. Something broken.",
tres,err);
return;
} else if (tag == DW_TAG_type_unit) {
/* Not checking since type units missing
address or range in CU header. */
return;
}
}
if (verbose > 1) {
int errcount = 0;
print_source_intro(cu_die);
print_one_die(dbg, cu_die,
/* print_information= */ 1,
/* indent level */0,
/* srcfiles= */ 0, /* cnt= */ 0,
/* ignore_die_stack= */TRUE);
DWARF_CHECK_COUNT(lines_result,1);
lres = dwarf_print_lines(cu_die, &err,&errcount);
if (errcount > 0) {
DWARF_ERROR_COUNT(lines_result,errcount);
DWARF_CHECK_COUNT(lines_result,(errcount-1));
}
if (lres == DW_DLV_ERROR) {
print_error(dbg, "dwarf_srclines details", lres, err);
}
return;
}
if (check_lines && checking_this_compiler()) {
DWARF_CHECK_COUNT(lines_result,1);
dwarf_check_lineheader(cu_die,&line_errs);
if (line_errs > 0) {
DWARF_CHECK_ERROR_PRINT_CU();
DWARF_ERROR_COUNT(lines_result,line_errs);
DWARF_CHECK_COUNT(lines_result,(line_errs-1));
}
}
/* The following is complicated by a desire to test
various line table interface functions. Hence
we test line_flag_selection.
Normal code should pick an interface
(for most the best choice is what we here call
line_flag_selection == std)
and use just that interface set.
Sorry about the length of the code that
results from having so many interfaces. */
if (line_flag_selection == std) {
lres = dwarf_srclines_b(cu_die,&lineversion,
&table_count,&line_context,
&err);
if(lres == DW_DLV_OK) {
lres = dwarf_srclines_from_linecontext(line_context,
&linebuf, &linecount,&err);
}
} else if (line_flag_selection == orig) {
/* DWARF2,3,4, ok for 5. */
/* Useless for experimental line tables */
lres = dwarf_srclines(cu_die,
&linebuf, &linecount, &err);
if(lres == DW_DLV_OK && linecount ){
table_count++;
}
} else if (line_flag_selection == orig2l) {
lres = dwarf_srclines_two_level(cu_die,
&lineversion,
&linebuf, &linecount,
&linebuf_actuals, &linecount_actuals,
&err);
if(lres == DW_DLV_OK && linecount){
table_count++;
}
if(lres == DW_DLV_OK && linecount_actuals){
table_count++;
}
} else if (line_flag_selection == s2l) {
lres = dwarf_srclines_b(cu_die,&lineversion,
&table_count,&line_context,
&err);
if(lres == DW_DLV_OK) {
lres = dwarf_srclines_two_level_from_linecontext(line_context,
&linebuf, &linecount,
&linebuf_actuals, &linecount_actuals,
&err);
}
}
if (lres == DW_DLV_ERROR) {
/* Do not terminate processing */
if (check_decl_file) {
DWARF_CHECK_COUNT(decl_file_result,1);
DWARF_CHECK_ERROR2(decl_file_result,"dwarf_srclines",
dwarf_errmsg(err));
record_dwarf_error = FALSE; /* Clear error condition */
} else {
print_error(dbg, "dwarf_srclines", lres, err);
}
} else if (lres == DW_DLV_NO_ENTRY) {
/* no line information is included */
} else if (table_count > 0) {
/* DW_DLV_OK */
if(line_context && verbose) {
print_line_context_record(dbg,line_context);
}
if (do_print_dwarf) {
print_source_intro(cu_die);
if (verbose) {
print_one_die(dbg, cu_die,
/* print_information= */ TRUE,
/* indent_level= */ 0,
/* srcfiles= */ 0, /* cnt= */ 0,
/* ignore_die_stack= */TRUE);
}
}
if(line_flag_selection == std || line_flag_selection == s2l) {
if (table_count == 0 || table_count == 1) {
/* ASSERT: is_single_table == true */
Dwarf_Bool is_logicals = FALSE;
Dwarf_Bool is_actuals = FALSE;
process_line_table(dbg,sec_name, linebuf, linecount,
is_logicals,is_actuals);
} else {
Dwarf_Bool is_logicals = TRUE;
Dwarf_Bool is_actuals = FALSE;
process_line_table(dbg,sec_name, linebuf, linecount,
is_logicals, is_actuals);
process_line_table(dbg,sec_name, linebuf_actuals,
linecount_actuals,
!is_logicals, !is_actuals);
}
dwarf_srclines_dealloc_b(line_context);
} else if (line_flag_selection == orig) {
Dwarf_Bool is_logicals = FALSE;
Dwarf_Bool is_actuals = FALSE;
process_line_table(dbg,sec_name, linebuf, linecount,
is_logicals, is_actuals);
dwarf_srclines_dealloc(dbg,linebuf,linecount);
} else if (line_flag_selection == orig2l) {
if (table_count == 1 || table_count == 0) {
Dwarf_Bool is_logicals = FALSE;
Dwarf_Bool is_actuals = FALSE;
process_line_table(dbg,sec_name, linebuf, linecount,
is_logicals, is_actuals);
} else {
Dwarf_Bool is_logicals = TRUE;
Dwarf_Bool is_actuals = FALSE;
process_line_table(dbg,sec_name, linebuf, linecount,
is_logicals, is_actuals);
process_line_table(dbg,sec_name, linebuf_actuals, linecount_actuals,
!is_logicals, !is_actuals);
}
dwarf_srclines_dealloc(dbg,linebuf,linecount);
}
/* end, table_count > 0 */
} else {
/* DW_DLV_OK */
/* table_count == 0. no lines in table.
Just a line table header. */
if (do_print_dwarf) {
int ores = 0;
Dwarf_Unsigned off = 0;
print_source_intro(cu_die);
if (verbose) {
print_one_die(dbg, cu_die,
/* print_information= */ TRUE,
/* indent_level= */ 0,
/* srcfiles= */ 0, /* cnt= */ 0,
/* ignore_die_stack= */TRUE);
}
if(line_context) {
if (verbose > 2) {
print_line_context_record(dbg,line_context);
}
ores = dwarf_srclines_table_offset(line_context,
&off,&err);
if (ores != DW_DLV_OK) {
print_error(dbg,"dwarf_srclines_table_offset fail",ores,err);
} else {
printf(" Line table is present (offset 0x%"
DW_PR_XZEROS DW_PR_DUx
") but no lines present\n", off);
}
} else {
printf(" Line table is present but no lines present\n");
}
}
if(line_flag_selection == std ||
line_flag_selection == s2l) {
dwarf_srclines_dealloc_b(line_context);
} else {
/* Original allocation. */
dwarf_srclines_dealloc(dbg,linebuf,linecount);
}
/* end, linecounttotal == 0 */
}
}
