/* Routines to help build PEI-format DLLs (Win32 etc)
- Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
- 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 1998-2023 Free Software Foundation, Inc.
Written by DJ Delorie <dj@cygnus.com>
This file is part of the GNU Binutils.
#include "bfd.h"
#include "bfdlink.h"
#include "libiberty.h"
+#include "filenames.h"
#include "safe-ctype.h"
+#include "ctf-api.h"
#include <time.h>
#include "../bfd/libcoff.h"
#include "deffile.h"
-#ifdef pe_use_x86_64
+#ifdef pe_use_plus
#define PE_IDATA4_SIZE 8
#define PE_IDATA5_SIZE 8
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
def_file * pe_def_file = 0;
int pe_dll_export_everything = 0;
+int pe_dll_exclude_all_symbols = 0;
int pe_dll_do_default_excludes = 1;
int pe_dll_kill_ats = 0;
int pe_dll_stdcall_aliases = 0;
int pe_dll_extra_pe_debug = 0;
int pe_use_nul_prefixed_import_tables = 0;
int pe_use_coff_long_section_names = -1;
+int pe_leading_underscore = -1;
+int pe_dll_enable_reloc_section = 1;
/* Static variables and types. */
static bfd *filler_bfd;
static struct bfd_section *edata_s, *reloc_s;
static unsigned char *edata_d, *reloc_d;
-static size_t edata_sz, reloc_sz;
+static unsigned char *reloc_d = NULL;
+static size_t edata_sz, reloc_sz = 0;
static int runtime_pseudo_relocs_created = 0;
-static int runtime_pseudp_reloc_v2_init = 0;
+static bool runtime_pseudp_reloc_v2_init = false;
typedef struct
{
unsigned int imagebase_reloc;
int pe_arch;
int bfd_arch;
- bfd_boolean underscored;
- const autofilter_entry_type* autofilter_symbollist;
+ bool underscored;
+ const autofilter_entry_type* autofilter_symbollist;
}
pe_details_type;
{ STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
/* Entry point symbols, and entry hooks. */
{ STRING_COMMA_LEN ("cygwin_crt0") },
-#ifdef pe_use_x86_64
+#ifdef pe_use_plus
{ STRING_COMMA_LEN ("DllMain") },
{ STRING_COMMA_LEN ("DllEntryPoint") },
{ STRING_COMMA_LEN ("DllMainCRTStartup") },
{ STRING_COMMA_LEN ("_cygwin_crt0_common@8") },
{ STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry@12") },
{ STRING_COMMA_LEN ("cygwin_attach_dll") },
-#endif
+#endif
{ STRING_COMMA_LEN ("cygwin_premain0") },
{ STRING_COMMA_LEN ("cygwin_premain1") },
{ STRING_COMMA_LEN ("cygwin_premain2") },
{ STRING_COMMA_LEN ("_impure_ptr") },
{ STRING_COMMA_LEN ("_fmode") },
{ STRING_COMMA_LEN ("environ") },
+ { STRING_COMMA_LEN ("__dso_handle") },
{ NULL, 0 }
};
#define PE_ARCH_sh 2
#define PE_ARCH_mips 3
#define PE_ARCH_arm 4
-#define PE_ARCH_arm_epoc 5
-#define PE_ARCH_arm_wince 6
+#define PE_ARCH_arm_wince 5
+#define PE_ARCH_aarch64 6
-static const pe_details_type pe_detail_list[] =
+/* Don't make it constant as underscore mode gets possibly overriden
+ by target or -(no-)leading-underscore option. */
+static pe_details_type pe_detail_list[] =
{
{
-#ifdef pe_use_x86_64
+#ifdef pe_use_plus
"pei-x86-64",
"pe-x86-64",
3 /* R_IMAGEBASE */,
#endif
PE_ARCH_i386,
bfd_arch_i386,
- TRUE,
+#ifdef pe_use_plus
+ false,
+#else
+ true,
+#endif
+ autofilter_symbollist_i386
+ },
+#ifdef pe_use_plus
+ {
+ "pei-x86-64",
+ "pe-bigobj-x86-64",
+ 3 /* R_IMAGEBASE */,
+ PE_ARCH_i386,
+ bfd_arch_i386,
+ false,
+ autofilter_symbollist_i386
+ },
+#else
+ {
+ "pei-i386",
+ "pe-bigobj-i386",
+ 7 /* R_IMAGEBASE */,
+ PE_ARCH_i386,
+ bfd_arch_i386,
+ true,
autofilter_symbollist_i386
},
+#endif
{
"pei-shl",
"pe-shl",
16 /* R_SH_IMAGEBASE */,
PE_ARCH_sh,
bfd_arch_sh,
- TRUE,
+ true,
autofilter_symbollist_generic
},
{
34 /* MIPS_R_RVA */,
PE_ARCH_mips,
bfd_arch_mips,
- FALSE,
+ false,
autofilter_symbollist_generic
},
{
11 /* ARM_RVA32 */,
PE_ARCH_arm,
bfd_arch_arm,
- TRUE,
- autofilter_symbollist_generic
- },
- {
- "epoc-pei-arm-little",
- "epoc-pe-arm-little",
- 11 /* ARM_RVA32 */,
- PE_ARCH_arm_epoc,
- bfd_arch_arm,
- FALSE,
+ true,
autofilter_symbollist_generic
},
{
2, /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c. */
PE_ARCH_arm_wince,
bfd_arch_arm,
- FALSE,
+ false,
autofilter_symbollist_generic
},
- { NULL, NULL, 0, 0, 0, FALSE, NULL }
+ {
+ "pei-aarch64-little",
+ "pe-aarch64-little",
+ 2, /* ARM64_RVA32 */
+ PE_ARCH_aarch64,
+ bfd_arch_aarch64,
+ false,
+ autofilter_symbollist_generic
+ },
+ { NULL, NULL, 0, 0, 0, false, NULL }
};
static const pe_details_type *pe_details;
{ STRING_COMMA_LEN ("libsupc++") },
{ STRING_COMMA_LEN ("libobjc") },
{ STRING_COMMA_LEN ("libgcj") },
+ { STRING_COMMA_LEN ("libmsvcrt") },
+ { STRING_COMMA_LEN ("libmsvcrt-os") },
+ { STRING_COMMA_LEN ("libucrt") },
+ { STRING_COMMA_LEN ("libucrtbase") },
{ NULL, 0 }
};
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))
+ if (filename_ncmp (libname, afptr->name, afptr->len))
return -1;
libname += afptr->len;
{ STRING_COMMA_LEN ("__rtti_") },
{ STRING_COMMA_LEN ("__builtin_") },
/* Don't re-export auto-imported symbols. */
- { STRING_COMMA_LEN ("_nm_") },
+ { STRING_COMMA_LEN ("__nm_") },
/* Don't export symbols specifying internal DLL layout. */
{ STRING_COMMA_LEN ("_head_") },
{ STRING_COMMA_LEN ("_IMPORT_DESCRIPTOR_") },
if (strcmp (pe_detail_list[i].target_name, target) == 0
|| strcmp (pe_detail_list[i].object_target, target) == 0)
{
+ int u = pe_leading_underscore; /* Underscoring mode. -1 for use default. */
+ if (u == -1)
+ bfd_get_target_info (target, NULL, NULL, &u, NULL);
+ if (u == -1)
+ abort ();
+ pe_detail_list[i].underscored = u != 0;
pe_details = pe_detail_list + i;
+ pe_leading_underscore = (u != 0 ? 1 : 0);
return;
}
- einfo (_("%XUnsupported PEI architecture: %s\n"), target);
+ einfo (_("%X%P: unsupported PEI architecture: %s\n"), target);
exit (1);
}
bfd_vma vma;
char type;
short extra;
+ int idx;
}
reloc_data_type;
static int
reloc_sort (const void *va, const void *vb)
{
- bfd_vma a = ((const reloc_data_type *) va)->vma;
- bfd_vma b = ((const reloc_data_type *) vb)->vma;
+ const reloc_data_type *a = (const reloc_data_type *) va;
+ const reloc_data_type *b = (const reloc_data_type *) vb;
- return (a > b) ? 1 : ((a < b) ? -1 : 0);
+ if (a->vma > b->vma)
+ return 1;
+ if (a->vma < b->vma)
+ return -1;
+ if (a->idx > b->idx)
+ return 1;
+ if (a->idx < b->idx)
+ return -1;
+ return 0;
}
static int
{
const def_file_export *a = va;
const def_file_export *b = vb;
-
- return strcmp (a->name, b->name);
+ char *an = a->name;
+ char *bn = b->name;
+ if (a->its_name)
+ an = a->its_name;
+ if (b->its_name)
+ bn = b->its_name;
+
+ return strcmp (an, bn);
}
/* Read and process the .DEF file. */
static int count_exported;
static int count_exported_byname;
static int count_with_ordinals;
-static const char *dll_name;
+static const char *dll_filename;
static int min_ordinal, max_ordinal;
static int *exported_symbols;
free (local_copy);
}
-static bfd_boolean
+static bool
is_import (const char* n)
{
- return (CONST_STRNEQ (n, "__imp_"));
+ return (startswith (n, "__imp_"));
}
/* abfd is a bfd containing n (or NULL)
static int
auto_export (bfd *abfd, def_file *d, const char *n)
{
- int i;
+ def_file_export key;
struct exclude_list_struct *ex;
const autofilter_entry_type *afptr;
- const char * libname = 0;
+ const char * libname = NULL;
+
if (abfd && abfd->my_archive)
- libname = lbasename (abfd->my_archive->filename);
+ libname = lbasename (bfd_get_filename (abfd->my_archive));
+
+ key.name = key.its_name = (char *) n;
- for (i = 0; i < d->num_exports; i++)
- if (strcmp (d->exports[i].name, n) == 0)
- return 0;
+ /* Return false if n is in the d->exports table. */
+ if (d->num_exports != 0
+ && bsearch (&key, d->exports, d->num_exports,
+ sizeof (pe_def_file->exports[0]), pe_export_sort))
+ return 0;
if (pe_dll_do_default_excludes)
{
/* Next, exclude symbols from certain startup objects. */
- if (abfd && (p = lbasename (abfd->filename)))
+ if (abfd && (p = lbasename (bfd_get_filename (abfd))))
{
afptr = autofilter_objlist;
while (afptr->name)
that begin with '__'; this was tried and
it is too restrictive. Instead we have
a target specific list to use: */
- afptr = pe_details->autofilter_symbollist;
+ afptr = pe_details->autofilter_symbollist;
while (afptr->name)
{
if (ex->type == EXCLUDELIBS)
{
if (libname
- && ((strcmp (libname, ex->string) == 0)
+ && ((filename_cmp (libname, ex->string) == 0)
|| (strcasecmp ("ALL", ex->string) == 0)))
return 0;
}
else if (ex->type == EXCLUDEFORIMPLIB)
{
- if (strcmp (abfd->filename, ex->string) == 0)
+ if (filename_cmp (bfd_get_filename (abfd), ex->string) == 0)
return 0;
}
else if (strcmp (n, ex->string) == 0)
}
static void
-process_def_file (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
+process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
{
int i, j;
+ unsigned int ui;
struct bfd_link_hash_entry *blhe;
bfd *b;
struct bfd_section *s;
def_file_export *e = 0;
+ bool resort_needed;
if (!pe_def_file)
pe_def_file = def_file_empty ();
/* 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 not building a DLL, when there are no exports
- we do not build an export table at all. */
- if (!pe_dll_export_everything && pe_def_file->num_exports == 0
- && info->executable)
+ /* Process aligned common symbol information from the
+ .drectve sections now; common symbol allocation is
+ done before final link, so it will be too late to
+ process them in process_embedded_commands() called
+ from _bfd_coff_link_input_bfd(). */
+ if (pe_def_file->aligncomms)
+ {
+ def_file_aligncomm *ac = pe_def_file->aligncomms;
+ while (ac)
+ {
+ struct coff_link_hash_entry *sym_hash;
+ sym_hash = coff_link_hash_lookup (coff_hash_table (info),
+ ac->symbol_name, false, false, false);
+ if (sym_hash && sym_hash->root.type == bfd_link_hash_common
+ && sym_hash->root.u.c.p->alignment_power < (unsigned) ac->alignment)
+ {
+ sym_hash->root.u.c.p->alignment_power = (unsigned) ac->alignment;
+ }
+ ac = ac->next;
+ }
+ }
+
+ if (pe_def_file->exclude_symbols)
+ {
+ for (ui = 0; ui < pe_def_file->num_exclude_symbols; ui++)
+ {
+ pe_dll_add_excludes (pe_def_file->exclude_symbols[ui].symbol_name,
+ EXCLUDESYMS);
+ }
+ }
+
+ /* If we are building an executable and there is nothing
+ to export, we do not build an export table at all. */
+ if (bfd_link_executable (info) && pe_def_file->num_exports == 0
+ && (!pe_dll_export_everything || pe_dll_exclude_all_symbols))
return;
/* Now, maybe export everything else the default way. */
- if (pe_dll_export_everything || pe_def_file->num_exports == 0)
+ 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;
if (!bfd_generic_link_read_symbols (b))
{
- einfo (_("%B%F: could not read symbols: %E\n"), b);
+ einfo (_("%F%P: %pB: could not read symbols: %E\n"), b);
return;
}
/* 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));
- if (lang_elf_version_info && would_export)
- {
- bfd_boolean hide = 0;
- char ofs = pe_details->underscored && symbols[j]->name[0] == '_';
- (void) bfd_find_version_for_sym (lang_elf_version_info,
- symbols[j]->name + ofs, &hide);
- would_export = !hide;
- }
+ bool 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,
+ symbols[j]->name);
if (would_export)
{
const char *sn = symbols[j]->name;
{
char *name;
if (is_import (sn))
- continue;
+ continue;
name = xmalloc (strlen ("__imp_") + strlen (sn) + 1);
sprintf (name, "%s%s", "__imp_", sn);
blhe = bfd_link_hash_lookup (info->hash, name,
- FALSE, FALSE, FALSE);
+ false, false, false);
free (name);
if (blhe && blhe->type == bfd_link_hash_defined)
if (auto_export (b, pe_def_file, sn))
{
+ bool is_dup = false;
def_file_export *p;
- p=def_file_add_export (pe_def_file, sn, 0, -1);
+
+ p = def_file_add_export (pe_def_file, sn, 0, -1,
+ NULL, &is_dup);
/* Fill data flag properly, from dlltool.c. */
- p->flag_data = !(symbols[j]->flags & BSF_FUNCTION);
+ if (!is_dup)
+ p->flag_data = !(symbols[j]->flags & BSF_FUNCTION);
}
}
}
#undef NE
#define NE pe_def_file->num_exports
+ /* Don't create an empty export table. */
+ if (NE == 0)
+ return;
+
+ resort_needed = false;
+
/* Canonicalize the export list. */
if (pe_dll_kill_ats)
{
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;
+ *tmp_at = 0;
else
- einfo (_("%XCannot export %s: invalid export name\n"),
+ einfo (_("%X%P: cannot export %s: invalid export name\n"),
pe_def_file->exports[i].name);
pe_def_file->exports[i].name = tmp;
+ resort_needed = true;
}
}
}
+ /* Re-sort the exports table as we have possibly changed the order
+ by removing leading @. */
+ if (resort_needed)
+ qsort (pe_def_file->exports, NE, sizeof (pe_def_file->exports[0]),
+ pe_export_sort);
+
if (pe_dll_stdcall_aliases)
{
for (i = 0; i < NE; i++)
if (strchr (pe_def_file->exports[i].name, '@'))
{
+ bool is_dup = true;
int lead_at = (*pe_def_file->exports[i].name == '@');
char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
if (auto_export (NULL, pe_def_file, tmp))
def_file_add_export (pe_def_file, tmp,
pe_def_file->exports[i].internal_name,
- -1);
- else
+ -1, NULL, &is_dup);
+ if (is_dup)
free (tmp);
}
}
/* Convenience, but watch out for it changing. */
e = pe_def_file->exports;
- exported_symbol_offsets = xmalloc (NE * sizeof (bfd_vma));
- exported_symbol_sections = xmalloc (NE * sizeof (struct bfd_section *));
-
- memset (exported_symbol_sections, 0, NE * sizeof (struct bfd_section *));
- max_ordinal = 0;
- min_ordinal = 65536;
- count_exported = 0;
- count_exported_byname = 0;
- count_with_ordinals = 0;
-
- qsort (pe_def_file->exports, NE, sizeof (pe_def_file->exports[0]),
- pe_export_sort);
for (i = 0, j = 0; i < NE; i++)
{
if (i > 0 && strcmp (e[i].name, e[i - 1].name) == 0)
{
if (pe_dll_warn_dup_exports)
/* xgettext:c-format */
- einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
+ einfo (_("%X%P: 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);
}
e[j - 1].flag_constant |= e[i].flag_constant;
e[j - 1].flag_noname |= e[i].flag_noname;
e[j - 1].flag_data |= e[i].flag_data;
+ free (e[i].name);
+ free (e[i].internal_name);
+ free (e[i].its_name);
}
else
{
}
pe_def_file->num_exports = j; /* == NE */
+ exported_symbol_offsets = xmalloc (NE * sizeof (bfd_vma));
+ exported_symbol_sections = xmalloc (NE * sizeof (struct bfd_section *));
+
+ memset (exported_symbol_sections, 0, NE * sizeof (struct bfd_section *));
+ max_ordinal = 0;
+ min_ordinal = 65536;
+ count_exported = 0;
+ count_exported_byname = 0;
+ count_with_ordinals = 0;
+
for (i = 0; i < NE; i++)
{
+ char *int_name = pe_def_file->exports[i].internal_name;
char *name;
- /* Check for forward exports */
- if (strchr (pe_def_file->exports[i].internal_name, '.'))
- {
- count_exported++;
- if (!pe_def_file->exports[i].flag_noname)
- count_exported_byname++;
-
- pe_def_file->exports[i].flag_forward = 1;
-
- if (pe_def_file->exports[i].ordinal != -1)
- {
- if (max_ordinal < pe_def_file->exports[i].ordinal)
- max_ordinal = pe_def_file->exports[i].ordinal;
- if (min_ordinal > pe_def_file->exports[i].ordinal)
- min_ordinal = pe_def_file->exports[i].ordinal;
- count_with_ordinals++;
- }
-
- continue;
- }
+ /* PR 19803: Make sure that any exported symbol does not get garbage collected. */
+ lang_add_gc_name (int_name);
- name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
- if (pe_details->underscored
- && (*pe_def_file->exports[i].internal_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,
- FALSE, FALSE, TRUE);
+ false, false, true);
if (blhe
&& (blhe->type == bfd_link_hash_defined
else
exported_symbol_sections[i] = blhe->u.c.p->section;
+ if (pe_def_file->exports[i].ordinal != -1)
+ {
+ if (max_ordinal < pe_def_file->exports[i].ordinal)
+ max_ordinal = pe_def_file->exports[i].ordinal;
+ if (min_ordinal > pe_def_file->exports[i].ordinal)
+ min_ordinal = pe_def_file->exports[i].ordinal;
+ count_with_ordinals++;
+ }
+ }
+ /* Check for forward exports. These are indicated in DEF files by an
+ export directive of the form NAME1 = MODULE-NAME.EXTERNAL-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 (int_name, '.'))
+ {
+ count_exported++;
+ if (!pe_def_file->exports[i].flag_noname)
+ count_exported_byname++;
+
+ pe_def_file->exports[i].flag_forward = 1;
+
if (pe_def_file->exports[i].ordinal != -1)
{
if (max_ordinal < pe_def_file->exports[i].ordinal)
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 (_("%X%P: 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 (_("%X%P: 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 (_("%X%P: cannot export %s: symbol not found\n"),
+ int_name);
}
free (name);
}
/* Build the bfd that will contain .edata and .reloc sections. */
static void
-build_filler_bfd (int include_edata)
+build_filler_bfd (bool include_edata)
{
lang_input_statement_type *filler_file;
+
filler_file = lang_add_input_file ("dll stuff",
lang_input_file_is_fake_enum,
NULL);
bfd_get_arch (link_info.output_bfd),
bfd_get_mach (link_info.output_bfd)))
{
- einfo ("%X%P: can not create BFD: %E\n");
+ einfo (_("%F%P: can not create BFD: %E\n"));
return;
}
{
edata_s = bfd_make_section_old_way (filler_bfd, ".edata");
if (edata_s == NULL
- || !bfd_set_section_flags (filler_bfd, edata_s,
- (SEC_HAS_CONTENTS
- | SEC_ALLOC
- | SEC_LOAD
- | SEC_KEEP
- | SEC_IN_MEMORY)))
+ || !bfd_set_section_flags (edata_s, (SEC_HAS_CONTENTS
+ | SEC_ALLOC
+ | SEC_LOAD
+ | SEC_KEEP
+ | SEC_IN_MEMORY)))
{
- einfo ("%X%P: can not create .edata section: %E\n");
+ einfo (_("%X%P: can not create .edata section: %E\n"));
return;
}
- bfd_set_section_size (filler_bfd, edata_s, edata_sz);
+ bfd_set_section_size (edata_s, edata_sz);
}
reloc_s = bfd_make_section_old_way (filler_bfd, ".reloc");
if (reloc_s == NULL
- || !bfd_set_section_flags (filler_bfd, reloc_s,
- (SEC_HAS_CONTENTS
- | SEC_ALLOC
- | SEC_LOAD
- | SEC_KEEP
- | SEC_IN_MEMORY)))
- {
- einfo ("%X%P: can not create .reloc section: %E\n");
+ || !bfd_set_section_flags (reloc_s, (SEC_HAS_CONTENTS
+ | SEC_ALLOC
+ | SEC_LOAD
+ | SEC_KEEP
+ | SEC_IN_MEMORY)))
+ {
+ einfo (_("%X%P: can not create .reloc section: %E\n"));
return;
}
- bfd_set_section_size (filler_bfd, reloc_s, 0);
+ bfd_set_section_size (reloc_s, 0);
+
+ /* FIXME: I am not sure if this is the right way to solve PR 29998.
+ It might be better to change ldlang.c:lang_statement_append() so that it
+ checks to see if *(list->tail) is non-NULL and if so, set element->next
+ to its contents.
+
+ The issue is that this function is called after lang_process().
+ lang_process () will have gone through any input archives, and if the
+ last input file is an archive then it will have left file_chain.tail
+ pointing to the last used element of that archive. Calling
+ ldlang_add_file() here then blows aaway the link to that archive element,
+ effectively deleting it from the input. In order to prevent this, the
+ assignment below fills in the next field of the statement that is about
+ to appended to the file chain. */
+ if (file_chain.tail != NULL)
+ filler_file->next = & (* file_chain.tail)->input_statement;
ldlang_add_file (filler_file);
}
/* Gather all the exported symbols and build the .edata section. */
static void
-generate_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
+generate_edata (void)
{
int i, next_ordinal;
int name_table_size = 0;
- const char *dlnp;
/* First, we need to know how many exported symbols there are,
and what the range of ordinals is. */
- if (pe_def_file->name)
- dll_name = pe_def_file->name;
- else
- {
- dll_name = abfd->filename;
-
- for (dlnp = dll_name; *dlnp; dlnp++)
- if (*dlnp == '\\' || *dlnp == '/' || *dlnp == ':')
- dll_name = dlnp + 1;
- }
-
if (count_with_ordinals && max_ordinal > count_exported)
{
if (min_ordinal > max_ordinal - count_exported + 1)
/* Now we need to assign ordinals to those that don't have them. */
for (i = 0; i < NE; i++)
{
- if (exported_symbol_sections[i] ||
- pe_def_file->exports[i].flag_forward)
+ if (exported_symbol_sections[i]
+ || pe_def_file->exports[i].flag_forward)
{
if (pe_def_file->exports[i].ordinal != -1)
{
if (pi != -1)
{
/* xgettext:c-format */
- einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
+ einfo (_("%X%P: 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);
}
exported_symbols[ei] = i;
}
- name_table_size += strlen (pe_def_file->exports[i].name) + 1;
+ if (pe_def_file->exports[i].its_name)
+ name_table_size += strlen (pe_def_file->exports[i].its_name) + 1;
+ else
+ name_table_size += strlen (pe_def_file->exports[i].name) + 1;
}
/* Reserve space for the forward name. */
next_ordinal = min_ordinal;
for (i = 0; i < NE; i++)
- if ((exported_symbol_sections[i] ||
- pe_def_file->exports[i].flag_forward) &&
- pe_def_file->exports[i].ordinal == -1)
+ if ((exported_symbol_sections[i]
+ || pe_def_file->exports[i].flag_forward)
+ && pe_def_file->exports[i].ordinal == -1)
{
while (exported_symbols[next_ordinal - min_ordinal] != -1)
next_ordinal++;
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(_("%X%P: 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 */
+ 4 * count_exported_byname /* name ptrs */
+ 2 * count_exported_byname /* ordinals */
- + name_table_size + strlen (dll_name) + 1);
+ + name_table_size + strlen (dll_filename) + 1);
}
/* Fill the exported symbol offsets. The preliminary work has already
- been done in process_def_file(). */
+ been done in process_def_file_and_drectve(). */
static void
fill_exported_offsets (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
if (pe_details->underscored
- && *pe_def_file->exports[i].internal_name != '@')
+ && *pe_def_file->exports[i].internal_name != '@')
{
*name = '_';
strcpy (name + 1, pe_def_file->exports[i].internal_name);
blhe = bfd_link_hash_lookup (info->hash,
name,
- FALSE, FALSE, TRUE);
+ false, false, true);
if (blhe && blhe->type == bfd_link_hash_defined)
exported_symbol_offsets[i] = blhe->u.def.value;
unsigned char *enameptrs;
unsigned char *eordinals;
char *enamestr;
- time_t now;
-
- time (&now);
edata_d = xmalloc (edata_sz);
/* Note use of array pointer math here. */
edirectory = edata_d;
- eaddresses = edata_d + 40;
+ eaddresses = edirectory + 40;
enameptrs = eaddresses + 4 * export_table_size;
eordinals = enameptrs + 4 * count_exported_byname;
enamestr = (char *) eordinals + 2 * count_exported_byname;
+ 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)->timestamp == -1)
+ H_PUT_32 (abfd, time (0), edata_d + 4);
+ else
+ H_PUT_32 (abfd, pe_data (abfd)->timestamp, edata_d + 4);
+
if (pe_def_file->version_major != -1)
{
bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8);
}
bfd_put_32 (abfd, ERVA (enamestr), edata_d + 12);
- strcpy (enamestr, dll_name);
+ strcpy (enamestr, dll_filename);
enamestr += strlen (enamestr) + 1;
bfd_put_32 (abfd, min_ordinal, edata_d + 16);
bfd_put_32 (abfd, export_table_size, edata_d + 20);
Scan alphabetically - ie the ordering in the exports[] table,
rather than by ordinal - the ordering in the exported_symbol[]
table. See dlltool.c and:
- http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
+ http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
for more information. */
hint = 0;
for (s = 0; s < NE; s++)
{
struct bfd_section *ssec = exported_symbol_sections[s];
- if (pe_def_file->exports[s].ordinal != -1 &&
- (pe_def_file->exports[s].flag_forward || ssec != NULL))
+ if (pe_def_file->exports[s].ordinal != -1
+ && (pe_def_file->exports[s].flag_forward || ssec != NULL))
{
int ord = pe_def_file->exports[s].ordinal;
if (pe_def_file->exports[s].flag_forward)
{
bfd_put_32 (abfd, ERVA (enamestr),
- eaddresses + 4 * (ord - min_ordinal));
+ eaddresses + 4 * (ord - min_ordinal));
strcpy (enamestr, pe_def_file->exports[s].internal_name);
enamestr += strlen (pe_def_file->exports[s].internal_name) + 1;
+ ssec->output_offset);
bfd_put_32 (abfd, srva - image_base,
- eaddresses + 4 * (ord - min_ordinal));
+ eaddresses + 4 * (ord - min_ordinal));
}
if (!pe_def_file->exports[s].flag_noname)
{
char *ename = pe_def_file->exports[s].name;
+ if (pe_def_file->exports[s].its_name)
+ ename = pe_def_file->exports[s].its_name;
bfd_put_32 (abfd, ERVA (enamestr), enameptrs);
enameptrs += 4;
static struct bfd_section *current_sec;
-void
-pe_walk_relocs_of_symbol (struct bfd_link_info *info,
- const char *name,
- int (*cb) (arelent *, asection *))
+static void
+pe_walk_relocs (struct bfd_link_info *info,
+ char *name,
+ const char *symname,
+ struct bfd_hash_table *import_hash,
+ void (*cb) (arelent *, asection *, char *, const 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;
- int nsyms;
if (!bfd_generic_link_read_symbols (b))
{
- einfo (_("%B%F: could not read symbols: %E\n"), b);
+ einfo (_("%F%P: %pB: could not read symbols: %E\n"), b);
return;
}
symbols = bfd_get_outsymbols (b);
- nsyms = bfd_get_symcount (b);
for (s = b->sections; s; s = s->next)
{
arelent **relocs;
int relsize, nrelocs, i;
- int flags = bfd_get_section_flags (b, s);
+ int flags = bfd_section_flags (s);
/* Skip discarded linkonce sections. */
if (flags & SEC_LINK_ONCE
{
struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
- if (!strcmp (name, sym->name))
- cb (relocs[i], s);
+ /* Warning: the callback needs to be passed NAME directly. */
+ if (import_hash)
+ {
+ if (bfd_hash_lookup (import_hash, sym->name, false, false))
+ {
+ strcpy (name, sym->name);
+ cb (relocs[i], s, name, symname);
+ }
+ }
+ else
+ {
+ if (strcmp (name, sym->name) == 0)
+ cb (relocs[i], s, name, symname);
+ }
}
free (relocs);
}
}
+void
+pe_find_data_imports (const char *symhead,
+ void (*cb) (arelent *, asection *, char *, const char *))
+{
+ struct bfd_link_hash_entry *undef;
+ const size_t headlen = strlen (symhead);
+ size_t namelen = 0;
+ char *buf, *name;
+ struct bfd_hash_table *import_hash;
+
+ for (undef = link_info.hash->undefs; undef; undef = undef->u.undef.next)
+ if (undef->type == bfd_link_hash_undefined)
+ {
+ size_t len = strlen (undef->root.string);
+ if (namelen < len)
+ namelen = len;
+ }
+ if (namelen == 0)
+ return;
+
+ /* For the pseudo-relocation support version 2, we can collect the symbols
+ that are subject to auto-import and adjust the relocations en masse. */
+ if (link_info.pei386_runtime_pseudo_reloc == 2)
+ {
+ import_hash
+ = (struct bfd_hash_table *) xmalloc (sizeof (struct bfd_hash_table));
+ if (!bfd_hash_table_init (import_hash,
+ bfd_hash_newfunc,
+ sizeof (struct bfd_hash_entry)))
+ einfo (_("%F%P: bfd_hash_table_init failed: %E\n"));
+ }
+ else
+ import_hash = NULL;
+
+ /* We are being a bit cunning here. The buffer will have space for
+ prefixes at the beginning. The prefix is modified here and in a
+ number of functions called from this function. */
+#define PREFIX_LEN 32
+ buf = xmalloc (PREFIX_LEN + namelen + 1);
+ name = buf + PREFIX_LEN;
+
+ for (undef = link_info.hash->undefs; undef; undef = undef->u.undef.next)
+ if (undef->type == bfd_link_hash_undefined)
+ {
+ struct bfd_link_hash_entry *sym;
+ char *impname;
+
+ if (pe_dll_extra_pe_debug)
+ printf ("%s:%s\n", __func__, undef->root.string);
+
+ strcpy (name, undef->root.string);
+ impname = name - (sizeof "__imp_" - 1);
+ memcpy (impname, "__imp_", sizeof "__imp_" - 1);
+
+ sym = bfd_link_hash_lookup (link_info.hash, impname, 0, 0, 1);
+
+ if (sym && sym->type == bfd_link_hash_defined)
+ {
+ if (import_hash)
+ bfd_hash_lookup (import_hash, undef->root.string, true, false);
+ else
+ {
+ bfd *b = sym->u.def.section->owner;
+ const char *symname = NULL;
+ asymbol **symbols;
+ int nsyms, i;
+
+ if (!bfd_generic_link_read_symbols (b))
+ {
+ einfo (_("%F%P: %pB: could not read symbols: %E\n"), b);
+ return;
+ }
+
+ symbols = bfd_get_outsymbols (b);
+ nsyms = bfd_get_symcount (b);
+
+ for (i = 0; i < nsyms; i++)
+ if (strncmp (symbols[i]->name, symhead, headlen) == 0)
+ {
+ if (pe_dll_extra_pe_debug)
+ printf ("->%s\n", symbols[i]->name);
+
+ symname = symbols[i]->name + headlen;
+ break;
+ }
+
+ /* If the symobl isn't part of an import table, there is no
+ point in building a fixup, this would give rise to link
+ errors for mangled symbols instead of the original one. */
+ if (symname)
+ pe_walk_relocs (&link_info, name, symname, NULL, cb);
+ else
+ continue;
+ }
+
+ /* Let's differentiate it somehow from defined. */
+ undef->type = bfd_link_hash_defweak;
+ undef->u.def.value = sym->u.def.value;
+ undef->u.def.section = sym->u.def.section;
+
+ /* We replace the original name with the __imp_ prefixed one, this
+ 1) may trash memory 2) leads to duplicate symbols. But this is
+ better than having a misleading name that can confuse GDB. */
+ undef->root.string = sym->root.string;
+
+ if (link_info.pei386_auto_import == -1)
+ {
+ static bool warned = false;
+
+ info_msg (_("Info: resolving %s by linking to %s "
+ "(auto-import)\n"), name, impname);
+
+ /* PR linker/4844. */
+ if (!warned)
+ {
+ einfo (_("%P: warning: auto-importing has been activated "
+ "without --enable-auto-import specified on the "
+ "command line; this should work unless it "
+ "involves constant data structures referencing "
+ "symbols from auto-imported DLLs\n"));
+ warned = true;
+ }
+ }
+ }
+ }
+
+ /* If we have the import hash table, walk the relocations only once. */
+ if (import_hash)
+ {
+ pe_walk_relocs (&link_info, name, NULL, import_hash, cb);
+ bfd_hash_table_free (import_hash);
+ free (import_hash);
+ }
+
+ free (buf);
+}
+
/* Gather all the relocations and build the .reloc section. */
static void
generate_reloc (bfd *abfd, struct bfd_link_info *info)
{
-
/* For .reloc stuff. */
reloc_data_type *reloc_data;
int total_relocs = 0;
int i;
bfd_vma sec_page = (bfd_vma) -1;
- bfd_vma page_ptr, page_count;
- int bi;
+ bfd_vma page_ptr;
bfd *b;
struct bfd_section *s;
+ if (reloc_s == NULL || reloc_s->output_section == bfd_abs_section_ptr)
+ return;
+
+ /* Set an upper bound for the total number of relocations we will have to generate. */
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;
reloc_data = xmalloc (total_relocs * sizeof (reloc_data_type));
total_relocs = 0;
- bi = 0;
- for (bi = 0, b = info->input_bfds; b; bi++, b = b->link_next)
+ for (b = info->input_bfds; b; b = b->link.next)
{
arelent **relocs;
- int relsize, nrelocs, i;
+ int relsize, nrelocs;
+ asymbol **symbols;
+
+ if (!bfd_generic_link_read_symbols (b))
+ {
+ einfo (_("%F%P: %pB: could not read symbols: %E\n"), b);
+ return;
+ }
+
+ symbols = bfd_get_outsymbols (b);
for (s = b->sections; s; s = s->next)
{
- bfd_vma sec_vma = s->output_section->vma + s->output_offset;
- asymbol **symbols;
- int nsyms;
+ bfd_vma sec_vma;
- /* If it's not loaded, we don't need to relocate it this way. */
- if (!(s->output_section->flags & SEC_LOAD))
- continue;
+ /* If the section is not going to be output, then ignore it. */
+ if (s->output_section == NULL)
+ {
+ /* FIXME: This should not happen. Convert to the correct
+ form here, but really, this should be investigated. */
+ s->output_section = bfd_abs_section_ptr;
+ continue;
+ }
/* 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 it's not loaded, we don't need to relocate it this way. */
+ if (!(s->output_section->flags & SEC_LOAD))
continue;
+ /* This happens when linking with --just-symbols=<file>
+ so do not generate an error. */
if (s->output_section->vma == 0)
- {
- /* Huh? Shouldn't happen, but punt if it does. */
- einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
- s->output_section->name, s->output_section->index,
- s->output_section->flags);
- continue;
- }
+ continue;
- if (!bfd_generic_link_read_symbols (b))
- {
- einfo (_("%B%F: could not read symbols: %E\n"), b);
- return;
- }
+ sec_vma = s->output_section->vma + s->output_offset;
- symbols = bfd_get_outsymbols (b);
- nsyms = bfd_get_symcount (b);
relsize = bfd_get_reloc_upper_bound (b, s);
relocs = xmalloc (relsize);
nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
if (!relocs[i]->howto->pc_relative
&& relocs[i]->howto->type != pe_details->imagebase_reloc)
{
- bfd_vma sym_vma;
struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
+ const struct bfd_link_hash_entry *blhe
+ = bfd_wrapped_link_hash_lookup (abfd, info, sym->name,
+ false, false, false);
- /* Don't create relocs for undefined weak symbols. */
+ /* Don't create relocs for undefined weak symbols. */
if (sym->flags == BSF_WEAK)
{
- struct bfd_link_hash_entry *blhe
- = bfd_link_hash_lookup (info->hash, sym->name,
- FALSE, FALSE, FALSE);
- if (!blhe || blhe->type != bfd_link_hash_defined)
- continue;
+ if (blhe && blhe->type == bfd_link_hash_undefweak)
+ {
+ /* Check aux sym and see if it is defined or not. */
+ struct coff_link_hash_entry *h, *h2;
+ h = (struct coff_link_hash_entry *)blhe;
+ if (h->symbol_class != C_NT_WEAK || h->numaux != 1)
+ continue;
+ h2 = h->auxbfd->tdata.coff_obj_data->sym_hashes
+ [h->aux->x_sym.x_tagndx.l];
+ /* We don't want a base reloc if the aux sym is not
+ found, undefined, or if it is the constant ABS
+ zero default value. (We broaden that slightly by
+ not testing the value, just the section; there's
+ 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_ptr)
+ continue;
+ }
+ else if (!blhe || blhe->type != bfd_link_hash_defined)
+ continue;
+ }
+ /* Nor for Dwarf FDE references to discarded sections. */
+ else if (bfd_is_abs_section (sym->section->output_section))
+ {
+ /* We only ignore relocs from .eh_frame sections, as
+ they are discarded by the final link rather than
+ resolved against the kept section. */
+ if (!strcmp (s->name, ".eh_frame"))
+ continue;
}
+ /* Nor for absolute symbols. */
+ else if (blhe && ldexp_is_final_sym_absolute (blhe)
+ && (!blhe->linker_def
+ || (strcmp (sym->name, "__image_base__")
+ && strcmp (sym->name, U ("__ImageBase")))))
+ continue;
- sym_vma = (relocs[i]->addend
- + sym->value
- + sym->section->vma
- + sym->section->output_offset
- + sym->section->output_section->vma);
reloc_data[total_relocs].vma = sec_vma + relocs[i]->address;
+ reloc_data[total_relocs].idx = total_relocs;
+
+ /* Since we're only about to determine .reloc's size,
+ subsequent output section VMA calculations will shift up
+ sections at this or higher addresses. Relocations for
+ such sections would hence end up not being correct. */
+ if (reloc_data[total_relocs].vma
+ >= reloc_s->output_section->vma)
+ einfo (_("%P: base relocation for section `%s' above "
+ ".reloc section\n"), s->output_section->name);
#define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
switch BITS_AND_SHIFT (relocs[i]->howto->bitsize,
relocs[i]->howto->rightshift)
{
-#ifdef pe_use_x86_64
+#ifdef pe_use_plus
case BITS_AND_SHIFT (64, 0):
- reloc_data[total_relocs].type = 10;
+ reloc_data[total_relocs].type = IMAGE_REL_BASED_DIR64;
total_relocs++;
break;
#endif
case BITS_AND_SHIFT (32, 0):
- reloc_data[total_relocs].type = 3;
+ reloc_data[total_relocs].type = IMAGE_REL_BASED_HIGHLOW;
total_relocs++;
break;
case BITS_AND_SHIFT (16, 0):
- reloc_data[total_relocs].type = 2;
+ reloc_data[total_relocs].type = IMAGE_REL_BASED_LOW;
total_relocs++;
break;
case BITS_AND_SHIFT (16, 16):
- reloc_data[total_relocs].type = 4;
+ reloc_data[total_relocs].type = IMAGE_REL_BASED_HIGHADJ;
/* FIXME: we can't know the symbol's right value
yet, but we probably can safely assume that
CE will relocate us in 64k blocks, so leaving
total_relocs++;
break;
case BITS_AND_SHIFT (26, 2):
- reloc_data[total_relocs].type = 5;
+ reloc_data[total_relocs].type =
+ IMAGE_REL_BASED_ARM_MOV32;
total_relocs++;
break;
case BITS_AND_SHIFT (24, 2):
/* Fall through. */
default:
/* xgettext:c-format */
- einfo (_("%XError: %d-bit reloc in dll\n"),
+ einfo (_("%X%P: error: %d-bit reloc in dll\n"),
relocs[i]->howto->bitsize);
break;
}
}
}
+
free (relocs);
/* Warning: the allocated symbols are remembered in BFD and
reused later, so don't free them! */
}
}
+ /* This can happen for example when LTO has eliminated all code. */
+ if (total_relocs == 0)
+ return;
+
/* At this point, we have total_relocs relocation addresses in
reloc_addresses, which are all suitable for the .reloc section.
We must now create the new sections. */
reloc_sz += 2;
- if (reloc_data[i].type == 4)
+ if (reloc_data[i].type == IMAGE_REL_BASED_HIGHADJ)
reloc_sz += 2;
}
reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
reloc_d = xmalloc (reloc_sz);
- sec_page = (bfd_vma) -1;
+
+ page_ptr = sec_page = (bfd_vma) -1;
reloc_sz = 0;
- page_ptr = (bfd_vma) -1;
- page_count = 0;
for (i = 0; i < total_relocs; i++)
{
page_ptr = reloc_sz;
reloc_sz += 8;
sec_page = this_page;
- page_count = 0;
}
bfd_put_16 (abfd, (rva & 0xfff) + (reloc_data[i].type << 12),
reloc_d + reloc_sz);
reloc_sz += 2;
- if (reloc_data[i].type == 4)
+ if (reloc_data[i].type == IMAGE_REL_BASED_HIGHADJ)
{
bfd_put_16 (abfd, reloc_data[i].extra, reloc_d + reloc_sz);
reloc_sz += 2;
}
-
- page_count++;
}
while (reloc_sz & 3)
if (page_ptr != (bfd_vma) -1)
bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
-
- while (reloc_sz < reloc_s->size)
- reloc_d[reloc_sz++] = 0;
}
/* Given the exiting def_file structure, print out a .DEF file that
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)
{
quoteput (pe_def_file->name, out, 1);
if (pe_data (link_info.output_bfd)->pe_opthdr.ImageBase)
- {
- fprintf (out, " BASE=0x");
- fprintf_vma (out, ((bfd_vma) pe_data (link_info.output_bfd)->pe_opthdr.ImageBase));
- }
+ fprintf (out, " BASE=0x%" PRIx64,
+ (uint64_t) pe_data (link_info.output_bfd)->pe_opthdr.ImageBase);
fprintf (out, "\n");
}
else
fprintf (out, "%d", im->ordinal);
+ if (im->its_name)
+ {
+ fprintf (out, " == ");
+ quoteput (im->its_name, out, 0);
+ }
+
fprintf (out, "\n");
}
}
if (fclose (out) == EOF)
/* xgettext:c-format */
- einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename);
+ einfo (_("%P: error closing file `%s'\n"), pe_out_def_filename);
}
/* Generate the import library. */
static asymbol **symtab;
static int symptr;
static int tmp_seq;
-static int tmp_seq2;
-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)
asymbol *sym;
sec = bfd_make_section_old_way (abfd, name);
- bfd_set_section_flags (abfd, sec, flags | SEC_ALLOC | SEC_LOAD | SEC_KEEP);
- bfd_set_section_alignment (abfd, sec, align);
+ bfd_set_section_flags (sec, flags | SEC_ALLOC | SEC_LOAD | SEC_KEEP);
+ bfd_set_section_alignment (sec, align);
/* Remember to undo this before trying to link internally! */
sec->output_section = sec;
}
/* .section .idata$2
- .global __head_my_dll
+ .global __head_my_dll
__head_my_dll:
- .rva hname
- .long 0
- .long 0
- .rva __my_dll_iname
- .rva fthunk
-
- .section .idata$5
- .long 0
+ .rva hname
+ .long 0
+ .long 0
+ .rva __my_dll_iname
+ .rva fthunk
+
+ .section .idata$5
+ .long 0
fthunk:
- .section .idata$4
- .long 0
+ .section .idata$4
+ .long 0
hname: */
static bfd *
char *oname;
bfd *abfd;
- oname = xmalloc (20);
- sprintf (oname, "d%06d.o", tmp_seq);
+ if (asprintf (&oname, "%s_d%06d.o", dll_symname, tmp_seq) < 4)
+ /* In theory we should return NULL here at let our caller decide what to
+ do. But currently the return value is not checked, just used, and
+ besides, this condition only happens when the system has run out of
+ memory. So just give up. */
+ exit (EXIT_FAILURE);
tmp_seq++;
abfd = bfd_create (oname, parent);
pointer to the list points to the *end* of this section, which is
the start of the list of sections from other objects. */
- bfd_set_section_size (abfd, id2, 20);
+ bfd_set_section_size (id2, 20);
d2 = xmalloc (20);
id2->contents = d2;
memset (d2, 0, 20);
save_relocs (id2);
if (pe_use_nul_prefixed_import_tables)
- bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
+ bfd_set_section_size (id5, PE_IDATA5_SIZE);
else
- bfd_set_section_size (abfd, id5, 0);
+ bfd_set_section_size (id5, 0);
d5 = xmalloc (PE_IDATA5_SIZE);
id5->contents = d5;
memset (d5, 0, PE_IDATA5_SIZE);
if (pe_use_nul_prefixed_import_tables)
- bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
+ bfd_set_section_size (id4, PE_IDATA4_SIZE);
else
- bfd_set_section_size (abfd, id4, 0);
+ bfd_set_section_size (id4, 0);
d4 = xmalloc (PE_IDATA4_SIZE);
id4->contents = d4;
memset (d4, 0, PE_IDATA4_SIZE);
}
/* .section .idata$4
- .long 0
+ .long 0
[.long 0] for PE+
- .section .idata$5
- .long 0
+ .section .idata$5
+ .long 0
[.long 0] for PE+
- .section idata$7
- .global __my_dll_iname
+ .section idata$7
+ .global __my_dll_iname
__my_dll_iname:
- .asciz "my.dll" */
+ .asciz "my.dll" */
static bfd *
make_tail (bfd *parent)
char *oname;
bfd *abfd;
- oname = xmalloc (20);
- sprintf (oname, "d%06d.o", tmp_seq);
+ if (asprintf (&oname, "%s_d%06d.o", dll_symname, tmp_seq) < 4)
+ /* In theory we should return NULL here at let our caller decide what to
+ do. But currently the return value is not checked, just used, and
+ besides, this condition only happens when the system has run out of
+ memory. So just give up. */
+ exit (EXIT_FAILURE);
tmp_seq++;
abfd = bfd_create (oname, parent);
id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
quick_symbol (abfd, U (""), dll_symname, "_iname", id7, BSF_GLOBAL, 0);
- bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
+ bfd_set_section_size (id4, PE_IDATA4_SIZE);
d4 = xmalloc (PE_IDATA4_SIZE);
id4->contents = d4;
memset (d4, 0, PE_IDATA4_SIZE);
- bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
+ bfd_set_section_size (id5, PE_IDATA5_SIZE);
d5 = xmalloc (PE_IDATA5_SIZE);
id5->contents = d5;
memset (d5, 0, PE_IDATA5_SIZE);
len = strlen (dll_filename) + 1;
if (len & 1)
len++;
- bfd_set_section_size (abfd, id7, len);
+ bfd_set_section_size (id7, len);
d7 = xmalloc (len);
id7->contents = d7;
strcpy ((char *) d7, dll_filename);
}
/* .text
- .global _function
- .global ___imp_function
- .global __imp__function
+ .global _function
+ .global ___imp_function
+ .global __imp__function
_function:
- jmp *__imp__function:
+ jmp *__imp__function:
- .section idata$7
- .long __head_my_dll
+ .section idata$7
+ .long __head_my_dll
- .section .idata$5
+ .section .idata$5
___imp_function:
__imp__function:
iat?
- .section .idata$4
+ .section .idata$4
iat?
- .section .idata$6
+ .section .idata$6
ID<ordinal>:
- .short <hint>
- .asciz "function" xlate? (add underscore, kill at) */
+ .short <hint>
+ .asciz "function" xlate? (add underscore, kill at) */
static const unsigned char jmp_ix86_bytes[] =
{
0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
};
+static const unsigned char jmp_aarch64_bytes[] =
+{
+ 0x10, 0x00, 0x00, 0x90, /* adrp x16, 0 */
+ 0x10, 0x02, 0x00, 0x91, /* add x16, x16, #0x0 */
+ 0x10, 0x02, 0x40, 0xf9, /* ldr x16, [x16] */
+ 0x00, 0x02, 0x1f, 0xd6 /* br x16 */
+};
+
/* _function:
- mov.l ip+8,r0
- mov.l @r0,r0
- jmp @r0
- nop
- .dw __imp_function */
+ mov.l ip+8,r0
+ mov.l @r0,r0
+ jmp @r0
+ nop
+ .dw __imp_function */
static const unsigned char jmp_sh_bytes[] =
{
};
/* _function:
- lui $t0,<high:__imp_function>
- lw $t0,<low:__imp_function>
- jr $t0
- nop */
+ lui $t0,<high:__imp_function>
+ lw $t0,<low:__imp_function>
+ jr $t0
+ nop */
static const unsigned char jmp_mips_bytes[] =
{
static bfd *
-make_one (def_file_export *exp, bfd *parent, bfd_boolean include_jmp_stub)
+make_one (def_file_export *exp, bfd *parent, bool include_jmp_stub)
{
asection *tx, *id7, *id5, *id4, *id6;
unsigned char *td = NULL, *d7, *d5, *d4, *d6 = NULL;
jmp_byte_count = sizeof (jmp_mips_bytes);
break;
case PE_ARCH_arm:
- case PE_ARCH_arm_epoc:
case PE_ARCH_arm_wince:
jmp_bytes = jmp_arm_bytes;
jmp_byte_count = sizeof (jmp_arm_bytes);
break;
+ case PE_ARCH_aarch64:
+ jmp_bytes = jmp_aarch64_bytes;
+ jmp_byte_count = sizeof (jmp_aarch64_bytes);
+ break;
default:
abort ();
}
}
- oname = xmalloc (20);
- sprintf (oname, "d%06d.o", tmp_seq);
+ if (asprintf (&oname, "%s_d%06d.o", dll_symname, tmp_seq) < 4)
+ /* In theory we should return NULL here at let our caller decide what to
+ do. But currently the return value is not checked, just used, and
+ besides, this condition only happens when the system has run out of
+ memory. So just give up. */
+ exit (EXIT_FAILURE);
tmp_seq++;
abfd = bfd_create (oname, parent);
bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
symptr = 0;
- symtab = xmalloc (11 * sizeof (asymbol *));
- tx = quick_section (abfd, ".text", SEC_CODE|SEC_HAS_CONTENTS, 2);
+ symtab = xmalloc (12 * sizeof (asymbol *));
+
+ tx = quick_section (abfd, ".text", SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY, 2);
id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
/* Symbol to reference ord/name of imported
data symbol, used to implement auto-import. */
if (exp->flag_data)
- quick_symbol (abfd, U ("_nm_"), U (""), exp->internal_name, id6,
+ quick_symbol (abfd, "__nm_", U (""), exp->internal_name, id6,
BSF_GLOBAL,0);
}
if (pe_dll_compat_implib)
- quick_symbol (abfd, U ("__imp_"), exp->internal_name, "", id5,
+ quick_symbol (abfd, "___imp_", exp->internal_name, "", id5,
BSF_GLOBAL, 0);
if (include_jmp_stub)
{
- bfd_set_section_size (abfd, tx, jmp_byte_count);
+ bfd_set_section_size (tx, jmp_byte_count);
td = xmalloc (jmp_byte_count);
tx->contents = td;
memcpy (td, jmp_bytes, jmp_byte_count);
switch (pe_details->pe_arch)
{
case PE_ARCH_i386:
-#ifdef pe_use_x86_64
+#ifdef pe_use_plus
quick_reloc (abfd, 2, BFD_RELOC_32_PCREL, 2);
#else
- quick_reloc (abfd, 2, BFD_RELOC_32, 2);
+ /* Mark this object as SAFESEH compatible. */
+ quick_symbol (abfd, "", "@feat.00", "", bfd_abs_section_ptr,
+ BSF_LOCAL, 1);
+ quick_reloc (abfd, 2, BFD_RELOC_32, 2);
#endif
break;
case PE_ARCH_sh:
quick_reloc (abfd, 4, BFD_RELOC_LO16, 2);
break;
case PE_ARCH_arm:
- case PE_ARCH_arm_epoc:
- case PE_ARCH_arm_wince:
+ case PE_ARCH_arm_wince:
quick_reloc (abfd, 8, BFD_RELOC_32, 2);
break;
+ case PE_ARCH_aarch64:
+ quick_reloc (abfd, 0, BFD_RELOC_AARCH64_ADR_HI21_NC_PCREL, 2);
+ quick_reloc (abfd, 4, BFD_RELOC_AARCH64_ADD_LO12, 2);
+ break;
default:
abort ();
}
save_relocs (tx);
}
else
- bfd_set_section_size (abfd, tx, 0);
+ bfd_set_section_size (tx, 0);
- bfd_set_section_size (abfd, id7, 4);
+ bfd_set_section_size (id7, 4);
d7 = xmalloc (4);
id7->contents = d7;
memset (d7, 0, 4);
quick_reloc (abfd, 0, BFD_RELOC_RVA, 5);
save_relocs (id7);
- bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
+ bfd_set_section_size (id5, PE_IDATA5_SIZE);
d5 = xmalloc (PE_IDATA5_SIZE);
id5->contents = d5;
memset (d5, 0, PE_IDATA5_SIZE);
save_relocs (id5);
}
- bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
+ bfd_set_section_size (id4, PE_IDATA4_SIZE);
d4 = xmalloc (PE_IDATA4_SIZE);
id4->contents = d4;
memset (d4, 0, PE_IDATA4_SIZE);
if (exp->flag_noname)
{
len = 0;
- bfd_set_section_size (abfd, id6, 0);
+ bfd_set_section_size (id6, 0);
}
else
{
+ int ord;
+
/* { short, asciz } */
- len = 2 + strlen (exp->name) + 1;
+ if (exp->its_name)
+ len = 2 + strlen (exp->its_name) + 1;
+ else
+ len = 2 + strlen (exp->name) + 1;
if (len & 1)
len++;
- bfd_set_section_size (abfd, id6, len);
+ bfd_set_section_size (id6, len);
d6 = xmalloc (len);
id6->contents = d6;
memset (d6, 0, len);
- d6[0] = exp->hint & 0xff;
- d6[1] = exp->hint >> 8;
- strcpy ((char *) d6 + 2, exp->name);
+
+ /* 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
+ strcpy ((char *) d6 + 2, exp->name);
}
bfd_set_symtab (abfd, symtab, symptr);
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)
{
char *oname;
bfd *abfd;
- oname = xmalloc (20);
- sprintf (oname, "nmth%06d.o", tmp_seq);
+ if (asprintf (&oname, "%s_nmth%06d.o", dll_symname, tmp_seq) < 4)
+ /* In theory we should return NULL here at let our caller decide what to
+ do. But currently the return value is not checked, just used, and
+ besides, this condition only happens when the system has run out of
+ memory. So just give up. */
+ exit (EXIT_FAILURE);
tmp_seq++;
abfd = bfd_create (oname, parent);
symptr = 0;
symtab = xmalloc (3 * sizeof (asymbol *));
id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
- quick_symbol (abfd, U ("_nm_thnk_"), import, "", id4, BSF_GLOBAL, 0);
- quick_symbol (abfd, U ("_nm_"), import, "", UNDSEC, BSF_GLOBAL, 0);
+ quick_symbol (abfd, "__nm_thnk_", import, "", id4, BSF_GLOBAL, 0);
+ quick_symbol (abfd, "__nm_", import, "", UNDSEC, BSF_GLOBAL, 0);
/* We need space for the real thunk and for the null terminator. */
- bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE * 2);
+ bfd_set_section_size (id4, PE_IDATA4_SIZE * 2);
d4 = xmalloc (PE_IDATA4_SIZE * 2);
id4->contents = d4;
memset (d4, 0, PE_IDATA4_SIZE * 2);
return abfd;
}
-static char *
-make_import_fixup_mark (arelent *rel)
+static const char *
+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[256];
+ 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,
current_sec, /* sym->section, */
- rel->address, NULL, TRUE, FALSE, &bh);
+ rel->address, NULL, true, false, &bh);
- return fixup_name;
+ return bh->root.string;
}
/* .section .idata$2
- .rva __nm_thnk_SYM (singleton thunk with name of func)
- .long 0
- .long 0
- .rva __my_dll_iname (name of dll)
- .rva __fuNN_SYM (pointer to reference (address) in text) */
+ .rva __nm_thnk_SYM (singleton thunk with name of func)
+ .long 0
+ .long 0
+ .rva __my_dll_iname (name of dll)
+ .rva __fuNN_SYM (pointer to reference (address) in text) */
static bfd *
make_import_fixup_entry (const char *name,
const char *fixup_name,
- const char *dll_symname,
+ const char *symname,
bfd *parent)
{
asection *id2;
char *oname;
bfd *abfd;
- oname = xmalloc (20);
- sprintf (oname, "fu%06d.o", tmp_seq);
+ if (asprintf (&oname, "%s_fu%06d.o", dll_symname, tmp_seq) < 4)
+ /* In theory we should return NULL here at let our caller decide what to
+ do. But currently the return value is not checked, just used, and
+ besides, this condition only happens when the system has run out of
+ memory. So just give up. */
+ exit (EXIT_FAILURE);
tmp_seq++;
abfd = bfd_create (oname, parent);
symtab = xmalloc (6 * sizeof (asymbol *));
id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
- quick_symbol (abfd, U ("_nm_thnk_"), name, "", UNDSEC, BSF_GLOBAL, 0);
- quick_symbol (abfd, U (""), dll_symname, "_iname", 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);
+ quick_symbol (abfd, "__nm_thnk_", name, "", UNDSEC, BSF_GLOBAL, 0);
+ quick_symbol (abfd, U (""), symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
+ quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
- bfd_set_section_size (abfd, id2, 20);
+ bfd_set_section_size (id2, 20);
d2 = xmalloc (20);
id2->contents = d2;
memset (d2, 0, 20);
}
/* .section .rdata_runtime_pseudo_reloc
- .long addend
- .rva __fuNN_SYM (pointer to reference (address) in text) */
+ .long addend
+ .rva __fuNN_SYM (pointer to reference (address) in text) */
static bfd *
make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED,
unsigned char *rt_rel_d;
char *oname;
bfd *abfd;
- oname = xmalloc (20);
- sprintf (oname, "rtr%06d.o", tmp_seq);
+ bfd_size_type size;
+
+ if (asprintf (&oname, "%s_rtr%06d.o", dll_symname, tmp_seq) < 4)
+ /* In theory we should return NULL here at let our caller decide what to
+ do. But currently the return value is not checked, just used, and
+ besides, this condition only happens when the system has run out of
+ memory. So just give up. */
+ exit (EXIT_FAILURE);
tmp_seq++;
abfd = bfd_create (oname, parent);
bfd_set_format (abfd, bfd_object);
bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
- symptr = 0;
if (link_info.pei386_runtime_pseudo_reloc == 2)
{
- symtab = xmalloc ((runtime_pseudp_reloc_v2_init ? 3 : 6) * sizeof (asymbol *));
+ if (runtime_pseudp_reloc_v2_init)
+ size = 3 * sizeof (asymbol *);
+ else
+ size = 6 * sizeof (asymbol *);
}
else
- {
- symtab = xmalloc (2 * sizeof (asymbol *));
- }
- rt_rel = quick_section (abfd, ".rdata_runtime_pseudo_reloc",
- SEC_HAS_CONTENTS, 2);
+ size = 2 * sizeof (asymbol *);
+
+ symptr = 0;
+ symtab = xmalloc (size);
+
+ rt_rel
+ = quick_section (abfd, ".rdata_runtime_pseudo_reloc", SEC_HAS_CONTENTS, 2);
quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
if (link_info.pei386_runtime_pseudo_reloc == 2)
{
- size_t size = 12;
- if (! runtime_pseudp_reloc_v2_init)
- {
- size += 12;
- runtime_pseudp_reloc_v2_init = 1;
- }
- quick_symbol (abfd, U ("_imp_"), name, "", UNDSEC, BSF_GLOBAL, 0);
+ size = 12;
+ if (!runtime_pseudp_reloc_v2_init)
+ {
+ size += 12;
+ runtime_pseudp_reloc_v2_init = true;
+ }
+
+ quick_symbol (abfd, "__imp_", name, "", UNDSEC, BSF_GLOBAL, 0);
- bfd_set_section_size (abfd, rt_rel, size);
+ bfd_set_section_size (rt_rel, size);
rt_rel_d = xmalloc (size);
rt_rel->contents = rt_rel_d;
memset (rt_rel_d, 0, size);
- quick_reloc (abfd, size - 8, BFD_RELOC_RVA, 1);
- quick_reloc (abfd, size - 12, BFD_RELOC_RVA, 2);
- bfd_put_32 (abfd, bitsize, rt_rel_d + (size - 4));
- if (size != 12)
- bfd_put_32 (abfd, 1, rt_rel_d + 8);
+ quick_reloc (abfd, size - 8, BFD_RELOC_RVA, 1);
+ quick_reloc (abfd, size - 12, BFD_RELOC_RVA, 2);
+ bfd_put_32 (abfd, bitsize, rt_rel_d + (size - 4));
+ if (size != 12)
+ bfd_put_32 (abfd, 1, rt_rel_d + 8);
save_relocs (rt_rel);
bfd_set_symtab (abfd, symtab, symptr);
bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, size);
- }
+ }
else
- {
- bfd_set_section_size (abfd, rt_rel, 8);
+ {
+ bfd_set_section_size (rt_rel, 8);
rt_rel_d = xmalloc (8);
rt_rel->contents = rt_rel_d;
memset (rt_rel_d, 0, 8);
bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, 8);
}
+
bfd_make_readable (abfd);
return abfd;
}
/* .section .rdata
- .rva __pei386_runtime_relocator */
+ .rva __pei386_runtime_relocator */
static bfd *
pe_create_runtime_relocator_reference (bfd *parent)
char *oname;
bfd *abfd;
- oname = xmalloc (20);
- sprintf (oname, "ertr%06d.o", tmp_seq);
+ if (asprintf (&oname, "%s_ertr%06d.o", dll_symname, tmp_seq) < 4)
+ /* In theory we should return NULL here at let our caller decide what to
+ do. But currently the return value is not checked, just used, and
+ besides, this condition only happens when the system has run out of
+ memory. So just give up. */
+ exit (EXIT_FAILURE);
tmp_seq++;
abfd = bfd_create (oname, parent);
quick_symbol (abfd, "", U ("_pei386_runtime_relocator"), "", UNDSEC,
BSF_NO_FLAGS, 0);
- bfd_set_section_size (abfd, extern_rt_rel, PE_IDATA5_SIZE);
- extern_rt_rel_d = xmalloc (PE_IDATA5_SIZE);
+ bfd_set_section_size (extern_rt_rel, 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,
+ const char *symname)
{
- 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);
+ const char *fixup_name = make_import_fixup_mark (rel, name);
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);
-
- /* 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.
- 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)
- && need_import_table == 1)
+ /* This is the original implementation of the auto-import feature, which
+ primarily relied on the OS loader to patch things up with some help
+ from the pseudo-relocator to overcome the main limitation. See the
+ comment at the beginning of the file for an overview of the feature. */
+ if (link_info.pei386_runtime_pseudo_reloc != 2)
{
- extern char * pe_data_import_dll;
- char * dll_symname = pe_data_import_dll ? pe_data_import_dll : "unknown";
+ struct bfd_link_hash_entry *name_thunk_sym;
+ /* name buffer is allocated with space at beginning for prefixes. */
+ char *thname = name - (sizeof "__nm_thnk_" - 1);
+ memcpy (thname, "__nm_thnk_", sizeof "__nm_thnk_" - 1);
+ name_thunk_sym = bfd_link_hash_lookup (link_info.hash, thname, 0, 0, 1);
- b = make_import_fixup_entry (name, fixup_name, dll_symname,
- link_info.output_bfd);
- add_bfd_to_link (b, b->filename, &link_info);
- }
+ if (!(name_thunk_sym && name_thunk_sym->type == bfd_link_hash_defined))
+ {
+ b = make_singleton_name_thunk (name, link_info.output_bfd);
+ add_bfd_to_link (b, bfd_get_filename (b), &link_info);
- if ((link_info.pei386_runtime_pseudo_reloc != 0 && addend != 0)
- || link_info.pei386_runtime_pseudo_reloc == 2)
- {
- if (pe_dll_extra_pe_debug)
- printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
- fixup_name, (int) addend);
+ /* If we ever use autoimport, we have to cast text section writable. */
+ config.text_read_only = false;
+ link_info.output_bfd->flags &= ~WP_TEXT;
+ }
- b = make_runtime_pseudo_reloc (name, fixup_name, addend, rel->howto->bitsize,
+ if (addend == 0 || link_info.pei386_runtime_pseudo_reloc == 1)
+ {
+ b = make_import_fixup_entry (name, fixup_name, symname,
link_info.output_bfd);
- add_bfd_to_link (b, b->filename, &link_info);
+ add_bfd_to_link (b, bfd_get_filename (b), &link_info);
+ }
+ }
- if (runtime_pseudo_relocs_created == 0)
- {
- b = pe_create_runtime_relocator_reference (link_info.output_bfd);
- add_bfd_to_link (b, b->filename, &link_info);
- }
- 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");
- }
-}
+ /* In the original implementation, the pseudo-relocator was only used when
+ the addend was not null. In the new implementation, the OS loader is
+ completely bypassed and the pseudo-relocator does the entire work. */
+ if ((addend != 0 && link_info.pei386_runtime_pseudo_reloc == 1)
+ || link_info.pei386_runtime_pseudo_reloc == 2)
+ {
+ if (pe_dll_extra_pe_debug)
+ printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
+ fixup_name, (int) addend);
+
+ b = make_runtime_pseudo_reloc (name, fixup_name, addend,
+ rel->howto->bitsize,
+ link_info.output_bfd);
+ add_bfd_to_link (b, bfd_get_filename (b), &link_info);
+
+ if (runtime_pseudo_relocs_created++ == 0)
+ {
+ b = pe_create_runtime_relocator_reference (link_info.output_bfd);
+ add_bfd_to_link (b, bfd_get_filename (b), &link_info);
+ }
+ }
+ else if (addend != 0)
+ einfo (_("%X%P: %C: variable '%pT' can't be auto-imported; please read the documentation for ld's --enable-auto-import for details\n"),
+ s->owner, s, rel->address, (*rel->sym_ptr_ptr)->name);
+}
void
pe_dll_generate_implib (def_file *def, const char *impfilename, struct bfd_link_info *info)
bfd *ibfd;
bfd *head = 0;
- dll_filename = (def->name) ? def->name : dll_name;
- dll_symname = xstrdup (dll_filename);
- for (i = 0; dll_symname[i]; i++)
- if (!ISALNUM (dll_symname[i]))
- dll_symname[i] = '_';
-
unlink_if_ordinary (impfilename);
outarch = bfd_openw (impfilename, 0);
if (!outarch)
{
/* xgettext:c-format */
- einfo (_("%XCan't open .lib file: %s\n"), impfilename);
+ einfo (_("%X%P: 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;
{
if (ex->type != EXCLUDEFORIMPLIB)
continue;
- found = (strcmp (ex->string, ibfd->filename) == 0);
+ found = (filename_cmp (ex->string, bfd_get_filename (ibfd)) == 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. */
+ 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);
+ ? bfd_get_filename (ibfd->my_archive)
+ : bfd_get_filename (ibfd), NULL);
if (!newbfd)
{
- einfo (_("%Xbfd_openr %s: %E\n"), ibfd->filename);
+ einfo (_("%X%P: bfd_openr %s: %E\n"), bfd_get_filename (ibfd));
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"),
- ibfd->my_archive->filename, ibfd->filename);
+ einfo (_("%X%P: %s(%s): can't find member in non-archive file"),
+ bfd_get_filename (ibfd->my_archive),
+ bfd_get_filename (ibfd));
return;
}
newbfd = NULL;
while ((newbfd = bfd_openr_next_archived_file (arbfd, newbfd)) != 0)
{
- if (strcmp (newbfd->filename, ibfd->filename) == 0)
+ if (filename_cmp (bfd_get_filename (newbfd),
+ bfd_get_filename (ibfd)) == 0)
break;
}
if (!newbfd)
{
- einfo (_("%X%s(%s): can't find member in archive"),
- ibfd->my_archive->filename, ibfd->filename);
+ einfo (_("%X%P: %s(%s): can't find member in archive"),
+ bfd_get_filename (ibfd->my_archive),
+ bfd_get_filename (ibfd));
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;
- n = make_one (def->exports + i, outarch,
- ! (def->exports + i)->flag_data);
+
+ /* 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 = n;
def->exports[i].internal_name = internal;
head = ar_tail;
if (! bfd_set_archive_head (outarch, head))
- einfo ("%Xbfd_set_archive_head: %E\n");
+ einfo ("%X%P: bfd_set_archive_head: %E\n");
if (! bfd_close (outarch))
- einfo ("%Xbfd_close %s: %E\n", impfilename);
+ einfo ("%X%P: bfd_close %s: %E\n", impfilename);
while (head != NULL)
{
}
}
+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
+ /* Use memmove rather than strcpy as that
+ can handle overlapping buffers. */
+ memmove (lname, lname + 1, strlen (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 (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 bool
+pe_undef_count (struct bfd_link_hash_entry *h ATTRIBUTE_UNUSED,
+ void *inf ATTRIBUTE_UNUSED)
+{
+ if (h->type == bfd_link_hash_undefined)
+ undef_count++;
+ return true;
+}
+
+static bool
+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 void
+pe_create_undef_table (void)
+{
+ 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
-add_bfd_to_link (bfd *abfd, const char *name, struct bfd_link_info *link_info)
+add_bfd_to_link (bfd *abfd, const char *name, struct bfd_link_info *linfo)
{
lang_input_statement_type *fake_file;
fake_file->the_bfd = abfd;
ldlang_add_file (fake_file);
- if (!bfd_link_add_symbols (abfd, link_info))
- einfo ("%Xaddsym %s: %E\n", name);
+ if (!bfd_link_add_symbols (abfd, linfo))
+ einfo (_("%X%P: add symbols %s: %E\n"), name);
}
void
-pe_process_import_defs (bfd *output_bfd, struct bfd_link_info *link_info)
+pe_process_import_defs (bfd *output_bfd, struct bfd_link_info *linfo)
{
- def_file_module *module;
-
pe_dll_id_target (bfd_get_target (output_bfd));
- if (!pe_def_file)
- return;
-
- for (module = pe_def_file->modules; module; module = module->next)
+ if (pe_def_file)
{
- int i, do_this_dll;
+ int i, j;
+ def_file_module *module;
+ def_file_import *imp;
- dll_filename = module->name;
- dll_symname = xstrdup (module->name);
- for (i = 0; dll_symname[i]; i++)
- if (!ISALNUM (dll_symname[i]))
- dll_symname[i] = '_';
+ imp = pe_def_file->imports;
- do_this_dll = 0;
+ pe_create_undef_table ();
- for (i = 0; i < pe_def_file->num_imports; i++)
- if (pe_def_file->imports[i].module == module)
- {
- def_file_export exp;
- struct bfd_link_hash_entry *blhe;
- int lead_at = (*pe_def_file->imports[i].internal_name == '@');
- /* See if we need this import. */
- size_t len = strlen (pe_def_file->imports[i].internal_name);
- char *name = xmalloc (len + 2 + 6);
- bfd_boolean include_jmp_stub = FALSE;
-
- if (lead_at)
- sprintf (name, "%s",
- pe_def_file->imports[i].internal_name);
- else
- sprintf (name, "%s%s",U (""),
- pe_def_file->imports[i].internal_name);
+ for (module = pe_def_file->modules; module; module = module->next)
+ {
+ int do_this_dll = 0;
- blhe = bfd_link_hash_lookup (link_info->hash, name,
- FALSE, FALSE, FALSE);
+ for (i = 0; i < pe_def_file->num_imports; i++)
+ if (imp[i].module == module)
+ break;
+ if (i >= pe_def_file->num_imports)
+ continue;
- /* Include the jump stub for <sym> only if the <sym>
- is undefined. */
- if (!blhe || (blhe && blhe->type != bfd_link_hash_undefined))
- {
- if (lead_at)
- sprintf (name, "%s%s", "__imp_",
- pe_def_file->imports[i].internal_name);
- else
- sprintf (name, "%s%s%s", "__imp_", U (""),
- pe_def_file->imports[i].internal_name);
+ dll_filename = module->name;
+ dll_symname = xstrdup (module->name);
+ for (j = 0; dll_symname[j]; j++)
+ if (!ISALNUM (dll_symname[j]))
+ dll_symname[j] = '_';
- blhe = bfd_link_hash_lookup (link_info->hash, name,
- FALSE, FALSE, FALSE);
- }
- else
- include_jmp_stub = TRUE;
+ for (; i < pe_def_file->num_imports && imp[i].module == module; i++)
+ {
+ def_file_export exp;
+ struct bfd_link_hash_entry *blhe;
+ int lead_at = (*imp[i].internal_name == '@');
+ /* See if we need this import. */
+ size_t len = strlen (imp[i].internal_name);
+ char *name = xmalloc (len + 2 + 6);
+ bool include_jmp_stub = false;
+ bool is_cdecl = false;
+ bool is_undef = false;
+
+ if (!lead_at && strchr (imp[i].internal_name, '@') == NULL)
+ is_cdecl = true;
+
+ if (lead_at)
+ sprintf (name, "%s", imp[i].internal_name);
+ else
+ sprintf (name, "%s%s",U (""), imp[i].internal_name);
- free (name);
+ blhe = bfd_link_hash_lookup (linfo->hash, name,
+ false, false, false);
- if (blhe && blhe->type == bfd_link_hash_undefined)
- {
- bfd *one;
- /* We do. */
- if (!do_this_dll)
- {
- bfd *ar_head = make_head (output_bfd);
- add_bfd_to_link (ar_head, ar_head->filename, link_info);
- do_this_dll = 1;
- }
- exp.internal_name = pe_def_file->imports[i].internal_name;
- exp.name = pe_def_file->imports[i].name;
- exp.ordinal = pe_def_file->imports[i].ordinal;
- exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
- exp.flag_private = 0;
- exp.flag_constant = 0;
- exp.flag_data = pe_def_file->imports[i].data;
- exp.flag_noname = exp.name ? 0 : 1;
- one = make_one (&exp, output_bfd, (! exp.flag_data) && include_jmp_stub);
- add_bfd_to_link (one, one->filename, link_info);
- }
- }
- if (do_this_dll)
+ /* Include the jump stub for <sym> only if the <sym>
+ is undefined. */
+ if (!blhe || (blhe && blhe->type != bfd_link_hash_undefined))
+ {
+ if (lead_at)
+ sprintf (name, "%s%s", "__imp_", imp[i].internal_name);
+ else
+ sprintf (name, "%s%s%s", "__imp_", U (""),
+ imp[i].internal_name);
+
+ 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;
+ is_undef = (blhe->type == bfd_link_hash_undefined);
+ }
+
+ 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 (linfo, name);
+ include_jmp_stub = true;
+ if (blhe)
+ is_undef = (blhe->type == bfd_link_hash_undefined);
+ }
+
+ free (name);
+
+ if (is_undef)
+ {
+ bfd *one;
+ /* We do. */
+ if (!do_this_dll)
+ {
+ bfd *ar_head = make_head (output_bfd);
+ add_bfd_to_link (ar_head, bfd_get_filename (ar_head),
+ linfo);
+ do_this_dll = 1;
+ }
+ exp.internal_name = imp[i].internal_name;
+ exp.name = imp[i].name;
+ exp.its_name = imp[i].its_name;
+ exp.ordinal = imp[i].ordinal;
+ exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
+ exp.flag_private = 0;
+ exp.flag_constant = 0;
+ exp.flag_data = imp[i].data;
+ exp.flag_noname = exp.name ? 0 : 1;
+ one = make_one (&exp, output_bfd,
+ !exp.flag_data && include_jmp_stub);
+ add_bfd_to_link (one, bfd_get_filename (one), linfo);
+ }
+ }
+ if (do_this_dll)
+ {
+ bfd *ar_tail = make_tail (output_bfd);
+ add_bfd_to_link (ar_tail, bfd_get_filename (ar_tail), linfo);
+ }
+
+ free (dll_symname);
+ }
+
+ while (undef_count)
{
- bfd *ar_tail = make_tail (output_bfd);
- add_bfd_to_link (ar_tail, ar_tail->filename, link_info);
+ --undef_count;
+ free (udef_table[undef_count].key);
}
+ free (udef_table);
+ }
- free (dll_symname);
+ if (pe_def_file && pe_def_file->name)
+ dll_filename = pe_def_file->name;
+ else
+ {
+ dll_filename = bfd_get_filename (output_bfd);
+ for (const char *p = dll_filename; *p; p++)
+ if (*p == '\\' || *p == '/' || *p == ':')
+ dll_filename = p + 1;
}
+ dll_symname = xstrdup (dll_filename);
+ for (int i = 0; dll_symname[i]; i++)
+ if (!ISALNUM (dll_symname[i]))
+ dll_symname[i] = '_';
}
/* We were handed a *.DLL file. Parse it and turn it into a set of
bfd_seek (abfd, (file_ptr) where, SEEK_SET);
bfd_bread (b, (bfd_size_type) 4, abfd);
- return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
+ return b[0] + (b[1] << 8) + (b[2] << 16) + ((unsigned) b[3] << 24);
}
static unsigned int
{
unsigned char *b = ptr;
- return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
+ return b[0] + (b[1] << 8) + (b[2] << 16) + ((unsigned) b[3] << 24);
}
-bfd_boolean
+bool
pe_implied_import_dll (const char *filename)
{
bfd *dll;
bfd_vma exp_funcbase;
unsigned char *expdata;
char *erva;
- bfd_vma name_rvas, ordinals, nexp, ordbase;
- const char *dll_name;
+ bfd_vma name_rvas, nexp;
+ const char *dllname;
/* Initialization with start > end guarantees that is_data
will not be set by mistake, and avoids compiler warning. */
bfd_vma data_start = 1;
bfd_vma rdata_end = 0;
bfd_vma bss_start = 1;
bfd_vma bss_end = 0;
+ int from;
/* No, I can't use bfd here. kernel32.dll puts its export table in
the middle of the .rdata section. */
dll = bfd_openr (filename, pe_details->target_name);
if (!dll)
{
- einfo ("%Xopen %s: %E\n", filename);
- return FALSE;
+ einfo (_("%X%P: open %s: %E\n"), filename);
+ return false;
}
+ track_dependency_files (filename);
+
/* 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);
- return FALSE;
+ einfo (_("%X%P: %s: this doesn't appear to be a DLL\n"), filename);
+ return false;
}
- /* Get pe_header, optional header and numbers of export entries. */
+ /* Get pe_header, optional header and numbers of directory entries. */
pe_header_offset = pe_get32 (dll, 0x3c);
opthdr_ofs = pe_header_offset + 4 + 20;
-#ifdef pe_use_x86_64
+#ifdef pe_use_plus
num_entries = pe_get32 (dll, opthdr_ofs + 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
#else
num_entries = pe_get32 (dll, opthdr_ofs + 92);
#endif
- if (num_entries < 1) /* No exports. */
- return FALSE;
+ /* No import or export directory entry. */
+ if (num_entries < 1)
+ return false;
-#ifdef pe_use_x86_64
+#ifdef pe_use_plus
export_rva = pe_get32 (dll, opthdr_ofs + 96 + 4 * 4);
export_size = pe_get32 (dll, opthdr_ofs + 100 + 4 * 4);
#else
export_size = pe_get32 (dll, opthdr_ofs + 100);
#endif
+ /* No export table - nothing to export. */
+ if (export_size == 0)
+ return false;
+
nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
secptr = (pe_header_offset + 4 + 20 +
pe_get16 (dll, pe_header_offset + 4 + 16));
if (pe_dll_extra_pe_debug)
printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
- __FUNCTION__, sec_name, (unsigned long) vaddr,
+ __func__, sec_name, (unsigned long) vaddr,
(unsigned long) (vaddr + vsize), (unsigned long) flags);
}
else if (strcmp(sec_name,".rdata") == 0)
if (pe_dll_extra_pe_debug)
printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
- __FUNCTION__, sec_name, (unsigned long) vaddr,
+ __func__, sec_name, (unsigned long) vaddr,
(unsigned long) (vaddr + vsize), (unsigned long) flags);
}
else if (strcmp (sec_name,".bss") == 0)
if (pe_dll_extra_pe_debug)
printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
- __FUNCTION__, sec_name, (unsigned long) vaddr,
+ __func__, sec_name, (unsigned long) vaddr,
(unsigned long) (vaddr + vsize), (unsigned long) flags);
}
}
nexp = pe_as32 (expdata + 24);
name_rvas = pe_as32 (expdata + 32);
- ordinals = pe_as32 (expdata + 36);
- ordbase = pe_as32 (expdata + 16);
exp_funcbase = pe_as32 (expdata + 28);
/* Use internal dll name instead of filename
to enable symbolic dll linking. */
- dll_name = erva + pe_as32 (expdata + 12);
+ dllname = erva + pe_as32 (expdata + 12);
/* Check to see if the dll has already been added to
the definition list and if so return without error.
This avoids multiple symbol definitions. */
- if (def_get_module (pe_def_file, dll_name))
+ if (def_get_module (pe_def_file, dllname))
{
if (pe_dll_extra_pe_debug)
- printf ("%s is already loaded\n", dll_name);
- return TRUE;
+ printf ("%s is already loaded\n", dllname);
+ return true;
+ }
+
+ /* This is an optimized version of the insertion loop, which avoids lots of
+ calls to realloc and memmove from def_file_add_import. */
+ if ((from = def_file_add_import_from (pe_def_file, nexp,
+ erva + pe_as32 (erva + name_rvas),
+ dllname, 0, NULL, NULL)) >= 0)
+ {
+ for (i = 0; i < nexp; i++)
+ {
+ /* Pointer to the names vector. */
+ bfd_vma name_rva = pe_as32 (erva + name_rvas + i * 4);
+ def_file_import *imp;
+ /* Pointer to the function address vector. */
+ bfd_vma func_rva = pe_as32 (erva + exp_funcbase + i * 4);
+ /* is_data is true if the address is in the data, rdata or bss
+ segment. */
+ const int is_data =
+ (func_rva >= data_start && func_rva < data_end)
+ || (func_rva >= rdata_start && func_rva < rdata_end)
+ || (func_rva >= bss_start && func_rva < bss_end);
+
+ imp = def_file_add_import_at (pe_def_file, from + i, erva + name_rva,
+ dllname, i, NULL, NULL);
+ /* Mark symbol type. */
+ imp->data = is_data;
+
+ if (pe_dll_extra_pe_debug)
+ printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
+ __func__, dllname, erva + name_rva,
+ (unsigned long) func_rva, is_data ? "(data)" : "");
+ }
+
+ return true;
}
/* Iterate through the list of symbols. */
/* Skip unwanted symbols, which are
exported in buggy auto-import releases. */
- if (! CONST_STRNEQ (erva + name_rva, "_nm_"))
- {
- /* is_data is true if the address is in the data, rdata or bss
+ if (! startswith (erva + name_rva, "__nm_"))
+ {
+ bool is_dup = false;
+ /* is_data is true if the address is in the data, rdata or bss
segment. */
- is_data =
+ is_data =
(func_rva >= data_start && func_rva < data_end)
|| (func_rva >= rdata_start && func_rva < rdata_end)
|| (func_rva >= bss_start && func_rva < bss_end);
imp = def_file_add_import (pe_def_file, erva + name_rva,
- dll_name, i, 0);
- /* Mark symbol type. */
- imp->data = is_data;
+ dllname, i, NULL, NULL, &is_dup);
+ /* Mark symbol type. */
+ if (!is_dup)
+ imp->data = is_data;
- if (pe_dll_extra_pe_debug)
+ if (pe_dll_extra_pe_debug)
printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
- __FUNCTION__, dll_name, erva + name_rva,
+ __func__, dllname, erva + name_rva,
(unsigned long) func_rva, is_data ? "(data)" : "");
- }
+ }
}
- return TRUE;
+ return true;
}
void
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 (_("%X%P: error: can't use long section names on this arch\n"));
}
/* These are the main functions, called from the emulation. The first
{
pe_dll_id_target (bfd_get_target (abfd));
pe_output_file_set_long_section_names (abfd);
- process_def_file (abfd, info);
+ process_def_file_and_drectve (abfd, info);
- if (pe_def_file->num_exports == 0 && !info->shared)
- return;
+ if (pe_def_file->num_exports == 0 && !bfd_link_pic (info))
+ {
+ if (pe_dll_enable_reloc_section)
+ {
+ build_filler_bfd (false /* edata not needed. */);
+ pe_output_file_set_long_section_names (filler_bfd);
+ }
+ return;
+ }
- generate_edata (abfd, info);
- build_filler_bfd (1);
+ generate_edata ();
+ build_filler_bfd (true /* edata is needed. */);
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;
+ pe_exe_fill_sections (abfd, info);
- generate_reloc (abfd, info);
- if (reloc_sz > 0)
+ if (edata_s)
{
- bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
-
- /* Resize the sections. */
- lang_reset_memory_regions ();
- lang_size_sections (NULL, TRUE);
-
- /* Redo special stuff. */
- ldemul_after_allocation ();
-
- /* Do the assignments again. */
- lang_do_assignments ();
+ fill_edata (abfd, info);
+ edata_s->contents = edata_d;
}
- fill_edata (abfd, info);
-
- if (info->shared && !info->pie)
+ if (bfd_link_dll (info))
pe_data (abfd)->dll = 1;
-
- edata_s->contents = edata_d;
- reloc_s->contents = reloc_d;
}
void
image_base = pe_data (abfd)->pe_opthdr.ImageBase;
generate_reloc (abfd, info);
+
if (reloc_sz > 0)
{
- bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
+ bfd_set_section_size (reloc_s, reloc_sz);
/* Resize the sections. */
lang_reset_memory_regions ();
- lang_size_sections (NULL, TRUE);
+ lang_size_sections (NULL, true);
/* Redo special stuff. */
ldemul_after_allocation ();
/* Do the assignments again. */
- lang_do_assignments ();
+ lang_do_assignments (lang_final_phase_enum);
+
+ reloc_s->contents = reloc_d;
+ }
+ else if (reloc_s)
+ {
+ /* Do not emit an empty reloc section. */
+ bfd_set_section_flags (reloc_s, SEC_IN_MEMORY | SEC_EXCLUDE);
+ reloc_s->output_section = bfd_abs_section_ptr;
}
- reloc_s->contents = reloc_d;
}
-bfd_boolean
+bool
pe_bfd_is_dll (bfd *abfd)
{
return (bfd_get_format (abfd) == bfd_object
- && obj_pe (abfd)
- && pe_data (abfd)->dll);
+ && obj_pe (abfd)
+ && pe_data (abfd)->dll);
}
projects / thirdparty / binutils-gdb.git / blobdiff