/* Routines to help build PEI-format DLLs (Win32 etc)
- Copyright (C) 1998-2017 Free Software Foundation, Inc.
+ Copyright (C) 1998-2020 Free Software Foundation, Inc.
Written by DJ Delorie <dj@cygnus.com>
This file is part of the GNU Binutils.
#include "libiberty.h"
#include "filenames.h"
#include "safe-ctype.h"
+#include "ctf-api.h"
#include <time.h>
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 = 0;
/* Static variables and types. */
static unsigned char *edata_d, *reloc_d;
static size_t edata_sz, reloc_sz;
static int runtime_pseudo_relocs_created = 0;
-static int runtime_pseudp_reloc_v2_init = 0;
+static bfd_boolean runtime_pseudp_reloc_v2_init = FALSE;
typedef struct
{
#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
/* Don't make it constant as underscore mode gets possibly overriden
by target or -(no-)leading-underscore option. */
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",
TRUE,
autofilter_symbollist_generic
},
- {
- "epoc-pei-arm-little",
- "epoc-pe-arm-little",
- 11 /* ARM_RVA32 */,
- PE_ARCH_arm_epoc,
- bfd_arch_arm,
- FALSE,
- autofilter_symbollist_generic
- },
{
"pei-arm-wince-little",
"pe-arm-wince-little",
pe_leading_underscore = (u != 0 ? 1 : 0);
return;
}
- einfo (_("%P%X: Unsupported 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 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;
/* 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)
}
else if (ex->type == EXCLUDEFORIMPLIB)
{
- if (filename_cmp (abfd->filename, ex->string) == 0)
+ if (filename_cmp (bfd_get_filename (abfd), ex->string) == 0)
return 0;
}
else if (strcmp (n, ex->string) == 0)
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;
}
if (tmp_at)
*tmp_at = 0;
else
- einfo (_("%P%X: Cannot 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;
{
if (pe_dll_warn_dup_exports)
/* xgettext:c-format */
- einfo (_("%P%X: Error, 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 (_("%P: 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;
- if (e[i].name)
- free (e[i].name);
- if (e[i].internal_name)
- free (e[i].internal_name);
- if (e[i].its_name)
- free (e[i].its_name);
+ free (e[i].name);
+ free (e[i].internal_name);
+ free (e[i].its_name);
}
else
{
else if (blhe && blhe->type == bfd_link_hash_undefined)
{
/* xgettext:c-format */
- einfo (_("%P%X: Cannot export %s: symbol not defined\n"),
+ einfo (_("%X%P: cannot export %s: symbol not defined\n"),
int_name);
}
else if (blhe)
{
/* xgettext:c-format */
- einfo (_("%P%X: Cannot export %s: symbol wrong type (%d vs %d)\n"),
+ 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 (_("%P%X: Cannot export %s: symbol not found\n"),
+ einfo (_("%X%P: cannot export %s: symbol not found\n"),
int_name);
}
free (name);
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"));
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)))
+ || !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);
ldlang_add_file (filler_file);
}
dll_name = pe_def_file->name;
else
{
- dll_name = abfd->filename;
+ dll_name = bfd_get_filename (abfd);
for (dlnp = dll_name; *dlnp; dlnp++)
if (*dlnp == '\\' || *dlnp == '/' || *dlnp == ':')
if (pi != -1)
{
/* xgettext:c-format */
- einfo (_("%P%X: Error: 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);
/* 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"),
+ 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. */
memset (edata_d, 0, edata_sz);
- if (pe_data (abfd)->insert_timestamp)
+ 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)
{
static struct bfd_section *current_sec;
-void
-pe_walk_relocs_of_symbol (struct bfd_link_info *info,
- char *name,
- int (*cb) (arelent *, asection *, char *))
+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;
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;
}
{
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, name);
+ /* 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", __FUNCTION__, 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 bfd_boolean 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
if (s->output_section->vma == 0)
{
/* Huh? Shouldn't happen, but punt if it does. */
- einfo (_("zero vma section reloc detected: `%s' #%d f=%d\n"),
+ einfo (_("%P: zero vma section reloc detected: `%s' #%d f=%d\n"),
s->output_section->name, s->output_section->index,
s->output_section->flags);
continue;
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;
}
}
reloc_data[total_relocs].vma = sec_vma + relocs[i]->address;
+ reloc_data[total_relocs].idx = total_relocs;
#define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
/* Fall through. */
default:
/* xgettext:c-format */
- einfo (_("%P%X: Error: %d-bit reloc in dll\n"),
+ einfo (_("%X%P: error: %d-bit reloc in dll\n"),
relocs[i]->howto->bitsize);
break;
}
if (out == NULL)
/* xgettext:c-format */
- einfo (_("%P: Can't open output def file %s\n"),
+ einfo (_("%P: can't open output def file %s\n"),
pe_out_def_filename);
if (pe_def_file)
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;
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;
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);
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);
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);
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);
quick_reloc (abfd, 4, BFD_RELOC_LO16, 2);
break;
case PE_ARCH_arm:
- case PE_ARCH_arm_epoc:
case PE_ARCH_arm_wince:
quick_reloc (abfd, 8, BFD_RELOC_32, 2);
break;
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
{
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);
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, "__imp_", import, "", id5, BSF_GLOBAL, 0);
-
- /* We need space for the real thunk and for the null terminator. */
- bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE * 2);
- d5 = xmalloc (PE_IDATA5_SIZE * 2);
- id5->contents = d5;
- memset (d5, 0, PE_IDATA5_SIZE * 2);
- quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
- save_relocs (id5);
-
- bfd_set_symtab (abfd, symtab, symptr);
-
- bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA4_SIZE * 2);
-
- bfd_make_readable (abfd);
- return abfd;
-}
-
static bfd *
make_singleton_name_thunk (const char *import, bfd *parent)
{
quick_symbol (abfd, "__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 *
+static const char *
make_import_fixup_mark (arelent *rel, char *name)
{
/* We convert reloc to symbol, for later reference. */
current_sec, /* sym->section, */
rel->address, NULL, TRUE, FALSE, &bh);
- return fixup_name;
+ return bh->root.string;
}
/* .section .idata$2
quick_symbol (abfd, "__nm_thnk_", name, "", UNDSEC, BSF_GLOBAL, 0);
quick_symbol (abfd, U (""), 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, "__imp_", name, "", UNDSEC, BSF_GLOBAL, 0);
- else
- quick_symbol (abfd, "", fixup_name, "", 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);
unsigned char *rt_rel_d;
char *oname;
bfd *abfd;
+ bfd_size_type size;
+
oname = xmalloc (20);
sprintf (oname, "rtr%06d.o", tmp_seq);
tmp_seq++;
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;
- }
+ 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;
}
quick_symbol (abfd, "", U ("_pei386_runtime_relocator"), "", UNDSEC,
BSF_NO_FLAGS, 0);
- bfd_set_section_size (abfd, extern_rt_rel, 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;
}
void
-pe_create_import_fixup (arelent *rel, asection *s, bfd_vma addend, char *name)
+pe_create_import_fixup (arelent *rel, asection *s, bfd_vma addend, char *name,
+ const char *symname)
{
- struct bfd_symbol *sym = *rel->sym_ptr_ptr;
- struct bfd_link_hash_entry *name_thunk_sym;
- struct bfd_link_hash_entry *name_imp_sym;
- char *fixup_name, *impname;
+ const char *fixup_name = make_import_fixup_mark (rel, name);
bfd *b;
- int need_import_table = 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);
-
- 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);
-
- 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. */
- 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))
+ /* 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)
{
- b = make_singleton_name_thunk (name, link_info.output_bfd);
- add_bfd_to_link (b, b->filename, &link_info);
+ 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);
- /* 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)
+ 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 we ever use autoimport, we have to cast text section writable. */
config.text_read_only = FALSE;
link_info.output_bfd->flags &= ~WP_TEXT;
}
- if (link_info.pei386_runtime_pseudo_reloc == 2)
+
+ if (addend == 0 || link_info.pei386_runtime_pseudo_reloc == 1)
{
- b = make_singleton_name_imp (name, link_info.output_bfd);
- add_bfd_to_link (b, b->filename, &link_info);
+ b = make_import_fixup_entry (name, fixup_name, symname,
+ link_info.output_bfd);
+ add_bfd_to_link (b, bfd_get_filename (b), &link_info);
}
}
- if ((addend == 0 || link_info.pei386_runtime_pseudo_reloc)
- && need_import_table == 1)
- {
- extern char * pe_data_import_dll;
- char * symname = pe_data_import_dll ? pe_data_import_dll : "unknown";
-
- b = make_import_fixup_entry (name, fixup_name, symname,
- link_info.output_bfd);
- add_bfd_to_link (b, b->filename, &link_info);
- }
-
- if ((link_info.pei386_runtime_pseudo_reloc != 0 && addend != 0)
+ /* 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)
b = make_runtime_pseudo_reloc (name, fixup_name, addend, rel->howto->bitsize,
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)
+ 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);
+ add_bfd_to_link (b, bfd_get_filename (b), &link_info);
}
- runtime_pseudo_relocs_created++;
}
+
else if (addend != 0)
- 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);
+ 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)
{
if (!outarch)
{
/* xgettext:c-format */
- einfo (_("%P%X: Can't open .lib file: %s\n"), impfilename);
+ einfo (_("%X%P: can't open .lib file: %s\n"), impfilename);
return;
}
{
if (ex->type != EXCLUDEFORIMPLIB)
continue;
- found = (filename_cmp (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
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 (_("%P%X: bfd_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 (_("%P%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 (filename_cmp (newbfd->filename, ibfd->filename) == 0)
+ if (filename_cmp (bfd_get_filename (newbfd),
+ bfd_get_filename (ibfd)) == 0)
break;
}
if (!newbfd)
{
- einfo (_("%P%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;
}
}
head = ar_tail;
if (! bfd_set_archive_head (outarch, head))
- einfo ("%P%X: bfd_set_archive_head: %E\n");
+ einfo ("%X%P: bfd_set_archive_head: %E\n");
if (! bfd_close (outarch))
- einfo ("%P%X: bfd_close %s: %E\n", impfilename);
+ einfo ("%X%P: bfd_close %s: %E\n", impfilename);
while (head != NULL)
{
ldlang_add_file (fake_file);
if (!bfd_link_add_symbols (abfd, linfo))
- einfo (_("%P%X: add symbols %s: %E\n"), name);
+ einfo (_("%X%P: add symbols %s: %E\n"), name);
}
void
if (!do_this_dll)
{
bfd *ar_head = make_head (output_bfd);
- add_bfd_to_link (ar_head, ar_head->filename, linfo);
+ add_bfd_to_link (ar_head, bfd_get_filename (ar_head), linfo);
do_this_dll = 1;
}
exp.internal_name = imp[i].internal_name;
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, one->filename, linfo);
+ 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, ar_tail->filename, linfo);
+ add_bfd_to_link (ar_tail, bfd_get_filename (ar_tail), linfo);
}
free (dll_symname);
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
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 (_("%P%X: open %s: %E\n"), filename);
+ 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 (_("%P%X: %s: this doesn't appear to be a DLL\n"), filename);
+ einfo (_("%X%P: %s: this doesn't appear to be a DLL\n"), filename);
return FALSE;
}
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",
+ __FUNCTION__, dllname, erva + name_rva,
+ (unsigned long) func_rva, is_data ? "(data)" : "");
+ }
+
+ return TRUE;
+ }
+
/* Iterate through the list of symbols. */
for (i = 0; i < nexp; i++)
{
if (pe_use_coff_long_section_names < 0)
return;
if (!bfd_coff_set_long_section_names (abfd, pe_use_coff_long_section_names))
- einfo (_("%P%X: Error: 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
process_def_file_and_drectve (abfd, info);
if (pe_def_file->num_exports == 0 && !bfd_link_pic (info))
- return;
+ {
+ if (pe_dll_enable_reloc_section)
+ {
+ build_filler_bfd (0);
+ pe_output_file_set_long_section_names (filler_bfd);
+ }
+ return;
+ }
generate_edata (abfd, info);
build_filler_bfd (1);
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 (lang_final_phase_enum);
+ fill_edata (abfd, info);
+ edata_s->contents = edata_d;
}
- fill_edata (abfd, info);
-
if (bfd_link_dll (info))
pe_data (abfd)->dll = 1;
-
- edata_s->contents = edata_d;
- reloc_s->contents = reloc_d;
}
void
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 ();
projects / deliverable / binutils-gdb.git / blobdiff