diff options
| author | Andrew Hsieh <andrewhsieh@google.com> | 2014-06-13 12:38:00 -0700 |
|---|---|---|
| committer | Andrew Hsieh <andrewhsieh@google.com> | 2014-06-13 12:38:00 -0700 |
| commit | 54f1b3cf509cd889905287cb8ce6c5ae33911a21 (patch) | |
| tree | e39b1a7fa04db86a8215b7f9d4656d74e394aec0 /binutils-2.25/ld/pe-dll.c | |
| parent | 2a6558a8ecfb81d75215b4ec7dc61113e12cfd5f (diff) | |
| download | toolchain_binutils-54f1b3cf509cd889905287cb8ce6c5ae33911a21.tar.gz toolchain_binutils-54f1b3cf509cd889905287cb8ce6c5ae33911a21.tar.bz2 toolchain_binutils-54f1b3cf509cd889905287cb8ce6c5ae33911a21.zip | |
Add upstream binutils-2.25 snapshot 4/4 2014
For MIPS -mmsa support
Change-Id: I08c4f002fa7b33dec85ed75956e6ab551bb03c96
Diffstat (limited to 'binutils-2.25/ld/pe-dll.c')
| -rw-r--r-- | binutils-2.25/ld/pe-dll.c | 3452 |
1 files changed, 3452 insertions, 0 deletions
diff --git a/binutils-2.25/ld/pe-dll.c b/binutils-2.25/ld/pe-dll.c new file mode 100644 index 00000000..bd3195f4 --- /dev/null +++ b/binutils-2.25/ld/pe-dll.c @@ -0,0 +1,3452 @@ +/* Routines to help build PEI-format DLLs (Win32 etc) + Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, + 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc. + Written by DJ Delorie <dj@cygnus.com> + + This file is part of the GNU Binutils. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, + MA 02110-1301, USA. */ + +#include "sysdep.h" +#include "bfd.h" +#include "bfdlink.h" +#include "libiberty.h" +#include "filenames.h" +#include "safe-ctype.h" + +#include <time.h> + +#include "ld.h" +#include "ldexp.h" +#include "ldlang.h" +#include "ldwrite.h" +#include "ldmisc.h" +#include <ldgram.h> +#include "ldmain.h" +#include "ldfile.h" +#include "ldemul.h" +#include "coff/internal.h" +#include "../bfd/libcoff.h" +#include "deffile.h" + +#ifdef pe_use_x86_64 + +#define PE_IDATA4_SIZE 8 +#define PE_IDATA5_SIZE 8 +#include "pep-dll.h" +#undef AOUTSZ +#define AOUTSZ PEPAOUTSZ +#define PEAOUTHDR PEPAOUTHDR + +#else + +#include "pe-dll.h" + +#endif + +#ifndef PE_IDATA4_SIZE +#define PE_IDATA4_SIZE 4 +#endif + +#ifndef PE_IDATA5_SIZE +#define PE_IDATA5_SIZE 4 +#endif + +/* This file turns a regular Windows PE image into a DLL. Because of + the complexity of this operation, it has been broken down into a + number of separate modules which are all called by the main function + at the end of this file. This function is not re-entrant and is + normally only called once, so static variables are used to reduce + the number of parameters and return values required. + + See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */ + +/* Auto-import feature by Paul Sokolovsky + + Quick facts: + + 1. With this feature on, DLL clients can import variables from DLL + without any concern from their side (for example, without any source + code modifications). + + 2. This is done completely in bounds of the PE specification (to be fair, + there's a place where it pokes nose out of, but in practice it works). + So, resulting module can be used with any other PE compiler/linker. + + 3. Auto-import is fully compatible with standard import method and they + can be mixed together. + + 4. Overheads: space: 8 bytes per imported symbol, plus 20 for each + reference to it; load time: negligible; virtual/physical memory: should be + less than effect of DLL relocation, and I sincerely hope it doesn't affect + DLL sharability (too much). + + Idea + + The obvious and only way to get rid of dllimport insanity is to make client + access variable directly in the DLL, bypassing extra dereference. I.e., + whenever client contains something like + + mov dll_var,%eax, + + address of dll_var in the command should be relocated to point into loaded + DLL. The aim is to make OS loader do so, and than make ld help with that. + Import section of PE made following way: there's a vector of structures + each describing imports from particular DLL. Each such structure points + to two other parallel vectors: one holding imported names, and one which + will hold address of corresponding imported name. So, the solution is + de-vectorize these structures, making import locations be sparse and + pointing directly into code. Before continuing, it is worth a note that, + while authors strives to make PE act ELF-like, there're some other people + make ELF act PE-like: elfvector, ;-) . + + Implementation + + For each reference of data symbol to be imported from DLL (to set of which + belong symbols with name <sym>, if __imp_<sym> is found in implib), the + import fixup entry is generated. That entry is of type + IMAGE_IMPORT_DESCRIPTOR and stored in .idata$2 subsection. Each + fixup entry contains pointer to symbol's address within .text section + (marked with __fuN_<sym> symbol, where N is integer), pointer to DLL name + (so, DLL name is referenced by multiple entries), and pointer to symbol + name thunk. Symbol name thunk is singleton vector (__nm_th_<symbol>) + pointing to IMAGE_IMPORT_BY_NAME structure (__nm_<symbol>) directly + containing imported name. Here comes that "on the edge" problem mentioned + above: PE specification rambles that name vector (OriginalFirstThunk) + 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 + 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 + overhead is 20 bytes per reference. Other question is whether having several + IMAGE_IMPORT_DESCRIPTORS for the same DLL is possible. Answer is yes, it is + done even by native compiler/linker (libth32's functions are in fact reside + in windows9x kernel32.dll, so if you use it, you have two + IMAGE_IMPORT_DESCRIPTORS for kernel32.dll). Yet other question is whether + referencing the same PE structures several times is valid. The answer is why + not, prohibiting that (detecting violation) would require more work on + behalf of loader than not doing it. + + See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */ + +static void add_bfd_to_link (bfd *, const char *, struct bfd_link_info *); + +/* For emultempl/pe.em. */ + +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 bfd_vma image_base; +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 int runtime_pseudo_relocs_created = 0; +static int runtime_pseudp_reloc_v2_init = 0; + +typedef struct +{ + const char *name; + int len; +} +autofilter_entry_type; + +typedef struct +{ + const char *target_name; + const char *object_target; + unsigned int imagebase_reloc; + int pe_arch; + int bfd_arch; + bfd_boolean underscored; + const autofilter_entry_type* autofilter_symbollist; +} +pe_details_type; + +static const autofilter_entry_type autofilter_symbollist_generic[] = +{ + { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") }, + /* Entry point symbols. */ + { STRING_COMMA_LEN ("DllMain") }, + { STRING_COMMA_LEN ("DllMainCRTStartup") }, + { STRING_COMMA_LEN ("_DllMainCRTStartup") }, + /* Runtime pseudo-reloc. */ + { STRING_COMMA_LEN ("_pei386_runtime_relocator") }, + { STRING_COMMA_LEN ("do_pseudo_reloc") }, + { NULL, 0 } +}; + +static const autofilter_entry_type autofilter_symbollist_i386[] = +{ + { 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 ("DllMain") }, + { STRING_COMMA_LEN ("DllEntryPoint") }, + { STRING_COMMA_LEN ("DllMainCRTStartup") }, + { STRING_COMMA_LEN ("_cygwin_dll_entry") }, + { STRING_COMMA_LEN ("_cygwin_crt0_common") }, + { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry") }, +#else + { STRING_COMMA_LEN ("DllMain@12") }, + { STRING_COMMA_LEN ("DllEntryPoint@0") }, + { STRING_COMMA_LEN ("DllMainCRTStartup@12") }, + { STRING_COMMA_LEN ("_cygwin_dll_entry@12") }, + { STRING_COMMA_LEN ("_cygwin_crt0_common@8") }, + { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry@12") }, + { STRING_COMMA_LEN ("cygwin_attach_dll") }, +#endif + { STRING_COMMA_LEN ("cygwin_premain0") }, + { STRING_COMMA_LEN ("cygwin_premain1") }, + { STRING_COMMA_LEN ("cygwin_premain2") }, + { STRING_COMMA_LEN ("cygwin_premain3") }, + /* Runtime pseudo-reloc. */ + { STRING_COMMA_LEN ("_pei386_runtime_relocator") }, + { STRING_COMMA_LEN ("do_pseudo_reloc") }, + /* Global vars that should not be exported. */ + { STRING_COMMA_LEN ("impure_ptr") }, + { STRING_COMMA_LEN ("_impure_ptr") }, + { STRING_COMMA_LEN ("_fmode") }, + { STRING_COMMA_LEN ("environ") }, + { NULL, 0 } +}; + +#define PE_ARCH_i386 1 +#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 + +/* 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 + "pei-x86-64", + "pe-x86-64", + 3 /* R_IMAGEBASE */, +#else + "pei-i386", + "pe-i386", + 7 /* R_IMAGEBASE */, +#endif + PE_ARCH_i386, + bfd_arch_i386, +#ifdef pe_use_x86_64 + FALSE, +#else + TRUE, +#endif + autofilter_symbollist_i386 + }, + { + "pei-shl", + "pe-shl", + 16 /* R_SH_IMAGEBASE */, + PE_ARCH_sh, + bfd_arch_sh, + TRUE, + autofilter_symbollist_generic + }, + { + "pei-mips", + "pe-mips", + 34 /* MIPS_R_RVA */, + PE_ARCH_mips, + bfd_arch_mips, + FALSE, + autofilter_symbollist_generic + }, + { + "pei-arm-little", + "pe-arm-little", + 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, + autofilter_symbollist_generic + }, + { + "pei-arm-wince-little", + "pe-arm-wince-little", + 2, /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c. */ + PE_ARCH_arm_wince, + bfd_arch_arm, + FALSE, + autofilter_symbollist_generic + }, + { NULL, NULL, 0, 0, 0, FALSE, NULL } +}; + +static const pe_details_type *pe_details; + +/* Do not specify library suffix explicitly, to allow for dllized versions. */ +static const autofilter_entry_type autofilter_liblist[] = +{ + { 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") }, + { STRING_COMMA_LEN ("libg2c") }, + { STRING_COMMA_LEN ("libsupc++") }, + { STRING_COMMA_LEN ("libobjc") }, + { STRING_COMMA_LEN ("libgcj") }, + { 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 ("crt1.o") }, + { STRING_COMMA_LEN ("crt2.o") }, + { STRING_COMMA_LEN ("dllcrt1.o") }, + { STRING_COMMA_LEN ("dllcrt2.o") }, + { STRING_COMMA_LEN ("gcrt0.o") }, + { STRING_COMMA_LEN ("gcrt1.o") }, + { STRING_COMMA_LEN ("gcrt2.o") }, + { STRING_COMMA_LEN ("crtbegin.o") }, + { STRING_COMMA_LEN ("crtend.o") }, + { NULL, 0 } +}; + +static const autofilter_entry_type autofilter_symbolprefixlist[] = +{ + /* _imp_ is treated specially, as it is always underscored. */ + /* { STRING_COMMA_LEN ("_imp_") }, */ + /* Don't export some c++ symbols. */ + { STRING_COMMA_LEN ("__rtti_") }, + { STRING_COMMA_LEN ("__builtin_") }, + /* Don't re-export auto-imported symbols. */ + { 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 } +}; + +#define U(str) (pe_details->underscored ? "_" str : str) + +void +pe_dll_id_target (const char *target) +{ + int i; + + for (i = 0; pe_detail_list[i].target_name; i++) + 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); + exit (1); +} + +/* Helper functions for qsort. Relocs must be sorted so that we can write + them out by pages. */ + +typedef struct + { + bfd_vma vma; + char type; + short extra; + } +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; + + return (a > b) ? 1 : ((a < b) ? -1 : 0); +} + +static int +pe_export_sort (const void *va, const void *vb) +{ + const def_file_export *a = va; + const def_file_export *b = vb; + 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. */ + +/* These correspond to the entries in pe_def_file->exports[]. I use + exported_symbol_sections[i] to tag whether or not the symbol was + defined, since we can't export symbols we don't have. */ + +static bfd_vma *exported_symbol_offsets; +static struct bfd_section **exported_symbol_sections; +static int export_table_size; +static int count_exported; +static int count_exported_byname; +static int count_with_ordinals; +static const char *dll_name; +static int min_ordinal, max_ordinal; +static int *exported_symbols; + +typedef struct exclude_list_struct + { + char *string; + struct exclude_list_struct *next; + exclude_type type; + } +exclude_list_struct; + +static struct exclude_list_struct *excludes = 0; + +void +pe_dll_add_excludes (const char *new_excludes, const exclude_type type) +{ + char *local_copy; + char *exclude_string; + + local_copy = xstrdup (new_excludes); + + exclude_string = strtok (local_copy, ",:"); + for (; exclude_string; exclude_string = strtok (NULL, ",:")) + { + struct exclude_list_struct *new_exclude; + + new_exclude = xmalloc (sizeof (struct exclude_list_struct)); + new_exclude->string = xmalloc (strlen (exclude_string) + 1); + strcpy (new_exclude->string, exclude_string); + new_exclude->type = type; + new_exclude->next = excludes; + excludes = new_exclude; + } + + free (local_copy); +} + +static bfd_boolean +is_import (const char* n) +{ + return (CONST_STRNEQ (n, "__imp_")); +} + +/* abfd is a bfd containing n (or NULL) + It can be used for contextual checks. */ + +static int +auto_export (bfd *abfd, def_file *d, const char *n) +{ + def_file_export key; + struct exclude_list_struct *ex; + const autofilter_entry_type *afptr; + const char * libname = NULL; + + if (abfd && abfd->my_archive) + libname = lbasename (abfd->my_archive->filename); + + key.name = key.its_name = (char *) n; + + /* Return false if n is in the d->exports table. */ + if (bsearch (&key, d->exports, d->num_exports, + sizeof (pe_def_file->exports[0]), pe_export_sort)) + return 0; + + if (pe_dll_do_default_excludes) + { + const char * p; + int len; + + if (pe_dll_extra_pe_debug) + printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n", + n, abfd, abfd->my_archive); + + /* First of all, make context checks: + Don't export anything from standard libs. */ + if (libname) + { + afptr = autofilter_liblist; + + while (afptr->name) + { + if (libnamencmp (libname, afptr) == 0 ) + return 0; + afptr++; + } + } + + /* Next, exclude symbols from certain startup objects. */ + + if (abfd && (p = lbasename (abfd->filename))) + { + afptr = autofilter_objlist; + while (afptr->name) + { + if (strcmp (p, afptr->name) == 0) + return 0; + afptr++; + } + } + + /* Don't try to blindly exclude all symbols + 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; + + while (afptr->name) + { + if (strcmp (n, afptr->name) == 0) + return 0; + + afptr++; + } + + /* Next, exclude symbols starting with ... */ + afptr = autofilter_symbolprefixlist; + while (afptr->name) + { + if (strncmp (n, afptr->name, afptr->len) == 0) + return 0; + + afptr++; + } + + /* Finally, exclude symbols ending with ... */ + len = strlen (n); + afptr = autofilter_symbolsuffixlist; + while (afptr->name) + { + if ((len >= afptr->len) + /* Add 1 to insure match with trailing '\0'. */ + && strncmp (n + len - afptr->len, afptr->name, + afptr->len + 1) == 0) + return 0; + + afptr++; + } + } + + for (ex = excludes; ex; ex = ex->next) + { + if (ex->type == EXCLUDELIBS) + { + if (libname + && ((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; + } + + return 1; +} + +static void +process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info) +{ + int i, j; + struct bfd_link_hash_entry *blhe; + bfd *b; + struct bfd_section *s; + def_file_export *e = 0; + bfd_boolean 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) + { + s = bfd_get_section_by_name (b, ".drectve"); + if (s) + { + long size = s->size; + char *buf = xmalloc (size); + + bfd_get_section_contents (b, s, buf, 0, size); + def_file_add_directive (pe_def_file, buf, size); + free (buf); + } + } + + /* 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) + && !pe_dll_exclude_all_symbols) + { + 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); + 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. */ + bfd_boolean would_export + = (symbols[j]->section != bfd_und_section_ptr + && ((symbols[j]->flags & BSF_GLOBAL) + || (symbols[j]->flags == 0))); + if (link_info.version_info && would_export) + would_export + = !bfd_hide_sym_by_version (link_info.version_info, + symbols[j]->name); + if (would_export) + { + const char *sn = symbols[j]->name; + + /* We should not re-export imported stuff. */ + { + char *name; + if (is_import (sn)) + 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); + free (name); + + if (blhe && blhe->type == bfd_link_hash_defined) + continue; + } + + if (pe_details->underscored && *sn == '_') + sn++; + + if (auto_export (b, pe_def_file, sn)) + { + int is_dup = 0; + def_file_export *p; + + p = def_file_add_export (pe_def_file, sn, 0, -1, + NULL, &is_dup); + /* Fill data flag properly, from dlltool.c. */ + 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++) + { + /* 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 = strrchr (tmp, '@'); + + if (tmp_at) + *tmp_at = 0; + else + einfo (_("%XCannot 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 (is_import (pe_def_file->exports[i].name)) + continue; + + if (strchr (pe_def_file->exports[i].name, '@')) + { + int is_dup = 1; + int lead_at = (*pe_def_file->exports[i].name == '@'); + char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at); + + *(strchr (tmp, '@')) = 0; + if (auto_export (NULL, pe_def_file, tmp)) + def_file_add_export (pe_def_file, tmp, + pe_def_file->exports[i].internal_name, + -1, NULL, &is_dup); + if (is_dup) + free (tmp); + } + } + } + + /* Convenience, but watch out for it changing. */ + e = pe_def_file->exports; + + for (i = 0, j = 0; i < NE; i++) + { + if (i > 0 && strcmp (e[i].name, e[i - 1].name) == 0) + { + /* This is a duplicate. */ + if (e[j - 1].ordinal != -1 + && e[i].ordinal != -1 + && e[j - 1].ordinal != e[i].ordinal) + { + if (pe_dll_warn_dup_exports) + /* xgettext:c-format */ + einfo (_("%XError, 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"), + e[j - 1].name); + } + + if (e[i].ordinal != -1) + e[j - 1].ordinal = e[i].ordinal; + e[j - 1].flag_private |= e[i].flag_private; + 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); + } + else + { + if (i != j) + e[j] = e[i]; + j++; + } + } + 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 *name; + name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2); + if (pe_details->underscored + && (*pe_def_file->exports[i].internal_name != '@')) + { + *name = '_'; + strcpy (name + 1, pe_def_file->exports[i].internal_name); + } + else + strcpy (name, pe_def_file->exports[i].internal_name); + + blhe = bfd_link_hash_lookup (info->hash, + name, + FALSE, FALSE, TRUE); + + if (blhe + && (blhe->type == bfd_link_hash_defined + || (blhe->type == bfd_link_hash_common))) + { + count_exported++; + if (!pe_def_file->exports[i].flag_noname) + count_exported_byname++; + + /* Only fill in the sections. The actual offsets are computed + in fill_exported_offsets() after common symbols are laid + out. */ + if (blhe->type == bfd_link_hash_defined) + exported_symbol_sections[i] = blhe->u.def.section; + 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) + 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++; + } + } + 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); + } + else if (blhe) + { + /* xgettext:c-format */ + einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"), + pe_def_file->exports[i].internal_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); + } + free (name); + } +} + +/* Build the bfd that will contain .edata and .reloc sections. */ + +static void +build_filler_bfd (int include_edata) +{ + lang_input_statement_type *filler_file; + filler_file = lang_add_input_file ("dll stuff", + lang_input_file_is_fake_enum, + NULL); + filler_file->the_bfd = filler_bfd = bfd_create ("dll stuff", + link_info.output_bfd); + if (filler_bfd == NULL + || !bfd_set_arch_mach (filler_bfd, + bfd_get_arch (link_info.output_bfd), + bfd_get_mach (link_info.output_bfd))) + { + einfo ("%X%P: can not create BFD: %E\n"); + return; + } + + if (include_edata) + { + 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))) + { + einfo ("%X%P: can not create .edata section: %E\n"); + return; + } + bfd_set_section_size (filler_bfd, 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"); + return; + } + + bfd_set_section_size (filler_bfd, reloc_s, 0); + + 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) +{ + 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) + min_ordinal = max_ordinal - count_exported + 1; + } + else + { + min_ordinal = 1; + max_ordinal = count_exported; + } + + export_table_size = max_ordinal - min_ordinal + 1; + exported_symbols = xmalloc (export_table_size * sizeof (int)); + for (i = 0; i < export_table_size; i++) + exported_symbols[i] = -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 (pe_def_file->exports[i].ordinal != -1) + { + int ei = pe_def_file->exports[i].ordinal - min_ordinal; + int pi = exported_symbols[ei]; + + if (pi != -1) + { + /* xgettext:c-format */ + einfo (_("%XError, 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; + } + 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. */ + if (pe_def_file->exports[i].flag_forward) + { + name_table_size += strlen (pe_def_file->exports[i].internal_name) + 1; + } + } + + 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) + { + while (exported_symbols[next_ordinal - min_ordinal] != -1) + next_ordinal++; + + exported_symbols[next_ordinal - min_ordinal] = i; + pe_def_file->exports[i].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); +} + +/* Fill the exported symbol offsets. The preliminary work has already + been done in process_def_file_and_drectve(). */ + +static void +fill_exported_offsets (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info) +{ + int i; + struct bfd_link_hash_entry *blhe; + + for (i = 0; i < pe_def_file->num_exports; i++) + { + char *name; + + name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2); + if (pe_details->underscored + && *pe_def_file->exports[i].internal_name != '@') + { + *name = '_'; + strcpy (name + 1, pe_def_file->exports[i].internal_name); + } + else + strcpy (name, pe_def_file->exports[i].internal_name); + + blhe = bfd_link_hash_lookup (info->hash, + name, + FALSE, FALSE, TRUE); + + if (blhe && blhe->type == bfd_link_hash_defined) + exported_symbol_offsets[i] = blhe->u.def.value; + + free (name); + } +} + +static void +fill_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED) +{ + int s, hint; + unsigned char *edirectory; + unsigned char *eaddresses; + 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 = edirectory + 40; + enameptrs = eaddresses + 4 * export_table_size; + eordinals = enameptrs + 4 * count_exported_byname; + enamestr = (char *) eordinals + 2 * count_exported_byname; + +#define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \ + + edata_s->output_section->vma - image_base) + + memset (edata_d, 0, edata_sz); + bfd_put_32 (abfd, now, edata_d + 4); + if (pe_def_file->version_major != -1) + { + bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8); + bfd_put_16 (abfd, pe_def_file->version_minor, edata_d + 10); + } + + bfd_put_32 (abfd, ERVA (enamestr), edata_d + 12); + strcpy (enamestr, dll_name); + enamestr += strlen (enamestr) + 1; + bfd_put_32 (abfd, min_ordinal, edata_d + 16); + bfd_put_32 (abfd, export_table_size, edata_d + 20); + bfd_put_32 (abfd, count_exported_byname, edata_d + 24); + bfd_put_32 (abfd, ERVA (eaddresses), edata_d + 28); + bfd_put_32 (abfd, ERVA (enameptrs), edata_d + 32); + bfd_put_32 (abfd, ERVA (eordinals), edata_d + 36); + + fill_exported_offsets (abfd, info); + + /* Ok, now for the filling in part. + 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 + 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)) + { + 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)); + + strcpy (enamestr, pe_def_file->exports[s].internal_name); + enamestr += strlen (pe_def_file->exports[s].internal_name) + 1; + } + else + { + bfd_vma srva = (exported_symbol_offsets[s] + + ssec->output_section->vma + + ssec->output_offset); + + bfd_put_32 (abfd, srva - image_base, + 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; + strcpy (enamestr, ename); + enamestr += strlen (enamestr) + 1; + bfd_put_16 (abfd, ord - min_ordinal, eordinals); + eordinals += 2; + pe_def_file->exports[s].hint = hint++; + } + } + } +} + + +static struct bfd_section *current_sec; + +void +pe_walk_relocs_of_symbol (struct bfd_link_info *info, + const char *name, + int (*cb) (arelent *, asection *)) +{ + bfd *b; + asection *s; + + for (b = info->input_bfds; b; b = b->link_next) + { + asymbol **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) + { + arelent **relocs; + int relsize, nrelocs, i; + int flags = bfd_get_section_flags (b, s); + + /* Skip discarded linkonce sections. */ + if (flags & SEC_LINK_ONCE + && s->output_section == bfd_abs_section_ptr) + continue; + + current_sec = s; + + relsize = bfd_get_reloc_upper_bound (b, s); + relocs = xmalloc (relsize); + nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols); + + for (i = 0; i < nrelocs; i++) + { + struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr; + + if (!strcmp (name, sym->name)) + cb (relocs[i], s); + } + + free (relocs); + + /* Warning: the allocated symbols are remembered in BFD and reused + later, so don't free them! */ + /* free (symbols); */ + } + } +} + +/* 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 *b; + struct bfd_section *s; + + total_relocs = 0; + 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) + { + arelent **relocs; + int relsize, nrelocs; + + for (s = b->sections; s; s = s->next) + { + bfd_vma sec_vma = s->output_section->vma + s->output_offset; + asymbol **symbols; + + /* If it's not loaded, we don't need to relocate it this way. */ + if (!(s->output_section->flags & SEC_LOAD)) + 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_ptr) + continue; + + 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; + } + + 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); + + for (i = 0; i < nrelocs; i++) + { + if (pe_dll_extra_pe_debug) + { + struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr; + printf ("rel: %s\n", sym->name); + } + if (!relocs[i]->howto->pc_relative + && relocs[i]->howto->type != pe_details->imagebase_reloc) + { + struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr; + + /* 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_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; + } + + reloc_data[total_relocs].vma = sec_vma + relocs[i]->address; + +#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 + case BITS_AND_SHIFT (64, 0): + reloc_data[total_relocs].type = 10; + total_relocs++; + break; +#endif + case BITS_AND_SHIFT (32, 0): + reloc_data[total_relocs].type = 3; + total_relocs++; + break; + case BITS_AND_SHIFT (16, 0): + reloc_data[total_relocs].type = 2; + total_relocs++; + break; + case BITS_AND_SHIFT (16, 16): + reloc_data[total_relocs].type = 4; + /* 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 + it zero is safe. */ + reloc_data[total_relocs].extra = 0; + total_relocs++; + break; + case BITS_AND_SHIFT (26, 2): + reloc_data[total_relocs].type = 5; + total_relocs++; + break; + case BITS_AND_SHIFT (24, 2): + /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c + Those ARM_xxx definitions should go in proper + header someday. */ + if (relocs[i]->howto->type == 0 + /* Older GNU linkers used 5 instead of 0 for this reloc. */ + || relocs[i]->howto->type == 5) + /* This is an ARM_26D reloc, which is an ARM_26 reloc + that has already been fully processed during a + previous link stage, so ignore it here. */ + break; + /* Fall through. */ + default: + /* xgettext:c-format */ + einfo (_("%XError: %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! */ + } + } + + /* 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. */ + qsort (reloc_data, total_relocs, sizeof (*reloc_data), reloc_sort); + + for (i = 0; i < total_relocs; i++) + { + bfd_vma this_page = (reloc_data[i].vma >> 12); + + if (this_page != sec_page) + { + reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */ + reloc_sz += 8; + sec_page = this_page; + } + + reloc_sz += 2; + + if (reloc_data[i].type == 4) + reloc_sz += 2; + } + + reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */ + reloc_d = xmalloc (reloc_sz); + sec_page = (bfd_vma) -1; + reloc_sz = 0; + page_ptr = (bfd_vma) -1; + page_count = 0; + + for (i = 0; i < total_relocs; i++) + { + 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 != (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); + 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) + { + bfd_put_16 (abfd, reloc_data[i].extra, reloc_d + reloc_sz); + reloc_sz += 2; + } + + page_count++; + } + + while (reloc_sz & 3) + reloc_d[reloc_sz++] = 0; + + 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 + corresponds to it. */ + +static void +quoteput (char *s, FILE *f, int needs_quotes) +{ + char *cp; + + for (cp = s; *cp; cp++) + if (*cp == '\'' + || *cp == '"' + || *cp == '\\' + || ISSPACE (*cp) + || *cp == ',' + || *cp == ';') + needs_quotes = 1; + + if (needs_quotes) + { + putc ('"', f); + + while (*s) + { + if (*s == '"' || *s == '\\') + putc ('\\', f); + + putc (*s, f); + s++; + } + + putc ('"', f); + } + else + fputs (s, f); +} + +void +pe_dll_generate_def_file (const char *pe_out_def_filename) +{ + int i; + FILE *out = fopen (pe_out_def_filename, "w"); + + if (out == NULL) + /* xgettext:c-format */ + einfo (_("%s: Can't open output def file %s\n"), + program_name, pe_out_def_filename); + + if (pe_def_file) + { + if (pe_def_file->name) + { + if (pe_def_file->is_dll) + fprintf (out, "LIBRARY "); + else + fprintf (out, "NAME "); + + 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, "\n"); + } + + if (pe_def_file->description) + { + fprintf (out, "DESCRIPTION "); + quoteput (pe_def_file->description, out, 1); + fprintf (out, "\n"); + } + + if (pe_def_file->version_minor != -1) + fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major, + pe_def_file->version_minor); + else if (pe_def_file->version_major != -1) + fprintf (out, "VERSION %d\n", pe_def_file->version_major); + + if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1) + fprintf (out, "\n"); + + if (pe_def_file->stack_commit != -1) + fprintf (out, "STACKSIZE 0x%x,0x%x\n", + pe_def_file->stack_reserve, pe_def_file->stack_commit); + else if (pe_def_file->stack_reserve != -1) + fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve); + + if (pe_def_file->heap_commit != -1) + fprintf (out, "HEAPSIZE 0x%x,0x%x\n", + pe_def_file->heap_reserve, pe_def_file->heap_commit); + else if (pe_def_file->heap_reserve != -1) + fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve); + + if (pe_def_file->num_section_defs > 0) + { + fprintf (out, "\nSECTIONS\n\n"); + + for (i = 0; i < pe_def_file->num_section_defs; i++) + { + fprintf (out, " "); + quoteput (pe_def_file->section_defs[i].name, out, 0); + + if (pe_def_file->section_defs[i].class) + { + fprintf (out, " CLASS "); + quoteput (pe_def_file->section_defs[i].class, out, 0); + } + + if (pe_def_file->section_defs[i].flag_read) + fprintf (out, " READ"); + + if (pe_def_file->section_defs[i].flag_write) + fprintf (out, " WRITE"); + + if (pe_def_file->section_defs[i].flag_execute) + fprintf (out, " EXECUTE"); + + if (pe_def_file->section_defs[i].flag_shared) + fprintf (out, " SHARED"); + + fprintf (out, "\n"); + } + } + + if (pe_def_file->num_exports > 0) + { + fprintf (out, "EXPORTS\n"); + + for (i = 0; i < pe_def_file->num_exports; i++) + { + def_file_export *e = pe_def_file->exports + i; + fprintf (out, " "); + quoteput (e->name, out, 0); + + if (e->internal_name && strcmp (e->internal_name, e->name)) + { + fprintf (out, " = "); + quoteput (e->internal_name, out, 0); + } + + if (e->ordinal != -1) + fprintf (out, " @%d", e->ordinal); + + if (e->flag_private) + fprintf (out, " PRIVATE"); + + if (e->flag_constant) + fprintf (out, " CONSTANT"); + + if (e->flag_noname) + fprintf (out, " NONAME"); + + if (e->flag_data) + fprintf (out, " DATA"); + + fprintf (out, "\n"); + } + } + + if (pe_def_file->num_imports > 0) + { + fprintf (out, "\nIMPORTS\n\n"); + + for (i = 0; i < pe_def_file->num_imports; i++) + { + def_file_import *im = pe_def_file->imports + i; + fprintf (out, " "); + + if (im->internal_name + && (!im->name || strcmp (im->internal_name, im->name))) + { + quoteput (im->internal_name, out, 0); + fprintf (out, " = "); + } + + quoteput (im->module->name, out, 0); + fprintf (out, "."); + + if (im->name) + quoteput (im->name, out, 0); + else + fprintf (out, "%d", im->ordinal); + + if (im->its_name) + { + fprintf (out, " == "); + quoteput (im->its_name, out, 0); + } + + fprintf (out, "\n"); + } + } + } + else + fprintf (out, _("; no contents available\n")); + + if (fclose (out) == EOF) + /* xgettext:c-format */ + 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 bfd_und_section_ptr + +static asection * +quick_section (bfd *abfd, const char *name, int flags, int align) +{ + asection *sec; + 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); + /* Remember to undo this before trying to link internally! */ + sec->output_section = sec; + + sym = bfd_make_empty_symbol (abfd); + symtab[symptr++] = sym; + sym->name = sec->name; + sym->section = sec; + sym->flags = BSF_LOCAL; + sym->value = 0; + + return sec; +} + +static void +quick_symbol (bfd *abfd, + const char *n1, + const char *n2, + const char *n3, + asection *sec, + int flags, + int addr) +{ + asymbol *sym; + char *name = xmalloc (strlen (n1) + strlen (n2) + strlen (n3) + 1); + + strcpy (name, n1); + strcat (name, n2); + strcat (name, n3); + sym = bfd_make_empty_symbol (abfd); + sym->name = name; + sym->section = sec; + sym->flags = flags; + sym->value = addr; + symtab[symptr++] = sym; +} + +static arelent *reltab = 0; +static int relcount = 0, relsize = 0; + +static void +quick_reloc (bfd *abfd, bfd_size_type address, int which_howto, int symidx) +{ + if (relcount >= relsize - 1) + { + relsize += 10; + if (reltab) + reltab = xrealloc (reltab, relsize * sizeof (arelent)); + else + reltab = xmalloc (relsize * sizeof (arelent)); + } + reltab[relcount].address = address; + reltab[relcount].addend = 0; + reltab[relcount].howto = bfd_reloc_type_lookup (abfd, which_howto); + reltab[relcount].sym_ptr_ptr = symtab + symidx; + relcount++; +} + +static void +save_relocs (asection *sec) +{ + int i; + + sec->relocation = reltab; + sec->reloc_count = relcount; + sec->orelocation = xmalloc ((relcount + 1) * sizeof (arelent *)); + for (i = 0; i < relcount; i++) + sec->orelocation[i] = sec->relocation + i; + sec->orelocation[relcount] = 0; + sec->flags |= SEC_RELOC; + reltab = 0; + relcount = relsize = 0; +} + +/* .section .idata$2 + .global __head_my_dll + __head_my_dll: + .rva hname + .long 0 + .long 0 + .rva __my_dll_iname + .rva fthunk + + .section .idata$5 + .long 0 + fthunk: + + .section .idata$4 + .long 0 + hname: */ + +static bfd * +make_head (bfd *parent) +{ + asection *id2, *id5, *id4; + unsigned char *d2, *d5, *d4; + char *oname; + bfd *abfd; + + oname = xmalloc (20); + sprintf (oname, "d%06d.o", tmp_seq); + tmp_seq++; + + 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 (6 * sizeof (asymbol *)); + id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2); + id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2); + id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2); + quick_symbol (abfd, U ("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0); + quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0); + + /* OK, pay attention here. I got confused myself looking back at + it. We create a four-byte section to mark the beginning of the + list, and we include an offset of 4 in the section, so that the + 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); + d2 = xmalloc (20); + id2->contents = d2; + memset (d2, 0, 20); + 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); + + 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); + 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); + 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; +} + +/* .section .idata$4 + .long 0 + [.long 0] for PE+ + .section .idata$5 + .long 0 + [.long 0] for PE+ + .section idata$7 + .global __my_dll_iname + __my_dll_iname: + .asciz "my.dll" */ + +static bfd * +make_tail (bfd *parent) +{ + asection *id4, *id5, *id7; + unsigned char *d4, *d5, *d7; + int len; + char *oname; + bfd *abfd; + + oname = xmalloc (20); + sprintf (oname, "d%06d.o", tmp_seq); + tmp_seq++; + + 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 (5 * sizeof (asymbol *)); + id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2); + id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2); + 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); + d4 = xmalloc (PE_IDATA4_SIZE); + id4->contents = d4; + memset (d4, 0, PE_IDATA4_SIZE); + + bfd_set_section_size (abfd, 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); + d7 = xmalloc (len); + id7->contents = d7; + strcpy ((char *) d7, dll_filename); + /* If len was odd, the above + strcpy leaves behind an undefined byte. That is harmless, + but we set it to 0 just so the binary dumps are pretty. */ + d7[len - 1] = 0; + + bfd_set_symtab (abfd, symtab, symptr); + + bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE); + bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE); + bfd_set_section_contents (abfd, id7, d7, 0, len); + + bfd_make_readable (abfd); + return abfd; +} + +/* .text + .global _function + .global ___imp_function + .global __imp__function + _function: + jmp *__imp__function: + + .section idata$7 + .long __head_my_dll + + .section .idata$5 + ___imp_function: + __imp__function: + iat? + .section .idata$4 + iat? + .section .idata$6 + ID<ordinal>: + .short <hint> + .asciz "function" xlate? (add underscore, kill at) */ + +static const unsigned char jmp_ix86_bytes[] = +{ + 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90 +}; + +/* _function: + mov.l ip+8,r0 + mov.l @r0,r0 + jmp @r0 + nop + .dw __imp_function */ + +static const unsigned char jmp_sh_bytes[] = +{ + 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00 +}; + +/* _function: + lui $t0,<high:__imp_function> + lw $t0,<low:__imp_function> + jr $t0 + nop */ + +static const unsigned char jmp_mips_bytes[] = +{ + 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d, + 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 +}; + +static const unsigned char jmp_arm_bytes[] = +{ + 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */ + 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */ + 0, 0, 0, 0 +}; + + +static bfd * +make_one (def_file_export *exp, bfd *parent, bfd_boolean include_jmp_stub) +{ + asection *tx, *id7, *id5, *id4, *id6; + unsigned char *td = NULL, *d7, *d5, *d4, *d6 = NULL; + int len; + char *oname; + bfd *abfd; + const unsigned char *jmp_bytes = NULL; + int jmp_byte_count = 0; + + /* Include the jump stub section only if it is needed. A jump + stub is needed if the symbol being imported <sym> is a function + symbol and there is at least one undefined reference to that + symbol. In other words, if all the import references to <sym> are + explicitly through _declspec(dllimport) then the jump stub is not + needed. */ + if (include_jmp_stub) + { + switch (pe_details->pe_arch) + { + case PE_ARCH_i386: + jmp_bytes = jmp_ix86_bytes; + jmp_byte_count = sizeof (jmp_ix86_bytes); + break; + case PE_ARCH_sh: + jmp_bytes = jmp_sh_bytes; + jmp_byte_count = sizeof (jmp_sh_bytes); + break; + case PE_ARCH_mips: + jmp_bytes = jmp_mips_bytes; + 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; + default: + abort (); + } + } + + oname = xmalloc (20); + sprintf (oname, "d%06d.o", tmp_seq); + tmp_seq++; + + 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 (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); + id6 = quick_section (abfd, ".idata$6", SEC_HAS_CONTENTS, 2); + + if (*exp->internal_name == '@') + { + quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC, + BSF_GLOBAL, 0); + if (include_jmp_stub) + quick_symbol (abfd, "", exp->internal_name, "", tx, BSF_GLOBAL, 0); + quick_symbol (abfd, "__imp_", exp->internal_name, "", id5, + BSF_GLOBAL, 0); + /* Fastcall applies only to functions, + so no need for auto-import symbol. */ + } + else + { + quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC, + BSF_GLOBAL, 0); + if (include_jmp_stub) + quick_symbol (abfd, U (""), exp->internal_name, "", tx, + BSF_GLOBAL, 0); + quick_symbol (abfd, "__imp_", U (""), exp->internal_name, id5, + BSF_GLOBAL, 0); + /* Symbol to reference ord/name of imported + data symbol, used to implement auto-import. */ + if (exp->flag_data) + quick_symbol (abfd, "__nm_", U (""), exp->internal_name, id6, + BSF_GLOBAL,0); + } + if (pe_dll_compat_implib) + quick_symbol (abfd, "___imp_", exp->internal_name, "", id5, + BSF_GLOBAL, 0); + + if (include_jmp_stub) + { + bfd_set_section_size (abfd, 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 + 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; + case PE_ARCH_sh: + quick_reloc (abfd, 8, BFD_RELOC_32, 2); + break; + case PE_ARCH_mips: + quick_reloc (abfd, 0, BFD_RELOC_HI16_S, 2); + quick_reloc (abfd, 0, BFD_RELOC_LO16, 0); /* MIPS_R_PAIR */ + 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; + default: + abort (); + } + save_relocs (tx); + } + else + bfd_set_section_size (abfd, tx, 0); + + bfd_set_section_size (abfd, 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); + d5 = xmalloc (PE_IDATA5_SIZE); + id5->contents = d5; + memset (d5, 0, PE_IDATA5_SIZE); + + if (exp->flag_noname) + { + d5[0] = exp->ordinal; + d5[1] = exp->ordinal >> 8; + d5[PE_IDATA5_SIZE - 1] = 0x80; + } + else + { + quick_reloc (abfd, 0, BFD_RELOC_RVA, 4); + save_relocs (id5); + } + + bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE); + d4 = xmalloc (PE_IDATA4_SIZE); + id4->contents = d4; + memset (d4, 0, PE_IDATA4_SIZE); + + if (exp->flag_noname) + { + d4[0] = exp->ordinal; + d4[1] = exp->ordinal >> 8; + d4[PE_IDATA4_SIZE - 1] = 0x80; + } + else + { + quick_reloc (abfd, 0, BFD_RELOC_RVA, 4); + save_relocs (id4); + } + + if (exp->flag_noname) + { + len = 0; + bfd_set_section_size (abfd, id6, 0); + } + else + { + /* { short, asciz } */ + 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); + d6 = xmalloc (len); + id6->contents = d6; + memset (d6, 0, len); + d6[0] = exp->hint & 0xff; + d6[1] = exp->hint >> 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); + + if (include_jmp_stub) + bfd_set_section_contents (abfd, tx, td, 0, jmp_byte_count); + bfd_set_section_contents (abfd, id7, d7, 0, 4); + bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE); + bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE); + if (!exp->flag_noname) + bfd_set_section_contents (abfd, id6, d6, 0, len); + + bfd_make_readable (abfd); + return abfd; +} + +static bfd * +make_singleton_name_imp (const char *import, bfd *parent) +{ + /* Name thunks go to idata$4. */ + asection *id5; + unsigned char *d5; + char *oname; + bfd *abfd; + + oname = xmalloc (20); + sprintf (oname, "nmimp%06d.o", tmp_seq2); + tmp_seq2++; + + abfd = bfd_create (oname, parent); + bfd_find_target (pe_details->object_target, abfd); + bfd_make_writable (abfd); + + bfd_set_format (abfd, bfd_object); + bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0); + + symptr = 0; + symtab = xmalloc (3 * sizeof (asymbol *)); + id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2); + quick_symbol (abfd, "__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) +{ + /* Name thunks go to idata$4. */ + asection *id4; + unsigned char *d4; + char *oname; + bfd *abfd; + + oname = xmalloc (20); + sprintf (oname, "nmth%06d.o", tmp_seq); + tmp_seq++; + + 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 *)); + id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2); + 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); + d4 = xmalloc (PE_IDATA4_SIZE * 2); + id4->contents = d4; + memset (d4, 0, PE_IDATA4_SIZE * 2); + quick_reloc (abfd, 0, BFD_RELOC_RVA, 2); + save_relocs (id4); + + bfd_set_symtab (abfd, symtab, symptr); + + bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE * 2); + + bfd_make_readable (abfd); + return abfd; +} + +static char * +make_import_fixup_mark (arelent *rel) +{ + /* We convert reloc to symbol, for later reference. */ + static int counter; + static char *fixup_name = NULL; + static size_t buffer_len = 0; + + struct bfd_symbol *sym = *rel->sym_ptr_ptr; + + bfd *abfd = bfd_asymbol_bfd (sym); + struct bfd_link_hash_entry *bh; + + 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); + + 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); + + return fixup_name; +} + +/* .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) */ + +static bfd * +make_import_fixup_entry (const char *name, + const char *fixup_name, + const char *symname, + bfd *parent) +{ + asection *id2; + unsigned char *d2; + char *oname; + bfd *abfd; + + oname = xmalloc (20); + sprintf (oname, "fu%06d.o", tmp_seq); + tmp_seq++; + + 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 (6 * sizeof (asymbol *)); + id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 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); + + bfd_set_section_size (abfd, id2, 20); + d2 = xmalloc (20); + id2->contents = d2; + memset (d2, 0, 20); + + quick_reloc (abfd, 0, BFD_RELOC_RVA, 1); + quick_reloc (abfd, 12, BFD_RELOC_RVA, 2); + quick_reloc (abfd, 16, BFD_RELOC_RVA, 3); + save_relocs (id2); + + bfd_set_symtab (abfd, symtab, symptr); + + bfd_set_section_contents (abfd, id2, d2, 0, 20); + + bfd_make_readable (abfd); + return abfd; +} + +/* .section .rdata_runtime_pseudo_reloc + .long addend + .rva __fuNN_SYM (pointer to reference (address) in text) */ + +static bfd * +make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED, + const char *fixup_name, + 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++; + + 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; + 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); + + 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); + + bfd_put_32 (abfd, addend, rt_rel_d); + quick_reloc (abfd, 4, BFD_RELOC_RVA, 1); + + save_relocs (rt_rel); + + bfd_set_symtab (abfd, symtab, symptr); + + bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, 8); + } + bfd_make_readable (abfd); + return abfd; +} + +/* .section .rdata + .rva __pei386_runtime_relocator */ + +static bfd * +pe_create_runtime_relocator_reference (bfd *parent) +{ + asection *extern_rt_rel; + unsigned char *extern_rt_rel_d; + char *oname; + bfd *abfd; + + oname = xmalloc (20); + sprintf (oname, "ertr%06d.o", tmp_seq); + tmp_seq++; + + 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 (2 * sizeof (asymbol *)); + extern_rt_rel = quick_section (abfd, ".rdata", SEC_HAS_CONTENTS, 2); + + 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); + extern_rt_rel->contents = extern_rt_rel_d; + + quick_reloc (abfd, 0, BFD_RELOC_RVA, 1); + save_relocs (extern_rt_rel); + + bfd_set_symtab (abfd, symtab, symptr); + + 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, 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, "__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)) + { + 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) + { + 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) + || 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, 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, 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; + 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); + return; + } + + if (verbose) + /* 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. */ + 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); + n->archive_next = head; + head = n; + def->exports[i].internal_name = internal; + } + + ar_tail = make_tail (outarch); + + if (ar_head == NULL || ar_tail == NULL) + return; + + /* Now stick them all into the archive. */ + ar_head->archive_next = head; + ar_tail->archive_next = ar_head; + head = ar_tail; + + if (! bfd_set_archive_head (outarch, head)) + einfo ("%Xbfd_set_archive_head: %E\n"); + + if (! bfd_close (outarch)) + einfo ("%Xbfd_close %s: %E\n", impfilename); + + while (head != NULL) + { + bfd *n = head->archive_next; + bfd_close (head); + head = n; + } +} + +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 = (char *) alloca (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) + return h; + } + if (lname[0] == '?') + return NULL; + if (at || lname[0] == '@') + { + if (lname[0] == '@') + { + if (pe_details->underscored) + lname[0] = '_'; + else + strcpy (lname, lname + 1); + key.key = lname; + kv = bsearch (&key, udef_table, undef_count, + sizeof (struct key_value), undef_sort_cmp); + if (kv) + { + h = bfd_link_hash_lookup (linfo->hash, kv->oname, FALSE, FALSE, FALSE); + if (h->type == bfd_link_hash_undefined) + 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) + return h; + } + 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) + 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) + return h; + } + + return NULL; +} + +static bfd_boolean +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 bfd_boolean +pe_undef_fill (struct bfd_link_hash_entry *h, void *inf ATTRIBUTE_UNUSED) +{ + if (h->type == bfd_link_hash_undefined) + { + char *at; + + udef_table[undef_count].key = xstrdup (h->root.string); + at = strchr (udef_table[undef_count].key + + (udef_table[undef_count].key[0] == '@'), '@'); + if (at) + at[1] = 0; + udef_table[undef_count].oname = h->root.string; + undef_count++; + } + return TRUE; +} + +static 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 *linfo) +{ + lang_input_statement_type *fake_file; + + fake_file = lang_add_input_file (name, + lang_input_file_is_fake_enum, + NULL); + fake_file->the_bfd = abfd; + ldlang_add_file (fake_file); + + 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 *linfo) +{ + int i, j; + def_file_module *module; + def_file_import *imp; + + pe_dll_id_target (bfd_get_target (output_bfd)); + + if (!pe_def_file) + return; + + imp = pe_def_file->imports; + + pe_create_undef_table (); + + for (module = pe_def_file->modules; module; module = module->next) + { + int do_this_dll = 0; + + for (i = 0; i < pe_def_file->num_imports && imp[i].module != module; i++) + ; + if (i >= pe_def_file->num_imports) + continue; + + dll_filename = module->name; + dll_symname = xstrdup (module->name); + for (j = 0; dll_symname[j]; j++) + if (!ISALNUM (dll_symname[j])) + dll_symname[j] = '_'; + + 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); + bfd_boolean include_jmp_stub = FALSE; + bfd_boolean is_cdecl = FALSE; + bfd_boolean is_undef = FALSE; + + if (!lead_at && strchr (imp[i].internal_name, '@') == NULL) + is_cdecl = TRUE; + + if (lead_at) + sprintf (name, "%s", imp[i].internal_name); + else + sprintf (name, "%s%s",U (""), imp[i].internal_name); + + blhe = bfd_link_hash_lookup (linfo->hash, name, + FALSE, FALSE, FALSE); + + /* 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, ar_head->filename, 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, one->filename, linfo); + } + } + if (do_this_dll) + { + bfd *ar_tail = make_tail (output_bfd); + add_bfd_to_link (ar_tail, ar_tail->filename, linfo); + } + + free (dll_symname); + } + + while (undef_count) + { + --undef_count; + free (udef_table[undef_count].key); + } + free (udef_table); +} + +/* We were handed a *.DLL file. Parse it and turn it into a set of + IMPORTS directives in the def file. Return TRUE if the file was + handled, FALSE if not. */ + +static unsigned int +pe_get16 (bfd *abfd, int where) +{ + unsigned char b[2]; + + bfd_seek (abfd, (file_ptr) where, SEEK_SET); + bfd_bread (b, (bfd_size_type) 2, abfd); + return b[0] + (b[1] << 8); +} + +static unsigned int +pe_get32 (bfd *abfd, int where) +{ + unsigned char b[4]; + + 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); +} + +static unsigned int +pe_as32 (void *ptr) +{ + unsigned char *b = ptr; + + return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24); +} + +bfd_boolean +pe_implied_import_dll (const char *filename) +{ + bfd *dll; + 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; + 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 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. */ + dll = bfd_openr (filename, pe_details->target_name); + if (!dll) + { + einfo ("%Xopen %s: %E\n", filename); + return FALSE; + } + + /* PEI dlls seem to be bfd_objects. */ + if (!bfd_check_format (dll, bfd_object)) + { + einfo ("%X%s: this doesn't appear to be a DLL\n", filename); + return FALSE; + } + + /* 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 + 4 * 4); /* & NumberOfRvaAndSizes. */ +#else + num_entries = pe_get32 (dll, opthdr_ofs + 92); +#endif + + /* 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 + 4 * 4); + export_size = pe_get32 (dll, opthdr_ofs + 100 + 4 * 4); +#else + 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)); + expptr = 0; + + /* Get the rva and size of the export section. */ + for (i = 0; i < nsections; i++) + { + char sname[8]; + 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); + + if (vaddr <= export_rva && vaddr + vsize > export_rva) + { + expptr = fptr + (export_rva - vaddr); + if (export_rva + export_size > vaddr + vsize) + export_size = vsize - (export_rva - vaddr); + break; + } + } + + /* Scan sections and store the base and size of the + data and bss segments in data/base_start/end. */ + for (i = 0; i < nsections; i++) + { + 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'; + bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET); + bfd_bread (sec_name, (bfd_size_type) 8, dll); + + if (strcmp(sec_name,".data") == 0) + { + data_start = vaddr; + data_end = vaddr + vsize; + + if (pe_dll_extra_pe_debug) + printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n", + __FUNCTION__, sec_name, (unsigned long) vaddr, + (unsigned long) (vaddr + vsize), (unsigned long) flags); + } + else if (strcmp(sec_name,".rdata") == 0) + { + rdata_start = vaddr; + rdata_end = vaddr + vsize; + + if (pe_dll_extra_pe_debug) + printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n", + __FUNCTION__, sec_name, (unsigned long) vaddr, + (unsigned long) (vaddr + vsize), (unsigned long) flags); + } + else if (strcmp (sec_name,".bss") == 0) + { + bss_start = vaddr; + bss_end = vaddr + vsize; + + if (pe_dll_extra_pe_debug) + printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n", + __FUNCTION__, sec_name, (unsigned long) vaddr, + (unsigned long) (vaddr + vsize), (unsigned long) flags); + } + } + + expdata = xmalloc (export_size); + bfd_seek (dll, (file_ptr) expptr, SEEK_SET); + bfd_bread (expdata, (bfd_size_type) export_size, dll); + erva = (char *) expdata - export_rva; + + if (pe_def_file == 0) + pe_def_file = def_file_empty (); + + nexp = pe_as32 (expdata + 24); + name_rvas = pe_as32 (expdata + 32); + exp_funcbase = pe_as32 (expdata + 28); + + /* Use internal dll name instead of filename + to enable symbolic dll linking. */ + 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, dllname)) + { + if (pe_dll_extra_pe_debug) + printf ("%s is already loaded\n", dllname); + return TRUE; + } + + /* Iterate through the list of symbols. */ + 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); + int is_data = 0; + + /* Skip unwanted symbols, which are + exported in buggy auto-import releases. */ + if (! CONST_STRNEQ (erva + name_rva, "__nm_")) + { + int is_dup = 0; + /* is_data is true if the address is in the data, rdata or bss + segment. */ + 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, + dllname, i, NULL, NULL, &is_dup); + /* Mark symbol type. */ + if (!is_dup) + 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; +} + +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 + can put the right values in place. */ + +void +pe_dll_build_sections (bfd *abfd, struct bfd_link_info *info) +{ + pe_dll_id_target (bfd_get_target (abfd)); + pe_output_file_set_long_section_names (abfd); + process_def_file_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); + if (reloc_sz > 0) + { + 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); + + if (info->shared && !info->pie) + pe_data (abfd)->dll = 1; + + edata_s->contents = edata_d; + reloc_s->contents = reloc_d; +} + +void +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); + if (reloc_sz > 0) + { + 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); + } + reloc_s->contents = reloc_d; +} + +bfd_boolean +pe_bfd_is_dll (bfd *abfd) +{ + return (bfd_get_format (abfd) == bfd_object + && obj_pe (abfd) + && pe_data (abfd)->dll); +} |