darkkirb/old-cross-binutils
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

2000-11-16 Kazu Hirata <kazu@hxi.com>

Browse source 
* dwarf1.c: Fix formatting.
	* dwarf2.c: Likewise.
This commit is contained in:
Kazu Hirata 2000-11-16 19:29:48 +00:00
parent 6f62085610
commit 98591c73cf
3 changed files with 172 additions and 179 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
bfd/ChangeLog
View file

@ -1,3 +1,8 @@
2000-11-16 Kazu Hirata <kazu@hxi.com>
* dwarf1.c: Fix formatting.
* dwarf2.c: Likewise.
2000-11-15 Kazu Hirata <kazu@hxi.com>
* coff-arm.c: Fix formatting.

206
bfd/dwarf1.c
View file

@ -1,7 +1,7 @@
/* DWARF 1 find nearest line (_bfd_dwarf1_find_nearest_line).
Copyright 1998, 1999, 2000 Free Software Foundation, Inc.
Written by Gavin Romig-Koch of Cygnus Solutions (gavin@cygnus.com).
Written by Gavin Romig-Koch of Cygnus Solutions (gavin@cygnus.com).
This file is part of BFD.
@ -26,121 +26,115 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
#include "elf-bfd.h"
#include "elf/dwarf.h"
/* dwarf1_debug is the starting point for all dwarf1 info. */
/* dwarf1_debug is the starting point for all dwarf1 info. */
struct dwarf1_debug {
/* The bfd we are working with. */
/* The bfd we are working with. */
bfd* abfd;
/* List of already parsed compilation units. */
/* List of already parsed compilation units. */
struct dwarf1_unit* lastUnit;
/* The buffer for the .debug section.
Zero indicates that the .debug section failed to load. */
/* The buffer for the .debug section.
Zero indicates that the .debug section failed to load. */
char* debug_section;
/* Pointer to the end of the .debug_info section memory buffer. */
/* Pointer to the end of the .debug_info section memory buffer. */
char* debug_section_end;
/* The buffer for the .line section. */
/* The buffer for the .line section. */
char* line_section;
/* End of that buffer. */
/* End of that buffer. */
char* line_section_end;
/* The current or next unread die within the .debug section. */
/* The current or next unread die within the .debug section. */
char* currentDie;
};
/* One dwarf1_unit for each parsed compilation unit die. */
/* One dwarf1_unit for each parsed compilation unit die. */
struct dwarf1_unit {
/* Linked starting from stash->lastUnit. */
/* Linked starting from stash->lastUnit. */
struct dwarf1_unit* prev;
/* Name of the compilation unit. */
/* Name of the compilation unit. */
char* name;
/* The highest and lowest address used in the compilation unit. */
/* The highest and lowest address used in the compilation unit. */
unsigned long low_pc;
unsigned long high_pc;
/* Does this unit have a statement list? */
int has_stmt_list;
/* If any, the offset of the line number table in the .line section. */
/* If any, the offset of the line number table in the .line section. */
unsigned long stmt_list_offset;
/* If non-zero, a pointer to the first child of this unit. */
/* If non-zero, a pointer to the first child of this unit. */
char* first_child;
/* How many line entries? */
unsigned long line_count;
/* The decoded line number table (line_count entries). */
/* The decoded line number table (line_count entries). */
struct linenumber* linenumber_table;
/* The list of functions in this unit. */
/* The list of functions in this unit. */
struct dwarf1_func* func_list;
};
/* One dwarf1_func for each parsed function die. */
struct dwarf1_func {
/* Linked starting from aUnit->func_list. */
/* Linked starting from aUnit->func_list. */
struct dwarf1_func* prev;
/* Name of function. */
/* Name of function. */
char* name;
/* The highest and lowest address used in the compilation unit. */
/* The highest and lowest address used in the compilation unit. */
unsigned long low_pc;
unsigned long high_pc;
};
/* Used to return info about a parsed die. */
/* Used to return info about a parsed die. */
struct die_info {
unsigned long length;
unsigned long sibling;
unsigned long low_pc;
unsigned long high_pc;
unsigned long stmt_list_offset;
char* name;
char* name;
int has_stmt_list;
unsigned short tag;
};
/* Parsed line number information. */
/* Parsed line number information. */
struct linenumber {
/* First address in the line. */
/* First address in the line. */
unsigned long addr;
/* The line number. */
/* The line number. */
unsigned long linenumber;
};
/* Find the form of an attr, from the attr field. */
/* Find the form of an attr, from the attr field. */
#define FORM_FROM_ATTR(attr) ((attr) & 0xF) /* Implicitly specified */
/* Return a newly allocated dwarf1_unit. It should be cleared and
then attached into the 'stash' at 'stash->lastUnit'. */
then attached into the 'stash' at 'stash->lastUnit'. */
static struct dwarf1_unit*
alloc_dwarf1_unit (stash)
struct dwarf1_debug* stash;
{
struct dwarf1_unit* x =
(struct dwarf1_unit*) bfd_zalloc (stash->abfd,
struct dwarf1_unit* x =
(struct dwarf1_unit*) bfd_zalloc (stash->abfd,
sizeof (struct dwarf1_unit));
x->prev = stash->lastUnit;
stash->lastUnit = x;
@ -149,28 +143,28 @@ alloc_dwarf1_unit (stash)
}
/* Return a newly allocated dwarf1_func. It must be cleared and
attached into 'aUnit' at 'aUnit->func_list'. */
attached into 'aUnit' at 'aUnit->func_list'. */
static struct dwarf1_func*
alloc_dwarf1_func (stash, aUnit)
struct dwarf1_debug* stash;
struct dwarf1_unit* aUnit;
{
struct dwarf1_func* x =
(struct dwarf1_func*) bfd_zalloc (stash->abfd,
struct dwarf1_func* x =
(struct dwarf1_func*) bfd_zalloc (stash->abfd,
sizeof (struct dwarf1_func));
x->prev = aUnit->func_list;
aUnit->func_list = x;
return x;
}
/* parse_die - parse a Dwarf1 die.
Parse the die starting at 'aDiePtr' into 'aDieInfo'.
'abfd' must be the bfd from which the section that 'aDiePtr'
points to was pulled from.
points to was pulled from.
Return false if the die is invalidly formatted; true otherwise. */
Return false if the die is invalidly formatted; true otherwise. */
static boolean
parse_die (abfd, aDieInfo, aDiePtr)
@ -181,36 +175,36 @@ parse_die (abfd, aDieInfo, aDiePtr)
char* this_die = aDiePtr;
char* xptr = this_die;
memset (aDieInfo,0,sizeof(*aDieInfo));
memset (aDieInfo,0,sizeof (*aDieInfo));
/* First comes the length. */
/* First comes the length. */
aDieInfo->length = bfd_get_32 (abfd, (bfd_byte *) xptr);
xptr += 4;
if (aDieInfo->length == 0)
return false;
if (aDieInfo->length < 6)
{
/* Just padding bytes. */
/* Just padding bytes. */
aDieInfo->tag = TAG_padding;
return true;
}
/* Then the tag. */
/* Then the tag. */
aDieInfo->tag = bfd_get_16 (abfd, (bfd_byte *) xptr);
xptr += 2;
/* Then the attributes. */
/* Then the attributes. */
while (xptr < (this_die + aDieInfo->length))
{
unsigned short attr;
/* Parse the attribute based on its form. This section
/* Parse the attribute based on its form. This section
must handle all dwarf1 forms, but need only handle the
actual attributes that we care about. */
actual attributes that we care about. */
attr = bfd_get_16 (abfd, (bfd_byte *) xptr);
xptr += 2;
switch (FORM_FROM_ATTR (attr))
{
case FORM_DATA2:
@ -255,9 +249,9 @@ parse_die (abfd, aDieInfo, aDiePtr)
}
/* Parse a dwarf1 line number table for 'aUnit->stmt_list_offset'
into 'aUnit->linenumber_table'. Return false if an error
occurs; true otherwise. */
into 'aUnit->linenumber_table'. Return false if an error
occurs; true otherwise. */
static boolean
parse_line_table (stash, aUnit)
struct dwarf1_debug* stash;
@ -265,19 +259,19 @@ parse_line_table (stash, aUnit)
{
char* xptr;
/* Load the ".line" section from the bfd if we haven't already. */
/* Load the ".line" section from the bfd if we haven't already. */
if (stash->line_section == 0)
{
asection *msec;
unsigned long size;
msec = bfd_get_section_by_name (stash->abfd, ".line");
if (! msec)
return false;
size = bfd_get_section_size_before_reloc (msec);
stash->line_section = (char *) bfd_alloc (stash->abfd, size);
if (! stash->line_section)
return false;
@ -298,11 +292,11 @@ parse_line_table (stash, aUnit)
char* tblend;
unsigned long base;
/* First comes the length. */
/* First comes the length. */
tblend = bfd_get_32 (stash->abfd, (bfd_byte *) xptr) + xptr;
xptr += 4;
/* Then the base address for each address in the table. */
/* Then the base address for each address in the table. */
base = bfd_get_32 (stash->abfd, (bfd_byte *) xptr);
xptr += 4;
@ -310,23 +304,23 @@ parse_line_table (stash, aUnit)
10 = 4 (line number) + 2 (pos in line) + 4 (address in line) */
aUnit->line_count = (tblend - xptr) / 10;
/* Allocate an array for the entries. */
/* Allocate an array for the entries. */
aUnit->linenumber_table = (struct linenumber *)
bfd_alloc (stash->abfd,
bfd_alloc (stash->abfd,
sizeof (struct linenumber) * aUnit->line_count);
for (eachLine = 0; eachLine < aUnit->line_count; eachLine++)
{
/* A line number. */
/* A line number. */
aUnit->linenumber_table[eachLine].linenumber
= bfd_get_32 (stash->abfd, (bfd_byte *) xptr);
xptr += 4;
/* Skip the position within the line. */
/* Skip the position within the line. */
xptr += 2;
/* And finally the address. */
aUnit->linenumber_table[eachLine].addr
/* And finally the address. */
aUnit->linenumber_table[eachLine].addr
= base + bfd_get_32 (stash->abfd, (bfd_byte *) xptr);
xptr += 4;
}
@ -338,7 +332,7 @@ parse_line_table (stash, aUnit)
/* Parse each function die in a compilation unit 'aUnit'.
The first child die of 'aUnit' should be in 'aUnit->first_child',
the result is placed in 'aUnit->func_list'.
Return false if error; true otherwise. */
Return false if error; true otherwise. */
static boolean
parse_functions_in_unit (stash, aUnit)
@ -353,37 +347,37 @@ parse_functions_in_unit (stash, aUnit)
)
{
struct die_info eachDieInfo;
if (! parse_die (stash->abfd, &eachDieInfo, eachDie))
return false;
if (eachDieInfo.tag == TAG_global_subroutine
|| eachDieInfo.tag == TAG_subroutine
|| eachDieInfo.tag == TAG_inlined_subroutine
|| eachDieInfo.tag == TAG_entry_point)
{
struct dwarf1_func* aFunc = alloc_dwarf1_func (stash,aUnit);
aFunc->name = eachDieInfo.name;
aFunc->low_pc = eachDieInfo.low_pc;
aFunc->high_pc = eachDieInfo.high_pc;
}
/* Move to next sibling, if none, end loop */
if (eachDieInfo.sibling)
eachDie = stash->debug_section + eachDieInfo.sibling;
else
break;
}
return true;
}
/* Find the nearest line to 'addr' in 'aUnit'.
Return whether we found the line (or a function) without error. */
Return whether we found the line (or a function) without error. */
static boolean
dwarf1_unit_find_nearest_line (stash, aUnit, addr,
dwarf1_unit_find_nearest_line (stash, aUnit, addr,
filename_ptr, functionname_ptr,
linenumber_ptr)
struct dwarf1_debug* stash;
@ -427,8 +421,8 @@ dwarf1_unit_find_nearest_line (stash, aUnit, addr,
}
}
for (eachFunc = aUnit->func_list;
eachFunc;
for (eachFunc = aUnit->func_list;
eachFunc;
eachFunc = eachFunc->prev)
{
if (eachFunc->low_pc <= addr
@ -445,11 +439,8 @@ dwarf1_unit_find_nearest_line (stash, aUnit, addr,
return line_p || func_p;
}
/* The DWARF 1 version of find_nearest line.
Return true if the line is found without error. */
Return true if the line is found without error. */
boolean
_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
@ -472,31 +463,30 @@ _bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
*filename_ptr = NULL;
*functionname_ptr = NULL;
*linenumber_ptr = 0;
if (! stash)
{
asection *msec;
unsigned long size;
stash = elf_tdata (abfd)->dwarf1_find_line_info =
(struct dwarf1_debug*) bfd_zalloc (abfd, sizeof (struct dwarf1_debug));
if (! stash)
return false;
msec = bfd_get_section_by_name (abfd, ".debug");
if (! msec)
{
/* No dwarf1 info. Note that at this point the stash
has been allocated, but contains zeros, this lets
future calls to this function fail quicker. */
future calls to this function fail quicker. */
return false;
}
size = bfd_get_section_size_before_reloc (msec);
stash->debug_section = (char *) bfd_alloc (abfd, size);
if (! stash->debug_section)
return false;
@ -512,20 +502,19 @@ _bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
}
/* A null debug_section indicates that there was no dwarf1 info
or that an error occured while setting up the stash. */
or that an error occured while setting up the stash. */
if (! stash->debug_section)
return false;
/* Look at the previously parsed units to see if any contain
the addr. */
the addr. */
for (eachUnit = stash->lastUnit; eachUnit; eachUnit = eachUnit->prev)
{
if (eachUnit->low_pc <= addr && addr < eachUnit->high_pc)
return dwarf1_unit_find_nearest_line (stash, eachUnit, addr,
filename_ptr,
functionname_ptr,
filename_ptr,
functionname_ptr,
linenumber_ptr);
}
@ -535,36 +524,36 @@ _bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
if (! parse_die (stash->abfd, &aDieInfo, stash->currentDie))
return false;
if (aDieInfo.tag == TAG_compile_unit)
{
struct dwarf1_unit* aUnit
= alloc_dwarf1_unit (stash);
aUnit->name = aDieInfo.name;
aUnit->low_pc = aDieInfo.low_pc;
aUnit->high_pc = aDieInfo.high_pc;
aUnit->has_stmt_list = aDieInfo.has_stmt_list;
aUnit->stmt_list_offset = aDieInfo.stmt_list_offset;
/* A die has a child if it's followed by a die that is
not it's sibling. */
if (aDieInfo.sibling
&& stash->currentDie + aDieInfo.length
not it's sibling. */
if (aDieInfo.sibling
&& stash->currentDie + aDieInfo.length
< stash->debug_section_end
&& stash->currentDie + aDieInfo.length
&& stash->currentDie + aDieInfo.length
!= stash->debug_section + aDieInfo.sibling)
aUnit->first_child = stash->currentDie + aDieInfo.length;
else
aUnit->first_child = 0;
if (aUnit->low_pc <= addr && addr < aUnit->high_pc)
return dwarf1_unit_find_nearest_line (stash, aUnit, addr,
filename_ptr,
functionname_ptr,
return dwarf1_unit_find_nearest_line (stash, aUnit, addr,
filename_ptr,
functionname_ptr,
linenumber_ptr);
}
if (aDieInfo.sibling != 0)
stash->currentDie = stash->debug_section + aDieInfo.sibling;
else
@ -574,5 +563,4 @@ _bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
return false;
}
/* EOF */

140
bfd/dwarf2.c
View file

@ -75,7 +75,7 @@ struct attribute
#define DW_SND(attr) ((attr)->u.snd)
#define DW_ADDR(attr) ((attr)->u.addr)
/* Blocks are a bunch of untyped bytes. */
/* Blocks are a bunch of untyped bytes. */
struct dwarf_block
{
unsigned int size;
@ -144,7 +144,7 @@ struct comp_unit
/* True if there is a line number table associated with this comp. unit. */
int stmtlist;
/* The offset into .debug_line of the line number table. */
unsigned long line_offset;
@ -158,14 +158,14 @@ struct comp_unit
struct line_info_table* line_table;
/* A list of the functions found in this comp. unit. */
struct funcinfo* function_table;
struct funcinfo* function_table;
/* Address size for this unit - from unit header. */
unsigned char addr_size;
};
/* VERBATIM
The following function up to the END VERBATIM mark are
/* VERBATIM
The following function up to the END VERBATIM mark are
copied directly from dwarf2read.c. */
/* Read dwarf information from a buffer. */
@ -260,7 +260,7 @@ read_string (abfd, buf, bytes_read_ptr)
*bytes_read_ptr = 1;
return NULL;
}
*bytes_read_ptr = strlen (buf) + 1;
return buf;
}
@ -279,7 +279,7 @@ read_unsigned_leb128 (abfd, buf, bytes_read_ptr)
result = 0;
shift = 0;
num_read = 0;
do
{
byte = bfd_get_8 (abfd, (bfd_byte *) buf);
@ -289,9 +289,9 @@ read_unsigned_leb128 (abfd, buf, bytes_read_ptr)
shift += 7;
}
while (byte & 0x80);
* bytes_read_ptr = num_read;
return result;
}
@ -319,12 +319,12 @@ read_signed_leb128 (abfd, buf, bytes_read_ptr)
shift += 7;
}
while (byte & 0x80);
if ((shift < 32) && (byte & 0x40))
result |= -(1 << shift);
* bytes_read_ptr = num_read;
return result;
}
@ -348,7 +348,7 @@ read_address (unit, buf)
}
}
/* This data structure holds the information of an abbrev. */
/* This data structure holds the information of an abbrev. */
struct abbrev_info
{
unsigned int number; /* Number identifying abbrev. */
@ -392,7 +392,7 @@ lookup_abbrev (number,abbrevs)
else
abbrev = abbrev->next;
}
return NULL;
}
@ -426,13 +426,13 @@ read_abbrevs (abfd, offset)
bfd_set_error (bfd_error_bad_value);
return 0;
}
stash->dwarf_abbrev_size = msec->_raw_size;
stash->dwarf_abbrev_buffer = (char*) bfd_alloc (abfd, stash->dwarf_abbrev_size);
if (! stash->dwarf_abbrev_buffer)
return 0;
if (! bfd_get_section_contents (abfd, msec,
if (! bfd_get_section_contents (abfd, msec,
stash->dwarf_abbrev_buffer, 0,
stash->dwarf_abbrev_size))
return 0;
@ -440,13 +440,13 @@ read_abbrevs (abfd, offset)
if (offset > stash->dwarf_abbrev_size)
{
(*_bfd_error_handler) (_("Dwarf Error: Abbrev offset (%u) bigger than abbrev size (%u)."),
(*_bfd_error_handler) (_("Dwarf Error: Abbrev offset (%u) bigger than abbrev size (%u)."),
offset, stash->dwarf_abbrev_size );
bfd_set_error (bfd_error_bad_value);
return 0;
}
abbrevs = (struct abbrev_info**) bfd_zalloc (abfd, sizeof(struct abbrev_info*) * ABBREV_HASH_SIZE);
abbrevs = (struct abbrev_info**) bfd_zalloc (abfd, sizeof (struct abbrev_info*) * ABBREV_HASH_SIZE);
abbrev_ptr = stash->dwarf_abbrev_buffer + offset;
abbrev_number = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
@ -469,7 +469,7 @@ read_abbrevs (abfd, offset)
abbrev_ptr += bytes_read;
abbrev_form = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
abbrev_ptr += bytes_read;
while (abbrev_name)
{
if ((cur_abbrev->num_attrs % ATTR_ALLOC_CHUNK) == 0)
@ -481,7 +481,7 @@ read_abbrevs (abfd, offset)
if (! cur_abbrev->attrs)
return 0;
}
cur_abbrev->attrs[cur_abbrev->num_attrs].name = abbrev_name;
cur_abbrev->attrs[cur_abbrev->num_attrs++].form = abbrev_form;
abbrev_name = read_unsigned_leb128 (abfd, abbrev_ptr, &bytes_read);
@ -528,7 +528,7 @@ read_attribute (attr, abbrev, unit, info_ptr)
attr->name = abbrev->name;
attr->form = abbrev->form;
switch (abbrev->form)
{
case DW_FORM_addr:
@ -664,7 +664,7 @@ struct line_info_table
struct line_info* last_line;
};
static void
static void
add_line_info (table, address, filename, line, column, end_sequence)
struct line_info_table* table;
bfd_vma address;
@ -723,7 +723,7 @@ arange_add (unit, low_pc, high_pc)
/* First see if we can cheaply extend an existing range. */
arange = &unit->arange;
do
{
if (low_pc == arange->high)
@ -787,13 +787,13 @@ decode_line_info (unit)
bfd_set_error (bfd_error_bad_value);
return 0;
}
stash->dwarf_line_size = msec->_raw_size;
stash->dwarf_line_buffer = (char *) bfd_alloc (abfd, stash->dwarf_line_size);
if (! stash->dwarf_line_buffer)
return 0;
if (! bfd_get_section_contents (abfd, msec,
if (! bfd_get_section_contents (abfd, msec,
stash->dwarf_line_buffer, 0,
stash->dwarf_line_size))
return 0;
@ -813,7 +813,7 @@ decode_line_info (unit)
return 0;
}
table = (struct line_info_table*) bfd_alloc (abfd,
table = (struct line_info_table*) bfd_alloc (abfd,
sizeof (struct line_info_table));
table->abfd = abfd;
table->comp_dir = unit->comp_dir;
@ -851,7 +851,7 @@ decode_line_info (unit)
bfd_alloc (abfd, lh.opcode_base * sizeof (unsigned char));
lh.standard_opcode_lengths[0] = 1;
for (i = 1; i < lh.opcode_base; ++i)
{
lh.standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
@ -862,7 +862,7 @@ decode_line_info (unit)
while ((cur_dir = read_string (abfd, line_ptr, &bytes_read)) != NULL)
{
line_ptr += bytes_read;
if ((table->num_dirs % DIR_ALLOC_CHUNK) == 0)
{
table->dirs = (char **)
@ -871,17 +871,17 @@ decode_line_info (unit)
if (! table->dirs)
return 0;
}
table->dirs[table->num_dirs++] = cur_dir;
}
line_ptr += bytes_read;
/* Read file name table. */
while ((cur_file = read_string (abfd, line_ptr, &bytes_read)) != NULL)
{
line_ptr += bytes_read;
if ((table->num_files % FILE_ALLOC_CHUNK) == 0)
{
table->files = (struct fileinfo *)
@ -891,7 +891,7 @@ decode_line_info (unit)
if (! table->files)
return 0;
}
table->files[table->num_files].name = cur_file;
table->files[table->num_files].dir =
read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
@ -904,7 +904,7 @@ decode_line_info (unit)
line_ptr += bytes_read;
table->num_files++;
}
line_ptr += bytes_read;
/* Read the statement sequences until there's nothing left. */
@ -925,7 +925,7 @@ decode_line_info (unit)
{
op_code = read_1_byte (abfd, line_ptr);
line_ptr += 1;
switch (op_code)
{
case DW_LNS_extended_op:
@ -1051,9 +1051,9 @@ decode_line_info (unit)
LINENUMBER_PTR, are pointers to the objects to be filled in. */
static boolean
lookup_address_in_line_info_table (table,
lookup_address_in_line_info_table (table,
addr,
filename_ptr,
filename_ptr,
linenumber_ptr)
struct line_info_table* table;
bfd_vma addr;
@ -1062,7 +1062,7 @@ lookup_address_in_line_info_table (table,
{
struct line_info* next_line = table->last_line;
struct line_info* each_line;
if (!next_line)
return false;
@ -1080,10 +1080,10 @@ lookup_address_in_line_info_table (table,
next_line = each_line;
each_line = each_line->prev_line;
}
return false;
}
/* Function table functions. */
struct funcinfo
@ -1094,10 +1094,10 @@ struct funcinfo
bfd_vma high;
};
/* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return true. */
/* If ADDR is within TABLE, set FUNCTIONNAME_PTR, and return true. */
static boolean
lookup_address_in_function_table (table,
lookup_address_in_function_table (table,
addr,
functionname_ptr)
struct funcinfo* table;
@ -1116,7 +1116,7 @@ lookup_address_in_function_table (table,
return true;
}
}
return false;
}
@ -1149,16 +1149,16 @@ scan_unit_for_functions (unit)
nesting_level--;
continue;
}
abbrev = lookup_abbrev (abbrev_number,unit->abbrevs);
if (! abbrev)
{
(*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %d."),
(*_bfd_error_handler) (_("Dwarf Error: Could not find abbrev number %d."),
abbrev_number);
bfd_set_error (bfd_error_bad_value);
return false;
}
if (abbrev->tag == DW_TAG_subprogram)
{
func = (struct funcinfo*) bfd_zalloc (abfd, sizeof (struct funcinfo));
@ -1167,24 +1167,24 @@ scan_unit_for_functions (unit)
}
else
func = NULL;
for (i = 0; i < abbrev->num_attrs; ++i)
{
info_ptr = read_attribute (&attr, &abbrev->attrs[i], unit, info_ptr);
if (func)
{
switch (attr.name)
{
case DW_AT_name:
name = DW_STRING (&attr);
/* Prefer DW_AT_MIPS_linkage_name over DW_AT_name. */
if (func->name == NULL)
func->name = DW_STRING (&attr);
break;
case DW_AT_MIPS_linkage_name:
func->name = DW_STRING (&attr);
break;
@ -1208,7 +1208,7 @@ scan_unit_for_functions (unit)
case DW_AT_name:
name = DW_STRING (&attr);
break;
default:
break;
}
@ -1309,10 +1309,10 @@ parse_comp_unit (abfd, info_ptr, end_ptr, abbrev_length)
bfd_set_error (bfd_error_bad_value);
return 0;
}
unit = (struct comp_unit*) bfd_zalloc (abfd, sizeof (struct comp_unit));
unit->abfd = abfd;
unit->addr_size = addr_size;
unit->addr_size = addr_size;
unit->abbrevs = abbrevs;
unit->end_ptr = end_ptr;
@ -1386,14 +1386,14 @@ comp_unit_contains_address (unit, addr)
arange = arange->next;
}
while (arange);
return 0;
}
/* If UNIT contains ADDR, set the output parameters to the values for
the line containing ADDR. The output parameters, FILENAME_PTR,
FUNCTIONNAME_PTR, and LINENUMBER_PTR, are pointers to the objects
to be filled in.
to be filled in.
Return true of UNIT contains ADDR, and no errors were encountered;
false otherwise. */
@ -1409,7 +1409,7 @@ comp_unit_find_nearest_line (unit, addr,
{
boolean line_p;
boolean func_p;
if (unit->error)
return false;
@ -1420,7 +1420,7 @@ comp_unit_find_nearest_line (unit, addr,
unit->error = 1;
return false;
}
unit->line_table = decode_line_info (unit);
if (! unit->line_table)
@ -1428,7 +1428,7 @@ comp_unit_find_nearest_line (unit, addr,
unit->error = 1;
return false;
}
if (! scan_unit_for_functions (unit))
{
unit->error = 1;
@ -1438,9 +1438,9 @@ comp_unit_find_nearest_line (unit, addr,
line_p = lookup_address_in_line_info_table (unit->line_table,
addr,
filename_ptr,
filename_ptr,
linenumber_ptr);
func_p = lookup_address_in_function_table (unit->function_table,
func_p = lookup_address_in_function_table (unit->function_table,
addr,
functionname_ptr);
return line_p || func_p;
@ -1506,10 +1506,10 @@ _bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
/* Read each compilation unit from the section .debug_info, and check
to see if it contains the address we are searching for. If yes,
lookup the address, and return the line number info. If no, go
on to the next compilation unit.
on to the next compilation unit.
We keep a list of all the previously read compilation units, and
a pointer to the next un-read compilation unit. Check the
a pointer to the next un-read compilation unit. Check the
previously read units before reading more. */
struct dwarf2_debug *stash = elf_tdata (abfd)->dwarf2_find_line_info;
@ -1517,7 +1517,7 @@ _bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
bfd_vma addr = offset + section->vma;
struct comp_unit* each;
*filename_ptr = NULL;
*functionname_ptr = NULL;
*linenumber_ptr = 0;
@ -1528,7 +1528,7 @@ _bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
if (addr_size == 0)
addr_size = 4;
BFD_ASSERT (addr_size == 4 || addr_size == 8);
if (! stash)
{
unsigned long total_size;
@ -1553,7 +1553,7 @@ _bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
us to avoid reallocing the data as we add sections to the stash. */
for (total_size = 0; msec; msec = find_debug_info (abfd, msec))
total_size += msec->_raw_size;
stash->info_ptr = (char *) bfd_alloc (abfd, total_size);
if (stash->info_ptr == NULL)
return false;
@ -1590,14 +1590,14 @@ _bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
relocs. There is a similar problem when the .debug_line
section is processed as well (e.g., there may be relocs
against the operand of the DW_LNE_set_address operator).
Unfortunately getting hold of the reloc information is hard...
For now, this means that disassembling object files (as
opposed to fully executables) does not always work as well as
we would like. */
/* A null info_ptr indicates that there is no dwarf2 info
/* A null info_ptr indicates that there is no dwarf2 info
(or that an error occured while setting up the stash). */
if (! stash->info_ptr)
return false;
@ -1605,7 +1605,7 @@ _bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
/* Check the previously read comp. units first. */
for (each = stash->all_comp_units; each; each = each->next_unit)
if (comp_unit_contains_address (each, addr))
return comp_unit_find_nearest_line (each, addr, filename_ptr,
return comp_unit_find_nearest_line (each, addr, filename_ptr,
functionname_ptr, linenumber_ptr);
/* Read each remaining comp. units checking each as they are read. */
@ -1623,7 +1623,7 @@ _bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
if (length > 0)
{
each = parse_comp_unit (abfd, stash->info_ptr,
each = parse_comp_unit (abfd, stash->info_ptr,
stash->info_ptr + length,
addr_size);
stash->info_ptr += length;