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

2000-09-07 Kazu Hirata <kazu@hxi.com>

Browse source 
* elf.c: Fix formatting.
This commit is contained in:
Kazu Hirata 2000-09-07 20:20:05 +00:00
parent 0fc93e6bc4
commit c044fabd5e
2 changed files with 156 additions and 162 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
bfd/ChangeLog
View file

@ -1,3 +1,7 @@
2000-09-07 Kazu Hirata <kazu@hxi.com>
* elf.c: Fix formatting.
2000-09-07 Alexandre Oliva <aoliva@redhat.com>
* config.bfd (sh-*-linux*): Added.

314
bfd/elf.c
View file

@ -229,11 +229,11 @@ bfd_elf_hash (namearg)
/* Read a specified number of bytes at a specified offset in an ELF
file, into a newly allocated buffer, and return a pointer to the
buffer. */
buffer. */
static char *
elf_read (abfd, offset, size)
bfd * abfd;
bfd *abfd;
long offset;
unsigned int size;
{
@ -254,31 +254,31 @@ elf_read (abfd, offset, size)
boolean
bfd_elf_mkobject (abfd)
bfd * abfd;
bfd *abfd;
{
/* this just does initialization */
/* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
/* This just does initialization. */
/* coff_mkobject zalloc's space for tdata.coff_obj_data ... */
elf_tdata (abfd) = (struct elf_obj_tdata *)
bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
if (elf_tdata (abfd) == 0)
return false;
/* since everything is done at close time, do we need any
initialization? */
/* Since everything is done at close time, do we need any
initialization? */
return true;
}
boolean
bfd_elf_mkcorefile (abfd)
bfd * abfd;
bfd *abfd;
{
/* I think this can be done just like an object file. */
/* I think this can be done just like an object file. */
return bfd_elf_mkobject (abfd);
}
char *
bfd_elf_get_str_section (abfd, shindex)
bfd * abfd;
bfd *abfd;
unsigned int shindex;
{
Elf_Internal_Shdr **i_shdrp;
@ -293,7 +293,7 @@ bfd_elf_get_str_section (abfd, shindex)
shstrtab = (char *) i_shdrp[shindex]->contents;
if (shstrtab == NULL)
{
/* No cached one, attempt to read, and cache what we read. */
/* No cached one, attempt to read, and cache what we read. */
offset = i_shdrp[shindex]->sh_offset;
shstrtabsize = i_shdrp[shindex]->sh_size;
shstrtab = elf_read (abfd, offset, shstrtabsize);
@ -304,7 +304,7 @@ bfd_elf_get_str_section (abfd, shindex)
char *
bfd_elf_string_from_elf_section (abfd, shindex, strindex)
bfd * abfd;
bfd *abfd;
unsigned int shindex;
unsigned int strindex;
{
@ -384,7 +384,7 @@ _bfd_elf_make_section_from_shdr (abfd, hdr, name)
/* The debugging sections appear to be recognized only by name, not
any sort of flag. */
{
const char * debug_sec_names [] =
const char *debug_sec_names [] =
{
".debug",
".gnu.linkonce.wi.",
@ -472,7 +472,7 @@ DESCRIPTION
struct elf_internal_shdr *
bfd_elf_find_section (abfd, name)
bfd * abfd;
bfd *abfd;
char *name;
{
Elf_Internal_Shdr **i_shdrp;
@ -512,7 +512,6 @@ const char *const bfd_elf_section_type_names[] = {
function. It just short circuits the reloc if producing
relocateable output against an external symbol. */
/*ARGSUSED*/
bfd_reloc_status_type
bfd_elf_generic_reloc (abfd,
reloc_entry,
@ -804,12 +803,12 @@ bfd_elf_print_symbol (abfd, filep, symbol, how)
CONST char *name = NULL;
struct elf_backend_data *bed;
unsigned char st_other;
section_name = symbol->section ? symbol->section->name : "(*none*)";
bed = get_elf_backend_data (abfd);
if (bed->elf_backend_print_symbol_all)
name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
if (name == NULL)
{
@ -880,7 +879,7 @@ bfd_elf_print_symbol (abfd, filep, symbol, how)
/* If the st_other field is not zero, print it. */
st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
switch (st_other)
{
case 0: break;
@ -1222,7 +1221,7 @@ _bfd_elf_stringtab_init ()
/* ELF .o/exec file reading */
/* Create a new bfd section from an ELF section header. */
/* Create a new bfd section from an ELF section header. */
boolean
bfd_section_from_shdr (abfd, shindex)
@ -1395,9 +1394,9 @@ bfd_section_from_shdr (abfd, shindex)
/* If this reloc section does not use the main symbol table we
don't treat it as a reloc section. BFD can't adequately
represent such a section, so at least for now, we don't
try. We just present it as a normal section. We also
try. We just present it as a normal section. We also
can't use it as a reloc section if it points to the null
section. */
section. */
if (hdr->sh_link != elf_onesymtab (abfd) || hdr->sh_info == SHN_UNDEF)
return _bfd_elf_make_section_from_shdr (abfd, hdr, name);
@ -1492,7 +1491,7 @@ _bfd_elf_new_section_hook (abfd, sec)
sec->used_by_bfd = (PTR) sdata;
/* Indicate whether or not this section should use RELA relocations. */
sdata->use_rela_p
sdata->use_rela_p
= get_elf_backend_data (abfd)->default_use_rela_p;
return true;
@ -1555,7 +1554,7 @@ _bfd_elf_make_section_from_phdr (abfd, hdr, index, typename)
if (hdr->p_flags & PF_X)
{
/* FIXME: all we known is that it has execute PERMISSION,
may be data. */
may be data. */
newsect->flags |= SEC_CODE;
}
}
@ -1627,7 +1626,7 @@ bfd_section_from_phdr (abfd, hdr, index)
default:
/* Check for any processor-specific program segment types.
If no handler for them, default to making "segment" sections. */
If no handler for them, default to making "segment" sections. */
bed = get_elf_backend_data (abfd);
if (bed->elf_backend_section_from_phdr)
return (*bed->elf_backend_section_from_phdr) (abfd, hdr, index);
@ -1675,7 +1674,6 @@ _bfd_elf_init_reloc_shdr (abfd, rel_hdr, asect, use_rela_p)
/* Set up an ELF internal section header for a section. */
/*ARGSUSED*/
static void
elf_fake_sections (abfd, asect, failedptrarg)
bfd *abfd;
@ -1814,11 +1812,11 @@ elf_fake_sections (abfd, asect, failedptrarg)
/* If the section has relocs, set up a section header for the
SHT_REL[A] section. If two relocation sections are required for
this section, it is up to the processor-specific back-end to
create the other. */
create the other. */
if ((asect->flags & SEC_RELOC) != 0
&& !_bfd_elf_init_reloc_shdr (abfd,
&& !_bfd_elf_init_reloc_shdr (abfd,
&elf_section_data (asect)->rel_hdr,
asect,
asect,
elf_section_data (asect)->use_rela_p))
*failedptr = true;
}
@ -2058,7 +2056,7 @@ elf_map_symbols (abfd)
for (idx = 0; idx < symcount; idx++)
{
sym = syms[idx];
if ((sym->flags & BSF_SECTION_SYM) != 0
&& sym->value == 0)
{
@ -2072,7 +2070,7 @@ elf_map_symbols (abfd)
{
if (sec->output_offset != 0)
continue;
sec = sec->output_section;
/* Empty sections in the input files may have had a section
@ -3368,10 +3366,10 @@ prep_headers (abfd)
case 0: i_ehdrp->e_machine = EM_CYGNUS_V850; break;
}
break;
case bfd_arch_arc:
case bfd_arch_arc:
i_ehdrp->e_machine = EM_CYGNUS_ARC;
break;
case bfd_arch_arm:
case bfd_arch_arm:
i_ehdrp->e_machine = EM_ARM;
break;
case bfd_arch_m32r:
@ -3396,24 +3394,24 @@ prep_headers (abfd)
i_ehdrp->e_version = bed->s->ev_current;
i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
/* no program header, for now. */
/* No program header, for now. */
i_ehdrp->e_phoff = 0;
i_ehdrp->e_phentsize = 0;
i_ehdrp->e_phnum = 0;
/* each bfd section is section header entry */
/* Each bfd section is section header entry. */
i_ehdrp->e_entry = bfd_get_start_address (abfd);
i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
/* if we're building an executable, we'll need a program header table */
/* If we're building an executable, we'll need a program header table. */
if (abfd->flags & EXEC_P)
{
/* it all happens later */
/* It all happens later. */
#if 0
i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
/* elf_build_phdrs() returns a (NULL-terminated) array of
Elf_Internal_Phdrs */
Elf_Internal_Phdrs. */
i_phdrp = elf_build_phdrs (abfd, i_ehdrp, i_shdrp, &i_ehdrp->e_phnum);
i_ehdrp->e_phoff = outbase;
outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum;
@ -3493,7 +3491,7 @@ _bfd_elf_write_object_contents (abfd)
_bfd_elf_assign_file_positions_for_relocs (abfd);
/* After writing the headers, we need to write the sections too... */
/* After writing the headers, we need to write the sections too... */
for (count = 1; count < i_ehdrp->e_shnum; count++)
{
if (bed->elf_backend_section_processing)
@ -3524,10 +3522,12 @@ boolean
_bfd_elf_write_corefile_contents (abfd)
bfd *abfd;
{
/* Hopefully this can be done just like an object file. */
/* Hopefully this can be done just like an object file. */
return _bfd_elf_write_object_contents (abfd);
}
/* given a section, search the header to find them... */
/* Given a section, search the header to find them. */
int
_bfd_elf_section_from_bfd_section (abfd, asect)
bfd *abfd;
@ -3649,7 +3649,7 @@ copy_private_bfd_data (ibfd, obfd)
struct elf_segment_map * phdr_adjust_seg = NULL;
unsigned int phdr_adjust_num = 0;
if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
|| bfd_get_flavour (obfd) != bfd_target_elf_flavour)
return true;
@ -3659,7 +3659,7 @@ copy_private_bfd_data (ibfd, obfd)
iehdr = elf_elfheader (ibfd);
map_first = NULL;
pointer_to_map = & map_first;
pointer_to_map = &map_first;
num_segments = elf_elfheader (ibfd)->e_phnum;
maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
@ -3675,7 +3675,7 @@ copy_private_bfd_data (ibfd, obfd)
(section->vma >= segment->p_vaddr \
&& (section->vma + section->_raw_size) \
<= (SEGMENT_END (segment, segment->p_vaddr)))
/* Returns true if the given section is contained within
the given segment. LMA addresses are compared. */
#define IS_CONTAINED_BY_LMA(section, segment, base) \
@ -3683,7 +3683,7 @@ copy_private_bfd_data (ibfd, obfd)
&& (section->lma + section->_raw_size) \
<= SEGMENT_END (segment, base))
/* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
/* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
#define IS_COREFILE_NOTE(p, s) \
(p->p_type == PT_NOTE \
&& bfd_get_format (ibfd) == bfd_core \
@ -3736,39 +3736,40 @@ copy_private_bfd_data (ibfd, obfd)
parameters to objcopy. */
for (i = 0, segment = elf_tdata (ibfd)->phdr;
i < num_segments;
i ++, segment ++)
i++, segment++)
{
unsigned int j;
Elf_Internal_Phdr * segment2;
Elf_Internal_Phdr *segment2;
if (segment->p_type != PT_LOAD)
continue;
/* Determine if this segment overlaps any previous segments. */
for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j ++, segment2 ++)
for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2 ++)
{
bfd_signed_vma extra_length;
if (segment2->p_type != PT_LOAD
|| ! SEGMENT_OVERLAPS (segment, segment2))
continue;
/* Merge the two segments together. */
if (segment2->p_vaddr < segment->p_vaddr)
{
/* Extend SEGMENT2 to include SEGMENT and then delete SEGMENT. */
/* Extend SEGMENT2 to include SEGMENT and then delete
SEGMENT. */
extra_length =
SEGMENT_END (segment, segment->p_vaddr)
- SEGMENT_END (segment2, segment2->p_vaddr);
if (extra_length > 0)
{
segment2->p_memsz += extra_length;
segment2->p_filesz += extra_length;
}
segment->p_type = PT_NULL;
/* Since we have deleted P we must restart the outer loop. */
i = 0;
segment = elf_tdata (ibfd)->phdr;
@ -3776,22 +3777,23 @@ copy_private_bfd_data (ibfd, obfd)
}
else
{
/* Extend SEGMENT to include SEGMENT2 and then delete SEGMENT2. */
/* Extend SEGMENT to include SEGMENT2 and then delete
SEGMENT2. */
extra_length =
SEGMENT_END (segment2, segment2->p_vaddr)
- SEGMENT_END (segment, segment->p_vaddr);
if (extra_length > 0)
{
segment->p_memsz += extra_length;
segment->p_filesz += extra_length;
}
segment2->p_type = PT_NULL;
}
}
}
/* The second scan attempts to assign sections to segments. */
for (i = 0, segment = elf_tdata (ibfd)->phdr;
i < num_segments;
@ -3807,12 +3809,12 @@ copy_private_bfd_data (ibfd, obfd)
if (segment->p_type == PT_NULL)
continue;
/* Compute how many sections might be placed into this segment. */
section_count = 0;
for (section = ibfd->sections; section != NULL; section = section->next)
if (INCLUDE_SECTION_IN_SEGMENT (section, segment))
++ section_count;
++section_count;
/* Allocate a segment map big enough to contain all of the
sections we have selected. */
@ -3846,7 +3848,7 @@ copy_private_bfd_data (ibfd, obfd)
&& (segment->p_offset + segment->p_filesz
>= ((bfd_vma) iehdr->e_phoff
+ iehdr->e_phnum * iehdr->e_phentsize)));
if (segment->p_type == PT_LOAD && map->includes_phdrs)
phdr_included = true;
}
@ -3862,8 +3864,8 @@ copy_private_bfd_data (ibfd, obfd)
bfd_get_filename (ibfd));
map->count = 0;
* pointer_to_map = map;
pointer_to_map = & map->next;
*pointer_to_map = map;
pointer_to_map = &map->next;
continue;
}
@ -3966,8 +3968,8 @@ copy_private_bfd_data (ibfd, obfd)
the list of built segments and carry on to process the next
program header in the input BFD. */
map->count = section_count;
* pointer_to_map = map;
pointer_to_map = & map->next;
*pointer_to_map = map;
pointer_to_map = &map->next;
free (sections);
continue;
@ -4032,7 +4034,7 @@ copy_private_bfd_data (ibfd, obfd)
output_section = section->output_section;
BFD_ASSERT (output_section != NULL);
if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
|| IS_COREFILE_NOTE (segment, section))
{
@ -4081,8 +4083,8 @@ copy_private_bfd_data (ibfd, obfd)
BFD_ASSERT (map->count > 0);
/* Add the current segment to the list of built segments. */
* pointer_to_map = map;
pointer_to_map = & map->next;
*pointer_to_map = map;
pointer_to_map = &map->next;
if (isec < section_count)
{
@ -4136,20 +4138,21 @@ copy_private_bfd_data (ibfd, obfd)
if (phdr_adjust_seg != NULL)
{
unsigned int count;
for (count = 0, map = map_first; map != NULL; map = map->next)
count ++;
count++;
if (count > phdr_adjust_num)
phdr_adjust_seg->p_paddr
-= (count - phdr_adjust_num) * iehdr->e_phentsize;
}
#if 0
/* Final Step: Sort the segments into ascending order of physical address. */
/* Final Step: Sort the segments into ascending order of physical
address. */
if (map_first != NULL)
{
struct elf_segment_map * prev;
struct elf_segment_map *prev;
prev = map_first;
for (map = map_first->next; map != NULL; prev = map, map = map->next)
@ -4298,7 +4301,7 @@ swap_out_syms (abfd, sttp, relocatable_p)
if (!elf_map_symbols (abfd))
return false;
/* Dump out the symtabs. */
/* Dump out the symtabs. */
{
int symcount = bfd_get_symcount (abfd);
asymbol **syms = bfd_get_outsymbols (abfd);
@ -4989,7 +4992,7 @@ _bfd_elf_find_nearest_line (abfd,
asymbol **p;
if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
filename_ptr, functionname_ptr,
filename_ptr, functionname_ptr,
line_ptr))
return true;
@ -5116,7 +5119,7 @@ _bfd_elf_validate_reloc (abfd, areloc)
bfd *abfd;
arelent *areloc;
{
/* Check whether we really have an ELF howto. */
/* Check whether we really have an ELF howto. */
if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
{
@ -5124,7 +5127,7 @@ _bfd_elf_validate_reloc (abfd, areloc)
reloc_howto_type *howto;
/* Alien reloc: Try to determine its type to replace it with an
equivalent ELF reloc. */
equivalent ELF reloc. */
if (areloc->howto->pc_relative)
{
@ -5237,48 +5240,44 @@ _bfd_elf_rel_vtable_reloc_fn (abfd, re, symbol, data, is, obfd, errmsg)
{
return bfd_reloc_ok;
}
/* Elf core file support. Much of this only works on native
toolchains, since we rely on knowing the
machine-dependent procfs structure in order to pick
out details about the corefile. */
out details about the corefile. */
#ifdef HAVE_SYS_PROCFS_H
# include <sys/procfs.h>
#endif
/* Define offsetof for those systems which lack it. */
/* Define offsetof for those systems which lack it. */
#ifndef offsetof
# define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
#endif
/* FIXME: this is kinda wrong, but it's what gdb wants. */
/* FIXME: this is kinda wrong, but it's what gdb wants. */
static int
elfcore_make_pid (abfd)
bfd* abfd;
bfd *abfd;
{
return ((elf_tdata (abfd)->core_lwpid << 16)
+ (elf_tdata (abfd)->core_pid));
}
/* If there isn't a section called NAME, make one, using
data from SECT. Note, this function will generate a
reference to NAME, so you shouldn't deallocate or
overwrite it. */
overwrite it. */
static boolean
elfcore_maybe_make_sect (abfd, name, sect)
bfd* abfd;
char* name;
asection* sect;
bfd *abfd;
char *name;
asection *sect;
{
asection* sect2;
asection *sect2;
if (bfd_get_section_by_name (abfd, name) != NULL)
return true;
@ -5294,7 +5293,6 @@ elfcore_maybe_make_sect (abfd, name, sect)
return true;
}
/* prstatus_t exists on:
solaris 2.5+
linux 2.[01] + glibc
@ -5304,12 +5302,12 @@ elfcore_maybe_make_sect (abfd, name, sect)
#if defined (HAVE_PRSTATUS_T)
static boolean
elfcore_grok_prstatus (abfd, note)
bfd* abfd;
Elf_Internal_Note* note;
bfd *abfd;
Elf_Internal_Note *note;
{
char buf[100];
char* name;
asection* sect;
char *name;
asection *sect;
int raw_size;
int offset;
@ -5365,7 +5363,7 @@ elfcore_grok_prstatus (abfd, note)
return true;
}
/* Make a ".reg/999" section. */
/* Make a ".reg/999" section. */
sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
name = bfd_alloc (abfd, strlen (buf) + 1);
@ -5390,7 +5388,6 @@ elfcore_grok_prstatus (abfd, note)
}
#endif /* defined (HAVE_PRSTATUS_T) */
/* Create a pseudosection containing the exact contents of NOTE. This
actually creates up to two pseudosections:
- For the single-threaded case, a section named NAME, unless
@ -5401,13 +5398,13 @@ elfcore_grok_prstatus (abfd, note)
static boolean
elfcore_make_note_pseudosection (abfd, name, note)
bfd* abfd;
bfd *abfd;
char *name;
Elf_Internal_Note* note;
Elf_Internal_Note *note;
{
char buf[100];
char *threaded_name;
asection* sect;
asection *sect;
/* Build the section name. */
@ -5431,31 +5428,30 @@ elfcore_make_note_pseudosection (abfd, name, note)
return true;
}
/* There isn't a consistent prfpregset_t across platforms,
but it doesn't matter, because we don't have to pick this
data structure apart. */
data structure apart. */
static boolean
elfcore_grok_prfpreg (abfd, note)
bfd* abfd;
Elf_Internal_Note* note;
bfd *abfd;
Elf_Internal_Note *note;
{
return elfcore_make_note_pseudosection (abfd, ".reg2", note);
}
/* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
type of 5 (NT_PRXFPREG). Just include the whole note's contents
literally. */
static boolean
elfcore_grok_prxfpreg (abfd, note)
bfd* abfd;
Elf_Internal_Note* note;
bfd *abfd;
Elf_Internal_Note *note;
{
return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
}
#if defined (HAVE_PRPSINFO_T)
typedef prpsinfo_t elfcore_psinfo_t;
#if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
@ -5470,21 +5466,20 @@ typedef psinfo32_t elfcore_psinfo32_t;
#endif
#endif
#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
/* return a malloc'ed copy of a string at START which is at
most MAX bytes long, possibly without a terminating '\0'.
the copy will always have a terminating '\0'. */
the copy will always have a terminating '\0'. */
static char*
elfcore_strndup (abfd, start, max)
bfd* abfd;
char* start;
bfd *abfd;
char *start;
int max;
{
char* dup;
char* end = memchr (start, '\0', max);
char *dup;
char *end = memchr (start, '\0', max);
int len;
if (end == NULL)
@ -5504,8 +5499,8 @@ elfcore_strndup (abfd, start, max)
static boolean
elfcore_grok_psinfo (abfd, note)
bfd* abfd;
Elf_Internal_Note* note;
bfd *abfd;
Elf_Internal_Note *note;
{
if (note->descsz == sizeof (elfcore_psinfo_t))
{
@ -5544,10 +5539,10 @@ elfcore_grok_psinfo (abfd, note)
/* Note that for some reason, a spurious space is tacked
onto the end of the args in some (at least one anyway)
implementations, so strip it off if it exists. */
implementations, so strip it off if it exists. */
{
char* command = elf_tdata (abfd)->core_command;
char *command = elf_tdata (abfd)->core_command;
int n = strlen (command);
if (0 < n && command[n - 1] == ' ')
@ -5558,12 +5553,11 @@ elfcore_grok_psinfo (abfd, note)
}
#endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
#if defined (HAVE_PSTATUS_T)
static boolean
elfcore_grok_pstatus (abfd, note)
bfd* abfd;
Elf_Internal_Note* note;
bfd *abfd;
Elf_Internal_Note *note;
{
if (note->descsz == sizeof (pstatus_t))
{
@ -5586,23 +5580,22 @@ elfcore_grok_pstatus (abfd, note)
#endif
/* Could grab some more details from the "representative"
lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
NT_LWPSTATUS note, presumably. */
NT_LWPSTATUS note, presumably. */
return true;
}
#endif /* defined (HAVE_PSTATUS_T) */
#if defined (HAVE_LWPSTATUS_T)
static boolean
elfcore_grok_lwpstatus (abfd, note)
bfd* abfd;
Elf_Internal_Note* note;
bfd *abfd;
Elf_Internal_Note *note;
{
lwpstatus_t lwpstat;
char buf[100];
char* name;
asection* sect;
char *name;
asection *sect;
if (note->descsz != sizeof (lwpstat))
return true;
@ -5612,7 +5605,7 @@ elfcore_grok_lwpstatus (abfd, note)
elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
/* Make a ".reg/999" section. */
/* Make a ".reg/999" section. */
sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
name = bfd_alloc (abfd, strlen (buf) + 1);
@ -5677,41 +5670,41 @@ elfcore_grok_lwpstatus (abfd, note)
#if defined (HAVE_WIN32_PSTATUS_T)
static boolean
elfcore_grok_win32pstatus (abfd, note)
bfd * abfd;
Elf_Internal_Note * note;
bfd *abfd;
Elf_Internal_Note *note;
{
char buf[30];
char * name;
asection * sect;
char *name;
asection *sect;
win32_pstatus_t pstatus;
if (note->descsz < sizeof (pstatus))
return true;
memcpy (& pstatus, note->descdata, note->descsz);
switch (pstatus.data_type)
memcpy (&pstatus, note->descdata, note->descsz);
switch (pstatus.data_type)
{
case NOTE_INFO_PROCESS:
/* FIXME: need to add ->core_command. */
elf_tdata (abfd)->core_signal = pstatus.data.process_info.signal;
elf_tdata (abfd)->core_pid = pstatus.data.process_info.pid;
break ;
break;
case NOTE_INFO_THREAD:
/* Make a ".reg/999" section. */
sprintf (buf, ".reg/%d", pstatus.data.thread_info.tid);
name = bfd_alloc (abfd, strlen (buf) + 1);
if (name == NULL)
return false;
return false;
strcpy (name, buf);
sect = bfd_make_section (abfd, name);
if (sect == NULL)
return false;
return false;
sect->_raw_size = sizeof (pstatus.data.thread_info.thread_context);
sect->filepos = note->descpos + offsetof (struct win32_pstatus,
data.thread_info.thread_context);
@ -5725,19 +5718,19 @@ elfcore_grok_win32pstatus (abfd, note)
case NOTE_INFO_MODULE:
/* Make a ".module/xxxxxxxx" section. */
sprintf (buf, ".module/%08x" , pstatus.data.module_info.base_address);
sprintf (buf, ".module/%08x", pstatus.data.module_info.base_address);
name = bfd_alloc (abfd, strlen (buf) + 1);
if (name == NULL)
return false;
strcpy (name, buf);
sect = bfd_make_section (abfd, name);
if (sect == NULL)
return false;
sect->_raw_size = note->descsz;
sect->filepos = note->descpos;
sect->flags = SEC_HAS_CONTENTS;
@ -5754,8 +5747,8 @@ elfcore_grok_win32pstatus (abfd, note)
static boolean
elfcore_grok_note (abfd, note)
bfd* abfd;
Elf_Internal_Note* note;
bfd *abfd;
Elf_Internal_Note *note;
{
switch (note->type)
{
@ -5781,11 +5774,11 @@ elfcore_grok_note (abfd, note)
return elfcore_grok_prfpreg (abfd, note);
#if defined (HAVE_WIN32_PSTATUS_T)
case NT_WIN32PSTATUS:
case NT_WIN32PSTATUS:
return elfcore_grok_win32pstatus (abfd, note);
#endif
case NT_PRXFPREG: /* Linux SSE extension */
case NT_PRXFPREG: /* Linux SSE extension */
if (note->namesz == 5
&& ! strcmp (note->namedata, "LINUX"))
return elfcore_grok_prxfpreg (abfd, note);
@ -5800,15 +5793,14 @@ elfcore_grok_note (abfd, note)
}
}
static boolean
elfcore_read_notes (abfd, offset, size)
bfd* abfd;
bfd *abfd;
bfd_vma offset;
bfd_vma size;
{
char* buf;
char* p;
char *buf;
char *p;
if (size <= 0)
return true;
@ -5830,8 +5822,8 @@ elfcore_read_notes (abfd, offset, size)
p = buf;
while (p < buf + size)
{
/* FIXME: bad alignment assumption. */
Elf_External_Note* xnp = (Elf_External_Note*) p;
/* FIXME: bad alignment assumption. */
Elf_External_Note *xnp = (Elf_External_Note *) p;
Elf_Internal_Note in;
in.type = bfd_h_get_32 (abfd, (bfd_byte *) xnp->type);
@ -5853,13 +5845,12 @@ elfcore_read_notes (abfd, offset, size)
return true;
}
/* FIXME: This function is now unnecessary. Callers can just call
bfd_section_from_phdr directly. */
boolean
_bfd_elfcore_section_from_phdr (abfd, phdr, sec_num)
bfd* abfd;
bfd *abfd;
Elf_Internal_Phdr* phdr;
int sec_num;
{
@ -5868,14 +5859,13 @@ _bfd_elfcore_section_from_phdr (abfd, phdr, sec_num)
return true;
}
/* Providing external access to the ELF program header table. */
/* Return an upper bound on the number of bytes required to store a
copy of ABFD's program header table entries. Return -1 if an error
occurs; bfd_get_error will return an appropriate code. */
long
bfd_get_elf_phdr_upper_bound (abfd)
bfd *abfd;
@ -5890,7 +5880,6 @@ bfd_get_elf_phdr_upper_bound (abfd)
* sizeof (Elf_Internal_Phdr));
}
/* Copy ABFD's program header table entries to *PHDRS. The entries
will be stored as an array of Elf_Internal_Phdr structures, as
defined in include/elf/internal.h. To find out how large the
@ -5898,6 +5887,7 @@ bfd_get_elf_phdr_upper_bound (abfd)
Return the number of program header table entries read, or -1 if an
error occurs; bfd_get_error will return an appropriate code. */
int
bfd_get_elf_phdrs (abfd, phdrs)
bfd *abfd;
@ -5912,7 +5902,7 @@ bfd_get_elf_phdrs (abfd, phdrs)
}
num_phdrs = elf_elfheader (abfd)->e_phnum;
memcpy (phdrs, elf_tdata (abfd)->phdr,
memcpy (phdrs, elf_tdata (abfd)->phdr,
num_phdrs * sizeof (Elf_Internal_Phdr));
return num_phdrs;