/* Routines to help build PEI-format DLLs (Win32 etc)
Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
- 2008 Free Software Foundation, Inc.
+ 2008, 2009, 2010 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 <time.h>
#include "coff/internal.h"
#include "../bfd/libcoff.h"
#include "deffile.h"
-#include "pe-dll.h"
#ifdef pe_use_x86_64
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_warn_dup_exports = 0;
int pe_dll_compat_implib = 0;
int pe_dll_extra_pe_debug = 0;
+int pe_use_nul_prefixed_import_tables = 0;
+int pe_use_coff_long_section_names = -1;
+int pe_leading_underscore = -1;
/* 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;
typedef struct
{
int pe_arch;
int bfd_arch;
bfd_boolean underscored;
- const autofilter_entry_type* autofilter_symbollist;
+ const autofilter_entry_type* autofilter_symbollist;
}
pe_details_type;
static const autofilter_entry_type autofilter_symbollist_generic[] =
{
- { STRING_COMMA_LEN (".text") },
+ { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
/* Entry point symbols. */
{ STRING_COMMA_LEN ("DllMain") },
{ STRING_COMMA_LEN ("DllMainCRTStartup") },
static const autofilter_entry_type autofilter_symbollist_i386[] =
{
- { STRING_COMMA_LEN (".text") },
+ { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
/* Entry point symbols, and entry hooks. */
{ STRING_COMMA_LEN ("cygwin_crt0") },
#ifdef pe_use_x86_64
{ 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") },
#define PE_ARCH_arm_epoc 5
#define PE_ARCH_arm_wince 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
#endif
PE_ARCH_i386,
bfd_arch_i386,
+#ifdef pe_use_x86_64
+ FALSE,
+#else
TRUE,
+#endif
autofilter_symbollist_i386
},
{
{ STRING_COMMA_LEN ("libcegcc") },
{ STRING_COMMA_LEN ("libcygwin") },
{ STRING_COMMA_LEN ("libgcc") },
+ { STRING_COMMA_LEN ("libgcc_s") },
{ STRING_COMMA_LEN ("libstdc++") },
{ STRING_COMMA_LEN ("libmingw32") },
{ STRING_COMMA_LEN ("libmingwex") },
{ NULL, 0 }
};
+/* Regardless of the suffix issue mentioned above, we must ensure that
+ we do not falsely match on a leading substring, such as when libtool
+ builds libstdc++ as a DLL using libsupc++convenience.a as an intermediate.
+ This routine ensures that the leading part of the name matches and that
+ it is followed by only an optional version suffix and a file extension,
+ returning zero if so or -1 if not. */
+static int libnamencmp (const char *libname, const autofilter_entry_type *afptr)
+{
+ if (filename_ncmp (libname, afptr->name, afptr->len))
+ return -1;
+
+ libname += afptr->len;
+
+ /* Be liberal in interpreting what counts as a version suffix; we
+ accept anything that has a dash to separate it from the name and
+ begins with a digit. */
+ if (libname[0] == '-')
+ {
+ if (!ISDIGIT (*++libname))
+ return -1;
+ /* Ensure the filename has an extension. */
+ while (*++libname != '.')
+ if (!*libname)
+ return -1;
+ }
+ else if (libname[0] != '.')
+ return -1;
+
+ return 0;
+}
+
static const autofilter_entry_type autofilter_objlist[] =
{
{ STRING_COMMA_LEN ("crt0.o") },
{ 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_") },
+ /* Don't export section labels or artificial symbols
+ (eg ".weak.foo". */
+ { STRING_COMMA_LEN (".") },
{ NULL, 0 }
};
static const autofilter_entry_type autofilter_symbolsuffixlist[] =
{
{ STRING_COMMA_LEN ("_iname") },
+ { STRING_COMMA_LEN ("_NULL_THUNK_DATA") },
{ NULL, 0 }
};
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 ? TRUE : FALSE);
pe_details = pe_detail_list + i;
+ pe_leading_underscore = (u != 0 ? 1 : 0);
return;
}
einfo (_("%XUnsupported PEI architecture: %s\n"), target);
{
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. */
{
char *string;
struct exclude_list_struct *next;
- int type;
+ exclude_type type;
}
exclude_list_struct;
static struct exclude_list_struct *excludes = 0;
void
-pe_dll_add_excludes (const char *new_excludes, const int type)
+pe_dll_add_excludes (const char *new_excludes, const exclude_type type)
{
char *local_copy;
char *exclude_string;
while (afptr->name)
{
- if (strncmp (libname, afptr->name, afptr->len) == 0 )
+ if (libnamencmp (libname, afptr) == 0 )
return 0;
afptr++;
}
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)
{
for (ex = excludes; ex; ex = ex->next)
{
- if (ex->type == 1) /* exclude-libs */
+ 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 (filename_cmp (abfd->filename, ex->string) == 0)
+ return 0;
+ }
else if (strcmp (n, ex->string) == 0)
return 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;
struct bfd_link_hash_entry *blhe;
}
}
- /* 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 we are building an executable and there is nothing
+ to export, we do not build an export table at all. */
+ if (info->executable && pe_def_file->num_exports == 0
+ && (!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)
{
asymbol **symbols;
- int nsyms, symsize;
+ int nsyms;
- symsize = bfd_get_symtab_upper_bound (b);
- symbols = xmalloc (symsize);
- nsyms = bfd_canonicalize_symtab (b, symbols);
+ if (!bfd_generic_link_read_symbols (b))
+ {
+ einfo (_("%B%F: could not read symbols: %E\n"), b);
+ return;
+ }
+
+ symbols = bfd_get_outsymbols (b);
+ nsyms = bfd_get_symcount (b);
for (j = 0; j < nsyms; j++)
{
/* We should export symbols which are either global or not
anything at all. (.bss data is the latter)
We should not export undefined symbols. */
- if (symbols[j]->section != &bfd_und_section
- && ((symbols[j]->flags & BSF_GLOBAL)
- || (symbols[j]->flags == BFD_FORT_COMM_DEFAULT_VALUE)))
+ 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;
+ (void) bfd_find_version_for_sym (lang_elf_version_info,
+ symbols[j]->name, &hide);
+ would_export = !hide;
+ }
+ if (would_export)
{
const char *sn = symbols[j]->name;
if (auto_export (b, pe_def_file, sn))
{
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);
/* Fill data flag properly, from dlltool.c. */
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;
+
/* Canonicalize the export list. */
if (pe_dll_kill_ats)
{
if (auto_export (NULL, pe_def_file, tmp))
def_file_add_export (pe_def_file, tmp,
pe_def_file->exports[i].internal_name,
- -1);
+ -1, NULL);
else
free (tmp);
}
for (i = 0; i < NE; i++)
{
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;
- }
-
name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
if (pe_details->underscored
&& (*pe_def_file->exports[i].internal_name != '@'))
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 (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)
}
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. */
}
/* 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)
/* 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;
}
else
{
- unsigned long srva = (exported_symbol_offsets[s]
+ bfd_vma srva = (exported_symbol_offsets[s]
+ ssec->output_section->vma
+ ssec->output_offset);
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;
for (b = info->input_bfds; b; b = b->link_next)
{
asymbol **symbols;
- int nsyms, symsize;
- symsize = bfd_get_symtab_upper_bound (b);
- symbols = xmalloc (symsize);
- nsyms = bfd_canonicalize_symtab (b, symbols);
+ if (!bfd_generic_link_read_symbols (b))
+ {
+ einfo (_("%B%F: could not read symbols: %E\n"), b);
+ return;
+ }
+
+ symbols = bfd_get_outsymbols (b);
for (s = b->sections; s; s = s->next)
{
reloc_data_type *reloc_data;
int total_relocs = 0;
int i;
- unsigned long sec_page = (unsigned long) -1;
- unsigned long page_ptr, page_count;
+ bfd_vma sec_page = (bfd_vma) -1;
+ bfd_vma page_ptr, page_count;
int bi;
bfd *b;
struct bfd_section *s;
for (bi = 0, b = info->input_bfds; b; bi++, b = b->link_next)
{
arelent **relocs;
- int relsize, nrelocs, i;
+ int relsize, nrelocs;
for (s = b->sections; s; s = s->next)
{
- unsigned long sec_vma = s->output_section->vma + s->output_offset;
+ bfd_vma sec_vma = s->output_section->vma + s->output_offset;
asymbol **symbols;
- int nsyms, symsize;
/* If it's not loaded, we don't need to relocate it this way. */
if (!(s->output_section->flags & SEC_LOAD))
continue;
}
- symsize = bfd_get_symtab_upper_bound (b);
- symbols = xmalloc (symsize);
- nsyms = bfd_canonicalize_symtab (b, symbols);
+ if (!bfd_generic_link_read_symbols (b))
+ {
+ einfo (_("%B%F: could not read symbols: %E\n"), b);
+ return;
+ }
+ symbols = bfd_get_outsymbols (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;
- sym_vma = (relocs[i]->addend
- + sym->value
- + sym->section->vma
- + sym->section->output_offset
- + sym->section->output_section->vma);
+ /* Don't create relocs for undefined weak symbols. */
+ if (sym->flags == BSF_WEAK)
+ {
+ struct bfd_link_hash_entry *blhe
+ = bfd_wrapped_link_hash_lookup (abfd, info, sym->name,
+ FALSE, FALSE, FALSE);
+ 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)
+ continue;
+ }
+ else if (!blhe || blhe->type != bfd_link_hash_defined)
+ continue;
+ }
+
reloc_data[total_relocs].vma = sec_vma + relocs[i]->address;
#define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
for (i = 0; i < total_relocs; i++)
{
- unsigned long this_page = (reloc_data[i].vma >> 12);
+ bfd_vma this_page = (reloc_data[i].vma >> 12);
if (this_page != sec_page)
{
reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
reloc_d = xmalloc (reloc_sz);
- sec_page = (unsigned long) -1;
+ sec_page = (bfd_vma) -1;
reloc_sz = 0;
- page_ptr = (unsigned long) -1;
+ page_ptr = (bfd_vma) -1;
page_count = 0;
for (i = 0; i < total_relocs; i++)
{
- unsigned long rva = reloc_data[i].vma - image_base;
- unsigned long this_page = (rva & ~0xfff);
+ bfd_vma rva = reloc_data[i].vma - image_base;
+ bfd_vma this_page = (rva & ~0xfff);
if (this_page != sec_page)
{
while (reloc_sz & 3)
reloc_d[reloc_sz++] = 0;
- if (page_ptr != (unsigned long) -1)
+ if (page_ptr != (bfd_vma) -1)
bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
bfd_put_32 (abfd, this_page, reloc_d + reloc_sz);
while (reloc_sz & 3)
reloc_d[reloc_sz++] = 0;
- if (page_ptr != (unsigned long) -1)
+ 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)
quoteput (pe_def_file->name, out, 1);
if (pe_data (link_info.output_bfd)->pe_opthdr.ImageBase)
- fprintf (out, " BASE=0x%lx",
- (unsigned long)
- 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, "\n");
}
else
fprintf (out, "%d", im->ordinal);
+ if (im->its_name)
+ {
+ fprintf (out, " == ");
+ quoteput (im->its_name, out, 0);
+ }
+
fprintf (out, "\n");
}
}
static asymbol **symtab;
static int symptr;
static int tmp_seq;
+static int tmp_seq2;
static const char *dll_filename;
static char *dll_symname;
static int relcount = 0, relsize = 0;
static void
-quick_reloc (bfd *abfd, int address, int which_howto, int symidx)
+quick_reloc (bfd *abfd, bfd_size_type address, int which_howto, int symidx)
{
if (relcount >= relsize - 1)
{
d2 = xmalloc (20);
id2->contents = d2;
memset (d2, 0, 20);
- d2[0] = d2[16] = 4; /* Reloc addend. */
+ if (pe_use_nul_prefixed_import_tables)
+ d2[0] = d2[16] = PE_IDATA5_SIZE; /* Reloc addend. */
quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
quick_reloc (abfd, 12, BFD_RELOC_RVA, 4);
quick_reloc (abfd, 16, BFD_RELOC_RVA, 1);
save_relocs (id2);
- bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
+ if (pe_use_nul_prefixed_import_tables)
+ bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
+ else
+ bfd_set_section_size (abfd, id5, 0);
d5 = xmalloc (PE_IDATA5_SIZE);
id5->contents = d5;
memset (d5, 0, PE_IDATA5_SIZE);
-
- bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
+ if (pe_use_nul_prefixed_import_tables)
+ bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
+ else
+ bfd_set_section_size (abfd, id4, 0);
d4 = xmalloc (PE_IDATA4_SIZE);
id4->contents = d4;
memset (d4, 0, PE_IDATA4_SIZE);
bfd_set_symtab (abfd, symtab, symptr);
bfd_set_section_contents (abfd, id2, d2, 0, 20);
- bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
- bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
+ if (pe_use_nul_prefixed_import_tables)
+ {
+ bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
+ bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
+ }
+ else
+ {
+ bfd_set_section_contents (abfd, id5, d5, 0, 0);
+ bfd_set_section_contents (abfd, id4, d4, 0, 0);
+ }
bfd_make_readable (abfd);
return abfd;
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)
#ifdef pe_use_x86_64
quick_reloc (abfd, 2, BFD_RELOC_32_PCREL, 2);
#else
+ /* 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;
else
{
/* { 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);
memset (d6, 0, len);
d6[0] = exp->hint & 0xff;
d6[1] = exp->hint >> 8;
- strcpy ((char *) d6 + 2, exp->name);
+ 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, "__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)
{
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);
static bfd *
make_import_fixup_entry (const char *name,
const char *fixup_name,
- const char *dll_symname,
+ const char *symname,
bfd *parent)
{
asection *id2;
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);
- 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);
+ /* 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);
bfd_set_section_size (abfd, id2, 20);
d2 = xmalloc (20);
static bfd *
make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED,
const char *fixup_name,
- int addend,
+ bfd_vma addend ATTRIBUTE_UNUSED,
+ bfd_vma bitsize,
bfd *parent)
{
asection *rt_rel;
unsigned char *rt_rel_d;
char *oname;
bfd *abfd;
-
oname = xmalloc (20);
sprintf (oname, "rtr%06d.o", tmp_seq);
tmp_seq++;
bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
symptr = 0;
- symtab = xmalloc (2 * sizeof (asymbol *));
+ if (link_info.pei386_runtime_pseudo_reloc == 2)
+ {
+ symtab = xmalloc ((runtime_pseudp_reloc_v2_init ? 3 : 6) * sizeof (asymbol *));
+ }
+ else
+ {
+ symtab = xmalloc (2 * sizeof (asymbol *));
+ }
rt_rel = quick_section (abfd, ".rdata_runtime_pseudo_reloc",
SEC_HAS_CONTENTS, 2);
quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
- bfd_set_section_size (abfd, rt_rel, 8);
- rt_rel_d = xmalloc (8);
- rt_rel->contents = rt_rel_d;
- memset (rt_rel_d, 0, 8);
- bfd_put_32 (abfd, addend, rt_rel_d);
+ 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, "__imp_", name, "", UNDSEC, BSF_GLOBAL, 0);
+
+ bfd_set_section_size (abfd, 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);
+ 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);
+ rt_rel_d = xmalloc (8);
+ rt_rel->contents = rt_rel_d;
+ memset (rt_rel_d, 0, 8);
- quick_reloc (abfd, 4, BFD_RELOC_RVA, 1);
- save_relocs (rt_rel);
+ bfd_put_32 (abfd, addend, rt_rel_d);
+ quick_reloc (abfd, 4, BFD_RELOC_RVA, 1);
- bfd_set_symtab (abfd, symtab, symptr);
+ save_relocs (rt_rel);
- bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, 8);
+ bfd_set_symtab (abfd, symtab, symptr);
+ 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, 4);
- extern_rt_rel_d = xmalloc (4);
+ bfd_set_section_size (abfd, extern_rt_rel, PE_IDATA5_SIZE);
+ extern_rt_rel_d = xmalloc (PE_IDATA5_SIZE);
extern_rt_rel->contents = extern_rt_rel_d;
quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
bfd_set_symtab (abfd, symtab, symptr);
- bfd_set_section_contents (abfd, extern_rt_rel, extern_rt_rel_d, 0, 4);
+ bfd_set_section_contents (abfd, extern_rt_rel, extern_rt_rel_d, 0, PE_IDATA5_SIZE);
bfd_make_readable (abfd);
return abfd;
}
void
-pe_create_import_fixup (arelent *rel, asection *s, int addend)
+pe_create_import_fixup (arelent *rel, asection *s, bfd_vma addend)
{
char buf[300];
struct bfd_symbol *sym = *rel->sym_ptr_ptr;
struct bfd_link_hash_entry *name_thunk_sym;
+ struct bfd_link_hash_entry *name_imp_sym;
const char *name = sym->name;
char *fixup_name = make_import_fixup_mark (rel);
bfd *b;
+ int need_import_table = 1;
+
+ sprintf (buf, "__imp_%s", name);
+ name_imp_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
- sprintf (buf, U ("_nm_thnk_%s"), name);
+ sprintf (buf, "__nm_thnk_%s", name);
name_thunk_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
- if (!name_thunk_sym || name_thunk_sym->type != bfd_link_hash_defined)
+ /* For version 2 pseudo relocation we don't need to add an import
+ if the import symbol is already present. */
+ if (link_info.pei386_runtime_pseudo_reloc == 2
+ && name_imp_sym
+ && name_imp_sym->type == bfd_link_hash_defined)
+ need_import_table = 0;
+
+ if (need_import_table == 1
+ && (!name_thunk_sym || name_thunk_sym->type != bfd_link_hash_defined))
{
- bfd *b = make_singleton_name_thunk (name, link_info.output_bfd);
+ b = make_singleton_name_thunk (name, link_info.output_bfd);
add_bfd_to_link (b, b->filename, &link_info);
- /* If we ever use autoimport, we have to cast text section writable. */
- config.text_read_only = FALSE;
- link_info.output_bfd->flags &= ~WP_TEXT;
+ /* If we ever use autoimport, we have to cast text section writable.
+ But not for version 2. */
+ if (link_info.pei386_runtime_pseudo_reloc != 2)
+ {
+ config.text_read_only = FALSE;
+ link_info.output_bfd->flags &= ~WP_TEXT;
+ }
+ if (link_info.pei386_runtime_pseudo_reloc == 2)
+ {
+ b = make_singleton_name_imp (name, link_info.output_bfd);
+ add_bfd_to_link (b, b->filename, &link_info);
+ }
}
- if (addend == 0 || link_info.pei386_runtime_pseudo_reloc)
+ if ((addend == 0 || link_info.pei386_runtime_pseudo_reloc)
+ && need_import_table == 1)
{
extern char * pe_data_import_dll;
- char * dll_symname = pe_data_import_dll ? pe_data_import_dll : "unknown";
+ char * symname = pe_data_import_dll ? pe_data_import_dll : "unknown";
- b = make_import_fixup_entry (name, fixup_name, dll_symname,
+ b = make_import_fixup_entry (name, fixup_name, symname,
link_info.output_bfd);
add_bfd_to_link (b, b->filename, &link_info);
}
- if (addend != 0)
- {
- if (link_info.pei386_runtime_pseudo_reloc)
- {
- if (pe_dll_extra_pe_debug)
- printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
- fixup_name, addend);
- b = make_runtime_pseudo_reloc (name, fixup_name, addend,
- link_info.output_bfd);
- add_bfd_to_link (b, b->filename, &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 (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
- {
- 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");
- }
- }
+ 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);
+
+ 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");
+ }
}
void
-pe_dll_generate_implib (def_file *def, const char *impfilename)
+pe_dll_generate_implib (def_file *def, const char *impfilename, struct bfd_link_info *info)
{
int i;
bfd *ar_head;
bfd *ar_tail;
bfd *outarch;
+ bfd *ibfd;
bfd *head = 0;
dll_filename = (def->name) ? def->name : dll_name;
/* xgettext:c-format */
info_msg (_("Creating library file: %s\n"), impfilename);
-
+
bfd_set_format (outarch, bfd_archive);
outarch->has_armap = 1;
/* Work out a reasonable size of things to put onto one line. */
ar_head = make_head (outarch);
+ /* Iterate the input BFDs, looking for exclude-modules-for-implib. */
+ for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link_next)
+ {
+ /* Iterate the exclude list. */
+ struct exclude_list_struct *ex;
+ char found;
+ for (ex = excludes, found = 0; ex && !found; ex = ex->next)
+ {
+ if (ex->type != EXCLUDEFORIMPLIB)
+ continue;
+ found = (filename_cmp (ex->string, ibfd->filename) == 0);
+ }
+ /* If it matched, we must open a fresh BFD for it (the original
+ input BFD is still needed for the DLL's final link) and add
+ it into the archive member chain. */
+ if (found)
+ {
+ bfd *newbfd = bfd_openr (ibfd->my_archive
+ ? ibfd->my_archive->filename : ibfd->filename, NULL);
+ if (!newbfd)
+ {
+ einfo (_("%Xbfd_openr %s: %E\n"), ibfd->filename);
+ return;
+ }
+ if (ibfd->my_archive)
+ {
+ /* Must now iterate through archive until we find the
+ required member. A minor shame that we'll open the
+ archive once per member that we require from it, and
+ leak those archive bfds rather than reuse them. */
+ bfd *arbfd = newbfd;
+ if (!bfd_check_format_matches (arbfd, bfd_archive, NULL))
+ {
+ einfo (_("%X%s(%s): can't find member in non-archive file"),
+ ibfd->my_archive->filename, ibfd->filename);
+ return;
+ }
+ newbfd = NULL;
+ while ((newbfd = bfd_openr_next_archived_file (arbfd, newbfd)) != 0)
+ {
+ if (filename_cmp (newbfd->filename, ibfd->filename) == 0)
+ break;
+ }
+ if (!newbfd)
+ {
+ einfo (_("%X%s(%s): can't find member in archive"),
+ ibfd->my_archive->filename, ibfd->filename);
+ return;
+ }
+ }
+ newbfd->archive_next = head;
+ head = newbfd;
+ }
+ }
+
for (i = 0; i < def->num_exports; i++)
{
/* The import library doesn't know about the internal name. */
char *internal = def->exports[i].internal_name;
bfd *n;
- /* Don't add PRIVATE entries to import lib. */
+ /* Don't add PRIVATE entries to import lib. */
if (pe_def_file->exports[i].flag_private)
continue;
def->exports[i].internal_name = def->exports[i].name;
}
}
+static struct bfd_link_hash_entry *found_sym;
+
+static bfd_boolean
+pe_undef_alias_cdecl_match (struct bfd_link_hash_entry *h, void *inf)
+{
+ int sl;
+ char *string = inf;
+ const char *hs = h->root.string;
+
+ sl = strlen (string);
+ if (h->type == bfd_link_hash_undefined
+ && ((*hs == '@' && (!pe_details->underscored || *string == '_')
+ && strncmp (hs + 1, string + (pe_details->underscored != 0),
+ sl - (pe_details->underscored != 0)) == 0)
+ || strncmp (hs, string, sl) == 0)
+ && h->root.string[sl] == '@')
+ {
+ found_sym = h;
+ return FALSE;
+ }
+ return TRUE;
+}
+
+static struct bfd_link_hash_entry *
+pe_find_cdecl_alias_match (char *name)
+{
+ found_sym = 0;
+ bfd_link_hash_traverse (link_info.hash, pe_undef_alias_cdecl_match,
+ (char *) name);
+ return found_sym;
+}
+
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))
+ if (!bfd_link_add_symbols (abfd, linfo))
einfo ("%Xaddsym %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;
size_t len = strlen (pe_def_file->imports[i].internal_name);
char *name = xmalloc (len + 2 + 6);
bfd_boolean include_jmp_stub = FALSE;
+ bfd_boolean is_cdecl = FALSE;
+ if (!lead_at && strchr (pe_def_file->imports[i].internal_name, '@') == NULL)
+ is_cdecl = TRUE;
if (lead_at)
sprintf (name, "%s",
sprintf (name, "%s%s",U (""),
pe_def_file->imports[i].internal_name);
- blhe = bfd_link_hash_lookup (link_info->hash, name,
+ blhe = bfd_link_hash_lookup (linfo->hash, name,
FALSE, FALSE, FALSE);
/* Include the jump stub for <sym> only if the <sym>
if (!blhe || (blhe && blhe->type != bfd_link_hash_undefined))
{
if (lead_at)
- sprintf (name, "%s%s", "__imp_",
+ sprintf (name, "%s%s", "__imp_",
pe_def_file->imports[i].internal_name);
else
sprintf (name, "%s%s%s", "__imp_", U (""),
pe_def_file->imports[i].internal_name);
- blhe = bfd_link_hash_lookup (link_info->hash, name,
+ blhe = bfd_link_hash_lookup (linfo->hash, name,
FALSE, FALSE, FALSE);
}
else
include_jmp_stub = TRUE;
+ if (is_cdecl && !blhe)
+ {
+ sprintf (name, "%s%s",U (""),
+ pe_def_file->imports[i].internal_name);
+ blhe = pe_find_cdecl_alias_match (name);
+ include_jmp_stub = TRUE;
+ }
+
free (name);
if (blhe && blhe->type == bfd_link_hash_undefined)
if (!do_this_dll)
{
bfd *ar_head = make_head (output_bfd);
- add_bfd_to_link (ar_head, ar_head->filename, link_info);
+ add_bfd_to_link (ar_head, ar_head->filename, linfo);
do_this_dll = 1;
}
exp.internal_name = pe_def_file->imports[i].internal_name;
exp.name = pe_def_file->imports[i].name;
+ exp.its_name = pe_def_file->imports[i].its_name;
exp.ordinal = pe_def_file->imports[i].ordinal;
exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
exp.flag_private = 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);
+ add_bfd_to_link (one, one->filename, linfo);
}
}
if (do_this_dll)
{
bfd *ar_tail = make_tail (output_bfd);
- add_bfd_to_link (ar_tail, ar_tail->filename, link_info);
+ add_bfd_to_link (ar_tail, ar_tail->filename, linfo);
}
free (dll_symname);
pe_implied_import_dll (const char *filename)
{
bfd *dll;
- unsigned long pe_header_offset, opthdr_ofs, num_entries, i;
- unsigned long export_rva, export_size, nsections, secptr, expptr;
- unsigned long exp_funcbase;
+ bfd_vma pe_header_offset, opthdr_ofs, num_entries, i;
+ bfd_vma export_rva, export_size, nsections, secptr, expptr;
+ bfd_vma exp_funcbase;
unsigned char *expdata;
char *erva;
- unsigned long 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. */
- unsigned long data_start = 1;
- unsigned long data_end = 0;
- unsigned long rdata_start = 1;
- unsigned long rdata_end = 0;
- unsigned long bss_start = 1;
- unsigned long bss_end = 0;
+ bfd_vma data_start = 1;
+ bfd_vma data_end = 0;
+ bfd_vma rdata_start = 1;
+ bfd_vma rdata_end = 0;
+ bfd_vma bss_start = 1;
+ bfd_vma bss_end = 0;
/* No, I can't use bfd here. kernel32.dll puts its export table in
the middle of the .rdata section. */
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
num_entries = pe_get32 (dll, opthdr_ofs + 92);
#endif
- if (num_entries < 1) /* No exports. */
+ /* No import or export directory entry. */
+ if (num_entries < 1)
return FALSE;
#ifdef pe_use_x86_64
export_rva = pe_get32 (dll, opthdr_ofs + 96);
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));
for (i = 0; i < nsections; i++)
{
char sname[8];
- unsigned long secptr1 = secptr + 40 * i;
- unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
- unsigned long vsize = pe_get32 (dll, secptr1 + 16);
- unsigned long fptr = pe_get32 (dll, secptr1 + 20);
+ bfd_vma secptr1 = secptr + 40 * i;
+ bfd_vma vaddr = pe_get32 (dll, secptr1 + 12);
+ bfd_vma vsize = pe_get32 (dll, secptr1 + 16);
+ bfd_vma fptr = pe_get32 (dll, secptr1 + 20);
bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
bfd_bread (sname, (bfd_size_type) 8, dll);
data and bss segments in data/base_start/end. */
for (i = 0; i < nsections; i++)
{
- unsigned long secptr1 = secptr + 40 * i;
- unsigned long vsize = pe_get32 (dll, secptr1 + 8);
- unsigned long vaddr = pe_get32 (dll, secptr1 + 12);
- unsigned long flags = pe_get32 (dll, secptr1 + 36);
+ bfd_vma secptr1 = secptr + 40 * i;
+ bfd_vma vsize = pe_get32 (dll, secptr1 + 8);
+ bfd_vma vaddr = pe_get32 (dll, secptr1 + 12);
+ bfd_vma flags = pe_get32 (dll, secptr1 + 36);
char sec_name[9];
sec_name[8] = '\0';
if (pe_dll_extra_pe_debug)
printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
- __FUNCTION__, sec_name, vaddr, vaddr + vsize, flags);
+ __FUNCTION__, 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, vaddr, vaddr + vsize, flags);
+ __FUNCTION__, 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, vaddr, vaddr + vsize, flags);
+ __FUNCTION__, 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);
+ printf ("%s is already loaded\n", dllname);
return TRUE;
}
for (i = 0; i < nexp; i++)
{
/* Pointer to the names vector. */
- unsigned long name_rva = pe_as32 (erva + name_rvas + i * 4);
+ bfd_vma name_rva = pe_as32 (erva + name_rvas + i * 4);
def_file_import *imp;
/* Pointer to the function address vector. */
- unsigned long func_rva = pe_as32 (erva + exp_funcbase + i * 4);
+ bfd_vma func_rva = pe_as32 (erva + exp_funcbase + i * 4);
int is_data = 0;
/* Skip unwanted symbols, which are
exported in buggy auto-import releases. */
- if (! CONST_STRNEQ (erva + name_rva, "_nm_"))
+ if (! CONST_STRNEQ (erva + name_rva, "__nm_"))
{
/* is_data is true if the address is in the data, rdata or bss
segment. */
|| (func_rva >= bss_start && func_rva < bss_end);
imp = def_file_add_import (pe_def_file, erva + name_rva,
- dll_name, i, 0);
+ dllname, i, 0, 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__, dll_name, erva + name_rva,
- func_rva, is_data ? "(data)" : "");
+ __FUNCTION__, dllname, erva + name_rva,
+ (unsigned long) func_rva, is_data ? "(data)" : "");
}
}
return TRUE;
}
+void
+pe_output_file_set_long_section_names (bfd *abfd)
+{
+ if (pe_use_coff_long_section_names < 0)
+ return;
+ if (!bfd_coff_set_long_section_names (abfd, pe_use_coff_long_section_names))
+ einfo (_("%XError: can't use long section names on this arch\n"));
+}
+
/* These are the main functions, called from the emulation. The first
is called after the bfds are read, so we can guess at how much space
we need. The second is called after everything is placed, so we
pe_dll_build_sections (bfd *abfd, struct bfd_link_info *info)
{
pe_dll_id_target (bfd_get_target (abfd));
- process_def_file (abfd, info);
+ pe_output_file_set_long_section_names (abfd);
+ process_def_file_and_drectve (abfd, info);
if (pe_def_file->num_exports == 0 && !info->shared)
return;
generate_edata (abfd, info);
build_filler_bfd (1);
+ pe_output_file_set_long_section_names (filler_bfd);
}
void
pe_exe_build_sections (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
{
pe_dll_id_target (bfd_get_target (abfd));
+ pe_output_file_set_long_section_names (abfd);
build_filler_bfd (0);
+ pe_output_file_set_long_section_names (filler_bfd);
}
void
pe_dll_fill_sections (bfd *abfd, struct bfd_link_info *info)
{
pe_dll_id_target (bfd_get_target (abfd));
+ pe_output_file_set_long_section_names (abfd);
image_base = pe_data (abfd)->pe_opthdr.ImageBase;
generate_reloc (abfd, info);
pe_exe_fill_sections (bfd *abfd, struct bfd_link_info *info)
{
pe_dll_id_target (bfd_get_target (abfd));
+ pe_output_file_set_long_section_names (abfd);
image_base = pe_data (abfd)->pe_opthdr.ImageBase;
generate_reloc (abfd, info);
projects / deliverable / binutils-gdb.git / blobdiff