+2012-05-01 Nick Clifton <nickc@redhat.com>
+
+ PR binutils/13121
+ * aoutx.h: Rename 'finfo' to 'flaginfo' to avoid conflicts with
+ AIX system headers.
+ * coff-ppc.c: Likewise.
+ * cofflink.c: Likewise.
+ * elf32-arm.c: Likewise.
+ * elf64-sparc.c: Likewise.
+ * elflink.c: Likewise.
+ * pdp11.c: Likewise.
+ * rescoff.c: Likewise.
+
2012-04-26 Mark Wielaard <mjw@redhat.com>
* dwarf2.c (scan_unit_for_symbols): Account for DW_AT_high_pc
aout_link_write_other_symbol (struct bfd_hash_entry *bh, void *data)
{
struct aout_link_hash_entry *h = (struct aout_link_hash_entry *) bh;
- struct aout_final_link_info *finfo = (struct aout_final_link_info *) data;
+ struct aout_final_link_info *flaginfo = (struct aout_final_link_info *) data;
bfd *output_bfd;
int type;
bfd_vma val;
return TRUE;
}
- output_bfd = finfo->output_bfd;
+ output_bfd = flaginfo->output_bfd;
if (aout_backend_info (output_bfd)->write_dynamic_symbol != NULL)
{
if (! ((*aout_backend_info (output_bfd)->write_dynamic_symbol)
- (output_bfd, finfo->info, h)))
+ (output_bfd, flaginfo->info, h)))
{
/* FIXME: No way to handle errors. */
abort ();
/* An indx of -2 means the symbol must be written. */
if (h->indx != -2
- && (finfo->info->strip == strip_all
- || (finfo->info->strip == strip_some
- && bfd_hash_lookup (finfo->info->keep_hash, h->root.root.string,
+ && (flaginfo->info->strip == strip_all
+ || (flaginfo->info->strip == strip_some
+ && bfd_hash_lookup (flaginfo->info->keep_hash, h->root.root.string,
FALSE, FALSE) == NULL)))
return TRUE;
H_PUT_8 (output_bfd, type, outsym.e_type);
H_PUT_8 (output_bfd, 0, outsym.e_other);
H_PUT_16 (output_bfd, 0, outsym.e_desc);
- indx = add_to_stringtab (output_bfd, finfo->strtab, h->root.root.string,
+ indx = add_to_stringtab (output_bfd, flaginfo->strtab, h->root.root.string,
FALSE);
if (indx == - (bfd_size_type) 1)
/* FIXME: No way to handle errors. */
PUT_WORD (output_bfd, val, outsym.e_value);
amt = EXTERNAL_NLIST_SIZE;
- if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0
+ if (bfd_seek (output_bfd, flaginfo->symoff, SEEK_SET) != 0
|| bfd_bwrite ((void *) &outsym, amt, output_bfd) != amt)
/* FIXME: No way to handle errors. */
abort ();
- finfo->symoff += EXTERNAL_NLIST_SIZE;
+ flaginfo->symoff += EXTERNAL_NLIST_SIZE;
h->indx = obj_aout_external_sym_count (output_bfd);
++obj_aout_external_sym_count (output_bfd);
/* Handle a link order which is supposed to generate a reloc. */
static bfd_boolean
-aout_link_reloc_link_order (struct aout_final_link_info *finfo,
+aout_link_reloc_link_order (struct aout_final_link_info *flaginfo,
asection *o,
struct bfd_link_order *p)
{
r_index = N_ABS | N_EXT;
else
{
- BFD_ASSERT (pr->u.section->owner == finfo->output_bfd);
+ BFD_ASSERT (pr->u.section->owner == flaginfo->output_bfd);
r_index = pr->u.section->target_index;
}
}
BFD_ASSERT (p->type == bfd_symbol_reloc_link_order);
r_extern = 1;
h = ((struct aout_link_hash_entry *)
- bfd_wrapped_link_hash_lookup (finfo->output_bfd, finfo->info,
+ bfd_wrapped_link_hash_lookup (flaginfo->output_bfd, flaginfo->info,
pr->u.name, FALSE, FALSE, TRUE));
if (h != NULL
&& h->indx >= 0)
symbol. */
h->indx = -2;
h->written = FALSE;
- if (!aout_link_write_other_symbol (&h->root.root, finfo))
+ if (!aout_link_write_other_symbol (&h->root.root, flaginfo))
return FALSE;
r_index = h->indx;
}
else
{
- if (! ((*finfo->info->callbacks->unattached_reloc)
- (finfo->info, pr->u.name, NULL, NULL, (bfd_vma) 0)))
+ if (! ((*flaginfo->info->callbacks->unattached_reloc)
+ (flaginfo->info, pr->u.name, NULL, NULL, (bfd_vma) 0)))
return FALSE;
r_index = 0;
}
}
- howto = bfd_reloc_type_lookup (finfo->output_bfd, pr->reloc);
+ howto = bfd_reloc_type_lookup (flaginfo->output_bfd, pr->reloc);
if (howto == 0)
{
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
- if (o == obj_textsec (finfo->output_bfd))
- reloff_ptr = &finfo->treloff;
- else if (o == obj_datasec (finfo->output_bfd))
- reloff_ptr = &finfo->dreloff;
+ if (o == obj_textsec (flaginfo->output_bfd))
+ reloff_ptr = &flaginfo->treloff;
+ else if (o == obj_datasec (flaginfo->output_bfd))
+ reloff_ptr = &flaginfo->dreloff;
else
abort ();
- if (obj_reloc_entry_size (finfo->output_bfd) == RELOC_STD_SIZE)
+ if (obj_reloc_entry_size (flaginfo->output_bfd) == RELOC_STD_SIZE)
{
#ifdef MY_put_reloc
- MY_put_reloc (finfo->output_bfd, r_extern, r_index, p->offset, howto,
+ MY_put_reloc (flaginfo->output_bfd, r_extern, r_index, p->offset, howto,
&srel);
#else
{
r_relative = (howto->type & 32) != 0;
r_length = howto->size;
- PUT_WORD (finfo->output_bfd, p->offset, srel.r_address);
- if (bfd_header_big_endian (finfo->output_bfd))
+ PUT_WORD (flaginfo->output_bfd, p->offset, srel.r_address);
+ if (bfd_header_big_endian (flaginfo->output_bfd))
{
srel.r_index[0] = r_index >> 16;
srel.r_index[1] = r_index >> 8;
buf = (bfd_byte *) bfd_zmalloc (size);
if (buf == NULL)
return FALSE;
- r = MY_relocate_contents (howto, finfo->output_bfd,
+ r = MY_relocate_contents (howto, flaginfo->output_bfd,
(bfd_vma) pr->addend, buf);
switch (r)
{
case bfd_reloc_outofrange:
abort ();
case bfd_reloc_overflow:
- if (! ((*finfo->info->callbacks->reloc_overflow)
- (finfo->info, NULL,
+ if (! ((*flaginfo->info->callbacks->reloc_overflow)
+ (flaginfo->info, NULL,
(p->type == bfd_section_reloc_link_order
- ? bfd_section_name (finfo->output_bfd,
+ ? bfd_section_name (flaginfo->output_bfd,
pr->u.section)
: pr->u.name),
howto->name, pr->addend, NULL, NULL, (bfd_vma) 0)))
}
break;
}
- ok = bfd_set_section_contents (finfo->output_bfd, o, (void *) buf,
+ ok = bfd_set_section_contents (flaginfo->output_bfd, o, (void *) buf,
(file_ptr) p->offset, size);
free (buf);
if (! ok)
else
{
#ifdef MY_put_ext_reloc
- MY_put_ext_reloc (finfo->output_bfd, r_extern, r_index, p->offset,
+ MY_put_ext_reloc (flaginfo->output_bfd, r_extern, r_index, p->offset,
howto, &erel, pr->addend);
#else
- PUT_WORD (finfo->output_bfd, p->offset, erel.r_address);
+ PUT_WORD (flaginfo->output_bfd, p->offset, erel.r_address);
- if (bfd_header_big_endian (finfo->output_bfd))
+ if (bfd_header_big_endian (flaginfo->output_bfd))
{
erel.r_index[0] = r_index >> 16;
erel.r_index[1] = r_index >> 8;
| (howto->type << RELOC_EXT_BITS_TYPE_SH_LITTLE);
}
- PUT_WORD (finfo->output_bfd, (bfd_vma) pr->addend, erel.r_addend);
+ PUT_WORD (flaginfo->output_bfd, (bfd_vma) pr->addend, erel.r_addend);
#endif /* MY_put_ext_reloc */
rel_ptr = (void *) &erel;
}
- amt = obj_reloc_entry_size (finfo->output_bfd);
- if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0
- || bfd_bwrite (rel_ptr, amt, finfo->output_bfd) != amt)
+ amt = obj_reloc_entry_size (flaginfo->output_bfd);
+ if (bfd_seek (flaginfo->output_bfd, *reloff_ptr, SEEK_SET) != 0
+ || bfd_bwrite (rel_ptr, amt, flaginfo->output_bfd) != amt)
return FALSE;
- *reloff_ptr += obj_reloc_entry_size (finfo->output_bfd);
+ *reloff_ptr += obj_reloc_entry_size (flaginfo->output_bfd);
/* Assert that the relocs have not run into the symbols, and that n
the text relocs have not run into the data relocs. */
- BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (finfo->output_bfd)
- && (reloff_ptr != &finfo->treloff
+ BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (flaginfo->output_bfd)
+ && (reloff_ptr != &flaginfo->treloff
|| (*reloff_ptr
- <= obj_datasec (finfo->output_bfd)->rel_filepos)));
+ <= obj_datasec (flaginfo->output_bfd)->rel_filepos)));
return TRUE;
}
/* Relocate an a.out section using standard a.out relocs. */
static bfd_boolean
-aout_link_input_section_std (struct aout_final_link_info *finfo,
+aout_link_input_section_std (struct aout_final_link_info *flaginfo,
bfd *input_bfd,
asection *input_section,
struct reloc_std_external *relocs,
struct reloc_std_external *rel;
struct reloc_std_external *rel_end;
- output_bfd = finfo->output_bfd;
+ output_bfd = flaginfo->output_bfd;
check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE);
BFD_ASSERT (input_bfd->xvec->header_byteorder
== output_bfd->xvec->header_byteorder);
- relocatable = finfo->info->relocatable;
+ relocatable = flaginfo->info->relocatable;
syms = obj_aout_external_syms (input_bfd);
strings = obj_aout_external_strings (input_bfd);
sym_hashes = obj_aout_sym_hashes (input_bfd);
- symbol_map = finfo->symbol_map;
+ symbol_map = flaginfo->symbol_map;
reloc_count = rel_size / RELOC_STD_SIZE;
rel = relocs;
if (howto == NULL)
{
- (*finfo->info->callbacks->einfo)
+ (*flaginfo->info->callbacks->einfo)
(_("%P: %B: unexpected relocation type\n"), input_bfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
h->indx = -2;
h->written = FALSE;
if (!aout_link_write_other_symbol (&h->root.root,
- finfo))
+ flaginfo))
return FALSE;
}
r_index = h->indx;
name = strings + GET_WORD (input_bfd,
syms[r_index].e_strx);
- if (! ((*finfo->info->callbacks->unattached_reloc)
- (finfo->info, name, input_bfd, input_section,
+ if (! ((*flaginfo->info->callbacks->unattached_reloc)
+ (flaginfo->info, name, input_bfd, input_section,
r_addr)))
return FALSE;
r_index = 0;
bfd_boolean skip;
if (! ((*check_dynamic_reloc)
- (finfo->info, input_bfd, input_section, h,
+ (flaginfo->info, input_bfd, input_section, h,
(void *) rel, contents, &skip, &relocation)))
return FALSE;
if (skip)
/* Now warn if a global symbol is undefined. We could not
do this earlier, because check_dynamic_reloc might want
to skip this reloc. */
- if (hundef && ! finfo->info->shared && ! r_baserel)
+ if (hundef && ! flaginfo->info->shared && ! r_baserel)
{
const char *name;
name = h->root.root.string;
else
name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
- if (! ((*finfo->info->callbacks->undefined_symbol)
- (finfo->info, name, input_bfd, input_section,
+ if (! ((*flaginfo->info->callbacks->undefined_symbol)
+ (flaginfo->info, name, input_bfd, input_section,
r_addr, TRUE)))
return FALSE;
}
s = aout_reloc_index_to_section (input_bfd, r_index);
name = bfd_section_name (input_bfd, s);
}
- if (! ((*finfo->info->callbacks->reloc_overflow)
- (finfo->info, (h ? &h->root : NULL), name,
+ if (! ((*flaginfo->info->callbacks->reloc_overflow)
+ (flaginfo->info, (h ? &h->root : NULL), name,
howto->name, (bfd_vma) 0, input_bfd,
input_section, r_addr)))
return FALSE;
/* Relocate an a.out section using extended a.out relocs. */
static bfd_boolean
-aout_link_input_section_ext (struct aout_final_link_info *finfo,
+aout_link_input_section_ext (struct aout_final_link_info *flaginfo,
bfd *input_bfd,
asection *input_section,
struct reloc_ext_external *relocs,
struct reloc_ext_external *rel;
struct reloc_ext_external *rel_end;
- output_bfd = finfo->output_bfd;
+ output_bfd = flaginfo->output_bfd;
check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_EXT_SIZE);
BFD_ASSERT (input_bfd->xvec->header_byteorder
== output_bfd->xvec->header_byteorder);
- relocatable = finfo->info->relocatable;
+ relocatable = flaginfo->info->relocatable;
syms = obj_aout_external_syms (input_bfd);
strings = obj_aout_external_strings (input_bfd);
sym_hashes = obj_aout_sym_hashes (input_bfd);
- symbol_map = finfo->symbol_map;
+ symbol_map = flaginfo->symbol_map;
reloc_count = rel_size / RELOC_EXT_SIZE;
rel = relocs;
if (r_type >= TABLE_SIZE (howto_table_ext))
{
- (*finfo->info->callbacks->einfo)
+ (*flaginfo->info->callbacks->einfo)
(_("%P: %B: unexpected relocation type\n"), input_bfd);
bfd_set_error (bfd_error_bad_value);
return FALSE;
h->indx = -2;
h->written = FALSE;
if (!aout_link_write_other_symbol (&h->root.root,
- finfo))
+ flaginfo))
return FALSE;
}
r_index = h->indx;
name = strings + GET_WORD (input_bfd,
syms[r_index].e_strx);
- if (! ((*finfo->info->callbacks->unattached_reloc)
- (finfo->info, name, input_bfd, input_section,
+ if (! ((*flaginfo->info->callbacks->unattached_reloc)
+ (flaginfo->info, name, input_bfd, input_section,
r_addr)))
return FALSE;
r_index = 0;
bfd_boolean skip;
if (! ((*check_dynamic_reloc)
- (finfo->info, input_bfd, input_section, h,
+ (flaginfo->info, input_bfd, input_section, h,
(void *) rel, contents, &skip, &relocation)))
return FALSE;
if (skip)
do this earlier, because check_dynamic_reloc might want
to skip this reloc. */
if (hundef
- && ! finfo->info->shared
+ && ! flaginfo->info->shared
&& r_type != (unsigned int) RELOC_BASE10
&& r_type != (unsigned int) RELOC_BASE13
&& r_type != (unsigned int) RELOC_BASE22)
name = h->root.root.string;
else
name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
- if (! ((*finfo->info->callbacks->undefined_symbol)
- (finfo->info, name, input_bfd, input_section,
+ if (! ((*flaginfo->info->callbacks->undefined_symbol)
+ (flaginfo->info, name, input_bfd, input_section,
r_addr, TRUE)))
return FALSE;
}
s = aout_reloc_index_to_section (input_bfd, r_index);
name = bfd_section_name (input_bfd, s);
}
- if (! ((*finfo->info->callbacks->reloc_overflow)
- (finfo->info, (h ? &h->root : NULL), name,
+ if (! ((*flaginfo->info->callbacks->reloc_overflow)
+ (flaginfo->info, (h ? &h->root : NULL), name,
howto_table_ext[r_type].name,
r_addend, input_bfd, input_section, r_addr)))
return FALSE;
/* Link an a.out section into the output file. */
static bfd_boolean
-aout_link_input_section (struct aout_final_link_info *finfo,
+aout_link_input_section (struct aout_final_link_info *flaginfo,
bfd *input_bfd,
asection *input_section,
file_ptr *reloff_ptr,
/* Get the section contents. */
input_size = input_section->size;
if (! bfd_get_section_contents (input_bfd, input_section,
- (void *) finfo->contents,
+ (void *) flaginfo->contents,
(file_ptr) 0, input_size))
return FALSE;
relocs = aout_section_data (input_section)->relocs;
else
{
- relocs = finfo->relocs;
+ relocs = flaginfo->relocs;
if (rel_size > 0)
{
if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
/* Relocate the section contents. */
if (obj_reloc_entry_size (input_bfd) == RELOC_STD_SIZE)
{
- if (! aout_link_input_section_std (finfo, input_bfd, input_section,
+ if (! aout_link_input_section_std (flaginfo, input_bfd, input_section,
(struct reloc_std_external *) relocs,
- rel_size, finfo->contents))
+ rel_size, flaginfo->contents))
return FALSE;
}
else
{
- if (! aout_link_input_section_ext (finfo, input_bfd, input_section,
+ if (! aout_link_input_section_ext (flaginfo, input_bfd, input_section,
(struct reloc_ext_external *) relocs,
- rel_size, finfo->contents))
+ rel_size, flaginfo->contents))
return FALSE;
}
/* Write out the section contents. */
- if (! bfd_set_section_contents (finfo->output_bfd,
+ if (! bfd_set_section_contents (flaginfo->output_bfd,
input_section->output_section,
- (void *) finfo->contents,
+ (void *) flaginfo->contents,
(file_ptr) input_section->output_offset,
input_size))
return FALSE;
/* If we are producing relocatable output, the relocs were
modified, and we now write them out. */
- if (finfo->info->relocatable && rel_size > 0)
+ if (flaginfo->info->relocatable && rel_size > 0)
{
- if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0)
+ if (bfd_seek (flaginfo->output_bfd, *reloff_ptr, SEEK_SET) != 0)
return FALSE;
- if (bfd_bwrite (relocs, rel_size, finfo->output_bfd) != rel_size)
+ if (bfd_bwrite (relocs, rel_size, flaginfo->output_bfd) != rel_size)
return FALSE;
*reloff_ptr += rel_size;
/* Assert that the relocs have not run into the symbols, and
that if these are the text relocs they have not run into the
data relocs. */
- BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (finfo->output_bfd)
- && (reloff_ptr != &finfo->treloff
+ BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (flaginfo->output_bfd)
+ && (reloff_ptr != &flaginfo->treloff
|| (*reloff_ptr
- <= obj_datasec (finfo->output_bfd)->rel_filepos)));
+ <= obj_datasec (flaginfo->output_bfd)->rel_filepos)));
}
return TRUE;
symbol indices into a symbol_map. */
static bfd_boolean
-aout_link_write_symbols (struct aout_final_link_info *finfo, bfd *input_bfd)
+aout_link_write_symbols (struct aout_final_link_info *flaginfo, bfd *input_bfd)
{
bfd *output_bfd;
bfd_size_type sym_count;
bfd_boolean pass;
bfd_boolean skip_next;
- output_bfd = finfo->output_bfd;
+ output_bfd = flaginfo->output_bfd;
sym_count = obj_aout_external_sym_count (input_bfd);
strings = obj_aout_external_strings (input_bfd);
- strip = finfo->info->strip;
- discard = finfo->info->discard;
- outsym = finfo->output_syms;
+ strip = flaginfo->info->strip;
+ discard = flaginfo->info->discard;
+ outsym = flaginfo->output_syms;
/* First write out a symbol for this object file, unless we are
discarding such symbols. */
if (strip != strip_all
&& (strip != strip_some
- || bfd_hash_lookup (finfo->info->keep_hash, input_bfd->filename,
+ || bfd_hash_lookup (flaginfo->info->keep_hash, input_bfd->filename,
FALSE, FALSE) != NULL)
&& discard != discard_all)
{
H_PUT_8 (output_bfd, N_TEXT, outsym->e_type);
H_PUT_8 (output_bfd, 0, outsym->e_other);
H_PUT_16 (output_bfd, 0, outsym->e_desc);
- strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
+ strtab_index = add_to_stringtab (output_bfd, flaginfo->strtab,
input_bfd->filename, FALSE);
if (strtab_index == (bfd_size_type) -1)
return FALSE;
sym = obj_aout_external_syms (input_bfd);
sym_end = sym + sym_count;
sym_hash = obj_aout_sym_hashes (input_bfd);
- symbol_map = finfo->symbol_map;
+ symbol_map = flaginfo->symbol_map;
memset (symbol_map, 0, (size_t) sym_count * sizeof *symbol_map);
for (; sym < sym_end; sym++, sym_hash++, symbol_map++)
{
skip = TRUE;
break;
case strip_some:
- if (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE, FALSE)
+ if (bfd_hash_lookup (flaginfo->info->keep_hash, name, FALSE, FALSE)
== NULL)
skip = TRUE;
break;
/* If we have already included a header file with the
same value, then replace this one with an N_EXCL
symbol. */
- copy = (bfd_boolean) (! finfo->info->keep_memory);
- incl_entry = aout_link_includes_lookup (&finfo->includes,
+ copy = (bfd_boolean) (! flaginfo->info->keep_memory);
+ incl_entry = aout_link_includes_lookup (&flaginfo->includes,
name, TRUE, copy);
if (incl_entry == NULL)
return FALSE;
/* This is the first time we have seen this header
file with this set of stabs strings. */
t = (struct aout_link_includes_totals *)
- bfd_hash_allocate (&finfo->includes.root,
+ bfd_hash_allocate (&flaginfo->includes.root,
sizeof *t);
if (t == NULL)
return FALSE;
H_PUT_8 (output_bfd, H_GET_8 (input_bfd, sym->e_other), outsym->e_other);
H_PUT_16 (output_bfd, H_GET_16 (input_bfd, sym->e_desc), outsym->e_desc);
copy = FALSE;
- if (! finfo->info->keep_memory)
+ if (! flaginfo->info->keep_memory)
{
/* name points into a string table which we are going to
free. If there is a hash table entry, use that string.
else
copy = TRUE;
}
- strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
+ strtab_index = add_to_stringtab (output_bfd, flaginfo->strtab,
name, copy);
if (strtab_index == (bfd_size_type) -1)
return FALSE;
}
/* Write out the output symbols we have just constructed. */
- if (outsym > finfo->output_syms)
+ if (outsym > flaginfo->output_syms)
{
bfd_size_type outsym_size;
- if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0)
+ if (bfd_seek (output_bfd, flaginfo->symoff, SEEK_SET) != 0)
return FALSE;
- outsym_size = outsym - finfo->output_syms;
+ outsym_size = outsym - flaginfo->output_syms;
outsym_size *= EXTERNAL_NLIST_SIZE;
- if (bfd_bwrite ((void *) finfo->output_syms, outsym_size, output_bfd)
+ if (bfd_bwrite ((void *) flaginfo->output_syms, outsym_size, output_bfd)
!= outsym_size)
return FALSE;
- finfo->symoff += outsym_size;
+ flaginfo->symoff += outsym_size;
}
return TRUE;
/* Link an a.out input BFD into the output file. */
static bfd_boolean
-aout_link_input_bfd (struct aout_final_link_info *finfo, bfd *input_bfd)
+aout_link_input_bfd (struct aout_final_link_info *flaginfo, bfd *input_bfd)
{
BFD_ASSERT (bfd_get_format (input_bfd) == bfd_object);
if ((input_bfd->flags & DYNAMIC) != 0
&& aout_backend_info (input_bfd)->link_dynamic_object != NULL)
return ((*aout_backend_info (input_bfd)->link_dynamic_object)
- (finfo->info, input_bfd));
+ (flaginfo->info, input_bfd));
/* Get the symbols. We probably have them already, unless
- finfo->info->keep_memory is FALSE. */
+ flaginfo->info->keep_memory is FALSE. */
if (! aout_get_external_symbols (input_bfd))
return FALSE;
/* Write out the symbols and get a map of the new indices. The map
- is placed into finfo->symbol_map. */
- if (! aout_link_write_symbols (finfo, input_bfd))
+ is placed into flaginfo->symbol_map. */
+ if (! aout_link_write_symbols (flaginfo, input_bfd))
return FALSE;
/* Relocate and write out the sections. These functions use the
link, which will normally be the case. */
if (obj_textsec (input_bfd)->linker_mark)
{
- if (! aout_link_input_section (finfo, input_bfd,
+ if (! aout_link_input_section (flaginfo, input_bfd,
obj_textsec (input_bfd),
- &finfo->treloff,
+ &flaginfo->treloff,
exec_hdr (input_bfd)->a_trsize))
return FALSE;
}
if (obj_datasec (input_bfd)->linker_mark)
{
- if (! aout_link_input_section (finfo, input_bfd,
+ if (! aout_link_input_section (flaginfo, input_bfd,
obj_datasec (input_bfd),
- &finfo->dreloff,
+ &flaginfo->dreloff,
exec_hdr (input_bfd)->a_drsize))
return FALSE;
}
/* If we are not keeping memory, we don't need the symbols any
longer. We still need them if we are keeping memory, because the
strings in the hash table point into them. */
- if (! finfo->info->keep_memory)
+ if (! flaginfo->info->keep_memory)
{
if (! aout_link_free_symbols (input_bfd))
return FALSE;
struct bfd_link_info *info;
{
bfd_size_type symesz;
- struct coff_final_link_info finfo;
+ struct coff_final_link_info flaginfo;
bfd_boolean debug_merge_allocated;
asection *o;
struct bfd_link_order *p;
symesz = bfd_coff_symesz (abfd);
- finfo.info = info;
- finfo.output_bfd = abfd;
- finfo.strtab = NULL;
- finfo.section_info = NULL;
- finfo.last_file_index = -1;
- finfo.last_bf_index = -1;
- finfo.internal_syms = NULL;
- finfo.sec_ptrs = NULL;
- finfo.sym_indices = NULL;
- finfo.outsyms = NULL;
- finfo.linenos = NULL;
- finfo.contents = NULL;
- finfo.external_relocs = NULL;
- finfo.internal_relocs = NULL;
+ flaginfo.info = info;
+ flaginfo.output_bfd = abfd;
+ flaginfo.strtab = NULL;
+ flaginfo.section_info = NULL;
+ flaginfo.last_file_index = -1;
+ flaginfo.last_bf_index = -1;
+ flaginfo.internal_syms = NULL;
+ flaginfo.sec_ptrs = NULL;
+ flaginfo.sym_indices = NULL;
+ flaginfo.outsyms = NULL;
+ flaginfo.linenos = NULL;
+ flaginfo.contents = NULL;
+ flaginfo.external_relocs = NULL;
+ flaginfo.internal_relocs = NULL;
debug_merge_allocated = FALSE;
coff_data (abfd)->link_info = info;
- finfo.strtab = _bfd_stringtab_init ();
- if (finfo.strtab == NULL)
+ flaginfo.strtab = _bfd_stringtab_init ();
+ if (flaginfo.strtab == NULL)
goto error_return;
- if (! coff_debug_merge_hash_table_init (&finfo.debug_merge))
+ if (! coff_debug_merge_hash_table_init (&flaginfo.debug_merge))
goto error_return;
debug_merge_allocated = TRUE;
the target_index fields are 1 based. */
amt = abfd->section_count + 1;
amt *= sizeof (struct coff_link_section_info);
- finfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt);
+ flaginfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt);
- if (finfo.section_info == NULL)
+ if (flaginfo.section_info == NULL)
goto error_return;
for (i = 0; i <= abfd->section_count; i++)
{
- finfo.section_info[i].relocs = NULL;
- finfo.section_info[i].rel_hashes = NULL;
+ flaginfo.section_info[i].relocs = NULL;
+ flaginfo.section_info[i].rel_hashes = NULL;
}
}
BFD_ASSERT (info->relocatable);
amt = o->reloc_count;
amt *= sizeof (struct internal_reloc);
- finfo.section_info[o->target_index].relocs =
+ flaginfo.section_info[o->target_index].relocs =
(struct internal_reloc *) bfd_malloc (amt);
amt = o->reloc_count;
amt *= sizeof (struct coff_link_hash_entry *);
- finfo.section_info[o->target_index].rel_hashes =
+ flaginfo.section_info[o->target_index].rel_hashes =
(struct coff_link_hash_entry **) bfd_malloc (amt);
- if (finfo.section_info[o->target_index].relocs == NULL
- || finfo.section_info[o->target_index].rel_hashes == NULL)
+ if (flaginfo.section_info[o->target_index].relocs == NULL
+ || flaginfo.section_info[o->target_index].rel_hashes == NULL)
goto error_return;
if (o->reloc_count > max_output_reloc_count)
/* Allocate some buffers used while linking. */
amt = max_sym_count * sizeof (struct internal_syment);
- finfo.internal_syms = (struct internal_syment *) bfd_malloc (amt);
+ flaginfo.internal_syms = (struct internal_syment *) bfd_malloc (amt);
amt = max_sym_count * sizeof (asection *);
- finfo.sec_ptrs = (asection **) bfd_malloc (amt);
+ flaginfo.sec_ptrs = (asection **) bfd_malloc (amt);
amt = max_sym_count * sizeof (long);
- finfo.sym_indices = (long *) bfd_malloc (amt);
+ flaginfo.sym_indices = (long *) bfd_malloc (amt);
amt = (max_sym_count + 1) * symesz;
- finfo.outsyms = (bfd_byte *) bfd_malloc (amt);
+ flaginfo.outsyms = (bfd_byte *) bfd_malloc (amt);
amt = max_lineno_count * bfd_coff_linesz (abfd);
- finfo.linenos = (bfd_byte *) bfd_malloc (amt);
- finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
- finfo.external_relocs = (bfd_byte *) bfd_malloc (max_reloc_count * relsz);
+ flaginfo.linenos = (bfd_byte *) bfd_malloc (amt);
+ flaginfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
+ flaginfo.external_relocs = (bfd_byte *) bfd_malloc (max_reloc_count * relsz);
if (! info->relocatable)
{
amt = max_reloc_count * sizeof (struct internal_reloc);
- finfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt);
+ flaginfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt);
}
- if ((finfo.internal_syms == NULL && max_sym_count > 0)
- || (finfo.sec_ptrs == NULL && max_sym_count > 0)
- || (finfo.sym_indices == NULL && max_sym_count > 0)
- || finfo.outsyms == NULL
- || (finfo.linenos == NULL && max_lineno_count > 0)
- || (finfo.contents == NULL && max_contents_size > 0)
- || (finfo.external_relocs == NULL && max_reloc_count > 0)
+ if ((flaginfo.internal_syms == NULL && max_sym_count > 0)
+ || (flaginfo.sec_ptrs == NULL && max_sym_count > 0)
+ || (flaginfo.sym_indices == NULL && max_sym_count > 0)
+ || flaginfo.outsyms == NULL
+ || (flaginfo.linenos == NULL && max_lineno_count > 0)
+ || (flaginfo.contents == NULL && max_contents_size > 0)
+ || (flaginfo.external_relocs == NULL && max_reloc_count > 0)
|| (! info->relocatable
- && finfo.internal_relocs == NULL
+ && flaginfo.internal_relocs == NULL
&& max_reloc_count > 0))
goto error_return;
if (! sub->output_has_begun)
#endif
{
- if (! _bfd_coff_link_input_bfd (&finfo, sub))
+ if (! _bfd_coff_link_input_bfd (&flaginfo, sub))
goto error_return;
sub->output_has_begun = TRUE;
}
else if (p->type == bfd_section_reloc_link_order
|| p->type == bfd_symbol_reloc_link_order)
{
- if (! _bfd_coff_reloc_link_order (abfd, &finfo, o, p))
+ if (! _bfd_coff_reloc_link_order (abfd, &flaginfo, o, p))
goto error_return;
}
else
bfd* last_one = ppc_get_last();
if (last_one)
{
- if (! _bfd_coff_link_input_bfd (&finfo, last_one))
+ if (! _bfd_coff_link_input_bfd (&flaginfo, last_one))
goto error_return;
}
last_one->output_has_begun = TRUE;
#endif
/* Free up the buffers used by _bfd_coff_link_input_bfd. */
- coff_debug_merge_hash_table_free (&finfo.debug_merge);
+ coff_debug_merge_hash_table_free (&flaginfo.debug_merge);
debug_merge_allocated = FALSE;
- if (finfo.internal_syms != NULL)
+ if (flaginfo.internal_syms != NULL)
{
- free (finfo.internal_syms);
- finfo.internal_syms = NULL;
+ free (flaginfo.internal_syms);
+ flaginfo.internal_syms = NULL;
}
- if (finfo.sec_ptrs != NULL)
+ if (flaginfo.sec_ptrs != NULL)
{
- free (finfo.sec_ptrs);
- finfo.sec_ptrs = NULL;
+ free (flaginfo.sec_ptrs);
+ flaginfo.sec_ptrs = NULL;
}
- if (finfo.sym_indices != NULL)
+ if (flaginfo.sym_indices != NULL)
{
- free (finfo.sym_indices);
- finfo.sym_indices = NULL;
+ free (flaginfo.sym_indices);
+ flaginfo.sym_indices = NULL;
}
- if (finfo.linenos != NULL)
+ if (flaginfo.linenos != NULL)
{
- free (finfo.linenos);
- finfo.linenos = NULL;
+ free (flaginfo.linenos);
+ flaginfo.linenos = NULL;
}
- if (finfo.contents != NULL)
+ if (flaginfo.contents != NULL)
{
- free (finfo.contents);
- finfo.contents = NULL;
+ free (flaginfo.contents);
+ flaginfo.contents = NULL;
}
- if (finfo.external_relocs != NULL)
+ if (flaginfo.external_relocs != NULL)
{
- free (finfo.external_relocs);
- finfo.external_relocs = NULL;
+ free (flaginfo.external_relocs);
+ flaginfo.external_relocs = NULL;
}
- if (finfo.internal_relocs != NULL)
+ if (flaginfo.internal_relocs != NULL)
{
- free (finfo.internal_relocs);
- finfo.internal_relocs = NULL;
+ free (flaginfo.internal_relocs);
+ flaginfo.internal_relocs = NULL;
}
/* The value of the last C_FILE symbol is supposed to be the symbol
index of the first external symbol. Write it out again if
necessary. */
- if (finfo.last_file_index != -1
- && (unsigned int) finfo.last_file.n_value != obj_raw_syment_count (abfd))
+ if (flaginfo.last_file_index != -1
+ && (unsigned int) flaginfo.last_file.n_value != obj_raw_syment_count (abfd))
{
file_ptr pos;
- finfo.last_file.n_value = obj_raw_syment_count (abfd);
- bfd_coff_swap_sym_out (abfd, (PTR) &finfo.last_file,
- (PTR) finfo.outsyms);
- pos = obj_sym_filepos (abfd) + finfo.last_file_index * symesz;
+ flaginfo.last_file.n_value = obj_raw_syment_count (abfd);
+ bfd_coff_swap_sym_out (abfd, (PTR) &flaginfo.last_file,
+ (PTR) flaginfo.outsyms);
+ pos = obj_sym_filepos (abfd) + flaginfo.last_file_index * symesz;
if (bfd_seek (abfd, pos, SEEK_SET) != 0
- || bfd_bwrite (finfo.outsyms, symesz, abfd) != symesz)
+ || bfd_bwrite (flaginfo.outsyms, symesz, abfd) != symesz)
return FALSE;
}
/* Write out the global symbols. */
- finfo.failed = FALSE;
- bfd_hash_traverse (&info->hash->table, _bfd_coff_write_global_sym, &finfo);
- if (finfo.failed)
+ flaginfo.failed = FALSE;
+ bfd_hash_traverse (&info->hash->table, _bfd_coff_write_global_sym, &flaginfo);
+ if (flaginfo.failed)
goto error_return;
/* The outsyms buffer is used by _bfd_coff_write_global_sym. */
- if (finfo.outsyms != NULL)
+ if (flaginfo.outsyms != NULL)
{
- free (finfo.outsyms);
- finfo.outsyms = NULL;
+ free (flaginfo.outsyms);
+ flaginfo.outsyms = NULL;
}
if (info->relocatable)
if (o->reloc_count == 0)
continue;
- irel = finfo.section_info[o->target_index].relocs;
+ irel = flaginfo.section_info[o->target_index].relocs;
irelend = irel + o->reloc_count;
- rel_hash = finfo.section_info[o->target_index].rel_hashes;
+ rel_hash = flaginfo.section_info[o->target_index].rel_hashes;
erel = external_relocs;
for (; irel < irelend; irel++, rel_hash++, erel += relsz)
{
}
/* Free up the section information. */
- if (finfo.section_info != NULL)
+ if (flaginfo.section_info != NULL)
{
unsigned int i;
for (i = 0; i < abfd->section_count; i++)
{
- if (finfo.section_info[i].relocs != NULL)
- free (finfo.section_info[i].relocs);
- if (finfo.section_info[i].rel_hashes != NULL)
- free (finfo.section_info[i].rel_hashes);
+ if (flaginfo.section_info[i].relocs != NULL)
+ free (flaginfo.section_info[i].relocs);
+ if (flaginfo.section_info[i].rel_hashes != NULL)
+ free (flaginfo.section_info[i].rel_hashes);
}
- free (finfo.section_info);
- finfo.section_info = NULL;
+ free (flaginfo.section_info);
+ flaginfo.section_info = NULL;
}
/* If we have optimized stabs strings, output them. */
#if STRING_SIZE_SIZE == 4
H_PUT_32 (abfd,
- _bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
+ _bfd_stringtab_size (flaginfo.strtab) + STRING_SIZE_SIZE,
strbuf);
#else
#error Change H_PUT_32 above
!= STRING_SIZE_SIZE)
return FALSE;
- if (! _bfd_stringtab_emit (abfd, finfo.strtab))
+ if (! _bfd_stringtab_emit (abfd, flaginfo.strtab))
return FALSE;
}
- _bfd_stringtab_free (finfo.strtab);
+ _bfd_stringtab_free (flaginfo.strtab);
/* Setting bfd_get_symcount to 0 will cause write_object_contents to
not try to write out the symbols. */
error_return:
if (debug_merge_allocated)
- coff_debug_merge_hash_table_free (&finfo.debug_merge);
- if (finfo.strtab != NULL)
- _bfd_stringtab_free (finfo.strtab);
- if (finfo.section_info != NULL)
+ coff_debug_merge_hash_table_free (&flaginfo.debug_merge);
+ if (flaginfo.strtab != NULL)
+ _bfd_stringtab_free (flaginfo.strtab);
+ if (flaginfo.section_info != NULL)
{
unsigned int i;
for (i = 0; i < abfd->section_count; i++)
{
- if (finfo.section_info[i].relocs != NULL)
- free (finfo.section_info[i].relocs);
- if (finfo.section_info[i].rel_hashes != NULL)
- free (finfo.section_info[i].rel_hashes);
+ if (flaginfo.section_info[i].relocs != NULL)
+ free (flaginfo.section_info[i].relocs);
+ if (flaginfo.section_info[i].rel_hashes != NULL)
+ free (flaginfo.section_info[i].rel_hashes);
}
- free (finfo.section_info);
+ free (flaginfo.section_info);
}
- if (finfo.internal_syms != NULL)
- free (finfo.internal_syms);
- if (finfo.sec_ptrs != NULL)
- free (finfo.sec_ptrs);
- if (finfo.sym_indices != NULL)
- free (finfo.sym_indices);
- if (finfo.outsyms != NULL)
- free (finfo.outsyms);
- if (finfo.linenos != NULL)
- free (finfo.linenos);
- if (finfo.contents != NULL)
- free (finfo.contents);
- if (finfo.external_relocs != NULL)
- free (finfo.external_relocs);
- if (finfo.internal_relocs != NULL)
- free (finfo.internal_relocs);
+ if (flaginfo.internal_syms != NULL)
+ free (flaginfo.internal_syms);
+ if (flaginfo.sec_ptrs != NULL)
+ free (flaginfo.sec_ptrs);
+ if (flaginfo.sym_indices != NULL)
+ free (flaginfo.sym_indices);
+ if (flaginfo.outsyms != NULL)
+ free (flaginfo.outsyms);
+ if (flaginfo.linenos != NULL)
+ free (flaginfo.linenos);
+ if (flaginfo.contents != NULL)
+ free (flaginfo.contents);
+ if (flaginfo.external_relocs != NULL)
+ free (flaginfo.external_relocs);
+ if (flaginfo.internal_relocs != NULL)
+ free (flaginfo.internal_relocs);
if (external_relocs != NULL)
free (external_relocs);
return FALSE;
struct bfd_link_info *info)
{
bfd_size_type symesz;
- struct coff_final_link_info finfo;
+ struct coff_final_link_info flaginfo;
bfd_boolean debug_merge_allocated;
bfd_boolean long_section_names;
asection *o;
symesz = bfd_coff_symesz (abfd);
- finfo.info = info;
- finfo.output_bfd = abfd;
- finfo.strtab = NULL;
- finfo.section_info = NULL;
- finfo.last_file_index = -1;
- finfo.last_bf_index = -1;
- finfo.internal_syms = NULL;
- finfo.sec_ptrs = NULL;
- finfo.sym_indices = NULL;
- finfo.outsyms = NULL;
- finfo.linenos = NULL;
- finfo.contents = NULL;
- finfo.external_relocs = NULL;
- finfo.internal_relocs = NULL;
- finfo.global_to_static = FALSE;
+ flaginfo.info = info;
+ flaginfo.output_bfd = abfd;
+ flaginfo.strtab = NULL;
+ flaginfo.section_info = NULL;
+ flaginfo.last_file_index = -1;
+ flaginfo.last_bf_index = -1;
+ flaginfo.internal_syms = NULL;
+ flaginfo.sec_ptrs = NULL;
+ flaginfo.sym_indices = NULL;
+ flaginfo.outsyms = NULL;
+ flaginfo.linenos = NULL;
+ flaginfo.contents = NULL;
+ flaginfo.external_relocs = NULL;
+ flaginfo.internal_relocs = NULL;
+ flaginfo.global_to_static = FALSE;
debug_merge_allocated = FALSE;
coff_data (abfd)->link_info = info;
- finfo.strtab = _bfd_stringtab_init ();
- if (finfo.strtab == NULL)
+ flaginfo.strtab = _bfd_stringtab_init ();
+ if (flaginfo.strtab == NULL)
goto error_return;
- if (! coff_debug_merge_hash_table_init (&finfo.debug_merge))
+ if (! coff_debug_merge_hash_table_init (&flaginfo.debug_merge))
goto error_return;
debug_merge_allocated = TRUE;
coff_write_object_contents which puts the string index
into the s_name field of the section header. That is why
we pass hash as FALSE. */
- if (_bfd_stringtab_add (finfo.strtab, o->name, FALSE, FALSE)
+ if (_bfd_stringtab_add (flaginfo.strtab, o->name, FALSE, FALSE)
== (bfd_size_type) -1)
goto error_return;
long_section_names = TRUE;
the target_index fields are 1 based. */
amt = abfd->section_count + 1;
amt *= sizeof (struct coff_link_section_info);
- finfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt);
- if (finfo.section_info == NULL)
+ flaginfo.section_info = (struct coff_link_section_info *) bfd_malloc (amt);
+ if (flaginfo.section_info == NULL)
goto error_return;
for (i = 0; i <= abfd->section_count; i++)
{
- finfo.section_info[i].relocs = NULL;
- finfo.section_info[i].rel_hashes = NULL;
+ flaginfo.section_info[i].relocs = NULL;
+ flaginfo.section_info[i].rel_hashes = NULL;
}
}
BFD_ASSERT (info->relocatable);
amt = o->reloc_count;
amt *= sizeof (struct internal_reloc);
- finfo.section_info[o->target_index].relocs =
+ flaginfo.section_info[o->target_index].relocs =
(struct internal_reloc *) bfd_malloc (amt);
amt = o->reloc_count;
amt *= sizeof (struct coff_link_hash_entry *);
- finfo.section_info[o->target_index].rel_hashes =
+ flaginfo.section_info[o->target_index].rel_hashes =
(struct coff_link_hash_entry **) bfd_malloc (amt);
- if (finfo.section_info[o->target_index].relocs == NULL
- || finfo.section_info[o->target_index].rel_hashes == NULL)
+ if (flaginfo.section_info[o->target_index].relocs == NULL
+ || flaginfo.section_info[o->target_index].rel_hashes == NULL)
goto error_return;
if (o->reloc_count > max_output_reloc_count)
/* Allocate some buffers used while linking. */
amt = max_sym_count * sizeof (struct internal_syment);
- finfo.internal_syms = (struct internal_syment *) bfd_malloc (amt);
+ flaginfo.internal_syms = (struct internal_syment *) bfd_malloc (amt);
amt = max_sym_count * sizeof (asection *);
- finfo.sec_ptrs = (asection **) bfd_malloc (amt);
+ flaginfo.sec_ptrs = (asection **) bfd_malloc (amt);
amt = max_sym_count * sizeof (long);
- finfo.sym_indices = (long int *) bfd_malloc (amt);
- finfo.outsyms = (bfd_byte *) bfd_malloc ((max_sym_count + 1) * symesz);
+ flaginfo.sym_indices = (long int *) bfd_malloc (amt);
+ flaginfo.outsyms = (bfd_byte *) bfd_malloc ((max_sym_count + 1) * symesz);
amt = max_lineno_count * bfd_coff_linesz (abfd);
- finfo.linenos = (bfd_byte *) bfd_malloc (amt);
- finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
+ flaginfo.linenos = (bfd_byte *) bfd_malloc (amt);
+ flaginfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
amt = max_reloc_count * relsz;
- finfo.external_relocs = (bfd_byte *) bfd_malloc (amt);
+ flaginfo.external_relocs = (bfd_byte *) bfd_malloc (amt);
if (! info->relocatable)
{
amt = max_reloc_count * sizeof (struct internal_reloc);
- finfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt);
+ flaginfo.internal_relocs = (struct internal_reloc *) bfd_malloc (amt);
}
- if ((finfo.internal_syms == NULL && max_sym_count > 0)
- || (finfo.sec_ptrs == NULL && max_sym_count > 0)
- || (finfo.sym_indices == NULL && max_sym_count > 0)
- || finfo.outsyms == NULL
- || (finfo.linenos == NULL && max_lineno_count > 0)
- || (finfo.contents == NULL && max_contents_size > 0)
- || (finfo.external_relocs == NULL && max_reloc_count > 0)
+ if ((flaginfo.internal_syms == NULL && max_sym_count > 0)
+ || (flaginfo.sec_ptrs == NULL && max_sym_count > 0)
+ || (flaginfo.sym_indices == NULL && max_sym_count > 0)
+ || flaginfo.outsyms == NULL
+ || (flaginfo.linenos == NULL && max_lineno_count > 0)
+ || (flaginfo.contents == NULL && max_contents_size > 0)
+ || (flaginfo.external_relocs == NULL && max_reloc_count > 0)
|| (! info->relocatable
- && finfo.internal_relocs == NULL
+ && flaginfo.internal_relocs == NULL
&& max_reloc_count > 0))
goto error_return;
&& bfd_family_coff (p->u.indirect.section->owner))
{
sub = p->u.indirect.section->owner;
- if (! bfd_coff_link_output_has_begun (sub, & finfo))
+ if (! bfd_coff_link_output_has_begun (sub, & flaginfo))
{
- if (! _bfd_coff_link_input_bfd (&finfo, sub))
+ if (! _bfd_coff_link_input_bfd (&flaginfo, sub))
goto error_return;
sub->output_has_begun = TRUE;
}
else if (p->type == bfd_section_reloc_link_order
|| p->type == bfd_symbol_reloc_link_order)
{
- if (! _bfd_coff_reloc_link_order (abfd, &finfo, o, p))
+ if (! _bfd_coff_reloc_link_order (abfd, &flaginfo, o, p))
goto error_return;
}
else
}
}
- if (finfo.info->strip != strip_all && finfo.info->discard != discard_all)
+ if (flaginfo.info->strip != strip_all && flaginfo.info->discard != discard_all)
{
/* Add local symbols from foreign inputs. */
for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
continue;
/* See if we are discarding symbols with this name. */
- if ((finfo.info->strip == strip_some
- && (bfd_hash_lookup (finfo.info->keep_hash,
+ if ((flaginfo.info->strip == strip_some
+ && (bfd_hash_lookup (flaginfo.info->keep_hash,
bfd_asymbol_name(sym), FALSE, FALSE)
== NULL))
- || (((finfo.info->discard == discard_sec_merge
+ || (((flaginfo.info->discard == discard_sec_merge
&& (bfd_get_section (sym)->flags & SEC_MERGE)
- && ! finfo.info->relocatable)
- || finfo.info->discard == discard_l)
+ && ! flaginfo.info->relocatable)
+ || flaginfo.info->discard == discard_l)
&& bfd_is_local_label_name (sub, bfd_asymbol_name(sym))))
continue;
bfd_boolean hash = ! (abfd->flags & BFD_TRADITIONAL_FORMAT);
bfd_size_type indx;
- indx = _bfd_stringtab_add (finfo.strtab,
+ indx = _bfd_stringtab_add (flaginfo.strtab,
bfd_asymbol_name (sym), hash,
FALSE);
if (indx == (bfd_size_type) -1)
goto error_return;
isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
- bfd_coff_swap_sym_out (abfd, &isym, finfo.outsyms);
+ bfd_coff_swap_sym_out (abfd, &isym, flaginfo.outsyms);
rewrite = TRUE;
}
if (isym.n_sclass == C_FILE)
{
- if (finfo.last_file_index != -1)
+ if (flaginfo.last_file_index != -1)
{
- finfo.last_file.n_value = obj_raw_syment_count (abfd);
- bfd_coff_swap_sym_out (abfd, &finfo.last_file,
- finfo.outsyms);
- pos = obj_sym_filepos (abfd) + finfo.last_file_index
+ flaginfo.last_file.n_value = obj_raw_syment_count (abfd);
+ bfd_coff_swap_sym_out (abfd, &flaginfo.last_file,
+ flaginfo.outsyms);
+ pos = obj_sym_filepos (abfd) + flaginfo.last_file_index
* symesz;
rewrite = TRUE;
}
- finfo.last_file_index = obj_raw_syment_count (abfd);
- finfo.last_file = isym;
+ flaginfo.last_file_index = obj_raw_syment_count (abfd);
+ flaginfo.last_file = isym;
}
if (rewrite
&& (bfd_seek (abfd, pos, SEEK_SET) != 0
- || bfd_bwrite (finfo.outsyms, symesz, abfd) != symesz))
+ || bfd_bwrite (flaginfo.outsyms, symesz, abfd) != symesz))
goto error_return;
obj_raw_syment_count (abfd) += written;
}
}
- if (! bfd_coff_final_link_postscript (abfd, & finfo))
+ if (! bfd_coff_final_link_postscript (abfd, & flaginfo))
goto error_return;
/* Free up the buffers used by _bfd_coff_link_input_bfd. */
- coff_debug_merge_hash_table_free (&finfo.debug_merge);
+ coff_debug_merge_hash_table_free (&flaginfo.debug_merge);
debug_merge_allocated = FALSE;
- if (finfo.internal_syms != NULL)
+ if (flaginfo.internal_syms != NULL)
{
- free (finfo.internal_syms);
- finfo.internal_syms = NULL;
+ free (flaginfo.internal_syms);
+ flaginfo.internal_syms = NULL;
}
- if (finfo.sec_ptrs != NULL)
+ if (flaginfo.sec_ptrs != NULL)
{
- free (finfo.sec_ptrs);
- finfo.sec_ptrs = NULL;
+ free (flaginfo.sec_ptrs);
+ flaginfo.sec_ptrs = NULL;
}
- if (finfo.sym_indices != NULL)
+ if (flaginfo.sym_indices != NULL)
{
- free (finfo.sym_indices);
- finfo.sym_indices = NULL;
+ free (flaginfo.sym_indices);
+ flaginfo.sym_indices = NULL;
}
- if (finfo.linenos != NULL)
+ if (flaginfo.linenos != NULL)
{
- free (finfo.linenos);
- finfo.linenos = NULL;
+ free (flaginfo.linenos);
+ flaginfo.linenos = NULL;
}
- if (finfo.contents != NULL)
+ if (flaginfo.contents != NULL)
{
- free (finfo.contents);
- finfo.contents = NULL;
+ free (flaginfo.contents);
+ flaginfo.contents = NULL;
}
- if (finfo.external_relocs != NULL)
+ if (flaginfo.external_relocs != NULL)
{
- free (finfo.external_relocs);
- finfo.external_relocs = NULL;
+ free (flaginfo.external_relocs);
+ flaginfo.external_relocs = NULL;
}
- if (finfo.internal_relocs != NULL)
+ if (flaginfo.internal_relocs != NULL)
{
- free (finfo.internal_relocs);
- finfo.internal_relocs = NULL;
+ free (flaginfo.internal_relocs);
+ flaginfo.internal_relocs = NULL;
}
/* The value of the last C_FILE symbol is supposed to be the symbol
index of the first external symbol. Write it out again if
necessary. */
- if (finfo.last_file_index != -1
- && (unsigned int) finfo.last_file.n_value != obj_raw_syment_count (abfd))
+ if (flaginfo.last_file_index != -1
+ && (unsigned int) flaginfo.last_file.n_value != obj_raw_syment_count (abfd))
{
file_ptr pos;
- finfo.last_file.n_value = obj_raw_syment_count (abfd);
- bfd_coff_swap_sym_out (abfd, &finfo.last_file,
- finfo.outsyms);
+ flaginfo.last_file.n_value = obj_raw_syment_count (abfd);
+ bfd_coff_swap_sym_out (abfd, &flaginfo.last_file,
+ flaginfo.outsyms);
- pos = obj_sym_filepos (abfd) + finfo.last_file_index * symesz;
+ pos = obj_sym_filepos (abfd) + flaginfo.last_file_index * symesz;
if (bfd_seek (abfd, pos, SEEK_SET) != 0
- || bfd_bwrite (finfo.outsyms, symesz, abfd) != symesz)
+ || bfd_bwrite (flaginfo.outsyms, symesz, abfd) != symesz)
return FALSE;
}
static. */
if (info->task_link)
{
- finfo.failed = FALSE;
+ flaginfo.failed = FALSE;
coff_link_hash_traverse (coff_hash_table (info),
- _bfd_coff_write_task_globals, &finfo);
- if (finfo.failed)
+ _bfd_coff_write_task_globals, &flaginfo);
+ if (flaginfo.failed)
goto error_return;
}
/* Write out the global symbols. */
- finfo.failed = FALSE;
- bfd_hash_traverse (&info->hash->table, _bfd_coff_write_global_sym, &finfo);
- if (finfo.failed)
+ flaginfo.failed = FALSE;
+ bfd_hash_traverse (&info->hash->table, _bfd_coff_write_global_sym, &flaginfo);
+ if (flaginfo.failed)
goto error_return;
/* The outsyms buffer is used by _bfd_coff_write_global_sym. */
- if (finfo.outsyms != NULL)
+ if (flaginfo.outsyms != NULL)
{
- free (finfo.outsyms);
- finfo.outsyms = NULL;
+ free (flaginfo.outsyms);
+ flaginfo.outsyms = NULL;
}
if (info->relocatable && max_output_reloc_count > 0)
if (o->reloc_count == 0)
continue;
- irel = finfo.section_info[o->target_index].relocs;
+ irel = flaginfo.section_info[o->target_index].relocs;
irelend = irel + o->reloc_count;
- rel_hash = finfo.section_info[o->target_index].rel_hashes;
+ rel_hash = flaginfo.section_info[o->target_index].rel_hashes;
erel = external_relocs;
for (; irel < irelend; irel++, rel_hash++, erel += relsz)
{
}
/* Free up the section information. */
- if (finfo.section_info != NULL)
+ if (flaginfo.section_info != NULL)
{
unsigned int i;
for (i = 0; i < abfd->section_count; i++)
{
- if (finfo.section_info[i].relocs != NULL)
- free (finfo.section_info[i].relocs);
- if (finfo.section_info[i].rel_hashes != NULL)
- free (finfo.section_info[i].rel_hashes);
+ if (flaginfo.section_info[i].relocs != NULL)
+ free (flaginfo.section_info[i].relocs);
+ if (flaginfo.section_info[i].rel_hashes != NULL)
+ free (flaginfo.section_info[i].rel_hashes);
}
- free (finfo.section_info);
- finfo.section_info = NULL;
+ free (flaginfo.section_info);
+ flaginfo.section_info = NULL;
}
/* If we have optimized stabs strings, output them. */
#if STRING_SIZE_SIZE == 4
H_PUT_32 (abfd,
- _bfd_stringtab_size (finfo.strtab) + STRING_SIZE_SIZE,
+ _bfd_stringtab_size (flaginfo.strtab) + STRING_SIZE_SIZE,
strbuf);
#else
#error Change H_PUT_32 above
!= STRING_SIZE_SIZE)
return FALSE;
- if (! _bfd_stringtab_emit (abfd, finfo.strtab))
+ if (! _bfd_stringtab_emit (abfd, flaginfo.strtab))
return FALSE;
obj_coff_strings_written (abfd) = TRUE;
}
- _bfd_stringtab_free (finfo.strtab);
+ _bfd_stringtab_free (flaginfo.strtab);
/* Setting bfd_get_symcount to 0 will cause write_object_contents to
not try to write out the symbols. */
error_return:
if (debug_merge_allocated)
- coff_debug_merge_hash_table_free (&finfo.debug_merge);
- if (finfo.strtab != NULL)
- _bfd_stringtab_free (finfo.strtab);
- if (finfo.section_info != NULL)
+ coff_debug_merge_hash_table_free (&flaginfo.debug_merge);
+ if (flaginfo.strtab != NULL)
+ _bfd_stringtab_free (flaginfo.strtab);
+ if (flaginfo.section_info != NULL)
{
unsigned int i;
for (i = 0; i < abfd->section_count; i++)
{
- if (finfo.section_info[i].relocs != NULL)
- free (finfo.section_info[i].relocs);
- if (finfo.section_info[i].rel_hashes != NULL)
- free (finfo.section_info[i].rel_hashes);
+ if (flaginfo.section_info[i].relocs != NULL)
+ free (flaginfo.section_info[i].relocs);
+ if (flaginfo.section_info[i].rel_hashes != NULL)
+ free (flaginfo.section_info[i].rel_hashes);
}
- free (finfo.section_info);
+ free (flaginfo.section_info);
}
- if (finfo.internal_syms != NULL)
- free (finfo.internal_syms);
- if (finfo.sec_ptrs != NULL)
- free (finfo.sec_ptrs);
- if (finfo.sym_indices != NULL)
- free (finfo.sym_indices);
- if (finfo.outsyms != NULL)
- free (finfo.outsyms);
- if (finfo.linenos != NULL)
- free (finfo.linenos);
- if (finfo.contents != NULL)
- free (finfo.contents);
- if (finfo.external_relocs != NULL)
- free (finfo.external_relocs);
- if (finfo.internal_relocs != NULL)
- free (finfo.internal_relocs);
+ if (flaginfo.internal_syms != NULL)
+ free (flaginfo.internal_syms);
+ if (flaginfo.sec_ptrs != NULL)
+ free (flaginfo.sec_ptrs);
+ if (flaginfo.sym_indices != NULL)
+ free (flaginfo.sym_indices);
+ if (flaginfo.outsyms != NULL)
+ free (flaginfo.outsyms);
+ if (flaginfo.linenos != NULL)
+ free (flaginfo.linenos);
+ if (flaginfo.contents != NULL)
+ free (flaginfo.contents);
+ if (flaginfo.external_relocs != NULL)
+ free (flaginfo.external_relocs);
+ if (flaginfo.internal_relocs != NULL)
+ free (flaginfo.internal_relocs);
if (external_relocs != NULL)
free (external_relocs);
return FALSE;
that symbol. */
static void
-mark_relocs (struct coff_final_link_info *finfo, bfd *input_bfd)
+mark_relocs (struct coff_final_link_info *flaginfo, bfd *input_bfd)
{
asection * a;
/* Read in the relocs. */
internal_relocs = _bfd_coff_read_internal_relocs
(input_bfd, a, FALSE,
- finfo->external_relocs,
- finfo->info->relocatable,
- (finfo->info->relocatable
- ? (finfo->section_info[ a->output_section->target_index ].relocs + a->output_section->reloc_count)
- : finfo->internal_relocs)
+ flaginfo->external_relocs,
+ flaginfo->info->relocatable,
+ (flaginfo->info->relocatable
+ ? (flaginfo->section_info[ a->output_section->target_index ].relocs + a->output_section->reloc_count)
+ : flaginfo->internal_relocs)
);
if (internal_relocs == NULL)
in the relocation table. This will then be picked up in the
skip/don't-skip pass. */
for (; irel < irelend; irel++)
- finfo->sym_indices[ irel->r_symndx ] = -1;
+ flaginfo->sym_indices[ irel->r_symndx ] = -1;
}
}
handles all the sections and relocations of the input file at once. */
bfd_boolean
-_bfd_coff_link_input_bfd (struct coff_final_link_info *finfo, bfd *input_bfd)
+_bfd_coff_link_input_bfd (struct coff_final_link_info *flaginfo, bfd *input_bfd)
{
unsigned int n_tmask = coff_data (input_bfd)->local_n_tmask;
unsigned int n_btshft = coff_data (input_bfd)->local_n_btshft;
/* Move all the symbols to the output file. */
- output_bfd = finfo->output_bfd;
+ output_bfd = flaginfo->output_bfd;
strings = NULL;
syment_base = obj_raw_syment_count (output_bfd);
isymesz = bfd_coff_symesz (input_bfd);
BFD_ASSERT (linesz == bfd_coff_linesz (output_bfd));
copy = FALSE;
- if (! finfo->info->keep_memory)
+ if (! flaginfo->info->keep_memory)
copy = TRUE;
hash = TRUE;
if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
- isymp = finfo->internal_syms;
- secpp = finfo->sec_ptrs;
- indexp = finfo->sym_indices;
+ isymp = flaginfo->internal_syms;
+ secpp = flaginfo->sec_ptrs;
+ indexp = flaginfo->sym_indices;
output_index = syment_base;
- outsym = finfo->outsyms;
+ outsym = flaginfo->outsyms;
if (coff_data (output_bfd)->pe
- && ! process_embedded_commands (output_bfd, finfo->info, input_bfd))
+ && ! process_embedded_commands (output_bfd, flaginfo->info, input_bfd))
return FALSE;
/* If we are going to perform relocations and also strip/discard some
symbols then we must make sure that we do not strip/discard those
symbols that are going to be involved in the relocations. */
- if (( finfo->info->strip != strip_none
- || finfo->info->discard != discard_none)
- && finfo->info->relocatable)
+ if (( flaginfo->info->strip != strip_none
+ || flaginfo->info->discard != discard_none)
+ && flaginfo->info->relocatable)
{
/* Mark the symbol array as 'not-used'. */
memset (indexp, 0, obj_raw_syment_count (input_bfd) * sizeof * indexp);
- mark_relocs (finfo, input_bfd);
+ mark_relocs (flaginfo, input_bfd);
}
while (esym < esym_end)
/* Extract the flag indicating if this symbol is used by a
relocation. */
- if ((finfo->info->strip != strip_none
- || finfo->info->discard != discard_none)
- && finfo->info->relocatable)
+ if ((flaginfo->info->strip != strip_none
+ || flaginfo->info->discard != discard_none)
+ && flaginfo->info->relocatable)
dont_skip_symbol = *indexp;
else
dont_skip_symbol = FALSE;
add = 1 + isym.n_numaux;
/* If we are stripping all symbols, we want to skip this one. */
- if (finfo->info->strip == strip_all && ! dont_skip_symbol)
+ if (flaginfo->info->strip == strip_all && ! dont_skip_symbol)
skip = TRUE;
if (! skip)
case COFF_SYMBOL_LOCAL:
/* This is a local symbol. Skip it if we are discarding
local symbols. */
- if (finfo->info->discard == discard_all && ! dont_skip_symbol)
+ if (flaginfo->info->discard == discard_all && ! dont_skip_symbol)
skip = TRUE;
break;
}
for some types of debugging symbols; I don't know if this is
a bug or not. In any case, we handle it here. */
if (! skip
- && finfo->info->strip == strip_debugger
+ && flaginfo->info->strip == strip_debugger
&& ! dont_skip_symbol
&& (isym.n_scnum == N_DEBUG
|| (isym.n_scnum == N_ABS
/* If some symbols are stripped based on the name, work out the
name and decide whether to skip this symbol. */
if (! skip
- && (finfo->info->strip == strip_some
- || finfo->info->discard == discard_l))
+ && (flaginfo->info->strip == strip_some
+ || flaginfo->info->discard == discard_l))
{
const char *name;
char buf[SYMNMLEN + 1];
return FALSE;
if (! dont_skip_symbol
- && ((finfo->info->strip == strip_some
- && (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE,
+ && ((flaginfo->info->strip == strip_some
+ && (bfd_hash_lookup (flaginfo->info->keep_hash, name, FALSE,
FALSE) == NULL))
|| (! global
- && finfo->info->discard == discard_l
+ && flaginfo->info->discard == discard_l
&& bfd_is_local_label_name (input_bfd, name))))
skip = TRUE;
}
/* If this is an enum, struct, or union tag, see if we have
already output an identical type. */
if (! skip
- && (finfo->output_bfd->flags & BFD_TRADITIONAL_FORMAT) == 0
+ && (flaginfo->output_bfd->flags & BFD_TRADITIONAL_FORMAT) == 0
&& (isym.n_sclass == C_ENTAG
|| isym.n_sclass == C_STRTAG
|| isym.n_sclass == C_UNTAG)
&& (name[1] == '~' || name[1] == '.' || name[1] == '$')))
name = "";
- mh = coff_debug_merge_hash_lookup (&finfo->debug_merge, name,
+ mh = coff_debug_merge_hash_lookup (&flaginfo->debug_merge, name,
TRUE, TRUE);
if (mh == NULL)
return FALSE;
(bfd_byte *) obj_coff_external_syms (input_bfd))
/ (long) isymesz)))
{
- (*epp)->tagndx = finfo->sym_indices[indx];
+ (*epp)->tagndx = flaginfo->sym_indices[indx];
if ((*epp)->tagndx < 0)
(*epp)->tagndx = 0;
}
name = _bfd_coff_internal_syment_name (input_bfd, &isym, NULL);
if (name == NULL)
return FALSE;
- indx = _bfd_stringtab_add (finfo->strtab, name, hash, copy);
+ indx = _bfd_stringtab_add (flaginfo->strtab, name, hash, copy);
if (indx == (bfd_size_type) -1)
return FALSE;
isym._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
isym.n_value += (*secpp)->output_offset;
if (! obj_pe (input_bfd))
isym.n_value -= (*secpp)->vma;
- if (! obj_pe (finfo->output_bfd))
+ if (! obj_pe (flaginfo->output_bfd))
isym.n_value += (*secpp)->output_section->vma;
}
break;
it). We try to get this right, below, just before we
write the symbols out, but in the general case we may
have to write the symbol out twice. */
- if (finfo->last_file_index != -1
- && finfo->last_file.n_value != (bfd_vma) output_index)
+ if (flaginfo->last_file_index != -1
+ && flaginfo->last_file.n_value != (bfd_vma) output_index)
{
/* We must correct the value of the last C_FILE
entry. */
- finfo->last_file.n_value = output_index;
- if ((bfd_size_type) finfo->last_file_index >= syment_base)
+ flaginfo->last_file.n_value = output_index;
+ if ((bfd_size_type) flaginfo->last_file_index >= syment_base)
{
/* The last C_FILE symbol is in this input file. */
bfd_coff_swap_sym_out (output_bfd,
- &finfo->last_file,
- (finfo->outsyms
- + ((finfo->last_file_index
+ &flaginfo->last_file,
+ (flaginfo->outsyms
+ + ((flaginfo->last_file_index
- syment_base)
* osymesz)));
}
symbol. We need to write it out again. We
borrow *outsym temporarily. */
bfd_coff_swap_sym_out (output_bfd,
- &finfo->last_file, outsym);
+ &flaginfo->last_file, outsym);
pos = obj_sym_filepos (output_bfd);
- pos += finfo->last_file_index * osymesz;
+ pos += flaginfo->last_file_index * osymesz;
if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
|| bfd_bwrite (outsym, osymesz, output_bfd) != osymesz)
return FALSE;
}
}
- finfo->last_file_index = output_index;
- finfo->last_file = isym;
+ flaginfo->last_file_index = output_index;
+ flaginfo->last_file = isym;
break;
}
/* If doing task linking, convert normal global function symbols to
static functions. */
- if (finfo->info->task_link && IS_EXTERNAL (input_bfd, isym))
+ if (flaginfo->info->task_link && IS_EXTERNAL (input_bfd, isym))
isym.n_sclass = C_STAT;
/* Output the symbol. */
already decided which symbols we are going to keep. */
esym = (bfd_byte *) obj_coff_external_syms (input_bfd);
esym_end = esym + obj_raw_syment_count (input_bfd) * isymesz;
- isymp = finfo->internal_syms;
- indexp = finfo->sym_indices;
+ isymp = flaginfo->internal_syms;
+ indexp = flaginfo->sym_indices;
sym_hash = obj_coff_sym_hashes (input_bfd);
- outsym = finfo->outsyms;
+ outsym = flaginfo->outsyms;
while (esym < esym_end)
{
return FALSE;
}
filename = strings + auxp->x_file.x_n.x_offset;
- indx = _bfd_stringtab_add (finfo->strtab, filename,
+ indx = _bfd_stringtab_add (flaginfo->strtab, filename,
hash, copy);
if (indx == (bfd_size_type) -1)
return FALSE;
the index of the next symbol we are going
to include. I don't know if this is
entirely right. */
- while ((finfo->sym_indices[indx] < 0
- || ((bfd_size_type) finfo->sym_indices[indx]
+ while ((flaginfo->sym_indices[indx] < 0
+ || ((bfd_size_type) flaginfo->sym_indices[indx]
< syment_base))
&& indx < obj_raw_syment_count (input_bfd))
++indx;
if (indx >= obj_raw_syment_count (input_bfd))
indx = output_index;
else
- indx = finfo->sym_indices[indx];
+ indx = flaginfo->sym_indices[indx];
auxp->x_sym.x_fcnary.x_fcn.x_endndx.l = indx;
}
}
{
long symindx;
- symindx = finfo->sym_indices[indx];
+ symindx = flaginfo->sym_indices[indx];
if (symindx < 0)
auxp->x_sym.x_tagndx.l = 0;
else
&& isymp->_n._n_name[2] == 'f'
&& isymp->_n._n_name[3] == '\0')
{
- if (finfo->last_bf_index != -1)
+ if (flaginfo->last_bf_index != -1)
{
- finfo->last_bf.x_sym.x_fcnary.x_fcn.x_endndx.l =
+ flaginfo->last_bf.x_sym.x_fcnary.x_fcn.x_endndx.l =
*indexp;
- if ((bfd_size_type) finfo->last_bf_index
+ if ((bfd_size_type) flaginfo->last_bf_index
>= syment_base)
{
void *auxout;
file. This will only happen if the
assembler did not set up the .bf
endndx symbols correctly. */
- auxout = (finfo->outsyms
- + ((finfo->last_bf_index
+ auxout = (flaginfo->outsyms
+ + ((flaginfo->last_bf_index
- syment_base)
* osymesz));
bfd_coff_swap_aux_out (output_bfd,
- &finfo->last_bf,
+ &flaginfo->last_bf,
isymp->n_type,
isymp->n_sclass,
0, isymp->n_numaux,
temporarily. FIXME: This case should
be made faster. */
bfd_coff_swap_aux_out (output_bfd,
- &finfo->last_bf,
+ &flaginfo->last_bf,
isymp->n_type,
isymp->n_sclass,
0, isymp->n_numaux,
outsym);
pos = obj_sym_filepos (output_bfd);
- pos += finfo->last_bf_index * osymesz;
+ pos += flaginfo->last_bf_index * osymesz;
if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
|| (bfd_bwrite (outsym, osymesz, output_bfd)
!= osymesz))
}
if (auxp->x_sym.x_fcnary.x_fcn.x_endndx.l != 0)
- finfo->last_bf_index = -1;
+ flaginfo->last_bf_index = -1;
else
{
/* The endndx field of this aux entry must
be updated with the symbol number of the
next .bf symbol. */
- finfo->last_bf = *auxp;
- finfo->last_bf_index = (((outsym - finfo->outsyms)
+ flaginfo->last_bf = *auxp;
+ flaginfo->last_bf_index = (((outsym - flaginfo->outsyms)
/ osymesz)
+ syment_base);
}
}
/* Relocate the line numbers, unless we are stripping them. */
- if (finfo->info->strip == strip_none
- || finfo->info->strip == strip_some)
+ if (flaginfo->info->strip == strip_none
+ || flaginfo->info->strip == strip_some)
{
for (o = input_bfd->sections; o != NULL; o = o->next)
{
continue;
if (bfd_seek (input_bfd, o->line_filepos, SEEK_SET) != 0
- || bfd_bread (finfo->linenos, linesz * o->lineno_count,
+ || bfd_bread (flaginfo->linenos, linesz * o->lineno_count,
input_bfd) != linesz * o->lineno_count)
return FALSE;
offset = o->output_section->vma + o->output_offset - o->vma;
- eline = finfo->linenos;
- oeline = finfo->linenos;
+ eline = flaginfo->linenos;
+ oeline = flaginfo->linenos;
elineend = eline + linesz * o->lineno_count;
skipping = FALSE;
for (; eline < elineend; eline += linesz)
{
long indx;
- indx = finfo->sym_indices[iline.l_addr.l_symndx];
+ indx = flaginfo->sym_indices[iline.l_addr.l_symndx];
if (indx < 0)
{
of the line numbers rather than an absolute
file index. */
bfd_coff_swap_sym_in (output_bfd,
- (finfo->outsyms
+ (flaginfo->outsyms
+ ((indx - syment_base)
* osymesz)), &is);
if ((ISFCN (is.n_type)
{
void *auxptr;
- auxptr = (finfo->outsyms
+ auxptr = (flaginfo->outsyms
+ ((indx - syment_base + 1)
* osymesz));
bfd_coff_swap_aux_in (output_bfd, auxptr,
ia.x_sym.x_fcnary.x_fcn.x_lnnoptr =
(o->output_section->line_filepos
+ o->output_section->lineno_count * linesz
- + eline - finfo->linenos);
+ + eline - flaginfo->linenos);
bfd_coff_swap_aux_out (output_bfd, &ia,
is.n_type, is.n_sclass, 0,
is.n_numaux, auxptr);
pos = o->output_section->line_filepos;
pos += o->output_section->lineno_count * linesz;
- amt = oeline - finfo->linenos;
+ amt = oeline - flaginfo->linenos;
if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
- || bfd_bwrite (finfo->linenos, amt, output_bfd) != amt)
+ || bfd_bwrite (flaginfo->linenos, amt, output_bfd) != amt)
return FALSE;
o->output_section->lineno_count += amt / linesz;
symbol will be the first symbol in the next input file. In the
normal case, this will save us from writing out the C_FILE symbol
again. */
- if (finfo->last_file_index != -1
- && (bfd_size_type) finfo->last_file_index >= syment_base)
+ if (flaginfo->last_file_index != -1
+ && (bfd_size_type) flaginfo->last_file_index >= syment_base)
{
- finfo->last_file.n_value = output_index;
- bfd_coff_swap_sym_out (output_bfd, &finfo->last_file,
- (finfo->outsyms
- + ((finfo->last_file_index - syment_base)
+ flaginfo->last_file.n_value = output_index;
+ bfd_coff_swap_sym_out (output_bfd, &flaginfo->last_file,
+ (flaginfo->outsyms
+ + ((flaginfo->last_file_index - syment_base)
* osymesz)));
}
/* Write the modified symbols to the output file. */
- if (outsym > finfo->outsyms)
+ if (outsym > flaginfo->outsyms)
{
file_ptr pos;
bfd_size_type amt;
pos = obj_sym_filepos (output_bfd) + syment_base * osymesz;
- amt = outsym - finfo->outsyms;
+ amt = outsym - flaginfo->outsyms;
if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
- || bfd_bwrite (finfo->outsyms, amt, output_bfd) != amt)
+ || bfd_bwrite (flaginfo->outsyms, amt, output_bfd) != amt)
return FALSE;
BFD_ASSERT ((obj_raw_syment_count (output_bfd)
- + (outsym - finfo->outsyms) / osymesz)
+ + (outsym - flaginfo->outsyms) / osymesz)
== output_index);
obj_raw_syment_count (output_bfd) = output_index;
else
{
bfd_size_type x = o->rawsize ? o->rawsize : o->size;
- if (! bfd_get_section_contents (input_bfd, o, finfo->contents, 0, x))
+ if (! bfd_get_section_contents (input_bfd, o, flaginfo->contents, 0, x))
return FALSE;
- contents = finfo->contents;
+ contents = flaginfo->contents;
}
if ((o->flags & SEC_RELOC) != 0)
/* Read in the relocs. */
target_index = o->output_section->target_index;
internal_relocs = (_bfd_coff_read_internal_relocs
- (input_bfd, o, FALSE, finfo->external_relocs,
- finfo->info->relocatable,
- (finfo->info->relocatable
- ? (finfo->section_info[target_index].relocs
+ (input_bfd, o, FALSE, flaginfo->external_relocs,
+ flaginfo->info->relocatable,
+ (flaginfo->info->relocatable
+ ? (flaginfo->section_info[target_index].relocs
+ o->output_section->reloc_count)
- : finfo->internal_relocs)));
+ : flaginfo->internal_relocs)));
if (internal_relocs == NULL)
return FALSE;
continue;
/* Complain if definition comes from an excluded section. */
if (ps->flags & SEC_EXCLUDE)
- (*finfo->info->callbacks->einfo)
+ (*flaginfo->info->callbacks->einfo)
(_("%X`%s' referenced in section `%A' of %B: "
"defined in discarded section `%A' of %B\n"),
h->root.root.string, o, input_bfd, ps, ps->owner);
/* Call processor specific code to relocate the section
contents. */
- if (! bfd_coff_relocate_section (output_bfd, finfo->info,
+ if (! bfd_coff_relocate_section (output_bfd, flaginfo->info,
input_bfd, o,
contents,
internal_relocs,
- finfo->internal_syms,
- finfo->sec_ptrs))
+ flaginfo->internal_syms,
+ flaginfo->sec_ptrs))
return FALSE;
- if (finfo->info->relocatable)
+ if (flaginfo->info->relocatable)
{
bfd_vma offset;
struct internal_reloc *irelend;
offset = o->output_section->vma + o->output_offset - o->vma;
irel = internal_relocs;
irelend = irel + o->reloc_count;
- rel_hash = (finfo->section_info[target_index].rel_hashes
+ rel_hash = (flaginfo->section_info[target_index].rel_hashes
+ o->output_section->reloc_count);
for (; irel < irelend; irel++, rel_hash++)
{
if (adjust_symndx)
{
- if (! (*adjust_symndx) (output_bfd, finfo->info,
+ if (! (*adjust_symndx) (output_bfd, flaginfo->info,
input_bfd, o, irel,
&adjusted))
return FALSE;
{
long indx;
- indx = finfo->sym_indices[irel->r_symndx];
+ indx = flaginfo->sym_indices[irel->r_symndx];
if (indx != -1)
irel->r_symndx = indx;
else
stripping. This should have been handled
by the 'dont_skip_symbol' code in the while
loop at the top of this function. */
- is = finfo->internal_syms + irel->r_symndx;
+ is = flaginfo->internal_syms + irel->r_symndx;
name = (_bfd_coff_internal_syment_name
(input_bfd, is, buf));
if (name == NULL)
return FALSE;
- if (! ((*finfo->info->callbacks->unattached_reloc)
- (finfo->info, name, input_bfd, o,
+ if (! ((*flaginfo->info->callbacks->unattached_reloc)
+ (flaginfo->info, name, input_bfd, o,
irel->r_vaddr)))
return FALSE;
}
else
{
if (! (_bfd_write_section_stabs
- (output_bfd, &coff_hash_table (finfo->info)->stab_info,
+ (output_bfd, &coff_hash_table (flaginfo->info)->stab_info,
o, &secdata->stab_info, contents)))
return FALSE;
}
}
- if (! finfo->info->keep_memory
+ if (! flaginfo->info->keep_memory
&& ! _bfd_coff_free_symbols (input_bfd))
return FALSE;
_bfd_coff_write_global_sym (struct bfd_hash_entry *bh, void *data)
{
struct coff_link_hash_entry *h = (struct coff_link_hash_entry *) bh;
- struct coff_final_link_info *finfo = (struct coff_final_link_info *) data;
+ struct coff_final_link_info *flaginfo = (struct coff_final_link_info *) data;
bfd *output_bfd;
struct internal_syment isym;
bfd_size_type symesz;
unsigned int i;
file_ptr pos;
- output_bfd = finfo->output_bfd;
+ output_bfd = flaginfo->output_bfd;
if (h->root.type == bfd_link_hash_warning)
{
return TRUE;
if (h->indx != -2
- && (finfo->info->strip == strip_all
- || (finfo->info->strip == strip_some
- && (bfd_hash_lookup (finfo->info->keep_hash,
+ && (flaginfo->info->strip == strip_all
+ || (flaginfo->info->strip == strip_some
+ && (bfd_hash_lookup (flaginfo->info->keep_hash,
h->root.root.string, FALSE, FALSE)
== NULL))))
return TRUE;
isym.n_scnum = sec->target_index;
isym.n_value = (h->root.u.def.value
+ h->root.u.def.section->output_offset);
- if (! obj_pe (finfo->output_bfd))
+ if (! obj_pe (flaginfo->output_bfd))
isym.n_value += sec->vma;
}
break;
hash = TRUE;
if ((output_bfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
hash = FALSE;
- indx = _bfd_stringtab_add (finfo->strtab, h->root.root.string, hash,
+ indx = _bfd_stringtab_add (flaginfo->strtab, h->root.root.string, hash,
FALSE);
if (indx == (bfd_size_type) -1)
{
- finfo->failed = TRUE;
+ flaginfo->failed = TRUE;
return FALSE;
}
isym._n._n_n._n_zeroes = 0;
defined globals to statics, then do that conversion now. If the
symbol is not being converted, just ignore it and it will be
output during a later pass. */
- if (finfo->global_to_static)
+ if (flaginfo->global_to_static)
{
if (! IS_EXTERNAL (output_bfd, isym))
return TRUE;
/* When a weak symbol is not overridden by a strong one,
turn it into an external symbol when not building a
shared or relocatable object. */
- if (! finfo->info->shared
- && ! finfo->info->relocatable
- && IS_WEAK_EXTERNAL (finfo->output_bfd, isym))
+ if (! flaginfo->info->shared
+ && ! flaginfo->info->relocatable
+ && IS_WEAK_EXTERNAL (flaginfo->output_bfd, isym))
isym.n_sclass = C_EXT;
isym.n_numaux = h->numaux;
- bfd_coff_swap_sym_out (output_bfd, &isym, finfo->outsyms);
+ bfd_coff_swap_sym_out (output_bfd, &isym, flaginfo->outsyms);
symesz = bfd_coff_symesz (output_bfd);
pos = obj_sym_filepos (output_bfd);
pos += obj_raw_syment_count (output_bfd) * symesz;
if (bfd_seek (output_bfd, pos, SEEK_SET) != 0
- || bfd_bwrite (finfo->outsyms, symesz, output_bfd) != symesz)
+ || bfd_bwrite (flaginfo->outsyms, symesz, output_bfd) != symesz)
{
- finfo->failed = TRUE;
+ flaginfo->failed = TRUE;
return FALSE;
}
not matter. FIXME: Why not? */
if (sec->reloc_count > 0xffff
&& (! obj_pe (output_bfd)
- || finfo->info->relocatable))
+ || flaginfo->info->relocatable))
(*_bfd_error_handler)
(_("%s: %s: reloc overflow: 0x%lx > 0xffff"),
bfd_get_filename (output_bfd),
if (sec->lineno_count > 0xffff
&& (! obj_pe (output_bfd)
- || finfo->info->relocatable))
+ || flaginfo->info->relocatable))
(*_bfd_error_handler)
(_("%s: warning: %s: line number overflow: 0x%lx > 0xffff"),
bfd_get_filename (output_bfd),
bfd_coff_swap_aux_out (output_bfd, auxp, isym.n_type,
isym.n_sclass, (int) i, isym.n_numaux,
- finfo->outsyms);
- if (bfd_bwrite (finfo->outsyms, symesz, output_bfd) != symesz)
+ flaginfo->outsyms);
+ if (bfd_bwrite (flaginfo->outsyms, symesz, output_bfd) != symesz)
{
- finfo->failed = TRUE;
+ flaginfo->failed = TRUE;
return FALSE;
}
++obj_raw_syment_count (output_bfd);
bfd_boolean
_bfd_coff_write_task_globals (struct coff_link_hash_entry *h, void *data)
{
- struct coff_final_link_info *finfo = (struct coff_final_link_info *) data;
+ struct coff_final_link_info *flaginfo = (struct coff_final_link_info *) data;
bfd_boolean rtnval = TRUE;
bfd_boolean save_global_to_static;
{
case bfd_link_hash_defined:
case bfd_link_hash_defweak:
- save_global_to_static = finfo->global_to_static;
- finfo->global_to_static = TRUE;
+ save_global_to_static = flaginfo->global_to_static;
+ flaginfo->global_to_static = TRUE;
rtnval = _bfd_coff_write_global_sym (&h->root.root, data);
- finfo->global_to_static = save_global_to_static;
+ flaginfo->global_to_static = save_global_to_static;
break;
default:
break;
bfd_boolean
_bfd_coff_reloc_link_order (bfd *output_bfd,
- struct coff_final_link_info *finfo,
+ struct coff_final_link_info *flaginfo,
asection *output_section,
struct bfd_link_order *link_order)
{
case bfd_reloc_outofrange:
abort ();
case bfd_reloc_overflow:
- if (! ((*finfo->info->callbacks->reloc_overflow)
- (finfo->info, NULL,
+ if (! ((*flaginfo->info->callbacks->reloc_overflow)
+ (flaginfo->info, NULL,
(link_order->type == bfd_section_reloc_link_order
? bfd_section_name (output_bfd,
link_order->u.reloc.p->u.section)
/* Store the reloc information in the right place. It will get
swapped and written out at the end of the final_link routine. */
- irel = (finfo->section_info[output_section->target_index].relocs
+ irel = (flaginfo->section_info[output_section->target_index].relocs
+ output_section->reloc_count);
- rel_hash_ptr = (finfo->section_info[output_section->target_index].rel_hashes
+ rel_hash_ptr = (flaginfo->section_info[output_section->target_index].rel_hashes
+ output_section->reloc_count);
memset (irel, 0, sizeof (struct internal_reloc));
struct coff_link_hash_entry *h;
h = ((struct coff_link_hash_entry *)
- bfd_wrapped_link_hash_lookup (output_bfd, finfo->info,
+ bfd_wrapped_link_hash_lookup (output_bfd, flaginfo->info,
link_order->u.reloc.p->u.name,
FALSE, FALSE, TRUE));
if (h != NULL)
}
else
{
- if (! ((*finfo->info->callbacks->unattached_reloc)
- (finfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL,
+ if (! ((*flaginfo->info->callbacks->unattached_reloc)
+ (flaginfo->info, link_order->u.reloc.p->u.name, (bfd *) NULL,
(asection *) NULL, (bfd_vma) 0)))
return FALSE;
irel->r_symndx = 0;
typedef struct
{
- void *finfo;
+ void *flaginfo;
struct bfd_link_info *info;
asection *sec;
int sec_shndx;
sym.st_shndx = osi->sec_shndx;
sym.st_target_internal = 0;
elf32_arm_section_map_add (osi->sec, names[type][1], offset);
- return osi->func (osi->finfo, names[type], &sym, osi->sec, NULL) == 1;
+ return osi->func (osi->flaginfo, names[type], &sym, osi->sec, NULL) == 1;
}
/* Output mapping symbols for the PLT entry described by ROOT_PLT and ARM_PLT.
sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
sym.st_shndx = osi->sec_shndx;
sym.st_target_internal = 0;
- return osi->func (osi->finfo, name, &sym, osi->sec, NULL) == 1;
+ return osi->func (osi->flaginfo, name, &sym, osi->sec, NULL) == 1;
}
static bfd_boolean
static bfd_boolean
elf32_arm_output_arch_local_syms (bfd *output_bfd,
struct bfd_link_info *info,
- void *finfo,
+ void *flaginfo,
int (*func) (void *, const char *,
Elf_Internal_Sym *,
asection *,
check_use_blx (htab);
- osi.finfo = finfo;
+ osi.flaginfo = flaginfo;
osi.info = info;
osi.func = func;
static bfd_boolean
elf64_sparc_output_arch_syms (bfd *output_bfd ATTRIBUTE_UNUSED,
struct bfd_link_info *info,
- PTR finfo,
+ PTR flaginfo,
int (*func) (PTR, const char *,
Elf_Internal_Sym *,
asection *,
sym.st_info = ELF_ST_INFO (app_regs [reg].bind, STT_REGISTER);
sym.st_shndx = app_regs [reg].shndx;
sym.st_target_internal = 0;
- if ((*func) (finfo, app_regs [reg].name, &sym,
+ if ((*func) (flaginfo, app_regs [reg].name, &sym,
sym.st_shndx == SHN_ABS
? bfd_abs_section_ptr : bfd_und_section_ptr,
NULL) != 1)
{
bfd_boolean failed;
bfd_boolean localsyms;
- struct elf_final_link_info *finfo;
+ struct elf_final_link_info *flaginfo;
};
static bfd_boolean
resolve_symbol (const char *name,
bfd *input_bfd,
- struct elf_final_link_info *finfo,
+ struct elf_final_link_info *flaginfo,
bfd_vma *result,
Elf_Internal_Sym *isymbuf,
size_t locsymcount)
#endif
if (candidate && strcmp (candidate, name) == 0)
{
- asection *sec = finfo->sections [i];
+ asection *sec = flaginfo->sections [i];
*result = _bfd_elf_rel_local_sym (input_bfd, sym, &sec, 0);
*result += sec->output_offset + sec->output_section->vma;
}
/* Hmm, haven't found it yet. perhaps it is a global. */
- global_entry = bfd_link_hash_lookup (finfo->info->hash, name,
+ global_entry = bfd_link_hash_lookup (flaginfo->info->hash, name,
FALSE, FALSE, TRUE);
if (!global_entry)
return FALSE;
eval_symbol (bfd_vma *result,
const char **symp,
bfd *input_bfd,
- struct elf_final_link_info *finfo,
+ struct elf_final_link_info *flaginfo,
bfd_vma dot,
Elf_Internal_Sym *isymbuf,
size_t locsymcount,
if (symbol_is_section)
{
- if (!resolve_section (symbuf, finfo->output_bfd->sections, result)
- && !resolve_symbol (symbuf, input_bfd, finfo, result,
+ if (!resolve_section (symbuf, flaginfo->output_bfd->sections, result)
+ && !resolve_symbol (symbuf, input_bfd, flaginfo, result,
isymbuf, locsymcount))
{
undefined_reference ("section", symbuf);
}
else
{
- if (!resolve_symbol (symbuf, input_bfd, finfo, result,
+ if (!resolve_symbol (symbuf, input_bfd, flaginfo, result,
isymbuf, locsymcount)
- && !resolve_section (symbuf, finfo->output_bfd->sections,
+ && !resolve_section (symbuf, flaginfo->output_bfd->sections,
result))
{
undefined_reference ("symbol", symbuf);
if (*sym == ':') \
++sym; \
*symp = sym; \
- if (!eval_symbol (&a, symp, input_bfd, finfo, dot, \
+ if (!eval_symbol (&a, symp, input_bfd, flaginfo, dot, \
isymbuf, locsymcount, signed_p)) \
return FALSE; \
if (signed_p) \
if (*sym == ':') \
++sym; \
*symp = sym; \
- if (!eval_symbol (&a, symp, input_bfd, finfo, dot, \
+ if (!eval_symbol (&a, symp, input_bfd, flaginfo, dot, \
isymbuf, locsymcount, signed_p)) \
return FALSE; \
++*symp; \
- if (!eval_symbol (&b, symp, input_bfd, finfo, dot, \
+ if (!eval_symbol (&b, symp, input_bfd, flaginfo, dot, \
isymbuf, locsymcount, signed_p)) \
return FALSE; \
if (signed_p) \
/* Flush the output symbols to the file. */
static bfd_boolean
-elf_link_flush_output_syms (struct elf_final_link_info *finfo,
+elf_link_flush_output_syms (struct elf_final_link_info *flaginfo,
const struct elf_backend_data *bed)
{
- if (finfo->symbuf_count > 0)
+ if (flaginfo->symbuf_count > 0)
{
Elf_Internal_Shdr *hdr;
file_ptr pos;
bfd_size_type amt;
- hdr = &elf_tdata (finfo->output_bfd)->symtab_hdr;
+ hdr = &elf_tdata (flaginfo->output_bfd)->symtab_hdr;
pos = hdr->sh_offset + hdr->sh_size;
- amt = finfo->symbuf_count * bed->s->sizeof_sym;
- if (bfd_seek (finfo->output_bfd, pos, SEEK_SET) != 0
- || bfd_bwrite (finfo->symbuf, amt, finfo->output_bfd) != amt)
+ amt = flaginfo->symbuf_count * bed->s->sizeof_sym;
+ if (bfd_seek (flaginfo->output_bfd, pos, SEEK_SET) != 0
+ || bfd_bwrite (flaginfo->symbuf, amt, flaginfo->output_bfd) != amt)
return FALSE;
hdr->sh_size += amt;
- finfo->symbuf_count = 0;
+ flaginfo->symbuf_count = 0;
}
return TRUE;
/* Add a symbol to the output symbol table. */
static int
-elf_link_output_sym (struct elf_final_link_info *finfo,
+elf_link_output_sym (struct elf_final_link_info *flaginfo,
const char *name,
Elf_Internal_Sym *elfsym,
asection *input_sec,
struct elf_link_hash_entry *);
const struct elf_backend_data *bed;
- bed = get_elf_backend_data (finfo->output_bfd);
+ bed = get_elf_backend_data (flaginfo->output_bfd);
output_symbol_hook = bed->elf_backend_link_output_symbol_hook;
if (output_symbol_hook != NULL)
{
- int ret = (*output_symbol_hook) (finfo->info, name, elfsym, input_sec, h);
+ int ret = (*output_symbol_hook) (flaginfo->info, name, elfsym, input_sec, h);
if (ret != 1)
return ret;
}
elfsym->st_name = 0;
else
{
- elfsym->st_name = (unsigned long) _bfd_stringtab_add (finfo->symstrtab,
+ elfsym->st_name = (unsigned long) _bfd_stringtab_add (flaginfo->symstrtab,
name, TRUE, FALSE);
if (elfsym->st_name == (unsigned long) -1)
return 0;
}
- if (finfo->symbuf_count >= finfo->symbuf_size)
+ if (flaginfo->symbuf_count >= flaginfo->symbuf_size)
{
- if (! elf_link_flush_output_syms (finfo, bed))
+ if (! elf_link_flush_output_syms (flaginfo, bed))
return 0;
}
- dest = finfo->symbuf + finfo->symbuf_count * bed->s->sizeof_sym;
- destshndx = finfo->symshndxbuf;
+ dest = flaginfo->symbuf + flaginfo->symbuf_count * bed->s->sizeof_sym;
+ destshndx = flaginfo->symshndxbuf;
if (destshndx != NULL)
{
- if (bfd_get_symcount (finfo->output_bfd) >= finfo->shndxbuf_size)
+ if (bfd_get_symcount (flaginfo->output_bfd) >= flaginfo->shndxbuf_size)
{
bfd_size_type amt;
- amt = finfo->shndxbuf_size * sizeof (Elf_External_Sym_Shndx);
+ amt = flaginfo->shndxbuf_size * sizeof (Elf_External_Sym_Shndx);
destshndx = (Elf_External_Sym_Shndx *) bfd_realloc (destshndx,
amt * 2);
if (destshndx == NULL)
return 0;
- finfo->symshndxbuf = destshndx;
+ flaginfo->symshndxbuf = destshndx;
memset ((char *) destshndx + amt, 0, amt);
- finfo->shndxbuf_size *= 2;
+ flaginfo->shndxbuf_size *= 2;
}
- destshndx += bfd_get_symcount (finfo->output_bfd);
+ destshndx += bfd_get_symcount (flaginfo->output_bfd);
}
- bed->s->swap_symbol_out (finfo->output_bfd, elfsym, dest, destshndx);
- finfo->symbuf_count += 1;
- bfd_get_symcount (finfo->output_bfd) += 1;
+ bed->s->swap_symbol_out (flaginfo->output_bfd, elfsym, dest, destshndx);
+ flaginfo->symbuf_count += 1;
+ bfd_get_symcount (flaginfo->output_bfd) += 1;
return 1;
}
{
struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
struct elf_outext_info *eoinfo = (struct elf_outext_info *) data;
- struct elf_final_link_info *finfo = eoinfo->finfo;
+ struct elf_final_link_info *flaginfo = eoinfo->flaginfo;
bfd_boolean strip;
Elf_Internal_Sym sym;
asection *input_sec;
return TRUE;
}
- bed = get_elf_backend_data (finfo->output_bfd);
+ bed = get_elf_backend_data (flaginfo->output_bfd);
if (h->root.type == bfd_link_hash_undefined)
{
/* If we are reporting errors for this situation then do so now. */
if (!ignore_undef
&& h->ref_dynamic
- && (!h->ref_regular || finfo->info->gc_sections)
- && ! elf_link_check_versioned_symbol (finfo->info, bed, h)
- && finfo->info->unresolved_syms_in_shared_libs != RM_IGNORE)
+ && (!h->ref_regular || flaginfo->info->gc_sections)
+ && ! elf_link_check_versioned_symbol (flaginfo->info, bed, h)
+ && flaginfo->info->unresolved_syms_in_shared_libs != RM_IGNORE)
{
- if (! (finfo->info->callbacks->undefined_symbol
- (finfo->info, h->root.root.string,
+ if (! (flaginfo->info->callbacks->undefined_symbol
+ (flaginfo->info, h->root.root.string,
h->ref_regular ? NULL : h->root.u.undef.abfd,
- NULL, 0, finfo->info->unresolved_syms_in_shared_libs == RM_GENERATE_ERROR)))
+ NULL, 0, flaginfo->info->unresolved_syms_in_shared_libs == RM_GENERATE_ERROR)))
{
bfd_set_error (bfd_error_bad_value);
eoinfo->failed = TRUE;
/* We should also warn if a forced local symbol is referenced from
shared libraries. */
- if (!finfo->info->relocatable
- && finfo->info->executable
+ if (!flaginfo->info->relocatable
+ && flaginfo->info->executable
&& h->forced_local
&& h->ref_dynamic
&& h->def_regular
&& !h->dynamic_def
&& !h->dynamic_weak
- && ! elf_link_check_versioned_symbol (finfo->info, bed, h))
+ && ! elf_link_check_versioned_symbol (flaginfo->info, bed, h))
{
bfd *def_bfd;
const char *msg;
msg = _("%B: hidden symbol `%s' in %B is referenced by DSO");
else
msg = _("%B: local symbol `%s' in %B is referenced by DSO");
- def_bfd = finfo->output_bfd;
+ def_bfd = flaginfo->output_bfd;
if (h->root.u.def.section != bfd_abs_section_ptr)
def_bfd = h->root.u.def.section->owner;
- (*_bfd_error_handler) (msg, finfo->output_bfd, def_bfd,
+ (*_bfd_error_handler) (msg, flaginfo->output_bfd, def_bfd,
h->root.root.string);
bfd_set_error (bfd_error_bad_value);
eoinfo->failed = TRUE;
&& !h->def_regular
&& !h->ref_regular)
strip = TRUE;
- else if (finfo->info->strip == strip_all)
+ else if (flaginfo->info->strip == strip_all)
strip = TRUE;
- else if (finfo->info->strip == strip_some
- && bfd_hash_lookup (finfo->info->keep_hash,
+ else if (flaginfo->info->strip == strip_some
+ && bfd_hash_lookup (flaginfo->info->keep_hash,
h->root.root.string, FALSE, FALSE) == NULL)
strip = TRUE;
else if ((h->root.type == bfd_link_hash_defined
|| h->root.type == bfd_link_hash_defweak)
- && ((finfo->info->strip_discarded
+ && ((flaginfo->info->strip_discarded
&& discarded_section (h->root.u.def.section))
|| (h->root.u.def.section->owner != NULL
&& (h->root.u.def.section->owner->flags & BFD_PLUGIN) != 0)))
if (input_sec->output_section != NULL)
{
sym.st_shndx =
- _bfd_elf_section_from_bfd_section (finfo->output_bfd,
+ _bfd_elf_section_from_bfd_section (flaginfo->output_bfd,
input_sec->output_section);
if (sym.st_shndx == SHN_BAD)
{
(*_bfd_error_handler)
(_("%B: could not find output section %A for input section %A"),
- finfo->output_bfd, input_sec->output_section, input_sec);
+ flaginfo->output_bfd, input_sec->output_section, input_sec);
bfd_set_error (bfd_error_nonrepresentable_section);
eoinfo->failed = TRUE;
return FALSE;
but in nonrelocatable files they are virtual
addresses. */
sym.st_value = h->root.u.def.value + input_sec->output_offset;
- if (! finfo->info->relocatable)
+ if (! flaginfo->info->relocatable)
{
sym.st_value += input_sec->output_section->vma;
if (h->type == STT_TLS)
{
- asection *tls_sec = elf_hash_table (finfo->info)->tls_sec;
+ asection *tls_sec = elf_hash_table (flaginfo->info)->tls_sec;
if (tls_sec != NULL)
sym.st_value -= tls_sec->vma;
else
{
/* The TLS section may have been garbage collected. */
- BFD_ASSERT (finfo->info->gc_sections
+ BFD_ASSERT (flaginfo->info->gc_sections
&& !input_sec->gc_mark);
}
}
STT_GNU_IFUNC symbol must go through PLT. */
if ((h->type == STT_GNU_IFUNC
&& h->def_regular
- && !finfo->info->relocatable)
+ && !flaginfo->info->relocatable)
|| ((h->dynindx != -1
|| h->forced_local)
- && ((finfo->info->shared
+ && ((flaginfo->info->shared
&& (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
|| h->root.type != bfd_link_hash_undefweak))
|| !h->forced_local)
- && elf_hash_table (finfo->info)->dynamic_sections_created))
+ && elf_hash_table (flaginfo->info)->dynamic_sections_created))
{
if (! ((*bed->elf_backend_finish_dynamic_symbol)
- (finfo->output_bfd, finfo->info, h, &sym)))
+ (flaginfo->output_bfd, flaginfo->info, h, &sym)))
{
eoinfo->failed = TRUE;
return FALSE;
/* If a non-weak symbol with non-default visibility is not defined
locally, it is a fatal error. */
- if (! finfo->info->relocatable
+ if (! flaginfo->info->relocatable
&& ELF_ST_VISIBILITY (sym.st_other) != STV_DEFAULT
&& ELF_ST_BIND (sym.st_info) != STB_WEAK
&& h->root.type == bfd_link_hash_undefined
msg = _("%B: internal symbol `%s' isn't defined");
else
msg = _("%B: hidden symbol `%s' isn't defined");
- (*_bfd_error_handler) (msg, finfo->output_bfd, h->root.root.string);
+ (*_bfd_error_handler) (msg, flaginfo->output_bfd, h->root.root.string);
bfd_set_error (bfd_error_bad_value);
eoinfo->failed = TRUE;
return FALSE;
/* If this symbol should be put in the .dynsym section, then put it
there now. We already know the symbol index. We also fill in
the entry in the .hash section. */
- if (finfo->dynsym_sec != NULL
+ if (flaginfo->dynsym_sec != NULL
&& h->dynindx != -1
- && elf_hash_table (finfo->info)->dynamic_sections_created)
+ && elf_hash_table (flaginfo->info)->dynamic_sections_created)
{
bfd_byte *esym;
sym.st_name = h->dynstr_index;
- esym = finfo->dynsym_sec->contents + h->dynindx * bed->s->sizeof_sym;
- if (! check_dynsym (finfo->output_bfd, &sym))
+ esym = flaginfo->dynsym_sec->contents + h->dynindx * bed->s->sizeof_sym;
+ if (! check_dynsym (flaginfo->output_bfd, &sym))
{
eoinfo->failed = TRUE;
return FALSE;
}
- bed->s->swap_symbol_out (finfo->output_bfd, &sym, esym, 0);
+ bed->s->swap_symbol_out (flaginfo->output_bfd, &sym, esym, 0);
- if (finfo->hash_sec != NULL)
+ if (flaginfo->hash_sec != NULL)
{
size_t hash_entry_size;
bfd_byte *bucketpos;
size_t bucketcount;
size_t bucket;
- bucketcount = elf_hash_table (finfo->info)->bucketcount;
+ bucketcount = elf_hash_table (flaginfo->info)->bucketcount;
bucket = h->u.elf_hash_value % bucketcount;
hash_entry_size
- = elf_section_data (finfo->hash_sec)->this_hdr.sh_entsize;
- bucketpos = ((bfd_byte *) finfo->hash_sec->contents
+ = elf_section_data (flaginfo->hash_sec)->this_hdr.sh_entsize;
+ bucketpos = ((bfd_byte *) flaginfo->hash_sec->contents
+ (bucket + 2) * hash_entry_size);
- chain = bfd_get (8 * hash_entry_size, finfo->output_bfd, bucketpos);
- bfd_put (8 * hash_entry_size, finfo->output_bfd, h->dynindx, bucketpos);
- bfd_put (8 * hash_entry_size, finfo->output_bfd, chain,
- ((bfd_byte *) finfo->hash_sec->contents
+ chain = bfd_get (8 * hash_entry_size, flaginfo->output_bfd, bucketpos);
+ bfd_put (8 * hash_entry_size, flaginfo->output_bfd, h->dynindx, bucketpos);
+ bfd_put (8 * hash_entry_size, flaginfo->output_bfd, chain,
+ ((bfd_byte *) flaginfo->hash_sec->contents
+ (bucketcount + 2 + h->dynindx) * hash_entry_size));
}
- if (finfo->symver_sec != NULL && finfo->symver_sec->contents != NULL)
+ if (flaginfo->symver_sec != NULL && flaginfo->symver_sec->contents != NULL)
{
Elf_Internal_Versym iversym;
Elf_External_Versym *eversym;
iversym.vs_vers = 1;
else
iversym.vs_vers = h->verinfo.vertree->vernum + 1;
- if (finfo->info->create_default_symver)
+ if (flaginfo->info->create_default_symver)
iversym.vs_vers++;
}
if (h->hidden)
iversym.vs_vers |= VERSYM_HIDDEN;
- eversym = (Elf_External_Versym *) finfo->symver_sec->contents;
+ eversym = (Elf_External_Versym *) flaginfo->symver_sec->contents;
eversym += h->dynindx;
- _bfd_elf_swap_versym_out (finfo->output_bfd, &iversym, eversym);
+ _bfd_elf_swap_versym_out (flaginfo->output_bfd, &iversym, eversym);
}
}
if (strip || (input_sec->flags & SEC_EXCLUDE) != 0)
return TRUE;
- indx = bfd_get_symcount (finfo->output_bfd);
- ret = elf_link_output_sym (finfo, h->root.root.string, &sym, input_sec, h);
+ indx = bfd_get_symcount (flaginfo->output_bfd);
+ ret = elf_link_output_sym (flaginfo, h->root.root.string, &sym, input_sec, h);
if (ret == 0)
{
eoinfo->failed = TRUE;
don't have to keep them in memory. */
static bfd_boolean
-elf_link_input_bfd (struct elf_final_link_info *finfo, bfd *input_bfd)
+elf_link_input_bfd (struct elf_final_link_info *flaginfo, bfd *input_bfd)
{
int (*relocate_section)
(bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
bfd_vma r_type_mask;
int r_sym_shift;
- output_bfd = finfo->output_bfd;
+ output_bfd = flaginfo->output_bfd;
bed = get_elf_backend_data (output_bfd);
relocate_section = bed->elf_backend_relocate_section;
if (isymbuf == NULL && locsymcount != 0)
{
isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
- finfo->internal_syms,
- finfo->external_syms,
- finfo->locsym_shndx);
+ flaginfo->internal_syms,
+ flaginfo->external_syms,
+ flaginfo->locsym_shndx);
if (isymbuf == NULL)
return FALSE;
}
SEC_MERGE sections. Write out those local symbols we know are
going into the output file. */
isymend = isymbuf + locsymcount;
- for (isym = isymbuf, pindex = finfo->indices, ppsection = finfo->sections;
+ for (isym = isymbuf, pindex = flaginfo->indices, ppsection = flaginfo->sections;
isym < isymend;
isym++, pindex++, ppsection++)
{
*ppsection = isec;
/* Don't output the first, undefined, symbol. */
- if (ppsection == finfo->sections)
+ if (ppsection == flaginfo->sections)
continue;
if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
/* If we are stripping all symbols, we don't want to output this
one. */
- if (finfo->info->strip == strip_all)
+ if (flaginfo->info->strip == strip_all)
continue;
/* If we are discarding all local symbols, we don't want to
file, then some of the local symbols may be required by
relocs; we output them below as we discover that they are
needed. */
- if (finfo->info->discard == discard_all)
+ if (flaginfo->info->discard == discard_all)
continue;
/* If this symbol is defined in a section which we are
return FALSE;
/* See if we are discarding symbols with this name. */
- if ((finfo->info->strip == strip_some
- && (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE, FALSE)
+ if ((flaginfo->info->strip == strip_some
+ && (bfd_hash_lookup (flaginfo->info->keep_hash, name, FALSE, FALSE)
== NULL))
- || (((finfo->info->discard == discard_sec_merge
- && (isec->flags & SEC_MERGE) && ! finfo->info->relocatable)
- || finfo->info->discard == discard_l)
+ || (((flaginfo->info->discard == discard_sec_merge
+ && (isec->flags & SEC_MERGE) && ! flaginfo->info->relocatable)
+ || flaginfo->info->discard == discard_l)
&& bfd_is_local_label_name (input_bfd, name)))
continue;
output_section. Any special sections must be set up to meet
these requirements. */
osym.st_value += isec->output_offset;
- if (! finfo->info->relocatable)
+ if (! flaginfo->info->relocatable)
{
osym.st_value += isec->output_section->vma;
if (ELF_ST_TYPE (osym.st_info) == STT_TLS)
{
/* STT_TLS symbols are relative to PT_TLS segment base. */
- BFD_ASSERT (elf_hash_table (finfo->info)->tls_sec != NULL);
- osym.st_value -= elf_hash_table (finfo->info)->tls_sec->vma;
+ BFD_ASSERT (elf_hash_table (flaginfo->info)->tls_sec != NULL);
+ osym.st_value -= elf_hash_table (flaginfo->info)->tls_sec->vma;
}
}
indx = bfd_get_symcount (output_bfd);
- ret = elf_link_output_sym (finfo, name, &osym, isec, NULL);
+ ret = elf_link_output_sym (flaginfo, name, &osym, isec, NULL);
if (ret == 0)
return FALSE;
else if (ret == 1)
continue;
}
- if (finfo->info->relocatable
+ if (flaginfo->info->relocatable
&& (o->flags & (SEC_LINKER_CREATED | SEC_GROUP)) == SEC_GROUP)
{
/* Deal with the group signature symbol. */
if (symndx >= locsymcount
|| (elf_bad_symtab (input_bfd)
- && finfo->sections[symndx] == NULL))
+ && flaginfo->sections[symndx] == NULL))
{
struct elf_link_hash_entry *h = sym_hashes[symndx - extsymoff];
while (h->root.type == bfd_link_hash_indirect
else if (ELF_ST_TYPE (isymbuf[symndx].st_info) == STT_SECTION)
{
/* We'll use the output section target_index. */
- asection *sec = finfo->sections[symndx]->output_section;
+ asection *sec = flaginfo->sections[symndx]->output_section;
elf_section_data (osec)->this_hdr.sh_info = sec->target_index;
}
else
{
- if (finfo->indices[symndx] == -1)
+ if (flaginfo->indices[symndx] == -1)
{
/* Otherwise output the local symbol now. */
Elf_Internal_Sym sym = isymbuf[symndx];
- asection *sec = finfo->sections[symndx]->output_section;
+ asection *sec = flaginfo->sections[symndx]->output_section;
const char *name;
long indx;
int ret;
sym.st_value += o->output_offset;
indx = bfd_get_symcount (output_bfd);
- ret = elf_link_output_sym (finfo, name, &sym, o, NULL);
+ ret = elf_link_output_sym (flaginfo, name, &sym, o, NULL);
if (ret == 0)
return FALSE;
else if (ret == 1)
- finfo->indices[symndx] = indx;
+ flaginfo->indices[symndx] = indx;
else
abort ();
}
elf_section_data (osec)->this_hdr.sh_info
- = finfo->indices[symndx];
+ = flaginfo->indices[symndx];
}
}
contents = elf_section_data (o)->this_hdr.contents;
else
{
- contents = finfo->contents;
+ contents = flaginfo->contents;
if (! bfd_get_full_section_contents (input_bfd, o, &contents))
return FALSE;
}
/* Get the swapped relocs. */
internal_relocs
- = _bfd_elf_link_read_relocs (input_bfd, o, finfo->external_relocs,
- finfo->internal_relocs, FALSE);
+ = _bfd_elf_link_read_relocs (input_bfd, o, flaginfo->external_relocs,
+ flaginfo->internal_relocs, FALSE);
if (internal_relocs == NULL
&& o->reloc_count > 0)
return FALSE;
if (r_symndx >= locsymcount
|| (elf_bad_symtab (input_bfd)
- && finfo->sections[r_symndx] == NULL))
+ && flaginfo->sections[r_symndx] == NULL))
{
h = sym_hashes[r_symndx - extsymoff];
Elf_Internal_Sym *sym = isymbuf + r_symndx;
s_type = ELF_ST_TYPE (sym->st_info);
- ps = &finfo->sections[r_symndx];
+ ps = &flaginfo->sections[r_symndx];
sym_name = bfd_elf_sym_name (input_bfd, symtab_hdr,
sym, *ps);
}
if ((s_type == STT_RELC || s_type == STT_SRELC)
- && !finfo->info->relocatable)
+ && !flaginfo->info->relocatable)
{
bfd_vma val;
bfd_vma dot = (rel->r_offset
(unsigned long) rel->r_info,
(unsigned long) rel->r_offset);
#endif
- if (!eval_symbol (&val, &sym_name, input_bfd, finfo, dot,
+ if (!eval_symbol (&val, &sym_name, input_bfd, flaginfo, dot,
isymbuf, locsymcount, s_type == STT_SRELC))
return FALSE;
{
BFD_ASSERT (r_symndx != STN_UNDEF);
if (action_discarded & COMPLAIN)
- (*finfo->info->callbacks->einfo)
+ (*flaginfo->info->callbacks->einfo)
(_("%X`%s' referenced in section `%A' of %B: "
"defined in discarded section `%A' of %B\n"),
sym_name, o, input_bfd, sec, sec->owner);
asection *kept;
kept = _bfd_elf_check_kept_section (sec,
- finfo->info);
+ flaginfo->info);
if (kept != NULL)
{
*ps = kept;
corresponding to the output section, which will require
the addend to be adjusted. */
- ret = (*relocate_section) (output_bfd, finfo->info,
+ ret = (*relocate_section) (output_bfd, flaginfo->info,
input_bfd, o, contents,
internal_relocs,
isymbuf,
- finfo->sections);
+ flaginfo->sections);
if (!ret)
return FALSE;
if (ret == 2
- || finfo->info->relocatable
- || finfo->info->emitrelocations)
+ || flaginfo->info->relocatable
+ || flaginfo->info->emitrelocations)
{
Elf_Internal_Rela *irela;
Elf_Internal_Rela *irelaend, *irelamid;
rel_hash_list = rel_hash;
rela_hash_list = NULL;
last_offset = o->output_offset;
- if (!finfo->info->relocatable)
+ if (!flaginfo->info->relocatable)
last_offset += o->output_section->vma;
for (next_erel = 0; irela < irelaend; irela++, next_erel++)
{
}
irela->r_offset = _bfd_elf_section_offset (output_bfd,
- finfo->info, o,
+ flaginfo->info, o,
irela->r_offset);
if (irela->r_offset >= (bfd_vma) -2)
{
irela->r_offset += o->output_offset;
/* Relocs in an executable have to be virtual addresses. */
- if (!finfo->info->relocatable)
+ if (!flaginfo->info->relocatable)
irela->r_offset += o->output_section->vma;
last_offset = irela->r_offset;
if (r_symndx >= locsymcount
|| (elf_bad_symtab (input_bfd)
- && finfo->sections[r_symndx] == NULL))
+ && flaginfo->sections[r_symndx] == NULL))
{
struct elf_link_hash_entry *rh;
unsigned long indx;
*rel_hash = NULL;
sym = isymbuf[r_symndx];
- sec = finfo->sections[r_symndx];
+ sec = flaginfo->sections[r_symndx];
if (ELF_ST_TYPE (sym.st_info) == STT_SECTION)
{
/* I suppose the backend ought to fill in the
}
else
{
- if (finfo->indices[r_symndx] == -1)
+ if (flaginfo->indices[r_symndx] == -1)
{
unsigned long shlink;
const char *name;
asection *osec;
long indx;
- if (finfo->info->strip == strip_all)
+ if (flaginfo->info->strip == strip_all)
{
/* You can't do ld -r -s. */
bfd_set_error (bfd_error_invalid_operation);
return FALSE;
sym.st_value += sec->output_offset;
- if (! finfo->info->relocatable)
+ if (! flaginfo->info->relocatable)
{
sym.st_value += osec->vma;
if (ELF_ST_TYPE (sym.st_info) == STT_TLS)
{
/* STT_TLS symbols are relative to PT_TLS
segment base. */
- BFD_ASSERT (elf_hash_table (finfo->info)
+ BFD_ASSERT (elf_hash_table (flaginfo->info)
->tls_sec != NULL);
- sym.st_value -= (elf_hash_table (finfo->info)
+ sym.st_value -= (elf_hash_table (flaginfo->info)
->tls_sec->vma);
}
}
indx = bfd_get_symcount (output_bfd);
- ret = elf_link_output_sym (finfo, name, &sym, sec,
+ ret = elf_link_output_sym (flaginfo, name, &sym, sec,
NULL);
if (ret == 0)
return FALSE;
else if (ret == 1)
- finfo->indices[r_symndx] = indx;
+ flaginfo->indices[r_symndx] = indx;
else
abort ();
}
- r_symndx = finfo->indices[r_symndx];
+ r_symndx = flaginfo->indices[r_symndx];
}
irela->r_info = ((bfd_vma) r_symndx << r_sym_shift
/* Write out the modified section contents. */
if (bed->elf_backend_write_section
- && (*bed->elf_backend_write_section) (output_bfd, finfo->info, o,
+ && (*bed->elf_backend_write_section) (output_bfd, flaginfo->info, o,
contents))
{
/* Section written out. */
case SEC_INFO_TYPE_STABS:
if (! (_bfd_write_section_stabs
(output_bfd,
- &elf_hash_table (finfo->info)->stab_info,
+ &elf_hash_table (flaginfo->info)->stab_info,
o, &elf_section_data (o)->sec_info, contents)))
return FALSE;
break;
break;
case SEC_INFO_TYPE_EH_FRAME:
{
- if (! _bfd_elf_write_section_eh_frame (output_bfd, finfo->info,
+ if (! _bfd_elf_write_section_eh_frame (output_bfd, flaginfo->info,
o, contents))
return FALSE;
}
bfd_boolean dynamic;
bfd_boolean emit_relocs;
bfd *dynobj;
- struct elf_final_link_info finfo;
+ struct elf_final_link_info flaginfo;
asection *o;
struct bfd_link_order *p;
bfd *sub;
emit_relocs = (info->relocatable
|| info->emitrelocations);
- finfo.info = info;
- finfo.output_bfd = abfd;
- finfo.symstrtab = _bfd_elf_stringtab_init ();
- if (finfo.symstrtab == NULL)
+ flaginfo.info = info;
+ flaginfo.output_bfd = abfd;
+ flaginfo.symstrtab = _bfd_elf_stringtab_init ();
+ if (flaginfo.symstrtab == NULL)
return FALSE;
if (! dynamic)
{
- finfo.dynsym_sec = NULL;
- finfo.hash_sec = NULL;
- finfo.symver_sec = NULL;
+ flaginfo.dynsym_sec = NULL;
+ flaginfo.hash_sec = NULL;
+ flaginfo.symver_sec = NULL;
}
else
{
- finfo.dynsym_sec = bfd_get_section_by_name (dynobj, ".dynsym");
- finfo.hash_sec = bfd_get_section_by_name (dynobj, ".hash");
+ flaginfo.dynsym_sec = bfd_get_section_by_name (dynobj, ".dynsym");
+ flaginfo.hash_sec = bfd_get_section_by_name (dynobj, ".hash");
/* Note that dynsym_sec can be NULL (on VMS). */
- finfo.symver_sec = bfd_get_section_by_name (dynobj, ".gnu.version");
+ flaginfo.symver_sec = bfd_get_section_by_name (dynobj, ".gnu.version");
/* Note that it is OK if symver_sec is NULL. */
}
- finfo.contents = NULL;
- finfo.external_relocs = NULL;
- finfo.internal_relocs = NULL;
- finfo.external_syms = NULL;
- finfo.locsym_shndx = NULL;
- finfo.internal_syms = NULL;
- finfo.indices = NULL;
- finfo.sections = NULL;
- finfo.symbuf = NULL;
- finfo.symshndxbuf = NULL;
- finfo.symbuf_count = 0;
- finfo.shndxbuf_size = 0;
+ flaginfo.contents = NULL;
+ flaginfo.external_relocs = NULL;
+ flaginfo.internal_relocs = NULL;
+ flaginfo.external_syms = NULL;
+ flaginfo.locsym_shndx = NULL;
+ flaginfo.internal_syms = NULL;
+ flaginfo.indices = NULL;
+ flaginfo.sections = NULL;
+ flaginfo.symbuf = NULL;
+ flaginfo.symshndxbuf = NULL;
+ flaginfo.symbuf_count = 0;
+ flaginfo.shndxbuf_size = 0;
/* The object attributes have been merged. Remove the input
sections from the link, and set the contents of the output
/* Allocate a buffer to hold swapped out symbols. This is to avoid
continuously seeking to the right position in the file. */
if (! info->keep_memory || max_sym_count < 20)
- finfo.symbuf_size = 20;
+ flaginfo.symbuf_size = 20;
else
- finfo.symbuf_size = max_sym_count;
- amt = finfo.symbuf_size;
+ flaginfo.symbuf_size = max_sym_count;
+ amt = flaginfo.symbuf_size;
amt *= bed->s->sizeof_sym;
- finfo.symbuf = (bfd_byte *) bfd_malloc (amt);
- if (finfo.symbuf == NULL)
+ flaginfo.symbuf = (bfd_byte *) bfd_malloc (amt);
+ if (flaginfo.symbuf == NULL)
goto error_return;
if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
{
/* Wild guess at number of output symbols. realloc'd as needed. */
amt = 2 * max_sym_count + elf_numsections (abfd) + 1000;
- finfo.shndxbuf_size = amt;
+ flaginfo.shndxbuf_size = amt;
amt *= sizeof (Elf_External_Sym_Shndx);
- finfo.symshndxbuf = (Elf_External_Sym_Shndx *) bfd_zmalloc (amt);
- if (finfo.symshndxbuf == NULL)
+ flaginfo.symshndxbuf = (Elf_External_Sym_Shndx *) bfd_zmalloc (amt);
+ if (flaginfo.symshndxbuf == NULL)
goto error_return;
}
elfsym.st_other = 0;
elfsym.st_shndx = SHN_UNDEF;
elfsym.st_target_internal = 0;
- if (elf_link_output_sym (&finfo, NULL, &elfsym, bfd_und_section_ptr,
+ if (elf_link_output_sym (&flaginfo, NULL, &elfsym, bfd_und_section_ptr,
NULL) != 1)
goto error_return;
}
elfsym.st_shndx = i;
if (!info->relocatable)
elfsym.st_value = o->vma;
- if (elf_link_output_sym (&finfo, NULL, &elfsym, o, NULL) != 1)
+ if (elf_link_output_sym (&flaginfo, NULL, &elfsym, o, NULL) != 1)
goto error_return;
}
}
files. */
if (max_contents_size != 0)
{
- finfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
- if (finfo.contents == NULL)
+ flaginfo.contents = (bfd_byte *) bfd_malloc (max_contents_size);
+ if (flaginfo.contents == NULL)
goto error_return;
}
if (max_external_reloc_size != 0)
{
- finfo.external_relocs = bfd_malloc (max_external_reloc_size);
- if (finfo.external_relocs == NULL)
+ flaginfo.external_relocs = bfd_malloc (max_external_reloc_size);
+ if (flaginfo.external_relocs == NULL)
goto error_return;
}
{
amt = max_internal_reloc_count * bed->s->int_rels_per_ext_rel;
amt *= sizeof (Elf_Internal_Rela);
- finfo.internal_relocs = (Elf_Internal_Rela *) bfd_malloc (amt);
- if (finfo.internal_relocs == NULL)
+ flaginfo.internal_relocs = (Elf_Internal_Rela *) bfd_malloc (amt);
+ if (flaginfo.internal_relocs == NULL)
goto error_return;
}
if (max_sym_count != 0)
{
amt = max_sym_count * bed->s->sizeof_sym;
- finfo.external_syms = (bfd_byte *) bfd_malloc (amt);
- if (finfo.external_syms == NULL)
+ flaginfo.external_syms = (bfd_byte *) bfd_malloc (amt);
+ if (flaginfo.external_syms == NULL)
goto error_return;
amt = max_sym_count * sizeof (Elf_Internal_Sym);
- finfo.internal_syms = (Elf_Internal_Sym *) bfd_malloc (amt);
- if (finfo.internal_syms == NULL)
+ flaginfo.internal_syms = (Elf_Internal_Sym *) bfd_malloc (amt);
+ if (flaginfo.internal_syms == NULL)
goto error_return;
amt = max_sym_count * sizeof (long);
- finfo.indices = (long int *) bfd_malloc (amt);
- if (finfo.indices == NULL)
+ flaginfo.indices = (long int *) bfd_malloc (amt);
+ if (flaginfo.indices == NULL)
goto error_return;
amt = max_sym_count * sizeof (asection *);
- finfo.sections = (asection **) bfd_malloc (amt);
- if (finfo.sections == NULL)
+ flaginfo.sections = (asection **) bfd_malloc (amt);
+ if (flaginfo.sections == NULL)
goto error_return;
}
if (max_sym_shndx_count != 0)
{
amt = max_sym_shndx_count * sizeof (Elf_External_Sym_Shndx);
- finfo.locsym_shndx = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
- if (finfo.locsym_shndx == NULL)
+ flaginfo.locsym_shndx = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
+ if (flaginfo.locsym_shndx == NULL)
goto error_return;
}
{
if (! sub->output_has_begun)
{
- if (! elf_link_input_bfd (&finfo, sub))
+ if (! elf_link_input_bfd (&flaginfo, sub))
goto error_return;
sub->output_has_begun = TRUE;
}
some global symbols were, in fact, converted to become local.
FIXME: Will this work correctly with the Irix 5 linker? */
eoinfo.failed = FALSE;
- eoinfo.finfo = &finfo;
+ eoinfo.flaginfo = &flaginfo;
eoinfo.localsyms = TRUE;
bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
if (eoinfo.failed)
struct elf_link_hash_entry *);
if (! ((*bed->elf_backend_output_arch_local_syms)
- (abfd, info, &finfo, (out_sym_func) elf_link_output_sym)))
+ (abfd, info, &flaginfo, (out_sym_func) elf_link_output_sym)))
return FALSE;
}
symtab_hdr->sh_info = bfd_get_symcount (abfd);
if (dynamic
- && finfo.dynsym_sec != NULL
- && finfo.dynsym_sec->output_section != bfd_abs_section_ptr)
+ && flaginfo.dynsym_sec != NULL
+ && flaginfo.dynsym_sec->output_section != bfd_abs_section_ptr)
{
Elf_Internal_Sym sym;
- bfd_byte *dynsym = finfo.dynsym_sec->contents;
+ bfd_byte *dynsym = flaginfo.dynsym_sec->contents;
long last_local = 0;
/* Write out the section symbols for the output sections. */
}
}
- elf_section_data (finfo.dynsym_sec->output_section)->this_hdr.sh_info =
+ elf_section_data (flaginfo.dynsym_sec->output_section)->this_hdr.sh_info =
last_local + 1;
}
/* We get the global symbols from the hash table. */
eoinfo.failed = FALSE;
eoinfo.localsyms = FALSE;
- eoinfo.finfo = &finfo;
+ eoinfo.flaginfo = &flaginfo;
bfd_hash_traverse (&info->hash->table, elf_link_output_extsym, &eoinfo);
if (eoinfo.failed)
return FALSE;
struct elf_link_hash_entry *);
if (! ((*bed->elf_backend_output_arch_syms)
- (abfd, info, &finfo, (out_sym_func) elf_link_output_sym)))
+ (abfd, info, &flaginfo, (out_sym_func) elf_link_output_sym)))
return FALSE;
}
/* Flush all symbols to the file. */
- if (! elf_link_flush_output_syms (&finfo, bed))
+ if (! elf_link_flush_output_syms (&flaginfo, bed))
return FALSE;
/* Now we know the size of the symtab section. */
off, TRUE);
if (bfd_seek (abfd, symtab_shndx_hdr->sh_offset, SEEK_SET) != 0
- || (bfd_bwrite (finfo.symshndxbuf, amt, abfd) != amt))
+ || (bfd_bwrite (flaginfo.symshndxbuf, amt, abfd) != amt))
return FALSE;
}
symstrtab_hdr->sh_type = SHT_STRTAB;
symstrtab_hdr->sh_flags = 0;
symstrtab_hdr->sh_addr = 0;
- symstrtab_hdr->sh_size = _bfd_stringtab_size (finfo.symstrtab);
+ symstrtab_hdr->sh_size = _bfd_stringtab_size (flaginfo.symstrtab);
symstrtab_hdr->sh_entsize = 0;
symstrtab_hdr->sh_link = 0;
symstrtab_hdr->sh_info = 0;
if (bfd_get_symcount (abfd) > 0)
{
if (bfd_seek (abfd, symstrtab_hdr->sh_offset, SEEK_SET) != 0
- || ! _bfd_stringtab_emit (abfd, finfo.symstrtab))
+ || ! _bfd_stringtab_emit (abfd, flaginfo.symstrtab))
return FALSE;
}
goto error_return;
}
- if (finfo.symstrtab != NULL)
- _bfd_stringtab_free (finfo.symstrtab);
- if (finfo.contents != NULL)
- free (finfo.contents);
- if (finfo.external_relocs != NULL)
- free (finfo.external_relocs);
- if (finfo.internal_relocs != NULL)
- free (finfo.internal_relocs);
- if (finfo.external_syms != NULL)
- free (finfo.external_syms);
- if (finfo.locsym_shndx != NULL)
- free (finfo.locsym_shndx);
- if (finfo.internal_syms != NULL)
- free (finfo.internal_syms);
- if (finfo.indices != NULL)
- free (finfo.indices);
- if (finfo.sections != NULL)
- free (finfo.sections);
- if (finfo.symbuf != NULL)
- free (finfo.symbuf);
- if (finfo.symshndxbuf != NULL)
- free (finfo.symshndxbuf);
+ if (flaginfo.symstrtab != NULL)
+ _bfd_stringtab_free (flaginfo.symstrtab);
+ if (flaginfo.contents != NULL)
+ free (flaginfo.contents);
+ if (flaginfo.external_relocs != NULL)
+ free (flaginfo.external_relocs);
+ if (flaginfo.internal_relocs != NULL)
+ free (flaginfo.internal_relocs);
+ if (flaginfo.external_syms != NULL)
+ free (flaginfo.external_syms);
+ if (flaginfo.locsym_shndx != NULL)
+ free (flaginfo.locsym_shndx);
+ if (flaginfo.internal_syms != NULL)
+ free (flaginfo.internal_syms);
+ if (flaginfo.indices != NULL)
+ free (flaginfo.indices);
+ if (flaginfo.sections != NULL)
+ free (flaginfo.sections);
+ if (flaginfo.symbuf != NULL)
+ free (flaginfo.symbuf);
+ if (flaginfo.symshndxbuf != NULL)
+ free (flaginfo.symshndxbuf);
for (o = abfd->sections; o != NULL; o = o->next)
{
struct bfd_elf_section_data *esdo = elf_section_data (o);
return TRUE;
error_return:
- if (finfo.symstrtab != NULL)
- _bfd_stringtab_free (finfo.symstrtab);
- if (finfo.contents != NULL)
- free (finfo.contents);
- if (finfo.external_relocs != NULL)
- free (finfo.external_relocs);
- if (finfo.internal_relocs != NULL)
- free (finfo.internal_relocs);
- if (finfo.external_syms != NULL)
- free (finfo.external_syms);
- if (finfo.locsym_shndx != NULL)
- free (finfo.locsym_shndx);
- if (finfo.internal_syms != NULL)
- free (finfo.internal_syms);
- if (finfo.indices != NULL)
- free (finfo.indices);
- if (finfo.sections != NULL)
- free (finfo.sections);
- if (finfo.symbuf != NULL)
- free (finfo.symbuf);
- if (finfo.symshndxbuf != NULL)
- free (finfo.symshndxbuf);
+ if (flaginfo.symstrtab != NULL)
+ _bfd_stringtab_free (flaginfo.symstrtab);
+ if (flaginfo.contents != NULL)
+ free (flaginfo.contents);
+ if (flaginfo.external_relocs != NULL)
+ free (flaginfo.external_relocs);
+ if (flaginfo.internal_relocs != NULL)
+ free (flaginfo.internal_relocs);
+ if (flaginfo.external_syms != NULL)
+ free (flaginfo.external_syms);
+ if (flaginfo.locsym_shndx != NULL)
+ free (flaginfo.locsym_shndx);
+ if (flaginfo.internal_syms != NULL)
+ free (flaginfo.internal_syms);
+ if (flaginfo.indices != NULL)
+ free (flaginfo.indices);
+ if (flaginfo.sections != NULL)
+ free (flaginfo.sections);
+ if (flaginfo.symbuf != NULL)
+ free (flaginfo.symbuf);
+ if (flaginfo.symshndxbuf != NULL)
+ free (flaginfo.symshndxbuf);
for (o = abfd->sections; o != NULL; o = o->next)
{
struct bfd_elf_section_data *esdo = elf_section_data (o);
void
bfd_elf_lookup_section_flags (struct bfd_link_info *info,
- struct flag_info *finfo)
+ struct flag_info *flaginfo)
{
bfd *output_bfd = info->output_bfd;
const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
- struct flag_info_list *tf = finfo->flag_list;
+ struct flag_info_list *tf = flaginfo->flag_list;
int with_hex = 0;
int without_hex = 0;
- for (tf = finfo->flag_list; tf != NULL; tf = tf->next)
+ for (tf = flaginfo->flag_list; tf != NULL; tf = tf->next)
{
int i;
if (bed->elf_backend_lookup_section_flags_hook)
return;
}
}
- finfo->flags_initialized = TRUE;
- finfo->only_with_flags |= with_hex;
- finfo->not_with_flags |= without_hex;
+ flaginfo->flags_initialized = TRUE;
+ flaginfo->only_with_flags |= with_hex;
+ flaginfo->not_with_flags |= without_hex;
return;
}
aout_link_write_other_symbol (struct bfd_hash_entry *bh, void *data)
{
struct aout_link_hash_entry *h = (struct aout_link_hash_entry *) bh;
- struct aout_final_link_info *finfo = (struct aout_final_link_info *) data;
+ struct aout_final_link_info *flaginfo = (struct aout_final_link_info *) data;
bfd *output_bfd;
int type;
bfd_vma val;
return TRUE;
}
- output_bfd = finfo->output_bfd;
+ output_bfd = flaginfo->output_bfd;
if (aout_backend_info (output_bfd)->write_dynamic_symbol != NULL)
{
if (! ((*aout_backend_info (output_bfd)->write_dynamic_symbol)
- (output_bfd, finfo->info, h)))
+ (output_bfd, flaginfo->info, h)))
{
/* FIXME: No way to handle errors. */
abort ();
/* An indx of -2 means the symbol must be written. */
if (h->indx != -2
- && (finfo->info->strip == strip_all
- || (finfo->info->strip == strip_some
- && bfd_hash_lookup (finfo->info->keep_hash, h->root.root.string,
+ && (flaginfo->info->strip == strip_all
+ || (flaginfo->info->strip == strip_some
+ && bfd_hash_lookup (flaginfo->info->keep_hash, h->root.root.string,
FALSE, FALSE) == NULL)))
return TRUE;
}
H_PUT_8 (output_bfd, type, outsym.e_type);
- indx = add_to_stringtab (output_bfd, finfo->strtab, h->root.root.string,
+ indx = add_to_stringtab (output_bfd, flaginfo->strtab, h->root.root.string,
FALSE);
if (indx == (bfd_size_type) -1)
/* FIXME: No way to handle errors. */
PUT_WORD (output_bfd, val, outsym.e_value);
amt = EXTERNAL_NLIST_SIZE;
- if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0
+ if (bfd_seek (output_bfd, flaginfo->symoff, SEEK_SET) != 0
|| bfd_bwrite ((void *) &outsym, amt, output_bfd) != amt)
/* FIXME: No way to handle errors. */
abort ();
- finfo->symoff += amt;
+ flaginfo->symoff += amt;
h->indx = obj_aout_external_sym_count (output_bfd);
++obj_aout_external_sym_count (output_bfd);
/* Handle a link order which is supposed to generate a reloc. */
static bfd_boolean
-aout_link_reloc_link_order (struct aout_final_link_info *finfo,
+aout_link_reloc_link_order (struct aout_final_link_info *flaginfo,
asection *o,
struct bfd_link_order *p)
{
r_index = N_ABS | N_EXT;
else
{
- BFD_ASSERT (pr->u.section->owner == finfo->output_bfd);
+ BFD_ASSERT (pr->u.section->owner == flaginfo->output_bfd);
r_index = pr->u.section->target_index;
}
}
BFD_ASSERT (p->type == bfd_symbol_reloc_link_order);
r_extern = 1;
h = ((struct aout_link_hash_entry *)
- bfd_wrapped_link_hash_lookup (finfo->output_bfd, finfo->info,
+ bfd_wrapped_link_hash_lookup (flaginfo->output_bfd, flaginfo->info,
pr->u.name, FALSE, FALSE, TRUE));
if (h != NULL
&& h->indx >= 0)
symbol. */
h->indx = -2;
h->written = FALSE;
- if (!aout_link_write_other_symbol (&h->root.root, finfo))
+ if (!aout_link_write_other_symbol (&h->root.root, flaginfo))
return FALSE;
r_index = h->indx;
}
else
{
- if (! ((*finfo->info->callbacks->unattached_reloc)
- (finfo->info, pr->u.name, NULL, NULL, (bfd_vma) 0)))
+ if (! ((*flaginfo->info->callbacks->unattached_reloc)
+ (flaginfo->info, pr->u.name, NULL, NULL, (bfd_vma) 0)))
return FALSE;
r_index = 0;
}
}
- howto = bfd_reloc_type_lookup (finfo->output_bfd, pr->reloc);
+ howto = bfd_reloc_type_lookup (flaginfo->output_bfd, pr->reloc);
if (howto == 0)
{
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
- if (o == obj_textsec (finfo->output_bfd))
- reloff_ptr = &finfo->treloff;
- else if (o == obj_datasec (finfo->output_bfd))
- reloff_ptr = &finfo->dreloff;
+ if (o == obj_textsec (flaginfo->output_bfd))
+ reloff_ptr = &flaginfo->treloff;
+ else if (o == obj_datasec (flaginfo->output_bfd))
+ reloff_ptr = &flaginfo->dreloff;
else
abort ();
#ifdef MY_put_reloc
- MY_put_reloc(finfo->output_bfd, r_extern, r_index, p->offset, howto,
+ MY_put_reloc(flaginfo->output_bfd, r_extern, r_index, p->offset, howto,
&srel);
#else
{
r_relative = (howto->type & 32) != 0;
r_length = howto->size;
- PUT_WORD (finfo->output_bfd, p->offset, srel.r_address);
- if (bfd_header_big_endian (finfo->output_bfd))
+ PUT_WORD (flaginfo->output_bfd, p->offset, srel.r_address);
+ if (bfd_header_big_endian (flaginfo->output_bfd))
{
srel.r_index[0] = r_index >> 16;
srel.r_index[1] = r_index >> 8;
buf = bfd_zmalloc (size);
if (buf == NULL)
return FALSE;
- r = MY_relocate_contents (howto, finfo->output_bfd,
+ r = MY_relocate_contents (howto, flaginfo->output_bfd,
pr->addend, buf);
switch (r)
{
case bfd_reloc_outofrange:
abort ();
case bfd_reloc_overflow:
- if (! ((*finfo->info->callbacks->reloc_overflow)
- (finfo->info, NULL,
+ if (! ((*flaginfo->info->callbacks->reloc_overflow)
+ (flaginfo->info, NULL,
(p->type == bfd_section_reloc_link_order
- ? bfd_section_name (finfo->output_bfd,
+ ? bfd_section_name (flaginfo->output_bfd,
pr->u.section)
: pr->u.name),
howto->name, pr->addend, NULL,
}
break;
}
- ok = bfd_set_section_contents (finfo->output_bfd, o,
+ ok = bfd_set_section_contents (flaginfo->output_bfd, o,
(void *) buf,
(file_ptr) p->offset,
size);
return FALSE;
}
- rel_size = obj_reloc_entry_size (finfo->output_bfd);
- if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0
- || bfd_bwrite (rel_ptr, rel_size, finfo->output_bfd) != rel_size)
+ rel_size = obj_reloc_entry_size (flaginfo->output_bfd);
+ if (bfd_seek (flaginfo->output_bfd, *reloff_ptr, SEEK_SET) != 0
+ || bfd_bwrite (rel_ptr, rel_size, flaginfo->output_bfd) != rel_size)
return FALSE;
*reloff_ptr += rel_size;
/* Assert that the relocs have not run into the symbols, and that n
the text relocs have not run into the data relocs. */
- BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (finfo->output_bfd)
- && (reloff_ptr != &finfo->treloff
+ BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (flaginfo->output_bfd)
+ && (reloff_ptr != &flaginfo->treloff
|| (*reloff_ptr
- <= obj_datasec (finfo->output_bfd)->rel_filepos)));
+ <= obj_datasec (flaginfo->output_bfd)->rel_filepos)));
return TRUE;
}
}
static bfd_boolean
-pdp11_aout_link_input_section (struct aout_final_link_info *finfo,
+pdp11_aout_link_input_section (struct aout_final_link_info *flaginfo,
bfd *input_bfd,
asection *input_section,
bfd_byte *relocs,
bfd_byte *rel;
bfd_byte *rel_end;
- output_bfd = finfo->output_bfd;
+ output_bfd = flaginfo->output_bfd;
check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_SIZE);
BFD_ASSERT (input_bfd->xvec->header_byteorder
== output_bfd->xvec->header_byteorder);
- relocatable = finfo->info->relocatable;
+ relocatable = flaginfo->info->relocatable;
syms = obj_aout_external_syms (input_bfd);
strings = obj_aout_external_strings (input_bfd);
sym_hashes = obj_aout_sym_hashes (input_bfd);
- symbol_map = finfo->symbol_map;
+ symbol_map = flaginfo->symbol_map;
rel = relocs;
rel_end = rel + rel_size;
h->indx = -2;
h->written = FALSE;
if (!aout_link_write_other_symbol (&h->root.root,
- finfo))
+ flaginfo))
return FALSE;
}
r_index = h->indx;
name = strings + GET_WORD (input_bfd,
syms[r_index].e_strx);
- if (! ((*finfo->info->callbacks->unattached_reloc)
- (finfo->info, name, input_bfd, input_section,
+ if (! ((*flaginfo->info->callbacks->unattached_reloc)
+ (flaginfo->info, name, input_bfd, input_section,
r_addr)))
return FALSE;
r_index = 0;
bfd_boolean skip;
if (! ((*check_dynamic_reloc)
- (finfo->info, input_bfd, input_section, h,
+ (flaginfo->info, input_bfd, input_section, h,
(void *) rel, contents, &skip, &relocation)))
return FALSE;
if (skip)
/* Now warn if a global symbol is undefined. We could not
do this earlier, because check_dynamic_reloc might want
to skip this reloc. */
- if (hundef && ! finfo->info->shared)
+ if (hundef && ! flaginfo->info->shared)
{
const char *name;
name = h->root.root.string;
else
name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
- if (! ((*finfo->info->callbacks->undefined_symbol)
- (finfo->info, name, input_bfd, input_section,
+ if (! ((*flaginfo->info->callbacks->undefined_symbol)
+ (flaginfo->info, name, input_bfd, input_section,
r_addr, TRUE)))
return FALSE;
}
s = aout_reloc_type_to_section (input_bfd, r_type);
name = bfd_section_name (input_bfd, s);
}
- if (! ((*finfo->info->callbacks->reloc_overflow)
- (finfo->info, (h ? &h->root : NULL), name,
+ if (! ((*flaginfo->info->callbacks->reloc_overflow)
+ (flaginfo->info, (h ? &h->root : NULL), name,
howto->name, (bfd_vma) 0, input_bfd,
input_section, r_addr)))
return FALSE;
/* Link an a.out section into the output file. */
static bfd_boolean
-aout_link_input_section (struct aout_final_link_info *finfo,
+aout_link_input_section (struct aout_final_link_info *flaginfo,
bfd *input_bfd,
asection *input_section,
file_ptr *reloff_ptr,
/* Get the section contents. */
input_size = input_section->size;
if (! bfd_get_section_contents (input_bfd, input_section,
- (void *) finfo->contents,
+ (void *) flaginfo->contents,
(file_ptr) 0, input_size))
return FALSE;
relocs = aout_section_data (input_section)->relocs;
else
{
- relocs = finfo->relocs;
+ relocs = flaginfo->relocs;
if (rel_size > 0)
{
if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
}
/* Relocate the section contents. */
- if (! pdp11_aout_link_input_section (finfo, input_bfd, input_section,
+ if (! pdp11_aout_link_input_section (flaginfo, input_bfd, input_section,
(bfd_byte *) relocs,
- rel_size, finfo->contents))
+ rel_size, flaginfo->contents))
return FALSE;
/* Write out the section contents. */
- if (! bfd_set_section_contents (finfo->output_bfd,
+ if (! bfd_set_section_contents (flaginfo->output_bfd,
input_section->output_section,
- (void *) finfo->contents,
+ (void *) flaginfo->contents,
(file_ptr) input_section->output_offset,
input_size))
return FALSE;
/* If we are producing relocatable output, the relocs were
modified, and we now write them out. */
- if (finfo->info->relocatable && rel_size > 0)
+ if (flaginfo->info->relocatable && rel_size > 0)
{
- if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0)
+ if (bfd_seek (flaginfo->output_bfd, *reloff_ptr, SEEK_SET) != 0)
return FALSE;
- if (bfd_bwrite (relocs, rel_size, finfo->output_bfd) != rel_size)
+ if (bfd_bwrite (relocs, rel_size, flaginfo->output_bfd) != rel_size)
return FALSE;
*reloff_ptr += rel_size;
/* Assert that the relocs have not run into the symbols, and
that if these are the text relocs they have not run into the
data relocs. */
- BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (finfo->output_bfd)
- && (reloff_ptr != &finfo->treloff
+ BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (flaginfo->output_bfd)
+ && (reloff_ptr != &flaginfo->treloff
|| (*reloff_ptr
- <= obj_datasec (finfo->output_bfd)->rel_filepos)));
+ <= obj_datasec (flaginfo->output_bfd)->rel_filepos)));
}
return TRUE;
/* Link an a.out input BFD into the output file. */
static bfd_boolean
-aout_link_input_bfd (struct aout_final_link_info *finfo, bfd *input_bfd)
+aout_link_input_bfd (struct aout_final_link_info *flaginfo, bfd *input_bfd)
{
BFD_ASSERT (bfd_get_format (input_bfd) == bfd_object);
if ((input_bfd->flags & DYNAMIC) != 0
&& aout_backend_info (input_bfd)->link_dynamic_object != NULL)
return ((*aout_backend_info (input_bfd)->link_dynamic_object)
- (finfo->info, input_bfd));
+ (flaginfo->info, input_bfd));
/* Get the symbols. We probably have them already, unless
- finfo->info->keep_memory is FALSE. */
+ flaginfo->info->keep_memory is FALSE. */
if (! aout_get_external_symbols (input_bfd))
return FALSE;
/* Write out the symbols and get a map of the new indices. The map
- is placed into finfo->symbol_map. */
- if (! aout_link_write_symbols (finfo, input_bfd))
+ is placed into flaginfo->symbol_map. */
+ if (! aout_link_write_symbols (flaginfo, input_bfd))
return FALSE;
/* Relocate and write out the sections. These functions use the
link, which will normally be the case. */
if (obj_textsec (input_bfd)->linker_mark)
{
- if (! aout_link_input_section (finfo, input_bfd,
+ if (! aout_link_input_section (flaginfo, input_bfd,
obj_textsec (input_bfd),
- &finfo->treloff,
+ &flaginfo->treloff,
exec_hdr (input_bfd)->a_trsize))
return FALSE;
}
if (obj_datasec (input_bfd)->linker_mark)
{
- if (! aout_link_input_section (finfo, input_bfd,
+ if (! aout_link_input_section (flaginfo, input_bfd,
obj_datasec (input_bfd),
- &finfo->dreloff,
+ &flaginfo->dreloff,
exec_hdr (input_bfd)->a_drsize))
return FALSE;
}
/* If we are not keeping memory, we don't need the symbols any
longer. We still need them if we are keeping memory, because the
strings in the hash table point into them. */
- if (! finfo->info->keep_memory)
+ if (! flaginfo->info->keep_memory)
{
if (! aout_link_free_symbols (input_bfd))
return FALSE;
symbol indices into a symbol_map. */
static bfd_boolean
-aout_link_write_symbols (struct aout_final_link_info *finfo, bfd *input_bfd)
+aout_link_write_symbols (struct aout_final_link_info *flaginfo, bfd *input_bfd)
{
bfd *output_bfd;
bfd_size_type sym_count;
bfd_boolean pass;
bfd_boolean skip_next;
- output_bfd = finfo->output_bfd;
+ output_bfd = flaginfo->output_bfd;
sym_count = obj_aout_external_sym_count (input_bfd);
strings = obj_aout_external_strings (input_bfd);
- strip = finfo->info->strip;
- discard = finfo->info->discard;
- outsym = finfo->output_syms;
+ strip = flaginfo->info->strip;
+ discard = flaginfo->info->discard;
+ outsym = flaginfo->output_syms;
/* First write out a symbol for this object file, unless we are
discarding such symbols. */
if (strip != strip_all
&& (strip != strip_some
- || bfd_hash_lookup (finfo->info->keep_hash, input_bfd->filename,
+ || bfd_hash_lookup (flaginfo->info->keep_hash, input_bfd->filename,
FALSE, FALSE) != NULL)
&& discard != discard_all)
{
H_PUT_8 (output_bfd, N_TEXT, outsym->e_type);
- strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
+ strtab_index = add_to_stringtab (output_bfd, flaginfo->strtab,
input_bfd->filename, FALSE);
if (strtab_index == (bfd_size_type) -1)
return FALSE;
sym = obj_aout_external_syms (input_bfd);
sym_end = sym + sym_count;
sym_hash = obj_aout_sym_hashes (input_bfd);
- symbol_map = finfo->symbol_map;
+ symbol_map = flaginfo->symbol_map;
memset (symbol_map, 0, (size_t) sym_count * sizeof *symbol_map);
for (; sym < sym_end; sym++, sym_hash++, symbol_map++)
{
skip = TRUE;
break;
case strip_some:
- if (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE, FALSE)
+ if (bfd_hash_lookup (flaginfo->info->keep_hash, name, FALSE, FALSE)
== NULL)
skip = TRUE;
break;
/* If we have already included a header file with the
same value, then replace this one with an N_EXCL
symbol. */
- copy = ! finfo->info->keep_memory;
- incl_entry = aout_link_includes_lookup (&finfo->includes,
+ copy = ! flaginfo->info->keep_memory;
+ incl_entry = aout_link_includes_lookup (&flaginfo->includes,
name, TRUE, copy);
if (incl_entry == NULL)
return FALSE;
{
/* This is the first time we have seen this header
file with this set of stabs strings. */
- t = bfd_hash_allocate (&finfo->includes.root,
+ t = bfd_hash_allocate (&flaginfo->includes.root,
sizeof *t);
if (t == NULL)
return FALSE;
write out. */
H_PUT_8 (output_bfd, type, outsym->e_type);
copy = FALSE;
- if (! finfo->info->keep_memory)
+ if (! flaginfo->info->keep_memory)
{
/* name points into a string table which we are going to
free. If there is a hash table entry, use that string.
else
copy = TRUE;
}
- strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
+ strtab_index = add_to_stringtab (output_bfd, flaginfo->strtab,
name, copy);
if (strtab_index == (bfd_size_type) -1)
return FALSE;
}
/* Write out the output symbols we have just constructed. */
- if (outsym > finfo->output_syms)
+ if (outsym > flaginfo->output_syms)
{
bfd_size_type size;
- if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0)
+ if (bfd_seek (output_bfd, flaginfo->symoff, SEEK_SET) != 0)
return FALSE;
- size = outsym - finfo->output_syms;
+ size = outsym - flaginfo->output_syms;
size *= EXTERNAL_NLIST_SIZE;
- if (bfd_bwrite ((void *) finfo->output_syms, size, output_bfd) != size)
+ if (bfd_bwrite ((void *) flaginfo->output_syms, size, output_bfd) != size)
return FALSE;
- finfo->symoff += size;
+ flaginfo->symoff += size;
}
return TRUE;
+2012-05-01 Nick Clifton <nickc@redhat.com>
+
+ PR binutils/13121
+ * rescoff.c: Rename 'finfo' to 'flaginfo' to avoid conflicts with
+ AIX system headers.
+
2012-04-25 Cary Coutant <ccoutant@google.com>
* doc/binutils.texi: Add -D/--enable-deterministic-archives option
asection *sec;
bfd_size_type size;
bfd_byte *data;
- struct coff_file_info finfo;
+ struct coff_file_info flaginfo;
if (filename == NULL)
fatal (_("filename required for COFF input"));
get_windres_bfd_content (&wrbfd, data, 0, size);
- finfo.filename = filename;
- finfo.data = data;
- finfo.data_end = data + size;
- finfo.secaddr = (bfd_get_section_vma (abfd, sec)
+ flaginfo.filename = filename;
+ flaginfo.data = data;
+ flaginfo.data_end = data + size;
+ flaginfo.secaddr = (bfd_get_section_vma (abfd, sec)
- pe_data (abfd)->pe_opthdr.ImageBase);
/* Now just read in the top level resource directory. Note that we
it. If we ever want to free up the resource information we read,
this will have to be cleaned up. */
- ret = read_coff_res_dir (&wrbfd, data, &finfo, (const rc_res_id *) NULL, 0);
+ ret = read_coff_res_dir (&wrbfd, data, &flaginfo, (const rc_res_id *) NULL, 0);
bfd_close (abfd);
/* Give an error if we are out of bounds. */
static void
-overrun (const struct coff_file_info *finfo, const char *msg)
+overrun (const struct coff_file_info *flaginfo, const char *msg)
{
- fatal (_("%s: %s: address out of bounds"), finfo->filename, msg);
+ fatal (_("%s: %s: address out of bounds"), flaginfo->filename, msg);
}
/* Read a resource directory. */
static rc_res_directory *
read_coff_res_dir (windres_bfd *wrbfd, const bfd_byte *data,
- const struct coff_file_info *finfo,
+ const struct coff_file_info *flaginfo,
const rc_res_id *type, int level)
{
const struct extern_res_directory *erd;
rc_res_entry **pp;
const struct extern_res_entry *ere;
- if ((size_t) (finfo->data_end - data) < sizeof (struct extern_res_directory))
- overrun (finfo, _("directory"));
+ if ((size_t) (flaginfo->data_end - data) < sizeof (struct extern_res_directory))
+ overrun (flaginfo, _("directory"));
erd = (const struct extern_res_directory *) data;
const bfd_byte *ers;
int length, j;
- if ((const bfd_byte *) ere >= finfo->data_end)
- overrun (finfo, _("named directory entry"));
+ if ((const bfd_byte *) ere >= flaginfo->data_end)
+ overrun (flaginfo, _("named directory entry"));
name = windres_get_32 (wrbfd, ere->name, 4);
rva = windres_get_32 (wrbfd, ere->rva, 4);
/* For some reason the high bit in NAME is set. */
name &=~ 0x80000000;
- if (name > (rc_uint_type) (finfo->data_end - finfo->data))
- overrun (finfo, _("directory entry name"));
+ if (name > (rc_uint_type) (flaginfo->data_end - flaginfo->data))
+ overrun (flaginfo, _("directory entry name"));
- ers = finfo->data + name;
+ ers = flaginfo->data + name;
re = (rc_res_entry *) res_alloc (sizeof *re);
re->next = NULL;
if ((rva & 0x80000000) != 0)
{
rva &=~ 0x80000000;
- if (rva >= (rc_uint_type) (finfo->data_end - finfo->data))
- overrun (finfo, _("named subdirectory"));
+ if (rva >= (rc_uint_type) (flaginfo->data_end - flaginfo->data))
+ overrun (flaginfo, _("named subdirectory"));
re->subdir = 1;
- re->u.dir = read_coff_res_dir (wrbfd, finfo->data + rva, finfo, type,
+ re->u.dir = read_coff_res_dir (wrbfd, flaginfo->data + rva, flaginfo, type,
level + 1);
}
else
{
- if (rva >= (rc_uint_type) (finfo->data_end - finfo->data))
- overrun (finfo, _("named resource"));
+ if (rva >= (rc_uint_type) (flaginfo->data_end - flaginfo->data))
+ overrun (flaginfo, _("named resource"));
re->subdir = 0;
- re->u.res = read_coff_data_entry (wrbfd, finfo->data + rva, finfo, type);
+ re->u.res = read_coff_data_entry (wrbfd, flaginfo->data + rva, flaginfo, type);
}
*pp = re;
unsigned long name, rva;
rc_res_entry *re;
- if ((const bfd_byte *) ere >= finfo->data_end)
- overrun (finfo, _("ID directory entry"));
+ if ((const bfd_byte *) ere >= flaginfo->data_end)
+ overrun (flaginfo, _("ID directory entry"));
name = windres_get_32 (wrbfd, ere->name, 4);
rva = windres_get_32 (wrbfd, ere->rva, 4);
if ((rva & 0x80000000) != 0)
{
rva &=~ 0x80000000;
- if (rva >= (rc_uint_type) (finfo->data_end - finfo->data))
- overrun (finfo, _("ID subdirectory"));
+ if (rva >= (rc_uint_type) (flaginfo->data_end - flaginfo->data))
+ overrun (flaginfo, _("ID subdirectory"));
re->subdir = 1;
- re->u.dir = read_coff_res_dir (wrbfd, finfo->data + rva, finfo, type,
+ re->u.dir = read_coff_res_dir (wrbfd, flaginfo->data + rva, flaginfo, type,
level + 1);
}
else
{
- if (rva >= (rc_uint_type) (finfo->data_end - finfo->data))
- overrun (finfo, _("ID resource"));
+ if (rva >= (rc_uint_type) (flaginfo->data_end - flaginfo->data))
+ overrun (flaginfo, _("ID resource"));
re->subdir = 0;
- re->u.res = read_coff_data_entry (wrbfd, finfo->data + rva, finfo, type);
+ re->u.res = read_coff_data_entry (wrbfd, flaginfo->data + rva, flaginfo, type);
}
*pp = re;
static rc_res_resource *
read_coff_data_entry (windres_bfd *wrbfd, const bfd_byte *data,
- const struct coff_file_info *finfo,
+ const struct coff_file_info *flaginfo,
const rc_res_id *type)
{
const struct extern_res_data *erd;
if (type == NULL)
fatal (_("resource type unknown"));
- if ((size_t) (finfo->data_end - data) < sizeof (struct extern_res_data))
- overrun (finfo, _("data entry"));
+ if ((size_t) (flaginfo->data_end - data) < sizeof (struct extern_res_data))
+ overrun (flaginfo, _("data entry"));
erd = (const struct extern_res_data *) data;
size = windres_get_32 (wrbfd, erd->size, 4);
rva = windres_get_32 (wrbfd, erd->rva, 4);
- if (rva < finfo->secaddr
- || rva - finfo->secaddr >= (rc_uint_type) (finfo->data_end - finfo->data))
- overrun (finfo, _("resource data"));
+ if (rva < flaginfo->secaddr
+ || rva - flaginfo->secaddr >= (rc_uint_type) (flaginfo->data_end - flaginfo->data))
+ overrun (flaginfo, _("resource data"));
- resdata = finfo->data + (rva - finfo->secaddr);
+ resdata = flaginfo->data + (rva - flaginfo->secaddr);
- if (size > (rc_uint_type) (finfo->data_end - resdata))
- overrun (finfo, _("resource data size"));
+ if (size > (rc_uint_type) (flaginfo->data_end - resdata))
+ overrun (flaginfo, _("resource data size"));
r = bin_to_res (wrbfd, *type, resdata, size);
projects / external / binutils.git / commitdiff