/* Routines to help build PEI-format DLLs (Win32 etc)
- Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
- 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
+ Copyright (C) 1998-2017 Free Software Foundation, Inc.
Written by DJ Delorie <dj@cygnus.com>
This file is part of the GNU Binutils.
should run in parallel with addresses vector (FirstThunk), i.e. that they
should have same number of elements and terminated with zero. We violate
this, since FirstThunk points directly into machine code. But in practice,
- OS loader implemented the sane way: it goes thru OriginalFirstThunk and
+ OS loader implemented the sane way: it goes through OriginalFirstThunk and
puts addresses to FirstThunk, not something else. It once again should be
noted that dll and symbol name structures are reused across fixup entries
and should be there anyway to support standard import stuff, so sustained
{ STRING_COMMA_LEN ("_impure_ptr") },
{ STRING_COMMA_LEN ("_fmode") },
{ STRING_COMMA_LEN ("environ") },
+ { STRING_COMMA_LEN ("__dso_handle") },
{ NULL, 0 }
};
#endif
autofilter_symbollist_i386
},
+#ifdef pe_use_x86_64
+ {
+ "pei-x86-64",
+ "pe-bigobj-x86-64",
+ 3 /* R_IMAGEBASE */,
+ PE_ARCH_i386,
+ bfd_arch_i386,
+ FALSE,
+ autofilter_symbollist_i386
+ },
+#endif
{
"pei-shl",
"pe-shl",
pe_leading_underscore = (u != 0 ? 1 : 0);
return;
}
- einfo (_("%XUnsupported PEI architecture: %s\n"), target);
+ einfo (_("%P%X: Unsupported PEI architecture: %s\n"), target);
exit (1);
}
/* First, run around to all the objects looking for the .drectve
sections, and push those into the def file too. */
- for (b = info->input_bfds; b; b = b->link_next)
+ for (b = info->input_bfds; b; b = b->link.next)
{
s = bfd_get_section_by_name (b, ".drectve");
if (s)
/* If we are building an executable and there is nothing
to export, we do not build an export table at all. */
- if (info->executable && pe_def_file->num_exports == 0
+ if (bfd_link_executable (info) && pe_def_file->num_exports == 0
&& (!pe_dll_export_everything || pe_dll_exclude_all_symbols))
return;
if ((pe_dll_export_everything || pe_def_file->num_exports == 0)
&& !pe_dll_exclude_all_symbols)
{
- for (b = info->input_bfds; b; b = b->link_next)
+ for (b = info->input_bfds; b; b = b->link.next)
{
asymbol **symbols;
int nsyms;
/* We should export symbols which are either global or not
anything at all. (.bss data is the latter)
We should not export undefined symbols. */
- bfd_boolean would_export = symbols[j]->section != &bfd_und_section
- && ((symbols[j]->flags & BSF_GLOBAL)
- || (symbols[j]->flags == 0));
+ bfd_boolean would_export
+ = (symbols[j]->section != bfd_und_section_ptr
+ && ((symbols[j]->flags & BSF_GLOBAL)
+ || (symbols[j]->flags == 0)));
if (link_info.version_info && would_export)
would_export
= !bfd_hide_sym_by_version (link_info.version_info,
{
for (i = 0; i < NE; i++)
{
- if (strchr (pe_def_file->exports[i].name, '@'))
+ /* Check for fastcall/stdcall-decoration, but ignore
+ C++ mangled names. */
+ if (pe_def_file->exports[i].name[0] != '?'
+ && strchr (pe_def_file->exports[i].name, '@'))
{
/* This will preserve internal_name, which may have been
pointing to the same memory as name, or might not
have. */
int lead_at = (*pe_def_file->exports[i].name == '@');
char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
- char *tmp_at = strchr (tmp, '@');
+ char *tmp_at = strrchr (tmp, '@');
if (tmp_at)
*tmp_at = 0;
else
- einfo (_("%XCannot export %s: invalid export name\n"),
+ einfo (_("%P%X: Cannot export %s: invalid export name\n"),
pe_def_file->exports[i].name);
pe_def_file->exports[i].name = tmp;
resort_needed = TRUE;
{
if (pe_dll_warn_dup_exports)
/* xgettext:c-format */
- einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
+ einfo (_("%P%X: Error, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
e[j - 1].name, e[j - 1].ordinal, e[i].ordinal);
}
else
{
if (pe_dll_warn_dup_exports)
/* xgettext:c-format */
- einfo (_("Warning, duplicate EXPORT: %s\n"),
+ einfo (_("%P: Warning, duplicate EXPORT: %s\n"),
e[j - 1].name);
}
for (i = 0; i < NE; i++)
{
+ char *int_name = pe_def_file->exports[i].internal_name;
char *name;
- name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
- if (pe_details->underscored
- && (*pe_def_file->exports[i].internal_name != '@'))
+
+ /* PR 19803: Make sure that any exported symbol does not get garbage collected. */
+ lang_add_gc_name (int_name);
+
+ name = xmalloc (strlen (int_name) + 2);
+ if (pe_details->underscored && int_name[0] != '@')
{
*name = '_';
- strcpy (name + 1, pe_def_file->exports[i].internal_name);
+ strcpy (name + 1, int_name);
+
+ /* PR 19803: The alias must be preserved as well. */
+ lang_add_gc_name (xstrdup (name));
}
else
- strcpy (name, pe_def_file->exports[i].internal_name);
+ strcpy (name, int_name);
blhe = bfd_link_hash_lookup (info->hash,
name,
but we must take care not to be fooled when the user wants to export
a symbol that actually really has a dot in it, so we only check
for them here, after real defined symbols have already been matched. */
- else if (strchr (pe_def_file->exports[i].internal_name, '.'))
+ else if (strchr (int_name, '.'))
{
count_exported++;
if (!pe_def_file->exports[i].flag_noname)
else if (blhe && blhe->type == bfd_link_hash_undefined)
{
/* xgettext:c-format */
- einfo (_("%XCannot export %s: symbol not defined\n"),
- pe_def_file->exports[i].internal_name);
+ einfo (_("%P%X: Cannot export %s: symbol not defined\n"),
+ int_name);
}
else if (blhe)
{
/* xgettext:c-format */
- einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
- pe_def_file->exports[i].internal_name,
+ einfo (_("%P%X: Cannot export %s: symbol wrong type (%d vs %d)\n"),
+ int_name,
blhe->type, bfd_link_hash_defined);
}
else
{
/* xgettext:c-format */
- einfo (_("%XCannot export %s: symbol not found\n"),
- pe_def_file->exports[i].internal_name);
+ einfo (_("%P%X: Cannot export %s: symbol not found\n"),
+ int_name);
}
free (name);
}
if (pi != -1)
{
/* xgettext:c-format */
- einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
+ einfo (_("%P%X: Error: ordinal used twice: %d (%s vs %s)\n"),
pe_def_file->exports[i].ordinal,
pe_def_file->exports[i].name,
pe_def_file->exports[pi].name);
pe_def_file->exports[i].ordinal = next_ordinal;
}
+ /* PR 12969: Check for more than 1^16 ordinals. */
+ if (max_ordinal > 65535 || next_ordinal > 65535)
+ /* xgettext:c-format */
+ einfo(_("%P%X: Error: export ordinal too large: %d\n"),
+ max_ordinal > next_ordinal ? max_ordinal : next_ordinal);
+
/* OK, now we can allocate some memory. */
edata_sz = (40 /* directory */
+ 4 * export_table_size /* addresses */
unsigned char *enameptrs;
unsigned char *eordinals;
char *enamestr;
- time_t now;
-
- time (&now);
edata_d = xmalloc (edata_sz);
+ edata_s->output_section->vma - image_base)
memset (edata_d, 0, edata_sz);
- bfd_put_32 (abfd, now, edata_d + 4);
+
+ if (pe_data (abfd)->insert_timestamp)
+ H_PUT_32 (abfd, time (0), edata_d + 4);
+
if (pe_def_file->version_major != -1)
{
bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8);
void
pe_walk_relocs_of_symbol (struct bfd_link_info *info,
- const char *name,
- int (*cb) (arelent *, asection *))
+ char *name,
+ int (*cb) (arelent *, asection *, char *))
{
bfd *b;
asection *s;
- for (b = info->input_bfds; b; b = b->link_next)
+ for (b = info->input_bfds; b; b = b->link.next)
{
asymbol **symbols;
struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
if (!strcmp (name, sym->name))
- cb (relocs[i], s);
+ cb (relocs[i], s, name);
}
free (relocs);
struct bfd_section *s;
total_relocs = 0;
- for (b = info->input_bfds; b; b = b->link_next)
+ for (b = info->input_bfds; b; b = b->link.next)
for (s = b->sections; s; s = s->next)
total_relocs += s->reloc_count;
total_relocs = 0;
bi = 0;
- for (bi = 0, b = info->input_bfds; b; bi++, b = b->link_next)
+ for (bi = 0, b = info->input_bfds; b; bi++, b = b->link.next)
{
arelent **relocs;
int relsize, nrelocs;
/* I don't know why there would be a reloc for these, but I've
seen it happen - DJ */
- if (s->output_section == &bfd_abs_section)
+ if (s->output_section == bfd_abs_section_ptr)
continue;
if (s->output_section->vma == 0)
no reason we'd want a reference to any absolute
address to get relocated during rebasing). */
if (!h2 || h2->root.type == bfd_link_hash_undefined
- || h2->root.u.def.section == &bfd_abs_section)
+ || h2->root.u.def.section == bfd_abs_section_ptr)
continue;
}
else if (!blhe || blhe->type != bfd_link_hash_defined)
/* Fall through. */
default:
/* xgettext:c-format */
- einfo (_("%XError: %d-bit reloc in dll\n"),
+ einfo (_("%P%X: Error: %d-bit reloc in dll\n"),
relocs[i]->howto->bitsize);
break;
}
if (out == NULL)
/* xgettext:c-format */
- einfo (_("%s: Can't open output def file %s\n"),
- program_name, pe_out_def_filename);
+ einfo (_("%P: Can't open output def file %s\n"),
+ pe_out_def_filename);
if (pe_def_file)
{
static const char *dll_filename;
static char *dll_symname;
-#define UNDSEC (asection *) &bfd_und_section
+#define UNDSEC bfd_und_section_ptr
static asection *
quick_section (bfd *abfd, const char *name, int flags, int align)
}
else
{
+ int ord;
+
/* { short, asciz } */
if (exp->its_name)
len = 2 + strlen (exp->its_name) + 1;
d6 = xmalloc (len);
id6->contents = d6;
memset (d6, 0, len);
- d6[0] = exp->hint & 0xff;
- d6[1] = exp->hint >> 8;
+
+ /* PR 20880: Use exp->hint as a backup, just in case exp->ordinal
+ contains an invalid value (-1). */
+ ord = (exp->ordinal >= 0) ? exp->ordinal : exp->hint;
+ d6[0] = ord;
+ d6[1] = ord >> 8;
+
if (exp->its_name)
strcpy ((char*) d6 + 2, exp->its_name);
else
}
static char *
-make_import_fixup_mark (arelent *rel)
+make_import_fixup_mark (arelent *rel, char *name)
{
/* We convert reloc to symbol, for later reference. */
- static int counter;
- static char *fixup_name = NULL;
- static size_t buffer_len = 0;
-
+ static unsigned int counter;
struct bfd_symbol *sym = *rel->sym_ptr_ptr;
-
bfd *abfd = bfd_asymbol_bfd (sym);
struct bfd_link_hash_entry *bh;
+ char *fixup_name, buf[26];
+ size_t prefix_len;
- if (!fixup_name)
- {
- fixup_name = xmalloc (384);
- buffer_len = 384;
- }
-
- if (strlen (sym->name) + 25 > buffer_len)
- /* Assume 25 chars for "__fu" + counter + "_". If counter is
- bigger than 20 digits long, we've got worse problems than
- overflowing this buffer... */
- {
- free (fixup_name);
- /* New buffer size is length of symbol, plus 25, but
- then rounded up to the nearest multiple of 128. */
- buffer_len = ((strlen (sym->name) + 25) + 127) & ~127;
- fixup_name = xmalloc (buffer_len);
- }
-
- sprintf (fixup_name, "__fu%d_%s", counter++, sym->name);
+ /* "name" buffer has space before the symbol name for prefixes. */
+ sprintf (buf, "__fu%d_", counter++);
+ prefix_len = strlen (buf);
+ fixup_name = name - prefix_len;
+ memcpy (fixup_name, buf, prefix_len);
bh = NULL;
bfd_coff_link_add_one_symbol (&link_info, abfd, fixup_name, BSF_GLOBAL,
BSF_NO_FLAGS, 0);
bfd_set_section_size (abfd, extern_rt_rel, PE_IDATA5_SIZE);
- extern_rt_rel_d = xmalloc (PE_IDATA5_SIZE);
+ extern_rt_rel_d = xcalloc (1, PE_IDATA5_SIZE);
extern_rt_rel->contents = extern_rt_rel_d;
quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
}
void
-pe_create_import_fixup (arelent *rel, asection *s, bfd_vma addend)
+pe_create_import_fixup (arelent *rel, asection *s, bfd_vma addend, char *name)
{
- 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);
+ char *fixup_name, *impname;
bfd *b;
int need_import_table = 1;
- sprintf (buf, "__imp_%s", name);
- name_imp_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
+ /* name buffer is allocated with space at beginning for prefixes. */
+ impname = name - (sizeof "__imp_" - 1);
+ memcpy (impname, "__imp_", sizeof "__imp_" - 1);
+ name_imp_sym = bfd_link_hash_lookup (link_info.hash, impname, 0, 0, 1);
- sprintf (buf, "__nm_thnk_%s", name);
+ impname = name - (sizeof "__nm_thnk_" - 1);
+ memcpy (impname, "__nm_thnk_", sizeof "__nm_thnk_" - 1);
+ name_thunk_sym = bfd_link_hash_lookup (link_info.hash, impname, 0, 0, 1);
- name_thunk_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
+ fixup_name = make_import_fixup_mark (rel, name);
/* For version 2 pseudo relocation we don't need to add an import
if the import symbol is already present. */
runtime_pseudo_relocs_created++;
}
else if (addend != 0)
- {
- einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
- s->owner, s, rel->address, sym->name);
- einfo ("%X");
- }
+ einfo (_("%P%X%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
+ s->owner, s, rel->address, sym->name);
}
if (!outarch)
{
/* xgettext:c-format */
- einfo (_("%XCan't open .lib file: %s\n"), impfilename);
+ einfo (_("%P%X: Can't open .lib file: %s\n"), impfilename);
return;
}
- /* xgettext:c-format */
- info_msg (_("Creating library file: %s\n"), impfilename);
+ if (verbose)
+ /* xgettext:c-format */
+ info_msg (_("Creating library file: %s\n"), impfilename);
bfd_set_format (outarch, bfd_archive);
outarch->has_armap = 1;
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)
+ for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next)
{
/* Iterate the exclude list. */
struct exclude_list_struct *ex;
? ibfd->my_archive->filename : ibfd->filename, NULL);
if (!newbfd)
{
- einfo (_("%Xbfd_openr %s: %E\n"), ibfd->filename);
+ einfo (_("%P%X: bfd_openr %s: %E\n"), ibfd->filename);
return;
}
if (ibfd->my_archive)
bfd *arbfd = newbfd;
if (!bfd_check_format_matches (arbfd, bfd_archive, NULL))
{
- einfo (_("%X%s(%s): can't find member in non-archive file"),
+ einfo (_("%P%X: %s(%s): can't find member in non-archive file"),
ibfd->my_archive->filename, ibfd->filename);
return;
}
}
if (!newbfd)
{
- einfo (_("%X%s(%s): can't find member in archive"),
+ einfo (_("%P%X: %s(%s): can't find member in archive"),
ibfd->my_archive->filename, ibfd->filename);
return;
}
/* 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;
+
+ /* PR 19803: If a symbol has been discard due to garbage
+ collection then do not create any exports for it. */
+ {
+ struct coff_link_hash_entry *h;
+
+ h = coff_link_hash_lookup (coff_hash_table (info), internal,
+ FALSE, FALSE, FALSE);
+ if (h != NULL
+ /* If the symbol is hidden and undefined then it
+ has been swept up by garbage collection. */
+ && h->symbol_class == C_HIDDEN
+ && h->root.u.def.section == bfd_und_section_ptr)
+ continue;
+
+ /* If necessary, check with an underscore prefix as well. */
+ if (pe_details->underscored && internal[0] != '@')
+ {
+ char *name;
+
+ name = xmalloc (strlen (internal) + 2);
+ sprintf (name, "_%s", internal);
+
+ h = coff_link_hash_lookup (coff_hash_table (info), name,
+ FALSE, FALSE, FALSE);
+ free (name);
+
+ if (h != NULL
+ /* If the symbol is hidden and undefined then it
+ has been swept up by garbage collection. */
+ && h->symbol_class == C_HIDDEN
+ && h->root.u.def.section == bfd_und_section_ptr)
+ continue;
+ }
+ }
+
n = make_one (def->exports + i, outarch,
! (def->exports + i)->flag_data);
n->archive_next = head;
head = ar_tail;
if (! bfd_set_archive_head (outarch, head))
- einfo ("%Xbfd_set_archive_head: %E\n");
+ einfo ("%P%X: bfd_set_archive_head: %E\n");
if (! bfd_close (outarch))
- einfo ("%Xbfd_close %s: %E\n", impfilename);
+ einfo ("%P%X: bfd_close %s: %E\n", impfilename);
while (head != NULL)
{
}
}
-static struct bfd_link_hash_entry *found_sym;
+static int undef_count = 0;
+
+struct key_value
+{
+ char *key;
+ const char *oname;
+};
+
+static struct key_value *udef_table;
+
+static int undef_sort_cmp (const void *l1, const void *r1)
+{
+ const struct key_value *l = l1;
+ const struct key_value *r = r1;
+
+ return strcmp (l->key, r->key);
+}
+
+static struct bfd_link_hash_entry *
+pe_find_cdecl_alias_match (struct bfd_link_info *linfo, char *name)
+{
+ struct bfd_link_hash_entry *h = NULL;
+ struct key_value *kv;
+ struct key_value key;
+ char *at, *lname = xmalloc (strlen (name) + 3);
+
+ strcpy (lname, name);
+
+ at = strchr (lname + (lname[0] == '@'), '@');
+ if (at)
+ at[1] = 0;
+
+ key.key = lname;
+ kv = bsearch (&key, udef_table, undef_count, sizeof (struct key_value),
+ undef_sort_cmp);
+
+ if (kv)
+ {
+ h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
+ if (h->type == bfd_link_hash_undefined)
+ goto return_h;
+ }
+
+ if (lname[0] == '?')
+ goto return_NULL;
+
+ if (at || lname[0] == '@')
+ {
+ if (lname[0] == '@')
+ {
+ if (pe_details->underscored)
+ lname[0] = '_';
+ else
+ strcpy (lname, lname + 1);
+ key.key = lname;
+ kv = bsearch (&key, udef_table, undef_count,
+ sizeof (struct key_value), undef_sort_cmp);
+ if (kv)
+ {
+ h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
+ if (h->type == bfd_link_hash_undefined)
+ goto return_h;
+ }
+ }
+ if (at)
+ *strchr (lname, '@') = 0;
+ key.key = lname;
+ kv = bsearch (&key, udef_table, undef_count,
+ sizeof (struct key_value), undef_sort_cmp);
+ if (kv)
+ {
+ h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
+ if (h->type == bfd_link_hash_undefined)
+ goto return_h;
+ }
+ goto return_NULL;
+ }
+
+ strcat (lname, "@");
+ key.key = lname;
+ kv = bsearch (&key, udef_table, undef_count,
+ sizeof (struct key_value), undef_sort_cmp);
+
+ if (kv)
+ {
+ h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
+ if (h->type == bfd_link_hash_undefined)
+ goto return_h;
+ }
+
+ if (lname[0] == '_' && pe_details->underscored)
+ lname[0] = '@';
+ else
+ {
+ memmove (lname + 1, lname, strlen (lname) + 1);
+ lname[0] = '@';
+ }
+ key.key = lname;
+
+ kv = bsearch (&key, udef_table, undef_count,
+ sizeof (struct key_value), undef_sort_cmp);
+
+ if (kv)
+ {
+ h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE);
+ if (h->type == bfd_link_hash_undefined)
+ goto return_h;
+ }
+
+ return_NULL:
+ h = NULL;
+ return_h:
+ free (lname);
+ return h;
+}
static bfd_boolean
-pe_undef_alias_cdecl_match (struct bfd_link_hash_entry *h, void *inf)
+pe_undef_count (struct bfd_link_hash_entry *h ATTRIBUTE_UNUSED,
+ void *inf ATTRIBUTE_UNUSED)
{
- int sl;
- char *string = inf;
- const char *hs = h->root.string;
-
- sl = strlen (string);
- if (h->type == bfd_link_hash_undefined
- && ((*hs == '@' && (!pe_details->underscored || *string == '_')
- && strncmp (hs + 1, string + (pe_details->underscored != 0),
- sl - (pe_details->underscored != 0)) == 0)
- || strncmp (hs, string, sl) == 0)
- && h->root.string[sl] == '@')
- {
- found_sym = h;
- return FALSE;
+ if (h->type == bfd_link_hash_undefined)
+ undef_count++;
+ return TRUE;
+}
+
+static bfd_boolean
+pe_undef_fill (struct bfd_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED)
+{
+ if (h->type == bfd_link_hash_undefined)
+ {
+ char *at;
+
+ udef_table[undef_count].key = xstrdup (h->root.string);
+ at = strchr (udef_table[undef_count].key
+ + (udef_table[undef_count].key[0] == '@'), '@');
+ if (at)
+ at[1] = 0;
+ udef_table[undef_count].oname = h->root.string;
+ undef_count++;
}
return TRUE;
}
-static struct bfd_link_hash_entry *
-pe_find_cdecl_alias_match (char *name)
+static void
+pe_create_undef_table (void)
{
- found_sym = 0;
- bfd_link_hash_traverse (link_info.hash, pe_undef_alias_cdecl_match,
- (char *) name);
- return found_sym;
+ undef_count = 0;
+
+ /* count undefined symbols */
+
+ bfd_link_hash_traverse (link_info.hash, pe_undef_count, "");
+
+ /* create and fill the corresponding table */
+ udef_table = xmalloc (undef_count * sizeof (struct key_value));
+
+ undef_count = 0;
+ bfd_link_hash_traverse (link_info.hash, pe_undef_fill, "");
+
+ /* sort items */
+ qsort (udef_table, undef_count, sizeof (struct key_value), undef_sort_cmp);
}
static void
ldlang_add_file (fake_file);
if (!bfd_link_add_symbols (abfd, linfo))
- einfo ("%Xaddsym %s: %E\n", name);
+ einfo ("%P%X: addsym %s: %E\n", name);
}
void
imp = pe_def_file->imports;
+ pe_create_undef_table ();
+
for (module = pe_def_file->modules; module; module = module->next)
{
int do_this_dll = 0;
char *name = xmalloc (len + 2 + 6);
bfd_boolean include_jmp_stub = FALSE;
bfd_boolean is_cdecl = FALSE;
+ bfd_boolean is_undef = FALSE;
+
if (!lead_at && strchr (imp[i].internal_name, '@') == NULL)
is_cdecl = TRUE;
blhe = bfd_link_hash_lookup (linfo->hash, name,
FALSE, FALSE, FALSE);
+ if (blhe)
+ is_undef = (blhe->type == bfd_link_hash_undefined);
}
else
- include_jmp_stub = TRUE;
+ {
+ include_jmp_stub = TRUE;
+ is_undef = (blhe->type == bfd_link_hash_undefined);
+ }
- if (is_cdecl && !blhe)
+ if (is_cdecl && (!blhe || (blhe && blhe->type != bfd_link_hash_undefined)))
{
sprintf (name, "%s%s",U (""), imp[i].internal_name);
- blhe = pe_find_cdecl_alias_match (name);
+ blhe = pe_find_cdecl_alias_match (linfo, name);
include_jmp_stub = TRUE;
+ if (blhe)
+ is_undef = (blhe->type == bfd_link_hash_undefined);
}
free (name);
- if (blhe && blhe->type == bfd_link_hash_undefined)
+ if (is_undef)
{
bfd *one;
/* We do. */
free (dll_symname);
}
+
+ while (undef_count)
+ {
+ --undef_count;
+ free (udef_table[undef_count].key);
+ }
+ free (udef_table);
}
/* We were handed a *.DLL file. Parse it and turn it into a set of
dll = bfd_openr (filename, pe_details->target_name);
if (!dll)
{
- einfo ("%Xopen %s: %E\n", filename);
+ einfo ("%P%X: open %s: %E\n", filename);
return FALSE;
}
/* PEI dlls seem to be bfd_objects. */
if (!bfd_check_format (dll, bfd_object))
{
- einfo ("%X%s: this doesn't appear to be a DLL\n", filename);
+ einfo ("%P%X: %s: this doesn't appear to be a DLL\n", filename);
return FALSE;
}
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"));
+ einfo (_("%P%X: Error: can't use long section names on this arch\n"));
}
/* These are the main functions, called from the emulation. The first
pe_output_file_set_long_section_names (abfd);
process_def_file_and_drectve (abfd, info);
- if (pe_def_file->num_exports == 0 && !info->shared)
+ if (pe_def_file->num_exports == 0 && !bfd_link_pic (info))
return;
generate_edata (abfd, info);
fill_edata (abfd, info);
- if (info->shared && !info->pie)
+ if (bfd_link_dll (info))
pe_data (abfd)->dll = 1;
edata_s->contents = edata_d;