/*
Copyright (C) 2000,2002,2004,2005,2006 Silicon Graphics, Inc. All Rights Reserved.
Portions Copyright (C) 2007-2010 David Anderson. All Rights Reserved.
under the terms of version 2.1 of the GNU Lesser General Public License
as published by the Free Software Foundation.
This program is distributed in the hope that it would be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
Further, this software is distributed without any warranty that it is
free of the rightful claim of any third person regarding infringement
or the like. Any license provided herein, whether implied or
otherwise, applies only to this software file. Patent licenses, if
any, provided herein do not apply to combinations of this program with
other software, or any other product whatsoever.
You should have received a copy of the GNU Lesser General Public
License along with this program; if not, write the Free Software
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston MA 02110-1301,
USA.
Contact information: Silicon Graphics, Inc., 1500 Crittenden Lane,
Mountain View, CA 94043, or:
For further information regarding this notice, see:
*/
/* The address of the Free Software Foundation is
Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
Boston, MA 02110-1301, USA.
SGI has moved from the Crittenden Lane address.
*/
#include "config.h"
#include "dwarf_incl.h"
#include <stdio.h>
#include <time.h>
#include "dwarf_line.h"
/* FIXME Need to add prologue_end epilogue_begin isa fields. */
static void
print_line_header(void)
{
(" s b e\n"
" t l s\n"
" m c e\n"
" section op col t k q\n"
" offset code address file line umn ? ? ?\n");
}
/* FIXME: print new line values: prologue_end epilogue_begin isa */
static void
int opcode,
unsigned long file,
unsigned long line,
unsigned long column,
{
"%2lu %4lu %2lu %1d %1d %1d\n",
(int) opcode,
(unsigned long) file,
(unsigned long) line,
(unsigned long) column,
}
/*
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
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. */
/*
This points to the last byte of the .debug_line portion for the
current cu. */
/*
Pointer to a DW_AT_stmt_list attribute in case it exists in the
die. */
/* Pointer to DW_AT_comp_dir attribute in die. */
/* Pointer to name of compilation directory. */
/*
Offset into .debug_line specified by a DW_AT_stmt_list
attribute. */
/* These are the state machine state variables. */
Dwarf_Sword i=0;
/*
This is the current opcode read from the statement program. */
/*
These variables are used to decode leb128 numbers. Leb128_num
holds the decoded number, and leb128_length is its length in
bytes. */
/*
This is the operand of the latest fixed_advance_pc extended
opcode. */
/* 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.
*/
/* The Dwarf_Debug this die belongs to. */
/* ***** BEGIN CODE ***** */
}
return res;
}
return resattr;
}
/* The list of relevant FORMs is small.
DW_FORM_data4, DW_FORM_data8, DW_FORM_sec_offset
*/
return lres;
}
attrform != DW_FORM_sec_offset ) {
return (DW_DLV_ERROR);
}
return lres;
}
return (DW_DLV_ERROR);
}
/*
If die has DW_AT_comp_dir attribute, get the string that names
the compilation directory. */
if (resattr == DW_DLV_ERROR) {
return resattr;
}
char *cdir = 0;
if (cres == DW_DLV_ERROR) {
return cres;
}
}
}
{
&prefix,
if (dres == DW_DLV_ERROR) {
return dres;
}
if (dres == DW_DLV_NO_ENTRY) {
return dres;
}
}
if(only_line_header) {
/* Just checking for header errors, nothing more here.*/
return DW_DLV_OK;
}
printf("total line info length %ld bytes, "
(long) prefix.pf_total_length,
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",
printf(" min instruction length %d\n",
(int) prefix.pf_minimum_instruction_length);
printf(" default is stmt %d\n", (int)
printf(" line base %d\n", (int)
printf(" line_range %d\n", (int)
printf(" opcode base %d\n", (int)
printf(" standard opcode count %d\n", (int)
printf(" opcode[%2d] length %d\n", (int) i,
}
printf(" include directories count %d\n", (int)
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)
for (i = 0; i < prefix.pf_files_count; ++i) {
printf(" file[%d] %s (file-number: %d) \n",
(int) i, (char *) lfile->lte_filename,
(int)(i+1));
{
newline */
}
printf(" file length %ld 0x%lx\n",
}
{
if(bogus_bytes_count > 0) {
printf("*** DWARF CHECK: the line table prologue header_length "
*err_count_out += 1;
}
}
/* Initialize the part of the state machine dependent on the
prefix. */
/* Start of statement program. */
while (line_ptr < line_ptr_end) {
int type = 0;
line_ptr++;
/* 'type' is the output */
if (type == LOP_DISCARD) {
int oc;
printf("*** DWARF CHECK: DISCARD standard opcode %d "
"with %d operands: "
*err_count_out += 1;
/*
* Read and discard operands we don't
* understand.
* Arbitrary choice of unsigned read.
* Signed read would work as well.
*/
(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) */
line =
basic_block = false;
} else if (type == LOP_STANDARD) {
switch (opcode) {
case DW_LNS_copy:{
print_line_detail("DW_LNS_copy",
basic_block = false;
break;
}
case DW_LNS_advance_pc:{
address =
address +
break;
}
case DW_LNS_advance_line:{
break;
}
case DW_LNS_set_file:{
break;
}
case DW_LNS_set_column:{
break;
}
case DW_LNS_negate_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:{
address =
address +
(Dwarf_Signed) address);
break;
}
case DW_LNS_fixed_advance_pc:{
line_ptr, sizeof(Dwarf_Half));
line_ptr += sizeof(Dwarf_Half);
(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);
/* The value of the isa did not fit in our
local so we record it wrong. declare an
error. */
return (DW_DLV_ERROR);
}
break;
}
}
} else if (type == LOP_EXTENDED) {
line_ptr++;
switch (ext_opcode) {
case DW_LNE_end_sequence:{
end_sequence = true;
print_line_detail("DW_LNE_end_sequence extended",
address = 0;
file = 1;
line = 1;
column = 0;
basic_block = false;
end_sequence = false;
prologue_end = false;
epilogue_begin = false;
break;
}
case DW_LNE_set_address:{
{
}
break;
}
case DW_LNE_define_file:{
{
/* ctime supplies newline */
printf(" last time 0x%x %s",
}
printf(" file length %ld 0x%lx\n",
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). */
return (DW_DLV_ERROR);
}
if(remaining_bytes > 0) {
printf(" linedata: 0x");
while (remaining_bytes > 0) {
line_ptr++;
}
}
printf("\n");
}
break;
}
}
}
return (DW_DLV_OK);
}
/*
This is support for dwarfdump: making it possible
for clients wanting line detail info on stdout
to get that detail without including internal libdwarf
header information.
Caller passes in compilation unit DIE.
The _dwarf_ version is obsolete (though supported for
compatibility).
The dwarf_ version is preferred.
The functions are intentionally identical: having
_dwarf_print_lines call dwarf_print_lines might
better emphasize they are intentionally identical, but
that seemed slightly silly given how short the functions are.
Interface adds error_count (output value) February 2009.
*/
int
{
int only_line_header = 0;
return res;
}
return res;
}
int
{
int only_line_header = 0;
int err_count = 0;
/* No way to get error count back in this interface */
return res;
}
return res;
}
/* The check is in case we are not printing full line data,
this gets some of the issues noted with .debug_line,
but not all. Call dwarf_print_lines() to get all issues.
Intended for apps like dwarfdump.
*/
void
{
return;
}