/* Routines to help build PEI-format DLLs (Win32 etc)
Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
- 2008 Free Software Foundation, Inc.
+ 2008, 2009 Free Software Foundation, Inc.
Written by DJ Delorie <dj@cygnus.com>
This file is part of the GNU Binutils.
int pe_dll_warn_dup_exports = 0;
int pe_dll_compat_implib = 0;
int pe_dll_extra_pe_debug = 0;
+int pe_use_nul_prefixed_import_tables = 0;
+int pe_use_coff_long_section_names = -1;
/* Static variables and types. */
{ STRING_COMMA_LEN ("libcegcc") },
{ STRING_COMMA_LEN ("libcygwin") },
{ STRING_COMMA_LEN ("libgcc") },
+ { STRING_COMMA_LEN ("libgcc_s") },
{ STRING_COMMA_LEN ("libstdc++") },
{ STRING_COMMA_LEN ("libmingw32") },
{ STRING_COMMA_LEN ("libmingwex") },
{ NULL, 0 }
};
+/* Regardless of the suffix issue mentioned above, we must ensure that
+ we do not falsely match on a leading substring, such as when libtool
+ builds libstdc++ as a DLL using libsupc++convenience.a as an intermediate.
+ This routine ensures that the leading part of the name matches and that
+ it is followed by only an optional version suffix and a file extension,
+ returning zero if so or -1 if not. */
+static int libnamencmp (const char *libname, const autofilter_entry_type *afptr)
+{
+ if (strncmp (libname, afptr->name, afptr->len))
+ return -1;
+
+ libname += afptr->len;
+
+ /* Be liberal in interpreting what counts as a version suffix; we
+ accept anything that has a dash to separate it from the name and
+ begins with a digit. */
+ if (libname[0] == '-')
+ {
+ if (!ISDIGIT (*++libname))
+ return -1;
+ /* Ensure the filename has an extension. */
+ while (*++libname != '.')
+ if (!*libname)
+ return -1;
+ }
+ else if (libname[0] != '.')
+ return -1;
+
+ return 0;
+}
+
static const autofilter_entry_type autofilter_objlist[] =
{
{ STRING_COMMA_LEN ("crt0.o") },
{
char *string;
struct exclude_list_struct *next;
- int type;
+ exclude_type type;
}
exclude_list_struct;
static struct exclude_list_struct *excludes = 0;
void
-pe_dll_add_excludes (const char *new_excludes, const int type)
+pe_dll_add_excludes (const char *new_excludes, const exclude_type type)
{
char *local_copy;
char *exclude_string;
while (afptr->name)
{
- if (strncmp (libname, afptr->name, afptr->len) == 0 )
+ if (libnamencmp (libname, afptr) == 0 )
return 0;
afptr++;
}
for (ex = excludes; ex; ex = ex->next)
{
- if (ex->type == 1) /* exclude-libs */
+ if (ex->type == EXCLUDELIBS)
{
if (libname
&& ((strcmp (libname, ex->string) == 0)
|| (strcasecmp ("ALL", ex->string) == 0)))
return 0;
}
+ else if (ex->type == EXCLUDEFORIMPLIB)
+ {
+ if (strcmp (abfd->filename, ex->string) == 0)
+ return 0;
+ }
else if (strcmp (n, ex->string) == 0)
return 0;
}
static asymbol **symtab;
static int symptr;
static int tmp_seq;
+static int tmp_seq2;
static const char *dll_filename;
static char *dll_symname;
d2 = xmalloc (20);
id2->contents = d2;
memset (d2, 0, 20);
- d2[0] = d2[16] = PE_IDATA5_SIZE; /* Reloc addend. */
+ if (pe_use_nul_prefixed_import_tables)
+ d2[0] = d2[16] = PE_IDATA5_SIZE; /* Reloc addend. */
quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
quick_reloc (abfd, 12, BFD_RELOC_RVA, 4);
quick_reloc (abfd, 16, BFD_RELOC_RVA, 1);
save_relocs (id2);
- bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
+ if (pe_use_nul_prefixed_import_tables)
+ bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
+ else
+ bfd_set_section_size (abfd, id5, 0);
d5 = xmalloc (PE_IDATA5_SIZE);
id5->contents = d5;
memset (d5, 0, PE_IDATA5_SIZE);
-
- bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
+ if (pe_use_nul_prefixed_import_tables)
+ bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
+ else
+ bfd_set_section_size (abfd, id4, 0);
d4 = xmalloc (PE_IDATA4_SIZE);
id4->contents = d4;
memset (d4, 0, PE_IDATA4_SIZE);
bfd_set_symtab (abfd, symtab, symptr);
bfd_set_section_contents (abfd, id2, d2, 0, 20);
- bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
- bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
+ if (pe_use_nul_prefixed_import_tables)
+ {
+ bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
+ bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
+ }
+ else
+ {
+ bfd_set_section_contents (abfd, id5, d5, 0, 0);
+ bfd_set_section_contents (abfd, id4, d4, 0, 0);
+ }
bfd_make_readable (abfd);
return abfd;
return abfd;
}
+static bfd *
+make_singleton_name_imp (const char *import, bfd *parent)
+{
+ /* Name thunks go to idata$4. */
+ asection *id5;
+ unsigned char *d5;
+ char *oname;
+ bfd *abfd;
+
+ oname = xmalloc (20);
+ sprintf (oname, "nmimp%06d.o", tmp_seq2);
+ tmp_seq2++;
+
+ abfd = bfd_create (oname, parent);
+ bfd_find_target (pe_details->object_target, abfd);
+ bfd_make_writable (abfd);
+
+ bfd_set_format (abfd, bfd_object);
+ bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
+
+ symptr = 0;
+ symtab = xmalloc (3 * sizeof (asymbol *));
+ id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
+ quick_symbol (abfd, U ("_imp_"), import, "", id5, BSF_GLOBAL, 0);
+
+ /* We need space for the real thunk and for the null terminator. */
+ bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE * 2);
+ d5 = xmalloc (PE_IDATA5_SIZE * 2);
+ id5->contents = d5;
+ memset (d5, 0, PE_IDATA5_SIZE * 2);
+ quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
+ save_relocs (id5);
+
+ bfd_set_symtab (abfd, symtab, symptr);
+
+ bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA4_SIZE * 2);
+
+ bfd_make_readable (abfd);
+ return abfd;
+}
+
static bfd *
make_singleton_name_thunk (const char *import, bfd *parent)
{
quick_symbol (abfd, U ("_nm_thnk_"), name, "", UNDSEC, BSF_GLOBAL, 0);
quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
- quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
+ /* For relocator v2 we have to use the .idata$5 element and not
+ fixup_name. */
+ if (link_info.pei386_runtime_pseudo_reloc == 2)
+ quick_symbol (abfd, U ("_imp_"), name, "", UNDSEC, BSF_GLOBAL, 0);
+ else
+ quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
bfd_set_section_size (abfd, id2, 20);
d2 = xmalloc (20);
id2->contents = d2;
memset (d2, 0, 20);
- d2[0] = d2[16] = PE_IDATA5_SIZE; /* Reloc addend. */
quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
quick_reloc (abfd, 12, BFD_RELOC_RVA, 2);
quick_symbol (abfd, "", U ("_pei386_runtime_relocator"), "", UNDSEC,
BSF_NO_FLAGS, 0);
- bfd_set_section_size (abfd, extern_rt_rel, 4);
- extern_rt_rel_d = xmalloc (4);
+ bfd_set_section_size (abfd, extern_rt_rel, PE_IDATA5_SIZE);
+ extern_rt_rel_d = xmalloc (PE_IDATA5_SIZE);
extern_rt_rel->contents = extern_rt_rel_d;
quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
bfd_set_symtab (abfd, symtab, symptr);
- bfd_set_section_contents (abfd, extern_rt_rel, extern_rt_rel_d, 0, 4);
+ bfd_set_section_contents (abfd, extern_rt_rel, extern_rt_rel_d, 0, PE_IDATA5_SIZE);
bfd_make_readable (abfd);
return abfd;
char buf[300];
struct bfd_symbol *sym = *rel->sym_ptr_ptr;
struct bfd_link_hash_entry *name_thunk_sym;
+ struct bfd_link_hash_entry *name_imp_sym;
const char *name = sym->name;
char *fixup_name = make_import_fixup_mark (rel);
bfd *b;
+ int need_import_table = 1;
+
+ sprintf (buf, U ("_imp_%s"), name);
+ name_imp_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
sprintf (buf, U ("_nm_thnk_%s"), name);
name_thunk_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
- if (!name_thunk_sym || name_thunk_sym->type != bfd_link_hash_defined)
+ /* For version 2 pseudo relocation we don't need to add an import
+ if the import symbol is already present. */
+ if (link_info.pei386_runtime_pseudo_reloc == 2
+ && name_imp_sym
+ && name_imp_sym->type == bfd_link_hash_defined)
+ need_import_table = 0;
+
+ if (need_import_table == 1
+ && (!name_thunk_sym || name_thunk_sym->type != bfd_link_hash_defined))
{
bfd *b = make_singleton_name_thunk (name, link_info.output_bfd);
add_bfd_to_link (b, b->filename, &link_info);
- /* If we ever use autoimport, we have to cast text section writable. */
- config.text_read_only = FALSE;
- link_info.output_bfd->flags &= ~WP_TEXT;
+ /* If we ever use autoimport, we have to cast text section writable.
+ But not for version 2. */
+ if (link_info.pei386_runtime_pseudo_reloc != 2)
+ {
+ config.text_read_only = FALSE;
+ link_info.output_bfd->flags &= ~WP_TEXT;
+ }
+ if (link_info.pei386_runtime_pseudo_reloc == 2)
+ {
+ b = make_singleton_name_imp (name, link_info.output_bfd);
+ add_bfd_to_link (b, b->filename, &link_info);
+ }
}
- if (addend == 0 || link_info.pei386_runtime_pseudo_reloc)
+ if ((addend == 0 || link_info.pei386_runtime_pseudo_reloc)
+ && need_import_table == 1)
{
extern char * pe_data_import_dll;
char * dll_symname = pe_data_import_dll ? pe_data_import_dll : "unknown";
void
-pe_dll_generate_implib (def_file *def, const char *impfilename)
+pe_dll_generate_implib (def_file *def, const char *impfilename, struct bfd_link_info *info)
{
int i;
bfd *ar_head;
bfd *ar_tail;
bfd *outarch;
+ bfd *ibfd;
bfd *head = 0;
dll_filename = (def->name) ? def->name : dll_name;
/* xgettext:c-format */
info_msg (_("Creating library file: %s\n"), impfilename);
-
+
bfd_set_format (outarch, bfd_archive);
outarch->has_armap = 1;
/* Work out a reasonable size of things to put onto one line. */
ar_head = make_head (outarch);
+ /* Iterate the input BFDs, looking for exclude-modules-for-implib. */
+ for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link_next)
+ {
+ /* Iterate the exclude list. */
+ struct exclude_list_struct *ex;
+ char found;
+ for (ex = excludes, found = 0; ex && !found; ex = ex->next)
+ {
+ if (ex->type != EXCLUDEFORIMPLIB)
+ continue;
+ found = (strcmp (ex->string, ibfd->filename) == 0);
+ }
+ /* If it matched, we must open a fresh BFD for it (the original
+ input BFD is still needed for the DLL's final link) and add
+ it into the archive member chain. */
+ if (found)
+ {
+ bfd *newbfd = bfd_openr (ibfd->my_archive
+ ? ibfd->my_archive->filename : ibfd->filename, NULL);
+ if (!newbfd)
+ {
+ einfo (_("%Xbfd_openr %s: %E\n"), ibfd->filename);
+ return;
+ }
+ if (ibfd->my_archive)
+ {
+ /* Must now iterate through archive until we find the
+ required member. A minor shame that we'll open the
+ archive once per member that we require from it, and
+ leak those archive bfds rather than reuse them. */
+ bfd *arbfd = newbfd;
+ if (!bfd_check_format_matches (arbfd, bfd_archive, NULL))
+ {
+ einfo (_("%X%s(%s): can't find member in non-archive file"),
+ ibfd->my_archive->filename, ibfd->filename);
+ return;
+ }
+ newbfd = NULL;
+ while ((newbfd = bfd_openr_next_archived_file (arbfd, newbfd)) != 0)
+ {
+ if (strcmp (newbfd->filename, ibfd->filename) == 0)
+ break;
+ }
+ if (!newbfd)
+ {
+ einfo (_("%X%s(%s): can't find member in archive"),
+ ibfd->my_archive->filename, ibfd->filename);
+ return;
+ }
+ }
+ newbfd->archive_next = head;
+ head = newbfd;
+ }
+ }
+
for (i = 0; i < def->num_exports; i++)
{
/* The import library doesn't know about the internal name. */
char *internal = def->exports[i].internal_name;
bfd *n;
- /* Don't add PRIVATE entries to import lib. */
+ /* Don't add PRIVATE entries to import lib. */
if (pe_def_file->exports[i].flag_private)
continue;
def->exports[i].internal_name = def->exports[i].name;
if (!blhe || (blhe && blhe->type != bfd_link_hash_undefined))
{
if (lead_at)
- sprintf (name, "%s%s", "__imp_",
+ sprintf (name, "%s%s", "__imp_",
pe_def_file->imports[i].internal_name);
else
sprintf (name, "%s%s%s", "__imp_", U (""),
export_rva = pe_get32 (dll, opthdr_ofs + 96);
export_size = pe_get32 (dll, opthdr_ofs + 100);
#endif
-
+
nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
secptr = (pe_header_offset + 4 + 20 +
pe_get16 (dll, pe_header_offset + 4 + 16));
return TRUE;
}
+void
+pe_output_file_set_long_section_names (bfd *abfd)
+{
+ if (pe_use_coff_long_section_names < 0)
+ return;
+ if (!bfd_coff_set_long_section_names (abfd, pe_use_coff_long_section_names))
+ einfo (_("%XError: can't use long section names on this arch\n"));
+}
+
/* These are the main functions, called from the emulation. The first
is called after the bfds are read, so we can guess at how much space
we need. The second is called after everything is placed, so we
pe_dll_build_sections (bfd *abfd, struct bfd_link_info *info)
{
pe_dll_id_target (bfd_get_target (abfd));
+ pe_output_file_set_long_section_names (abfd);
process_def_file (abfd, info);
if (pe_def_file->num_exports == 0 && !info->shared)
generate_edata (abfd, info);
build_filler_bfd (1);
+ pe_output_file_set_long_section_names (filler_bfd);
}
void
pe_exe_build_sections (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
{
pe_dll_id_target (bfd_get_target (abfd));
+ pe_output_file_set_long_section_names (abfd);
build_filler_bfd (0);
+ pe_output_file_set_long_section_names (filler_bfd);
}
void
pe_dll_fill_sections (bfd *abfd, struct bfd_link_info *info)
{
pe_dll_id_target (bfd_get_target (abfd));
+ pe_output_file_set_long_section_names (abfd);
image_base = pe_data (abfd)->pe_opthdr.ImageBase;
generate_reloc (abfd, info);
pe_exe_fill_sections (bfd *abfd, struct bfd_link_info *info)
{
pe_dll_id_target (bfd_get_target (abfd));
+ pe_output_file_set_long_section_names (abfd);
image_base = pe_data (abfd)->pe_opthdr.ImageBase;
generate_reloc (abfd, info);