1 /* Routines to help build PEI-format DLLs (Win32 etc)
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008, 2009, 2010 Free Software Foundation, Inc.
4 Written by DJ Delorie <dj@cygnus.com>
6 This file is part of the GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
26 #include "libiberty.h"
27 #include "safe-ctype.h"
40 #include "coff/internal.h"
41 #include "../bfd/libcoff.h"
46 #define PE_IDATA4_SIZE 8
47 #define PE_IDATA5_SIZE 8
50 #define AOUTSZ PEPAOUTSZ
51 #define PEAOUTHDR PEPAOUTHDR
59 #ifndef PE_IDATA4_SIZE
60 #define PE_IDATA4_SIZE 4
63 #ifndef PE_IDATA5_SIZE
64 #define PE_IDATA5_SIZE 4
67 /* This file turns a regular Windows PE image into a DLL. Because of
68 the complexity of this operation, it has been broken down into a
69 number of separate modules which are all called by the main function
70 at the end of this file. This function is not re-entrant and is
71 normally only called once, so static variables are used to reduce
72 the number of parameters and return values required.
74 See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */
76 /* Auto-import feature by Paul Sokolovsky
80 1. With this feature on, DLL clients can import variables from DLL
81 without any concern from their side (for example, without any source
84 2. This is done completely in bounds of the PE specification (to be fair,
85 there's a place where it pokes nose out of, but in practice it works).
86 So, resulting module can be used with any other PE compiler/linker.
88 3. Auto-import is fully compatible with standard import method and they
89 can be mixed together.
91 4. Overheads: space: 8 bytes per imported symbol, plus 20 for each
92 reference to it; load time: negligible; virtual/physical memory: should be
93 less than effect of DLL relocation, and I sincerely hope it doesn't affect
94 DLL sharability (too much).
98 The obvious and only way to get rid of dllimport insanity is to make client
99 access variable directly in the DLL, bypassing extra dereference. I.e.,
100 whenever client contains something like
104 address of dll_var in the command should be relocated to point into loaded
105 DLL. The aim is to make OS loader do so, and than make ld help with that.
106 Import section of PE made following way: there's a vector of structures
107 each describing imports from particular DLL. Each such structure points
108 to two other parallel vectors: one holding imported names, and one which
109 will hold address of corresponding imported name. So, the solution is
110 de-vectorize these structures, making import locations be sparse and
111 pointing directly into code. Before continuing, it is worth a note that,
112 while authors strives to make PE act ELF-like, there're some other people
113 make ELF act PE-like: elfvector, ;-) .
117 For each reference of data symbol to be imported from DLL (to set of which
118 belong symbols with name <sym>, if __imp_<sym> is found in implib), the
119 import fixup entry is generated. That entry is of type
120 IMAGE_IMPORT_DESCRIPTOR and stored in .idata$2 subsection. Each
121 fixup entry contains pointer to symbol's address within .text section
122 (marked with __fuN_<sym> symbol, where N is integer), pointer to DLL name
123 (so, DLL name is referenced by multiple entries), and pointer to symbol
124 name thunk. Symbol name thunk is singleton vector (__nm_th_<symbol>)
125 pointing to IMAGE_IMPORT_BY_NAME structure (__nm_<symbol>) directly
126 containing imported name. Here comes that "on the edge" problem mentioned
127 above: PE specification rambles that name vector (OriginalFirstThunk)
128 should run in parallel with addresses vector (FirstThunk), i.e. that they
129 should have same number of elements and terminated with zero. We violate
130 this, since FirstThunk points directly into machine code. But in practice,
131 OS loader implemented the sane way: it goes thru OriginalFirstThunk and
132 puts addresses to FirstThunk, not something else. It once again should be
133 noted that dll and symbol name structures are reused across fixup entries
134 and should be there anyway to support standard import stuff, so sustained
135 overhead is 20 bytes per reference. Other question is whether having several
136 IMAGE_IMPORT_DESCRIPTORS for the same DLL is possible. Answer is yes, it is
137 done even by native compiler/linker (libth32's functions are in fact reside
138 in windows9x kernel32.dll, so if you use it, you have two
139 IMAGE_IMPORT_DESCRIPTORS for kernel32.dll). Yet other question is whether
140 referencing the same PE structures several times is valid. The answer is why
141 not, prohibiting that (detecting violation) would require more work on
142 behalf of loader than not doing it.
144 See also: ld/emultempl/pe.em and ld/emultempl/pep.em. */
146 static void add_bfd_to_link (bfd *, const char *, struct bfd_link_info *);
148 /* For emultempl/pe.em. */
150 def_file * pe_def_file = 0;
151 int pe_dll_export_everything = 0;
152 int pe_dll_exclude_all_symbols = 0;
153 int pe_dll_do_default_excludes = 1;
154 int pe_dll_kill_ats = 0;
155 int pe_dll_stdcall_aliases = 0;
156 int pe_dll_warn_dup_exports = 0;
157 int pe_dll_compat_implib = 0;
158 int pe_dll_extra_pe_debug = 0;
159 int pe_use_nul_prefixed_import_tables = 0;
160 int pe_use_coff_long_section_names = -1;
161 int pe_leading_underscore = -1;
163 /* Static variables and types. */
165 static bfd_vma image_base;
166 static bfd *filler_bfd;
167 static struct bfd_section *edata_s, *reloc_s;
168 static unsigned char *edata_d, *reloc_d;
169 static size_t edata_sz, reloc_sz;
170 static int runtime_pseudo_relocs_created = 0;
171 static int runtime_pseudp_reloc_v2_init = 0;
178 autofilter_entry_type;
182 const char *target_name;
183 const char *object_target;
184 unsigned int imagebase_reloc;
187 bfd_boolean underscored;
188 const autofilter_entry_type* autofilter_symbollist;
192 static const autofilter_entry_type autofilter_symbollist_generic[] =
194 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
195 /* Entry point symbols. */
196 { STRING_COMMA_LEN ("DllMain") },
197 { STRING_COMMA_LEN ("DllMainCRTStartup") },
198 { STRING_COMMA_LEN ("_DllMainCRTStartup") },
199 /* Runtime pseudo-reloc. */
200 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
201 { STRING_COMMA_LEN ("do_pseudo_reloc") },
205 static const autofilter_entry_type autofilter_symbollist_i386[] =
207 { STRING_COMMA_LEN ("_NULL_IMPORT_DESCRIPTOR") },
208 /* Entry point symbols, and entry hooks. */
209 { STRING_COMMA_LEN ("cygwin_crt0") },
211 { STRING_COMMA_LEN ("DllMain") },
212 { STRING_COMMA_LEN ("DllEntryPoint") },
213 { STRING_COMMA_LEN ("DllMainCRTStartup") },
214 { STRING_COMMA_LEN ("_cygwin_dll_entry") },
215 { STRING_COMMA_LEN ("_cygwin_crt0_common") },
216 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry") },
218 { STRING_COMMA_LEN ("DllMain@12") },
219 { STRING_COMMA_LEN ("DllEntryPoint@0") },
220 { STRING_COMMA_LEN ("DllMainCRTStartup@12") },
221 { STRING_COMMA_LEN ("_cygwin_dll_entry@12") },
222 { STRING_COMMA_LEN ("_cygwin_crt0_common@8") },
223 { STRING_COMMA_LEN ("_cygwin_noncygwin_dll_entry@12") },
224 { STRING_COMMA_LEN ("cygwin_attach_dll") },
226 { STRING_COMMA_LEN ("cygwin_premain0") },
227 { STRING_COMMA_LEN ("cygwin_premain1") },
228 { STRING_COMMA_LEN ("cygwin_premain2") },
229 { STRING_COMMA_LEN ("cygwin_premain3") },
230 /* Runtime pseudo-reloc. */
231 { STRING_COMMA_LEN ("_pei386_runtime_relocator") },
232 { STRING_COMMA_LEN ("do_pseudo_reloc") },
233 /* Global vars that should not be exported. */
234 { STRING_COMMA_LEN ("impure_ptr") },
235 { STRING_COMMA_LEN ("_impure_ptr") },
236 { STRING_COMMA_LEN ("_fmode") },
237 { STRING_COMMA_LEN ("environ") },
241 #define PE_ARCH_i386 1
243 #define PE_ARCH_mips 3
244 #define PE_ARCH_arm 4
245 #define PE_ARCH_arm_epoc 5
246 #define PE_ARCH_arm_wince 6
248 /* Don't make it constant as underscore mode gets possibly overriden
249 by target or -(no-)leading-underscore option. */
250 static pe_details_type pe_detail_list[] =
269 autofilter_symbollist_i386
274 16 /* R_SH_IMAGEBASE */,
278 autofilter_symbollist_generic
287 autofilter_symbollist_generic
296 autofilter_symbollist_generic
299 "epoc-pei-arm-little",
300 "epoc-pe-arm-little",
305 autofilter_symbollist_generic
308 "pei-arm-wince-little",
309 "pe-arm-wince-little",
310 2, /* ARM_RVA32 on Windows CE, see bfd/coff-arm.c. */
314 autofilter_symbollist_generic
316 { NULL, NULL, 0, 0, 0, FALSE, NULL }
319 static const pe_details_type *pe_details;
321 /* Do not specify library suffix explicitly, to allow for dllized versions. */
322 static const autofilter_entry_type autofilter_liblist[] =
324 { STRING_COMMA_LEN ("libcegcc") },
325 { STRING_COMMA_LEN ("libcygwin") },
326 { STRING_COMMA_LEN ("libgcc") },
327 { STRING_COMMA_LEN ("libgcc_s") },
328 { STRING_COMMA_LEN ("libstdc++") },
329 { STRING_COMMA_LEN ("libmingw32") },
330 { STRING_COMMA_LEN ("libmingwex") },
331 { STRING_COMMA_LEN ("libg2c") },
332 { STRING_COMMA_LEN ("libsupc++") },
333 { STRING_COMMA_LEN ("libobjc") },
334 { STRING_COMMA_LEN ("libgcj") },
338 /* Regardless of the suffix issue mentioned above, we must ensure that
339 we do not falsely match on a leading substring, such as when libtool
340 builds libstdc++ as a DLL using libsupc++convenience.a as an intermediate.
341 This routine ensures that the leading part of the name matches and that
342 it is followed by only an optional version suffix and a file extension,
343 returning zero if so or -1 if not. */
344 static int libnamencmp (const char *libname, const autofilter_entry_type *afptr)
346 if (strncmp (libname, afptr->name, afptr->len))
349 libname += afptr->len;
351 /* Be liberal in interpreting what counts as a version suffix; we
352 accept anything that has a dash to separate it from the name and
353 begins with a digit. */
354 if (libname[0] == '-')
356 if (!ISDIGIT (*++libname))
358 /* Ensure the filename has an extension. */
359 while (*++libname != '.')
363 else if (libname[0] != '.')
369 static const autofilter_entry_type autofilter_objlist[] =
371 { STRING_COMMA_LEN ("crt0.o") },
372 { STRING_COMMA_LEN ("crt1.o") },
373 { STRING_COMMA_LEN ("crt2.o") },
374 { STRING_COMMA_LEN ("dllcrt1.o") },
375 { STRING_COMMA_LEN ("dllcrt2.o") },
376 { STRING_COMMA_LEN ("gcrt0.o") },
377 { STRING_COMMA_LEN ("gcrt1.o") },
378 { STRING_COMMA_LEN ("gcrt2.o") },
379 { STRING_COMMA_LEN ("crtbegin.o") },
380 { STRING_COMMA_LEN ("crtend.o") },
384 static const autofilter_entry_type autofilter_symbolprefixlist[] =
386 /* _imp_ is treated specially, as it is always underscored. */
387 /* { STRING_COMMA_LEN ("_imp_") }, */
388 /* Don't export some c++ symbols. */
389 { STRING_COMMA_LEN ("__rtti_") },
390 { STRING_COMMA_LEN ("__builtin_") },
391 /* Don't re-export auto-imported symbols. */
392 { STRING_COMMA_LEN ("__nm_") },
393 /* Don't export symbols specifying internal DLL layout. */
394 { STRING_COMMA_LEN ("_head_") },
395 { STRING_COMMA_LEN ("_IMPORT_DESCRIPTOR_") },
396 /* Don't export section labels or artificial symbols
398 { STRING_COMMA_LEN (".") },
402 static const autofilter_entry_type autofilter_symbolsuffixlist[] =
404 { STRING_COMMA_LEN ("_iname") },
405 { STRING_COMMA_LEN ("_NULL_THUNK_DATA") },
409 #define U(str) (pe_details->underscored ? "_" str : str)
412 pe_dll_id_target (const char *target)
416 for (i = 0; pe_detail_list[i].target_name; i++)
417 if (strcmp (pe_detail_list[i].target_name, target) == 0
418 || strcmp (pe_detail_list[i].object_target, target) == 0)
420 int u = pe_leading_underscore; /* Underscoring mode. -1 for use default. */
422 bfd_get_target_info (target, NULL, NULL, &u, NULL);
425 pe_detail_list[i].underscored = (u != 0 ? TRUE : FALSE);
426 pe_details = pe_detail_list + i;
427 pe_leading_underscore = (u != 0 ? 1 : 0);
430 einfo (_("%XUnsupported PEI architecture: %s\n"), target);
434 /* Helper functions for qsort. Relocs must be sorted so that we can write
435 them out by pages. */
446 reloc_sort (const void *va, const void *vb)
448 bfd_vma a = ((const reloc_data_type *) va)->vma;
449 bfd_vma b = ((const reloc_data_type *) vb)->vma;
451 return (a > b) ? 1 : ((a < b) ? -1 : 0);
455 pe_export_sort (const void *va, const void *vb)
457 const def_file_export *a = va;
458 const def_file_export *b = vb;
466 return strcmp (an, bn);
469 /* Read and process the .DEF file. */
471 /* These correspond to the entries in pe_def_file->exports[]. I use
472 exported_symbol_sections[i] to tag whether or not the symbol was
473 defined, since we can't export symbols we don't have. */
475 static bfd_vma *exported_symbol_offsets;
476 static struct bfd_section **exported_symbol_sections;
477 static int export_table_size;
478 static int count_exported;
479 static int count_exported_byname;
480 static int count_with_ordinals;
481 static const char *dll_name;
482 static int min_ordinal, max_ordinal;
483 static int *exported_symbols;
485 typedef struct exclude_list_struct
488 struct exclude_list_struct *next;
493 static struct exclude_list_struct *excludes = 0;
496 pe_dll_add_excludes (const char *new_excludes, const exclude_type type)
499 char *exclude_string;
501 local_copy = xstrdup (new_excludes);
503 exclude_string = strtok (local_copy, ",:");
504 for (; exclude_string; exclude_string = strtok (NULL, ",:"))
506 struct exclude_list_struct *new_exclude;
508 new_exclude = xmalloc (sizeof (struct exclude_list_struct));
509 new_exclude->string = xmalloc (strlen (exclude_string) + 1);
510 strcpy (new_exclude->string, exclude_string);
511 new_exclude->type = type;
512 new_exclude->next = excludes;
513 excludes = new_exclude;
520 is_import (const char* n)
522 return (CONST_STRNEQ (n, "__imp_"));
525 /* abfd is a bfd containing n (or NULL)
526 It can be used for contextual checks. */
529 auto_export (bfd *abfd, def_file *d, const char *n)
532 struct exclude_list_struct *ex;
533 const autofilter_entry_type *afptr;
534 const char * libname = 0;
535 if (abfd && abfd->my_archive)
536 libname = lbasename (abfd->my_archive->filename);
538 for (i = 0; i < d->num_exports; i++)
539 if (strcmp (d->exports[i].name, n) == 0)
542 if (pe_dll_do_default_excludes)
547 if (pe_dll_extra_pe_debug)
548 printf ("considering exporting: %s, abfd=%p, abfd->my_arc=%p\n",
549 n, abfd, abfd->my_archive);
551 /* First of all, make context checks:
552 Don't export anything from standard libs. */
555 afptr = autofilter_liblist;
559 if (libnamencmp (libname, afptr) == 0 )
565 /* Next, exclude symbols from certain startup objects. */
567 if (abfd && (p = lbasename (abfd->filename)))
569 afptr = autofilter_objlist;
572 if (strcmp (p, afptr->name) == 0)
578 /* Don't try to blindly exclude all symbols
579 that begin with '__'; this was tried and
580 it is too restrictive. Instead we have
581 a target specific list to use: */
582 afptr = pe_details->autofilter_symbollist;
586 if (strcmp (n, afptr->name) == 0)
592 /* Next, exclude symbols starting with ... */
593 afptr = autofilter_symbolprefixlist;
596 if (strncmp (n, afptr->name, afptr->len) == 0)
602 /* Finally, exclude symbols ending with ... */
604 afptr = autofilter_symbolsuffixlist;
607 if ((len >= afptr->len)
608 /* Add 1 to insure match with trailing '\0'. */
609 && strncmp (n + len - afptr->len, afptr->name,
610 afptr->len + 1) == 0)
617 for (ex = excludes; ex; ex = ex->next)
619 if (ex->type == EXCLUDELIBS)
622 && ((strcmp (libname, ex->string) == 0)
623 || (strcasecmp ("ALL", ex->string) == 0)))
626 else if (ex->type == EXCLUDEFORIMPLIB)
628 if (strcmp (abfd->filename, ex->string) == 0)
631 else if (strcmp (n, ex->string) == 0)
639 process_def_file_and_drectve (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
642 struct bfd_link_hash_entry *blhe;
644 struct bfd_section *s;
645 def_file_export *e = 0;
648 pe_def_file = def_file_empty ();
650 /* First, run around to all the objects looking for the .drectve
651 sections, and push those into the def file too. */
652 for (b = info->input_bfds; b; b = b->link_next)
654 s = bfd_get_section_by_name (b, ".drectve");
658 char *buf = xmalloc (size);
660 bfd_get_section_contents (b, s, buf, 0, size);
661 def_file_add_directive (pe_def_file, buf, size);
666 /* Process aligned common symbol information from the
667 .drectve sections now; common symbol allocation is
668 done before final link, so it will be too late to
669 process them in process_embedded_commands() called
670 from _bfd_coff_link_input_bfd(). */
671 if (pe_def_file->aligncomms)
673 def_file_aligncomm *ac = pe_def_file->aligncomms;
676 struct coff_link_hash_entry *sym_hash;
677 sym_hash = coff_link_hash_lookup (coff_hash_table (info),
678 ac->symbol_name, FALSE, FALSE, FALSE);
679 if (sym_hash && sym_hash->root.type == bfd_link_hash_common
680 && sym_hash->root.u.c.p->alignment_power < (unsigned) ac->alignment)
682 sym_hash->root.u.c.p->alignment_power = (unsigned) ac->alignment;
688 /* If we are building an executable and there is nothing
689 to export, we do not build an export table at all. */
690 if (info->executable && pe_def_file->num_exports == 0
691 && (!pe_dll_export_everything || pe_dll_exclude_all_symbols))
694 /* Now, maybe export everything else the default way. */
695 if ((pe_dll_export_everything || pe_def_file->num_exports == 0)
696 && !pe_dll_exclude_all_symbols)
698 for (b = info->input_bfds; b; b = b->link_next)
703 if (!bfd_generic_link_read_symbols (b))
705 einfo (_("%B%F: could not read symbols: %E\n"), b);
709 symbols = bfd_get_outsymbols (b);
710 nsyms = bfd_get_symcount (b);
712 for (j = 0; j < nsyms; j++)
714 /* We should export symbols which are either global or not
715 anything at all. (.bss data is the latter)
716 We should not export undefined symbols. */
717 bfd_boolean would_export = symbols[j]->section != &bfd_und_section
718 && ((symbols[j]->flags & BSF_GLOBAL)
719 || (symbols[j]->flags == 0));
720 if (lang_elf_version_info && would_export)
722 bfd_boolean hide = 0;
723 char ofs = pe_details->underscored && symbols[j]->name[0] == '_';
724 (void) bfd_find_version_for_sym (lang_elf_version_info,
725 symbols[j]->name + ofs, &hide);
726 would_export = !hide;
730 const char *sn = symbols[j]->name;
732 /* We should not re-export imported stuff. */
738 name = xmalloc (strlen ("__imp_") + strlen (sn) + 1);
739 sprintf (name, "%s%s", "__imp_", sn);
741 blhe = bfd_link_hash_lookup (info->hash, name,
742 FALSE, FALSE, FALSE);
745 if (blhe && blhe->type == bfd_link_hash_defined)
749 if (pe_details->underscored && *sn == '_')
752 if (auto_export (b, pe_def_file, sn))
755 p=def_file_add_export (pe_def_file, sn, 0, -1, NULL);
756 /* Fill data flag properly, from dlltool.c. */
757 p->flag_data = !(symbols[j]->flags & BSF_FUNCTION);
765 #define NE pe_def_file->num_exports
767 /* Don't create an empty export table. */
771 /* Canonicalize the export list. */
774 for (i = 0; i < NE; i++)
776 if (strchr (pe_def_file->exports[i].name, '@'))
778 /* This will preserve internal_name, which may have been
779 pointing to the same memory as name, or might not
781 int lead_at = (*pe_def_file->exports[i].name == '@');
782 char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
783 char *tmp_at = strchr (tmp, '@');
788 einfo (_("%XCannot export %s: invalid export name\n"),
789 pe_def_file->exports[i].name);
790 pe_def_file->exports[i].name = tmp;
795 if (pe_dll_stdcall_aliases)
797 for (i = 0; i < NE; i++)
799 if (is_import (pe_def_file->exports[i].name))
802 if (strchr (pe_def_file->exports[i].name, '@'))
804 int lead_at = (*pe_def_file->exports[i].name == '@');
805 char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
807 *(strchr (tmp, '@')) = 0;
808 if (auto_export (NULL, pe_def_file, tmp))
809 def_file_add_export (pe_def_file, tmp,
810 pe_def_file->exports[i].internal_name,
818 /* Convenience, but watch out for it changing. */
819 e = pe_def_file->exports;
821 exported_symbol_offsets = xmalloc (NE * sizeof (bfd_vma));
822 exported_symbol_sections = xmalloc (NE * sizeof (struct bfd_section *));
824 memset (exported_symbol_sections, 0, NE * sizeof (struct bfd_section *));
828 count_exported_byname = 0;
829 count_with_ordinals = 0;
831 qsort (pe_def_file->exports, NE, sizeof (pe_def_file->exports[0]),
833 for (i = 0, j = 0; i < NE; i++)
835 if (i > 0 && strcmp (e[i].name, e[i - 1].name) == 0)
837 /* This is a duplicate. */
838 if (e[j - 1].ordinal != -1
839 && e[i].ordinal != -1
840 && e[j - 1].ordinal != e[i].ordinal)
842 if (pe_dll_warn_dup_exports)
843 /* xgettext:c-format */
844 einfo (_("%XError, duplicate EXPORT with ordinals: %s (%d vs %d)\n"),
845 e[j - 1].name, e[j - 1].ordinal, e[i].ordinal);
849 if (pe_dll_warn_dup_exports)
850 /* xgettext:c-format */
851 einfo (_("Warning, duplicate EXPORT: %s\n"),
855 if (e[i].ordinal != -1)
856 e[j - 1].ordinal = e[i].ordinal;
857 e[j - 1].flag_private |= e[i].flag_private;
858 e[j - 1].flag_constant |= e[i].flag_constant;
859 e[j - 1].flag_noname |= e[i].flag_noname;
860 e[j - 1].flag_data |= e[i].flag_data;
869 pe_def_file->num_exports = j; /* == NE */
871 for (i = 0; i < NE; i++)
875 /* Check for forward exports */
876 if (strchr (pe_def_file->exports[i].internal_name, '.'))
879 if (!pe_def_file->exports[i].flag_noname)
880 count_exported_byname++;
882 pe_def_file->exports[i].flag_forward = 1;
884 if (pe_def_file->exports[i].ordinal != -1)
886 if (max_ordinal < pe_def_file->exports[i].ordinal)
887 max_ordinal = pe_def_file->exports[i].ordinal;
888 if (min_ordinal > pe_def_file->exports[i].ordinal)
889 min_ordinal = pe_def_file->exports[i].ordinal;
890 count_with_ordinals++;
896 name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
897 if (pe_details->underscored
898 && (*pe_def_file->exports[i].internal_name != '@'))
901 strcpy (name + 1, pe_def_file->exports[i].internal_name);
904 strcpy (name, pe_def_file->exports[i].internal_name);
906 blhe = bfd_link_hash_lookup (info->hash,
911 && (blhe->type == bfd_link_hash_defined
912 || (blhe->type == bfd_link_hash_common)))
915 if (!pe_def_file->exports[i].flag_noname)
916 count_exported_byname++;
918 /* Only fill in the sections. The actual offsets are computed
919 in fill_exported_offsets() after common symbols are laid
921 if (blhe->type == bfd_link_hash_defined)
922 exported_symbol_sections[i] = blhe->u.def.section;
924 exported_symbol_sections[i] = blhe->u.c.p->section;
926 if (pe_def_file->exports[i].ordinal != -1)
928 if (max_ordinal < pe_def_file->exports[i].ordinal)
929 max_ordinal = pe_def_file->exports[i].ordinal;
930 if (min_ordinal > pe_def_file->exports[i].ordinal)
931 min_ordinal = pe_def_file->exports[i].ordinal;
932 count_with_ordinals++;
935 else if (blhe && blhe->type == bfd_link_hash_undefined)
937 /* xgettext:c-format */
938 einfo (_("%XCannot export %s: symbol not defined\n"),
939 pe_def_file->exports[i].internal_name);
943 /* xgettext:c-format */
944 einfo (_("%XCannot export %s: symbol wrong type (%d vs %d)\n"),
945 pe_def_file->exports[i].internal_name,
946 blhe->type, bfd_link_hash_defined);
950 /* xgettext:c-format */
951 einfo (_("%XCannot export %s: symbol not found\n"),
952 pe_def_file->exports[i].internal_name);
958 /* Build the bfd that will contain .edata and .reloc sections. */
961 build_filler_bfd (int include_edata)
963 lang_input_statement_type *filler_file;
964 filler_file = lang_add_input_file ("dll stuff",
965 lang_input_file_is_fake_enum,
967 filler_file->the_bfd = filler_bfd = bfd_create ("dll stuff",
968 link_info.output_bfd);
969 if (filler_bfd == NULL
970 || !bfd_set_arch_mach (filler_bfd,
971 bfd_get_arch (link_info.output_bfd),
972 bfd_get_mach (link_info.output_bfd)))
974 einfo ("%X%P: can not create BFD: %E\n");
980 edata_s = bfd_make_section_old_way (filler_bfd, ".edata");
982 || !bfd_set_section_flags (filler_bfd, edata_s,
989 einfo ("%X%P: can not create .edata section: %E\n");
992 bfd_set_section_size (filler_bfd, edata_s, edata_sz);
995 reloc_s = bfd_make_section_old_way (filler_bfd, ".reloc");
997 || !bfd_set_section_flags (filler_bfd, reloc_s,
1004 einfo ("%X%P: can not create .reloc section: %E\n");
1008 bfd_set_section_size (filler_bfd, reloc_s, 0);
1010 ldlang_add_file (filler_file);
1013 /* Gather all the exported symbols and build the .edata section. */
1016 generate_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
1018 int i, next_ordinal;
1019 int name_table_size = 0;
1022 /* First, we need to know how many exported symbols there are,
1023 and what the range of ordinals is. */
1024 if (pe_def_file->name)
1025 dll_name = pe_def_file->name;
1028 dll_name = abfd->filename;
1030 for (dlnp = dll_name; *dlnp; dlnp++)
1031 if (*dlnp == '\\' || *dlnp == '/' || *dlnp == ':')
1032 dll_name = dlnp + 1;
1035 if (count_with_ordinals && max_ordinal > count_exported)
1037 if (min_ordinal > max_ordinal - count_exported + 1)
1038 min_ordinal = max_ordinal - count_exported + 1;
1043 max_ordinal = count_exported;
1046 export_table_size = max_ordinal - min_ordinal + 1;
1047 exported_symbols = xmalloc (export_table_size * sizeof (int));
1048 for (i = 0; i < export_table_size; i++)
1049 exported_symbols[i] = -1;
1051 /* Now we need to assign ordinals to those that don't have them. */
1052 for (i = 0; i < NE; i++)
1054 if (exported_symbol_sections[i] ||
1055 pe_def_file->exports[i].flag_forward)
1057 if (pe_def_file->exports[i].ordinal != -1)
1059 int ei = pe_def_file->exports[i].ordinal - min_ordinal;
1060 int pi = exported_symbols[ei];
1064 /* xgettext:c-format */
1065 einfo (_("%XError, ordinal used twice: %d (%s vs %s)\n"),
1066 pe_def_file->exports[i].ordinal,
1067 pe_def_file->exports[i].name,
1068 pe_def_file->exports[pi].name);
1070 exported_symbols[ei] = i;
1072 if (pe_def_file->exports[i].its_name)
1073 name_table_size += strlen (pe_def_file->exports[i].its_name) + 1;
1075 name_table_size += strlen (pe_def_file->exports[i].name) + 1;
1078 /* Reserve space for the forward name. */
1079 if (pe_def_file->exports[i].flag_forward)
1081 name_table_size += strlen (pe_def_file->exports[i].internal_name) + 1;
1085 next_ordinal = min_ordinal;
1086 for (i = 0; i < NE; i++)
1087 if ((exported_symbol_sections[i] ||
1088 pe_def_file->exports[i].flag_forward) &&
1089 pe_def_file->exports[i].ordinal == -1)
1091 while (exported_symbols[next_ordinal - min_ordinal] != -1)
1094 exported_symbols[next_ordinal - min_ordinal] = i;
1095 pe_def_file->exports[i].ordinal = next_ordinal;
1098 /* OK, now we can allocate some memory. */
1099 edata_sz = (40 /* directory */
1100 + 4 * export_table_size /* addresses */
1101 + 4 * count_exported_byname /* name ptrs */
1102 + 2 * count_exported_byname /* ordinals */
1103 + name_table_size + strlen (dll_name) + 1);
1106 /* Fill the exported symbol offsets. The preliminary work has already
1107 been done in process_def_file_and_drectve(). */
1110 fill_exported_offsets (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
1113 struct bfd_link_hash_entry *blhe;
1115 for (i = 0; i < pe_def_file->num_exports; i++)
1119 name = xmalloc (strlen (pe_def_file->exports[i].internal_name) + 2);
1120 if (pe_details->underscored
1121 && *pe_def_file->exports[i].internal_name != '@')
1124 strcpy (name + 1, pe_def_file->exports[i].internal_name);
1127 strcpy (name, pe_def_file->exports[i].internal_name);
1129 blhe = bfd_link_hash_lookup (info->hash,
1131 FALSE, FALSE, TRUE);
1133 if (blhe && blhe->type == bfd_link_hash_defined)
1134 exported_symbol_offsets[i] = blhe->u.def.value;
1141 fill_edata (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
1144 unsigned char *edirectory;
1145 unsigned char *eaddresses;
1146 unsigned char *enameptrs;
1147 unsigned char *eordinals;
1153 edata_d = xmalloc (edata_sz);
1155 /* Note use of array pointer math here. */
1156 edirectory = edata_d;
1157 eaddresses = edata_d + 40;
1158 enameptrs = eaddresses + 4 * export_table_size;
1159 eordinals = enameptrs + 4 * count_exported_byname;
1160 enamestr = (char *) eordinals + 2 * count_exported_byname;
1162 #define ERVA(ptr) (((unsigned char *)(ptr) - edata_d) \
1163 + edata_s->output_section->vma - image_base)
1165 memset (edata_d, 0, edata_sz);
1166 bfd_put_32 (abfd, now, edata_d + 4);
1167 if (pe_def_file->version_major != -1)
1169 bfd_put_16 (abfd, pe_def_file->version_major, edata_d + 8);
1170 bfd_put_16 (abfd, pe_def_file->version_minor, edata_d + 10);
1173 bfd_put_32 (abfd, ERVA (enamestr), edata_d + 12);
1174 strcpy (enamestr, dll_name);
1175 enamestr += strlen (enamestr) + 1;
1176 bfd_put_32 (abfd, min_ordinal, edata_d + 16);
1177 bfd_put_32 (abfd, export_table_size, edata_d + 20);
1178 bfd_put_32 (abfd, count_exported_byname, edata_d + 24);
1179 bfd_put_32 (abfd, ERVA (eaddresses), edata_d + 28);
1180 bfd_put_32 (abfd, ERVA (enameptrs), edata_d + 32);
1181 bfd_put_32 (abfd, ERVA (eordinals), edata_d + 36);
1183 fill_exported_offsets (abfd, info);
1185 /* Ok, now for the filling in part.
1186 Scan alphabetically - ie the ordering in the exports[] table,
1187 rather than by ordinal - the ordering in the exported_symbol[]
1188 table. See dlltool.c and:
1189 http://sources.redhat.com/ml/binutils/2003-04/msg00379.html
1190 for more information. */
1192 for (s = 0; s < NE; s++)
1194 struct bfd_section *ssec = exported_symbol_sections[s];
1195 if (pe_def_file->exports[s].ordinal != -1 &&
1196 (pe_def_file->exports[s].flag_forward || ssec != NULL))
1198 int ord = pe_def_file->exports[s].ordinal;
1200 if (pe_def_file->exports[s].flag_forward)
1202 bfd_put_32 (abfd, ERVA (enamestr),
1203 eaddresses + 4 * (ord - min_ordinal));
1205 strcpy (enamestr, pe_def_file->exports[s].internal_name);
1206 enamestr += strlen (pe_def_file->exports[s].internal_name) + 1;
1210 bfd_vma srva = (exported_symbol_offsets[s]
1211 + ssec->output_section->vma
1212 + ssec->output_offset);
1214 bfd_put_32 (abfd, srva - image_base,
1215 eaddresses + 4 * (ord - min_ordinal));
1218 if (!pe_def_file->exports[s].flag_noname)
1220 char *ename = pe_def_file->exports[s].name;
1221 if (pe_def_file->exports[s].its_name)
1222 ename = pe_def_file->exports[s].its_name;
1224 bfd_put_32 (abfd, ERVA (enamestr), enameptrs);
1226 strcpy (enamestr, ename);
1227 enamestr += strlen (enamestr) + 1;
1228 bfd_put_16 (abfd, ord - min_ordinal, eordinals);
1230 pe_def_file->exports[s].hint = hint++;
1237 static struct bfd_section *current_sec;
1240 pe_walk_relocs_of_symbol (struct bfd_link_info *info,
1242 int (*cb) (arelent *, asection *))
1247 for (b = info->input_bfds; b; b = b->link_next)
1252 if (!bfd_generic_link_read_symbols (b))
1254 einfo (_("%B%F: could not read symbols: %E\n"), b);
1258 symbols = bfd_get_outsymbols (b);
1259 nsyms = bfd_get_symcount (b);
1261 for (s = b->sections; s; s = s->next)
1264 int relsize, nrelocs, i;
1265 int flags = bfd_get_section_flags (b, s);
1267 /* Skip discarded linkonce sections. */
1268 if (flags & SEC_LINK_ONCE
1269 && s->output_section == bfd_abs_section_ptr)
1274 relsize = bfd_get_reloc_upper_bound (b, s);
1275 relocs = xmalloc (relsize);
1276 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1278 for (i = 0; i < nrelocs; i++)
1280 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1282 if (!strcmp (name, sym->name))
1288 /* Warning: the allocated symbols are remembered in BFD and reused
1289 later, so don't free them! */
1290 /* free (symbols); */
1295 /* Gather all the relocations and build the .reloc section. */
1298 generate_reloc (bfd *abfd, struct bfd_link_info *info)
1301 /* For .reloc stuff. */
1302 reloc_data_type *reloc_data;
1303 int total_relocs = 0;
1305 bfd_vma sec_page = (bfd_vma) -1;
1306 bfd_vma page_ptr, page_count;
1309 struct bfd_section *s;
1312 for (b = info->input_bfds; b; b = b->link_next)
1313 for (s = b->sections; s; s = s->next)
1314 total_relocs += s->reloc_count;
1316 reloc_data = xmalloc (total_relocs * sizeof (reloc_data_type));
1320 for (bi = 0, b = info->input_bfds; b; bi++, b = b->link_next)
1323 int relsize, nrelocs;
1325 for (s = b->sections; s; s = s->next)
1327 bfd_vma sec_vma = s->output_section->vma + s->output_offset;
1331 /* If it's not loaded, we don't need to relocate it this way. */
1332 if (!(s->output_section->flags & SEC_LOAD))
1335 /* I don't know why there would be a reloc for these, but I've
1336 seen it happen - DJ */
1337 if (s->output_section == &bfd_abs_section)
1340 if (s->output_section->vma == 0)
1342 /* Huh? Shouldn't happen, but punt if it does. */
1343 einfo ("DJ: zero vma section reloc detected: `%s' #%d f=%d\n",
1344 s->output_section->name, s->output_section->index,
1345 s->output_section->flags);
1349 if (!bfd_generic_link_read_symbols (b))
1351 einfo (_("%B%F: could not read symbols: %E\n"), b);
1355 symbols = bfd_get_outsymbols (b);
1356 nsyms = bfd_get_symcount (b);
1357 relsize = bfd_get_reloc_upper_bound (b, s);
1358 relocs = xmalloc (relsize);
1359 nrelocs = bfd_canonicalize_reloc (b, s, relocs, symbols);
1361 for (i = 0; i < nrelocs; i++)
1363 if (pe_dll_extra_pe_debug)
1365 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1366 printf ("rel: %s\n", sym->name);
1368 if (!relocs[i]->howto->pc_relative
1369 && relocs[i]->howto->type != pe_details->imagebase_reloc)
1372 struct bfd_symbol *sym = *relocs[i]->sym_ptr_ptr;
1374 /* Don't create relocs for undefined weak symbols. */
1375 if (sym->flags == BSF_WEAK)
1377 struct bfd_link_hash_entry *blhe
1378 = bfd_wrapped_link_hash_lookup (abfd, info, sym->name,
1379 FALSE, FALSE, FALSE);
1380 if (blhe && blhe->type == bfd_link_hash_undefweak)
1382 /* Check aux sym and see if it is defined or not. */
1383 struct coff_link_hash_entry *h, *h2;
1384 h = (struct coff_link_hash_entry *)blhe;
1385 if (h->symbol_class != C_NT_WEAK || h->numaux != 1)
1387 h2 = h->auxbfd->tdata.coff_obj_data->sym_hashes
1388 [h->aux->x_sym.x_tagndx.l];
1389 /* We don't want a base reloc if the aux sym is not
1390 found, undefined, or if it is the constant ABS
1391 zero default value. (We broaden that slightly by
1392 not testing the value, just the section; there's
1393 no reason we'd want a reference to any absolute
1394 address to get relocated during rebasing). */
1395 if (!h2 || h2->root.type == bfd_link_hash_undefined
1396 || h2->root.u.def.section == &bfd_abs_section)
1399 else if (!blhe || blhe->type != bfd_link_hash_defined)
1403 sym_vma = (relocs[i]->addend
1406 + sym->section->output_offset
1407 + sym->section->output_section->vma);
1408 reloc_data[total_relocs].vma = sec_vma + relocs[i]->address;
1410 #define BITS_AND_SHIFT(bits, shift) (bits * 1000 | shift)
1412 switch BITS_AND_SHIFT (relocs[i]->howto->bitsize,
1413 relocs[i]->howto->rightshift)
1415 #ifdef pe_use_x86_64
1416 case BITS_AND_SHIFT (64, 0):
1417 reloc_data[total_relocs].type = 10;
1421 case BITS_AND_SHIFT (32, 0):
1422 reloc_data[total_relocs].type = 3;
1425 case BITS_AND_SHIFT (16, 0):
1426 reloc_data[total_relocs].type = 2;
1429 case BITS_AND_SHIFT (16, 16):
1430 reloc_data[total_relocs].type = 4;
1431 /* FIXME: we can't know the symbol's right value
1432 yet, but we probably can safely assume that
1433 CE will relocate us in 64k blocks, so leaving
1435 reloc_data[total_relocs].extra = 0;
1438 case BITS_AND_SHIFT (26, 2):
1439 reloc_data[total_relocs].type = 5;
1442 case BITS_AND_SHIFT (24, 2):
1443 /* FIXME: 0 is ARM_26D, it is defined in bfd/coff-arm.c
1444 Those ARM_xxx definitions should go in proper
1446 if (relocs[i]->howto->type == 0
1447 /* Older GNU linkers used 5 instead of 0 for this reloc. */
1448 || relocs[i]->howto->type == 5)
1449 /* This is an ARM_26D reloc, which is an ARM_26 reloc
1450 that has already been fully processed during a
1451 previous link stage, so ignore it here. */
1455 /* xgettext:c-format */
1456 einfo (_("%XError: %d-bit reloc in dll\n"),
1457 relocs[i]->howto->bitsize);
1463 /* Warning: the allocated symbols are remembered in BFD and
1464 reused later, so don't free them! */
1468 /* At this point, we have total_relocs relocation addresses in
1469 reloc_addresses, which are all suitable for the .reloc section.
1470 We must now create the new sections. */
1471 qsort (reloc_data, total_relocs, sizeof (*reloc_data), reloc_sort);
1473 for (i = 0; i < total_relocs; i++)
1475 bfd_vma this_page = (reloc_data[i].vma >> 12);
1477 if (this_page != sec_page)
1479 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1481 sec_page = this_page;
1486 if (reloc_data[i].type == 4)
1490 reloc_sz = (reloc_sz + 3) & ~3; /* 4-byte align. */
1491 reloc_d = xmalloc (reloc_sz);
1492 sec_page = (bfd_vma) -1;
1494 page_ptr = (bfd_vma) -1;
1497 for (i = 0; i < total_relocs; i++)
1499 bfd_vma rva = reloc_data[i].vma - image_base;
1500 bfd_vma this_page = (rva & ~0xfff);
1502 if (this_page != sec_page)
1504 while (reloc_sz & 3)
1505 reloc_d[reloc_sz++] = 0;
1507 if (page_ptr != (bfd_vma) -1)
1508 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1510 bfd_put_32 (abfd, this_page, reloc_d + reloc_sz);
1511 page_ptr = reloc_sz;
1513 sec_page = this_page;
1517 bfd_put_16 (abfd, (rva & 0xfff) + (reloc_data[i].type << 12),
1518 reloc_d + reloc_sz);
1521 if (reloc_data[i].type == 4)
1523 bfd_put_16 (abfd, reloc_data[i].extra, reloc_d + reloc_sz);
1530 while (reloc_sz & 3)
1531 reloc_d[reloc_sz++] = 0;
1533 if (page_ptr != (bfd_vma) -1)
1534 bfd_put_32 (abfd, reloc_sz - page_ptr, reloc_d + page_ptr + 4);
1536 while (reloc_sz < reloc_s->size)
1537 reloc_d[reloc_sz++] = 0;
1540 /* Given the exiting def_file structure, print out a .DEF file that
1541 corresponds to it. */
1544 quoteput (char *s, FILE *f, int needs_quotes)
1548 for (cp = s; *cp; cp++)
1563 if (*s == '"' || *s == '\\')
1577 pe_dll_generate_def_file (const char *pe_out_def_filename)
1580 FILE *out = fopen (pe_out_def_filename, "w");
1583 /* xgettext:c-format */
1584 einfo (_("%s: Can't open output def file %s\n"),
1585 program_name, pe_out_def_filename);
1589 if (pe_def_file->name)
1591 if (pe_def_file->is_dll)
1592 fprintf (out, "LIBRARY ");
1594 fprintf (out, "NAME ");
1596 quoteput (pe_def_file->name, out, 1);
1598 if (pe_data (link_info.output_bfd)->pe_opthdr.ImageBase)
1600 fprintf (out, " BASE=0x");
1601 fprintf_vma (out, ((bfd_vma) pe_data (link_info.output_bfd)->pe_opthdr.ImageBase));
1603 fprintf (out, "\n");
1606 if (pe_def_file->description)
1608 fprintf (out, "DESCRIPTION ");
1609 quoteput (pe_def_file->description, out, 1);
1610 fprintf (out, "\n");
1613 if (pe_def_file->version_minor != -1)
1614 fprintf (out, "VERSION %d.%d\n", pe_def_file->version_major,
1615 pe_def_file->version_minor);
1616 else if (pe_def_file->version_major != -1)
1617 fprintf (out, "VERSION %d\n", pe_def_file->version_major);
1619 if (pe_def_file->stack_reserve != -1 || pe_def_file->heap_reserve != -1)
1620 fprintf (out, "\n");
1622 if (pe_def_file->stack_commit != -1)
1623 fprintf (out, "STACKSIZE 0x%x,0x%x\n",
1624 pe_def_file->stack_reserve, pe_def_file->stack_commit);
1625 else if (pe_def_file->stack_reserve != -1)
1626 fprintf (out, "STACKSIZE 0x%x\n", pe_def_file->stack_reserve);
1628 if (pe_def_file->heap_commit != -1)
1629 fprintf (out, "HEAPSIZE 0x%x,0x%x\n",
1630 pe_def_file->heap_reserve, pe_def_file->heap_commit);
1631 else if (pe_def_file->heap_reserve != -1)
1632 fprintf (out, "HEAPSIZE 0x%x\n", pe_def_file->heap_reserve);
1634 if (pe_def_file->num_section_defs > 0)
1636 fprintf (out, "\nSECTIONS\n\n");
1638 for (i = 0; i < pe_def_file->num_section_defs; i++)
1641 quoteput (pe_def_file->section_defs[i].name, out, 0);
1643 if (pe_def_file->section_defs[i].class)
1645 fprintf (out, " CLASS ");
1646 quoteput (pe_def_file->section_defs[i].class, out, 0);
1649 if (pe_def_file->section_defs[i].flag_read)
1650 fprintf (out, " READ");
1652 if (pe_def_file->section_defs[i].flag_write)
1653 fprintf (out, " WRITE");
1655 if (pe_def_file->section_defs[i].flag_execute)
1656 fprintf (out, " EXECUTE");
1658 if (pe_def_file->section_defs[i].flag_shared)
1659 fprintf (out, " SHARED");
1661 fprintf (out, "\n");
1665 if (pe_def_file->num_exports > 0)
1667 fprintf (out, "EXPORTS\n");
1669 for (i = 0; i < pe_def_file->num_exports; i++)
1671 def_file_export *e = pe_def_file->exports + i;
1673 quoteput (e->name, out, 0);
1675 if (e->internal_name && strcmp (e->internal_name, e->name))
1677 fprintf (out, " = ");
1678 quoteput (e->internal_name, out, 0);
1681 if (e->ordinal != -1)
1682 fprintf (out, " @%d", e->ordinal);
1684 if (e->flag_private)
1685 fprintf (out, " PRIVATE");
1687 if (e->flag_constant)
1688 fprintf (out, " CONSTANT");
1691 fprintf (out, " NONAME");
1694 fprintf (out, " DATA");
1696 fprintf (out, "\n");
1700 if (pe_def_file->num_imports > 0)
1702 fprintf (out, "\nIMPORTS\n\n");
1704 for (i = 0; i < pe_def_file->num_imports; i++)
1706 def_file_import *im = pe_def_file->imports + i;
1709 if (im->internal_name
1710 && (!im->name || strcmp (im->internal_name, im->name)))
1712 quoteput (im->internal_name, out, 0);
1713 fprintf (out, " = ");
1716 quoteput (im->module->name, out, 0);
1720 quoteput (im->name, out, 0);
1722 fprintf (out, "%d", im->ordinal);
1726 fprintf (out, " == ");
1727 quoteput (im->its_name, out, 0);
1730 fprintf (out, "\n");
1735 fprintf (out, _("; no contents available\n"));
1737 if (fclose (out) == EOF)
1738 /* xgettext:c-format */
1739 einfo (_("%P: Error closing file `%s'\n"), pe_out_def_filename);
1742 /* Generate the import library. */
1744 static asymbol **symtab;
1747 static int tmp_seq2;
1748 static const char *dll_filename;
1749 static char *dll_symname;
1751 #define UNDSEC (asection *) &bfd_und_section
1754 quick_section (bfd *abfd, const char *name, int flags, int align)
1759 sec = bfd_make_section_old_way (abfd, name);
1760 bfd_set_section_flags (abfd, sec, flags | SEC_ALLOC | SEC_LOAD | SEC_KEEP);
1761 bfd_set_section_alignment (abfd, sec, align);
1762 /* Remember to undo this before trying to link internally! */
1763 sec->output_section = sec;
1765 sym = bfd_make_empty_symbol (abfd);
1766 symtab[symptr++] = sym;
1767 sym->name = sec->name;
1769 sym->flags = BSF_LOCAL;
1776 quick_symbol (bfd *abfd,
1785 char *name = xmalloc (strlen (n1) + strlen (n2) + strlen (n3) + 1);
1790 sym = bfd_make_empty_symbol (abfd);
1795 symtab[symptr++] = sym;
1798 static arelent *reltab = 0;
1799 static int relcount = 0, relsize = 0;
1802 quick_reloc (bfd *abfd, bfd_size_type address, int which_howto, int symidx)
1804 if (relcount >= relsize - 1)
1808 reltab = xrealloc (reltab, relsize * sizeof (arelent));
1810 reltab = xmalloc (relsize * sizeof (arelent));
1812 reltab[relcount].address = address;
1813 reltab[relcount].addend = 0;
1814 reltab[relcount].howto = bfd_reloc_type_lookup (abfd, which_howto);
1815 reltab[relcount].sym_ptr_ptr = symtab + symidx;
1820 save_relocs (asection *sec)
1824 sec->relocation = reltab;
1825 sec->reloc_count = relcount;
1826 sec->orelocation = xmalloc ((relcount + 1) * sizeof (arelent *));
1827 for (i = 0; i < relcount; i++)
1828 sec->orelocation[i] = sec->relocation + i;
1829 sec->orelocation[relcount] = 0;
1830 sec->flags |= SEC_RELOC;
1832 relcount = relsize = 0;
1835 /* .section .idata$2
1836 .global __head_my_dll
1853 make_head (bfd *parent)
1855 asection *id2, *id5, *id4;
1856 unsigned char *d2, *d5, *d4;
1860 oname = xmalloc (20);
1861 sprintf (oname, "d%06d.o", tmp_seq);
1864 abfd = bfd_create (oname, parent);
1865 bfd_find_target (pe_details->object_target, abfd);
1866 bfd_make_writable (abfd);
1868 bfd_set_format (abfd, bfd_object);
1869 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1872 symtab = xmalloc (6 * sizeof (asymbol *));
1873 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
1874 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1875 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1876 quick_symbol (abfd, U ("_head_"), dll_symname, "", id2, BSF_GLOBAL, 0);
1877 quick_symbol (abfd, U (""), dll_symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
1879 /* OK, pay attention here. I got confused myself looking back at
1880 it. We create a four-byte section to mark the beginning of the
1881 list, and we include an offset of 4 in the section, so that the
1882 pointer to the list points to the *end* of this section, which is
1883 the start of the list of sections from other objects. */
1885 bfd_set_section_size (abfd, id2, 20);
1889 if (pe_use_nul_prefixed_import_tables)
1890 d2[0] = d2[16] = PE_IDATA5_SIZE; /* Reloc addend. */
1891 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
1892 quick_reloc (abfd, 12, BFD_RELOC_RVA, 4);
1893 quick_reloc (abfd, 16, BFD_RELOC_RVA, 1);
1896 if (pe_use_nul_prefixed_import_tables)
1897 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
1899 bfd_set_section_size (abfd, id5, 0);
1900 d5 = xmalloc (PE_IDATA5_SIZE);
1902 memset (d5, 0, PE_IDATA5_SIZE);
1903 if (pe_use_nul_prefixed_import_tables)
1904 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
1906 bfd_set_section_size (abfd, id4, 0);
1907 d4 = xmalloc (PE_IDATA4_SIZE);
1909 memset (d4, 0, PE_IDATA4_SIZE);
1911 bfd_set_symtab (abfd, symtab, symptr);
1913 bfd_set_section_contents (abfd, id2, d2, 0, 20);
1914 if (pe_use_nul_prefixed_import_tables)
1916 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
1917 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
1921 bfd_set_section_contents (abfd, id5, d5, 0, 0);
1922 bfd_set_section_contents (abfd, id4, d4, 0, 0);
1925 bfd_make_readable (abfd);
1929 /* .section .idata$4
1936 .global __my_dll_iname
1941 make_tail (bfd *parent)
1943 asection *id4, *id5, *id7;
1944 unsigned char *d4, *d5, *d7;
1949 oname = xmalloc (20);
1950 sprintf (oname, "d%06d.o", tmp_seq);
1953 abfd = bfd_create (oname, parent);
1954 bfd_find_target (pe_details->object_target, abfd);
1955 bfd_make_writable (abfd);
1957 bfd_set_format (abfd, bfd_object);
1958 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
1961 symtab = xmalloc (5 * sizeof (asymbol *));
1962 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
1963 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
1964 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
1965 quick_symbol (abfd, U (""), dll_symname, "_iname", id7, BSF_GLOBAL, 0);
1967 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
1968 d4 = xmalloc (PE_IDATA4_SIZE);
1970 memset (d4, 0, PE_IDATA4_SIZE);
1972 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
1973 d5 = xmalloc (PE_IDATA5_SIZE);
1975 memset (d5, 0, PE_IDATA5_SIZE);
1977 len = strlen (dll_filename) + 1;
1980 bfd_set_section_size (abfd, id7, len);
1983 strcpy ((char *) d7, dll_filename);
1984 /* If len was odd, the above
1985 strcpy leaves behind an undefined byte. That is harmless,
1986 but we set it to 0 just so the binary dumps are pretty. */
1989 bfd_set_symtab (abfd, symtab, symptr);
1991 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
1992 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
1993 bfd_set_section_contents (abfd, id7, d7, 0, len);
1995 bfd_make_readable (abfd);
2001 .global ___imp_function
2002 .global __imp__function
2004 jmp *__imp__function:
2018 .asciz "function" xlate? (add underscore, kill at) */
2020 static const unsigned char jmp_ix86_bytes[] =
2022 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, 0x90, 0x90
2030 .dw __imp_function */
2032 static const unsigned char jmp_sh_bytes[] =
2034 0x01, 0xd0, 0x02, 0x60, 0x2b, 0x40, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
2038 lui $t0,<high:__imp_function>
2039 lw $t0,<low:__imp_function>
2043 static const unsigned char jmp_mips_bytes[] =
2045 0x00, 0x00, 0x08, 0x3c, 0x00, 0x00, 0x08, 0x8d,
2046 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00
2049 static const unsigned char jmp_arm_bytes[] =
2051 0x00, 0xc0, 0x9f, 0xe5, /* ldr ip, [pc] */
2052 0x00, 0xf0, 0x9c, 0xe5, /* ldr pc, [ip] */
2058 make_one (def_file_export *exp, bfd *parent, bfd_boolean include_jmp_stub)
2060 asection *tx, *id7, *id5, *id4, *id6;
2061 unsigned char *td = NULL, *d7, *d5, *d4, *d6 = NULL;
2065 const unsigned char *jmp_bytes = NULL;
2066 int jmp_byte_count = 0;
2068 /* Include the jump stub section only if it is needed. A jump
2069 stub is needed if the symbol being imported <sym> is a function
2070 symbol and there is at least one undefined reference to that
2071 symbol. In other words, if all the import references to <sym> are
2072 explicitly through _declspec(dllimport) then the jump stub is not
2074 if (include_jmp_stub)
2076 switch (pe_details->pe_arch)
2079 jmp_bytes = jmp_ix86_bytes;
2080 jmp_byte_count = sizeof (jmp_ix86_bytes);
2083 jmp_bytes = jmp_sh_bytes;
2084 jmp_byte_count = sizeof (jmp_sh_bytes);
2087 jmp_bytes = jmp_mips_bytes;
2088 jmp_byte_count = sizeof (jmp_mips_bytes);
2091 case PE_ARCH_arm_epoc:
2092 case PE_ARCH_arm_wince:
2093 jmp_bytes = jmp_arm_bytes;
2094 jmp_byte_count = sizeof (jmp_arm_bytes);
2101 oname = xmalloc (20);
2102 sprintf (oname, "d%06d.o", tmp_seq);
2105 abfd = bfd_create (oname, parent);
2106 bfd_find_target (pe_details->object_target, abfd);
2107 bfd_make_writable (abfd);
2109 bfd_set_format (abfd, bfd_object);
2110 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2113 symtab = xmalloc (12 * sizeof (asymbol *));
2115 tx = quick_section (abfd, ".text", SEC_CODE | SEC_HAS_CONTENTS | SEC_READONLY, 2);
2116 id7 = quick_section (abfd, ".idata$7", SEC_HAS_CONTENTS, 2);
2117 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
2118 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2119 id6 = quick_section (abfd, ".idata$6", SEC_HAS_CONTENTS, 2);
2121 if (*exp->internal_name == '@')
2123 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
2125 if (include_jmp_stub)
2126 quick_symbol (abfd, "", exp->internal_name, "", tx, BSF_GLOBAL, 0);
2127 quick_symbol (abfd, "__imp_", exp->internal_name, "", id5,
2129 /* Fastcall applies only to functions,
2130 so no need for auto-import symbol. */
2134 quick_symbol (abfd, U ("_head_"), dll_symname, "", UNDSEC,
2136 if (include_jmp_stub)
2137 quick_symbol (abfd, U (""), exp->internal_name, "", tx,
2139 quick_symbol (abfd, "__imp_", U (""), exp->internal_name, id5,
2141 /* Symbol to reference ord/name of imported
2142 data symbol, used to implement auto-import. */
2144 quick_symbol (abfd, "__nm_", U (""), exp->internal_name, id6,
2147 if (pe_dll_compat_implib)
2148 quick_symbol (abfd, "___imp_", exp->internal_name, "", id5,
2151 if (include_jmp_stub)
2153 bfd_set_section_size (abfd, tx, jmp_byte_count);
2154 td = xmalloc (jmp_byte_count);
2156 memcpy (td, jmp_bytes, jmp_byte_count);
2158 switch (pe_details->pe_arch)
2161 #ifdef pe_use_x86_64
2162 quick_reloc (abfd, 2, BFD_RELOC_32_PCREL, 2);
2164 /* Mark this object as SAFESEH compatible. */
2165 quick_symbol (abfd, "", "@feat.00", "", bfd_abs_section_ptr,
2167 quick_reloc (abfd, 2, BFD_RELOC_32, 2);
2171 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
2174 quick_reloc (abfd, 0, BFD_RELOC_HI16_S, 2);
2175 quick_reloc (abfd, 0, BFD_RELOC_LO16, 0); /* MIPS_R_PAIR */
2176 quick_reloc (abfd, 4, BFD_RELOC_LO16, 2);
2179 case PE_ARCH_arm_epoc:
2180 case PE_ARCH_arm_wince:
2181 quick_reloc (abfd, 8, BFD_RELOC_32, 2);
2189 bfd_set_section_size (abfd, tx, 0);
2191 bfd_set_section_size (abfd, id7, 4);
2195 quick_reloc (abfd, 0, BFD_RELOC_RVA, 5);
2198 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE);
2199 d5 = xmalloc (PE_IDATA5_SIZE);
2201 memset (d5, 0, PE_IDATA5_SIZE);
2203 if (exp->flag_noname)
2205 d5[0] = exp->ordinal;
2206 d5[1] = exp->ordinal >> 8;
2207 d5[PE_IDATA5_SIZE - 1] = 0x80;
2211 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
2215 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE);
2216 d4 = xmalloc (PE_IDATA4_SIZE);
2218 memset (d4, 0, PE_IDATA4_SIZE);
2220 if (exp->flag_noname)
2222 d4[0] = exp->ordinal;
2223 d4[1] = exp->ordinal >> 8;
2224 d4[PE_IDATA4_SIZE - 1] = 0x80;
2228 quick_reloc (abfd, 0, BFD_RELOC_RVA, 4);
2232 if (exp->flag_noname)
2235 bfd_set_section_size (abfd, id6, 0);
2239 /* { short, asciz } */
2241 len = 2 + strlen (exp->its_name) + 1;
2243 len = 2 + strlen (exp->name) + 1;
2246 bfd_set_section_size (abfd, id6, len);
2249 memset (d6, 0, len);
2250 d6[0] = exp->hint & 0xff;
2251 d6[1] = exp->hint >> 8;
2253 strcpy ((char*) d6 + 2, exp->its_name);
2255 strcpy ((char *) d6 + 2, exp->name);
2258 bfd_set_symtab (abfd, symtab, symptr);
2260 if (include_jmp_stub)
2261 bfd_set_section_contents (abfd, tx, td, 0, jmp_byte_count);
2262 bfd_set_section_contents (abfd, id7, d7, 0, 4);
2263 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA5_SIZE);
2264 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE);
2265 if (!exp->flag_noname)
2266 bfd_set_section_contents (abfd, id6, d6, 0, len);
2268 bfd_make_readable (abfd);
2273 make_singleton_name_imp (const char *import, bfd *parent)
2275 /* Name thunks go to idata$4. */
2281 oname = xmalloc (20);
2282 sprintf (oname, "nmimp%06d.o", tmp_seq2);
2285 abfd = bfd_create (oname, parent);
2286 bfd_find_target (pe_details->object_target, abfd);
2287 bfd_make_writable (abfd);
2289 bfd_set_format (abfd, bfd_object);
2290 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2293 symtab = xmalloc (3 * sizeof (asymbol *));
2294 id5 = quick_section (abfd, ".idata$5", SEC_HAS_CONTENTS, 2);
2295 quick_symbol (abfd, "__imp_", import, "", id5, BSF_GLOBAL, 0);
2297 /* We need space for the real thunk and for the null terminator. */
2298 bfd_set_section_size (abfd, id5, PE_IDATA5_SIZE * 2);
2299 d5 = xmalloc (PE_IDATA5_SIZE * 2);
2301 memset (d5, 0, PE_IDATA5_SIZE * 2);
2302 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
2305 bfd_set_symtab (abfd, symtab, symptr);
2307 bfd_set_section_contents (abfd, id5, d5, 0, PE_IDATA4_SIZE * 2);
2309 bfd_make_readable (abfd);
2314 make_singleton_name_thunk (const char *import, bfd *parent)
2316 /* Name thunks go to idata$4. */
2322 oname = xmalloc (20);
2323 sprintf (oname, "nmth%06d.o", tmp_seq);
2326 abfd = bfd_create (oname, parent);
2327 bfd_find_target (pe_details->object_target, abfd);
2328 bfd_make_writable (abfd);
2330 bfd_set_format (abfd, bfd_object);
2331 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2334 symtab = xmalloc (3 * sizeof (asymbol *));
2335 id4 = quick_section (abfd, ".idata$4", SEC_HAS_CONTENTS, 2);
2336 quick_symbol (abfd, "__nm_thnk_", import, "", id4, BSF_GLOBAL, 0);
2337 quick_symbol (abfd, "__nm_", import, "", UNDSEC, BSF_GLOBAL, 0);
2339 /* We need space for the real thunk and for the null terminator. */
2340 bfd_set_section_size (abfd, id4, PE_IDATA4_SIZE * 2);
2341 d4 = xmalloc (PE_IDATA4_SIZE * 2);
2343 memset (d4, 0, PE_IDATA4_SIZE * 2);
2344 quick_reloc (abfd, 0, BFD_RELOC_RVA, 2);
2347 bfd_set_symtab (abfd, symtab, symptr);
2349 bfd_set_section_contents (abfd, id4, d4, 0, PE_IDATA4_SIZE * 2);
2351 bfd_make_readable (abfd);
2356 make_import_fixup_mark (arelent *rel)
2358 /* We convert reloc to symbol, for later reference. */
2360 static char *fixup_name = NULL;
2361 static size_t buffer_len = 0;
2363 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
2365 bfd *abfd = bfd_asymbol_bfd (sym);
2366 struct bfd_link_hash_entry *bh;
2370 fixup_name = xmalloc (384);
2374 if (strlen (sym->name) + 25 > buffer_len)
2375 /* Assume 25 chars for "__fu" + counter + "_". If counter is
2376 bigger than 20 digits long, we've got worse problems than
2377 overflowing this buffer... */
2380 /* New buffer size is length of symbol, plus 25, but
2381 then rounded up to the nearest multiple of 128. */
2382 buffer_len = ((strlen (sym->name) + 25) + 127) & ~127;
2383 fixup_name = xmalloc (buffer_len);
2386 sprintf (fixup_name, "__fu%d_%s", counter++, sym->name);
2389 bfd_coff_link_add_one_symbol (&link_info, abfd, fixup_name, BSF_GLOBAL,
2390 current_sec, /* sym->section, */
2391 rel->address, NULL, TRUE, FALSE, &bh);
2396 /* .section .idata$2
2397 .rva __nm_thnk_SYM (singleton thunk with name of func)
2400 .rva __my_dll_iname (name of dll)
2401 .rva __fuNN_SYM (pointer to reference (address) in text) */
2404 make_import_fixup_entry (const char *name,
2405 const char *fixup_name,
2406 const char *symname,
2414 oname = xmalloc (20);
2415 sprintf (oname, "fu%06d.o", tmp_seq);
2418 abfd = bfd_create (oname, parent);
2419 bfd_find_target (pe_details->object_target, abfd);
2420 bfd_make_writable (abfd);
2422 bfd_set_format (abfd, bfd_object);
2423 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2426 symtab = xmalloc (6 * sizeof (asymbol *));
2427 id2 = quick_section (abfd, ".idata$2", SEC_HAS_CONTENTS, 2);
2429 quick_symbol (abfd, "__nm_thnk_", name, "", UNDSEC, BSF_GLOBAL, 0);
2430 quick_symbol (abfd, U (""), symname, "_iname", UNDSEC, BSF_GLOBAL, 0);
2431 /* For relocator v2 we have to use the .idata$5 element and not
2433 if (link_info.pei386_runtime_pseudo_reloc == 2)
2434 quick_symbol (abfd, "__imp_", name, "", UNDSEC, BSF_GLOBAL, 0);
2436 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2438 bfd_set_section_size (abfd, id2, 20);
2443 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2444 quick_reloc (abfd, 12, BFD_RELOC_RVA, 2);
2445 quick_reloc (abfd, 16, BFD_RELOC_RVA, 3);
2448 bfd_set_symtab (abfd, symtab, symptr);
2450 bfd_set_section_contents (abfd, id2, d2, 0, 20);
2452 bfd_make_readable (abfd);
2456 /* .section .rdata_runtime_pseudo_reloc
2458 .rva __fuNN_SYM (pointer to reference (address) in text) */
2461 make_runtime_pseudo_reloc (const char *name ATTRIBUTE_UNUSED,
2462 const char *fixup_name,
2463 bfd_vma addend ATTRIBUTE_UNUSED,
2468 unsigned char *rt_rel_d;
2471 oname = xmalloc (20);
2472 sprintf (oname, "rtr%06d.o", tmp_seq);
2475 abfd = bfd_create (oname, parent);
2476 bfd_find_target (pe_details->object_target, abfd);
2477 bfd_make_writable (abfd);
2479 bfd_set_format (abfd, bfd_object);
2480 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2483 if (link_info.pei386_runtime_pseudo_reloc == 2)
2485 symtab = xmalloc ((runtime_pseudp_reloc_v2_init ? 3 : 6) * sizeof (asymbol *));
2489 symtab = xmalloc (2 * sizeof (asymbol *));
2491 rt_rel = quick_section (abfd, ".rdata_runtime_pseudo_reloc",
2492 SEC_HAS_CONTENTS, 2);
2494 quick_symbol (abfd, "", fixup_name, "", UNDSEC, BSF_GLOBAL, 0);
2496 if (link_info.pei386_runtime_pseudo_reloc == 2)
2499 if (! runtime_pseudp_reloc_v2_init)
2502 runtime_pseudp_reloc_v2_init = 1;
2504 quick_symbol (abfd, "__imp_", name, "", UNDSEC, BSF_GLOBAL, 0);
2506 bfd_set_section_size (abfd, rt_rel, size);
2507 rt_rel_d = xmalloc (size);
2508 rt_rel->contents = rt_rel_d;
2509 memset (rt_rel_d, 0, size);
2510 quick_reloc (abfd, size - 8, BFD_RELOC_RVA, 1);
2511 quick_reloc (abfd, size - 12, BFD_RELOC_RVA, 2);
2512 bfd_put_32 (abfd, bitsize, rt_rel_d + (size - 4));
2514 bfd_put_32 (abfd, 1, rt_rel_d + 8);
2515 save_relocs (rt_rel);
2517 bfd_set_symtab (abfd, symtab, symptr);
2519 bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, size);
2523 bfd_set_section_size (abfd, rt_rel, 8);
2524 rt_rel_d = xmalloc (8);
2525 rt_rel->contents = rt_rel_d;
2526 memset (rt_rel_d, 0, 8);
2528 bfd_put_32 (abfd, addend, rt_rel_d);
2529 quick_reloc (abfd, 4, BFD_RELOC_RVA, 1);
2531 save_relocs (rt_rel);
2533 bfd_set_symtab (abfd, symtab, symptr);
2535 bfd_set_section_contents (abfd, rt_rel, rt_rel_d, 0, 8);
2537 bfd_make_readable (abfd);
2542 .rva __pei386_runtime_relocator */
2545 pe_create_runtime_relocator_reference (bfd *parent)
2547 asection *extern_rt_rel;
2548 unsigned char *extern_rt_rel_d;
2552 oname = xmalloc (20);
2553 sprintf (oname, "ertr%06d.o", tmp_seq);
2556 abfd = bfd_create (oname, parent);
2557 bfd_find_target (pe_details->object_target, abfd);
2558 bfd_make_writable (abfd);
2560 bfd_set_format (abfd, bfd_object);
2561 bfd_set_arch_mach (abfd, pe_details->bfd_arch, 0);
2564 symtab = xmalloc (2 * sizeof (asymbol *));
2565 extern_rt_rel = quick_section (abfd, ".rdata", SEC_HAS_CONTENTS, 2);
2567 quick_symbol (abfd, "", U ("_pei386_runtime_relocator"), "", UNDSEC,
2570 bfd_set_section_size (abfd, extern_rt_rel, PE_IDATA5_SIZE);
2571 extern_rt_rel_d = xmalloc (PE_IDATA5_SIZE);
2572 extern_rt_rel->contents = extern_rt_rel_d;
2574 quick_reloc (abfd, 0, BFD_RELOC_RVA, 1);
2575 save_relocs (extern_rt_rel);
2577 bfd_set_symtab (abfd, symtab, symptr);
2579 bfd_set_section_contents (abfd, extern_rt_rel, extern_rt_rel_d, 0, PE_IDATA5_SIZE);
2581 bfd_make_readable (abfd);
2586 pe_create_import_fixup (arelent *rel, asection *s, bfd_vma addend)
2589 struct bfd_symbol *sym = *rel->sym_ptr_ptr;
2590 struct bfd_link_hash_entry *name_thunk_sym;
2591 struct bfd_link_hash_entry *name_imp_sym;
2592 const char *name = sym->name;
2593 char *fixup_name = make_import_fixup_mark (rel);
2595 int need_import_table = 1;
2597 sprintf (buf, "__imp_%s", name);
2598 name_imp_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
2600 sprintf (buf, "__nm_thnk_%s", name);
2602 name_thunk_sym = bfd_link_hash_lookup (link_info.hash, buf, 0, 0, 1);
2604 /* For version 2 pseudo relocation we don't need to add an import
2605 if the import symbol is already present. */
2606 if (link_info.pei386_runtime_pseudo_reloc == 2
2608 && name_imp_sym->type == bfd_link_hash_defined)
2609 need_import_table = 0;
2611 if (need_import_table == 1
2612 && (!name_thunk_sym || name_thunk_sym->type != bfd_link_hash_defined))
2614 b = make_singleton_name_thunk (name, link_info.output_bfd);
2615 add_bfd_to_link (b, b->filename, &link_info);
2617 /* If we ever use autoimport, we have to cast text section writable.
2618 But not for version 2. */
2619 if (link_info.pei386_runtime_pseudo_reloc != 2)
2621 config.text_read_only = FALSE;
2622 link_info.output_bfd->flags &= ~WP_TEXT;
2624 if (link_info.pei386_runtime_pseudo_reloc == 2)
2626 b = make_singleton_name_imp (name, link_info.output_bfd);
2627 add_bfd_to_link (b, b->filename, &link_info);
2631 if ((addend == 0 || link_info.pei386_runtime_pseudo_reloc)
2632 && need_import_table == 1)
2634 extern char * pe_data_import_dll;
2635 char * symname = pe_data_import_dll ? pe_data_import_dll : "unknown";
2637 b = make_import_fixup_entry (name, fixup_name, symname,
2638 link_info.output_bfd);
2639 add_bfd_to_link (b, b->filename, &link_info);
2642 if ((link_info.pei386_runtime_pseudo_reloc != 0 && addend != 0)
2643 || link_info.pei386_runtime_pseudo_reloc == 2)
2645 if (pe_dll_extra_pe_debug)
2646 printf ("creating runtime pseudo-reloc entry for %s (addend=%d)\n",
2647 fixup_name, (int) addend);
2649 b = make_runtime_pseudo_reloc (name, fixup_name, addend, rel->howto->bitsize,
2650 link_info.output_bfd);
2651 add_bfd_to_link (b, b->filename, &link_info);
2653 if (runtime_pseudo_relocs_created == 0)
2655 b = pe_create_runtime_relocator_reference (link_info.output_bfd);
2656 add_bfd_to_link (b, b->filename, &link_info);
2658 runtime_pseudo_relocs_created++;
2660 else if (addend != 0)
2662 einfo (_("%C: variable '%T' can't be auto-imported. Please read the documentation for ld's --enable-auto-import for details.\n"),
2663 s->owner, s, rel->address, sym->name);
2670 pe_dll_generate_implib (def_file *def, const char *impfilename, struct bfd_link_info *info)
2679 dll_filename = (def->name) ? def->name : dll_name;
2680 dll_symname = xstrdup (dll_filename);
2681 for (i = 0; dll_symname[i]; i++)
2682 if (!ISALNUM (dll_symname[i]))
2683 dll_symname[i] = '_';
2685 unlink_if_ordinary (impfilename);
2687 outarch = bfd_openw (impfilename, 0);
2691 /* xgettext:c-format */
2692 einfo (_("%XCan't open .lib file: %s\n"), impfilename);
2696 /* xgettext:c-format */
2697 info_msg (_("Creating library file: %s\n"), impfilename);
2699 bfd_set_format (outarch, bfd_archive);
2700 outarch->has_armap = 1;
2702 /* Work out a reasonable size of things to put onto one line. */
2703 ar_head = make_head (outarch);
2705 /* Iterate the input BFDs, looking for exclude-modules-for-implib. */
2706 for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link_next)
2708 /* Iterate the exclude list. */
2709 struct exclude_list_struct *ex;
2711 for (ex = excludes, found = 0; ex && !found; ex = ex->next)
2713 if (ex->type != EXCLUDEFORIMPLIB)
2715 found = (strcmp (ex->string, ibfd->filename) == 0);
2717 /* If it matched, we must open a fresh BFD for it (the original
2718 input BFD is still needed for the DLL's final link) and add
2719 it into the archive member chain. */
2722 bfd *newbfd = bfd_openr (ibfd->my_archive
2723 ? ibfd->my_archive->filename : ibfd->filename, NULL);
2726 einfo (_("%Xbfd_openr %s: %E\n"), ibfd->filename);
2729 if (ibfd->my_archive)
2731 /* Must now iterate through archive until we find the
2732 required member. A minor shame that we'll open the
2733 archive once per member that we require from it, and
2734 leak those archive bfds rather than reuse them. */
2735 bfd *arbfd = newbfd;
2736 if (!bfd_check_format_matches (arbfd, bfd_archive, NULL))
2738 einfo (_("%X%s(%s): can't find member in non-archive file"),
2739 ibfd->my_archive->filename, ibfd->filename);
2743 while ((newbfd = bfd_openr_next_archived_file (arbfd, newbfd)) != 0)
2745 if (strcmp (newbfd->filename, ibfd->filename) == 0)
2750 einfo (_("%X%s(%s): can't find member in archive"),
2751 ibfd->my_archive->filename, ibfd->filename);
2755 newbfd->archive_next = head;
2760 for (i = 0; i < def->num_exports; i++)
2762 /* The import library doesn't know about the internal name. */
2763 char *internal = def->exports[i].internal_name;
2766 /* Don't add PRIVATE entries to import lib. */
2767 if (pe_def_file->exports[i].flag_private)
2769 def->exports[i].internal_name = def->exports[i].name;
2770 n = make_one (def->exports + i, outarch,
2771 ! (def->exports + i)->flag_data);
2772 n->archive_next = head;
2774 def->exports[i].internal_name = internal;
2777 ar_tail = make_tail (outarch);
2779 if (ar_head == NULL || ar_tail == NULL)
2782 /* Now stick them all into the archive. */
2783 ar_head->archive_next = head;
2784 ar_tail->archive_next = ar_head;
2787 if (! bfd_set_archive_head (outarch, head))
2788 einfo ("%Xbfd_set_archive_head: %E\n");
2790 if (! bfd_close (outarch))
2791 einfo ("%Xbfd_close %s: %E\n", impfilename);
2793 while (head != NULL)
2795 bfd *n = head->archive_next;
2801 static struct bfd_link_hash_entry *found_sym;
2804 pe_undef_alias_cdecl_match (struct bfd_link_hash_entry *h, void *inf)
2808 const char *hs = h->root.string;
2810 sl = strlen (string);
2811 if (h->type == bfd_link_hash_undefined
2812 && ((*hs == '@' && (!pe_details->underscored || *string == '_')
2813 && strncmp (hs + 1, string + (pe_details->underscored != 0),
2814 sl - (pe_details->underscored != 0)) == 0)
2815 || strncmp (hs, string, sl) == 0)
2816 && h->root.string[sl] == '@')
2824 static struct bfd_link_hash_entry *
2825 pe_find_cdecl_alias_match (char *name)
2828 bfd_link_hash_traverse (link_info.hash, pe_undef_alias_cdecl_match,
2834 add_bfd_to_link (bfd *abfd, const char *name, struct bfd_link_info *linfo)
2836 lang_input_statement_type *fake_file;
2838 fake_file = lang_add_input_file (name,
2839 lang_input_file_is_fake_enum,
2841 fake_file->the_bfd = abfd;
2842 ldlang_add_file (fake_file);
2844 if (!bfd_link_add_symbols (abfd, linfo))
2845 einfo ("%Xaddsym %s: %E\n", name);
2849 pe_process_import_defs (bfd *output_bfd, struct bfd_link_info *linfo)
2851 def_file_module *module;
2853 pe_dll_id_target (bfd_get_target (output_bfd));
2858 for (module = pe_def_file->modules; module; module = module->next)
2862 dll_filename = module->name;
2863 dll_symname = xstrdup (module->name);
2864 for (i = 0; dll_symname[i]; i++)
2865 if (!ISALNUM (dll_symname[i]))
2866 dll_symname[i] = '_';
2870 for (i = 0; i < pe_def_file->num_imports; i++)
2871 if (pe_def_file->imports[i].module == module)
2873 def_file_export exp;
2874 struct bfd_link_hash_entry *blhe;
2875 int lead_at = (*pe_def_file->imports[i].internal_name == '@');
2876 /* See if we need this import. */
2877 size_t len = strlen (pe_def_file->imports[i].internal_name);
2878 char *name = xmalloc (len + 2 + 6);
2879 bfd_boolean include_jmp_stub = FALSE;
2880 bfd_boolean is_cdecl = FALSE;
2881 if (!lead_at && strchr (pe_def_file->imports[i].internal_name, '@') == NULL)
2885 sprintf (name, "%s",
2886 pe_def_file->imports[i].internal_name);
2888 sprintf (name, "%s%s",U (""),
2889 pe_def_file->imports[i].internal_name);
2891 blhe = bfd_link_hash_lookup (linfo->hash, name,
2892 FALSE, FALSE, FALSE);
2894 /* Include the jump stub for <sym> only if the <sym>
2896 if (!blhe || (blhe && blhe->type != bfd_link_hash_undefined))
2899 sprintf (name, "%s%s", "__imp_",
2900 pe_def_file->imports[i].internal_name);
2902 sprintf (name, "%s%s%s", "__imp_", U (""),
2903 pe_def_file->imports[i].internal_name);
2905 blhe = bfd_link_hash_lookup (linfo->hash, name,
2906 FALSE, FALSE, FALSE);
2909 include_jmp_stub = TRUE;
2911 if (is_cdecl && !blhe)
2913 sprintf (name, "%s%s",U (""),
2914 pe_def_file->imports[i].internal_name);
2915 blhe = pe_find_cdecl_alias_match (name);
2916 include_jmp_stub = TRUE;
2921 if (blhe && blhe->type == bfd_link_hash_undefined)
2927 bfd *ar_head = make_head (output_bfd);
2928 add_bfd_to_link (ar_head, ar_head->filename, linfo);
2931 exp.internal_name = pe_def_file->imports[i].internal_name;
2932 exp.name = pe_def_file->imports[i].name;
2933 exp.its_name = pe_def_file->imports[i].its_name;
2934 exp.ordinal = pe_def_file->imports[i].ordinal;
2935 exp.hint = exp.ordinal >= 0 ? exp.ordinal : 0;
2936 exp.flag_private = 0;
2937 exp.flag_constant = 0;
2938 exp.flag_data = pe_def_file->imports[i].data;
2939 exp.flag_noname = exp.name ? 0 : 1;
2940 one = make_one (&exp, output_bfd, (! exp.flag_data) && include_jmp_stub);
2941 add_bfd_to_link (one, one->filename, linfo);
2946 bfd *ar_tail = make_tail (output_bfd);
2947 add_bfd_to_link (ar_tail, ar_tail->filename, linfo);
2954 /* We were handed a *.DLL file. Parse it and turn it into a set of
2955 IMPORTS directives in the def file. Return TRUE if the file was
2956 handled, FALSE if not. */
2959 pe_get16 (bfd *abfd, int where)
2963 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
2964 bfd_bread (b, (bfd_size_type) 2, abfd);
2965 return b[0] + (b[1] << 8);
2969 pe_get32 (bfd *abfd, int where)
2973 bfd_seek (abfd, (file_ptr) where, SEEK_SET);
2974 bfd_bread (b, (bfd_size_type) 4, abfd);
2975 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
2981 unsigned char *b = ptr;
2983 return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
2987 pe_implied_import_dll (const char *filename)
2990 bfd_vma pe_header_offset, opthdr_ofs, num_entries, i;
2991 bfd_vma export_rva, export_size, nsections, secptr, expptr;
2992 bfd_vma exp_funcbase;
2993 unsigned char *expdata;
2995 bfd_vma name_rvas, ordinals, nexp, ordbase;
2996 const char *dllname;
2997 /* Initialization with start > end guarantees that is_data
2998 will not be set by mistake, and avoids compiler warning. */
2999 bfd_vma data_start = 1;
3000 bfd_vma data_end = 0;
3001 bfd_vma rdata_start = 1;
3002 bfd_vma rdata_end = 0;
3003 bfd_vma bss_start = 1;
3004 bfd_vma bss_end = 0;
3006 /* No, I can't use bfd here. kernel32.dll puts its export table in
3007 the middle of the .rdata section. */
3008 dll = bfd_openr (filename, pe_details->target_name);
3011 einfo ("%Xopen %s: %E\n", filename);
3015 /* PEI dlls seem to be bfd_objects. */
3016 if (!bfd_check_format (dll, bfd_object))
3018 einfo ("%X%s: this doesn't appear to be a DLL\n", filename);
3022 /* Get pe_header, optional header and numbers of directory entries. */
3023 pe_header_offset = pe_get32 (dll, 0x3c);
3024 opthdr_ofs = pe_header_offset + 4 + 20;
3025 #ifdef pe_use_x86_64
3026 num_entries = pe_get32 (dll, opthdr_ofs + 92 + 4 * 4); /* & NumberOfRvaAndSizes. */
3028 num_entries = pe_get32 (dll, opthdr_ofs + 92);
3031 /* No import or export directory entry. */
3032 if (num_entries < 1)
3035 #ifdef pe_use_x86_64
3036 export_rva = pe_get32 (dll, opthdr_ofs + 96 + 4 * 4);
3037 export_size = pe_get32 (dll, opthdr_ofs + 100 + 4 * 4);
3039 export_rva = pe_get32 (dll, opthdr_ofs + 96);
3040 export_size = pe_get32 (dll, opthdr_ofs + 100);
3043 /* No export table - nothing to export. */
3044 if (export_size == 0)
3047 nsections = pe_get16 (dll, pe_header_offset + 4 + 2);
3048 secptr = (pe_header_offset + 4 + 20 +
3049 pe_get16 (dll, pe_header_offset + 4 + 16));
3052 /* Get the rva and size of the export section. */
3053 for (i = 0; i < nsections; i++)
3056 bfd_vma secptr1 = secptr + 40 * i;
3057 bfd_vma vaddr = pe_get32 (dll, secptr1 + 12);
3058 bfd_vma vsize = pe_get32 (dll, secptr1 + 16);
3059 bfd_vma fptr = pe_get32 (dll, secptr1 + 20);
3061 bfd_seek (dll, (file_ptr) secptr1, SEEK_SET);
3062 bfd_bread (sname, (bfd_size_type) 8, dll);
3064 if (vaddr <= export_rva && vaddr + vsize > export_rva)
3066 expptr = fptr + (export_rva - vaddr);
3067 if (export_rva + export_size > vaddr + vsize)
3068 export_size = vsize - (export_rva - vaddr);
3073 /* Scan sections and store the base and size of the
3074 data and bss segments in data/base_start/end. */
3075 for (i = 0; i < nsections; i++)
3077 bfd_vma secptr1 = secptr + 40 * i;
3078 bfd_vma vsize = pe_get32 (dll, secptr1 + 8);
3079 bfd_vma vaddr = pe_get32 (dll, secptr1 + 12);
3080 bfd_vma flags = pe_get32 (dll, secptr1 + 36);
3084 bfd_seek (dll, (file_ptr) secptr1 + 0, SEEK_SET);
3085 bfd_bread (sec_name, (bfd_size_type) 8, dll);
3087 if (strcmp(sec_name,".data") == 0)
3090 data_end = vaddr + vsize;
3092 if (pe_dll_extra_pe_debug)
3093 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3094 __FUNCTION__, sec_name, (unsigned long) vaddr,
3095 (unsigned long) (vaddr + vsize), (unsigned long) flags);
3097 else if (strcmp(sec_name,".rdata") == 0)
3099 rdata_start = vaddr;
3100 rdata_end = vaddr + vsize;
3102 if (pe_dll_extra_pe_debug)
3103 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3104 __FUNCTION__, sec_name, (unsigned long) vaddr,
3105 (unsigned long) (vaddr + vsize), (unsigned long) flags);
3107 else if (strcmp (sec_name,".bss") == 0)
3110 bss_end = vaddr + vsize;
3112 if (pe_dll_extra_pe_debug)
3113 printf ("%s %s: 0x%08lx-0x%08lx (0x%08lx)\n",
3114 __FUNCTION__, sec_name, (unsigned long) vaddr,
3115 (unsigned long) (vaddr + vsize), (unsigned long) flags);
3119 expdata = xmalloc (export_size);
3120 bfd_seek (dll, (file_ptr) expptr, SEEK_SET);
3121 bfd_bread (expdata, (bfd_size_type) export_size, dll);
3122 erva = (char *) expdata - export_rva;
3124 if (pe_def_file == 0)
3125 pe_def_file = def_file_empty ();
3127 nexp = pe_as32 (expdata + 24);
3128 name_rvas = pe_as32 (expdata + 32);
3129 ordinals = pe_as32 (expdata + 36);
3130 ordbase = pe_as32 (expdata + 16);
3131 exp_funcbase = pe_as32 (expdata + 28);
3133 /* Use internal dll name instead of filename
3134 to enable symbolic dll linking. */
3135 dllname = erva + pe_as32 (expdata + 12);
3137 /* Check to see if the dll has already been added to
3138 the definition list and if so return without error.
3139 This avoids multiple symbol definitions. */
3140 if (def_get_module (pe_def_file, dllname))
3142 if (pe_dll_extra_pe_debug)
3143 printf ("%s is already loaded\n", dllname);
3147 /* Iterate through the list of symbols. */
3148 for (i = 0; i < nexp; i++)
3150 /* Pointer to the names vector. */
3151 bfd_vma name_rva = pe_as32 (erva + name_rvas + i * 4);
3152 def_file_import *imp;
3153 /* Pointer to the function address vector. */
3154 bfd_vma func_rva = pe_as32 (erva + exp_funcbase + i * 4);
3157 /* Skip unwanted symbols, which are
3158 exported in buggy auto-import releases. */
3159 if (! CONST_STRNEQ (erva + name_rva, "__nm_"))
3161 /* is_data is true if the address is in the data, rdata or bss
3164 (func_rva >= data_start && func_rva < data_end)
3165 || (func_rva >= rdata_start && func_rva < rdata_end)
3166 || (func_rva >= bss_start && func_rva < bss_end);
3168 imp = def_file_add_import (pe_def_file, erva + name_rva,
3169 dllname, i, 0, NULL);
3170 /* Mark symbol type. */
3171 imp->data = is_data;
3173 if (pe_dll_extra_pe_debug)
3174 printf ("%s dll-name: %s sym: %s addr: 0x%lx %s\n",
3175 __FUNCTION__, dllname, erva + name_rva,
3176 (unsigned long) func_rva, is_data ? "(data)" : "");
3184 pe_output_file_set_long_section_names (bfd *abfd)
3186 if (pe_use_coff_long_section_names < 0)
3188 if (!bfd_coff_set_long_section_names (abfd, pe_use_coff_long_section_names))
3189 einfo (_("%XError: can't use long section names on this arch\n"));
3192 /* These are the main functions, called from the emulation. The first
3193 is called after the bfds are read, so we can guess at how much space
3194 we need. The second is called after everything is placed, so we
3195 can put the right values in place. */
3198 pe_dll_build_sections (bfd *abfd, struct bfd_link_info *info)
3200 pe_dll_id_target (bfd_get_target (abfd));
3201 pe_output_file_set_long_section_names (abfd);
3202 process_def_file_and_drectve (abfd, info);
3204 if (pe_def_file->num_exports == 0 && !info->shared)
3207 generate_edata (abfd, info);
3208 build_filler_bfd (1);
3209 pe_output_file_set_long_section_names (filler_bfd);
3213 pe_exe_build_sections (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED)
3215 pe_dll_id_target (bfd_get_target (abfd));
3216 pe_output_file_set_long_section_names (abfd);
3217 build_filler_bfd (0);
3218 pe_output_file_set_long_section_names (filler_bfd);
3222 pe_dll_fill_sections (bfd *abfd, struct bfd_link_info *info)
3224 pe_dll_id_target (bfd_get_target (abfd));
3225 pe_output_file_set_long_section_names (abfd);
3226 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
3228 generate_reloc (abfd, info);
3231 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
3233 /* Resize the sections. */
3234 lang_reset_memory_regions ();
3235 lang_size_sections (NULL, TRUE);
3237 /* Redo special stuff. */
3238 ldemul_after_allocation ();
3240 /* Do the assignments again. */
3241 lang_do_assignments ();
3244 fill_edata (abfd, info);
3246 if (info->shared && !info->pie)
3247 pe_data (abfd)->dll = 1;
3249 edata_s->contents = edata_d;
3250 reloc_s->contents = reloc_d;
3254 pe_exe_fill_sections (bfd *abfd, struct bfd_link_info *info)
3256 pe_dll_id_target (bfd_get_target (abfd));
3257 pe_output_file_set_long_section_names (abfd);
3258 image_base = pe_data (abfd)->pe_opthdr.ImageBase;
3260 generate_reloc (abfd, info);
3263 bfd_set_section_size (filler_bfd, reloc_s, reloc_sz);
3265 /* Resize the sections. */
3266 lang_reset_memory_regions ();
3267 lang_size_sections (NULL, TRUE);
3269 /* Redo special stuff. */
3270 ldemul_after_allocation ();
3272 /* Do the assignments again. */
3273 lang_do_assignments ();
3275 reloc_s->contents = reloc_d;
3279 pe_bfd_is_dll (bfd *abfd)
3281 return (bfd_get_format (abfd) == bfd_object
3283 && pe_data (abfd)->dll);