Reimplement segment writing.
(elf_write_phdrs): Use precomputed e_phoff rather than making assumptions. (elf_build_phdrs): Disabled, for now. (assign_file_position_for_section): Don't change file offset for SHT_NOBITS. (assign_file_positions_for_symtab_and_strtabs): New function. (struct seg_info): New type. (map_program_segments): New function. (assign_file_positions_except_relocs): For executables, leave section headers &c for last, and properly align all sections with flag SHF_ALLOC set. (prep_headers): No longer abort when EXEC_P is set. (write_shdrs_and_ehdr): Deleted all code relating to program segments. (various): Deleted some unused code, and debugging "malloc(0)" calls. (write_relocs): Cache value of last symbol looked up, to save time if the symbol is referred to repeatedly. (elf_fake_sections): Check only SEC_RELOC flag, not number of relocs. (assign_section_numbers): Likewise.
This commit is contained in:
parent
08ecd8f3d8
commit
300adb3110
463
bfd/elfcode.h
463
bfd/elfcode.h
|
@ -63,6 +63,10 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|||
#include "libbfd.h"
|
||||
#include "libelf.h"
|
||||
|
||||
#ifndef alloca
|
||||
PTR alloca ();
|
||||
#endif
|
||||
|
||||
/* Renaming structures, typedefs, macros and functions to be size-specific. */
|
||||
#define Elf_External_Ehdr NAME(Elf,External_Ehdr)
|
||||
#define Elf_External_Sym NAME(Elf,External_Sym)
|
||||
|
@ -671,7 +675,9 @@ DEFUN (elf_new_section_hook, (abfd, sec),
|
|||
AND asection *sec)
|
||||
{
|
||||
struct bfd_elf_section_data *sdata;
|
||||
sec->used_by_bfd = sdata = bfd_alloc (abfd, sizeof (*sdata));
|
||||
|
||||
sdata = (struct bfd_elf_section_data *) bfd_alloc (abfd, sizeof (*sdata));
|
||||
sec->used_by_bfd = (PTR) sdata;
|
||||
memset (sdata, 0, sizeof (*sdata));
|
||||
return true;
|
||||
}
|
||||
|
@ -893,7 +899,8 @@ DEFUN (elf_object_p, (abfd), bfd * abfd)
|
|||
goto wrong;
|
||||
i_shdrp = (Elf_Internal_Shdr *)
|
||||
bfd_alloc (abfd, sizeof (*i_shdrp) * i_ehdrp->e_shnum);
|
||||
elf_elfsections (abfd) = bfd_alloc (abfd, sizeof (i_shdrp) * i_ehdrp->e_shnum);
|
||||
elf_elfsections (abfd) =
|
||||
(Elf_Internal_Shdr **) bfd_alloc (abfd, sizeof (i_shdrp) * i_ehdrp->e_shnum);
|
||||
if (!i_shdrp || !elf_elfsections(abfd))
|
||||
{
|
||||
bfd_error = no_memory;
|
||||
|
@ -1076,12 +1083,7 @@ DEFUN (elf_make_sections, (abfd, asect, obj),
|
|||
this_hdr->sh_size = asect->_raw_size;
|
||||
/* contents already set by elf_set_section_contents */
|
||||
|
||||
if ((asect->flags & SEC_RELOC)
|
||||
#if 0
|
||||
/* The flags are sometimes inconsistent. */
|
||||
&& asect->reloc_count > 0
|
||||
#endif
|
||||
)
|
||||
if (asect->flags & SEC_RELOC)
|
||||
{
|
||||
/* emit a reloc section, and thus strtab and symtab... */
|
||||
Elf_Internal_Shdr *rela_hdr;
|
||||
|
@ -1135,8 +1137,9 @@ write_relocs (abfd, sec, xxx)
|
|||
Elf_External_Rel *outbound_relocs;
|
||||
int idx;
|
||||
int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
|
||||
asymbol *last_sym = 0;
|
||||
int last_sym_idx;
|
||||
|
||||
malloc(0);
|
||||
if ((sec->flags & SEC_RELOC) == 0)
|
||||
return;
|
||||
/* Flags are sometimes inconsistent. */
|
||||
|
@ -1149,81 +1152,77 @@ malloc(0);
|
|||
rela_hdr->contents = (void *) bfd_alloc (abfd, rela_hdr->sh_size);
|
||||
|
||||
/* orelocation has the data, reloc_count has the count... */
|
||||
if (use_rela_p)
|
||||
if (use_rela_p)
|
||||
{
|
||||
outbound_relocas = (Elf_External_Rela *) rela_hdr->contents;
|
||||
|
||||
for (idx = 0; idx < sec->reloc_count; idx++)
|
||||
{
|
||||
outbound_relocas = (Elf_External_Rela *) rela_hdr->contents;
|
||||
Elf_Internal_Rela dst_rela;
|
||||
Elf_External_Rela *src_rela;
|
||||
arelent *ptr;
|
||||
asymbol *sym;
|
||||
int n;
|
||||
|
||||
for (idx = 0; idx < sec->reloc_count; idx++)
|
||||
ptr = sec->orelocation[idx];
|
||||
src_rela = outbound_relocas + idx;
|
||||
if (!(abfd->flags & EXEC_P))
|
||||
dst_rela.r_offset = ptr->address - sec->vma;
|
||||
else
|
||||
dst_rela.r_offset = ptr->address;
|
||||
|
||||
sym = *ptr->sym_ptr_ptr;
|
||||
if (sym == last_sym)
|
||||
n = last_sym_idx;
|
||||
else
|
||||
{
|
||||
Elf_Internal_Rela dst_rela;
|
||||
Elf_External_Rela *src_rela;
|
||||
arelent *ptr;
|
||||
asymbol *sym;
|
||||
|
||||
ptr = sec->orelocation[idx];
|
||||
src_rela = outbound_relocas + idx;
|
||||
if (!(abfd->flags & EXEC_P))
|
||||
dst_rela.r_offset = ptr->address - sec->vma;
|
||||
else
|
||||
dst_rela.r_offset = ptr->address;
|
||||
|
||||
sym = *ptr->sym_ptr_ptr;
|
||||
#if 0
|
||||
/* I think this bit is wrong. But doing it right here means
|
||||
fixing bfd_perform_relocation, and verifying that it doesn't
|
||||
break other targets. Sigh.
|
||||
|
||||
Problem I'm trying to solve here: `ld -r' tends to get
|
||||
offset of target symbol in output-file section put into
|
||||
addend, but retains the original symbol, so the net
|
||||
result is doubling of that offset. */
|
||||
if (!bfd_is_com_section (sym->section)
|
||||
&& sym->section != &bfd_und_section)
|
||||
{
|
||||
/* Could adjust either the offset or the symbol here.
|
||||
I'm pretty indifferent. */
|
||||
sym = sym->section->symbol;
|
||||
}
|
||||
#endif
|
||||
dst_rela.r_info
|
||||
= ELF_R_INFO (elf_symbol_from_bfd_symbol (abfd, &sym),
|
||||
ptr->howto->type);
|
||||
|
||||
dst_rela.r_addend = ptr->addend;
|
||||
elf_swap_reloca_out (abfd, &dst_rela, src_rela);
|
||||
malloc(0);
|
||||
last_sym = sym;
|
||||
last_sym_idx = n = elf_symbol_from_bfd_symbol (abfd, &sym);
|
||||
}
|
||||
dst_rela.r_info = ELF_R_INFO (n, ptr->howto->type);
|
||||
|
||||
dst_rela.r_addend = ptr->addend;
|
||||
elf_swap_reloca_out (abfd, &dst_rela, src_rela);
|
||||
}
|
||||
else
|
||||
/* REL relocations */
|
||||
}
|
||||
else
|
||||
/* REL relocations */
|
||||
{
|
||||
outbound_relocs = (Elf_External_Rel *) rela_hdr->contents;
|
||||
|
||||
for (idx = 0; idx < sec->reloc_count; idx++)
|
||||
{
|
||||
outbound_relocs = (Elf_External_Rel *) rela_hdr->contents;
|
||||
Elf_Internal_Rel dst_rel;
|
||||
Elf_External_Rel *src_rel;
|
||||
arelent *ptr;
|
||||
int n;
|
||||
asymbol *sym;
|
||||
|
||||
for (idx = 0; idx < sec->reloc_count; idx++)
|
||||
ptr = sec->orelocation[idx];
|
||||
sym = *ptr->sym_ptr_ptr;
|
||||
src_rel = outbound_relocs + idx;
|
||||
if (!(abfd->flags & EXEC_P))
|
||||
dst_rel.r_offset = ptr->address - sec->vma;
|
||||
else
|
||||
dst_rel.r_offset = ptr->address;
|
||||
|
||||
if (sym == last_sym)
|
||||
n = last_sym_idx;
|
||||
else
|
||||
{
|
||||
Elf_Internal_Rel dst_rel;
|
||||
Elf_External_Rel *src_rel;
|
||||
arelent *ptr;
|
||||
|
||||
ptr = sec->orelocation[idx];
|
||||
src_rel = outbound_relocs + idx;
|
||||
if (!(abfd->flags & EXEC_P))
|
||||
dst_rel.r_offset = ptr->address - sec->vma;
|
||||
else
|
||||
dst_rel.r_offset = ptr->address;
|
||||
|
||||
dst_rel.r_info
|
||||
= ELF_R_INFO (elf_symbol_from_bfd_symbol (abfd, ptr->sym_ptr_ptr),
|
||||
ptr->howto->type);
|
||||
|
||||
elf_swap_reloc_out (abfd, &dst_rel, src_rel);
|
||||
|
||||
/* Update the addend -- FIXME add 64 bit support. */
|
||||
bfd_put_32 (abfd, ptr->addend,
|
||||
(unsigned char *) (elf_section_data (sec)->this_hdr.contents)
|
||||
+ dst_rel.r_offset);
|
||||
last_sym = sym;
|
||||
last_sym_idx = n = elf_symbol_from_bfd_symbol (abfd, &sym);
|
||||
}
|
||||
dst_rel.r_info = ELF_R_INFO (n, ptr->howto->type);
|
||||
|
||||
elf_swap_reloc_out (abfd, &dst_rel, src_rel);
|
||||
|
||||
/* Update the addend -- FIXME add 64 bit support. */
|
||||
bfd_put_32 (abfd, ptr->addend,
|
||||
(unsigned char *) (elf_section_data (sec)->this_hdr.contents)
|
||||
+ dst_rel.r_offset);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
|
@ -1296,9 +1295,7 @@ DEFUN (elf_fake_sections, (abfd, asect, obj),
|
|||
/* Note that only one symtab is used, so just remember it
|
||||
for now. */
|
||||
|
||||
if ((asect->flags & SEC_RELOC)
|
||||
/* inconsistent flags... */
|
||||
&& asect->reloc_count > 0)
|
||||
if (asect->flags & SEC_RELOC)
|
||||
{
|
||||
int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
|
||||
|
||||
|
@ -1511,7 +1508,7 @@ DEFUN (elf_write_phdrs, (abfd, i_ehdrp, i_phdrp, phdr_cnt),
|
|||
Elf32_Half phdr_cnt)
|
||||
{
|
||||
/* first program header entry goes after the file header */
|
||||
int outbase = i_ehdrp->e_ehsize;
|
||||
int outbase = i_ehdrp->e_phoff;
|
||||
int i;
|
||||
Elf_External_Phdr x_phdr;
|
||||
|
||||
|
@ -1526,6 +1523,7 @@ DEFUN (elf_write_phdrs, (abfd, i_ehdrp, i_phdrp, phdr_cnt),
|
|||
return true;
|
||||
}
|
||||
|
||||
#if 0
|
||||
static Elf_Internal_Phdr *
|
||||
DEFUN (elf_build_phdrs, (abfd, i_ehdrp, i_shdrp, phdr_cnt),
|
||||
bfd * abfd AND
|
||||
|
@ -1700,6 +1698,7 @@ DEFUN (elf_build_phdrs, (abfd, i_ehdrp, i_shdrp, phdr_cnt),
|
|||
|
||||
return phdr_buf;
|
||||
}
|
||||
#endif
|
||||
|
||||
static const Elf_Internal_Shdr null_shdr;
|
||||
|
||||
|
@ -1733,7 +1732,7 @@ assign_section_numbers (abfd)
|
|||
{
|
||||
struct bfd_elf_section_data *d = elf_section_data (sec);
|
||||
d->this_idx = section_number++;
|
||||
if (sec->reloc_count != 0)
|
||||
if (sec->flags & SEC_RELOC)
|
||||
{
|
||||
d->rel_idx = section_number++;
|
||||
d->rel_hdr.sh_link = t->symtab_section;
|
||||
|
@ -1747,8 +1746,8 @@ assign_section_numbers (abfd)
|
|||
|
||||
/* Set up the list of section header pointers, in agreement with the
|
||||
indices. */
|
||||
i_shdrp = bfd_alloc (abfd,
|
||||
section_number * sizeof (Elf_Internal_Shdr *));
|
||||
i_shdrp = (Elf_Internal_Shdr **)
|
||||
bfd_alloc (abfd, section_number * sizeof (Elf_Internal_Shdr *));
|
||||
elf_elfsections(abfd) = i_shdrp;
|
||||
for (i = 0; i < section_number; i++)
|
||||
i_shdrp[i] = 0;
|
||||
|
@ -1779,10 +1778,196 @@ assign_file_position_for_section (i_shdrp, offset)
|
|||
file_ptr offset;
|
||||
{
|
||||
i_shdrp->sh_offset = offset;
|
||||
offset += i_shdrp->sh_size;
|
||||
if (i_shdrp->sh_type != SHT_NOBITS)
|
||||
offset += i_shdrp->sh_size;
|
||||
return offset;
|
||||
}
|
||||
|
||||
static INLINE file_ptr
|
||||
assign_file_positions_for_symtab_and_strtabs (abfd, off)
|
||||
bfd *abfd;
|
||||
file_ptr off;
|
||||
{
|
||||
struct elf_obj_tdata *t = elf_tdata (abfd);
|
||||
|
||||
off = assign_file_position_for_section (&t->shstrtab_hdr, off);
|
||||
off = assign_file_position_for_section (&t->symtab_hdr, off);
|
||||
off = assign_file_position_for_section (&t->strtab_hdr, off);
|
||||
return off;
|
||||
}
|
||||
|
||||
struct seg_info {
|
||||
bfd_vma low, mem_size;
|
||||
file_ptr file_size;
|
||||
int start_pos;
|
||||
int sh_flags;
|
||||
struct seg_info *next;
|
||||
};
|
||||
|
||||
static void
|
||||
map_program_segments (abfd)
|
||||
bfd *abfd;
|
||||
{
|
||||
Elf_Internal_Shdr **i_shdrpp = elf_elfsections (abfd);
|
||||
Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
|
||||
Elf_Internal_Shdr *i_shdrp;
|
||||
Elf_Internal_Phdr *phdr;
|
||||
char *done;
|
||||
int i, n_left = 0;
|
||||
file_ptr lowest_offset = 0;
|
||||
struct seg_info *seg = 0;
|
||||
|
||||
done = alloca (i_ehdrp->e_shnum);
|
||||
memset (done, 0, i_ehdrp->e_shnum);
|
||||
for (i = 0; i < i_ehdrp->e_shnum; i++)
|
||||
{
|
||||
i_shdrp = i_shdrpp[i];
|
||||
/* If it's going to be mapped in, it's been assigned a position. */
|
||||
if (i_shdrp->sh_offset + 1 == 0)
|
||||
{
|
||||
/* Well, not really, but we won't process it here. */
|
||||
done[i] = 1;
|
||||
continue;
|
||||
}
|
||||
if (i_shdrp->sh_offset < lowest_offset
|
||||
|| lowest_offset == 0)
|
||||
lowest_offset = i_shdrp->sh_offset;
|
||||
/* Only interested in PROGBITS or NOBITS for generating segments. */
|
||||
switch (i_shdrp->sh_type)
|
||||
{
|
||||
case SHT_PROGBITS:
|
||||
case SHT_NOBITS:
|
||||
break;
|
||||
default:
|
||||
done[i] = 1;
|
||||
}
|
||||
if (!done[i])
|
||||
n_left++;
|
||||
}
|
||||
while (n_left)
|
||||
{
|
||||
bfd_vma lowest_vma = -1, high;
|
||||
int low_sec = 0;
|
||||
int mem_size;
|
||||
int file_size = 0;
|
||||
|
||||
for (i = 1; i < i_ehdrp->e_shnum; i++)
|
||||
{
|
||||
i_shdrp = i_shdrpp[i];
|
||||
if (!done[i] && i_shdrp->sh_addr < lowest_vma)
|
||||
{
|
||||
lowest_vma = i_shdrp->sh_addr;
|
||||
low_sec = i;
|
||||
}
|
||||
}
|
||||
if (low_sec == 0)
|
||||
abort ();
|
||||
/* So now we know the lowest vma of any unassigned sections; start
|
||||
a segment there. */
|
||||
{
|
||||
struct seg_info *s;
|
||||
s = (struct seg_info *) bfd_alloc (abfd, sizeof (struct seg_info));
|
||||
s->next = seg;
|
||||
seg = s;
|
||||
}
|
||||
seg->low = lowest_vma;
|
||||
i_shdrp = i_shdrpp[low_sec];
|
||||
seg->start_pos = i_shdrp->sh_offset;
|
||||
seg->sh_flags = i_shdrp->sh_flags;
|
||||
done[low_sec] = 1, n_left--;
|
||||
mem_size = i_shdrp->sh_size;
|
||||
high = lowest_vma + i_shdrp->sh_size;
|
||||
|
||||
if (i_shdrp->sh_type == SHT_PROGBITS)
|
||||
file_size = i_shdrp->sh_size;
|
||||
|
||||
for (i = 0; i < i_ehdrp->e_shnum; i++)
|
||||
{
|
||||
file_ptr f1;
|
||||
|
||||
if (file_size != mem_size)
|
||||
break;
|
||||
if (done[i])
|
||||
continue;
|
||||
i_shdrp = i_shdrpp[i];
|
||||
/* position of next byte on disk */
|
||||
f1 = seg->start_pos + file_size;
|
||||
if (i_shdrp->sh_type == SHT_PROGBITS)
|
||||
{
|
||||
if (i_shdrp->sh_offset - f1 != i_shdrp->sh_addr - high)
|
||||
continue;
|
||||
}
|
||||
else /* sh_type == NOBITS */
|
||||
{
|
||||
/* If the section in question has no contents in the disk
|
||||
file, we really don't care where it supposedly starts.
|
||||
But we don't want to bother merging it into this segment
|
||||
if it doesn't start on this memory page. */
|
||||
bfd_vma page1, page2;
|
||||
bfd_vma maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
|
||||
|
||||
/* page number in address space of current end of seg */
|
||||
page1 = (high - 1 + maxpagesize - 1) / maxpagesize;
|
||||
/* page number in address space of start of this section */
|
||||
page2 = (i_shdrp->sh_addr + maxpagesize - 1) / maxpagesize;
|
||||
|
||||
if (page1 != page2)
|
||||
continue;
|
||||
}
|
||||
done[i] = 1, n_left--;
|
||||
if (i_shdrp->sh_type == SHT_PROGBITS)
|
||||
file_size = i_shdrp->sh_offset + i_shdrp->sh_size - seg->start_pos;
|
||||
mem_size = i_shdrp->sh_addr + i_shdrp->sh_size - seg->low;
|
||||
high = i_shdrp->sh_addr + i_shdrp->sh_size;
|
||||
i = 0;
|
||||
}
|
||||
seg->file_size = file_size;
|
||||
seg->mem_size = mem_size;
|
||||
}
|
||||
/* Now do something with the list of segments we've built up. */
|
||||
{
|
||||
bfd_vma maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
|
||||
struct seg_info *s;
|
||||
int n_segs = 0;
|
||||
int sz;
|
||||
|
||||
for (s = seg; s; s = s->next)
|
||||
{
|
||||
n_segs++;
|
||||
}
|
||||
i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
|
||||
sz = sizeof (Elf_External_Phdr) * n_segs;
|
||||
if (i_ehdrp->e_ehsize + sz <= lowest_offset)
|
||||
i_ehdrp->e_phoff = i_ehdrp->e_ehsize;
|
||||
else
|
||||
{
|
||||
i_ehdrp->e_phoff = elf_tdata (abfd)->next_file_pos;
|
||||
elf_tdata (abfd)->next_file_pos += sz;
|
||||
}
|
||||
phdr = bfd_alloc (abfd, n_segs * sizeof (Elf_Internal_Phdr));
|
||||
elf_tdata (abfd)->phdr = phdr;
|
||||
while (seg)
|
||||
{
|
||||
phdr->p_type = PT_LOAD; /* only type we really support so far */
|
||||
phdr->p_offset = seg->start_pos;
|
||||
phdr->p_vaddr = seg->low;
|
||||
phdr->p_paddr = 0;
|
||||
phdr->p_filesz = seg->file_size;
|
||||
phdr->p_memsz = seg->mem_size;
|
||||
phdr->p_flags = PF_R;
|
||||
phdr->p_align = maxpagesize; /* ? */
|
||||
if (seg->sh_flags & SHF_WRITE)
|
||||
phdr->p_flags |= PF_W;
|
||||
if (seg->sh_flags & SHF_EXECINSTR)
|
||||
phdr->p_flags |= PF_X;
|
||||
phdr++;
|
||||
seg = seg->next;
|
||||
}
|
||||
i_ehdrp->e_phnum = n_segs;
|
||||
}
|
||||
elf_write_phdrs (abfd, i_ehdrp, elf_tdata (abfd)->phdr, i_ehdrp->e_phnum);
|
||||
}
|
||||
|
||||
static void
|
||||
assign_file_positions_except_relocs (abfd)
|
||||
bfd *abfd;
|
||||
|
@ -1795,20 +1980,27 @@ assign_file_positions_except_relocs (abfd)
|
|||
a given section, we don't figure them in here. We'll put them at the
|
||||
end of the file, at positions computed during bfd_close.
|
||||
|
||||
The order, for now: <ehdr> <shdr> <sec1> <sec2> <sec3> ... <rel1> ... */
|
||||
The order, for now: <ehdr> <shdr> <sec1> <sec2> <sec3> ... <rel1> ...
|
||||
or: <ehdr> <phdr> <sec1> <sec2> ... <shdr> <rel1> ... */
|
||||
|
||||
file_ptr off;
|
||||
int i;
|
||||
Elf_Internal_Shdr **i_shdrpp = elf_elfsections (abfd);
|
||||
Elf_Internal_Shdr *i_shdrp;
|
||||
Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
|
||||
int exec_p = (abfd->flags & EXEC_P) != 0;
|
||||
|
||||
/* Everything starts after the ELF file header. */
|
||||
off = i_ehdrp->e_ehsize;
|
||||
i_ehdrp->e_shoff = off;
|
||||
off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
|
||||
off = assign_file_position_for_section (&elf_tdata(abfd)->shstrtab_hdr, off);
|
||||
off = assign_file_position_for_section (&elf_tdata(abfd)->symtab_hdr, off);
|
||||
off = assign_file_position_for_section (&elf_tdata(abfd)->strtab_hdr, off);
|
||||
|
||||
if (!exec_p)
|
||||
{
|
||||
/* Section headers. */
|
||||
i_ehdrp->e_shoff = off;
|
||||
off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
|
||||
|
||||
off = assign_file_positions_for_symtab_and_strtabs (abfd, off);
|
||||
}
|
||||
for (i = 0; i < i_ehdrp->e_shnum; i++)
|
||||
{
|
||||
i_shdrp = i_shdrpp[i];
|
||||
|
@ -1817,7 +2009,70 @@ assign_file_positions_except_relocs (abfd)
|
|||
i_shdrp->sh_offset = -1;
|
||||
continue;
|
||||
}
|
||||
if (exec_p)
|
||||
{
|
||||
bfd_vma maxpagesize = get_elf_backend_data (abfd)->maxpagesize;
|
||||
if (maxpagesize == 0)
|
||||
maxpagesize = 1; /* make the arithmetic work */
|
||||
/* This isn't necessarily going to give the best packing, if the
|
||||
segments require padding between them, but since that isn't
|
||||
usually the case, this'll do. */
|
||||
if ((i_shdrp->sh_flags & SHF_ALLOC) == 0)
|
||||
{
|
||||
i_shdrp->sh_offset = -1;
|
||||
continue;
|
||||
}
|
||||
/* Blindly assume that the segments are ordered optimally. With
|
||||
the default LD script, they will be. */
|
||||
{
|
||||
/* need big unsigned type */
|
||||
bfd_vma addtl_off;
|
||||
addtl_off = i_shdrp->sh_addr - off;
|
||||
addtl_off = addtl_off % maxpagesize;
|
||||
if (addtl_off)
|
||||
{
|
||||
off += addtl_off;
|
||||
}
|
||||
}
|
||||
if (i_shdrp->sh_type == SHT_NOBITS)
|
||||
{
|
||||
file_ptr off2;
|
||||
i_shdrp->sh_offset = off;
|
||||
if (off % maxpagesize != 0)
|
||||
off2 = maxpagesize - (off % maxpagesize);
|
||||
if (off2 > i_shdrp->sh_size)
|
||||
off2 = i_shdrp->sh_size;
|
||||
off += off2;
|
||||
}
|
||||
}
|
||||
off = assign_file_position_for_section (i_shdrp, off);
|
||||
if (exec_p
|
||||
&& get_elf_backend_data(abfd)->maxpagesize > 1
|
||||
&& i_shdrp->sh_type == SHT_PROGBITS
|
||||
&& (i_shdrp->sh_flags & SHF_ALLOC)
|
||||
&& (i_shdrp->sh_offset - i_shdrp->sh_addr) % get_elf_backend_data(abfd)->maxpagesize != 0)
|
||||
abort ();
|
||||
}
|
||||
if (exec_p)
|
||||
{
|
||||
elf_tdata (abfd)->next_file_pos = off;
|
||||
map_program_segments (abfd);
|
||||
off = elf_tdata (abfd)->next_file_pos;
|
||||
|
||||
/* Section headers. */
|
||||
i_ehdrp->e_shoff = off;
|
||||
off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
|
||||
|
||||
off = assign_file_positions_for_symtab_and_strtabs (abfd, off);
|
||||
|
||||
for (i = 0; i < i_ehdrp->e_shnum; i++)
|
||||
{
|
||||
i_shdrp = i_shdrpp[i];
|
||||
if (i_shdrp->sh_offset + 1 == 0
|
||||
&& i_shdrp->sh_type != SHT_REL
|
||||
&& i_shdrp->sh_type != SHT_RELA)
|
||||
off = assign_file_position_for_section (i_shdrp, off);
|
||||
}
|
||||
}
|
||||
elf_tdata (abfd)->next_file_pos = off;
|
||||
}
|
||||
|
@ -1906,8 +2161,7 @@ prep_headers (abfd)
|
|||
/* if we're building an executable, we'll need a program header table */
|
||||
if (abfd->flags & EXEC_P)
|
||||
{
|
||||
abort ();
|
||||
|
||||
/* it all happens later */
|
||||
#if 0
|
||||
i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
|
||||
|
||||
|
@ -2117,30 +2371,6 @@ write_shdrs_and_ehdr (abfd)
|
|||
bfd_seek (abfd, (file_ptr) 0, SEEK_SET);
|
||||
bfd_write ((PTR) & x_ehdr, sizeof (x_ehdr), 1, abfd);
|
||||
|
||||
/* If we're building an executable, fixup the program header table
|
||||
offsets.
|
||||
|
||||
@@ For now, assume that the entries are in a fixed order: text,
|
||||
data, bss. FIXME */
|
||||
|
||||
if (abfd->flags & EXEC_P)
|
||||
{
|
||||
static char *CONST section_name[] =
|
||||
{".text", ".data", ".bss"};
|
||||
|
||||
for (count = 0; count < 3; count++)
|
||||
{
|
||||
asection *asect = bfd_get_section_by_name (abfd,
|
||||
section_name[count]);
|
||||
int sh_idx = elf_section_from_bfd_section (abfd, asect);
|
||||
|
||||
i_phdrp[count].p_offset = i_shdrp[sh_idx]->sh_offset;
|
||||
}
|
||||
|
||||
/* write out the program header table entries */
|
||||
elf_write_phdrs (abfd, i_ehdrp, i_phdrp, i_ehdrp->e_phnum);
|
||||
}
|
||||
|
||||
/* at this point we've concocted all the ELF sections... */
|
||||
x_shdrp = (Elf_External_Shdr *)
|
||||
bfd_alloc (abfd, sizeof (*x_shdrp) * (i_ehdrp->e_shnum));
|
||||
|
@ -2192,11 +2422,8 @@ DEFUN (NAME(bfd_elf,write_object_contents), (abfd), bfd * abfd)
|
|||
|
||||
if (abfd->output_has_begun == false)
|
||||
{
|
||||
malloc (0);
|
||||
prep_headers (abfd);
|
||||
malloc(0);
|
||||
elf_compute_section_file_positions (abfd);
|
||||
malloc(0);
|
||||
abfd->output_has_begun = true;
|
||||
}
|
||||
|
||||
|
@ -2204,7 +2431,6 @@ malloc(0);
|
|||
i_ehdrp = elf_elfheader (abfd);
|
||||
|
||||
bfd_map_over_sections (abfd, write_relocs, (PTR) 0);
|
||||
malloc(0);
|
||||
assign_file_positions_for_relocs (abfd);
|
||||
|
||||
/* After writing the headers, we need to write the sections too... */
|
||||
|
@ -2513,6 +2739,7 @@ DEFUN (elf_slurp_symbol_table, (abfd, symptrs),
|
|||
sym->symbol.flags |= BSF_FUNCTION;
|
||||
break;
|
||||
}
|
||||
|
||||
/* Is this a definition of $global$? If so, keep it because it will be
|
||||
needd if any relocations are performed. */
|
||||
if (!strcmp (sym->symbol.name, "$global$")
|
||||
|
|
Loading…
Reference in New Issue