static bfd_boolean
tilegx_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
{
int offset;
size_t size;
if (note->descsz != TILEGX_PRSTATUS_SIZEOF)
return FALSE;
/* pr_cursig */
elf_tdata (abfd)->core->signal =
bfd_get_16 (abfd, note->descdata + TILEGX_PRSTATUS_OFFSET_PR_CURSIG);
/* pr_pid */
elf_tdata (abfd)->core->pid =
bfd_get_32 (abfd, note->descdata + TILEGX_PRSTATUS_OFFSET_PR_PID);
/* pr_reg */
offset = TILEGX_PRSTATUS_OFFSET_PR_REG;
size = TILEGX_GREGSET_T_SIZE;
/* Make a ".reg/999" section. */
return _bfd_elfcore_make_pseudosection (abfd, ".reg",
size, note->descpos + offset);
}
static bfd_boolean
tilegx_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
{
if (note->descsz != TILEGX_PRPSINFO_SIZEOF)
return FALSE;
elf_tdata (abfd)->core->program
= _bfd_elfcore_strndup (abfd, note->descdata + TILEGX_PRPSINFO_OFFSET_PR_FNAME, 16);
elf_tdata (abfd)->core->command
= _bfd_elfcore_strndup (abfd, note->descdata + TILEGX_PRPSINFO_OFFSET_PR_PSARGS, ELF_PR_PSARGS_SIZE);
/* 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. */
{
char *command = elf_tdata (abfd)->core->command;
int n = strlen (command);
if (0 < n && command[n - 1] == ' ')
command[n - 1] = '\0';
}
return TRUE;
}
static bfd_boolean
elf32_am33lin_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
{
switch (note->descsz)
{
default:
return FALSE;
case 124: /* Linux/am33 elf_prpsinfo */
elf_tdata (abfd)->core->program
= _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
elf_tdata (abfd)->core->command
= _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
}
/* 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. */
{
char *command = elf_tdata (abfd)->core->command;
int n = strlen (command);
if (0 < n && command[n - 1] == ' ')
command[n - 1] = '\0';
}
return TRUE;
}
static bfd_boolean
elf32_sparc_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
{
switch (note->descsz)
{
default:
return FALSE;
case 260: /* Solaris prpsinfo_t. */
elf_tdata (abfd)->core_program
= _bfd_elfcore_strndup (abfd, note->descdata + 84, 16);
elf_tdata (abfd)->core_command
= _bfd_elfcore_strndup (abfd, note->descdata + 100, 80);
break;
case 336: /* Solaris psinfo_t. */
elf_tdata (abfd)->core_program
= _bfd_elfcore_strndup (abfd, note->descdata + 88, 16);
elf_tdata (abfd)->core_command
= _bfd_elfcore_strndup (abfd, note->descdata + 104, 80);
break;
}
return TRUE;
}
/* Support for core dump NOTE sections. */
static bfd_boolean
elf32_am33lin_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
{
int offset;
unsigned int size;
switch (note->descsz)
{
default:
return FALSE;
case 184:
case 188: /* Linux/am33 */
/* pr_cursig */
elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
/* pr_pid */
elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
/* pr_reg */
offset = 72;
size = 112;
break;
}
/* Make a ".reg/999" section. */
return _bfd_elfcore_make_pseudosection (abfd, ".reg", size,
note->descpos + offset);
}
static const struct elf_build_id *
build_id_bfd_get (bfd *abfd)
{
if (!bfd_check_format (abfd, bfd_object)
|| bfd_get_flavour (abfd) != bfd_target_elf_flavour
/* Although this is ELF_specific, it is safe to do in generic
code because it does not rely on any ELF-specific symbols at
link time, and if the ELF code is not available in BFD, then
ABFD will not have the ELF flavour. */
|| elf_tdata (abfd)->build_id == NULL)
return NULL;
return elf_tdata (abfd)->build_id;
}
bfd_boolean
_bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
{
struct elf_link_hash_table *htab;
struct eh_frame_hdr_info *hdr_info;
asection *sec;
htab = elf_hash_table (info);
hdr_info = &htab->eh_info;
if (hdr_info->cies != NULL)
{
htab_delete (hdr_info->cies);
hdr_info->cies = NULL;
}
sec = hdr_info->hdr_sec;
if (sec == NULL)
return FALSE;
sec->size = EH_FRAME_HDR_SIZE;
if (hdr_info->table)
sec->size += 4 + hdr_info->fde_count * 8;
elf_tdata (abfd)->eh_frame_hdr = sec;
return TRUE;
}
bfd_boolean
_bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
{
struct elf_link_hash_table *htab;
struct eh_frame_hdr_info *hdr_info;
asection *sec;
htab = elf_hash_table (info);
hdr_info = &htab->eh_info;
sec = hdr_info->hdr_sec;
if (sec == NULL)
return FALSE;
sec->size = EH_FRAME_HDR_SIZE;
if (hdr_info->table)
sec->size += 4 + hdr_info->fde_count * 8;
/* Request program headers to be recalculated. */
elf_tdata (abfd)->program_header_size = 0;
elf_tdata (abfd)->eh_frame_hdr = sec;
return TRUE;
}
static void
fbsd_core_open (char *filename, int from_tty)
{
int err;
fbsd_thread_core = 1;
orig_core_ops.to_open (filename, from_tty);
if (fbsd_thread_present)
{
err = td_ta_new_p (&proc_handle, &thread_agent);
if (err == TD_OK)
{
proc_handle.pid = elf_tdata (core_bfd)->core_pid;
fbsd_thread_activate ();
}
else
error ("fbsd_core_open: td_ta_new: %s", thread_db_err_str (err));
}
}
/* After nacl_modify_segment_map has done its work, the file layout has
been done as we wanted. But the PT_LOAD phdrs are no longer in the
proper order for the ELF rule that they must appear in ascending address
order. So find the two segments we swapped before, and swap them back. */
bfd_boolean
nacl_modify_program_headers (bfd *abfd, struct bfd_link_info *info)
{
struct elf_segment_map **m = &elf_seg_map (abfd);
Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr;
Elf_Internal_Phdr *p = phdr;
if (info != NULL && info->user_phdrs)
/* The linker script used PHDRS explicitly, so don't change what the
user asked for. */
return TRUE;
/* Find the PT_LOAD that contains the headers (should be the first). */
while (*m != NULL)
{
if ((*m)->p_type == PT_LOAD && (*m)->includes_filehdr)
break;
m = &(*m)->next;
++p;
}
if (*m != NULL)
{
struct elf_segment_map **first_load_seg = m;
Elf_Internal_Phdr *first_load_phdr = p;
struct elf_segment_map **next_load_seg = NULL;
Elf_Internal_Phdr *next_load_phdr = NULL;
/* Now move past that first one and find the PT_LOAD that should be
before it by address order. */
m = &(*m)->next;
++p;
while (*m != NULL)
{
if (p->p_type == PT_LOAD && p->p_vaddr < first_load_phdr->p_vaddr)
{
next_load_seg = m;
next_load_phdr = p;
break;
}
m = &(*m)->next;
++p;
}
/* Swap their positions in the segment_map back to how they used to be.
The phdrs have already been set up by now, so we have to slide up
the earlier ones to insert the one that should be first. */
if (next_load_seg != NULL)
{
Elf_Internal_Phdr move_phdr;
struct elf_segment_map *first_seg = *first_load_seg;
struct elf_segment_map *next_seg = *next_load_seg;
struct elf_segment_map *first_next = first_seg->next;
struct elf_segment_map *next_next = next_seg->next;
if (next_load_seg == &first_seg->next)
{
*first_load_seg = next_seg;
next_seg->next = first_seg;
first_seg->next = next_next;
}
else
{
*first_load_seg = first_next;
*next_load_seg = next_next;
first_seg->next = *next_load_seg;
*next_load_seg = first_seg;
next_seg->next = *first_load_seg;
*first_load_seg = next_seg;
}
move_phdr = *next_load_phdr;
memmove (first_load_phdr + 1, first_load_phdr,
(next_load_phdr - first_load_phdr) * sizeof move_phdr);
*first_load_phdr = move_phdr;
}
}
return TRUE;
}
bfd_boolean
_bfd_dwarf1_find_nearest_line (bfd *abfd,
asection *section,
asymbol **symbols,
bfd_vma offset,
const char **filename_ptr,
const char **functionname_ptr,
unsigned int *linenumber_ptr)
{
struct dwarf1_debug *stash = elf_tdata (abfd)->dwarf1_find_line_info;
struct dwarf1_unit* eachUnit;
/* What address are we looking for? */
unsigned long addr = (unsigned long)(offset + section->vma);
*filename_ptr = NULL;
*functionname_ptr = NULL;
*linenumber_ptr = 0;
if (! stash)
{
asection *msec;
bfd_size_type size = sizeof (struct dwarf1_debug);
stash = elf_tdata (abfd)->dwarf1_find_line_info
= (struct dwarf1_debug *) bfd_zalloc (abfd, size);
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. */
return FALSE;
size = msec->rawsize ? msec->rawsize : msec->size;
stash->debug_section
= bfd_simple_get_relocated_section_contents (abfd, msec, NULL,
symbols);
if (! stash->debug_section)
return FALSE;
stash->debug_section_end = stash->debug_section + size;
stash->currentDie = stash->debug_section;
stash->abfd = abfd;
stash->syms = symbols;
}
/* A null debug_section indicates that there was no dwarf1 info
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. */
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,
linenumber_ptr);
while (stash->currentDie < stash->debug_section_end)
{
struct die_info aDieInfo;
if (! parse_die (stash->abfd, &aDieInfo, stash->currentDie,
stash->debug_section_end))
return FALSE;
if (aDieInfo.tag == TAG_compile_unit)
{
struct dwarf1_unit* aUnit
= alloc_dwarf1_unit (stash);
if (!aUnit)
return FALSE;
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
< stash->debug_section_end
&& 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,
linenumber_ptr);
}
if (aDieInfo.sibling != 0)
stash->currentDie = stash->debug_section + aDieInfo.sibling;
else
stash->currentDie += aDieInfo.length;
}
return FALSE;
}
/* We permute the segment_map to get BFD to do the file layout we want:
The first non-executable PT_LOAD segment appears first in the file
and contains the ELF file header and phdrs. */
bfd_boolean
nacl_modify_segment_map (bfd *abfd, struct bfd_link_info *info)
{
struct elf_segment_map **m = &elf_tdata (abfd)->segment_map;
struct elf_segment_map **first_load = NULL;
struct elf_segment_map **last_load = NULL;
bfd_boolean moved_headers = FALSE;
if (info != NULL && info->user_phdrs)
/* The linker script used PHDRS explicitly, so don't change what the
user asked for. */
return TRUE;
while (*m != NULL)
{
struct elf_segment_map *seg = *m;
if (seg->p_type == PT_LOAD)
{
/* First, we're just finding the earliest PT_LOAD.
By the normal rules, this will be the lowest-addressed one.
We only have anything interesting to do if it's executable. */
last_load = m;
if (first_load == NULL)
{
if (!segment_executable (*m))
return TRUE;
first_load = m;
}
/* Now that we've noted the first PT_LOAD, we're looking for
the first non-executable PT_LOAD with a nonempty p_filesz. */
else if (!moved_headers
&& segment_nonexecutable_and_has_contents (seg))
{
/* This is the one we were looking for!
First, clear the flags on previous segments that
say they include the file header and phdrs. */
struct elf_segment_map *prevseg;
for (prevseg = *first_load;
prevseg != seg;
prevseg = prevseg->next)
if (prevseg->p_type == PT_LOAD)
{
prevseg->includes_filehdr = 0;
prevseg->includes_phdrs = 0;
}
/* This segment will include those headers instead. */
seg->includes_filehdr = 1;
seg->includes_phdrs = 1;
moved_headers = TRUE;
}
}
m = &seg->next;
}
if (first_load != last_load && moved_headers)
{
/* Now swap the first and last PT_LOAD segments'
positions in segment_map. */
struct elf_segment_map *first = *first_load;
struct elf_segment_map *last = *last_load;
*first_load = first->next;
first->next = last->next;
last->next = first;
}
return TRUE;
}
first->next = last->next;
last->next = first;
}
return TRUE;
}
/* After nacl_modify_segment_map has done its work, the file layout has
been done as we wanted. But the PT_LOAD phdrs are no longer in the
proper order for the ELF rule that they must appear in ascending address
order. So find the two segments we swapped before, and swap them back. */
bfd_boolean
nacl_modify_program_headers (bfd *abfd,
struct bfd_link_info *info ATTRIBUTE_UNUSED)
{
struct elf_segment_map **m = &elf_tdata (abfd)->segment_map;
Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr;
Elf_Internal_Phdr *p = phdr;
if (info != NULL && info->user_phdrs)
/* The linker script used PHDRS explicitly, so don't change what the
user asked for. */
return TRUE;
/* Find the PT_LOAD that contains the headers (should be the first). */
while (*m != NULL)
{
if ((*m)->p_type == PT_LOAD && (*m)->includes_filehdr)
break;
m = &(*m)->next;
