bfd_boolean
_bfd_cgc_strtab_emit (register bfd *abfd, struct cgc_strtab_hash *tab)
{
bfd_size_type off = 1, i;
if (bfd_bwrite ("", 1, abfd) != 1)
return FALSE;
for (i = 1; i < tab->size; ++i)
{
register const char *str;
register unsigned int len;
BFD_ASSERT (tab->array[i]->refcount == 0);
len = tab->array[i]->len;
if ((int) len < 0)
continue;
str = tab->array[i]->root.string;
if (bfd_bwrite (str, len, abfd) != len)
return FALSE;
off += len;
}
BFD_ASSERT (off == tab->sec_size);
return TRUE;
}
void
nacl_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
{
struct elf_segment_map *seg;
for (seg = elf_seg_map (abfd); seg != NULL; seg = seg->next)
if (seg->p_type == PT_LOAD
&& seg->count > 1
&& seg->sections[seg->count - 1]->owner == NULL)
{
/* This is a fake section added in nacl_modify_segment_map, above.
It's not a real BFD section, so nothing wrote its contents.
Now write out its contents. */
asection *sec = seg->sections[seg->count - 1];
char *fill;
BFD_ASSERT (sec->flags & SEC_LINKER_CREATED);
BFD_ASSERT (sec->flags & SEC_CODE);
BFD_ASSERT (sec->size > 0);
fill = abfd->arch_info->fill (sec->size, bfd_big_endian (abfd), TRUE);
if (fill == NULL
|| bfd_seek (abfd, sec->filepos, SEEK_SET) != 0
|| bfd_bwrite (fill, sec->size, abfd) != sec->size)
{
/* We don't have a proper way to report an error here. So
instead fudge things so that elf_write_shdrs_and_ehdr will
fail. */
elf_elfheader (abfd)->e_shoff = (file_ptr) -1;
}
free (fill);
}
}
static bfd_boolean
aout_adobe_set_section_contents (bfd *abfd,
asection *section,
const void * location,
file_ptr offset,
bfd_size_type count)
{
file_ptr section_start;
sec_ptr sect;
/* Set by bfd.c handler. */
if (! abfd->output_has_begun)
{
/* Assign file offsets to sections. Text sections are first, and
are contiguous. Then data sections. Everything else at the end. */
section_start = N_TXTOFF (0);
for (sect = abfd->sections; sect; sect = sect->next)
{
if (sect->flags & SEC_CODE)
{
sect->filepos = section_start;
/* FIXME: Round to alignment. */
section_start += sect->size;
}
}
for (sect = abfd->sections; sect; sect = sect->next)
{
if (sect->flags & SEC_DATA)
{
sect->filepos = section_start;
/* FIXME: Round to alignment. */
section_start += sect->size;
}
}
for (sect = abfd->sections; sect; sect = sect->next)
{
if (sect->flags & SEC_HAS_CONTENTS &&
!(sect->flags & (SEC_CODE | SEC_DATA)))
{
sect->filepos = section_start;
/* FIXME: Round to alignment. */
section_start += sect->size;
}
}
}
/* Regardless, once we know what we're doing, we might as well get
going. */
if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
return FALSE;
if (count == 0)
return TRUE;
return bfd_bwrite (location, count, abfd) == count;
}
static bfd_boolean
nlm_alpha_write_prefix (bfd *abfd)
{
struct nlm32_alpha_external_prefix_header s;
memset (&s, 0, sizeof s);
H_PUT_32 (abfd, NLM32_ALPHA_MAGIC, s.magic);
H_PUT_32 (abfd, 2, s.format);
H_PUT_32 (abfd, sizeof s, s.size);
if (bfd_bwrite (&s, (bfd_size_type) sizeof s, abfd) != sizeof s)
return FALSE;
return TRUE;
}
static bfd_boolean
nlm_powerpc_write_prefix (bfd *abfd)
{
struct nlm32_powerpc_external_prefix_header s;
memset (&s, 0, sizeof s);
memcpy (s.signature, NLM32_POWERPC_SIGNATURE, sizeof s.signature);
H_PUT_32 (abfd, NLM32_POWERPC_HEADER_VERSION, s.headerVersion);
H_PUT_32 (abfd, 0, s.origins);
/* FIXME: What should we do about the date? */
if (bfd_bwrite (& s, (bfd_size_type) sizeof s, abfd) != sizeof s)
return FALSE;
return TRUE;
}
static bfd_boolean
wasm_write_uleb128 (bfd *abfd, bfd_vma v)
{
do
{
bfd_byte c = v & 0x7f;
v >>= 7;
if (v)
c |= 0x80;
if (bfd_bwrite (&c, 1, abfd) != 1)
return FALSE;
}
while (v);
return TRUE;
}
static bfd_boolean
aout_adobe_write_object_contents (bfd *abfd)
{
struct external_exec swapped_hdr;
static struct external_segdesc sentinel[1]; /* Initialized to zero. */
asection *sect;
bfd_size_type amt;
exec_hdr (abfd)->a_info = ZMAGIC;
/* Calculate text size as total of text sections, etc. */
exec_hdr (abfd)->a_text = 0;
exec_hdr (abfd)->a_data = 0;
exec_hdr (abfd)->a_bss = 0;
exec_hdr (abfd)->a_trsize = 0;
exec_hdr (abfd)->a_drsize = 0;
for (sect = abfd->sections; sect; sect = sect->next)
{
if (sect->flags & SEC_CODE)
{
exec_hdr (abfd)->a_text += sect->size;
exec_hdr (abfd)->a_trsize += sect->reloc_count *
sizeof (struct reloc_std_external);
}
else if (sect->flags & SEC_DATA)
{
exec_hdr (abfd)->a_data += sect->size;
exec_hdr (abfd)->a_drsize += sect->reloc_count *
sizeof (struct reloc_std_external);
}
else if (sect->flags & SEC_ALLOC && !(sect->flags & SEC_LOAD))
exec_hdr (abfd)->a_bss += sect->size;
}
exec_hdr (abfd)->a_syms = bfd_get_symcount (abfd)
* sizeof (struct external_nlist);
exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd);
aout_adobe_swap_exec_header_out (abfd, exec_hdr (abfd), &swapped_hdr);
amt = EXEC_BYTES_SIZE;
if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0
|| bfd_bwrite (& swapped_hdr, amt, abfd) != amt)
return FALSE;
/* Now write out the section information. Text first, data next, rest
afterward. */
for (sect = abfd->sections; sect; sect = sect->next)
if (sect->flags & SEC_CODE)
aout_adobe_write_section (abfd, sect);
for (sect = abfd->sections; sect; sect = sect->next)
if (sect->flags & SEC_DATA)
aout_adobe_write_section (abfd, sect);
for (sect = abfd->sections; sect; sect = sect->next)
if (!(sect->flags & (SEC_CODE | SEC_DATA)))
aout_adobe_write_section (abfd, sect);
/* Write final `sentinel` section header (with type of 0). */
amt = sizeof (*sentinel);
if (bfd_bwrite (sentinel, amt, abfd) != amt)
return FALSE;
/* Now write out reloc info, followed by syms and strings. */
if (bfd_get_symcount (abfd) != 0)
{
if (bfd_seek (abfd, (file_ptr) (N_SYMOFF (*exec_hdr (abfd))), SEEK_SET)
!= 0)
return FALSE;
if (! aout_32_write_syms (abfd))
return FALSE;
if (bfd_seek (abfd, (file_ptr) (N_TRELOFF (*exec_hdr (abfd))), SEEK_SET)
!= 0)
return FALSE;
for (sect = abfd->sections; sect; sect = sect->next)
if (sect->flags & SEC_CODE)
if (!aout_32_squirt_out_relocs (abfd, sect))
return FALSE;
if (bfd_seek (abfd, (file_ptr) (N_DRELOFF (*exec_hdr (abfd))), SEEK_SET)
!= 0)
return FALSE;
for (sect = abfd->sections; sect; sect = sect->next)
if (sect->flags & SEC_DATA)
if (!aout_32_squirt_out_relocs (abfd, sect))
return FALSE;
}
return TRUE;
}
bfd_boolean
bfd_elf64_archive_write_armap (bfd *arch,
unsigned int elength,
struct orl *map,
unsigned int symbol_count,
int stridx)
{
unsigned int ranlibsize = (symbol_count * 8) + 8;
unsigned int stringsize = stridx;
unsigned int mapsize = stringsize + ranlibsize;
file_ptr archive_member_file_ptr;
bfd *current = arch->archive_head;
unsigned int count;
struct ar_hdr hdr;
int padding;
bfd_byte buf[8];
padding = BFD_ALIGN (mapsize, 8) - mapsize;
mapsize += padding;
/* work out where the first object file will go in the archive */
archive_member_file_ptr = (mapsize
+ elength
+ sizeof (struct ar_hdr)
+ SARMAG);
memset (&hdr, ' ', sizeof (struct ar_hdr));
memcpy (hdr.ar_name, "/SYM64/", strlen ("/SYM64/"));
if (!_bfd_ar_sizepad (hdr.ar_size, sizeof (hdr.ar_size), mapsize))
return FALSE;
_bfd_ar_spacepad (hdr.ar_date, sizeof (hdr.ar_date), "%ld",
time (NULL));
/* This, at least, is what Intel coff sets the values to.: */
_bfd_ar_spacepad (hdr.ar_uid, sizeof (hdr.ar_uid), "%ld", 0);
_bfd_ar_spacepad (hdr.ar_gid, sizeof (hdr.ar_gid), "%ld", 0);
_bfd_ar_spacepad (hdr.ar_mode, sizeof (hdr.ar_mode), "%-7lo", 0);
memcpy (hdr.ar_fmag, ARFMAG, 2);
/* Write the ar header for this item and the number of symbols */
if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch)
!= sizeof (struct ar_hdr))
return FALSE;
bfd_putb64 ((bfd_vma) symbol_count, buf);
if (bfd_bwrite (buf, 8, arch) != 8)
return FALSE;
/* Two passes, first write the file offsets for each symbol -
remembering that each offset is on a two byte boundary. */
/* Write out the file offset for the file associated with each
symbol, and remember to keep the offsets padded out. */
count = 0;
for (current = arch->archive_head;
current != NULL && count < symbol_count;
current = current->archive_next)
{
/* For each symbol which is used defined in this object, write out
the object file's address in the archive. */
for (;
count < symbol_count && map[count].u.abfd == current;
count++)
{
bfd_putb64 ((bfd_vma) archive_member_file_ptr, buf);
if (bfd_bwrite (buf, 8, arch) != 8)
return FALSE;
}
/* Add size of this archive entry */
archive_member_file_ptr += sizeof (struct ar_hdr);
if (! bfd_is_thin_archive (arch))
archive_member_file_ptr += arelt_size (current);
/* remember about the even alignment */
archive_member_file_ptr += archive_member_file_ptr % 2;
}
/* now write the strings themselves */
for (count = 0; count < symbol_count; count++)
{
size_t len = strlen (*map[count].name) + 1;
if (bfd_bwrite (*map[count].name, len, arch) != len)
return FALSE;
}
/* The spec says that this should be padded to an 8 byte boundary.
However, the Irix 6.2 tools do not appear to do this. */
while (padding != 0)
{
if (bfd_bwrite ("", 1, arch) != 1)
return FALSE;
--padding;
}
return TRUE;
}
static bfd_boolean
MY (write_object_contents) (bfd * abfd)
{
struct external_exec exec_bytes;
struct internal_exec *execp = exec_hdr (abfd);
bfd_size_type text_size; /* dummy vars */
file_ptr text_end;
memset (&exec_bytes, 0, sizeof (exec_bytes));
obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
if (adata (abfd).magic == undecided_magic)
NAME (aout,adjust_sizes_and_vmas) (abfd, &text_size, &text_end);
execp->a_syms = 0;
execp->a_entry = bfd_get_start_address (abfd);
execp->a_trsize = ((obj_textsec (abfd)->reloc_count) *
obj_reloc_entry_size (abfd));
execp->a_drsize = ((obj_datasec (abfd)->reloc_count) *
obj_reloc_entry_size (abfd));
N_SET_MACHTYPE (*execp, 0xc);
N_SET_FLAGS (*execp, aout_backend_info (abfd)->exec_hdr_flags);
NAME (aout,swap_exec_header_out) (abfd, execp, &exec_bytes);
/* update fields not covered by default swap_exec_header_out */
/* this is really the sym table size but we store it in drelocs */
H_PUT_32 (abfd, (bfd_get_symcount (abfd) * 12), exec_bytes.e_drelocs);
if (bfd_seek (abfd, (file_ptr) 0, FALSE) != 0
|| (bfd_bwrite (&exec_bytes, (bfd_size_type) EXEC_BYTES_SIZE, abfd)
!= EXEC_BYTES_SIZE))
return FALSE;
/* Write out the symbols, and then the relocs. We must write out
the symbols first so that we know the symbol indices. */
if (bfd_get_symcount (abfd) != 0)
{
/* Skip the relocs to where we want to put the symbols. */
if (bfd_seek (abfd, (file_ptr) (N_DRELOFF (*execp) + execp->a_drsize),
SEEK_SET) != 0)
return FALSE;
}
if (!MY (write_syms) (abfd))
return FALSE;
if (bfd_get_symcount (abfd) != 0)
{
if (bfd_seek (abfd, (file_ptr) N_TRELOFF (*execp), SEEK_CUR) != 0)
return FALSE;
if (!NAME (aout,squirt_out_relocs) (abfd, obj_textsec (abfd)))
return FALSE;
if (bfd_seek (abfd, (file_ptr) N_DRELOFF (*execp), SEEK_CUR) != 0)
return FALSE;
if (!NAME (aout,squirt_out_relocs) (abfd, obj_datasec (abfd)))
return FALSE;
}
return TRUE;
}
